Merge pull request #111 from tendermint/develop

Develop
2025-06-01 15:41:22 +00:00 · 2017-09-22 11:16:23 -04:00 · 2017-09-22 11:16:23 -04:00 · 191c4b6d17
commit 191c4b6d17
parent f1094f760b 88cb73d95a
26 changed files with 350 additions and 364 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,5 +1,17 @@
 # Changelog

+## 0.6.0 (September 22, 2017)
+
+BREAKING CHANGES:
+
+- [types/client] app.BeginBlock takes RequestBeginBlock
+- [types/client] app.InitChain takes RequestInitChain
+- [types/client] app.Info takes RequestInfo
+
+IMPROVEMENTS:
+
+- various linting
+
 ## 0.5.0 (May 18, 2017)

 BREAKING CHANGES:
--- a/45
+++ b/45
@ -1,6 +1,7 @@
 GOTOOLS = \
 					github.com/mitchellh/gox \
-					github.com/Masterminds/glide
+					github.com/Masterminds/glide \
+					github.com/alecthomas/gometalinter

 all: protoc install test

@ -32,12 +33,6 @@ test: install
 fmt:
 	@ go fmt ./...

-lint:
-	@ go get -u github.com/golang/lint/golint
-	@ for file in $$(find "." -name '*.go' | grep -v '/vendor/' | grep -v '\.pb\.go'); do \
-		golint -set_exit_status $${file}; \
-		done;
-
 test_integrations: get_vendor_deps install test

 get_deps:
@ -50,4 +45,38 @@ get_vendor_deps:
 	@ go get github.com/Masterminds/glide
 	@ glide install

-.PHONY: all build test fmt lint get_deps tools
+metalinter: tools
+	@gometalinter --install
+	gometalinter --vendor --deadline=600s --enable-all --disable=lll ./...
+
+metalinter_test: tools
+	@gometalinter --install
+	gometalinter --vendor --deadline=600s --disable-all  \
+		--enable=aligncheck \
+		--enable=deadcode \
+		--enable=gas \
+		--enable=goconst \
+		--enable=goimports \
+		--enable=gosimple \
+		--enable=gotype \
+	 	--enable=ineffassign \
+		--enable=megacheck \
+	 	--enable=misspell \
+	   	--enable=staticcheck \
+		--enable=safesql \
+	   	--enable=structcheck \
+	   	--enable=unconvert \
+		--enable=unused \
+	   	--enable=varcheck \
+		--enable=vetshadow \
+		./...
+
+		#--enable=dupl \
+		#--enable=errcheck \
+		#--enable=gocyclo \
+		#--enable=golint \ <== comments on anything exported
+	   	#--enable=interfacer \
+	   	#--enable=unparam \
+		#--enable=vet \
+
+.PHONY: all build test fmt get_deps tools
--- a/README.md
+++ b/README.md
@ -8,7 +8,7 @@ and the state machine (the application).
 By using a socket protocol, we enable a consensus engine running in one process
 to manage an application state running in another.

-# Install
+## Install

 ```
 go get github.com/tendermint/abci
@ -17,18 +17,54 @@ glide install
 go install ./cmd/...
 ```

