github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/tm34/proto/tendermint/state/types.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/state/types.proto 3 4 package state 5 6 import ( 7 fmt "fmt" 8 _ "github.com/gogo/protobuf/gogoproto" 9 proto "github.com/gogo/protobuf/proto" 10 _ "github.com/gogo/protobuf/types" 11 github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" 12 types1 "github.com/supragya/TendermintConnector/chains/tm34/proto/tendermint/types" 13 version "github.com/supragya/TendermintConnector/chains/tm34/proto/tendermint/version" 14 types "github.com/tendermint/tendermint/abci/types" 15 io "io" 16 math "math" 17 math_bits "math/bits" 18 time "time" 19 ) 20 21 // Reference imports to suppress errors if they are not otherwise used. 22 var _ = proto.Marshal 23 var _ = fmt.Errorf 24 var _ = math.Inf 25 var _ = time.Kitchen 26 27 // This is a compile-time assertion to ensure that this generated file 28 // is compatible with the proto package it is being compiled against. 29 // A compilation error at this line likely means your copy of the 30 // proto package needs to be updated. 31 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 32 33 // ABCIResponses retains the responses 34 // of the various ABCI calls during block processing. 35 // It is persisted to disk for each height before calling Commit. 36 type ABCIResponses struct { 37 DeliverTxs []*types.ResponseDeliverTx `protobuf:"bytes,1,rep,name=deliver_txs,json=deliverTxs,proto3" json:"deliver_txs,omitempty"` 38 EndBlock *types.ResponseEndBlock `protobuf:"bytes,2,opt,name=end_block,json=endBlock,proto3" json:"end_block,omitempty"` 39 BeginBlock *types.ResponseBeginBlock `protobuf:"bytes,3,opt,name=begin_block,json=beginBlock,proto3" json:"begin_block,omitempty"` 40 } 41 42 func (m *ABCIResponses) Reset() { *m = ABCIResponses{} } 43 func (m *ABCIResponses) String() string { return proto.CompactTextString(m) } 44 func (*ABCIResponses) ProtoMessage() {} 45 func (*ABCIResponses) Descriptor() ([]byte, []int) { 46 return fileDescriptor_ccfacf933f22bf93, []int{0} 47 } 48 func (m *ABCIResponses) XXX_Unmarshal(b []byte) error { 49 return m.Unmarshal(b) 50 } 51 func (m *ABCIResponses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 52 if deterministic { 53 return xxx_messageInfo_ABCIResponses.Marshal(b, m, deterministic) 54 } else { 55 b = b[:cap(b)] 56 n, err := m.MarshalToSizedBuffer(b) 57 if err != nil { 58 return nil, err 59 } 60 return b[:n], nil 61 } 62 } 63 func (m *ABCIResponses) XXX_Merge(src proto.Message) { 64 xxx_messageInfo_ABCIResponses.Merge(m, src) 65 } 66 func (m *ABCIResponses) XXX_Size() int { 67 return m.Size() 68 } 69 func (m *ABCIResponses) XXX_DiscardUnknown() { 70 xxx_messageInfo_ABCIResponses.DiscardUnknown(m) 71 } 72 73 var xxx_messageInfo_ABCIResponses proto.InternalMessageInfo 74 75 func (m *ABCIResponses) GetDeliverTxs() []*types.ResponseDeliverTx { 76 if m != nil { 77 return m.DeliverTxs 78 } 79 return nil 80 } 81 82 func (m *ABCIResponses) GetEndBlock() *types.ResponseEndBlock { 83 if m != nil { 84 return m.EndBlock 85 } 86 return nil 87 } 88 89 func (m *ABCIResponses) GetBeginBlock() *types.ResponseBeginBlock { 90 if m != nil { 91 return m.BeginBlock 92 } 93 return nil 94 } 95 96 // ValidatorsInfo represents the latest validator set, or the last height it changed 97 type ValidatorsInfo struct { 98 ValidatorSet *types1.ValidatorSet `protobuf:"bytes,1,opt,name=validator_set,json=validatorSet,proto3" json:"validator_set,omitempty"` 99 LastHeightChanged int64 `protobuf:"varint,2,opt,name=last_height_changed,json=lastHeightChanged,proto3" json:"last_height_changed,omitempty"` 100 } 101 102 func (m *ValidatorsInfo) Reset() { *m = ValidatorsInfo{} } 103 func (m *ValidatorsInfo) String() string { return proto.CompactTextString(m) } 104 func (*ValidatorsInfo) ProtoMessage() {} 105 func (*ValidatorsInfo) Descriptor() ([]byte, []int) { 106 return fileDescriptor_ccfacf933f22bf93, []int{1} 107 } 108 func (m *ValidatorsInfo) XXX_Unmarshal(b []byte) error { 109 return m.Unmarshal(b) 110 } 111 func (m *ValidatorsInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 112 if deterministic { 113 return xxx_messageInfo_ValidatorsInfo.Marshal(b, m, deterministic) 114 } else { 115 b = b[:cap(b)] 116 n, err := m.MarshalToSizedBuffer(b) 117 if err != nil { 118 return nil, err 119 } 120 return b[:n], nil 121 } 122 } 123 func (m *ValidatorsInfo) XXX_Merge(src proto.Message) { 124 xxx_messageInfo_ValidatorsInfo.Merge(m, src) 125 } 126 func (m *ValidatorsInfo) XXX_Size() int { 127 return m.Size() 128 } 129 func (m *ValidatorsInfo) XXX_DiscardUnknown() { 130 xxx_messageInfo_ValidatorsInfo.DiscardUnknown(m) 131 } 132 133 var xxx_messageInfo_ValidatorsInfo proto.InternalMessageInfo 134 135 func (m *ValidatorsInfo) GetValidatorSet() *types1.ValidatorSet { 136 if m != nil { 137 return m.ValidatorSet 138 } 139 return nil 140 } 141 142 func (m *ValidatorsInfo) GetLastHeightChanged() int64 { 143 if m != nil { 144 return m.LastHeightChanged 145 } 146 return 0 147 } 148 149 // ConsensusParamsInfo represents the latest consensus params, or the last height it changed 150 type ConsensusParamsInfo struct { 151 ConsensusParams types1.ConsensusParams `protobuf:"bytes,1,opt,name=consensus_params,json=consensusParams,proto3" json:"consensus_params"` 152 LastHeightChanged int64 `protobuf:"varint,2,opt,name=last_height_changed,json=lastHeightChanged,proto3" json:"last_height_changed,omitempty"` 153 } 154 155 func (m *ConsensusParamsInfo) Reset() { *m = ConsensusParamsInfo{} } 156 func (m *ConsensusParamsInfo) String() string { return proto.CompactTextString(m) } 157 func (*ConsensusParamsInfo) ProtoMessage() {} 158 func (*ConsensusParamsInfo) Descriptor() ([]byte, []int) { 159 return fileDescriptor_ccfacf933f22bf93, []int{2} 160 } 161 func (m *ConsensusParamsInfo) XXX_Unmarshal(b []byte) error { 162 return m.Unmarshal(b) 163 } 164 func (m *ConsensusParamsInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 165 if deterministic { 166 return xxx_messageInfo_ConsensusParamsInfo.Marshal(b, m, deterministic) 167 } else { 168 b = b[:cap(b)] 169 n, err := m.MarshalToSizedBuffer(b) 170 if err != nil { 171 return nil, err 172 } 173 return b[:n], nil 174 } 175 } 176 func (m *ConsensusParamsInfo) XXX_Merge(src proto.Message) { 177 xxx_messageInfo_ConsensusParamsInfo.Merge(m, src) 178 } 179 func (m *ConsensusParamsInfo) XXX_Size() int { 180 return m.Size() 181 } 182 func (m *ConsensusParamsInfo) XXX_DiscardUnknown() { 183 xxx_messageInfo_ConsensusParamsInfo.DiscardUnknown(m) 184 } 185 186 var xxx_messageInfo_ConsensusParamsInfo proto.InternalMessageInfo 187 188 func (m *ConsensusParamsInfo) GetConsensusParams() types1.ConsensusParams { 189 if m != nil { 190 return m.ConsensusParams 191 } 192 return types1.ConsensusParams{} 193 } 194 195 func (m *ConsensusParamsInfo) GetLastHeightChanged() int64 { 196 if m != nil { 197 return m.LastHeightChanged 198 } 199 return 0 200 } 201 202 type Version struct { 203 Consensus version.Consensus `protobuf:"bytes,1,opt,name=consensus,proto3" json:"consensus"` 204 Software string `protobuf:"bytes,2,opt,name=software,proto3" json:"software,omitempty"` 205 } 206 207 func (m *Version) Reset() { *m = Version{} } 208 func (m *Version) String() string { return proto.CompactTextString(m) } 209 func (*Version) ProtoMessage() {} 210 func (*Version) Descriptor() ([]byte, []int) { 211 return fileDescriptor_ccfacf933f22bf93, []int{3} 212 } 213 func (m *Version) XXX_Unmarshal(b []byte) error { 214 return m.Unmarshal(b) 215 } 216 func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 217 if deterministic { 218 return xxx_messageInfo_Version.Marshal(b, m, deterministic) 219 } else { 220 b = b[:cap(b)] 221 n, err := m.MarshalToSizedBuffer(b) 222 if err != nil { 223 return nil, err 224 } 225 return b[:n], nil 226 } 227 } 228 func (m *Version) XXX_Merge(src proto.Message) { 229 xxx_messageInfo_Version.Merge(m, src) 230 } 231 func (m *Version) XXX_Size() int { 232 return m.Size() 233 } 234 func (m *Version) XXX_DiscardUnknown() { 235 xxx_messageInfo_Version.DiscardUnknown(m) 236 } 237 238 var xxx_messageInfo_Version proto.InternalMessageInfo 239 240 func (m *Version) GetConsensus() version.Consensus { 241 if m != nil { 242 return m.Consensus 243 } 244 return version.Consensus{} 245 } 246 247 func (m *Version) GetSoftware() string { 248 if m != nil { 249 return m.Software 250 } 251 return "" 252 } 253 254 type State struct { 255 Version Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version"` 256 // immutable 257 ChainID string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` 258 InitialHeight int64 `protobuf:"varint,14,opt,name=initial_height,json=initialHeight,proto3" json:"initial_height,omitempty"` 259 // LastBlockHeight=0 at genesis (ie. block(H=0) does not exist) 260 LastBlockHeight int64 `protobuf:"varint,3,opt,name=last_block_height,json=lastBlockHeight,proto3" json:"last_block_height,omitempty"` 261 LastBlockID types1.BlockID `protobuf:"bytes,4,opt,name=last_block_id,json=lastBlockId,proto3" json:"last_block_id"` 262 LastBlockTime time.Time `protobuf:"bytes,5,opt,name=last_block_time,json=lastBlockTime,proto3,stdtime" json:"last_block_time"` 263 // LastValidators is used to validate block.LastCommit. 264 // Validators are persisted to the database separately every time they change, 265 // so we can query for historical validator sets. 266 // Note that if s.LastBlockHeight causes a valset change, 267 // we set s.LastHeightValidatorsChanged = s.LastBlockHeight + 1 + 1 268 // Extra +1 due to nextValSet delay. 269 NextValidators *types1.ValidatorSet `protobuf:"bytes,6,opt,name=next_validators,json=nextValidators,proto3" json:"next_validators,omitempty"` 270 Validators *types1.ValidatorSet `protobuf:"bytes,7,opt,name=validators,proto3" json:"validators,omitempty"` 271 LastValidators *types1.ValidatorSet `protobuf:"bytes,8,opt,name=last_validators,json=lastValidators,proto3" json:"last_validators,omitempty"` 272 LastHeightValidatorsChanged int64 `protobuf:"varint,9,opt,name=last_height_validators_changed,json=lastHeightValidatorsChanged,proto3" json:"last_height_validators_changed,omitempty"` 273 // Consensus parameters used for validating blocks. 274 // Changes returned by EndBlock and updated after Commit. 275 ConsensusParams types1.ConsensusParams `protobuf:"bytes,10,opt,name=consensus_params,json=consensusParams,proto3" json:"consensus_params"` 276 LastHeightConsensusParamsChanged int64 `protobuf:"varint,11,opt,name=last_height_consensus_params_changed,json=lastHeightConsensusParamsChanged,proto3" json:"last_height_consensus_params_changed,omitempty"` 277 // Merkle root of the results from executing prev block 278 LastResultsHash []byte `protobuf:"bytes,12,opt,name=last_results_hash,json=lastResultsHash,proto3" json:"last_results_hash,omitempty"` 279 // the latest AppHash we've received from calling abci.Commit() 280 AppHash []byte `protobuf:"bytes,13,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` 281 } 282 283 func (m *State) Reset() { *m = State{} } 284 func (m *State) String() string { return proto.CompactTextString(m) } 285 func (*State) ProtoMessage() {} 286 func (*State) Descriptor() ([]byte, []int) { 287 return fileDescriptor_ccfacf933f22bf93, []int{4} 288 } 289 func (m *State) XXX_Unmarshal(b []byte) error { 290 return m.Unmarshal(b) 291 } 292 func (m *State) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 293 if deterministic { 294 return xxx_messageInfo_State.Marshal(b, m, deterministic) 295 } else { 296 b = b[:cap(b)] 297 n, err := m.MarshalToSizedBuffer(b) 298 if err != nil { 299 return nil, err 300 } 301 return b[:n], nil 302 } 303 } 304 func (m *State) XXX_Merge(src proto.Message) { 305 xxx_messageInfo_State.Merge(m, src) 306 } 307 func (m *State) XXX_Size() int { 308 return m.Size() 309 } 310 func (m *State) XXX_DiscardUnknown() { 311 xxx_messageInfo_State.DiscardUnknown(m) 312 } 313 314 var xxx_messageInfo_State proto.InternalMessageInfo 315 316 func (m *State) GetVersion() Version { 317 if m != nil { 318 return m.Version 319 } 320 return Version{} 321 } 322 323 func (m *State) GetChainID() string { 324 if m != nil { 325 return m.ChainID 326 } 327 return "" 328 } 329 330 func (m *State) GetInitialHeight() int64 { 331 if m != nil { 332 return m.InitialHeight 333 } 334 return 0 335 } 336 337 func (m *State) GetLastBlockHeight() int64 { 338 if m != nil { 339 return m.LastBlockHeight 340 } 341 return 0 342 } 343 344 func (m *State) GetLastBlockID() types1.BlockID { 345 if m != nil { 346 return m.LastBlockID 347 } 348 return types1.BlockID{} 349 } 350 351 func (m *State) GetLastBlockTime() time.Time { 352 if m != nil { 353 return m.LastBlockTime 354 } 355 return time.Time{} 356 } 357 358 func (m *State) GetNextValidators() *types1.ValidatorSet { 359 if m != nil { 360 return m.NextValidators 361 } 362 return nil 363 } 364 365 func (m *State) GetValidators() *types1.ValidatorSet { 366 if m != nil { 367 return m.Validators 368 } 369 return nil 370 } 371 372 func (m *State) GetLastValidators() *types1.ValidatorSet { 373 if m != nil { 374 return m.LastValidators 375 } 376 return nil 377 } 378 379 func (m *State) GetLastHeightValidatorsChanged() int64 { 380 if m != nil { 381 return m.LastHeightValidatorsChanged 382 } 383 return 0 384 } 385 386 func (m *State) GetConsensusParams() types1.ConsensusParams { 387 if m != nil { 388 return m.ConsensusParams 389 } 390 return types1.ConsensusParams{} 391 } 392 393 func (m *State) GetLastHeightConsensusParamsChanged() int64 { 394 if m != nil { 395 return m.LastHeightConsensusParamsChanged 396 } 397 return 0 398 } 399 400 func (m *State) GetLastResultsHash() []byte { 401 if m != nil { 402 return m.LastResultsHash 403 } 404 return nil 405 } 406 407 func (m *State) GetAppHash() []byte { 408 if m != nil { 409 return m.AppHash 410 } 411 return nil 412 } 413 414 func init() { 415 proto.RegisterType((*ABCIResponses)(nil), "tendermint.state.ABCIResponses") 416 proto.RegisterType((*ValidatorsInfo)(nil), "tendermint.state.ValidatorsInfo") 417 proto.RegisterType((*ConsensusParamsInfo)(nil), "tendermint.state.ConsensusParamsInfo") 418 proto.RegisterType((*Version)(nil), "tendermint.state.Version") 419 proto.RegisterType((*State)(nil), "tendermint.state.State") 420 } 421 422 func init() { proto.RegisterFile("tendermint/state/types.proto", fileDescriptor_ccfacf933f22bf93) } 423 424 var fileDescriptor_ccfacf933f22bf93 = []byte{ 425 // 787 bytes of a gzipped FileDescriptorProto 426 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x95, 0xcf, 0x4f, 0xe3, 0x46, 427 0x14, 0xc7, 0xe3, 0x06, 0x48, 0x32, 0x26, 0x09, 0x1d, 0x7a, 0x30, 0xa1, 0x38, 0x21, 0xfd, 0x21, 428 0xd4, 0x83, 0x2d, 0x41, 0x2f, 0xbd, 0x20, 0x61, 0xa7, 0x2a, 0xa9, 0x50, 0x55, 0x19, 0xc4, 0xa1, 429 0x17, 0x6b, 0x62, 0x0f, 0xb6, 0xd5, 0xc4, 0xb6, 0x3c, 0x93, 0x14, 0xfe, 0x80, 0xde, 0xb9, 0xee, 430 0x7f, 0xc4, 0x91, 0xe3, 0x6a, 0x0f, 0xec, 0x6e, 0xf8, 0x47, 0x56, 0x33, 0x63, 0x3b, 0x93, 0x64, 431 0x91, 0x58, 0xed, 0x6d, 0x3c, 0xef, 0xfb, 0x3e, 0xf3, 0x9d, 0x37, 0xef, 0xc9, 0xe0, 0x7b, 0x8a, 432 0x63, 0x1f, 0x67, 0x93, 0x28, 0xa6, 0x26, 0xa1, 0x88, 0x62, 0x93, 0xde, 0xa5, 0x98, 0x18, 0x69, 433 0x96, 0xd0, 0x04, 0xee, 0x2c, 0xa2, 0x06, 0x8f, 0x76, 0xbe, 0x0b, 0x92, 0x20, 0xe1, 0x41, 0x93, 434 0xad, 0x84, 0xae, 0xb3, 0x2f, 0x51, 0xd0, 0xc8, 0x8b, 0x64, 0x48, 0x47, 0x3e, 0x82, 0xef, 0x2f, 435 0x45, 0x7b, 0x6b, 0xd1, 0x19, 0x1a, 0x47, 0x3e, 0xa2, 0x49, 0x96, 0x2b, 0x0e, 0xd6, 0x14, 0x29, 436 0xca, 0xd0, 0xa4, 0x00, 0xe8, 0x52, 0x78, 0x86, 0x33, 0x12, 0x25, 0xf1, 0xd2, 0x01, 0xdd, 0x20, 437 0x49, 0x82, 0x31, 0x36, 0xf9, 0xd7, 0x68, 0x7a, 0x63, 0xd2, 0x68, 0x82, 0x09, 0x45, 0x93, 0x54, 438 0x08, 0xfa, 0xef, 0x14, 0xd0, 0x3c, 0xb3, 0xec, 0xa1, 0x83, 0x49, 0x9a, 0xc4, 0x04, 0x13, 0x68, 439 0x03, 0xd5, 0xc7, 0xe3, 0x68, 0x86, 0x33, 0x97, 0xde, 0x12, 0x4d, 0xe9, 0x55, 0x8f, 0xd4, 0xe3, 440 0xbe, 0x21, 0x15, 0x83, 0x5d, 0xd2, 0x28, 0x12, 0x06, 0x42, 0x7b, 0x75, 0xeb, 0x00, 0xbf, 0x58, 441 0x12, 0x78, 0x0a, 0x1a, 0x38, 0xf6, 0xdd, 0xd1, 0x38, 0xf1, 0xfe, 0xd5, 0xbe, 0xe9, 0x29, 0x47, 442 0xea, 0xf1, 0xe1, 0x8b, 0x88, 0xdf, 0x63, 0xdf, 0x62, 0x42, 0xa7, 0x8e, 0xf3, 0x15, 0x1c, 0x00, 443 0x75, 0x84, 0x83, 0x28, 0xce, 0x09, 0x55, 0x4e, 0xf8, 0xe1, 0x45, 0x82, 0xc5, 0xb4, 0x82, 0x01, 444 0x46, 0xe5, 0xba, 0xff, 0xbf, 0x02, 0x5a, 0xd7, 0x45, 0x41, 0xc9, 0x30, 0xbe, 0x49, 0xa0, 0x0d, 445 0x9a, 0x65, 0x89, 0x5d, 0x82, 0xa9, 0xa6, 0x70, 0xb4, 0x2e, 0xa3, 0x45, 0x01, 0xcb, 0xc4, 0x4b, 446 0x4c, 0x9d, 0xed, 0x99, 0xf4, 0x05, 0x0d, 0xb0, 0x3b, 0x46, 0x84, 0xba, 0x21, 0x8e, 0x82, 0x90, 447 0xba, 0x5e, 0x88, 0xe2, 0x00, 0xfb, 0xfc, 0x9e, 0x55, 0xe7, 0x5b, 0x16, 0x3a, 0xe7, 0x11, 0x5b, 448 0x04, 0xfa, 0x6f, 0x14, 0xb0, 0x6b, 0x33, 0x9f, 0x31, 0x99, 0x92, 0xbf, 0xf9, 0xfb, 0x71, 0x33, 449 0x0e, 0xd8, 0xf1, 0x8a, 0x6d, 0x57, 0xbc, 0x6b, 0xee, 0xe7, 0x70, 0xdd, 0xcf, 0x0a, 0xc0, 0xda, 450 0x78, 0x78, 0xea, 0x56, 0x9c, 0xb6, 0xb7, 0xbc, 0xfd, 0xc5, 0xde, 0x42, 0x50, 0xbb, 0x16, 0x8d, 451 0x03, 0xcf, 0x40, 0xa3, 0xa4, 0xe5, 0x3e, 0x0e, 0x64, 0x1f, 0x79, 0x83, 0x2d, 0x9c, 0xe4, 0x1e, 452 0x16, 0x59, 0xb0, 0x03, 0xea, 0x24, 0xb9, 0xa1, 0xff, 0xa1, 0x0c, 0xf3, 0x23, 0x1b, 0x4e, 0xf9, 453 0xdd, 0xff, 0xb8, 0x05, 0x36, 0x2f, 0xd9, 0x1c, 0xc1, 0xdf, 0x40, 0x2d, 0x67, 0xe5, 0xc7, 0xec, 454 0x19, 0xab, 0xb3, 0x66, 0xe4, 0xa6, 0xf2, 0x23, 0x0a, 0x3d, 0xfc, 0x19, 0xd4, 0xbd, 0x10, 0x45, 455 0xb1, 0x1b, 0x89, 0x3b, 0x35, 0x2c, 0x75, 0xfe, 0xd4, 0xad, 0xd9, 0x6c, 0x6f, 0x38, 0x70, 0x6a, 456 0x3c, 0x38, 0xf4, 0xe1, 0x4f, 0xa0, 0x15, 0xc5, 0x11, 0x8d, 0xd0, 0x38, 0xaf, 0x84, 0xd6, 0xe2, 457 0x15, 0x68, 0xe6, 0xbb, 0xa2, 0x08, 0xf0, 0x17, 0xc0, 0x4b, 0x22, 0xda, 0xac, 0x50, 0x56, 0xb9, 458 0xb2, 0xcd, 0x02, 0xbc, 0x8f, 0x72, 0xad, 0x03, 0x9a, 0x92, 0x36, 0xf2, 0xb5, 0x8d, 0x75, 0xef, 459 0xe2, 0xa9, 0x78, 0xd6, 0x70, 0x60, 0xed, 0x32, 0xef, 0xf3, 0xa7, 0xae, 0x7a, 0x51, 0xa0, 0x86, 460 0x03, 0x47, 0x2d, 0xb9, 0x43, 0x1f, 0x5e, 0x80, 0xb6, 0xc4, 0x64, 0xc3, 0xa9, 0x6d, 0x72, 0x6a, 461 0xc7, 0x10, 0x93, 0x6b, 0x14, 0x93, 0x6b, 0x5c, 0x15, 0x93, 0x6b, 0xd5, 0x19, 0xf6, 0xfe, 0x7d, 462 0x57, 0x71, 0x9a, 0x25, 0x8b, 0x45, 0xe1, 0x1f, 0xa0, 0x1d, 0xe3, 0x5b, 0xea, 0x96, 0xcd, 0x4a, 463 0xb4, 0xad, 0x57, 0xb5, 0x77, 0x8b, 0xa5, 0x2d, 0x26, 0x05, 0x9e, 0x02, 0x20, 0x31, 0x6a, 0xaf, 464 0x62, 0x48, 0x19, 0xcc, 0x08, 0xbf, 0x96, 0x04, 0xa9, 0xbf, 0xce, 0x08, 0x4b, 0x93, 0x8c, 0xd8, 465 0x40, 0x97, 0xbb, 0x79, 0xc1, 0x2b, 0x1b, 0xbb, 0xc1, 0x1f, 0x6b, 0x7f, 0xd1, 0xd8, 0x8b, 0xec, 466 0xbc, 0xc5, 0x3f, 0x3b, 0x66, 0xe0, 0x2b, 0xc7, 0xec, 0x2f, 0xf0, 0xe3, 0xd2, 0x98, 0xad, 0xf0, 467 0x4b, 0x7b, 0x2a, 0xb7, 0xd7, 0x93, 0xe6, 0x6e, 0x19, 0x54, 0x78, 0x2c, 0x1a, 0x31, 0xc3, 0x64, 468 0x3a, 0xa6, 0xc4, 0x0d, 0x11, 0x09, 0xb5, 0xed, 0x9e, 0x72, 0xb4, 0x2d, 0x1a, 0xd1, 0x11, 0xfb, 469 0xe7, 0x88, 0x84, 0x70, 0x0f, 0xd4, 0x51, 0x9a, 0x0a, 0x49, 0x93, 0x4b, 0x6a, 0x28, 0x4d, 0x59, 470 0xc8, 0xf2, 0x1f, 0xe6, 0xba, 0xf2, 0x38, 0xd7, 0x95, 0x0f, 0x73, 0x5d, 0xb9, 0x7f, 0xd6, 0x2b, 471 0x8f, 0xcf, 0x7a, 0xe5, 0xed, 0xb3, 0x5e, 0xf9, 0xe7, 0xcf, 0x20, 0xa2, 0xe1, 0x74, 0x64, 0x78, 472 0xc9, 0xc4, 0x24, 0xd3, 0x34, 0x43, 0xc1, 0x1d, 0x32, 0xaf, 0xca, 0xdb, 0xdb, 0x49, 0x1c, 0x63, 473 0x8f, 0x26, 0x99, 0xc9, 0x27, 0x88, 0x98, 0x74, 0x72, 0xf2, 0xab, 0xf8, 0x6d, 0x98, 0xab, 0x7f, 474 0xc9, 0xd1, 0x16, 0xdf, 0x3f, 0xf9, 0x14, 0x00, 0x00, 0xff, 0xff, 0xf8, 0xcb, 0x21, 0xa6, 0x40, 475 0x07, 0x00, 0x00, 476 } 477 478 func (m *ABCIResponses) Marshal() (dAtA []byte, err error) { 479 size := m.Size() 480 dAtA = make([]byte, size) 481 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 482 if err != nil { 483 return nil, err 484 } 485 return dAtA[:n], nil 486 } 487 488 func (m *ABCIResponses) MarshalTo(dAtA []byte) (int, error) { 489 size := m.Size() 490 return m.MarshalToSizedBuffer(dAtA[:size]) 491 } 492 493 func (m *ABCIResponses) MarshalToSizedBuffer(dAtA []byte) (int, error) { 494 i := len(dAtA) 495 _ = i 496 var l int 497 _ = l 498 if m.BeginBlock != nil { 499 { 500 size, err := m.BeginBlock.MarshalToSizedBuffer(dAtA[:i]) 501 if err != nil { 502 return 0, err 503 } 504 i -= size 505 i = encodeVarintTypes(dAtA, i, uint64(size)) 506 } 507 i-- 508 dAtA[i] = 0x1a 509 } 510 if m.EndBlock != nil { 511 { 512 size, err := m.EndBlock.MarshalToSizedBuffer(dAtA[:i]) 513 if err != nil { 514 return 0, err 515 } 516 i -= size 517 i = encodeVarintTypes(dAtA, i, uint64(size)) 518 } 519 i-- 520 dAtA[i] = 0x12 521 } 522 if len(m.DeliverTxs) > 0 { 523 for iNdEx := len(m.DeliverTxs) - 1; iNdEx >= 0; iNdEx-- { 524 { 525 size, err := m.DeliverTxs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 526 if err != nil { 527 return 0, err 528 } 529 i -= size 530 i = encodeVarintTypes(dAtA, i, uint64(size)) 531 } 532 i-- 533 dAtA[i] = 0xa 534 } 535 } 536 return len(dAtA) - i, nil 537 } 538 539 func (m *ValidatorsInfo) Marshal() (dAtA []byte, err error) { 540 size := m.Size() 541 dAtA = make([]byte, size) 542 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 543 if err != nil { 544 return nil, err 545 } 546 return dAtA[:n], nil 547 } 548 549 func (m *ValidatorsInfo) MarshalTo(dAtA []byte) (int, error) { 550 size := m.Size() 551 return m.MarshalToSizedBuffer(dAtA[:size]) 552 } 553 554 func (m *ValidatorsInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 555 i := len(dAtA) 556 _ = i 557 var l int 558 _ = l 559 if m.LastHeightChanged != 0 { 560 i = encodeVarintTypes(dAtA, i, uint64(m.LastHeightChanged)) 561 i-- 562 dAtA[i] = 0x10 563 } 564 if m.ValidatorSet != nil { 565 { 566 size, err := m.ValidatorSet.MarshalToSizedBuffer(dAtA[:i]) 567 if err != nil { 568 return 0, err 569 } 570 i -= size 571 i = encodeVarintTypes(dAtA, i, uint64(size)) 572 } 573 i-- 574 dAtA[i] = 0xa 575 } 576 return len(dAtA) - i, nil 577 } 578 579 func (m *ConsensusParamsInfo) Marshal() (dAtA []byte, err error) { 580 size := m.Size() 581 dAtA = make([]byte, size) 582 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 583 if err != nil { 584 return nil, err 585 } 586 return dAtA[:n], nil 587 } 588 589 func (m *ConsensusParamsInfo) MarshalTo(dAtA []byte) (int, error) { 590 size := m.Size() 591 return m.MarshalToSizedBuffer(dAtA[:size]) 592 } 593 594 func (m *ConsensusParamsInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 595 i := len(dAtA) 596 _ = i 597 var l int 598 _ = l 599 if m.LastHeightChanged != 0 { 600 i = encodeVarintTypes(dAtA, i, uint64(m.LastHeightChanged)) 601 i-- 602 dAtA[i] = 0x10 603 } 604 { 605 size, err := m.ConsensusParams.MarshalToSizedBuffer(dAtA[:i]) 606 if err != nil { 607 return 0, err 608 } 609 i -= size 610 i = encodeVarintTypes(dAtA, i, uint64(size)) 611 } 612 i-- 613 dAtA[i] = 0xa 614 return len(dAtA) - i, nil 615 } 616 617 func (m *Version) Marshal() (dAtA []byte, err error) { 618 size := m.Size() 619 dAtA = make([]byte, size) 620 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 621 if err != nil { 622 return nil, err 623 } 624 return dAtA[:n], nil 625 } 626 627 func (m *Version) MarshalTo(dAtA []byte) (int, error) { 628 size := m.Size() 629 return m.MarshalToSizedBuffer(dAtA[:size]) 630 } 631 632 func (m *Version) MarshalToSizedBuffer(dAtA []byte) (int, error) { 633 i := len(dAtA) 634 _ = i 635 var l int 636 _ = l 637 if len(m.Software) > 0 { 638 i -= len(m.Software) 639 copy(dAtA[i:], m.Software) 640 i = encodeVarintTypes(dAtA, i, uint64(len(m.Software))) 641 i-- 642 dAtA[i] = 0x12 643 } 644 { 645 size, err := m.Consensus.MarshalToSizedBuffer(dAtA[:i]) 646 if err != nil { 647 return 0, err 648 } 649 i -= size 650 i = encodeVarintTypes(dAtA, i, uint64(size)) 651 } 652 i-- 653 dAtA[i] = 0xa 654 return len(dAtA) - i, nil 655 } 656 657 func (m *State) Marshal() (dAtA []byte, err error) { 658 size := m.Size() 659 dAtA = make([]byte, size) 660 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 661 if err != nil { 662 return nil, err 663 } 664 return dAtA[:n], nil 665 } 666 667 func (m *State) MarshalTo(dAtA []byte) (int, error) { 668 size := m.Size() 669 return m.MarshalToSizedBuffer(dAtA[:size]) 670 } 671 672 func (m *State) MarshalToSizedBuffer(dAtA []byte) (int, error) { 673 i := len(dAtA) 674 _ = i 675 var l int 676 _ = l 677 if m.InitialHeight != 0 { 678 i = encodeVarintTypes(dAtA, i, uint64(m.InitialHeight)) 679 i-- 680 dAtA[i] = 0x70 681 } 682 if len(m.AppHash) > 0 { 683 i -= len(m.AppHash) 684 copy(dAtA[i:], m.AppHash) 685 i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) 686 i-- 687 dAtA[i] = 0x6a 688 } 689 if len(m.LastResultsHash) > 0 { 690 i -= len(m.LastResultsHash) 691 copy(dAtA[i:], m.LastResultsHash) 692 i = encodeVarintTypes(dAtA, i, uint64(len(m.LastResultsHash))) 693 i-- 694 dAtA[i] = 0x62 695 } 696 if m.LastHeightConsensusParamsChanged != 0 { 697 i = encodeVarintTypes(dAtA, i, uint64(m.LastHeightConsensusParamsChanged)) 698 i-- 699 dAtA[i] = 0x58 700 } 701 { 702 size, err := m.ConsensusParams.MarshalToSizedBuffer(dAtA[:i]) 703 if err != nil { 704 return 0, err 705 } 706 i -= size 707 i = encodeVarintTypes(dAtA, i, uint64(size)) 708 } 709 i-- 710 dAtA[i] = 0x52 711 if m.LastHeightValidatorsChanged != 0 { 712 i = encodeVarintTypes(dAtA, i, uint64(m.LastHeightValidatorsChanged)) 713 i-- 714 dAtA[i] = 0x48 715 } 716 if m.LastValidators != nil { 717 { 718 size, err := m.LastValidators.MarshalToSizedBuffer(dAtA[:i]) 719 if err != nil { 720 return 0, err 721 } 722 i -= size 723 i = encodeVarintTypes(dAtA, i, uint64(size)) 724 } 725 i-- 726 dAtA[i] = 0x42 727 } 728 if m.Validators != nil { 729 { 730 size, err := m.Validators.MarshalToSizedBuffer(dAtA[:i]) 731 if err != nil { 732 return 0, err 733 } 734 i -= size 735 i = encodeVarintTypes(dAtA, i, uint64(size)) 736 } 737 i-- 738 dAtA[i] = 0x3a 739 } 740 if m.NextValidators != nil { 741 { 742 size, err := m.NextValidators.MarshalToSizedBuffer(dAtA[:i]) 743 if err != nil { 744 return 0, err 745 } 746 i -= size 747 i = encodeVarintTypes(dAtA, i, uint64(size)) 748 } 749 i-- 750 dAtA[i] = 0x32 751 } 752 n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastBlockTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastBlockTime):]) 753 if err10 != nil { 754 return 0, err10 755 } 756 i -= n10 757 i = encodeVarintTypes(dAtA, i, uint64(n10)) 758 i-- 759 dAtA[i] = 0x2a 760 { 761 size, err := m.LastBlockID.MarshalToSizedBuffer(dAtA[:i]) 762 if err != nil { 763 return 0, err 764 } 765 i -= size 766 i = encodeVarintTypes(dAtA, i, uint64(size)) 767 } 768 i-- 769 dAtA[i] = 0x22 770 if m.LastBlockHeight != 0 { 771 i = encodeVarintTypes(dAtA, i, uint64(m.LastBlockHeight)) 772 i-- 773 dAtA[i] = 0x18 774 } 775 if len(m.ChainID) > 0 { 776 i -= len(m.ChainID) 777 copy(dAtA[i:], m.ChainID) 778 i = encodeVarintTypes(dAtA, i, uint64(len(m.ChainID))) 779 i-- 780 dAtA[i] = 0x12 781 } 782 { 783 size, err := m.Version.MarshalToSizedBuffer(dAtA[:i]) 784 if err != nil { 785 return 0, err 786 } 787 i -= size 788 i = encodeVarintTypes(dAtA, i, uint64(size)) 789 } 790 i-- 791 dAtA[i] = 0xa 792 return len(dAtA) - i, nil 793 } 794 795 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { 796 offset -= sovTypes(v) 797 base := offset 798 for v >= 1<<7 { 799 dAtA[offset] = uint8(v&0x7f | 0x80) 800 v >>= 7 801 offset++ 802 } 803 dAtA[offset] = uint8(v) 804 return base 805 } 806 func (m *ABCIResponses) Size() (n int) { 807 if m == nil { 808 return 0 809 } 810 var l int 811 _ = l 812 if len(m.DeliverTxs) > 0 { 813 for _, e := range m.DeliverTxs { 814 l = e.Size() 815 n += 1 + l + sovTypes(uint64(l)) 816 } 817 } 818 if m.EndBlock != nil { 819 l = m.EndBlock.Size() 820 n += 1 + l + sovTypes(uint64(l)) 821 } 822 if m.BeginBlock != nil { 823 l = m.BeginBlock.Size() 824 n += 1 + l + sovTypes(uint64(l)) 825 } 826 return n 827 } 828 829 func (m *ValidatorsInfo) Size() (n int) { 830 if m == nil { 831 return 0 832 } 833 var l int 834 _ = l 835 if m.ValidatorSet != nil { 836 l = m.ValidatorSet.Size() 837 n += 1 + l + sovTypes(uint64(l)) 838 } 839 if m.LastHeightChanged != 0 { 840 n += 1 + sovTypes(uint64(m.LastHeightChanged)) 841 } 842 return n 843 } 844 845 func (m *ConsensusParamsInfo) Size() (n int) { 846 if m == nil { 847 return 0 848 } 849 var l int 850 _ = l 851 l = m.ConsensusParams.Size() 852 n += 1 + l + sovTypes(uint64(l)) 853 if m.LastHeightChanged != 0 { 854 n += 1 + sovTypes(uint64(m.LastHeightChanged)) 855 } 856 return n 857 } 858 859 func (m *Version) Size() (n int) { 860 if m == nil { 861 return 0 862 } 863 var l int 864 _ = l 865 l = m.Consensus.Size() 866 n += 1 + l + sovTypes(uint64(l)) 867 l = len(m.Software) 868 if l > 0 { 869 n += 1 + l + sovTypes(uint64(l)) 870 } 871 return n 872 } 873 874 func (m *State) Size() (n int) { 875 if m == nil { 876 return 0 877 } 878 var l int 879 _ = l 880 l = m.Version.Size() 881 n += 1 + l + sovTypes(uint64(l)) 882 l = len(m.ChainID) 883 if l > 0 { 884 n += 1 + l + sovTypes(uint64(l)) 885 } 886 if m.LastBlockHeight != 0 { 887 n += 1 + sovTypes(uint64(m.LastBlockHeight)) 888 } 889 l = m.LastBlockID.Size() 890 n += 1 + l + sovTypes(uint64(l)) 891 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastBlockTime) 892 n += 1 + l + sovTypes(uint64(l)) 893 if m.NextValidators != nil { 894 l = m.NextValidators.Size() 895 n += 1 + l + sovTypes(uint64(l)) 896 } 897 if m.Validators != nil { 898 l = m.Validators.Size() 899 n += 1 + l + sovTypes(uint64(l)) 900 } 901 if m.LastValidators != nil { 902 l = m.LastValidators.Size() 903 n += 1 + l + sovTypes(uint64(l)) 904 } 905 if m.LastHeightValidatorsChanged != 0 { 906 n += 1 + sovTypes(uint64(m.LastHeightValidatorsChanged)) 907 } 908 l = m.ConsensusParams.Size() 909 n += 1 + l + sovTypes(uint64(l)) 910 if m.LastHeightConsensusParamsChanged != 0 { 911 n += 1 + sovTypes(uint64(m.LastHeightConsensusParamsChanged)) 912 } 913 l = len(m.LastResultsHash) 914 if l > 0 { 915 n += 1 + l + sovTypes(uint64(l)) 916 } 917 l = len(m.AppHash) 918 if l > 0 { 919 n += 1 + l + sovTypes(uint64(l)) 920 } 921 if m.InitialHeight != 0 { 922 n += 1 + sovTypes(uint64(m.InitialHeight)) 923 } 924 return n 925 } 926 927 func sovTypes(x uint64) (n int) { 928 return (math_bits.Len64(x|1) + 6) / 7 929 } 930 func sozTypes(x uint64) (n int) { 931 return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 932 } 933 func (m *ABCIResponses) Unmarshal(dAtA []byte) error { 934 l := len(dAtA) 935 iNdEx := 0 936 for iNdEx < l { 937 preIndex := iNdEx 938 var wire uint64 939 for shift := uint(0); ; shift += 7 { 940 if shift >= 64 { 941 return ErrIntOverflowTypes 942 } 943 if iNdEx >= l { 944 return io.ErrUnexpectedEOF 945 } 946 b := dAtA[iNdEx] 947 iNdEx++ 948 wire |= uint64(b&0x7F) << shift 949 if b < 0x80 { 950 break 951 } 952 } 953 fieldNum := int32(wire >> 3) 954 wireType := int(wire & 0x7) 955 if wireType == 4 { 956 return fmt.Errorf("proto: ABCIResponses: wiretype end group for non-group") 957 } 958 if fieldNum <= 0 { 959 return fmt.Errorf("proto: ABCIResponses: illegal tag %d (wire type %d)", fieldNum, wire) 960 } 961 switch fieldNum { 962 case 1: 963 if wireType != 2 { 964 return fmt.Errorf("proto: wrong wireType = %d for field DeliverTxs", wireType) 965 } 966 var msglen int 967 for shift := uint(0); ; shift += 7 { 968 if shift >= 64 { 969 return ErrIntOverflowTypes 970 } 971 if iNdEx >= l { 972 return io.ErrUnexpectedEOF 973 } 974 b := dAtA[iNdEx] 975 iNdEx++ 976 msglen |= int(b&0x7F) << shift 977 if b < 0x80 { 978 break 979 } 980 } 981 if msglen < 0 { 982 return ErrInvalidLengthTypes 983 } 984 postIndex := iNdEx + msglen 985 if postIndex < 0 { 986 return ErrInvalidLengthTypes 987 } 988 if postIndex > l { 989 return io.ErrUnexpectedEOF 990 } 991 m.DeliverTxs = append(m.DeliverTxs, &types.ResponseDeliverTx{}) 992 if err := m.DeliverTxs[len(m.DeliverTxs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 993 return err 994 } 995 iNdEx = postIndex 996 case 2: 997 if wireType != 2 { 998 return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) 999 } 1000 var msglen int 1001 for shift := uint(0); ; shift += 7 { 1002 if shift >= 64 { 1003 return ErrIntOverflowTypes 1004 } 1005 if iNdEx >= l { 1006 return io.ErrUnexpectedEOF 1007 } 1008 b := dAtA[iNdEx] 1009 iNdEx++ 1010 msglen |= int(b&0x7F) << shift 1011 if b < 0x80 { 1012 break 1013 } 1014 } 1015 if msglen < 0 { 1016 return ErrInvalidLengthTypes 1017 } 1018 postIndex := iNdEx + msglen 1019 if postIndex < 0 { 1020 return ErrInvalidLengthTypes 1021 } 1022 if postIndex > l { 1023 return io.ErrUnexpectedEOF 1024 } 1025 if m.EndBlock == nil { 1026 m.EndBlock = &types.ResponseEndBlock{} 1027 } 1028 if err := m.EndBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1029 return err 1030 } 1031 iNdEx = postIndex 1032 case 3: 1033 if wireType != 2 { 1034 return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType) 1035 } 1036 var msglen int 1037 for shift := uint(0); ; shift += 7 { 1038 if shift >= 64 { 1039 return ErrIntOverflowTypes 1040 } 1041 if iNdEx >= l { 1042 return io.ErrUnexpectedEOF 1043 } 1044 b := dAtA[iNdEx] 1045 iNdEx++ 1046 msglen |= int(b&0x7F) << shift 1047 if b < 0x80 { 1048 break 1049 } 1050 } 1051 if msglen < 0 { 1052 return ErrInvalidLengthTypes 1053 } 1054 postIndex := iNdEx + msglen 1055 if postIndex < 0 { 1056 return ErrInvalidLengthTypes 1057 } 1058 if postIndex > l { 1059 return io.ErrUnexpectedEOF 1060 } 1061 if m.BeginBlock == nil { 1062 m.BeginBlock = &types.ResponseBeginBlock{} 1063 } 1064 if err := m.BeginBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1065 return err 1066 } 1067 iNdEx = postIndex 1068 default: 1069 iNdEx = preIndex 1070 skippy, err := skipTypes(dAtA[iNdEx:]) 1071 if err != nil { 1072 return err 1073 } 1074 if (skippy < 0) || (iNdEx+skippy) < 0 { 1075 return ErrInvalidLengthTypes 1076 } 1077 if (iNdEx + skippy) > l { 1078 return io.ErrUnexpectedEOF 1079 } 1080 iNdEx += skippy 1081 } 1082 } 1083 1084 if iNdEx > l { 1085 return io.ErrUnexpectedEOF 1086 } 1087 return nil 1088 } 1089 func (m *ValidatorsInfo) Unmarshal(dAtA []byte) error { 1090 l := len(dAtA) 1091 iNdEx := 0 1092 for iNdEx < l { 1093 preIndex := iNdEx 1094 var wire uint64 1095 for shift := uint(0); ; shift += 7 { 1096 if shift >= 64 { 1097 return ErrIntOverflowTypes 1098 } 1099 if iNdEx >= l { 1100 return io.ErrUnexpectedEOF 1101 } 1102 b := dAtA[iNdEx] 1103 iNdEx++ 1104 wire |= uint64(b&0x7F) << shift 1105 if b < 0x80 { 1106 break 1107 } 1108 } 1109 fieldNum := int32(wire >> 3) 1110 wireType := int(wire & 0x7) 1111 if wireType == 4 { 1112 return fmt.Errorf("proto: ValidatorsInfo: wiretype end group for non-group") 1113 } 1114 if fieldNum <= 0 { 1115 return fmt.Errorf("proto: ValidatorsInfo: illegal tag %d (wire type %d)", fieldNum, wire) 1116 } 1117 switch fieldNum { 1118 case 1: 1119 if wireType != 2 { 1120 return fmt.Errorf("proto: wrong wireType = %d for field ValidatorSet", wireType) 1121 } 1122 var msglen int 1123 for shift := uint(0); ; shift += 7 { 1124 if shift >= 64 { 1125 return ErrIntOverflowTypes 1126 } 1127 if iNdEx >= l { 1128 return io.ErrUnexpectedEOF 1129 } 1130 b := dAtA[iNdEx] 1131 iNdEx++ 1132 msglen |= int(b&0x7F) << shift 1133 if b < 0x80 { 1134 break 1135 } 1136 } 1137 if msglen < 0 { 1138 return ErrInvalidLengthTypes 1139 } 1140 postIndex := iNdEx + msglen 1141 if postIndex < 0 { 1142 return ErrInvalidLengthTypes 1143 } 1144 if postIndex > l { 1145 return io.ErrUnexpectedEOF 1146 } 1147 if m.ValidatorSet == nil { 1148 m.ValidatorSet = &types1.ValidatorSet{} 1149 } 1150 if err := m.ValidatorSet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1151 return err 1152 } 1153 iNdEx = postIndex 1154 case 2: 1155 if wireType != 0 { 1156 return fmt.Errorf("proto: wrong wireType = %d for field LastHeightChanged", wireType) 1157 } 1158 m.LastHeightChanged = 0 1159 for shift := uint(0); ; shift += 7 { 1160 if shift >= 64 { 1161 return ErrIntOverflowTypes 1162 } 1163 if iNdEx >= l { 1164 return io.ErrUnexpectedEOF 1165 } 1166 b := dAtA[iNdEx] 1167 iNdEx++ 1168 m.LastHeightChanged |= int64(b&0x7F) << shift 1169 if b < 0x80 { 1170 break 1171 } 1172 } 1173 default: 1174 iNdEx = preIndex 1175 skippy, err := skipTypes(dAtA[iNdEx:]) 1176 if err != nil { 1177 return err 1178 } 1179 if (skippy < 0) || (iNdEx+skippy) < 0 { 1180 return ErrInvalidLengthTypes 1181 } 1182 if (iNdEx + skippy) > l { 1183 return io.ErrUnexpectedEOF 1184 } 1185 iNdEx += skippy 1186 } 1187 } 1188 1189 if iNdEx > l { 1190 return io.ErrUnexpectedEOF 1191 } 1192 return nil 1193 } 1194 func (m *ConsensusParamsInfo) Unmarshal(dAtA []byte) error { 1195 l := len(dAtA) 1196 iNdEx := 0 1197 for iNdEx < l { 1198 preIndex := iNdEx 1199 var wire uint64 1200 for shift := uint(0); ; shift += 7 { 1201 if shift >= 64 { 1202 return ErrIntOverflowTypes 1203 } 1204 if iNdEx >= l { 1205 return io.ErrUnexpectedEOF 1206 } 1207 b := dAtA[iNdEx] 1208 iNdEx++ 1209 wire |= uint64(b&0x7F) << shift 1210 if b < 0x80 { 1211 break 1212 } 1213 } 1214 fieldNum := int32(wire >> 3) 1215 wireType := int(wire & 0x7) 1216 if wireType == 4 { 1217 return fmt.Errorf("proto: ConsensusParamsInfo: wiretype end group for non-group") 1218 } 1219 if fieldNum <= 0 { 1220 return fmt.Errorf("proto: ConsensusParamsInfo: illegal tag %d (wire type %d)", fieldNum, wire) 1221 } 1222 switch fieldNum { 1223 case 1: 1224 if wireType != 2 { 1225 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) 1226 } 1227 var msglen int 1228 for shift := uint(0); ; shift += 7 { 1229 if shift >= 64 { 1230 return ErrIntOverflowTypes 1231 } 1232 if iNdEx >= l { 1233 return io.ErrUnexpectedEOF 1234 } 1235 b := dAtA[iNdEx] 1236 iNdEx++ 1237 msglen |= int(b&0x7F) << shift 1238 if b < 0x80 { 1239 break 1240 } 1241 } 1242 if msglen < 0 { 1243 return ErrInvalidLengthTypes 1244 } 1245 postIndex := iNdEx + msglen 1246 if postIndex < 0 { 1247 return ErrInvalidLengthTypes 1248 } 1249 if postIndex > l { 1250 return io.ErrUnexpectedEOF 1251 } 1252 if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1253 return err 1254 } 1255 iNdEx = postIndex 1256 case 2: 1257 if wireType != 0 { 1258 return fmt.Errorf("proto: wrong wireType = %d for field LastHeightChanged", wireType) 1259 } 1260 m.LastHeightChanged = 0 1261 for shift := uint(0); ; shift += 7 { 1262 if shift >= 64 { 1263 return ErrIntOverflowTypes 1264 } 1265 if iNdEx >= l { 1266 return io.ErrUnexpectedEOF 1267 } 1268 b := dAtA[iNdEx] 1269 iNdEx++ 1270 m.LastHeightChanged |= int64(b&0x7F) << shift 1271 if b < 0x80 { 1272 break 1273 } 1274 } 1275 default: 1276 iNdEx = preIndex 1277 skippy, err := skipTypes(dAtA[iNdEx:]) 1278 if err != nil { 1279 return err 1280 } 1281 if (skippy < 0) || (iNdEx+skippy) < 0 { 1282 return ErrInvalidLengthTypes 1283 } 1284 if (iNdEx + skippy) > l { 1285 return io.ErrUnexpectedEOF 1286 } 1287 iNdEx += skippy 1288 } 1289 } 1290 1291 if iNdEx > l { 1292 return io.ErrUnexpectedEOF 1293 } 1294 return nil 1295 } 1296 func (m *Version) Unmarshal(dAtA []byte) error { 1297 l := len(dAtA) 1298 iNdEx := 0 1299 for iNdEx < l { 1300 preIndex := iNdEx 1301 var wire uint64 1302 for shift := uint(0); ; shift += 7 { 1303 if shift >= 64 { 1304 return ErrIntOverflowTypes 1305 } 1306 if iNdEx >= l { 1307 return io.ErrUnexpectedEOF 1308 } 1309 b := dAtA[iNdEx] 1310 iNdEx++ 1311 wire |= uint64(b&0x7F) << shift 1312 if b < 0x80 { 1313 break 1314 } 1315 } 1316 fieldNum := int32(wire >> 3) 1317 wireType := int(wire & 0x7) 1318 if wireType == 4 { 1319 return fmt.Errorf("proto: Version: wiretype end group for non-group") 1320 } 1321 if fieldNum <= 0 { 1322 return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire) 1323 } 1324 switch fieldNum { 1325 case 1: 1326 if wireType != 2 { 1327 return fmt.Errorf("proto: wrong wireType = %d for field Consensus", wireType) 1328 } 1329 var msglen int 1330 for shift := uint(0); ; shift += 7 { 1331 if shift >= 64 { 1332 return ErrIntOverflowTypes 1333 } 1334 if iNdEx >= l { 1335 return io.ErrUnexpectedEOF 1336 } 1337 b := dAtA[iNdEx] 1338 iNdEx++ 1339 msglen |= int(b&0x7F) << shift 1340 if b < 0x80 { 1341 break 1342 } 1343 } 1344 if msglen < 0 { 1345 return ErrInvalidLengthTypes 1346 } 1347 postIndex := iNdEx + msglen 1348 if postIndex < 0 { 1349 return ErrInvalidLengthTypes 1350 } 1351 if postIndex > l { 1352 return io.ErrUnexpectedEOF 1353 } 1354 if err := m.Consensus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1355 return err 1356 } 1357 iNdEx = postIndex 1358 case 2: 1359 if wireType != 2 { 1360 return fmt.Errorf("proto: wrong wireType = %d for field Software", wireType) 1361 } 1362 var stringLen uint64 1363 for shift := uint(0); ; shift += 7 { 1364 if shift >= 64 { 1365 return ErrIntOverflowTypes 1366 } 1367 if iNdEx >= l { 1368 return io.ErrUnexpectedEOF 1369 } 1370 b := dAtA[iNdEx] 1371 iNdEx++ 1372 stringLen |= uint64(b&0x7F) << shift 1373 if b < 0x80 { 1374 break 1375 } 1376 } 1377 intStringLen := int(stringLen) 1378 if intStringLen < 0 { 1379 return ErrInvalidLengthTypes 1380 } 1381 postIndex := iNdEx + intStringLen 1382 if postIndex < 0 { 1383 return ErrInvalidLengthTypes 1384 } 1385 if postIndex > l { 1386 return io.ErrUnexpectedEOF 1387 } 1388 m.Software = string(dAtA[iNdEx:postIndex]) 1389 iNdEx = postIndex 1390 default: 1391 iNdEx = preIndex 1392 skippy, err := skipTypes(dAtA[iNdEx:]) 1393 if err != nil { 1394 return err 1395 } 1396 if (skippy < 0) || (iNdEx+skippy) < 0 { 1397 return ErrInvalidLengthTypes 1398 } 1399 if (iNdEx + skippy) > l { 1400 return io.ErrUnexpectedEOF 1401 } 1402 iNdEx += skippy 1403 } 1404 } 1405 1406 if iNdEx > l { 1407 return io.ErrUnexpectedEOF 1408 } 1409 return nil 1410 } 1411 func (m *State) Unmarshal(dAtA []byte) error { 1412 l := len(dAtA) 1413 iNdEx := 0 1414 for iNdEx < l { 1415 preIndex := iNdEx 1416 var wire uint64 1417 for shift := uint(0); ; shift += 7 { 1418 if shift >= 64 { 1419 return ErrIntOverflowTypes 1420 } 1421 if iNdEx >= l { 1422 return io.ErrUnexpectedEOF 1423 } 1424 b := dAtA[iNdEx] 1425 iNdEx++ 1426 wire |= uint64(b&0x7F) << shift 1427 if b < 0x80 { 1428 break 1429 } 1430 } 1431 fieldNum := int32(wire >> 3) 1432 wireType := int(wire & 0x7) 1433 if wireType == 4 { 1434 return fmt.Errorf("proto: State: wiretype end group for non-group") 1435 } 1436 if fieldNum <= 0 { 1437 return fmt.Errorf("proto: State: illegal tag %d (wire type %d)", fieldNum, wire) 1438 } 1439 switch fieldNum { 1440 case 1: 1441 if wireType != 2 { 1442 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 1443 } 1444 var msglen int 1445 for shift := uint(0); ; shift += 7 { 1446 if shift >= 64 { 1447 return ErrIntOverflowTypes 1448 } 1449 if iNdEx >= l { 1450 return io.ErrUnexpectedEOF 1451 } 1452 b := dAtA[iNdEx] 1453 iNdEx++ 1454 msglen |= int(b&0x7F) << shift 1455 if b < 0x80 { 1456 break 1457 } 1458 } 1459 if msglen < 0 { 1460 return ErrInvalidLengthTypes 1461 } 1462 postIndex := iNdEx + msglen 1463 if postIndex < 0 { 1464 return ErrInvalidLengthTypes 1465 } 1466 if postIndex > l { 1467 return io.ErrUnexpectedEOF 1468 } 1469 if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1470 return err 1471 } 1472 iNdEx = postIndex 1473 case 2: 1474 if wireType != 2 { 1475 return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) 1476 } 1477 var stringLen uint64 1478 for shift := uint(0); ; shift += 7 { 1479 if shift >= 64 { 1480 return ErrIntOverflowTypes 1481 } 1482 if iNdEx >= l { 1483 return io.ErrUnexpectedEOF 1484 } 1485 b := dAtA[iNdEx] 1486 iNdEx++ 1487 stringLen |= uint64(b&0x7F) << shift 1488 if b < 0x80 { 1489 break 1490 } 1491 } 1492 intStringLen := int(stringLen) 1493 if intStringLen < 0 { 1494 return ErrInvalidLengthTypes 1495 } 1496 postIndex := iNdEx + intStringLen 1497 if postIndex < 0 { 1498 return ErrInvalidLengthTypes 1499 } 1500 if postIndex > l { 1501 return io.ErrUnexpectedEOF 1502 } 1503 m.ChainID = string(dAtA[iNdEx:postIndex]) 1504 iNdEx = postIndex 1505 case 3: 1506 if wireType != 0 { 1507 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockHeight", wireType) 1508 } 1509 m.LastBlockHeight = 0 1510 for shift := uint(0); ; shift += 7 { 1511 if shift >= 64 { 1512 return ErrIntOverflowTypes 1513 } 1514 if iNdEx >= l { 1515 return io.ErrUnexpectedEOF 1516 } 1517 b := dAtA[iNdEx] 1518 iNdEx++ 1519 m.LastBlockHeight |= int64(b&0x7F) << shift 1520 if b < 0x80 { 1521 break 1522 } 1523 } 1524 case 4: 1525 if wireType != 2 { 1526 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockID", wireType) 1527 } 1528 var msglen int 1529 for shift := uint(0); ; shift += 7 { 1530 if shift >= 64 { 1531 return ErrIntOverflowTypes 1532 } 1533 if iNdEx >= l { 1534 return io.ErrUnexpectedEOF 1535 } 1536 b := dAtA[iNdEx] 1537 iNdEx++ 1538 msglen |= int(b&0x7F) << shift 1539 if b < 0x80 { 1540 break 1541 } 1542 } 1543 if msglen < 0 { 1544 return ErrInvalidLengthTypes 1545 } 1546 postIndex := iNdEx + msglen 1547 if postIndex < 0 { 1548 return ErrInvalidLengthTypes 1549 } 1550 if postIndex > l { 1551 return io.ErrUnexpectedEOF 1552 } 1553 if err := m.LastBlockID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1554 return err 1555 } 1556 iNdEx = postIndex 1557 case 5: 1558 if wireType != 2 { 1559 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockTime", wireType) 1560 } 1561 var msglen int 1562 for shift := uint(0); ; shift += 7 { 1563 if shift >= 64 { 1564 return ErrIntOverflowTypes 1565 } 1566 if iNdEx >= l { 1567 return io.ErrUnexpectedEOF 1568 } 1569 b := dAtA[iNdEx] 1570 iNdEx++ 1571 msglen |= int(b&0x7F) << shift 1572 if b < 0x80 { 1573 break 1574 } 1575 } 1576 if msglen < 0 { 1577 return ErrInvalidLengthTypes 1578 } 1579 postIndex := iNdEx + msglen 1580 if postIndex < 0 { 1581 return ErrInvalidLengthTypes 1582 } 1583 if postIndex > l { 1584 return io.ErrUnexpectedEOF 1585 } 1586 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastBlockTime, dAtA[iNdEx:postIndex]); err != nil { 1587 return err 1588 } 1589 iNdEx = postIndex 1590 case 6: 1591 if wireType != 2 { 1592 return fmt.Errorf("proto: wrong wireType = %d for field NextValidators", wireType) 1593 } 1594 var msglen int 1595 for shift := uint(0); ; shift += 7 { 1596 if shift >= 64 { 1597 return ErrIntOverflowTypes 1598 } 1599 if iNdEx >= l { 1600 return io.ErrUnexpectedEOF 1601 } 1602 b := dAtA[iNdEx] 1603 iNdEx++ 1604 msglen |= int(b&0x7F) << shift 1605 if b < 0x80 { 1606 break 1607 } 1608 } 1609 if msglen < 0 { 1610 return ErrInvalidLengthTypes 1611 } 1612 postIndex := iNdEx + msglen 1613 if postIndex < 0 { 1614 return ErrInvalidLengthTypes 1615 } 1616 if postIndex > l { 1617 return io.ErrUnexpectedEOF 1618 } 1619 if m.NextValidators == nil { 1620 m.NextValidators = &types1.ValidatorSet{} 1621 } 1622 if err := m.NextValidators.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1623 return err 1624 } 1625 iNdEx = postIndex 1626 case 7: 1627 if wireType != 2 { 1628 return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) 1629 } 1630 var msglen int 1631 for shift := uint(0); ; shift += 7 { 1632 if shift >= 64 { 1633 return ErrIntOverflowTypes 1634 } 1635 if iNdEx >= l { 1636 return io.ErrUnexpectedEOF 1637 } 1638 b := dAtA[iNdEx] 1639 iNdEx++ 1640 msglen |= int(b&0x7F) << shift 1641 if b < 0x80 { 1642 break 1643 } 1644 } 1645 if msglen < 0 { 1646 return ErrInvalidLengthTypes 1647 } 1648 postIndex := iNdEx + msglen 1649 if postIndex < 0 { 1650 return ErrInvalidLengthTypes 1651 } 1652 if postIndex > l { 1653 return io.ErrUnexpectedEOF 1654 } 1655 if m.Validators == nil { 1656 m.Validators = &types1.ValidatorSet{} 1657 } 1658 if err := m.Validators.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1659 return err 1660 } 1661 iNdEx = postIndex 1662 case 8: 1663 if wireType != 2 { 1664 return fmt.Errorf("proto: wrong wireType = %d for field LastValidators", wireType) 1665 } 1666 var msglen int 1667 for shift := uint(0); ; shift += 7 { 1668 if shift >= 64 { 1669 return ErrIntOverflowTypes 1670 } 1671 if iNdEx >= l { 1672 return io.ErrUnexpectedEOF 1673 } 1674 b := dAtA[iNdEx] 1675 iNdEx++ 1676 msglen |= int(b&0x7F) << shift 1677 if b < 0x80 { 1678 break 1679 } 1680 } 1681 if msglen < 0 { 1682 return ErrInvalidLengthTypes 1683 } 1684 postIndex := iNdEx + msglen 1685 if postIndex < 0 { 1686 return ErrInvalidLengthTypes 1687 } 1688 if postIndex > l { 1689 return io.ErrUnexpectedEOF 1690 } 1691 if m.LastValidators == nil { 1692 m.LastValidators = &types1.ValidatorSet{} 1693 } 1694 if err := m.LastValidators.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1695 return err 1696 } 1697 iNdEx = postIndex 1698 case 9: 1699 if wireType != 0 { 1700 return fmt.Errorf("proto: wrong wireType = %d for field LastHeightValidatorsChanged", wireType) 1701 } 1702 m.LastHeightValidatorsChanged = 0 1703 for shift := uint(0); ; shift += 7 { 1704 if shift >= 64 { 1705 return ErrIntOverflowTypes 1706 } 1707 if iNdEx >= l { 1708 return io.ErrUnexpectedEOF 1709 } 1710 b := dAtA[iNdEx] 1711 iNdEx++ 1712 m.LastHeightValidatorsChanged |= int64(b&0x7F) << shift 1713 if b < 0x80 { 1714 break 1715 } 1716 } 1717 case 10: 1718 if wireType != 2 { 1719 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) 1720 } 1721 var msglen int 1722 for shift := uint(0); ; shift += 7 { 1723 if shift >= 64 { 1724 return ErrIntOverflowTypes 1725 } 1726 if iNdEx >= l { 1727 return io.ErrUnexpectedEOF 1728 } 1729 b := dAtA[iNdEx] 1730 iNdEx++ 1731 msglen |= int(b&0x7F) << shift 1732 if b < 0x80 { 1733 break 1734 } 1735 } 1736 if msglen < 0 { 1737 return ErrInvalidLengthTypes 1738 } 1739 postIndex := iNdEx + msglen 1740 if postIndex < 0 { 1741 return ErrInvalidLengthTypes 1742 } 1743 if postIndex > l { 1744 return io.ErrUnexpectedEOF 1745 } 1746 if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 1747 return err 1748 } 1749 iNdEx = postIndex 1750 case 11: 1751 if wireType != 0 { 1752 return fmt.Errorf("proto: wrong wireType = %d for field LastHeightConsensusParamsChanged", wireType) 1753 } 1754 m.LastHeightConsensusParamsChanged = 0 1755 for shift := uint(0); ; shift += 7 { 1756 if shift >= 64 { 1757 return ErrIntOverflowTypes 1758 } 1759 if iNdEx >= l { 1760 return io.ErrUnexpectedEOF 1761 } 1762 b := dAtA[iNdEx] 1763 iNdEx++ 1764 m.LastHeightConsensusParamsChanged |= int64(b&0x7F) << shift 1765 if b < 0x80 { 1766 break 1767 } 1768 } 1769 case 12: 1770 if wireType != 2 { 1771 return fmt.Errorf("proto: wrong wireType = %d for field LastResultsHash", wireType) 1772 } 1773 var byteLen int 1774 for shift := uint(0); ; shift += 7 { 1775 if shift >= 64 { 1776 return ErrIntOverflowTypes 1777 } 1778 if iNdEx >= l { 1779 return io.ErrUnexpectedEOF 1780 } 1781 b := dAtA[iNdEx] 1782 iNdEx++ 1783 byteLen |= int(b&0x7F) << shift 1784 if b < 0x80 { 1785 break 1786 } 1787 } 1788 if byteLen < 0 { 1789 return ErrInvalidLengthTypes 1790 } 1791 postIndex := iNdEx + byteLen 1792 if postIndex < 0 { 1793 return ErrInvalidLengthTypes 1794 } 1795 if postIndex > l { 1796 return io.ErrUnexpectedEOF 1797 } 1798 m.LastResultsHash = append(m.LastResultsHash[:0], dAtA[iNdEx:postIndex]...) 1799 if m.LastResultsHash == nil { 1800 m.LastResultsHash = []byte{} 1801 } 1802 iNdEx = postIndex 1803 case 13: 1804 if wireType != 2 { 1805 return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType) 1806 } 1807 var byteLen int 1808 for shift := uint(0); ; shift += 7 { 1809 if shift >= 64 { 1810 return ErrIntOverflowTypes 1811 } 1812 if iNdEx >= l { 1813 return io.ErrUnexpectedEOF 1814 } 1815 b := dAtA[iNdEx] 1816 iNdEx++ 1817 byteLen |= int(b&0x7F) << shift 1818 if b < 0x80 { 1819 break 1820 } 1821 } 1822 if byteLen < 0 { 1823 return ErrInvalidLengthTypes 1824 } 1825 postIndex := iNdEx + byteLen 1826 if postIndex < 0 { 1827 return ErrInvalidLengthTypes 1828 } 1829 if postIndex > l { 1830 return io.ErrUnexpectedEOF 1831 } 1832 m.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) 1833 if m.AppHash == nil { 1834 m.AppHash = []byte{} 1835 } 1836 iNdEx = postIndex 1837 case 14: 1838 if wireType != 0 { 1839 return fmt.Errorf("proto: wrong wireType = %d for field InitialHeight", wireType) 1840 } 1841 m.InitialHeight = 0 1842 for shift := uint(0); ; shift += 7 { 1843 if shift >= 64 { 1844 return ErrIntOverflowTypes 1845 } 1846 if iNdEx >= l { 1847 return io.ErrUnexpectedEOF 1848 } 1849 b := dAtA[iNdEx] 1850 iNdEx++ 1851 m.InitialHeight |= int64(b&0x7F) << shift 1852 if b < 0x80 { 1853 break 1854 } 1855 } 1856 default: 1857 iNdEx = preIndex 1858 skippy, err := skipTypes(dAtA[iNdEx:]) 1859 if err != nil { 1860 return err 1861 } 1862 if (skippy < 0) || (iNdEx+skippy) < 0 { 1863 return ErrInvalidLengthTypes 1864 } 1865 if (iNdEx + skippy) > l { 1866 return io.ErrUnexpectedEOF 1867 } 1868 iNdEx += skippy 1869 } 1870 } 1871 1872 if iNdEx > l { 1873 return io.ErrUnexpectedEOF 1874 } 1875 return nil 1876 } 1877 func skipTypes(dAtA []byte) (n int, err error) { 1878 l := len(dAtA) 1879 iNdEx := 0 1880 depth := 0 1881 for iNdEx < l { 1882 var wire uint64 1883 for shift := uint(0); ; shift += 7 { 1884 if shift >= 64 { 1885 return 0, ErrIntOverflowTypes 1886 } 1887 if iNdEx >= l { 1888 return 0, io.ErrUnexpectedEOF 1889 } 1890 b := dAtA[iNdEx] 1891 iNdEx++ 1892 wire |= (uint64(b) & 0x7F) << shift 1893 if b < 0x80 { 1894 break 1895 } 1896 } 1897 wireType := int(wire & 0x7) 1898 switch wireType { 1899 case 0: 1900 for shift := uint(0); ; shift += 7 { 1901 if shift >= 64 { 1902 return 0, ErrIntOverflowTypes 1903 } 1904 if iNdEx >= l { 1905 return 0, io.ErrUnexpectedEOF 1906 } 1907 iNdEx++ 1908 if dAtA[iNdEx-1] < 0x80 { 1909 break 1910 } 1911 } 1912 case 1: 1913 iNdEx += 8 1914 case 2: 1915 var length int 1916 for shift := uint(0); ; shift += 7 { 1917 if shift >= 64 { 1918 return 0, ErrIntOverflowTypes 1919 } 1920 if iNdEx >= l { 1921 return 0, io.ErrUnexpectedEOF 1922 } 1923 b := dAtA[iNdEx] 1924 iNdEx++ 1925 length |= (int(b) & 0x7F) << shift 1926 if b < 0x80 { 1927 break 1928 } 1929 } 1930 if length < 0 { 1931 return 0, ErrInvalidLengthTypes 1932 } 1933 iNdEx += length 1934 case 3: 1935 depth++ 1936 case 4: 1937 if depth == 0 { 1938 return 0, ErrUnexpectedEndOfGroupTypes 1939 } 1940 depth-- 1941 case 5: 1942 iNdEx += 4 1943 default: 1944 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 1945 } 1946 if iNdEx < 0 { 1947 return 0, ErrInvalidLengthTypes 1948 } 1949 if depth == 0 { 1950 return iNdEx, nil 1951 } 1952 } 1953 return 0, io.ErrUnexpectedEOF 1954 } 1955 1956 var ( 1957 ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") 1958 ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 1959 ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") 1960 )