proto: change to use gogofaster (#4957)

abci/types/types.proto

@@ -14,11 +14,6 @@ import "third_party/proto/gogoproto/gogo.proto";
 // NOTE: When using custom types, mind the warnings.
 // https://github.com/gogo/protobuf/blob/master/custom_types.md#warnings-and-issues
 
-option (gogoproto.marshaler_all)        = true;
-option (gogoproto.unmarshaler_all)      = true;
-option (gogoproto.sizer_all)            = true;
-option (gogoproto.goproto_registration) = true;
-
 //----------------------------------------
 // Request types
 

crypto/merkle/merkle.pb.go

@@ -27,12 +27,9 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 // The data could be arbitrary format, providing nessecary data
 // for example neighbouring node hash
 type ProofOp struct {
-	Type                 string   `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
-	Key                  []byte   `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
-	Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
+	Key  []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
 }
 
 func (m *ProofOp) Reset()         { *m = ProofOp{} }
@@ -91,10 +88,7 @@ func (m *ProofOp) GetData() []byte {
 
 // Proof is Merkle proof defined by the list of ProofOps
 type Proof struct {
-	Ops                  []ProofOp `protobuf:"bytes,1,rep,name=ops,proto3" json:"ops"`
-	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
-	XXX_unrecognized     []byte    `json:"-"`
-	XXX_sizecache        int32     `json:"-"`
+	Ops []ProofOp `protobuf:"bytes,1,rep,name=ops,proto3" json:"ops"`
 }
 
 func (m *Proof) Reset()         { *m = Proof{} }
@@ -145,7 +139,7 @@ func init() {
 func init() { proto.RegisterFile("crypto/merkle/merkle.proto", fileDescriptor_9c1c2162d560d38e) }
 
 var fileDescriptor_9c1c2162d560d38e = []byte{
-	// 221 bytes of a gzipped FileDescriptorProto
+	// 234 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4a, 0x2e, 0xaa, 0x2c,
 	0x28, 0xc9, 0xd7, 0xcf, 0x4d, 0x2d, 0xca, 0xce, 0x49, 0x85, 0x52, 0x7a, 0x05, 0x45, 0xf9, 0x25,
 	0xf9, 0x42, 0x12, 0x25, 0xa9, 0x79, 0x29, 0xa9, 0x45, 0xb9, 0x99, 0x79, 0x25, 0x7a, 0x10, 0x65,
@@ -156,10 +150,11 @@ var fileDescriptor_9c1c2162d560d38e = []byte{
 	0xa4, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0x62, 0x82, 0x54, 0xa5, 0x24, 0x96, 0x24, 0x4a, 0x30, 0x83,
 	0x85, 0xc0, 0x6c, 0x25, 0x27, 0x2e, 0x56, 0xb0, 0x21, 0x42, 0x96, 0x5c, 0xcc, 0xf9, 0x05, 0xc5,
 	0x12, 0x8c, 0x0a, 0xcc, 0x1a, 0xdc, 0x46, 0x8a, 0x7a, 0xb8, 0x5c, 0xa7, 0x07, 0xb5, 0xd2, 0x89,
-	0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x90, 0x1e, 0x27, 0x9b, 0x13, 0x8f, 0xe4, 0x18, 0x2f, 0x3c,
-	0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x31, 0x4a, 0x2f, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f,
-	0x39, 0x3f, 0x57, 0x1f, 0x61, 0x0a, 0x32, 0x13, 0x25, 0x54, 0x92, 0xd8, 0xc0, 0xbe, 0x31, 0x06,
-	0x04, 0x00, 0x00, 0xff, 0xff, 0xb6, 0x3d, 0x69, 0x56, 0x2d, 0x01, 0x00, 0x00,
+	0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x90, 0x1e, 0x27, 0x8f, 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, 0xd2, 0x4b, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5,
+	0x47, 0x98, 0x88, 0xcc, 0x44, 0x09, 0xa1, 0x24, 0x36, 0xb0, 0xcf, 0x8c, 0x01, 0x01, 0x00, 0x00,
+	0xff, 0xff, 0x39, 0xc0, 0xa3, 0x13, 0x39, 0x01, 0x00, 0x00,
 }
 
 func (m *ProofOp) Marshal() (dAtA []byte, err error) {
@@ -182,10 +177,6 @@ func (m *ProofOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Data) > 0 {
 		i -= len(m.Data)
 		copy(dAtA[i:], m.Data)
@@ -230,10 +221,6 @@ func (m *Proof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Ops) > 0 {
 		for iNdEx := len(m.Ops) - 1; iNdEx >= 0; iNdEx-- {
 			{
@@ -280,9 +267,6 @@ func (m *ProofOp) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovMerkle(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -298,9 +282,6 @@ func (m *Proof) Size() (n int) {
 			n += 1 + l + sovMerkle(uint64(l))
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -454,7 +435,6 @@ func (m *ProofOp) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -542,7 +522,6 @@ func (m *Proof) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}

proto/crypto/keys/types.pb.go

@@ -8,7 +8,9 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -26,10 +28,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 type PublicKey struct {
 	// Types that are valid to be assigned to Sum:
 	//	*PublicKey_Ed25519
-	Sum                  isPublicKey_Sum `protobuf_oneof:"sum"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	Sum isPublicKey_Sum `protobuf_oneof:"sum"`
 }
 
 func (m *PublicKey) Reset()         { *m = PublicKey{} }
@@ -39,16 +38,25 @@ func (*PublicKey) Descriptor() ([]byte, []int) {
 	return fileDescriptor_943d79b57ec0188f, []int{0}
 }
 func (m *PublicKey) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PublicKey.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PublicKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PublicKey.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PublicKey) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PublicKey.Merge(m, src)
 }
 func (m *PublicKey) XXX_Size() int {
-	return xxx_messageInfo_PublicKey.Size(m)
+	return m.Size()
 }
 func (m *PublicKey) XXX_DiscardUnknown() {
 	xxx_messageInfo_PublicKey.DiscardUnknown(m)
@@ -59,6 +67,8 @@ var xxx_messageInfo_PublicKey proto.InternalMessageInfo
 type isPublicKey_Sum interface {
 	isPublicKey_Sum()
 	Equal(interface{}) bool
+	MarshalTo([]byte) (int, error)
+	Size() int
 	Compare(interface{}) int
 }
 
@@ -94,10 +104,7 @@ func (*PublicKey) XXX_OneofWrappers() []interface{} {
 type PrivateKey struct {
 	// Types that are valid to be assigned to Sum:
 	//	*PrivateKey_Ed25519
-	Sum                  isPrivateKey_Sum `protobuf_oneof:"sum"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	Sum isPrivateKey_Sum `protobuf_oneof:"sum"`
 }
 
 func (m *PrivateKey) Reset()         { *m = PrivateKey{} }
@@ -107,16 +114,25 @@ func (*PrivateKey) Descriptor() ([]byte, []int) {
 	return fileDescriptor_943d79b57ec0188f, []int{1}
 }
 func (m *PrivateKey) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PrivateKey.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PrivateKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PrivateKey.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PrivateKey.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PrivateKey) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PrivateKey.Merge(m, src)
 }
 func (m *PrivateKey) XXX_Size() int {
-	return xxx_messageInfo_PrivateKey.Size(m)
+	return m.Size()
 }
 func (m *PrivateKey) XXX_DiscardUnknown() {
 	xxx_messageInfo_PrivateKey.DiscardUnknown(m)
@@ -126,6 +142,8 @@ var xxx_messageInfo_PrivateKey proto.InternalMessageInfo
 
 type isPrivateKey_Sum interface {
 	isPrivateKey_Sum()
+	MarshalTo([]byte) (int, error)
+	Size() int
 }
 
 type PrivateKey_Ed25519 struct {
@@ -163,7 +181,7 @@ func init() {
 func init() { proto.RegisterFile("proto/crypto/keys/types.proto", fileDescriptor_943d79b57ec0188f) }
 
 var fileDescriptor_943d79b57ec0188f = []byte{
-	// 190 bytes of a gzipped FileDescriptorProto
+	// 215 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2d, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x4f, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0xcf, 0x4e, 0xad, 0x2c, 0xd6, 0x2f, 0xa9,
 	0x2c, 0x48, 0x2d, 0xd6, 0x03, 0x8b, 0x0b, 0xc9, 0x94, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66,
@@ -173,9 +191,11 @@ var fileDescriptor_943d79b57ec0188f = []byte{
 	0x52, 0x5c, 0xec, 0xa9, 0x29, 0x46, 0xa6, 0xa6, 0x86, 0x96, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0x3c,
 	0x1e, 0x0c, 0x41, 0x30, 0x01, 0x2b, 0x8e, 0x17, 0x0b, 0xe4, 0x19, 0x5f, 0x2c, 0x94, 0x67, 0x74,
 	0x62, 0xe5, 0x62, 0x2e, 0x2e, 0xcd, 0x55, 0xd2, 0xe7, 0xe2, 0x0a, 0x28, 0xca, 0x2c, 0x4b, 0x2c,
-	0x49, 0x25, 0xa0, 0x15, 0xaa, 0xc1, 0xc9, 0x24, 0xca, 0x28, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49,
-	0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xe1, 0x7a, 0x64, 0x26, 0x86, 0x97, 0x93, 0xd8, 0xc0, 0x42, 0xc6,
-	0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x51, 0xcf, 0x02, 0x32, 0x0e, 0x01, 0x00, 0x00,
+	0x49, 0x25, 0xa0, 0x15, 0xaa, 0xc1, 0xc9, 0xe7, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18,
+	0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5,
+	0x18, 0xa2, 0x8c, 0xd2, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x11, 0xbe,
+	0x42, 0x66, 0x62, 0x04, 0x45, 0x12, 0x1b, 0x58, 0xc8, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x85,
+	0x0d, 0xee, 0x82, 0x26, 0x01, 0x00, 0x00,
 }
 
 func (this *PublicKey) Compare(that interface{}) int {
@@ -234,9 +254,6 @@ func (this *PublicKey) Compare(that interface{}) int {
 			return 1
 		}
 	}
-	if c := bytes.Compare(this.XXX_unrecognized, that1.XXX_unrecognized); c != 0 {
-		return c
-	}
 	return 0
 }
 func (this *PublicKey_Ed25519) Compare(that interface{}) int {
@@ -297,9 +314,6 @@ func (this *PublicKey) Equal(that interface{}) bool {
 	} else if !this.Sum.Equal(that1.Sum) {
 		return false
 	}
-	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
-		return false
-	}
 	return true
 }
 func (this *PublicKey_Ed25519) Equal(that interface{}) bool {
@@ -326,3 +340,421 @@ func (this *PublicKey_Ed25519) Equal(that interface{}) bool {
 	}
 	return true
 }
+func (m *PublicKey) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PublicKey) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PublicKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Sum != nil {
+		{
+			size := m.Sum.Size()
+			i -= size
+			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *PublicKey_Ed25519) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PublicKey_Ed25519) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Ed25519 != nil {
+		i -= len(m.Ed25519)
+		copy(dAtA[i:], m.Ed25519)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Ed25519)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+func (m *PrivateKey) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PrivateKey) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PrivateKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Sum != nil {
+		{
+			size := m.Sum.Size()
+			i -= size
+			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *PrivateKey_Ed25519) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PrivateKey_Ed25519) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.Ed25519 != nil {
+		i -= len(m.Ed25519)
+		copy(dAtA[i:], m.Ed25519)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Ed25519)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
+	offset -= sovTypes(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *PublicKey) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Sum != nil {
+		n += m.Sum.Size()
+	}
+	return n
+}
+
+func (m *PublicKey_Ed25519) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Ed25519 != nil {
+		l = len(m.Ed25519)
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+func (m *PrivateKey) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Sum != nil {
+		n += m.Sum.Size()
+	}
+	return n
+}
+
+func (m *PrivateKey_Ed25519) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Ed25519 != nil {
+		l = len(m.Ed25519)
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
+func sovTypes(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTypes(x uint64) (n int) {
+	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *PublicKey) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PublicKey: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PublicKey: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ed25519", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := make([]byte, postIndex-iNdEx)
+			copy(v, dAtA[iNdEx:postIndex])
+			m.Sum = &PublicKey_Ed25519{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PrivateKey) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PrivateKey: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PrivateKey: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ed25519", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := make([]byte, postIndex-iNdEx)
+			copy(v, dAtA[iNdEx:postIndex])
+			m.Sum = &PrivateKey_Ed25519{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipTypes(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthTypes
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupTypes
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthTypes
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
+)

proto/crypto/merkle/types.pb.go

@@ -5,7 +5,6 @@ package merkle
 
 import (
 	fmt "fmt"
-	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	io "io"
 	math "math"
@@ -24,13 +23,10 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type SimpleProof struct {
-	Total                int64    `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
-	Index                int64    `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
-	LeafHash             []byte   `protobuf:"bytes,3,opt,name=leaf_hash,json=leafHash,proto3" json:"leaf_hash,omitempty"`
-	Aunts                [][]byte `protobuf:"bytes,4,rep,name=aunts,proto3" json:"aunts,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Total    int64    `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
+	Index    int64    `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
+	LeafHash []byte   `protobuf:"bytes,3,opt,name=leaf_hash,json=leafHash,proto3" json:"leaf_hash,omitempty"`
+	Aunts    [][]byte `protobuf:"bytes,4,rep,name=aunts,proto3" json:"aunts,omitempty"`
 }
 
 func (m *SimpleProof) Reset()         { *m = SimpleProof{} }
@@ -101,22 +97,21 @@ func init() {
 func init() { proto.RegisterFile("proto/crypto/merkle/types.proto", fileDescriptor_57e39eefdaf7ae96) }
 
 var fileDescriptor_57e39eefdaf7ae96 = []byte{
-	// 225 bytes of a gzipped FileDescriptorProto
+	// 214 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2f, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x4f, 0x2e, 0xaa, 0x2c, 0x28, 0xc9, 0xd7, 0xcf, 0x4d, 0x2d, 0xca, 0xce, 0x49, 0xd5,
 	0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x03, 0xcb, 0x08, 0xc9, 0x95, 0xa4, 0xe6, 0xa5, 0xa4, 0x16,
-	0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44, 0xf4, 0x20, 0x6a, 0xf5, 0x20, 0x6a, 0xa5, 0xd4, 0x4a, 0x32,
-	0x32, 0x8b, 0x52, 0xe2, 0x0b, 0x12, 0x8b, 0x4a, 0x2a, 0xf5, 0x21, 0x86, 0xa5, 0xe7, 0xa7, 0xe7,
-	0x23, 0x58, 0x10, 0x5d, 0x4a, 0x39, 0x5c, 0xdc, 0xc1, 0x99, 0xb9, 0x05, 0x39, 0xa9, 0x01, 0x45,
-	0xf9, 0xf9, 0x69, 0x42, 0x22, 0x5c, 0xac, 0x25, 0xf9, 0x25, 0x89, 0x39, 0x12, 0x8c, 0x0a, 0x8c,
-	0x1a, 0xcc, 0x41, 0x10, 0x0e, 0x48, 0x34, 0x33, 0x2f, 0x25, 0xb5, 0x42, 0x82, 0x09, 0x22, 0x0a,
-	0xe6, 0x08, 0x49, 0x73, 0x71, 0xe6, 0xa4, 0x26, 0xa6, 0xc5, 0x67, 0x24, 0x16, 0x67, 0x48, 0x30,
-	0x2b, 0x30, 0x6a, 0xf0, 0x04, 0x71, 0x80, 0x04, 0x3c, 0x12, 0x8b, 0x33, 0x40, 0x5a, 0x12, 0x4b,
-	0xf3, 0x4a, 0x8a, 0x25, 0x58, 0x14, 0x98, 0x35, 0x78, 0x82, 0x20, 0x1c, 0x27, 0xa7, 0x13, 0x8f,
-	0xe4, 0x18, 0x2f, 0x3c, 0x92, 0x63, 0x7c, 0xf0, 0x48, 0x8e, 0x31, 0xca, 0x24, 0x3d, 0xb3, 0x24,
-	0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xe1, 0x1d, 0x64, 0x26, 0x96, 0x50, 0x48, 0x62,
-	0x03, 0x0b, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0x90, 0x2f, 0xe5, 0x58, 0x23, 0x01, 0x00,
-	0x00,
+	0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44, 0xf4, 0x20, 0x6a, 0xf5, 0x20, 0x6a, 0x95, 0x72, 0xb8, 0xb8,
+	0x83, 0x33, 0x73, 0x0b, 0x72, 0x52, 0x03, 0x8a, 0xf2, 0xf3, 0xd3, 0x84, 0x44, 0xb8, 0x58, 0x4b,
+	0xf2, 0x4b, 0x12, 0x73, 0x24, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83, 0x20, 0x1c, 0x90, 0x68, 0x66,
+	0x5e, 0x4a, 0x6a, 0x85, 0x04, 0x13, 0x44, 0x14, 0xcc, 0x11, 0x92, 0xe6, 0xe2, 0xcc, 0x49, 0x4d,
+	0x4c, 0x8b, 0xcf, 0x48, 0x2c, 0xce, 0x90, 0x60, 0x56, 0x60, 0xd4, 0xe0, 0x09, 0xe2, 0x00, 0x09,
+	0x78, 0x24, 0x16, 0x67, 0x80, 0xb4, 0x24, 0x96, 0xe6, 0x95, 0x14, 0x4b, 0xb0, 0x28, 0x30, 0x6b,
+	0xf0, 0x04, 0x41, 0x38, 0x4e, 0x7e, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0,
+	0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10,
+	0x65, 0x92, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0x70, 0x32, 0x32,
+	0x13, 0x8b, 0x4f, 0x93, 0xd8, 0xc0, 0x82, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x91, 0x57,
+	0x16, 0x46, 0x07, 0x01, 0x00, 0x00,
 }
 
 func (m *SimpleProof) Marshal() (dAtA []byte, err error) {
@@ -139,10 +134,6 @@ func (m *SimpleProof) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Aunts) > 0 {
 		for iNdEx := len(m.Aunts) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.Aunts[iNdEx])
@@ -205,9 +196,6 @@ func (m *SimpleProof) Size() (n int) {
 			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -365,7 +353,6 @@ func (m *SimpleProof) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}

proto/crypto/merkle/types.proto

@@ -3,12 +3,6 @@ package tendermint.proto.crypto.merkle;
 
 option go_package = "github.com/tendermint/tendermint/proto/crypto/merkle";
 
-import "third_party/proto/gogoproto/gogo.proto";
-
-option (gogoproto.marshaler_all)        = true;
-option (gogoproto.unmarshaler_all)      = true;
-option (gogoproto.sizer_all)            = true;
-
 message SimpleProof {
   int64          total     = 1;
   int64          index     = 2;

proto/evidence/msgs.pb.go

@@ -8,7 +8,9 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	types "github.com/tendermint/tendermint/proto/types"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -23,10 +25,7 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type List struct {
-	Evidence             []types.Evidence `protobuf:"bytes,1,rep,name=evidence,proto3" json:"evidence"`
-	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
-	XXX_unrecognized     []byte           `json:"-"`
-	XXX_sizecache        int32            `json:"-"`
+	Evidence []types.Evidence `protobuf:"bytes,1,rep,name=evidence,proto3" json:"evidence"`
 }
 
 func (m *List) Reset()         { *m = List{} }
@@ -36,16 +35,25 @@ func (*List) Descriptor() ([]byte, []int) {
 	return fileDescriptor_df8322769b0bd7d6, []int{0}
 }
 func (m *List) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_List.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *List) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_List.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_List.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *List) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_List.Merge(m, src)
 }
 func (m *List) XXX_Size() int {
-	return xxx_messageInfo_List.Size(m)
+	return m.Size()
 }
 func (m *List) XXX_DiscardUnknown() {
 	xxx_messageInfo_List.DiscardUnknown(m)
@@ -61,12 +69,9 @@ func (m *List) GetEvidence() []types.Evidence {
 }
 
 type Info struct {
-	Committed            bool           `protobuf:"varint,1,opt,name=committed,proto3" json:"committed,omitempty"`
-	Priority             int64          `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
-	Evidence             types.Evidence `protobuf:"bytes,3,opt,name=evidence,proto3" json:"evidence"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Committed bool           `protobuf:"varint,1,opt,name=committed,proto3" json:"committed,omitempty"`
+	Priority  int64          `protobuf:"varint,2,opt,name=priority,proto3" json:"priority,omitempty"`
+	Evidence  types.Evidence `protobuf:"bytes,3,opt,name=evidence,proto3" json:"evidence"`
 }
 
 func (m *Info) Reset()         { *m = Info{} }
@@ -76,16 +81,25 @@ func (*Info) Descriptor() ([]byte, []int) {
 	return fileDescriptor_df8322769b0bd7d6, []int{1}
 }
 func (m *Info) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Info.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Info) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Info.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Info.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *Info) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Info.Merge(m, src)
 }
 func (m *Info) XXX_Size() int {
-	return xxx_messageInfo_Info.Size(m)
+	return m.Size()
 }
 func (m *Info) XXX_DiscardUnknown() {
 	xxx_messageInfo_Info.DiscardUnknown(m)
@@ -122,7 +136,7 @@ func init() {
 func init() { proto.RegisterFile("proto/evidence/msgs.proto", fileDescriptor_df8322769b0bd7d6) }
 
 var fileDescriptor_df8322769b0bd7d6 = []byte{
-	// 228 bytes of a gzipped FileDescriptorProto
+	// 253 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2c, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x4f, 0x2d, 0xcb, 0x4c, 0x49, 0xcd, 0x4b, 0x4e, 0xd5, 0xcf, 0x2d, 0x4e, 0x2f, 0xd6,
 	0x03, 0x8b, 0x09, 0x49, 0x96, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44,
@@ -134,8 +148,440 @@ var fileDescriptor_df8322769b0bd7d6 = []byte{
 	0x53, 0x6a, 0x61, 0xe4, 0x62, 0xf1, 0xcc, 0x4b, 0xcb, 0x17, 0x92, 0xe1, 0xe2, 0x4c, 0xce, 0xcf,
 	0xcd, 0xcd, 0x2c, 0x29, 0x49, 0x4d, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x08, 0x42, 0x08, 0x08,
 	0x49, 0x71, 0x71, 0x14, 0x14, 0x65, 0xe6, 0x17, 0x65, 0x96, 0x54, 0x4a, 0x30, 0x29, 0x30, 0x6a,
-	0x30, 0x07, 0xc1, 0xf9, 0x28, 0xce, 0x60, 0x56, 0x60, 0x24, 0xc7, 0x19, 0x4e, 0x86, 0x51, 0xfa,
-	0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x08, 0xdd, 0xc8, 0x4c, 0xd4,
-	0xf0, 0x4e, 0x62, 0x03, 0xf3, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x0f, 0x66, 0x20, 0x26,
-	0x88, 0x01, 0x00, 0x00,
+	0x30, 0x07, 0xc1, 0xf9, 0x28, 0xce, 0x60, 0x56, 0x60, 0x24, 0xc7, 0x19, 0x4e, 0x9e, 0x27, 0x1e,
+	0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17,
+	0x1e, 0xcb, 0x31, 0xdc, 0x78, 0x2c, 0xc7, 0x10, 0xa5, 0x9f, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4,
+	0x97, 0x9c, 0x9f, 0xab, 0x8f, 0x30, 0x15, 0x99, 0x89, 0x1a, 0x0f, 0x49, 0x6c, 0x60, 0xbe, 0x31,
+	0x20, 0x00, 0x00, 0xff, 0xff, 0xf7, 0xf9, 0xc5, 0xd0, 0xa0, 0x01, 0x00, 0x00,
+}
+
+func (m *List) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *List) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *List) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Evidence) > 0 {
+		for iNdEx := len(m.Evidence) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Evidence[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintMsgs(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Info) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Info) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Info) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	{
+		size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintMsgs(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	if m.Priority != 0 {
+		i = encodeVarintMsgs(dAtA, i, uint64(m.Priority))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Committed {
+		i--
+		if m.Committed {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintMsgs(dAtA []byte, offset int, v uint64) int {
+	offset -= sovMsgs(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *List) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Evidence) > 0 {
+		for _, e := range m.Evidence {
+			l = e.Size()
+			n += 1 + l + sovMsgs(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Info) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Committed {
+		n += 2
+	}
+	if m.Priority != 0 {
+		n += 1 + sovMsgs(uint64(m.Priority))
+	}
+	l = m.Evidence.Size()
+	n += 1 + l + sovMsgs(uint64(l))
+	return n
+}
+
+func sovMsgs(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozMsgs(x uint64) (n int) {
+	return sovMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *List) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: List: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: List: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Evidence", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Evidence = append(m.Evidence, types.Evidence{})
+			if err := m.Evidence[len(m.Evidence)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Info) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Info: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Info: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Committed", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Committed = bool(v != 0)
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
+			}
+			m.Priority = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Priority |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Evidence", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipMsgs(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowMsgs
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowMsgs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowMsgs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthMsgs
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupMsgs
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthMsgs
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
 }
+
+var (
+	ErrInvalidLengthMsgs        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowMsgs          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupMsgs = fmt.Errorf("proto: unexpected end of group")
+)

proto/libs/bits/types.pb.go

@@ -5,9 +5,7 @@ package bits
 
 import (
 	fmt "fmt"
-	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	golang_proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -15,7 +13,6 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
-var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
@@ -26,11 +23,8 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type BitArray struct {
-	Bits                 int64    `protobuf:"varint,1,opt,name=bits,proto3" json:"bits,omitempty"`
-	Elems                []uint64 `protobuf:"varint,2,rep,packed,name=elems,proto3" json:"elems,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Bits  int64    `protobuf:"varint,1,opt,name=bits,proto3" json:"bits,omitempty"`
+	Elems []uint64 `protobuf:"varint,2,rep,packed,name=elems,proto3" json:"elems,omitempty"`
 }
 
 func (m *BitArray) Reset()         { *m = BitArray{} }
@@ -82,28 +76,23 @@ func (m *BitArray) GetElems() []uint64 {
 
 func init() {
 	proto.RegisterType((*BitArray)(nil), "tendermint.proto.libs.bits.BitArray")
-	golang_proto.RegisterType((*BitArray)(nil), "tendermint.proto.libs.bits.BitArray")
 }
 
 func init() { proto.RegisterFile("proto/libs/bits/types.proto", fileDescriptor_3f1fbe70d7999e09) }
-func init() {
-	golang_proto.RegisterFile("proto/libs/bits/types.proto", fileDescriptor_3f1fbe70d7999e09)
-}
 
 var fileDescriptor_3f1fbe70d7999e09 = []byte{
-	// 182 bytes of a gzipped FileDescriptorProto
+	// 166 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0xcf, 0xc9, 0x4c, 0x2a, 0xd6, 0x4f, 0xca, 0x2c, 0x29, 0xd6, 0x2f, 0xa9, 0x2c, 0x48,
 	0x2d, 0xd6, 0x03, 0x8b, 0x0a, 0x49, 0x95, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95,
-	0x40, 0x44, 0xf4, 0x40, 0xea, 0xf4, 0x40, 0xea, 0xa4, 0xd4, 0x4a, 0x32, 0x32, 0x8b, 0x52, 0xe2,
-	0x0b, 0x12, 0x8b, 0x4a, 0x2a, 0xf5, 0x21, 0x86, 0xa4, 0xe7, 0xa7, 0xe7, 0x23, 0x58, 0x10, 0x1d,
-	0x4a, 0x26, 0x5c, 0x1c, 0x4e, 0x99, 0x25, 0x8e, 0x45, 0x45, 0x89, 0x95, 0x42, 0x42, 0x5c, 0x2c,
-	0x20, 0xbd, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x60, 0xb6, 0x90, 0x08, 0x17, 0x6b, 0x6a,
-	0x4e, 0x6a, 0x6e, 0xb1, 0x04, 0x93, 0x02, 0xb3, 0x06, 0x4b, 0x10, 0x84, 0xe3, 0xe4, 0x74, 0xe2,
-	0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x1e, 0x78, 0x2c, 0xc7, 0x18,
-	0x65, 0x90, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0x70, 0x16, 0x32,
-	0x13, 0xcd, 0x27, 0x49, 0x6c, 0x60, 0x01, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xe8, 0xed,
-	0xf8, 0x61, 0xe3, 0x00, 0x00, 0x00,
+	0x40, 0x44, 0xf4, 0x40, 0xea, 0xf4, 0x40, 0xea, 0x94, 0x4c, 0xb8, 0x38, 0x9c, 0x32, 0x4b, 0x1c,
+	0x8b, 0x8a, 0x12, 0x2b, 0x85, 0x84, 0xb8, 0x58, 0x40, 0x62, 0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc,
+	0x41, 0x60, 0xb6, 0x90, 0x08, 0x17, 0x6b, 0x6a, 0x4e, 0x6a, 0x6e, 0xb1, 0x04, 0x93, 0x02, 0xb3,
+	0x06, 0x4b, 0x10, 0x84, 0xe3, 0xe4, 0x75, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f,
+	0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c, 0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c,
+	0x51, 0x06, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x08, 0x6b, 0x91,
+	0x99, 0x68, 0x2e, 0x4d, 0x62, 0x03, 0x0b, 0x18, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xb8, 0x2c,
+	0xa7, 0xda, 0xc3, 0x00, 0x00, 0x00,
 }
 
 func (m *BitArray) Marshal() (dAtA []byte, err error) {
@@ -126,10 +115,6 @@ func (m *BitArray) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Elems) > 0 {
 		dAtA2 := make([]byte, len(m.Elems)*10)
 		var j1 int
@@ -183,9 +168,6 @@ func (m *BitArray) Size() (n int) {
 		}
 		n += 1 + sovTypes(uint64(l)) + l
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -334,7 +316,6 @@ func (m *BitArray) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}

proto/libs/bits/types.proto

@@ -3,13 +3,6 @@ package tendermint.proto.libs.bits;
 
 option go_package = "github.com/tendermint/tendermint/proto/libs/bits";
 
-import "third_party/proto/gogoproto/gogo.proto";
-
-option (gogoproto.marshaler_all)        = true;
-option (gogoproto.unmarshaler_all)      = true;
-option (gogoproto.sizer_all)            = true;
-option (gogoproto.goproto_registration) = true;
-
 message BitArray {
   int64           bits  = 1;
   repeated uint64 elems = 2;

proto/p2p/conn_msgs.pb.go

@@ -7,7 +7,9 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -22,9 +24,6 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type PacketPing struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *PacketPing) Reset()         { *m = PacketPing{} }
@@ -34,16 +33,25 @@ func (*PacketPing) Descriptor() ([]byte, []int) {
 	return fileDescriptor_8c680f0b24d73fe7, []int{0}
 }
 func (m *PacketPing) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PacketPing.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PacketPing) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PacketPing.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PacketPing.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PacketPing) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PacketPing.Merge(m, src)
 }
 func (m *PacketPing) XXX_Size() int {
-	return xxx_messageInfo_PacketPing.Size(m)
+	return m.Size()
 }
 func (m *PacketPing) XXX_DiscardUnknown() {
 	xxx_messageInfo_PacketPing.DiscardUnknown(m)
@@ -52,9 +60,6 @@ func (m *PacketPing) XXX_DiscardUnknown() {
 var xxx_messageInfo_PacketPing proto.InternalMessageInfo
 
 type PacketPong struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *PacketPong) Reset()         { *m = PacketPong{} }
@@ -64,16 +69,25 @@ func (*PacketPong) Descriptor() ([]byte, []int) {
 	return fileDescriptor_8c680f0b24d73fe7, []int{1}
 }
 func (m *PacketPong) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PacketPong.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PacketPong) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PacketPong.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PacketPong.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PacketPong) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PacketPong.Merge(m, src)
 }
 func (m *PacketPong) XXX_Size() int {
-	return xxx_messageInfo_PacketPong.Size(m)
+	return m.Size()
 }
 func (m *PacketPong) XXX_DiscardUnknown() {
 	xxx_messageInfo_PacketPong.DiscardUnknown(m)
@@ -82,12 +96,9 @@ func (m *PacketPong) XXX_DiscardUnknown() {
 var xxx_messageInfo_PacketPong proto.InternalMessageInfo
 
 type PacketMsg struct {
-	ChannelID            int32    `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
-	EOF                  int32    `protobuf:"varint,2,opt,name=eof,proto3" json:"eof,omitempty"`
-	Data                 []byte   `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	ChannelID int32  `protobuf:"varint,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
+	EOF       int32  `protobuf:"varint,2,opt,name=eof,proto3" json:"eof,omitempty"`
+	Data      []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
 }
 
 func (m *PacketMsg) Reset()         { *m = PacketMsg{} }
@@ -97,16 +108,25 @@ func (*PacketMsg) Descriptor() ([]byte, []int) {
 	return fileDescriptor_8c680f0b24d73fe7, []int{2}
 }
 func (m *PacketMsg) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PacketMsg.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PacketMsg) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PacketMsg.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PacketMsg.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PacketMsg) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PacketMsg.Merge(m, src)
 }
 func (m *PacketMsg) XXX_Size() int {
-	return xxx_messageInfo_PacketMsg.Size(m)
+	return m.Size()
 }
 func (m *PacketMsg) XXX_DiscardUnknown() {
 	xxx_messageInfo_PacketMsg.DiscardUnknown(m)
@@ -140,10 +160,7 @@ type Packet struct {
 	//	*Packet_PacketPing
 	//	*Packet_PacketPong
 	//	*Packet_PacketMsg
-	Sum                  isPacket_Sum `protobuf_oneof:"sum"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Sum isPacket_Sum `protobuf_oneof:"sum"`
 }
 
 func (m *Packet) Reset()         { *m = Packet{} }
@@ -153,16 +170,25 @@ func (*Packet) Descriptor() ([]byte, []int) {
 	return fileDescriptor_8c680f0b24d73fe7, []int{3}
 }
 func (m *Packet) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Packet.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Packet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Packet.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Packet.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *Packet) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Packet.Merge(m, src)
 }
 func (m *Packet) XXX_Size() int {
-	return xxx_messageInfo_Packet.Size(m)
+	return m.Size()
 }
 func (m *Packet) XXX_DiscardUnknown() {
 	xxx_messageInfo_Packet.DiscardUnknown(m)
@@ -172,6 +198,8 @@ var xxx_messageInfo_Packet proto.InternalMessageInfo
 
 type isPacket_Sum interface {
 	isPacket_Sum()
+	MarshalTo([]byte) (int, error)
+	Size() int
 }
 
 type Packet_PacketPing struct {
@@ -235,24 +263,784 @@ func init() {
 func init() { proto.RegisterFile("proto/p2p/conn_msgs.proto", fileDescriptor_8c680f0b24d73fe7) }
 
 var fileDescriptor_8c680f0b24d73fe7 = []byte{
-	// 295 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0xc1, 0x4f, 0x83, 0x30,
-	0x14, 0xc6, 0x45, 0xdc, 0x0c, 0x8f, 0x79, 0x69, 0x3c, 0x30, 0x2f, 0x10, 0x0e, 0x66, 0x31, 0x0b,
-	0x24, 0xf8, 0x0f, 0x18, 0xa6, 0xc6, 0x1d, 0x16, 0x17, 0x8e, 0x5e, 0x08, 0x03, 0x2c, 0x8d, 0xd2,
-	0xd7, 0x40, 0x77, 0xf0, 0x6f, 0x35, 0xd9, 0x61, 0x7f, 0x89, 0xa1, 0x9d, 0x03, 0x13, 0xa3, 0xb7,
-	0xef, 0xfb, 0xf2, 0xfa, 0x7b, 0x5f, 0x5b, 0x98, 0x8a, 0x06, 0x25, 0x86, 0x22, 0x12, 0x61, 0x8e,
-	0x9c, 0xa7, 0x75, 0x4b, 0xdb, 0x40, 0x65, 0xe4, 0x52, 0x96, 0xbc, 0x28, 0x9b, 0x9a, 0x71, 0xa9,
-	0x93, 0x40, 0x44, 0xe2, 0xea, 0x5a, 0x56, 0xac, 0x29, 0x52, 0x91, 0x35, 0xf2, 0x23, 0xd4, 0x87,
-	0x29, 0x52, 0xec, 0x95, 0x9e, 0xf5, 0x27, 0x00, 0xeb, 0x2c, 0x7f, 0x2b, 0xe5, 0x9a, 0x71, 0x3a,
-	0x70, 0xc8, 0xa9, 0x5f, 0x81, 0xa5, 0xdd, 0xaa, 0xa5, 0x64, 0x0e, 0x90, 0x57, 0x19, 0xe7, 0xe5,
-	0x7b, 0xca, 0x0a, 0xc7, 0xf0, 0x8c, 0xd9, 0x28, 0xbe, 0xd8, 0xef, 0x5c, 0x6b, 0xa1, 0xd3, 0xe5,
-	0x7d, 0x62, 0x1d, 0x06, 0x96, 0x05, 0x99, 0x82, 0x59, 0xe2, 0xab, 0x73, 0xaa, 0xc6, 0xce, 0xf7,
-	0x3b, 0xd7, 0x7c, 0x78, 0x7e, 0x4c, 0xba, 0x8c, 0x10, 0x38, 0x2b, 0x32, 0x99, 0x39, 0xa6, 0x67,
-	0xcc, 0x26, 0x89, 0xd2, 0xfe, 0xa7, 0x01, 0x63, 0xbd, 0x8a, 0x2c, 0xc0, 0x16, 0x4a, 0xa5, 0x82,
-	0x71, 0xaa, 0x16, 0xd9, 0x91, 0x17, 0xfc, 0x76, 0xc9, 0xa0, 0x6f, 0xfe, 0x74, 0x92, 0x80, 0x38,
-	0xba, 0x21, 0x04, 0x39, 0x55, 0x35, 0xfe, 0x83, 0xe0, 0x0f, 0x08, 0x72, 0x4a, 0xee, 0xe0, 0xe0,
-	0xba, 0xd7, 0x56, 0x75, 0xed, 0xc8, 0xfd, 0x8b, 0xb1, 0x6a, 0x3b, 0x84, 0x25, 0xbe, 0x4d, 0x3c,
-	0x02, 0xb3, 0xdd, 0xd6, 0xf1, 0xfc, 0xe5, 0x86, 0x32, 0x59, 0x6d, 0x37, 0x41, 0x8e, 0x75, 0xd8,
-	0x03, 0x86, 0xf2, 0xf8, 0xbf, 0x9b, 0xb1, 0x92, 0xb7, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x87,
-	0x8c, 0x0a, 0x5f, 0xf3, 0x01, 0x00, 0x00,
+	// 324 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x91, 0x41, 0x4b, 0xfb, 0x30,
+	0x18, 0xc6, 0x9b, 0x7f, 0xff, 0x9b, 0xf4, 0xdd, 0xbc, 0x04, 0x0f, 0x9b, 0x87, 0x6c, 0xec, 0x20,
+	0x43, 0xa4, 0x85, 0xfa, 0x05, 0x64, 0x9b, 0xe2, 0x0e, 0xc3, 0xd1, 0xa3, 0x97, 0xd2, 0xb5, 0x35,
+	0x0d, 0xda, 0x24, 0xb4, 0xd9, 0xc1, 0x6f, 0xe1, 0xc7, 0xf2, 0xb8, 0xa3, 0x20, 0x0c, 0xe9, 0xbe,
+	0x88, 0x2c, 0x99, 0x5b, 0x05, 0xd1, 0xdb, 0xf3, 0x3c, 0xbc, 0xf9, 0xbd, 0x4f, 0x12, 0xe8, 0xca,
+	0x42, 0x28, 0xe1, 0x49, 0x5f, 0x7a, 0xb1, 0xe0, 0x3c, 0xcc, 0x4b, 0x5a, 0xba, 0x3a, 0xc3, 0x27,
+	0x2a, 0xe5, 0x49, 0x5a, 0xe4, 0x8c, 0x2b, 0x93, 0xb8, 0xd2, 0x97, 0xa7, 0x67, 0x2a, 0x63, 0x45,
+	0x12, 0xca, 0xa8, 0x50, 0xcf, 0x9e, 0x39, 0x4c, 0x05, 0x15, 0x07, 0x65, 0x66, 0x07, 0x6d, 0x80,
+	0x79, 0x14, 0x3f, 0xa6, 0x6a, 0xce, 0x38, 0xad, 0x39, 0xc1, 0xe9, 0x20, 0x03, 0xc7, 0xb8, 0x59,
+	0x49, 0xf1, 0x05, 0x40, 0x9c, 0x45, 0x9c, 0xa7, 0x4f, 0x21, 0x4b, 0x3a, 0xa8, 0x8f, 0x86, 0x8d,
+	0xd1, 0x71, 0xb5, 0xee, 0x39, 0x63, 0x93, 0x4e, 0x27, 0x81, 0xb3, 0x1b, 0x98, 0x26, 0xb8, 0x0b,
+	0x76, 0x2a, 0x1e, 0x3a, 0xff, 0xf4, 0xd8, 0x51, 0xb5, 0xee, 0xd9, 0xd7, 0x77, 0x37, 0xc1, 0x36,
+	0xc3, 0x18, 0xfe, 0x27, 0x91, 0x8a, 0x3a, 0x76, 0x1f, 0x0d, 0xdb, 0x81, 0xd6, 0x83, 0x77, 0x04,
+	0x4d, 0xb3, 0x0a, 0x8f, 0xa1, 0x25, 0xb5, 0x0a, 0x25, 0xe3, 0x54, 0x2f, 0x6a, 0xf9, 0x7d, 0xf7,
+	0xa7, 0x4b, 0xba, 0x87, 0xe6, 0xb7, 0x56, 0x00, 0x72, 0xef, 0xea, 0x10, 0xc1, 0xa9, 0xae, 0xf1,
+	0x17, 0x44, 0x7c, 0x83, 0x08, 0x4e, 0xf1, 0x15, 0xec, 0xdc, 0xf6, 0xb5, 0x75, 0xdd, 0x96, 0xdf,
+	0xfb, 0x8d, 0x31, 0x2b, 0xb7, 0x08, 0x47, 0x7e, 0x99, 0x51, 0x03, 0xec, 0x72, 0x99, 0x8f, 0x26,
+	0xaf, 0x15, 0x41, 0xab, 0x8a, 0xa0, 0x8f, 0x8a, 0xa0, 0x97, 0x0d, 0xb1, 0x56, 0x1b, 0x62, 0xbd,
+	0x6d, 0x88, 0x75, 0x7f, 0x4e, 0x99, 0xca, 0x96, 0x0b, 0x37, 0x16, 0xb9, 0x77, 0x00, 0xd7, 0xe5,
+	0xfe, 0xdf, 0x17, 0x4d, 0x2d, 0x2f, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xad, 0x8c, 0xf9, 0x97,
+	0x0b, 0x02, 0x00, 0x00,
+}
+
+func (m *PacketPing) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PacketPing) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PacketPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *PacketPong) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PacketPong) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PacketPong) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *PacketMsg) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PacketMsg) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PacketMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Data) > 0 {
+		i -= len(m.Data)
+		copy(dAtA[i:], m.Data)
+		i = encodeVarintConnMsgs(dAtA, i, uint64(len(m.Data)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.EOF != 0 {
+		i = encodeVarintConnMsgs(dAtA, i, uint64(m.EOF))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.ChannelID != 0 {
+		i = encodeVarintConnMsgs(dAtA, i, uint64(m.ChannelID))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Packet) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Packet) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Packet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Sum != nil {
+		{
+			size := m.Sum.Size()
+			i -= size
+			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Packet_PacketPing) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Packet_PacketPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.PacketPing != nil {
+		{
+			size, err := m.PacketPing.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintConnMsgs(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+func (m *Packet_PacketPong) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Packet_PacketPong) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.PacketPong != nil {
+		{
+			size, err := m.PacketPong.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintConnMsgs(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	return len(dAtA) - i, nil
+}
+func (m *Packet_PacketMsg) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
+
+func (m *Packet_PacketMsg) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.PacketMsg != nil {
+		{
+			size, err := m.PacketMsg.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintConnMsgs(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x1a
+	}
+	return len(dAtA) - i, nil
+}
+func encodeVarintConnMsgs(dAtA []byte, offset int, v uint64) int {
+	offset -= sovConnMsgs(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *PacketPing) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *PacketPong) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *PacketMsg) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.ChannelID != 0 {
+		n += 1 + sovConnMsgs(uint64(m.ChannelID))
+	}
+	if m.EOF != 0 {
+		n += 1 + sovConnMsgs(uint64(m.EOF))
+	}
+	l = len(m.Data)
+	if l > 0 {
+		n += 1 + l + sovConnMsgs(uint64(l))
+	}
+	return n
+}
+
+func (m *Packet) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Sum != nil {
+		n += m.Sum.Size()
+	}
+	return n
+}
+
+func (m *Packet_PacketPing) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PacketPing != nil {
+		l = m.PacketPing.Size()
+		n += 1 + l + sovConnMsgs(uint64(l))
+	}
+	return n
+}
+func (m *Packet_PacketPong) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PacketPong != nil {
+		l = m.PacketPong.Size()
+		n += 1 + l + sovConnMsgs(uint64(l))
+	}
+	return n
+}
+func (m *Packet_PacketMsg) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PacketMsg != nil {
+		l = m.PacketMsg.Size()
+		n += 1 + l + sovConnMsgs(uint64(l))
+	}
+	return n
+}
+
+func sovConnMsgs(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozConnMsgs(x uint64) (n int) {
+	return sovConnMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *PacketPing) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowConnMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PacketPing: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PacketPing: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipConnMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PacketPong) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowConnMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PacketPong: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PacketPong: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipConnMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PacketMsg) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowConnMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PacketMsg: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PacketMsg: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ChannelID", wireType)
+			}
+			m.ChannelID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ChannelID |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field EOF", wireType)
+			}
+			m.EOF = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.EOF |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
+			if m.Data == nil {
+				m.Data = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipConnMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Packet) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowConnMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Packet: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Packet: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PacketPing", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PacketPing{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Packet_PacketPing{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PacketPong", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PacketPong{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Packet_PacketPong{v}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PacketMsg", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PacketMsg{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Packet_PacketMsg{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipConnMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthConnMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipConnMsgs(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowConnMsgs
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowConnMsgs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthConnMsgs
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupConnMsgs
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthConnMsgs
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthConnMsgs        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowConnMsgs          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupConnMsgs = fmt.Errorf("proto: unexpected end of group")
+)

proto/p2p/pex_msgs.pb.go

@@ -7,7 +7,9 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -22,9 +24,6 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type PexRequest struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *PexRequest) Reset()         { *m = PexRequest{} }
@@ -34,16 +33,25 @@ func (*PexRequest) Descriptor() ([]byte, []int) {
 	return fileDescriptor_b4d6fe6b009e47d8, []int{0}
 }
 func (m *PexRequest) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PexRequest.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PexRequest.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PexRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PexRequest) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PexRequest.Merge(m, src)
 }
 func (m *PexRequest) XXX_Size() int {
-	return xxx_messageInfo_PexRequest.Size(m)
+	return m.Size()
 }
 func (m *PexRequest) XXX_DiscardUnknown() {
 	xxx_messageInfo_PexRequest.DiscardUnknown(m)
@@ -52,10 +60,7 @@ func (m *PexRequest) XXX_DiscardUnknown() {
 var xxx_messageInfo_PexRequest proto.InternalMessageInfo
 
 type PexAddrs struct {
-	Addrs                []NetAddress `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Addrs []NetAddress `protobuf:"bytes,1,rep,name=addrs,proto3" json:"addrs"`
 }
 
 func (m *PexAddrs) Reset()         { *m = PexAddrs{} }
@@ -65,16 +70,25 @@ func (*PexAddrs) Descriptor() ([]byte, []int) {
 	return fileDescriptor_b4d6fe6b009e47d8, []int{1}
 }
 func (m *PexAddrs) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_PexAddrs.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *PexAddrs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_PexAddrs.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_PexAddrs.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *PexAddrs) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_PexAddrs.Merge(m, src)
 }
 func (m *PexAddrs) XXX_Size() int {
-	return xxx_messageInfo_PexAddrs.Size(m)
+	return m.Size()
 }
 func (m *PexAddrs) XXX_DiscardUnknown() {
 	xxx_messageInfo_PexAddrs.DiscardUnknown(m)
@@ -93,10 +107,7 @@ type Message struct {
 	// Types that are valid to be assigned to Sum:
 	//	*Message_PexRequest
 	//	*Message_PexAddrs
-	Sum                  isMessage_Sum `protobuf_oneof:"sum"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
+	Sum isMessage_Sum `protobuf_oneof:"sum"`
 }
 
 func (m *Message) Reset()         { *m = Message{} }
@@ -106,16 +117,25 @@ func (*Message) Descriptor() ([]byte, []int) {
 	return fileDescriptor_b4d6fe6b009e47d8, []int{2}
 }
 func (m *Message) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Message.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Message.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *Message) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Message.Merge(m, src)
 }
 func (m *Message) XXX_Size() int {
-	return xxx_messageInfo_Message.Size(m)
+	return m.Size()
 }
 func (m *Message) XXX_DiscardUnknown() {
 	xxx_messageInfo_Message.DiscardUnknown(m)
@@ -125,6 +145,8 @@ var xxx_messageInfo_Message proto.InternalMessageInfo
 
 type isMessage_Sum interface {
 	isMessage_Sum()
+	MarshalTo([]byte) (int, error)
+	Size() int
 }
 
 type Message_PexRequest struct {
@@ -175,7 +197,7 @@ func init() {
 func init() { proto.RegisterFile("proto/p2p/pex_msgs.proto", fileDescriptor_b4d6fe6b009e47d8) }
 
 var fileDescriptor_b4d6fe6b009e47d8 = []byte{
-	// 255 bytes of a gzipped FileDescriptorProto
+	// 280 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x2f, 0x30, 0x2a, 0xd0, 0x2f, 0x48, 0xad, 0x88, 0xcf, 0x2d, 0x4e, 0x2f, 0xd6, 0x03,
 	0x0b, 0x09, 0x89, 0x94, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44, 0xf4,
@@ -189,7 +211,569 @@ var fileDescriptor_b4d6fe6b009e47d8 = []byte{
 	0x72, 0xe6, 0xe2, 0x06, 0x79, 0xa5, 0x08, 0x62, 0x89, 0x04, 0xa3, 0x02, 0x23, 0x6e, 0xf3, 0x10,
 	0x8e, 0xf1, 0x60, 0x08, 0xe2, 0x2a, 0x80, 0xf3, 0x84, 0x6c, 0xb9, 0x38, 0x41, 0x86, 0x40, 0x9c,
 	0xc4, 0x04, 0x36, 0x42, 0x0e, 0xa7, 0x11, 0x60, 0x1f, 0x78, 0x30, 0x04, 0x71, 0x14, 0x40, 0xd9,
-	0x4e, 0xac, 0x5c, 0xcc, 0xc5, 0xa5, 0xb9, 0x4e, 0x3a, 0x51, 0x5a, 0xe9, 0x99, 0x25, 0x19, 0xa5,
-	0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x08, 0xed, 0xc8, 0x4c, 0x78, 0x80, 0x26, 0xb1, 0x81, 0x99,
-	0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x73, 0x54, 0xb6, 0xcc, 0x94, 0x01, 0x00, 0x00,
+	0x4e, 0xac, 0x5c, 0xcc, 0xc5, 0xa5, 0xb9, 0x4e, 0x2e, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24,
+	0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78,
+	0x2c, 0xc7, 0x10, 0xa5, 0x95, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f,
+	0x30, 0x16, 0x99, 0x09, 0x0f, 0xe8, 0x24, 0x36, 0x30, 0xd3, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff,
+	0xb1, 0x53, 0x9c, 0x92, 0xac, 0x01, 0x00, 0x00,
+}
+
+func (m *PexRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PexRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	return len(dAtA) - i, nil
+}
+
+func (m *PexAddrs) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PexAddrs) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *PexAddrs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Addrs) > 0 {
+		for iNdEx := len(m.Addrs) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Addrs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintPexMsgs(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Message) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Message) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Message) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Sum != nil {
+		{
+			size := m.Sum.Size()
+			i -= size
+			if _, err := m.Sum.MarshalTo(dAtA[i:]); err != nil {
+				return 0, err
+			}
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Message_PexRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Message_PexRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.PexRequest != nil {
+		{
+			size, err := m.PexRequest.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPexMsgs(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+func (m *Message_PexAddrs) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Message_PexAddrs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	if m.PexAddrs != nil {
+		{
+			size, err := m.PexAddrs.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintPexMsgs(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	return len(dAtA) - i, nil
+}
+func encodeVarintPexMsgs(dAtA []byte, offset int, v uint64) int {
+	offset -= sovPexMsgs(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *PexRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	return n
+}
+
+func (m *PexAddrs) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Addrs) > 0 {
+		for _, e := range m.Addrs {
+			l = e.Size()
+			n += 1 + l + sovPexMsgs(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Message) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Sum != nil {
+		n += m.Sum.Size()
+	}
+	return n
+}
+
+func (m *Message_PexRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PexRequest != nil {
+		l = m.PexRequest.Size()
+		n += 1 + l + sovPexMsgs(uint64(l))
+	}
+	return n
+}
+func (m *Message_PexAddrs) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.PexAddrs != nil {
+		l = m.PexAddrs.Size()
+		n += 1 + l + sovPexMsgs(uint64(l))
+	}
+	return n
+}
+
+func sovPexMsgs(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozPexMsgs(x uint64) (n int) {
+	return sovPexMsgs(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 }
+func (m *PexRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPexMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PexRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PexRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPexMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PexAddrs) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPexMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PexAddrs: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PexAddrs: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Addrs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPexMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Addrs = append(m.Addrs, NetAddress{})
+			if err := m.Addrs[len(m.Addrs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPexMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Message) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowPexMsgs
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Message: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Message: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PexRequest", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPexMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PexRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Message_PexRequest{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PexAddrs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowPexMsgs
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PexAddrs{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Sum = &Message_PexAddrs{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipPexMsgs(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthPexMsgs
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipPexMsgs(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowPexMsgs
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowPexMsgs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowPexMsgs
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthPexMsgs
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupPexMsgs
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthPexMsgs
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthPexMsgs        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowPexMsgs          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupPexMsgs = fmt.Errorf("proto: unexpected end of group")
+)

proto/privval/types.pb.go

@@ -8,7 +8,9 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	keys "github.com/tendermint/tendermint/proto/crypto/keys"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -24,13 +26,10 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 // FilePVKey stores the immutable part of PrivValidator.
 type FilePVKey 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"`
-	PrivKey              keys.PrivateKey `protobuf:"bytes,3,opt,name=priv_key,json=privKey,proto3" json:"priv_key"`
-	FilePath             string          `protobuf:"bytes,4,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
-	XXX_unrecognized     []byte          `json:"-"`
-	XXX_sizecache        int32           `json:"-"`
+	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"`
+	PrivKey  keys.PrivateKey `protobuf:"bytes,3,opt,name=priv_key,json=privKey,proto3" json:"priv_key"`
+	FilePath string          `protobuf:"bytes,4,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
 }
 
 func (m *FilePVKey) Reset()         { *m = FilePVKey{} }
@@ -40,16 +39,25 @@ func (*FilePVKey) Descriptor() ([]byte, []int) {
 	return fileDescriptor_a9d74c406df3ad93, []int{0}
 }
 func (m *FilePVKey) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FilePVKey.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *FilePVKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FilePVKey.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_FilePVKey.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *FilePVKey) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilePVKey.Merge(m, src)
 }
 func (m *FilePVKey) XXX_Size() int {
-	return xxx_messageInfo_FilePVKey.Size(m)
+	return m.Size()
 }
 func (m *FilePVKey) XXX_DiscardUnknown() {
 	xxx_messageInfo_FilePVKey.DiscardUnknown(m)
@@ -87,15 +95,12 @@ func (m *FilePVKey) GetFilePath() string {
 
 // FilePVLastSignState stores the mutable part of PrivValidator.
 type FilePVLastSignState struct {
-	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
-	Round                int64    `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
-	Step                 int32    `protobuf:"varint,3,opt,name=step,proto3" json:"step,omitempty"`
-	Signature            []byte   `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
-	SignBytes            []byte   `protobuf:"bytes,5,opt,name=sign_bytes,json=signBytes,proto3" json:"sign_bytes,omitempty"`
-	FilePath             string   `protobuf:"bytes,6,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Height    int64  `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	Round     int64  `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
+	Step      int32  `protobuf:"varint,3,opt,name=step,proto3" json:"step,omitempty"`
+	Signature []byte `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
+	SignBytes []byte `protobuf:"bytes,5,opt,name=sign_bytes,json=signBytes,proto3" json:"sign_bytes,omitempty"`
+	FilePath  string `protobuf:"bytes,6,opt,name=file_path,json=filePath,proto3" json:"file_path,omitempty"`
 }
 
 func (m *FilePVLastSignState) Reset()         { *m = FilePVLastSignState{} }
@@ -105,16 +110,25 @@ func (*FilePVLastSignState) Descriptor() ([]byte, []int) {
 	return fileDescriptor_a9d74c406df3ad93, []int{1}
 }
 func (m *FilePVLastSignState) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_FilePVLastSignState.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *FilePVLastSignState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_FilePVLastSignState.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_FilePVLastSignState.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *FilePVLastSignState) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_FilePVLastSignState.Merge(m, src)
 }
 func (m *FilePVLastSignState) XXX_Size() int {
-	return xxx_messageInfo_FilePVLastSignState.Size(m)
+	return m.Size()
 }
 func (m *FilePVLastSignState) XXX_DiscardUnknown() {
 	xxx_messageInfo_FilePVLastSignState.DiscardUnknown(m)
@@ -172,28 +186,694 @@ func init() {
 func init() { proto.RegisterFile("proto/privval/types.proto", fileDescriptor_a9d74c406df3ad93) }
 
 var fileDescriptor_a9d74c406df3ad93 = []byte{
-	// 357 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x4d, 0x6e, 0xe2, 0x30,
-	0x14, 0x9e, 0x0c, 0x10, 0x88, 0x87, 0x95, 0x67, 0x34, 0xca, 0x30, 0x45, 0x45, 0x2c, 0xda, 0xac,
-	0x92, 0xaa, 0xbd, 0x01, 0x0b, 0xa4, 0x8a, 0x2e, 0x50, 0x90, 0xba, 0xe8, 0x26, 0x72, 0xc8, 0x6b,
-	0x62, 0x11, 0x12, 0xcb, 0x7e, 0x41, 0xf2, 0xb1, 0x7a, 0x8b, 0x5e, 0xa0, 0xdb, 0x9e, 0xa5, 0xb2,
-	0x43, 0x15, 0x50, 0x17, 0xdd, 0xbd, 0xef, 0xf3, 0xf3, 0xf7, 0x63, 0x99, 0xfc, 0x13, 0xb2, 0xc6,
-	0x3a, 0x12, 0x92, 0x1f, 0x0e, 0xac, 0x8c, 0x50, 0x0b, 0x50, 0xa1, 0xe5, 0xa8, 0x8f, 0x50, 0x65,
-	0x20, 0xf7, 0xbc, 0xc2, 0x96, 0x09, 0x8f, 0x5b, 0x93, 0x2b, 0x2c, 0xb8, 0xcc, 0x12, 0xc1, 0x24,
-	0xea, 0xa8, 0x15, 0xc8, 0xeb, 0xbc, 0xee, 0xa6, 0x76, 0x7f, 0x32, 0x6d, 0x99, 0xad, 0xd4, 0x02,
-	0xeb, 0x68, 0x07, 0x5a, 0x9d, 0x1a, 0xcc, 0xdf, 0x1c, 0xe2, 0x2d, 0x79, 0x09, 0xeb, 0xc7, 0x15,
-	0x68, 0xea, 0x93, 0x21, 0xcb, 0x32, 0x09, 0x4a, 0xf9, 0xce, 0xcc, 0x09, 0xc6, 0xf1, 0x27, 0xa4,
-	0x4b, 0x32, 0x14, 0x4d, 0x9a, 0xec, 0x40, 0xfb, 0x3f, 0x67, 0x4e, 0xf0, 0xeb, 0xf6, 0x3a, 0xfc,
-	0x12, 0xad, 0xf5, 0x08, 0x8d, 0x47, 0xb8, 0x6e, 0xd2, 0x92, 0x6f, 0x57, 0xa0, 0x17, 0xfd, 0xd7,
-	0xf7, 0xcb, 0x1f, 0xb1, 0x2b, 0x9a, 0xd4, 0x38, 0xdc, 0x93, 0x91, 0x69, 0x60, 0x85, 0x7a, 0x56,
-	0x28, 0xf8, 0x46, 0x48, 0xf2, 0x03, 0x43, 0xe8, 0x94, 0x86, 0xe6, 0xbe, 0x91, 0xfa, 0x4f, 0xbc,
-	0x67, 0x5e, 0x42, 0x22, 0x18, 0x16, 0x7e, 0x7f, 0xe6, 0x04, 0x5e, 0x3c, 0x32, 0xc4, 0x9a, 0x61,
-	0x31, 0x7f, 0x71, 0xc8, 0xef, 0xb6, 0xd7, 0x03, 0x53, 0xb8, 0xe1, 0x79, 0xb5, 0x41, 0x86, 0x40,
-	0xff, 0x12, 0xb7, 0x00, 0x9e, 0x17, 0x68, 0x0b, 0xf6, 0xe2, 0x23, 0xa2, 0x7f, 0xc8, 0x40, 0xd6,
-	0x4d, 0x95, 0xd9, 0x76, 0xbd, 0xb8, 0x05, 0x94, 0x92, 0xbe, 0x42, 0x10, 0x36, 0xe9, 0x20, 0xb6,
-	0x33, 0xbd, 0x20, 0x9e, 0xe2, 0x79, 0xc5, 0xb0, 0x91, 0x60, 0x6d, 0xc7, 0x71, 0x47, 0xd0, 0x29,
-	0x21, 0x06, 0x24, 0xa9, 0x46, 0x50, 0xfe, 0xa0, 0x3b, 0x5e, 0x18, 0xe2, 0x3c, 0xb3, 0x7b, 0x9e,
-	0x79, 0x71, 0xf3, 0x14, 0xe6, 0x1c, 0x8b, 0x26, 0x0d, 0xb7, 0xf5, 0x3e, 0xea, 0x5e, 0xe5, 0x74,
-	0x3c, 0xfb, 0x2a, 0xa9, 0x6b, 0xe1, 0xdd, 0x47, 0x00, 0x00, 0x00, 0xff, 0xff, 0xf3, 0xa3, 0x78,
-	0xe9, 0x42, 0x02, 0x00, 0x00,
+	// 385 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x4d, 0x8e, 0xd3, 0x30,
+	0x14, 0x8e, 0x69, 0x9b, 0x4e, 0xcc, 0xac, 0x0c, 0x42, 0x61, 0x60, 0x42, 0x35, 0x0b, 0xc8, 0x2a,
+	0x91, 0xe0, 0x06, 0x5d, 0x8c, 0x40, 0xc3, 0xa2, 0xca, 0x48, 0x2c, 0xd8, 0x44, 0x4e, 0xf3, 0x48,
+	0xac, 0xc9, 0x24, 0x96, 0xfd, 0x52, 0xc9, 0xb7, 0xe0, 0x2a, 0xdc, 0x62, 0x96, 0xdd, 0x20, 0xb1,
+	0x42, 0xa8, 0xbd, 0x08, 0xb2, 0x53, 0x94, 0x56, 0x2c, 0x66, 0xf7, 0xbe, 0xcf, 0xcf, 0xdf, 0x8f,
+	0x65, 0xfa, 0x52, 0xaa, 0x0e, 0xbb, 0x54, 0x2a, 0xb1, 0xd9, 0xf0, 0x26, 0x45, 0x23, 0x41, 0x27,
+	0x8e, 0x63, 0x21, 0x42, 0x5b, 0x82, 0xba, 0x17, 0x2d, 0x0e, 0x4c, 0x72, 0xd8, 0xba, 0x78, 0x8b,
+	0xb5, 0x50, 0x65, 0x2e, 0xb9, 0x42, 0x93, 0x0e, 0x02, 0x55, 0x57, 0x75, 0xe3, 0x34, 0xec, 0x5f,
+	0x5c, 0x0e, 0xcc, 0x5a, 0x19, 0x89, 0x5d, 0x7a, 0x07, 0x46, 0x1f, 0x1b, 0x5c, 0xfd, 0x24, 0x34,
+	0xb8, 0x16, 0x0d, 0xac, 0xbe, 0xdc, 0x80, 0x61, 0x21, 0x9d, 0xf3, 0xb2, 0x54, 0xa0, 0x75, 0x48,
+	0x16, 0x24, 0x3e, 0xcf, 0xfe, 0x41, 0x76, 0x4d, 0xe7, 0xb2, 0x2f, 0xf2, 0x3b, 0x30, 0xe1, 0x93,
+	0x05, 0x89, 0x9f, 0xbe, 0x7f, 0x97, 0xfc, 0x17, 0x6d, 0xf0, 0x48, 0xac, 0x47, 0xb2, 0xea, 0x8b,
+	0x46, 0xac, 0x6f, 0xc0, 0x2c, 0xa7, 0x0f, 0xbf, 0xdf, 0x78, 0x99, 0x2f, 0xfb, 0xc2, 0x3a, 0x7c,
+	0xa2, 0x67, 0xb6, 0x81, 0x13, 0x9a, 0x38, 0xa1, 0xf8, 0x11, 0x21, 0x25, 0x36, 0x1c, 0x61, 0x54,
+	0x9a, 0xdb, 0xfb, 0x56, 0xea, 0x15, 0x0d, 0xbe, 0x89, 0x06, 0x72, 0xc9, 0xb1, 0x0e, 0xa7, 0x0b,
+	0x12, 0x07, 0xd9, 0x99, 0x25, 0x56, 0x1c, 0xeb, 0xab, 0x1f, 0x84, 0x3e, 0x1b, 0x7a, 0x7d, 0xe6,
+	0x1a, 0x6f, 0x45, 0xd5, 0xde, 0x22, 0x47, 0x60, 0x2f, 0xa8, 0x5f, 0x83, 0xa8, 0x6a, 0x74, 0x05,
+	0x27, 0xd9, 0x01, 0xb1, 0xe7, 0x74, 0xa6, 0xba, 0xbe, 0x2d, 0x5d, 0xbb, 0x49, 0x36, 0x00, 0xc6,
+	0xe8, 0x54, 0x23, 0x48, 0x97, 0x74, 0x96, 0xb9, 0x99, 0xbd, 0xa6, 0x81, 0x16, 0x55, 0xcb, 0xb1,
+	0x57, 0xe0, 0x6c, 0xcf, 0xb3, 0x91, 0x60, 0x97, 0x94, 0x5a, 0x90, 0x17, 0x06, 0x41, 0x87, 0xb3,
+	0xf1, 0x78, 0x69, 0x89, 0xd3, 0xcc, 0xfe, 0x69, 0xe6, 0xe5, 0xc7, 0x87, 0x5d, 0x44, 0xb6, 0xbb,
+	0x88, 0xfc, 0xd9, 0x45, 0xe4, 0xfb, 0x3e, 0xf2, 0xb6, 0xfb, 0xc8, 0xfb, 0xb5, 0x8f, 0xbc, 0xaf,
+	0x49, 0x25, 0xb0, 0xee, 0x8b, 0x64, 0xdd, 0xdd, 0xa7, 0xe3, 0x6b, 0x1d, 0x8f, 0x27, 0x5f, 0xa8,
+	0xf0, 0x1d, 0xfc, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0xe5, 0xc6, 0x2f, 0x79, 0x5a, 0x02, 0x00,
+	0x00,
+}
+
+func (m *FilePVKey) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *FilePVKey) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *FilePVKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.FilePath) > 0 {
+		i -= len(m.FilePath)
+		copy(dAtA[i:], m.FilePath)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.FilePath)))
+		i--
+		dAtA[i] = 0x22
+	}
+	{
+		size, err := m.PrivKey.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintTypes(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	{
+		size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintTypes(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *FilePVLastSignState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *FilePVLastSignState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
 }
+
+func (m *FilePVLastSignState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.FilePath) > 0 {
+		i -= len(m.FilePath)
+		copy(dAtA[i:], m.FilePath)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.FilePath)))
+		i--
+		dAtA[i] = 0x32
+	}
+	if len(m.SignBytes) > 0 {
+		i -= len(m.SignBytes)
+		copy(dAtA[i:], m.SignBytes)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.SignBytes)))
+		i--
+		dAtA[i] = 0x2a
+	}
+	if len(m.Signature) > 0 {
+		i -= len(m.Signature)
+		copy(dAtA[i:], m.Signature)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Signature)))
+		i--
+		dAtA[i] = 0x22
+	}
+	if m.Step != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Step))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.Round != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Round))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Height != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
+	offset -= sovTypes(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *FilePVKey) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = m.PubKey.Size()
+	n += 1 + l + sovTypes(uint64(l))
+	l = m.PrivKey.Size()
+	n += 1 + l + sovTypes(uint64(l))
+	l = len(m.FilePath)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
+func (m *FilePVLastSignState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Height != 0 {
+		n += 1 + sovTypes(uint64(m.Height))
+	}
+	if m.Round != 0 {
+		n += 1 + sovTypes(uint64(m.Round))
+	}
+	if m.Step != 0 {
+		n += 1 + sovTypes(uint64(m.Step))
+	}
+	l = len(m.Signature)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.SignBytes)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	l = len(m.FilePath)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
+	return n
+}
+
+func sovTypes(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTypes(x uint64) (n int) {
+	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *FilePVKey) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: FilePVKey: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FilePVKey: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
+			if m.Address == nil {
+				m.Address = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrivKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PrivKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FilePath = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *FilePVLastSignState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: FilePVLastSignState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: FilePVLastSignState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			m.Height = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Height |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
+			}
+			m.Round = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Round |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
+			}
+			m.Step = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Step |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
+			if m.Signature == nil {
+				m.Signature = []byte{}
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SignBytes", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SignBytes = append(m.SignBytes[:0], dAtA[iNdEx:postIndex]...)
+			if m.SignBytes == nil {
+				m.SignBytes = []byte{}
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field FilePath", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.FilePath = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipTypes(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthTypes
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupTypes
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthTypes
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
+)

proto/store/types.pb.go

@@ -6,7 +6,9 @@ package store
 import (
 	fmt "fmt"
 	proto "github.com/gogo/protobuf/proto"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -21,11 +23,8 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type BlockStoreState struct {
-	Base                 int64    `protobuf:"varint,1,opt,name=base,proto3" json:"base,omitempty"`
-	Height               int64    `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Base   int64 `protobuf:"varint,1,opt,name=base,proto3" json:"base,omitempty"`
+	Height int64 `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
 }
 
 func (m *BlockStoreState) Reset()         { *m = BlockStoreState{} }
@@ -35,16 +34,25 @@ func (*BlockStoreState) Descriptor() ([]byte, []int) {
 	return fileDescriptor_45a8553e38baf31c, []int{0}
 }
 func (m *BlockStoreState) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_BlockStoreState.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *BlockStoreState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_BlockStoreState.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_BlockStoreState.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *BlockStoreState) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_BlockStoreState.Merge(m, src)
 }
 func (m *BlockStoreState) XXX_Size() int {
-	return xxx_messageInfo_BlockStoreState.Size(m)
+	return m.Size()
 }
 func (m *BlockStoreState) XXX_DiscardUnknown() {
 	xxx_messageInfo_BlockStoreState.DiscardUnknown(m)
@@ -73,14 +81,257 @@ func init() {
 func init() { proto.RegisterFile("proto/store/types.proto", fileDescriptor_45a8553e38baf31c) }
 
 var fileDescriptor_45a8553e38baf31c = []byte{
-	// 138 bytes of a gzipped FileDescriptorProto
+	// 164 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2f, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x2f, 0x2e, 0xc9, 0x2f, 0x4a, 0xd5, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x03, 0x8b,
 	0x08, 0x89, 0x95, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44, 0xf4, 0xc0,
 	0x6a, 0x94, 0x6c, 0xb9, 0xf8, 0x9d, 0x72, 0xf2, 0x93, 0xb3, 0x83, 0x41, 0xbc, 0xe0, 0x92, 0xc4,
 	0x92, 0x54, 0x21, 0x21, 0x2e, 0x96, 0xa4, 0xc4, 0xe2, 0x54, 0x09, 0x46, 0x05, 0x46, 0x0d, 0xe6,
 	0x20, 0x30, 0x5b, 0x48, 0x8c, 0x8b, 0x2d, 0x23, 0x35, 0x33, 0x3d, 0xa3, 0x44, 0x82, 0x09, 0x2c,
-	0x0a, 0xe5, 0x39, 0xe9, 0x45, 0xe9, 0xa4, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7,
-	0xea, 0x23, 0xec, 0x40, 0x66, 0x22, 0x39, 0x29, 0x89, 0x0d, 0xcc, 0x31, 0x06, 0x04, 0x00, 0x00,
-	0xff, 0xff, 0xb2, 0x6b, 0x69, 0x83, 0xa8, 0x00, 0x00, 0x00,
+	0x0a, 0xe5, 0x39, 0xb9, 0x9d, 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, 0x4e,
+	0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0xc2, 0x6e, 0x64, 0x26, 0x92,
+	0x53, 0x93, 0xd8, 0xc0, 0x1c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0x1d, 0xd0, 0xc2, 0xbe,
+	0xc0, 0x00, 0x00, 0x00,
+}
+
+func (m *BlockStoreState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *BlockStoreState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *BlockStoreState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.Height != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Height))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Base != 0 {
+		i = encodeVarintTypes(dAtA, i, uint64(m.Base))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
+	offset -= sovTypes(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *BlockStoreState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Base != 0 {
+		n += 1 + sovTypes(uint64(m.Base))
+	}
+	if m.Height != 0 {
+		n += 1 + sovTypes(uint64(m.Height))
+	}
+	return n
+}
+
+func sovTypes(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTypes(x uint64) (n int) {
+	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *BlockStoreState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: BlockStoreState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: BlockStoreState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Base", wireType)
+			}
+			m.Base = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Base |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			m.Height = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Height |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipTypes(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
 }
+func skipTypes(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowTypes
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthTypes
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupTypes
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthTypes
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
+)

proto/types/block.pb.go

@@ -7,7 +7,9 @@ import (
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -22,13 +24,10 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type Block struct {
-	Header               Header       `protobuf:"bytes,1,opt,name=header,proto3" json:"header"`
-	Data                 Data         `protobuf:"bytes,2,opt,name=data,proto3" json:"data"`
-	Evidence             EvidenceData `protobuf:"bytes,3,opt,name=evidence,proto3" json:"evidence"`
-	LastCommit           *Commit      `protobuf:"bytes,4,opt,name=last_commit,json=lastCommit,proto3" json:"last_commit,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Header     Header       `protobuf:"bytes,1,opt,name=header,proto3" json:"header"`
+	Data       Data         `protobuf:"bytes,2,opt,name=data,proto3" json:"data"`
+	Evidence   EvidenceData `protobuf:"bytes,3,opt,name=evidence,proto3" json:"evidence"`
+	LastCommit *Commit      `protobuf:"bytes,4,opt,name=last_commit,json=lastCommit,proto3" json:"last_commit,omitempty"`
 }
 
 func (m *Block) Reset()         { *m = Block{} }
@@ -38,16 +37,25 @@ func (*Block) Descriptor() ([]byte, []int) {
 	return fileDescriptor_3aa007336dea920d, []int{0}
 }
 func (m *Block) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Block.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Block.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Block.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *Block) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Block.Merge(m, src)
 }
 func (m *Block) XXX_Size() int {
-	return xxx_messageInfo_Block.Size(m)
+	return m.Size()
 }
 func (m *Block) XXX_DiscardUnknown() {
 	xxx_messageInfo_Block.DiscardUnknown(m)
@@ -90,7 +98,7 @@ func init() {
 func init() { proto.RegisterFile("proto/types/block.proto", fileDescriptor_3aa007336dea920d) }
 
 var fileDescriptor_3aa007336dea920d = []byte{
-	// 248 bytes of a gzipped FileDescriptorProto
+	// 273 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2f, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x4f, 0xca, 0xc9, 0x4f, 0xce, 0xd6, 0x03, 0x8b,
 	0x08, 0x89, 0x95, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44, 0xf4, 0xc0,
@@ -104,7 +112,383 @@ var fileDescriptor_3aa007336dea920d = []byte{
 	0x1b, 0x17, 0x07, 0xcc, 0x45, 0x12, 0xcc, 0x60, 0xbd, 0x2a, 0xb8, 0xf4, 0xba, 0x42, 0xd5, 0x21,
 	0x99, 0x01, 0xd7, 0x2b, 0x64, 0xcf, 0xc5, 0x9d, 0x93, 0x58, 0x5c, 0x12, 0x9f, 0x9c, 0x9f, 0x9b,
 	0x9b, 0x59, 0x22, 0xc1, 0x82, 0xdf, 0x0b, 0xce, 0x60, 0x55, 0x41, 0x5c, 0x20, 0x2d, 0x10, 0xb6,
-	0x93, 0x5e, 0x94, 0x4e, 0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x3e, 0x42,
-	0x1f, 0x32, 0x13, 0x29, 0x1c, 0x93, 0xd8, 0xc0, 0x1c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0x46, 0x9a, 0x1b, 0xf7, 0xcf, 0x01, 0x00, 0x00,
+	0x93, 0xdb, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1,
+	0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0xe9, 0xa4, 0x67, 0x96,
+	0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x23, 0xcc, 0x43, 0x66, 0x22, 0x85, 0x6f, 0x12,
+	0x1b, 0x98, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0x5f, 0x42, 0x07, 0x4a, 0xe7, 0x01, 0x00,
+	0x00,
+}
+
+func (m *Block) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Block) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Block) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.LastCommit != nil {
+		{
+			size, err := m.LastCommit.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintBlock(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x22
+	}
+	{
+		size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintBlock(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x1a
+	{
+		size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintBlock(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	{
+		size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintBlock(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintBlock(dAtA []byte, offset int, v uint64) int {
+	offset -= sovBlock(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
 }
+func (m *Block) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = m.Header.Size()
+	n += 1 + l + sovBlock(uint64(l))
+	l = m.Data.Size()
+	n += 1 + l + sovBlock(uint64(l))
+	l = m.Evidence.Size()
+	n += 1 + l + sovBlock(uint64(l))
+	if m.LastCommit != nil {
+		l = m.LastCommit.Size()
+		n += 1 + l + sovBlock(uint64(l))
+	}
+	return n
+}
+
+func sovBlock(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozBlock(x uint64) (n int) {
+	return sovBlock(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Block) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowBlock
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Block: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Block: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBlock
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthBlock
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthBlock
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBlock
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthBlock
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthBlock
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Evidence", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBlock
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthBlock
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthBlock
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LastCommit", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowBlock
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthBlock
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthBlock
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.LastCommit == nil {
+				m.LastCommit = &Commit{}
+			}
+			if err := m.LastCommit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipBlock(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthBlock
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthBlock
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipBlock(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowBlock
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowBlock
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowBlock
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthBlock
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupBlock
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthBlock
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthBlock        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowBlock          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupBlock = fmt.Errorf("proto: unexpected end of group")
+)

proto/types/events.pb.go

@@ -6,7 +6,9 @@ package types
 import (
 	fmt "fmt"
 	proto "github.com/gogo/protobuf/proto"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -21,12 +23,9 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type EventDataRoundState struct {
-	Height               int64    `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
-	Round                int32    `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
-	Step                 string   `protobuf:"bytes,3,opt,name=step,proto3" json:"step,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Height int64  `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	Round  int32  `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
+	Step   string `protobuf:"bytes,3,opt,name=step,proto3" json:"step,omitempty"`
 }
 
 func (m *EventDataRoundState) Reset()         { *m = EventDataRoundState{} }
@@ -36,16 +35,25 @@ func (*EventDataRoundState) Descriptor() ([]byte, []int) {
 	return fileDescriptor_1bb9bdae76a076d6, []int{0}
 }
 func (m *EventDataRoundState) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_EventDataRoundState.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *EventDataRoundState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_EventDataRoundState.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_EventDataRoundState.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *EventDataRoundState) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_EventDataRoundState.Merge(m, src)
 }
 func (m *EventDataRoundState) XXX_Size() int {
-	return xxx_messageInfo_EventDataRoundState.Size(m)
+	return m.Size()
 }
 func (m *EventDataRoundState) XXX_DiscardUnknown() {
 	xxx_messageInfo_EventDataRoundState.DiscardUnknown(m)
@@ -81,7 +89,7 @@ func init() {
 func init() { proto.RegisterFile("proto/types/events.proto", fileDescriptor_1bb9bdae76a076d6) }
 
 var fileDescriptor_1bb9bdae76a076d6 = []byte{
-	// 162 bytes of a gzipped FileDescriptorProto
+	// 188 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x28, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x4f, 0x2d, 0x4b, 0xcd, 0x2b, 0x29, 0xd6, 0x03,
 	0x0b, 0x09, 0x89, 0x95, 0xa4, 0xe6, 0xa5, 0xa4, 0x16, 0xe5, 0x66, 0xe6, 0x95, 0x40, 0x44, 0xf4,
@@ -89,8 +97,293 @@ var fileDescriptor_1bb9bdae76a076d6 = []byte{
 	0xf3, 0x52, 0x82, 0x4b, 0x12, 0x4b, 0x52, 0x85, 0xc4, 0xb8, 0xd8, 0x32, 0x52, 0x33, 0xd3, 0x33,
 	0x4a, 0x24, 0x18, 0x15, 0x18, 0x35, 0x98, 0x83, 0xa0, 0x3c, 0x21, 0x11, 0x2e, 0xd6, 0x22, 0x90,
 	0x2a, 0x09, 0x26, 0x05, 0x46, 0x0d, 0xd6, 0x20, 0x08, 0x47, 0x48, 0x88, 0x8b, 0xa5, 0xb8, 0x24,
-	0xb5, 0x40, 0x82, 0x59, 0x81, 0x51, 0x83, 0x33, 0x08, 0xcc, 0x76, 0xd2, 0x8b, 0xd2, 0x49, 0xcf,
-	0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x47, 0xd8, 0x8e, 0xcc, 0x44, 0x72, 0x6d,
-	0x12, 0x1b, 0x98, 0x63, 0x0c, 0x08, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x3c, 0x7d, 0xad, 0xc3, 0x00,
-	0x00, 0x00,
+	0xb5, 0x40, 0x82, 0x59, 0x81, 0x51, 0x83, 0x33, 0x08, 0xcc, 0x76, 0x72, 0x3b, 0xf1, 0x48, 0x8e,
+	0xf1, 0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58,
+	0x8e, 0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0x9d, 0xf4, 0xcc, 0x92, 0x8c, 0xd2, 0x24, 0xbd, 0xe4,
+	0xfc, 0x5c, 0x7d, 0x84, 0xab, 0x90, 0x99, 0x48, 0xbe, 0x48, 0x62, 0x03, 0x73, 0x8c, 0x01, 0x01,
+	0x00, 0x00, 0xff, 0xff, 0x66, 0xcc, 0x41, 0x01, 0xdb, 0x00, 0x00, 0x00,
+}
+
+func (m *EventDataRoundState) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *EventDataRoundState) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EventDataRoundState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if len(m.Step) > 0 {
+		i -= len(m.Step)
+		copy(dAtA[i:], m.Step)
+		i = encodeVarintEvents(dAtA, i, uint64(len(m.Step)))
+		i--
+		dAtA[i] = 0x1a
+	}
+	if m.Round != 0 {
+		i = encodeVarintEvents(dAtA, i, uint64(m.Round))
+		i--
+		dAtA[i] = 0x10
+	}
+	if m.Height != 0 {
+		i = encodeVarintEvents(dAtA, i, uint64(m.Height))
+		i--
+		dAtA[i] = 0x8
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
+	offset -= sovEvents(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *EventDataRoundState) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.Height != 0 {
+		n += 1 + sovEvents(uint64(m.Height))
+	}
+	if m.Round != 0 {
+		n += 1 + sovEvents(uint64(m.Round))
+	}
+	l = len(m.Step)
+	if l > 0 {
+		n += 1 + l + sovEvents(uint64(l))
+	}
+	return n
 }
+
+func sovEvents(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozEvents(x uint64) (n int) {
+	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *EventDataRoundState) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowEvents
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: EventDataRoundState: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EventDataRoundState: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
+			}
+			m.Height = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvents
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Height |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType)
+			}
+			m.Round = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvents
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Round |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Step", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEvents
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthEvents
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthEvents
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Step = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipEvents(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthEvents
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthEvents
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipEvents(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowEvents
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowEvents
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowEvents
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthEvents
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupEvents
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthEvents
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
+)

proto/types/types.pb.go

@@ -8,7 +8,6 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
-	golang_proto "github.com/golang/protobuf/proto"
 	_ "github.com/golang/protobuf/ptypes/timestamp"
 	merkle "github.com/tendermint/tendermint/proto/crypto/merkle"
 	bits "github.com/tendermint/tendermint/proto/libs/bits"
@@ -21,7 +20,6 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
-var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 var _ = time.Kitchen
@@ -90,11 +88,8 @@ func (SignedMsgType) EnumDescriptor() ([]byte, []int) {
 
 // PartsetHeader
 type PartSetHeader struct {
-	Total                uint32   `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
-	Hash                 []byte   `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Total uint32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
+	Hash  []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
 }
 
 func (m *PartSetHeader) Reset()         { *m = PartSetHeader{} }
@@ -145,12 +140,9 @@ 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.SimpleProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof"`
-	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
-	XXX_unrecognized     []byte             `json:"-"`
-	XXX_sizecache        int32              `json:"-"`
+	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.SimpleProof `protobuf:"bytes,3,opt,name=proof,proto3" json:"proof"`
 }
 
 func (m *Part) Reset()         { *m = Part{} }
@@ -209,11 +201,8 @@ func (m *Part) GetProof() merkle.SimpleProof {
 
 // BlockID
 type BlockID struct {
-	Hash                 []byte        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
-	PartsHeader          PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
+	Hash        []byte        `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+	PartsHeader PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"`
 }
 
 func (m *BlockID) Reset()         { *m = BlockID{} }
@@ -282,11 +271,8 @@ type Header struct {
 	AppHash            []byte `protobuf:"bytes,11,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
 	LastResultsHash    []byte `protobuf:"bytes,12,opt,name=last_results_hash,json=lastResultsHash,proto3" json:"last_results_hash,omitempty"`
 	// consensus info
-	EvidenceHash         []byte   `protobuf:"bytes,13,opt,name=evidence_hash,json=evidenceHash,proto3" json:"evidence_hash,omitempty"`
-	ProposerAddress      []byte   `protobuf:"bytes,14,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	EvidenceHash    []byte `protobuf:"bytes,13,opt,name=evidence_hash,json=evidenceHash,proto3" json:"evidence_hash,omitempty"`
+	ProposerAddress []byte `protobuf:"bytes,14,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"`
 }
 
 func (m *Header) Reset()         { *m = Header{} }
@@ -427,10 +413,7 @@ type Data struct {
 	// This means that block.AppHash does not include these txs.
 	Txs [][]byte `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
 	// Volatile
-	Hash                 []byte   `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
 }
 
 func (m *Data) Reset()         { *m = Data{} }
@@ -483,17 +466,14 @@ func (m *Data) GetHash() []byte {
 // Vote represents a prevote, precommit, or commit vote from validators for
 // consensus.
 type Vote struct {
-	Type                 SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
-	Height               int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
-	Round                int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
-	BlockID              BlockID       `protobuf:"bytes,4,opt,name=block_id,json=blockId,proto3" json:"block_id"`
-	Timestamp            time.Time     `protobuf:"bytes,5,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
-	ValidatorAddress     []byte        `protobuf:"bytes,6,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
-	ValidatorIndex       int32         `protobuf:"varint,7,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"`
-	Signature            []byte        `protobuf:"bytes,8,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
+	Type             SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
+	Height           int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
+	Round            int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
+	BlockID          BlockID       `protobuf:"bytes,4,opt,name=block_id,json=blockId,proto3" json:"block_id"`
+	Timestamp        time.Time     `protobuf:"bytes,5,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+	ValidatorAddress []byte        `protobuf:"bytes,6,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	ValidatorIndex   int32         `protobuf:"varint,7,opt,name=validator_index,json=validatorIndex,proto3" json:"validator_index,omitempty"`
+	Signature        []byte        `protobuf:"bytes,8,opt,name=signature,proto3" json:"signature,omitempty"`
 }
 
 func (m *Vote) Reset()         { *m = Vote{} }
@@ -587,15 +567,12 @@ func (m *Vote) GetSignature() []byte {
 
 // Commit contains the evidence that a block was committed by a set of validators.
 type Commit struct {
-	Height               int64          `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
-	Round                int32          `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
-	BlockID              BlockID        `protobuf:"bytes,3,opt,name=block_id,json=blockId,proto3" json:"block_id"`
-	Signatures           []CommitSig    `protobuf:"bytes,4,rep,name=signatures,proto3" json:"signatures"`
-	Hash                 []byte         `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"`
-	BitArray             *bits.BitArray `protobuf:"bytes,6,opt,name=bit_array,json=bitArray,proto3" json:"bit_array,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	Height     int64          `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
+	Round      int32          `protobuf:"varint,2,opt,name=round,proto3" json:"round,omitempty"`
+	BlockID    BlockID        `protobuf:"bytes,3,opt,name=block_id,json=blockId,proto3" json:"block_id"`
+	Signatures []CommitSig    `protobuf:"bytes,4,rep,name=signatures,proto3" json:"signatures"`
+	Hash       []byte         `protobuf:"bytes,5,opt,name=hash,proto3" json:"hash,omitempty"`
+	BitArray   *bits.BitArray `protobuf:"bytes,6,opt,name=bit_array,json=bitArray,proto3" json:"bit_array,omitempty"`
 }
 
 func (m *Commit) Reset()         { *m = Commit{} }
@@ -675,13 +652,10 @@ func (m *Commit) GetBitArray() *bits.BitArray {
 
 // CommitSig is a part of the Vote included in a Commit.
 type CommitSig struct {
-	BlockIdFlag          BlockIDFlag `protobuf:"varint,1,opt,name=block_id_flag,json=blockIdFlag,proto3,enum=tendermint.proto.types.BlockIDFlag" json:"block_id_flag,omitempty"`
-	ValidatorAddress     []byte      `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
-	Timestamp            time.Time   `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
-	Signature            []byte      `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
-	XXX_unrecognized     []byte      `json:"-"`
-	XXX_sizecache        int32       `json:"-"`
+	BlockIdFlag      BlockIDFlag `protobuf:"varint,1,opt,name=block_id_flag,json=blockIdFlag,proto3,enum=tendermint.proto.types.BlockIDFlag" json:"block_id_flag,omitempty"`
+	ValidatorAddress []byte      `protobuf:"bytes,2,opt,name=validator_address,json=validatorAddress,proto3" json:"validator_address,omitempty"`
+	Timestamp        time.Time   `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+	Signature        []byte      `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
 }
 
 func (m *CommitSig) Reset()         { *m = CommitSig{} }
@@ -746,16 +720,13 @@ func (m *CommitSig) GetSignature() []byte {
 }
 
 type Proposal struct {
-	Type                 SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
-	Height               int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
-	Round                int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
-	PolRound             int32         `protobuf:"varint,4,opt,name=pol_round,json=polRound,proto3" json:"pol_round,omitempty"`
-	BlockID              BlockID       `protobuf:"bytes,5,opt,name=block_id,json=blockId,proto3" json:"block_id"`
-	Timestamp            time.Time     `protobuf:"bytes,6,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
-	Signature            []byte        `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
-	XXX_unrecognized     []byte        `json:"-"`
-	XXX_sizecache        int32         `json:"-"`
+	Type      SignedMsgType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.proto.types.SignedMsgType" json:"type,omitempty"`
+	Height    int64         `protobuf:"varint,2,opt,name=height,proto3" json:"height,omitempty"`
+	Round     int32         `protobuf:"varint,3,opt,name=round,proto3" json:"round,omitempty"`
+	PolRound  int32         `protobuf:"varint,4,opt,name=pol_round,json=polRound,proto3" json:"pol_round,omitempty"`
+	BlockID   BlockID       `protobuf:"bytes,5,opt,name=block_id,json=blockId,proto3" json:"block_id"`
+	Timestamp time.Time     `protobuf:"bytes,6,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
+	Signature []byte        `protobuf:"bytes,7,opt,name=signature,proto3" json:"signature,omitempty"`
 }
 
 func (m *Proposal) Reset()         { *m = Proposal{} }
@@ -841,11 +812,8 @@ func (m *Proposal) GetSignature() []byte {
 }
 
 type SignedHeader struct {
-	Header               *Header  `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
-	Commit               *Commit  `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Header *Header `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"`
+	Commit *Commit `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
 }
 
 func (m *SignedHeader) Reset()         { *m = SignedHeader{} }
@@ -896,13 +864,10 @@ func (m *SignedHeader) GetCommit() *Commit {
 }
 
 type BlockMeta struct {
-	BlockID              BlockID  `protobuf:"bytes,1,opt,name=block_id,json=blockId,proto3" json:"block_id"`
-	BlockSize            int64    `protobuf:"varint,2,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
-	Header               Header   `protobuf:"bytes,3,opt,name=header,proto3" json:"header"`
-	NumTxs               int64    `protobuf:"varint,4,opt,name=num_txs,json=numTxs,proto3" json:"num_txs,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	BlockID   BlockID `protobuf:"bytes,1,opt,name=block_id,json=blockId,proto3" json:"block_id"`
+	BlockSize int64   `protobuf:"varint,2,opt,name=block_size,json=blockSize,proto3" json:"block_size,omitempty"`
+	Header    Header  `protobuf:"bytes,3,opt,name=header,proto3" json:"header"`
+	NumTxs    int64   `protobuf:"varint,4,opt,name=num_txs,json=numTxs,proto3" json:"num_txs,omitempty"`
 }
 
 func (m *BlockMeta) Reset()         { *m = BlockMeta{} }
@@ -968,118 +933,105 @@ func (m *BlockMeta) GetNumTxs() int64 {
 
 func init() {
 	proto.RegisterEnum("tendermint.proto.types.BlockIDFlag", BlockIDFlag_name, BlockIDFlag_value)
-	golang_proto.RegisterEnum("tendermint.proto.types.BlockIDFlag", BlockIDFlag_name, BlockIDFlag_value)
 	proto.RegisterEnum("tendermint.proto.types.SignedMsgType", SignedMsgType_name, SignedMsgType_value)
-	golang_proto.RegisterEnum("tendermint.proto.types.SignedMsgType", SignedMsgType_name, SignedMsgType_value)
 	proto.RegisterType((*PartSetHeader)(nil), "tendermint.proto.types.PartSetHeader")
-	golang_proto.RegisterType((*PartSetHeader)(nil), "tendermint.proto.types.PartSetHeader")
 	proto.RegisterType((*Part)(nil), "tendermint.proto.types.Part")
-	golang_proto.RegisterType((*Part)(nil), "tendermint.proto.types.Part")
 	proto.RegisterType((*BlockID)(nil), "tendermint.proto.types.BlockID")
-	golang_proto.RegisterType((*BlockID)(nil), "tendermint.proto.types.BlockID")
 	proto.RegisterType((*Header)(nil), "tendermint.proto.types.Header")
-	golang_proto.RegisterType((*Header)(nil), "tendermint.proto.types.Header")
 	proto.RegisterType((*Data)(nil), "tendermint.proto.types.Data")
-	golang_proto.RegisterType((*Data)(nil), "tendermint.proto.types.Data")
 	proto.RegisterType((*Vote)(nil), "tendermint.proto.types.Vote")
-	golang_proto.RegisterType((*Vote)(nil), "tendermint.proto.types.Vote")
 	proto.RegisterType((*Commit)(nil), "tendermint.proto.types.Commit")
-	golang_proto.RegisterType((*Commit)(nil), "tendermint.proto.types.Commit")
 	proto.RegisterType((*CommitSig)(nil), "tendermint.proto.types.CommitSig")
-	golang_proto.RegisterType((*CommitSig)(nil), "tendermint.proto.types.CommitSig")
 	proto.RegisterType((*Proposal)(nil), "tendermint.proto.types.Proposal")
-	golang_proto.RegisterType((*Proposal)(nil), "tendermint.proto.types.Proposal")
 	proto.RegisterType((*SignedHeader)(nil), "tendermint.proto.types.SignedHeader")
-	golang_proto.RegisterType((*SignedHeader)(nil), "tendermint.proto.types.SignedHeader")
 	proto.RegisterType((*BlockMeta)(nil), "tendermint.proto.types.BlockMeta")
-	golang_proto.RegisterType((*BlockMeta)(nil), "tendermint.proto.types.BlockMeta")
 }
 
 func init() { proto.RegisterFile("proto/types/types.proto", fileDescriptor_ff06f8095857fb18) }
-func init() { golang_proto.RegisterFile("proto/types/types.proto", fileDescriptor_ff06f8095857fb18) }
 
 var fileDescriptor_ff06f8095857fb18 = []byte{
-	// 1276 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xdf, 0x6e, 0x1a, 0xc7,
-	0x17, 0xf6, 0xc2, 0x62, 0xe0, 0x00, 0x36, 0x5e, 0xf9, 0x97, 0xf0, 0xc3, 0x2d, 0x26, 0xb8, 0x49,
-	0x9d, 0x3f, 0x5a, 0x2a, 0x57, 0xaa, 0x1a, 0xa9, 0xaa, 0x04, 0xb6, 0x43, 0x50, 0x6c, 0x40, 0x0b,
-	0x4d, 0xd5, 0xde, 0xac, 0x06, 0x76, 0xb2, 0xac, 0xb2, 0xec, 0xae, 0x76, 0x07, 0xcb, 0xa4, 0x52,
-	0xaf, 0x2b, 0x5f, 0xf5, 0x05, 0x7c, 0x95, 0x56, 0xea, 0x5b, 0x34, 0x97, 0xb9, 0xaa, 0xfa, 0x04,
-	0x69, 0xe5, 0xbc, 0x41, 0xd5, 0x07, 0xa8, 0xe6, 0xcf, 0x2e, 0x10, 0x4c, 0x6b, 0x35, 0x51, 0x6f,
-	0xec, 0x9d, 0x73, 0xbe, 0xef, 0xcc, 0x9c, 0x6f, 0xbe, 0x99, 0x11, 0x70, 0xdd, 0xf3, 0x5d, 0xe2,
-	0x56, 0xc9, 0xc4, 0xc3, 0x01, 0xff, 0xab, 0xb2, 0x88, 0x72, 0x8d, 0x60, 0xc7, 0xc0, 0xfe, 0xc8,
-	0x72, 0x08, 0x8f, 0xa8, 0x2c, 0x5b, 0xbc, 0x45, 0x86, 0x96, 0x6f, 0xe8, 0x1e, 0xf2, 0xc9, 0xa4,
-	0xca, 0xc9, 0xa6, 0x6b, 0xba, 0xd3, 0x2f, 0x8e, 0x2e, 0x6e, 0x9b, 0xae, 0x6b, 0xda, 0x98, 0x43,
-	0xfa, 0xe3, 0x27, 0x55, 0x62, 0x8d, 0x70, 0x40, 0xd0, 0xc8, 0x13, 0x80, 0x2d, 0x4e, 0xb1, 0xad,
-	0x7e, 0x50, 0xed, 0x5b, 0x64, 0x6e, 0xf6, 0xe2, 0x36, 0x4f, 0x0e, 0xfc, 0x89, 0x47, 0xdc, 0xea,
-	0x08, 0xfb, 0x4f, 0x6d, 0x3c, 0x07, 0x10, 0xec, 0x13, 0xec, 0x07, 0x96, 0xeb, 0x84, 0xff, 0x79,
-	0xb2, 0x72, 0x1f, 0x72, 0x1d, 0xe4, 0x93, 0x2e, 0x26, 0x0f, 0x31, 0x32, 0xb0, 0xaf, 0x6c, 0x42,
-	0x82, 0xb8, 0x04, 0xd9, 0x05, 0xa9, 0x2c, 0xed, 0xe6, 0x34, 0x3e, 0x50, 0x14, 0x90, 0x87, 0x28,
-	0x18, 0x16, 0x62, 0x65, 0x69, 0x37, 0xab, 0xb1, 0xef, 0xca, 0x37, 0x20, 0x53, 0x2a, 0x65, 0x58,
-	0x8e, 0x81, 0x4f, 0x43, 0x06, 0x1b, 0xd0, 0x68, 0x7f, 0x42, 0x70, 0x20, 0x28, 0x7c, 0xa0, 0x34,
-	0x20, 0xe1, 0xf9, 0xae, 0xfb, 0xa4, 0x10, 0x2f, 0x4b, 0xbb, 0x99, 0xbd, 0xbb, 0xea, 0x82, 0x74,
-	0xbc, 0x0f, 0x95, 0xf7, 0xa1, 0x76, 0xad, 0x91, 0x67, 0xe3, 0x0e, 0xa5, 0xd4, 0xe5, 0x97, 0xaf,
-	0xb6, 0x57, 0x34, 0xce, 0xaf, 0x8c, 0x20, 0x59, 0xb7, 0xdd, 0xc1, 0xd3, 0xe6, 0x41, 0xb4, 0x36,
-	0x69, 0xba, 0x36, 0xa5, 0x05, 0x59, 0x2a, 0x7b, 0xa0, 0x0f, 0x59, 0x57, 0x6c, 0x11, 0x99, 0xbd,
-	0x9b, 0xea, 0xe5, 0x3b, 0xa5, 0xce, 0x49, 0x20, 0x26, 0xca, 0xb0, 0x02, 0x3c, 0x54, 0xf9, 0x43,
-	0x86, 0x55, 0x21, 0xd0, 0x3e, 0x24, 0x85, 0x84, 0x6c, 0xc6, 0xcc, 0xde, 0xce, 0x62, 0xd5, 0x50,
-	0xe3, 0x7d, 0xd7, 0x09, 0xb0, 0x13, 0x8c, 0x03, 0x51, 0x33, 0x64, 0x2a, 0xb7, 0x20, 0x35, 0x18,
-	0x22, 0xcb, 0xd1, 0x2d, 0x83, 0xad, 0x2d, 0x5d, 0xcf, 0x5c, 0xbc, 0xda, 0x4e, 0xee, 0xd3, 0x58,
-	0xf3, 0x40, 0x4b, 0xb2, 0x64, 0xd3, 0x50, 0xae, 0xc1, 0xea, 0x10, 0x5b, 0xe6, 0x90, 0x30, 0xc1,
-	0xe2, 0x9a, 0x18, 0x29, 0x9f, 0x82, 0x4c, 0x4d, 0x52, 0x90, 0xd9, 0x0a, 0x8a, 0x2a, 0x77, 0x90,
-	0x1a, 0x3a, 0x48, 0xed, 0x85, 0x0e, 0xaa, 0xa7, 0xe8, 0xc4, 0xdf, 0xff, 0xb6, 0x2d, 0x69, 0x8c,
-	0xa1, 0x34, 0x21, 0x67, 0xa3, 0x80, 0xe8, 0x7d, 0xaa, 0x1e, 0x9d, 0x3e, 0xc1, 0x4a, 0x6c, 0x2f,
-	0x93, 0x46, 0xa8, 0x1c, 0x8a, 0x42, 0xb9, 0x3c, 0x64, 0x28, 0xbb, 0x90, 0x67, 0xa5, 0x06, 0xee,
-	0x68, 0x64, 0x11, 0x9d, 0x6d, 0xc2, 0x2a, 0xdb, 0x84, 0x35, 0x1a, 0xdf, 0x67, 0xe1, 0x87, 0x74,
-	0x3b, 0xb6, 0x20, 0x6d, 0x20, 0x82, 0x38, 0x24, 0xc9, 0x20, 0x29, 0x1a, 0x60, 0xc9, 0x0f, 0x61,
-	0xfd, 0x04, 0xd9, 0x96, 0x81, 0x88, 0xeb, 0x07, 0x1c, 0x92, 0xe2, 0x55, 0xa6, 0x61, 0x06, 0xfc,
-	0x08, 0x36, 0x1d, 0x7c, 0x4a, 0xf4, 0x37, 0xd1, 0x69, 0x86, 0x56, 0x68, 0xee, 0xf1, 0x3c, 0xe3,
-	0x26, 0xac, 0x0d, 0xc2, 0x2d, 0xe0, 0x58, 0x60, 0xd8, 0x5c, 0x14, 0x65, 0xb0, 0xff, 0x43, 0x0a,
-	0x79, 0x1e, 0x07, 0x64, 0x18, 0x20, 0x89, 0x3c, 0x8f, 0xa5, 0xee, 0xc0, 0x06, 0xeb, 0xd1, 0xc7,
-	0xc1, 0xd8, 0x26, 0xa2, 0x48, 0x96, 0x61, 0xd6, 0x69, 0x42, 0xe3, 0x71, 0x86, 0xdd, 0x81, 0x1c,
-	0x3e, 0xb1, 0x0c, 0xec, 0x0c, 0x30, 0xc7, 0xe5, 0x18, 0x2e, 0x1b, 0x06, 0x19, 0xe8, 0x36, 0xe4,
-	0x3d, 0xdf, 0xf5, 0xdc, 0x00, 0xfb, 0x3a, 0x32, 0x0c, 0x1f, 0x07, 0x41, 0x61, 0x8d, 0xd7, 0x0b,
-	0xe3, 0x35, 0x1e, 0xae, 0xdc, 0x03, 0xf9, 0x00, 0x11, 0xa4, 0xe4, 0x21, 0x4e, 0x4e, 0x83, 0x82,
-	0x54, 0x8e, 0xef, 0x66, 0x35, 0xfa, 0x79, 0xe9, 0x71, 0xfc, 0x33, 0x06, 0xf2, 0x63, 0x97, 0x60,
-	0xe5, 0x3e, 0xc8, 0x74, 0xeb, 0x98, 0x3b, 0xd7, 0x96, 0x7b, 0xbe, 0x6b, 0x99, 0x0e, 0x36, 0x8e,
-	0x03, 0xb3, 0x37, 0xf1, 0xb0, 0xc6, 0x28, 0x33, 0x76, 0x8b, 0xcd, 0xd9, 0x6d, 0x13, 0x12, 0xbe,
-	0x3b, 0x76, 0x0c, 0xe6, 0xc2, 0x84, 0xc6, 0x07, 0xca, 0x23, 0x48, 0x45, 0x2e, 0x92, 0xaf, 0xe6,
-	0xa2, 0x75, 0xea, 0x22, 0xea, 0x74, 0x11, 0xd0, 0x92, 0x7d, 0x61, 0xa6, 0x3a, 0xa4, 0xa3, 0x6b,
-	0x4f, 0x78, 0xf2, 0x6a, 0xb6, 0x9e, 0xd2, 0x94, 0xbb, 0xb0, 0x11, 0x79, 0x23, 0x12, 0x97, 0x3b,
-	0x32, 0x1f, 0x25, 0x84, 0xba, 0x73, 0xb6, 0xd3, 0xf9, 0x05, 0x96, 0x64, 0xdd, 0x4d, 0x6d, 0xd7,
-	0x64, 0x37, 0xd9, 0x7b, 0x90, 0x0e, 0x2c, 0xd3, 0x41, 0x64, 0xec, 0x63, 0xe1, 0xcc, 0x69, 0xa0,
-	0xf2, 0x3c, 0x06, 0xab, 0xdc, 0xe9, 0x33, 0xea, 0x49, 0x97, 0xab, 0x17, 0x5b, 0xa6, 0x5e, 0xfc,
-	0x6d, 0xd5, 0x6b, 0x00, 0x44, 0x4b, 0x0a, 0x0a, 0x72, 0x39, 0xbe, 0x9b, 0xd9, 0xbb, 0xb1, 0xac,
-	0x1c, 0x5f, 0x6e, 0xd7, 0x32, 0xc5, 0xa1, 0x9e, 0xa1, 0x46, 0xce, 0x4a, 0xcc, 0x5c, 0xa6, 0x35,
-	0x48, 0xf7, 0x2d, 0xa2, 0x23, 0xdf, 0x47, 0x13, 0x26, 0x67, 0x66, 0xef, 0x83, 0xc5, 0xda, 0xf4,
-	0x75, 0x52, 0xe9, 0xeb, 0xa4, 0xd6, 0x2d, 0x52, 0xa3, 0x58, 0x2d, 0xd5, 0x17, 0x5f, 0x95, 0xd7,
-	0x12, 0xa4, 0xa3, 0x69, 0x95, 0x06, 0xe4, 0xc2, 0xd6, 0xf5, 0x27, 0x36, 0x32, 0x85, 0x55, 0x77,
-	0xfe, 0xa1, 0xff, 0x07, 0x36, 0x32, 0xb5, 0x8c, 0x68, 0x99, 0x0e, 0x2e, 0xdf, 0xf0, 0xd8, 0x92,
-	0x0d, 0x9f, 0x73, 0x58, 0xfc, 0xdf, 0x39, 0x6c, 0xce, 0x0b, 0xf2, 0x9b, 0x5e, 0xf8, 0x39, 0x06,
-	0xa9, 0x0e, 0x3b, 0xc4, 0xc8, 0xfe, 0xef, 0x8e, 0xe1, 0x16, 0xa4, 0x3d, 0xd7, 0xd6, 0x79, 0x46,
-	0x66, 0x99, 0x94, 0xe7, 0xda, 0xda, 0x82, 0xcb, 0x12, 0xef, 0xf4, 0x8c, 0xae, 0xbe, 0x03, 0x05,
-	0x93, 0x6f, 0x2a, 0xf8, 0x2d, 0x64, 0xb9, 0x20, 0xe2, 0xb1, 0xfd, 0x84, 0x2a, 0xc1, 0x5e, 0x70,
-	0xfe, 0xd6, 0x96, 0x96, 0x2d, 0x9e, 0xe3, 0x35, 0x81, 0xa6, 0x3c, 0xfe, 0x2a, 0x89, 0x97, 0xbf,
-	0xf4, 0xf7, 0x67, 0x41, 0x13, 0xe8, 0xca, 0x2f, 0x12, 0xa4, 0x59, 0xdb, 0xc7, 0x98, 0xa0, 0x39,
-	0xf1, 0xa4, 0xb7, 0x15, 0xef, 0x7d, 0x00, 0x5e, 0x2c, 0xb0, 0x9e, 0x61, 0xb1, 0xb1, 0x69, 0x16,
-	0xe9, 0x5a, 0xcf, 0xb0, 0xf2, 0x59, 0xd4, 0x69, 0xfc, 0x2a, 0x9d, 0x8a, 0xa3, 0x1b, 0xf6, 0x7b,
-	0x1d, 0x92, 0xce, 0x78, 0xa4, 0xd3, 0x67, 0x42, 0xe6, 0x96, 0x71, 0xc6, 0xa3, 0xde, 0x69, 0x70,
-	0xe7, 0x85, 0x04, 0x99, 0x99, 0xe3, 0xa3, 0x14, 0xe1, 0x5a, 0xfd, 0xa8, 0xbd, 0xff, 0xe8, 0x40,
-	0x6f, 0x1e, 0xe8, 0x0f, 0x8e, 0x6a, 0x0d, 0xfd, 0x8b, 0xd6, 0xa3, 0x56, 0xfb, 0xcb, 0x56, 0x7e,
-	0x45, 0xa9, 0xc2, 0x26, 0xcb, 0x45, 0xa9, 0x5a, 0xbd, 0x7b, 0xd8, 0xea, 0xe5, 0xa5, 0xe2, 0xff,
-	0xce, 0xce, 0xcb, 0x1b, 0x33, 0x65, 0x6a, 0xfd, 0x00, 0x3b, 0x64, 0x91, 0xb0, 0xdf, 0x3e, 0x3e,
-	0x6e, 0xf6, 0xf2, 0xb1, 0x05, 0x82, 0xb8, 0x21, 0x6f, 0xc3, 0xc6, 0x3c, 0xa1, 0xd5, 0x3c, 0xca,
-	0xc7, 0x8b, 0xca, 0xd9, 0x79, 0x79, 0x6d, 0x06, 0xdd, 0xb2, 0xec, 0x62, 0xea, 0xbb, 0xe7, 0xa5,
-	0x95, 0x9f, 0x7e, 0x28, 0xad, 0xdc, 0xf9, 0x51, 0x82, 0xdc, 0xdc, 0x29, 0x51, 0xb6, 0xe0, 0x7a,
-	0xb7, 0xd9, 0x68, 0x1d, 0x1e, 0xe8, 0xc7, 0xdd, 0x86, 0xde, 0xfb, 0xaa, 0x73, 0x38, 0xd3, 0xc5,
-	0x0d, 0xc8, 0x76, 0xb4, 0xc3, 0xc7, 0xed, 0xde, 0x21, 0xcb, 0xe4, 0xa5, 0xe2, 0xfa, 0xd9, 0x79,
-	0x39, 0xd3, 0xf1, 0xf1, 0x89, 0x4b, 0x30, 0xe3, 0xdf, 0x84, 0xb5, 0x8e, 0x76, 0xc8, 0x17, 0xcb,
-	0x41, 0xb1, 0xe2, 0xc6, 0xd9, 0x79, 0x39, 0xd7, 0xf1, 0x31, 0x37, 0x02, 0x83, 0xed, 0x40, 0xae,
-	0xa3, 0xb5, 0x3b, 0xed, 0x6e, 0xed, 0x88, 0xa3, 0xe2, 0xc5, 0xfc, 0xd9, 0x79, 0x39, 0x1b, 0x1e,
-	0x71, 0x0a, 0x9a, 0xae, 0xb3, 0xfe, 0xf9, 0xcb, 0x8b, 0x92, 0xf4, 0xeb, 0x45, 0x49, 0xfa, 0xfd,
-	0xa2, 0x24, 0xbd, 0x78, 0x5d, 0x92, 0xbe, 0xbe, 0x67, 0x5a, 0x64, 0x38, 0xee, 0xab, 0x03, 0x77,
-	0x54, 0x9d, 0xee, 0xe6, 0xec, 0xe7, 0xcc, 0x4f, 0x8a, 0xfe, 0x2a, 0x1b, 0x7c, 0xfc, 0x57, 0x00,
-	0x00, 0x00, 0xff, 0xff, 0xb0, 0x53, 0xb3, 0xf9, 0x68, 0x0c, 0x00, 0x00,
+	// 1283 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0x4d, 0x6f, 0x1a, 0x47,
+	0x18, 0x66, 0x61, 0x31, 0xf0, 0x02, 0x36, 0x5e, 0xb9, 0x09, 0xc5, 0x2d, 0x26, 0xb8, 0x49, 0x9d,
+	0x0f, 0x2d, 0x95, 0x2b, 0x55, 0x8d, 0xd4, 0x0b, 0xd8, 0x8e, 0x83, 0x62, 0x63, 0xb4, 0xd0, 0x54,
+	0xed, 0x65, 0x35, 0xb0, 0x93, 0x65, 0x95, 0x65, 0x77, 0xb5, 0x3b, 0x58, 0x26, 0x95, 0x7a, 0xae,
+	0x7c, 0xca, 0x1f, 0xf0, 0x29, 0xad, 0xd4, 0x7f, 0xd1, 0x1e, 0x73, 0xaa, 0x72, 0xec, 0x29, 0xad,
+	0xec, 0x7f, 0x50, 0xf5, 0x07, 0x54, 0xf3, 0xb1, 0x0b, 0x04, 0xd3, 0x5a, 0x4d, 0xd4, 0x8b, 0xbd,
+	0xf3, 0xbe, 0xcf, 0xf3, 0xce, 0xbc, 0xcf, 0x3c, 0x33, 0x23, 0xe0, 0xba, 0xe7, 0xbb, 0xc4, 0xad,
+	0x91, 0xb1, 0x87, 0x03, 0xfe, 0x57, 0x65, 0x11, 0xe5, 0x1a, 0xc1, 0x8e, 0x81, 0xfd, 0xa1, 0xe5,
+	0x10, 0x1e, 0x51, 0x59, 0xb6, 0x74, 0x8b, 0x0c, 0x2c, 0xdf, 0xd0, 0x3d, 0xe4, 0x93, 0x71, 0x8d,
+	0x93, 0x4d, 0xd7, 0x74, 0x27, 0x5f, 0x1c, 0x5d, 0xda, 0x30, 0x5d, 0xd7, 0xb4, 0x31, 0x87, 0xf4,
+	0x46, 0x4f, 0x6a, 0xc4, 0x1a, 0xe2, 0x80, 0xa0, 0xa1, 0x27, 0x00, 0xeb, 0x9c, 0x62, 0x5b, 0xbd,
+	0xa0, 0xd6, 0xb3, 0xc8, 0xcc, 0xec, 0xa5, 0x0d, 0x9e, 0xec, 0xfb, 0x63, 0x8f, 0xb8, 0xb5, 0x21,
+	0xf6, 0x9f, 0xda, 0x78, 0x06, 0x20, 0xd8, 0xc7, 0xd8, 0x0f, 0x2c, 0xd7, 0x09, 0xff, 0xf3, 0x64,
+	0xf5, 0x3e, 0xe4, 0xdb, 0xc8, 0x27, 0x1d, 0x4c, 0x1e, 0x62, 0x64, 0x60, 0x5f, 0x59, 0x83, 0x24,
+	0x71, 0x09, 0xb2, 0x8b, 0x52, 0x45, 0xda, 0xca, 0x6b, 0x7c, 0xa0, 0x28, 0x20, 0x0f, 0x50, 0x30,
+	0x28, 0xc6, 0x2b, 0xd2, 0x56, 0x4e, 0x63, 0xdf, 0xd5, 0x6f, 0x41, 0xa6, 0x54, 0xca, 0xb0, 0x1c,
+	0x03, 0x9f, 0x84, 0x0c, 0x36, 0xa0, 0xd1, 0xde, 0x98, 0xe0, 0x40, 0x50, 0xf8, 0x40, 0xd9, 0x87,
+	0xa4, 0xe7, 0xbb, 0xee, 0x93, 0x62, 0xa2, 0x22, 0x6d, 0x65, 0xb7, 0xef, 0xaa, 0x73, 0xd2, 0xf1,
+	0x3e, 0x54, 0xde, 0x87, 0xda, 0xb1, 0x86, 0x9e, 0x8d, 0xdb, 0x94, 0xd2, 0x90, 0x5f, 0xbe, 0xde,
+	0x88, 0x69, 0x9c, 0x5f, 0x1d, 0x42, 0xaa, 0x61, 0xbb, 0xfd, 0xa7, 0xcd, 0xdd, 0x68, 0x6d, 0xd2,
+	0x64, 0x6d, 0x4a, 0x0b, 0x72, 0x54, 0xf6, 0x40, 0x1f, 0xb0, 0xae, 0xd8, 0x22, 0xb2, 0xdb, 0x37,
+	0xd5, 0xcb, 0x77, 0x4a, 0x9d, 0x91, 0x40, 0x4c, 0x94, 0x65, 0x05, 0x78, 0xa8, 0xfa, 0xa7, 0x0c,
+	0x4b, 0x42, 0xa0, 0x1d, 0x48, 0x09, 0x09, 0xd9, 0x8c, 0xd9, 0xed, 0xcd, 0xf9, 0xaa, 0xa1, 0xc6,
+	0x3b, 0xae, 0x13, 0x60, 0x27, 0x18, 0x05, 0xa2, 0x66, 0xc8, 0x54, 0x6e, 0x41, 0xba, 0x3f, 0x40,
+	0x96, 0xa3, 0x5b, 0x06, 0x5b, 0x5b, 0xa6, 0x91, 0x3d, 0x7f, 0xbd, 0x91, 0xda, 0xa1, 0xb1, 0xe6,
+	0xae, 0x96, 0x62, 0xc9, 0xa6, 0xa1, 0x5c, 0x83, 0xa5, 0x01, 0xb6, 0xcc, 0x01, 0x61, 0x82, 0x25,
+	0x34, 0x31, 0x52, 0x3e, 0x07, 0x99, 0x9a, 0xa4, 0x28, 0xb3, 0x15, 0x94, 0x54, 0xee, 0x20, 0x35,
+	0x74, 0x90, 0xda, 0x0d, 0x1d, 0xd4, 0x48, 0xd3, 0x89, 0x9f, 0xff, 0xbe, 0x21, 0x69, 0x8c, 0xa1,
+	0x34, 0x21, 0x6f, 0xa3, 0x80, 0xe8, 0x3d, 0xaa, 0x1e, 0x9d, 0x3e, 0xc9, 0x4a, 0x6c, 0x2c, 0x92,
+	0x46, 0xa8, 0x1c, 0x8a, 0x42, 0xb9, 0x3c, 0x64, 0x28, 0x5b, 0x50, 0x60, 0xa5, 0xfa, 0xee, 0x70,
+	0x68, 0x11, 0x9d, 0x6d, 0xc2, 0x12, 0xdb, 0x84, 0x65, 0x1a, 0xdf, 0x61, 0xe1, 0x87, 0x74, 0x3b,
+	0xd6, 0x21, 0x63, 0x20, 0x82, 0x38, 0x24, 0xc5, 0x20, 0x69, 0x1a, 0x60, 0xc9, 0x8f, 0x61, 0xe5,
+	0x18, 0xd9, 0x96, 0x81, 0x88, 0xeb, 0x07, 0x1c, 0x92, 0xe6, 0x55, 0x26, 0x61, 0x06, 0xfc, 0x04,
+	0xd6, 0x1c, 0x7c, 0x42, 0xf4, 0x37, 0xd1, 0x19, 0x86, 0x56, 0x68, 0xee, 0xf1, 0x2c, 0xe3, 0x26,
+	0x2c, 0xf7, 0xc3, 0x2d, 0xe0, 0x58, 0x60, 0xd8, 0x7c, 0x14, 0x65, 0xb0, 0xf7, 0x21, 0x8d, 0x3c,
+	0x8f, 0x03, 0xb2, 0x0c, 0x90, 0x42, 0x9e, 0xc7, 0x52, 0x77, 0x60, 0x95, 0xf5, 0xe8, 0xe3, 0x60,
+	0x64, 0x13, 0x51, 0x24, 0xc7, 0x30, 0x2b, 0x34, 0xa1, 0xf1, 0x38, 0xc3, 0x6e, 0x42, 0x1e, 0x1f,
+	0x5b, 0x06, 0x76, 0xfa, 0x98, 0xe3, 0xf2, 0x0c, 0x97, 0x0b, 0x83, 0x0c, 0x74, 0x1b, 0x0a, 0x9e,
+	0xef, 0x7a, 0x6e, 0x80, 0x7d, 0x1d, 0x19, 0x86, 0x8f, 0x83, 0xa0, 0xb8, 0xcc, 0xeb, 0x85, 0xf1,
+	0x3a, 0x0f, 0x57, 0xef, 0x81, 0xbc, 0x8b, 0x08, 0x52, 0x0a, 0x90, 0x20, 0x27, 0x41, 0x51, 0xaa,
+	0x24, 0xb6, 0x72, 0x1a, 0xfd, 0xbc, 0xf4, 0x38, 0xfe, 0x15, 0x07, 0xf9, 0xb1, 0x4b, 0xb0, 0x72,
+	0x1f, 0x64, 0xba, 0x75, 0xcc, 0x9d, 0xcb, 0x8b, 0x3d, 0xdf, 0xb1, 0x4c, 0x07, 0x1b, 0x87, 0x81,
+	0xd9, 0x1d, 0x7b, 0x58, 0x63, 0x94, 0x29, 0xbb, 0xc5, 0x67, 0xec, 0xb6, 0x06, 0x49, 0xdf, 0x1d,
+	0x39, 0x06, 0x73, 0x61, 0x52, 0xe3, 0x03, 0xe5, 0x11, 0xa4, 0x23, 0x17, 0xc9, 0x57, 0x73, 0xd1,
+	0x0a, 0x75, 0x11, 0x75, 0xba, 0x08, 0x68, 0xa9, 0x9e, 0x30, 0x53, 0x03, 0x32, 0xd1, 0xb5, 0x27,
+	0x3c, 0x79, 0x35, 0x5b, 0x4f, 0x68, 0xca, 0x5d, 0x58, 0x8d, 0xbc, 0x11, 0x89, 0xcb, 0x1d, 0x59,
+	0x88, 0x12, 0x42, 0xdd, 0x19, 0xdb, 0xe9, 0xfc, 0x02, 0x4b, 0xb1, 0xee, 0x26, 0xb6, 0x6b, 0xb2,
+	0x9b, 0xec, 0x03, 0xc8, 0x04, 0x96, 0xe9, 0x20, 0x32, 0xf2, 0xb1, 0x70, 0xe6, 0x24, 0x50, 0x7d,
+	0x11, 0x87, 0x25, 0xee, 0xf4, 0x29, 0xf5, 0xa4, 0xcb, 0xd5, 0x8b, 0x2f, 0x52, 0x2f, 0xf1, 0xb6,
+	0xea, 0xed, 0x03, 0x44, 0x4b, 0x0a, 0x8a, 0x72, 0x25, 0xb1, 0x95, 0xdd, 0xbe, 0xb1, 0xa8, 0x1c,
+	0x5f, 0x6e, 0xc7, 0x32, 0xc5, 0xa1, 0x9e, 0xa2, 0x46, 0xce, 0x4a, 0x4e, 0x5d, 0xa6, 0x75, 0xc8,
+	0xf4, 0x2c, 0xa2, 0x23, 0xdf, 0x47, 0x63, 0x26, 0x67, 0x76, 0xfb, 0xa3, 0xf9, 0xda, 0xf4, 0x75,
+	0x52, 0xe9, 0xeb, 0xa4, 0x36, 0x2c, 0x52, 0xa7, 0x58, 0x2d, 0xdd, 0x13, 0x5f, 0xd5, 0x0b, 0x09,
+	0x32, 0xd1, 0xb4, 0xca, 0x3e, 0xe4, 0xc3, 0xd6, 0xf5, 0x27, 0x36, 0x32, 0x85, 0x55, 0x37, 0xff,
+	0xa5, 0xff, 0x07, 0x36, 0x32, 0xb5, 0xac, 0x68, 0x99, 0x0e, 0x2e, 0xdf, 0xf0, 0xf8, 0x82, 0x0d,
+	0x9f, 0x71, 0x58, 0xe2, 0xbf, 0x39, 0x6c, 0xc6, 0x0b, 0xf2, 0x9b, 0x5e, 0xf8, 0x39, 0x0e, 0xe9,
+	0x36, 0x3b, 0xc4, 0xc8, 0xfe, 0xff, 0x8e, 0xe1, 0x3a, 0x64, 0x3c, 0xd7, 0xd6, 0x79, 0x46, 0x66,
+	0x99, 0xb4, 0xe7, 0xda, 0xda, 0x9c, 0xcb, 0x92, 0xef, 0xf4, 0x8c, 0x2e, 0xbd, 0x03, 0x05, 0x53,
+	0x6f, 0x2a, 0xf8, 0x1d, 0xe4, 0xb8, 0x20, 0xe2, 0xb1, 0xfd, 0x8c, 0x2a, 0xc1, 0x5e, 0x70, 0xfe,
+	0xd6, 0x96, 0x17, 0x2d, 0x9e, 0xe3, 0x35, 0x81, 0xa6, 0x3c, 0xfe, 0x2a, 0x89, 0x97, 0xbf, 0xfc,
+	0xcf, 0x67, 0x41, 0x13, 0xe8, 0xea, 0xaf, 0x12, 0x64, 0x58, 0xdb, 0x87, 0x98, 0xa0, 0x19, 0xf1,
+	0xa4, 0xb7, 0x15, 0xef, 0x43, 0x00, 0x5e, 0x2c, 0xb0, 0x9e, 0x61, 0xb1, 0xb1, 0x19, 0x16, 0xe9,
+	0x58, 0xcf, 0xb0, 0xf2, 0x45, 0xd4, 0x69, 0xe2, 0x2a, 0x9d, 0x8a, 0xa3, 0x1b, 0xf6, 0x7b, 0x1d,
+	0x52, 0xce, 0x68, 0xa8, 0xd3, 0x67, 0x42, 0xe6, 0x96, 0x71, 0x46, 0xc3, 0xee, 0x49, 0x70, 0xe7,
+	0x17, 0x09, 0xb2, 0x53, 0xc7, 0x47, 0x29, 0xc1, 0xb5, 0xc6, 0xc1, 0xd1, 0xce, 0xa3, 0x5d, 0xbd,
+	0xb9, 0xab, 0x3f, 0x38, 0xa8, 0xef, 0xeb, 0x5f, 0xb6, 0x1e, 0xb5, 0x8e, 0xbe, 0x6a, 0x15, 0x62,
+	0x4a, 0x0d, 0xd6, 0x58, 0x2e, 0x4a, 0xd5, 0x1b, 0x9d, 0xbd, 0x56, 0xb7, 0x20, 0x95, 0xde, 0x3b,
+	0x3d, 0xab, 0xac, 0x4e, 0x95, 0xa9, 0xf7, 0x02, 0xec, 0x90, 0x79, 0xc2, 0xce, 0xd1, 0xe1, 0x61,
+	0xb3, 0x5b, 0x88, 0xcf, 0x11, 0xc4, 0x0d, 0x79, 0x1b, 0x56, 0x67, 0x09, 0xad, 0xe6, 0x41, 0x21,
+	0x51, 0x52, 0x4e, 0xcf, 0x2a, 0xcb, 0x53, 0xe8, 0x96, 0x65, 0x97, 0xd2, 0xdf, 0xbf, 0x28, 0xc7,
+	0x7e, 0xfa, 0xa1, 0x1c, 0xbb, 0xf3, 0xa3, 0x04, 0xf9, 0x99, 0x53, 0xa2, 0xac, 0xc3, 0xf5, 0x4e,
+	0x73, 0xbf, 0xb5, 0xb7, 0xab, 0x1f, 0x76, 0xf6, 0xf5, 0xee, 0xd7, 0xed, 0xbd, 0xa9, 0x2e, 0x6e,
+	0x40, 0xae, 0xad, 0xed, 0x3d, 0x3e, 0xea, 0xee, 0xb1, 0x4c, 0x41, 0x2a, 0xad, 0x9c, 0x9e, 0x55,
+	0xb2, 0x6d, 0x1f, 0x1f, 0xbb, 0x04, 0x33, 0xfe, 0x4d, 0x58, 0x6e, 0x6b, 0x7b, 0x7c, 0xb1, 0x1c,
+	0x14, 0x2f, 0xad, 0x9e, 0x9e, 0x55, 0xf2, 0x6d, 0x1f, 0x73, 0x23, 0x30, 0xd8, 0x26, 0xe4, 0xdb,
+	0xda, 0x51, 0xfb, 0xa8, 0x53, 0x3f, 0xe0, 0xa8, 0x44, 0xa9, 0x70, 0x7a, 0x56, 0xc9, 0x85, 0x47,
+	0x9c, 0x82, 0x26, 0xeb, 0x6c, 0x3c, 0x78, 0x79, 0x5e, 0x96, 0x5e, 0x9d, 0x97, 0xa5, 0x3f, 0xce,
+	0xcb, 0xd2, 0xf3, 0x8b, 0x72, 0xec, 0xd5, 0x45, 0x39, 0xf6, 0xdb, 0x45, 0x39, 0xf6, 0xcd, 0x3d,
+	0xd3, 0x22, 0x83, 0x51, 0x4f, 0xed, 0xbb, 0xc3, 0xda, 0x64, 0x57, 0xa7, 0x3f, 0xa7, 0x7e, 0x5a,
+	0xf4, 0x96, 0xd8, 0xe0, 0xd3, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xb2, 0xd1, 0x12, 0x04, 0x70,
+	0x0c, 0x00, 0x00,
 }
 
 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) {
@@ -1102,10 +1054,6 @@ func (m *PartSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Hash) > 0 {
 		i -= len(m.Hash)
 		copy(dAtA[i:], m.Hash)
@@ -1141,10 +1089,6 @@ func (m *Part) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	{
 		size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
@@ -1190,10 +1134,6 @@ func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	{
 		size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
@@ -1234,10 +1174,6 @@ func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.ProposerAddress) > 0 {
 		i -= len(m.ProposerAddress)
 		copy(dAtA[i:], m.ProposerAddress)
@@ -1364,10 +1300,6 @@ func (m *Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Hash) > 0 {
 		i -= len(m.Hash)
 		copy(dAtA[i:], m.Hash)
@@ -1407,10 +1339,6 @@ func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Signature) > 0 {
 		i -= len(m.Signature)
 		copy(dAtA[i:], m.Signature)
@@ -1486,10 +1414,6 @@ func (m *Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.BitArray != nil {
 		{
 			size, err := m.BitArray.MarshalToSizedBuffer(dAtA[:i])
@@ -1566,10 +1490,6 @@ func (m *CommitSig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Signature) > 0 {
 		i -= len(m.Signature)
 		copy(dAtA[i:], m.Signature)
@@ -1620,10 +1540,6 @@ func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Signature) > 0 {
 		i -= len(m.Signature)
 		copy(dAtA[i:], m.Signature)
@@ -1692,10 +1608,6 @@ func (m *SignedHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.Commit != nil {
 		{
 			size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i])
@@ -1743,10 +1655,6 @@ func (m *BlockMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.NumTxs != 0 {
 		i = encodeVarintTypes(dAtA, i, uint64(m.NumTxs))
 		i--
@@ -1804,9 +1712,6 @@ func (m *PartSetHeader) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -1825,9 +1730,6 @@ func (m *Part) Size() (n int) {
 	}
 	l = m.Proof.Size()
 	n += 1 + l + sovTypes(uint64(l))
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -1843,9 +1745,6 @@ func (m *BlockID) Size() (n int) {
 	}
 	l = m.PartsHeader.Size()
 	n += 1 + l + sovTypes(uint64(l))
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -1904,9 +1803,6 @@ func (m *Header) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -1926,9 +1822,6 @@ func (m *Data) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -1962,9 +1855,6 @@ func (m *Vote) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -1996,9 +1886,6 @@ func (m *Commit) Size() (n int) {
 		l = m.BitArray.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -2021,9 +1908,6 @@ func (m *CommitSig) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -2053,9 +1937,6 @@ func (m *Proposal) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -2073,9 +1954,6 @@ func (m *SignedHeader) Size() (n int) {
 		l = m.Commit.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -2095,9 +1973,6 @@ func (m *BlockMeta) Size() (n int) {
 	if m.NumTxs != 0 {
 		n += 1 + sovTypes(uint64(m.NumTxs))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -2204,7 +2079,6 @@ func (m *PartSetHeader) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2344,7 +2218,6 @@ func (m *Part) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2465,7 +2338,6 @@ func (m *BlockID) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -2975,7 +2847,6 @@ func (m *Header) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3095,7 +2966,6 @@ func (m *Data) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3359,7 +3229,6 @@ func (m *Vote) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3588,7 +3457,6 @@ func (m *Commit) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3762,7 +3630,6 @@ func (m *CommitSig) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -3992,7 +3859,6 @@ func (m *Proposal) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4118,7 +3984,6 @@ func (m *SignedHeader) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -4276,7 +4141,6 @@ func (m *BlockMeta) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}

proto/types/types.proto

@@ -9,11 +9,6 @@ import "proto/libs/bits/types.proto";
 import "proto/crypto/merkle/types.proto";
 import "proto/version/version.proto";
 
-option (gogoproto.marshaler_all)        = true;
-option (gogoproto.unmarshaler_all)      = true;
-option (gogoproto.sizer_all)            = true;
-option (gogoproto.goproto_registration) = true;
-
 // BlockIdFlag indicates which BlcokID the signature is for
 enum BlockIDFlag {
   option (gogoproto.goproto_enum_stringer) = false;

proto/types/validator.pb.go

@@ -8,7 +8,9 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 	keys "github.com/tendermint/tendermint/proto/crypto/keys"
+	io "io"
 	math "math"
+	math_bits "math/bits"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -23,12 +25,9 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type ValidatorSet struct {
-	Validators           []*Validator `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators,omitempty"`
-	Proposer             *Validator   `protobuf:"bytes,2,opt,name=proposer,proto3" json:"proposer,omitempty"`
-	TotalVotingPower     int64        `protobuf:"varint,3,opt,name=total_voting_power,json=totalVotingPower,proto3" json:"total_voting_power,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
-	XXX_unrecognized     []byte       `json:"-"`
-	XXX_sizecache        int32        `json:"-"`
+	Validators       []*Validator `protobuf:"bytes,1,rep,name=validators,proto3" json:"validators,omitempty"`
+	Proposer         *Validator   `protobuf:"bytes,2,opt,name=proposer,proto3" json:"proposer,omitempty"`
+	TotalVotingPower int64        `protobuf:"varint,3,opt,name=total_voting_power,json=totalVotingPower,proto3" json:"total_voting_power,omitempty"`
 }
 
 func (m *ValidatorSet) Reset()         { *m = ValidatorSet{} }
@@ -38,16 +37,25 @@ func (*ValidatorSet) Descriptor() ([]byte, []int) {
 	return fileDescriptor_2e7c6b38c20e5406, []int{0}
 }
 func (m *ValidatorSet) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_ValidatorSet.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *ValidatorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_ValidatorSet.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_ValidatorSet.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *ValidatorSet) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_ValidatorSet.Merge(m, src)
 }
 func (m *ValidatorSet) XXX_Size() int {
-	return xxx_messageInfo_ValidatorSet.Size(m)
+	return m.Size()
 }
 func (m *ValidatorSet) XXX_DiscardUnknown() {
 	xxx_messageInfo_ValidatorSet.DiscardUnknown(m)
@@ -77,13 +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"`
-	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
-	XXX_unrecognized     []byte         `json:"-"`
-	XXX_sizecache        int32          `json:"-"`
+	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"`
 }
 
 func (m *Validator) Reset()         { *m = Validator{} }
@@ -93,16 +98,25 @@ func (*Validator) Descriptor() ([]byte, []int) {
 	return fileDescriptor_2e7c6b38c20e5406, []int{1}
 }
 func (m *Validator) XXX_Unmarshal(b []byte) error {
-	return xxx_messageInfo_Validator.Unmarshal(m, b)
+	return m.Unmarshal(b)
 }
 func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
-	return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
+	if deterministic {
+		return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
 }
 func (m *Validator) XXX_Merge(src proto.Message) {
 	xxx_messageInfo_Validator.Merge(m, src)
 }
 func (m *Validator) XXX_Size() int {
-	return xxx_messageInfo_Validator.Size(m)
+	return m.Size()
 }
 func (m *Validator) XXX_DiscardUnknown() {
 	xxx_messageInfo_Validator.DiscardUnknown(m)
@@ -146,26 +160,577 @@ func init() {
 func init() { proto.RegisterFile("proto/types/validator.proto", fileDescriptor_2e7c6b38c20e5406) }
 
 var fileDescriptor_2e7c6b38c20e5406 = []byte{
-	// 325 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xbd, 0x4e, 0x02, 0x41,
-	0x10, 0xc7, 0x5d, 0x21, 0xa0, 0x0b, 0x85, 0x6e, 0x61, 0x2e, 0x18, 0x23, 0x50, 0x28, 0x89, 0x64,
-	0x2f, 0xd1, 0xda, 0x42, 0x0a, 0x1b, 0x1a, 0x72, 0x26, 0x14, 0x36, 0x97, 0x3b, 0x6e, 0x73, 0x6c,
-	0xf8, 0x98, 0xcd, 0xdc, 0x1c, 0x66, 0x1f, 0x4e, 0x6b, 0x9f, 0xc2, 0x67, 0x31, 0xdc, 0x72, 0x07,
-	0x89, 0x14, 0x76, 0x33, 0xff, 0xff, 0x7c, 0xfc, 0x76, 0xb2, 0xfc, 0xda, 0x20, 0x10, 0xf8, 0x64,
-	0x8d, 0xca, 0xfc, 0x4d, 0xb4, 0xd4, 0x49, 0x44, 0x80, 0xb2, 0x50, 0xc5, 0x15, 0xa9, 0x75, 0xa2,
-	0x70, 0xa5, 0xd7, 0xe4, 0x14, 0x59, 0xd4, 0x75, 0xee, 0x68, 0xae, 0x31, 0x09, 0x4d, 0x84, 0x64,
-	0x7d, 0x37, 0x20, 0x85, 0x14, 0xf6, 0x91, 0xab, 0xee, 0xdc, 0x38, 0x65, 0x86, 0xd6, 0x10, 0xf8,
-	0x0b, 0x65, 0x33, 0xb7, 0xc8, 0xd9, 0xfd, 0x2f, 0xc6, 0xdb, 0xd3, 0x72, 0xe5, 0x9b, 0x22, 0xf1,
-	0xc2, 0x79, 0x85, 0x90, 0x79, 0xac, 0x5b, 0x1b, 0xb4, 0x1e, 0x7b, 0xf2, 0x38, 0x84, 0xac, 0x3a,
-	0x83, 0x83, 0x26, 0xf1, 0xcc, 0xcf, 0x0c, 0x82, 0x81, 0x4c, 0xa1, 0x77, 0xda, 0x65, 0xff, 0x1b,
-	0x50, 0xb5, 0x88, 0x21, 0x17, 0x04, 0x14, 0x2d, 0xc3, 0x0d, 0x90, 0x5e, 0xa7, 0xa1, 0x81, 0x0f,
-	0x85, 0x5e, 0xad, 0xcb, 0x06, 0xb5, 0xe0, 0xa2, 0x70, 0xa6, 0x85, 0x31, 0xd9, 0xea, 0xfd, 0x4f,
-	0xc6, 0xcf, 0xab, 0x29, 0xc2, 0xe3, 0xcd, 0x28, 0x49, 0x50, 0x65, 0x5b, 0x74, 0x36, 0x68, 0x07,
-	0x65, 0x2a, 0x5e, 0x79, 0xd3, 0xe4, 0x71, 0xb8, 0x50, 0x76, 0xc7, 0x74, 0xff, 0x97, 0xc9, 0x1d,
-	0x49, 0x6e, 0x8f, 0x24, 0x27, 0x79, 0xbc, 0xd4, 0xb3, 0xb1, 0xb2, 0xa3, 0xfa, 0xf7, 0xcf, 0xed,
-	0x49, 0xd0, 0x30, 0x79, 0x3c, 0x56, 0x56, 0xf4, 0x78, 0xfb, 0x08, 0x57, 0x6b, 0xb3, 0x47, 0x12,
-	0x0f, 0xfc, 0xb2, 0x7c, 0x4c, 0x68, 0x50, 0x03, 0x6a, 0xb2, 0x5e, 0xdd, 0xf1, 0x97, 0xc6, 0x64,
-	0xa7, 0x8f, 0xe4, 0xfb, 0x30, 0xd5, 0x34, 0xcf, 0x63, 0x39, 0x83, 0x95, 0xbf, 0x47, 0x3a, 0x0c,
-	0x0f, 0xfe, 0x47, 0xdc, 0x28, 0x92, 0xa7, 0xdf, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x28, 0xeb,
-	0x40, 0x35, 0x02, 0x00, 0x00,
+	// 354 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xbd, 0x6e, 0xea, 0x30,
+	0x14, 0xc7, 0xe3, 0x0b, 0x82, 0x7b, 0x0d, 0xc3, 0xad, 0x87, 0x2a, 0xa2, 0x6a, 0x0a, 0x0c, 0x2d,
+	0x52, 0x91, 0x23, 0xb5, 0x73, 0x87, 0x32, 0xb0, 0xb0, 0xa0, 0x54, 0x62, 0xe8, 0x12, 0x25, 0xc4,
+	0x0a, 0x16, 0x1f, 0xb6, 0x9c, 0x13, 0x2a, 0xbf, 0x45, 0x5f, 0xa8, 0x9d, 0x19, 0x19, 0x3b, 0x55,
+	0x15, 0xbc, 0x48, 0x45, 0x4c, 0x02, 0x52, 0x19, 0xba, 0x9d, 0xf3, 0xff, 0x9f, 0x8f, 0x9f, 0x8f,
+	0x8c, 0x2f, 0xa4, 0x12, 0x20, 0x5c, 0xd0, 0x92, 0x25, 0xee, 0x32, 0x98, 0xf1, 0x28, 0x00, 0xa1,
+	0x68, 0xa6, 0x92, 0x73, 0x60, 0x8b, 0x88, 0xa9, 0x39, 0x5f, 0x80, 0x51, 0x68, 0x56, 0xd7, 0xb8,
+	0x86, 0x09, 0x57, 0x91, 0x2f, 0x03, 0x05, 0xda, 0x35, 0x03, 0x62, 0x11, 0x8b, 0x43, 0x64, 0xaa,
+	0x1b, 0x97, 0x46, 0x19, 0x2b, 0x2d, 0x41, 0xb8, 0x53, 0xa6, 0x13, 0xb3, 0xc8, 0xd8, 0xed, 0x77,
+	0x84, 0xeb, 0xa3, 0x7c, 0xe5, 0x13, 0x03, 0xf2, 0x88, 0x71, 0x81, 0x90, 0xd8, 0xa8, 0x59, 0xea,
+	0xd4, 0xee, 0x5a, 0xf4, 0x34, 0x04, 0x2d, 0x3a, 0xbd, 0xa3, 0x26, 0xf2, 0x80, 0xff, 0x4a, 0x25,
+	0xa4, 0x48, 0x98, 0xb2, 0xff, 0x34, 0xd1, 0xef, 0x06, 0x14, 0x2d, 0xa4, 0x8b, 0x09, 0x08, 0x08,
+	0x66, 0xfe, 0x52, 0x00, 0x5f, 0xc4, 0xbe, 0x14, 0x2f, 0x4c, 0xd9, 0xa5, 0x26, 0xea, 0x94, 0xbc,
+	0xff, 0x99, 0x33, 0xca, 0x8c, 0xe1, 0x4e, 0x6f, 0xbf, 0x21, 0xfc, 0xaf, 0x98, 0x42, 0x6c, 0x5c,
+	0x0d, 0xa2, 0x48, 0xb1, 0x64, 0x87, 0x8e, 0x3a, 0x75, 0x2f, 0x4f, 0x49, 0x1f, 0x57, 0x65, 0x1a,
+	0xfa, 0x53, 0xa6, 0xf7, 0x4c, 0x37, 0x3f, 0x99, 0xcc, 0x91, 0xe8, 0xee, 0x48, 0x74, 0x98, 0x86,
+	0x33, 0x3e, 0x1e, 0x30, 0xdd, 0x2b, 0xaf, 0x3e, 0xaf, 0x2c, 0xaf, 0x22, 0xd3, 0x70, 0xc0, 0x34,
+	0x69, 0xe1, 0xfa, 0x09, 0xae, 0xda, 0xf2, 0x80, 0x44, 0x6e, 0xf1, 0x59, 0xfe, 0x18, 0x5f, 0x2a,
+	0x2e, 0x14, 0x07, 0x6d, 0x97, 0x0d, 0x7f, 0x6e, 0x0c, 0xf7, 0x7a, 0xaf, 0xbf, 0xda, 0x38, 0x68,
+	0xbd, 0x71, 0xd0, 0xd7, 0xc6, 0x41, 0xaf, 0x5b, 0xc7, 0x5a, 0x6f, 0x1d, 0xeb, 0x63, 0xeb, 0x58,
+	0xcf, 0xdd, 0x98, 0xc3, 0x24, 0x0d, 0xe9, 0x58, 0xcc, 0xdd, 0x03, 0xea, 0x71, 0x78, 0xf4, 0x6f,
+	0xc2, 0x4a, 0x96, 0xdc, 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0xd9, 0x3e, 0xe6, 0x5d, 0x4d, 0x02,
+	0x00, 0x00,
+}
+
+func (m *ValidatorSet) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ValidatorSet) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ValidatorSet) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.TotalVotingPower != 0 {
+		i = encodeVarintValidator(dAtA, i, uint64(m.TotalVotingPower))
+		i--
+		dAtA[i] = 0x18
+	}
+	if m.Proposer != nil {
+		{
+			size, err := m.Proposer.MarshalToSizedBuffer(dAtA[:i])
+			if err != nil {
+				return 0, err
+			}
+			i -= size
+			i = encodeVarintValidator(dAtA, i, uint64(size))
+		}
+		i--
+		dAtA[i] = 0x12
+	}
+	if len(m.Validators) > 0 {
+		for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- {
+			{
+				size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+				if err != nil {
+					return 0, err
+				}
+				i -= size
+				i = encodeVarintValidator(dAtA, i, uint64(size))
+			}
+			i--
+			dAtA[i] = 0xa
+		}
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *Validator) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Validator) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.ProposerPriority != 0 {
+		i = encodeVarintValidator(dAtA, i, uint64(m.ProposerPriority))
+		i--
+		dAtA[i] = 0x20
+	}
+	if m.VotingPower != 0 {
+		i = encodeVarintValidator(dAtA, i, uint64(m.VotingPower))
+		i--
+		dAtA[i] = 0x18
+	}
+	{
+		size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintValidator(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	if len(m.Address) > 0 {
+		i -= len(m.Address)
+		copy(dAtA[i:], m.Address)
+		i = encodeVarintValidator(dAtA, i, uint64(len(m.Address)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func encodeVarintValidator(dAtA []byte, offset int, v uint64) int {
+	offset -= sovValidator(v)
+	base := offset
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return base
+}
+func (m *ValidatorSet) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if len(m.Validators) > 0 {
+		for _, e := range m.Validators {
+			l = e.Size()
+			n += 1 + l + sovValidator(uint64(l))
+		}
+	}
+	if m.Proposer != nil {
+		l = m.Proposer.Size()
+		n += 1 + l + sovValidator(uint64(l))
+	}
+	if m.TotalVotingPower != 0 {
+		n += 1 + sovValidator(uint64(m.TotalVotingPower))
+	}
+	return n
+}
+
+func (m *Validator) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Address)
+	if l > 0 {
+		n += 1 + l + sovValidator(uint64(l))
+	}
+	l = m.PubKey.Size()
+	n += 1 + l + sovValidator(uint64(l))
+	if m.VotingPower != 0 {
+		n += 1 + sovValidator(uint64(m.VotingPower))
+	}
+	if m.ProposerPriority != 0 {
+		n += 1 + sovValidator(uint64(m.ProposerPriority))
+	}
+	return n
 }
+
+func sovValidator(x uint64) (n int) {
+	return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozValidator(x uint64) (n int) {
+	return sovValidator(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *ValidatorSet) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowValidator
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ValidatorSet: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ValidatorSet: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthValidator
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Validators = append(m.Validators, &Validator{})
+			if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Proposer", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthValidator
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Proposer == nil {
+				m.Proposer = &Validator{}
+			}
+			if err := m.Proposer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TotalVotingPower", wireType)
+			}
+			m.TotalVotingPower = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TotalVotingPower |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipValidator(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Validator) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowValidator
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Validator: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthValidator
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
+			if m.Address == nil {
+				m.Address = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthValidator
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field VotingPower", wireType)
+			}
+			m.VotingPower = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.VotingPower |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ProposerPriority", wireType)
+			}
+			m.ProposerPriority = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ProposerPriority |= int64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipValidator(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if (iNdEx + skippy) < 0 {
+				return ErrInvalidLengthValidator
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipValidator(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	depth := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowValidator
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+		case 1:
+			iNdEx += 8
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowValidator
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if length < 0 {
+				return 0, ErrInvalidLengthValidator
+			}
+			iNdEx += length
+		case 3:
+			depth++
+		case 4:
+			if depth == 0 {
+				return 0, ErrUnexpectedEndOfGroupValidator
+			}
+			depth--
+		case 5:
+			iNdEx += 4
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+		if iNdEx < 0 {
+			return 0, ErrInvalidLengthValidator
+		}
+		if depth == 0 {
+			return iNdEx, nil
+		}
+	}
+	return 0, io.ErrUnexpectedEOF
+}
+
+var (
+	ErrInvalidLengthValidator        = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowValidator          = fmt.Errorf("proto: integer overflow")
+	ErrUnexpectedEndOfGroupValidator = fmt.Errorf("proto: unexpected end of group")
+)

proto/version/version.pb.go

@@ -4,11 +4,9 @@
 package version
 
 import (
-	bytes "bytes"
 	fmt "fmt"
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	golang_proto "github.com/golang/protobuf/proto"
 	io "io"
 	math "math"
 	math_bits "math/bits"
@@ -16,7 +14,6 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
-var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
@@ -30,11 +27,8 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 // This information is included in ResponseInfo. The App.Protocol can be
 // updated in ResponseEndBlock.
 type App struct {
-	Protocol             uint64   `protobuf:"varint,1,opt,name=protocol,proto3" json:"protocol,omitempty"`
-	Software             string   `protobuf:"bytes,2,opt,name=software,proto3" json:"software,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Protocol uint64 `protobuf:"varint,1,opt,name=protocol,proto3" json:"protocol,omitempty"`
+	Software string `protobuf:"bytes,2,opt,name=software,proto3" json:"software,omitempty"`
 }
 
 func (m *App) Reset()         { *m = App{} }
@@ -88,11 +82,8 @@ func (m *App) GetSoftware() string {
 // including all blockchain data structures and the rules of the application's
 // state transition machine.
 type Consensus struct {
-	Block                uint64   `protobuf:"varint,1,opt,name=block,proto3" json:"block,omitempty"`
-	App                  uint64   `protobuf:"varint,2,opt,name=app,proto3" json:"app,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Block uint64 `protobuf:"varint,1,opt,name=block,proto3" json:"block,omitempty"`
+	App   uint64 `protobuf:"varint,2,opt,name=app,proto3" json:"app,omitempty"`
 }
 
 func (m *Consensus) Reset()         { *m = Consensus{} }
@@ -144,18 +135,13 @@ func (m *Consensus) GetApp() uint64 {
 
 func init() {
 	proto.RegisterType((*App)(nil), "tendermint.proto.version.App")
-	golang_proto.RegisterType((*App)(nil), "tendermint.proto.version.App")
 	proto.RegisterType((*Consensus)(nil), "tendermint.proto.version.Consensus")
-	golang_proto.RegisterType((*Consensus)(nil), "tendermint.proto.version.Consensus")
 }
 
 func init() { proto.RegisterFile("proto/version/version.proto", fileDescriptor_14aa2353622f11e1) }
-func init() {
-	golang_proto.RegisterFile("proto/version/version.proto", fileDescriptor_14aa2353622f11e1)
-}
 
 var fileDescriptor_14aa2353622f11e1 = []byte{
-	// 216 bytes of a gzipped FileDescriptorProto
+	// 224 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2e, 0x28, 0xca, 0x2f,
 	0xc9, 0xd7, 0x2f, 0x4b, 0x2d, 0x2a, 0xce, 0xcc, 0xcf, 0x83, 0xd1, 0x7a, 0x60, 0x51, 0x21, 0x89,
 	0x92, 0xd4, 0xbc, 0x94, 0xd4, 0xa2, 0xdc, 0xcc, 0xbc, 0x12, 0x88, 0x88, 0x1e, 0x54, 0x5e, 0x4a,
@@ -166,10 +152,10 @@ var fileDescriptor_14aa2353622f11e1 = []byte{
 	0x38, 0x5f, 0xc9, 0x92, 0x8b, 0xd3, 0x39, 0x3f, 0xaf, 0x38, 0x35, 0xaf, 0xb8, 0xb4, 0x58, 0x48,
 	0x84, 0x8b, 0x35, 0x29, 0x27, 0x3f, 0x39, 0x1b, 0x6a, 0x02, 0x84, 0x23, 0x24, 0xc0, 0xc5, 0x9c,
 	0x58, 0x50, 0x00, 0xd6, 0xc9, 0x12, 0x04, 0x62, 0x5a, 0xb1, 0xbc, 0x58, 0x20, 0xcf, 0xe8, 0xe4,
-	0x70, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x1e, 0x78, 0x2c,
-	0xc7, 0x18, 0xa5, 0x97, 0x9e, 0x59, 0x92, 0x51, 0x9a, 0xa4, 0x97, 0x9c, 0x9f, 0xab, 0x8f, 0xf0,
-	0x18, 0x32, 0x13, 0x25, 0x2c, 0x92, 0xd8, 0xc0, 0x5c, 0x63, 0x40, 0x00, 0x00, 0x00, 0xff, 0xff,
-	0xe4, 0xc8, 0xb4, 0x99, 0x23, 0x01, 0x00, 0x00,
+	0x71, 0xe2, 0x91, 0x1c, 0xe3, 0x85, 0x47, 0x72, 0x8c, 0x0f, 0x1e, 0xc9, 0x31, 0x4e, 0x78, 0x2c,
+	0xc7, 0x70, 0xe1, 0xb1, 0x1c, 0xc3, 0x8d, 0xc7, 0x72, 0x0c, 0x51, 0x7a, 0xe9, 0x99, 0x25, 0x19,
+	0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0x08, 0x0f, 0x22, 0x33, 0x51, 0xc2, 0x24, 0x89, 0x0d,
+	0xcc, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x05, 0x3a, 0xdb, 0xd4, 0x2b, 0x01, 0x00, 0x00,
 }
 
 func (this *Consensus) Equal(that interface{}) bool {
@@ -197,9 +183,6 @@ func (this *Consensus) Equal(that interface{}) bool {
 	if this.App != that1.App {
 		return false
 	}
-	if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) {
-		return false
-	}
 	return true
 }
 func (m *App) Marshal() (dAtA []byte, err error) {
@@ -222,10 +205,6 @@ func (m *App) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Software) > 0 {
 		i -= len(m.Software)
 		copy(dAtA[i:], m.Software)
@@ -261,10 +240,6 @@ func (m *Consensus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.App != 0 {
 		i = encodeVarintVersion(dAtA, i, uint64(m.App))
 		i--
@@ -302,9 +277,6 @@ func (m *App) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovVersion(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -320,9 +292,6 @@ func (m *Consensus) Size() (n int) {
 	if m.App != 0 {
 		n += 1 + sovVersion(uint64(m.App))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -427,7 +396,6 @@ func (m *App) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -519,7 +487,6 @@ func (m *Consensus) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}

proto/version/version.proto

@@ -5,11 +5,6 @@ option go_package = "github.com/tendermint/tendermint/proto/version";
 
 import "third_party/proto/gogoproto/gogo.proto";
 
-option (gogoproto.marshaler_all)        = true;
-option (gogoproto.unmarshaler_all)      = true;
-option (gogoproto.sizer_all)            = true;
-option (gogoproto.goproto_registration) = true;
-
 // App includes the protocol and software version for the application.
 // This information is included in ResponseInfo. The App.Protocol can be
 // updated in ResponseEndBlock.

rpc/grpc/types.pb.go

@@ -6,9 +6,7 @@ package coregrpc
 import (
 	context "context"
 	fmt "fmt"
-	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
-	golang_proto "github.com/golang/protobuf/proto"
 	types "github.com/tendermint/tendermint/abci/types"
 	grpc "google.golang.org/grpc"
 	codes "google.golang.org/grpc/codes"
@@ -20,7 +18,6 @@ import (
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
-var _ = golang_proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
 
@@ -31,9 +28,6 @@ var _ = math.Inf
 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 
 type RequestPing struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *RequestPing) Reset()         { *m = RequestPing{} }
@@ -70,10 +64,7 @@ func (m *RequestPing) XXX_DiscardUnknown() {
 var xxx_messageInfo_RequestPing proto.InternalMessageInfo
 
 type RequestBroadcastTx struct {
-	Tx                   []byte   `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
+	Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
 }
 
 func (m *RequestBroadcastTx) Reset()         { *m = RequestBroadcastTx{} }
@@ -117,9 +108,6 @@ func (m *RequestBroadcastTx) GetTx() []byte {
 }
 
 type ResponsePing struct {
-	XXX_NoUnkeyedLiteral struct{} `json:"-"`
-	XXX_unrecognized     []byte   `json:"-"`
-	XXX_sizecache        int32    `json:"-"`
 }
 
 func (m *ResponsePing) Reset()         { *m = ResponsePing{} }
@@ -156,11 +144,8 @@ func (m *ResponsePing) XXX_DiscardUnknown() {
 var xxx_messageInfo_ResponsePing proto.InternalMessageInfo
 
 type ResponseBroadcastTx struct {
-	CheckTx              *types.ResponseCheckTx   `protobuf:"bytes,1,opt,name=check_tx,json=checkTx,proto3" json:"check_tx,omitempty"`
-	DeliverTx            *types.ResponseDeliverTx `protobuf:"bytes,2,opt,name=deliver_tx,json=deliverTx,proto3" json:"deliver_tx,omitempty"`
-	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
-	XXX_unrecognized     []byte                   `json:"-"`
-	XXX_sizecache        int32                    `json:"-"`
+	CheckTx   *types.ResponseCheckTx   `protobuf:"bytes,1,opt,name=check_tx,json=checkTx,proto3" json:"check_tx,omitempty"`
+	DeliverTx *types.ResponseDeliverTx `protobuf:"bytes,2,opt,name=deliver_tx,json=deliverTx,proto3" json:"deliver_tx,omitempty"`
 }
 
 func (m *ResponseBroadcastTx) Reset()         { *m = ResponseBroadcastTx{} }
@@ -212,41 +197,35 @@ func (m *ResponseBroadcastTx) GetDeliverTx() *types.ResponseDeliverTx {
 
 func init() {
 	proto.RegisterType((*RequestPing)(nil), "tendermint.rpc.grpc.RequestPing")
-	golang_proto.RegisterType((*RequestPing)(nil), "tendermint.rpc.grpc.RequestPing")
 	proto.RegisterType((*RequestBroadcastTx)(nil), "tendermint.rpc.grpc.RequestBroadcastTx")
-	golang_proto.RegisterType((*RequestBroadcastTx)(nil), "tendermint.rpc.grpc.RequestBroadcastTx")
 	proto.RegisterType((*ResponsePing)(nil), "tendermint.rpc.grpc.ResponsePing")
-	golang_proto.RegisterType((*ResponsePing)(nil), "tendermint.rpc.grpc.ResponsePing")
 	proto.RegisterType((*ResponseBroadcastTx)(nil), "tendermint.rpc.grpc.ResponseBroadcastTx")
-	golang_proto.RegisterType((*ResponseBroadcastTx)(nil), "tendermint.rpc.grpc.ResponseBroadcastTx")
 }
 
 func init() { proto.RegisterFile("rpc/grpc/types.proto", fileDescriptor_15f63baabf91876a) }
-func init() { golang_proto.RegisterFile("rpc/grpc/types.proto", fileDescriptor_15f63baabf91876a) }
 
 var fileDescriptor_15f63baabf91876a = []byte{
-	// 330 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xcd, 0x4a, 0xc3, 0x40,
-	0x14, 0x85, 0x99, 0x22, 0xfe, 0xdc, 0xd6, 0x2e, 0xa6, 0x22, 0x92, 0x45, 0xa8, 0x45, 0x6a, 0x57,
-	0x13, 0xa8, 0x4b, 0x57, 0xad, 0x05, 0x11, 0x37, 0x25, 0x74, 0xe5, 0xa6, 0xa6, 0x93, 0x21, 0x19,
-	0xb4, 0x99, 0x71, 0x32, 0x95, 0xf4, 0x71, 0x7c, 0x10, 0xc1, 0xa5, 0x4b, 0x1f, 0x41, 0xe2, 0x8b,
-	0xc8, 0x24, 0x8d, 0x99, 0x85, 0xd6, 0x4d, 0x38, 0xb9, 0x7c, 0xe7, 0x70, 0xee, 0x4d, 0xe0, 0x48,
-	0x49, 0xea, 0x45, 0xe6, 0xa1, 0xd7, 0x92, 0xa5, 0x44, 0x2a, 0xa1, 0x05, 0xee, 0x68, 0x96, 0x84,
-	0x4c, 0x2d, 0x79, 0xa2, 0x89, 0x92, 0x94, 0x18, 0xc0, 0x39, 0x0e, 0x16, 0x94, 0x97, 0x98, 0x0d,
-	0x3b, 0x7d, 0x1d, 0x73, 0x15, 0xce, 0x65, 0xa0, 0xf4, 0xda, 0x2b, 0x46, 0x5e, 0x24, 0x22, 0x51,
-	0xab, 0x92, 0xeb, 0x1d, 0x42, 0xd3, 0x67, 0x4f, 0x2b, 0x96, 0xea, 0x29, 0x4f, 0xa2, 0xde, 0x19,
-	0xe0, 0xcd, 0xeb, 0x58, 0x89, 0x20, 0xa4, 0x41, 0xaa, 0x67, 0x19, 0x6e, 0x43, 0x43, 0x67, 0x27,
-	0xa8, 0x8b, 0x06, 0x2d, 0xbf, 0xa1, 0xb3, 0x5e, 0x1b, 0x5a, 0x3e, 0x4b, 0xa5, 0x48, 0x52, 0x56,
-	0xb8, 0x5e, 0x10, 0x74, 0xaa, 0x81, 0xed, 0x1b, 0xc1, 0x3e, 0x8d, 0x19, 0x7d, 0x98, 0x6f, 0xdc,
-	0xcd, 0x61, 0x9f, 0x58, 0x4b, 0x98, 0xea, 0xa4, 0x2c, 0x5d, 0xb9, 0xaf, 0x0c, 0x3e, 0xcb, 0xfc,
-	0x3d, 0x5a, 0x0a, 0x7c, 0x0d, 0x10, 0xb2, 0x47, 0xfe, 0xcc, 0x94, 0x09, 0x69, 0x14, 0x21, 0x83,
-	0x7f, 0x42, 0x26, 0xa5, 0x61, 0x96, 0xf9, 0x07, 0x61, 0x25, 0x87, 0xaf, 0x08, 0x5a, 0x3f, 0xdd,
-	0x46, 0xd3, 0x1b, 0x7c, 0x0b, 0x3b, 0xa6, 0x3c, 0xee, 0x92, 0x5f, 0xee, 0x4a, 0xac, 0xa3, 0x38,
-	0xa7, 0x7f, 0x10, 0xf5, 0x05, 0xf0, 0x3d, 0x34, 0xed, 0xc5, 0xcf, 0xb7, 0x65, 0x5a, 0xa0, 0x33,
-	0xd8, 0x1a, 0x6d, 0x91, 0xe3, 0xc9, 0x7b, 0xee, 0xa2, 0x8f, 0xdc, 0x45, 0x9f, 0xb9, 0x8b, 0xde,
-	0xbe, 0x5c, 0x74, 0x37, 0x8c, 0xb8, 0x8e, 0x57, 0x0b, 0x42, 0xc5, 0xd2, 0xab, 0x53, 0x6c, 0x59,
-	0xfd, 0x46, 0x97, 0x54, 0x28, 0x66, 0xc4, 0x62, 0xb7, 0xf8, 0xea, 0x17, 0xdf, 0x01, 0x00, 0x00,
-	0xff, 0xff, 0x21, 0xfc, 0xde, 0xc4, 0x62, 0x02, 0x00, 0x00,
+	// 317 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x29, 0x2a, 0x48, 0xd6,
+	0x4f, 0x07, 0x11, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x7a, 0x05, 0x45, 0xf9, 0x25, 0xf9, 0x42, 0xc2,
+	0x25, 0xa9, 0x79, 0x29, 0xa9, 0x45, 0xb9, 0x99, 0x79, 0x25, 0x7a, 0x45, 0x05, 0xc9, 0x7a, 0x20,
+	0x05, 0x52, 0x62, 0x89, 0x49, 0xc9, 0x99, 0x10, 0x65, 0xc8, 0x8a, 0x95, 0x78, 0xb9, 0xb8, 0x83,
+	0x52, 0x0b, 0x4b, 0x53, 0x8b, 0x4b, 0x02, 0x32, 0xf3, 0xd2, 0x95, 0x54, 0xb8, 0x84, 0xa0, 0x5c,
+	0xa7, 0xa2, 0xfc, 0xc4, 0x94, 0xe4, 0xc4, 0xe2, 0x92, 0x90, 0x0a, 0x21, 0x3e, 0x2e, 0xa6, 0x92,
+	0x0a, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x9e, 0x20, 0xa6, 0x92, 0x0a, 0x25, 0x3e, 0x2e, 0x9e, 0xa0,
+	0xd4, 0xe2, 0x82, 0xfc, 0xbc, 0xe2, 0x54, 0xb0, 0xae, 0x85, 0x8c, 0x5c, 0xc2, 0x30, 0x01, 0x64,
+	0x7d, 0x8e, 0x5c, 0x1c, 0xc9, 0x19, 0xa9, 0xc9, 0xd9, 0xf1, 0x50, 0xdd, 0xdc, 0x46, 0x6a, 0x7a,
+	0x48, 0x8e, 0x03, 0x39, 0x49, 0x0f, 0xe2, 0x18, 0x98, 0x6e, 0x67, 0x90, 0xf2, 0x90, 0x8a, 0x20,
+	0xf6, 0x64, 0x08, 0x43, 0xc8, 0x9d, 0x8b, 0x2b, 0x25, 0x35, 0x27, 0xb3, 0x2c, 0xb5, 0x08, 0x64,
+	0x08, 0x13, 0xd8, 0x10, 0x0d, 0x02, 0x86, 0xb8, 0x40, 0x34, 0x84, 0x54, 0x04, 0x71, 0xa6, 0xc0,
+	0x98, 0x46, 0x7b, 0x19, 0xb9, 0x78, 0xe0, 0x6e, 0x73, 0x0c, 0xf0, 0x14, 0xf2, 0xe6, 0x62, 0x01,
+	0x39, 0x5e, 0x48, 0x41, 0x0f, 0x4b, 0x78, 0xe9, 0x21, 0x05, 0x8a, 0x94, 0x22, 0x0e, 0x15, 0x88,
+	0x10, 0x10, 0x4a, 0xe0, 0xe2, 0x46, 0xf6, 0xb8, 0x3a, 0x3e, 0x33, 0x91, 0x14, 0x4a, 0x69, 0xe0,
+	0x35, 0x1a, 0x49, 0xa5, 0x93, 0xcf, 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78,
+	0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c, 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44,
+	0x19, 0xa5, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x23, 0x4c, 0x43, 0x66,
+	0xc2, 0x92, 0x89, 0x75, 0x72, 0x7e, 0x51, 0x2a, 0x88, 0x91, 0xc4, 0x06, 0x8e, 0x7d, 0x63, 0x40,
+	0x00, 0x00, 0x00, 0xff, 0xff, 0xdb, 0x5d, 0xfe, 0x6b, 0x42, 0x02, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -385,10 +364,6 @@ func (m *RequestPing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	return len(dAtA) - i, nil
 }
 
@@ -412,10 +387,6 @@ func (m *RequestBroadcastTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if len(m.Tx) > 0 {
 		i -= len(m.Tx)
 		copy(dAtA[i:], m.Tx)
@@ -446,10 +417,6 @@ func (m *ResponsePing) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	return len(dAtA) - i, nil
 }
 
@@ -473,10 +440,6 @@ func (m *ResponseBroadcastTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		i -= len(m.XXX_unrecognized)
-		copy(dAtA[i:], m.XXX_unrecognized)
-	}
 	if m.DeliverTx != nil {
 		{
 			size, err := m.DeliverTx.MarshalToSizedBuffer(dAtA[:i])
@@ -521,9 +484,6 @@ func (m *RequestPing) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -537,9 +497,6 @@ func (m *RequestBroadcastTx) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -549,9 +506,6 @@ func (m *ResponsePing) Size() (n int) {
 	}
 	var l int
 	_ = l
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -569,9 +523,6 @@ func (m *ResponseBroadcastTx) Size() (n int) {
 		l = m.DeliverTx.Size()
 		n += 1 + l + sovTypes(uint64(l))
 	}
-	if m.XXX_unrecognized != nil {
-		n += len(m.XXX_unrecognized)
-	}
 	return n
 }
 
@@ -625,7 +576,6 @@ func (m *RequestPing) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -713,7 +663,6 @@ func (m *RequestBroadcastTx) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -767,7 +716,6 @@ func (m *ResponsePing) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}
@@ -893,7 +841,6 @@ func (m *ResponseBroadcastTx) Unmarshal(dAtA []byte) error {
 			if (iNdEx + skippy) > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
 			iNdEx += skippy
 		}
 	}

rpc/grpc/types.proto

@@ -3,13 +3,6 @@ package tendermint.rpc.grpc;
 option  go_package = "github.com/tendermint/tendermint/rpc/grpc;coregrpc";
 
 import "abci/types/types.proto";
-import "third_party/proto/gogoproto/gogo.proto";
-
-option (gogoproto.marshaler_all)        = true;
-option (gogoproto.unmarshaler_all)      = true;
-option (gogoproto.sizer_all)            = true;
-option (gogoproto.goproto_registration) = true;
-
 
 //----------------------------------------
 // Request types

scripts/protocgen.sh

@@ -6,6 +6,6 @@ proto_dirs=$(find . -path ./third_party -prune -o -name '*.proto' -print0 | xarg
 for dir in $proto_dirs; do
   protoc \
   -I. \
-  --gogo_out=Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc,paths=source_relative:. \
+  --gogofaster_out=Mgoogle/protobuf/timestamp.proto=github.com/golang/protobuf/ptypes/timestamp,Mgoogle/protobuf/duration.proto=github.com/golang/protobuf/ptypes/duration,plugins=grpc,paths=source_relative:. \
   $(find "${dir}" -maxdepth 1 -name '*.proto')
 done

types/proto3_test.go

@@ -4,7 +4,7 @@ import (
 	"testing"
 	"time"
 
-	"github.com/golang/protobuf/proto"
+	"github.com/gogo/protobuf/proto"
 	"github.com/stretchr/testify/assert"
 
 	"github.com/tendermint/tendermint/types/proto3"