proto: reorganize Protobuf schemas (#5102)

Reorganizes the Protobuf schemas. It is mostly bikeshedding, so if something is contentious or causes a lot of extra work then I'm fine with reverting. Some Protobuf and Go import paths will change.

* Move `abci/types/types.proto` to `abci/types.proto`.

* Move `crypto/keys/types.proto` and `crypto/merkle/types.proto` to `crypto/keys.proto` and `crypto/proof.proto`.

* Drop the use of `msgs` in filenames, as "message" is a very overloaded term (all Protobuf types are messages, and we also have `message Message`). Use `types.proto` as a catch-all, and otherwise name files by conceptual grouping instead of message kind.

abci/cmd/abci-cli/abci-cli.go

@@ -22,7 +22,7 @@ import (
 	servertest "github.com/tendermint/tendermint/abci/tests/server"
 	"github.com/tendermint/tendermint/abci/types"
 	"github.com/tendermint/tendermint/abci/version"
-	"github.com/tendermint/tendermint/proto/tendermint/crypto/merkle"
+	"github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 // client is a global variable so it can be reused by the console
@@ -101,7 +101,7 @@ type queryResponse struct {
 	Key      []byte
 	Value    []byte
 	Height   int64
-	ProofOps *merkle.ProofOps
+	ProofOps *crypto.ProofOps
 }
 
 func Execute() error {

abci/example/kvstore/persistent_kvstore.go

@@ -13,7 +13,7 @@ import (
 	"github.com/tendermint/tendermint/abci/types"
 	cryptoenc "github.com/tendermint/tendermint/crypto/encoding"
 	"github.com/tendermint/tendermint/libs/log"
-	pc "github.com/tendermint/tendermint/proto/tendermint/crypto/keys"
+	pc "github.com/tendermint/tendermint/proto/tendermint/crypto"
 	tmtypes "github.com/tendermint/tendermint/types"
 )
 

crypto/encoding/codec.go

@@ -6,7 +6,7 @@ import (
 
 	"github.com/tendermint/tendermint/crypto"
 	"github.com/tendermint/tendermint/crypto/ed25519"
-	pc "github.com/tendermint/tendermint/proto/tendermint/crypto/keys"
+	pc "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 // PubKeyToProto takes crypto.PubKey and transforms it to a protobuf Pubkey

crypto/merkle/proof.go

@@ -6,7 +6,7 @@ import (
 	"fmt"
 
 	"github.com/tendermint/tendermint/crypto/tmhash"
-	tmmerkle "github.com/tendermint/tendermint/proto/tendermint/crypto/merkle"
+	tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 const (
@@ -116,11 +116,11 @@ func (sp *Proof) ValidateBasic() error {
 	return nil
 }
 
-func (sp *Proof) ToProto() *tmmerkle.Proof {
+func (sp *Proof) ToProto() *tmcrypto.Proof {
 	if sp == nil {
 		return nil
 	}
-	pb := new(tmmerkle.Proof)
+	pb := new(tmcrypto.Proof)
 
 	pb.Total = sp.Total
 	pb.Index = sp.Index
@@ -130,7 +130,7 @@ func (sp *Proof) ToProto() *tmmerkle.Proof {
 	return pb
 }
 
-func ProofFromProto(pb *tmmerkle.Proof) (*Proof, error) {
+func ProofFromProto(pb *tmcrypto.Proof) (*Proof, error) {
 	if pb == nil {
 		return nil, errors.New("nil proof")
 	}

crypto/merkle/proof_op.go

@@ -5,7 +5,7 @@ import (
 	"errors"
 	"fmt"
 
-	tmmerkle "github.com/tendermint/tendermint/proto/tendermint/crypto/merkle"
+	tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 //----------------------------------------
@@ -21,7 +21,7 @@ import (
 type ProofOperator interface {
 	Run([][]byte) ([][]byte, error)
 	GetKey() []byte
-	ProofOp() tmmerkle.ProofOp
+	ProofOp() tmcrypto.ProofOp
 }
 
 //----------------------------------------
@@ -71,7 +71,7 @@ func (poz ProofOperators) Verify(root []byte, keypath string, args [][]byte) (er
 //----------------------------------------
 // ProofRuntime - main entrypoint
 
-type OpDecoder func(tmmerkle.ProofOp) (ProofOperator, error)
+type OpDecoder func(tmcrypto.ProofOp) (ProofOperator, error)
 
 type ProofRuntime struct {
 	decoders map[string]OpDecoder
@@ -91,7 +91,7 @@ func (prt *ProofRuntime) RegisterOpDecoder(typ string, dec OpDecoder) {
 	prt.decoders[typ] = dec
 }
 
-func (prt *ProofRuntime) Decode(pop tmmerkle.ProofOp) (ProofOperator, error) {
+func (prt *ProofRuntime) Decode(pop tmcrypto.ProofOp) (ProofOperator, error) {
 	decoder := prt.decoders[pop.Type]
 	if decoder == nil {
 		return nil, fmt.Errorf("unrecognized proof type %v", pop.Type)
@@ -99,7 +99,7 @@ func (prt *ProofRuntime) Decode(pop tmmerkle.ProofOp) (ProofOperator, error) {
 	return decoder(pop)
 }
 
-func (prt *ProofRuntime) DecodeProof(proof *tmmerkle.ProofOps) (ProofOperators, error) {
+func (prt *ProofRuntime) DecodeProof(proof *tmcrypto.ProofOps) (ProofOperators, error) {
 	poz := make(ProofOperators, 0, len(proof.Ops))
 	for _, pop := range proof.Ops {
 		operator, err := prt.Decode(pop)
@@ -111,17 +111,17 @@ func (prt *ProofRuntime) DecodeProof(proof *tmmerkle.ProofOps) (ProofOperators,
 	return poz, nil
 }
 
-func (prt *ProofRuntime) VerifyValue(proof *tmmerkle.ProofOps, root []byte, keypath string, value []byte) (err error) {
+func (prt *ProofRuntime) VerifyValue(proof *tmcrypto.ProofOps, root []byte, keypath string, value []byte) (err error) {
 	return prt.Verify(proof, root, keypath, [][]byte{value})
 }
 
 // TODO In the long run we'll need a method of classifcation of ops,
 // whether existence or absence or perhaps a third?
-func (prt *ProofRuntime) VerifyAbsence(proof *tmmerkle.ProofOps, root []byte, keypath string) (err error) {
+func (prt *ProofRuntime) VerifyAbsence(proof *tmcrypto.ProofOps, root []byte, keypath string) (err error) {
 	return prt.Verify(proof, root, keypath, nil)
 }
 
-func (prt *ProofRuntime) Verify(proof *tmmerkle.ProofOps, root []byte, keypath string, args [][]byte) (err error) {
+func (prt *ProofRuntime) Verify(proof *tmcrypto.ProofOps, root []byte, keypath string, args [][]byte) (err error) {
 	poz, err := prt.DecodeProof(proof)
 	if err != nil {
 		return fmt.Errorf("decoding proof: %w", err)

crypto/merkle/proof_test.go

@@ -8,7 +8,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
-	tmmerkle "github.com/tendermint/tendermint/proto/tendermint/crypto/merkle"
+	tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 const ProofOpDomino = "test:domino"
@@ -29,8 +29,8 @@ func NewDominoOp(key, input, output string) DominoOp {
 	}
 }
 
-func (dop DominoOp) ProofOp() tmmerkle.ProofOp {
-	dopb := tmmerkle.DominoOp{
+func (dop DominoOp) ProofOp() tmcrypto.ProofOp {
+	dopb := tmcrypto.DominoOp{
 		Key:    dop.key,
 		Input:  dop.Input,
 		Output: dop.Output,
@@ -40,7 +40,7 @@ func (dop DominoOp) ProofOp() tmmerkle.ProofOp {
 		panic(err)
 	}
 
-	return tmmerkle.ProofOp{
+	return tmcrypto.ProofOp{
 		Type: ProofOpDomino,
 		Key:  []byte(dop.key),
 		Data: bz,

crypto/merkle/proof_value.go

@@ -5,7 +5,7 @@ import (
 	"fmt"
 
 	"github.com/tendermint/tendermint/crypto/tmhash"
-	tmmerkle "github.com/tendermint/tendermint/proto/tendermint/crypto/merkle"
+	tmcrypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 )
 
 const ProofOpValue = "simple:v"
@@ -37,11 +37,11 @@ func NewValueOp(key []byte, proof *Proof) ValueOp {
 	}
 }
 
-func ValueOpDecoder(pop tmmerkle.ProofOp) (ProofOperator, error) {
+func ValueOpDecoder(pop tmcrypto.ProofOp) (ProofOperator, error) {
 	if pop.Type != ProofOpValue {
 		return nil, fmt.Errorf("unexpected ProofOp.Type; got %v, want %v", pop.Type, ProofOpValue)
 	}
-	var pbop tmmerkle.ValueOp // a bit strange as we'll discard this, but it works.
+	var pbop tmcrypto.ValueOp // a bit strange as we'll discard this, but it works.
 	err := pbop.Unmarshal(pop.Data)
 	if err != nil {
 		return nil, fmt.Errorf("decoding ProofOp.Data into ValueOp: %w", err)
@@ -54,8 +54,8 @@ func ValueOpDecoder(pop tmmerkle.ProofOp) (ProofOperator, error) {
 	return NewValueOp(pop.Key, sp), nil
 }
 
-func (op ValueOp) ProofOp() tmmerkle.ProofOp {
-	pbval := tmmerkle.ValueOp{
+func (op ValueOp) ProofOp() tmcrypto.ProofOp {
+	pbval := tmcrypto.ValueOp{
 		Key:   op.key,
 		Proof: op.Proof.ToProto(),
 	}
@@ -63,7 +63,7 @@ func (op ValueOp) ProofOp() tmmerkle.ProofOp {
 	if err != nil {
 		panic(err)
 	}
-	return tmmerkle.ProofOp{
+	return tmcrypto.ProofOp{
 		Type: ProofOpValue,
 		Key:  op.key,
 		Data: bz,

proto/tendermint/privval/msgs.proto

@@ -1,63 +0,0 @@
-syntax = "proto3";
-package tendermint.privval;
-
-option go_package = "github.com/tendermint/tendermint/proto/tendermint/privval";
-
-import "gogoproto/gogo.proto";
-import "tendermint/crypto/keys/types.proto";
-import "tendermint/types/types.proto";
-
-message RemoteSignerError {
-  int32  code        = 1;
-  string description = 2;
-}
-
-// PubKeyRequest requests the consensus public key from the remote signer.
-message PubKeyRequest {}
-
-// PubKeyResponse is a response message containing the public key.
-message PubKeyResponse {
-  tendermint.crypto.keys.PublicKey pub_key = 1;
-  RemoteSignerError                error   = 2;
-}
-
-// SignVoteRequest is a request to sign a vote
-message SignVoteRequest {
-  tendermint.types.Vote vote = 1;
-}
-
-// SignedVoteResponse is a response containing a signed vote or an error
-message SignedVoteResponse {
-  tendermint.types.Vote vote  = 1;
-  RemoteSignerError     error = 2;
-}
-
-// SignProposalRequest is a request to sign a proposal
-message SignProposalRequest {
-  tendermint.types.Proposal proposal = 1 [(gogoproto.nullable) = false];
-}
-
-// SignedProposalResponse is response containing a signed proposal or an error
-message SignedProposalResponse {
-  tendermint.types.Proposal proposal = 1;
-  RemoteSignerError         error    = 2;
-}
-
-// PingRequest is a request to confirm that the connection is alive.
-message PingRequest {}
-
-// PingResponse is a response to confirm that the connection is alive.
-message PingResponse {}
-
-message Message {
-  oneof sum {
-    PubKeyRequest          pub_key_request          = 1;
-    PubKeyResponse         pub_key_response         = 2;
-    SignVoteRequest        sign_vote_request        = 3;
-    SignedVoteResponse     signed_vote_response     = 4;
-    SignProposalRequest    sign_proposal_request    = 5;
-    SignedProposalResponse signed_proposal_response = 6;
-    PingRequest            ping_request             = 7;
-    PingResponse           ping_response            = 8;
-  }
-}

proto/tendermint/privval/types.proto

@@ -1,6 +1,10 @@
 syntax = "proto3";
 package tendermint.privval;
 
+import "gogoproto/gogo.proto";
+import "tendermint/crypto/keys.proto";
+import "tendermint/types/types.proto";
+
 option go_package = "github.com/tendermint/tendermint/proto/tendermint/privval";
 
 enum Errors {
@@ -11,3 +15,59 @@ enum Errors {
   ERRORS_READ_TIMEOUT        = 4;
   ERRORS_WRITE_TIMEOUT       = 5;
 }
+
+message RemoteSignerError {
+  int32  code        = 1;
+  string description = 2;
+}
+
+// PubKeyRequest requests the consensus public key from the remote signer.
+message PubKeyRequest {}
+
+// PubKeyResponse is a response message containing the public key.
+message PubKeyResponse {
+  tendermint.crypto.PublicKey pub_key = 1;
+  RemoteSignerError           error   = 2;
+}
+
+// SignVoteRequest is a request to sign a vote
+message SignVoteRequest {
+  tendermint.types.Vote vote = 1;
+}
+
+// SignedVoteResponse is a response containing a signed vote or an error
+message SignedVoteResponse {
+  tendermint.types.Vote vote  = 1;
+  RemoteSignerError     error = 2;
+}
+
+// SignProposalRequest is a request to sign a proposal
+message SignProposalRequest {
+  tendermint.types.Proposal proposal = 1 [(gogoproto.nullable) = false];
+}
+
+// SignedProposalResponse is response containing a signed proposal or an error
+message SignedProposalResponse {
+  tendermint.types.Proposal proposal = 1;
+  RemoteSignerError         error    = 2;
+}
+
+// PingRequest is a request to confirm that the connection is alive.
+message PingRequest {}
+
+// PingResponse is a response to confirm that the connection is alive.
+message PingResponse {}
+
+message Message {
+  oneof sum {
+    PubKeyRequest          pub_key_request          = 1;
+    PubKeyResponse         pub_key_response         = 2;
+    SignVoteRequest        sign_vote_request        = 3;
+    SignedVoteResponse     signed_vote_response     = 4;
+    SignProposalRequest    sign_proposal_request    = 5;
+    SignedProposalResponse signed_proposal_response = 6;
+    PingRequest            ping_request             = 7;
+    PingResponse           ping_response            = 8;
+  }
+}
+

proto/tendermint/rpc/grpc/types.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 package tendermint.rpc.grpc;
 option  go_package = "github.com/tendermint/tendermint/rpc/grpc;coregrpc";
 
-import "tendermint/abci/types/types.proto";
+import "tendermint/abci/types.proto";
 
 //----------------------------------------
 // Request types
@@ -19,8 +19,8 @@ message RequestBroadcastTx {
 message ResponsePing {}
 
 message ResponseBroadcastTx {
-  tendermint.abci.types.ResponseCheckTx   check_tx   = 1;
-  tendermint.abci.types.ResponseDeliverTx deliver_tx = 2;
+  tendermint.abci.ResponseCheckTx   check_tx   = 1;
+  tendermint.abci.ResponseDeliverTx deliver_tx = 2;
 }
 
 //----------------------------------------

proto/tendermint/state/types.pb.go

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

proto/tendermint/state/types.proto

@@ -4,20 +4,20 @@ package tendermint.state;
 option go_package = "github.com/tendermint/tendermint/proto/tendermint/state";
 
 import "gogoproto/gogo.proto";
-import "tendermint/abci/types/types.proto";
+import "tendermint/abci/types.proto";
 import "tendermint/types/types.proto";
 import "tendermint/types/validator.proto";
 import "tendermint/types/params.proto";
-import "tendermint/version/version.proto";
+import "tendermint/version/types.proto";
 import "google/protobuf/timestamp.proto";
 
 // ABCIResponses retains the responses
 // of the various ABCI calls during block processing.
 // It is persisted to disk for each height before calling Commit.
 message ABCIResponses {
-  repeated tendermint.abci.types.ResponseDeliverTx deliver_txs = 1;
-  tendermint.abci.types.ResponseEndBlock           end_block   = 2;
-  tendermint.abci.types.ResponseBeginBlock         begin_block = 3;
+  repeated tendermint.abci.ResponseDeliverTx deliver_txs = 1;
+  tendermint.abci.ResponseEndBlock           end_block   = 2;
+  tendermint.abci.ResponseBeginBlock         begin_block = 3;
 }
 
 // ValidatorsInfo represents the latest validator set, or the last height it changed

proto/tendermint/types/evidence.pb.go

@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	keys "github.com/tendermint/tendermint/proto/tendermint/crypto/keys"
+	crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -545,8 +545,8 @@ func (m *EvidenceData) GetHash() []byte {
 }
 
 type ProofOfLockChange struct {
-	Votes  []*Vote         `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes,omitempty"`
-	PubKey *keys.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	Votes  []*Vote           `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes,omitempty"`
+	PubKey *crypto.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
 }
 
 func (m *ProofOfLockChange) Reset()         { *m = ProofOfLockChange{} }
@@ -589,7 +589,7 @@ func (m *ProofOfLockChange) GetVotes() []*Vote {
 	return nil
 }
 
-func (m *ProofOfLockChange) GetPubKey() *keys.PublicKey {
+func (m *ProofOfLockChange) GetPubKey() *crypto.PublicKey {
 	if m != nil {
 		return m.PubKey
 	}
@@ -611,53 +611,53 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/evidence.proto", fileDescriptor_6825fabc78e0a168) }
 
 var fileDescriptor_6825fabc78e0a168 = []byte{
-	// 733 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x4f, 0x6f, 0xd3, 0x30,
-	0x1c, 0x6d, 0xd6, 0xae, 0x8c, 0xdf, 0x26, 0x6d, 0x44, 0x1b, 0x44, 0x65, 0xea, 0xb6, 0x70, 0x60,
-	0x9a, 0x46, 0xba, 0x95, 0xc3, 0x24, 0xc4, 0x65, 0xff, 0x50, 0xd1, 0x26, 0x18, 0x99, 0x34, 0x24,
-	0x2e, 0xc1, 0x4d, 0xdc, 0xc4, 0x5b, 0x6a, 0x47, 0x8d, 0x53, 0x54, 0x09, 0x3e, 0x02, 0x12, 0x77,
-	0xbe, 0x01, 0x67, 0x3e, 0xc4, 0x8e, 0x3b, 0x72, 0x42, 0x68, 0xfb, 0x16, 0x9c, 0x50, 0x1c, 0x37,
-	0xed, 0x9a, 0x66, 0x83, 0x0b, 0x97, 0x28, 0xf2, 0xef, 0xf9, 0xbd, 0x67, 0xfb, 0xfd, 0x6c, 0x58,
-	0xe2, 0x98, 0x3a, 0xb8, 0xd3, 0x26, 0x94, 0xd7, 0x78, 0x2f, 0xc0, 0x61, 0x0d, 0x77, 0x89, 0x83,
-	0xa9, 0x8d, 0x8d, 0xa0, 0xc3, 0x38, 0x53, 0xe7, 0x06, 0x00, 0x43, 0x00, 0x2a, 0xf3, 0x2e, 0x73,
-	0x99, 0x28, 0xd6, 0xe2, 0xbf, 0x04, 0x57, 0x59, 0xcc, 0x10, 0x89, 0xaf, 0xac, 0xea, 0x43, 0x55,
-	0xbb, 0xd3, 0x0b, 0x38, 0xab, 0x9d, 0xe1, 0xde, 0x35, 0x8c, 0x1e, 0xc1, 0xc2, 0x5e, 0x14, 0xf8,
-	0xc4, 0x46, 0x1c, 0x9f, 0x30, 0x8e, 0xf7, 0xa5, 0x11, 0xf5, 0x09, 0x94, 0xbb, 0x8c, 0x63, 0x0b,
-	0x69, 0xca, 0xb2, 0xb2, 0x3a, 0x5d, 0xbf, 0x6f, 0x8c, 0x7a, 0x32, 0x62, 0xbc, 0x39, 0x19, 0xa3,
-	0xb6, 0x53, 0x78, 0x53, 0x9b, 0xb8, 0x1d, 0xbe, 0xa3, 0x7f, 0x55, 0x40, 0x3b, 0x62, 0x1c, 0x53,
-	0x4e, 0x90, 0xbf, 0xdd, 0xa6, 0x38, 0x24, 0xe8, 0xff, 0x48, 0xab, 0x2b, 0x30, 0xe3, 0x61, 0xe2,
-	0x7a, 0xdc, 0x0a, 0x39, 0x6a, 0x07, 0x5a, 0x71, 0x59, 0x59, 0x2d, 0x9a, 0xd3, 0xc9, 0xd8, 0x71,
-	0x3c, 0xa4, 0x7f, 0x57, 0x60, 0x76, 0xd4, 0x94, 0x07, 0x95, 0xa0, 0x6f, 0xd8, 0x42, 0x49, 0xd1,
-	0xea, 0x1f, 0x9b, 0x34, 0xba, 0x96, 0x55, 0xce, 0x5b, 0xa4, 0xa9, 0x05, 0x79, 0xcb, 0xdf, 0x82,
-	0x52, 0xc0, 0x7c, 0x5b, 0xae, 0xe6, 0xd1, 0x18, 0xce, 0x0e, 0x63, 0xad, 0xd7, 0xad, 0x43, 0x66,
-	0x9f, 0xed, 0x7a, 0x88, 0xba, 0xd8, 0x14, 0x13, 0xf4, 0x8f, 0x50, 0xd9, 0x65, 0xb4, 0xe5, 0x13,
-	0x9b, 0x13, 0xea, 0x36, 0x30, 0x72, 0x70, 0x27, 0x4c, 0x69, 0x0d, 0x98, 0xf0, 0x36, 0xa5, 0xd1,
-	0x6a, 0x96, 0xf4, 0x98, 0xb8, 0x14, 0x3b, 0xc9, 0x24, 0x73, 0xc2, 0xdb, 0x14, 0xf8, 0xba, 0x34,
-	0x71, 0x3b, 0xbe, 0xae, 0x7f, 0x53, 0x40, 0x3b, 0x8c, 0x28, 0xe2, 0xc4, 0x3e, 0x41, 0x3e, 0x71,
-	0x10, 0x67, 0x9d, 0x54, 0x7c, 0x03, 0xca, 0x9e, 0x80, 0x4a, 0x03, 0x5a, 0x96, 0x50, 0x52, 0x49,
-	0x9c, 0xba, 0x06, 0xa5, 0xf8, 0xbc, 0x6e, 0x39, 0x53, 0x81, 0x51, 0x37, 0x60, 0x9e, 0xd0, 0x6e,
-	0x2c, 0x6a, 0x25, 0xb3, 0xad, 0x16, 0xc1, 0xbe, 0x23, 0x8e, 0xf6, 0xae, 0xa9, 0xca, 0x5a, 0x22,
-	0xf0, 0x22, 0xae, 0xe8, 0x9f, 0xe3, 0xfc, 0x79, 0x88, 0x72, 0xd6, 0xce, 0x9a, 0xed, 0x4b, 0x2b,
-	0x7f, 0x21, 0xbd, 0x0f, 0xcb, 0x3e, 0x0a, 0xb9, 0x25, 0x23, 0xd5, 0xed, 0x93, 0x59, 0x1f, 0x50,
-	0x68, 0x11, 0x6a, 0x85, 0x98, 0x8b, 0x25, 0x14, 0xcd, 0x87, 0x31, 0xae, 0x21, 0x60, 0xa9, 0xe4,
-	0x5b, 0x14, 0xbe, 0xa4, 0xc7, 0x98, 0xeb, 0xbf, 0x4b, 0x30, 0x95, 0xea, 0x23, 0x78, 0xe0, 0xf4,
-	0x7b, 0xd2, 0x12, 0xd1, 0x1e, 0xc9, 0xd9, 0xe3, 0xac, 0xa5, 0xb1, 0x4d, 0xdc, 0x28, 0x98, 0x0b,
-	0xce, 0xd8, 0xee, 0x0e, 0x60, 0xd1, 0x1e, 0x44, 0x45, 0xee, 0x5a, 0x38, 0xd0, 0x49, 0x76, 0x7d,
-	0x3d, 0xab, 0x93, 0x1f, 0xb0, 0x46, 0xc1, 0xac, 0xd8, 0xf9, 0xf1, 0x3b, 0x85, 0x8a, 0x9f, 0xa4,
-	0x63, 0x68, 0x93, 0x52, 0xbd, 0x62, 0x5e, 0xff, 0xe4, 0x25, 0xaa, 0x51, 0x30, 0x35, 0x3f, 0x2f,
-	0x6d, 0xa7, 0x37, 0xf6, 0x6a, 0xe9, 0x5f, 0x7b, 0x35, 0xd6, 0xca, 0xed, 0xd6, 0x57, 0x30, 0x97,
-	0x51, 0x98, 0x14, 0x0a, 0x2b, 0x59, 0x85, 0x2c, 0xf1, 0x2c, 0x1a, 0xe1, 0x8b, 0xbd, 0x27, 0xc1,
-	0x1c, 0xb7, 0x4f, 0xe5, 0x5c, 0xef, 0x39, 0x61, 0x16, 0xde, 0x73, 0x6a, 0x3b, 0x93, 0x50, 0x0c,
-	0xa3, 0xb6, 0xfe, 0x1e, 0x66, 0xfa, 0x43, 0x7b, 0x88, 0x23, 0xf5, 0x39, 0x4c, 0x0d, 0x05, 0xae,
-	0xb8, 0x3a, 0x5d, 0xaf, 0x64, 0x05, 0x53, 0x92, 0xd2, 0xf9, 0xcf, 0xa5, 0x82, 0x99, 0xce, 0x50,
-	0x55, 0x28, 0x79, 0x28, 0xf4, 0x44, 0x84, 0x66, 0x4c, 0xf1, 0xaf, 0x7f, 0x82, 0x7b, 0x99, 0x4b,
-	0x4b, 0x5d, 0x07, 0x71, 0x23, 0x87, 0x52, 0xe3, 0xc6, 0x6b, 0x3b, 0x54, 0x9f, 0xc1, 0x9d, 0x20,
-	0x6a, 0x5a, 0x67, 0xb8, 0x27, 0xc3, 0x79, 0x6d, 0x7b, 0x93, 0xe7, 0xcd, 0x88, 0x9f, 0x37, 0xe3,
-	0x28, 0x6a, 0xfa, 0xc4, 0x3e, 0xc0, 0x3d, 0xb3, 0x1c, 0x44, 0xcd, 0x03, 0xdc, 0xdb, 0x79, 0x73,
-	0x7e, 0x59, 0x55, 0x2e, 0x2e, 0xab, 0xca, 0xaf, 0xcb, 0xaa, 0xf2, 0xe5, 0xaa, 0x5a, 0xb8, 0xb8,
-	0xaa, 0x16, 0x7e, 0x5c, 0x55, 0x0b, 0xef, 0xb6, 0x5c, 0xc2, 0xbd, 0xa8, 0x69, 0xd8, 0xac, 0x5d,
-	0x1b, 0x7e, 0x4b, 0x07, 0xbf, 0xc9, 0x9b, 0x3b, 0xfa, 0xce, 0x36, 0xcb, 0x62, 0xfc, 0xe9, 0x9f,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x3e, 0xd5, 0x42, 0xcb, 0x07, 0x00, 0x00,
+	// 728 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0xcd, 0x4e, 0xdb, 0x4a,
+	0x18, 0x8d, 0x49, 0xc8, 0xe5, 0x7e, 0x20, 0xc1, 0xb5, 0xe0, 0xd6, 0x4a, 0x91, 0x01, 0x77, 0x51,
+	0x84, 0xa8, 0x03, 0xa9, 0x2a, 0x36, 0xdd, 0xf0, 0x57, 0xa5, 0x02, 0xb5, 0xd4, 0x48, 0x54, 0xea,
+	0xc6, 0x9d, 0xd8, 0x13, 0x7b, 0xc0, 0x99, 0xb1, 0xe2, 0x71, 0xda, 0x48, 0x7d, 0x85, 0x4a, 0xdd,
+	0xf7, 0x0d, 0xba, 0xee, 0x43, 0xb0, 0x64, 0xd9, 0x55, 0x55, 0xc1, 0x5b, 0x74, 0x55, 0x79, 0x3c,
+	0x71, 0xa2, 0x38, 0x86, 0x76, 0xd3, 0x8d, 0x65, 0xcd, 0x77, 0xe6, 0x9c, 0x33, 0x33, 0xe7, 0x9b,
+	0x81, 0x15, 0x8e, 0xa9, 0x8b, 0xbb, 0x1d, 0x42, 0x79, 0x9d, 0xf7, 0x43, 0x1c, 0xd5, 0x71, 0x8f,
+	0xb8, 0x98, 0x3a, 0xd8, 0x0c, 0xbb, 0x8c, 0x33, 0x75, 0x61, 0x08, 0x30, 0x05, 0xa0, 0xb6, 0xe8,
+	0x31, 0x8f, 0x89, 0x62, 0x3d, 0xf9, 0x4b, 0x71, 0xb5, 0xe5, 0x1c, 0x91, 0xf8, 0x4e, 0xa8, 0x3a,
+	0xdd, 0x7e, 0xc8, 0x59, 0xfd, 0x02, 0xf7, 0x65, 0xd5, 0x88, 0x61, 0xe9, 0x20, 0x0e, 0x03, 0xe2,
+	0x20, 0x8e, 0xcf, 0x18, 0xc7, 0x87, 0xd2, 0x82, 0xfa, 0x08, 0xaa, 0x3d, 0xc6, 0xb1, 0x8d, 0x34,
+	0x65, 0x55, 0x59, 0x9f, 0x6d, 0xfc, 0x6f, 0x8e, 0xbb, 0x31, 0x13, 0xbc, 0x35, 0x9d, 0xa0, 0x76,
+	0x33, 0x78, 0x4b, 0x9b, 0xba, 0x1b, 0xbe, 0x67, 0x7c, 0x56, 0x40, 0x3b, 0x61, 0x1c, 0x53, 0x4e,
+	0x50, 0xb0, 0xdb, 0xa1, 0x38, 0x22, 0xe8, 0xef, 0x48, 0xab, 0x6b, 0x30, 0xe7, 0x63, 0xe2, 0xf9,
+	0xdc, 0x8e, 0x38, 0xea, 0x84, 0x5a, 0x79, 0x55, 0x59, 0x2f, 0x5b, 0xb3, 0xe9, 0xd8, 0x69, 0x32,
+	0x64, 0x7c, 0x55, 0x60, 0x7e, 0xdc, 0x94, 0x0f, 0xb5, 0x70, 0x60, 0xd8, 0x46, 0x69, 0xd1, 0x1e,
+	0x1c, 0x98, 0x34, 0xba, 0x91, 0x57, 0x2e, 0x5a, 0xa4, 0xa5, 0x85, 0x45, 0xcb, 0xdf, 0x81, 0x4a,
+	0xc8, 0x02, 0x47, 0xae, 0xe6, 0xc1, 0x04, 0xce, 0x2e, 0x63, 0xed, 0x97, 0xed, 0x63, 0xe6, 0x5c,
+	0xec, 0xfb, 0x88, 0x7a, 0xd8, 0x12, 0x13, 0x8c, 0x0f, 0x50, 0xdb, 0x67, 0xb4, 0x1d, 0x10, 0x87,
+	0x13, 0xea, 0x35, 0x31, 0x72, 0x71, 0x37, 0xca, 0x68, 0x4d, 0x98, 0xf2, 0xb7, 0xa5, 0x51, 0x3d,
+	0x4f, 0x7a, 0x4a, 0x3c, 0x8a, 0xdd, 0x74, 0x92, 0x35, 0xe5, 0x6f, 0x0b, 0x7c, 0x43, 0x9a, 0xb8,
+	0x1b, 0xdf, 0x30, 0xbe, 0x28, 0xa0, 0x1d, 0xc7, 0x14, 0x71, 0xe2, 0x9c, 0xa1, 0x80, 0xb8, 0x88,
+	0xb3, 0x6e, 0x26, 0xbe, 0x05, 0x55, 0x5f, 0x40, 0xa5, 0x01, 0x2d, 0x4f, 0x28, 0xa9, 0x24, 0x4e,
+	0xdd, 0x80, 0x4a, 0x72, 0x5e, 0x77, 0x9c, 0xa9, 0xc0, 0xa8, 0x5b, 0xb0, 0x48, 0x68, 0x2f, 0x11,
+	0xb5, 0xd3, 0xd9, 0x76, 0x9b, 0xe0, 0xc0, 0x15, 0x47, 0xfb, 0xaf, 0xa5, 0xca, 0x5a, 0x2a, 0xf0,
+	0x2c, 0xa9, 0x18, 0x1f, 0x93, 0xfc, 0xf9, 0x88, 0x72, 0xd6, 0xc9, 0x9b, 0x1d, 0x48, 0x2b, 0xbf,
+	0x21, 0x7d, 0x08, 0xab, 0x01, 0x8a, 0xb8, 0x2d, 0x23, 0xd5, 0x1b, 0x90, 0xd9, 0xef, 0x50, 0x64,
+	0x13, 0x6a, 0x47, 0x98, 0x8b, 0x25, 0x94, 0xad, 0xfb, 0x09, 0xae, 0x29, 0x60, 0x99, 0xe4, 0x6b,
+	0x14, 0x3d, 0xa7, 0xa7, 0x98, 0x1b, 0x3f, 0x2b, 0x30, 0x93, 0xe9, 0x23, 0xb8, 0xe7, 0x0e, 0x7a,
+	0xd2, 0x16, 0xd1, 0x1e, 0xcb, 0xd9, 0xc3, 0xbc, 0xa5, 0x89, 0x4d, 0xdc, 0x2c, 0x59, 0x4b, 0xee,
+	0xc4, 0xee, 0x0e, 0x61, 0xd9, 0x19, 0x46, 0x45, 0xee, 0x5a, 0x34, 0xd4, 0x49, 0x77, 0x7d, 0x33,
+	0xaf, 0x53, 0x1c, 0xb0, 0x66, 0xc9, 0xaa, 0x39, 0xc5, 0xf1, 0x3b, 0x87, 0x5a, 0x90, 0xa6, 0x63,
+	0x64, 0x93, 0x32, 0xbd, 0x72, 0x51, 0xff, 0x14, 0x25, 0xaa, 0x59, 0xb2, 0xb4, 0xa0, 0x28, 0x6d,
+	0xe7, 0xb7, 0xf6, 0x6a, 0xe5, 0x4f, 0x7b, 0x35, 0xd1, 0x2a, 0xec, 0xd6, 0x17, 0xb0, 0x90, 0x53,
+	0x98, 0x16, 0x0a, 0x6b, 0x79, 0x85, 0x3c, 0xf1, 0x3c, 0x1a, 0xe3, 0x4b, 0xbc, 0xa7, 0xc1, 0x9c,
+	0xb4, 0x4f, 0xd5, 0x42, 0xef, 0x05, 0x61, 0x16, 0xde, 0x0b, 0x6a, 0x7b, 0xd3, 0x50, 0x8e, 0xe2,
+	0x8e, 0xf1, 0x16, 0xe6, 0x06, 0x43, 0x07, 0x88, 0x23, 0xf5, 0x29, 0xcc, 0x8c, 0x04, 0xae, 0xbc,
+	0x3e, 0xdb, 0xa8, 0xe5, 0x05, 0x33, 0x92, 0xca, 0xe5, 0xf7, 0x95, 0x92, 0x95, 0xcd, 0x50, 0x55,
+	0xa8, 0xf8, 0x28, 0xf2, 0x45, 0x84, 0xe6, 0x2c, 0xf1, 0x6f, 0xbc, 0x87, 0xff, 0x72, 0x97, 0x96,
+	0xba, 0x09, 0xe2, 0x46, 0x8e, 0xa4, 0xc6, 0xad, 0xd7, 0x76, 0xa4, 0x3e, 0x81, 0x7f, 0xc2, 0xb8,
+	0x65, 0x5f, 0xe0, 0xbe, 0x0c, 0xe7, 0xf2, 0x28, 0x3e, 0x7d, 0xd8, 0xcc, 0x93, 0xb8, 0x15, 0x10,
+	0xe7, 0x08, 0xf7, 0xad, 0x6a, 0x18, 0xb7, 0x8e, 0x70, 0x7f, 0xef, 0xd5, 0xe5, 0xb5, 0xae, 0x5c,
+	0x5d, 0xeb, 0xca, 0x8f, 0x6b, 0x5d, 0xf9, 0x74, 0xa3, 0x97, 0xae, 0x6e, 0xf4, 0xd2, 0xb7, 0x1b,
+	0xbd, 0xf4, 0x66, 0xc7, 0x23, 0xdc, 0x8f, 0x5b, 0xa6, 0xc3, 0x3a, 0xf5, 0xd1, 0x07, 0x74, 0xf8,
+	0x9b, 0x3e, 0xb4, 0xe3, 0x8f, 0x6b, 0xab, 0x2a, 0xc6, 0x1f, 0xff, 0x0a, 0x00, 0x00, 0xff, 0xff,
+	0xdc, 0x62, 0x93, 0xc8, 0xc0, 0x07, 0x00, 0x00,
 }
 
 func (m *DuplicateVoteEvidence) Marshal() (dAtA []byte, err error) {
@@ -2706,7 +2706,7 @@ func (m *ProofOfLockChange) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.PubKey == nil {
-				m.PubKey = &keys.PublicKey{}
+				m.PubKey = &crypto.PublicKey{}
 			}
 			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err

proto/tendermint/types/evidence.proto

@@ -5,7 +5,7 @@ option go_package = "github.com/tendermint/tendermint/proto/tendermint/types";
 
 import "gogoproto/gogo.proto";
 import "tendermint/types/types.proto";
-import "tendermint/crypto/keys/types.proto";
+import "tendermint/crypto/keys.proto";
 
 // DuplicateVoteEvidence contains evidence a validator signed two conflicting
 // votes.
@@ -60,6 +60,6 @@ message EvidenceData {
 }
 
 message ProofOfLockChange {
-  repeated Vote                    votes   = 1;
-  tendermint.crypto.keys.PublicKey pub_key = 2;
+  repeated Vote               votes   = 1;
+  tendermint.crypto.PublicKey pub_key = 2;
 }

proto/tendermint/types/types.pb.go

@@ -9,7 +9,7 @@ import (
 	proto "github.com/gogo/protobuf/proto"
 	_ "github.com/gogo/protobuf/types"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	merkle "github.com/tendermint/tendermint/proto/tendermint/crypto/merkle"
+	crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 	bits "github.com/tendermint/tendermint/proto/tendermint/libs/bits"
 	version "github.com/tendermint/tendermint/proto/tendermint/version"
 	io "io"
@@ -152,7 +152,7 @@ func (m *PartSetHeader) GetHash() []byte {
 type Part struct {
 	Index uint32       `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
 	Bytes []byte       `protobuf:"bytes,2,opt,name=bytes,proto3" json:"bytes,omitempty"`
-	Proof merkle.Proof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof"`
+	Proof crypto.Proof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof"`
 }
 
 func (m *Part) Reset()         { *m = Part{} }
@@ -202,11 +202,11 @@ func (m *Part) GetBytes() []byte {
 	return nil
 }
 
-func (m *Part) GetProof() merkle.Proof {
+func (m *Part) GetProof() crypto.Proof {
 	if m != nil {
 		return m.Proof
 	}
-	return merkle.Proof{}
+	return crypto.Proof{}
 }
 
 // BlockID
@@ -945,7 +945,7 @@ func (m *BlockMeta) GetNumTxs() int64 {
 type TxProof struct {
 	RootHash []byte        `protobuf:"bytes,1,opt,name=root_hash,json=rootHash,proto3" json:"root_hash,omitempty"`
 	Data     []byte        `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
-	Proof    *merkle.Proof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
+	Proof    *crypto.Proof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof,omitempty"`
 }
 
 func (m *TxProof) Reset()         { *m = TxProof{} }
@@ -995,7 +995,7 @@ func (m *TxProof) GetData() []byte {
 	return nil
 }
 
-func (m *TxProof) GetProof() *merkle.Proof {
+func (m *TxProof) GetProof() *crypto.Proof {
 	if m != nil {
 		return m.Proof
 	}
@@ -1022,90 +1022,89 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/types.proto", fileDescriptor_d3a6e55e2345de56) }
 
 var fileDescriptor_d3a6e55e2345de56 = []byte{
-	// 1318 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4d, 0x6f, 0xdb, 0x46,
-	0x13, 0x36, 0x25, 0xca, 0x92, 0x46, 0x96, 0x2d, 0x2f, 0x9c, 0x44, 0x51, 0x12, 0x99, 0xd0, 0xfb,
-	0xb6, 0x75, 0xd2, 0x40, 0x4a, 0x1d, 0xf4, 0x0b, 0x41, 0x0f, 0x92, 0xed, 0x24, 0x42, 0x6c, 0x59,
-	0xa5, 0x94, 0x14, 0xed, 0x85, 0xa0, 0xc4, 0x8d, 0x44, 0x84, 0xe2, 0xb2, 0xe4, 0xca, 0xb5, 0xf3,
-	0x0b, 0x0a, 0x9f, 0xd2, 0x1f, 0xa0, 0x53, 0x7b, 0xe8, 0xbd, 0xff, 0xa0, 0xa7, 0x1c, 0x73, 0x6b,
-	0x2f, 0x4d, 0x0b, 0x07, 0x28, 0xfa, 0x33, 0x8a, 0xfd, 0xa0, 0x44, 0x5a, 0x76, 0x3f, 0x82, 0xa0,
-	0x17, 0x7b, 0x77, 0xf6, 0x99, 0x99, 0x9d, 0x67, 0x9f, 0xdd, 0xa1, 0xe0, 0x2a, 0xc5, 0xae, 0x85,
-	0xfd, 0x91, 0xed, 0xd2, 0x1a, 0x3d, 0xf2, 0x70, 0x20, 0xfe, 0x56, 0x3d, 0x9f, 0x50, 0x82, 0x0a,
-	0xb3, 0xd5, 0x2a, 0xb7, 0x97, 0xd6, 0x06, 0x64, 0x40, 0xf8, 0x62, 0x8d, 0x8d, 0x04, 0xae, 0xb4,
-	0x3e, 0x20, 0x64, 0xe0, 0xe0, 0x1a, 0x9f, 0xf5, 0xc6, 0x8f, 0x6b, 0xd4, 0x1e, 0xe1, 0x80, 0x9a,
-	0x23, 0x4f, 0x02, 0xb4, 0x48, 0x1a, 0xc7, 0xee, 0x05, 0xb5, 0x9e, 0x4d, 0x63, 0xa9, 0x4a, 0xff,
-	0x8f, 0x20, 0xfa, 0xfe, 0x91, 0x47, 0x49, 0x6d, 0x84, 0xfd, 0x27, 0x0e, 0x8e, 0xa1, 0xa2, 0x71,
-	0x0e, 0xb0, 0x1f, 0xd8, 0xc4, 0x0d, 0xff, 0x0b, 0x44, 0xe5, 0x63, 0xc8, 0xb7, 0x4d, 0x9f, 0x76,
-	0x30, 0xbd, 0x8f, 0x4d, 0x0b, 0xfb, 0x68, 0x0d, 0x52, 0x94, 0x50, 0xd3, 0x29, 0x2a, 0x9a, 0xb2,
-	0x91, 0xd7, 0xc5, 0x04, 0x21, 0x50, 0x87, 0x66, 0x30, 0x2c, 0x26, 0x34, 0x65, 0x63, 0x49, 0xe7,
-	0xe3, 0x0a, 0x01, 0x95, 0xb9, 0x32, 0x0f, 0xdb, 0xb5, 0xf0, 0x61, 0xe8, 0xc1, 0x27, 0xcc, 0xda,
-	0x3b, 0xa2, 0x38, 0x90, 0x2e, 0x62, 0x82, 0xee, 0x40, 0xca, 0xf3, 0x09, 0x79, 0x5c, 0x4c, 0x6a,
-	0xca, 0x46, 0x6e, 0x73, 0xbd, 0x1a, 0x61, 0x4c, 0x94, 0x51, 0x15, 0x65, 0x54, 0xdb, 0x0c, 0xd6,
-	0x50, 0x9f, 0xbf, 0x5c, 0x5f, 0xd0, 0x85, 0x4f, 0xc5, 0x81, 0x74, 0xc3, 0x21, 0xfd, 0x27, 0xcd,
-	0xed, 0xe9, 0x7e, 0x94, 0xd9, 0x7e, 0xd0, 0x1e, 0xac, 0x78, 0xa6, 0x4f, 0x8d, 0x00, 0x53, 0x63,
-	0xc8, 0x8b, 0xe1, 0xb9, 0x4f, 0x65, 0x11, 0xf4, 0xc4, 0x6a, 0x96, 0x59, 0xf2, 0x5e, 0xd4, 0x58,
-	0xf9, 0x5d, 0x85, 0x45, 0xc9, 0xc9, 0x27, 0x90, 0x96, 0xac, 0xf1, 0x84, 0xb9, 0xcd, 0x6b, 0xd1,
-	0x88, 0x21, 0xa1, 0x5b, 0xc4, 0x0d, 0xb0, 0x1b, 0x8c, 0x03, 0x19, 0x2f, 0xf4, 0x41, 0x6f, 0x43,
-	0xa6, 0x3f, 0x34, 0x6d, 0xd7, 0xb0, 0x2d, 0xbe, 0xa3, 0x6c, 0x23, 0x77, 0xf2, 0x72, 0x3d, 0xbd,
-	0xc5, 0x6c, 0xcd, 0x6d, 0x3d, 0xcd, 0x17, 0x9b, 0x16, 0xba, 0x08, 0x8b, 0x43, 0x6c, 0x0f, 0x86,
-	0x94, 0xb3, 0x93, 0xd4, 0xe5, 0x0c, 0x7d, 0x04, 0x2a, 0x13, 0x48, 0x51, 0xe5, 0xb9, 0x4b, 0x55,
-	0xa1, 0x9e, 0x6a, 0xa8, 0x9e, 0x6a, 0x37, 0x54, 0x4f, 0x23, 0xc3, 0x12, 0x3f, 0xfb, 0x75, 0x5d,
-	0xd1, 0xb9, 0x07, 0xda, 0x82, 0xbc, 0x63, 0x06, 0xd4, 0xe8, 0x31, 0xda, 0x58, 0xfa, 0x14, 0x0f,
-	0x71, 0x79, 0x9e, 0x10, 0x49, 0xac, 0xdc, 0x7a, 0x8e, 0x79, 0x09, 0x93, 0x85, 0x36, 0xa0, 0xc0,
-	0x83, 0xf4, 0xc9, 0x68, 0x64, 0x53, 0x83, 0xf3, 0xbe, 0xc8, 0x79, 0x5f, 0x66, 0xf6, 0x2d, 0x6e,
-	0xbe, 0xcf, 0x4e, 0xe0, 0x0a, 0x64, 0x2d, 0x93, 0x9a, 0x02, 0x92, 0xe6, 0x90, 0x0c, 0x33, 0xf0,
-	0xc5, 0x77, 0x60, 0xe5, 0xc0, 0x74, 0x6c, 0xcb, 0xa4, 0xc4, 0x0f, 0x04, 0x24, 0x23, 0xa2, 0xcc,
-	0xcc, 0x1c, 0x78, 0x0b, 0xd6, 0x5c, 0x7c, 0x48, 0x8d, 0xd3, 0xe8, 0x2c, 0x47, 0x23, 0xb6, 0xf6,
-	0x28, 0xee, 0xf1, 0x16, 0x2c, 0xf7, 0x43, 0xf2, 0x05, 0x16, 0x38, 0x36, 0x3f, 0xb5, 0x72, 0xd8,
-	0x65, 0xc8, 0x98, 0x9e, 0x27, 0x00, 0x39, 0x0e, 0x48, 0x9b, 0x9e, 0xc7, 0x97, 0x6e, 0xc0, 0x2a,
-	0xaf, 0xd1, 0xc7, 0xc1, 0xd8, 0xa1, 0x32, 0xc8, 0x12, 0xc7, 0xac, 0xb0, 0x05, 0x5d, 0xd8, 0x39,
-	0xf6, 0x7f, 0x90, 0xc7, 0x07, 0xb6, 0x85, 0xdd, 0x3e, 0x16, 0xb8, 0x3c, 0xc7, 0x2d, 0x85, 0x46,
-	0x0e, 0xba, 0x0e, 0x05, 0xcf, 0x27, 0x1e, 0x09, 0xb0, 0x6f, 0x98, 0x96, 0xe5, 0xe3, 0x20, 0x28,
-	0x2e, 0x8b, 0x78, 0xa1, 0xbd, 0x2e, 0xcc, 0x95, 0x9b, 0xa0, 0x6e, 0x9b, 0xd4, 0x44, 0x05, 0x48,
-	0xd2, 0xc3, 0xa0, 0xa8, 0x68, 0xc9, 0x8d, 0x25, 0x9d, 0x0d, 0xcf, 0xbc, 0x75, 0x7f, 0x24, 0x40,
-	0x7d, 0x44, 0x28, 0x46, 0xb7, 0x41, 0x65, 0x47, 0xc7, 0x15, 0xb9, 0x7c, 0x96, 0xc6, 0x3b, 0xf6,
-	0xc0, 0xc5, 0xd6, 0x5e, 0x30, 0xe8, 0x1e, 0x79, 0x58, 0xe7, 0xe0, 0x88, 0xc4, 0x12, 0x31, 0x89,
-	0xad, 0x41, 0xca, 0x27, 0x63, 0xd7, 0xe2, 0xca, 0x4b, 0xe9, 0x62, 0x82, 0x76, 0x20, 0x33, 0x55,
-	0x8e, 0xfa, 0x77, 0xca, 0x59, 0x61, 0xca, 0x61, 0xba, 0x96, 0x06, 0x3d, 0xdd, 0x93, 0x02, 0x6a,
-	0x40, 0x76, 0xfa, 0xc0, 0x49, 0x05, 0xfe, 0x33, 0x11, 0xcf, 0xdc, 0xd0, 0xbb, 0xb0, 0x3a, 0xd5,
-	0xc3, 0x94, 0x50, 0xa1, 0xc2, 0xc2, 0x74, 0x41, 0x32, 0x1a, 0x93, 0x9a, 0x21, 0xde, 0xa6, 0x34,
-	0xaf, 0x6b, 0x26, 0xb5, 0x26, 0x7f, 0xa4, 0xae, 0x42, 0x36, 0xb0, 0x07, 0xae, 0x49, 0xc7, 0x3e,
-	0x96, 0x6a, 0x9c, 0x19, 0x2a, 0xdf, 0x24, 0x60, 0x51, 0xa8, 0x3b, 0xc2, 0x9b, 0x72, 0x36, 0x6f,
-	0x89, 0xf3, 0x78, 0x4b, 0xbe, 0x3e, 0x6f, 0x75, 0x80, 0xe9, 0x66, 0x82, 0xa2, 0xaa, 0x25, 0x37,
-	0x72, 0x9b, 0x57, 0xe6, 0x03, 0x89, 0x2d, 0x76, 0xec, 0x81, 0xbc, 0xbc, 0x11, 0xa7, 0xa9, 0x82,
-	0x52, 0x91, 0x77, 0xf2, 0x0e, 0x64, 0x7b, 0x36, 0x35, 0x4c, 0xdf, 0x37, 0x8f, 0x38, 0x85, 0xb9,
-	0xcd, 0x72, 0x34, 0x2a, 0x6b, 0x38, 0x55, 0xd6, 0x70, 0xaa, 0x0d, 0x9b, 0xd6, 0x19, 0x4a, 0xcf,
-	0xf4, 0xe4, 0xa8, 0xf2, 0x8b, 0x02, 0xd9, 0x69, 0x42, 0x54, 0x87, 0x7c, 0x58, 0xa8, 0xf1, 0xd8,
-	0x31, 0x07, 0x52, 0x8c, 0xd7, 0xce, 0xad, 0xf6, 0xae, 0x63, 0x0e, 0xf4, 0x9c, 0x2c, 0x90, 0x4d,
-	0xce, 0x3e, 0xd8, 0xc4, 0x39, 0x07, 0x1b, 0x53, 0x52, 0xf2, 0xf5, 0x94, 0x14, 0x3b, 0x73, 0xf5,
-	0xf4, 0x99, 0xff, 0x90, 0x80, 0x4c, 0x9b, 0x5f, 0x50, 0xd3, 0xf9, 0x2f, 0xae, 0xd8, 0x15, 0xc8,
-	0x7a, 0xc4, 0x31, 0xc4, 0x8a, 0xca, 0x57, 0x32, 0x1e, 0x71, 0xf4, 0x39, 0x1d, 0xa5, 0xde, 0xd0,
-	0xfd, 0x5b, 0x7c, 0x03, 0xac, 0xa5, 0x4f, 0xb3, 0xe6, 0xc3, 0x92, 0xa0, 0x42, 0x36, 0xcc, 0x5b,
-	0x8c, 0x03, 0xde, 0x81, 0x45, 0xbf, 0x2c, 0xce, 0x6f, 0x5b, 0x20, 0x75, 0x89, 0x63, 0x1e, 0xa2,
-	0xbf, 0xc8, 0x9e, 0x5d, 0x3c, 0x4f, 0xe7, 0xba, 0xc4, 0x55, 0x7e, 0x54, 0x20, 0xcb, 0x4b, 0xdd,
-	0xc3, 0xd4, 0x8c, 0x51, 0xa5, 0xbc, 0x3e, 0x55, 0xd7, 0x00, 0x44, 0x98, 0xc0, 0x7e, 0x8a, 0xe5,
-	0x01, 0x66, 0xb9, 0xa5, 0x63, 0x3f, 0xc5, 0xe8, 0x83, 0x69, 0x5d, 0xc9, 0xbf, 0xae, 0x4b, 0x5e,
-	0xc5, 0xb0, 0xba, 0x4b, 0x90, 0x76, 0xc7, 0x23, 0x83, 0x3d, 0xef, 0xaa, 0x10, 0x85, 0x3b, 0x1e,
-	0x75, 0x0f, 0x83, 0xca, 0x97, 0x90, 0xee, 0x1e, 0xf2, 0x4f, 0x1d, 0xa6, 0x04, 0x9f, 0x10, 0xd9,
-	0x5f, 0xc5, 0x77, 0x4d, 0x86, 0x19, 0x78, 0x3b, 0x41, 0xa0, 0xb2, 0x46, 0x1a, 0x76, 0x02, 0x36,
-	0x46, 0xef, 0xff, 0xbb, 0x6f, 0x29, 0xf9, 0x15, 0x75, 0xe3, 0x27, 0x05, 0x72, 0x91, 0xdb, 0x88,
-	0xde, 0x83, 0x0b, 0x8d, 0xdd, 0xfd, 0xad, 0x07, 0x46, 0x73, 0xdb, 0xb8, 0xbb, 0x5b, 0xbf, 0x67,
-	0x3c, 0x6c, 0x3d, 0x68, 0xed, 0x7f, 0xd6, 0x2a, 0x2c, 0x94, 0x2e, 0x1e, 0x4f, 0x34, 0x14, 0xc1,
-	0x3e, 0x74, 0x9f, 0xb8, 0xe4, 0x2b, 0x17, 0xd5, 0x60, 0x2d, 0xee, 0x52, 0x6f, 0x74, 0x76, 0x5a,
-	0xdd, 0x82, 0x52, 0xba, 0x70, 0x3c, 0xd1, 0x56, 0x23, 0x1e, 0xf5, 0x5e, 0x80, 0x5d, 0x3a, 0xef,
-	0xb0, 0xb5, 0xbf, 0xb7, 0xd7, 0xec, 0x16, 0x12, 0x73, 0x0e, 0xf2, 0xbd, 0xbd, 0x0e, 0xab, 0x71,
-	0x87, 0x56, 0x73, 0xb7, 0x90, 0x2c, 0xa1, 0xe3, 0x89, 0xb6, 0x1c, 0x41, 0xb7, 0x6c, 0xa7, 0x94,
-	0xf9, 0xfa, 0xdb, 0xf2, 0xc2, 0xf7, 0xdf, 0x95, 0x15, 0x56, 0x59, 0x3e, 0x76, 0x23, 0xd1, 0x4d,
-	0xb8, 0xd4, 0x69, 0xde, 0x6b, 0xed, 0x6c, 0x1b, 0x7b, 0x9d, 0x7b, 0x46, 0xf7, 0xf3, 0xf6, 0x4e,
-	0xa4, 0xba, 0x95, 0xe3, 0x89, 0x96, 0x93, 0x25, 0x9d, 0x87, 0x6e, 0xeb, 0x3b, 0x8f, 0xf6, 0xbb,
-	0x3b, 0x05, 0x45, 0xa0, 0xdb, 0x3e, 0x3e, 0x20, 0x14, 0x73, 0xf4, 0x2d, 0xb8, 0x7c, 0x06, 0x7a,
-	0x5a, 0xd8, 0xea, 0xf1, 0x44, 0xcb, 0xb7, 0x7d, 0x2c, 0xd4, 0xca, 0x3d, 0xaa, 0x50, 0x9c, 0xf7,
-	0xd8, 0x6f, 0xef, 0x77, 0xea, 0xbb, 0x05, 0xad, 0x54, 0x38, 0x9e, 0x68, 0x4b, 0xe1, 0xd3, 0xc3,
-	0xf0, 0xb3, 0xca, 0x1a, 0x9f, 0x3e, 0x3f, 0x29, 0x2b, 0x2f, 0x4e, 0xca, 0xca, 0x6f, 0x27, 0x65,
-	0xe5, 0xd9, 0xab, 0xf2, 0xc2, 0x8b, 0x57, 0xe5, 0x85, 0x9f, 0x5f, 0x95, 0x17, 0xbe, 0xf8, 0x70,
-	0x60, 0xd3, 0xe1, 0xb8, 0x57, 0xed, 0x93, 0x51, 0x2d, 0xfa, 0xdb, 0x64, 0x36, 0x14, 0xbf, 0x3e,
-	0x4e, 0xff, 0x6e, 0xe9, 0x2d, 0x72, 0xfb, 0xed, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x43, 0x91,
-	0x60, 0x8d, 0xd2, 0x0c, 0x00, 0x00,
+	// 1312 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xcf, 0x6e, 0xdb, 0xc6,
+	0x13, 0x36, 0x25, 0xca, 0x92, 0x46, 0x96, 0x2d, 0x2f, 0x9c, 0x44, 0x51, 0x62, 0x99, 0xd0, 0x0f,
+	0xbf, 0xd6, 0x49, 0x03, 0x2a, 0x75, 0x8a, 0xfe, 0x41, 0xd1, 0x83, 0x64, 0x3b, 0x89, 0x10, 0x5b,
+	0x56, 0x29, 0x25, 0x45, 0x7b, 0x21, 0x28, 0x71, 0x23, 0xb1, 0xa1, 0xb8, 0x04, 0xb9, 0x72, 0xed,
+	0x3c, 0x41, 0xe1, 0x53, 0xfa, 0x00, 0x3a, 0xb5, 0x87, 0xde, 0xfb, 0x06, 0x3d, 0xe5, 0x98, 0x5b,
+	0x7b, 0x69, 0x5a, 0x38, 0x40, 0xd1, 0xc7, 0x28, 0xf6, 0x8f, 0x28, 0xca, 0xb2, 0xdb, 0x20, 0x08,
+	0x7a, 0x11, 0x76, 0x67, 0xbe, 0x99, 0xdd, 0xf9, 0xf6, 0xdb, 0x1d, 0x0a, 0xae, 0x53, 0xec, 0xd9,
+	0x38, 0x18, 0x3a, 0x1e, 0xad, 0xd2, 0x63, 0x1f, 0x87, 0xe2, 0x57, 0xf7, 0x03, 0x42, 0x09, 0x2a,
+	0x4c, 0xbd, 0x3a, 0xb7, 0x97, 0xd6, 0xfa, 0xa4, 0x4f, 0xb8, 0xb3, 0xca, 0x46, 0x02, 0x57, 0xda,
+	0xe8, 0x13, 0xd2, 0x77, 0x71, 0x95, 0xcf, 0xba, 0xa3, 0xc7, 0x55, 0xea, 0x0c, 0x71, 0x48, 0xad,
+	0xa1, 0x2f, 0x01, 0x5a, 0x6c, 0x19, 0xd7, 0xe9, 0x86, 0xd5, 0xae, 0x43, 0x67, 0x96, 0x2a, 0xad,
+	0xc7, 0x10, 0xbd, 0xe0, 0xd8, 0xa7, 0x84, 0x65, 0x23, 0x8f, 0xa5, 0xbb, 0x1c, 0x73, 0x1f, 0xe2,
+	0x20, 0x74, 0x88, 0x17, 0x0f, 0xaf, 0x7c, 0x02, 0xf9, 0x96, 0x15, 0xd0, 0x36, 0xa6, 0xf7, 0xb1,
+	0x65, 0xe3, 0x00, 0xad, 0x41, 0x8a, 0x12, 0x6a, 0xb9, 0x45, 0x45, 0x53, 0x36, 0xf3, 0x86, 0x98,
+	0x20, 0x04, 0xea, 0xc0, 0x0a, 0x07, 0xc5, 0x84, 0xa6, 0x6c, 0x2e, 0x19, 0x7c, 0x5c, 0x19, 0x80,
+	0xca, 0x42, 0x59, 0x84, 0xe3, 0xd9, 0xf8, 0x68, 0x12, 0xc1, 0x27, 0xcc, 0xda, 0x3d, 0xa6, 0x38,
+	0x94, 0x21, 0x62, 0x82, 0x3e, 0x80, 0x14, 0xdf, 0x5d, 0x31, 0xa9, 0x29, 0x9b, 0xb9, 0xad, 0xa2,
+	0x1e, 0x23, 0x4a, 0xec, 0x5e, 0x6f, 0x31, 0x7f, 0x5d, 0x7d, 0xfe, 0x72, 0x63, 0xc1, 0x10, 0xe0,
+	0x8a, 0x0b, 0xe9, 0xba, 0x4b, 0x7a, 0x4f, 0x1a, 0x3b, 0xd1, 0x46, 0x94, 0xe9, 0x46, 0xd0, 0x3e,
+	0xac, 0xf8, 0x56, 0x40, 0xcd, 0x10, 0x53, 0x73, 0xc0, 0xab, 0xe0, 0x8b, 0xe6, 0xb6, 0x36, 0xf4,
+	0xb3, 0xe7, 0xa0, 0xcf, 0x14, 0x2b, 0x57, 0xc9, 0xfb, 0x71, 0x63, 0xe5, 0x4f, 0x15, 0x16, 0x25,
+	0x19, 0x9f, 0x41, 0x5a, 0x92, 0xc6, 0x17, 0xcc, 0x6d, 0xad, 0xc7, 0x33, 0x4a, 0x97, 0xbe, 0x4d,
+	0xbc, 0x10, 0x7b, 0xe1, 0x28, 0x94, 0xf9, 0x26, 0x31, 0xe8, 0x1d, 0xc8, 0xf4, 0x06, 0x96, 0xe3,
+	0x99, 0x8e, 0xcd, 0x77, 0x94, 0xad, 0xe7, 0x4e, 0x5f, 0x6e, 0xa4, 0xb7, 0x99, 0xad, 0xb1, 0x63,
+	0xa4, 0xb9, 0xb3, 0x61, 0xa3, 0xcb, 0xb0, 0x38, 0xc0, 0x4e, 0x7f, 0x40, 0x39, 0x2d, 0x49, 0x43,
+	0xce, 0xd0, 0xc7, 0xa0, 0x32, 0x41, 0x14, 0x55, 0xbe, 0x76, 0x49, 0x17, 0x6a, 0xd1, 0x27, 0x6a,
+	0xd1, 0x3b, 0x13, 0xb5, 0xd4, 0x33, 0x6c, 0xe1, 0x67, 0xbf, 0x6f, 0x28, 0x06, 0x8f, 0x40, 0xdb,
+	0x90, 0x77, 0xad, 0x90, 0x9a, 0x5d, 0x46, 0x1b, 0x5b, 0x3e, 0xc5, 0x53, 0x5c, 0x9d, 0x27, 0x44,
+	0x12, 0x2b, 0xb7, 0x9e, 0x63, 0x51, 0xc2, 0x64, 0xa3, 0x4d, 0x28, 0xf0, 0x24, 0x3d, 0x32, 0x1c,
+	0x3a, 0xd4, 0xe4, 0xbc, 0x2f, 0x72, 0xde, 0x97, 0x99, 0x7d, 0x9b, 0x9b, 0xef, 0xb3, 0x13, 0xb8,
+	0x06, 0x59, 0xdb, 0xa2, 0x96, 0x80, 0xa4, 0x39, 0x24, 0xc3, 0x0c, 0xdc, 0xf9, 0x2e, 0xac, 0x1c,
+	0x5a, 0xae, 0x63, 0x5b, 0x94, 0x04, 0xa1, 0x80, 0x64, 0x44, 0x96, 0xa9, 0x99, 0x03, 0x6f, 0xc3,
+	0x9a, 0x87, 0x8f, 0xa8, 0x79, 0x16, 0x9d, 0xe5, 0x68, 0xc4, 0x7c, 0x8f, 0x66, 0x23, 0xfe, 0x0f,
+	0xcb, 0xbd, 0x09, 0xf9, 0x02, 0x0b, 0x1c, 0x9b, 0x8f, 0xac, 0x1c, 0x76, 0x15, 0x32, 0x96, 0xef,
+	0x0b, 0x40, 0x8e, 0x03, 0xd2, 0x96, 0xef, 0x73, 0xd7, 0x4d, 0x58, 0xe5, 0x35, 0x06, 0x38, 0x1c,
+	0xb9, 0x54, 0x26, 0x59, 0xe2, 0x98, 0x15, 0xe6, 0x30, 0x84, 0x9d, 0x63, 0xff, 0x07, 0x79, 0x7c,
+	0xe8, 0xd8, 0xd8, 0xeb, 0x61, 0x81, 0xcb, 0x73, 0xdc, 0xd2, 0xc4, 0xc8, 0x41, 0x37, 0xa0, 0xe0,
+	0x07, 0xc4, 0x27, 0x21, 0x0e, 0x4c, 0xcb, 0xb6, 0x03, 0x1c, 0x86, 0xc5, 0x65, 0x91, 0x6f, 0x62,
+	0xaf, 0x09, 0x73, 0xe5, 0x16, 0xa8, 0x3b, 0x16, 0xb5, 0x50, 0x01, 0x92, 0xf4, 0x28, 0x2c, 0x2a,
+	0x5a, 0x72, 0x73, 0xc9, 0x60, 0xc3, 0x73, 0xaf, 0xdb, 0x5f, 0x09, 0x50, 0x1f, 0x11, 0x8a, 0xd1,
+	0x1d, 0x50, 0xd9, 0xd1, 0x71, 0x45, 0x2e, 0x9f, 0xa7, 0xf1, 0xb6, 0xd3, 0xf7, 0xb0, 0xbd, 0x1f,
+	0xf6, 0x3b, 0xc7, 0x3e, 0x36, 0x38, 0x38, 0x26, 0xb1, 0xc4, 0x8c, 0xc4, 0xd6, 0x20, 0x15, 0x90,
+	0x91, 0x67, 0x73, 0xe5, 0xa5, 0x0c, 0x31, 0x41, 0xbb, 0x90, 0x89, 0x94, 0xa3, 0xfe, 0x9b, 0x72,
+	0x56, 0x98, 0x72, 0x98, 0xae, 0xa5, 0xc1, 0x48, 0x77, 0xa5, 0x80, 0xea, 0x90, 0x8d, 0x1e, 0x34,
+	0xa9, 0xc0, 0xd7, 0x13, 0xf1, 0x34, 0x0c, 0xbd, 0x07, 0xab, 0x91, 0x1e, 0x22, 0x42, 0x85, 0x0a,
+	0x0b, 0x91, 0x43, 0x32, 0x3a, 0x23, 0x35, 0x53, 0x3c, 0x4a, 0x69, 0x5e, 0xd7, 0x54, 0x6a, 0x0d,
+	0xfe, 0x3a, 0x5d, 0x87, 0x6c, 0xe8, 0xf4, 0x3d, 0x8b, 0x8e, 0x02, 0x2c, 0xd5, 0x38, 0x35, 0x54,
+	0xbe, 0x4b, 0xc0, 0xa2, 0x50, 0x77, 0x8c, 0x37, 0xe5, 0x7c, 0xde, 0x12, 0x17, 0xf1, 0x96, 0x7c,
+	0x73, 0xde, 0x6a, 0x00, 0xd1, 0x66, 0xc2, 0xa2, 0xaa, 0x25, 0x37, 0x73, 0x5b, 0xd7, 0xe6, 0x13,
+	0x89, 0x2d, 0xb6, 0x9d, 0xbe, 0xbc, 0xbc, 0xb1, 0xa0, 0x48, 0x41, 0xa9, 0xd8, 0x3b, 0xf9, 0x29,
+	0x64, 0xbb, 0x0e, 0x35, 0xad, 0x20, 0xb0, 0x8e, 0x39, 0x85, 0xb9, 0xad, 0x72, 0x3c, 0x2b, 0x6b,
+	0x30, 0x3a, 0x6b, 0x30, 0x7a, 0xdd, 0xa1, 0x35, 0x86, 0x32, 0x32, 0x5d, 0x39, 0xaa, 0xfc, 0xa6,
+	0x40, 0x36, 0x5a, 0x10, 0xd5, 0x20, 0x3f, 0x29, 0xd4, 0x7c, 0xec, 0x5a, 0x7d, 0x29, 0xc6, 0xf5,
+	0x0b, 0xab, 0xbd, 0xeb, 0x5a, 0x7d, 0x23, 0x27, 0x0b, 0x64, 0x93, 0xf3, 0x0f, 0x36, 0x71, 0xc1,
+	0xc1, 0xce, 0x28, 0x29, 0xf9, 0x66, 0x4a, 0x9a, 0x39, 0x73, 0xf5, 0xec, 0x99, 0xff, 0x94, 0x80,
+	0x4c, 0x8b, 0x5f, 0x50, 0xcb, 0xfd, 0x2f, 0xae, 0xd8, 0x35, 0xc8, 0xfa, 0xc4, 0x35, 0x85, 0x47,
+	0xe5, 0x9e, 0x8c, 0x4f, 0x5c, 0x63, 0x4e, 0x47, 0xa9, 0xb7, 0x74, 0xff, 0x16, 0xdf, 0x02, 0x6b,
+	0xe9, 0xb3, 0xac, 0x05, 0xb0, 0x24, 0xa8, 0x90, 0x0d, 0xf3, 0x36, 0xe3, 0x80, 0x77, 0x60, 0x65,
+	0xbe, 0xc1, 0x8b, 0x6d, 0x0b, 0xa4, 0x21, 0x71, 0x2c, 0x42, 0xf4, 0x17, 0xd9, 0xb3, 0x8b, 0x17,
+	0xe9, 0xdc, 0x90, 0xb8, 0xca, 0xcf, 0x0a, 0x64, 0x79, 0xa9, 0xfb, 0x98, 0x5a, 0x33, 0x54, 0x29,
+	0x6f, 0x4e, 0xd5, 0x3a, 0x80, 0x48, 0x13, 0x3a, 0x4f, 0xb1, 0x3c, 0xc0, 0x2c, 0xb7, 0xb4, 0x9d,
+	0xa7, 0x18, 0x7d, 0x18, 0xd5, 0x95, 0xfc, 0xe7, 0xba, 0xe4, 0x55, 0x9c, 0x54, 0x77, 0x05, 0xd2,
+	0xde, 0x68, 0x68, 0xb2, 0xe7, 0x5d, 0x15, 0xa2, 0xf0, 0x46, 0xc3, 0xce, 0x51, 0x58, 0xf9, 0x1a,
+	0xd2, 0x9d, 0x23, 0xfe, 0xa9, 0xc3, 0x94, 0x10, 0x10, 0x22, 0xfb, 0xab, 0xf8, 0xae, 0xc9, 0x30,
+	0x03, 0x6f, 0x27, 0x08, 0x54, 0xd6, 0x48, 0x27, 0x9d, 0x80, 0x8d, 0x91, 0xfe, 0x9a, 0x1f, 0x51,
+	0xf2, 0xf3, 0xe9, 0xe6, 0x2f, 0x0a, 0xe4, 0x62, 0xd7, 0x10, 0xbd, 0x0f, 0x97, 0xea, 0x7b, 0x07,
+	0xdb, 0x0f, 0xcc, 0xc6, 0x8e, 0x79, 0x77, 0xaf, 0x76, 0xcf, 0x7c, 0xd8, 0x7c, 0xd0, 0x3c, 0xf8,
+	0xa2, 0x59, 0x58, 0x28, 0x5d, 0x3e, 0x19, 0x6b, 0x28, 0x86, 0x7d, 0xe8, 0x3d, 0xf1, 0xc8, 0x37,
+	0x1e, 0xaa, 0xc2, 0xda, 0x6c, 0x48, 0xad, 0xde, 0xde, 0x6d, 0x76, 0x0a, 0x4a, 0xe9, 0xd2, 0xc9,
+	0x58, 0x5b, 0x8d, 0x45, 0xd4, 0xba, 0x21, 0xf6, 0xe8, 0x7c, 0xc0, 0xf6, 0xc1, 0xfe, 0x7e, 0xa3,
+	0x53, 0x48, 0xcc, 0x05, 0xc8, 0x87, 0xf6, 0x06, 0xac, 0xce, 0x06, 0x34, 0x1b, 0x7b, 0x85, 0x64,
+	0x09, 0x9d, 0x8c, 0xb5, 0xe5, 0x18, 0xba, 0xe9, 0xb8, 0xa5, 0xcc, 0xb7, 0xdf, 0x97, 0x17, 0x7e,
+	0xfc, 0xa1, 0xac, 0xb0, 0xca, 0xf2, 0x33, 0x57, 0x11, 0xdd, 0x82, 0x2b, 0xed, 0xc6, 0xbd, 0xe6,
+	0xee, 0x8e, 0xb9, 0xdf, 0xbe, 0x67, 0x76, 0xbe, 0x6c, 0xed, 0xc6, 0xaa, 0x5b, 0x39, 0x19, 0x6b,
+	0x39, 0x59, 0xd2, 0x45, 0xe8, 0x96, 0xb1, 0xfb, 0xe8, 0xa0, 0xb3, 0x5b, 0x50, 0x04, 0xba, 0x15,
+	0xe0, 0x43, 0x42, 0x31, 0x47, 0xdf, 0x86, 0xab, 0xe7, 0xa0, 0xa3, 0xc2, 0x56, 0x4f, 0xc6, 0x5a,
+	0xbe, 0x15, 0x60, 0x21, 0x53, 0x1e, 0xa1, 0x43, 0x71, 0x3e, 0xe2, 0xa0, 0x75, 0xd0, 0xae, 0xed,
+	0x15, 0xb4, 0x52, 0xe1, 0x64, 0xac, 0x2d, 0x4d, 0xde, 0x1c, 0x86, 0x9f, 0x56, 0x56, 0xff, 0xfc,
+	0xf9, 0x69, 0x59, 0x79, 0x71, 0x5a, 0x56, 0xfe, 0x38, 0x2d, 0x2b, 0xcf, 0x5e, 0x95, 0x17, 0x5e,
+	0xbc, 0x2a, 0x2f, 0xfc, 0xfa, 0xaa, 0xbc, 0xf0, 0xd5, 0x47, 0x7d, 0x87, 0x0e, 0x46, 0x5d, 0xbd,
+	0x47, 0x86, 0xd5, 0xf8, 0x9f, 0x90, 0xe9, 0x50, 0xfc, 0xcd, 0x38, 0xfb, 0x07, 0xa5, 0xbb, 0xc8,
+	0xed, 0x77, 0xfe, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xbd, 0x5b, 0x78, 0xe7, 0xbb, 0x0c, 0x00, 0x00,
 }
 
 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -4421,7 +4420,7 @@ func (m *TxProof) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.Proof == nil {
-				m.Proof = &merkle.Proof{}
+				m.Proof = &crypto.Proof{}
 			}
 			if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err

proto/tendermint/types/types.proto

@@ -6,8 +6,8 @@ option go_package = "github.com/tendermint/tendermint/proto/tendermint/types";
 import "gogoproto/gogo.proto";
 import "google/protobuf/timestamp.proto";
 import "tendermint/libs/bits/types.proto";
-import "tendermint/crypto/merkle/types.proto";
-import "tendermint/version/version.proto";
+import "tendermint/crypto/proof.proto";
+import "tendermint/version/types.proto";
 
 // BlockIdFlag indicates which BlcokID the signature is for
 enum BlockIDFlag {
@@ -41,9 +41,9 @@ message PartSetHeader {
 }
 
 message Part {
-  uint32                         index = 1;
-  bytes                          bytes = 2;
-  tendermint.crypto.merkle.Proof proof = 3 [(gogoproto.nullable) = false];
+  uint32                  index = 1;
+  bytes                   bytes = 2;
+  tendermint.crypto.Proof proof = 3 [(gogoproto.nullable) = false];
 }
 
 // BlockID
@@ -150,7 +150,7 @@ message BlockMeta {
 
 // TxProof represents a Merkle proof of the presence of a transaction in the Merkle tree.
 message TxProof {
-  bytes                          root_hash = 1;
-  bytes                          data      = 2;
-  tendermint.crypto.merkle.Proof proof     = 3;
+  bytes                   root_hash = 1;
+  bytes                   data      = 2;
+  tendermint.crypto.Proof proof     = 3;
 }

proto/tendermint/types/validator.pb.go

@@ -7,7 +7,7 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	keys "github.com/tendermint/tendermint/proto/tendermint/crypto/keys"
+	crypto "github.com/tendermint/tendermint/proto/tendermint/crypto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -85,10 +85,10 @@ func (m *ValidatorSet) GetTotalVotingPower() int64 {
 }
 
 type Validator struct {
-	Address          []byte         `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
-	PubKey           keys.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"`
-	VotingPower      int64          `protobuf:"varint,3,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
-	ProposerPriority int64          `protobuf:"varint,4,opt,name=proposer_priority,json=proposerPriority,proto3" json:"proposer_priority,omitempty"`
+	Address          []byte           `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+	PubKey           crypto.PublicKey `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"`
+	VotingPower      int64            `protobuf:"varint,3,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
+	ProposerPriority int64            `protobuf:"varint,4,opt,name=proposer_priority,json=proposerPriority,proto3" json:"proposer_priority,omitempty"`
 }
 
 func (m *Validator) Reset()         { *m = Validator{} }
@@ -131,11 +131,11 @@ func (m *Validator) GetAddress() []byte {
 	return nil
 }
 
-func (m *Validator) GetPubKey() keys.PublicKey {
+func (m *Validator) GetPubKey() crypto.PublicKey {
 	if m != nil {
 		return m.PubKey
 	}
-	return keys.PublicKey{}
+	return crypto.PublicKey{}
 }
 
 func (m *Validator) GetVotingPower() int64 {
@@ -153,8 +153,8 @@ func (m *Validator) GetProposerPriority() int64 {
 }
 
 type SimpleValidator struct {
-	PubKey      *keys.PublicKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
-	VotingPower int64           `protobuf:"varint,2,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
+	PubKey      *crypto.PublicKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
+	VotingPower int64             `protobuf:"varint,2,opt,name=voting_power,json=votingPower,proto3" json:"voting_power,omitempty"`
 }
 
 func (m *SimpleValidator) Reset()         { *m = SimpleValidator{} }
@@ -190,7 +190,7 @@ func (m *SimpleValidator) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_SimpleValidator proto.InternalMessageInfo
 
-func (m *SimpleValidator) GetPubKey() *keys.PublicKey {
+func (m *SimpleValidator) GetPubKey() *crypto.PublicKey {
 	if m != nil {
 		return m.PubKey
 	}
@@ -213,31 +213,30 @@ func init() {
 func init() { proto.RegisterFile("tendermint/types/validator.proto", fileDescriptor_4e92274df03d3088) }
 
 var fileDescriptor_4e92274df03d3088 = []byte{
-	// 371 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xcf, 0x6a, 0xea, 0x40,
-	0x14, 0xc6, 0x33, 0x2a, 0x7a, 0xef, 0x28, 0x5c, 0xef, 0xd0, 0x45, 0xb0, 0x90, 0xc6, 0xac, 0x84,
-	0x96, 0x04, 0xda, 0x85, 0xd0, 0x6e, 0x8a, 0x5b, 0x37, 0x36, 0x82, 0x8b, 0x6e, 0x42, 0x62, 0x86,
-	0x74, 0x30, 0x3a, 0xc3, 0x64, 0x62, 0x99, 0xb7, 0xe8, 0xb3, 0x74, 0xd3, 0x57, 0x70, 0xe9, 0xb2,
-	0xab, 0x52, 0xf4, 0x45, 0x4a, 0x12, 0xf3, 0x07, 0xdb, 0xd2, 0xee, 0x26, 0xe7, 0xfb, 0xce, 0x77,
-	0x7e, 0x39, 0x1c, 0xa8, 0x0b, 0xbc, 0xf2, 0x31, 0x5f, 0x92, 0x95, 0xb0, 0x84, 0x64, 0x38, 0xb2,
-	0xd6, 0x6e, 0x48, 0x7c, 0x57, 0x50, 0x6e, 0x32, 0x4e, 0x05, 0x45, 0xdd, 0xd2, 0x61, 0xa6, 0x8e,
-	0xde, 0x49, 0x40, 0x03, 0x9a, 0x8a, 0x56, 0xf2, 0xca, 0x7c, 0x3d, 0xa3, 0x92, 0x34, 0xe7, 0x92,
-	0x09, 0x6a, 0x2d, 0xb0, 0x8c, 0xb2, 0xd4, 0xcc, 0x63, 0x3c, 0x03, 0xd8, 0x99, 0xe5, 0xf9, 0x53,
-	0x2c, 0xd0, 0x0d, 0x84, 0xc5, 0xbc, 0x48, 0x05, 0x7a, 0x7d, 0xd0, 0xbe, 0x3c, 0x35, 0x8f, 0x27,
-	0x9a, 0x45, 0x8f, 0x5d, 0xb1, 0xa3, 0x21, 0xfc, 0xc3, 0x38, 0x65, 0x34, 0xc2, 0x5c, 0xad, 0xe9,
-	0xe0, 0xa7, 0xd6, 0xc2, 0x8c, 0x2e, 0x20, 0x12, 0x54, 0xb8, 0xa1, 0xb3, 0xa6, 0x82, 0xac, 0x02,
-	0x87, 0xd1, 0x47, 0xcc, 0xd5, 0xba, 0x0e, 0x06, 0x75, 0xbb, 0x9b, 0x2a, 0xb3, 0x54, 0x98, 0x24,
-	0x75, 0xe3, 0x05, 0xc0, 0xbf, 0x45, 0x0a, 0x52, 0x61, 0xcb, 0xf5, 0x7d, 0x8e, 0xa3, 0x04, 0x17,
-	0x0c, 0x3a, 0x76, 0xfe, 0x89, 0x6e, 0x61, 0x8b, 0xc5, 0x9e, 0xb3, 0xc0, 0xf2, 0x40, 0xd3, 0xaf,
-	0xd2, 0x64, 0x2b, 0x31, 0x93, 0x95, 0x98, 0x93, 0xd8, 0x0b, 0xc9, 0x7c, 0x8c, 0xe5, 0xa8, 0xb1,
-	0x79, 0x3b, 0x53, 0xec, 0x26, 0x8b, 0xbd, 0x31, 0x96, 0xa8, 0x0f, 0x3b, 0x5f, 0x10, 0xb5, 0xd7,
-	0x25, 0x0c, 0x3a, 0x87, 0xff, 0xf3, 0xdf, 0x70, 0x18, 0x27, 0x94, 0x13, 0x21, 0xd5, 0x46, 0x46,
-	0x9e, 0x0b, 0x93, 0x43, 0xdd, 0x60, 0xf0, 0xdf, 0x94, 0x2c, 0x59, 0x88, 0x4b, 0xfc, 0xeb, 0x12,
-	0x12, 0xfc, 0x12, 0xf2, 0x5b, 0xbc, 0xda, 0x27, 0xbc, 0xd1, 0xdd, 0x66, 0xa7, 0x81, 0xed, 0x4e,
-	0x03, 0xef, 0x3b, 0x0d, 0x3c, 0xed, 0x35, 0x65, 0xbb, 0xd7, 0x94, 0xd7, 0xbd, 0xa6, 0xdc, 0x0f,
-	0x03, 0x22, 0x1e, 0x62, 0xcf, 0x9c, 0xd3, 0xa5, 0x55, 0xbd, 0xb9, 0xf2, 0x99, 0x5d, 0xd4, 0xf1,
-	0x3d, 0x7a, 0xcd, 0xb4, 0x7e, 0xf5, 0x11, 0x00, 0x00, 0xff, 0xff, 0x10, 0x63, 0x26, 0x50, 0xaa,
-	0x02, 0x00, 0x00,
+	// 361 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xcf, 0x4e, 0xc2, 0x40,
+	0x10, 0xc6, 0xbb, 0x40, 0x40, 0x17, 0x12, 0x71, 0xe3, 0xa1, 0x41, 0x52, 0x2b, 0x27, 0x12, 0x4d,
+	0x9b, 0x68, 0x0c, 0x07, 0x6e, 0x5c, 0xb9, 0x60, 0x49, 0x38, 0x78, 0x69, 0x5a, 0xba, 0xa9, 0x1b,
+	0x0a, 0xbb, 0xd9, 0x6e, 0x31, 0xfb, 0x16, 0x3e, 0x8b, 0x4f, 0xc1, 0x91, 0xa3, 0x27, 0x63, 0xe0,
+	0x45, 0x4c, 0x5b, 0xfa, 0x27, 0xa8, 0xe1, 0x36, 0x9d, 0xef, 0x9b, 0x99, 0x5f, 0x37, 0x1f, 0xd4,
+	0x05, 0x5e, 0x79, 0x98, 0x2f, 0xc9, 0x4a, 0x98, 0x42, 0x32, 0x1c, 0x9a, 0x6b, 0x27, 0x20, 0x9e,
+	0x23, 0x28, 0x37, 0x18, 0xa7, 0x82, 0xa2, 0x76, 0xe1, 0x30, 0x12, 0x47, 0xe7, 0xca, 0xa7, 0x3e,
+	0x4d, 0x44, 0x33, 0xae, 0x52, 0x5f, 0xa7, 0x5b, 0xda, 0x34, 0xe7, 0x92, 0x09, 0x6a, 0x2e, 0xb0,
+	0x0c, 0x53, 0xb5, 0xf7, 0x01, 0x60, 0x6b, 0x96, 0x6d, 0x9e, 0x62, 0x81, 0x86, 0x10, 0xe6, 0x97,
+	0x42, 0x15, 0xe8, 0xd5, 0x7e, 0xf3, 0xe1, 0xda, 0x38, 0xbe, 0x65, 0xe4, 0x33, 0x56, 0xc9, 0x8e,
+	0x06, 0xf0, 0x8c, 0x71, 0xca, 0x68, 0x88, 0xb9, 0x5a, 0xd1, 0xc1, 0xa9, 0xd1, 0xdc, 0x8c, 0xee,
+	0x21, 0x12, 0x54, 0x38, 0x81, 0xbd, 0xa6, 0x82, 0xac, 0x7c, 0x9b, 0xd1, 0x37, 0xcc, 0xd5, 0xaa,
+	0x0e, 0xfa, 0x55, 0xab, 0x9d, 0x28, 0xb3, 0x44, 0x98, 0xc4, 0xfd, 0x18, 0xfa, 0x3c, 0xdf, 0x82,
+	0x54, 0xd8, 0x70, 0x3c, 0x8f, 0xe3, 0x30, 0xc6, 0x05, 0xfd, 0x96, 0x95, 0x7d, 0xa2, 0x21, 0x6c,
+	0xb0, 0xc8, 0xb5, 0x17, 0x58, 0x1e, 0x68, 0xba, 0x65, 0x9a, 0xf4, 0x31, 0x8c, 0x49, 0xe4, 0x06,
+	0x64, 0x3e, 0xc6, 0x72, 0x54, 0xdb, 0x7c, 0xdd, 0x28, 0x56, 0x9d, 0x45, 0xee, 0x18, 0x4b, 0x74,
+	0x0b, 0x5b, 0x7f, 0xc0, 0x34, 0xd7, 0x05, 0x07, 0xba, 0x83, 0x97, 0xd9, 0x1f, 0xd8, 0x8c, 0x13,
+	0xca, 0x89, 0x90, 0x6a, 0x2d, 0x85, 0xce, 0x84, 0xc9, 0xa1, 0xdf, 0x5b, 0xc0, 0x8b, 0x29, 0x59,
+	0xb2, 0x00, 0x17, 0xe4, 0x4f, 0x05, 0x1f, 0x38, 0xcd, 0xf7, 0x2f, 0x59, 0xe5, 0x17, 0xd9, 0xe8,
+	0x79, 0xb3, 0xd3, 0xc0, 0x76, 0xa7, 0x81, 0xef, 0x9d, 0x06, 0xde, 0xf7, 0x9a, 0xb2, 0xdd, 0x6b,
+	0xca, 0xe7, 0x5e, 0x53, 0x5e, 0x06, 0x3e, 0x11, 0xaf, 0x91, 0x6b, 0xcc, 0xe9, 0xd2, 0x2c, 0x67,
+	0xac, 0x28, 0xd3, 0x04, 0x1d, 0xe7, 0xcf, 0xad, 0x27, 0xfd, 0xc7, 0x9f, 0x00, 0x00, 0x00, 0xff,
+	0xff, 0x48, 0xbf, 0x34, 0x35, 0x9a, 0x02, 0x00, 0x00,
 }
 
 func (m *ValidatorSet) Marshal() (dAtA []byte, err error) {
@@ -819,7 +818,7 @@ func (m *SimpleValidator) Unmarshal(dAtA []byte) error {
 				return io.ErrUnexpectedEOF
 			}
 			if m.PubKey == nil {
-				m.PubKey = &keys.PublicKey{}
+				m.PubKey = &crypto.PublicKey{}
 			}
 			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err

proto/tendermint/types/validator.proto

@@ -4,7 +4,7 @@ package tendermint.types;
 option go_package = "github.com/tendermint/tendermint/proto/tendermint/types";
 
 import "gogoproto/gogo.proto";
-import "tendermint/crypto/keys/types.proto";
+import "tendermint/crypto/keys.proto";
 
 message ValidatorSet {
   repeated Validator validators         = 1;
@@ -13,13 +13,13 @@ message ValidatorSet {
 }
 
 message Validator {
-  bytes                            address           = 1;
-  tendermint.crypto.keys.PublicKey pub_key           = 2 [(gogoproto.nullable) = false];
-  int64                            voting_power      = 3;
-  int64                            proposer_priority = 4;
+  bytes                       address           = 1;
+  tendermint.crypto.PublicKey pub_key           = 2 [(gogoproto.nullable) = false];
+  int64                       voting_power      = 3;
+  int64                       proposer_priority = 4;
 }
 
 message SimpleValidator {
-  tendermint.crypto.keys.PublicKey pub_key      = 1;
-  int64                            voting_power = 2;
+  tendermint.crypto.PublicKey pub_key      = 1;
+  int64                       voting_power = 2;
 }

rpc/grpc/types.pb.go

@@ -205,27 +205,27 @@ func init() {
 func init() { proto.RegisterFile("tendermint/rpc/grpc/types.proto", fileDescriptor_0ffff5682c662b95) }
 
 var fileDescriptor_0ffff5682c662b95 = []byte{
-	// 320 bytes of a gzipped FileDescriptorProto
+	// 316 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2f, 0x49, 0xcd, 0x4b,
 	0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x2f, 0x2a, 0x48, 0xd6, 0x4f, 0x07, 0x11, 0x25, 0x95,
 	0x05, 0xa9, 0xc5, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xc2, 0x08, 0x05, 0x7a, 0x45, 0x05,
-	0xc9, 0x7a, 0x20, 0x05, 0x52, 0x8a, 0x48, 0xba, 0x12, 0x93, 0x92, 0x33, 0x21, 0x3a, 0x90, 0xf5,
-	0x29, 0xf1, 0x72, 0x71, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x04, 0x64, 0xe6, 0xa5, 0x2b,
-	0xa9, 0x70, 0x09, 0x41, 0xb9, 0x4e, 0x45, 0xf9, 0x89, 0x29, 0xc9, 0x89, 0xc5, 0x25, 0x21, 0x15,
-	0x42, 0x7c, 0x5c, 0x4c, 0x25, 0x15, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x4c, 0x25, 0x15,
-	0x4a, 0x7c, 0x5c, 0x3c, 0x41, 0xa9, 0xc5, 0x05, 0xf9, 0x79, 0xc5, 0xa9, 0x60, 0x5d, 0x0b, 0x19,
-	0xb9, 0x84, 0x61, 0x02, 0xc8, 0xfa, 0x1c, 0xb9, 0x38, 0x92, 0x33, 0x52, 0x93, 0xb3, 0xe3, 0xa1,
-	0xba, 0xb9, 0x8d, 0xd4, 0xf4, 0x90, 0xdc, 0x09, 0x72, 0x92, 0x1e, 0xc4, 0x31, 0x30, 0xdd, 0xce,
-	0x20, 0xe5, 0x21, 0x15, 0x41, 0xec, 0xc9, 0x10, 0x86, 0x90, 0x3b, 0x17, 0x57, 0x4a, 0x6a, 0x4e,
-	0x66, 0x59, 0x6a, 0x11, 0xc8, 0x10, 0x26, 0xb0, 0x21, 0x1a, 0x04, 0x0c, 0x71, 0x81, 0x68, 0x08,
-	0xa9, 0x08, 0xe2, 0x4c, 0x81, 0x31, 0x8d, 0xf6, 0x32, 0x72, 0xf1, 0xc0, 0xdd, 0xe6, 0x18, 0xe0,
-	0x29, 0xe4, 0xcd, 0xc5, 0x02, 0x72, 0xbc, 0x90, 0x82, 0x1e, 0x96, 0xa0, 0xd3, 0x43, 0x0a, 0x14,
-	0x29, 0x45, 0x1c, 0x2a, 0x10, 0x21, 0x20, 0x94, 0xc0, 0xc5, 0x8d, 0xec, 0x71, 0x75, 0x7c, 0x66,
-	0x22, 0x29, 0x94, 0xd2, 0xc0, 0x6b, 0x34, 0x92, 0x4a, 0x27, 0x9f, 0x13, 0x8f, 0xe4, 0x18, 0x2f,
-	0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x71, 0xc2, 0x63, 0x39, 0x86, 0x0b, 0x8f, 0xe5, 0x18,
-	0x6e, 0x3c, 0x96, 0x63, 0x88, 0x32, 0x4a, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf,
-	0xd5, 0x47, 0x8a, 0x70, 0x2c, 0x29, 0xc6, 0x3a, 0x39, 0xbf, 0x28, 0x15, 0xc4, 0x48, 0x62, 0x03,
-	0xc7, 0xbe, 0x31, 0x20, 0x00, 0x00, 0xff, 0xff, 0x57, 0xba, 0xbe, 0x62, 0x58, 0x02, 0x00, 0x00,
+	0xc9, 0x7a, 0x20, 0x05, 0x52, 0xd2, 0x48, 0xba, 0x12, 0x93, 0x92, 0x33, 0x91, 0x75, 0x28, 0xf1,
+	0x72, 0x71, 0x07, 0xa5, 0x16, 0x96, 0xa6, 0x16, 0x97, 0x04, 0x64, 0xe6, 0xa5, 0x2b, 0xa9, 0x70,
+	0x09, 0x41, 0xb9, 0x4e, 0x45, 0xf9, 0x89, 0x29, 0xc9, 0x89, 0xc5, 0x25, 0x21, 0x15, 0x42, 0x7c,
+	0x5c, 0x4c, 0x25, 0x15, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c, 0x41, 0x4c, 0x25, 0x15, 0x4a, 0x7c,
+	0x5c, 0x3c, 0x41, 0xa9, 0xc5, 0x05, 0xf9, 0x79, 0xc5, 0xa9, 0x60, 0x5d, 0x53, 0x19, 0xb9, 0x84,
+	0x61, 0x02, 0xc8, 0xfa, 0xac, 0xb9, 0x38, 0x92, 0x33, 0x52, 0x93, 0xb3, 0xe3, 0xa1, 0xba, 0xb9,
+	0x8d, 0x14, 0xf4, 0x90, 0x5c, 0x08, 0x72, 0x8c, 0x1e, 0x4c, 0x9f, 0x33, 0x48, 0x61, 0x48, 0x45,
+	0x10, 0x7b, 0x32, 0x84, 0x21, 0xe4, 0xc8, 0xc5, 0x95, 0x92, 0x9a, 0x93, 0x59, 0x96, 0x5a, 0x04,
+	0xd2, 0xce, 0x04, 0xd6, 0xae, 0x84, 0x53, 0xbb, 0x0b, 0x44, 0x69, 0x48, 0x45, 0x10, 0x67, 0x0a,
+	0x8c, 0x69, 0xb4, 0x97, 0x91, 0x8b, 0x07, 0xee, 0x1e, 0xc7, 0x00, 0x4f, 0x21, 0x6f, 0x2e, 0x16,
+	0x90, 0x83, 0x85, 0x50, 0x9c, 0x01, 0x0b, 0x28, 0x3d, 0xa4, 0x80, 0x90, 0x52, 0xc4, 0xa1, 0x02,
+	0xe1, 0x6b, 0xa1, 0x04, 0x2e, 0x6e, 0x64, 0xcf, 0xaa, 0xe3, 0x33, 0x13, 0x49, 0xa1, 0x94, 0x06,
+	0x5e, 0xa3, 0x91, 0x54, 0x3a, 0xf9, 0x9c, 0x78, 0x24, 0xc7, 0x78, 0xe1, 0x91, 0x1c, 0xe3, 0x83,
+	0x47, 0x72, 0x8c, 0x13, 0x1e, 0xcb, 0x31, 0x5c, 0x78, 0x2c, 0xc7, 0x70, 0xe3, 0xb1, 0x1c, 0x43,
+	0x94, 0x51, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x52, 0xf4, 0x62,
+	0x49, 0x1f, 0xd6, 0xc9, 0xf9, 0x45, 0xa9, 0x20, 0x46, 0x12, 0x1b, 0x38, 0xc6, 0x8d, 0x01, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0xf6, 0x4b, 0x02, 0xd8, 0x46, 0x02, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.

scripts/protocgen.sh

@@ -17,6 +17,6 @@ done
 cp -r ./tendermint/* ./proto/*
 rm -rf tendermint
 
-mv ./proto/tendermint/abci/types/types.pb.go ./abci/types
+mv ./proto/tendermint/abci/types.pb.go ./abci/types
 
 mv ./proto/tendermint/rpc/grpc/types.pb.go ./rpc/grpc