diff --git a/Gopkg.lock b/Gopkg.lock
index 6bc40c0bb..13fe0e5e4 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -29,26 +29,15 @@
   revision = "259ab82a6cad3992b4e21ff5cac294ccb06474bc"
   version = "v1.7.0"
 
-[[projects]]
-  name = "github.com/gogo/protobuf"
-  packages = [
-    "gogoproto",
-    "jsonpb",
-    "proto",
-    "protoc-gen-gogo/descriptor",
-    "sortkeys",
-    "types"
-  ]
-  revision = "1adfc126b41513cc696b209667c8656ea7aac67c"
-  version = "v1.0.0"
-
 [[projects]]
   name = "github.com/golang/protobuf"
   packages = [
+    "jsonpb",
     "proto",
     "ptypes",
     "ptypes/any",
     "ptypes/duration",
+    "ptypes/struct",
     "ptypes/timestamp"
   ]
   revision = "925541529c1fa6821df4e44ce2723319eb2be768"
@@ -58,7 +47,7 @@
   branch = "master"
   name = "github.com/golang/snappy"
   packages = ["."]
-  revision = "553a641470496b2327abcac10b36396bd98e45c9"
+  revision = "2e65f85255dbc3072edf28d6b5b8efc472979f5a"
 
 [[projects]]
   name = "github.com/inconshreveable/mousetrap"
@@ -93,14 +82,14 @@
 [[projects]]
   name = "github.com/spf13/cobra"
   packages = ["."]
-  revision = "a1f051bc3eba734da4772d60e2d677f47cf93ef4"
-  version = "v0.0.2"
+  revision = "ef82de70bb3f60c65fb8eebacbb2d122ef517385"
+  version = "v0.0.3"
 
 [[projects]]
   name = "github.com/spf13/pflag"
   packages = ["."]
-  revision = "e57e3eeb33f795204c1ca35f56c44f83227c6e66"
-  version = "v1.0.0"
+  revision = "583c0c0531f06d5278b7d917446061adc344b5cd"
+  version = "v1.0.1"
 
 [[projects]]
   name = "github.com/stretchr/testify"
@@ -128,31 +117,31 @@
     "leveldb/table",
     "leveldb/util"
   ]
-  revision = "714f901b98fdb3aa954b4193d8cbd64a28d80cad"
+  revision = "5d6fca44a948d2be89a9702de7717f0168403d3d"
 
 [[projects]]
+  branch = "develop"
   name = "github.com/tendermint/tmlibs"
   packages = [
     "common",
     "db",
     "log"
   ]
-  revision = "2e24b64fc121dcdf1cabceab8dc2f7257675483c"
-  version = "v0.8.1"
+  revision = "e0acf357bb8832faebdb79f07490d0f530afc7b1"
 
 [[projects]]
   branch = "master"
   name = "golang.org/x/net"
   packages = [
     "context",
+    "http/httpguts",
     "http2",
     "http2/hpack",
     "idna",
     "internal/timeseries",
-    "lex/httplex",
     "trace"
   ]
-  revision = "61147c48b25b599e5b561d2e9c4f3e1ef489ca41"
+  revision = "89e543239a64caf31d3a6865872ea120b41446df"
 
 [[projects]]
   name = "golang.org/x/text"
@@ -176,10 +165,9 @@
   version = "v0.3.0"
 
 [[projects]]
-  branch = "master"
   name = "google.golang.org/genproto"
   packages = ["googleapis/rpc/status"]
-  revision = "ce84044298496ef4b54b4a0a0909ba593cc60e30"
+  revision = "7fd901a49ba6a7f87732eb344f6e3c5b19d1b200"
 
 [[projects]]
   name = "google.golang.org/grpc"
@@ -208,6 +196,6 @@
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "e42d4a691fb0d0db9c717394e580dd00b36ba9e185541f99fc56689338470123"
+  inputs-digest = "5a730a9d84b37f95b1b10260a91bcd26a143a50b3301ec6dfb7483e89c44eabd"
   solver-name = "gps-cdcl"
   solver-version = 1
diff --git a/Gopkg.toml b/Gopkg.toml
index 3f9a207df..235b071d7 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -32,7 +32,7 @@
 # Use `~` for only minor version bumps.
 
 [[constraint]]
-  name = "github.com/gogo/protobuf"
+  name = "github.com/golang/protobuf"
   version = "~1.0.0"
 
 [[constraint]]
@@ -45,12 +45,19 @@
 
 [[constraint]]
   name = "github.com/tendermint/tmlibs"
-  version = "0.8.1"
+  branch = "develop"
+  # version = "0.8.1"
 
 [[constraint]]
   name = "google.golang.org/grpc"
   version = "~1.7.3"
 
+# this got updated and broke, so locked to an old working commit ...
+[[override]]
+  name = "google.golang.org/genproto"
+  revision = "7fd901a49ba6a7f87732eb344f6e3c5b19d1b200"
+
+
 [prune]
   go-tests = true
   unused-packages = true
diff --git a/Makefile b/Makefile
index 1823812ea..29a3172df 100644
--- a/Makefile
+++ b/Makefile
@@ -2,11 +2,10 @@ GOTOOLS = \
 	github.com/mitchellh/gox \
 	github.com/golang/dep/cmd/dep \
 	gopkg.in/alecthomas/gometalinter.v2 \
-	github.com/gogo/protobuf/protoc-gen-gogo \
-	github.com/gogo/protobuf/gogoproto
-GOTOOLS_CHECK = gox dep gometalinter.v2 protoc protoc-gen-gogo
+	github.com/golang/protobuf/protoc-gen-go
+GOTOOLS_CHECK = gox dep gometalinter.v2 protoc protoc-gen-go
 PACKAGES=$(shell go list ./... | grep -v '/vendor/')
-INCLUDE = -I=. -I=${GOPATH}/src -I=${GOPATH}/src/github.com/gogo/protobuf/protobuf
+INCLUDE = -I=. -I=${GOPATH}/src
 
 all: check get_vendor_deps protoc build test install metalinter
 
@@ -20,7 +19,7 @@ protoc:
 	## If you get the following error,
 	## "error while loading shared libraries: libprotobuf.so.14: cannot open shared object file: No such file or directory"
 	## See https://stackoverflow.com/a/25518702
-	protoc $(INCLUDE) --gogo_out=plugins=grpc:. types/*.proto
+	protoc $(INCLUDE) --go_out=plugins=grpc:. types/*.proto
 	@echo "--> adding nolint declarations to protobuf generated files"
 	@awk '/package types/ { print "//nolint: gas"; print; next }1' types/types.pb.go > types/types.pb.go.new
 	@mv types/types.pb.go.new types/types.pb.go
diff --git a/client/local_client.go b/client/local_client.go
index 64bf5fe08..804c558f3 100644
--- a/client/local_client.go
+++ b/client/local_client.go
@@ -53,21 +53,21 @@ func (app *localClient) EchoAsync(msg string) *ReqRes {
 
 func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes {
 	app.mtx.Lock()
-	res := app.Application.Info(req)
+	res := app.Application.Info(types.ToParamsInfo(req))
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestInfo(req),
-		types.ToResponseInfo(res),
+		types.ToResponseInfo(types.FromResultInfo(res)),
 	)
 }
 
 func (app *localClient) SetOptionAsync(req types.RequestSetOption) *ReqRes {
 	app.mtx.Lock()
-	res := app.Application.SetOption(req)
+	res := app.Application.SetOption(types.ToParamsSetOption(req))
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestSetOption(req),
-		types.ToResponseSetOption(res),
+		types.ToResponseSetOption(types.FromResultSetOption(res)),
 	)
 }
 
@@ -77,7 +77,7 @@ func (app *localClient) DeliverTxAsync(tx []byte) *ReqRes {
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestDeliverTx(tx),
-		types.ToResponseDeliverTx(res),
+		types.ToResponseDeliverTx(types.FromResultDeliverTx(res)),
 	)
 }
 
@@ -87,17 +87,17 @@ func (app *localClient) CheckTxAsync(tx []byte) *ReqRes {
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestCheckTx(tx),
-		types.ToResponseCheckTx(res),
+		types.ToResponseCheckTx(types.FromResultCheckTx(res)),
 	)
 }
 
 func (app *localClient) QueryAsync(req types.RequestQuery) *ReqRes {
 	app.mtx.Lock()
-	res := app.Application.Query(req)
+	res := app.Application.Query(types.ToParamsQuery(req))
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestQuery(req),
-		types.ToResponseQuery(res),
+		types.ToResponseQuery(types.FromResultQuery(res)),
 	)
 }
 
@@ -107,16 +107,16 @@ func (app *localClient) CommitAsync() *ReqRes {
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestCommit(),
-		types.ToResponseCommit(res),
+		types.ToResponseCommit(types.FromResultCommit(res)),
 	)
 }
 
 func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes {
 	app.mtx.Lock()
-	res := app.Application.InitChain(req)
+	res := app.Application.InitChain(types.ToParamsInitChain(req))
 	reqRes := app.callback(
 		types.ToRequestInitChain(req),
-		types.ToResponseInitChain(res),
+		types.ToResponseInitChain(types.FromResultInitChain(res)),
 	)
 	app.mtx.Unlock()
 	return reqRes
@@ -124,21 +124,21 @@ func (app *localClient) InitChainAsync(req types.RequestInitChain) *ReqRes {
 
 func (app *localClient) BeginBlockAsync(req types.RequestBeginBlock) *ReqRes {
 	app.mtx.Lock()
-	res := app.Application.BeginBlock(req)
+	res := app.Application.BeginBlock(types.ToParamsBeginBlock(req))
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestBeginBlock(req),
-		types.ToResponseBeginBlock(res),
+		types.ToResponseBeginBlock(types.FromResultBeginBlock(res)),
 	)
 }
 
 func (app *localClient) EndBlockAsync(req types.RequestEndBlock) *ReqRes {
 	app.mtx.Lock()
-	res := app.Application.EndBlock(req)
+	res := app.Application.EndBlock(types.ToParamsEndBlock(req))
 	app.mtx.Unlock()
 	return app.callback(
 		types.ToRequestEndBlock(req),
-		types.ToResponseEndBlock(res),
+		types.ToResponseEndBlock(types.FromResultEndBlock(res)),
 	)
 }
 
@@ -154,63 +154,63 @@ func (app *localClient) EchoSync(msg string) (*types.ResponseEcho, error) {
 
 func (app *localClient) InfoSync(req types.RequestInfo) (*types.ResponseInfo, error) {
 	app.mtx.Lock()
-	res := app.Application.Info(req)
+	res := types.FromResultInfo(app.Application.Info(types.ToParamsInfo(req)))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) SetOptionSync(req types.RequestSetOption) (*types.ResponseSetOption, error) {
 	app.mtx.Lock()
-	res := app.Application.SetOption(req)
+	res := types.FromResultSetOption(app.Application.SetOption(types.ToParamsSetOption(req)))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) DeliverTxSync(tx []byte) (*types.ResponseDeliverTx, error) {
 	app.mtx.Lock()
-	res := app.Application.DeliverTx(tx)
+	res := types.FromResultDeliverTx(app.Application.DeliverTx(tx))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) CheckTxSync(tx []byte) (*types.ResponseCheckTx, error) {
 	app.mtx.Lock()
-	res := app.Application.CheckTx(tx)
+	res := types.FromResultCheckTx(app.Application.CheckTx(tx))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) QuerySync(req types.RequestQuery) (*types.ResponseQuery, error) {
 	app.mtx.Lock()
-	res := app.Application.Query(req)
+	res := types.FromResultQuery(app.Application.Query(types.ToParamsQuery(req)))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) CommitSync() (*types.ResponseCommit, error) {
 	app.mtx.Lock()
-	res := app.Application.Commit()
+	res := types.FromResultCommit(app.Application.Commit())
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) InitChainSync(req types.RequestInitChain) (*types.ResponseInitChain, error) {
 	app.mtx.Lock()
-	res := app.Application.InitChain(req)
+	res := types.FromResultInitChain(app.Application.InitChain(types.ToParamsInitChain(req)))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) BeginBlockSync(req types.RequestBeginBlock) (*types.ResponseBeginBlock, error) {
 	app.mtx.Lock()
-	res := app.Application.BeginBlock(req)
+	res := types.FromResultBeginBlock(app.Application.BeginBlock(types.ToParamsBeginBlock(req)))
 	app.mtx.Unlock()
 	return &res, nil
 }
 
 func (app *localClient) EndBlockSync(req types.RequestEndBlock) (*types.ResponseEndBlock, error) {
 	app.mtx.Lock()
-	res := app.Application.EndBlock(req)
+	res := types.FromResultEndBlock(app.Application.EndBlock(types.ToParamsEndBlock(req)))
 	app.mtx.Unlock()
 	return &res, nil
 }
diff --git a/example/counter/counter.go b/example/counter/counter.go
index a6d5df6ab..3437da670 100644
--- a/example/counter/counter.go
+++ b/example/counter/counter.go
@@ -21,11 +21,11 @@ func NewCounterApplication(serial bool) *CounterApplication {
 	return &CounterApplication{serial: serial}
 }
 
-func (app *CounterApplication) Info(req types.RequestInfo) types.ResponseInfo {
-	return types.ResponseInfo{Data: cmn.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
+func (app *CounterApplication) Info(req types.ParamsInfo) types.ResultInfo {
+	return types.ResultInfo{Data: cmn.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
 }
 
-func (app *CounterApplication) SetOption(req types.RequestSetOption) types.ResponseSetOption {
+func (app *CounterApplication) SetOption(req types.ParamsSetOption) types.ResultSetOption {
 	key, value := req.Key, req.Value
 	if key == "serial" && value == "on" {
 		app.serial = true
@@ -33,20 +33,20 @@ func (app *CounterApplication) SetOption(req types.RequestSetOption) types.Respo
 		/*
 			TODO Panic and have the ABCI server pass an exception.
 			The client can call SetOptionSync() and get an `error`.
-			return types.ResponseSetOption{
+			return types.ResultSetOption{
 				Error: cmn.Fmt("Unknown key (%s) or value (%s)", key, value),
 			}
 		*/
-		return types.ResponseSetOption{}
+		return types.ResultSetOption{}
 	}
 
-	return types.ResponseSetOption{}
+	return types.ResultSetOption{}
 }
 
-func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
+func (app *CounterApplication) DeliverTx(tx []byte) types.ResultDeliverTx {
 	if app.serial {
 		if len(tx) > 8 {
-			return types.ResponseDeliverTx{
+			return types.ResultDeliverTx{
 				Code: code.CodeTypeEncodingError,
 				Log:  fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx))}
 		}
@@ -54,19 +54,19 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue != uint64(app.txCount) {
-			return types.ResponseDeliverTx{
+			return types.ResultDeliverTx{
 				Code: code.CodeTypeBadNonce,
 				Log:  fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)}
 		}
 	}
 	app.txCount++
-	return types.ResponseDeliverTx{Code: code.CodeTypeOK}
+	return types.ResultDeliverTx{Code: code.CodeTypeOK}
 }
 
