mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-09-26 09:54:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

proto: change to use gogofaster (#4957)

Browse Source
This commit is contained in:
Marko
2020-06-05 14:18:44 +02:00
committed by GitHub
parent b9af87c4ea
commit b4aca980e9
34 changed files with 21089 additions and 2521 deletions
Download Patch File Download Diff File Expand all files Collapse all files
proto/types/block.pb.go
+398 -14
View File
@@ -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
+307 -14
View File
@@ -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/evidence.pb.go
+2404 -124
View File
File diff suppressed because it is too large Load Diff
proto/types/params.pb.go
+1044 -85
View File
File diff suppressed because it is too large Load Diff
proto/types/types.pb.go
+123 -259
View File
@@ -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
-5
View File
@@ -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
+606 -41
View File
@@ -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")
)