-For more information on ABCI, motivations, and tutorials, please visit [our blog post](https://tendermint.com/blog/abci-the-application-blockchain-interface),
-and the more detailed [application developer's guide](https://tendermint.com/docs/guides/app-development).
+For background information on ABCI, motivations, and tendermint, please visit [the documentation](http://tendermint.readthedocs.io/en/master/).
+The two guides to focus on are the `Application Development Guide` and `Using ABCI-CLI`.

 Previously, the ABCI was referred to as TMSP.

-Other implementations:
-* C++ [cpp-tmsp](https://github.com/mdyring/cpp-tmsp) by Martin Dyring-Andersen
-* JavaScript [js-abci](https://github.com/tendermint/js-abci)
-* Java [jABCI](https://github.com/jTendermint/jabci)
-* Erlang [abci_server](https://github.com/KrzysiekJ/abci_server) by Krzysztof Jurewicz
+The community has provided a number of addtional implementations, see the `Tendermint Ecosystem` in [the documentation](http://tendermint.readthedocs.io/en/master/).

-# Specification
+## Implementation
+
+We provide three implementations of the ABCI in Go:
+
+- ABCI-socket
+- GRPC
+- Golang in-process
+
+### Socket
+
+ABCI is best implemented as a streaming protocol.
+The socket implementation provides for asynchronous, ordered message passing over unix or tcp.
+Messages are serialized using Protobuf3 and length-prefixed.
+Protobuf3 doesn't have an official length-prefix standard, so we use our own.  The first byte represents the length of the big-endian encoded length.
+
+For example, if the Protobuf3 encoded ABCI message is `0xDEADBEEF` (4 bytes), the length-prefixed message is `0x0104DEADBEEF`.  If the Protobuf3 encoded ABCI message is 65535 bytes long, the length-prefixed message would be like `0x02FFFF...`.
+
+### GRPC
+
+GRPC is an rpc framework native to Protocol Buffers with support in many languages.
+Implementing the ABCI using GRPC can allow for faster prototyping, but is expected to be much slower than
+the ordered, asynchronous socket protocol.
+
+Note the length-prefixing used in the socket implementation does not apply for GRPC.
+
+### In Process
+
+The simplest implementation just uses function calls within Go.
+This means ABCI applications written in Golang can be compiled with TendermintCore and run as a single binary.
+
+## Example Apps
+
+The `abci-cli` tool wraps any ABCI client and can be used for probing/testing an ABCI application.
+See [the documentation](http://tendermint.readthedocs.io/en/master/) for more details.
+
+Multiple example apps are included:
+- the `counter` application, which illustrates nonce checking in txs
+- the `dummy` application, which illustrates a simple key-value merkle tree
+- the `dummy --persistent` application, which augments the dummy with persistence and validator set changes
+
+## Specification

 The [primary specification](https://github.com/tendermint/abci/blob/master/types/types.proto) is made using Protocol Buffers.
 To build it, run
@ -42,7 +78,7 @@ Note we also include a [GRPC](http://www.grpc.io/docs) service definition.

 For the specification as an interface in Go, see the [types/application.go file](https://github.com/tendermint/abci/blob/master/types/application.go).

-## Message Types
+### Message Types

 ABCI requests/responses are defined as simple Protobuf messages in [this schema file](https://github.com/tendermint/abci/blob/master/types/types.proto).
 TendermintCore sends the requests, and the ABCI application sends the responses.
@ -148,49 +184,6 @@ Here, we describe the requests and responses as function arguments and return va
  * __Usage__:<br/>
    * Echo a string to test an abci client/server implementation

-
 #### Flush
  * __Usage__:<br/>
    * Signals that messages queued on the client should be flushed to the server. It is called periodically by the client implementation to ensure asynchronous requests are actually sent, and is called immediately to make a synchronous request, which returns when the Flush response comes back.
-
-
-# Implementation
-
-We provide three implementations of the ABCI in Go:
-
-1. ABCI-socket
-2. GRPC
-3. Golang in-process
-
-## Socket
-
-ABCI is best implemented as a streaming protocol.
-The socket implementation provides for asynchronous, ordered message passing over unix or tcp.
-Messages are serialized using Protobuf3 and length-prefixed.
-Protobuf3 doesn't have an official length-prefix standard, so we use our own.  The first byte represents the length of the big-endian encoded length.
-
-For example, if the Protobuf3 encoded ABCI message is `0xDEADBEEF` (4 bytes), the length-prefixed message is `0x0104DEADBEEF`.  If the Protobuf3 encoded ABCI message is 65535 bytes long, the length-prefixed message would be like `0x02FFFF...`.
-
-## GRPC
-
-GRPC is an rpc framework native to Protocol Buffers with support in many languages.
-Implementing the ABCI using GRPC can allow for faster prototyping, but is expected to be much slower than
-the ordered, asynchronous socket protocol.
-
-Note the length-prefixing used in the socket implementation does not apply for GRPC.
-
-## In Process
-
-The simplest implementation just uses function calls within Go.
-This means ABCI applications written in Golang can be compiled with TendermintCore and run as a single binary.
-
-
-# Tools and Apps
-
-The `abci-cli` tool wraps any ABCI client and can be used for probing/testing an ABCI application.
-See the [guide](https://tendermint.com/docs/guides/abci-cli) for more details.
-
-Multiple example apps are included:
- the `counter` application, which illustrates nonce checking in txs
- the `dummy` application, which illustrates a simple key-value merkle tree
- the `dummy --persistent` application, which augments the dummy with persistence and validator set changes
--- a/circle.yml
+++ b/circle.yml
@ -18,4 +18,5 @@ checkout:
 test:
  override:
    - "go version"
+    - "cd $REPO && make get_vendor_deps && make metalinter_test"
    - "cd $REPO && make test_integrations"
--- a/client/client.go
+++ b/client/client.go
@ -16,28 +16,28 @@ type Client interface {

 	FlushAsync() *ReqRes
 	EchoAsync(msg string) *ReqRes
-	InfoAsync() *ReqRes
+	InfoAsync(types.RequestInfo) *ReqRes
 	SetOptionAsync(key string, value string) *ReqRes
 	DeliverTxAsync(tx []byte) *ReqRes
 	CheckTxAsync(tx []byte) *ReqRes
-	QueryAsync(reqQuery types.RequestQuery) *ReqRes
+	QueryAsync(types.RequestQuery) *ReqRes
 	CommitAsync() *ReqRes

 	FlushSync() error
 	EchoSync(msg string) (res types.Result)
-	InfoSync() (resInfo types.ResponseInfo, err error)
+	InfoSync(types.RequestInfo) (resInfo types.ResponseInfo, err error)
 	SetOptionSync(key string, value string) (res types.Result)
 	DeliverTxSync(tx []byte) (res types.Result)
 	CheckTxSync(tx []byte) (res types.Result)
-	QuerySync(reqQuery types.RequestQuery) (resQuery types.ResponseQuery, err error)
+	QuerySync(types.RequestQuery) (resQuery types.ResponseQuery, err error)
 	CommitSync() (res types.Result)

-	InitChainAsync(validators []*types.Validator) *ReqRes
-	BeginBlockAsync(hash []byte, header *types.Header) *ReqRes
+	InitChainAsync(types.RequestInitChain) *ReqRes
+	BeginBlockAsync(types.RequestBeginBlock) *ReqRes
 	EndBlockAsync(height uint64) *ReqRes

-	InitChainSync(validators []*types.Validator) (err error)
-	BeginBlockSync(hash []byte, header *types.Header) (err error)
+	InitChainSync(types.RequestInitChain) (err error)
+	BeginBlockSync(types.RequestBeginBlock) (err error)
 	EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error)
 }

--- a/client/grpc_client.go
+++ b/client/grpc_client.go
@ -41,7 +41,9 @@ func dialerFunc(addr string, timeout time.Duration) (net.Conn, error) {
 }

 func (cli *grpcClient) OnStart() error {
-	cli.BaseService.OnStart()
+	if err := cli.BaseService.OnStart(); err != nil {
+		return err
+	}
 RETRY_LOOP:

 	for {
@ -113,7 +115,7 @@ func (cli *grpcClient) SetResponseCallback(resCb Callback) {
 //----------------------------------------
 // GRPC calls are synchronous, but some callbacks expect to be called asynchronously
 // (eg. the mempool expects to be able to lock to remove bad txs from cache).
-// To accomodate, we finish each call in its own go-routine,
+// To accommodate, we finish each call in its own go-routine,
 // which is expensive, but easy - if you want something better, use the socket protocol!
 // maybe one day, if people really want it, we use grpc streams,
 // but hopefully not :D
@ -136,8 +138,8 @@ func (cli *grpcClient) FlushAsync() *ReqRes {
 	return cli.finishAsyncCall(req, &types.Response{&types.Response_Flush{res}})
 }

-func (cli *grpcClient) InfoAsync() *ReqRes {
-	req := types.ToRequestInfo()
+func (cli *grpcClient) InfoAsync(params types.RequestInfo) *ReqRes {
+	req := types.ToRequestInfo(params)
 	res, err := cli.client.Info(context.Background(), req.GetInfo(), grpc.FailFast(true))
 	if err != nil {
 		cli.StopForError(err)
@ -172,8 +174,8 @@ func (cli *grpcClient) CheckTxAsync(tx []byte) *ReqRes {
 	return cli.finishAsyncCall(req, &types.Response{&types.Response_CheckTx{res}})
 }

-func (cli *grpcClient) QueryAsync(reqQuery types.RequestQuery) *ReqRes {
-	req := types.ToRequestQuery(reqQuery)
+func (cli *grpcClient) QueryAsync(params types.RequestQuery) *ReqRes {
+	req := types.ToRequestQuery(params)
 	res, err := cli.client.Query(context.Background(), req.GetQuery(), grpc.FailFast(true))
 	if err != nil {
 		cli.StopForError(err)
@ -190,8 +192,8 @@ func (cli *grpcClient) CommitAsync() *ReqRes {
 	return cli.finishAsyncCall(req, &types.Response{&types.Response_Commit{res}})
 }

-func (cli *grpcClient) InitChainAsync(validators []*types.Validator) *ReqRes {
-	req := types.ToRequestInitChain(validators)
+func (cli *grpcClient) InitChainAsync(params types.RequestInitChain) *ReqRes {
+	req := types.ToRequestInitChain(params)
 	res, err := cli.client.InitChain(context.Background(), req.GetInitChain(), grpc.FailFast(true))
 	if err != nil {
 		cli.StopForError(err)
@ -199,8 +201,8 @@ func (cli *grpcClient) InitChainAsync(validators []*types.Validator) *ReqRes {
 	return cli.finishAsyncCall(req, &types.Response{&types.Response_InitChain{res}})
 }

-func (cli *grpcClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqRes {
-	req := types.ToRequestBeginBlock(hash, header)
+func (cli *grpcClient) BeginBlockAsync(params types.RequestBeginBlock) *ReqRes {
+	req := types.ToRequestBeginBlock(params)
 	res, err := cli.client.BeginBlock(context.Background(), req.GetBeginBlock(), grpc.FailFast(true))
 	if err != nil {
 		cli.StopForError(err)
@ -261,8 +263,8 @@ func (cli *grpcClient) FlushSync() error {
 	return nil
 }

-func (cli *grpcClient) InfoSync() (resInfo types.ResponseInfo, err error) {
-	reqres := cli.InfoAsync()
+func (cli *grpcClient) InfoSync(req types.RequestInfo) (resInfo types.ResponseInfo, err error) {
+	reqres := cli.InfoAsync(req)
 	if err = cli.Error(); err != nil {
 		return resInfo, err
 	}
@ -319,13 +321,13 @@ func (cli *grpcClient) CommitSync() (res types.Result) {
 	return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log}
 }

-func (cli *grpcClient) InitChainSync(validators []*types.Validator) (err error) {
-	cli.InitChainAsync(validators)
+func (cli *grpcClient) InitChainSync(params types.RequestInitChain) (err error) {
+	cli.InitChainAsync(params)
 	return cli.Error()
 }

-func (cli *grpcClient) BeginBlockSync(hash []byte, header *types.Header) (err error) {
-	cli.BeginBlockAsync(hash, header)
+func (cli *grpcClient) BeginBlockSync(params types.RequestBeginBlock) (err error) {
+	cli.BeginBlockAsync(params)
 	return cli.Error()
 }

--- a/client/local_client.go
+++ b/client/local_client.go
@ -49,12 +49,12 @@ func (app *localClient) EchoAsync(msg string) *ReqRes {
 	)
 }

-func (app *localClient) InfoAsync() *ReqRes {
+func (app *localClient) InfoAsync(req types.RequestInfo) *ReqRes {
 	app.mtx.Lock()
-	resInfo := app.Application.Info()
+	resInfo := app.Application.Info(req)
 	app.mtx.Unlock()
 	return app.callback(
-		types.ToRequestInfo(),
+		types.ToRequestInfo(req),
 		types.ToResponseInfo(resInfo),
 	)
 }
@ -109,23 +109,23 @@ func (app *localClient) CommitAsync() *ReqRes {
 	)
 }

-func (app *localClient) InitChainAsync(validators []*types.Validator) *ReqRes {
+func (app *localClient) InitChainAsync(params types.RequestInitChain) *ReqRes {
 	app.mtx.Lock()
-	app.Application.InitChain(validators)
+	app.Application.InitChain(params)
 	reqRes := app.callback(
-		types.ToRequestInitChain(validators),
+		types.ToRequestInitChain(params),
 		types.ToResponseInitChain(),
 	)
 	app.mtx.Unlock()
 	return reqRes
 }

-func (app *localClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqRes {
+func (app *localClient) BeginBlockAsync(params types.RequestBeginBlock) *ReqRes {
 	app.mtx.Lock()
-	app.Application.BeginBlock(hash, header)
+	app.Application.BeginBlock(params)
 	app.mtx.Unlock()
 	return app.callback(
-		types.ToRequestBeginBlock(hash, header),
+		types.ToRequestBeginBlock(params),
 		types.ToResponseBeginBlock(),
 	)
 }
@ -150,10 +150,10 @@ func (app *localClient) EchoSync(msg string) (res types.Result) {
 	return types.OK.SetData([]byte(msg))
 }

-func (app *localClient) InfoSync() (resInfo types.ResponseInfo, err error) {
+func (app *localClient) InfoSync(req types.RequestInfo) (resInfo types.ResponseInfo, err error) {
 	app.mtx.Lock()
 	defer app.mtx.Unlock()
-	resInfo = app.Application.Info()
+	resInfo = app.Application.Info(req)
 	return resInfo, nil
 }

@ -192,16 +192,16 @@ func (app *localClient) CommitSync() (res types.Result) {
 	return res
 }

-func (app *localClient) InitChainSync(validators []*types.Validator) (err error) {
+func (app *localClient) InitChainSync(params types.RequestInitChain) (err error) {
 	app.mtx.Lock()
-	app.Application.InitChain(validators)
+	app.Application.InitChain(params)
 	app.mtx.Unlock()
 	return nil
 }

-func (app *localClient) BeginBlockSync(hash []byte, header *types.Header) (err error) {
+func (app *localClient) BeginBlockSync(params types.RequestBeginBlock) (err error) {
 	app.mtx.Lock()
-	app.Application.BeginBlock(hash, header)
+	app.Application.BeginBlock(params)
 	app.mtx.Unlock()
 	return nil
 }
--- a/client/socket_client.go
+++ b/client/socket_client.go
@ -19,9 +19,9 @@ const (
 	LOG = ""
 )

-const reqQueueSize = 256        // TODO make configurable
-const maxResponseSize = 1048576 // 1MB TODO make configurable
-const flushThrottleMS = 20      // Don't wait longer than...
+const reqQueueSize = 256 // TODO make configurable
+// const maxResponseSize = 1048576 // 1MB TODO make configurable
+const flushThrottleMS = 20 // Don't wait longer than...

 // This is goroutine-safe, but users should beware that
 // the application in general is not meant to be interfaced
@ -57,7 +57,9 @@ func NewSocketClient(addr string, mustConnect bool) *socketClient {
 }

 func (cli *socketClient) OnStart() error {
-	cli.BaseService.OnStart()
+	if err := cli.BaseService.OnStart(); err != nil {
+		return err
+	}

 	var err error
 	var conn net.Conn
@ -231,8 +233,8 @@ func (cli *socketClient) FlushAsync() *ReqRes {
 	return cli.queueRequest(types.ToRequestFlush())
 }

-func (cli *socketClient) InfoAsync() *ReqRes {
-	return cli.queueRequest(types.ToRequestInfo())
+func (cli *socketClient) InfoAsync(req types.RequestInfo) *ReqRes {
+	return cli.queueRequest(types.ToRequestInfo(req))
 }

 func (cli *socketClient) SetOptionAsync(key string, value string) *ReqRes {
@ -255,12 +257,12 @@ func (cli *socketClient) CommitAsync() *ReqRes {
 	return cli.queueRequest(types.ToRequestCommit())
 }

-func (cli *socketClient) InitChainAsync(validators []*types.Validator) *ReqRes {
-	return cli.queueRequest(types.ToRequestInitChain(validators))
+func (cli *socketClient) InitChainAsync(params types.RequestInitChain) *ReqRes {
+	return cli.queueRequest(types.ToRequestInitChain(params))
 }

-func (cli *socketClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqRes {
-	return cli.queueRequest(types.ToRequestBeginBlock(hash, header))
+func (cli *socketClient) BeginBlockAsync(params types.RequestBeginBlock) *ReqRes {
+	return cli.queueRequest(types.ToRequestBeginBlock(params))
 }

 func (cli *socketClient) EndBlockAsync(height uint64) *ReqRes {
@ -288,8 +290,8 @@ func (cli *socketClient) FlushSync() error {
 	return cli.Error()
 }

-func (cli *socketClient) InfoSync() (resInfo types.ResponseInfo, err error) {
-	reqres := cli.queueRequest(types.ToRequestInfo())
+func (cli *socketClient) InfoSync(req types.RequestInfo) (resInfo types.ResponseInfo, err error) {
+	reqres := cli.queueRequest(types.ToRequestInfo(req))
 	cli.FlushSync()
 	if err := cli.Error(); err != nil {
 		return resInfo, err
@ -352,22 +354,16 @@ func (cli *socketClient) CommitSync() (res types.Result) {
 	return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log}
 }

-func (cli *socketClient) InitChainSync(validators []*types.Validator) (err error) {
-	cli.queueRequest(types.ToRequestInitChain(validators))
+func (cli *socketClient) InitChainSync(params types.RequestInitChain) (err error) {
+	cli.queueRequest(types.ToRequestInitChain(params))
 	cli.FlushSync()
-	if err := cli.Error(); err != nil {
-		return err
-	}
-	return nil
+	return cli.Error()
 }

-func (cli *socketClient) BeginBlockSync(hash []byte, header *types.Header) (err error) {
-	cli.queueRequest(types.ToRequestBeginBlock(hash, header))
+func (cli *socketClient) BeginBlockSync(params types.RequestBeginBlock) (err error) {
+	cli.queueRequest(types.ToRequestBeginBlock(params))
 	cli.FlushSync()
-	if err := cli.Error(); err != nil {
-		return err
-	}
-	return nil
+	return cli.Error()
 }

 func (cli *socketClient) EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error) {
--- a/cmd/abci-cli/abci-cli.go
+++ b/cmd/abci-cli/abci-cli.go
@ -183,12 +183,12 @@ func badCmd(c *cli.Context, cmd string) {
 //Generates new Args array based off of previous call args to maintain flag persistence
 func persistentArgs(line []byte) []string {

-	//generate the arguments to run from orginal os.Args
+	// generate the arguments to run from original os.Args
 	// to maintain flag arguments
 	args := os.Args
 	args = args[:len(args)-1] // remove the previous command argument

-	if len(line) > 0 { //prevents introduction of extra space leading to argument parse errors
+	if len(line) > 0 { // prevents introduction of extra space leading to argument parse errors
 		args = append(args, strings.Split(string(line), " ")...)
 	}
 	return args
@ -250,7 +250,12 @@ func cmdEcho(c *cli.Context) error {

 // Get some info from the application
 func cmdInfo(c *cli.Context) error {
-	resInfo, err := client.InfoSync()
+	args := c.Args()
+	var version string
+	if len(args) == 1 {
+		version = args[0]
+	}
+	resInfo, err := client.InfoSync(types.RequestInfo{version})
 	if err != nil {
 		return err
 	}
--- a/example/block_aware/block_aware_app.go
+++ b/example/block_aware/block_aware_app.go
@ -55,9 +55,8 @@ func (app *ChainAwareApplication) Query(reqQuery types.RequestQuery) (resQuery t
 	}
 }

-func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {
+func (app *ChainAwareApplication) BeginBlock(reqBeginBlock types.RequestBeginBlock) {
 	app.beginCount++
-	return
 }

 func (app *ChainAwareApplication) EndBlock(height uint64) (resEndBlock types.ResponseEndBlock) {
--- a/example/block_aware/block_aware_test.go
+++ b/example/block_aware/block_aware_test.go
@ -37,7 +37,7 @@ func TestChainAware(t *testing.T) {
 	hash := []byte("fake block hash")
 	header := &types.Header{}
 	for i := uint64(0); i < n; i++ {
-		client.BeginBlockSync(hash, header)
+		client.BeginBlockSync(types.RequestBeginBlock{hash, header})
 		client.EndBlockSync(i)
 		client.CommitSync()
 	}
--- a/example/counter/counter.go
+++ b/example/counter/counter.go
@ -19,7 +19,7 @@ func NewCounterApplication(serial bool) *CounterApplication {
 	return &CounterApplication{serial: serial}
 }

-func (app *CounterApplication) Info() types.ResponseInfo {
+func (app *CounterApplication) Info(req types.RequestInfo) types.ResponseInfo {
 	return types.ResponseInfo{Data: cmn.Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
 }

--- a/example/dummy/dummy.go
+++ b/example/dummy/dummy.go
@ -20,7 +20,7 @@ func NewDummyApplication() *DummyApplication {
 	return &DummyApplication{state: state}
 }

-func (app *DummyApplication) Info() (resInfo types.ResponseInfo) {
+func (app *DummyApplication) Info(req types.RequestInfo) (resInfo types.ResponseInfo) {
 	return types.ResponseInfo{Data: cmn.Fmt("{\"size\":%v}", app.state.Size())}
 }

--- a/example/dummy/dummy_test.go
+++ b/example/dummy/dummy_test.go
@ -80,7 +80,7 @@ func TestPersistentDummyInfo(t *testing.T) {
 	dummy := NewPersistentDummyApplication(dir)
 	height := uint64(0)

-	resInfo := dummy.Info()
+	resInfo := dummy.Info(types.RequestInfo{})
 	if resInfo.LastBlockHeight != height {
 		t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
 	}
@ -91,11 +91,11 @@ func TestPersistentDummyInfo(t *testing.T) {
 	header := &types.Header{
 		Height: uint64(height),
 	}
-	dummy.BeginBlock(hash, header)
+	dummy.BeginBlock(types.RequestBeginBlock{hash, header})
 	dummy.EndBlock(height)
 	dummy.Commit()

-	resInfo = dummy.Info()
+	resInfo = dummy.Info(types.RequestInfo{})
 	if resInfo.LastBlockHeight != height {
 		t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
 	}
@ -120,7 +120,7 @@ func TestValSetChanges(t *testing.T) {
 		vals[i] = &types.Validator{pubkey, uint64(power)}
 	}
 	// iniitalize with the first nInit
-	dummy.InitChain(vals[:nInit])
+	dummy.InitChain(types.RequestInitChain{vals[:nInit]})

 	vals1, vals2 := vals[:nInit], dummy.Validators()
 	valsEqual(t, vals1, vals2)
@ -166,7 +166,7 @@ func TestValSetChanges(t *testing.T) {

 	makeApplyBlock(t, dummy, 3, diff, tx1)

-	vals1 = append([]*types.Validator{v1}, vals1[1:len(vals1)]...)
+	vals1 = append([]*types.Validator{v1}, vals1[1:]...)
 	vals2 = dummy.Validators()
 	valsEqual(t, vals1, vals2)

@ -180,7 +180,7 @@ func makeApplyBlock(t *testing.T, dummy types.Application, heightInt int, diff [
 		Height: height,
 	}

-	dummy.BeginBlock(hash, header)
+	dummy.BeginBlock(types.RequestBeginBlock{hash, header})
 	for _, tx := range txs {
 		if r := dummy.DeliverTx(tx); r.IsErr() {
 			t.Fatal(r)
--- a/example/dummy/persistent_dummy.go
+++ b/example/dummy/persistent_dummy.go
@ -55,8 +55,8 @@ func (app *PersistentDummyApplication) SetLogger(l log.Logger) {
 	app.logger = l
 }

-func (app *PersistentDummyApplication) Info() (resInfo types.ResponseInfo) {
-	resInfo = app.app.Info()
+func (app *PersistentDummyApplication) Info(req types.RequestInfo) (resInfo types.ResponseInfo) {
+	resInfo = app.app.Info(req)
 	lastBlock := LoadLastBlock(app.db)
 	resInfo.LastBlockHeight = lastBlock.Height
 	resInfo.LastBlockAppHash = lastBlock.AppHash
@ -106,8 +106,8 @@ func (app *PersistentDummyApplication) Query(reqQuery types.RequestQuery) types.
 }

 // Save the validators in the merkle tree
-func (app *PersistentDummyApplication) InitChain(validators []*types.Validator) {
-	for _, v := range validators {
+func (app *PersistentDummyApplication) InitChain(params types.RequestInitChain) {
+	for _, v := range params.Validators {
 		r := app.updateValidator(v)
 		if r.IsErr() {
 			app.logger.Error("Error updating validators", "r", r)
@ -116,9 +116,9 @@ func (app *PersistentDummyApplication) InitChain(validators []*types.Validator)
 }

 // Track the block hash and header information
-func (app *PersistentDummyApplication) BeginBlock(hash []byte, header *types.Header) {
+func (app *PersistentDummyApplication) BeginBlock(params types.RequestBeginBlock) {
 	// update latest block info
-	app.blockHeader = header
+	app.blockHeader = params.Header

 	// reset valset changes
 	app.changes = make([]*types.Validator, 0)
@ -187,10 +187,7 @@ func MakeValSetChangeTx(pubkey []byte, power uint64) []byte {
 }

 func isValidatorTx(tx []byte) bool {
-	if strings.HasPrefix(string(tx), ValidatorSetChangePrefix) {
-		return true
-	}
-	return false
+	return strings.HasPrefix(string(tx), ValidatorSetChangePrefix)
 }

 // format is "val:pubkey1/power1,addr2/power2,addr3/power3"tx
@ -232,7 +229,7 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
 		app.app.state.Set(key, value.Bytes())
 	}

-	// we only update the changes array if we succesfully updated the tree
+	// we only update the changes array if we successfully updated the tree
 	app.changes = append(app.changes, v)

 	return types.OK
--- a/glide.lock
+++ b/glide.lock
@ -1,5 +1,5 @@
 hash: f9c2ddad16bf8652076a93bd9f398bb498eefb2f5bd2c89a77d966ebd12feec8
-updated: 2017-05-15T10:11:42.094564957-04:00
+updated: 2017-09-22T10:34:17.228026799-04:00
 imports:
 - name: github.com/btcsuite/btcd
  version: b8df516b4b267acf2de46be593a9d948d1d2c420
@ -7,8 +7,6 @@ imports:
  - btcec
 - name: github.com/btcsuite/fastsha256
  version: 637e656429416087660c84436a2a035d69d54e2e
- name: github.com/clipperhouse/typewriter
-  version: c1a48da378ebb7db1db9f35981b5cc24bf2e5b85
 - name: github.com/go-kit/kit
  version: d67bb4c202e3b91377d1079b110a6c9ce23ab2f8
  subpackages:
@ -17,6 +15,12 @@ imports:
  - log/term
 - name: github.com/go-logfmt/logfmt
  version: 390ab7935ee28ec6b286364bba9b4dd6410cb3d5
+- name: github.com/go-playground/locales
+  version: 1e5f1161c6416a5ff48840eb8724a394e48cc534
+  subpackages:
+  - currency
+- name: github.com/go-playground/universal-translator
+  version: 71201497bace774495daed26a3874fd339e0b538
 - name: github.com/go-stack/stack
  version: 100eb0c0a9c5b306ca2fb4f165df21d80ada4b82
 - name: github.com/golang/protobuf
@ -31,7 +35,7 @@ imports:
 - name: github.com/kr/logfmt
  version: b84e30acd515aadc4b783ad4ff83aff3299bdfe0
 - name: github.com/pkg/errors
-  version: ff09b135c25aae272398c51a07235b90a75aa4f0
+  version: 645ef00459ed84a119197bfb8d8205042c6df63d
 - name: github.com/syndtr/goleveldb
  version: 8c81ea47d4c41a385645e133e15510fc6a2a74b4
  subpackages:
@ -53,17 +57,17 @@ imports:
  - edwards25519
  - extra25519
 - name: github.com/tendermint/go-crypto
-  version: a42b10e0feb465eb56fbc6bb5b71d57ef646ec57
+  version: e6ea9499ff958479e4a921850d2382eb599f204c
 - name: github.com/tendermint/go-wire
-  version: 301a758c9d28e9f3900ff5d545403cf4e5f6e73f
+  version: 5f88da3dbc1a72844e6dfaf274ce87f851d488eb
  subpackages:
  - data
 - name: github.com/tendermint/merkleeyes
-  version: c722818b460381bc5b82e38c73ff6e22a9df624d
+  version: 2f6e5d31e7a35045d8d0a5895cb1fec33dd4d32b
  subpackages:
  - iavl
 - name: github.com/tendermint/tmlibs
-  version: 812d9f9b84d1dfe4cb46ce021b3a2d97b48d1292
+  version: bffe6744ec277d60f707ab442e25513617842f8e
  subpackages:
  - common
  - db
@ -98,11 +102,6 @@ imports:
  - transform
  - unicode/bidi
  - unicode/norm
- name: golang.org/x/tools
-  version: 144c6642b5d832d6c44a53dad6ee61665dd432ce
-  subpackages:
-  - go/ast/astutil
-  - imports
 - name: google.golang.org/genproto
  version: 411e09b969b1170a9f0c467558eb4c4c110d9c77
  subpackages:
@ -123,6 +122,8 @@ imports:
  - status
  - tap
  - transport
+- name: gopkg.in/go-playground/validator.v9
+  version: d529ee1b0f30352444f507cc6cdac96bfd12decc
 testImports:
 - name: github.com/davecgh/go-spew
  version: 6d212800a42e8ab5c146b8ace3490ee17e5225f9
--- a/server/grpc_server.go
+++ b/server/grpc_server.go
@ -37,7 +37,9 @@ func NewGRPCServer(protoAddr string, app types.ABCIApplicationServer) cmn.Servic

 // OnStart starts the gRPC service
 func (s *GRPCServer) OnStart() error {
-	s.BaseService.OnStart()
+	if err := s.BaseService.OnStart(); err != nil {
+		return err
+	}
 	ln, err := net.Listen(s.proto, s.addr)
 	if err != nil {
 		return err
--- a/server/socket_server.go
+++ b/server/socket_server.go
@ -44,7 +44,9 @@ func NewSocketServer(protoAddr string, app types.Application) cmn.Service {
 }

 func (s *SocketServer) OnStart() error {
-	s.BaseService.OnStart()
+	if err := s.BaseService.OnStart(); err != nil {
+		return err
+	}
 	ln, err := net.Listen(s.proto, s.addr)
 	if err != nil {
 		return err
@ -167,7 +169,7 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 	case *types.Request_Flush:
 		responses <- types.ToResponseFlush()
 	case *types.Request_Info:
-		resInfo := s.app.Info()
+		resInfo := s.app.Info(*r.Info)
 		responses <- types.ToResponseInfo(resInfo)
 	case *types.Request_SetOption:
 		so := r.SetOption
@ -186,10 +188,10 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
 		resQuery := s.app.Query(*r.Query)
 		responses <- types.ToResponseQuery(resQuery)
 	case *types.Request_InitChain:
-		s.app.InitChain(r.InitChain.Validators)
+		s.app.InitChain(*r.InitChain)
 		responses <- types.ToResponseInitChain()
 	case *types.Request_BeginBlock:
-		s.app.BeginBlock(r.BeginBlock.Hash, r.BeginBlock.Header)
+		s.app.BeginBlock(*r.BeginBlock)
 		responses <- types.ToResponseBeginBlock()
 	case *types.Request_EndBlock:
 		resEndBlock := s.app.EndBlock(r.EndBlock.Height)
--- a/tests/test_app/app.go
+++ b/tests/test_app/app.go
@ -57,9 +57,9 @@ func setOption(client abcicli.Client, key, value string) {

 func commit(client abcicli.Client, hashExp []byte) {
 	res := client.CommitSync()
-	_, data, log := res.Code, res.Data, res.Log
+	_, data, _ := res.Code, res.Data, res.Log
 	if res.IsErr() {
-		panic(fmt.Sprintf("committing %v\nlog: %v", log))
+		panic(fmt.Sprintf("committing err %v\n", res))
 	}
 	if !bytes.Equal(res.Data, hashExp) {
 		panic(fmt.Sprintf("Commit hash was unexpected. Got %X expected %X",
@ -80,7 +80,7 @@ func deliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, da
 	}
 }

-func checkTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
+/*func checkTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
 	res := client.CheckTxSync(txBytes)
 	code, data, log := res.Code, res.Data, res.Log
 	if res.IsErr() {
@ -94,4 +94,4 @@ func checkTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, data
 		panic(fmt.Sprintf("CheckTx response data was unexpected. Got %X expected %X",
 			data, dataExp))
 	}
-}
+}*/
--- a/types/application.go
+++ b/types/application.go
@ -1,22 +1,23 @@
-package types
+package types // nolint: goimports

 import (
 	context "golang.org/x/net/context"
 )

-// Applications
+// Application is an interface that enables any finite, deterministic state machine
+// to be driven by a blockchain-based replication engine via the ABCI
 type Application interface {
 	// Info/Query Connection
-	Info() ResponseInfo                              // Return application info
+	Info(RequestInfo) ResponseInfo                   // Return application info
 	SetOption(key string, value string) (log string) // Set application option
-	Query(reqQuery RequestQuery) ResponseQuery       // Query for state
+	Query(RequestQuery) ResponseQuery                // Query for state

 	// Mempool Connection
 	CheckTx(tx []byte) Result // Validate a tx for the mempool

 	// Consensus Connection
-	InitChain(validators []*Validator)       // Initialize blockchain with validators from TendermintCore
-	BeginBlock(hash []byte, header *Header)  // Signals the beginning of a block
+	InitChain(RequestInitChain)              // Initialize blockchain with validators and other info from TendermintCore
+	BeginBlock(RequestBeginBlock)            // Signals the beginning of a block
 	DeliverTx(tx []byte) Result              // Deliver a tx for full processing
 	EndBlock(height uint64) ResponseEndBlock // Signals the end of a block, returns changes to the validator set
 	Commit() Result                          // Commit the state and return the application Merkle root hash
@ -24,7 +25,7 @@ type Application interface {

 //------------------------------------

-// GRPC wrapper for application
+// GRPCApplication is a GRPC wrapper for Application
 type GRPCApplication struct {
 	app Application
 }
@ -42,7 +43,7 @@ func (app *GRPCApplication) Flush(ctx context.Context, req *RequestFlush) (*Resp
 }

 func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) {
-	resInfo := app.app.Info()
+	resInfo := app.app.Info(*req)
 	return &resInfo, nil
 }

@ -71,12 +72,12 @@ func (app *GRPCApplication) Commit(ctx context.Context, req *RequestCommit) (*Re
 }

 func (app *GRPCApplication) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) {
-	app.app.InitChain(req.Validators)
+	app.app.InitChain(*req)
 	return &ResponseInitChain{}, nil // NOTE: empty return
 }

 func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) {
-	app.app.BeginBlock(req.Hash, req.Header)
+	app.app.BeginBlock(*req)
 	return &ResponseBeginBlock{}, nil // NOTE: empty return
 }

--- a/types/base_app.go
+++ b/types/base_app.go
@ -7,7 +7,7 @@ func NewBaseApplication() *BaseApplication {
 	return &BaseApplication{}
 }

-func (app *BaseApplication) Info() (resInfo ResponseInfo) {
+func (app *BaseApplication) Info(req RequestInfo) (resInfo ResponseInfo) {
 	return
 }

@ -27,14 +27,14 @@ func (app *BaseApplication) Commit() Result {
 	return NewResultOK([]byte("nil"), "")
 }

-func (app *BaseApplication) Query(reqQuery RequestQuery) (resQuery ResponseQuery) {
+func (app *BaseApplication) Query(req RequestQuery) (resQuery ResponseQuery) {
 	return
 }

-func (app *BaseApplication) InitChain(validators []*Validator) {
+func (app *BaseApplication) InitChain(req RequestInitChain) {
 }

-func (app *BaseApplication) BeginBlock(hash []byte, header *Header) {
+func (app *BaseApplication) BeginBlock(req RequestBeginBlock) {
 }

 func (app *BaseApplication) EndBlock(height uint64) (resEndBlock ResponseEndBlock) {
--- a/types/messages.go
+++ b/types/messages.go
@ -19,9 +19,9 @@ func ToRequestFlush() *Request {
 	}
 }

-func ToRequestInfo() *Request {
+func ToRequestInfo(req RequestInfo) *Request {
 	return &Request{
-		Value: &Request_Info{&RequestInfo{}},
+		Value: &Request_Info{&req},
 	}
 }

@ -49,21 +49,21 @@ func ToRequestCommit() *Request {
 	}
 }

-func ToRequestQuery(reqQuery RequestQuery) *Request {
+func ToRequestQuery(req RequestQuery) *Request {
 	return &Request{
-		Value: &Request_Query{&reqQuery},
+		Value: &Request_Query{&req},
 	}
 }

-func ToRequestInitChain(validators []*Validator) *Request {
+func ToRequestInitChain(req RequestInitChain) *Request {
 	return &Request{
-		Value: &Request_InitChain{&RequestInitChain{validators}},
+		Value: &Request_InitChain{&req},
 	}
 }

-func ToRequestBeginBlock(hash []byte, header *Header) *Request {
+func ToRequestBeginBlock(req RequestBeginBlock) *Request {
 	return &Request{
-		Value: &Request_BeginBlock{&RequestBeginBlock{hash, header}},
+		Value: &Request_BeginBlock{&req},
 	}
 }

--- a/types/result.go
+++ b/types/result.go
@ -6,6 +6,7 @@ import (
 	"github.com/tendermint/go-wire/data"
 )

+// Result is a common result object for ABCI calls.
 // CONTRACT: a zero Result is OK.
 type Result struct {
 	Code CodeType   `json:"code"`
--- a/types/types.pb.go
+++ b/types/types.pb.go
@ -61,64 +61,6 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

-// Not being used
-// Could be added to request/response
-// so we don't have to type switch
-// (would be twice as fast, but we're talking about 15ns)
-type MessageType int32
-
-const (
-	MessageType_NullMessage MessageType = 0
-	MessageType_Echo        MessageType = 1
-	MessageType_Flush       MessageType = 2
-	MessageType_Info        MessageType = 3
-	MessageType_SetOption   MessageType = 4
-	MessageType_Exception   MessageType = 5
-	MessageType_DeliverTx   MessageType = 17
-	MessageType_CheckTx     MessageType = 18
-	MessageType_Commit      MessageType = 19
-	MessageType_Query       MessageType = 20
-	MessageType_InitChain   MessageType = 21
-	MessageType_BeginBlock  MessageType = 22
-	MessageType_EndBlock    MessageType = 23
-)
-
-var MessageType_name = map[int32]string{
-	0:  "NullMessage",
-	1:  "Echo",
-	2:  "Flush",
-	3:  "Info",
-	4:  "SetOption",
-	5:  "Exception",
-	17: "DeliverTx",
-	18: "CheckTx",
-	19: "Commit",
-	20: "Query",
-	21: "InitChain",
-	22: "BeginBlock",
-	23: "EndBlock",
-}
-var MessageType_value = map[string]int32{
-	"NullMessage": 0,
-	"Echo":        1,
-	"Flush":       2,
-	"Info":        3,
-	"SetOption":   4,
-	"Exception":   5,
-	"DeliverTx":   17,
-	"CheckTx":     18,
-	"Commit":      19,
-	"Query":       20,
-	"InitChain":   21,
-	"BeginBlock":  22,
-	"EndBlock":    23,
-}
-
-func (x MessageType) String() string {
-	return proto.EnumName(MessageType_name, int32(x))
-}
-func (MessageType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
-
 type CodeType int32

 const (
@ -225,7 +167,7 @@ var CodeType_value = map[string]int32{
 func (x CodeType) String() string {
 	return proto.EnumName(CodeType_name, int32(x))
 }
-func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

 type Request struct {
 	// Types that are valid to be assigned to Value:
@ -652,6 +594,7 @@ func (*RequestFlush) ProtoMessage()               {}
 func (*RequestFlush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

 type RequestInfo struct {
+	Version string `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"`
 }

 func (m *RequestInfo) Reset()                    { *m = RequestInfo{} }
@ -659,6 +602,13 @@ func (m *RequestInfo) String() string            { return proto.CompactTextStrin
 func (*RequestInfo) ProtoMessage()               {}
 func (*RequestInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }

+func (m *RequestInfo) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
 type RequestSetOption struct {
 	Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
 	Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
@ -1523,7 +1473,7 @@ func (*ResponseBeginBlock) ProtoMessage()               {}
 func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }

 type ResponseEndBlock struct {
-	Diffs []*Validator `protobuf:"bytes,4,rep,name=diffs" json:"diffs,omitempty"`
+	Diffs []*Validator `protobuf:"bytes,1,rep,name=diffs" json:"diffs,omitempty"`
 }

 func (m *ResponseEndBlock) Reset()                    { *m = ResponseEndBlock{} }
@ -1720,7 +1670,6 @@ func init() {
 	proto.RegisterType((*BlockID)(nil), "types.BlockID")
 	proto.RegisterType((*PartSetHeader)(nil), "types.PartSetHeader")
 	proto.RegisterType((*Validator)(nil), "types.Validator")
-	proto.RegisterEnum("types.MessageType", MessageType_name, MessageType_value)
 	proto.RegisterEnum("types.CodeType", CodeType_name, CodeType_value)
 }

@ -2129,112 +2078,107 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
 func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }

 var fileDescriptor0 = []byte{
-	// 1697 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x4b, 0x6f, 0x1b, 0x47,
-	0x12, 0xf6, 0xf0, 0xcd, 0xa6, 0x44, 0xb6, 0x5a, 0x92, 0x4d, 0x73, 0xf7, 0x60, 0xcc, 0xc2, 0x6b,
-	0x49, 0xeb, 0xb5, 0x17, 0x32, 0x76, 0xb1, 0x5a, 0x2f, 0x02, 0x48, 0xb2, 0x6c, 0x13, 0x86, 0x6d,
-	0x65, 0xfc, 0xb8, 0x24, 0x08, 0x31, 0xe2, 0x34, 0xc5, 0x89, 0xa8, 0x99, 0xf1, 0x3c, 0x64, 0x29,
-	0xbf, 0x21, 0xf7, 0xfc, 0x84, 0xdc, 0x03, 0xe4, 0x94, 0x7b, 0x80, 0xbc, 0x1f, 0xbf, 0x28, 0x55,
-	0xdd, 0x3d, 0x4f, 0xcd, 0x18, 0x39, 0xf8, 0x42, 0x4c, 0x3d, 0xbb, 0xab, 0xab, 0xea, 0xeb, 0x6a,
-	0x92, 0x95, 0xf0, 0xc2, 0xe3, 0xc1, 0x5d, 0xf1, 0x7b, 0xc7, 0xf3, 0xdd, 0xd0, 0x65, 0x4d, 0x41,
-	0xe8, 0xdf, 0x36, 0x48, 0xdb, 0xe0, 0x6f, 0x22, 0x1e, 0x84, 0x6c, 0x83, 0x34, 0xf8, 0x74, 0xee,
-	0x0e, 0xb5, 0x1b, 0xda, 0x46, 0x6f, 0x9b, 0xdd, 0x91, 0xea, 0x4a, 0x7a, 0x00, 0x92, 0xc7, 0x57,
-	0x0c, 0xa1, 0xc1, 0xfe, 0x41, 0x9a, 0xb3, 0x45, 0x14, 0xcc, 0x87, 0x35, 0xa1, 0xba, 0x9a, 0x57,
-	0x7d, 0x88, 0x22, 0xd0, 0x95, 0x3a, 0xe8, 0xd6, 0x76, 0x66, 0xee, 0xb0, 0x5e, 0xe6, 0x76, 0x0c,
-	0x12, 0x74, 0x8b, 0x1a, 0xec, 0xbf, 0x84, 0x04, 0x3c, 0x9c, 0xb8, 0x5e, 0x68, 0xbb, 0xce, 0xb0,
-	0x21, 0xf4, 0xaf, 0xe5, 0xf5, 0x5f, 0xf0, 0xf0, 0xb9, 0x10, 0x83, 0x51, 0x37, 0x88, 0x09, 0xb4,
-	0xb4, 0xf8, 0xc2, 0x3e, 0xe3, 0xfe, 0x24, 0x3c, 0x1f, 0x36, 0xcb, 0x2c, 0x1f, 0x48, 0xf9, 0xcb,
-	0x73, 0xb4, 0xb4, 0x62, 0x82, 0x6d, 0x93, 0xce, 0x74, 0xce, 0xa7, 0x27, 0x68, 0xd7, 0x12, 0x76,
-	0xeb, 0x79, 0xbb, 0x7d, 0x94, 0x0a, 0xab, 0xf6, 0x54, 0x7e, 0xb2, 0x3b, 0xa4, 0x35, 0x75, 0x4f,
-	0x4f, 0xed, 0x70, 0xd8, 0x16, 0x16, 0x6b, 0x05, 0x0b, 0x21, 0x03, 0x03, 0xa5, 0x85, 0xc7, 0x05,
-	0x02, 0xff, 0x62, 0xd8, 0x29, 0x3b, 0xae, 0x0f, 0x51, 0x84, 0xc7, 0x25, 0x74, 0x30, 0x14, 0xdb,
-	0xb1, 0xc3, 0xc9, 0x74, 0x6e, 0xda, 0xce, 0xb0, 0x5b, 0x16, 0xca, 0x18, 0xe4, 0xfb, 0x28, 0xc6,
-	0x50, 0xec, 0x98, 0x60, 0xf7, 0x49, 0xef, 0x88, 0x1f, 0xdb, 0xce, 0xe4, 0x68, 0xe1, 0x4e, 0x4f,
-	0x86, 0x44, 0x98, 0x0e, 0xf3, 0xa6, 0x7b, 0xa8, 0xb0, 0x87, 0x72, 0xb0, 0x25, 0x47, 0x09, 0xc5,
-	0xfe, 0x4d, 0xba, 0xdc, 0xb1, 0x94, 0x69, 0x4f, 0x98, 0x5e, 0x2d, 0x54, 0x80, 0x63, 0xc5, 0x86,
-	0x1d, 0xae, 0xbe, 0xf7, 0xda, 0xa4, 0x79, 0x66, 0x2e, 0x22, 0xae, 0xdf, 0x22, 0xbd, 0x4c, 0xa5,
-	0xb0, 0x21, 0x69, 0x9f, 0xf2, 0x20, 0x30, 0x8f, 0xb9, 0x28, 0xa7, 0xae, 0x11, 0x93, 0x7a, 0x9f,
-	0x2c, 0x65, 0xeb, 0x44, 0x5f, 0x4e, 0x0c, 0xb1, 0x16, 0xf4, 0xff, 0x11, 0x5a, 0x4c, 0x35, 0xa3,
-	0xa4, 0x7e, 0xc2, 0x2f, 0x94, 0x23, 0xfc, 0x64, 0x6b, 0x6a, 0x59, 0x51, 0x80, 0x5d, 0x43, 0xed,
-	0x41, 0x4f, 0x6c, 0x93, 0x64, 0xb3, 0x3e, 0xa9, 0x41, 0x66, 0xd1, 0x74, 0xc9, 0x80, 0x2f, 0xfd,
-	0x06, 0xe9, 0xe7, 0x13, 0x7b, 0x49, 0xc3, 0x4a, 0x36, 0x28, 0x32, 0xc3, 0x18, 0x69, 0x58, 0x66,
-	0x68, 0x2a, 0x0d, 0xf1, 0x8d, 0x3c, 0xcf, 0x0c, 0xe7, 0x6a, 0x79, 0xf1, 0xcd, 0xae, 0x92, 0xd6,
-	0x9c, 0xdb, 0xc7, 0xf3, 0x50, 0x54, 0x7a, 0xc3, 0x50, 0x14, 0xee, 0x15, 0x5a, 0xee, 0x8c, 0x8b,
-	0x82, 0xee, 0x18, 0x92, 0xd0, 0x07, 0x64, 0x39, 0x57, 0x2e, 0xfa, 0x83, 0x64, 0xf3, 0x49, 0x7a,
-	0xd9, 0xbf, 0x08, 0x81, 0xc8, 0x6c, 0x58, 0xd2, 0xf5, 0x03, 0xd8, 0x40, 0x1d, 0xb2, 0x42, 0x55,
-	0x56, 0x5e, 0xc7, 0x02, 0x23, 0xa3, 0xa3, 0x3f, 0x23, 0x2b, 0x97, 0x32, 0x8d, 0xbb, 0x9d, 0x9b,
-	0xd0, 0xad, 0x2a, 0x02, 0xfc, 0x66, 0x37, 0x71, 0xb7, 0xa6, 0xc5, 0x7d, 0xd5, 0xc3, 0xcb, 0xca,
-	0xed, 0x63, 0xc1, 0x34, 0x94, 0x50, 0xdf, 0x24, 0x83, 0x42, 0xfa, 0x33, 0x71, 0x6a, 0xd9, 0x38,
-	0xf5, 0xcf, 0x9b, 0xa4, 0x63, 0xf0, 0xc0, 0x73, 0x9d, 0x80, 0x43, 0x15, 0x77, 0xf9, 0xf9, 0x94,
-	0xcb, 0x4e, 0xd6, 0x0a, 0x95, 0x28, 0x75, 0x0e, 0x62, 0x39, 0x56, 0x71, 0xa2, 0xcc, 0x36, 0x15,
-	0x0a, 0x15, 0xa1, 0x45, 0x19, 0x65, 0x61, 0xe8, 0x76, 0x0c, 0x43, 0xf5, 0x42, 0x1b, 0x4a, 0xdd,
-	0x02, 0x0e, 0x6d, 0x2a, 0x1c, 0x6a, 0x94, 0x3a, 0xce, 0x01, 0xd1, 0x4e, 0x0e, 0x88, 0x9a, 0xa5,
-	0xdb, 0xaf, 0x40, 0xa2, 0x9d, 0x1c, 0x12, 0xb5, 0x4a, 0x4d, 0x2b, 0xa0, 0xe8, 0x5e, 0x06, 0x8a,
-	0xda, 0x85, 0x0e, 0x94, 0x86, 0x25, 0x58, 0x74, 0x37, 0xc1, 0xa2, 0x4e, 0x01, 0xbd, 0x94, 0x49,
-	0x11, 0x8c, 0x6e, 0xc7, 0x60, 0xd4, 0x2d, 0x3d, 0xb4, 0x02, 0x1a, 0xed, 0xe4, 0xd0, 0x88, 0x94,
-	0x86, 0x53, 0x01, 0x47, 0xff, 0xcf, 0xc3, 0x91, 0xc4, 0x94, 0xeb, 0x05, 0xdb, 0x4a, 0x3c, 0xfa,
-	0x4f, 0x16, 0x8f, 0x96, 0x0a, 0x28, 0xa8, 0x6a, 0xe1, 0x9d, 0x80, 0xb4, 0x89, 0x9d, 0x50, 0xa8,
-	0x34, 0xec, 0x45, 0xee, 0xfb, 0xae, 0xaf, 0xb0, 0x44, 0x12, 0xfa, 0x06, 0x76, 0x7c, 0x5a, 0x5f,
-	0xef, 0x00, 0x2f, 0xd1, 0xb5, 0x99, 0xea, 0xd2, 0xbf, 0xd0, 0x52, 0x5b, 0x2c, 0xa1, 0x1c, 0x5a,
-	0x74, 0x15, 0x5a, 0x80, 0x3f, 0xc8, 0x70, 0x80, 0xb5, 0x24, 0x01, 0x23, 0x26, 0xd9, 0x16, 0x59,
-	0x59, 0x98, 0x41, 0x28, 0xc3, 0x9c, 0xe4, 0xe0, 0x63, 0x80, 0x02, 0x19, 0x9f, 0xc4, 0x91, 0x7f,
-	0x92, 0xd5, 0x8c, 0xae, 0xe9, 0x79, 0x13, 0xd1, 0xd4, 0x0d, 0xd1, 0xd4, 0x34, 0xd1, 0xde, 0xf5,
-	0xbc, 0xc7, 0xc0, 0xd7, 0x6f, 0xa6, 0xf1, 0xe7, 0x90, 0x74, 0xe1, 0x1e, 0xc7, 0x48, 0x0a, 0x9f,
-	0xfa, 0x27, 0xa9, 0x5a, 0x0a, 0x9a, 0x7f, 0x23, 0x8d, 0xa9, 0x6b, 0xc9, 0xe8, 0xfb, 0xdb, 0x03,
-	0x75, 0xee, 0xfb, 0xc0, 0x7a, 0x09, 0x5f, 0x86, 0x10, 0x26, 0x91, 0xd6, 0x32, 0xb8, 0xa8, 0xfc,
-	0xd7, 0x53, 0xff, 0x1f, 0x23, 0x80, 0xe4, 0xaa, 0xf7, 0x7d, 0x7a, 0xff, 0x4a, 0x4b, 0x13, 0x22,
-	0xd1, 0xfa, 0x4f, 0x39, 0x87, 0x32, 0xb0, 0x1d, 0x8b, 0x9f, 0x0b, 0xef, 0x75, 0x43, 0x12, 0xf1,
-	0x35, 0x53, 0x17, 0x2b, 0xe6, 0xaf, 0x19, 0x79, 0xc8, 0x92, 0x50, 0x80, 0xee, 0xce, 0x04, 0x30,
-	0x2c, 0x19, 0x92, 0xc8, 0xc0, 0x62, 0x2b, 0x07, 0xff, 0x6a, 0xd3, 0xed, 0x74, 0xd3, 0x1f, 0xe1,
-	0x15, 0x94, 0xed, 0xce, 0xf7, 0x79, 0x22, 0xab, 0x69, 0x3e, 0x93, 0xbe, 0xd4, 0xd7, 0x08, 0xbb,
-	0xdc, 0x70, 0xf2, 0xaa, 0xcd, 0xb7, 0x12, 0xfb, 0x3b, 0x69, 0x5a, 0xf6, 0x6c, 0x16, 0x40, 0xc4,
-	0xe5, 0x97, 0x8d, 0x14, 0xeb, 0x5f, 0xd6, 0x48, 0x4b, 0x5e, 0x15, 0xec, 0x3a, 0xc2, 0x16, 0xac,
-	0x32, 0xb1, 0xad, 0xb8, 0x5d, 0x04, 0x3d, 0xb6, 0x32, 0x67, 0x52, 0xcb, 0x9d, 0x09, 0x84, 0x12,
-	0xda, 0xa7, 0x5c, 0x55, 0xba, 0xf8, 0x66, 0xd7, 0x48, 0xdb, 0x89, 0x4e, 0x01, 0xfb, 0x02, 0x71,
-	0xda, 0xa0, 0x0c, 0xe4, 0xcb, 0xf3, 0x00, 0x26, 0xb4, 0xe5, 0x4c, 0xdd, 0xc3, 0x22, 0x12, 0x8f,
-	0xfb, 0x6a, 0x6b, 0x62, 0xdf, 0xe3, 0x07, 0x46, 0x2f, 0xe9, 0x00, 0x58, 0x78, 0x83, 0x88, 0x86,
-	0x98, 0x48, 0xcc, 0x93, 0x8d, 0xd2, 0x12, 0xe7, 0xd6, 0x47, 0xbe, 0x02, 0x45, 0xbc, 0x07, 0xff,
-	0x42, 0xba, 0x78, 0x92, 0x52, 0xa5, 0x2d, 0x54, 0x3a, 0xc8, 0x10, 0xc2, 0x5b, 0x64, 0x90, 0xde,
-	0xad, 0x52, 0xa5, 0x23, 0xbd, 0xa4, 0x6c, 0xa1, 0x08, 0x67, 0x90, 0x34, 0x64, 0x57, 0x68, 0xb4,
-	0x4d, 0xd5, 0x87, 0x63, 0xd2, 0x56, 0x5b, 0x2c, 0xbd, 0x87, 0xb7, 0xa0, 0x98, 0x4c, 0x3f, 0x0c,
-	0xd4, 0x7d, 0x17, 0xc3, 0xf1, 0x21, 0xf0, 0xa0, 0x6d, 0xd5, 0x6d, 0x2c, 0x55, 0xf4, 0x1d, 0xb2,
-	0x9c, 0xe3, 0x63, 0x25, 0x86, 0x6e, 0x68, 0x2e, 0xd4, 0x4d, 0x2c, 0x89, 0x64, 0x99, 0x5a, 0xba,
-	0x0c, 0x98, 0x76, 0x93, 0x1c, 0x62, 0x5a, 0xbc, 0xe8, 0xe8, 0x89, 0x1a, 0xa9, 0x96, 0x0c, 0x45,
-	0x89, 0xc2, 0x76, 0xdf, 0xaa, 0x91, 0x00, 0xdc, 0x09, 0x62, 0xeb, 0x1b, 0x8d, 0xf4, 0x9e, 0x4a,
-	0xfc, 0xc3, 0x6a, 0x64, 0x03, 0xd2, 0x7b, 0x16, 0x2d, 0x16, 0x8a, 0x45, 0xaf, 0xb0, 0x0e, 0x69,
-	0x20, 0x6c, 0x52, 0x8d, 0x75, 0x49, 0x53, 0xc0, 0x22, 0xad, 0x21, 0x13, 0xf1, 0x90, 0xd6, 0xd9,
-	0x32, 0xe9, 0x26, 0x00, 0x44, 0x1b, 0x48, 0x26, 0x78, 0x4c, 0x9b, 0x48, 0x26, 0xb8, 0x43, 0x57,
-	0x58, 0x8f, 0xb4, 0x15, 0x4c, 0x50, 0x88, 0x83, 0xb4, 0x64, 0xa6, 0xe8, 0x2a, 0xba, 0x16, 0x0d,
-	0x4e, 0xd7, 0xd0, 0x24, 0x29, 0x6d, 0xba, 0x0e, 0xf3, 0x1b, 0x49, 0x8b, 0x9a, 0x5e, 0x65, 0x4b,
-	0xa4, 0x13, 0x97, 0x33, 0xbd, 0xb6, 0xf5, 0x35, 0x4c, 0x25, 0x71, 0x23, 0xb1, 0x16, 0xa9, 0x3d,
-	0x7f, 0x02, 0x3b, 0x5e, 0x21, 0xcb, 0x63, 0x27, 0xe4, 0xbe, 0x63, 0x2e, 0x0e, 0xf0, 0x06, 0x80,
-	0xad, 0x03, 0xeb, 0xc0, 0x81, 0x3e, 0xb3, 0x9d, 0x63, 0xc9, 0xaa, 0xa1, 0xa3, 0x3d, 0xd3, 0x7a,
-	0xe6, 0x3a, 0x53, 0x0e, 0x61, 0x50, 0xb2, 0xf4, 0xca, 0x31, 0xa3, 0x70, 0xee, 0xfa, 0xf6, 0x67,
-	0xdc, 0x82, 0x48, 0xd6, 0xc9, 0xca, 0xd8, 0x09, 0xa2, 0xd9, 0xcc, 0x9e, 0xda, 0xdc, 0x09, 0x1f,
-	0x46, 0x8e, 0x15, 0x40, 0x44, 0x8c, 0xf4, 0x5f, 0x39, 0x27, 0x8e, 0xfb, 0xd6, 0x51, 0x93, 0x13,
-	0x6d, 0xc1, 0x0d, 0xb0, 0xb6, 0x67, 0x02, 0xc2, 0x46, 0xde, 0xc2, 0x9e, 0x9a, 0x21, 0xdf, 0xb5,
-	0x2c, 0x1f, 0xce, 0x8f, 0x72, 0x74, 0x82, 0x92, 0xfc, 0xda, 0xb3, 0xd8, 0x20, 0xe7, 0x9f, 0xf3,
-	0x80, 0x1e, 0x43, 0xa9, 0xad, 0x5f, 0x92, 0x88, 0x95, 0xe7, 0xec, 0xaf, 0x64, 0x58, 0x14, 0x3d,
-	0x32, 0x83, 0x43, 0xdf, 0x86, 0x00, 0x6c, 0xc8, 0x2e, 0x95, 0x52, 0x51, 0xbb, 0x63, 0xc7, 0x8b,
-	0x42, 0xfa, 0x69, 0xbc, 0xbe, 0xe2, 0x3e, 0x8f, 0x42, 0x64, 0x9f, 0x14, 0xd8, 0x87, 0xa2, 0x3e,
-	0xe8, 0x02, 0x9a, 0x74, 0x35, 0xc3, 0x7e, 0x81, 0xf1, 0xe1, 0xe9, 0x9c, 0xa6, 0xfb, 0x95, 0x02,
-	0xfb, 0xd8, 0x31, 0xc3, 0xc8, 0xe7, 0xd4, 0x81, 0x62, 0x63, 0x28, 0x51, 0x47, 0x12, 0x07, 0xee,
-	0xc6, 0x2b, 0x28, 0xbe, 0x5a, 0xc1, 0x2b, 0xb2, 0x17, 0x11, 0x64, 0x96, 0xbe, 0x01, 0x36, 0x7d,
-	0xe4, 0x9e, 0x29, 0xee, 0x81, 0x13, 0xda, 0xe1, 0x05, 0xfd, 0x4e, 0x83, 0x98, 0x06, 0x29, 0xfb,
-	0x91, 0xef, 0x46, 0x1e, 0xfd, 0x5e, 0x83, 0x5d, 0xb2, 0x94, 0x7b, 0xe8, 0xbb, 0x9e, 0x1b, 0x98,
-	0x0b, 0xfa, 0x83, 0x06, 0x7b, 0x59, 0x01, 0x41, 0x92, 0x05, 0x69, 0xf0, 0x63, 0x6c, 0x90, 0xf0,
-	0x9f, 0xf2, 0xd3, 0x23, 0xee, 0xd3, 0x9f, 0x34, 0x38, 0xec, 0xb5, 0xac, 0x20, 0xf1, 0xf5, 0xb3,
-	0xa6, 0x76, 0x94, 0x88, 0x5e, 0xbb, 0x21, 0xa7, 0xbf, 0xc4, 0x6c, 0x75, 0x0e, 0xca, 0xd1, 0xaf,
-	0x1a, 0x5b, 0x25, 0xfd, 0x94, 0x2d, 0x74, 0x7f, 0xd3, 0xd8, 0x88, 0xac, 0xe7, 0x98, 0x90, 0xff,
-	0x43, 0x6c, 0x39, 0xfa, 0xbb, 0xb6, 0x0d, 0xd3, 0xf4, 0x60, 0x77, 0x6f, 0x7f, 0x0c, 0xd7, 0xb9,
-	0x58, 0x00, 0x6f, 0xef, 0xbb, 0xb2, 0xd1, 0x58, 0xc9, 0xd3, 0x7c, 0x54, 0x36, 0x28, 0x03, 0x74,
-	0xca, 0x7e, 0x64, 0x65, 0x2f, 0xf4, 0x51, 0xe9, 0xbc, 0x8c, 0x8b, 0xc8, 0x41, 0xe6, 0xf2, 0x43,
-	0x7d, 0x54, 0x36, 0x34, 0xb3, 0x0f, 0x32, 0xfd, 0xcd, 0xaa, 0x9e, 0xeb, 0xa3, 0xca, 0xf1, 0x19,
-	0xed, 0xd3, 0xc9, 0xa3, 0xea, 0xd1, 0x3e, 0xaa, 0x9c, 0xa1, 0xe1, 0xa9, 0x11, 0x43, 0x06, 0x2b,
-	0x7f, 0xba, 0x8f, 0x2a, 0xc6, 0x68, 0x3c, 0x1e, 0x39, 0x34, 0x94, 0xbd, 0xc8, 0x47, 0xa5, 0x93,
-	0x31, 0xbc, 0x93, 0x15, 0x26, 0xb1, 0xd2, 0x57, 0xff, 0xa8, 0x7c, 0xfe, 0xc6, 0x20, 0xd3, 0x67,
-	0x5d, 0xd5, 0x73, 0x7e, 0x54, 0x39, 0x59, 0xb3, 0xdd, 0x2c, 0xc8, 0xb1, 0xca, 0x47, 0xfd, 0xa8,
-	0x7a, 0xbe, 0x66, 0xf7, 0x53, 0x5c, 0x64, 0x15, 0x4f, 0xfb, 0x51, 0xd5, 0x88, 0x7d, 0xd4, 0x12,
-	0xff, 0x1a, 0xdd, 0xfb, 0x23, 0x00, 0x00, 0xff, 0xff, 0x73, 0x34, 0x90, 0x2d, 0x4a, 0x12, 0x00,
-	0x00,
+	// 1625 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x59, 0x6f, 0xdb, 0xc6,
+	0x16, 0x36, 0xb5, 0xeb, 0xd8, 0x96, 0xe9, 0xb1, 0x6c, 0xcb, 0xba, 0xf7, 0x21, 0xe0, 0x45, 0x6e,
+	0xec, 0xdc, 0xdc, 0xa4, 0x70, 0x90, 0x22, 0x6e, 0x8a, 0x02, 0xde, 0x62, 0x0b, 0x41, 0x13, 0x97,
+	0x59, 0x5e, 0x5a, 0x54, 0xa0, 0xc9, 0x91, 0xc4, 0x5a, 0x9a, 0x61, 0xc8, 0xa1, 0x23, 0xf7, 0x37,
+	0xe4, 0xbd, 0x3f, 0xa1, 0xef, 0x05, 0xfa, 0x17, 0x0a, 0x74, 0x5f, 0x7e, 0x51, 0x31, 0x0b, 0x57,
+	0x93, 0x41, 0x1f, 0xf2, 0x22, 0xf0, 0x6c, 0x33, 0x73, 0xce, 0x9c, 0xf3, 0x9d, 0x33, 0x82, 0x55,
+	0x76, 0xe5, 0xe1, 0xe0, 0x9e, 0xf8, 0xbd, 0xeb, 0xf9, 0x94, 0x51, 0x54, 0x17, 0x84, 0xf1, 0x43,
+	0x0d, 0x9a, 0x26, 0x7e, 0x1d, 0xe2, 0x80, 0xa1, 0x6d, 0xa8, 0x61, 0x7b, 0x42, 0x7b, 0xda, 0x0d,
+	0x6d, 0x7b, 0x71, 0x17, 0xdd, 0x95, 0xea, 0x4a, 0x7a, 0x6c, 0x4f, 0xe8, 0xe9, 0x82, 0x29, 0x34,
+	0xd0, 0xff, 0xa0, 0x3e, 0x9a, 0x86, 0xc1, 0xa4, 0x57, 0x11, 0xaa, 0x6b, 0x59, 0xd5, 0xc7, 0x5c,
+	0x74, 0xba, 0x60, 0x4a, 0x1d, 0xbe, 0xac, 0x4b, 0x46, 0xb4, 0x57, 0x2d, 0x5a, 0x76, 0x40, 0x46,
+	0x62, 0x59, 0xae, 0x81, 0x1e, 0x02, 0x04, 0x98, 0x0d, 0xa9, 0xc7, 0x5c, 0x4a, 0x7a, 0x35, 0xa1,
+	0xbf, 0x99, 0xd5, 0x7f, 0x8e, 0xd9, 0x33, 0x21, 0x3e, 0x5d, 0x30, 0xdb, 0x41, 0x44, 0x70, 0x4b,
+	0x07, 0x4f, 0xdd, 0x4b, 0xec, 0x0f, 0xd9, 0xbc, 0x57, 0x2f, 0xb2, 0x3c, 0x92, 0xf2, 0x17, 0x73,
+	0x6e, 0xe9, 0x44, 0x04, 0xda, 0x85, 0x96, 0x3d, 0xc1, 0xf6, 0x05, 0xb7, 0x6b, 0x08, 0xbb, 0xf5,
+	0xac, 0xdd, 0x21, 0x97, 0x0a, 0xab, 0xa6, 0x2d, 0x3f, 0xd1, 0x5d, 0x68, 0xd8, 0x74, 0x36, 0x73,
+	0x59, 0xaf, 0x29, 0x2c, 0xba, 0x39, 0x0b, 0x21, 0x3b, 0x5d, 0x30, 0x95, 0x16, 0x0f, 0xd7, 0xeb,
+	0x10, 0xfb, 0x57, 0xbd, 0x56, 0x51, 0xb8, 0x3e, 0xe3, 0x22, 0x1e, 0x2e, 0xa1, 0xc3, 0x5d, 0x71,
+	0x89, 0xcb, 0x86, 0xf6, 0xc4, 0x72, 0x49, 0xaf, 0x5d, 0xe4, 0xca, 0x80, 0xb8, 0xec, 0x90, 0x8b,
+	0xb9, 0x2b, 0x6e, 0x44, 0xa0, 0x47, 0xb0, 0x78, 0x8e, 0xc7, 0x2e, 0x19, 0x9e, 0x4f, 0xa9, 0x7d,
+	0xd1, 0x03, 0x61, 0xda, 0xcb, 0x9a, 0x1e, 0x70, 0x85, 0x03, 0x2e, 0x3f, 0x5d, 0x30, 0xe1, 0x3c,
+	0xa6, 0xd0, 0x03, 0x68, 0x63, 0xe2, 0x28, 0xd3, 0x45, 0x61, 0xba, 0x91, 0xcb, 0x00, 0xe2, 0x44,
+	0x86, 0x2d, 0xac, 0xbe, 0x0f, 0x9a, 0x50, 0xbf, 0xb4, 0xa6, 0x21, 0x36, 0x6e, 0xc1, 0x62, 0x2a,
+	0x53, 0x50, 0x0f, 0x9a, 0x33, 0x1c, 0x04, 0xd6, 0x18, 0x8b, 0x74, 0x6a, 0x9b, 0x11, 0x69, 0x74,
+	0x60, 0x29, 0x9d, 0x27, 0x29, 0x43, 0x9e, 0x0b, 0xdc, 0xf0, 0x12, 0xfb, 0x01, 0x4f, 0x00, 0x65,
+	0xa8, 0x48, 0xe3, 0x23, 0xd0, 0xf3, 0x49, 0x80, 0x74, 0xa8, 0x5e, 0xe0, 0x2b, 0xa5, 0xc9, 0x3f,
+	0x51, 0x57, 0x1d, 0x48, 0xa4, 0x66, 0xdb, 0x54, 0xa7, 0x33, 0x62, 0xdb, 0x38, 0x0d, 0x50, 0x07,
+	0x2a, 0x6c, 0x2e, 0x4c, 0x97, 0xcc, 0x0a, 0x9b, 0x1b, 0x37, 0xa0, 0x93, 0xbd, 0xf2, 0x6b, 0x1a,
+	0x4e, 0x7c, 0x74, 0x71, 0x67, 0x08, 0x41, 0xcd, 0xb1, 0x98, 0xa5, 0x34, 0xc4, 0x37, 0xe7, 0x79,
+	0x16, 0x9b, 0xa8, 0xed, 0xc5, 0x37, 0xda, 0x80, 0xc6, 0x04, 0xbb, 0xe3, 0x09, 0x13, 0x35, 0x50,
+	0x33, 0x15, 0xc5, 0xcf, 0xea, 0xf9, 0xf4, 0x12, 0x8b, 0x54, 0x6f, 0x99, 0x92, 0x30, 0x56, 0x60,
+	0x39, 0x93, 0x48, 0xc6, 0x51, 0x7c, 0xf8, 0xf8, 0xe2, 0xd1, 0x07, 0x00, 0x97, 0xd6, 0xd4, 0x75,
+	0x2c, 0x46, 0xfd, 0xa0, 0xa7, 0xdd, 0xa8, 0x6e, 0x2f, 0xee, 0xea, 0xea, 0xbe, 0x5e, 0x45, 0x02,
+	0x33, 0xa5, 0x63, 0x3c, 0x85, 0xd5, 0x6b, 0x39, 0xc0, 0x4f, 0x3b, 0xb1, 0x82, 0x49, 0xe4, 0x01,
+	0xff, 0x46, 0x37, 0xf9, 0x69, 0x2d, 0x07, 0xfb, 0xaa, 0xba, 0x97, 0xd5, 0xb2, 0xa7, 0x82, 0x69,
+	0x2a, 0xa1, 0xb1, 0x03, 0x2b, 0xb9, 0xc4, 0x48, 0xf9, 0xa9, 0xa5, 0xfd, 0x34, 0xde, 0xd6, 0xa1,
+	0x65, 0xe2, 0xc0, 0xa3, 0x24, 0xc0, 0xe8, 0x21, 0xb4, 0xf1, 0xdc, 0xc6, 0xb2, 0xc6, 0xb5, 0x5c,
+	0x8e, 0x4a, 0x9d, 0xe3, 0x48, 0xce, 0xf3, 0x3b, 0x56, 0x46, 0x3b, 0x0a, 0x9f, 0xf2, 0xa0, 0xa3,
+	0x8c, 0xd2, 0x00, 0x75, 0x27, 0x02, 0xa8, 0x6a, 0xae, 0x40, 0xa5, 0x6e, 0x0e, 0xa1, 0x76, 0x14,
+	0x42, 0xd5, 0x0a, 0x17, 0xce, 0x40, 0xd4, 0x5e, 0x06, 0xa2, 0xea, 0x85, 0xc7, 0x2f, 0xc1, 0xa8,
+	0xbd, 0x0c, 0x46, 0x35, 0x0a, 0x4d, 0x4b, 0x40, 0xea, 0x7e, 0x0a, 0xa4, 0x9a, 0xb9, 0xda, 0x94,
+	0x86, 0x05, 0x28, 0x75, 0x2f, 0x46, 0xa9, 0x56, 0x0e, 0xd7, 0x94, 0x49, 0x1e, 0xa6, 0xee, 0x44,
+	0x30, 0xd5, 0x2e, 0x0c, 0x5a, 0x0e, 0xa7, 0xf6, 0x32, 0x38, 0x05, 0x85, 0xee, 0x94, 0x00, 0xd5,
+	0xc7, 0x59, 0xa0, 0x92, 0x68, 0xb3, 0x95, 0xb3, 0x2d, 0x45, 0xaa, 0x0f, 0xd3, 0x48, 0xb5, 0x94,
+	0xc3, 0x47, 0x95, 0x0b, 0xef, 0x84, 0xaa, 0x1d, 0x5e, 0x09, 0xb9, 0x4c, 0xe3, 0xb5, 0x88, 0x7d,
+	0x9f, 0xfa, 0x0a, 0x4b, 0x24, 0x61, 0x6c, 0xf3, 0x8a, 0x4f, 0xf2, 0xeb, 0x1d, 0xb0, 0x26, 0xaa,
+	0x36, 0x95, 0x5d, 0xc6, 0x37, 0x5a, 0x62, 0x2b, 0x90, 0x2d, 0x8d, 0x16, 0x6d, 0x85, 0x16, 0x29,
+	0xb4, 0xab, 0x64, 0xd0, 0x0e, 0xdd, 0x86, 0xd5, 0xa9, 0x15, 0x30, 0xe9, 0xe6, 0x30, 0x03, 0x1f,
+	0x2b, 0x5c, 0x20, 0xfd, 0x93, 0x38, 0xf2, 0x7f, 0x58, 0x4b, 0xe9, 0x5a, 0x9e, 0x37, 0x14, 0x45,
+	0x5d, 0x13, 0x45, 0xad, 0xc7, 0xda, 0xfb, 0x9e, 0x77, 0x6a, 0x05, 0x13, 0xe3, 0x66, 0xe2, 0x7f,
+	0x06, 0x49, 0xa7, 0x74, 0x1c, 0x21, 0xe9, 0x94, 0x8e, 0x8d, 0x2f, 0x13, 0xb5, 0x04, 0x34, 0xff,
+	0x03, 0x35, 0x9b, 0x3a, 0xd2, 0xfb, 0xce, 0xee, 0x8a, 0x8a, 0xfb, 0x21, 0x75, 0xf0, 0x8b, 0x2b,
+	0x0f, 0x9b, 0x42, 0x18, 0x7b, 0x5a, 0x49, 0xe1, 0xa2, 0x5a, 0xbf, 0x9a, 0xac, 0xff, 0x05, 0x07,
+	0x90, 0x4c, 0xf6, 0xbe, 0xcf, 0xd5, 0xbf, 0xd3, 0x92, 0x0b, 0x91, 0x68, 0xfd, 0x8f, 0x16, 0xef,
+	0x42, 0xdd, 0x25, 0x0e, 0x9e, 0x8b, 0xd5, 0xab, 0xa6, 0x24, 0xa2, 0x36, 0x53, 0x15, 0x3b, 0x66,
+	0xdb, 0x8c, 0x0c, 0xb2, 0x24, 0x14, 0xa0, 0xd3, 0x91, 0x00, 0x86, 0x25, 0x53, 0x12, 0x29, 0x58,
+	0x6c, 0x64, 0xe0, 0x5f, 0x1d, 0xba, 0x99, 0x1c, 0xfa, 0x73, 0xde, 0x82, 0xd2, 0xd5, 0xf9, 0x3e,
+	0x23, 0xb2, 0x96, 0xdc, 0x67, 0x5c, 0x97, 0x46, 0x17, 0xd0, 0xf5, 0x82, 0x93, 0xad, 0x36, 0x5b,
+	0x4a, 0xe8, 0xbf, 0x50, 0x77, 0xdc, 0xd1, 0xa8, 0xbc, 0xd9, 0x48, 0xb1, 0xf1, 0x6d, 0x05, 0x1a,
+	0xb2, 0x55, 0xa0, 0x2d, 0x0e, 0x5b, 0x96, 0x4b, 0x86, 0xae, 0x13, 0x95, 0x8b, 0xa0, 0x07, 0x4e,
+	0x2a, 0x26, 0x95, 0x4c, 0x4c, 0x10, 0xd4, 0x98, 0x3b, 0xc3, 0x2a, 0xd3, 0xc5, 0x37, 0xda, 0x84,
+	0x26, 0x09, 0x67, 0x43, 0x36, 0x0f, 0x44, 0xb4, 0x6b, 0x66, 0x83, 0x84, 0xb3, 0x17, 0xf3, 0x00,
+	0xed, 0xc2, 0x72, 0x2a, 0xef, 0x5d, 0x47, 0xe1, 0x71, 0x47, 0x1d, 0x4d, 0x9c, 0x7b, 0x70, 0x64,
+	0x2e, 0xc6, 0x15, 0x30, 0x70, 0xd0, 0x36, 0x88, 0x82, 0x18, 0x4a, 0xcc, 0x93, 0x85, 0xd2, 0x10,
+	0x71, 0xeb, 0x70, 0xbe, 0x02, 0x45, 0xde, 0x07, 0xff, 0x05, 0x6d, 0x1e, 0x49, 0xa9, 0xd2, 0x14,
+	0x2a, 0x2d, 0xce, 0x10, 0xc2, 0x5b, 0xb0, 0x92, 0xf4, 0x56, 0xa9, 0xd2, 0x92, 0xab, 0x24, 0x6c,
+	0xa1, 0xb8, 0x05, 0xad, 0xb8, 0x20, 0xdb, 0x42, 0xa3, 0x69, 0xa9, 0x3a, 0x1c, 0x40, 0x53, 0x1d,
+	0xb1, 0xb0, 0x0f, 0xdf, 0x86, 0xba, 0x67, 0xf9, 0x2c, 0x50, 0xfd, 0x2e, 0x82, 0xe3, 0x33, 0xcb,
+	0xe7, 0x03, 0x90, 0xea, 0xc6, 0x52, 0xc5, 0xd8, 0x83, 0xe5, 0x0c, 0x9f, 0x67, 0x22, 0xa3, 0xcc,
+	0x9a, 0xaa, 0x4e, 0x2c, 0x89, 0x78, 0x9b, 0x4a, 0xb2, 0x8d, 0xb1, 0x07, 0xed, 0xf8, 0x0e, 0xf9,
+	0xb5, 0x78, 0xe1, 0xf9, 0x13, 0x35, 0x52, 0x2d, 0x99, 0x8a, 0x12, 0x89, 0x4d, 0xdf, 0xa8, 0x91,
+	0xa0, 0x66, 0x4a, 0xe2, 0xf6, 0xf7, 0x75, 0x68, 0x45, 0xa9, 0x88, 0x1a, 0x50, 0x79, 0xf6, 0x44,
+	0x5f, 0x40, 0xab, 0xb0, 0x3c, 0x20, 0x0c, 0xfb, 0xc4, 0x9a, 0x1e, 0x73, 0x0c, 0xd5, 0x35, 0xce,
+	0x3a, 0x26, 0x36, 0x75, 0x5c, 0x32, 0x96, 0xac, 0x0a, 0x5a, 0x82, 0xd6, 0x81, 0xe5, 0x3c, 0xa5,
+	0xc4, 0xc6, 0x7a, 0x15, 0xe9, 0xb0, 0xf4, 0x92, 0x58, 0x21, 0x9b, 0x50, 0xdf, 0xfd, 0x1a, 0x3b,
+	0x7a, 0x0d, 0xad, 0xc3, 0xea, 0x80, 0x04, 0xe1, 0x68, 0xe4, 0xda, 0x2e, 0x26, 0xec, 0x71, 0x48,
+	0x9c, 0x40, 0xaf, 0x23, 0x04, 0x9d, 0x97, 0xe4, 0x82, 0xd0, 0x37, 0x44, 0xcd, 0x1e, 0x7a, 0x03,
+	0xf5, 0xa0, 0x7b, 0x60, 0x05, 0xf8, 0x28, 0xf4, 0xa6, 0xae, 0x6d, 0x31, 0xbc, 0xef, 0x38, 0x3e,
+	0x0e, 0x02, 0x1d, 0xf3, 0x45, 0xb8, 0x24, 0xbb, 0xf7, 0x28, 0x32, 0xc8, 0xac, 0x8f, 0x71, 0xa0,
+	0x8f, 0xd1, 0x16, 0xac, 0x5f, 0x93, 0x88, 0x9d, 0x27, 0xe8, 0xdf, 0xd0, 0xcb, 0x8b, 0x4e, 0xac,
+	0xe0, 0xcc, 0x77, 0x6d, 0xac, 0xbb, 0xa8, 0x0b, 0xba, 0x94, 0x8a, 0xdb, 0x1f, 0x10, 0x2f, 0x64,
+	0xfa, 0x57, 0xd1, 0xfe, 0x8a, 0xfb, 0x2c, 0x64, 0x9c, 0x7d, 0x91, 0x63, 0x9f, 0x89, 0x08, 0xeb,
+	0x53, 0xb4, 0x09, 0x6b, 0x29, 0xf6, 0x73, 0xee, 0x1f, 0x8f, 0xce, 0x2c, 0x39, 0xaf, 0x14, 0xb8,
+	0x63, 0x62, 0xb1, 0xd0, 0xc7, 0x3a, 0x41, 0x1b, 0x80, 0xb8, 0x44, 0x85, 0x24, 0x72, 0x9c, 0x46,
+	0x3b, 0x28, 0xbe, 0xda, 0xc1, 0xcb, 0xb3, 0xa7, 0xe1, 0xd8, 0x25, 0xfa, 0x6b, 0xb4, 0x0e, 0xfa,
+	0x09, 0xbd, 0x54, 0xdc, 0x63, 0xc2, 0x5c, 0x76, 0xa5, 0xff, 0xa8, 0xa1, 0x2e, 0xac, 0x24, 0xec,
+	0x13, 0x9f, 0x86, 0x9e, 0xfe, 0x93, 0x86, 0x36, 0x01, 0x25, 0xdc, 0x33, 0x9f, 0x7a, 0x34, 0xb0,
+	0xa6, 0xfa, 0xcf, 0x1a, 0xda, 0x80, 0xd5, 0x13, 0x7a, 0x19, 0xdf, 0x82, 0x34, 0xf8, 0x25, 0x32,
+	0x88, 0xf9, 0x9f, 0xe2, 0xd9, 0x39, 0xf6, 0xf5, 0x5f, 0x35, 0xb4, 0x05, 0xdd, 0xb4, 0x20, 0x5e,
+	0xeb, 0x37, 0x4d, 0x9d, 0x28, 0x16, 0xbd, 0xa2, 0x0c, 0xeb, 0xbf, 0x47, 0x6c, 0x15, 0x07, 0xb5,
+	0xd0, 0x1f, 0x1a, 0x5a, 0x83, 0x4e, 0xc2, 0x16, 0xba, 0x7f, 0x6a, 0xa8, 0x0f, 0xeb, 0x19, 0xa6,
+	0x4b, 0xc6, 0x67, 0x3c, 0x69, 0xf5, 0xbf, 0xb4, 0xdd, 0xb7, 0x75, 0x58, 0xd9, 0x3f, 0x38, 0x1c,
+	0xec, 0x7b, 0x72, 0x03, 0xde, 0xff, 0xee, 0x41, 0x4d, 0x74, 0xf8, 0x82, 0x67, 0x6f, 0xbf, 0x68,
+	0xd4, 0x44, 0xbb, 0x50, 0x17, 0x8d, 0x1e, 0x15, 0xbd, 0x7e, 0xfb, 0x85, 0x13, 0x27, 0xdf, 0x44,
+	0x8e, 0x02, 0xd7, 0x1f, 0xc1, 0xfd, 0xa2, 0xb1, 0x13, 0x7d, 0x02, 0xed, 0xa4, 0x45, 0x97, 0x3d,
+	0x85, 0xfb, 0xa5, 0x03, 0x28, 0xb7, 0x4f, 0x7a, 0x77, 0xd9, 0x83, 0xb8, 0x5f, 0x3a, 0x85, 0xa2,
+	0x87, 0xd0, 0x8c, 0x7a, 0x73, 0xf1, 0xb3, 0xb8, 0x5f, 0x32, 0x88, 0xf2, 0xf0, 0xc8, 0xb6, 0x5b,
+	0xf4, 0xda, 0xed, 0x17, 0xce, 0x96, 0xe8, 0x01, 0x34, 0x54, 0xdb, 0x2b, 0x7c, 0x51, 0xf7, 0x8b,
+	0x27, 0x58, 0xee, 0x64, 0xf2, 0x30, 0x2a, 0x7b, 0x2a, 0xf7, 0x4b, 0x67, 0x53, 0xb4, 0x0f, 0x90,
+	0x7a, 0x12, 0x95, 0x3e, 0x98, 0xfb, 0xe5, 0x13, 0x2a, 0x7a, 0x04, 0xad, 0xe4, 0x15, 0x54, 0xfc,
+	0x6c, 0xee, 0x97, 0x0d, 0xa9, 0xe7, 0x0d, 0xf1, 0x8f, 0xcc, 0xfd, 0xbf, 0x03, 0x00, 0x00, 0xff,
+	0xff, 0xbd, 0xb6, 0xa5, 0xad, 0xa6, 0x11, 0x00, 0x00,
 }
--- a/types/types.proto
+++ b/types/types.proto
@ -73,6 +73,7 @@ message RequestFlush {
 }

 message RequestInfo {
+    string version = 1;
 }

 message RequestSetOption{
--- a/version/version.go
+++ b/version/version.go
@ -3,7 +3,7 @@ package version
 // NOTE: we should probably be versioning the ABCI and the abci-cli separately

 const Maj = "0"
-const Min = "5"
+const Min = "6"
 const Fix = "0"

-const Version = "0.5.0"
+const Version = "0.6.0"