-func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx {
+func (app *CounterApplication) CheckTx(tx []byte) types.ResultCheckTx {
 	if app.serial {
 		if len(tx) > 8 {
-			return types.ResponseCheckTx{
+			return types.ResultCheckTx{
 				Code: code.CodeTypeEncodingError,
 				Log:  fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx))}
 		}
@@ -74,31 +74,31 @@ func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx {
 		copy(tx8[len(tx8)-len(tx):], tx)
 		txValue := binary.BigEndian.Uint64(tx8)
 		if txValue < uint64(app.txCount) {
-			return types.ResponseCheckTx{
+			return types.ResultCheckTx{
 				Code: code.CodeTypeBadNonce,
 				Log:  fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue)}
 		}
 	}
-	return types.ResponseCheckTx{Code: code.CodeTypeOK}
+	return types.ResultCheckTx{Code: code.CodeTypeOK}
 }
 
-func (app *CounterApplication) Commit() (resp types.ResponseCommit) {
+func (app *CounterApplication) Commit() (resp types.ResultCommit) {
 	app.hashCount++
 	if app.txCount == 0 {
-		return types.ResponseCommit{}
+		return types.ResultCommit{}
 	}
 	hash := make([]byte, 8)
 	binary.BigEndian.PutUint64(hash, uint64(app.txCount))
-	return types.ResponseCommit{Data: hash}
+	return types.ResultCommit{Data: hash}
 }
 
-func (app *CounterApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {
+func (app *CounterApplication) Query(reqQuery types.ParamsQuery) types.ResultQuery {
 	switch reqQuery.Path {
 	case "hash":
-		return types.ResponseQuery{Value: []byte(cmn.Fmt("%v", app.hashCount))}
+		return types.ResultQuery{Value: []byte(cmn.Fmt("%v", app.hashCount))}
 	case "tx":
-		return types.ResponseQuery{Value: []byte(cmn.Fmt("%v", app.txCount))}
+		return types.ResultQuery{Value: []byte(cmn.Fmt("%v", app.txCount))}
 	default:
-		return types.ResponseQuery{Log: cmn.Fmt("Invalid query path. Expected hash or tx, got %v", reqQuery.Path)}
+		return types.ResultQuery{Log: cmn.Fmt("Invalid query path. Expected hash or tx, got %v", reqQuery.Path)}
 	}
 }
diff --git a/example/kvstore/helpers.go b/example/kvstore/helpers.go
index da826fe65..e302a6d17 100644
--- a/example/kvstore/helpers.go
+++ b/example/kvstore/helpers.go
@@ -32,7 +32,7 @@ func RandVals(cnt int) []types.Validator {
 // which allows tests to pass and is fine as long as you
 // don't make any tx that modify the validator state
 func InitKVStore(app *PersistentKVStoreApplication) {
-	app.InitChain(types.RequestInitChain{
+	app.InitChain(types.ParamsInitChain{
 		Validators:   RandVals(1),
 		GenesisBytes: []byte("[]"),
 	})
diff --git a/example/kvstore/kvstore.go b/example/kvstore/kvstore.go
index 4ccbc56b0..573168df1 100644
--- a/example/kvstore/kvstore.go
+++ b/example/kvstore/kvstore.go
@@ -64,12 +64,12 @@ func NewKVStoreApplication() *KVStoreApplication {
 	return &KVStoreApplication{state: state}
 }
 
-func (app *KVStoreApplication) Info(req types.RequestInfo) (resInfo types.ResponseInfo) {
-	return types.ResponseInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size)}
+func (app *KVStoreApplication) Info(req types.ParamsInfo) (resInfo types.ResultInfo) {
+	return types.ResultInfo{Data: fmt.Sprintf("{\"size\":%v}", app.state.Size)}
 }
 
 // tx is either "key=value" or just arbitrary bytes
-func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
+func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResultDeliverTx {
 	var key, value []byte
 	parts := bytes.Split(tx, []byte("="))
 	if len(parts) == 2 {
@@ -84,24 +84,24 @@ func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
 		{[]byte("app.creator"), []byte("jae")},
 		{[]byte("app.key"), key},
 	}
-	return types.ResponseDeliverTx{Code: code.CodeTypeOK, Tags: tags}
+	return types.ResultDeliverTx{Code: code.CodeTypeOK, Tags: tags}
 }
 
-func (app *KVStoreApplication) CheckTx(tx []byte) types.ResponseCheckTx {
-	return types.ResponseCheckTx{Code: code.CodeTypeOK}
+func (app *KVStoreApplication) CheckTx(tx []byte) types.ResultCheckTx {
+	return types.ResultCheckTx{Code: code.CodeTypeOK}
 }
 
-func (app *KVStoreApplication) Commit() types.ResponseCommit {
+func (app *KVStoreApplication) Commit() types.ResultCommit {
 	// Using a memdb - just return the big endian size of the db
 	appHash := make([]byte, 8)
 	binary.PutVarint(appHash, app.state.Size)
 	app.state.AppHash = appHash
 	app.state.Height += 1
 	saveState(app.state)
-	return types.ResponseCommit{Data: appHash}
+	return types.ResultCommit{Data: appHash}
 }
 
-func (app *KVStoreApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {
+func (app *KVStoreApplication) Query(reqQuery types.ParamsQuery) (resQuery types.ResultQuery) {
 	if reqQuery.Prove {
 		value := app.state.db.Get(prefixKey(reqQuery.Data))
 		resQuery.Index = -1 // TODO make Proof return index
diff --git a/example/kvstore/kvstore_test.go b/example/kvstore/kvstore_test.go
index ff3e49208..32c667979 100644
--- a/example/kvstore/kvstore_test.go
+++ b/example/kvstore/kvstore_test.go
@@ -25,7 +25,7 @@ func testKVStore(t *testing.T, app types.Application, tx []byte, key, value stri
 	require.False(t, ar.IsErr(), ar)
 
 	// make sure query is fine
-	resQuery := app.Query(types.RequestQuery{
+	resQuery := app.Query(types.ParamsQuery{
 		Path: "/store",
 		Data: []byte(key),
 	})
@@ -33,7 +33,7 @@ func testKVStore(t *testing.T, app types.Application, tx []byte, key, value stri
 	require.Equal(t, value, string(resQuery.Value))
 
 	// make sure proof is fine
-	resQuery = app.Query(types.RequestQuery{
+	resQuery = app.Query(types.ParamsQuery{
 		Path:  "/store",
 		Data:  []byte(key),
 		Prove: true,
@@ -79,7 +79,7 @@ func TestPersistentKVStoreInfo(t *testing.T) {
 	InitKVStore(kvstore)
 	height := int64(0)
 
-	resInfo := kvstore.Info(types.RequestInfo{})
+	resInfo := kvstore.Info(types.ParamsInfo{})
 	if resInfo.LastBlockHeight != height {
 		t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
 	}
@@ -90,11 +90,11 @@ func TestPersistentKVStoreInfo(t *testing.T) {
 	header := types.Header{
 		Height: int64(height),
 	}
-	kvstore.BeginBlock(types.RequestBeginBlock{hash, header, nil, nil})
-	kvstore.EndBlock(types.RequestEndBlock{header.Height})
+	kvstore.BeginBlock(types.ParamsBeginBlock{hash, header, nil, nil})
+	kvstore.EndBlock(types.ParamsEndBlock{header.Height})
 	kvstore.Commit()
 
-	resInfo = kvstore.Info(types.RequestInfo{})
+	resInfo = kvstore.Info(types.ParamsInfo{})
 	if resInfo.LastBlockHeight != height {
 		t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
 	}
@@ -114,7 +114,7 @@ func TestValUpdates(t *testing.T) {
 	nInit := 5
 	vals := RandVals(total)
 	// iniitalize with the first nInit
-	kvstore.InitChain(types.RequestInitChain{
+	kvstore.InitChain(types.ParamsInitChain{
 		Validators: vals[:nInit],
 	})
 
@@ -176,13 +176,13 @@ func makeApplyBlock(t *testing.T, kvstore types.Application, heightInt int, diff
 		Height: height,
 	}
 
-	kvstore.BeginBlock(types.RequestBeginBlock{hash, header, nil, nil})
+	kvstore.BeginBlock(types.ParamsBeginBlock{hash, header, nil, nil})
 	for _, tx := range txs {
 		if r := kvstore.DeliverTx(tx); r.IsErr() {
 			t.Fatal(r)
 		}
 	}
-	resEndBlock := kvstore.EndBlock(types.RequestEndBlock{header.Height})
+	resEndBlock := kvstore.EndBlock(types.ParamsEndBlock{header.Height})
 	kvstore.Commit()
 
 	valsEqual(t, diff, resEndBlock.ValidatorUpdates)
diff --git a/example/kvstore/persistent_kvstore.go b/example/kvstore/persistent_kvstore.go
index 02f7ce74a..fda7a7a1b 100644
--- a/example/kvstore/persistent_kvstore.go
+++ b/example/kvstore/persistent_kvstore.go
@@ -50,19 +50,19 @@ func (app *PersistentKVStoreApplication) SetLogger(l log.Logger) {
 	app.logger = l
 }
 
-func (app *PersistentKVStoreApplication) Info(req types.RequestInfo) types.ResponseInfo {
+func (app *PersistentKVStoreApplication) Info(req types.ParamsInfo) types.ResultInfo {
 	res := app.app.Info(req)
 	res.LastBlockHeight = app.app.state.Height
 	res.LastBlockAppHash = app.app.state.AppHash
 	return res
 }
 
-func (app *PersistentKVStoreApplication) SetOption(req types.RequestSetOption) types.ResponseSetOption {
+func (app *PersistentKVStoreApplication) SetOption(req types.ParamsSetOption) types.ResultSetOption {
 	return app.app.SetOption(req)
 }
 
 // tx is either "val:pubkey/power" or "key=value" or just arbitrary bytes
-func (app *PersistentKVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
+func (app *PersistentKVStoreApplication) DeliverTx(tx []byte) types.ResultDeliverTx {
 	// if it starts with "val:", update the validator set
 	// format is "val:pubkey/power"
 	if isValidatorTx(tx) {
@@ -75,40 +75,40 @@ func (app *PersistentKVStoreApplication) DeliverTx(tx []byte) types.ResponseDeli
 	return app.app.DeliverTx(tx)
 }
 
-func (app *PersistentKVStoreApplication) CheckTx(tx []byte) types.ResponseCheckTx {
+func (app *PersistentKVStoreApplication) CheckTx(tx []byte) types.ResultCheckTx {
 	return app.app.CheckTx(tx)
 }
 
 // Commit will panic if InitChain was not called
-func (app *PersistentKVStoreApplication) Commit() types.ResponseCommit {
+func (app *PersistentKVStoreApplication) Commit() types.ResultCommit {
 	return app.app.Commit()
 }
 
-func (app *PersistentKVStoreApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {
+func (app *PersistentKVStoreApplication) Query(reqQuery types.ParamsQuery) types.ResultQuery {
 	return app.app.Query(reqQuery)
 }
 
 // Save the validators in the merkle tree
-func (app *PersistentKVStoreApplication) InitChain(req types.RequestInitChain) types.ResponseInitChain {
+func (app *PersistentKVStoreApplication) InitChain(req types.ParamsInitChain) types.ResultInitChain {
 	for _, v := range req.Validators {
 		r := app.updateValidator(v)
 		if r.IsErr() {
 			app.logger.Error("Error updating validators", "r", r)
 		}
 	}
-	return types.ResponseInitChain{}
+	return types.ResultInitChain{}
 }
 
 // Track the block hash and header information
-func (app *PersistentKVStoreApplication) BeginBlock(req types.RequestBeginBlock) types.ResponseBeginBlock {
+func (app *PersistentKVStoreApplication) BeginBlock(req types.ParamsBeginBlock) types.ResultBeginBlock {
 	// reset valset changes
 	app.ValUpdates = make([]types.Validator, 0)
-	return types.ResponseBeginBlock{}
+	return types.ResultBeginBlock{}
 }
 
 // Update the validator set
-func (app *PersistentKVStoreApplication) EndBlock(req types.RequestEndBlock) types.ResponseEndBlock {
-	return types.ResponseEndBlock{ValidatorUpdates: app.ValUpdates}
+func (app *PersistentKVStoreApplication) EndBlock(req types.ParamsEndBlock) types.ResultEndBlock {
+	return types.ResultEndBlock{ValidatorUpdates: app.ValUpdates}
 }
 
 //---------------------------------------------
@@ -129,7 +129,7 @@ func (app *PersistentKVStoreApplication) Validators() (validators []types.Valida
 	return
 }
 
-func MakeValSetChangeTx(pubkey types.PubKey, power int64) []byte {
+func MakeValSetChangeTx(pubkey *types.PubKey, power int64) []byte {
 	return []byte(cmn.Fmt("val:%X/%d", pubkey.Data, power))
 }
 
@@ -139,13 +139,13 @@ func isValidatorTx(tx []byte) bool {
 
 // format is "val:pubkey/power"
 // pubkey is raw 32-byte ed25519 key
-func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.ResponseDeliverTx {
+func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.ResultDeliverTx {
 	tx = tx[len(ValidatorSetChangePrefix):]
 
 	//get the pubkey and power
 	pubKeyAndPower := strings.Split(string(tx), "/")
 	if len(pubKeyAndPower) != 2 {
-		return types.ResponseDeliverTx{
+		return types.ResultDeliverTx{
 			Code: code.CodeTypeEncodingError,
 			Log:  fmt.Sprintf("Expected 'pubkey/power'. Got %v", pubKeyAndPower)}
 	}
@@ -154,7 +154,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon
 	// decode the pubkey
 	pubkey, err := hex.DecodeString(pubkeyS)
 	if err != nil {
-		return types.ResponseDeliverTx{
+		return types.ResultDeliverTx{
 			Code: code.CodeTypeEncodingError,
 			Log:  fmt.Sprintf("Pubkey (%s) is invalid hex", pubkeyS)}
 	}
@@ -162,7 +162,7 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon
 	// decode the power
 	power, err := strconv.ParseInt(powerS, 10, 64)
 	if err != nil {
-		return types.ResponseDeliverTx{
+		return types.ResultDeliverTx{
 			Code: code.CodeTypeEncodingError,
 			Log:  fmt.Sprintf("Power (%s) is not an int", powerS)}
 	}
@@ -172,12 +172,12 @@ func (app *PersistentKVStoreApplication) execValidatorTx(tx []byte) types.Respon
 }
 
 // add, update, or remove a validator
-func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) types.ResponseDeliverTx {
+func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) types.ResultDeliverTx {
 	key := []byte("val:" + string(v.PubKey.Data))
 	if v.Power == 0 {
 		// remove validator
 		if !app.app.state.db.Has(key) {
-			return types.ResponseDeliverTx{
+			return types.ResultDeliverTx{
 				Code: code.CodeTypeUnauthorized,
 				Log:  fmt.Sprintf("Cannot remove non-existent validator %X", key)}
 		}
@@ -186,7 +186,7 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) type
 		// add or update validator
 		value := bytes.NewBuffer(make([]byte, 0))
 		if err := types.WriteMessage(&v, value); err != nil {
-			return types.ResponseDeliverTx{
+			return types.ResultDeliverTx{
 				Code: code.CodeTypeEncodingError,
 				Log:  fmt.Sprintf("Error encoding validator: %v", err)}
 		}
@@ -196,5 +196,5 @@ func (app *PersistentKVStoreApplication) updateValidator(v types.Validator) type
 	// we only update the changes array if we successfully updated the tree
 	app.ValUpdates = append(app.ValUpdates, v)
 
-	return types.ResponseDeliverTx{Code: code.CodeTypeOK}
+	return types.ResultDeliverTx{Code: code.CodeTypeOK}
 }
diff --git a/server/socket_server.go b/server/socket_server.go
index eb26dc353..d9aa97402 100644
--- a/server/socket_server.go
+++ b/server/socket_server.go
@@ -172,32 +172,32 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_Flush:
 		responses <- types.ToResponseFlush()
 	case *types.Request_Info:
-		res := s.app.Info(*r.Info)
-		responses <- types.ToResponseInfo(res)
+		res := s.app.Info(types.ToParamsInfo(*r.Info))
+		responses <- types.ToResponseInfo(types.FromResultInfo(res))
 	case *types.Request_SetOption:
-		res := s.app.SetOption(*r.SetOption)
-		responses <- types.ToResponseSetOption(res)
+		res := s.app.SetOption(types.ToParamsSetOption(*r.SetOption))
+		responses <- types.ToResponseSetOption(types.FromResultSetOption(res))
 	case *types.Request_DeliverTx:
 		res := s.app.DeliverTx(r.DeliverTx.Tx)
-		responses <- types.ToResponseDeliverTx(res)
+		responses <- types.ToResponseDeliverTx(types.FromResultDeliverTx(res))
 	case *types.Request_CheckTx:
 		res := s.app.CheckTx(r.CheckTx.Tx)
-		responses <- types.ToResponseCheckTx(res)
+		responses <- types.ToResponseCheckTx(types.FromResultCheckTx(res))
 	case *types.Request_Commit:
 		res := s.app.Commit()
-		responses <- types.ToResponseCommit(res)
+		responses <- types.ToResponseCommit(types.FromResultCommit(res))
 	case *types.Request_Query:
-		res := s.app.Query(*r.Query)
-		responses <- types.ToResponseQuery(res)
+		res := s.app.Query(types.ToParamsQuery(*r.Query))
+		responses <- types.ToResponseQuery(types.FromResultQuery(res))
 	case *types.Request_InitChain:
-		res := s.app.InitChain(*r.InitChain)
-		responses <- types.ToResponseInitChain(res)
+		res := s.app.InitChain(types.ToParamsInitChain(*r.InitChain))
+		responses <- types.ToResponseInitChain(types.FromResultInitChain(res))
 	case *types.Request_BeginBlock:
-		res := s.app.BeginBlock(*r.BeginBlock)
-		responses <- types.ToResponseBeginBlock(res)
+		res := s.app.BeginBlock(types.ToParamsBeginBlock(*r.BeginBlock))
+		responses <- types.ToResponseBeginBlock(types.FromResultBeginBlock(res))
 	case *types.Request_EndBlock:
-		res := s.app.EndBlock(*r.EndBlock)
-		responses <- types.ToResponseEndBlock(res)
+		res := s.app.EndBlock(types.ToParamsEndBlock(*r.EndBlock))
+		responses <- types.ToResponseEndBlock(types.FromResultEndBlock(res))
 	default:
 		responses <- types.ToResponseException("Unknown request")
 	}
diff --git a/tests/server/client.go b/tests/server/client.go
index 14b4007a1..e1d028507 100644
--- a/tests/server/client.go
+++ b/tests/server/client.go
@@ -12,11 +12,12 @@ import (
 
 func InitChain(client abcicli.Client) error {
 	total := 10
-	vals := make([]types.Validator, total)
+	vals := make([]*types.Validator, total)
 	for i := 0; i < total; i++ {
 		pubkey := cmn.RandBytes(33)
 		power := cmn.RandInt()
-		vals[i] = types.Ed25519Validator(pubkey, int64(power))
+		v := types.Ed25519Validator(pubkey, int64(power))
+		vals[i] = &v
 	}
 	_, err := client.InitChainSync(types.RequestInitChain{
 		Validators:   vals,
diff --git a/types/application.go b/types/application.go
index ef1bc92e5..03d0c8fb0 100644
--- a/types/application.go
+++ b/types/application.go
@@ -6,23 +6,23 @@ import (
 
 // Application is an interface that enables any finite, deterministic state machine
 // to be driven by a blockchain-based replication engine via the ABCI.
-// All methods take a RequestXxx argument and return a ResponseXxx argument,
+// All methods take a ParamsXxx argument and return a ResultXxx argument,
 // except CheckTx/DeliverTx, which take `tx []byte`, and `Commit`, which takes nothing.
 type Application interface {
 	// Info/Query Connection
-	Info(RequestInfo) ResponseInfo                // Return application info
-	SetOption(RequestSetOption) ResponseSetOption // Set application option
-	Query(RequestQuery) ResponseQuery             // Query for state
+	Info(ParamsInfo) ResultInfo                // Return application info
+	SetOption(ParamsSetOption) ResultSetOption // Set application option
+	Query(ParamsQuery) ResultQuery             // Query for state
 
 	// Mempool Connection
-	CheckTx(tx []byte) ResponseCheckTx // Validate a tx for the mempool
+	CheckTx(tx []byte) ResultCheckTx // Validate a tx for the mempool
 
 	// Consensus Connection
-	InitChain(RequestInitChain) ResponseInitChain    // Initialize blockchain with validators and other info from TendermintCore
-	BeginBlock(RequestBeginBlock) ResponseBeginBlock // Signals the beginning of a block
-	DeliverTx(tx []byte) ResponseDeliverTx           // Deliver a tx for full processing
-	EndBlock(RequestEndBlock) ResponseEndBlock       // Signals the end of a block, returns changes to the validator set
-	Commit() ResponseCommit                          // Commit the state and return the application Merkle root hash
+	InitChain(ParamsInitChain) ResultInitChain    // Initialize blockchain with validators and other info from TendermintCore
+	BeginBlock(ParamsBeginBlock) ResultBeginBlock // Signals the beginning of a block
+	DeliverTx(tx []byte) ResultDeliverTx          // Deliver a tx for full processing
+	EndBlock(ParamsEndBlock) ResultEndBlock       // Signals the end of a block, returns changes to the validator set
+	Commit() ResultCommit                         // Commit the state and return the application Merkle root hash
 }
 
 //-------------------------------------------------------
@@ -37,40 +37,40 @@ func NewBaseApplication() *BaseApplication {
 	return &BaseApplication{}
 }
 
-func (BaseApplication) Info(req RequestInfo) ResponseInfo {
-	return ResponseInfo{}
+func (BaseApplication) Info(req ParamsInfo) ResultInfo {
+	return ResultInfo{}
 }
 
-func (BaseApplication) SetOption(req RequestSetOption) ResponseSetOption {
-	return ResponseSetOption{}
+func (BaseApplication) SetOption(req ParamsSetOption) ResultSetOption {
+	return ResultSetOption{}
 }
 
-func (BaseApplication) DeliverTx(tx []byte) ResponseDeliverTx {
-	return ResponseDeliverTx{Code: CodeTypeOK}
+func (BaseApplication) DeliverTx(tx []byte) ResultDeliverTx {
+	return ResultDeliverTx{Code: CodeTypeOK}
 }
 
-func (BaseApplication) CheckTx(tx []byte) ResponseCheckTx {
-	return ResponseCheckTx{Code: CodeTypeOK}
+func (BaseApplication) CheckTx(tx []byte) ResultCheckTx {
+	return ResultCheckTx{Code: CodeTypeOK}
 }
 
-func (BaseApplication) Commit() ResponseCommit {
-	return ResponseCommit{}
+func (BaseApplication) Commit() ResultCommit {
+	return ResultCommit{}
 }
 
-func (BaseApplication) Query(req RequestQuery) ResponseQuery {
-	return ResponseQuery{Code: CodeTypeOK}
+func (BaseApplication) Query(req ParamsQuery) ResultQuery {
+	return ResultQuery{Code: CodeTypeOK}
 }
 
-func (BaseApplication) InitChain(req RequestInitChain) ResponseInitChain {
-	return ResponseInitChain{}
+func (BaseApplication) InitChain(req ParamsInitChain) ResultInitChain {
+	return ResultInitChain{}
 }
 
-func (BaseApplication) BeginBlock(req RequestBeginBlock) ResponseBeginBlock {
-	return ResponseBeginBlock{}
+func (BaseApplication) BeginBlock(req ParamsBeginBlock) ResultBeginBlock {
+	return ResultBeginBlock{}
 }
 
-func (BaseApplication) EndBlock(req RequestEndBlock) ResponseEndBlock {
-	return ResponseEndBlock{}
+func (BaseApplication) EndBlock(req ParamsEndBlock) ResultEndBlock {
+	return ResultEndBlock{}
 }
 
 //-------------------------------------------------------
@@ -93,46 +93,55 @@ func (app *GRPCApplication) Flush(ctx context.Context, req *RequestFlush) (*Resp
 }
 
 func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) {
-	res := app.app.Info(*req)
-	return &res, nil
+	res := app.app.Info(ToParamsInfo(*req))
+	r := FromResultInfo(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) {
-	res := app.app.SetOption(*req)
-	return &res, nil
+	res := app.app.SetOption(ToParamsSetOption(*req))
+	r := FromResultSetOption(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) {
 	res := app.app.DeliverTx(req.Tx)
-	return &res, nil
+	r := FromResultDeliverTx(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) {
 	res := app.app.CheckTx(req.Tx)
-	return &res, nil
+	r := FromResultCheckTx(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) {
-	res := app.app.Query(*req)
-	return &res, nil
+	res := app.app.Query(ToParamsQuery(*req))
+	r := FromResultQuery(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) {
 	res := app.app.Commit()
-	return &res, nil
+	r := FromResultCommit(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) {
-	res := app.app.InitChain(*req)
-	return &res, nil
+	res := app.app.InitChain(ToParamsInitChain(*req))
+	r := FromResultInitChain(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) {
-	res := app.app.BeginBlock(*req)
-	return &res, nil
+	res := app.app.BeginBlock(ToParamsBeginBlock(*req))
+	r := FromResultBeginBlock(res)
+	return &r, nil
 }
 
 func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) {
-	res := app.app.EndBlock(*req)
-	return &res, nil
+	res := app.app.EndBlock(ToParamsEndBlock(*req))
+	r := FromResultEndBlock(res)
+	return &r, nil
 }
diff --git a/types/codetype.go b/types/codetype.go
new file mode 100644
index 000000000..287f9e814
--- /dev/null
+++ b/types/codetype.go
@@ -0,0 +1,67 @@
+package types
+
+const (
+	CodeTypeOK uint32 = 0
+)
+
+// IsOK returns true if Code is OK.
+func (r ResponseCheckTx) IsOK() bool {
+	return r.Code == CodeTypeOK
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResponseCheckTx) IsErr() bool {
+	return r.Code != CodeTypeOK
+}
+
+// IsOK returns true if Code is OK.
+func (r ResponseDeliverTx) IsOK() bool {
+	return r.Code == CodeTypeOK
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResponseDeliverTx) IsErr() bool {
+	return r.Code != CodeTypeOK
+}
+
+// IsOK returns true if Code is OK.
+func (r ResponseQuery) IsOK() bool {
+	return r.Code == CodeTypeOK
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResponseQuery) IsErr() bool {
+	return r.Code != CodeTypeOK
+}
+
+//----------------------------------------------------
+
+// IsOK returns true if Code is OK.
+func (r ResultCheckTx) IsOK() bool {
+	return r.Code == CodeTypeOK
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResultCheckTx) IsErr() bool {
+	return r.Code != CodeTypeOK
+}
+
+// IsOK returns true if Code is OK.
+func (r ResultDeliverTx) IsOK() bool {
+	return r.Code == CodeTypeOK
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResultDeliverTx) IsErr() bool {
+	return r.Code != CodeTypeOK
+}
+
+// IsOK returns true if Code is OK.
+func (r ResultQuery) IsOK() bool {
+	return r.Code == CodeTypeOK
+}
+
+// IsErr returns true if Code is something other than OK.
+func (r ResultQuery) IsErr() bool {
+	return r.Code != CodeTypeOK
+}
diff --git a/types/json.go b/types/json.go
new file mode 100644
index 000000000..9bbf01a03
--- /dev/null
+++ b/types/json.go
@@ -0,0 +1,87 @@
+package types
+
+import (
+	"bytes"
+	"encoding/json"
+
+	"github.com/golang/protobuf/jsonpb"
+)
+
+//---------------------------------------------------------------------------
+// override JSON marshalling so we dont emit defaults (ie. disable omitempty)
+// note we need Unmarshal functions too because protobuf had the bright idea
+// to marshal int64->string. cool. cool, cool, cool: https://developers.google.com/protocol-buffers/docs/proto3#json
+
+var (
+	jsonpbMarshaller = jsonpb.Marshaler{
+		EnumsAsInts:  true,
+		EmitDefaults: false,
+	}
+	jsonpbUnmarshaller = jsonpb.Unmarshaler{}
+)
+
+func (r *ResponseSetOption) MarshalJSON() ([]byte, error) {
+	s, err := jsonpbMarshaller.MarshalToString(r)
+	return []byte(s), err
+}
+
+func (r *ResponseSetOption) UnmarshalJSON(b []byte) error {
+	reader := bytes.NewBuffer(b)
+	return jsonpbUnmarshaller.Unmarshal(reader, r)
+}
+
+func (r *ResponseCheckTx) MarshalJSON() ([]byte, error) {
+	s, err := jsonpbMarshaller.MarshalToString(r)
+	return []byte(s), err
+}
+
+func (r *ResponseCheckTx) UnmarshalJSON(b []byte) error {
+	reader := bytes.NewBuffer(b)
+	return jsonpbUnmarshaller.Unmarshal(reader, r)
+}
+
+func (r *ResponseDeliverTx) MarshalJSON() ([]byte, error) {
+	s, err := jsonpbMarshaller.MarshalToString(r)
+	return []byte(s), err
+}
+
+func (r *ResponseDeliverTx) UnmarshalJSON(b []byte) error {
+	reader := bytes.NewBuffer(b)
+	return jsonpbUnmarshaller.Unmarshal(reader, r)
+}
+
+func (r *ResponseQuery) MarshalJSON() ([]byte, error) {
+	s, err := jsonpbMarshaller.MarshalToString(r)
+	return []byte(s), err
+}
+
+func (r *ResponseQuery) UnmarshalJSON(b []byte) error {
+	reader := bytes.NewBuffer(b)
+	return jsonpbUnmarshaller.Unmarshal(reader, r)
+}
+
+func (r *ResponseCommit) MarshalJSON() ([]byte, error) {
+	s, err := jsonpbMarshaller.MarshalToString(r)
+	return []byte(s), err
+}
+
+func (r *ResponseCommit) UnmarshalJSON(b []byte) error {
+	reader := bytes.NewBuffer(b)
+	return jsonpbUnmarshaller.Unmarshal(reader, r)
+}
+
+// Some compile time assertions to ensure we don't
+// have accidental runtime surprises later on.
+
+// jsonEncodingRoundTripper ensures that asserted
+// interfaces implement both MarshalJSON and UnmarshalJSON
+type jsonRoundTripper interface {
+	json.Marshaler
+	json.Unmarshaler
+}
+
+var _ jsonRoundTripper = (*ResponseCommit)(nil)
+var _ jsonRoundTripper = (*ResponseQuery)(nil)
+var _ jsonRoundTripper = (*ResponseDeliverTx)(nil)
+var _ jsonRoundTripper = (*ResponseCheckTx)(nil)
+var _ jsonRoundTripper = (*ResponseSetOption)(nil)
diff --git a/types/messages.go b/types/messages.go
index 52e4b6758..e4d1c68f9 100644
--- a/types/messages.go
+++ b/types/messages.go
@@ -5,7 +5,7 @@ import (
 	"encoding/binary"
 	"io"
 
-	"github.com/gogo/protobuf/proto"
+	"github.com/golang/protobuf/proto"
 )
 
 const (
@@ -27,12 +27,12 @@ func ReadMessage(r io.Reader, msg proto.Message) error {
 }
 
 func readProtoMsg(r io.Reader, msg proto.Message, maxSize int) error {
-	// binary.ReadVarint takes an io.ByteReader, eg. a bufio.Reader
+	// binary.ReadUvarint takes an io.ByteReader, eg. a bufio.Reader
 	reader, ok := r.(*bufio.Reader)
 	if !ok {
 		reader = bufio.NewReader(r)
 	}
-	length64, err := binary.ReadVarint(reader)
+	length64, err := binary.ReadUvarint(reader)
 	if err != nil {
 		return err
 	}
@@ -48,11 +48,11 @@ func readProtoMsg(r io.Reader, msg proto.Message, maxSize int) error {
 }
 
 //-----------------------------------------------------------------------
-// NOTE: we copied wire.EncodeByteSlice from go-wire rather than keep
-// go-wire as a dep
+// NOTE: we copied wire.EncodeByteSlice from go-amino rather than keep
+// go-amino as a dep
 
 func encodeByteSlice(w io.Writer, bz []byte) (err error) {
-	err = encodeVarint(w, int64(len(bz)))
+	err = encodeUvarint(w, uint64(len(bz)))
 	if err != nil {
 		return
 	}
@@ -60,9 +60,9 @@ func encodeByteSlice(w io.Writer, bz []byte) (err error) {
 	return
 }
 
-func encodeVarint(w io.Writer, i int64) (err error) {
+func encodeUvarint(w io.Writer, u uint64) (err error) {
 	var buf [10]byte
-	n := binary.PutVarint(buf[:], i)
+	n := binary.PutUvarint(buf[:], u)
 	_, err = w.Write(buf[0:n])
 	return
 }
diff --git a/types/messages_test.go b/types/messages_test.go
index 21d3595f0..fb93a0ab8 100644
--- a/types/messages_test.go
+++ b/types/messages_test.go
@@ -6,7 +6,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/gogo/protobuf/proto"
+	"github.com/golang/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 	cmn "github.com/tendermint/tmlibs/common"
 )
@@ -21,7 +21,7 @@ func TestMarshalJSON(t *testing.T) {
 		Code:      1,
 		Data:      []byte("hello"),
 		GasWanted: 43,
-		Tags: []cmn.KVPair{
+		Tags: []*cmn.KVPair{
 			{[]byte("pho"), []byte("bo")},
 		},
 	}
@@ -82,8 +82,8 @@ func TestWriteReadMessage2(t *testing.T) {
 			Data:      []byte(phrase),
 			Log:       phrase,
 			GasWanted: 10,
-			Tags: []cmn.KVPair{
-				cmn.KVPair{[]byte("abc"), []byte("def")},
+			Tags: []*cmn.KVPair{
+				{[]byte("abc"), []byte("def")},
 			},
 			// Fee: cmn.KI64Pair{
 		},
diff --git a/types/params.go b/types/params.go
new file mode 100644
index 000000000..dbf5021e4
--- /dev/null
+++ b/types/params.go
@@ -0,0 +1,111 @@
+package types
+
+type ParamsEcho struct {
+	Message string `json:"message,omitempty"`
+}
+
+type ParamsFlush struct {
+}
+
+type ParamsInfo struct {
+	Version string `json:"version,omitempty"`
+}
+
+func ToParamsInfo(req RequestInfo) ParamsInfo {
+	return ParamsInfo{
+		Version: req.Version,
+	}
+}
+
+type ParamsSetOption struct {
+	Key   string `json:"key,omitempty"`
+	Value string `json:"value,omitempty"`
+}
+
+func ToParamsSetOption(req RequestSetOption) ParamsSetOption {
+	return ParamsSetOption{
+		Key:   req.Key,
+		Value: req.Value,
+	}
+}
+
+type ParamsInitChain struct {
+	Validators   []Validator `json:"validators"`
+	GenesisBytes []byte      `json:"genesis_bytes,omitempty"`
+}
+
+func ToParamsInitChain(req RequestInitChain) ParamsInitChain {
+	vals := make([]Validator, len(req.Validators))
+	for i := 0; i < len(vals); i++ {
+		v := req.Validators[i]
+		vals[i] = *v
+	}
+	return ParamsInitChain{
+		Validators:   vals,
+		GenesisBytes: req.GenesisBytes,
+	}
+}
+
+type ParamsQuery struct {
+	Data   []byte `json:"data,omitempty"`
+	Path   string `json:"path,omitempty"`
+	Height int64  `json:"height,omitempty"`
+	Prove  bool   `json:"prove,omitempty"`
+}
+
+func ToParamsQuery(req RequestQuery) ParamsQuery {
+	return ParamsQuery{
+		Data:   req.Data,
+		Path:   req.Path,
+		Height: req.Height,
+		Prove:  req.Prove,
+	}
+}
+
+type ParamsBeginBlock struct {
+	Hash                []byte             `json:"hash,omitempty"`
+	Header              Header             `json:"header"`
+	Validators          []SigningValidator `json:"validators,omitempty"`
+	ByzantineValidators []Evidence         `json:"byzantine_validators"`
+}
+
+func ToParamsBeginBlock(req RequestBeginBlock) ParamsBeginBlock {
+	vals := make([]SigningValidator, len(req.Validators))
+	for i := 0; i < len(vals); i++ {
+		v := req.Validators[i]
+		vals[i] = *v
+	}
+
+	evidence := make([]Evidence, len(req.ByzantineValidators))
+	for i := 0; i < len(evidence); i++ {
+		ev := req.ByzantineValidators[i]
+		evidence[i] = *ev
+	}
+	return ParamsBeginBlock{
+		Hash:                req.Hash,
+		Header:              *req.Header,
+		Validators:          vals,
+		ByzantineValidators: evidence,
+	}
+}
+
+type ParamsCheckTx struct {
+	Tx []byte `json:"tx,omitempty"`
+}
+
+type ParamsDeliverTx struct {
+	Tx []byte `json:"tx,omitempty"`
+}
+
+type ParamsEndBlock struct {
+	Height int64 `json:"height,omitempty"`
+}
+
+func ToParamsEndBlock(req RequestEndBlock) ParamsEndBlock {
+	return ParamsEndBlock{
+		Height: req.Height,
+	}
+}
+
+type ParamsCommit struct {
+}
diff --git a/types/protoreplace/protoreplace.go b/types/protoreplace/protoreplace.go
deleted file mode 100644
index 3ea0c73da..000000000
--- a/types/protoreplace/protoreplace.go
+++ /dev/null
@@ -1,55 +0,0 @@
-// +build ignore
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"os/exec"
-	"regexp"
-	"strings"
-)
-
-// This script replaces most `[]byte` with `data.Bytes` in a `.pb.go` file.
-// It was written before we realized we could use `gogo/protobuf` to achieve
-// this more natively. So it's here for safe keeping in case we ever need to
-// abandon `gogo/protobuf`.
-
-func main() {
-	bytePattern := regexp.MustCompile("[[][]]byte")
-	const oldPath = "types/types.pb.go"
-	const tmpPath = "types/types.pb.new"
-	content, err := ioutil.ReadFile(oldPath)
-	if err != nil {
-		panic("cannot read " + oldPath)
-		os.Exit(1)
-	}
-	lines := bytes.Split(content, []byte("\n"))
-	outFile, _ := os.Create(tmpPath)
-	wroteImport := false
-	for _, line_bytes := range lines {
-		line := string(line_bytes)
-		gotPackageLine := strings.HasPrefix(line, "package ")
-		writeImportTime := strings.HasPrefix(line, "import ")
-		containsDescriptor := strings.Contains(line, "Descriptor")
-		containsByteArray := strings.Contains(line, "[]byte")
-		if containsByteArray && !containsDescriptor {
-			line = string(bytePattern.ReplaceAll([]byte(line), []byte("data.Bytes")))
-		}
-		if writeImportTime && !wroteImport {
-			wroteImport = true
-			fmt.Fprintf(outFile, "import \"github.com/tendermint/go-wire/data\"\n")
-
-		}
-		if gotPackageLine {
-			fmt.Fprintf(outFile, "%s\n", "//nolint: gas")
-		}
-		fmt.Fprintf(outFile, "%s\n", line)
-	}
-	outFile.Close()
-	os.Remove(oldPath)
-	os.Rename(tmpPath, oldPath)
-	exec.Command("goimports", "-w", oldPath)
-}
diff --git a/types/pubkey.go b/types/pubkey.go
deleted file mode 100644
index e5cd5fbf3..000000000
--- a/types/pubkey.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package types
-
-const (
-	PubKeyEd25519 = "ed25519"
-)
-
-func Ed25519Validator(pubkey []byte, power int64) Validator {
-	return Validator{
-		// Address:
-		PubKey: PubKey{
-			Type: PubKeyEd25519,
-			Data: pubkey,
-		},
-		Power: power,
-	}
-}
diff --git a/types/result.go b/types/result.go
index dbf409f4c..63cea4496 100644
--- a/types/result.go
+++ b/types/result.go
@@ -1,121 +1,170 @@
 package types
 
-import (
-	"bytes"
-	"encoding/json"
+import cmn "github.com/tendermint/tmlibs/common"
 
-	"github.com/gogo/protobuf/jsonpb"
-)
-
-const (
-	CodeTypeOK uint32 = 0
-)
+// nondeterministic
+type ResultException struct {
+	Error string `json:"error,omitempty"`
+}
 
-// IsOK returns true if Code is OK.
-func (r ResponseCheckTx) IsOK() bool {
-	return r.Code == CodeTypeOK
+type ResultEcho struct {
+	Message string `json:"message,omitempty"`
 }
 
-// IsErr returns true if Code is something other than OK.
-func (r ResponseCheckTx) IsErr() bool {
-	return r.Code != CodeTypeOK
+type ResultFlush struct {
 }
 
-// IsOK returns true if Code is OK.
-func (r ResponseDeliverTx) IsOK() bool {
-	return r.Code == CodeTypeOK
+type ResultInfo struct {
+	Data             string `json:"data,omitempty"`
+	Version          string `json:"version,omitempty"`
+	LastBlockHeight  int64  `json:"last_block_height,omitempty"`
+	LastBlockAppHash []byte `json:"last_block_app_hash,omitempty"`
 }
 
-// IsErr returns true if Code is something other than OK.
-func (r ResponseDeliverTx) IsErr() bool {
-	return r.Code != CodeTypeOK
+func FromResultInfo(res ResultInfo) ResponseInfo {
+	return ResponseInfo(res)
 }
 
-// IsOK returns true if Code is OK.
-func (r ResponseQuery) IsOK() bool {
-	return r.Code == CodeTypeOK
+type ResultSetOption struct {
+	Code uint32 `json:"code,omitempty"`
+	// bytes data = 2;
+	Log  string `json:"log,omitempty"`
+	Info string `json:"info,omitempty"`
 }
 
-// IsErr returns true if Code is something other than OK.
-func (r ResponseQuery) IsErr() bool {
-	return r.Code != CodeTypeOK
+func FromResultSetOption(res ResultSetOption) ResponseSetOption {
+	return ResponseSetOption(res)
 }
 
-//---------------------------------------------------------------------------
-// override JSON marshalling so we dont emit defaults (ie. disable omitempty)
-// note we need Unmarshal functions too because protobuf had the bright idea
-// to marshal int64->string. cool. cool, cool, cool: https://developers.google.com/protocol-buffers/docs/proto3#json
+type ResultInitChain struct {
+	Validators []Validator `json:"validators"`
+}
 
-var (
-	jsonpbMarshaller = jsonpb.Marshaler{
-		EnumsAsInts:  true,
-		EmitDefaults: false,
+func FromResultInitChain(res ResultInitChain) ResponseInitChain {
+	vals := valsToPointers(res.Validators)
+	return ResponseInitChain{
+		Validators: vals,
 	}
-	jsonpbUnmarshaller = jsonpb.Unmarshaler{}
-)
+}
 
-func (r *ResponseSetOption) MarshalJSON() ([]byte, error) {
-	s, err := jsonpbMarshaller.MarshalToString(r)
-	return []byte(s), err
+type ResultQuery struct {
+	Code uint32 `json:"code,omitempty"`
+	// bytes data = 2; // use "value" instead.
+	Log    string `json:"log,omitempty"`
+	Info   string `json:"info,omitempty"`
+	Index  int64  `json:"index,omitempty"`
+	Key    []byte `json:"key,omitempty"`
+	Value  []byte `json:"value,omitempty"`
+	Proof  []byte `json:"proof,omitempty"`
+	Height int64  `json:"height,omitempty"`
 }
 
-func (r *ResponseSetOption) UnmarshalJSON(b []byte) error {
-	reader := bytes.NewBuffer(b)
-	return jsonpbUnmarshaller.Unmarshal(reader, r)
+func FromResultQuery(res ResultQuery) ResponseQuery {
+	return ResponseQuery(res)
 }
 
-func (r *ResponseCheckTx) MarshalJSON() ([]byte, error) {
-	s, err := jsonpbMarshaller.MarshalToString(r)
-	return []byte(s), err
+type ResultBeginBlock struct {
+	Tags []cmn.KVPair `json:"tags,omitempty"`
 }
 
-func (r *ResponseCheckTx) UnmarshalJSON(b []byte) error {
-	reader := bytes.NewBuffer(b)
-	return jsonpbUnmarshaller.Unmarshal(reader, r)
+func FromResultBeginBlock(res ResultBeginBlock) ResponseBeginBlock {
+	tags := tagsToPointers(res.Tags)
+	return ResponseBeginBlock{
+		Tags: tags,
+	}
 }
 
-func (r *ResponseDeliverTx) MarshalJSON() ([]byte, error) {
-	s, err := jsonpbMarshaller.MarshalToString(r)
-	return []byte(s), err
+type ResultCheckTx struct {
+	Code      uint32       `json:"code,omitempty"`
+	Data      []byte       `json:"data,omitempty"`
+	Log       string       `json:"log,omitempty"`
+	Info      string       `json:"info,omitempty"`
+	GasWanted int64        `json:"gas_wanted,omitempty"`
+	GasUsed   int64        `json:"gas_used,omitempty"`
+	Tags      []cmn.KVPair `json:"tags,omitempty"`
+	Fee       cmn.KI64Pair `json:"fee"`
+}
+
+func FromResultCheckTx(res ResultCheckTx) ResponseCheckTx {
+	tags := tagsToPointers(res.Tags)
+	return ResponseCheckTx{
+		Code:      res.Code,
+		Data:      res.Data,
+		Log:       res.Log,
+		Info:      res.Info,
+		GasWanted: res.GasWanted,
+		GasUsed:   res.GasUsed,
+		Tags:      tags,
+		Fee:       &res.Fee,
+	}
 }
 
-func (r *ResponseDeliverTx) UnmarshalJSON(b []byte) error {
-	reader := bytes.NewBuffer(b)
-	return jsonpbUnmarshaller.Unmarshal(reader, r)
+type ResultDeliverTx struct {
+	Code      uint32       `json:"code,omitempty"`
+	Data      []byte       `json:"data,omitempty"`
+	Log       string       `json:"log,omitempty"`
+	Info      string       `json:"info,omitempty"`
+	GasWanted int64        `json:"gas_wanted,omitempty"`
+	GasUsed   int64        `json:"gas_used,omitempty"`
+	Tags      []cmn.KVPair `json:"tags,omitempty"`
+	Fee       cmn.KI64Pair `json:"fee"`
+}
+
+func FromResultDeliverTx(res ResultDeliverTx) ResponseDeliverTx {
+	tags := tagsToPointers(res.Tags)
+	return ResponseDeliverTx{
+		Code:      res.Code,
+		Data:      res.Data,
+		Log:       res.Log,
+		Info:      res.Info,
+		GasWanted: res.GasWanted,
+		GasUsed:   res.GasUsed,
+		Tags:      tags,
+		Fee:       &res.Fee,
+	}
 }
 
-func (r *ResponseQuery) MarshalJSON() ([]byte, error) {
-	s, err := jsonpbMarshaller.MarshalToString(r)
-	return []byte(s), err
+type ResultEndBlock struct {
+	ValidatorUpdates      []Validator      `json:"validator_updates"`
+	ConsensusParamUpdates *ConsensusParams `json:"consensus_param_updates,omitempty"`
+	Tags                  []cmn.KVPair     `json:"tags,omitempty"`
 }
 
-func (r *ResponseQuery) UnmarshalJSON(b []byte) error {
-	reader := bytes.NewBuffer(b)
-	return jsonpbUnmarshaller.Unmarshal(reader, r)
+func FromResultEndBlock(res ResultEndBlock) ResponseEndBlock {
+	tags := tagsToPointers(res.Tags)
+	vals := valsToPointers(res.ValidatorUpdates)
+	return ResponseEndBlock{
+		ValidatorUpdates:      vals,
+		ConsensusParamUpdates: res.ConsensusParamUpdates,
+		Tags: tags,
+	}
 }
 
-func (r *ResponseCommit) MarshalJSON() ([]byte, error) {
-	s, err := jsonpbMarshaller.MarshalToString(r)
-	return []byte(s), err
+type ResultCommit struct {
+	// reserve 1
+	Data []byte `json:"data,omitempty"`
 }
 
-func (r *ResponseCommit) UnmarshalJSON(b []byte) error {
-	reader := bytes.NewBuffer(b)
-	return jsonpbUnmarshaller.Unmarshal(reader, r)
+func FromResultCommit(res ResultCommit) ResponseCommit {
+	return ResponseCommit(res)
 }
 
-// Some compile time assertions to ensure we don't
-// have accidental runtime surprises later on.
+//-------------------------------------------------------
 
-// jsonEncodingRoundTripper ensures that asserted
-// interfaces implement both MarshalJSON and UnmarshalJSON
-type jsonRoundTripper interface {
-	json.Marshaler
-	json.Unmarshaler
+func tagsToPointers(tags []cmn.KVPair) []*cmn.KVPair {
+	tagPtrs := make([]*cmn.KVPair, len(tags))
+	for i := 0; i < len(tags); i++ {
+		t := tags[i]
+		tagPtrs[i] = &t
+	}
+	return tagPtrs
 }
 
-var _ jsonRoundTripper = (*ResponseCommit)(nil)
-var _ jsonRoundTripper = (*ResponseQuery)(nil)
-var _ jsonRoundTripper = (*ResponseDeliverTx)(nil)
-var _ jsonRoundTripper = (*ResponseCheckTx)(nil)
-var _ jsonRoundTripper = (*ResponseSetOption)(nil)
+func valsToPointers(vals []Validator) []*Validator {
+	valPtrs := make([]*Validator, len(vals))
+	for i := 0; i < len(vals); i++ {
+		v := vals[i]
+		valPtrs[i] = &v
+	}
+	return valPtrs
+}
diff --git a/types/types.pb.go b/types/types.pb.go
index e04a4f4bf..6f6a8874b 100644
--- a/types/types.pb.go
+++ b/types/types.pb.go
@@ -1,4 +1,4 @@
-// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// Code generated by protoc-gen-go. DO NOT EDIT.
 // source: types/types.proto
 
 /*
@@ -46,14 +46,15 @@ It has these top-level messages:
 //nolint: gas
 package types
 
-import proto "github.com/gogo/protobuf/proto"
+import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
-import _ "github.com/gogo/protobuf/gogoproto"
 import common "github.com/tendermint/tmlibs/common"
 
-import context "golang.org/x/net/context"
-import grpc "google.golang.org/grpc"
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
@@ -64,7 +65,7 @@ var _ = math.Inf
 // is compatible with the proto package it is being compiled against.
 // A compilation error at this line likely means your copy of the
 // proto package needs to be updated.
-const _ = proto.GoGoProtoPackageIsVersion2 // please upgrade the proto package
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
 
 type Request struct {
 	// Types that are valid to be assigned to Value:
@@ -85,7 +86,7 @@ type Request struct {
 func (m *Request) Reset()                    { *m = Request{} }
 func (m *Request) String() string            { return proto.CompactTextString(m) }
 func (*Request) ProtoMessage()               {}
-func (*Request) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{0} }
+func (*Request) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 
 type isRequest_Value interface {
 	isRequest_Value()
@@ -243,57 +244,57 @@ func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 	// value
 	switch x := m.Value.(type) {
 	case *Request_Echo:
-		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
+		b.EncodeVarint(2<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Echo); err != nil {
 			return err
 		}
 	case *Request_Flush:
-		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
+		b.EncodeVarint(3<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Flush); err != nil {
 			return err
 		}
 	case *Request_Info:
-		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		b.EncodeVarint(4<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Info); err != nil {
 			return err
 		}
 	case *Request_SetOption:
-		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
+		b.EncodeVarint(5<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.SetOption); err != nil {
 			return err
 		}
 	case *Request_InitChain:
-		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
+		b.EncodeVarint(6<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.InitChain); err != nil {
 			return err
 		}
 	case *Request_Query:
-		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
+		b.EncodeVarint(7<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Query); err != nil {
 			return err
 		}
 	case *Request_BeginBlock:
-		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
+		b.EncodeVarint(8<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.BeginBlock); err != nil {
 			return err
 		}
 	case *Request_CheckTx:
-		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
+		b.EncodeVarint(9<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.CheckTx); err != nil {
 			return err
 		}
 	case *Request_DeliverTx:
-		_ = b.EncodeVarint(19<<3 | proto.WireBytes)
+		b.EncodeVarint(19<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.DeliverTx); err != nil {
 			return err
 		}
 	case *Request_EndBlock:
-		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
+		b.EncodeVarint(11<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.EndBlock); err != nil {
 			return err
 		}
 	case *Request_Commit:
-		_ = b.EncodeVarint(12<<3 | proto.WireBytes)
+		b.EncodeVarint(12<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Commit); err != nil {
 			return err
 		}
@@ -467,13 +468,13 @@ func _Request_OneofSizer(msg proto.Message) (n int) {
 }
 
 type RequestEcho struct {
-	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
 }
 
 func (m *RequestEcho) Reset()                    { *m = RequestEcho{} }
 func (m *RequestEcho) String() string            { return proto.CompactTextString(m) }
 func (*RequestEcho) ProtoMessage()               {}
-func (*RequestEcho) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{1} }
+func (*RequestEcho) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 
 func (m *RequestEcho) GetMessage() string {
 	if m != nil {
@@ -488,16 +489,16 @@ type RequestFlush struct {
 func (m *RequestFlush) Reset()                    { *m = RequestFlush{} }
 func (m *RequestFlush) String() string            { return proto.CompactTextString(m) }
 func (*RequestFlush) ProtoMessage()               {}
-func (*RequestFlush) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{2} }
+func (*RequestFlush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 
 type RequestInfo struct {
-	Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
+	Version string `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"`
 }
 
 func (m *RequestInfo) Reset()                    { *m = RequestInfo{} }
 func (m *RequestInfo) String() string            { return proto.CompactTextString(m) }
 func (*RequestInfo) ProtoMessage()               {}
-func (*RequestInfo) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{3} }
+func (*RequestInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 
 func (m *RequestInfo) GetVersion() string {
 	if m != nil {
@@ -508,14 +509,14 @@ func (m *RequestInfo) GetVersion() string {
 
 // nondeterministic
 type RequestSetOption struct {
-	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
-	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
+	Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
 }
 
 func (m *RequestSetOption) Reset()                    { *m = RequestSetOption{} }
 func (m *RequestSetOption) String() string            { return proto.CompactTextString(m) }
 func (*RequestSetOption) ProtoMessage()               {}
-func (*RequestSetOption) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{4} }
+func (*RequestSetOption) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 
 func (m *RequestSetOption) GetKey() string {
 	if m != nil {
@@ -532,16 +533,16 @@ func (m *RequestSetOption) GetValue() string {
 }
 
 type RequestInitChain struct {
-	Validators   []Validator `protobuf:"bytes,1,rep,name=validators" json:"validators"`
-	GenesisBytes []byte      `protobuf:"bytes,2,opt,name=genesis_bytes,json=genesisBytes,proto3" json:"genesis_bytes,omitempty"`
+	Validators   []*Validator `protobuf:"bytes,1,rep,name=validators" json:"validators,omitempty"`
+	GenesisBytes []byte       `protobuf:"bytes,2,opt,name=genesis_bytes,json=genesisBytes,proto3" json:"genesis_bytes,omitempty"`
 }
 
 func (m *RequestInitChain) Reset()                    { *m = RequestInitChain{} }
 func (m *RequestInitChain) String() string            { return proto.CompactTextString(m) }
 func (*RequestInitChain) ProtoMessage()               {}
-func (*RequestInitChain) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{5} }
+func (*RequestInitChain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 
-func (m *RequestInitChain) GetValidators() []Validator {
+func (m *RequestInitChain) GetValidators() []*Validator {
 	if m != nil {
 		return m.Validators
 	}
@@ -557,15 +558,15 @@ func (m *RequestInitChain) GetGenesisBytes() []byte {
 
 type RequestQuery struct {
 	Data   []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
-	Path   string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"`
-	Height int64  `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
-	Prove  bool   `protobuf:"varint,4,opt,name=prove,proto3" json:"prove,omitempty"`
+	Path   string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
+	Height int64  `protobuf:"varint,3,opt,name=height" json:"height,omitempty"`
+	Prove  bool   `protobuf:"varint,4,opt,name=prove" json:"prove,omitempty"`
 }
 
 func (m *RequestQuery) Reset()                    { *m = RequestQuery{} }
 func (m *RequestQuery) String() string            { return proto.CompactTextString(m) }
 func (*RequestQuery) ProtoMessage()               {}
-func (*RequestQuery) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{6} }
+func (*RequestQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 
 func (m *RequestQuery) GetData() []byte {
 	if m != nil {
@@ -597,15 +598,15 @@ func (m *RequestQuery) GetProve() bool {
 
 type RequestBeginBlock struct {
 	Hash                []byte              `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	Header              Header              `protobuf:"bytes,2,opt,name=header" json:"header"`
+	Header              *Header             `protobuf:"bytes,2,opt,name=header" json:"header,omitempty"`
 	Validators          []*SigningValidator `protobuf:"bytes,3,rep,name=validators" json:"validators,omitempty"`
-	ByzantineValidators []Evidence          `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators" json:"byzantine_validators"`
+	ByzantineValidators []*Evidence         `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators" json:"byzantine_validators,omitempty"`
 }
 
 func (m *RequestBeginBlock) Reset()                    { *m = RequestBeginBlock{} }
 func (m *RequestBeginBlock) String() string            { return proto.CompactTextString(m) }
 func (*RequestBeginBlock) ProtoMessage()               {}
-func (*RequestBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{7} }
+func (*RequestBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 
 func (m *RequestBeginBlock) GetHash() []byte {
 	if m != nil {
@@ -614,11 +615,11 @@ func (m *RequestBeginBlock) GetHash() []byte {
 	return nil
 }
 
-func (m *RequestBeginBlock) GetHeader() Header {
+func (m *RequestBeginBlock) GetHeader() *Header {
 	if m != nil {
 		return m.Header
 	}
-	return Header{}
+	return nil
 }
 
 func (m *RequestBeginBlock) GetValidators() []*SigningValidator {
@@ -628,7 +629,7 @@ func (m *RequestBeginBlock) GetValidators() []*SigningValidator {
 	return nil
 }
 
-func (m *RequestBeginBlock) GetByzantineValidators() []Evidence {
+func (m *RequestBeginBlock) GetByzantineValidators() []*Evidence {
 	if m != nil {
 		return m.ByzantineValidators
 	}
@@ -642,7 +643,7 @@ type RequestCheckTx struct {
 func (m *RequestCheckTx) Reset()                    { *m = RequestCheckTx{} }
 func (m *RequestCheckTx) String() string            { return proto.CompactTextString(m) }
 func (*RequestCheckTx) ProtoMessage()               {}
-func (*RequestCheckTx) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{8} }
+func (*RequestCheckTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 
 func (m *RequestCheckTx) GetTx() []byte {
 	if m != nil {
@@ -658,7 +659,7 @@ type RequestDeliverTx struct {
 func (m *RequestDeliverTx) Reset()                    { *m = RequestDeliverTx{} }
 func (m *RequestDeliverTx) String() string            { return proto.CompactTextString(m) }
 func (*RequestDeliverTx) ProtoMessage()               {}
-func (*RequestDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{9} }
+func (*RequestDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 
 func (m *RequestDeliverTx) GetTx() []byte {
 	if m != nil {
@@ -668,13 +669,13 @@ func (m *RequestDeliverTx) GetTx() []byte {
 }
 
 type RequestEndBlock struct {
-	Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	Height int64 `protobuf:"varint,1,opt,name=height" json:"height,omitempty"`
 }
 
 func (m *RequestEndBlock) Reset()                    { *m = RequestEndBlock{} }
 func (m *RequestEndBlock) String() string            { return proto.CompactTextString(m) }
 func (*RequestEndBlock) ProtoMessage()               {}
-func (*RequestEndBlock) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{10} }
+func (*RequestEndBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 
 func (m *RequestEndBlock) GetHeight() int64 {
 	if m != nil {
@@ -689,7 +690,7 @@ type RequestCommit struct {
 func (m *RequestCommit) Reset()                    { *m = RequestCommit{} }
 func (m *RequestCommit) String() string            { return proto.CompactTextString(m) }
 func (*RequestCommit) ProtoMessage()               {}
-func (*RequestCommit) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{11} }
+func (*RequestCommit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 
 type Response struct {
 	// Types that are valid to be assigned to Value:
@@ -711,7 +712,7 @@ type Response struct {
 func (m *Response) Reset()                    { *m = Response{} }
 func (m *Response) String() string            { return proto.CompactTextString(m) }
 func (*Response) ProtoMessage()               {}
-func (*Response) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{12} }
+func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 
 type isResponse_Value interface {
 	isResponse_Value()
@@ -881,62 +882,62 @@ func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 	// value
 	switch x := m.Value.(type) {
 	case *Response_Exception:
-		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
+		b.EncodeVarint(1<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Exception); err != nil {
 			return err
 		}
 	case *Response_Echo:
-		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
+		b.EncodeVarint(2<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Echo); err != nil {
 			return err
 		}
 	case *Response_Flush:
-		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
+		b.EncodeVarint(3<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Flush); err != nil {
 			return err
 		}
 	case *Response_Info:
-		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		b.EncodeVarint(4<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Info); err != nil {
 			return err
 		}
 	case *Response_SetOption:
-		_ = b.EncodeVarint(5<<3 | proto.WireBytes)
+		b.EncodeVarint(5<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.SetOption); err != nil {
 			return err
 		}
 	case *Response_InitChain:
-		_ = b.EncodeVarint(6<<3 | proto.WireBytes)
+		b.EncodeVarint(6<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.InitChain); err != nil {
 			return err
 		}
 	case *Response_Query:
-		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
+		b.EncodeVarint(7<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Query); err != nil {
 			return err
 		}
 	case *Response_BeginBlock:
-		_ = b.EncodeVarint(8<<3 | proto.WireBytes)
+		b.EncodeVarint(8<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.BeginBlock); err != nil {
 			return err
 		}
 	case *Response_CheckTx:
-		_ = b.EncodeVarint(9<<3 | proto.WireBytes)
+		b.EncodeVarint(9<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.CheckTx); err != nil {
 			return err
 		}
 	case *Response_DeliverTx:
-		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
+		b.EncodeVarint(10<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.DeliverTx); err != nil {
 			return err
 		}
 	case *Response_EndBlock:
-		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
+		b.EncodeVarint(11<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.EndBlock); err != nil {
 			return err
 		}
 	case *Response_Commit:
-		_ = b.EncodeVarint(12<<3 | proto.WireBytes)
+		b.EncodeVarint(12<<3 | proto.WireBytes)
 		if err := b.EncodeMessage(x.Commit); err != nil {
 			return err
 		}
@@ -1124,13 +1125,13 @@ func _Response_OneofSizer(msg proto.Message) (n int) {
 
 // nondeterministic
 type ResponseException struct {
-	Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
+	Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
 }
 
 func (m *ResponseException) Reset()                    { *m = ResponseException{} }
 func (m *ResponseException) String() string            { return proto.CompactTextString(m) }
 func (*ResponseException) ProtoMessage()               {}
-func (*ResponseException) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{13} }
+func (*ResponseException) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
 
 func (m *ResponseException) GetError() string {
 	if m != nil {
@@ -1140,13 +1141,13 @@ func (m *ResponseException) GetError() string {
 }
 
 type ResponseEcho struct {
-	Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"`
+	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
 }
 
 func (m *ResponseEcho) Reset()                    { *m = ResponseEcho{} }
 func (m *ResponseEcho) String() string            { return proto.CompactTextString(m) }
 func (*ResponseEcho) ProtoMessage()               {}
-func (*ResponseEcho) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{14} }
+func (*ResponseEcho) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
 
 func (m *ResponseEcho) GetMessage() string {
 	if m != nil {
@@ -1161,19 +1162,19 @@ type ResponseFlush struct {
 func (m *ResponseFlush) Reset()                    { *m = ResponseFlush{} }
 func (m *ResponseFlush) String() string            { return proto.CompactTextString(m) }
 func (*ResponseFlush) ProtoMessage()               {}
-func (*ResponseFlush) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{15} }
+func (*ResponseFlush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
 
 type ResponseInfo struct {
-	Data             string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
-	Version          string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
-	LastBlockHeight  int64  `protobuf:"varint,3,opt,name=last_block_height,json=lastBlockHeight,proto3" json:"last_block_height,omitempty"`
+	Data             string `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
+	Version          string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
+	LastBlockHeight  int64  `protobuf:"varint,3,opt,name=last_block_height,json=lastBlockHeight" json:"last_block_height,omitempty"`
 	LastBlockAppHash []byte `protobuf:"bytes,4,opt,name=last_block_app_hash,json=lastBlockAppHash,proto3" json:"last_block_app_hash,omitempty"`
 }
 
 func (m *ResponseInfo) Reset()                    { *m = ResponseInfo{} }
 func (m *ResponseInfo) String() string            { return proto.CompactTextString(m) }
 func (*ResponseInfo) ProtoMessage()               {}
-func (*ResponseInfo) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{16} }
+func (*ResponseInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
 
 func (m *ResponseInfo) GetData() string {
 	if m != nil {
@@ -1205,16 +1206,16 @@ func (m *ResponseInfo) GetLastBlockAppHash() []byte {
 
 // nondeterministic
 type ResponseSetOption struct {
-	Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
+	Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
 	// bytes data = 2;
-	Log  string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
-	Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
+	Log  string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
+	Info string `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"`
 }
 
 func (m *ResponseSetOption) Reset()                    { *m = ResponseSetOption{} }
 func (m *ResponseSetOption) String() string            { return proto.CompactTextString(m) }
 func (*ResponseSetOption) ProtoMessage()               {}
-func (*ResponseSetOption) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{17} }
+func (*ResponseSetOption) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
 
 func (m *ResponseSetOption) GetCode() uint32 {
 	if m != nil {
@@ -1238,15 +1239,15 @@ func (m *ResponseSetOption) GetInfo() string {
 }
 
 type ResponseInitChain struct {
-	Validators []Validator `protobuf:"bytes,1,rep,name=validators" json:"validators"`
+	Validators []*Validator `protobuf:"bytes,1,rep,name=validators" json:"validators,omitempty"`
 }
 
 func (m *ResponseInitChain) Reset()                    { *m = ResponseInitChain{} }
 func (m *ResponseInitChain) String() string            { return proto.CompactTextString(m) }
 func (*ResponseInitChain) ProtoMessage()               {}
-func (*ResponseInitChain) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{18} }
+func (*ResponseInitChain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
 
-func (m *ResponseInitChain) GetValidators() []Validator {
+func (m *ResponseInitChain) GetValidators() []*Validator {
 	if m != nil {
 		return m.Validators
 	}
@@ -1254,21 +1255,21 @@ func (m *ResponseInitChain) GetValidators() []Validator {
 }
 
 type ResponseQuery struct {
-	Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
+	Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
 	// bytes data = 2; // use "value" instead.
-	Log    string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
-	Info   string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
-	Index  int64  `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"`
+	Log    string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
+	Info   string `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"`
+	Index  int64  `protobuf:"varint,5,opt,name=index" json:"index,omitempty"`
 	Key    []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
 	Value  []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
 	Proof  []byte `protobuf:"bytes,8,opt,name=proof,proto3" json:"proof,omitempty"`
-	Height int64  `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"`
+	Height int64  `protobuf:"varint,9,opt,name=height" json:"height,omitempty"`
 }
 
 func (m *ResponseQuery) Reset()                    { *m = ResponseQuery{} }
 func (m *ResponseQuery) String() string            { return proto.CompactTextString(m) }
 func (*ResponseQuery) ProtoMessage()               {}
-func (*ResponseQuery) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{19} }
+func (*ResponseQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
 
 func (m *ResponseQuery) GetCode() uint32 {
 	if m != nil {
@@ -1327,15 +1328,15 @@ func (m *ResponseQuery) GetHeight() int64 {
 }
 
 type ResponseBeginBlock struct {
-	Tags []common.KVPair `protobuf:"bytes,1,rep,name=tags" json:"tags,omitempty"`
+	Tags []*common.KVPair `protobuf:"bytes,1,rep,name=tags" json:"tags,omitempty"`
 }
 
 func (m *ResponseBeginBlock) Reset()                    { *m = ResponseBeginBlock{} }
 func (m *ResponseBeginBlock) String() string            { return proto.CompactTextString(m) }
 func (*ResponseBeginBlock) ProtoMessage()               {}
-func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{20} }
+func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
 
-func (m *ResponseBeginBlock) GetTags() []common.KVPair {
+func (m *ResponseBeginBlock) GetTags() []*common.KVPair {
 	if m != nil {
 		return m.Tags
 	}
@@ -1343,20 +1344,20 @@ func (m *ResponseBeginBlock) GetTags() []common.KVPair {
 }
 
 type ResponseCheckTx struct {
-	Code      uint32          `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
-	Data      []byte          `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
-	Log       string          `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
-	Info      string          `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
-	GasWanted int64           `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"`
-	GasUsed   int64           `protobuf:"varint,6,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
-	Tags      []common.KVPair `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
-	Fee       common.KI64Pair `protobuf:"bytes,8,opt,name=fee" json:"fee"`
+	Code      uint32           `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
+	Data      []byte           `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+	Log       string           `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
+	Info      string           `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"`
+	GasWanted int64            `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted" json:"gas_wanted,omitempty"`
+	GasUsed   int64            `protobuf:"varint,6,opt,name=gas_used,json=gasUsed" json:"gas_used,omitempty"`
+	Tags      []*common.KVPair `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
+	Fee       *common.KI64Pair `protobuf:"bytes,8,opt,name=fee" json:"fee,omitempty"`
 }
 
 func (m *ResponseCheckTx) Reset()                    { *m = ResponseCheckTx{} }
 func (m *ResponseCheckTx) String() string            { return proto.CompactTextString(m) }
 func (*ResponseCheckTx) ProtoMessage()               {}
-func (*ResponseCheckTx) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{21} }
+func (*ResponseCheckTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
 
 func (m *ResponseCheckTx) GetCode() uint32 {
 	if m != nil {
@@ -1400,35 +1401,35 @@ func (m *ResponseCheckTx) GetGasUsed() int64 {
 	return 0
 }
 
-func (m *ResponseCheckTx) GetTags() []common.KVPair {
+func (m *ResponseCheckTx) GetTags() []*common.KVPair {
 	if m != nil {
 		return m.Tags
 	}
 	return nil
 }
 
-func (m *ResponseCheckTx) GetFee() common.KI64Pair {
+func (m *ResponseCheckTx) GetFee() *common.KI64Pair {
 	if m != nil {
 		return m.Fee
 	}
-	return common.KI64Pair{}
+	return nil
 }
 
 type ResponseDeliverTx struct {
-	Code      uint32          `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
-	Data      []byte          `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
-	Log       string          `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
-	Info      string          `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
-	GasWanted int64           `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"`
-	GasUsed   int64           `protobuf:"varint,6,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
-	Tags      []common.KVPair `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
-	Fee       common.KI64Pair `protobuf:"bytes,8,opt,name=fee" json:"fee"`
+	Code      uint32           `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
+	Data      []byte           `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+	Log       string           `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
+	Info      string           `protobuf:"bytes,4,opt,name=info" json:"info,omitempty"`
+	GasWanted int64            `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted" json:"gas_wanted,omitempty"`
+	GasUsed   int64            `protobuf:"varint,6,opt,name=gas_used,json=gasUsed" json:"gas_used,omitempty"`
+	Tags      []*common.KVPair `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
+	Fee       *common.KI64Pair `protobuf:"bytes,8,opt,name=fee" json:"fee,omitempty"`
 }
 
 func (m *ResponseDeliverTx) Reset()                    { *m = ResponseDeliverTx{} }
 func (m *ResponseDeliverTx) String() string            { return proto.CompactTextString(m) }
 func (*ResponseDeliverTx) ProtoMessage()               {}
-func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{22} }
+func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
 
 func (m *ResponseDeliverTx) GetCode() uint32 {
 	if m != nil {
@@ -1472,32 +1473,32 @@ func (m *ResponseDeliverTx) GetGasUsed() int64 {
 	return 0
 }
 
-func (m *ResponseDeliverTx) GetTags() []common.KVPair {
+func (m *ResponseDeliverTx) GetTags() []*common.KVPair {
 	if m != nil {
 		return m.Tags
 	}
 	return nil
 }
 
-func (m *ResponseDeliverTx) GetFee() common.KI64Pair {
+func (m *ResponseDeliverTx) GetFee() *common.KI64Pair {
 	if m != nil {
 		return m.Fee
 	}
-	return common.KI64Pair{}
+	return nil
 }
 
 type ResponseEndBlock struct {
-	ValidatorUpdates      []Validator      `protobuf:"bytes,1,rep,name=validator_updates,json=validatorUpdates" json:"validator_updates"`
+	ValidatorUpdates      []*Validator     `protobuf:"bytes,1,rep,name=validator_updates,json=validatorUpdates" json:"validator_updates,omitempty"`
 	ConsensusParamUpdates *ConsensusParams `protobuf:"bytes,2,opt,name=consensus_param_updates,json=consensusParamUpdates" json:"consensus_param_updates,omitempty"`
-	Tags                  []common.KVPair  `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"`
+	Tags                  []*common.KVPair `protobuf:"bytes,3,rep,name=tags" json:"tags,omitempty"`
 }
 
 func (m *ResponseEndBlock) Reset()                    { *m = ResponseEndBlock{} }
 func (m *ResponseEndBlock) String() string            { return proto.CompactTextString(m) }
 func (*ResponseEndBlock) ProtoMessage()               {}
-func (*ResponseEndBlock) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{23} }
+func (*ResponseEndBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
 
-func (m *ResponseEndBlock) GetValidatorUpdates() []Validator {
+func (m *ResponseEndBlock) GetValidatorUpdates() []*Validator {
 	if m != nil {
 		return m.ValidatorUpdates
 	}
@@ -1511,7 +1512,7 @@ func (m *ResponseEndBlock) GetConsensusParamUpdates() *ConsensusParams {
 	return nil
 }
 
-func (m *ResponseEndBlock) GetTags() []common.KVPair {
+func (m *ResponseEndBlock) GetTags() []*common.KVPair {
 	if m != nil {
 		return m.Tags
 	}
@@ -1526,7 +1527,7 @@ type ResponseCommit struct {
 func (m *ResponseCommit) Reset()                    { *m = ResponseCommit{} }
 func (m *ResponseCommit) String() string            { return proto.CompactTextString(m) }
 func (*ResponseCommit) ProtoMessage()               {}
-func (*ResponseCommit) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{24} }
+func (*ResponseCommit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
 
 func (m *ResponseCommit) GetData() []byte {
 	if m != nil {
@@ -1546,7 +1547,7 @@ type ConsensusParams struct {
 func (m *ConsensusParams) Reset()                    { *m = ConsensusParams{} }
 func (m *ConsensusParams) String() string            { return proto.CompactTextString(m) }
 func (*ConsensusParams) ProtoMessage()               {}
-func (*ConsensusParams) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{25} }
+func (*ConsensusParams) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
 
 func (m *ConsensusParams) GetBlockSize() *BlockSize {
 	if m != nil {
@@ -1571,15 +1572,15 @@ func (m *ConsensusParams) GetBlockGossip() *BlockGossip {
 
 // BlockSize contain limits on the block size.
 type BlockSize struct {
-	MaxBytes int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"`
-	MaxTxs   int32 `protobuf:"varint,2,opt,name=max_txs,json=maxTxs,proto3" json:"max_txs,omitempty"`
-	MaxGas   int64 `protobuf:"varint,3,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"`
+	MaxBytes int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
+	MaxTxs   int32 `protobuf:"varint,2,opt,name=max_txs,json=maxTxs" json:"max_txs,omitempty"`
+	MaxGas   int64 `protobuf:"varint,3,opt,name=max_gas,json=maxGas" json:"max_gas,omitempty"`
 }
 
 func (m *BlockSize) Reset()                    { *m = BlockSize{} }
 func (m *BlockSize) String() string            { return proto.CompactTextString(m) }
 func (*BlockSize) ProtoMessage()               {}
-func (*BlockSize) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{26} }
+func (*BlockSize) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
 
 func (m *BlockSize) GetMaxBytes() int32 {
 	if m != nil {
@@ -1604,14 +1605,14 @@ func (m *BlockSize) GetMaxGas() int64 {
 
 // TxSize contain limits on the tx size.
 type TxSize struct {
-	MaxBytes int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"`
-	MaxGas   int64 `protobuf:"varint,2,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"`
+	MaxBytes int32 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes" json:"max_bytes,omitempty"`
+	MaxGas   int64 `protobuf:"varint,2,opt,name=max_gas,json=maxGas" json:"max_gas,omitempty"`
 }
 
 func (m *TxSize) Reset()                    { *m = TxSize{} }
 func (m *TxSize) String() string            { return proto.CompactTextString(m) }
 func (*TxSize) ProtoMessage()               {}
-func (*TxSize) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{27} }
+func (*TxSize) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
 
 func (m *TxSize) GetMaxBytes() int32 {
 	if m != nil {
@@ -1631,13 +1632,13 @@ func (m *TxSize) GetMaxGas() int64 {
 // elements of how blocks are gossiped
 type BlockGossip struct {
 	// Note: must not be 0
-	BlockPartSizeBytes int32 `protobuf:"varint,1,opt,name=block_part_size_bytes,json=blockPartSizeBytes,proto3" json:"block_part_size_bytes,omitempty"`
+	BlockPartSizeBytes int32 `protobuf:"varint,1,opt,name=block_part_size_bytes,json=blockPartSizeBytes" json:"block_part_size_bytes,omitempty"`
 }
 
 func (m *BlockGossip) Reset()                    { *m = BlockGossip{} }
 func (m *BlockGossip) String() string            { return proto.CompactTextString(m) }
 func (*BlockGossip) ProtoMessage()               {}
-func (*BlockGossip) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{28} }
+func (*BlockGossip) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
 
 func (m *BlockGossip) GetBlockPartSizeBytes() int32 {
 	if m != nil {
@@ -1649,12 +1650,12 @@ func (m *BlockGossip) GetBlockPartSizeBytes() int32 {
 // just the minimum the app might need
 type Header struct {
 	// basics
-	ChainID string `protobuf:"bytes,1,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"`
-	Height  int64  `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
-	Time    int64  `protobuf:"varint,3,opt,name=time,proto3" json:"time,omitempty"`
+	ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
+	Height  int64  `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
+	Time    int64  `protobuf:"varint,3,opt,name=time" json:"time,omitempty"`
 	// txs
-	NumTxs   int32 `protobuf:"varint,4,opt,name=num_txs,json=numTxs,proto3" json:"num_txs,omitempty"`
-	TotalTxs int64 `protobuf:"varint,5,opt,name=total_txs,json=totalTxs,proto3" json:"total_txs,omitempty"`
+	NumTxs   int32 `protobuf:"varint,4,opt,name=num_txs,json=numTxs" json:"num_txs,omitempty"`
+	TotalTxs int64 `protobuf:"varint,5,opt,name=total_txs,json=totalTxs" json:"total_txs,omitempty"`
 	// hashes
 	LastBlockHash []byte `protobuf:"bytes,6,opt,name=last_block_hash,json=lastBlockHash,proto3" json:"last_block_hash,omitempty"`
 	AppHash       []byte `protobuf:"bytes,7,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
@@ -1665,11 +1666,11 @@ type Header struct {
 func (m *Header) Reset()                    { *m = Header{} }
 func (m *Header) String() string            { return proto.CompactTextString(m) }
 func (*Header) ProtoMessage()               {}
-func (*Header) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
+func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
 
-func (m *Header) GetChainID() string {
+func (m *Header) GetChainId() string {
 	if m != nil {
-		return m.ChainID
+		return m.ChainId
 	}
 	return ""
 }
@@ -1725,15 +1726,15 @@ func (m *Header) GetProposer() *Validator {
 
 // Validator
 type Validator struct {
-	Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
-	PubKey  PubKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey" json:"pub_key"`
-	Power   int64  `protobuf:"varint,3,opt,name=power,proto3" json:"power,omitempty"`
+	Address []byte  `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	PubKey  *PubKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey" json:"pub_key,omitempty"`
+	Power   int64   `protobuf:"varint,3,opt,name=power" json:"power,omitempty"`
 }
 
 func (m *Validator) Reset()                    { *m = Validator{} }
 func (m *Validator) String() string            { return proto.CompactTextString(m) }
 func (*Validator) ProtoMessage()               {}
-func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
+func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
 
 func (m *Validator) GetAddress() []byte {
 	if m != nil {
@@ -1742,11 +1743,11 @@ func (m *Validator) GetAddress() []byte {
 	return nil
 }
 
-func (m *Validator) GetPubKey() PubKey {
+func (m *Validator) GetPubKey() *PubKey {
 	if m != nil {
 		return m.PubKey
 	}
-	return PubKey{}
+	return nil
 }
 
 func (m *Validator) GetPower() int64 {
@@ -1759,13 +1760,13 @@ func (m *Validator) GetPower() int64 {
 // Validator with an extra bool
 type SigningValidator struct {
 	Validator       *Validator `protobuf:"bytes,1,opt,name=validator" json:"validator,omitempty"`
-	SignedLastBlock bool       `protobuf:"varint,2,opt,name=signed_last_block,json=signedLastBlock,proto3" json:"signed_last_block,omitempty"`
+	SignedLastBlock bool       `protobuf:"varint,2,opt,name=signed_last_block,json=signedLastBlock" json:"signed_last_block,omitempty"`
 }
 
 func (m *SigningValidator) Reset()                    { *m = SigningValidator{} }
 func (m *SigningValidator) String() string            { return proto.CompactTextString(m) }
 func (*SigningValidator) ProtoMessage()               {}
-func (*SigningValidator) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
+func (*SigningValidator) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
 
 func (m *SigningValidator) GetValidator() *Validator {
 	if m != nil {
@@ -1782,14 +1783,14 @@ func (m *SigningValidator) GetSignedLastBlock() bool {
 }
 
 type PubKey struct {
-	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+	Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
 	Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
 }
 
 func (m *PubKey) Reset()                    { *m = PubKey{} }
 func (m *PubKey) String() string            { return proto.CompactTextString(m) }
 func (*PubKey) ProtoMessage()               {}
-func (*PubKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
+func (*PubKey) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} }
 
 func (m *PubKey) GetType() string {
 	if m != nil {
@@ -1806,17 +1807,17 @@ func (m *PubKey) GetData() []byte {
 }
 
 type Evidence struct {
-	Type             string     `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+	Type             string     `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
 	Validator        *Validator `protobuf:"bytes,2,opt,name=validator" json:"validator,omitempty"`
-	Height           int64      `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"`
-	Time             int64      `protobuf:"varint,4,opt,name=time,proto3" json:"time,omitempty"`
-	TotalVotingPower int64      `protobuf:"varint,5,opt,name=total_voting_power,json=totalVotingPower,proto3" json:"total_voting_power,omitempty"`
+	Height           int64      `protobuf:"varint,3,opt,name=height" json:"height,omitempty"`
+	Time             int64      `protobuf:"varint,4,opt,name=time" json:"time,omitempty"`
+	TotalVotingPower int64      `protobuf:"varint,5,opt,name=total_voting_power,json=totalVotingPower" json:"total_voting_power,omitempty"`
 }
 
 func (m *Evidence) Reset()                    { *m = Evidence{} }
 func (m *Evidence) String() string            { return proto.CompactTextString(m) }
 func (*Evidence) ProtoMessage()               {}
-func (*Evidence) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{33} }
+func (*Evidence) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} }
 
 func (m *Evidence) GetType() string {
 	if m != nil {
@@ -2292,120 +2293,116 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
 	Metadata: "types/types.proto",
 }
 
-func init() { proto.RegisterFile("types/types.proto", fileDescriptorTypes) }
-
-var fileDescriptorTypes = []byte{
-	// 1789 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4b, 0x73, 0x1c, 0x49,
-	0x11, 0xd6, 0xbc, 0xa7, 0x53, 0x4f, 0x97, 0xfc, 0x18, 0xcf, 0x06, 0x61, 0x47, 0x43, 0x18, 0x99,
-	0xd5, 0x6a, 0x40, 0x8b, 0x8d, 0xbd, 0x4b, 0x6c, 0x20, 0x69, 0xcd, 0x8e, 0xc2, 0x3c, 0x44, 0xdb,
-	0x6b, 0x22, 0xb8, 0x4c, 0xd4, 0x4c, 0x97, 0x7a, 0x2a, 0x3c, 0xd3, 0xdd, 0xdb, 0x55, 0xa3, 0x9d,
-	0xf1, 0x8d, 0xe0, 0xba, 0x77, 0xce, 0xdc, 0xf8, 0x03, 0xfc, 0x05, 0x82, 0x7f, 0xc0, 0xcd, 0x07,
-	0xb8, 0xf1, 0x27, 0x20, 0x32, 0xab, 0xdf, 0xea, 0x59, 0x16, 0x73, 0xdc, 0x8b, 0x54, 0x59, 0x99,
-	0x59, 0x9d, 0x99, 0x93, 0xf9, 0x65, 0x56, 0xc1, 0x0d, 0xbd, 0x0a, 0x85, 0x1a, 0xd0, 0xdf, 0xa3,
-	0x30, 0x0a, 0x74, 0xc0, 0x5a, 0x44, 0xf4, 0x3f, 0xf0, 0xa4, 0x9e, 0x2e, 0xc6, 0x47, 0x93, 0x60,
-	0x3e, 0xf0, 0x02, 0x2f, 0x18, 0x10, 0x77, 0xbc, 0xb8, 0x24, 0x8a, 0x08, 0x5a, 0x19, 0xad, 0xfe,
-	0x20, 0x27, 0xae, 0x85, 0xef, 0x8a, 0x68, 0x2e, 0x7d, 0x3d, 0xd0, 0xf3, 0x99, 0x1c, 0xab, 0xc1,
-	0x24, 0x98, 0xcf, 0x03, 0x3f, 0xff, 0x19, 0xfb, 0xaf, 0x4d, 0xe8, 0x38, 0xe2, 0x8b, 0x85, 0x50,
-	0x9a, 0x1d, 0x40, 0x53, 0x4c, 0xa6, 0x41, 0xaf, 0x7e, 0xbf, 0x76, 0xb0, 0x79, 0xcc, 0x8e, 0x8c,
-	0x5c, 0xcc, 0x7d, 0x36, 0x99, 0x06, 0xc3, 0x0d, 0x87, 0x24, 0xd8, 0xfb, 0xd0, 0xba, 0x9c, 0x2d,
-	0xd4, 0xb4, 0xd7, 0x20, 0xd1, 0xfd, 0xa2, 0xe8, 0xcf, 0x91, 0x35, 0xdc, 0x70, 0x8c, 0x0c, 0x1e,
-	0x2b, 0xfd, 0xcb, 0xa0, 0xd7, 0xac, 0x3a, 0xf6, 0xdc, 0xbf, 0xa4, 0x63, 0x51, 0x82, 0x3d, 0x01,
-	0x50, 0x42, 0x8f, 0x82, 0x50, 0xcb, 0xc0, 0xef, 0xb5, 0x48, 0xfe, 0x4e, 0x51, 0xfe, 0x85, 0xd0,
-	0xbf, 0x26, 0xf6, 0x70, 0xc3, 0xb1, 0x54, 0x42, 0xa0, 0xa6, 0xf4, 0xa5, 0x1e, 0x4d, 0xa6, 0x5c,
-	0xfa, 0xbd, 0x76, 0x95, 0xe6, 0xb9, 0x2f, 0xf5, 0x19, 0xb2, 0x51, 0x53, 0x26, 0x04, 0xba, 0xf2,
-	0xc5, 0x42, 0x44, 0xab, 0x5e, 0xa7, 0xca, 0x95, 0xdf, 0x20, 0x0b, 0x5d, 0x21, 0x19, 0xf6, 0x31,
-	0x6c, 0x8e, 0x85, 0x27, 0xfd, 0xd1, 0x78, 0x16, 0x4c, 0x5e, 0xf7, 0xba, 0xa4, 0xd2, 0x2b, 0xaa,
-	0x9c, 0xa2, 0xc0, 0x29, 0xf2, 0x87, 0x1b, 0x0e, 0x8c, 0x53, 0x8a, 0x1d, 0x43, 0x77, 0x32, 0x15,
-	0x93, 0xd7, 0x23, 0xbd, 0xec, 0x59, 0xa4, 0x79, 0xab, 0xa8, 0x79, 0x86, 0xdc, 0x97, 0xcb, 0xe1,
-	0x86, 0xd3, 0x99, 0x98, 0x25, 0xfa, 0xe5, 0x8a, 0x99, 0xbc, 0x12, 0x11, 0x6a, 0xed, 0x57, 0xf9,
-	0xf5, 0xa9, 0xe1, 0x93, 0x9e, 0xe5, 0x26, 0x04, 0x7b, 0x04, 0x96, 0xf0, 0xdd, 0xd8, 0xd0, 0x4d,
-	0x52, 0xbc, 0x5d, 0xfa, 0x45, 0x7d, 0x37, 0x31, 0xb3, 0x2b, 0xe2, 0x35, 0x3b, 0x82, 0x36, 0x66,
-	0x89, 0xd4, 0xbd, 0x2d, 0xd2, 0xb9, 0x59, 0x32, 0x91, 0x78, 0xc3, 0x0d, 0x27, 0x96, 0x3a, 0xed,
-	0x40, 0xeb, 0x8a, 0xcf, 0x16, 0xc2, 0xfe, 0x3e, 0x6c, 0xe6, 0x32, 0x85, 0xf5, 0xa0, 0x33, 0x17,
-	0x4a, 0x71, 0x4f, 0xf4, 0x6a, 0xf7, 0x6b, 0x07, 0x96, 0x93, 0x90, 0xf6, 0x0e, 0x6c, 0xe5, 0xf3,
-	0x24, 0xa7, 0x88, 0xb9, 0x80, 0x8a, 0x57, 0x22, 0x52, 0x98, 0x00, 0xb1, 0x62, 0x4c, 0xda, 0x1f,
-	0xc1, 0x5e, 0x39, 0x09, 0xd8, 0x1e, 0x34, 0x5e, 0x8b, 0x55, 0x2c, 0x89, 0x4b, 0x76, 0x33, 0x36,
-	0x88, 0xb2, 0xd8, 0x72, 0x62, 0xeb, 0x82, 0x54, 0x37, 0x4d, 0x03, 0xf6, 0x18, 0xe0, 0x8a, 0xcf,
-	0xa4, 0xcb, 0x75, 0x10, 0xa9, 0x5e, 0xed, 0x7e, 0xe3, 0x60, 0xf3, 0x78, 0x2f, 0x76, 0xf7, 0x55,
-	0xc2, 0x38, 0x6d, 0xfe, 0xed, 0xed, 0xbd, 0x0d, 0x27, 0x27, 0xc9, 0xbe, 0x0b, 0xdb, 0x9e, 0xf0,
-	0x85, 0x92, 0x6a, 0x34, 0x5e, 0x69, 0xa1, 0xe8, 0x4b, 0x5b, 0xce, 0x56, 0xbc, 0x79, 0x8a, 0x7b,
-	0xb6, 0x9b, 0x7a, 0x49, 0x29, 0xc4, 0x18, 0x34, 0x5d, 0xae, 0x39, 0x59, 0xba, 0xe5, 0xd0, 0x1a,
-	0xf7, 0x42, 0xae, 0xa7, 0xb1, 0xa5, 0xb4, 0x66, 0xb7, 0xa1, 0x3d, 0x15, 0xd2, 0x9b, 0x6a, 0x2a,
-	0xad, 0x86, 0x13, 0x53, 0xe8, 0x56, 0x18, 0x05, 0x57, 0x82, 0xaa, 0xa8, 0xeb, 0x18, 0xc2, 0xfe,
-	0x7b, 0x0d, 0x6e, 0x5c, 0x4b, 0x3b, 0x3c, 0x77, 0xca, 0xd5, 0x34, 0xf9, 0x16, 0xae, 0xd9, 0xfb,
-	0x78, 0x2e, 0x77, 0x45, 0x14, 0x57, 0xf7, 0x76, 0xec, 0xe8, 0x90, 0x36, 0x63, 0x2f, 0x63, 0x11,
-	0xf6, 0x93, 0x42, 0x64, 0x1a, 0x14, 0x99, 0x24, 0xeb, 0x5e, 0x48, 0xcf, 0x97, 0xbe, 0x97, 0x06,
-	0xa8, 0x10, 0x9a, 0x21, 0xdc, 0x1c, 0xaf, 0xde, 0x70, 0x5f, 0x4b, 0x5f, 0x8c, 0x72, 0x47, 0x34,
-	0xe9, 0x88, 0xdd, 0xf8, 0x88, 0x67, 0x57, 0xd2, 0x15, 0xfe, 0x44, 0xc4, 0x5f, 0xdd, 0x4f, 0x55,
-	0xd2, 0x43, 0x95, 0x7d, 0x1f, 0x76, 0x8a, 0x55, 0xc1, 0x76, 0xa0, 0xae, 0x97, 0xb1, 0x4f, 0x75,
-	0xbd, 0xb4, 0xed, 0xf4, 0x27, 0x4d, 0x2b, 0xe0, 0x9a, 0xcc, 0x43, 0xd8, 0x2d, 0x25, 0x7b, 0x2e,
-	0xc0, 0xb5, 0x7c, 0x80, 0xed, 0x5d, 0xd8, 0x2e, 0xe4, 0xb8, 0xfd, 0x55, 0x0b, 0xba, 0x8e, 0x50,
-	0x61, 0xe0, 0x2b, 0xc1, 0x9e, 0x80, 0x25, 0x96, 0x13, 0x61, 0x80, 0xa9, 0x56, 0x2a, 0x7b, 0x23,
-	0xf3, 0x2c, 0xe1, 0x63, 0x1d, 0xa6, 0xc2, 0xec, 0x61, 0x01, 0x54, 0xf7, 0xcb, 0x4a, 0x79, 0x54,
-	0x3d, 0x2c, 0xa2, 0xea, 0xcd, 0x92, 0x6c, 0x09, 0x56, 0x1f, 0x16, 0x60, 0xb5, 0x7c, 0x70, 0x01,
-	0x57, 0x9f, 0x56, 0xe0, 0x6a, 0xd9, 0xfc, 0x35, 0xc0, 0xfa, 0xb4, 0x02, 0x58, 0x7b, 0xd7, 0xbe,
-	0x55, 0x89, 0xac, 0x87, 0x45, 0x64, 0x2d, 0xbb, 0x53, 0x82, 0xd6, 0x9f, 0x56, 0x41, 0xeb, 0xdd,
-	0x92, 0xce, 0x5a, 0x6c, 0xfd, 0xf0, 0x1a, 0xb6, 0xde, 0x2e, 0xa9, 0x56, 0x80, 0xeb, 0xd3, 0x02,
-	0xb8, 0x42, 0xa5, 0x6f, 0x6b, 0xd0, 0xf5, 0xf1, 0x75, 0x74, 0xbd, 0x53, 0xfe, 0x69, 0xab, 0xe0,
-	0x75, 0x50, 0x82, 0xd7, 0x5b, 0x65, 0x2b, 0xd7, 0xe2, 0xeb, 0x43, 0xac, 0xf4, 0x52, 0xa6, 0x21,
-	0x2a, 0x88, 0x28, 0x0a, 0xa2, 0x18, 0x00, 0x0d, 0x61, 0x1f, 0x20, 0xf6, 0x64, 0xf9, 0xf5, 0x35,
-	0x58, 0x4c, 0x49, 0x9f, 0xcb, 0x2e, 0xfb, 0x8f, 0xb5, 0x4c, 0x97, 0xe0, 0x38, 0x8f, 0x5b, 0x56,
-	0x8c, 0x5b, 0x39, 0x88, 0xae, 0x17, 0x20, 0x9a, 0xfd, 0x00, 0x6e, 0xcc, 0xb8, 0xd2, 0x26, 0x2e,
-	0xa3, 0x02, 0x90, 0xed, 0x22, 0xc3, 0x04, 0xc4, 0x20, 0xda, 0x07, 0xb0, 0x9f, 0x93, 0xe5, 0x61,
-	0x38, 0x22, 0xd0, 0x6a, 0x52, 0xf1, 0xee, 0xa5, 0xd2, 0x27, 0x61, 0x38, 0xe4, 0x6a, 0x6a, 0xff,
-	0x32, 0xf3, 0x3f, 0x83, 0x7f, 0x06, 0xcd, 0x49, 0xe0, 0x1a, 0xb7, 0xb6, 0x1d, 0x5a, 0x63, 0x4b,
-	0x98, 0x05, 0x1e, 0x7d, 0xd5, 0x72, 0x70, 0x89, 0x52, 0x69, 0xa5, 0x58, 0xa6, 0x24, 0xec, 0xe7,
-	0xd9, 0x71, 0xff, 0x77, 0x47, 0xb0, 0xff, 0x52, 0xcb, 0xe2, 0x98, 0xc2, 0xfd, 0xbb, 0x19, 0x86,
-	0x3f, 0xa9, 0xf4, 0x5d, 0xb1, 0xa4, 0x32, 0x6d, 0x38, 0x86, 0x48, 0xfa, 0x5c, 0x9b, 0x82, 0x53,
-	0xec, 0x73, 0x1d, 0xda, 0x33, 0x44, 0xdc, 0x26, 0x82, 0x4b, 0xaa, 0x9f, 0x2d, 0xc7, 0x10, 0x39,
-	0xcc, 0xb3, 0x0a, 0x98, 0x77, 0x01, 0xec, 0x7a, 0x65, 0xb1, 0x8f, 0xa0, 0xa9, 0xb9, 0x97, 0xf8,
-	0xbf, 0x73, 0x64, 0xa6, 0xc6, 0xa3, 0xe7, 0xaf, 0x2e, 0xb8, 0x8c, 0x4e, 0x6f, 0xa3, 0xf7, 0xff,
-	0x7a, 0x7b, 0x6f, 0x07, 0x65, 0x0e, 0x83, 0xb9, 0xd4, 0x62, 0x1e, 0xea, 0x95, 0x43, 0x3a, 0xf6,
-	0xbf, 0x6b, 0x88, 0xb8, 0x85, 0x8a, 0xab, 0x8c, 0x45, 0x92, 0x56, 0xf5, 0x5c, 0x3b, 0xfc, 0x66,
-	0xf1, 0xf9, 0x0e, 0x80, 0xc7, 0xd5, 0xe8, 0x4b, 0xee, 0x6b, 0xe1, 0xc6, 0x41, 0xb2, 0x3c, 0xae,
-	0x7e, 0x4b, 0x1b, 0xec, 0x2e, 0x74, 0x91, 0xbd, 0x50, 0xc2, 0xa5, 0x68, 0x35, 0x9c, 0x8e, 0xc7,
-	0xd5, 0xe7, 0x4a, 0xb8, 0xa9, 0x5f, 0x9d, 0xff, 0xdd, 0x2f, 0x76, 0x00, 0x8d, 0x4b, 0x21, 0x62,
-	0x54, 0xda, 0x4b, 0x55, 0xcf, 0x1f, 0xff, 0x98, 0x94, 0x4d, 0x4a, 0xa0, 0x88, 0xfd, 0xfb, 0x7a,
-	0x96, 0x59, 0x59, 0x63, 0xfa, 0x76, 0xc5, 0xe0, 0x9f, 0x35, 0xec, 0xcd, 0x45, 0x18, 0x64, 0x67,
-	0x70, 0x23, 0x2d, 0x99, 0xd1, 0x22, 0x74, 0x39, 0x8e, 0x4e, 0x5f, 0x5f, 0x63, 0x7b, 0xa9, 0xc2,
-	0xe7, 0x46, 0x9e, 0xfd, 0x0a, 0xee, 0x4c, 0xf0, 0x54, 0x5f, 0x2d, 0xd4, 0x28, 0xe4, 0x11, 0x9f,
-	0xa7, 0x47, 0xd5, 0x0b, 0xb0, 0x7f, 0x96, 0x48, 0x5d, 0xa0, 0x90, 0x72, 0x6e, 0x4d, 0x0a, 0x1b,
-	0xc9, 0x79, 0x49, 0x3c, 0x1a, 0xef, 0x90, 0xeb, 0xdf, 0xc3, 0x11, 0x25, 0x0f, 0xdb, 0x55, 0xbf,
-	0xa8, 0xfd, 0xa7, 0x1a, 0xec, 0x96, 0x8c, 0x61, 0x03, 0x00, 0x83, 0x7a, 0x4a, 0xbe, 0x11, 0xf1,
-	0x38, 0x91, 0xc4, 0x80, 0x82, 0xf5, 0x42, 0xbe, 0x11, 0x8e, 0x35, 0x4e, 0x96, 0xec, 0x01, 0x74,
-	0xf4, 0xd2, 0x48, 0x17, 0xc7, 0xb7, 0x97, 0x4b, 0x12, 0x6d, 0x6b, 0xfa, 0xcf, 0x1e, 0xc1, 0x96,
-	0x39, 0xd8, 0x0b, 0x94, 0x92, 0x61, 0x3c, 0x48, 0xb0, 0xfc, 0xd1, 0x9f, 0x11, 0xc7, 0xd9, 0x1c,
-	0x67, 0x84, 0xfd, 0x3b, 0xb0, 0xd2, 0xcf, 0xb2, 0xf7, 0xc0, 0x9a, 0xf3, 0x65, 0x3c, 0xda, 0xa2,
-	0x6d, 0x2d, 0xa7, 0x3b, 0xe7, 0x4b, 0x1a, 0x6b, 0xd9, 0x1d, 0xe8, 0x20, 0x53, 0x2f, 0x4d, 0xbc,
-	0x5b, 0x4e, 0x7b, 0xce, 0x97, 0x2f, 0x97, 0x29, 0xc3, 0xe3, 0x2a, 0x19, 0x5c, 0xe7, 0x7c, 0xf9,
-	0x19, 0x57, 0xf6, 0x27, 0xd0, 0x36, 0x46, 0x7e, 0xa3, 0x83, 0x51, 0xbf, 0x5e, 0xd0, 0xff, 0x19,
-	0x6c, 0xe6, 0xec, 0x66, 0x3f, 0x82, 0x5b, 0xc6, 0xc3, 0x90, 0x47, 0x9a, 0x22, 0x52, 0x38, 0x90,
-	0x11, 0xf3, 0x82, 0x47, 0x1a, 0x3f, 0x69, 0x46, 0xf1, 0x3f, 0xd4, 0xa1, 0x6d, 0xc6, 0x5c, 0xf6,
-	0x00, 0xc7, 0x04, 0x2e, 0xfd, 0x91, 0x74, 0x4d, 0x47, 0x3b, 0xdd, 0xfc, 0xc7, 0xdb, 0x7b, 0x1d,
-	0x42, 0xff, 0xf3, 0x4f, 0x71, 0x32, 0xc0, 0x85, 0x9b, 0x03, 0xcc, 0x7a, 0x61, 0x0a, 0x67, 0xd0,
-	0xd4, 0x72, 0x2e, 0x62, 0x17, 0x69, 0x8d, 0x96, 0xfb, 0x8b, 0x39, 0x85, 0xa4, 0x69, 0x42, 0xe2,
-	0x2f, 0xe6, 0x18, 0x92, 0xf7, 0xc0, 0xd2, 0x81, 0xe6, 0x33, 0x62, 0x99, 0x22, 0xed, 0xd2, 0x06,
-	0x32, 0x1f, 0xc0, 0x6e, 0xbe, 0x53, 0x62, 0xe7, 0x33, 0xe0, 0xbe, 0x9d, 0xf5, 0x49, 0x9c, 0xdb,
-	0xef, 0x42, 0x37, 0x6d, 0x8d, 0x06, 0xe9, 0x3b, 0xdc, 0x74, 0x44, 0x76, 0x08, 0xdd, 0x30, 0x0a,
-	0xc2, 0x40, 0x89, 0x28, 0x2d, 0xca, 0x52, 0x1d, 0x39, 0xa9, 0x84, 0x2d, 0xc1, 0x4a, 0xb7, 0xb1,
-	0x83, 0x73, 0xd7, 0x8d, 0x84, 0x52, 0xf1, 0xb0, 0x9c, 0x90, 0xec, 0x10, 0x3a, 0xe1, 0x62, 0x3c,
-	0xc2, 0x66, 0x53, 0xcc, 0xb4, 0x8b, 0xc5, 0xf8, 0xb9, 0x58, 0x25, 0x17, 0x85, 0x90, 0x28, 0x6a,
-	0x37, 0xc1, 0x97, 0x22, 0x8a, 0x03, 0x62, 0x08, 0xdb, 0x87, 0xbd, 0xf2, 0x2d, 0x81, 0x1d, 0x81,
-	0x95, 0x16, 0x73, 0x29, 0xe3, 0x33, 0x6b, 0x33, 0x11, 0x9c, 0x24, 0x94, 0xf4, 0x7c, 0xe1, 0x8e,
-	0xb2, 0x30, 0x91, 0x45, 0x5d, 0x67, 0xd7, 0x30, 0x7e, 0x91, 0xc4, 0xc9, 0xfe, 0x21, 0xb4, 0x8d,
-	0x75, 0xf4, 0xfb, 0xac, 0xc2, 0x64, 0xcc, 0xa1, 0x75, 0x65, 0x51, 0xfe, 0xb9, 0x06, 0xdd, 0xe4,
-	0x16, 0x52, 0xa9, 0x54, 0x30, 0xb7, 0xfe, 0xdf, 0xcd, 0x5d, 0x77, 0x6d, 0x4b, 0x12, 0xa6, 0x99,
-	0x4b, 0x98, 0x43, 0x60, 0x26, 0x2f, 0xae, 0x02, 0x2d, 0x7d, 0x6f, 0x64, 0x22, 0x68, 0x12, 0x64,
-	0x8f, 0x38, 0xaf, 0x88, 0x71, 0x81, 0xfb, 0xc7, 0x5f, 0xb5, 0x60, 0xf7, 0xe4, 0xf4, 0xec, 0xfc,
-	0x24, 0x0c, 0x67, 0x72, 0xc2, 0x69, 0xec, 0x19, 0x40, 0x93, 0x06, 0xbb, 0x8a, 0x27, 0x9a, 0x7e,
-	0xd5, 0x0d, 0x83, 0x1d, 0x43, 0x8b, 0xe6, 0x3b, 0x56, 0xf5, 0x52, 0xd3, 0xaf, 0xbc, 0x68, 0xe0,
-	0x47, 0xcc, 0x04, 0x78, 0xfd, 0xc1, 0xa6, 0x5f, 0x75, 0xdb, 0x60, 0x9f, 0x80, 0x95, 0x4d, 0x66,
-	0xeb, 0x9e, 0x6d, 0xfa, 0x6b, 0xef, 0x1d, 0xa8, 0x9f, 0x35, 0xcc, 0x75, 0x8f, 0x1c, 0xfd, 0xb5,
-	0x03, 0x3a, 0x7b, 0x02, 0x9d, 0x64, 0xe4, 0xa8, 0x7e, 0x58, 0xe9, 0xaf, 0xb9, 0x13, 0x60, 0x78,
-	0xcc, 0xd8, 0x56, 0xf5, 0xfa, 0xd3, 0xaf, 0xbc, 0xb8, 0xb0, 0x47, 0xd0, 0x8e, 0x51, 0xbf, 0xf2,
-	0x89, 0xa4, 0x5f, 0x3d, 0xd9, 0xa3, 0x93, 0xd9, 0xbc, 0xb9, 0xee, 0x85, 0xaa, 0xbf, 0xf6, 0x86,
-	0xc5, 0x4e, 0x00, 0x72, 0xa3, 0xda, 0xda, 0xa7, 0xa7, 0xfe, 0xfa, 0x9b, 0x13, 0xfb, 0x18, 0xba,
-	0xd9, 0x6d, 0xb8, 0xfa, 0x49, 0xa8, 0xbf, 0xee, 0x32, 0x33, 0x6e, 0xd3, 0xb3, 0xe1, 0x87, 0xff,
-	0x09, 0x00, 0x00, 0xff, 0xff, 0x39, 0xa6, 0xae, 0x4d, 0xb2, 0x14, 0x00, 0x00,
+func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 1716 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x58, 0x4b, 0x73, 0x1b, 0xc7,
+	0x11, 0x26, 0xde, 0xd8, 0xe6, 0x03, 0xe0, 0x90, 0x14, 0x21, 0xa8, 0x52, 0xc5, 0xda, 0x24, 0x0a,
+	0x99, 0x30, 0x84, 0x42, 0x45, 0x0a, 0x15, 0x25, 0xaa, 0x90, 0x0c, 0x23, 0xb0, 0x94, 0x07, 0xb3,
+	0x7a, 0xb8, 0xca, 0x17, 0xd4, 0x60, 0x77, 0xb8, 0xd8, 0x12, 0xb0, 0xbb, 0xda, 0x19, 0x50, 0xa0,
+	0x7e, 0x83, 0xee, 0x3e, 0xfb, 0xe6, 0x3f, 0xe0, 0x9f, 0x60, 0x5f, 0xfc, 0x2b, 0x5c, 0xfe, 0x0f,
+	0x3e, 0xbb, 0xa6, 0x67, 0xdf, 0xdc, 0x95, 0x55, 0xf6, 0xcd, 0x17, 0x60, 0x66, 0xfa, 0xb1, 0xdd,
+	0xbd, 0xdd, 0x5f, 0xf7, 0x0e, 0xac, 0x8b, 0x6b, 0x9f, 0xf1, 0x01, 0xfe, 0x1e, 0xf8, 0x81, 0x27,
+	0x3c, 0xd2, 0xc0, 0x4d, 0x7f, 0x60, 0x3b, 0x62, 0x32, 0x1f, 0x1f, 0x98, 0xde, 0x6c, 0x20, 0x98,
+	0x6b, 0xb1, 0x60, 0xe6, 0xb8, 0x62, 0x20, 0x66, 0x53, 0x67, 0xcc, 0x07, 0xa6, 0x37, 0x9b, 0x79,
+	0x6e, 0x5a, 0x4e, 0xff, 0xba, 0x0e, 0x2d, 0x83, 0xbd, 0x99, 0x33, 0x2e, 0xc8, 0x2e, 0xd4, 0x99,
+	0x39, 0xf1, 0x7a, 0xd5, 0x9d, 0xca, 0xee, 0xf2, 0x21, 0x39, 0x50, 0x7c, 0x21, 0xf5, 0xcc, 0x9c,
+	0x78, 0xc3, 0x25, 0x03, 0x39, 0xc8, 0x1f, 0xa0, 0x71, 0x39, 0x9d, 0xf3, 0x49, 0xaf, 0x86, 0xac,
+	0x1b, 0x59, 0xd6, 0x7f, 0x49, 0xd2, 0x70, 0xc9, 0x50, 0x3c, 0x52, 0xad, 0xe3, 0x5e, 0x7a, 0xbd,
+	0x7a, 0x91, 0xda, 0x73, 0xf7, 0x12, 0xd5, 0x4a, 0x0e, 0x72, 0x04, 0xc0, 0x99, 0x18, 0x79, 0xbe,
+	0x70, 0x3c, 0xb7, 0xd7, 0x40, 0xfe, 0xed, 0x2c, 0xff, 0x73, 0x26, 0xfe, 0x87, 0xe4, 0xe1, 0x92,
+	0xa1, 0xf1, 0x68, 0x23, 0x25, 0x1d, 0xd7, 0x11, 0x23, 0x73, 0x42, 0x1d, 0xb7, 0xd7, 0x2c, 0x92,
+	0x3c, 0x77, 0x1d, 0x71, 0x2a, 0xc9, 0x52, 0xd2, 0x89, 0x36, 0xd2, 0x95, 0x37, 0x73, 0x16, 0x5c,
+	0xf7, 0x5a, 0x45, 0xae, 0xfc, 0x5f, 0x92, 0xa4, 0x2b, 0xc8, 0x43, 0x1e, 0xc3, 0xf2, 0x98, 0xd9,
+	0x8e, 0x3b, 0x1a, 0x4f, 0x3d, 0xf3, 0x75, 0xaf, 0x8d, 0x22, 0xbd, 0xac, 0xc8, 0x89, 0x64, 0x38,
+	0x91, 0xf4, 0xe1, 0x92, 0x01, 0xe3, 0x78, 0x47, 0x0e, 0xa1, 0x6d, 0x4e, 0x98, 0xf9, 0x7a, 0x24,
+	0x16, 0x3d, 0x0d, 0x25, 0xb7, 0xb2, 0x92, 0xa7, 0x92, 0xfa, 0x62, 0x31, 0x5c, 0x32, 0x5a, 0xa6,
+	0x5a, 0x4a, 0xbf, 0x2c, 0x36, 0x75, 0xae, 0x58, 0x20, 0xa5, 0x36, 0x8a, 0xfc, 0xfa, 0xa7, 0xa2,
+	0xa3, 0x9c, 0x66, 0x45, 0x1b, 0xf2, 0x00, 0x34, 0xe6, 0x5a, 0xa1, 0xa1, 0xcb, 0x28, 0x78, 0x2b,
+	0xf7, 0x46, 0x5d, 0x2b, 0x32, 0xb3, 0xcd, 0xc2, 0x35, 0x39, 0x80, 0xa6, 0xcc, 0x12, 0x47, 0xf4,
+	0x56, 0x50, 0x66, 0x33, 0x67, 0x22, 0xd2, 0x86, 0x4b, 0x46, 0xc8, 0x75, 0xd2, 0x82, 0xc6, 0x15,
+	0x9d, 0xce, 0x99, 0xfe, 0x3b, 0x58, 0x4e, 0x65, 0x0a, 0xe9, 0x41, 0x6b, 0xc6, 0x38, 0xa7, 0x36,
+	0xeb, 0x55, 0x76, 0x2a, 0xbb, 0x9a, 0x11, 0x6d, 0xf5, 0x35, 0x58, 0x49, 0xe7, 0x49, 0x4a, 0x50,
+	0xe6, 0x82, 0x14, 0xbc, 0x62, 0x01, 0x97, 0x09, 0x10, 0x0a, 0x86, 0x5b, 0xfd, 0xaf, 0xd0, 0xcd,
+	0x27, 0x01, 0xe9, 0x42, 0xed, 0x35, 0xbb, 0x0e, 0x39, 0xe5, 0x92, 0x6c, 0x86, 0x06, 0x61, 0x16,
+	0x6b, 0x46, 0x68, 0x9d, 0x13, 0xcb, 0xc6, 0x69, 0x40, 0xee, 0x01, 0x5c, 0xd1, 0xa9, 0x63, 0x51,
+	0xe1, 0x05, 0xbc, 0x57, 0xd9, 0xa9, 0xed, 0x2e, 0x1f, 0x76, 0x43, 0x77, 0x5f, 0x45, 0x04, 0x23,
+	0xc5, 0x43, 0x7e, 0x0d, 0xab, 0x36, 0x73, 0x19, 0x77, 0xf8, 0x68, 0x7c, 0x2d, 0x18, 0xc7, 0x67,
+	0xac, 0x18, 0x2b, 0xe1, 0xe1, 0x89, 0x3c, 0xd3, 0xad, 0xd8, 0x3f, 0x4c, 0x1e, 0x42, 0xa0, 0x6e,
+	0x51, 0x41, 0xd1, 0xc6, 0x15, 0x03, 0xd7, 0xf2, 0xcc, 0xa7, 0x62, 0x12, 0xda, 0x88, 0x6b, 0x72,
+	0x0b, 0x9a, 0x13, 0xe6, 0xd8, 0x13, 0x81, 0x45, 0x55, 0x33, 0xc2, 0x9d, 0x74, 0xc8, 0x0f, 0xbc,
+	0x2b, 0x86, 0xf5, 0xd3, 0x36, 0xd4, 0x46, 0xff, 0xa6, 0x02, 0xeb, 0x37, 0x12, 0x4e, 0xea, 0x9d,
+	0x50, 0x3e, 0x89, 0x9e, 0x25, 0xd7, 0xe4, 0xb7, 0x52, 0x2f, 0xb5, 0x58, 0x10, 0xd6, 0xf5, 0x6a,
+	0xe8, 0xe2, 0x10, 0x0f, 0x8d, 0x90, 0x48, 0xfe, 0x92, 0x89, 0x46, 0x0d, 0xa3, 0x11, 0x65, 0xda,
+	0x73, 0xc7, 0x76, 0x1d, 0xd7, 0x2e, 0x0e, 0xca, 0x09, 0x6c, 0x8e, 0xaf, 0xdf, 0x51, 0x57, 0x38,
+	0x2e, 0x1b, 0xa5, 0x54, 0xd4, 0x51, 0x45, 0x27, 0x54, 0x71, 0x76, 0xe5, 0x58, 0xcc, 0x35, 0x99,
+	0xb1, 0x11, 0x33, 0xc7, 0xea, 0xb8, 0xbe, 0x03, 0x6b, 0xd9, 0x1a, 0x20, 0x6b, 0x50, 0x15, 0x8b,
+	0xd0, 0x8f, 0xaa, 0x58, 0xe8, 0x7a, 0xfc, 0x02, 0xe3, 0x7c, 0xbf, 0xc1, 0xb3, 0x07, 0x9d, 0x5c,
+	0x6a, 0xa7, 0x82, 0x5a, 0x49, 0x07, 0x55, 0xef, 0xc0, 0x6a, 0x26, 0xa3, 0xf5, 0xf7, 0x0d, 0x68,
+	0x1b, 0x8c, 0xfb, 0x9e, 0xcb, 0x19, 0x39, 0x02, 0x8d, 0x2d, 0x4c, 0xa6, 0x60, 0xa8, 0x92, 0x2b,
+	0x72, 0xc5, 0x73, 0x16, 0xd1, 0x65, 0xd5, 0xc5, 0xcc, 0x64, 0x2f, 0x03, 0xa1, 0x1b, 0x79, 0xa1,
+	0x34, 0x86, 0xee, 0x67, 0x31, 0x74, 0x33, 0xc7, 0x9b, 0x03, 0xd1, 0xbd, 0x0c, 0x88, 0xe6, 0x15,
+	0x67, 0x50, 0xf4, 0x51, 0x01, 0x8a, 0xe6, 0xcd, 0x2f, 0x81, 0xd1, 0x47, 0x05, 0x30, 0xda, 0xbb,
+	0xf1, 0xac, 0x42, 0x1c, 0xdd, 0xcf, 0xe2, 0x68, 0xde, 0x9d, 0x1c, 0x90, 0xfe, 0xad, 0x08, 0x48,
+	0x6f, 0xe7, 0x64, 0x4a, 0x91, 0xf4, 0xfe, 0x0d, 0x24, 0xbd, 0x95, 0x13, 0x2d, 0x80, 0xd2, 0x47,
+	0x19, 0x28, 0x85, 0x42, 0xdf, 0x4a, 0xb0, 0xf4, 0xe1, 0x4d, 0x2c, 0xdd, 0xce, 0xbf, 0xda, 0x22,
+	0x30, 0x1d, 0xe4, 0xc0, 0x74, 0x2b, 0x6f, 0x65, 0x29, 0x9a, 0xee, 0xc9, 0xea, 0xce, 0x65, 0x9a,
+	0x44, 0x02, 0x16, 0x04, 0x5e, 0x10, 0xc2, 0x9d, 0xda, 0xe8, 0xbb, 0x12, 0x6f, 0x92, 0xfc, 0xfa,
+	0x00, 0xf2, 0x62, 0xd2, 0xa7, 0xb2, 0x4b, 0xff, 0xac, 0x92, 0xc8, 0x22, 0xf8, 0xa6, 0xb1, 0x4a,
+	0x0b, 0xb1, 0x2a, 0x05, 0xc8, 0xd5, 0x0c, 0x20, 0x93, 0xdf, 0xc3, 0xfa, 0x94, 0x72, 0xa1, 0xe2,
+	0x32, 0xca, 0x80, 0x57, 0x47, 0x12, 0x54, 0x40, 0x14, 0x8a, 0xfd, 0x11, 0x36, 0x52, 0xbc, 0xd4,
+	0xf7, 0x47, 0x08, 0x54, 0x75, 0x2c, 0xde, 0x6e, 0xcc, 0x7d, 0xec, 0xfb, 0x43, 0xca, 0x27, 0xfa,
+	0x7f, 0x12, 0xff, 0x13, 0xb0, 0x27, 0x50, 0x37, 0x3d, 0x4b, 0xb9, 0xb5, 0x6a, 0xe0, 0x5a, 0x36,
+	0x80, 0xa9, 0x67, 0xe3, 0x53, 0x35, 0x43, 0x2e, 0x25, 0x57, 0x5c, 0x29, 0x9a, 0x2a, 0x09, 0xfd,
+	0x2c, 0x51, 0xf7, 0x33, 0xf0, 0x5f, 0xff, 0xb2, 0x92, 0x44, 0x30, 0x06, 0xf7, 0x9f, 0x66, 0x92,
+	0x7c, 0x99, 0x8e, 0x6b, 0xb1, 0x05, 0x16, 0x68, 0xcd, 0x50, 0x9b, 0xa8, 0x9f, 0x35, 0x31, 0x2c,
+	0xd9, 0x7e, 0xd6, 0xc2, 0x33, 0xb5, 0x09, 0x9b, 0x82, 0x77, 0x89, 0x95, 0xb3, 0x62, 0xa8, 0x4d,
+	0x0a, 0xed, 0xb4, 0x0c, 0xda, 0x1d, 0x01, 0xb9, 0x59, 0x53, 0x44, 0x87, 0xba, 0xa0, 0x76, 0xe4,
+	0xf9, 0xda, 0x81, 0x9a, 0x0e, 0x0f, 0x9e, 0xbd, 0xba, 0xa0, 0x4e, 0x60, 0x20, 0x4d, 0xff, 0xb6,
+	0x22, 0x31, 0x35, 0x53, 0x53, 0x85, 0x3e, 0x47, 0x89, 0x53, 0x4d, 0x35, 0xb9, 0x8f, 0x8b, 0xc3,
+	0xaf, 0x00, 0x6c, 0xca, 0x47, 0x6f, 0xa9, 0x2b, 0x98, 0x15, 0x06, 0x43, 0xb3, 0x29, 0xff, 0x04,
+	0x0f, 0xc8, 0x6d, 0x68, 0x4b, 0xf2, 0x9c, 0x33, 0x0b, 0xa3, 0x52, 0x33, 0x5a, 0x36, 0xe5, 0x2f,
+	0x39, 0xb3, 0x62, 0xfb, 0x5b, 0xe5, 0xf6, 0x13, 0x1d, 0x6a, 0x97, 0x8c, 0x85, 0xf8, 0xd2, 0x8d,
+	0x59, 0xce, 0x1f, 0xfe, 0x19, 0x99, 0x24, 0x51, 0xff, 0xae, 0x92, 0x64, 0x47, 0xd2, 0x5c, 0x7e,
+	0x69, 0x5e, 0x7e, 0x55, 0x91, 0x1d, 0x34, 0x0b, 0x56, 0xe4, 0xef, 0xb0, 0x1e, 0xa7, 0xf7, 0x68,
+	0xee, 0x5b, 0x54, 0x0e, 0x35, 0x65, 0x95, 0xd0, 0x8d, 0x59, 0x5f, 0x2a, 0x4e, 0xf2, 0x5f, 0xd8,
+	0x36, 0xa5, 0x3e, 0x97, 0xcf, 0xf9, 0xc8, 0xa7, 0x01, 0x9d, 0xc5, 0x4a, 0xaa, 0x19, 0x58, 0x3e,
+	0x8d, 0xb8, 0x2e, 0x24, 0x13, 0x37, 0xb6, 0xcc, 0xcc, 0x41, 0xa4, 0x2f, 0xf2, 0xb5, 0xf6, 0x81,
+	0x8c, 0xfc, 0x8d, 0x1c, 0x15, 0xd2, 0xf0, 0x59, 0xf4, 0x56, 0xf4, 0xcf, 0x2b, 0xd0, 0xc9, 0x3d,
+	0x94, 0x0c, 0x00, 0x14, 0xfa, 0x70, 0xe7, 0x1d, 0x0b, 0xdb, 0x7a, 0xe4, 0x25, 0x86, 0xe3, 0xb9,
+	0xf3, 0x8e, 0x19, 0xda, 0x38, 0x5a, 0x92, 0xbb, 0xd0, 0x12, 0x0b, 0xc5, 0x9d, 0x1d, 0x9d, 0x5e,
+	0x2c, 0x90, 0xb5, 0x29, 0xf0, 0x9f, 0x3c, 0x80, 0x15, 0xa5, 0xd8, 0xf6, 0x38, 0x77, 0xfc, 0xb0,
+	0xa1, 0x93, 0xb4, 0xea, 0xa7, 0x48, 0x31, 0x96, 0xc7, 0xc9, 0x46, 0xff, 0x14, 0xb4, 0xf8, 0xb1,
+	0xe4, 0x0e, 0x68, 0x33, 0xba, 0x08, 0xc7, 0x4a, 0x69, 0x5b, 0xc3, 0x68, 0xcf, 0xe8, 0x02, 0x47,
+	0x4a, 0xb2, 0x0d, 0x2d, 0x49, 0x14, 0x0b, 0x15, 0xd7, 0x86, 0xd1, 0x9c, 0xd1, 0xc5, 0x8b, 0x45,
+	0x4c, 0xb0, 0x29, 0x8f, 0x86, 0xc6, 0x19, 0x5d, 0x3c, 0xa5, 0x5c, 0x7f, 0x02, 0x4d, 0x65, 0xe4,
+	0x47, 0x29, 0x96, 0xf2, 0xd5, 0x8c, 0xfc, 0x3f, 0x60, 0x39, 0x65, 0x37, 0xf9, 0x13, 0x6c, 0x29,
+	0x0f, 0x7d, 0x1a, 0x08, 0x8c, 0x48, 0x46, 0x21, 0x41, 0xe2, 0x05, 0x0d, 0x84, 0x7c, 0xa4, 0x1a,
+	0x83, 0xbf, 0xaf, 0x40, 0x53, 0x8d, 0x98, 0x32, 0xbb, 0x71, 0xa0, 0x18, 0x39, 0x56, 0xd4, 0x92,
+	0x70, 0x7f, 0x6e, 0xa5, 0x10, 0xab, 0x9a, 0x19, 0x7a, 0x09, 0xd4, 0x85, 0x33, 0x63, 0xa1, 0x57,
+	0xb8, 0x96, 0xc6, 0xba, 0xf3, 0x19, 0x46, 0xa1, 0xae, 0xa2, 0xe0, 0xce, 0x67, 0x32, 0x0a, 0x77,
+	0x40, 0x13, 0x9e, 0xa0, 0x53, 0x24, 0xa9, 0xda, 0x6a, 0xe3, 0x81, 0x24, 0xde, 0x85, 0x4e, 0xba,
+	0x49, 0xc9, 0xa6, 0xa3, 0xd0, 0x75, 0x35, 0x69, 0x51, 0x72, 0x4c, 0xbe, 0x0d, 0xed, 0xb8, 0x2b,
+	0x29, 0xa8, 0x6d, 0x51, 0xd5, 0x8c, 0xc8, 0x3e, 0xb4, 0xfd, 0xc0, 0xf3, 0x3d, 0xce, 0x82, 0xb8,
+	0xc6, 0xf2, 0xc5, 0x11, 0x73, 0xe8, 0x26, 0x68, 0xf1, 0xb1, 0x6c, 0x9e, 0xd4, 0xb2, 0x02, 0xc6,
+	0x79, 0x38, 0xa7, 0x46, 0x5b, 0x99, 0x5c, 0xfe, 0x7c, 0x3c, 0x92, 0x68, 0x9f, 0x4d, 0xae, 0x8b,
+	0xf9, 0xf8, 0x19, 0xbb, 0x36, 0x9a, 0x3e, 0xfe, 0x23, 0xd2, 0x7b, 0x6f, 0x59, 0x10, 0x86, 0x42,
+	0x6d, 0x74, 0x17, 0xba, 0xf9, 0xa1, 0x9c, 0x1c, 0x80, 0x16, 0x57, 0x68, 0x2e, 0xbd, 0x13, 0x3b,
+	0x13, 0x16, 0xd9, 0xbe, 0xb9, 0x63, 0xbb, 0xcc, 0x1a, 0x25, 0x01, 0x42, 0x5b, 0xda, 0x46, 0x47,
+	0x11, 0xfe, 0x1d, 0x45, 0x48, 0xbf, 0x07, 0x4d, 0x65, 0x17, 0xbe, 0x99, 0x6b, 0x3f, 0x9a, 0x2d,
+	0x70, 0x5d, 0x58, 0x81, 0x5f, 0x54, 0xa0, 0x1d, 0x0d, 0xfd, 0x85, 0x42, 0x19, 0x73, 0xab, 0x3f,
+	0x6e, 0x6e, 0xd9, 0xf7, 0x51, 0x94, 0x2a, 0xf5, 0x54, 0xaa, 0xec, 0x03, 0x51, 0x19, 0x71, 0xe5,
+	0x09, 0xc7, 0xb5, 0x47, 0x2a, 0x82, 0x2a, 0x35, 0xba, 0x48, 0x79, 0x85, 0x84, 0x0b, 0x79, 0x7e,
+	0xf8, 0xbe, 0x01, 0x9d, 0xe3, 0x93, 0xd3, 0xf3, 0x63, 0xdf, 0x9f, 0x3a, 0x26, 0xc5, 0x59, 0x63,
+	0x00, 0x75, 0x9c, 0xa6, 0x0a, 0x6e, 0x41, 0xfa, 0x45, 0x63, 0x3d, 0x39, 0x84, 0x06, 0x0e, 0x55,
+	0xa4, 0xe8, 0x32, 0xa4, 0x5f, 0x38, 0xdd, 0xcb, 0x87, 0xa8, 0xb1, 0xeb, 0xe6, 0x9d, 0x48, 0xbf,
+	0x68, 0xc4, 0x27, 0x4f, 0x40, 0x4b, 0xc6, 0xa1, 0xb2, 0x9b, 0x91, 0x7e, 0xe9, 0xb0, 0x2f, 0xe5,
+	0x93, 0x0e, 0x57, 0x76, 0x8f, 0xd0, 0x2f, 0x9d, 0x8a, 0xc9, 0x11, 0xb4, 0xa2, 0x29, 0xa0, 0xf8,
+	0xee, 0xa2, 0x5f, 0x32, 0x88, 0xcb, 0xf0, 0xa8, 0x89, 0xa9, 0xe8, 0x82, 0xa5, 0x5f, 0xf8, 0xb5,
+	0x40, 0x1e, 0x40, 0x33, 0x84, 0xf8, 0xc2, 0x5b, 0x88, 0x7e, 0xf1, 0x38, 0x2d, 0x9d, 0x4c, 0x86,
+	0xbc, 0xb2, 0x4b, 0xa0, 0x7e, 0xe9, 0x67, 0x0d, 0x39, 0x06, 0x48, 0x4d, 0x49, 0xa5, 0xb7, 0x3b,
+	0xfd, 0xf2, 0xcf, 0x15, 0xf2, 0x18, 0xda, 0xc9, 0x27, 0x68, 0xf1, 0xad, 0x4b, 0xbf, 0xec, 0x0b,
+	0x62, 0xdc, 0xc4, 0x9b, 0xb9, 0xfb, 0x3f, 0x04, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x76, 0x50, 0x7d,
+	0xe6, 0x13, 0x00, 0x00,
 }
diff --git a/types/types.proto b/types/types.proto
index 2cea82d0d..c97b73811 100644
--- a/types/types.proto
+++ b/types/types.proto
@@ -1,14 +1,9 @@
 syntax = "proto3";
 package types;
 
-// For more information on gogo.proto, see:
-// https://github.com/gogo/protobuf/blob/master/extensions.md
-import "github.com/gogo/protobuf/gogoproto/gogo.proto";
 import "github.com/tendermint/tmlibs/common/types.proto";
 
 // This file is copied from http://github.com/tendermint/abci
-// NOTE: When using custom types, mind the warnings.
-// https://github.com/gogo/protobuf/blob/master/custom_types.md#warnings-and-issues
 
 //----------------------------------------
 // Request types
@@ -47,7 +42,7 @@ message RequestSetOption {
 }
 
 message RequestInitChain {
-  repeated Validator validators = 1 [(gogoproto.nullable)=false];
+  repeated Validator validators = 1;
   bytes genesis_bytes = 2;
 }
 
@@ -60,9 +55,9 @@ message RequestQuery {
 
 message RequestBeginBlock {
   bytes hash = 1;
-  Header header = 2 [(gogoproto.nullable)=false];
+  Header header = 2;
   repeated SigningValidator validators = 3;
-  repeated Evidence byzantine_validators = 4 [(gogoproto.nullable)=false];
+  repeated Evidence byzantine_validators = 4;
 }
 
 message RequestCheckTx {
@@ -128,7 +123,7 @@ message ResponseSetOption {
 }
 
 message ResponseInitChain {
-  repeated Validator validators = 1 [(gogoproto.nullable)=false];
+  repeated Validator validators = 1;
 }
 
 message ResponseQuery {
@@ -144,7 +139,7 @@ message ResponseQuery {
 }
 
 message ResponseBeginBlock {
-  repeated common.KVPair tags = 1 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
+  repeated common.KVPair tags = 1;
 }
 
 message ResponseCheckTx {
@@ -154,8 +149,8 @@ message ResponseCheckTx {
   string info = 4; // nondeterministic
   int64 gas_wanted  = 5;
   int64 gas_used = 6;
-  repeated common.KVPair tags = 7 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
-  common.KI64Pair fee = 8 [(gogoproto.nullable)=false];
+  repeated common.KVPair tags = 7;
+  common.KI64Pair fee = 8;
 }
 
 message ResponseDeliverTx {
@@ -165,14 +160,14 @@ message ResponseDeliverTx {
   string info = 4; // nondeterministic
   int64 gas_wanted = 5;
   int64 gas_used = 6;
-  repeated common.KVPair tags = 7 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
-  common.KI64Pair fee = 8 [(gogoproto.nullable)=false];
+  repeated common.KVPair tags = 7;
+  common.KI64Pair fee = 8;
 }
 
 message ResponseEndBlock {
-  repeated Validator validator_updates = 1 [(gogoproto.nullable)=false];
+  repeated Validator validator_updates = 1;
   ConsensusParams consensus_param_updates = 2;
-  repeated common.KVPair tags = 3 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
+  repeated common.KVPair tags = 3;
 }
 
 message ResponseCommit {
@@ -217,7 +212,7 @@ message BlockGossip {
 // just the minimum the app might need
 message Header {
   // basics
-  string chain_id = 1 [(gogoproto.customname)="ChainID"];
+  string chain_id = 1;
   int64 height = 2;
   int64 time = 3;
 
@@ -236,7 +231,7 @@ message Header {
 // Validator
 message Validator {
   bytes address = 1;
-  PubKey pub_key = 2 [(gogoproto.nullable)=false];
+  PubKey pub_key = 2;
   int64 power = 3;
 }
 
diff --git a/types/util.go b/types/validator.go
similarity index 85%
rename from types/util.go
rename to types/validator.go
index 0924ab5ff..f73c978b2 100644
--- a/types/util.go
+++ b/types/validator.go
@@ -8,6 +8,21 @@ import (
 	cmn "github.com/tendermint/tmlibs/common"
 )
 
+const (
+	PubKeyEd25519 = "ed25519"
+)
+
+func Ed25519Validator(pubkey []byte, power int64) Validator {
+	return Validator{
+		// Address:
+		PubKey: &PubKey{
+			Type: PubKeyEd25519,
+			Data: pubkey,
+		},
+		Power: power,
+	}
+}
+
 //------------------------------------------------------------------------------
 
 // Validators is a list of validators that implements the Sort interface