github.com/vipernet-xyz/tendermint-core@v0.32.0/abci/types/types.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: abci/types/types.proto 3 4 package types 5 6 import ( 7 "bytes" 8 "context" 9 "fmt" 10 _ "github.com/gogo/protobuf/gogoproto" 11 "github.com/gogo/protobuf/proto" 12 github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" 13 golang_proto "github.com/golang/protobuf/proto" 14 _ "github.com/golang/protobuf/ptypes/timestamp" 15 "github.com/tendermint/tendermint/crypto/merkle" 16 "github.com/tendermint/tendermint/libs/kv" 17 "google.golang.org/grpc" 18 "google.golang.org/grpc/codes" 19 "google.golang.org/grpc/status" 20 "io" 21 "math" 22 math_bits "math/bits" 23 "time" 24 ) 25 26 // Reference imports to suppress errors if they are not otherwise used. 27 var _ = proto.Marshal 28 var _ = golang_proto.Marshal 29 var _ = fmt.Errorf 30 var _ = math.Inf 31 var _ = time.Kitchen 32 33 // This is a compile-time assertion to ensure that this generated file 34 // is compatible with the proto package it is being compiled against. 35 // A compilation error at this line likely means your copy of the 36 // proto package needs to be updated. 37 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 38 39 type CheckTxType int32 40 41 const ( 42 CheckTxType_New CheckTxType = 0 43 CheckTxType_Recheck CheckTxType = 1 44 ) 45 46 var CheckTxType_name = map[int32]string{ 47 0: "New", 48 1: "Recheck", 49 } 50 51 var CheckTxType_value = map[string]int32{ 52 "New": 0, 53 "Recheck": 1, 54 } 55 56 func (x CheckTxType) String() string { 57 return proto.EnumName(CheckTxType_name, int32(x)) 58 } 59 60 func (CheckTxType) EnumDescriptor() ([]byte, []int) { 61 return fileDescriptor_9f1eaa49c51fa1ac, []int{0} 62 } 63 64 type Request struct { 65 // Types that are valid to be assigned to Value: 66 // *Request_Echo 67 // *Request_Flush 68 // *Request_Info 69 // *Request_SetOption 70 // *Request_InitChain 71 // *Request_Query 72 // *Request_BeginBlock 73 // *Request_CheckTx 74 // *Request_DeliverTx 75 // *Request_EndBlock 76 // *Request_Commit 77 Value isRequest_Value `protobuf_oneof:"value"` 78 XXX_NoUnkeyedLiteral struct{} `json:"-"` 79 XXX_unrecognized []byte `json:"-"` 80 XXX_sizecache int32 `json:"-"` 81 } 82 83 func (m *Request) Reset() { *m = Request{} } 84 func (m *Request) String() string { return proto.CompactTextString(m) } 85 func (*Request) ProtoMessage() {} 86 func (*Request) Descriptor() ([]byte, []int) { 87 return fileDescriptor_9f1eaa49c51fa1ac, []int{0} 88 } 89 func (m *Request) XXX_Unmarshal(b []byte) error { 90 return m.Unmarshal(b) 91 } 92 func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 93 if deterministic { 94 return xxx_messageInfo_Request.Marshal(b, m, deterministic) 95 } else { 96 b = b[:cap(b)] 97 n, err := m.MarshalToSizedBuffer(b) 98 if err != nil { 99 return nil, err 100 } 101 return b[:n], nil 102 } 103 } 104 func (m *Request) XXX_Merge(src proto.Message) { 105 xxx_messageInfo_Request.Merge(m, src) 106 } 107 func (m *Request) XXX_Size() int { 108 return m.Size() 109 } 110 func (m *Request) XXX_DiscardUnknown() { 111 xxx_messageInfo_Request.DiscardUnknown(m) 112 } 113 114 var xxx_messageInfo_Request proto.InternalMessageInfo 115 116 type isRequest_Value interface { 117 isRequest_Value() 118 Equal(interface{}) bool 119 MarshalTo([]byte) (int, error) 120 Size() int 121 } 122 123 type Request_Echo struct { 124 Echo *RequestEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof" json:"echo,omitempty"` 125 } 126 type Request_Flush struct { 127 Flush *RequestFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"` 128 } 129 type Request_Info struct { 130 Info *RequestInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof" json:"info,omitempty"` 131 } 132 type Request_SetOption struct { 133 SetOption *RequestSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof" json:"set_option,omitempty"` 134 } 135 type Request_InitChain struct { 136 InitChain *RequestInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof" json:"init_chain,omitempty"` 137 } 138 type Request_Query struct { 139 Query *RequestQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof" json:"query,omitempty"` 140 } 141 type Request_BeginBlock struct { 142 BeginBlock *RequestBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof" json:"begin_block,omitempty"` 143 } 144 type Request_CheckTx struct { 145 CheckTx *RequestCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof" json:"check_tx,omitempty"` 146 } 147 type Request_DeliverTx struct { 148 DeliverTx *RequestDeliverTx `protobuf:"bytes,19,opt,name=deliver_tx,json=deliverTx,proto3,oneof" json:"deliver_tx,omitempty"` 149 } 150 type Request_EndBlock struct { 151 EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof" json:"end_block,omitempty"` 152 } 153 type Request_Commit struct { 154 Commit *RequestCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"` 155 } 156 157 func (*Request_Echo) isRequest_Value() {} 158 func (*Request_Flush) isRequest_Value() {} 159 func (*Request_Info) isRequest_Value() {} 160 func (*Request_SetOption) isRequest_Value() {} 161 func (*Request_InitChain) isRequest_Value() {} 162 func (*Request_Query) isRequest_Value() {} 163 func (*Request_BeginBlock) isRequest_Value() {} 164 func (*Request_CheckTx) isRequest_Value() {} 165 func (*Request_DeliverTx) isRequest_Value() {} 166 func (*Request_EndBlock) isRequest_Value() {} 167 func (*Request_Commit) isRequest_Value() {} 168 169 func (m *Request) GetValue() isRequest_Value { 170 if m != nil { 171 return m.Value 172 } 173 return nil 174 } 175 176 func (m *Request) GetEcho() *RequestEcho { 177 if x, ok := m.GetValue().(*Request_Echo); ok { 178 return x.Echo 179 } 180 return nil 181 } 182 183 func (m *Request) GetFlush() *RequestFlush { 184 if x, ok := m.GetValue().(*Request_Flush); ok { 185 return x.Flush 186 } 187 return nil 188 } 189 190 func (m *Request) GetInfo() *RequestInfo { 191 if x, ok := m.GetValue().(*Request_Info); ok { 192 return x.Info 193 } 194 return nil 195 } 196 197 func (m *Request) GetSetOption() *RequestSetOption { 198 if x, ok := m.GetValue().(*Request_SetOption); ok { 199 return x.SetOption 200 } 201 return nil 202 } 203 204 func (m *Request) GetInitChain() *RequestInitChain { 205 if x, ok := m.GetValue().(*Request_InitChain); ok { 206 return x.InitChain 207 } 208 return nil 209 } 210 211 func (m *Request) GetQuery() *RequestQuery { 212 if x, ok := m.GetValue().(*Request_Query); ok { 213 return x.Query 214 } 215 return nil 216 } 217 218 func (m *Request) GetBeginBlock() *RequestBeginBlock { 219 if x, ok := m.GetValue().(*Request_BeginBlock); ok { 220 return x.BeginBlock 221 } 222 return nil 223 } 224 225 func (m *Request) GetCheckTx() *RequestCheckTx { 226 if x, ok := m.GetValue().(*Request_CheckTx); ok { 227 return x.CheckTx 228 } 229 return nil 230 } 231 232 func (m *Request) GetDeliverTx() *RequestDeliverTx { 233 if x, ok := m.GetValue().(*Request_DeliverTx); ok { 234 return x.DeliverTx 235 } 236 return nil 237 } 238 239 func (m *Request) GetEndBlock() *RequestEndBlock { 240 if x, ok := m.GetValue().(*Request_EndBlock); ok { 241 return x.EndBlock 242 } 243 return nil 244 } 245 246 func (m *Request) GetCommit() *RequestCommit { 247 if x, ok := m.GetValue().(*Request_Commit); ok { 248 return x.Commit 249 } 250 return nil 251 } 252 253 // XXX_OneofWrappers is for the internal use of the proto package. 254 func (*Request) XXX_OneofWrappers() []interface{} { 255 return []interface{}{ 256 (*Request_Echo)(nil), 257 (*Request_Flush)(nil), 258 (*Request_Info)(nil), 259 (*Request_SetOption)(nil), 260 (*Request_InitChain)(nil), 261 (*Request_Query)(nil), 262 (*Request_BeginBlock)(nil), 263 (*Request_CheckTx)(nil), 264 (*Request_DeliverTx)(nil), 265 (*Request_EndBlock)(nil), 266 (*Request_Commit)(nil), 267 } 268 } 269 270 type RequestEcho struct { 271 Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` 272 XXX_NoUnkeyedLiteral struct{} `json:"-"` 273 XXX_unrecognized []byte `json:"-"` 274 XXX_sizecache int32 `json:"-"` 275 } 276 277 func (m *RequestEcho) Reset() { *m = RequestEcho{} } 278 func (m *RequestEcho) String() string { return proto.CompactTextString(m) } 279 func (*RequestEcho) ProtoMessage() {} 280 func (*RequestEcho) Descriptor() ([]byte, []int) { 281 return fileDescriptor_9f1eaa49c51fa1ac, []int{1} 282 } 283 func (m *RequestEcho) XXX_Unmarshal(b []byte) error { 284 return m.Unmarshal(b) 285 } 286 func (m *RequestEcho) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 287 if deterministic { 288 return xxx_messageInfo_RequestEcho.Marshal(b, m, deterministic) 289 } else { 290 b = b[:cap(b)] 291 n, err := m.MarshalToSizedBuffer(b) 292 if err != nil { 293 return nil, err 294 } 295 return b[:n], nil 296 } 297 } 298 func (m *RequestEcho) XXX_Merge(src proto.Message) { 299 xxx_messageInfo_RequestEcho.Merge(m, src) 300 } 301 func (m *RequestEcho) XXX_Size() int { 302 return m.Size() 303 } 304 func (m *RequestEcho) XXX_DiscardUnknown() { 305 xxx_messageInfo_RequestEcho.DiscardUnknown(m) 306 } 307 308 var xxx_messageInfo_RequestEcho proto.InternalMessageInfo 309 310 func (m *RequestEcho) GetMessage() string { 311 if m != nil { 312 return m.Message 313 } 314 return "" 315 } 316 317 type RequestFlush struct { 318 XXX_NoUnkeyedLiteral struct{} `json:"-"` 319 XXX_unrecognized []byte `json:"-"` 320 XXX_sizecache int32 `json:"-"` 321 } 322 323 func (m *RequestFlush) Reset() { *m = RequestFlush{} } 324 func (m *RequestFlush) String() string { return proto.CompactTextString(m) } 325 func (*RequestFlush) ProtoMessage() {} 326 func (*RequestFlush) Descriptor() ([]byte, []int) { 327 return fileDescriptor_9f1eaa49c51fa1ac, []int{2} 328 } 329 func (m *RequestFlush) XXX_Unmarshal(b []byte) error { 330 return m.Unmarshal(b) 331 } 332 func (m *RequestFlush) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 333 if deterministic { 334 return xxx_messageInfo_RequestFlush.Marshal(b, m, deterministic) 335 } else { 336 b = b[:cap(b)] 337 n, err := m.MarshalToSizedBuffer(b) 338 if err != nil { 339 return nil, err 340 } 341 return b[:n], nil 342 } 343 } 344 func (m *RequestFlush) XXX_Merge(src proto.Message) { 345 xxx_messageInfo_RequestFlush.Merge(m, src) 346 } 347 func (m *RequestFlush) XXX_Size() int { 348 return m.Size() 349 } 350 func (m *RequestFlush) XXX_DiscardUnknown() { 351 xxx_messageInfo_RequestFlush.DiscardUnknown(m) 352 } 353 354 var xxx_messageInfo_RequestFlush proto.InternalMessageInfo 355 356 type RequestInfo struct { 357 Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` 358 BlockVersion uint64 `protobuf:"varint,2,opt,name=block_version,json=blockVersion,proto3" json:"block_version,omitempty"` 359 P2PVersion uint64 `protobuf:"varint,3,opt,name=p2p_version,json=p2pVersion,proto3" json:"p2p_version,omitempty"` 360 XXX_NoUnkeyedLiteral struct{} `json:"-"` 361 XXX_unrecognized []byte `json:"-"` 362 XXX_sizecache int32 `json:"-"` 363 } 364 365 func (m *RequestInfo) Reset() { *m = RequestInfo{} } 366 func (m *RequestInfo) String() string { return proto.CompactTextString(m) } 367 func (*RequestInfo) ProtoMessage() {} 368 func (*RequestInfo) Descriptor() ([]byte, []int) { 369 return fileDescriptor_9f1eaa49c51fa1ac, []int{3} 370 } 371 func (m *RequestInfo) XXX_Unmarshal(b []byte) error { 372 return m.Unmarshal(b) 373 } 374 func (m *RequestInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 375 if deterministic { 376 return xxx_messageInfo_RequestInfo.Marshal(b, m, deterministic) 377 } else { 378 b = b[:cap(b)] 379 n, err := m.MarshalToSizedBuffer(b) 380 if err != nil { 381 return nil, err 382 } 383 return b[:n], nil 384 } 385 } 386 func (m *RequestInfo) XXX_Merge(src proto.Message) { 387 xxx_messageInfo_RequestInfo.Merge(m, src) 388 } 389 func (m *RequestInfo) XXX_Size() int { 390 return m.Size() 391 } 392 func (m *RequestInfo) XXX_DiscardUnknown() { 393 xxx_messageInfo_RequestInfo.DiscardUnknown(m) 394 } 395 396 var xxx_messageInfo_RequestInfo proto.InternalMessageInfo 397 398 func (m *RequestInfo) GetVersion() string { 399 if m != nil { 400 return m.Version 401 } 402 return "" 403 } 404 405 func (m *RequestInfo) GetBlockVersion() uint64 { 406 if m != nil { 407 return m.BlockVersion 408 } 409 return 0 410 } 411 412 func (m *RequestInfo) GetP2PVersion() uint64 { 413 if m != nil { 414 return m.P2PVersion 415 } 416 return 0 417 } 418 419 // nondeterministic 420 type RequestSetOption struct { 421 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 422 Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 423 XXX_NoUnkeyedLiteral struct{} `json:"-"` 424 XXX_unrecognized []byte `json:"-"` 425 XXX_sizecache int32 `json:"-"` 426 } 427 428 func (m *RequestSetOption) Reset() { *m = RequestSetOption{} } 429 func (m *RequestSetOption) String() string { return proto.CompactTextString(m) } 430 func (*RequestSetOption) ProtoMessage() {} 431 func (*RequestSetOption) Descriptor() ([]byte, []int) { 432 return fileDescriptor_9f1eaa49c51fa1ac, []int{4} 433 } 434 func (m *RequestSetOption) XXX_Unmarshal(b []byte) error { 435 return m.Unmarshal(b) 436 } 437 func (m *RequestSetOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 438 if deterministic { 439 return xxx_messageInfo_RequestSetOption.Marshal(b, m, deterministic) 440 } else { 441 b = b[:cap(b)] 442 n, err := m.MarshalToSizedBuffer(b) 443 if err != nil { 444 return nil, err 445 } 446 return b[:n], nil 447 } 448 } 449 func (m *RequestSetOption) XXX_Merge(src proto.Message) { 450 xxx_messageInfo_RequestSetOption.Merge(m, src) 451 } 452 func (m *RequestSetOption) XXX_Size() int { 453 return m.Size() 454 } 455 func (m *RequestSetOption) XXX_DiscardUnknown() { 456 xxx_messageInfo_RequestSetOption.DiscardUnknown(m) 457 } 458 459 var xxx_messageInfo_RequestSetOption proto.InternalMessageInfo 460 461 func (m *RequestSetOption) GetKey() string { 462 if m != nil { 463 return m.Key 464 } 465 return "" 466 } 467 468 func (m *RequestSetOption) GetValue() string { 469 if m != nil { 470 return m.Value 471 } 472 return "" 473 } 474 475 type RequestInitChain struct { 476 Time time.Time `protobuf:"bytes,1,opt,name=time,proto3,stdtime" json:"time"` 477 ChainId string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` 478 ConsensusParams *ConsensusParams `protobuf:"bytes,3,opt,name=consensus_params,json=consensusParams,proto3" json:"consensus_params,omitempty"` 479 Validators []ValidatorUpdate `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"` 480 AppStateBytes []byte `protobuf:"bytes,5,opt,name=app_state_bytes,json=appStateBytes,proto3" json:"app_state_bytes,omitempty"` 481 XXX_NoUnkeyedLiteral struct{} `json:"-"` 482 XXX_unrecognized []byte `json:"-"` 483 XXX_sizecache int32 `json:"-"` 484 } 485 486 func (m *RequestInitChain) Reset() { *m = RequestInitChain{} } 487 func (m *RequestInitChain) String() string { return proto.CompactTextString(m) } 488 func (*RequestInitChain) ProtoMessage() {} 489 func (*RequestInitChain) Descriptor() ([]byte, []int) { 490 return fileDescriptor_9f1eaa49c51fa1ac, []int{5} 491 } 492 func (m *RequestInitChain) XXX_Unmarshal(b []byte) error { 493 return m.Unmarshal(b) 494 } 495 func (m *RequestInitChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 496 if deterministic { 497 return xxx_messageInfo_RequestInitChain.Marshal(b, m, deterministic) 498 } else { 499 b = b[:cap(b)] 500 n, err := m.MarshalToSizedBuffer(b) 501 if err != nil { 502 return nil, err 503 } 504 return b[:n], nil 505 } 506 } 507 func (m *RequestInitChain) XXX_Merge(src proto.Message) { 508 xxx_messageInfo_RequestInitChain.Merge(m, src) 509 } 510 func (m *RequestInitChain) XXX_Size() int { 511 return m.Size() 512 } 513 func (m *RequestInitChain) XXX_DiscardUnknown() { 514 xxx_messageInfo_RequestInitChain.DiscardUnknown(m) 515 } 516 517 var xxx_messageInfo_RequestInitChain proto.InternalMessageInfo 518 519 func (m *RequestInitChain) GetTime() time.Time { 520 if m != nil { 521 return m.Time 522 } 523 return time.Time{} 524 } 525 526 func (m *RequestInitChain) GetChainId() string { 527 if m != nil { 528 return m.ChainId 529 } 530 return "" 531 } 532 533 func (m *RequestInitChain) GetConsensusParams() *ConsensusParams { 534 if m != nil { 535 return m.ConsensusParams 536 } 537 return nil 538 } 539 540 func (m *RequestInitChain) GetValidators() []ValidatorUpdate { 541 if m != nil { 542 return m.Validators 543 } 544 return nil 545 } 546 547 func (m *RequestInitChain) GetAppStateBytes() []byte { 548 if m != nil { 549 return m.AppStateBytes 550 } 551 return nil 552 } 553 554 type RequestQuery struct { 555 Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 556 Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` 557 Height int64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` 558 Prove bool `protobuf:"varint,4,opt,name=prove,proto3" json:"prove,omitempty"` 559 XXX_NoUnkeyedLiteral struct{} `json:"-"` 560 XXX_unrecognized []byte `json:"-"` 561 XXX_sizecache int32 `json:"-"` 562 } 563 564 func (m *RequestQuery) Reset() { *m = RequestQuery{} } 565 func (m *RequestQuery) String() string { return proto.CompactTextString(m) } 566 func (*RequestQuery) ProtoMessage() {} 567 func (*RequestQuery) Descriptor() ([]byte, []int) { 568 return fileDescriptor_9f1eaa49c51fa1ac, []int{6} 569 } 570 func (m *RequestQuery) XXX_Unmarshal(b []byte) error { 571 return m.Unmarshal(b) 572 } 573 func (m *RequestQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 574 if deterministic { 575 return xxx_messageInfo_RequestQuery.Marshal(b, m, deterministic) 576 } else { 577 b = b[:cap(b)] 578 n, err := m.MarshalToSizedBuffer(b) 579 if err != nil { 580 return nil, err 581 } 582 return b[:n], nil 583 } 584 } 585 func (m *RequestQuery) XXX_Merge(src proto.Message) { 586 xxx_messageInfo_RequestQuery.Merge(m, src) 587 } 588 func (m *RequestQuery) XXX_Size() int { 589 return m.Size() 590 } 591 func (m *RequestQuery) XXX_DiscardUnknown() { 592 xxx_messageInfo_RequestQuery.DiscardUnknown(m) 593 } 594 595 var xxx_messageInfo_RequestQuery proto.InternalMessageInfo 596 597 func (m *RequestQuery) GetData() []byte { 598 if m != nil { 599 return m.Data 600 } 601 return nil 602 } 603 604 func (m *RequestQuery) GetPath() string { 605 if m != nil { 606 return m.Path 607 } 608 return "" 609 } 610 611 func (m *RequestQuery) GetHeight() int64 { 612 if m != nil { 613 return m.Height 614 } 615 return 0 616 } 617 618 func (m *RequestQuery) GetProve() bool { 619 if m != nil { 620 return m.Prove 621 } 622 return false 623 } 624 625 type RequestBeginBlock struct { 626 Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` 627 Header Header `protobuf:"bytes,2,opt,name=header,proto3" json:"header"` 628 LastCommitInfo LastCommitInfo `protobuf:"bytes,3,opt,name=last_commit_info,json=lastCommitInfo,proto3" json:"last_commit_info"` 629 ByzantineValidators []Evidence `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators,proto3" json:"byzantine_validators"` 630 XXX_NoUnkeyedLiteral struct{} `json:"-"` 631 XXX_unrecognized []byte `json:"-"` 632 XXX_sizecache int32 `json:"-"` 633 } 634 635 func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} } 636 func (m *RequestBeginBlock) String() string { return proto.CompactTextString(m) } 637 func (*RequestBeginBlock) ProtoMessage() {} 638 func (*RequestBeginBlock) Descriptor() ([]byte, []int) { 639 return fileDescriptor_9f1eaa49c51fa1ac, []int{7} 640 } 641 func (m *RequestBeginBlock) XXX_Unmarshal(b []byte) error { 642 return m.Unmarshal(b) 643 } 644 func (m *RequestBeginBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 645 if deterministic { 646 return xxx_messageInfo_RequestBeginBlock.Marshal(b, m, deterministic) 647 } else { 648 b = b[:cap(b)] 649 n, err := m.MarshalToSizedBuffer(b) 650 if err != nil { 651 return nil, err 652 } 653 return b[:n], nil 654 } 655 } 656 func (m *RequestBeginBlock) XXX_Merge(src proto.Message) { 657 xxx_messageInfo_RequestBeginBlock.Merge(m, src) 658 } 659 func (m *RequestBeginBlock) XXX_Size() int { 660 return m.Size() 661 } 662 func (m *RequestBeginBlock) XXX_DiscardUnknown() { 663 xxx_messageInfo_RequestBeginBlock.DiscardUnknown(m) 664 } 665 666 var xxx_messageInfo_RequestBeginBlock proto.InternalMessageInfo 667 668 func (m *RequestBeginBlock) GetHash() []byte { 669 if m != nil { 670 return m.Hash 671 } 672 return nil 673 } 674 675 func (m *RequestBeginBlock) GetHeader() Header { 676 if m != nil { 677 return m.Header 678 } 679 return Header{} 680 } 681 682 func (m *RequestBeginBlock) GetLastCommitInfo() LastCommitInfo { 683 if m != nil { 684 return m.LastCommitInfo 685 } 686 return LastCommitInfo{} 687 } 688 689 func (m *RequestBeginBlock) GetByzantineValidators() []Evidence { 690 if m != nil { 691 return m.ByzantineValidators 692 } 693 return nil 694 } 695 696 type RequestCheckTx struct { 697 Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` 698 Type CheckTxType `protobuf:"varint,2,opt,name=type,proto3,enum=tendermint.abci.types.CheckTxType" json:"type,omitempty"` 699 XXX_NoUnkeyedLiteral struct{} `json:"-"` 700 XXX_unrecognized []byte `json:"-"` 701 XXX_sizecache int32 `json:"-"` 702 } 703 704 func (m *RequestCheckTx) Reset() { *m = RequestCheckTx{} } 705 func (m *RequestCheckTx) String() string { return proto.CompactTextString(m) } 706 func (*RequestCheckTx) ProtoMessage() {} 707 func (*RequestCheckTx) Descriptor() ([]byte, []int) { 708 return fileDescriptor_9f1eaa49c51fa1ac, []int{8} 709 } 710 func (m *RequestCheckTx) XXX_Unmarshal(b []byte) error { 711 return m.Unmarshal(b) 712 } 713 func (m *RequestCheckTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 714 if deterministic { 715 return xxx_messageInfo_RequestCheckTx.Marshal(b, m, deterministic) 716 } else { 717 b = b[:cap(b)] 718 n, err := m.MarshalToSizedBuffer(b) 719 if err != nil { 720 return nil, err 721 } 722 return b[:n], nil 723 } 724 } 725 func (m *RequestCheckTx) XXX_Merge(src proto.Message) { 726 xxx_messageInfo_RequestCheckTx.Merge(m, src) 727 } 728 func (m *RequestCheckTx) XXX_Size() int { 729 return m.Size() 730 } 731 func (m *RequestCheckTx) XXX_DiscardUnknown() { 732 xxx_messageInfo_RequestCheckTx.DiscardUnknown(m) 733 } 734 735 var xxx_messageInfo_RequestCheckTx proto.InternalMessageInfo 736 737 func (m *RequestCheckTx) GetTx() []byte { 738 if m != nil { 739 return m.Tx 740 } 741 return nil 742 } 743 744 func (m *RequestCheckTx) GetType() CheckTxType { 745 if m != nil { 746 return m.Type 747 } 748 return CheckTxType_New 749 } 750 751 type RequestDeliverTx struct { 752 Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` 753 XXX_NoUnkeyedLiteral struct{} `json:"-"` 754 XXX_unrecognized []byte `json:"-"` 755 XXX_sizecache int32 `json:"-"` 756 } 757 758 func (m *RequestDeliverTx) Reset() { *m = RequestDeliverTx{} } 759 func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) } 760 func (*RequestDeliverTx) ProtoMessage() {} 761 func (*RequestDeliverTx) Descriptor() ([]byte, []int) { 762 return fileDescriptor_9f1eaa49c51fa1ac, []int{9} 763 } 764 func (m *RequestDeliverTx) XXX_Unmarshal(b []byte) error { 765 return m.Unmarshal(b) 766 } 767 func (m *RequestDeliverTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 768 if deterministic { 769 return xxx_messageInfo_RequestDeliverTx.Marshal(b, m, deterministic) 770 } else { 771 b = b[:cap(b)] 772 n, err := m.MarshalToSizedBuffer(b) 773 if err != nil { 774 return nil, err 775 } 776 return b[:n], nil 777 } 778 } 779 func (m *RequestDeliverTx) XXX_Merge(src proto.Message) { 780 xxx_messageInfo_RequestDeliverTx.Merge(m, src) 781 } 782 func (m *RequestDeliverTx) XXX_Size() int { 783 return m.Size() 784 } 785 func (m *RequestDeliverTx) XXX_DiscardUnknown() { 786 xxx_messageInfo_RequestDeliverTx.DiscardUnknown(m) 787 } 788 789 var xxx_messageInfo_RequestDeliverTx proto.InternalMessageInfo 790 791 func (m *RequestDeliverTx) GetTx() []byte { 792 if m != nil { 793 return m.Tx 794 } 795 return nil 796 } 797 798 type RequestEndBlock struct { 799 Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` 800 XXX_NoUnkeyedLiteral struct{} `json:"-"` 801 XXX_unrecognized []byte `json:"-"` 802 XXX_sizecache int32 `json:"-"` 803 } 804 805 func (m *RequestEndBlock) Reset() { *m = RequestEndBlock{} } 806 func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) } 807 func (*RequestEndBlock) ProtoMessage() {} 808 func (*RequestEndBlock) Descriptor() ([]byte, []int) { 809 return fileDescriptor_9f1eaa49c51fa1ac, []int{10} 810 } 811 func (m *RequestEndBlock) XXX_Unmarshal(b []byte) error { 812 return m.Unmarshal(b) 813 } 814 func (m *RequestEndBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 815 if deterministic { 816 return xxx_messageInfo_RequestEndBlock.Marshal(b, m, deterministic) 817 } else { 818 b = b[:cap(b)] 819 n, err := m.MarshalToSizedBuffer(b) 820 if err != nil { 821 return nil, err 822 } 823 return b[:n], nil 824 } 825 } 826 func (m *RequestEndBlock) XXX_Merge(src proto.Message) { 827 xxx_messageInfo_RequestEndBlock.Merge(m, src) 828 } 829 func (m *RequestEndBlock) XXX_Size() int { 830 return m.Size() 831 } 832 func (m *RequestEndBlock) XXX_DiscardUnknown() { 833 xxx_messageInfo_RequestEndBlock.DiscardUnknown(m) 834 } 835 836 var xxx_messageInfo_RequestEndBlock proto.InternalMessageInfo 837 838 func (m *RequestEndBlock) GetHeight() int64 { 839 if m != nil { 840 return m.Height 841 } 842 return 0 843 } 844 845 type RequestCommit struct { 846 XXX_NoUnkeyedLiteral struct{} `json:"-"` 847 XXX_unrecognized []byte `json:"-"` 848 XXX_sizecache int32 `json:"-"` 849 } 850 851 func (m *RequestCommit) Reset() { *m = RequestCommit{} } 852 func (m *RequestCommit) String() string { return proto.CompactTextString(m) } 853 func (*RequestCommit) ProtoMessage() {} 854 func (*RequestCommit) Descriptor() ([]byte, []int) { 855 return fileDescriptor_9f1eaa49c51fa1ac, []int{11} 856 } 857 func (m *RequestCommit) XXX_Unmarshal(b []byte) error { 858 return m.Unmarshal(b) 859 } 860 func (m *RequestCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 861 if deterministic { 862 return xxx_messageInfo_RequestCommit.Marshal(b, m, deterministic) 863 } else { 864 b = b[:cap(b)] 865 n, err := m.MarshalToSizedBuffer(b) 866 if err != nil { 867 return nil, err 868 } 869 return b[:n], nil 870 } 871 } 872 func (m *RequestCommit) XXX_Merge(src proto.Message) { 873 xxx_messageInfo_RequestCommit.Merge(m, src) 874 } 875 func (m *RequestCommit) XXX_Size() int { 876 return m.Size() 877 } 878 func (m *RequestCommit) XXX_DiscardUnknown() { 879 xxx_messageInfo_RequestCommit.DiscardUnknown(m) 880 } 881 882 var xxx_messageInfo_RequestCommit proto.InternalMessageInfo 883 884 type Response struct { 885 // Types that are valid to be assigned to Value: 886 // *Response_Exception 887 // *Response_Echo 888 // *Response_Flush 889 // *Response_Info 890 // *Response_SetOption 891 // *Response_InitChain 892 // *Response_Query 893 // *Response_BeginBlock 894 // *Response_CheckTx 895 // *Response_DeliverTx 896 // *Response_EndBlock 897 // *Response_Commit 898 Value isResponse_Value `protobuf_oneof:"value"` 899 XXX_NoUnkeyedLiteral struct{} `json:"-"` 900 XXX_unrecognized []byte `json:"-"` 901 XXX_sizecache int32 `json:"-"` 902 } 903 904 func (m *Response) Reset() { *m = Response{} } 905 func (m *Response) String() string { return proto.CompactTextString(m) } 906 func (*Response) ProtoMessage() {} 907 func (*Response) Descriptor() ([]byte, []int) { 908 return fileDescriptor_9f1eaa49c51fa1ac, []int{12} 909 } 910 func (m *Response) XXX_Unmarshal(b []byte) error { 911 return m.Unmarshal(b) 912 } 913 func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 914 if deterministic { 915 return xxx_messageInfo_Response.Marshal(b, m, deterministic) 916 } else { 917 b = b[:cap(b)] 918 n, err := m.MarshalToSizedBuffer(b) 919 if err != nil { 920 return nil, err 921 } 922 return b[:n], nil 923 } 924 } 925 func (m *Response) XXX_Merge(src proto.Message) { 926 xxx_messageInfo_Response.Merge(m, src) 927 } 928 func (m *Response) XXX_Size() int { 929 return m.Size() 930 } 931 func (m *Response) XXX_DiscardUnknown() { 932 xxx_messageInfo_Response.DiscardUnknown(m) 933 } 934 935 var xxx_messageInfo_Response proto.InternalMessageInfo 936 937 type isResponse_Value interface { 938 isResponse_Value() 939 Equal(interface{}) bool 940 MarshalTo([]byte) (int, error) 941 Size() int 942 } 943 944 type Response_Exception struct { 945 Exception *ResponseException `protobuf:"bytes,1,opt,name=exception,proto3,oneof" json:"exception,omitempty"` 946 } 947 type Response_Echo struct { 948 Echo *ResponseEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof" json:"echo,omitempty"` 949 } 950 type Response_Flush struct { 951 Flush *ResponseFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"` 952 } 953 type Response_Info struct { 954 Info *ResponseInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof" json:"info,omitempty"` 955 } 956 type Response_SetOption struct { 957 SetOption *ResponseSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof" json:"set_option,omitempty"` 958 } 959 type Response_InitChain struct { 960 InitChain *ResponseInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof" json:"init_chain,omitempty"` 961 } 962 type Response_Query struct { 963 Query *ResponseQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof" json:"query,omitempty"` 964 } 965 type Response_BeginBlock struct { 966 BeginBlock *ResponseBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof" json:"begin_block,omitempty"` 967 } 968 type Response_CheckTx struct { 969 CheckTx *ResponseCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof" json:"check_tx,omitempty"` 970 } 971 type Response_DeliverTx struct { 972 DeliverTx *ResponseDeliverTx `protobuf:"bytes,10,opt,name=deliver_tx,json=deliverTx,proto3,oneof" json:"deliver_tx,omitempty"` 973 } 974 type Response_EndBlock struct { 975 EndBlock *ResponseEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof" json:"end_block,omitempty"` 976 } 977 type Response_Commit struct { 978 Commit *ResponseCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"` 979 } 980 981 func (*Response_Exception) isResponse_Value() {} 982 func (*Response_Echo) isResponse_Value() {} 983 func (*Response_Flush) isResponse_Value() {} 984 func (*Response_Info) isResponse_Value() {} 985 func (*Response_SetOption) isResponse_Value() {} 986 func (*Response_InitChain) isResponse_Value() {} 987 func (*Response_Query) isResponse_Value() {} 988 func (*Response_BeginBlock) isResponse_Value() {} 989 func (*Response_CheckTx) isResponse_Value() {} 990 func (*Response_DeliverTx) isResponse_Value() {} 991 func (*Response_EndBlock) isResponse_Value() {} 992 func (*Response_Commit) isResponse_Value() {} 993 994 func (m *Response) GetValue() isResponse_Value { 995 if m != nil { 996 return m.Value 997 } 998 return nil 999 } 1000 1001 func (m *Response) GetException() *ResponseException { 1002 if x, ok := m.GetValue().(*Response_Exception); ok { 1003 return x.Exception 1004 } 1005 return nil 1006 } 1007 1008 func (m *Response) GetEcho() *ResponseEcho { 1009 if x, ok := m.GetValue().(*Response_Echo); ok { 1010 return x.Echo 1011 } 1012 return nil 1013 } 1014 1015 func (m *Response) GetFlush() *ResponseFlush { 1016 if x, ok := m.GetValue().(*Response_Flush); ok { 1017 return x.Flush 1018 } 1019 return nil 1020 } 1021 1022 func (m *Response) GetInfo() *ResponseInfo { 1023 if x, ok := m.GetValue().(*Response_Info); ok { 1024 return x.Info 1025 } 1026 return nil 1027 } 1028 1029 func (m *Response) GetSetOption() *ResponseSetOption { 1030 if x, ok := m.GetValue().(*Response_SetOption); ok { 1031 return x.SetOption 1032 } 1033 return nil 1034 } 1035 1036 func (m *Response) GetInitChain() *ResponseInitChain { 1037 if x, ok := m.GetValue().(*Response_InitChain); ok { 1038 return x.InitChain 1039 } 1040 return nil 1041 } 1042 1043 func (m *Response) GetQuery() *ResponseQuery { 1044 if x, ok := m.GetValue().(*Response_Query); ok { 1045 return x.Query 1046 } 1047 return nil 1048 } 1049 1050 func (m *Response) GetBeginBlock() *ResponseBeginBlock { 1051 if x, ok := m.GetValue().(*Response_BeginBlock); ok { 1052 return x.BeginBlock 1053 } 1054 return nil 1055 } 1056 1057 func (m *Response) GetCheckTx() *ResponseCheckTx { 1058 if x, ok := m.GetValue().(*Response_CheckTx); ok { 1059 return x.CheckTx 1060 } 1061 return nil 1062 } 1063 1064 func (m *Response) GetDeliverTx() *ResponseDeliverTx { 1065 if x, ok := m.GetValue().(*Response_DeliverTx); ok { 1066 return x.DeliverTx 1067 } 1068 return nil 1069 } 1070 1071 func (m *Response) GetEndBlock() *ResponseEndBlock { 1072 if x, ok := m.GetValue().(*Response_EndBlock); ok { 1073 return x.EndBlock 1074 } 1075 return nil 1076 } 1077 1078 func (m *Response) GetCommit() *ResponseCommit { 1079 if x, ok := m.GetValue().(*Response_Commit); ok { 1080 return x.Commit 1081 } 1082 return nil 1083 } 1084 1085 // XXX_OneofWrappers is for the internal use of the proto package. 1086 func (*Response) XXX_OneofWrappers() []interface{} { 1087 return []interface{}{ 1088 (*Response_Exception)(nil), 1089 (*Response_Echo)(nil), 1090 (*Response_Flush)(nil), 1091 (*Response_Info)(nil), 1092 (*Response_SetOption)(nil), 1093 (*Response_InitChain)(nil), 1094 (*Response_Query)(nil), 1095 (*Response_BeginBlock)(nil), 1096 (*Response_CheckTx)(nil), 1097 (*Response_DeliverTx)(nil), 1098 (*Response_EndBlock)(nil), 1099 (*Response_Commit)(nil), 1100 } 1101 } 1102 1103 // nondeterministic 1104 type ResponseException struct { 1105 Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` 1106 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1107 XXX_unrecognized []byte `json:"-"` 1108 XXX_sizecache int32 `json:"-"` 1109 } 1110 1111 func (m *ResponseException) Reset() { *m = ResponseException{} } 1112 func (m *ResponseException) String() string { return proto.CompactTextString(m) } 1113 func (*ResponseException) ProtoMessage() {} 1114 func (*ResponseException) Descriptor() ([]byte, []int) { 1115 return fileDescriptor_9f1eaa49c51fa1ac, []int{13} 1116 } 1117 func (m *ResponseException) XXX_Unmarshal(b []byte) error { 1118 return m.Unmarshal(b) 1119 } 1120 func (m *ResponseException) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1121 if deterministic { 1122 return xxx_messageInfo_ResponseException.Marshal(b, m, deterministic) 1123 } else { 1124 b = b[:cap(b)] 1125 n, err := m.MarshalToSizedBuffer(b) 1126 if err != nil { 1127 return nil, err 1128 } 1129 return b[:n], nil 1130 } 1131 } 1132 func (m *ResponseException) XXX_Merge(src proto.Message) { 1133 xxx_messageInfo_ResponseException.Merge(m, src) 1134 } 1135 func (m *ResponseException) XXX_Size() int { 1136 return m.Size() 1137 } 1138 func (m *ResponseException) XXX_DiscardUnknown() { 1139 xxx_messageInfo_ResponseException.DiscardUnknown(m) 1140 } 1141 1142 var xxx_messageInfo_ResponseException proto.InternalMessageInfo 1143 1144 func (m *ResponseException) GetError() string { 1145 if m != nil { 1146 return m.Error 1147 } 1148 return "" 1149 } 1150 1151 type ResponseEcho struct { 1152 Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` 1153 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1154 XXX_unrecognized []byte `json:"-"` 1155 XXX_sizecache int32 `json:"-"` 1156 } 1157 1158 func (m *ResponseEcho) Reset() { *m = ResponseEcho{} } 1159 func (m *ResponseEcho) String() string { return proto.CompactTextString(m) } 1160 func (*ResponseEcho) ProtoMessage() {} 1161 func (*ResponseEcho) Descriptor() ([]byte, []int) { 1162 return fileDescriptor_9f1eaa49c51fa1ac, []int{14} 1163 } 1164 func (m *ResponseEcho) XXX_Unmarshal(b []byte) error { 1165 return m.Unmarshal(b) 1166 } 1167 func (m *ResponseEcho) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1168 if deterministic { 1169 return xxx_messageInfo_ResponseEcho.Marshal(b, m, deterministic) 1170 } else { 1171 b = b[:cap(b)] 1172 n, err := m.MarshalToSizedBuffer(b) 1173 if err != nil { 1174 return nil, err 1175 } 1176 return b[:n], nil 1177 } 1178 } 1179 func (m *ResponseEcho) XXX_Merge(src proto.Message) { 1180 xxx_messageInfo_ResponseEcho.Merge(m, src) 1181 } 1182 func (m *ResponseEcho) XXX_Size() int { 1183 return m.Size() 1184 } 1185 func (m *ResponseEcho) XXX_DiscardUnknown() { 1186 xxx_messageInfo_ResponseEcho.DiscardUnknown(m) 1187 } 1188 1189 var xxx_messageInfo_ResponseEcho proto.InternalMessageInfo 1190 1191 func (m *ResponseEcho) GetMessage() string { 1192 if m != nil { 1193 return m.Message 1194 } 1195 return "" 1196 } 1197 1198 type ResponseFlush struct { 1199 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1200 XXX_unrecognized []byte `json:"-"` 1201 XXX_sizecache int32 `json:"-"` 1202 } 1203 1204 func (m *ResponseFlush) Reset() { *m = ResponseFlush{} } 1205 func (m *ResponseFlush) String() string { return proto.CompactTextString(m) } 1206 func (*ResponseFlush) ProtoMessage() {} 1207 func (*ResponseFlush) Descriptor() ([]byte, []int) { 1208 return fileDescriptor_9f1eaa49c51fa1ac, []int{15} 1209 } 1210 func (m *ResponseFlush) XXX_Unmarshal(b []byte) error { 1211 return m.Unmarshal(b) 1212 } 1213 func (m *ResponseFlush) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1214 if deterministic { 1215 return xxx_messageInfo_ResponseFlush.Marshal(b, m, deterministic) 1216 } else { 1217 b = b[:cap(b)] 1218 n, err := m.MarshalToSizedBuffer(b) 1219 if err != nil { 1220 return nil, err 1221 } 1222 return b[:n], nil 1223 } 1224 } 1225 func (m *ResponseFlush) XXX_Merge(src proto.Message) { 1226 xxx_messageInfo_ResponseFlush.Merge(m, src) 1227 } 1228 func (m *ResponseFlush) XXX_Size() int { 1229 return m.Size() 1230 } 1231 func (m *ResponseFlush) XXX_DiscardUnknown() { 1232 xxx_messageInfo_ResponseFlush.DiscardUnknown(m) 1233 } 1234 1235 var xxx_messageInfo_ResponseFlush proto.InternalMessageInfo 1236 1237 type ResponseInfo struct { 1238 Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 1239 Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` 1240 AppVersion uint64 `protobuf:"varint,3,opt,name=app_version,json=appVersion,proto3" json:"app_version,omitempty"` 1241 LastBlockHeight int64 `protobuf:"varint,4,opt,name=last_block_height,json=lastBlockHeight,proto3" json:"last_block_height,omitempty"` 1242 LastBlockAppHash []byte `protobuf:"bytes,5,opt,name=last_block_app_hash,json=lastBlockAppHash,proto3" json:"last_block_app_hash,omitempty"` 1243 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1244 XXX_unrecognized []byte `json:"-"` 1245 XXX_sizecache int32 `json:"-"` 1246 } 1247 1248 func (m *ResponseInfo) Reset() { *m = ResponseInfo{} } 1249 func (m *ResponseInfo) String() string { return proto.CompactTextString(m) } 1250 func (*ResponseInfo) ProtoMessage() {} 1251 func (*ResponseInfo) Descriptor() ([]byte, []int) { 1252 return fileDescriptor_9f1eaa49c51fa1ac, []int{16} 1253 } 1254 func (m *ResponseInfo) XXX_Unmarshal(b []byte) error { 1255 return m.Unmarshal(b) 1256 } 1257 func (m *ResponseInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1258 if deterministic { 1259 return xxx_messageInfo_ResponseInfo.Marshal(b, m, deterministic) 1260 } else { 1261 b = b[:cap(b)] 1262 n, err := m.MarshalToSizedBuffer(b) 1263 if err != nil { 1264 return nil, err 1265 } 1266 return b[:n], nil 1267 } 1268 } 1269 func (m *ResponseInfo) XXX_Merge(src proto.Message) { 1270 xxx_messageInfo_ResponseInfo.Merge(m, src) 1271 } 1272 func (m *ResponseInfo) XXX_Size() int { 1273 return m.Size() 1274 } 1275 func (m *ResponseInfo) XXX_DiscardUnknown() { 1276 xxx_messageInfo_ResponseInfo.DiscardUnknown(m) 1277 } 1278 1279 var xxx_messageInfo_ResponseInfo proto.InternalMessageInfo 1280 1281 func (m *ResponseInfo) GetData() string { 1282 if m != nil { 1283 return m.Data 1284 } 1285 return "" 1286 } 1287 1288 func (m *ResponseInfo) GetVersion() string { 1289 if m != nil { 1290 return m.Version 1291 } 1292 return "" 1293 } 1294 1295 func (m *ResponseInfo) GetAppVersion() uint64 { 1296 if m != nil { 1297 return m.AppVersion 1298 } 1299 return 0 1300 } 1301 1302 func (m *ResponseInfo) GetLastBlockHeight() int64 { 1303 if m != nil { 1304 return m.LastBlockHeight 1305 } 1306 return 0 1307 } 1308 1309 func (m *ResponseInfo) GetLastBlockAppHash() []byte { 1310 if m != nil { 1311 return m.LastBlockAppHash 1312 } 1313 return nil 1314 } 1315 1316 // nondeterministic 1317 type ResponseSetOption struct { 1318 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1319 // bytes data = 2; 1320 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1321 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1322 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1323 XXX_unrecognized []byte `json:"-"` 1324 XXX_sizecache int32 `json:"-"` 1325 } 1326 1327 func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} } 1328 func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) } 1329 func (*ResponseSetOption) ProtoMessage() {} 1330 func (*ResponseSetOption) Descriptor() ([]byte, []int) { 1331 return fileDescriptor_9f1eaa49c51fa1ac, []int{17} 1332 } 1333 func (m *ResponseSetOption) XXX_Unmarshal(b []byte) error { 1334 return m.Unmarshal(b) 1335 } 1336 func (m *ResponseSetOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1337 if deterministic { 1338 return xxx_messageInfo_ResponseSetOption.Marshal(b, m, deterministic) 1339 } else { 1340 b = b[:cap(b)] 1341 n, err := m.MarshalToSizedBuffer(b) 1342 if err != nil { 1343 return nil, err 1344 } 1345 return b[:n], nil 1346 } 1347 } 1348 func (m *ResponseSetOption) XXX_Merge(src proto.Message) { 1349 xxx_messageInfo_ResponseSetOption.Merge(m, src) 1350 } 1351 func (m *ResponseSetOption) XXX_Size() int { 1352 return m.Size() 1353 } 1354 func (m *ResponseSetOption) XXX_DiscardUnknown() { 1355 xxx_messageInfo_ResponseSetOption.DiscardUnknown(m) 1356 } 1357 1358 var xxx_messageInfo_ResponseSetOption proto.InternalMessageInfo 1359 1360 func (m *ResponseSetOption) GetCode() uint32 { 1361 if m != nil { 1362 return m.Code 1363 } 1364 return 0 1365 } 1366 1367 func (m *ResponseSetOption) GetLog() string { 1368 if m != nil { 1369 return m.Log 1370 } 1371 return "" 1372 } 1373 1374 func (m *ResponseSetOption) GetInfo() string { 1375 if m != nil { 1376 return m.Info 1377 } 1378 return "" 1379 } 1380 1381 type ResponseInitChain struct { 1382 ConsensusParams *ConsensusParams `protobuf:"bytes,1,opt,name=consensus_params,json=consensusParams,proto3" json:"consensus_params,omitempty"` 1383 Validators []ValidatorUpdate `protobuf:"bytes,2,rep,name=validators,proto3" json:"validators"` 1384 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1385 XXX_unrecognized []byte `json:"-"` 1386 XXX_sizecache int32 `json:"-"` 1387 } 1388 1389 func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} } 1390 func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) } 1391 func (*ResponseInitChain) ProtoMessage() {} 1392 func (*ResponseInitChain) Descriptor() ([]byte, []int) { 1393 return fileDescriptor_9f1eaa49c51fa1ac, []int{18} 1394 } 1395 func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error { 1396 return m.Unmarshal(b) 1397 } 1398 func (m *ResponseInitChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1399 if deterministic { 1400 return xxx_messageInfo_ResponseInitChain.Marshal(b, m, deterministic) 1401 } else { 1402 b = b[:cap(b)] 1403 n, err := m.MarshalToSizedBuffer(b) 1404 if err != nil { 1405 return nil, err 1406 } 1407 return b[:n], nil 1408 } 1409 } 1410 func (m *ResponseInitChain) XXX_Merge(src proto.Message) { 1411 xxx_messageInfo_ResponseInitChain.Merge(m, src) 1412 } 1413 func (m *ResponseInitChain) XXX_Size() int { 1414 return m.Size() 1415 } 1416 func (m *ResponseInitChain) XXX_DiscardUnknown() { 1417 xxx_messageInfo_ResponseInitChain.DiscardUnknown(m) 1418 } 1419 1420 var xxx_messageInfo_ResponseInitChain proto.InternalMessageInfo 1421 1422 func (m *ResponseInitChain) GetConsensusParams() *ConsensusParams { 1423 if m != nil { 1424 return m.ConsensusParams 1425 } 1426 return nil 1427 } 1428 1429 func (m *ResponseInitChain) GetValidators() []ValidatorUpdate { 1430 if m != nil { 1431 return m.Validators 1432 } 1433 return nil 1434 } 1435 1436 type ResponseQuery struct { 1437 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1438 // bytes data = 2; // use "value" instead. 1439 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1440 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1441 Index int64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"` 1442 Key []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"` 1443 Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"` 1444 Proof *merkle.Proof `protobuf:"bytes,8,opt,name=proof,proto3" json:"proof,omitempty"` 1445 Height int64 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"` 1446 Codespace string `protobuf:"bytes,10,opt,name=codespace,proto3" json:"codespace,omitempty"` 1447 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1448 XXX_unrecognized []byte `json:"-"` 1449 XXX_sizecache int32 `json:"-"` 1450 } 1451 1452 func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } 1453 func (m *ResponseQuery) String() string { return proto.CompactTextString(m) } 1454 func (*ResponseQuery) ProtoMessage() {} 1455 func (*ResponseQuery) Descriptor() ([]byte, []int) { 1456 return fileDescriptor_9f1eaa49c51fa1ac, []int{19} 1457 } 1458 func (m *ResponseQuery) XXX_Unmarshal(b []byte) error { 1459 return m.Unmarshal(b) 1460 } 1461 func (m *ResponseQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1462 if deterministic { 1463 return xxx_messageInfo_ResponseQuery.Marshal(b, m, deterministic) 1464 } else { 1465 b = b[:cap(b)] 1466 n, err := m.MarshalToSizedBuffer(b) 1467 if err != nil { 1468 return nil, err 1469 } 1470 return b[:n], nil 1471 } 1472 } 1473 func (m *ResponseQuery) XXX_Merge(src proto.Message) { 1474 xxx_messageInfo_ResponseQuery.Merge(m, src) 1475 } 1476 func (m *ResponseQuery) XXX_Size() int { 1477 return m.Size() 1478 } 1479 func (m *ResponseQuery) XXX_DiscardUnknown() { 1480 xxx_messageInfo_ResponseQuery.DiscardUnknown(m) 1481 } 1482 1483 var xxx_messageInfo_ResponseQuery proto.InternalMessageInfo 1484 1485 func (m *ResponseQuery) GetCode() uint32 { 1486 if m != nil { 1487 return m.Code 1488 } 1489 return 0 1490 } 1491 1492 func (m *ResponseQuery) GetLog() string { 1493 if m != nil { 1494 return m.Log 1495 } 1496 return "" 1497 } 1498 1499 func (m *ResponseQuery) GetInfo() string { 1500 if m != nil { 1501 return m.Info 1502 } 1503 return "" 1504 } 1505 1506 func (m *ResponseQuery) GetIndex() int64 { 1507 if m != nil { 1508 return m.Index 1509 } 1510 return 0 1511 } 1512 1513 func (m *ResponseQuery) GetKey() []byte { 1514 if m != nil { 1515 return m.Key 1516 } 1517 return nil 1518 } 1519 1520 func (m *ResponseQuery) GetValue() []byte { 1521 if m != nil { 1522 return m.Value 1523 } 1524 return nil 1525 } 1526 1527 func (m *ResponseQuery) GetProof() *merkle.Proof { 1528 if m != nil { 1529 return m.Proof 1530 } 1531 return nil 1532 } 1533 1534 func (m *ResponseQuery) GetHeight() int64 { 1535 if m != nil { 1536 return m.Height 1537 } 1538 return 0 1539 } 1540 1541 func (m *ResponseQuery) GetCodespace() string { 1542 if m != nil { 1543 return m.Codespace 1544 } 1545 return "" 1546 } 1547 1548 type ResponseBeginBlock struct { 1549 Events []Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` 1550 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1551 XXX_unrecognized []byte `json:"-"` 1552 XXX_sizecache int32 `json:"-"` 1553 } 1554 1555 func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} } 1556 func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) } 1557 func (*ResponseBeginBlock) ProtoMessage() {} 1558 func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { 1559 return fileDescriptor_9f1eaa49c51fa1ac, []int{20} 1560 } 1561 func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error { 1562 return m.Unmarshal(b) 1563 } 1564 func (m *ResponseBeginBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1565 if deterministic { 1566 return xxx_messageInfo_ResponseBeginBlock.Marshal(b, m, deterministic) 1567 } else { 1568 b = b[:cap(b)] 1569 n, err := m.MarshalToSizedBuffer(b) 1570 if err != nil { 1571 return nil, err 1572 } 1573 return b[:n], nil 1574 } 1575 } 1576 func (m *ResponseBeginBlock) XXX_Merge(src proto.Message) { 1577 xxx_messageInfo_ResponseBeginBlock.Merge(m, src) 1578 } 1579 func (m *ResponseBeginBlock) XXX_Size() int { 1580 return m.Size() 1581 } 1582 func (m *ResponseBeginBlock) XXX_DiscardUnknown() { 1583 xxx_messageInfo_ResponseBeginBlock.DiscardUnknown(m) 1584 } 1585 1586 var xxx_messageInfo_ResponseBeginBlock proto.InternalMessageInfo 1587 1588 func (m *ResponseBeginBlock) GetEvents() []Event { 1589 if m != nil { 1590 return m.Events 1591 } 1592 return nil 1593 } 1594 1595 type ResponseCheckTx struct { 1596 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1597 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 1598 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1599 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1600 GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"` 1601 GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` 1602 Events []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"` 1603 Codespace string `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"` 1604 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1605 XXX_unrecognized []byte `json:"-"` 1606 XXX_sizecache int32 `json:"-"` 1607 } 1608 1609 func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } 1610 func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) } 1611 func (*ResponseCheckTx) ProtoMessage() {} 1612 func (*ResponseCheckTx) Descriptor() ([]byte, []int) { 1613 return fileDescriptor_9f1eaa49c51fa1ac, []int{21} 1614 } 1615 func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error { 1616 return m.Unmarshal(b) 1617 } 1618 func (m *ResponseCheckTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1619 if deterministic { 1620 return xxx_messageInfo_ResponseCheckTx.Marshal(b, m, deterministic) 1621 } else { 1622 b = b[:cap(b)] 1623 n, err := m.MarshalToSizedBuffer(b) 1624 if err != nil { 1625 return nil, err 1626 } 1627 return b[:n], nil 1628 } 1629 } 1630 func (m *ResponseCheckTx) XXX_Merge(src proto.Message) { 1631 xxx_messageInfo_ResponseCheckTx.Merge(m, src) 1632 } 1633 func (m *ResponseCheckTx) XXX_Size() int { 1634 return m.Size() 1635 } 1636 func (m *ResponseCheckTx) XXX_DiscardUnknown() { 1637 xxx_messageInfo_ResponseCheckTx.DiscardUnknown(m) 1638 } 1639 1640 var xxx_messageInfo_ResponseCheckTx proto.InternalMessageInfo 1641 1642 func (m *ResponseCheckTx) GetCode() uint32 { 1643 if m != nil { 1644 return m.Code 1645 } 1646 return 0 1647 } 1648 1649 func (m *ResponseCheckTx) GetData() []byte { 1650 if m != nil { 1651 return m.Data 1652 } 1653 return nil 1654 } 1655 1656 func (m *ResponseCheckTx) GetLog() string { 1657 if m != nil { 1658 return m.Log 1659 } 1660 return "" 1661 } 1662 1663 func (m *ResponseCheckTx) GetInfo() string { 1664 if m != nil { 1665 return m.Info 1666 } 1667 return "" 1668 } 1669 1670 func (m *ResponseCheckTx) GetGasWanted() int64 { 1671 if m != nil { 1672 return m.GasWanted 1673 } 1674 return 0 1675 } 1676 1677 func (m *ResponseCheckTx) GetGasUsed() int64 { 1678 if m != nil { 1679 return m.GasUsed 1680 } 1681 return 0 1682 } 1683 1684 func (m *ResponseCheckTx) GetEvents() []Event { 1685 if m != nil { 1686 return m.Events 1687 } 1688 return nil 1689 } 1690 1691 func (m *ResponseCheckTx) GetCodespace() string { 1692 if m != nil { 1693 return m.Codespace 1694 } 1695 return "" 1696 } 1697 1698 type ResponseDeliverTx struct { 1699 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1700 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 1701 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1702 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1703 GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"` 1704 GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` 1705 Events []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"` 1706 Codespace string `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"` 1707 Signer []byte `protobuf:"bytes,9,opt,name=signer,proto3" json:"signer,omitempty"` 1708 Recipient []byte `protobuf:"bytes,10,opt,name=recipient,proto3" json:"recipient,omitempty"` 1709 MessageType string `protobuf:"bytes,11,opt,name=message_type,proto3" json:"message_type,omitempty"` 1710 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1711 XXX_unrecognized []byte `json:"-"` 1712 XXX_sizecache int32 `json:"-"` 1713 } 1714 1715 func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } 1716 func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) } 1717 func (*ResponseDeliverTx) ProtoMessage() {} 1718 func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { 1719 return fileDescriptor_9f1eaa49c51fa1ac, []int{22} 1720 } 1721 func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error { 1722 return m.Unmarshal(b) 1723 } 1724 func (m *ResponseDeliverTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1725 if deterministic { 1726 return xxx_messageInfo_ResponseDeliverTx.Marshal(b, m, deterministic) 1727 } else { 1728 b = b[:cap(b)] 1729 n, err := m.MarshalToSizedBuffer(b) 1730 if err != nil { 1731 return nil, err 1732 } 1733 return b[:n], nil 1734 } 1735 } 1736 func (m *ResponseDeliverTx) XXX_Merge(src proto.Message) { 1737 xxx_messageInfo_ResponseDeliverTx.Merge(m, src) 1738 } 1739 func (m *ResponseDeliverTx) XXX_Size() int { 1740 return m.Size() 1741 } 1742 func (m *ResponseDeliverTx) XXX_DiscardUnknown() { 1743 xxx_messageInfo_ResponseDeliverTx.DiscardUnknown(m) 1744 } 1745 1746 var xxx_messageInfo_ResponseDeliverTx proto.InternalMessageInfo 1747 1748 func (m *ResponseDeliverTx) GetCode() uint32 { 1749 if m != nil { 1750 return m.Code 1751 } 1752 return 0 1753 } 1754 1755 func (m *ResponseDeliverTx) GetData() []byte { 1756 if m != nil { 1757 return m.Data 1758 } 1759 return nil 1760 } 1761 1762 func (m *ResponseDeliverTx) GetLog() string { 1763 if m != nil { 1764 return m.Log 1765 } 1766 return "" 1767 } 1768 1769 func (m *ResponseDeliverTx) GetInfo() string { 1770 if m != nil { 1771 return m.Info 1772 } 1773 return "" 1774 } 1775 1776 func (m *ResponseDeliverTx) GetGasWanted() int64 { 1777 if m != nil { 1778 return m.GasWanted 1779 } 1780 return 0 1781 } 1782 1783 func (m *ResponseDeliverTx) GetGasUsed() int64 { 1784 if m != nil { 1785 return m.GasUsed 1786 } 1787 return 0 1788 } 1789 1790 func (m *ResponseDeliverTx) GetEvents() []Event { 1791 if m != nil { 1792 return m.Events 1793 } 1794 return nil 1795 } 1796 1797 func (m *ResponseDeliverTx) GetCodespace() string { 1798 if m != nil { 1799 return m.Codespace 1800 } 1801 return "" 1802 } 1803 1804 type ResponseEndBlock struct { 1805 ValidatorUpdates []ValidatorUpdate `protobuf:"bytes,1,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates"` 1806 ConsensusParamUpdates *ConsensusParams `protobuf:"bytes,2,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"` 1807 Events []Event `protobuf:"bytes,3,rep,name=events,proto3" json:"events,omitempty"` 1808 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1809 XXX_unrecognized []byte `json:"-"` 1810 XXX_sizecache int32 `json:"-"` 1811 } 1812 1813 func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} } 1814 func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) } 1815 func (*ResponseEndBlock) ProtoMessage() {} 1816 func (*ResponseEndBlock) Descriptor() ([]byte, []int) { 1817 return fileDescriptor_9f1eaa49c51fa1ac, []int{23} 1818 } 1819 func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error { 1820 return m.Unmarshal(b) 1821 } 1822 func (m *ResponseEndBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1823 if deterministic { 1824 return xxx_messageInfo_ResponseEndBlock.Marshal(b, m, deterministic) 1825 } else { 1826 b = b[:cap(b)] 1827 n, err := m.MarshalToSizedBuffer(b) 1828 if err != nil { 1829 return nil, err 1830 } 1831 return b[:n], nil 1832 } 1833 } 1834 func (m *ResponseEndBlock) XXX_Merge(src proto.Message) { 1835 xxx_messageInfo_ResponseEndBlock.Merge(m, src) 1836 } 1837 func (m *ResponseEndBlock) XXX_Size() int { 1838 return m.Size() 1839 } 1840 func (m *ResponseEndBlock) XXX_DiscardUnknown() { 1841 xxx_messageInfo_ResponseEndBlock.DiscardUnknown(m) 1842 } 1843 1844 var xxx_messageInfo_ResponseEndBlock proto.InternalMessageInfo 1845 1846 func (m *ResponseEndBlock) GetValidatorUpdates() []ValidatorUpdate { 1847 if m != nil { 1848 return m.ValidatorUpdates 1849 } 1850 return nil 1851 } 1852 1853 func (m *ResponseEndBlock) GetConsensusParamUpdates() *ConsensusParams { 1854 if m != nil { 1855 return m.ConsensusParamUpdates 1856 } 1857 return nil 1858 } 1859 1860 func (m *ResponseEndBlock) GetEvents() []Event { 1861 if m != nil { 1862 return m.Events 1863 } 1864 return nil 1865 } 1866 1867 type ResponseCommit struct { 1868 // reserve 1 1869 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 1870 RetainHeight int64 `protobuf:"varint,3,opt,name=retain_height,json=retainHeight,proto3" json:"retain_height,omitempty"` 1871 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1872 XXX_unrecognized []byte `json:"-"` 1873 XXX_sizecache int32 `json:"-"` 1874 } 1875 1876 func (m *ResponseCommit) Reset() { *m = ResponseCommit{} } 1877 func (m *ResponseCommit) String() string { return proto.CompactTextString(m) } 1878 func (*ResponseCommit) ProtoMessage() {} 1879 func (*ResponseCommit) Descriptor() ([]byte, []int) { 1880 return fileDescriptor_9f1eaa49c51fa1ac, []int{24} 1881 } 1882 func (m *ResponseCommit) XXX_Unmarshal(b []byte) error { 1883 return m.Unmarshal(b) 1884 } 1885 func (m *ResponseCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1886 if deterministic { 1887 return xxx_messageInfo_ResponseCommit.Marshal(b, m, deterministic) 1888 } else { 1889 b = b[:cap(b)] 1890 n, err := m.MarshalToSizedBuffer(b) 1891 if err != nil { 1892 return nil, err 1893 } 1894 return b[:n], nil 1895 } 1896 } 1897 func (m *ResponseCommit) XXX_Merge(src proto.Message) { 1898 xxx_messageInfo_ResponseCommit.Merge(m, src) 1899 } 1900 func (m *ResponseCommit) XXX_Size() int { 1901 return m.Size() 1902 } 1903 func (m *ResponseCommit) XXX_DiscardUnknown() { 1904 xxx_messageInfo_ResponseCommit.DiscardUnknown(m) 1905 } 1906 1907 var xxx_messageInfo_ResponseCommit proto.InternalMessageInfo 1908 1909 func (m *ResponseCommit) GetData() []byte { 1910 if m != nil { 1911 return m.Data 1912 } 1913 return nil 1914 } 1915 1916 func (m *ResponseCommit) GetRetainHeight() int64 { 1917 if m != nil { 1918 return m.RetainHeight 1919 } 1920 return 0 1921 } 1922 1923 // ConsensusParams contains all consensus-relevant parameters 1924 // that can be adjusted by the abci app 1925 type ConsensusParams struct { 1926 Block *BlockParams `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` 1927 Evidence *EvidenceParams `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"` 1928 Validator *ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"` 1929 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1930 XXX_unrecognized []byte `json:"-"` 1931 XXX_sizecache int32 `json:"-"` 1932 } 1933 1934 func (m *ConsensusParams) Reset() { *m = ConsensusParams{} } 1935 func (m *ConsensusParams) String() string { return proto.CompactTextString(m) } 1936 func (*ConsensusParams) ProtoMessage() {} 1937 func (*ConsensusParams) Descriptor() ([]byte, []int) { 1938 return fileDescriptor_9f1eaa49c51fa1ac, []int{25} 1939 } 1940 func (m *ConsensusParams) XXX_Unmarshal(b []byte) error { 1941 return m.Unmarshal(b) 1942 } 1943 func (m *ConsensusParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1944 if deterministic { 1945 return xxx_messageInfo_ConsensusParams.Marshal(b, m, deterministic) 1946 } else { 1947 b = b[:cap(b)] 1948 n, err := m.MarshalToSizedBuffer(b) 1949 if err != nil { 1950 return nil, err 1951 } 1952 return b[:n], nil 1953 } 1954 } 1955 func (m *ConsensusParams) XXX_Merge(src proto.Message) { 1956 xxx_messageInfo_ConsensusParams.Merge(m, src) 1957 } 1958 func (m *ConsensusParams) XXX_Size() int { 1959 return m.Size() 1960 } 1961 func (m *ConsensusParams) XXX_DiscardUnknown() { 1962 xxx_messageInfo_ConsensusParams.DiscardUnknown(m) 1963 } 1964 1965 var xxx_messageInfo_ConsensusParams proto.InternalMessageInfo 1966 1967 func (m *ConsensusParams) GetBlock() *BlockParams { 1968 if m != nil { 1969 return m.Block 1970 } 1971 return nil 1972 } 1973 1974 func (m *ConsensusParams) GetEvidence() *EvidenceParams { 1975 if m != nil { 1976 return m.Evidence 1977 } 1978 return nil 1979 } 1980 1981 func (m *ConsensusParams) GetValidator() *ValidatorParams { 1982 if m != nil { 1983 return m.Validator 1984 } 1985 return nil 1986 } 1987 1988 // BlockParams contains limits on the block size. 1989 type BlockParams struct { 1990 // Note: must be greater than 0 1991 MaxBytes int64 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"` 1992 // Note: must be greater or equal to -1 1993 MaxGas int64 `protobuf:"varint,2,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"` 1994 XXX_NoUnkeyedLiteral struct{} `json:"-"` 1995 XXX_unrecognized []byte `json:"-"` 1996 XXX_sizecache int32 `json:"-"` 1997 } 1998 1999 func (m *BlockParams) Reset() { *m = BlockParams{} } 2000 func (m *BlockParams) String() string { return proto.CompactTextString(m) } 2001 func (*BlockParams) ProtoMessage() {} 2002 func (*BlockParams) Descriptor() ([]byte, []int) { 2003 return fileDescriptor_9f1eaa49c51fa1ac, []int{26} 2004 } 2005 func (m *BlockParams) XXX_Unmarshal(b []byte) error { 2006 return m.Unmarshal(b) 2007 } 2008 func (m *BlockParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2009 if deterministic { 2010 return xxx_messageInfo_BlockParams.Marshal(b, m, deterministic) 2011 } else { 2012 b = b[:cap(b)] 2013 n, err := m.MarshalToSizedBuffer(b) 2014 if err != nil { 2015 return nil, err 2016 } 2017 return b[:n], nil 2018 } 2019 } 2020 func (m *BlockParams) XXX_Merge(src proto.Message) { 2021 xxx_messageInfo_BlockParams.Merge(m, src) 2022 } 2023 func (m *BlockParams) XXX_Size() int { 2024 return m.Size() 2025 } 2026 func (m *BlockParams) XXX_DiscardUnknown() { 2027 xxx_messageInfo_BlockParams.DiscardUnknown(m) 2028 } 2029 2030 var xxx_messageInfo_BlockParams proto.InternalMessageInfo 2031 2032 func (m *BlockParams) GetMaxBytes() int64 { 2033 if m != nil { 2034 return m.MaxBytes 2035 } 2036 return 0 2037 } 2038 2039 func (m *BlockParams) GetMaxGas() int64 { 2040 if m != nil { 2041 return m.MaxGas 2042 } 2043 return 0 2044 } 2045 2046 type EvidenceParams struct { 2047 // Note: must be greater than 0 2048 MaxAge int64 `protobuf:"varint,1,opt,name=max_age,json=maxAge,proto3" json:"max_age,omitempty"` 2049 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2050 XXX_unrecognized []byte `json:"-"` 2051 XXX_sizecache int32 `json:"-"` 2052 } 2053 2054 func (m *EvidenceParams) Reset() { *m = EvidenceParams{} } 2055 func (m *EvidenceParams) String() string { return proto.CompactTextString(m) } 2056 func (*EvidenceParams) ProtoMessage() {} 2057 func (*EvidenceParams) Descriptor() ([]byte, []int) { 2058 return fileDescriptor_9f1eaa49c51fa1ac, []int{27} 2059 } 2060 func (m *EvidenceParams) XXX_Unmarshal(b []byte) error { 2061 return m.Unmarshal(b) 2062 } 2063 func (m *EvidenceParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2064 if deterministic { 2065 return xxx_messageInfo_EvidenceParams.Marshal(b, m, deterministic) 2066 } else { 2067 b = b[:cap(b)] 2068 n, err := m.MarshalToSizedBuffer(b) 2069 if err != nil { 2070 return nil, err 2071 } 2072 return b[:n], nil 2073 } 2074 } 2075 func (m *EvidenceParams) XXX_Merge(src proto.Message) { 2076 xxx_messageInfo_EvidenceParams.Merge(m, src) 2077 } 2078 func (m *EvidenceParams) XXX_Size() int { 2079 return m.Size() 2080 } 2081 func (m *EvidenceParams) XXX_DiscardUnknown() { 2082 xxx_messageInfo_EvidenceParams.DiscardUnknown(m) 2083 } 2084 2085 var xxx_messageInfo_EvidenceParams proto.InternalMessageInfo 2086 2087 func (m *EvidenceParams) GetMaxAge() int64 { 2088 if m != nil { 2089 return m.MaxAge 2090 } 2091 return 0 2092 } 2093 2094 // ValidatorParams contains limits on validators. 2095 type ValidatorParams struct { 2096 PubKeyTypes []string `protobuf:"bytes,1,rep,name=pub_key_types,json=pubKeyTypes,proto3" json:"pub_key_types,omitempty"` 2097 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2098 XXX_unrecognized []byte `json:"-"` 2099 XXX_sizecache int32 `json:"-"` 2100 } 2101 2102 func (m *ValidatorParams) Reset() { *m = ValidatorParams{} } 2103 func (m *ValidatorParams) String() string { return proto.CompactTextString(m) } 2104 func (*ValidatorParams) ProtoMessage() {} 2105 func (*ValidatorParams) Descriptor() ([]byte, []int) { 2106 return fileDescriptor_9f1eaa49c51fa1ac, []int{28} 2107 } 2108 func (m *ValidatorParams) XXX_Unmarshal(b []byte) error { 2109 return m.Unmarshal(b) 2110 } 2111 func (m *ValidatorParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2112 if deterministic { 2113 return xxx_messageInfo_ValidatorParams.Marshal(b, m, deterministic) 2114 } else { 2115 b = b[:cap(b)] 2116 n, err := m.MarshalToSizedBuffer(b) 2117 if err != nil { 2118 return nil, err 2119 } 2120 return b[:n], nil 2121 } 2122 } 2123 func (m *ValidatorParams) XXX_Merge(src proto.Message) { 2124 xxx_messageInfo_ValidatorParams.Merge(m, src) 2125 } 2126 func (m *ValidatorParams) XXX_Size() int { 2127 return m.Size() 2128 } 2129 func (m *ValidatorParams) XXX_DiscardUnknown() { 2130 xxx_messageInfo_ValidatorParams.DiscardUnknown(m) 2131 } 2132 2133 var xxx_messageInfo_ValidatorParams proto.InternalMessageInfo 2134 2135 func (m *ValidatorParams) GetPubKeyTypes() []string { 2136 if m != nil { 2137 return m.PubKeyTypes 2138 } 2139 return nil 2140 } 2141 2142 type LastCommitInfo struct { 2143 Round int32 `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"` 2144 Votes []VoteInfo `protobuf:"bytes,2,rep,name=votes,proto3" json:"votes"` 2145 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2146 XXX_unrecognized []byte `json:"-"` 2147 XXX_sizecache int32 `json:"-"` 2148 } 2149 2150 func (m *LastCommitInfo) Reset() { *m = LastCommitInfo{} } 2151 func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) } 2152 func (*LastCommitInfo) ProtoMessage() {} 2153 func (*LastCommitInfo) Descriptor() ([]byte, []int) { 2154 return fileDescriptor_9f1eaa49c51fa1ac, []int{29} 2155 } 2156 func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error { 2157 return m.Unmarshal(b) 2158 } 2159 func (m *LastCommitInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2160 if deterministic { 2161 return xxx_messageInfo_LastCommitInfo.Marshal(b, m, deterministic) 2162 } else { 2163 b = b[:cap(b)] 2164 n, err := m.MarshalToSizedBuffer(b) 2165 if err != nil { 2166 return nil, err 2167 } 2168 return b[:n], nil 2169 } 2170 } 2171 func (m *LastCommitInfo) XXX_Merge(src proto.Message) { 2172 xxx_messageInfo_LastCommitInfo.Merge(m, src) 2173 } 2174 func (m *LastCommitInfo) XXX_Size() int { 2175 return m.Size() 2176 } 2177 func (m *LastCommitInfo) XXX_DiscardUnknown() { 2178 xxx_messageInfo_LastCommitInfo.DiscardUnknown(m) 2179 } 2180 2181 var xxx_messageInfo_LastCommitInfo proto.InternalMessageInfo 2182 2183 func (m *LastCommitInfo) GetRound() int32 { 2184 if m != nil { 2185 return m.Round 2186 } 2187 return 0 2188 } 2189 2190 func (m *LastCommitInfo) GetVotes() []VoteInfo { 2191 if m != nil { 2192 return m.Votes 2193 } 2194 return nil 2195 } 2196 2197 type Event struct { 2198 Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` 2199 Attributes []kv.Pair `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"` 2200 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2201 XXX_unrecognized []byte `json:"-"` 2202 XXX_sizecache int32 `json:"-"` 2203 } 2204 2205 func (m *Event) Reset() { *m = Event{} } 2206 func (m *Event) String() string { return proto.CompactTextString(m) } 2207 func (*Event) ProtoMessage() {} 2208 func (*Event) Descriptor() ([]byte, []int) { 2209 return fileDescriptor_9f1eaa49c51fa1ac, []int{30} 2210 } 2211 func (m *Event) XXX_Unmarshal(b []byte) error { 2212 return m.Unmarshal(b) 2213 } 2214 func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2215 if deterministic { 2216 return xxx_messageInfo_Event.Marshal(b, m, deterministic) 2217 } else { 2218 b = b[:cap(b)] 2219 n, err := m.MarshalToSizedBuffer(b) 2220 if err != nil { 2221 return nil, err 2222 } 2223 return b[:n], nil 2224 } 2225 } 2226 func (m *Event) XXX_Merge(src proto.Message) { 2227 xxx_messageInfo_Event.Merge(m, src) 2228 } 2229 func (m *Event) XXX_Size() int { 2230 return m.Size() 2231 } 2232 func (m *Event) XXX_DiscardUnknown() { 2233 xxx_messageInfo_Event.DiscardUnknown(m) 2234 } 2235 2236 var xxx_messageInfo_Event proto.InternalMessageInfo 2237 2238 func (m *Event) GetType() string { 2239 if m != nil { 2240 return m.Type 2241 } 2242 return "" 2243 } 2244 2245 func (m *Event) GetAttributes() []kv.Pair { 2246 if m != nil { 2247 return m.Attributes 2248 } 2249 return nil 2250 } 2251 2252 type Header struct { 2253 // basic block info 2254 Version Version `protobuf:"bytes,1,opt,name=version,proto3" json:"version"` 2255 ChainID string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` 2256 Height int64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` 2257 Time time.Time `protobuf:"bytes,4,opt,name=time,proto3,stdtime" json:"time"` 2258 NumTxs int64 `protobuf:"varint,5,opt,name=num_txs,json=numTxs,proto3" json:"num_txs,omitempty"` 2259 TotalTxs int64 `protobuf:"varint,6,opt,name=total_txs,json=totalTxs,proto3" json:"total_txs,omitempty"` 2260 // prev block info 2261 LastBlockId BlockID `protobuf:"bytes,7,opt,name=last_block_id,json=lastBlockId,proto3" json:"last_block_id"` 2262 // hashes of block data 2263 LastCommitHash []byte `protobuf:"bytes,8,opt,name=last_commit_hash,json=lastCommitHash,proto3" json:"last_commit_hash,omitempty"` 2264 DataHash []byte `protobuf:"bytes,9,opt,name=data_hash,json=dataHash,proto3" json:"data_hash,omitempty"` 2265 // hashes from the app output from the prev block 2266 ValidatorsHash []byte `protobuf:"bytes,10,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"` 2267 NextValidatorsHash []byte `protobuf:"bytes,11,opt,name=next_validators_hash,json=nextValidatorsHash,proto3" json:"next_validators_hash,omitempty"` 2268 ConsensusHash []byte `protobuf:"bytes,12,opt,name=consensus_hash,json=consensusHash,proto3" json:"consensus_hash,omitempty"` 2269 AppHash []byte `protobuf:"bytes,13,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` 2270 LastResultsHash []byte `protobuf:"bytes,14,opt,name=last_results_hash,json=lastResultsHash,proto3" json:"last_results_hash,omitempty"` 2271 // consensus info 2272 EvidenceHash []byte `protobuf:"bytes,15,opt,name=evidence_hash,json=evidenceHash,proto3" json:"evidence_hash,omitempty"` 2273 ProposerAddress []byte `protobuf:"bytes,16,opt,name=proposer_address,json=proposerAddress,proto3" json:"proposer_address,omitempty"` 2274 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2275 XXX_unrecognized []byte `json:"-"` 2276 XXX_sizecache int32 `json:"-"` 2277 } 2278 2279 func (m *Header) Reset() { *m = Header{} } 2280 func (m *Header) String() string { return proto.CompactTextString(m) } 2281 func (*Header) ProtoMessage() {} 2282 func (*Header) Descriptor() ([]byte, []int) { 2283 return fileDescriptor_9f1eaa49c51fa1ac, []int{31} 2284 } 2285 func (m *Header) XXX_Unmarshal(b []byte) error { 2286 return m.Unmarshal(b) 2287 } 2288 func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2289 if deterministic { 2290 return xxx_messageInfo_Header.Marshal(b, m, deterministic) 2291 } else { 2292 b = b[:cap(b)] 2293 n, err := m.MarshalToSizedBuffer(b) 2294 if err != nil { 2295 return nil, err 2296 } 2297 return b[:n], nil 2298 } 2299 } 2300 func (m *Header) XXX_Merge(src proto.Message) { 2301 xxx_messageInfo_Header.Merge(m, src) 2302 } 2303 func (m *Header) XXX_Size() int { 2304 return m.Size() 2305 } 2306 func (m *Header) XXX_DiscardUnknown() { 2307 xxx_messageInfo_Header.DiscardUnknown(m) 2308 } 2309 2310 var xxx_messageInfo_Header proto.InternalMessageInfo 2311 2312 func (m *Header) GetVersion() Version { 2313 if m != nil { 2314 return m.Version 2315 } 2316 return Version{} 2317 } 2318 2319 func (m *Header) GetChainID() string { 2320 if m != nil { 2321 return m.ChainID 2322 } 2323 return "" 2324 } 2325 2326 func (m *Header) GetHeight() int64 { 2327 if m != nil { 2328 return m.Height 2329 } 2330 return 0 2331 } 2332 2333 func (m *Header) GetTime() time.Time { 2334 if m != nil { 2335 return m.Time 2336 } 2337 return time.Time{} 2338 } 2339 2340 func (m *Header) GetNumTxs() int64 { 2341 if m != nil { 2342 return m.NumTxs 2343 } 2344 return 0 2345 } 2346 2347 func (m *Header) GetTotalTxs() int64 { 2348 if m != nil { 2349 return m.TotalTxs 2350 } 2351 return 0 2352 } 2353 2354 func (m *Header) GetLastBlockId() BlockID { 2355 if m != nil { 2356 return m.LastBlockId 2357 } 2358 return BlockID{} 2359 } 2360 2361 func (m *Header) GetLastCommitHash() []byte { 2362 if m != nil { 2363 return m.LastCommitHash 2364 } 2365 return nil 2366 } 2367 2368 func (m *Header) GetDataHash() []byte { 2369 if m != nil { 2370 return m.DataHash 2371 } 2372 return nil 2373 } 2374 2375 func (m *Header) GetValidatorsHash() []byte { 2376 if m != nil { 2377 return m.ValidatorsHash 2378 } 2379 return nil 2380 } 2381 2382 func (m *Header) GetNextValidatorsHash() []byte { 2383 if m != nil { 2384 return m.NextValidatorsHash 2385 } 2386 return nil 2387 } 2388 2389 func (m *Header) GetConsensusHash() []byte { 2390 if m != nil { 2391 return m.ConsensusHash 2392 } 2393 return nil 2394 } 2395 2396 func (m *Header) GetAppHash() []byte { 2397 if m != nil { 2398 return m.AppHash 2399 } 2400 return nil 2401 } 2402 2403 func (m *Header) GetLastResultsHash() []byte { 2404 if m != nil { 2405 return m.LastResultsHash 2406 } 2407 return nil 2408 } 2409 2410 func (m *Header) GetEvidenceHash() []byte { 2411 if m != nil { 2412 return m.EvidenceHash 2413 } 2414 return nil 2415 } 2416 2417 func (m *Header) GetProposerAddress() []byte { 2418 if m != nil { 2419 return m.ProposerAddress 2420 } 2421 return nil 2422 } 2423 2424 type Version struct { 2425 Block uint64 `protobuf:"varint,1,opt,name=Block,proto3" json:"Block,omitempty"` 2426 App uint64 `protobuf:"varint,2,opt,name=App,proto3" json:"App,omitempty"` 2427 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2428 XXX_unrecognized []byte `json:"-"` 2429 XXX_sizecache int32 `json:"-"` 2430 } 2431 2432 func (m *Version) Reset() { *m = Version{} } 2433 func (m *Version) String() string { return proto.CompactTextString(m) } 2434 func (*Version) ProtoMessage() {} 2435 func (*Version) Descriptor() ([]byte, []int) { 2436 return fileDescriptor_9f1eaa49c51fa1ac, []int{32} 2437 } 2438 func (m *Version) XXX_Unmarshal(b []byte) error { 2439 return m.Unmarshal(b) 2440 } 2441 func (m *Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2442 if deterministic { 2443 return xxx_messageInfo_Version.Marshal(b, m, deterministic) 2444 } else { 2445 b = b[:cap(b)] 2446 n, err := m.MarshalToSizedBuffer(b) 2447 if err != nil { 2448 return nil, err 2449 } 2450 return b[:n], nil 2451 } 2452 } 2453 func (m *Version) XXX_Merge(src proto.Message) { 2454 xxx_messageInfo_Version.Merge(m, src) 2455 } 2456 func (m *Version) XXX_Size() int { 2457 return m.Size() 2458 } 2459 func (m *Version) XXX_DiscardUnknown() { 2460 xxx_messageInfo_Version.DiscardUnknown(m) 2461 } 2462 2463 var xxx_messageInfo_Version proto.InternalMessageInfo 2464 2465 func (m *Version) GetBlock() uint64 { 2466 if m != nil { 2467 return m.Block 2468 } 2469 return 0 2470 } 2471 2472 func (m *Version) GetApp() uint64 { 2473 if m != nil { 2474 return m.App 2475 } 2476 return 0 2477 } 2478 2479 type BlockID struct { 2480 Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` 2481 PartsHeader PartSetHeader `protobuf:"bytes,2,opt,name=parts_header,json=partsHeader,proto3" json:"parts_header"` 2482 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2483 XXX_unrecognized []byte `json:"-"` 2484 XXX_sizecache int32 `json:"-"` 2485 } 2486 2487 func (m *BlockID) Reset() { *m = BlockID{} } 2488 func (m *BlockID) String() string { return proto.CompactTextString(m) } 2489 func (*BlockID) ProtoMessage() {} 2490 func (*BlockID) Descriptor() ([]byte, []int) { 2491 return fileDescriptor_9f1eaa49c51fa1ac, []int{33} 2492 } 2493 func (m *BlockID) XXX_Unmarshal(b []byte) error { 2494 return m.Unmarshal(b) 2495 } 2496 func (m *BlockID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2497 if deterministic { 2498 return xxx_messageInfo_BlockID.Marshal(b, m, deterministic) 2499 } else { 2500 b = b[:cap(b)] 2501 n, err := m.MarshalToSizedBuffer(b) 2502 if err != nil { 2503 return nil, err 2504 } 2505 return b[:n], nil 2506 } 2507 } 2508 func (m *BlockID) XXX_Merge(src proto.Message) { 2509 xxx_messageInfo_BlockID.Merge(m, src) 2510 } 2511 func (m *BlockID) XXX_Size() int { 2512 return m.Size() 2513 } 2514 func (m *BlockID) XXX_DiscardUnknown() { 2515 xxx_messageInfo_BlockID.DiscardUnknown(m) 2516 } 2517 2518 var xxx_messageInfo_BlockID proto.InternalMessageInfo 2519 2520 func (m *BlockID) GetHash() []byte { 2521 if m != nil { 2522 return m.Hash 2523 } 2524 return nil 2525 } 2526 2527 func (m *BlockID) GetPartsHeader() PartSetHeader { 2528 if m != nil { 2529 return m.PartsHeader 2530 } 2531 return PartSetHeader{} 2532 } 2533 2534 type PartSetHeader struct { 2535 Total int32 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"` 2536 Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"` 2537 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2538 XXX_unrecognized []byte `json:"-"` 2539 XXX_sizecache int32 `json:"-"` 2540 } 2541 2542 func (m *PartSetHeader) Reset() { *m = PartSetHeader{} } 2543 func (m *PartSetHeader) String() string { return proto.CompactTextString(m) } 2544 func (*PartSetHeader) ProtoMessage() {} 2545 func (*PartSetHeader) Descriptor() ([]byte, []int) { 2546 return fileDescriptor_9f1eaa49c51fa1ac, []int{34} 2547 } 2548 func (m *PartSetHeader) XXX_Unmarshal(b []byte) error { 2549 return m.Unmarshal(b) 2550 } 2551 func (m *PartSetHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2552 if deterministic { 2553 return xxx_messageInfo_PartSetHeader.Marshal(b, m, deterministic) 2554 } else { 2555 b = b[:cap(b)] 2556 n, err := m.MarshalToSizedBuffer(b) 2557 if err != nil { 2558 return nil, err 2559 } 2560 return b[:n], nil 2561 } 2562 } 2563 func (m *PartSetHeader) XXX_Merge(src proto.Message) { 2564 xxx_messageInfo_PartSetHeader.Merge(m, src) 2565 } 2566 func (m *PartSetHeader) XXX_Size() int { 2567 return m.Size() 2568 } 2569 func (m *PartSetHeader) XXX_DiscardUnknown() { 2570 xxx_messageInfo_PartSetHeader.DiscardUnknown(m) 2571 } 2572 2573 var xxx_messageInfo_PartSetHeader proto.InternalMessageInfo 2574 2575 func (m *PartSetHeader) GetTotal() int32 { 2576 if m != nil { 2577 return m.Total 2578 } 2579 return 0 2580 } 2581 2582 func (m *PartSetHeader) GetHash() []byte { 2583 if m != nil { 2584 return m.Hash 2585 } 2586 return nil 2587 } 2588 2589 // Validator 2590 type Validator struct { 2591 Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` 2592 // PubKey pub_key = 2 [(gogoproto.nullable)=false]; 2593 Power int64 `protobuf:"varint,3,opt,name=power,proto3" json:"power,omitempty"` 2594 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2595 XXX_unrecognized []byte `json:"-"` 2596 XXX_sizecache int32 `json:"-"` 2597 } 2598 2599 func (m *Validator) Reset() { *m = Validator{} } 2600 func (m *Validator) String() string { return proto.CompactTextString(m) } 2601 func (*Validator) ProtoMessage() {} 2602 func (*Validator) Descriptor() ([]byte, []int) { 2603 return fileDescriptor_9f1eaa49c51fa1ac, []int{35} 2604 } 2605 func (m *Validator) XXX_Unmarshal(b []byte) error { 2606 return m.Unmarshal(b) 2607 } 2608 func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2609 if deterministic { 2610 return xxx_messageInfo_Validator.Marshal(b, m, deterministic) 2611 } else { 2612 b = b[:cap(b)] 2613 n, err := m.MarshalToSizedBuffer(b) 2614 if err != nil { 2615 return nil, err 2616 } 2617 return b[:n], nil 2618 } 2619 } 2620 func (m *Validator) XXX_Merge(src proto.Message) { 2621 xxx_messageInfo_Validator.Merge(m, src) 2622 } 2623 func (m *Validator) XXX_Size() int { 2624 return m.Size() 2625 } 2626 func (m *Validator) XXX_DiscardUnknown() { 2627 xxx_messageInfo_Validator.DiscardUnknown(m) 2628 } 2629 2630 var xxx_messageInfo_Validator proto.InternalMessageInfo 2631 2632 func (m *Validator) GetAddress() []byte { 2633 if m != nil { 2634 return m.Address 2635 } 2636 return nil 2637 } 2638 2639 func (m *Validator) GetPower() int64 { 2640 if m != nil { 2641 return m.Power 2642 } 2643 return 0 2644 } 2645 2646 // ValidatorUpdate 2647 type ValidatorUpdate struct { 2648 PubKey PubKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"` 2649 Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"` 2650 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2651 XXX_unrecognized []byte `json:"-"` 2652 XXX_sizecache int32 `json:"-"` 2653 } 2654 2655 func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} } 2656 func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) } 2657 func (*ValidatorUpdate) ProtoMessage() {} 2658 func (*ValidatorUpdate) Descriptor() ([]byte, []int) { 2659 return fileDescriptor_9f1eaa49c51fa1ac, []int{36} 2660 } 2661 func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error { 2662 return m.Unmarshal(b) 2663 } 2664 func (m *ValidatorUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2665 if deterministic { 2666 return xxx_messageInfo_ValidatorUpdate.Marshal(b, m, deterministic) 2667 } else { 2668 b = b[:cap(b)] 2669 n, err := m.MarshalToSizedBuffer(b) 2670 if err != nil { 2671 return nil, err 2672 } 2673 return b[:n], nil 2674 } 2675 } 2676 func (m *ValidatorUpdate) XXX_Merge(src proto.Message) { 2677 xxx_messageInfo_ValidatorUpdate.Merge(m, src) 2678 } 2679 func (m *ValidatorUpdate) XXX_Size() int { 2680 return m.Size() 2681 } 2682 func (m *ValidatorUpdate) XXX_DiscardUnknown() { 2683 xxx_messageInfo_ValidatorUpdate.DiscardUnknown(m) 2684 } 2685 2686 var xxx_messageInfo_ValidatorUpdate proto.InternalMessageInfo 2687 2688 func (m *ValidatorUpdate) GetPubKey() PubKey { 2689 if m != nil { 2690 return m.PubKey 2691 } 2692 return PubKey{} 2693 } 2694 2695 func (m *ValidatorUpdate) GetPower() int64 { 2696 if m != nil { 2697 return m.Power 2698 } 2699 return 0 2700 } 2701 2702 // VoteInfo 2703 type VoteInfo struct { 2704 Validator Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator"` 2705 SignedLastBlock bool `protobuf:"varint,2,opt,name=signed_last_block,json=signedLastBlock,proto3" json:"signed_last_block,omitempty"` 2706 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2707 XXX_unrecognized []byte `json:"-"` 2708 XXX_sizecache int32 `json:"-"` 2709 } 2710 2711 func (m *VoteInfo) Reset() { *m = VoteInfo{} } 2712 func (m *VoteInfo) String() string { return proto.CompactTextString(m) } 2713 func (*VoteInfo) ProtoMessage() {} 2714 func (*VoteInfo) Descriptor() ([]byte, []int) { 2715 return fileDescriptor_9f1eaa49c51fa1ac, []int{37} 2716 } 2717 func (m *VoteInfo) XXX_Unmarshal(b []byte) error { 2718 return m.Unmarshal(b) 2719 } 2720 func (m *VoteInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2721 if deterministic { 2722 return xxx_messageInfo_VoteInfo.Marshal(b, m, deterministic) 2723 } else { 2724 b = b[:cap(b)] 2725 n, err := m.MarshalToSizedBuffer(b) 2726 if err != nil { 2727 return nil, err 2728 } 2729 return b[:n], nil 2730 } 2731 } 2732 func (m *VoteInfo) XXX_Merge(src proto.Message) { 2733 xxx_messageInfo_VoteInfo.Merge(m, src) 2734 } 2735 func (m *VoteInfo) XXX_Size() int { 2736 return m.Size() 2737 } 2738 func (m *VoteInfo) XXX_DiscardUnknown() { 2739 xxx_messageInfo_VoteInfo.DiscardUnknown(m) 2740 } 2741 2742 var xxx_messageInfo_VoteInfo proto.InternalMessageInfo 2743 2744 func (m *VoteInfo) GetValidator() Validator { 2745 if m != nil { 2746 return m.Validator 2747 } 2748 return Validator{} 2749 } 2750 2751 func (m *VoteInfo) GetSignedLastBlock() bool { 2752 if m != nil { 2753 return m.SignedLastBlock 2754 } 2755 return false 2756 } 2757 2758 type PubKey struct { 2759 Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` 2760 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 2761 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2762 XXX_unrecognized []byte `json:"-"` 2763 XXX_sizecache int32 `json:"-"` 2764 } 2765 2766 func (m *PubKey) Reset() { *m = PubKey{} } 2767 func (m *PubKey) String() string { return proto.CompactTextString(m) } 2768 func (*PubKey) ProtoMessage() {} 2769 func (*PubKey) Descriptor() ([]byte, []int) { 2770 return fileDescriptor_9f1eaa49c51fa1ac, []int{38} 2771 } 2772 func (m *PubKey) XXX_Unmarshal(b []byte) error { 2773 return m.Unmarshal(b) 2774 } 2775 func (m *PubKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2776 if deterministic { 2777 return xxx_messageInfo_PubKey.Marshal(b, m, deterministic) 2778 } else { 2779 b = b[:cap(b)] 2780 n, err := m.MarshalToSizedBuffer(b) 2781 if err != nil { 2782 return nil, err 2783 } 2784 return b[:n], nil 2785 } 2786 } 2787 func (m *PubKey) XXX_Merge(src proto.Message) { 2788 xxx_messageInfo_PubKey.Merge(m, src) 2789 } 2790 func (m *PubKey) XXX_Size() int { 2791 return m.Size() 2792 } 2793 func (m *PubKey) XXX_DiscardUnknown() { 2794 xxx_messageInfo_PubKey.DiscardUnknown(m) 2795 } 2796 2797 var xxx_messageInfo_PubKey proto.InternalMessageInfo 2798 2799 func (m *PubKey) GetType() string { 2800 if m != nil { 2801 return m.Type 2802 } 2803 return "" 2804 } 2805 2806 func (m *PubKey) GetData() []byte { 2807 if m != nil { 2808 return m.Data 2809 } 2810 return nil 2811 } 2812 2813 type Evidence struct { 2814 Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` 2815 Validator Validator `protobuf:"bytes,2,opt,name=validator,proto3" json:"validator"` 2816 Height int64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` 2817 Time time.Time `protobuf:"bytes,4,opt,name=time,proto3,stdtime" json:"time"` 2818 TotalVotingPower int64 `protobuf:"varint,5,opt,name=total_voting_power,json=totalVotingPower,proto3" json:"total_voting_power,omitempty"` 2819 XXX_NoUnkeyedLiteral struct{} `json:"-"` 2820 XXX_unrecognized []byte `json:"-"` 2821 XXX_sizecache int32 `json:"-"` 2822 } 2823 2824 func (m *Evidence) Reset() { *m = Evidence{} } 2825 func (m *Evidence) String() string { return proto.CompactTextString(m) } 2826 func (*Evidence) ProtoMessage() {} 2827 func (*Evidence) Descriptor() ([]byte, []int) { 2828 return fileDescriptor_9f1eaa49c51fa1ac, []int{39} 2829 } 2830 func (m *Evidence) XXX_Unmarshal(b []byte) error { 2831 return m.Unmarshal(b) 2832 } 2833 func (m *Evidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2834 if deterministic { 2835 return xxx_messageInfo_Evidence.Marshal(b, m, deterministic) 2836 } else { 2837 b = b[:cap(b)] 2838 n, err := m.MarshalToSizedBuffer(b) 2839 if err != nil { 2840 return nil, err 2841 } 2842 return b[:n], nil 2843 } 2844 } 2845 func (m *Evidence) XXX_Merge(src proto.Message) { 2846 xxx_messageInfo_Evidence.Merge(m, src) 2847 } 2848 func (m *Evidence) XXX_Size() int { 2849 return m.Size() 2850 } 2851 func (m *Evidence) XXX_DiscardUnknown() { 2852 xxx_messageInfo_Evidence.DiscardUnknown(m) 2853 } 2854 2855 var xxx_messageInfo_Evidence proto.InternalMessageInfo 2856 2857 func (m *Evidence) GetType() string { 2858 if m != nil { 2859 return m.Type 2860 } 2861 return "" 2862 } 2863 2864 func (m *Evidence) GetValidator() Validator { 2865 if m != nil { 2866 return m.Validator 2867 } 2868 return Validator{} 2869 } 2870 2871 func (m *Evidence) GetHeight() int64 { 2872 if m != nil { 2873 return m.Height 2874 } 2875 return 0 2876 } 2877 2878 func (m *Evidence) GetTime() time.Time { 2879 if m != nil { 2880 return m.Time 2881 } 2882 return time.Time{} 2883 } 2884 2885 func (m *Evidence) GetTotalVotingPower() int64 { 2886 if m != nil { 2887 return m.TotalVotingPower 2888 } 2889 return 0 2890 } 2891 2892 func init() { 2893 proto.RegisterEnum("tendermint.abci.types.CheckTxType", CheckTxType_name, CheckTxType_value) 2894 golang_proto.RegisterEnum("tendermint.abci.types.CheckTxType", CheckTxType_name, CheckTxType_value) 2895 proto.RegisterType((*Request)(nil), "tendermint.abci.types.Request") 2896 golang_proto.RegisterType((*Request)(nil), "tendermint.abci.types.Request") 2897 proto.RegisterType((*RequestEcho)(nil), "tendermint.abci.types.RequestEcho") 2898 golang_proto.RegisterType((*RequestEcho)(nil), "tendermint.abci.types.RequestEcho") 2899 proto.RegisterType((*RequestFlush)(nil), "tendermint.abci.types.RequestFlush") 2900 golang_proto.RegisterType((*RequestFlush)(nil), "tendermint.abci.types.RequestFlush") 2901 proto.RegisterType((*RequestInfo)(nil), "tendermint.abci.types.RequestInfo") 2902 golang_proto.RegisterType((*RequestInfo)(nil), "tendermint.abci.types.RequestInfo") 2903 proto.RegisterType((*RequestSetOption)(nil), "tendermint.abci.types.RequestSetOption") 2904 golang_proto.RegisterType((*RequestSetOption)(nil), "tendermint.abci.types.RequestSetOption") 2905 proto.RegisterType((*RequestInitChain)(nil), "tendermint.abci.types.RequestInitChain") 2906 golang_proto.RegisterType((*RequestInitChain)(nil), "tendermint.abci.types.RequestInitChain") 2907 proto.RegisterType((*RequestQuery)(nil), "tendermint.abci.types.RequestQuery") 2908 golang_proto.RegisterType((*RequestQuery)(nil), "tendermint.abci.types.RequestQuery") 2909 proto.RegisterType((*RequestBeginBlock)(nil), "tendermint.abci.types.RequestBeginBlock") 2910 golang_proto.RegisterType((*RequestBeginBlock)(nil), "tendermint.abci.types.RequestBeginBlock") 2911 proto.RegisterType((*RequestCheckTx)(nil), "tendermint.abci.types.RequestCheckTx") 2912 golang_proto.RegisterType((*RequestCheckTx)(nil), "tendermint.abci.types.RequestCheckTx") 2913 proto.RegisterType((*RequestDeliverTx)(nil), "tendermint.abci.types.RequestDeliverTx") 2914 golang_proto.RegisterType((*RequestDeliverTx)(nil), "tendermint.abci.types.RequestDeliverTx") 2915 proto.RegisterType((*RequestEndBlock)(nil), "tendermint.abci.types.RequestEndBlock") 2916 golang_proto.RegisterType((*RequestEndBlock)(nil), "tendermint.abci.types.RequestEndBlock") 2917 proto.RegisterType((*RequestCommit)(nil), "tendermint.abci.types.RequestCommit") 2918 golang_proto.RegisterType((*RequestCommit)(nil), "tendermint.abci.types.RequestCommit") 2919 proto.RegisterType((*Response)(nil), "tendermint.abci.types.Response") 2920 golang_proto.RegisterType((*Response)(nil), "tendermint.abci.types.Response") 2921 proto.RegisterType((*ResponseException)(nil), "tendermint.abci.types.ResponseException") 2922 golang_proto.RegisterType((*ResponseException)(nil), "tendermint.abci.types.ResponseException") 2923 proto.RegisterType((*ResponseEcho)(nil), "tendermint.abci.types.ResponseEcho") 2924 golang_proto.RegisterType((*ResponseEcho)(nil), "tendermint.abci.types.ResponseEcho") 2925 proto.RegisterType((*ResponseFlush)(nil), "tendermint.abci.types.ResponseFlush") 2926 golang_proto.RegisterType((*ResponseFlush)(nil), "tendermint.abci.types.ResponseFlush") 2927 proto.RegisterType((*ResponseInfo)(nil), "tendermint.abci.types.ResponseInfo") 2928 golang_proto.RegisterType((*ResponseInfo)(nil), "tendermint.abci.types.ResponseInfo") 2929 proto.RegisterType((*ResponseSetOption)(nil), "tendermint.abci.types.ResponseSetOption") 2930 golang_proto.RegisterType((*ResponseSetOption)(nil), "tendermint.abci.types.ResponseSetOption") 2931 proto.RegisterType((*ResponseInitChain)(nil), "tendermint.abci.types.ResponseInitChain") 2932 golang_proto.RegisterType((*ResponseInitChain)(nil), "tendermint.abci.types.ResponseInitChain") 2933 proto.RegisterType((*ResponseQuery)(nil), "tendermint.abci.types.ResponseQuery") 2934 golang_proto.RegisterType((*ResponseQuery)(nil), "tendermint.abci.types.ResponseQuery") 2935 proto.RegisterType((*ResponseBeginBlock)(nil), "tendermint.abci.types.ResponseBeginBlock") 2936 golang_proto.RegisterType((*ResponseBeginBlock)(nil), "tendermint.abci.types.ResponseBeginBlock") 2937 proto.RegisterType((*ResponseCheckTx)(nil), "tendermint.abci.types.ResponseCheckTx") 2938 golang_proto.RegisterType((*ResponseCheckTx)(nil), "tendermint.abci.types.ResponseCheckTx") 2939 proto.RegisterType((*ResponseDeliverTx)(nil), "tendermint.abci.types.ResponseDeliverTx") 2940 golang_proto.RegisterType((*ResponseDeliverTx)(nil), "tendermint.abci.types.ResponseDeliverTx") 2941 proto.RegisterType((*ResponseEndBlock)(nil), "tendermint.abci.types.ResponseEndBlock") 2942 golang_proto.RegisterType((*ResponseEndBlock)(nil), "tendermint.abci.types.ResponseEndBlock") 2943 proto.RegisterType((*ResponseCommit)(nil), "tendermint.abci.types.ResponseCommit") 2944 golang_proto.RegisterType((*ResponseCommit)(nil), "tendermint.abci.types.ResponseCommit") 2945 proto.RegisterType((*ConsensusParams)(nil), "tendermint.abci.types.ConsensusParams") 2946 golang_proto.RegisterType((*ConsensusParams)(nil), "tendermint.abci.types.ConsensusParams") 2947 proto.RegisterType((*BlockParams)(nil), "tendermint.abci.types.BlockParams") 2948 golang_proto.RegisterType((*BlockParams)(nil), "tendermint.abci.types.BlockParams") 2949 proto.RegisterType((*EvidenceParams)(nil), "tendermint.abci.types.EvidenceParams") 2950 golang_proto.RegisterType((*EvidenceParams)(nil), "tendermint.abci.types.EvidenceParams") 2951 proto.RegisterType((*ValidatorParams)(nil), "tendermint.abci.types.ValidatorParams") 2952 golang_proto.RegisterType((*ValidatorParams)(nil), "tendermint.abci.types.ValidatorParams") 2953 proto.RegisterType((*LastCommitInfo)(nil), "tendermint.abci.types.LastCommitInfo") 2954 golang_proto.RegisterType((*LastCommitInfo)(nil), "tendermint.abci.types.LastCommitInfo") 2955 proto.RegisterType((*Event)(nil), "tendermint.abci.types.Event") 2956 golang_proto.RegisterType((*Event)(nil), "tendermint.abci.types.Event") 2957 proto.RegisterType((*Header)(nil), "tendermint.abci.types.Header") 2958 golang_proto.RegisterType((*Header)(nil), "tendermint.abci.types.Header") 2959 proto.RegisterType((*Version)(nil), "tendermint.abci.types.Version") 2960 golang_proto.RegisterType((*Version)(nil), "tendermint.abci.types.Version") 2961 proto.RegisterType((*BlockID)(nil), "tendermint.abci.types.BlockID") 2962 golang_proto.RegisterType((*BlockID)(nil), "tendermint.abci.types.BlockID") 2963 proto.RegisterType((*PartSetHeader)(nil), "tendermint.abci.types.PartSetHeader") 2964 golang_proto.RegisterType((*PartSetHeader)(nil), "tendermint.abci.types.PartSetHeader") 2965 proto.RegisterType((*Validator)(nil), "tendermint.abci.types.Validator") 2966 golang_proto.RegisterType((*Validator)(nil), "tendermint.abci.types.Validator") 2967 proto.RegisterType((*ValidatorUpdate)(nil), "tendermint.abci.types.ValidatorUpdate") 2968 golang_proto.RegisterType((*ValidatorUpdate)(nil), "tendermint.abci.types.ValidatorUpdate") 2969 proto.RegisterType((*VoteInfo)(nil), "tendermint.abci.types.VoteInfo") 2970 golang_proto.RegisterType((*VoteInfo)(nil), "tendermint.abci.types.VoteInfo") 2971 proto.RegisterType((*PubKey)(nil), "tendermint.abci.types.PubKey") 2972 golang_proto.RegisterType((*PubKey)(nil), "tendermint.abci.types.PubKey") 2973 proto.RegisterType((*Evidence)(nil), "tendermint.abci.types.Evidence") 2974 golang_proto.RegisterType((*Evidence)(nil), "tendermint.abci.types.Evidence") 2975 } 2976 2977 func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) } 2978 func init() { golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) } 2979 2980 var fileDescriptor_9f1eaa49c51fa1ac = []byte{ 2981 // 2356 bytes of a gzipped FileDescriptorProto 2982 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x4d, 0x90, 0x1b, 0x47, 2983 0xf5, 0xdf, 0xd1, 0xb7, 0x9e, 0x76, 0x57, 0x4a, 0xdb, 0x49, 0x14, 0xfd, 0x9d, 0x5d, 0xd7, 0x6c, 2984 0x6c, 0xaf, 0xf3, 0x0f, 0xda, 0xb0, 0x54, 0xa8, 0x18, 0xbb, 0x42, 0xad, 0xd6, 0x0e, 0x52, 0xc5, 2985 0x49, 0x36, 0x63, 0x7b, 0x31, 0x50, 0x15, 0x55, 0x4b, 0xd3, 0x96, 0xa6, 0x56, 0x9a, 0x99, 0xcc, 2986 0xb4, 0x64, 0x89, 0xe2, 0x4e, 0x71, 0xe3, 0xc2, 0x91, 0x0b, 0x27, 0x8e, 0x1c, 0x38, 0xe4, 0xc8, 2987 0x31, 0x07, 0x0e, 0x1c, 0x38, 0x1b, 0x58, 0x38, 0x51, 0x1c, 0x29, 0x8a, 0x23, 0xd5, 0xaf, 0x7b, 2988 0xbe, 0x64, 0x69, 0x35, 0x0e, 0xbe, 0x71, 0x91, 0xa6, 0xbb, 0xdf, 0x7b, 0xdd, 0xfd, 0xfa, 0xf5, 2989 0xfb, 0xbd, 0xf7, 0x1a, 0x5e, 0xa3, 0xbd, 0xbe, 0x75, 0xc0, 0xe7, 0x2e, 0xf3, 0xe5, 0x6f, 0xd3, 2990 0xf5, 0x1c, 0xee, 0x90, 0x57, 0x39, 0xb3, 0x4d, 0xe6, 0x8d, 0x2d, 0x9b, 0x37, 0x05, 0x49, 0x13, 2991 0x07, 0x1b, 0xd7, 0xf9, 0xd0, 0xf2, 0xcc, 0xae, 0x4b, 0x3d, 0x3e, 0x3f, 0x40, 0xca, 0x83, 0x81, 2992 0x33, 0x70, 0xa2, 0x2f, 0xc9, 0xde, 0x68, 0xf4, 0xbd, 0xb9, 0xcb, 0x9d, 0x83, 0x31, 0xf3, 0xce, 2993 0x46, 0x4c, 0xfd, 0xa9, 0xb1, 0x4b, 0x23, 0xab, 0xe7, 0x1f, 0x9c, 0x4d, 0xe3, 0xf3, 0x35, 0x76, 2994 0x07, 0x8e, 0x33, 0x18, 0x31, 0x29, 0xb3, 0x37, 0x79, 0x72, 0xc0, 0xad, 0x31, 0xf3, 0x39, 0x1d, 2995 0xbb, 0x92, 0x40, 0xff, 0x57, 0x1e, 0x8a, 0x06, 0xfb, 0x62, 0xc2, 0x7c, 0x4e, 0xde, 0x87, 0x1c, 2996 0xeb, 0x0f, 0x9d, 0x7a, 0xe6, 0xaa, 0xb6, 0x5f, 0x39, 0xd4, 0x9b, 0x4b, 0xd7, 0xda, 0x54, 0xd4, 2997 0xf7, 0xfa, 0x43, 0xa7, 0xbd, 0x61, 0x20, 0x07, 0xb9, 0x0d, 0xf9, 0x27, 0xa3, 0x89, 0x3f, 0xac, 2998 0x67, 0x91, 0x75, 0xef, 0x62, 0xd6, 0x0f, 0x05, 0x69, 0x7b, 0xc3, 0x90, 0x3c, 0x62, 0x5a, 0xcb, 2999 0x7e, 0xe2, 0xd4, 0x73, 0x69, 0xa6, 0xed, 0xd8, 0x4f, 0x70, 0x5a, 0xc1, 0x41, 0xda, 0x00, 0x3e, 3000 0xe3, 0x5d, 0xc7, 0xe5, 0x96, 0x63, 0xd7, 0xf3, 0xc8, 0x7f, 0xe3, 0x62, 0xfe, 0x07, 0x8c, 0x7f, 3001 0x8a, 0xe4, 0xed, 0x0d, 0xa3, 0xec, 0x07, 0x0d, 0x21, 0xc9, 0xb2, 0x2d, 0xde, 0xed, 0x0f, 0xa9, 3002 0x65, 0xd7, 0x0b, 0x69, 0x24, 0x75, 0x6c, 0x8b, 0x1f, 0x0b, 0x72, 0x21, 0xc9, 0x0a, 0x1a, 0x42, 3003 0x15, 0x5f, 0x4c, 0x98, 0x37, 0xaf, 0x17, 0xd3, 0xa8, 0xe2, 0x33, 0x41, 0x2a, 0x54, 0x81, 0x3c, 3004 0xe4, 0x23, 0xa8, 0xf4, 0xd8, 0xc0, 0xb2, 0xbb, 0xbd, 0x91, 0xd3, 0x3f, 0xab, 0x97, 0x50, 0xc4, 3005 0xfe, 0xc5, 0x22, 0x5a, 0x82, 0xa1, 0x25, 0xe8, 0xdb, 0x1b, 0x06, 0xf4, 0xc2, 0x16, 0x69, 0x41, 3006 0xa9, 0x3f, 0x64, 0xfd, 0xb3, 0x2e, 0x9f, 0xd5, 0xcb, 0x28, 0xe9, 0xda, 0xc5, 0x92, 0x8e, 0x05, 3007 0xf5, 0xc3, 0x59, 0x7b, 0xc3, 0x28, 0xf6, 0xe5, 0xa7, 0xd0, 0x8b, 0xc9, 0x46, 0xd6, 0x94, 0x79, 3008 0x42, 0xca, 0xa5, 0x34, 0x7a, 0xb9, 0x2b, 0xe9, 0x51, 0x4e, 0xd9, 0x0c, 0x1a, 0xe4, 0x1e, 0x94, 3009 0x99, 0x6d, 0xaa, 0x8d, 0x55, 0x50, 0xd0, 0xf5, 0x35, 0x16, 0x66, 0x9b, 0xc1, 0xb6, 0x4a, 0x4c, 3010 0x7d, 0x93, 0x0f, 0xa0, 0xd0, 0x77, 0xc6, 0x63, 0x8b, 0xd7, 0x37, 0x51, 0xc6, 0x5b, 0x6b, 0xb6, 3011 0x84, 0xb4, 0xed, 0x0d, 0x43, 0x71, 0xb5, 0x8a, 0x90, 0x9f, 0xd2, 0xd1, 0x84, 0xe9, 0x37, 0xa0, 3012 0x12, 0xb3, 0x64, 0x52, 0x87, 0xe2, 0x98, 0xf9, 0x3e, 0x1d, 0xb0, 0xba, 0x76, 0x55, 0xdb, 0x2f, 3013 0x1b, 0x41, 0x53, 0xdf, 0x86, 0xcd, 0xb8, 0xdd, 0xea, 0xe3, 0x90, 0x51, 0xd8, 0xa2, 0x60, 0x9c, 3014 0x32, 0xcf, 0x17, 0x06, 0xa8, 0x18, 0x55, 0x93, 0xec, 0xc1, 0x16, 0xee, 0xb6, 0x1b, 0x8c, 0x8b, 3015 0x7b, 0x95, 0x33, 0x36, 0xb1, 0xf3, 0x54, 0x11, 0xed, 0x42, 0xc5, 0x3d, 0x74, 0x43, 0x92, 0x2c, 3016 0x92, 0x80, 0x7b, 0xe8, 0x2a, 0x02, 0xfd, 0x3b, 0x50, 0x5b, 0x34, 0x5d, 0x52, 0x83, 0xec, 0x19, 3017 0x9b, 0xab, 0xf9, 0xc4, 0x27, 0xb9, 0xac, 0xb6, 0x85, 0x73, 0x94, 0x0d, 0xb5, 0xc7, 0xdf, 0x64, 3018 0x42, 0xe6, 0xd0, 0x5a, 0xc5, 0x75, 0x13, 0x4e, 0x00, 0xb9, 0x2b, 0x87, 0x8d, 0xa6, 0xf4, 0x10, 3019 0xcd, 0xc0, 0x43, 0x34, 0x1f, 0x06, 0x1e, 0xa2, 0x55, 0xfa, 0xea, 0xd9, 0xee, 0xc6, 0xcf, 0xff, 3020 0xb4, 0xab, 0x19, 0xc8, 0x41, 0xde, 0x10, 0x06, 0x45, 0x2d, 0xbb, 0x6b, 0x99, 0x6a, 0x9e, 0x22, 3021 0xb6, 0x3b, 0x26, 0xf9, 0x0c, 0x6a, 0x7d, 0xc7, 0xf6, 0x99, 0xed, 0x4f, 0x7c, 0xe1, 0xc6, 0xe8, 3022 0xd8, 0x57, 0xbe, 0x60, 0xd5, 0x21, 0x1f, 0x07, 0xe4, 0x27, 0x48, 0x6d, 0x54, 0xfb, 0xc9, 0x0e, 3023 0x72, 0x1f, 0x60, 0x4a, 0x47, 0x96, 0x49, 0xb9, 0xe3, 0xf9, 0xf5, 0xdc, 0xd5, 0xec, 0x05, 0xc2, 3024 0x4e, 0x03, 0xc2, 0x47, 0xae, 0x49, 0x39, 0x6b, 0xe5, 0xc4, 0xca, 0x8d, 0x18, 0x3f, 0xb9, 0x0e, 3025 0x55, 0xea, 0xba, 0x5d, 0x9f, 0x53, 0xce, 0xba, 0xbd, 0x39, 0x67, 0x3e, 0xfa, 0x8b, 0x4d, 0x63, 3026 0x8b, 0xba, 0xee, 0x03, 0xd1, 0xdb, 0x12, 0x9d, 0xba, 0x19, 0x9e, 0x36, 0x5e, 0x4d, 0x42, 0x20, 3027 0x67, 0x52, 0x4e, 0x51, 0x5b, 0x9b, 0x06, 0x7e, 0x8b, 0x3e, 0x97, 0xf2, 0xa1, 0xd2, 0x01, 0x7e, 3028 0x93, 0xd7, 0xa0, 0x30, 0x64, 0xd6, 0x60, 0xc8, 0x71, 0xdb, 0x59, 0x43, 0xb5, 0xc4, 0xc1, 0xb8, 3029 0x9e, 0x33, 0x65, 0xe8, 0xdd, 0x4a, 0x86, 0x6c, 0xe8, 0xbf, 0xc8, 0xc0, 0x2b, 0xcf, 0x5d, 0x5f, 3030 0x21, 0x77, 0x48, 0xfd, 0x61, 0x30, 0x97, 0xf8, 0x26, 0xb7, 0x85, 0x5c, 0x6a, 0x32, 0x4f, 0x79, 3031 0xe5, 0x37, 0x57, 0x68, 0xa0, 0x8d, 0x44, 0x6a, 0xe3, 0x8a, 0x85, 0x3c, 0x82, 0xda, 0x88, 0xfa, 3032 0xbc, 0x2b, 0x6d, 0xbf, 0x8b, 0x5e, 0x36, 0x7b, 0xa1, 0x27, 0xb8, 0x4f, 0x83, 0x3b, 0x23, 0x8c, 3033 0x5b, 0x89, 0xdb, 0x1e, 0x25, 0x7a, 0xc9, 0x63, 0xb8, 0xdc, 0x9b, 0xff, 0x98, 0xda, 0xdc, 0xb2, 3034 0x59, 0xf7, 0xb9, 0x33, 0xda, 0x5d, 0x21, 0xfa, 0xde, 0xd4, 0x32, 0x99, 0xdd, 0x0f, 0x0e, 0xe7, 3035 0x52, 0x28, 0x22, 0x3c, 0x3c, 0x5f, 0x7f, 0x0c, 0xdb, 0x49, 0x5f, 0x44, 0xb6, 0x21, 0xc3, 0x67, 3036 0x4a, 0x23, 0x19, 0x3e, 0x23, 0xdf, 0x86, 0x9c, 0x10, 0x87, 0xda, 0xd8, 0x5e, 0x09, 0x16, 0x8a, 3037 0xfb, 0xe1, 0xdc, 0x65, 0x06, 0xd2, 0xeb, 0x7a, 0x78, 0x13, 0x42, 0xff, 0xb4, 0x28, 0x5b, 0xbf, 3038 0x09, 0xd5, 0x05, 0xd7, 0x13, 0x3b, 0x56, 0x2d, 0x7e, 0xac, 0x7a, 0x15, 0xb6, 0x12, 0x1e, 0x46, 3039 0xff, 0x7d, 0x01, 0x4a, 0x06, 0xf3, 0x5d, 0x61, 0xc4, 0xa4, 0x0d, 0x65, 0x36, 0xeb, 0x33, 0x09, 3040 0x4b, 0xda, 0x1a, 0x27, 0x2e, 0x79, 0xee, 0x05, 0xf4, 0xc2, 0x6b, 0x86, 0xcc, 0xe4, 0x56, 0x02, 3041 0x92, 0xf7, 0xd6, 0x09, 0x89, 0x63, 0xf2, 0x9d, 0x24, 0x26, 0xbf, 0xb5, 0x86, 0x77, 0x01, 0x94, 3042 0x6f, 0x25, 0x40, 0x79, 0xdd, 0xc4, 0x09, 0x54, 0xee, 0x2c, 0x41, 0xe5, 0x75, 0xdb, 0x5f, 0x01, 3043 0xcb, 0x9d, 0x25, 0xb0, 0xbc, 0xbf, 0x76, 0x2d, 0x4b, 0x71, 0xf9, 0x4e, 0x12, 0x97, 0xd7, 0xa9, 3044 0x63, 0x01, 0x98, 0xef, 0x2f, 0x03, 0xe6, 0x9b, 0x6b, 0x64, 0xac, 0x44, 0xe6, 0xe3, 0xe7, 0x90, 3045 0xf9, 0xfa, 0x1a, 0x51, 0x4b, 0xa0, 0xb9, 0x93, 0x80, 0x66, 0x48, 0xa5, 0x9b, 0x15, 0xd8, 0xfc, 3046 0xe1, 0xf3, 0xd8, 0x7c, 0x63, 0x9d, 0xa9, 0x2d, 0x03, 0xe7, 0xef, 0x2e, 0x80, 0xf3, 0xb5, 0x75, 3047 0xbb, 0x5a, 0x89, 0xce, 0x37, 0x85, 0x7f, 0x5c, 0xb8, 0x19, 0xc2, 0x97, 0x32, 0xcf, 0x73, 0x3c, 3048 0x05, 0x7c, 0xb2, 0xa1, 0xef, 0x0b, 0x8f, 0x1d, 0xd9, 0xff, 0x05, 0x48, 0x8e, 0x97, 0x36, 0x66, 3049 0xed, 0xfa, 0x97, 0x5a, 0xc4, 0x8b, 0x9e, 0x2d, 0xee, 0xed, 0xcb, 0xca, 0xdb, 0xc7, 0x00, 0x3e, 3050 0x93, 0x04, 0xf8, 0x5d, 0xa8, 0x08, 0x4c, 0x59, 0xc0, 0x6e, 0xea, 0x06, 0xd8, 0x4d, 0xde, 0x86, 3051 0x57, 0xd0, 0xff, 0xca, 0x30, 0x40, 0x39, 0x92, 0x1c, 0x3a, 0x92, 0xaa, 0x18, 0x90, 0x1a, 0x94, 3052 0x40, 0xf1, 0x0d, 0xb8, 0x14, 0xa3, 0x15, 0x72, 0x11, 0x0b, 0x24, 0x48, 0xd5, 0x42, 0xea, 0x23, 3053 0xd7, 0x6d, 0x53, 0x7f, 0xa8, 0x7f, 0x1c, 0x29, 0x28, 0x8a, 0x0b, 0x08, 0xe4, 0xfa, 0x8e, 0x29, 3054 0xf7, 0xbd, 0x65, 0xe0, 0xb7, 0x88, 0x15, 0x46, 0xce, 0x00, 0x17, 0x57, 0x36, 0xc4, 0xa7, 0xa0, 3055 0x0a, 0xaf, 0x76, 0x59, 0xde, 0x59, 0xfd, 0xb7, 0x5a, 0x24, 0x2f, 0x0a, 0x15, 0x96, 0xa1, 0xba, 3056 0xf6, 0x32, 0x51, 0x3d, 0xf3, 0xdf, 0xa1, 0xba, 0xfe, 0x4f, 0x2d, 0x3a, 0xd2, 0x10, 0xaf, 0xbf, 3057 0x9e, 0x0a, 0x84, 0x75, 0x59, 0xb6, 0xc9, 0x66, 0xa8, 0xf2, 0xac, 0x21, 0x1b, 0x41, 0xa8, 0x55, 3058 0xc0, 0x63, 0x48, 0x86, 0x5a, 0x45, 0xec, 0x93, 0x0d, 0xf2, 0x1e, 0xe2, 0xbc, 0xf3, 0x44, 0xb9, 3059 0x86, 0x04, 0x08, 0xca, 0xa4, 0xad, 0xa9, 0xb2, 0xb5, 0x13, 0x41, 0x66, 0x48, 0xea, 0x18, 0xbe, 3060 0x94, 0x13, 0x61, 0xc3, 0x15, 0x28, 0x8b, 0xa5, 0xfb, 0x2e, 0xed, 0x33, 0xbc, 0xdb, 0x65, 0x23, 3061 0xea, 0xd0, 0x4d, 0x20, 0xcf, 0xfb, 0x18, 0xf2, 0x09, 0x14, 0xd8, 0x94, 0xd9, 0x5c, 0x9c, 0x91, 3062 0x50, 0xeb, 0x95, 0x95, 0x40, 0xcc, 0x6c, 0xde, 0xaa, 0x0b, 0x65, 0xfe, 0xfd, 0xd9, 0x6e, 0x4d, 3063 0xf2, 0xbc, 0xe3, 0x8c, 0x2d, 0xce, 0xc6, 0x2e, 0x9f, 0x1b, 0x4a, 0x8a, 0xfe, 0xd3, 0x8c, 0xc0, 3064 0xc3, 0x84, 0xff, 0x59, 0xaa, 0xde, 0xe0, 0xd2, 0x64, 0x62, 0x21, 0x52, 0x3a, 0x95, 0xbf, 0x09, 3065 0x30, 0xa0, 0x7e, 0xf7, 0x29, 0xb5, 0x39, 0x33, 0x95, 0xde, 0xcb, 0x03, 0xea, 0x7f, 0x1f, 0x3b, 3066 0x44, 0xbc, 0x29, 0x86, 0x27, 0x3e, 0x33, 0xf1, 0x00, 0xb2, 0x46, 0x71, 0x40, 0xfd, 0x47, 0x3e, 3067 0x33, 0x63, 0x7b, 0x2d, 0xbe, 0x8c, 0xbd, 0x26, 0xf5, 0x5d, 0x5a, 0xd4, 0xf7, 0xcf, 0x32, 0xd1, 3068 0xed, 0x88, 0xc2, 0x87, 0xff, 0x4d, 0x5d, 0xfc, 0x12, 0x73, 0x8a, 0x24, 0x08, 0x90, 0x1f, 0xc0, 3069 0x2b, 0xe1, 0xad, 0xec, 0x4e, 0xf0, 0xb6, 0x06, 0x56, 0xf8, 0x62, 0x97, 0xbb, 0x36, 0x4d, 0x76, 3070 0xfb, 0xe4, 0x73, 0x78, 0x7d, 0xc1, 0x07, 0x85, 0x13, 0x64, 0x5e, 0xc8, 0x15, 0xbd, 0x9a, 0x74, 3071 0x45, 0x81, 0xfc, 0x48, 0x7b, 0xd9, 0x97, 0x72, 0x6b, 0x3a, 0x22, 0x84, 0x8d, 0xc3, 0xdb, 0x52, 3072 0x9b, 0xd8, 0x83, 0x2d, 0x8f, 0x71, 0x91, 0x4b, 0x25, 0xb2, 0x86, 0x4d, 0xd9, 0x29, 0x21, 0x41, 3073 0xff, 0xa3, 0x06, 0xd5, 0x85, 0x5d, 0x90, 0xf7, 0x21, 0x2f, 0x61, 0x5a, 0xbb, 0xb0, 0x5a, 0x82, 3074 0xc7, 0xa2, 0x36, 0x2e, 0x19, 0xc8, 0x11, 0x94, 0x98, 0x0a, 0xc1, 0x95, 0xe6, 0xae, 0xad, 0x89, 3075 0xd4, 0x15, 0x7f, 0xc8, 0x46, 0xee, 0x42, 0x39, 0x3c, 0x9f, 0x35, 0xe9, 0x5d, 0x78, 0xbc, 0x4a, 3076 0x48, 0xc4, 0xa8, 0x1f, 0x43, 0x25, 0xb6, 0x3c, 0xf2, 0x7f, 0x50, 0x1e, 0xd3, 0x99, 0xca, 0xc9, 3077 0x64, 0x94, 0x5d, 0x1a, 0xd3, 0x19, 0xa6, 0x63, 0xe4, 0x75, 0x28, 0x8a, 0xc1, 0x01, 0x95, 0xa7, 3078 0x9d, 0x35, 0x0a, 0x63, 0x3a, 0xfb, 0x1e, 0xf5, 0xf5, 0x9b, 0xb0, 0x9d, 0x5c, 0x66, 0x40, 0x1a, 3079 0xe0, 0xbe, 0x24, 0x3d, 0x1a, 0x30, 0xfd, 0x3d, 0xa8, 0x2e, 0xac, 0x86, 0xe8, 0xb0, 0xe5, 0x4e, 3080 0x7a, 0xdd, 0x33, 0x36, 0xef, 0xe2, 0x72, 0xd1, 0x56, 0xcb, 0x46, 0xc5, 0x9d, 0xf4, 0x3e, 0x62, 3081 0x73, 0x91, 0x36, 0xf8, 0x7a, 0x1f, 0xb6, 0x93, 0xd9, 0x90, 0xf0, 0xfc, 0x9e, 0x33, 0xb1, 0x4d, 3082 0x94, 0x9f, 0x37, 0x64, 0x83, 0xdc, 0x86, 0xfc, 0xd4, 0x91, 0xe6, 0x78, 0x51, 0xfa, 0x73, 0xea, 3083 0x70, 0x16, 0xcb, 0xa9, 0x24, 0x8f, 0xee, 0x43, 0x1e, 0x0d, 0x4b, 0x18, 0x09, 0xe6, 0x35, 0x2a, 3084 0xf2, 0x10, 0xdf, 0xe4, 0x14, 0x80, 0x72, 0xee, 0x59, 0xbd, 0x49, 0x24, 0xbe, 0x1e, 0x17, 0x3f, 3085 0xb2, 0x7a, 0x7e, 0xf3, 0x6c, 0xda, 0x3c, 0xa1, 0x96, 0xd7, 0xba, 0xa2, 0x4c, 0xf3, 0x72, 0xc4, 3086 0x13, 0x33, 0xcf, 0x98, 0x24, 0xfd, 0x57, 0x79, 0x28, 0xc8, 0x7c, 0x91, 0x7c, 0x90, 0xac, 0x5e, 3087 0x54, 0x0e, 0x77, 0x56, 0x2d, 0x5f, 0x52, 0xa9, 0xd5, 0x87, 0x21, 0xd0, 0xf5, 0xc5, 0x92, 0x40, 3088 0xab, 0x72, 0xfe, 0x6c, 0xb7, 0x88, 0xe1, 0x43, 0xe7, 0x6e, 0x54, 0x1f, 0x58, 0x95, 0x1e, 0x07, 3089 0xc5, 0x88, 0xdc, 0x0b, 0x17, 0x23, 0x5e, 0x87, 0xa2, 0x3d, 0x19, 0x77, 0xf9, 0xcc, 0x57, 0xce, 3090 0xb2, 0x60, 0x4f, 0xc6, 0x0f, 0x67, 0x68, 0x4f, 0xdc, 0xe1, 0x74, 0x84, 0x43, 0xd2, 0x55, 0x96, 3091 0xb0, 0x43, 0x0c, 0xb6, 0x61, 0x2b, 0x16, 0x65, 0x59, 0xa6, 0xca, 0x06, 0x76, 0x2e, 0xba, 0x46, 3092 0x9d, 0xbb, 0x6a, 0xd7, 0x95, 0x30, 0x0a, 0xeb, 0x98, 0x64, 0x3f, 0x99, 0x5b, 0x63, 0xb0, 0x56, 3093 0xc2, 0x1b, 0x1e, 0x4b, 0x97, 0x45, 0xa8, 0x26, 0x16, 0x24, 0xee, 0xbc, 0x24, 0x29, 0x23, 0x49, 3094 0x49, 0x74, 0xe0, 0xe0, 0x0d, 0xa8, 0x46, 0xf1, 0x8c, 0x24, 0x01, 0x29, 0x25, 0xea, 0x46, 0xc2, 3095 0x77, 0xe1, 0xb2, 0xcd, 0x66, 0xbc, 0xbb, 0x48, 0x5d, 0x41, 0x6a, 0x22, 0xc6, 0x4e, 0x93, 0x1c, 3096 0xd7, 0x60, 0x3b, 0xf2, 0x9c, 0x48, 0xbb, 0x29, 0x2b, 0x1e, 0x61, 0x2f, 0x92, 0xbd, 0x01, 0xa5, 3097 0x30, 0xda, 0xdc, 0x42, 0x82, 0x22, 0x95, 0x41, 0x66, 0x18, 0xbf, 0x7a, 0xcc, 0x9f, 0x8c, 0xb8, 3098 0x12, 0xb2, 0x8d, 0x34, 0x18, 0xbf, 0x1a, 0xb2, 0x1f, 0x69, 0xf7, 0x60, 0x2b, 0xf0, 0x13, 0x92, 3099 0xae, 0x8a, 0x74, 0x9b, 0x41, 0x27, 0x12, 0xdd, 0x84, 0x9a, 0xeb, 0x39, 0xae, 0xe3, 0x33, 0xaf, 3100 0x4b, 0x4d, 0xd3, 0x63, 0xbe, 0x5f, 0xaf, 0x49, 0x79, 0x41, 0xff, 0x91, 0xec, 0xd6, 0xbf, 0x09, 3101 0xc5, 0x20, 0x8c, 0xbe, 0x0c, 0xf9, 0x56, 0xe8, 0xf3, 0x72, 0x86, 0x6c, 0x08, 0x58, 0x3d, 0x72, 3102 0x5d, 0x55, 0x54, 0x13, 0x9f, 0xfa, 0x08, 0x8a, 0xea, 0xc0, 0x96, 0x96, 0x52, 0x3e, 0x86, 0x4d, 3103 0x97, 0x7a, 0x62, 0x1b, 0xf1, 0x82, 0xca, 0xaa, 0x44, 0xf0, 0x84, 0x7a, 0xfc, 0x01, 0xe3, 0x89, 3104 0xba, 0x4a, 0x05, 0xf9, 0x65, 0x97, 0x7e, 0x0b, 0xb6, 0x12, 0x34, 0x62, 0x99, 0x68, 0x67, 0x81, 3105 0x7b, 0xc0, 0x46, 0xb8, 0x92, 0x4c, 0xb4, 0x12, 0xfd, 0x36, 0x94, 0xc3, 0xb3, 0x12, 0xf9, 0x45, 3106 0xa0, 0x0a, 0x4d, 0xa9, 0x5f, 0x36, 0xb1, 0x76, 0xe4, 0x3c, 0x65, 0x9e, 0xba, 0x33, 0xb2, 0xa1, 3107 0xb3, 0x98, 0x3b, 0x93, 0x20, 0x46, 0xee, 0x40, 0x51, 0xb9, 0x33, 0x75, 0x8b, 0x57, 0x55, 0x89, 3108 0x4e, 0xd0, 0xbf, 0x05, 0x55, 0x22, 0xe9, 0xed, 0xa2, 0x69, 0x32, 0xf1, 0x69, 0x7e, 0x02, 0xa5, 3109 0xc0, 0x65, 0x25, 0xfd, 0xbe, 0x9c, 0xe1, 0xea, 0x3a, 0xbf, 0xaf, 0x26, 0x89, 0x18, 0x85, 0x35, 3110 0xf9, 0xd6, 0xc0, 0x66, 0x66, 0x37, 0xba, 0x82, 0x38, 0x67, 0xc9, 0xa8, 0xca, 0x81, 0xfb, 0xc1, 3111 0xfd, 0xd2, 0xdf, 0x85, 0x82, 0x5c, 0xeb, 0x52, 0xc7, 0xb8, 0x04, 0x51, 0xf5, 0xbf, 0x69, 0x50, 3112 0x0a, 0x10, 0x61, 0x29, 0x53, 0x62, 0x13, 0x99, 0xaf, 0xbb, 0x89, 0x97, 0xef, 0xc8, 0xde, 0x01, 3113 0x22, 0xfd, 0xd5, 0xd4, 0xe1, 0x96, 0x3d, 0xe8, 0xca, 0xb3, 0x90, 0x3e, 0xad, 0x86, 0x23, 0xa7, 3114 0x38, 0x70, 0x22, 0xfa, 0xdf, 0xde, 0x83, 0x4a, 0xac, 0xb8, 0x45, 0x8a, 0x90, 0xfd, 0x84, 0x3d, 3115 0xad, 0x6d, 0x90, 0x0a, 0x14, 0x0d, 0x86, 0xa5, 0x81, 0x9a, 0x76, 0xf8, 0x8f, 0x22, 0x54, 0x8f, 3116 0x5a, 0xc7, 0x9d, 0x23, 0xd7, 0x1d, 0x59, 0x7d, 0x8a, 0xb9, 0xe1, 0xa7, 0x90, 0xc3, 0xf4, 0x38, 3117 0xc5, 0xb3, 0x4e, 0x23, 0x4d, 0x9d, 0x89, 0x18, 0x90, 0xc7, 0x2c, 0x9a, 0xa4, 0x79, 0xed, 0x69, 3118 0xa4, 0x2a, 0x3f, 0x89, 0x45, 0xa2, 0xc1, 0xa5, 0x78, 0x04, 0x6a, 0xa4, 0xa9, 0x49, 0x91, 0xcf, 3119 0xa1, 0x1c, 0xa5, 0xc7, 0x69, 0x9f, 0x86, 0x1a, 0xa9, 0xab, 0x55, 0x42, 0x7e, 0x94, 0x10, 0xa4, 3120 0x7d, 0x18, 0x69, 0xa4, 0x2e, 0xd3, 0x90, 0xc7, 0x50, 0x0c, 0x52, 0xaf, 0x74, 0x8f, 0x37, 0x8d, 3121 0x94, 0x95, 0x24, 0x71, 0x7c, 0x32, 0x63, 0x4e, 0xf3, 0x42, 0xd5, 0x48, 0x55, 0x2e, 0x23, 0x8f, 3122 0xa0, 0xa0, 0x62, 0xde, 0x54, 0xcf, 0x32, 0x8d, 0x74, 0xf5, 0x21, 0xa1, 0xe4, 0xa8, 0x26, 0x91, 3123 0xf6, 0x55, 0xae, 0x91, 0xba, 0x4e, 0x48, 0x28, 0x40, 0x2c, 0x8d, 0x4e, 0xfd, 0xdc, 0xd6, 0x48, 3124 0x5f, 0xff, 0x23, 0x3f, 0x82, 0x52, 0x98, 0x2c, 0xa5, 0x7c, 0xf6, 0x6a, 0xa4, 0x2d, 0xc1, 0xb5, 3125 0x3a, 0xff, 0xfe, 0xcb, 0x8e, 0xf6, 0xeb, 0xf3, 0x1d, 0xed, 0xcb, 0xf3, 0x1d, 0xed, 0xab, 0xf3, 3126 0x1d, 0xed, 0x0f, 0xe7, 0x3b, 0xda, 0x9f, 0xcf, 0x77, 0xb4, 0xdf, 0xfd, 0x75, 0x47, 0xfb, 0xe1, 3127 0xff, 0x0f, 0x2c, 0x3e, 0x9c, 0xf4, 0x9a, 0x7d, 0x67, 0x7c, 0x10, 0x09, 0x8c, 0x7f, 0x46, 0x6f, 3128 0xd5, 0xbd, 0x02, 0x3a, 0xac, 0x6f, 0xfd, 0x27, 0x00, 0x00, 0xff, 0xff, 0x4a, 0x5b, 0x3a, 0x56, 3129 0xc0, 0x1e, 0x00, 0x00, 3130 } 3131 3132 func (this *Request) Equal(that interface{}) bool { 3133 if that == nil { 3134 return this == nil 3135 } 3136 3137 that1, ok := that.(*Request) 3138 if !ok { 3139 that2, ok := that.(Request) 3140 if ok { 3141 that1 = &that2 3142 } else { 3143 return false 3144 } 3145 } 3146 if that1 == nil { 3147 return this == nil 3148 } else if this == nil { 3149 return false 3150 } 3151 if that1.Value == nil { 3152 if this.Value != nil { 3153 return false 3154 } 3155 } else if this.Value == nil { 3156 return false 3157 } else if !this.Value.Equal(that1.Value) { 3158 return false 3159 } 3160 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3161 return false 3162 } 3163 return true 3164 } 3165 func (this *Request_Echo) Equal(that interface{}) bool { 3166 if that == nil { 3167 return this == nil 3168 } 3169 3170 that1, ok := that.(*Request_Echo) 3171 if !ok { 3172 that2, ok := that.(Request_Echo) 3173 if ok { 3174 that1 = &that2 3175 } else { 3176 return false 3177 } 3178 } 3179 if that1 == nil { 3180 return this == nil 3181 } else if this == nil { 3182 return false 3183 } 3184 if !this.Echo.Equal(that1.Echo) { 3185 return false 3186 } 3187 return true 3188 } 3189 func (this *Request_Flush) Equal(that interface{}) bool { 3190 if that == nil { 3191 return this == nil 3192 } 3193 3194 that1, ok := that.(*Request_Flush) 3195 if !ok { 3196 that2, ok := that.(Request_Flush) 3197 if ok { 3198 that1 = &that2 3199 } else { 3200 return false 3201 } 3202 } 3203 if that1 == nil { 3204 return this == nil 3205 } else if this == nil { 3206 return false 3207 } 3208 if !this.Flush.Equal(that1.Flush) { 3209 return false 3210 } 3211 return true 3212 } 3213 func (this *Request_Info) Equal(that interface{}) bool { 3214 if that == nil { 3215 return this == nil 3216 } 3217 3218 that1, ok := that.(*Request_Info) 3219 if !ok { 3220 that2, ok := that.(Request_Info) 3221 if ok { 3222 that1 = &that2 3223 } else { 3224 return false 3225 } 3226 } 3227 if that1 == nil { 3228 return this == nil 3229 } else if this == nil { 3230 return false 3231 } 3232 if !this.Info.Equal(that1.Info) { 3233 return false 3234 } 3235 return true 3236 } 3237 func (this *Request_SetOption) Equal(that interface{}) bool { 3238 if that == nil { 3239 return this == nil 3240 } 3241 3242 that1, ok := that.(*Request_SetOption) 3243 if !ok { 3244 that2, ok := that.(Request_SetOption) 3245 if ok { 3246 that1 = &that2 3247 } else { 3248 return false 3249 } 3250 } 3251 if that1 == nil { 3252 return this == nil 3253 } else if this == nil { 3254 return false 3255 } 3256 if !this.SetOption.Equal(that1.SetOption) { 3257 return false 3258 } 3259 return true 3260 } 3261 func (this *Request_InitChain) Equal(that interface{}) bool { 3262 if that == nil { 3263 return this == nil 3264 } 3265 3266 that1, ok := that.(*Request_InitChain) 3267 if !ok { 3268 that2, ok := that.(Request_InitChain) 3269 if ok { 3270 that1 = &that2 3271 } else { 3272 return false 3273 } 3274 } 3275 if that1 == nil { 3276 return this == nil 3277 } else if this == nil { 3278 return false 3279 } 3280 if !this.InitChain.Equal(that1.InitChain) { 3281 return false 3282 } 3283 return true 3284 } 3285 func (this *Request_Query) Equal(that interface{}) bool { 3286 if that == nil { 3287 return this == nil 3288 } 3289 3290 that1, ok := that.(*Request_Query) 3291 if !ok { 3292 that2, ok := that.(Request_Query) 3293 if ok { 3294 that1 = &that2 3295 } else { 3296 return false 3297 } 3298 } 3299 if that1 == nil { 3300 return this == nil 3301 } else if this == nil { 3302 return false 3303 } 3304 if !this.Query.Equal(that1.Query) { 3305 return false 3306 } 3307 return true 3308 } 3309 func (this *Request_BeginBlock) Equal(that interface{}) bool { 3310 if that == nil { 3311 return this == nil 3312 } 3313 3314 that1, ok := that.(*Request_BeginBlock) 3315 if !ok { 3316 that2, ok := that.(Request_BeginBlock) 3317 if ok { 3318 that1 = &that2 3319 } else { 3320 return false 3321 } 3322 } 3323 if that1 == nil { 3324 return this == nil 3325 } else if this == nil { 3326 return false 3327 } 3328 if !this.BeginBlock.Equal(that1.BeginBlock) { 3329 return false 3330 } 3331 return true 3332 } 3333 func (this *Request_CheckTx) Equal(that interface{}) bool { 3334 if that == nil { 3335 return this == nil 3336 } 3337 3338 that1, ok := that.(*Request_CheckTx) 3339 if !ok { 3340 that2, ok := that.(Request_CheckTx) 3341 if ok { 3342 that1 = &that2 3343 } else { 3344 return false 3345 } 3346 } 3347 if that1 == nil { 3348 return this == nil 3349 } else if this == nil { 3350 return false 3351 } 3352 if !this.CheckTx.Equal(that1.CheckTx) { 3353 return false 3354 } 3355 return true 3356 } 3357 func (this *Request_DeliverTx) Equal(that interface{}) bool { 3358 if that == nil { 3359 return this == nil 3360 } 3361 3362 that1, ok := that.(*Request_DeliverTx) 3363 if !ok { 3364 that2, ok := that.(Request_DeliverTx) 3365 if ok { 3366 that1 = &that2 3367 } else { 3368 return false 3369 } 3370 } 3371 if that1 == nil { 3372 return this == nil 3373 } else if this == nil { 3374 return false 3375 } 3376 if !this.DeliverTx.Equal(that1.DeliverTx) { 3377 return false 3378 } 3379 return true 3380 } 3381 func (this *Request_EndBlock) Equal(that interface{}) bool { 3382 if that == nil { 3383 return this == nil 3384 } 3385 3386 that1, ok := that.(*Request_EndBlock) 3387 if !ok { 3388 that2, ok := that.(Request_EndBlock) 3389 if ok { 3390 that1 = &that2 3391 } else { 3392 return false 3393 } 3394 } 3395 if that1 == nil { 3396 return this == nil 3397 } else if this == nil { 3398 return false 3399 } 3400 if !this.EndBlock.Equal(that1.EndBlock) { 3401 return false 3402 } 3403 return true 3404 } 3405 func (this *Request_Commit) Equal(that interface{}) bool { 3406 if that == nil { 3407 return this == nil 3408 } 3409 3410 that1, ok := that.(*Request_Commit) 3411 if !ok { 3412 that2, ok := that.(Request_Commit) 3413 if ok { 3414 that1 = &that2 3415 } else { 3416 return false 3417 } 3418 } 3419 if that1 == nil { 3420 return this == nil 3421 } else if this == nil { 3422 return false 3423 } 3424 if !this.Commit.Equal(that1.Commit) { 3425 return false 3426 } 3427 return true 3428 } 3429 func (this *RequestEcho) Equal(that interface{}) bool { 3430 if that == nil { 3431 return this == nil 3432 } 3433 3434 that1, ok := that.(*RequestEcho) 3435 if !ok { 3436 that2, ok := that.(RequestEcho) 3437 if ok { 3438 that1 = &that2 3439 } else { 3440 return false 3441 } 3442 } 3443 if that1 == nil { 3444 return this == nil 3445 } else if this == nil { 3446 return false 3447 } 3448 if this.Message != that1.Message { 3449 return false 3450 } 3451 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3452 return false 3453 } 3454 return true 3455 } 3456 func (this *RequestFlush) Equal(that interface{}) bool { 3457 if that == nil { 3458 return this == nil 3459 } 3460 3461 that1, ok := that.(*RequestFlush) 3462 if !ok { 3463 that2, ok := that.(RequestFlush) 3464 if ok { 3465 that1 = &that2 3466 } else { 3467 return false 3468 } 3469 } 3470 if that1 == nil { 3471 return this == nil 3472 } else if this == nil { 3473 return false 3474 } 3475 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3476 return false 3477 } 3478 return true 3479 } 3480 func (this *RequestInfo) Equal(that interface{}) bool { 3481 if that == nil { 3482 return this == nil 3483 } 3484 3485 that1, ok := that.(*RequestInfo) 3486 if !ok { 3487 that2, ok := that.(RequestInfo) 3488 if ok { 3489 that1 = &that2 3490 } else { 3491 return false 3492 } 3493 } 3494 if that1 == nil { 3495 return this == nil 3496 } else if this == nil { 3497 return false 3498 } 3499 if this.Version != that1.Version { 3500 return false 3501 } 3502 if this.BlockVersion != that1.BlockVersion { 3503 return false 3504 } 3505 if this.P2PVersion != that1.P2PVersion { 3506 return false 3507 } 3508 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3509 return false 3510 } 3511 return true 3512 } 3513 func (this *RequestSetOption) Equal(that interface{}) bool { 3514 if that == nil { 3515 return this == nil 3516 } 3517 3518 that1, ok := that.(*RequestSetOption) 3519 if !ok { 3520 that2, ok := that.(RequestSetOption) 3521 if ok { 3522 that1 = &that2 3523 } else { 3524 return false 3525 } 3526 } 3527 if that1 == nil { 3528 return this == nil 3529 } else if this == nil { 3530 return false 3531 } 3532 if this.Key != that1.Key { 3533 return false 3534 } 3535 if this.Value != that1.Value { 3536 return false 3537 } 3538 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3539 return false 3540 } 3541 return true 3542 } 3543 func (this *RequestInitChain) Equal(that interface{}) bool { 3544 if that == nil { 3545 return this == nil 3546 } 3547 3548 that1, ok := that.(*RequestInitChain) 3549 if !ok { 3550 that2, ok := that.(RequestInitChain) 3551 if ok { 3552 that1 = &that2 3553 } else { 3554 return false 3555 } 3556 } 3557 if that1 == nil { 3558 return this == nil 3559 } else if this == nil { 3560 return false 3561 } 3562 if !this.Time.Equal(that1.Time) { 3563 return false 3564 } 3565 if this.ChainId != that1.ChainId { 3566 return false 3567 } 3568 if !this.ConsensusParams.Equal(that1.ConsensusParams) { 3569 return false 3570 } 3571 if len(this.Validators) != len(that1.Validators) { 3572 return false 3573 } 3574 for i := range this.Validators { 3575 if !this.Validators[i].Equal(&that1.Validators[i]) { 3576 return false 3577 } 3578 } 3579 if !bytes.Equal(this.AppStateBytes, that1.AppStateBytes) { 3580 return false 3581 } 3582 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3583 return false 3584 } 3585 return true 3586 } 3587 func (this *RequestQuery) Equal(that interface{}) bool { 3588 if that == nil { 3589 return this == nil 3590 } 3591 3592 that1, ok := that.(*RequestQuery) 3593 if !ok { 3594 that2, ok := that.(RequestQuery) 3595 if ok { 3596 that1 = &that2 3597 } else { 3598 return false 3599 } 3600 } 3601 if that1 == nil { 3602 return this == nil 3603 } else if this == nil { 3604 return false 3605 } 3606 if !bytes.Equal(this.Data, that1.Data) { 3607 return false 3608 } 3609 if this.Path != that1.Path { 3610 return false 3611 } 3612 if this.Height != that1.Height { 3613 return false 3614 } 3615 if this.Prove != that1.Prove { 3616 return false 3617 } 3618 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3619 return false 3620 } 3621 return true 3622 } 3623 func (this *RequestBeginBlock) Equal(that interface{}) bool { 3624 if that == nil { 3625 return this == nil 3626 } 3627 3628 that1, ok := that.(*RequestBeginBlock) 3629 if !ok { 3630 that2, ok := that.(RequestBeginBlock) 3631 if ok { 3632 that1 = &that2 3633 } else { 3634 return false 3635 } 3636 } 3637 if that1 == nil { 3638 return this == nil 3639 } else if this == nil { 3640 return false 3641 } 3642 if !bytes.Equal(this.Hash, that1.Hash) { 3643 return false 3644 } 3645 if !this.Header.Equal(&that1.Header) { 3646 return false 3647 } 3648 if !this.LastCommitInfo.Equal(&that1.LastCommitInfo) { 3649 return false 3650 } 3651 if len(this.ByzantineValidators) != len(that1.ByzantineValidators) { 3652 return false 3653 } 3654 for i := range this.ByzantineValidators { 3655 if !this.ByzantineValidators[i].Equal(&that1.ByzantineValidators[i]) { 3656 return false 3657 } 3658 } 3659 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3660 return false 3661 } 3662 return true 3663 } 3664 func (this *RequestCheckTx) Equal(that interface{}) bool { 3665 if that == nil { 3666 return this == nil 3667 } 3668 3669 that1, ok := that.(*RequestCheckTx) 3670 if !ok { 3671 that2, ok := that.(RequestCheckTx) 3672 if ok { 3673 that1 = &that2 3674 } else { 3675 return false 3676 } 3677 } 3678 if that1 == nil { 3679 return this == nil 3680 } else if this == nil { 3681 return false 3682 } 3683 if !bytes.Equal(this.Tx, that1.Tx) { 3684 return false 3685 } 3686 if this.Type != that1.Type { 3687 return false 3688 } 3689 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3690 return false 3691 } 3692 return true 3693 } 3694 func (this *RequestDeliverTx) Equal(that interface{}) bool { 3695 if that == nil { 3696 return this == nil 3697 } 3698 3699 that1, ok := that.(*RequestDeliverTx) 3700 if !ok { 3701 that2, ok := that.(RequestDeliverTx) 3702 if ok { 3703 that1 = &that2 3704 } else { 3705 return false 3706 } 3707 } 3708 if that1 == nil { 3709 return this == nil 3710 } else if this == nil { 3711 return false 3712 } 3713 if !bytes.Equal(this.Tx, that1.Tx) { 3714 return false 3715 } 3716 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3717 return false 3718 } 3719 return true 3720 } 3721 func (this *RequestEndBlock) Equal(that interface{}) bool { 3722 if that == nil { 3723 return this == nil 3724 } 3725 3726 that1, ok := that.(*RequestEndBlock) 3727 if !ok { 3728 that2, ok := that.(RequestEndBlock) 3729 if ok { 3730 that1 = &that2 3731 } else { 3732 return false 3733 } 3734 } 3735 if that1 == nil { 3736 return this == nil 3737 } else if this == nil { 3738 return false 3739 } 3740 if this.Height != that1.Height { 3741 return false 3742 } 3743 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3744 return false 3745 } 3746 return true 3747 } 3748 func (this *RequestCommit) Equal(that interface{}) bool { 3749 if that == nil { 3750 return this == nil 3751 } 3752 3753 that1, ok := that.(*RequestCommit) 3754 if !ok { 3755 that2, ok := that.(RequestCommit) 3756 if ok { 3757 that1 = &that2 3758 } else { 3759 return false 3760 } 3761 } 3762 if that1 == nil { 3763 return this == nil 3764 } else if this == nil { 3765 return false 3766 } 3767 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3768 return false 3769 } 3770 return true 3771 } 3772 func (this *Response) Equal(that interface{}) bool { 3773 if that == nil { 3774 return this == nil 3775 } 3776 3777 that1, ok := that.(*Response) 3778 if !ok { 3779 that2, ok := that.(Response) 3780 if ok { 3781 that1 = &that2 3782 } else { 3783 return false 3784 } 3785 } 3786 if that1 == nil { 3787 return this == nil 3788 } else if this == nil { 3789 return false 3790 } 3791 if that1.Value == nil { 3792 if this.Value != nil { 3793 return false 3794 } 3795 } else if this.Value == nil { 3796 return false 3797 } else if !this.Value.Equal(that1.Value) { 3798 return false 3799 } 3800 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 3801 return false 3802 } 3803 return true 3804 } 3805 func (this *Response_Exception) Equal(that interface{}) bool { 3806 if that == nil { 3807 return this == nil 3808 } 3809 3810 that1, ok := that.(*Response_Exception) 3811 if !ok { 3812 that2, ok := that.(Response_Exception) 3813 if ok { 3814 that1 = &that2 3815 } else { 3816 return false 3817 } 3818 } 3819 if that1 == nil { 3820 return this == nil 3821 } else if this == nil { 3822 return false 3823 } 3824 if !this.Exception.Equal(that1.Exception) { 3825 return false 3826 } 3827 return true 3828 } 3829 func (this *Response_Echo) Equal(that interface{}) bool { 3830 if that == nil { 3831 return this == nil 3832 } 3833 3834 that1, ok := that.(*Response_Echo) 3835 if !ok { 3836 that2, ok := that.(Response_Echo) 3837 if ok { 3838 that1 = &that2 3839 } else { 3840 return false 3841 } 3842 } 3843 if that1 == nil { 3844 return this == nil 3845 } else if this == nil { 3846 return false 3847 } 3848 if !this.Echo.Equal(that1.Echo) { 3849 return false 3850 } 3851 return true 3852 } 3853 func (this *Response_Flush) Equal(that interface{}) bool { 3854 if that == nil { 3855 return this == nil 3856 } 3857 3858 that1, ok := that.(*Response_Flush) 3859 if !ok { 3860 that2, ok := that.(Response_Flush) 3861 if ok { 3862 that1 = &that2 3863 } else { 3864 return false 3865 } 3866 } 3867 if that1 == nil { 3868 return this == nil 3869 } else if this == nil { 3870 return false 3871 } 3872 if !this.Flush.Equal(that1.Flush) { 3873 return false 3874 } 3875 return true 3876 } 3877 func (this *Response_Info) Equal(that interface{}) bool { 3878 if that == nil { 3879 return this == nil 3880 } 3881 3882 that1, ok := that.(*Response_Info) 3883 if !ok { 3884 that2, ok := that.(Response_Info) 3885 if ok { 3886 that1 = &that2 3887 } else { 3888 return false 3889 } 3890 } 3891 if that1 == nil { 3892 return this == nil 3893 } else if this == nil { 3894 return false 3895 } 3896 if !this.Info.Equal(that1.Info) { 3897 return false 3898 } 3899 return true 3900 } 3901 func (this *Response_SetOption) Equal(that interface{}) bool { 3902 if that == nil { 3903 return this == nil 3904 } 3905 3906 that1, ok := that.(*Response_SetOption) 3907 if !ok { 3908 that2, ok := that.(Response_SetOption) 3909 if ok { 3910 that1 = &that2 3911 } else { 3912 return false 3913 } 3914 } 3915 if that1 == nil { 3916 return this == nil 3917 } else if this == nil { 3918 return false 3919 } 3920 if !this.SetOption.Equal(that1.SetOption) { 3921 return false 3922 } 3923 return true 3924 } 3925 func (this *Response_InitChain) Equal(that interface{}) bool { 3926 if that == nil { 3927 return this == nil 3928 } 3929 3930 that1, ok := that.(*Response_InitChain) 3931 if !ok { 3932 that2, ok := that.(Response_InitChain) 3933 if ok { 3934 that1 = &that2 3935 } else { 3936 return false 3937 } 3938 } 3939 if that1 == nil { 3940 return this == nil 3941 } else if this == nil { 3942 return false 3943 } 3944 if !this.InitChain.Equal(that1.InitChain) { 3945 return false 3946 } 3947 return true 3948 } 3949 func (this *Response_Query) Equal(that interface{}) bool { 3950 if that == nil { 3951 return this == nil 3952 } 3953 3954 that1, ok := that.(*Response_Query) 3955 if !ok { 3956 that2, ok := that.(Response_Query) 3957 if ok { 3958 that1 = &that2 3959 } else { 3960 return false 3961 } 3962 } 3963 if that1 == nil { 3964 return this == nil 3965 } else if this == nil { 3966 return false 3967 } 3968 if !this.Query.Equal(that1.Query) { 3969 return false 3970 } 3971 return true 3972 } 3973 func (this *Response_BeginBlock) Equal(that interface{}) bool { 3974 if that == nil { 3975 return this == nil 3976 } 3977 3978 that1, ok := that.(*Response_BeginBlock) 3979 if !ok { 3980 that2, ok := that.(Response_BeginBlock) 3981 if ok { 3982 that1 = &that2 3983 } else { 3984 return false 3985 } 3986 } 3987 if that1 == nil { 3988 return this == nil 3989 } else if this == nil { 3990 return false 3991 } 3992 if !this.BeginBlock.Equal(that1.BeginBlock) { 3993 return false 3994 } 3995 return true 3996 } 3997 func (this *Response_CheckTx) Equal(that interface{}) bool { 3998 if that == nil { 3999 return this == nil 4000 } 4001 4002 that1, ok := that.(*Response_CheckTx) 4003 if !ok { 4004 that2, ok := that.(Response_CheckTx) 4005 if ok { 4006 that1 = &that2 4007 } else { 4008 return false 4009 } 4010 } 4011 if that1 == nil { 4012 return this == nil 4013 } else if this == nil { 4014 return false 4015 } 4016 if !this.CheckTx.Equal(that1.CheckTx) { 4017 return false 4018 } 4019 return true 4020 } 4021 func (this *Response_DeliverTx) Equal(that interface{}) bool { 4022 if that == nil { 4023 return this == nil 4024 } 4025 4026 that1, ok := that.(*Response_DeliverTx) 4027 if !ok { 4028 that2, ok := that.(Response_DeliverTx) 4029 if ok { 4030 that1 = &that2 4031 } else { 4032 return false 4033 } 4034 } 4035 if that1 == nil { 4036 return this == nil 4037 } else if this == nil { 4038 return false 4039 } 4040 if !this.DeliverTx.Equal(that1.DeliverTx) { 4041 return false 4042 } 4043 return true 4044 } 4045 func (this *Response_EndBlock) Equal(that interface{}) bool { 4046 if that == nil { 4047 return this == nil 4048 } 4049 4050 that1, ok := that.(*Response_EndBlock) 4051 if !ok { 4052 that2, ok := that.(Response_EndBlock) 4053 if ok { 4054 that1 = &that2 4055 } else { 4056 return false 4057 } 4058 } 4059 if that1 == nil { 4060 return this == nil 4061 } else if this == nil { 4062 return false 4063 } 4064 if !this.EndBlock.Equal(that1.EndBlock) { 4065 return false 4066 } 4067 return true 4068 } 4069 func (this *Response_Commit) Equal(that interface{}) bool { 4070 if that == nil { 4071 return this == nil 4072 } 4073 4074 that1, ok := that.(*Response_Commit) 4075 if !ok { 4076 that2, ok := that.(Response_Commit) 4077 if ok { 4078 that1 = &that2 4079 } else { 4080 return false 4081 } 4082 } 4083 if that1 == nil { 4084 return this == nil 4085 } else if this == nil { 4086 return false 4087 } 4088 if !this.Commit.Equal(that1.Commit) { 4089 return false 4090 } 4091 return true 4092 } 4093 func (this *ResponseException) Equal(that interface{}) bool { 4094 if that == nil { 4095 return this == nil 4096 } 4097 4098 that1, ok := that.(*ResponseException) 4099 if !ok { 4100 that2, ok := that.(ResponseException) 4101 if ok { 4102 that1 = &that2 4103 } else { 4104 return false 4105 } 4106 } 4107 if that1 == nil { 4108 return this == nil 4109 } else if this == nil { 4110 return false 4111 } 4112 if this.Error != that1.Error { 4113 return false 4114 } 4115 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4116 return false 4117 } 4118 return true 4119 } 4120 func (this *ResponseEcho) Equal(that interface{}) bool { 4121 if that == nil { 4122 return this == nil 4123 } 4124 4125 that1, ok := that.(*ResponseEcho) 4126 if !ok { 4127 that2, ok := that.(ResponseEcho) 4128 if ok { 4129 that1 = &that2 4130 } else { 4131 return false 4132 } 4133 } 4134 if that1 == nil { 4135 return this == nil 4136 } else if this == nil { 4137 return false 4138 } 4139 if this.Message != that1.Message { 4140 return false 4141 } 4142 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4143 return false 4144 } 4145 return true 4146 } 4147 func (this *ResponseFlush) Equal(that interface{}) bool { 4148 if that == nil { 4149 return this == nil 4150 } 4151 4152 that1, ok := that.(*ResponseFlush) 4153 if !ok { 4154 that2, ok := that.(ResponseFlush) 4155 if ok { 4156 that1 = &that2 4157 } else { 4158 return false 4159 } 4160 } 4161 if that1 == nil { 4162 return this == nil 4163 } else if this == nil { 4164 return false 4165 } 4166 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4167 return false 4168 } 4169 return true 4170 } 4171 func (this *ResponseInfo) Equal(that interface{}) bool { 4172 if that == nil { 4173 return this == nil 4174 } 4175 4176 that1, ok := that.(*ResponseInfo) 4177 if !ok { 4178 that2, ok := that.(ResponseInfo) 4179 if ok { 4180 that1 = &that2 4181 } else { 4182 return false 4183 } 4184 } 4185 if that1 == nil { 4186 return this == nil 4187 } else if this == nil { 4188 return false 4189 } 4190 if this.Data != that1.Data { 4191 return false 4192 } 4193 if this.Version != that1.Version { 4194 return false 4195 } 4196 if this.AppVersion != that1.AppVersion { 4197 return false 4198 } 4199 if this.LastBlockHeight != that1.LastBlockHeight { 4200 return false 4201 } 4202 if !bytes.Equal(this.LastBlockAppHash, that1.LastBlockAppHash) { 4203 return false 4204 } 4205 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4206 return false 4207 } 4208 return true 4209 } 4210 func (this *ResponseSetOption) Equal(that interface{}) bool { 4211 if that == nil { 4212 return this == nil 4213 } 4214 4215 that1, ok := that.(*ResponseSetOption) 4216 if !ok { 4217 that2, ok := that.(ResponseSetOption) 4218 if ok { 4219 that1 = &that2 4220 } else { 4221 return false 4222 } 4223 } 4224 if that1 == nil { 4225 return this == nil 4226 } else if this == nil { 4227 return false 4228 } 4229 if this.Code != that1.Code { 4230 return false 4231 } 4232 if this.Log != that1.Log { 4233 return false 4234 } 4235 if this.Info != that1.Info { 4236 return false 4237 } 4238 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4239 return false 4240 } 4241 return true 4242 } 4243 func (this *ResponseInitChain) Equal(that interface{}) bool { 4244 if that == nil { 4245 return this == nil 4246 } 4247 4248 that1, ok := that.(*ResponseInitChain) 4249 if !ok { 4250 that2, ok := that.(ResponseInitChain) 4251 if ok { 4252 that1 = &that2 4253 } else { 4254 return false 4255 } 4256 } 4257 if that1 == nil { 4258 return this == nil 4259 } else if this == nil { 4260 return false 4261 } 4262 if !this.ConsensusParams.Equal(that1.ConsensusParams) { 4263 return false 4264 } 4265 if len(this.Validators) != len(that1.Validators) { 4266 return false 4267 } 4268 for i := range this.Validators { 4269 if !this.Validators[i].Equal(&that1.Validators[i]) { 4270 return false 4271 } 4272 } 4273 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4274 return false 4275 } 4276 return true 4277 } 4278 func (this *ResponseQuery) Equal(that interface{}) bool { 4279 if that == nil { 4280 return this == nil 4281 } 4282 4283 that1, ok := that.(*ResponseQuery) 4284 if !ok { 4285 that2, ok := that.(ResponseQuery) 4286 if ok { 4287 that1 = &that2 4288 } else { 4289 return false 4290 } 4291 } 4292 if that1 == nil { 4293 return this == nil 4294 } else if this == nil { 4295 return false 4296 } 4297 if this.Code != that1.Code { 4298 return false 4299 } 4300 if this.Log != that1.Log { 4301 return false 4302 } 4303 if this.Info != that1.Info { 4304 return false 4305 } 4306 if this.Index != that1.Index { 4307 return false 4308 } 4309 if !bytes.Equal(this.Key, that1.Key) { 4310 return false 4311 } 4312 if !bytes.Equal(this.Value, that1.Value) { 4313 return false 4314 } 4315 if !this.Proof.Equal(that1.Proof) { 4316 return false 4317 } 4318 if this.Height != that1.Height { 4319 return false 4320 } 4321 if this.Codespace != that1.Codespace { 4322 return false 4323 } 4324 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4325 return false 4326 } 4327 return true 4328 } 4329 func (this *ResponseBeginBlock) Equal(that interface{}) bool { 4330 if that == nil { 4331 return this == nil 4332 } 4333 4334 that1, ok := that.(*ResponseBeginBlock) 4335 if !ok { 4336 that2, ok := that.(ResponseBeginBlock) 4337 if ok { 4338 that1 = &that2 4339 } else { 4340 return false 4341 } 4342 } 4343 if that1 == nil { 4344 return this == nil 4345 } else if this == nil { 4346 return false 4347 } 4348 if len(this.Events) != len(that1.Events) { 4349 return false 4350 } 4351 for i := range this.Events { 4352 if !this.Events[i].Equal(&that1.Events[i]) { 4353 return false 4354 } 4355 } 4356 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4357 return false 4358 } 4359 return true 4360 } 4361 func (this *ResponseCheckTx) Equal(that interface{}) bool { 4362 if that == nil { 4363 return this == nil 4364 } 4365 4366 that1, ok := that.(*ResponseCheckTx) 4367 if !ok { 4368 that2, ok := that.(ResponseCheckTx) 4369 if ok { 4370 that1 = &that2 4371 } else { 4372 return false 4373 } 4374 } 4375 if that1 == nil { 4376 return this == nil 4377 } else if this == nil { 4378 return false 4379 } 4380 if this.Code != that1.Code { 4381 return false 4382 } 4383 if !bytes.Equal(this.Data, that1.Data) { 4384 return false 4385 } 4386 if this.Log != that1.Log { 4387 return false 4388 } 4389 if this.Info != that1.Info { 4390 return false 4391 } 4392 if this.GasWanted != that1.GasWanted { 4393 return false 4394 } 4395 if this.GasUsed != that1.GasUsed { 4396 return false 4397 } 4398 if len(this.Events) != len(that1.Events) { 4399 return false 4400 } 4401 for i := range this.Events { 4402 if !this.Events[i].Equal(&that1.Events[i]) { 4403 return false 4404 } 4405 } 4406 if this.Codespace != that1.Codespace { 4407 return false 4408 } 4409 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4410 return false 4411 } 4412 return true 4413 } 4414 func (this *ResponseDeliverTx) Equal(that interface{}) bool { 4415 if that == nil { 4416 return this == nil 4417 } 4418 4419 that1, ok := that.(*ResponseDeliverTx) 4420 if !ok { 4421 that2, ok := that.(ResponseDeliverTx) 4422 if ok { 4423 that1 = &that2 4424 } else { 4425 return false 4426 } 4427 } 4428 if that1 == nil { 4429 return this == nil 4430 } else if this == nil { 4431 return false 4432 } 4433 if this.Code != that1.Code { 4434 return false 4435 } 4436 if !bytes.Equal(this.Data, that1.Data) { 4437 return false 4438 } 4439 if this.Log != that1.Log { 4440 return false 4441 } 4442 if this.Info != that1.Info { 4443 return false 4444 } 4445 if this.GasWanted != that1.GasWanted { 4446 return false 4447 } 4448 if this.GasUsed != that1.GasUsed { 4449 return false 4450 } 4451 if len(this.Events) != len(that1.Events) { 4452 return false 4453 } 4454 for i := range this.Events { 4455 if !this.Events[i].Equal(&that1.Events[i]) { 4456 return false 4457 } 4458 } 4459 if this.Codespace != that1.Codespace { 4460 return false 4461 } 4462 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4463 return false 4464 } 4465 return true 4466 } 4467 func (this *ResponseEndBlock) Equal(that interface{}) bool { 4468 if that == nil { 4469 return this == nil 4470 } 4471 4472 that1, ok := that.(*ResponseEndBlock) 4473 if !ok { 4474 that2, ok := that.(ResponseEndBlock) 4475 if ok { 4476 that1 = &that2 4477 } else { 4478 return false 4479 } 4480 } 4481 if that1 == nil { 4482 return this == nil 4483 } else if this == nil { 4484 return false 4485 } 4486 if len(this.ValidatorUpdates) != len(that1.ValidatorUpdates) { 4487 return false 4488 } 4489 for i := range this.ValidatorUpdates { 4490 if !this.ValidatorUpdates[i].Equal(&that1.ValidatorUpdates[i]) { 4491 return false 4492 } 4493 } 4494 if !this.ConsensusParamUpdates.Equal(that1.ConsensusParamUpdates) { 4495 return false 4496 } 4497 if len(this.Events) != len(that1.Events) { 4498 return false 4499 } 4500 for i := range this.Events { 4501 if !this.Events[i].Equal(&that1.Events[i]) { 4502 return false 4503 } 4504 } 4505 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4506 return false 4507 } 4508 return true 4509 } 4510 func (this *ResponseCommit) Equal(that interface{}) bool { 4511 if that == nil { 4512 return this == nil 4513 } 4514 4515 that1, ok := that.(*ResponseCommit) 4516 if !ok { 4517 that2, ok := that.(ResponseCommit) 4518 if ok { 4519 that1 = &that2 4520 } else { 4521 return false 4522 } 4523 } 4524 if that1 == nil { 4525 return this == nil 4526 } else if this == nil { 4527 return false 4528 } 4529 if !bytes.Equal(this.Data, that1.Data) { 4530 return false 4531 } 4532 if this.RetainHeight != that1.RetainHeight { 4533 return false 4534 } 4535 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4536 return false 4537 } 4538 return true 4539 } 4540 func (this *ConsensusParams) Equal(that interface{}) bool { 4541 if that == nil { 4542 return this == nil 4543 } 4544 4545 that1, ok := that.(*ConsensusParams) 4546 if !ok { 4547 that2, ok := that.(ConsensusParams) 4548 if ok { 4549 that1 = &that2 4550 } else { 4551 return false 4552 } 4553 } 4554 if that1 == nil { 4555 return this == nil 4556 } else if this == nil { 4557 return false 4558 } 4559 if !this.Block.Equal(that1.Block) { 4560 return false 4561 } 4562 if !this.Evidence.Equal(that1.Evidence) { 4563 return false 4564 } 4565 if !this.Validator.Equal(that1.Validator) { 4566 return false 4567 } 4568 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4569 return false 4570 } 4571 return true 4572 } 4573 func (this *BlockParams) Equal(that interface{}) bool { 4574 if that == nil { 4575 return this == nil 4576 } 4577 4578 that1, ok := that.(*BlockParams) 4579 if !ok { 4580 that2, ok := that.(BlockParams) 4581 if ok { 4582 that1 = &that2 4583 } else { 4584 return false 4585 } 4586 } 4587 if that1 == nil { 4588 return this == nil 4589 } else if this == nil { 4590 return false 4591 } 4592 if this.MaxBytes != that1.MaxBytes { 4593 return false 4594 } 4595 if this.MaxGas != that1.MaxGas { 4596 return false 4597 } 4598 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4599 return false 4600 } 4601 return true 4602 } 4603 func (this *EvidenceParams) Equal(that interface{}) bool { 4604 if that == nil { 4605 return this == nil 4606 } 4607 4608 that1, ok := that.(*EvidenceParams) 4609 if !ok { 4610 that2, ok := that.(EvidenceParams) 4611 if ok { 4612 that1 = &that2 4613 } else { 4614 return false 4615 } 4616 } 4617 if that1 == nil { 4618 return this == nil 4619 } else if this == nil { 4620 return false 4621 } 4622 if this.MaxAge != that1.MaxAge { 4623 return false 4624 } 4625 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4626 return false 4627 } 4628 return true 4629 } 4630 func (this *ValidatorParams) Equal(that interface{}) bool { 4631 if that == nil { 4632 return this == nil 4633 } 4634 4635 that1, ok := that.(*ValidatorParams) 4636 if !ok { 4637 that2, ok := that.(ValidatorParams) 4638 if ok { 4639 that1 = &that2 4640 } else { 4641 return false 4642 } 4643 } 4644 if that1 == nil { 4645 return this == nil 4646 } else if this == nil { 4647 return false 4648 } 4649 if len(this.PubKeyTypes) != len(that1.PubKeyTypes) { 4650 return false 4651 } 4652 for i := range this.PubKeyTypes { 4653 if this.PubKeyTypes[i] != that1.PubKeyTypes[i] { 4654 return false 4655 } 4656 } 4657 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4658 return false 4659 } 4660 return true 4661 } 4662 func (this *LastCommitInfo) Equal(that interface{}) bool { 4663 if that == nil { 4664 return this == nil 4665 } 4666 4667 that1, ok := that.(*LastCommitInfo) 4668 if !ok { 4669 that2, ok := that.(LastCommitInfo) 4670 if ok { 4671 that1 = &that2 4672 } else { 4673 return false 4674 } 4675 } 4676 if that1 == nil { 4677 return this == nil 4678 } else if this == nil { 4679 return false 4680 } 4681 if this.Round != that1.Round { 4682 return false 4683 } 4684 if len(this.Votes) != len(that1.Votes) { 4685 return false 4686 } 4687 for i := range this.Votes { 4688 if !this.Votes[i].Equal(&that1.Votes[i]) { 4689 return false 4690 } 4691 } 4692 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4693 return false 4694 } 4695 return true 4696 } 4697 func (this *Event) Equal(that interface{}) bool { 4698 if that == nil { 4699 return this == nil 4700 } 4701 4702 that1, ok := that.(*Event) 4703 if !ok { 4704 that2, ok := that.(Event) 4705 if ok { 4706 that1 = &that2 4707 } else { 4708 return false 4709 } 4710 } 4711 if that1 == nil { 4712 return this == nil 4713 } else if this == nil { 4714 return false 4715 } 4716 if this.Type != that1.Type { 4717 return false 4718 } 4719 if len(this.Attributes) != len(that1.Attributes) { 4720 return false 4721 } 4722 for i := range this.Attributes { 4723 if !this.Attributes[i].Equal(&that1.Attributes[i]) { 4724 return false 4725 } 4726 } 4727 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4728 return false 4729 } 4730 return true 4731 } 4732 func (this *Header) Equal(that interface{}) bool { 4733 if that == nil { 4734 return this == nil 4735 } 4736 4737 that1, ok := that.(*Header) 4738 if !ok { 4739 that2, ok := that.(Header) 4740 if ok { 4741 that1 = &that2 4742 } else { 4743 return false 4744 } 4745 } 4746 if that1 == nil { 4747 return this == nil 4748 } else if this == nil { 4749 return false 4750 } 4751 if !this.Version.Equal(&that1.Version) { 4752 return false 4753 } 4754 if this.ChainID != that1.ChainID { 4755 return false 4756 } 4757 if this.Height != that1.Height { 4758 return false 4759 } 4760 if !this.Time.Equal(that1.Time) { 4761 return false 4762 } 4763 if this.NumTxs != that1.NumTxs { 4764 return false 4765 } 4766 if this.TotalTxs != that1.TotalTxs { 4767 return false 4768 } 4769 if !this.LastBlockId.Equal(&that1.LastBlockId) { 4770 return false 4771 } 4772 if !bytes.Equal(this.LastCommitHash, that1.LastCommitHash) { 4773 return false 4774 } 4775 if !bytes.Equal(this.DataHash, that1.DataHash) { 4776 return false 4777 } 4778 if !bytes.Equal(this.ValidatorsHash, that1.ValidatorsHash) { 4779 return false 4780 } 4781 if !bytes.Equal(this.NextValidatorsHash, that1.NextValidatorsHash) { 4782 return false 4783 } 4784 if !bytes.Equal(this.ConsensusHash, that1.ConsensusHash) { 4785 return false 4786 } 4787 if !bytes.Equal(this.AppHash, that1.AppHash) { 4788 return false 4789 } 4790 if !bytes.Equal(this.LastResultsHash, that1.LastResultsHash) { 4791 return false 4792 } 4793 if !bytes.Equal(this.EvidenceHash, that1.EvidenceHash) { 4794 return false 4795 } 4796 if !bytes.Equal(this.ProposerAddress, that1.ProposerAddress) { 4797 return false 4798 } 4799 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4800 return false 4801 } 4802 return true 4803 } 4804 func (this *Version) Equal(that interface{}) bool { 4805 if that == nil { 4806 return this == nil 4807 } 4808 4809 that1, ok := that.(*Version) 4810 if !ok { 4811 that2, ok := that.(Version) 4812 if ok { 4813 that1 = &that2 4814 } else { 4815 return false 4816 } 4817 } 4818 if that1 == nil { 4819 return this == nil 4820 } else if this == nil { 4821 return false 4822 } 4823 if this.Block != that1.Block { 4824 return false 4825 } 4826 if this.App != that1.App { 4827 return false 4828 } 4829 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4830 return false 4831 } 4832 return true 4833 } 4834 func (this *BlockID) Equal(that interface{}) bool { 4835 if that == nil { 4836 return this == nil 4837 } 4838 4839 that1, ok := that.(*BlockID) 4840 if !ok { 4841 that2, ok := that.(BlockID) 4842 if ok { 4843 that1 = &that2 4844 } else { 4845 return false 4846 } 4847 } 4848 if that1 == nil { 4849 return this == nil 4850 } else if this == nil { 4851 return false 4852 } 4853 if !bytes.Equal(this.Hash, that1.Hash) { 4854 return false 4855 } 4856 if !this.PartsHeader.Equal(&that1.PartsHeader) { 4857 return false 4858 } 4859 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4860 return false 4861 } 4862 return true 4863 } 4864 func (this *PartSetHeader) Equal(that interface{}) bool { 4865 if that == nil { 4866 return this == nil 4867 } 4868 4869 that1, ok := that.(*PartSetHeader) 4870 if !ok { 4871 that2, ok := that.(PartSetHeader) 4872 if ok { 4873 that1 = &that2 4874 } else { 4875 return false 4876 } 4877 } 4878 if that1 == nil { 4879 return this == nil 4880 } else if this == nil { 4881 return false 4882 } 4883 if this.Total != that1.Total { 4884 return false 4885 } 4886 if !bytes.Equal(this.Hash, that1.Hash) { 4887 return false 4888 } 4889 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4890 return false 4891 } 4892 return true 4893 } 4894 func (this *Validator) Equal(that interface{}) bool { 4895 if that == nil { 4896 return this == nil 4897 } 4898 4899 that1, ok := that.(*Validator) 4900 if !ok { 4901 that2, ok := that.(Validator) 4902 if ok { 4903 that1 = &that2 4904 } else { 4905 return false 4906 } 4907 } 4908 if that1 == nil { 4909 return this == nil 4910 } else if this == nil { 4911 return false 4912 } 4913 if !bytes.Equal(this.Address, that1.Address) { 4914 return false 4915 } 4916 if this.Power != that1.Power { 4917 return false 4918 } 4919 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4920 return false 4921 } 4922 return true 4923 } 4924 func (this *ValidatorUpdate) Equal(that interface{}) bool { 4925 if that == nil { 4926 return this == nil 4927 } 4928 4929 that1, ok := that.(*ValidatorUpdate) 4930 if !ok { 4931 that2, ok := that.(ValidatorUpdate) 4932 if ok { 4933 that1 = &that2 4934 } else { 4935 return false 4936 } 4937 } 4938 if that1 == nil { 4939 return this == nil 4940 } else if this == nil { 4941 return false 4942 } 4943 if !this.PubKey.Equal(&that1.PubKey) { 4944 return false 4945 } 4946 if this.Power != that1.Power { 4947 return false 4948 } 4949 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4950 return false 4951 } 4952 return true 4953 } 4954 func (this *VoteInfo) Equal(that interface{}) bool { 4955 if that == nil { 4956 return this == nil 4957 } 4958 4959 that1, ok := that.(*VoteInfo) 4960 if !ok { 4961 that2, ok := that.(VoteInfo) 4962 if ok { 4963 that1 = &that2 4964 } else { 4965 return false 4966 } 4967 } 4968 if that1 == nil { 4969 return this == nil 4970 } else if this == nil { 4971 return false 4972 } 4973 if !this.Validator.Equal(&that1.Validator) { 4974 return false 4975 } 4976 if this.SignedLastBlock != that1.SignedLastBlock { 4977 return false 4978 } 4979 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 4980 return false 4981 } 4982 return true 4983 } 4984 func (this *PubKey) Equal(that interface{}) bool { 4985 if that == nil { 4986 return this == nil 4987 } 4988 4989 that1, ok := that.(*PubKey) 4990 if !ok { 4991 that2, ok := that.(PubKey) 4992 if ok { 4993 that1 = &that2 4994 } else { 4995 return false 4996 } 4997 } 4998 if that1 == nil { 4999 return this == nil 5000 } else if this == nil { 5001 return false 5002 } 5003 if this.Type != that1.Type { 5004 return false 5005 } 5006 if !bytes.Equal(this.Data, that1.Data) { 5007 return false 5008 } 5009 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 5010 return false 5011 } 5012 return true 5013 } 5014 func (this *Evidence) Equal(that interface{}) bool { 5015 if that == nil { 5016 return this == nil 5017 } 5018 5019 that1, ok := that.(*Evidence) 5020 if !ok { 5021 that2, ok := that.(Evidence) 5022 if ok { 5023 that1 = &that2 5024 } else { 5025 return false 5026 } 5027 } 5028 if that1 == nil { 5029 return this == nil 5030 } else if this == nil { 5031 return false 5032 } 5033 if this.Type != that1.Type { 5034 return false 5035 } 5036 if !this.Validator.Equal(&that1.Validator) { 5037 return false 5038 } 5039 if this.Height != that1.Height { 5040 return false 5041 } 5042 if !this.Time.Equal(that1.Time) { 5043 return false 5044 } 5045 if this.TotalVotingPower != that1.TotalVotingPower { 5046 return false 5047 } 5048 if !bytes.Equal(this.XXX_unrecognized, that1.XXX_unrecognized) { 5049 return false 5050 } 5051 return true 5052 } 5053 5054 // Reference imports to suppress errors if they are not otherwise used. 5055 var _ context.Context 5056 var _ grpc.ClientConn 5057 5058 // This is a compile-time assertion to ensure that this generated file 5059 // is compatible with the grpc package it is being compiled against. 5060 const _ = grpc.SupportPackageIsVersion4 5061 5062 // ABCIApplicationClient is the client API for ABCIApplication service. 5063 // 5064 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 5065 type ABCIApplicationClient interface { 5066 Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) 5067 Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) 5068 Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) 5069 SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) 5070 DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) 5071 CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) 5072 Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) 5073 Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) 5074 InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) 5075 BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) 5076 EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) 5077 } 5078 5079 type aBCIApplicationClient struct { 5080 cc *grpc.ClientConn 5081 } 5082 5083 func NewABCIApplicationClient(cc *grpc.ClientConn) ABCIApplicationClient { 5084 return &aBCIApplicationClient{cc} 5085 } 5086 5087 func (c *aBCIApplicationClient) Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) { 5088 out := new(ResponseEcho) 5089 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/Echo", in, out, opts...) 5090 if err != nil { 5091 return nil, err 5092 } 5093 return out, nil 5094 } 5095 5096 func (c *aBCIApplicationClient) Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) { 5097 out := new(ResponseFlush) 5098 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/Flush", in, out, opts...) 5099 if err != nil { 5100 return nil, err 5101 } 5102 return out, nil 5103 } 5104 5105 func (c *aBCIApplicationClient) Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) { 5106 out := new(ResponseInfo) 5107 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/Info", in, out, opts...) 5108 if err != nil { 5109 return nil, err 5110 } 5111 return out, nil 5112 } 5113 5114 func (c *aBCIApplicationClient) SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) { 5115 out := new(ResponseSetOption) 5116 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/SetOption", in, out, opts...) 5117 if err != nil { 5118 return nil, err 5119 } 5120 return out, nil 5121 } 5122 5123 func (c *aBCIApplicationClient) DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) { 5124 out := new(ResponseDeliverTx) 5125 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/DeliverTx", in, out, opts...) 5126 if err != nil { 5127 return nil, err 5128 } 5129 return out, nil 5130 } 5131 5132 func (c *aBCIApplicationClient) CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) { 5133 out := new(ResponseCheckTx) 5134 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/CheckTx", in, out, opts...) 5135 if err != nil { 5136 return nil, err 5137 } 5138 return out, nil 5139 } 5140 5141 func (c *aBCIApplicationClient) Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) { 5142 out := new(ResponseQuery) 5143 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/Query", in, out, opts...) 5144 if err != nil { 5145 return nil, err 5146 } 5147 return out, nil 5148 } 5149 5150 func (c *aBCIApplicationClient) Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) { 5151 out := new(ResponseCommit) 5152 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/Commit", in, out, opts...) 5153 if err != nil { 5154 return nil, err 5155 } 5156 return out, nil 5157 } 5158 5159 func (c *aBCIApplicationClient) InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) { 5160 out := new(ResponseInitChain) 5161 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/InitChain", in, out, opts...) 5162 if err != nil { 5163 return nil, err 5164 } 5165 return out, nil 5166 } 5167 5168 func (c *aBCIApplicationClient) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) { 5169 out := new(ResponseBeginBlock) 5170 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/BeginBlock", in, out, opts...) 5171 if err != nil { 5172 return nil, err 5173 } 5174 return out, nil 5175 } 5176 5177 func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) { 5178 out := new(ResponseEndBlock) 5179 err := c.cc.Invoke(ctx, "/tendermint.abci.types.ABCIApplication/EndBlock", in, out, opts...) 5180 if err != nil { 5181 return nil, err 5182 } 5183 return out, nil 5184 } 5185 5186 // ABCIApplicationServer is the server API for ABCIApplication service. 5187 type ABCIApplicationServer interface { 5188 Echo(context.Context, *RequestEcho) (*ResponseEcho, error) 5189 Flush(context.Context, *RequestFlush) (*ResponseFlush, error) 5190 Info(context.Context, *RequestInfo) (*ResponseInfo, error) 5191 SetOption(context.Context, *RequestSetOption) (*ResponseSetOption, error) 5192 DeliverTx(context.Context, *RequestDeliverTx) (*ResponseDeliverTx, error) 5193 CheckTx(context.Context, *RequestCheckTx) (*ResponseCheckTx, error) 5194 Query(context.Context, *RequestQuery) (*ResponseQuery, error) 5195 Commit(context.Context, *RequestCommit) (*ResponseCommit, error) 5196 InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error) 5197 BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error) 5198 EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error) 5199 } 5200 5201 // UnimplementedABCIApplicationServer can be embedded to have forward compatible implementations. 5202 type UnimplementedABCIApplicationServer struct { 5203 } 5204 5205 func (*UnimplementedABCIApplicationServer) Echo(ctx context.Context, req *RequestEcho) (*ResponseEcho, error) { 5206 return nil, status.Errorf(codes.Unimplemented, "method Echo not implemented") 5207 } 5208 func (*UnimplementedABCIApplicationServer) Flush(ctx context.Context, req *RequestFlush) (*ResponseFlush, error) { 5209 return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented") 5210 } 5211 func (*UnimplementedABCIApplicationServer) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) { 5212 return nil, status.Errorf(codes.Unimplemented, "method Info not implemented") 5213 } 5214 func (*UnimplementedABCIApplicationServer) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) { 5215 return nil, status.Errorf(codes.Unimplemented, "method SetOption not implemented") 5216 } 5217 func (*UnimplementedABCIApplicationServer) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) { 5218 return nil, status.Errorf(codes.Unimplemented, "method DeliverTx not implemented") 5219 } 5220 func (*UnimplementedABCIApplicationServer) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) { 5221 return nil, status.Errorf(codes.Unimplemented, "method CheckTx not implemented") 5222 } 5223 func (*UnimplementedABCIApplicationServer) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) { 5224 return nil, status.Errorf(codes.Unimplemented, "method Query not implemented") 5225 } 5226 func (*UnimplementedABCIApplicationServer) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) { 5227 return nil, status.Errorf(codes.Unimplemented, "method Commit not implemented") 5228 } 5229 func (*UnimplementedABCIApplicationServer) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) { 5230 return nil, status.Errorf(codes.Unimplemented, "method InitChain not implemented") 5231 } 5232 func (*UnimplementedABCIApplicationServer) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) { 5233 return nil, status.Errorf(codes.Unimplemented, "method BeginBlock not implemented") 5234 } 5235 func (*UnimplementedABCIApplicationServer) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) { 5236 return nil, status.Errorf(codes.Unimplemented, "method EndBlock not implemented") 5237 } 5238 5239 func RegisterABCIApplicationServer(s *grpc.Server, srv ABCIApplicationServer) { 5240 s.RegisterService(&_ABCIApplication_serviceDesc, srv) 5241 } 5242 5243 func _ABCIApplication_Echo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5244 in := new(RequestEcho) 5245 if err := dec(in); err != nil { 5246 return nil, err 5247 } 5248 if interceptor == nil { 5249 return srv.(ABCIApplicationServer).Echo(ctx, in) 5250 } 5251 info := &grpc.UnaryServerInfo{ 5252 Server: srv, 5253 FullMethod: "/tendermint.abci.types.ABCIApplication/Echo", 5254 } 5255 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5256 return srv.(ABCIApplicationServer).Echo(ctx, req.(*RequestEcho)) 5257 } 5258 return interceptor(ctx, in, info, handler) 5259 } 5260 5261 func _ABCIApplication_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5262 in := new(RequestFlush) 5263 if err := dec(in); err != nil { 5264 return nil, err 5265 } 5266 if interceptor == nil { 5267 return srv.(ABCIApplicationServer).Flush(ctx, in) 5268 } 5269 info := &grpc.UnaryServerInfo{ 5270 Server: srv, 5271 FullMethod: "/tendermint.abci.types.ABCIApplication/Flush", 5272 } 5273 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5274 return srv.(ABCIApplicationServer).Flush(ctx, req.(*RequestFlush)) 5275 } 5276 return interceptor(ctx, in, info, handler) 5277 } 5278 5279 func _ABCIApplication_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5280 in := new(RequestInfo) 5281 if err := dec(in); err != nil { 5282 return nil, err 5283 } 5284 if interceptor == nil { 5285 return srv.(ABCIApplicationServer).Info(ctx, in) 5286 } 5287 info := &grpc.UnaryServerInfo{ 5288 Server: srv, 5289 FullMethod: "/tendermint.abci.types.ABCIApplication/Info", 5290 } 5291 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5292 return srv.(ABCIApplicationServer).Info(ctx, req.(*RequestInfo)) 5293 } 5294 return interceptor(ctx, in, info, handler) 5295 } 5296 5297 func _ABCIApplication_SetOption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5298 in := new(RequestSetOption) 5299 if err := dec(in); err != nil { 5300 return nil, err 5301 } 5302 if interceptor == nil { 5303 return srv.(ABCIApplicationServer).SetOption(ctx, in) 5304 } 5305 info := &grpc.UnaryServerInfo{ 5306 Server: srv, 5307 FullMethod: "/tendermint.abci.types.ABCIApplication/SetOption", 5308 } 5309 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5310 return srv.(ABCIApplicationServer).SetOption(ctx, req.(*RequestSetOption)) 5311 } 5312 return interceptor(ctx, in, info, handler) 5313 } 5314 5315 func _ABCIApplication_DeliverTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5316 in := new(RequestDeliverTx) 5317 if err := dec(in); err != nil { 5318 return nil, err 5319 } 5320 if interceptor == nil { 5321 return srv.(ABCIApplicationServer).DeliverTx(ctx, in) 5322 } 5323 info := &grpc.UnaryServerInfo{ 5324 Server: srv, 5325 FullMethod: "/tendermint.abci.types.ABCIApplication/DeliverTx", 5326 } 5327 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5328 return srv.(ABCIApplicationServer).DeliverTx(ctx, req.(*RequestDeliverTx)) 5329 } 5330 return interceptor(ctx, in, info, handler) 5331 } 5332 5333 func _ABCIApplication_CheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5334 in := new(RequestCheckTx) 5335 if err := dec(in); err != nil { 5336 return nil, err 5337 } 5338 if interceptor == nil { 5339 return srv.(ABCIApplicationServer).CheckTx(ctx, in) 5340 } 5341 info := &grpc.UnaryServerInfo{ 5342 Server: srv, 5343 FullMethod: "/tendermint.abci.types.ABCIApplication/CheckTx", 5344 } 5345 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5346 return srv.(ABCIApplicationServer).CheckTx(ctx, req.(*RequestCheckTx)) 5347 } 5348 return interceptor(ctx, in, info, handler) 5349 } 5350 5351 func _ABCIApplication_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5352 in := new(RequestQuery) 5353 if err := dec(in); err != nil { 5354 return nil, err 5355 } 5356 if interceptor == nil { 5357 return srv.(ABCIApplicationServer).Query(ctx, in) 5358 } 5359 info := &grpc.UnaryServerInfo{ 5360 Server: srv, 5361 FullMethod: "/tendermint.abci.types.ABCIApplication/Query", 5362 } 5363 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5364 return srv.(ABCIApplicationServer).Query(ctx, req.(*RequestQuery)) 5365 } 5366 return interceptor(ctx, in, info, handler) 5367 } 5368 5369 func _ABCIApplication_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5370 in := new(RequestCommit) 5371 if err := dec(in); err != nil { 5372 return nil, err 5373 } 5374 if interceptor == nil { 5375 return srv.(ABCIApplicationServer).Commit(ctx, in) 5376 } 5377 info := &grpc.UnaryServerInfo{ 5378 Server: srv, 5379 FullMethod: "/tendermint.abci.types.ABCIApplication/Commit", 5380 } 5381 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5382 return srv.(ABCIApplicationServer).Commit(ctx, req.(*RequestCommit)) 5383 } 5384 return interceptor(ctx, in, info, handler) 5385 } 5386 5387 func _ABCIApplication_InitChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5388 in := new(RequestInitChain) 5389 if err := dec(in); err != nil { 5390 return nil, err 5391 } 5392 if interceptor == nil { 5393 return srv.(ABCIApplicationServer).InitChain(ctx, in) 5394 } 5395 info := &grpc.UnaryServerInfo{ 5396 Server: srv, 5397 FullMethod: "/tendermint.abci.types.ABCIApplication/InitChain", 5398 } 5399 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5400 return srv.(ABCIApplicationServer).InitChain(ctx, req.(*RequestInitChain)) 5401 } 5402 return interceptor(ctx, in, info, handler) 5403 } 5404 5405 func _ABCIApplication_BeginBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5406 in := new(RequestBeginBlock) 5407 if err := dec(in); err != nil { 5408 return nil, err 5409 } 5410 if interceptor == nil { 5411 return srv.(ABCIApplicationServer).BeginBlock(ctx, in) 5412 } 5413 info := &grpc.UnaryServerInfo{ 5414 Server: srv, 5415 FullMethod: "/tendermint.abci.types.ABCIApplication/BeginBlock", 5416 } 5417 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5418 return srv.(ABCIApplicationServer).BeginBlock(ctx, req.(*RequestBeginBlock)) 5419 } 5420 return interceptor(ctx, in, info, handler) 5421 } 5422 5423 func _ABCIApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 5424 in := new(RequestEndBlock) 5425 if err := dec(in); err != nil { 5426 return nil, err 5427 } 5428 if interceptor == nil { 5429 return srv.(ABCIApplicationServer).EndBlock(ctx, in) 5430 } 5431 info := &grpc.UnaryServerInfo{ 5432 Server: srv, 5433 FullMethod: "/tendermint.abci.types.ABCIApplication/EndBlock", 5434 } 5435 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 5436 return srv.(ABCIApplicationServer).EndBlock(ctx, req.(*RequestEndBlock)) 5437 } 5438 return interceptor(ctx, in, info, handler) 5439 } 5440 5441 var _ABCIApplication_serviceDesc = grpc.ServiceDesc{ 5442 ServiceName: "tendermint.abci.types.ABCIApplication", 5443 HandlerType: (*ABCIApplicationServer)(nil), 5444 Methods: []grpc.MethodDesc{ 5445 { 5446 MethodName: "Echo", 5447 Handler: _ABCIApplication_Echo_Handler, 5448 }, 5449 { 5450 MethodName: "Flush", 5451 Handler: _ABCIApplication_Flush_Handler, 5452 }, 5453 { 5454 MethodName: "Info", 5455 Handler: _ABCIApplication_Info_Handler, 5456 }, 5457 { 5458 MethodName: "SetOption", 5459 Handler: _ABCIApplication_SetOption_Handler, 5460 }, 5461 { 5462 MethodName: "DeliverTx", 5463 Handler: _ABCIApplication_DeliverTx_Handler, 5464 }, 5465 { 5466 MethodName: "CheckTx", 5467 Handler: _ABCIApplication_CheckTx_Handler, 5468 }, 5469 { 5470 MethodName: "Query", 5471 Handler: _ABCIApplication_Query_Handler, 5472 }, 5473 { 5474 MethodName: "Commit", 5475 Handler: _ABCIApplication_Commit_Handler, 5476 }, 5477 { 5478 MethodName: "InitChain", 5479 Handler: _ABCIApplication_InitChain_Handler, 5480 }, 5481 { 5482 MethodName: "BeginBlock", 5483 Handler: _ABCIApplication_BeginBlock_Handler, 5484 }, 5485 { 5486 MethodName: "EndBlock", 5487 Handler: _ABCIApplication_EndBlock_Handler, 5488 }, 5489 }, 5490 Streams: []grpc.StreamDesc{}, 5491 Metadata: "abci/types/types.proto", 5492 } 5493 5494 func (m *Request) Marshal() (dAtA []byte, err error) { 5495 size := m.Size() 5496 dAtA = make([]byte, size) 5497 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5498 if err != nil { 5499 return nil, err 5500 } 5501 return dAtA[:n], nil 5502 } 5503 5504 func (m *Request) MarshalTo(dAtA []byte) (int, error) { 5505 size := m.Size() 5506 return m.MarshalToSizedBuffer(dAtA[:size]) 5507 } 5508 5509 func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5510 i := len(dAtA) 5511 _ = i 5512 var l int 5513 _ = l 5514 if m.XXX_unrecognized != nil { 5515 i -= len(m.XXX_unrecognized) 5516 copy(dAtA[i:], m.XXX_unrecognized) 5517 } 5518 if m.Value != nil { 5519 { 5520 size := m.Value.Size() 5521 i -= size 5522 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { 5523 return 0, err 5524 } 5525 } 5526 } 5527 return len(dAtA) - i, nil 5528 } 5529 5530 func (m *Request_Echo) MarshalTo(dAtA []byte) (int, error) { 5531 size := m.Size() 5532 return m.MarshalToSizedBuffer(dAtA[:size]) 5533 } 5534 5535 func (m *Request_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5536 i := len(dAtA) 5537 if m.Echo != nil { 5538 { 5539 size, err := m.Echo.MarshalToSizedBuffer(dAtA[:i]) 5540 if err != nil { 5541 return 0, err 5542 } 5543 i -= size 5544 i = encodeVarintTypes(dAtA, i, uint64(size)) 5545 } 5546 i-- 5547 dAtA[i] = 0x12 5548 } 5549 return len(dAtA) - i, nil 5550 } 5551 func (m *Request_Flush) MarshalTo(dAtA []byte) (int, error) { 5552 size := m.Size() 5553 return m.MarshalToSizedBuffer(dAtA[:size]) 5554 } 5555 5556 func (m *Request_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5557 i := len(dAtA) 5558 if m.Flush != nil { 5559 { 5560 size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i]) 5561 if err != nil { 5562 return 0, err 5563 } 5564 i -= size 5565 i = encodeVarintTypes(dAtA, i, uint64(size)) 5566 } 5567 i-- 5568 dAtA[i] = 0x1a 5569 } 5570 return len(dAtA) - i, nil 5571 } 5572 func (m *Request_Info) MarshalTo(dAtA []byte) (int, error) { 5573 size := m.Size() 5574 return m.MarshalToSizedBuffer(dAtA[:size]) 5575 } 5576 5577 func (m *Request_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5578 i := len(dAtA) 5579 if m.Info != nil { 5580 { 5581 size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) 5582 if err != nil { 5583 return 0, err 5584 } 5585 i -= size 5586 i = encodeVarintTypes(dAtA, i, uint64(size)) 5587 } 5588 i-- 5589 dAtA[i] = 0x22 5590 } 5591 return len(dAtA) - i, nil 5592 } 5593 func (m *Request_SetOption) MarshalTo(dAtA []byte) (int, error) { 5594 size := m.Size() 5595 return m.MarshalToSizedBuffer(dAtA[:size]) 5596 } 5597 5598 func (m *Request_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5599 i := len(dAtA) 5600 if m.SetOption != nil { 5601 { 5602 size, err := m.SetOption.MarshalToSizedBuffer(dAtA[:i]) 5603 if err != nil { 5604 return 0, err 5605 } 5606 i -= size 5607 i = encodeVarintTypes(dAtA, i, uint64(size)) 5608 } 5609 i-- 5610 dAtA[i] = 0x2a 5611 } 5612 return len(dAtA) - i, nil 5613 } 5614 func (m *Request_InitChain) MarshalTo(dAtA []byte) (int, error) { 5615 size := m.Size() 5616 return m.MarshalToSizedBuffer(dAtA[:size]) 5617 } 5618 5619 func (m *Request_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5620 i := len(dAtA) 5621 if m.InitChain != nil { 5622 { 5623 size, err := m.InitChain.MarshalToSizedBuffer(dAtA[:i]) 5624 if err != nil { 5625 return 0, err 5626 } 5627 i -= size 5628 i = encodeVarintTypes(dAtA, i, uint64(size)) 5629 } 5630 i-- 5631 dAtA[i] = 0x32 5632 } 5633 return len(dAtA) - i, nil 5634 } 5635 func (m *Request_Query) MarshalTo(dAtA []byte) (int, error) { 5636 size := m.Size() 5637 return m.MarshalToSizedBuffer(dAtA[:size]) 5638 } 5639 5640 func (m *Request_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5641 i := len(dAtA) 5642 if m.Query != nil { 5643 { 5644 size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) 5645 if err != nil { 5646 return 0, err 5647 } 5648 i -= size 5649 i = encodeVarintTypes(dAtA, i, uint64(size)) 5650 } 5651 i-- 5652 dAtA[i] = 0x3a 5653 } 5654 return len(dAtA) - i, nil 5655 } 5656 func (m *Request_BeginBlock) MarshalTo(dAtA []byte) (int, error) { 5657 size := m.Size() 5658 return m.MarshalToSizedBuffer(dAtA[:size]) 5659 } 5660 5661 func (m *Request_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5662 i := len(dAtA) 5663 if m.BeginBlock != nil { 5664 { 5665 size, err := m.BeginBlock.MarshalToSizedBuffer(dAtA[:i]) 5666 if err != nil { 5667 return 0, err 5668 } 5669 i -= size 5670 i = encodeVarintTypes(dAtA, i, uint64(size)) 5671 } 5672 i-- 5673 dAtA[i] = 0x42 5674 } 5675 return len(dAtA) - i, nil 5676 } 5677 func (m *Request_CheckTx) MarshalTo(dAtA []byte) (int, error) { 5678 size := m.Size() 5679 return m.MarshalToSizedBuffer(dAtA[:size]) 5680 } 5681 5682 func (m *Request_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5683 i := len(dAtA) 5684 if m.CheckTx != nil { 5685 { 5686 size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i]) 5687 if err != nil { 5688 return 0, err 5689 } 5690 i -= size 5691 i = encodeVarintTypes(dAtA, i, uint64(size)) 5692 } 5693 i-- 5694 dAtA[i] = 0x4a 5695 } 5696 return len(dAtA) - i, nil 5697 } 5698 func (m *Request_EndBlock) MarshalTo(dAtA []byte) (int, error) { 5699 size := m.Size() 5700 return m.MarshalToSizedBuffer(dAtA[:size]) 5701 } 5702 5703 func (m *Request_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5704 i := len(dAtA) 5705 if m.EndBlock != nil { 5706 { 5707 size, err := m.EndBlock.MarshalToSizedBuffer(dAtA[:i]) 5708 if err != nil { 5709 return 0, err 5710 } 5711 i -= size 5712 i = encodeVarintTypes(dAtA, i, uint64(size)) 5713 } 5714 i-- 5715 dAtA[i] = 0x5a 5716 } 5717 return len(dAtA) - i, nil 5718 } 5719 func (m *Request_Commit) MarshalTo(dAtA []byte) (int, error) { 5720 size := m.Size() 5721 return m.MarshalToSizedBuffer(dAtA[:size]) 5722 } 5723 5724 func (m *Request_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5725 i := len(dAtA) 5726 if m.Commit != nil { 5727 { 5728 size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) 5729 if err != nil { 5730 return 0, err 5731 } 5732 i -= size 5733 i = encodeVarintTypes(dAtA, i, uint64(size)) 5734 } 5735 i-- 5736 dAtA[i] = 0x62 5737 } 5738 return len(dAtA) - i, nil 5739 } 5740 func (m *Request_DeliverTx) MarshalTo(dAtA []byte) (int, error) { 5741 size := m.Size() 5742 return m.MarshalToSizedBuffer(dAtA[:size]) 5743 } 5744 5745 func (m *Request_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5746 i := len(dAtA) 5747 if m.DeliverTx != nil { 5748 { 5749 size, err := m.DeliverTx.MarshalToSizedBuffer(dAtA[:i]) 5750 if err != nil { 5751 return 0, err 5752 } 5753 i -= size 5754 i = encodeVarintTypes(dAtA, i, uint64(size)) 5755 } 5756 i-- 5757 dAtA[i] = 0x1 5758 i-- 5759 dAtA[i] = 0x9a 5760 } 5761 return len(dAtA) - i, nil 5762 } 5763 func (m *RequestEcho) Marshal() (dAtA []byte, err error) { 5764 size := m.Size() 5765 dAtA = make([]byte, size) 5766 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5767 if err != nil { 5768 return nil, err 5769 } 5770 return dAtA[:n], nil 5771 } 5772 5773 func (m *RequestEcho) MarshalTo(dAtA []byte) (int, error) { 5774 size := m.Size() 5775 return m.MarshalToSizedBuffer(dAtA[:size]) 5776 } 5777 5778 func (m *RequestEcho) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5779 i := len(dAtA) 5780 _ = i 5781 var l int 5782 _ = l 5783 if m.XXX_unrecognized != nil { 5784 i -= len(m.XXX_unrecognized) 5785 copy(dAtA[i:], m.XXX_unrecognized) 5786 } 5787 if len(m.Message) > 0 { 5788 i -= len(m.Message) 5789 copy(dAtA[i:], m.Message) 5790 i = encodeVarintTypes(dAtA, i, uint64(len(m.Message))) 5791 i-- 5792 dAtA[i] = 0xa 5793 } 5794 return len(dAtA) - i, nil 5795 } 5796 5797 func (m *RequestFlush) Marshal() (dAtA []byte, err error) { 5798 size := m.Size() 5799 dAtA = make([]byte, size) 5800 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5801 if err != nil { 5802 return nil, err 5803 } 5804 return dAtA[:n], nil 5805 } 5806 5807 func (m *RequestFlush) MarshalTo(dAtA []byte) (int, error) { 5808 size := m.Size() 5809 return m.MarshalToSizedBuffer(dAtA[:size]) 5810 } 5811 5812 func (m *RequestFlush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5813 i := len(dAtA) 5814 _ = i 5815 var l int 5816 _ = l 5817 if m.XXX_unrecognized != nil { 5818 i -= len(m.XXX_unrecognized) 5819 copy(dAtA[i:], m.XXX_unrecognized) 5820 } 5821 return len(dAtA) - i, nil 5822 } 5823 5824 func (m *RequestInfo) Marshal() (dAtA []byte, err error) { 5825 size := m.Size() 5826 dAtA = make([]byte, size) 5827 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5828 if err != nil { 5829 return nil, err 5830 } 5831 return dAtA[:n], nil 5832 } 5833 5834 func (m *RequestInfo) MarshalTo(dAtA []byte) (int, error) { 5835 size := m.Size() 5836 return m.MarshalToSizedBuffer(dAtA[:size]) 5837 } 5838 5839 func (m *RequestInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5840 i := len(dAtA) 5841 _ = i 5842 var l int 5843 _ = l 5844 if m.XXX_unrecognized != nil { 5845 i -= len(m.XXX_unrecognized) 5846 copy(dAtA[i:], m.XXX_unrecognized) 5847 } 5848 if m.P2PVersion != 0 { 5849 i = encodeVarintTypes(dAtA, i, uint64(m.P2PVersion)) 5850 i-- 5851 dAtA[i] = 0x18 5852 } 5853 if m.BlockVersion != 0 { 5854 i = encodeVarintTypes(dAtA, i, uint64(m.BlockVersion)) 5855 i-- 5856 dAtA[i] = 0x10 5857 } 5858 if len(m.Version) > 0 { 5859 i -= len(m.Version) 5860 copy(dAtA[i:], m.Version) 5861 i = encodeVarintTypes(dAtA, i, uint64(len(m.Version))) 5862 i-- 5863 dAtA[i] = 0xa 5864 } 5865 return len(dAtA) - i, nil 5866 } 5867 5868 func (m *RequestSetOption) Marshal() (dAtA []byte, err error) { 5869 size := m.Size() 5870 dAtA = make([]byte, size) 5871 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5872 if err != nil { 5873 return nil, err 5874 } 5875 return dAtA[:n], nil 5876 } 5877 5878 func (m *RequestSetOption) MarshalTo(dAtA []byte) (int, error) { 5879 size := m.Size() 5880 return m.MarshalToSizedBuffer(dAtA[:size]) 5881 } 5882 5883 func (m *RequestSetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5884 i := len(dAtA) 5885 _ = i 5886 var l int 5887 _ = l 5888 if m.XXX_unrecognized != nil { 5889 i -= len(m.XXX_unrecognized) 5890 copy(dAtA[i:], m.XXX_unrecognized) 5891 } 5892 if len(m.Value) > 0 { 5893 i -= len(m.Value) 5894 copy(dAtA[i:], m.Value) 5895 i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) 5896 i-- 5897 dAtA[i] = 0x12 5898 } 5899 if len(m.Key) > 0 { 5900 i -= len(m.Key) 5901 copy(dAtA[i:], m.Key) 5902 i = encodeVarintTypes(dAtA, i, uint64(len(m.Key))) 5903 i-- 5904 dAtA[i] = 0xa 5905 } 5906 return len(dAtA) - i, nil 5907 } 5908 5909 func (m *RequestInitChain) Marshal() (dAtA []byte, err error) { 5910 size := m.Size() 5911 dAtA = make([]byte, size) 5912 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5913 if err != nil { 5914 return nil, err 5915 } 5916 return dAtA[:n], nil 5917 } 5918 5919 func (m *RequestInitChain) MarshalTo(dAtA []byte) (int, error) { 5920 size := m.Size() 5921 return m.MarshalToSizedBuffer(dAtA[:size]) 5922 } 5923 5924 func (m *RequestInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5925 i := len(dAtA) 5926 _ = i 5927 var l int 5928 _ = l 5929 if m.XXX_unrecognized != nil { 5930 i -= len(m.XXX_unrecognized) 5931 copy(dAtA[i:], m.XXX_unrecognized) 5932 } 5933 if len(m.AppStateBytes) > 0 { 5934 i -= len(m.AppStateBytes) 5935 copy(dAtA[i:], m.AppStateBytes) 5936 i = encodeVarintTypes(dAtA, i, uint64(len(m.AppStateBytes))) 5937 i-- 5938 dAtA[i] = 0x2a 5939 } 5940 if len(m.Validators) > 0 { 5941 for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { 5942 { 5943 size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5944 if err != nil { 5945 return 0, err 5946 } 5947 i -= size 5948 i = encodeVarintTypes(dAtA, i, uint64(size)) 5949 } 5950 i-- 5951 dAtA[i] = 0x22 5952 } 5953 } 5954 if m.ConsensusParams != nil { 5955 { 5956 size, err := m.ConsensusParams.MarshalToSizedBuffer(dAtA[:i]) 5957 if err != nil { 5958 return 0, err 5959 } 5960 i -= size 5961 i = encodeVarintTypes(dAtA, i, uint64(size)) 5962 } 5963 i-- 5964 dAtA[i] = 0x1a 5965 } 5966 if len(m.ChainId) > 0 { 5967 i -= len(m.ChainId) 5968 copy(dAtA[i:], m.ChainId) 5969 i = encodeVarintTypes(dAtA, i, uint64(len(m.ChainId))) 5970 i-- 5971 dAtA[i] = 0x12 5972 } 5973 n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) 5974 if err13 != nil { 5975 return 0, err13 5976 } 5977 i -= n13 5978 i = encodeVarintTypes(dAtA, i, uint64(n13)) 5979 i-- 5980 dAtA[i] = 0xa 5981 return len(dAtA) - i, nil 5982 } 5983 5984 func (m *RequestQuery) Marshal() (dAtA []byte, err error) { 5985 size := m.Size() 5986 dAtA = make([]byte, size) 5987 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5988 if err != nil { 5989 return nil, err 5990 } 5991 return dAtA[:n], nil 5992 } 5993 5994 func (m *RequestQuery) MarshalTo(dAtA []byte) (int, error) { 5995 size := m.Size() 5996 return m.MarshalToSizedBuffer(dAtA[:size]) 5997 } 5998 5999 func (m *RequestQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6000 i := len(dAtA) 6001 _ = i 6002 var l int 6003 _ = l 6004 if m.XXX_unrecognized != nil { 6005 i -= len(m.XXX_unrecognized) 6006 copy(dAtA[i:], m.XXX_unrecognized) 6007 } 6008 if m.Prove { 6009 i-- 6010 if m.Prove { 6011 dAtA[i] = 1 6012 } else { 6013 dAtA[i] = 0 6014 } 6015 i-- 6016 dAtA[i] = 0x20 6017 } 6018 if m.Height != 0 { 6019 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 6020 i-- 6021 dAtA[i] = 0x18 6022 } 6023 if len(m.Path) > 0 { 6024 i -= len(m.Path) 6025 copy(dAtA[i:], m.Path) 6026 i = encodeVarintTypes(dAtA, i, uint64(len(m.Path))) 6027 i-- 6028 dAtA[i] = 0x12 6029 } 6030 if len(m.Data) > 0 { 6031 i -= len(m.Data) 6032 copy(dAtA[i:], m.Data) 6033 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 6034 i-- 6035 dAtA[i] = 0xa 6036 } 6037 return len(dAtA) - i, nil 6038 } 6039 6040 func (m *RequestBeginBlock) Marshal() (dAtA []byte, err error) { 6041 size := m.Size() 6042 dAtA = make([]byte, size) 6043 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6044 if err != nil { 6045 return nil, err 6046 } 6047 return dAtA[:n], nil 6048 } 6049 6050 func (m *RequestBeginBlock) MarshalTo(dAtA []byte) (int, error) { 6051 size := m.Size() 6052 return m.MarshalToSizedBuffer(dAtA[:size]) 6053 } 6054 6055 func (m *RequestBeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6056 i := len(dAtA) 6057 _ = i 6058 var l int 6059 _ = l 6060 if m.XXX_unrecognized != nil { 6061 i -= len(m.XXX_unrecognized) 6062 copy(dAtA[i:], m.XXX_unrecognized) 6063 } 6064 if len(m.ByzantineValidators) > 0 { 6065 for iNdEx := len(m.ByzantineValidators) - 1; iNdEx >= 0; iNdEx-- { 6066 { 6067 size, err := m.ByzantineValidators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 6068 if err != nil { 6069 return 0, err 6070 } 6071 i -= size 6072 i = encodeVarintTypes(dAtA, i, uint64(size)) 6073 } 6074 i-- 6075 dAtA[i] = 0x22 6076 } 6077 } 6078 { 6079 size, err := m.LastCommitInfo.MarshalToSizedBuffer(dAtA[:i]) 6080 if err != nil { 6081 return 0, err 6082 } 6083 i -= size 6084 i = encodeVarintTypes(dAtA, i, uint64(size)) 6085 } 6086 i-- 6087 dAtA[i] = 0x1a 6088 { 6089 size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) 6090 if err != nil { 6091 return 0, err 6092 } 6093 i -= size 6094 i = encodeVarintTypes(dAtA, i, uint64(size)) 6095 } 6096 i-- 6097 dAtA[i] = 0x12 6098 if len(m.Hash) > 0 { 6099 i -= len(m.Hash) 6100 copy(dAtA[i:], m.Hash) 6101 i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) 6102 i-- 6103 dAtA[i] = 0xa 6104 } 6105 return len(dAtA) - i, nil 6106 } 6107 6108 func (m *RequestCheckTx) Marshal() (dAtA []byte, err error) { 6109 size := m.Size() 6110 dAtA = make([]byte, size) 6111 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6112 if err != nil { 6113 return nil, err 6114 } 6115 return dAtA[:n], nil 6116 } 6117 6118 func (m *RequestCheckTx) MarshalTo(dAtA []byte) (int, error) { 6119 size := m.Size() 6120 return m.MarshalToSizedBuffer(dAtA[:size]) 6121 } 6122 6123 func (m *RequestCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6124 i := len(dAtA) 6125 _ = i 6126 var l int 6127 _ = l 6128 if m.XXX_unrecognized != nil { 6129 i -= len(m.XXX_unrecognized) 6130 copy(dAtA[i:], m.XXX_unrecognized) 6131 } 6132 if m.Type != 0 { 6133 i = encodeVarintTypes(dAtA, i, uint64(m.Type)) 6134 i-- 6135 dAtA[i] = 0x10 6136 } 6137 if len(m.Tx) > 0 { 6138 i -= len(m.Tx) 6139 copy(dAtA[i:], m.Tx) 6140 i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) 6141 i-- 6142 dAtA[i] = 0xa 6143 } 6144 return len(dAtA) - i, nil 6145 } 6146 6147 func (m *RequestDeliverTx) Marshal() (dAtA []byte, err error) { 6148 size := m.Size() 6149 dAtA = make([]byte, size) 6150 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6151 if err != nil { 6152 return nil, err 6153 } 6154 return dAtA[:n], nil 6155 } 6156 6157 func (m *RequestDeliverTx) MarshalTo(dAtA []byte) (int, error) { 6158 size := m.Size() 6159 return m.MarshalToSizedBuffer(dAtA[:size]) 6160 } 6161 6162 func (m *RequestDeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6163 i := len(dAtA) 6164 _ = i 6165 var l int 6166 _ = l 6167 if m.XXX_unrecognized != nil { 6168 i -= len(m.XXX_unrecognized) 6169 copy(dAtA[i:], m.XXX_unrecognized) 6170 } 6171 if len(m.Tx) > 0 { 6172 i -= len(m.Tx) 6173 copy(dAtA[i:], m.Tx) 6174 i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) 6175 i-- 6176 dAtA[i] = 0xa 6177 } 6178 return len(dAtA) - i, nil 6179 } 6180 6181 func (m *RequestEndBlock) Marshal() (dAtA []byte, err error) { 6182 size := m.Size() 6183 dAtA = make([]byte, size) 6184 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6185 if err != nil { 6186 return nil, err 6187 } 6188 return dAtA[:n], nil 6189 } 6190 6191 func (m *RequestEndBlock) MarshalTo(dAtA []byte) (int, error) { 6192 size := m.Size() 6193 return m.MarshalToSizedBuffer(dAtA[:size]) 6194 } 6195 6196 func (m *RequestEndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6197 i := len(dAtA) 6198 _ = i 6199 var l int 6200 _ = l 6201 if m.XXX_unrecognized != nil { 6202 i -= len(m.XXX_unrecognized) 6203 copy(dAtA[i:], m.XXX_unrecognized) 6204 } 6205 if m.Height != 0 { 6206 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 6207 i-- 6208 dAtA[i] = 0x8 6209 } 6210 return len(dAtA) - i, nil 6211 } 6212 6213 func (m *RequestCommit) Marshal() (dAtA []byte, err error) { 6214 size := m.Size() 6215 dAtA = make([]byte, size) 6216 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6217 if err != nil { 6218 return nil, err 6219 } 6220 return dAtA[:n], nil 6221 } 6222 6223 func (m *RequestCommit) MarshalTo(dAtA []byte) (int, error) { 6224 size := m.Size() 6225 return m.MarshalToSizedBuffer(dAtA[:size]) 6226 } 6227 6228 func (m *RequestCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6229 i := len(dAtA) 6230 _ = i 6231 var l int 6232 _ = l 6233 if m.XXX_unrecognized != nil { 6234 i -= len(m.XXX_unrecognized) 6235 copy(dAtA[i:], m.XXX_unrecognized) 6236 } 6237 return len(dAtA) - i, nil 6238 } 6239 6240 func (m *Response) Marshal() (dAtA []byte, err error) { 6241 size := m.Size() 6242 dAtA = make([]byte, size) 6243 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6244 if err != nil { 6245 return nil, err 6246 } 6247 return dAtA[:n], nil 6248 } 6249 6250 func (m *Response) MarshalTo(dAtA []byte) (int, error) { 6251 size := m.Size() 6252 return m.MarshalToSizedBuffer(dAtA[:size]) 6253 } 6254 6255 func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6256 i := len(dAtA) 6257 _ = i 6258 var l int 6259 _ = l 6260 if m.XXX_unrecognized != nil { 6261 i -= len(m.XXX_unrecognized) 6262 copy(dAtA[i:], m.XXX_unrecognized) 6263 } 6264 if m.Value != nil { 6265 { 6266 size := m.Value.Size() 6267 i -= size 6268 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { 6269 return 0, err 6270 } 6271 } 6272 } 6273 return len(dAtA) - i, nil 6274 } 6275 6276 func (m *Response_Exception) MarshalTo(dAtA []byte) (int, error) { 6277 size := m.Size() 6278 return m.MarshalToSizedBuffer(dAtA[:size]) 6279 } 6280 6281 func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6282 i := len(dAtA) 6283 if m.Exception != nil { 6284 { 6285 size, err := m.Exception.MarshalToSizedBuffer(dAtA[:i]) 6286 if err != nil { 6287 return 0, err 6288 } 6289 i -= size 6290 i = encodeVarintTypes(dAtA, i, uint64(size)) 6291 } 6292 i-- 6293 dAtA[i] = 0xa 6294 } 6295 return len(dAtA) - i, nil 6296 } 6297 func (m *Response_Echo) MarshalTo(dAtA []byte) (int, error) { 6298 size := m.Size() 6299 return m.MarshalToSizedBuffer(dAtA[:size]) 6300 } 6301 6302 func (m *Response_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6303 i := len(dAtA) 6304 if m.Echo != nil { 6305 { 6306 size, err := m.Echo.MarshalToSizedBuffer(dAtA[:i]) 6307 if err != nil { 6308 return 0, err 6309 } 6310 i -= size 6311 i = encodeVarintTypes(dAtA, i, uint64(size)) 6312 } 6313 i-- 6314 dAtA[i] = 0x12 6315 } 6316 return len(dAtA) - i, nil 6317 } 6318 func (m *Response_Flush) MarshalTo(dAtA []byte) (int, error) { 6319 size := m.Size() 6320 return m.MarshalToSizedBuffer(dAtA[:size]) 6321 } 6322 6323 func (m *Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6324 i := len(dAtA) 6325 if m.Flush != nil { 6326 { 6327 size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i]) 6328 if err != nil { 6329 return 0, err 6330 } 6331 i -= size 6332 i = encodeVarintTypes(dAtA, i, uint64(size)) 6333 } 6334 i-- 6335 dAtA[i] = 0x1a 6336 } 6337 return len(dAtA) - i, nil 6338 } 6339 func (m *Response_Info) MarshalTo(dAtA []byte) (int, error) { 6340 size := m.Size() 6341 return m.MarshalToSizedBuffer(dAtA[:size]) 6342 } 6343 6344 func (m *Response_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6345 i := len(dAtA) 6346 if m.Info != nil { 6347 { 6348 size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) 6349 if err != nil { 6350 return 0, err 6351 } 6352 i -= size 6353 i = encodeVarintTypes(dAtA, i, uint64(size)) 6354 } 6355 i-- 6356 dAtA[i] = 0x22 6357 } 6358 return len(dAtA) - i, nil 6359 } 6360 func (m *Response_SetOption) MarshalTo(dAtA []byte) (int, error) { 6361 size := m.Size() 6362 return m.MarshalToSizedBuffer(dAtA[:size]) 6363 } 6364 6365 func (m *Response_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6366 i := len(dAtA) 6367 if m.SetOption != nil { 6368 { 6369 size, err := m.SetOption.MarshalToSizedBuffer(dAtA[:i]) 6370 if err != nil { 6371 return 0, err 6372 } 6373 i -= size 6374 i = encodeVarintTypes(dAtA, i, uint64(size)) 6375 } 6376 i-- 6377 dAtA[i] = 0x2a 6378 } 6379 return len(dAtA) - i, nil 6380 } 6381 func (m *Response_InitChain) MarshalTo(dAtA []byte) (int, error) { 6382 size := m.Size() 6383 return m.MarshalToSizedBuffer(dAtA[:size]) 6384 } 6385 6386 func (m *Response_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6387 i := len(dAtA) 6388 if m.InitChain != nil { 6389 { 6390 size, err := m.InitChain.MarshalToSizedBuffer(dAtA[:i]) 6391 if err != nil { 6392 return 0, err 6393 } 6394 i -= size 6395 i = encodeVarintTypes(dAtA, i, uint64(size)) 6396 } 6397 i-- 6398 dAtA[i] = 0x32 6399 } 6400 return len(dAtA) - i, nil 6401 } 6402 func (m *Response_Query) MarshalTo(dAtA []byte) (int, error) { 6403 size := m.Size() 6404 return m.MarshalToSizedBuffer(dAtA[:size]) 6405 } 6406 6407 func (m *Response_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6408 i := len(dAtA) 6409 if m.Query != nil { 6410 { 6411 size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) 6412 if err != nil { 6413 return 0, err 6414 } 6415 i -= size 6416 i = encodeVarintTypes(dAtA, i, uint64(size)) 6417 } 6418 i-- 6419 dAtA[i] = 0x3a 6420 } 6421 return len(dAtA) - i, nil 6422 } 6423 func (m *Response_BeginBlock) MarshalTo(dAtA []byte) (int, error) { 6424 size := m.Size() 6425 return m.MarshalToSizedBuffer(dAtA[:size]) 6426 } 6427 6428 func (m *Response_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6429 i := len(dAtA) 6430 if m.BeginBlock != nil { 6431 { 6432 size, err := m.BeginBlock.MarshalToSizedBuffer(dAtA[:i]) 6433 if err != nil { 6434 return 0, err 6435 } 6436 i -= size 6437 i = encodeVarintTypes(dAtA, i, uint64(size)) 6438 } 6439 i-- 6440 dAtA[i] = 0x42 6441 } 6442 return len(dAtA) - i, nil 6443 } 6444 func (m *Response_CheckTx) MarshalTo(dAtA []byte) (int, error) { 6445 size := m.Size() 6446 return m.MarshalToSizedBuffer(dAtA[:size]) 6447 } 6448 6449 func (m *Response_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6450 i := len(dAtA) 6451 if m.CheckTx != nil { 6452 { 6453 size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i]) 6454 if err != nil { 6455 return 0, err 6456 } 6457 i -= size 6458 i = encodeVarintTypes(dAtA, i, uint64(size)) 6459 } 6460 i-- 6461 dAtA[i] = 0x4a 6462 } 6463 return len(dAtA) - i, nil 6464 } 6465 func (m *Response_DeliverTx) MarshalTo(dAtA []byte) (int, error) { 6466 size := m.Size() 6467 return m.MarshalToSizedBuffer(dAtA[:size]) 6468 } 6469 6470 func (m *Response_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6471 i := len(dAtA) 6472 if m.DeliverTx != nil { 6473 { 6474 size, err := m.DeliverTx.MarshalToSizedBuffer(dAtA[:i]) 6475 if err != nil { 6476 return 0, err 6477 } 6478 i -= size 6479 i = encodeVarintTypes(dAtA, i, uint64(size)) 6480 } 6481 i-- 6482 dAtA[i] = 0x52 6483 } 6484 return len(dAtA) - i, nil 6485 } 6486 func (m *Response_EndBlock) MarshalTo(dAtA []byte) (int, error) { 6487 size := m.Size() 6488 return m.MarshalToSizedBuffer(dAtA[:size]) 6489 } 6490 6491 func (m *Response_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6492 i := len(dAtA) 6493 if m.EndBlock != nil { 6494 { 6495 size, err := m.EndBlock.MarshalToSizedBuffer(dAtA[:i]) 6496 if err != nil { 6497 return 0, err 6498 } 6499 i -= size 6500 i = encodeVarintTypes(dAtA, i, uint64(size)) 6501 } 6502 i-- 6503 dAtA[i] = 0x5a 6504 } 6505 return len(dAtA) - i, nil 6506 } 6507 func (m *Response_Commit) MarshalTo(dAtA []byte) (int, error) { 6508 size := m.Size() 6509 return m.MarshalToSizedBuffer(dAtA[:size]) 6510 } 6511 6512 func (m *Response_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6513 i := len(dAtA) 6514 if m.Commit != nil { 6515 { 6516 size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) 6517 if err != nil { 6518 return 0, err 6519 } 6520 i -= size 6521 i = encodeVarintTypes(dAtA, i, uint64(size)) 6522 } 6523 i-- 6524 dAtA[i] = 0x62 6525 } 6526 return len(dAtA) - i, nil 6527 } 6528 func (m *ResponseException) Marshal() (dAtA []byte, err error) { 6529 size := m.Size() 6530 dAtA = make([]byte, size) 6531 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6532 if err != nil { 6533 return nil, err 6534 } 6535 return dAtA[:n], nil 6536 } 6537 6538 func (m *ResponseException) MarshalTo(dAtA []byte) (int, error) { 6539 size := m.Size() 6540 return m.MarshalToSizedBuffer(dAtA[:size]) 6541 } 6542 6543 func (m *ResponseException) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6544 i := len(dAtA) 6545 _ = i 6546 var l int 6547 _ = l 6548 if m.XXX_unrecognized != nil { 6549 i -= len(m.XXX_unrecognized) 6550 copy(dAtA[i:], m.XXX_unrecognized) 6551 } 6552 if len(m.Error) > 0 { 6553 i -= len(m.Error) 6554 copy(dAtA[i:], m.Error) 6555 i = encodeVarintTypes(dAtA, i, uint64(len(m.Error))) 6556 i-- 6557 dAtA[i] = 0xa 6558 } 6559 return len(dAtA) - i, nil 6560 } 6561 6562 func (m *ResponseEcho) Marshal() (dAtA []byte, err error) { 6563 size := m.Size() 6564 dAtA = make([]byte, size) 6565 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6566 if err != nil { 6567 return nil, err 6568 } 6569 return dAtA[:n], nil 6570 } 6571 6572 func (m *ResponseEcho) MarshalTo(dAtA []byte) (int, error) { 6573 size := m.Size() 6574 return m.MarshalToSizedBuffer(dAtA[:size]) 6575 } 6576 6577 func (m *ResponseEcho) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6578 i := len(dAtA) 6579 _ = i 6580 var l int 6581 _ = l 6582 if m.XXX_unrecognized != nil { 6583 i -= len(m.XXX_unrecognized) 6584 copy(dAtA[i:], m.XXX_unrecognized) 6585 } 6586 if len(m.Message) > 0 { 6587 i -= len(m.Message) 6588 copy(dAtA[i:], m.Message) 6589 i = encodeVarintTypes(dAtA, i, uint64(len(m.Message))) 6590 i-- 6591 dAtA[i] = 0xa 6592 } 6593 return len(dAtA) - i, nil 6594 } 6595 6596 func (m *ResponseFlush) Marshal() (dAtA []byte, err error) { 6597 size := m.Size() 6598 dAtA = make([]byte, size) 6599 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6600 if err != nil { 6601 return nil, err 6602 } 6603 return dAtA[:n], nil 6604 } 6605 6606 func (m *ResponseFlush) MarshalTo(dAtA []byte) (int, error) { 6607 size := m.Size() 6608 return m.MarshalToSizedBuffer(dAtA[:size]) 6609 } 6610 6611 func (m *ResponseFlush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6612 i := len(dAtA) 6613 _ = i 6614 var l int 6615 _ = l 6616 if m.XXX_unrecognized != nil { 6617 i -= len(m.XXX_unrecognized) 6618 copy(dAtA[i:], m.XXX_unrecognized) 6619 } 6620 return len(dAtA) - i, nil 6621 } 6622 6623 func (m *ResponseInfo) Marshal() (dAtA []byte, err error) { 6624 size := m.Size() 6625 dAtA = make([]byte, size) 6626 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6627 if err != nil { 6628 return nil, err 6629 } 6630 return dAtA[:n], nil 6631 } 6632 6633 func (m *ResponseInfo) MarshalTo(dAtA []byte) (int, error) { 6634 size := m.Size() 6635 return m.MarshalToSizedBuffer(dAtA[:size]) 6636 } 6637 6638 func (m *ResponseInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6639 i := len(dAtA) 6640 _ = i 6641 var l int 6642 _ = l 6643 if m.XXX_unrecognized != nil { 6644 i -= len(m.XXX_unrecognized) 6645 copy(dAtA[i:], m.XXX_unrecognized) 6646 } 6647 if len(m.LastBlockAppHash) > 0 { 6648 i -= len(m.LastBlockAppHash) 6649 copy(dAtA[i:], m.LastBlockAppHash) 6650 i = encodeVarintTypes(dAtA, i, uint64(len(m.LastBlockAppHash))) 6651 i-- 6652 dAtA[i] = 0x2a 6653 } 6654 if m.LastBlockHeight != 0 { 6655 i = encodeVarintTypes(dAtA, i, uint64(m.LastBlockHeight)) 6656 i-- 6657 dAtA[i] = 0x20 6658 } 6659 if m.AppVersion != 0 { 6660 i = encodeVarintTypes(dAtA, i, uint64(m.AppVersion)) 6661 i-- 6662 dAtA[i] = 0x18 6663 } 6664 if len(m.Version) > 0 { 6665 i -= len(m.Version) 6666 copy(dAtA[i:], m.Version) 6667 i = encodeVarintTypes(dAtA, i, uint64(len(m.Version))) 6668 i-- 6669 dAtA[i] = 0x12 6670 } 6671 if len(m.Data) > 0 { 6672 i -= len(m.Data) 6673 copy(dAtA[i:], m.Data) 6674 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 6675 i-- 6676 dAtA[i] = 0xa 6677 } 6678 return len(dAtA) - i, nil 6679 } 6680 6681 func (m *ResponseSetOption) Marshal() (dAtA []byte, err error) { 6682 size := m.Size() 6683 dAtA = make([]byte, size) 6684 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6685 if err != nil { 6686 return nil, err 6687 } 6688 return dAtA[:n], nil 6689 } 6690 6691 func (m *ResponseSetOption) MarshalTo(dAtA []byte) (int, error) { 6692 size := m.Size() 6693 return m.MarshalToSizedBuffer(dAtA[:size]) 6694 } 6695 6696 func (m *ResponseSetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6697 i := len(dAtA) 6698 _ = i 6699 var l int 6700 _ = l 6701 if m.XXX_unrecognized != nil { 6702 i -= len(m.XXX_unrecognized) 6703 copy(dAtA[i:], m.XXX_unrecognized) 6704 } 6705 if len(m.Info) > 0 { 6706 i -= len(m.Info) 6707 copy(dAtA[i:], m.Info) 6708 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 6709 i-- 6710 dAtA[i] = 0x22 6711 } 6712 if len(m.Log) > 0 { 6713 i -= len(m.Log) 6714 copy(dAtA[i:], m.Log) 6715 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 6716 i-- 6717 dAtA[i] = 0x1a 6718 } 6719 if m.Code != 0 { 6720 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 6721 i-- 6722 dAtA[i] = 0x8 6723 } 6724 return len(dAtA) - i, nil 6725 } 6726 6727 func (m *ResponseInitChain) Marshal() (dAtA []byte, err error) { 6728 size := m.Size() 6729 dAtA = make([]byte, size) 6730 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6731 if err != nil { 6732 return nil, err 6733 } 6734 return dAtA[:n], nil 6735 } 6736 6737 func (m *ResponseInitChain) MarshalTo(dAtA []byte) (int, error) { 6738 size := m.Size() 6739 return m.MarshalToSizedBuffer(dAtA[:size]) 6740 } 6741 6742 func (m *ResponseInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6743 i := len(dAtA) 6744 _ = i 6745 var l int 6746 _ = l 6747 if m.XXX_unrecognized != nil { 6748 i -= len(m.XXX_unrecognized) 6749 copy(dAtA[i:], m.XXX_unrecognized) 6750 } 6751 if len(m.Validators) > 0 { 6752 for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { 6753 { 6754 size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 6755 if err != nil { 6756 return 0, err 6757 } 6758 i -= size 6759 i = encodeVarintTypes(dAtA, i, uint64(size)) 6760 } 6761 i-- 6762 dAtA[i] = 0x12 6763 } 6764 } 6765 if m.ConsensusParams != nil { 6766 { 6767 size, err := m.ConsensusParams.MarshalToSizedBuffer(dAtA[:i]) 6768 if err != nil { 6769 return 0, err 6770 } 6771 i -= size 6772 i = encodeVarintTypes(dAtA, i, uint64(size)) 6773 } 6774 i-- 6775 dAtA[i] = 0xa 6776 } 6777 return len(dAtA) - i, nil 6778 } 6779 6780 func (m *ResponseQuery) Marshal() (dAtA []byte, err error) { 6781 size := m.Size() 6782 dAtA = make([]byte, size) 6783 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6784 if err != nil { 6785 return nil, err 6786 } 6787 return dAtA[:n], nil 6788 } 6789 6790 func (m *ResponseQuery) MarshalTo(dAtA []byte) (int, error) { 6791 size := m.Size() 6792 return m.MarshalToSizedBuffer(dAtA[:size]) 6793 } 6794 6795 func (m *ResponseQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6796 i := len(dAtA) 6797 _ = i 6798 var l int 6799 _ = l 6800 if m.XXX_unrecognized != nil { 6801 i -= len(m.XXX_unrecognized) 6802 copy(dAtA[i:], m.XXX_unrecognized) 6803 } 6804 if len(m.Codespace) > 0 { 6805 i -= len(m.Codespace) 6806 copy(dAtA[i:], m.Codespace) 6807 i = encodeVarintTypes(dAtA, i, uint64(len(m.Codespace))) 6808 i-- 6809 dAtA[i] = 0x52 6810 } 6811 if m.Height != 0 { 6812 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 6813 i-- 6814 dAtA[i] = 0x48 6815 } 6816 if m.Proof != nil { 6817 { 6818 size, err := m.Proof.MarshalToSizedBuffer(dAtA[:i]) 6819 if err != nil { 6820 return 0, err 6821 } 6822 i -= size 6823 i = encodeVarintTypes(dAtA, i, uint64(size)) 6824 } 6825 i-- 6826 dAtA[i] = 0x42 6827 } 6828 if len(m.Value) > 0 { 6829 i -= len(m.Value) 6830 copy(dAtA[i:], m.Value) 6831 i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) 6832 i-- 6833 dAtA[i] = 0x3a 6834 } 6835 if len(m.Key) > 0 { 6836 i -= len(m.Key) 6837 copy(dAtA[i:], m.Key) 6838 i = encodeVarintTypes(dAtA, i, uint64(len(m.Key))) 6839 i-- 6840 dAtA[i] = 0x32 6841 } 6842 if m.Index != 0 { 6843 i = encodeVarintTypes(dAtA, i, uint64(m.Index)) 6844 i-- 6845 dAtA[i] = 0x28 6846 } 6847 if len(m.Info) > 0 { 6848 i -= len(m.Info) 6849 copy(dAtA[i:], m.Info) 6850 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 6851 i-- 6852 dAtA[i] = 0x22 6853 } 6854 if len(m.Log) > 0 { 6855 i -= len(m.Log) 6856 copy(dAtA[i:], m.Log) 6857 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 6858 i-- 6859 dAtA[i] = 0x1a 6860 } 6861 if m.Code != 0 { 6862 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 6863 i-- 6864 dAtA[i] = 0x8 6865 } 6866 return len(dAtA) - i, nil 6867 } 6868 6869 func (m *ResponseBeginBlock) Marshal() (dAtA []byte, err error) { 6870 size := m.Size() 6871 dAtA = make([]byte, size) 6872 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6873 if err != nil { 6874 return nil, err 6875 } 6876 return dAtA[:n], nil 6877 } 6878 6879 func (m *ResponseBeginBlock) MarshalTo(dAtA []byte) (int, error) { 6880 size := m.Size() 6881 return m.MarshalToSizedBuffer(dAtA[:size]) 6882 } 6883 6884 func (m *ResponseBeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6885 i := len(dAtA) 6886 _ = i 6887 var l int 6888 _ = l 6889 if m.XXX_unrecognized != nil { 6890 i -= len(m.XXX_unrecognized) 6891 copy(dAtA[i:], m.XXX_unrecognized) 6892 } 6893 if len(m.Events) > 0 { 6894 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 6895 { 6896 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 6897 if err != nil { 6898 return 0, err 6899 } 6900 i -= size 6901 i = encodeVarintTypes(dAtA, i, uint64(size)) 6902 } 6903 i-- 6904 dAtA[i] = 0xa 6905 } 6906 } 6907 return len(dAtA) - i, nil 6908 } 6909 6910 func (m *ResponseCheckTx) Marshal() (dAtA []byte, err error) { 6911 size := m.Size() 6912 dAtA = make([]byte, size) 6913 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6914 if err != nil { 6915 return nil, err 6916 } 6917 return dAtA[:n], nil 6918 } 6919 6920 func (m *ResponseCheckTx) MarshalTo(dAtA []byte) (int, error) { 6921 size := m.Size() 6922 return m.MarshalToSizedBuffer(dAtA[:size]) 6923 } 6924 6925 func (m *ResponseCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6926 i := len(dAtA) 6927 _ = i 6928 var l int 6929 _ = l 6930 if m.XXX_unrecognized != nil { 6931 i -= len(m.XXX_unrecognized) 6932 copy(dAtA[i:], m.XXX_unrecognized) 6933 } 6934 if len(m.Codespace) > 0 { 6935 i -= len(m.Codespace) 6936 copy(dAtA[i:], m.Codespace) 6937 i = encodeVarintTypes(dAtA, i, uint64(len(m.Codespace))) 6938 i-- 6939 dAtA[i] = 0x42 6940 } 6941 if len(m.Events) > 0 { 6942 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 6943 { 6944 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 6945 if err != nil { 6946 return 0, err 6947 } 6948 i -= size 6949 i = encodeVarintTypes(dAtA, i, uint64(size)) 6950 } 6951 i-- 6952 dAtA[i] = 0x3a 6953 } 6954 } 6955 if m.GasUsed != 0 { 6956 i = encodeVarintTypes(dAtA, i, uint64(m.GasUsed)) 6957 i-- 6958 dAtA[i] = 0x30 6959 } 6960 if m.GasWanted != 0 { 6961 i = encodeVarintTypes(dAtA, i, uint64(m.GasWanted)) 6962 i-- 6963 dAtA[i] = 0x28 6964 } 6965 if len(m.Info) > 0 { 6966 i -= len(m.Info) 6967 copy(dAtA[i:], m.Info) 6968 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 6969 i-- 6970 dAtA[i] = 0x22 6971 } 6972 if len(m.Log) > 0 { 6973 i -= len(m.Log) 6974 copy(dAtA[i:], m.Log) 6975 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 6976 i-- 6977 dAtA[i] = 0x1a 6978 } 6979 if len(m.Data) > 0 { 6980 i -= len(m.Data) 6981 copy(dAtA[i:], m.Data) 6982 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 6983 i-- 6984 dAtA[i] = 0x12 6985 } 6986 if m.Code != 0 { 6987 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 6988 i-- 6989 dAtA[i] = 0x8 6990 } 6991 return len(dAtA) - i, nil 6992 } 6993 6994 func (m *ResponseDeliverTx) Marshal() (dAtA []byte, err error) { 6995 size := m.Size() 6996 dAtA = make([]byte, size) 6997 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6998 if err != nil { 6999 return nil, err 7000 } 7001 return dAtA[:n], nil 7002 } 7003 7004 func (m *ResponseDeliverTx) MarshalTo(dAtA []byte) (int, error) { 7005 size := m.Size() 7006 return m.MarshalToSizedBuffer(dAtA[:size]) 7007 } 7008 7009 func (m *ResponseDeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7010 i := len(dAtA) 7011 _ = i 7012 var l int 7013 _ = l 7014 if m.XXX_unrecognized != nil { 7015 i -= len(m.XXX_unrecognized) 7016 copy(dAtA[i:], m.XXX_unrecognized) 7017 } 7018 if len(m.Codespace) > 0 { 7019 i -= len(m.Codespace) 7020 copy(dAtA[i:], m.Codespace) 7021 i = encodeVarintTypes(dAtA, i, uint64(len(m.Codespace))) 7022 i-- 7023 dAtA[i] = 0x42 7024 } 7025 if len(m.Events) > 0 { 7026 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 7027 { 7028 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 7029 if err != nil { 7030 return 0, err 7031 } 7032 i -= size 7033 i = encodeVarintTypes(dAtA, i, uint64(size)) 7034 } 7035 i-- 7036 dAtA[i] = 0x3a 7037 } 7038 } 7039 if m.GasUsed != 0 { 7040 i = encodeVarintTypes(dAtA, i, uint64(m.GasUsed)) 7041 i-- 7042 dAtA[i] = 0x30 7043 } 7044 if m.GasWanted != 0 { 7045 i = encodeVarintTypes(dAtA, i, uint64(m.GasWanted)) 7046 i-- 7047 dAtA[i] = 0x28 7048 } 7049 if len(m.Info) > 0 { 7050 i -= len(m.Info) 7051 copy(dAtA[i:], m.Info) 7052 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 7053 i-- 7054 dAtA[i] = 0x22 7055 } 7056 if len(m.Log) > 0 { 7057 i -= len(m.Log) 7058 copy(dAtA[i:], m.Log) 7059 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 7060 i-- 7061 dAtA[i] = 0x1a 7062 } 7063 if len(m.Data) > 0 { 7064 i -= len(m.Data) 7065 copy(dAtA[i:], m.Data) 7066 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 7067 i-- 7068 dAtA[i] = 0x12 7069 } 7070 if m.Code != 0 { 7071 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 7072 i-- 7073 dAtA[i] = 0x8 7074 } 7075 return len(dAtA) - i, nil 7076 } 7077 7078 func (m *ResponseEndBlock) Marshal() (dAtA []byte, err error) { 7079 size := m.Size() 7080 dAtA = make([]byte, size) 7081 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7082 if err != nil { 7083 return nil, err 7084 } 7085 return dAtA[:n], nil 7086 } 7087 7088 func (m *ResponseEndBlock) MarshalTo(dAtA []byte) (int, error) { 7089 size := m.Size() 7090 return m.MarshalToSizedBuffer(dAtA[:size]) 7091 } 7092 7093 func (m *ResponseEndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7094 i := len(dAtA) 7095 _ = i 7096 var l int 7097 _ = l 7098 if m.XXX_unrecognized != nil { 7099 i -= len(m.XXX_unrecognized) 7100 copy(dAtA[i:], m.XXX_unrecognized) 7101 } 7102 if len(m.Events) > 0 { 7103 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 7104 { 7105 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 7106 if err != nil { 7107 return 0, err 7108 } 7109 i -= size 7110 i = encodeVarintTypes(dAtA, i, uint64(size)) 7111 } 7112 i-- 7113 dAtA[i] = 0x1a 7114 } 7115 } 7116 if m.ConsensusParamUpdates != nil { 7117 { 7118 size, err := m.ConsensusParamUpdates.MarshalToSizedBuffer(dAtA[:i]) 7119 if err != nil { 7120 return 0, err 7121 } 7122 i -= size 7123 i = encodeVarintTypes(dAtA, i, uint64(size)) 7124 } 7125 i-- 7126 dAtA[i] = 0x12 7127 } 7128 if len(m.ValidatorUpdates) > 0 { 7129 for iNdEx := len(m.ValidatorUpdates) - 1; iNdEx >= 0; iNdEx-- { 7130 { 7131 size, err := m.ValidatorUpdates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 7132 if err != nil { 7133 return 0, err 7134 } 7135 i -= size 7136 i = encodeVarintTypes(dAtA, i, uint64(size)) 7137 } 7138 i-- 7139 dAtA[i] = 0xa 7140 } 7141 } 7142 return len(dAtA) - i, nil 7143 } 7144 7145 func (m *ResponseCommit) Marshal() (dAtA []byte, err error) { 7146 size := m.Size() 7147 dAtA = make([]byte, size) 7148 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7149 if err != nil { 7150 return nil, err 7151 } 7152 return dAtA[:n], nil 7153 } 7154 7155 func (m *ResponseCommit) MarshalTo(dAtA []byte) (int, error) { 7156 size := m.Size() 7157 return m.MarshalToSizedBuffer(dAtA[:size]) 7158 } 7159 7160 func (m *ResponseCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7161 i := len(dAtA) 7162 _ = i 7163 var l int 7164 _ = l 7165 if m.XXX_unrecognized != nil { 7166 i -= len(m.XXX_unrecognized) 7167 copy(dAtA[i:], m.XXX_unrecognized) 7168 } 7169 if m.RetainHeight != 0 { 7170 i = encodeVarintTypes(dAtA, i, uint64(m.RetainHeight)) 7171 i-- 7172 dAtA[i] = 0x18 7173 } 7174 if len(m.Data) > 0 { 7175 i -= len(m.Data) 7176 copy(dAtA[i:], m.Data) 7177 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 7178 i-- 7179 dAtA[i] = 0x12 7180 } 7181 return len(dAtA) - i, nil 7182 } 7183 7184 func (m *ConsensusParams) Marshal() (dAtA []byte, err error) { 7185 size := m.Size() 7186 dAtA = make([]byte, size) 7187 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7188 if err != nil { 7189 return nil, err 7190 } 7191 return dAtA[:n], nil 7192 } 7193 7194 func (m *ConsensusParams) MarshalTo(dAtA []byte) (int, error) { 7195 size := m.Size() 7196 return m.MarshalToSizedBuffer(dAtA[:size]) 7197 } 7198 7199 func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7200 i := len(dAtA) 7201 _ = i 7202 var l int 7203 _ = l 7204 if m.XXX_unrecognized != nil { 7205 i -= len(m.XXX_unrecognized) 7206 copy(dAtA[i:], m.XXX_unrecognized) 7207 } 7208 if m.Validator != nil { 7209 { 7210 size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) 7211 if err != nil { 7212 return 0, err 7213 } 7214 i -= size 7215 i = encodeVarintTypes(dAtA, i, uint64(size)) 7216 } 7217 i-- 7218 dAtA[i] = 0x1a 7219 } 7220 if m.Evidence != nil { 7221 { 7222 size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i]) 7223 if err != nil { 7224 return 0, err 7225 } 7226 i -= size 7227 i = encodeVarintTypes(dAtA, i, uint64(size)) 7228 } 7229 i-- 7230 dAtA[i] = 0x12 7231 } 7232 if m.Block != nil { 7233 { 7234 size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) 7235 if err != nil { 7236 return 0, err 7237 } 7238 i -= size 7239 i = encodeVarintTypes(dAtA, i, uint64(size)) 7240 } 7241 i-- 7242 dAtA[i] = 0xa 7243 } 7244 return len(dAtA) - i, nil 7245 } 7246 7247 func (m *BlockParams) Marshal() (dAtA []byte, err error) { 7248 size := m.Size() 7249 dAtA = make([]byte, size) 7250 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7251 if err != nil { 7252 return nil, err 7253 } 7254 return dAtA[:n], nil 7255 } 7256 7257 func (m *BlockParams) MarshalTo(dAtA []byte) (int, error) { 7258 size := m.Size() 7259 return m.MarshalToSizedBuffer(dAtA[:size]) 7260 } 7261 7262 func (m *BlockParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7263 i := len(dAtA) 7264 _ = i 7265 var l int 7266 _ = l 7267 if m.XXX_unrecognized != nil { 7268 i -= len(m.XXX_unrecognized) 7269 copy(dAtA[i:], m.XXX_unrecognized) 7270 } 7271 if m.MaxGas != 0 { 7272 i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas)) 7273 i-- 7274 dAtA[i] = 0x10 7275 } 7276 if m.MaxBytes != 0 { 7277 i = encodeVarintTypes(dAtA, i, uint64(m.MaxBytes)) 7278 i-- 7279 dAtA[i] = 0x8 7280 } 7281 return len(dAtA) - i, nil 7282 } 7283 7284 func (m *EvidenceParams) Marshal() (dAtA []byte, err error) { 7285 size := m.Size() 7286 dAtA = make([]byte, size) 7287 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7288 if err != nil { 7289 return nil, err 7290 } 7291 return dAtA[:n], nil 7292 } 7293 7294 func (m *EvidenceParams) MarshalTo(dAtA []byte) (int, error) { 7295 size := m.Size() 7296 return m.MarshalToSizedBuffer(dAtA[:size]) 7297 } 7298 7299 func (m *EvidenceParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7300 i := len(dAtA) 7301 _ = i 7302 var l int 7303 _ = l 7304 if m.XXX_unrecognized != nil { 7305 i -= len(m.XXX_unrecognized) 7306 copy(dAtA[i:], m.XXX_unrecognized) 7307 } 7308 if m.MaxAge != 0 { 7309 i = encodeVarintTypes(dAtA, i, uint64(m.MaxAge)) 7310 i-- 7311 dAtA[i] = 0x8 7312 } 7313 return len(dAtA) - i, nil 7314 } 7315 7316 func (m *ValidatorParams) Marshal() (dAtA []byte, err error) { 7317 size := m.Size() 7318 dAtA = make([]byte, size) 7319 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7320 if err != nil { 7321 return nil, err 7322 } 7323 return dAtA[:n], nil 7324 } 7325 7326 func (m *ValidatorParams) MarshalTo(dAtA []byte) (int, error) { 7327 size := m.Size() 7328 return m.MarshalToSizedBuffer(dAtA[:size]) 7329 } 7330 7331 func (m *ValidatorParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7332 i := len(dAtA) 7333 _ = i 7334 var l int 7335 _ = l 7336 if m.XXX_unrecognized != nil { 7337 i -= len(m.XXX_unrecognized) 7338 copy(dAtA[i:], m.XXX_unrecognized) 7339 } 7340 if len(m.PubKeyTypes) > 0 { 7341 for iNdEx := len(m.PubKeyTypes) - 1; iNdEx >= 0; iNdEx-- { 7342 i -= len(m.PubKeyTypes[iNdEx]) 7343 copy(dAtA[i:], m.PubKeyTypes[iNdEx]) 7344 i = encodeVarintTypes(dAtA, i, uint64(len(m.PubKeyTypes[iNdEx]))) 7345 i-- 7346 dAtA[i] = 0xa 7347 } 7348 } 7349 return len(dAtA) - i, nil 7350 } 7351 7352 func (m *LastCommitInfo) Marshal() (dAtA []byte, err error) { 7353 size := m.Size() 7354 dAtA = make([]byte, size) 7355 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7356 if err != nil { 7357 return nil, err 7358 } 7359 return dAtA[:n], nil 7360 } 7361 7362 func (m *LastCommitInfo) MarshalTo(dAtA []byte) (int, error) { 7363 size := m.Size() 7364 return m.MarshalToSizedBuffer(dAtA[:size]) 7365 } 7366 7367 func (m *LastCommitInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7368 i := len(dAtA) 7369 _ = i 7370 var l int 7371 _ = l 7372 if m.XXX_unrecognized != nil { 7373 i -= len(m.XXX_unrecognized) 7374 copy(dAtA[i:], m.XXX_unrecognized) 7375 } 7376 if len(m.Votes) > 0 { 7377 for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- { 7378 { 7379 size, err := m.Votes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 7380 if err != nil { 7381 return 0, err 7382 } 7383 i -= size 7384 i = encodeVarintTypes(dAtA, i, uint64(size)) 7385 } 7386 i-- 7387 dAtA[i] = 0x12 7388 } 7389 } 7390 if m.Round != 0 { 7391 i = encodeVarintTypes(dAtA, i, uint64(m.Round)) 7392 i-- 7393 dAtA[i] = 0x8 7394 } 7395 return len(dAtA) - i, nil 7396 } 7397 7398 func (m *Event) Marshal() (dAtA []byte, err error) { 7399 size := m.Size() 7400 dAtA = make([]byte, size) 7401 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7402 if err != nil { 7403 return nil, err 7404 } 7405 return dAtA[:n], nil 7406 } 7407 7408 func (m *Event) MarshalTo(dAtA []byte) (int, error) { 7409 size := m.Size() 7410 return m.MarshalToSizedBuffer(dAtA[:size]) 7411 } 7412 7413 func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7414 i := len(dAtA) 7415 _ = i 7416 var l int 7417 _ = l 7418 if m.XXX_unrecognized != nil { 7419 i -= len(m.XXX_unrecognized) 7420 copy(dAtA[i:], m.XXX_unrecognized) 7421 } 7422 if len(m.Attributes) > 0 { 7423 for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- { 7424 { 7425 size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 7426 if err != nil { 7427 return 0, err 7428 } 7429 i -= size 7430 i = encodeVarintTypes(dAtA, i, uint64(size)) 7431 } 7432 i-- 7433 dAtA[i] = 0x12 7434 } 7435 } 7436 if len(m.Type) > 0 { 7437 i -= len(m.Type) 7438 copy(dAtA[i:], m.Type) 7439 i = encodeVarintTypes(dAtA, i, uint64(len(m.Type))) 7440 i-- 7441 dAtA[i] = 0xa 7442 } 7443 return len(dAtA) - i, nil 7444 } 7445 7446 func (m *Header) Marshal() (dAtA []byte, err error) { 7447 size := m.Size() 7448 dAtA = make([]byte, size) 7449 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7450 if err != nil { 7451 return nil, err 7452 } 7453 return dAtA[:n], nil 7454 } 7455 7456 func (m *Header) MarshalTo(dAtA []byte) (int, error) { 7457 size := m.Size() 7458 return m.MarshalToSizedBuffer(dAtA[:size]) 7459 } 7460 7461 func (m *Header) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7462 i := len(dAtA) 7463 _ = i 7464 var l int 7465 _ = l 7466 if m.XXX_unrecognized != nil { 7467 i -= len(m.XXX_unrecognized) 7468 copy(dAtA[i:], m.XXX_unrecognized) 7469 } 7470 if len(m.ProposerAddress) > 0 { 7471 i -= len(m.ProposerAddress) 7472 copy(dAtA[i:], m.ProposerAddress) 7473 i = encodeVarintTypes(dAtA, i, uint64(len(m.ProposerAddress))) 7474 i-- 7475 dAtA[i] = 0x1 7476 i-- 7477 dAtA[i] = 0x82 7478 } 7479 if len(m.EvidenceHash) > 0 { 7480 i -= len(m.EvidenceHash) 7481 copy(dAtA[i:], m.EvidenceHash) 7482 i = encodeVarintTypes(dAtA, i, uint64(len(m.EvidenceHash))) 7483 i-- 7484 dAtA[i] = 0x7a 7485 } 7486 if len(m.LastResultsHash) > 0 { 7487 i -= len(m.LastResultsHash) 7488 copy(dAtA[i:], m.LastResultsHash) 7489 i = encodeVarintTypes(dAtA, i, uint64(len(m.LastResultsHash))) 7490 i-- 7491 dAtA[i] = 0x72 7492 } 7493 if len(m.AppHash) > 0 { 7494 i -= len(m.AppHash) 7495 copy(dAtA[i:], m.AppHash) 7496 i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) 7497 i-- 7498 dAtA[i] = 0x6a 7499 } 7500 if len(m.ConsensusHash) > 0 { 7501 i -= len(m.ConsensusHash) 7502 copy(dAtA[i:], m.ConsensusHash) 7503 i = encodeVarintTypes(dAtA, i, uint64(len(m.ConsensusHash))) 7504 i-- 7505 dAtA[i] = 0x62 7506 } 7507 if len(m.NextValidatorsHash) > 0 { 7508 i -= len(m.NextValidatorsHash) 7509 copy(dAtA[i:], m.NextValidatorsHash) 7510 i = encodeVarintTypes(dAtA, i, uint64(len(m.NextValidatorsHash))) 7511 i-- 7512 dAtA[i] = 0x5a 7513 } 7514 if len(m.ValidatorsHash) > 0 { 7515 i -= len(m.ValidatorsHash) 7516 copy(dAtA[i:], m.ValidatorsHash) 7517 i = encodeVarintTypes(dAtA, i, uint64(len(m.ValidatorsHash))) 7518 i-- 7519 dAtA[i] = 0x52 7520 } 7521 if len(m.DataHash) > 0 { 7522 i -= len(m.DataHash) 7523 copy(dAtA[i:], m.DataHash) 7524 i = encodeVarintTypes(dAtA, i, uint64(len(m.DataHash))) 7525 i-- 7526 dAtA[i] = 0x4a 7527 } 7528 if len(m.LastCommitHash) > 0 { 7529 i -= len(m.LastCommitHash) 7530 copy(dAtA[i:], m.LastCommitHash) 7531 i = encodeVarintTypes(dAtA, i, uint64(len(m.LastCommitHash))) 7532 i-- 7533 dAtA[i] = 0x42 7534 } 7535 { 7536 size, err := m.LastBlockId.MarshalToSizedBuffer(dAtA[:i]) 7537 if err != nil { 7538 return 0, err 7539 } 7540 i -= size 7541 i = encodeVarintTypes(dAtA, i, uint64(size)) 7542 } 7543 i-- 7544 dAtA[i] = 0x3a 7545 if m.TotalTxs != 0 { 7546 i = encodeVarintTypes(dAtA, i, uint64(m.TotalTxs)) 7547 i-- 7548 dAtA[i] = 0x30 7549 } 7550 if m.NumTxs != 0 { 7551 i = encodeVarintTypes(dAtA, i, uint64(m.NumTxs)) 7552 i-- 7553 dAtA[i] = 0x28 7554 } 7555 n35, err35 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) 7556 if err35 != nil { 7557 return 0, err35 7558 } 7559 i -= n35 7560 i = encodeVarintTypes(dAtA, i, uint64(n35)) 7561 i-- 7562 dAtA[i] = 0x22 7563 if m.Height != 0 { 7564 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 7565 i-- 7566 dAtA[i] = 0x18 7567 } 7568 if len(m.ChainID) > 0 { 7569 i -= len(m.ChainID) 7570 copy(dAtA[i:], m.ChainID) 7571 i = encodeVarintTypes(dAtA, i, uint64(len(m.ChainID))) 7572 i-- 7573 dAtA[i] = 0x12 7574 } 7575 { 7576 size, err := m.Version.MarshalToSizedBuffer(dAtA[:i]) 7577 if err != nil { 7578 return 0, err 7579 } 7580 i -= size 7581 i = encodeVarintTypes(dAtA, i, uint64(size)) 7582 } 7583 i-- 7584 dAtA[i] = 0xa 7585 return len(dAtA) - i, nil 7586 } 7587 7588 func (m *Version) Marshal() (dAtA []byte, err error) { 7589 size := m.Size() 7590 dAtA = make([]byte, size) 7591 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7592 if err != nil { 7593 return nil, err 7594 } 7595 return dAtA[:n], nil 7596 } 7597 7598 func (m *Version) MarshalTo(dAtA []byte) (int, error) { 7599 size := m.Size() 7600 return m.MarshalToSizedBuffer(dAtA[:size]) 7601 } 7602 7603 func (m *Version) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7604 i := len(dAtA) 7605 _ = i 7606 var l int 7607 _ = l 7608 if m.XXX_unrecognized != nil { 7609 i -= len(m.XXX_unrecognized) 7610 copy(dAtA[i:], m.XXX_unrecognized) 7611 } 7612 if m.App != 0 { 7613 i = encodeVarintTypes(dAtA, i, uint64(m.App)) 7614 i-- 7615 dAtA[i] = 0x10 7616 } 7617 if m.Block != 0 { 7618 i = encodeVarintTypes(dAtA, i, uint64(m.Block)) 7619 i-- 7620 dAtA[i] = 0x8 7621 } 7622 return len(dAtA) - i, nil 7623 } 7624 7625 func (m *BlockID) Marshal() (dAtA []byte, err error) { 7626 size := m.Size() 7627 dAtA = make([]byte, size) 7628 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7629 if err != nil { 7630 return nil, err 7631 } 7632 return dAtA[:n], nil 7633 } 7634 7635 func (m *BlockID) MarshalTo(dAtA []byte) (int, error) { 7636 size := m.Size() 7637 return m.MarshalToSizedBuffer(dAtA[:size]) 7638 } 7639 7640 func (m *BlockID) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7641 i := len(dAtA) 7642 _ = i 7643 var l int 7644 _ = l 7645 if m.XXX_unrecognized != nil { 7646 i -= len(m.XXX_unrecognized) 7647 copy(dAtA[i:], m.XXX_unrecognized) 7648 } 7649 { 7650 size, err := m.PartsHeader.MarshalToSizedBuffer(dAtA[:i]) 7651 if err != nil { 7652 return 0, err 7653 } 7654 i -= size 7655 i = encodeVarintTypes(dAtA, i, uint64(size)) 7656 } 7657 i-- 7658 dAtA[i] = 0x12 7659 if len(m.Hash) > 0 { 7660 i -= len(m.Hash) 7661 copy(dAtA[i:], m.Hash) 7662 i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) 7663 i-- 7664 dAtA[i] = 0xa 7665 } 7666 return len(dAtA) - i, nil 7667 } 7668 7669 func (m *PartSetHeader) Marshal() (dAtA []byte, err error) { 7670 size := m.Size() 7671 dAtA = make([]byte, size) 7672 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7673 if err != nil { 7674 return nil, err 7675 } 7676 return dAtA[:n], nil 7677 } 7678 7679 func (m *PartSetHeader) MarshalTo(dAtA []byte) (int, error) { 7680 size := m.Size() 7681 return m.MarshalToSizedBuffer(dAtA[:size]) 7682 } 7683 7684 func (m *PartSetHeader) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7685 i := len(dAtA) 7686 _ = i 7687 var l int 7688 _ = l 7689 if m.XXX_unrecognized != nil { 7690 i -= len(m.XXX_unrecognized) 7691 copy(dAtA[i:], m.XXX_unrecognized) 7692 } 7693 if len(m.Hash) > 0 { 7694 i -= len(m.Hash) 7695 copy(dAtA[i:], m.Hash) 7696 i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) 7697 i-- 7698 dAtA[i] = 0x12 7699 } 7700 if m.Total != 0 { 7701 i = encodeVarintTypes(dAtA, i, uint64(m.Total)) 7702 i-- 7703 dAtA[i] = 0x8 7704 } 7705 return len(dAtA) - i, nil 7706 } 7707 7708 func (m *Validator) Marshal() (dAtA []byte, err error) { 7709 size := m.Size() 7710 dAtA = make([]byte, size) 7711 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7712 if err != nil { 7713 return nil, err 7714 } 7715 return dAtA[:n], nil 7716 } 7717 7718 func (m *Validator) MarshalTo(dAtA []byte) (int, error) { 7719 size := m.Size() 7720 return m.MarshalToSizedBuffer(dAtA[:size]) 7721 } 7722 7723 func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7724 i := len(dAtA) 7725 _ = i 7726 var l int 7727 _ = l 7728 if m.XXX_unrecognized != nil { 7729 i -= len(m.XXX_unrecognized) 7730 copy(dAtA[i:], m.XXX_unrecognized) 7731 } 7732 if m.Power != 0 { 7733 i = encodeVarintTypes(dAtA, i, uint64(m.Power)) 7734 i-- 7735 dAtA[i] = 0x18 7736 } 7737 if len(m.Address) > 0 { 7738 i -= len(m.Address) 7739 copy(dAtA[i:], m.Address) 7740 i = encodeVarintTypes(dAtA, i, uint64(len(m.Address))) 7741 i-- 7742 dAtA[i] = 0xa 7743 } 7744 return len(dAtA) - i, nil 7745 } 7746 7747 func (m *ValidatorUpdate) Marshal() (dAtA []byte, err error) { 7748 size := m.Size() 7749 dAtA = make([]byte, size) 7750 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7751 if err != nil { 7752 return nil, err 7753 } 7754 return dAtA[:n], nil 7755 } 7756 7757 func (m *ValidatorUpdate) MarshalTo(dAtA []byte) (int, error) { 7758 size := m.Size() 7759 return m.MarshalToSizedBuffer(dAtA[:size]) 7760 } 7761 7762 func (m *ValidatorUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7763 i := len(dAtA) 7764 _ = i 7765 var l int 7766 _ = l 7767 if m.XXX_unrecognized != nil { 7768 i -= len(m.XXX_unrecognized) 7769 copy(dAtA[i:], m.XXX_unrecognized) 7770 } 7771 if m.Power != 0 { 7772 i = encodeVarintTypes(dAtA, i, uint64(m.Power)) 7773 i-- 7774 dAtA[i] = 0x10 7775 } 7776 { 7777 size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i]) 7778 if err != nil { 7779 return 0, err 7780 } 7781 i -= size 7782 i = encodeVarintTypes(dAtA, i, uint64(size)) 7783 } 7784 i-- 7785 dAtA[i] = 0xa 7786 return len(dAtA) - i, nil 7787 } 7788 7789 func (m *VoteInfo) Marshal() (dAtA []byte, err error) { 7790 size := m.Size() 7791 dAtA = make([]byte, size) 7792 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7793 if err != nil { 7794 return nil, err 7795 } 7796 return dAtA[:n], nil 7797 } 7798 7799 func (m *VoteInfo) MarshalTo(dAtA []byte) (int, error) { 7800 size := m.Size() 7801 return m.MarshalToSizedBuffer(dAtA[:size]) 7802 } 7803 7804 func (m *VoteInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7805 i := len(dAtA) 7806 _ = i 7807 var l int 7808 _ = l 7809 if m.XXX_unrecognized != nil { 7810 i -= len(m.XXX_unrecognized) 7811 copy(dAtA[i:], m.XXX_unrecognized) 7812 } 7813 if m.SignedLastBlock { 7814 i-- 7815 if m.SignedLastBlock { 7816 dAtA[i] = 1 7817 } else { 7818 dAtA[i] = 0 7819 } 7820 i-- 7821 dAtA[i] = 0x10 7822 } 7823 { 7824 size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) 7825 if err != nil { 7826 return 0, err 7827 } 7828 i -= size 7829 i = encodeVarintTypes(dAtA, i, uint64(size)) 7830 } 7831 i-- 7832 dAtA[i] = 0xa 7833 return len(dAtA) - i, nil 7834 } 7835 7836 func (m *PubKey) Marshal() (dAtA []byte, err error) { 7837 size := m.Size() 7838 dAtA = make([]byte, size) 7839 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7840 if err != nil { 7841 return nil, err 7842 } 7843 return dAtA[:n], nil 7844 } 7845 7846 func (m *PubKey) MarshalTo(dAtA []byte) (int, error) { 7847 size := m.Size() 7848 return m.MarshalToSizedBuffer(dAtA[:size]) 7849 } 7850 7851 func (m *PubKey) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7852 i := len(dAtA) 7853 _ = i 7854 var l int 7855 _ = l 7856 if m.XXX_unrecognized != nil { 7857 i -= len(m.XXX_unrecognized) 7858 copy(dAtA[i:], m.XXX_unrecognized) 7859 } 7860 if len(m.Data) > 0 { 7861 i -= len(m.Data) 7862 copy(dAtA[i:], m.Data) 7863 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 7864 i-- 7865 dAtA[i] = 0x12 7866 } 7867 if len(m.Type) > 0 { 7868 i -= len(m.Type) 7869 copy(dAtA[i:], m.Type) 7870 i = encodeVarintTypes(dAtA, i, uint64(len(m.Type))) 7871 i-- 7872 dAtA[i] = 0xa 7873 } 7874 return len(dAtA) - i, nil 7875 } 7876 7877 func (m *Evidence) Marshal() (dAtA []byte, err error) { 7878 size := m.Size() 7879 dAtA = make([]byte, size) 7880 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 7881 if err != nil { 7882 return nil, err 7883 } 7884 return dAtA[:n], nil 7885 } 7886 7887 func (m *Evidence) MarshalTo(dAtA []byte) (int, error) { 7888 size := m.Size() 7889 return m.MarshalToSizedBuffer(dAtA[:size]) 7890 } 7891 7892 func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) { 7893 i := len(dAtA) 7894 _ = i 7895 var l int 7896 _ = l 7897 if m.XXX_unrecognized != nil { 7898 i -= len(m.XXX_unrecognized) 7899 copy(dAtA[i:], m.XXX_unrecognized) 7900 } 7901 if m.TotalVotingPower != 0 { 7902 i = encodeVarintTypes(dAtA, i, uint64(m.TotalVotingPower)) 7903 i-- 7904 dAtA[i] = 0x28 7905 } 7906 n40, err40 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) 7907 if err40 != nil { 7908 return 0, err40 7909 } 7910 i -= n40 7911 i = encodeVarintTypes(dAtA, i, uint64(n40)) 7912 i-- 7913 dAtA[i] = 0x22 7914 if m.Height != 0 { 7915 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 7916 i-- 7917 dAtA[i] = 0x18 7918 } 7919 { 7920 size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) 7921 if err != nil { 7922 return 0, err 7923 } 7924 i -= size 7925 i = encodeVarintTypes(dAtA, i, uint64(size)) 7926 } 7927 i-- 7928 dAtA[i] = 0x12 7929 if len(m.Type) > 0 { 7930 i -= len(m.Type) 7931 copy(dAtA[i:], m.Type) 7932 i = encodeVarintTypes(dAtA, i, uint64(len(m.Type))) 7933 i-- 7934 dAtA[i] = 0xa 7935 } 7936 return len(dAtA) - i, nil 7937 } 7938 7939 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { 7940 offset -= sovTypes(v) 7941 base := offset 7942 for v >= 1<<7 { 7943 dAtA[offset] = uint8(v&0x7f | 0x80) 7944 v >>= 7 7945 offset++ 7946 } 7947 dAtA[offset] = uint8(v) 7948 return base 7949 } 7950 func NewPopulatedRequest(r randyTypes, easy bool) *Request { 7951 this := &Request{} 7952 oneofNumber_Value := []int32{2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 19}[r.Intn(11)] 7953 switch oneofNumber_Value { 7954 case 2: 7955 this.Value = NewPopulatedRequest_Echo(r, easy) 7956 case 3: 7957 this.Value = NewPopulatedRequest_Flush(r, easy) 7958 case 4: 7959 this.Value = NewPopulatedRequest_Info(r, easy) 7960 case 5: 7961 this.Value = NewPopulatedRequest_SetOption(r, easy) 7962 case 6: 7963 this.Value = NewPopulatedRequest_InitChain(r, easy) 7964 case 7: 7965 this.Value = NewPopulatedRequest_Query(r, easy) 7966 case 8: 7967 this.Value = NewPopulatedRequest_BeginBlock(r, easy) 7968 case 9: 7969 this.Value = NewPopulatedRequest_CheckTx(r, easy) 7970 case 11: 7971 this.Value = NewPopulatedRequest_EndBlock(r, easy) 7972 case 12: 7973 this.Value = NewPopulatedRequest_Commit(r, easy) 7974 case 19: 7975 this.Value = NewPopulatedRequest_DeliverTx(r, easy) 7976 } 7977 if !easy && r.Intn(10) != 0 { 7978 this.XXX_unrecognized = randUnrecognizedTypes(r, 20) 7979 } 7980 return this 7981 } 7982 7983 func NewPopulatedRequest_Echo(r randyTypes, easy bool) *Request_Echo { 7984 this := &Request_Echo{} 7985 this.Echo = NewPopulatedRequestEcho(r, easy) 7986 return this 7987 } 7988 func NewPopulatedRequest_Flush(r randyTypes, easy bool) *Request_Flush { 7989 this := &Request_Flush{} 7990 this.Flush = NewPopulatedRequestFlush(r, easy) 7991 return this 7992 } 7993 func NewPopulatedRequest_Info(r randyTypes, easy bool) *Request_Info { 7994 this := &Request_Info{} 7995 this.Info = NewPopulatedRequestInfo(r, easy) 7996 return this 7997 } 7998 func NewPopulatedRequest_SetOption(r randyTypes, easy bool) *Request_SetOption { 7999 this := &Request_SetOption{} 8000 this.SetOption = NewPopulatedRequestSetOption(r, easy) 8001 return this 8002 } 8003 func NewPopulatedRequest_InitChain(r randyTypes, easy bool) *Request_InitChain { 8004 this := &Request_InitChain{} 8005 this.InitChain = NewPopulatedRequestInitChain(r, easy) 8006 return this 8007 } 8008 func NewPopulatedRequest_Query(r randyTypes, easy bool) *Request_Query { 8009 this := &Request_Query{} 8010 this.Query = NewPopulatedRequestQuery(r, easy) 8011 return this 8012 } 8013 func NewPopulatedRequest_BeginBlock(r randyTypes, easy bool) *Request_BeginBlock { 8014 this := &Request_BeginBlock{} 8015 this.BeginBlock = NewPopulatedRequestBeginBlock(r, easy) 8016 return this 8017 } 8018 func NewPopulatedRequest_CheckTx(r randyTypes, easy bool) *Request_CheckTx { 8019 this := &Request_CheckTx{} 8020 this.CheckTx = NewPopulatedRequestCheckTx(r, easy) 8021 return this 8022 } 8023 func NewPopulatedRequest_EndBlock(r randyTypes, easy bool) *Request_EndBlock { 8024 this := &Request_EndBlock{} 8025 this.EndBlock = NewPopulatedRequestEndBlock(r, easy) 8026 return this 8027 } 8028 func NewPopulatedRequest_Commit(r randyTypes, easy bool) *Request_Commit { 8029 this := &Request_Commit{} 8030 this.Commit = NewPopulatedRequestCommit(r, easy) 8031 return this 8032 } 8033 func NewPopulatedRequest_DeliverTx(r randyTypes, easy bool) *Request_DeliverTx { 8034 this := &Request_DeliverTx{} 8035 this.DeliverTx = NewPopulatedRequestDeliverTx(r, easy) 8036 return this 8037 } 8038 func NewPopulatedRequestEcho(r randyTypes, easy bool) *RequestEcho { 8039 this := &RequestEcho{} 8040 this.Message = string(randStringTypes(r)) 8041 if !easy && r.Intn(10) != 0 { 8042 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8043 } 8044 return this 8045 } 8046 8047 func NewPopulatedRequestFlush(r randyTypes, easy bool) *RequestFlush { 8048 this := &RequestFlush{} 8049 if !easy && r.Intn(10) != 0 { 8050 this.XXX_unrecognized = randUnrecognizedTypes(r, 1) 8051 } 8052 return this 8053 } 8054 8055 func NewPopulatedRequestInfo(r randyTypes, easy bool) *RequestInfo { 8056 this := &RequestInfo{} 8057 this.Version = string(randStringTypes(r)) 8058 this.BlockVersion = uint64(uint64(r.Uint32())) 8059 this.P2PVersion = uint64(uint64(r.Uint32())) 8060 if !easy && r.Intn(10) != 0 { 8061 this.XXX_unrecognized = randUnrecognizedTypes(r, 4) 8062 } 8063 return this 8064 } 8065 8066 func NewPopulatedRequestSetOption(r randyTypes, easy bool) *RequestSetOption { 8067 this := &RequestSetOption{} 8068 this.Key = string(randStringTypes(r)) 8069 this.Value = string(randStringTypes(r)) 8070 if !easy && r.Intn(10) != 0 { 8071 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8072 } 8073 return this 8074 } 8075 8076 func NewPopulatedRequestInitChain(r randyTypes, easy bool) *RequestInitChain { 8077 this := &RequestInitChain{} 8078 v1 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) 8079 this.Time = *v1 8080 this.ChainId = string(randStringTypes(r)) 8081 if r.Intn(5) != 0 { 8082 this.ConsensusParams = NewPopulatedConsensusParams(r, easy) 8083 } 8084 if r.Intn(5) != 0 { 8085 v2 := r.Intn(5) 8086 this.Validators = make([]ValidatorUpdate, v2) 8087 for i := 0; i < v2; i++ { 8088 v3 := NewPopulatedValidatorUpdate(r, easy) 8089 this.Validators[i] = *v3 8090 } 8091 } 8092 v4 := r.Intn(100) 8093 this.AppStateBytes = make([]byte, v4) 8094 for i := 0; i < v4; i++ { 8095 this.AppStateBytes[i] = byte(r.Intn(256)) 8096 } 8097 if !easy && r.Intn(10) != 0 { 8098 this.XXX_unrecognized = randUnrecognizedTypes(r, 6) 8099 } 8100 return this 8101 } 8102 8103 func NewPopulatedRequestQuery(r randyTypes, easy bool) *RequestQuery { 8104 this := &RequestQuery{} 8105 v5 := r.Intn(100) 8106 this.Data = make([]byte, v5) 8107 for i := 0; i < v5; i++ { 8108 this.Data[i] = byte(r.Intn(256)) 8109 } 8110 this.Path = string(randStringTypes(r)) 8111 this.Height = int64(r.Int63()) 8112 if r.Intn(2) == 0 { 8113 this.Height *= -1 8114 } 8115 this.Prove = bool(bool(r.Intn(2) == 0)) 8116 if !easy && r.Intn(10) != 0 { 8117 this.XXX_unrecognized = randUnrecognizedTypes(r, 5) 8118 } 8119 return this 8120 } 8121 8122 func NewPopulatedRequestBeginBlock(r randyTypes, easy bool) *RequestBeginBlock { 8123 this := &RequestBeginBlock{} 8124 v6 := r.Intn(100) 8125 this.Hash = make([]byte, v6) 8126 for i := 0; i < v6; i++ { 8127 this.Hash[i] = byte(r.Intn(256)) 8128 } 8129 v7 := NewPopulatedHeader(r, easy) 8130 this.Header = *v7 8131 v8 := NewPopulatedLastCommitInfo(r, easy) 8132 this.LastCommitInfo = *v8 8133 if r.Intn(5) != 0 { 8134 v9 := r.Intn(5) 8135 this.ByzantineValidators = make([]Evidence, v9) 8136 for i := 0; i < v9; i++ { 8137 v10 := NewPopulatedEvidence(r, easy) 8138 this.ByzantineValidators[i] = *v10 8139 } 8140 } 8141 if !easy && r.Intn(10) != 0 { 8142 this.XXX_unrecognized = randUnrecognizedTypes(r, 5) 8143 } 8144 return this 8145 } 8146 8147 func NewPopulatedRequestCheckTx(r randyTypes, easy bool) *RequestCheckTx { 8148 this := &RequestCheckTx{} 8149 v11 := r.Intn(100) 8150 this.Tx = make([]byte, v11) 8151 for i := 0; i < v11; i++ { 8152 this.Tx[i] = byte(r.Intn(256)) 8153 } 8154 this.Type = CheckTxType([]int32{0, 1}[r.Intn(2)]) 8155 if !easy && r.Intn(10) != 0 { 8156 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8157 } 8158 return this 8159 } 8160 8161 func NewPopulatedRequestDeliverTx(r randyTypes, easy bool) *RequestDeliverTx { 8162 this := &RequestDeliverTx{} 8163 v12 := r.Intn(100) 8164 this.Tx = make([]byte, v12) 8165 for i := 0; i < v12; i++ { 8166 this.Tx[i] = byte(r.Intn(256)) 8167 } 8168 if !easy && r.Intn(10) != 0 { 8169 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8170 } 8171 return this 8172 } 8173 8174 func NewPopulatedRequestEndBlock(r randyTypes, easy bool) *RequestEndBlock { 8175 this := &RequestEndBlock{} 8176 this.Height = int64(r.Int63()) 8177 if r.Intn(2) == 0 { 8178 this.Height *= -1 8179 } 8180 if !easy && r.Intn(10) != 0 { 8181 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8182 } 8183 return this 8184 } 8185 8186 func NewPopulatedRequestCommit(r randyTypes, easy bool) *RequestCommit { 8187 this := &RequestCommit{} 8188 if !easy && r.Intn(10) != 0 { 8189 this.XXX_unrecognized = randUnrecognizedTypes(r, 1) 8190 } 8191 return this 8192 } 8193 8194 func NewPopulatedResponse(r randyTypes, easy bool) *Response { 8195 this := &Response{} 8196 oneofNumber_Value := []int32{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}[r.Intn(12)] 8197 switch oneofNumber_Value { 8198 case 1: 8199 this.Value = NewPopulatedResponse_Exception(r, easy) 8200 case 2: 8201 this.Value = NewPopulatedResponse_Echo(r, easy) 8202 case 3: 8203 this.Value = NewPopulatedResponse_Flush(r, easy) 8204 case 4: 8205 this.Value = NewPopulatedResponse_Info(r, easy) 8206 case 5: 8207 this.Value = NewPopulatedResponse_SetOption(r, easy) 8208 case 6: 8209 this.Value = NewPopulatedResponse_InitChain(r, easy) 8210 case 7: 8211 this.Value = NewPopulatedResponse_Query(r, easy) 8212 case 8: 8213 this.Value = NewPopulatedResponse_BeginBlock(r, easy) 8214 case 9: 8215 this.Value = NewPopulatedResponse_CheckTx(r, easy) 8216 case 10: 8217 this.Value = NewPopulatedResponse_DeliverTx(r, easy) 8218 case 11: 8219 this.Value = NewPopulatedResponse_EndBlock(r, easy) 8220 case 12: 8221 this.Value = NewPopulatedResponse_Commit(r, easy) 8222 } 8223 if !easy && r.Intn(10) != 0 { 8224 this.XXX_unrecognized = randUnrecognizedTypes(r, 13) 8225 } 8226 return this 8227 } 8228 8229 func NewPopulatedResponse_Exception(r randyTypes, easy bool) *Response_Exception { 8230 this := &Response_Exception{} 8231 this.Exception = NewPopulatedResponseException(r, easy) 8232 return this 8233 } 8234 func NewPopulatedResponse_Echo(r randyTypes, easy bool) *Response_Echo { 8235 this := &Response_Echo{} 8236 this.Echo = NewPopulatedResponseEcho(r, easy) 8237 return this 8238 } 8239 func NewPopulatedResponse_Flush(r randyTypes, easy bool) *Response_Flush { 8240 this := &Response_Flush{} 8241 this.Flush = NewPopulatedResponseFlush(r, easy) 8242 return this 8243 } 8244 func NewPopulatedResponse_Info(r randyTypes, easy bool) *Response_Info { 8245 this := &Response_Info{} 8246 this.Info = NewPopulatedResponseInfo(r, easy) 8247 return this 8248 } 8249 func NewPopulatedResponse_SetOption(r randyTypes, easy bool) *Response_SetOption { 8250 this := &Response_SetOption{} 8251 this.SetOption = NewPopulatedResponseSetOption(r, easy) 8252 return this 8253 } 8254 func NewPopulatedResponse_InitChain(r randyTypes, easy bool) *Response_InitChain { 8255 this := &Response_InitChain{} 8256 this.InitChain = NewPopulatedResponseInitChain(r, easy) 8257 return this 8258 } 8259 func NewPopulatedResponse_Query(r randyTypes, easy bool) *Response_Query { 8260 this := &Response_Query{} 8261 this.Query = NewPopulatedResponseQuery(r, easy) 8262 return this 8263 } 8264 func NewPopulatedResponse_BeginBlock(r randyTypes, easy bool) *Response_BeginBlock { 8265 this := &Response_BeginBlock{} 8266 this.BeginBlock = NewPopulatedResponseBeginBlock(r, easy) 8267 return this 8268 } 8269 func NewPopulatedResponse_CheckTx(r randyTypes, easy bool) *Response_CheckTx { 8270 this := &Response_CheckTx{} 8271 this.CheckTx = NewPopulatedResponseCheckTx(r, easy) 8272 return this 8273 } 8274 func NewPopulatedResponse_DeliverTx(r randyTypes, easy bool) *Response_DeliverTx { 8275 this := &Response_DeliverTx{} 8276 this.DeliverTx = NewPopulatedResponseDeliverTx(r, easy) 8277 return this 8278 } 8279 func NewPopulatedResponse_EndBlock(r randyTypes, easy bool) *Response_EndBlock { 8280 this := &Response_EndBlock{} 8281 this.EndBlock = NewPopulatedResponseEndBlock(r, easy) 8282 return this 8283 } 8284 func NewPopulatedResponse_Commit(r randyTypes, easy bool) *Response_Commit { 8285 this := &Response_Commit{} 8286 this.Commit = NewPopulatedResponseCommit(r, easy) 8287 return this 8288 } 8289 func NewPopulatedResponseException(r randyTypes, easy bool) *ResponseException { 8290 this := &ResponseException{} 8291 this.Error = string(randStringTypes(r)) 8292 if !easy && r.Intn(10) != 0 { 8293 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8294 } 8295 return this 8296 } 8297 8298 func NewPopulatedResponseEcho(r randyTypes, easy bool) *ResponseEcho { 8299 this := &ResponseEcho{} 8300 this.Message = string(randStringTypes(r)) 8301 if !easy && r.Intn(10) != 0 { 8302 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8303 } 8304 return this 8305 } 8306 8307 func NewPopulatedResponseFlush(r randyTypes, easy bool) *ResponseFlush { 8308 this := &ResponseFlush{} 8309 if !easy && r.Intn(10) != 0 { 8310 this.XXX_unrecognized = randUnrecognizedTypes(r, 1) 8311 } 8312 return this 8313 } 8314 8315 func NewPopulatedResponseInfo(r randyTypes, easy bool) *ResponseInfo { 8316 this := &ResponseInfo{} 8317 this.Data = string(randStringTypes(r)) 8318 this.Version = string(randStringTypes(r)) 8319 this.AppVersion = uint64(uint64(r.Uint32())) 8320 this.LastBlockHeight = int64(r.Int63()) 8321 if r.Intn(2) == 0 { 8322 this.LastBlockHeight *= -1 8323 } 8324 v13 := r.Intn(100) 8325 this.LastBlockAppHash = make([]byte, v13) 8326 for i := 0; i < v13; i++ { 8327 this.LastBlockAppHash[i] = byte(r.Intn(256)) 8328 } 8329 if !easy && r.Intn(10) != 0 { 8330 this.XXX_unrecognized = randUnrecognizedTypes(r, 6) 8331 } 8332 return this 8333 } 8334 8335 func NewPopulatedResponseSetOption(r randyTypes, easy bool) *ResponseSetOption { 8336 this := &ResponseSetOption{} 8337 this.Code = uint32(r.Uint32()) 8338 this.Log = string(randStringTypes(r)) 8339 this.Info = string(randStringTypes(r)) 8340 if !easy && r.Intn(10) != 0 { 8341 this.XXX_unrecognized = randUnrecognizedTypes(r, 5) 8342 } 8343 return this 8344 } 8345 8346 func NewPopulatedResponseInitChain(r randyTypes, easy bool) *ResponseInitChain { 8347 this := &ResponseInitChain{} 8348 if r.Intn(5) != 0 { 8349 this.ConsensusParams = NewPopulatedConsensusParams(r, easy) 8350 } 8351 if r.Intn(5) != 0 { 8352 v14 := r.Intn(5) 8353 this.Validators = make([]ValidatorUpdate, v14) 8354 for i := 0; i < v14; i++ { 8355 v15 := NewPopulatedValidatorUpdate(r, easy) 8356 this.Validators[i] = *v15 8357 } 8358 } 8359 if !easy && r.Intn(10) != 0 { 8360 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8361 } 8362 return this 8363 } 8364 8365 func NewPopulatedResponseQuery(r randyTypes, easy bool) *ResponseQuery { 8366 this := &ResponseQuery{} 8367 this.Code = uint32(r.Uint32()) 8368 this.Log = string(randStringTypes(r)) 8369 this.Info = string(randStringTypes(r)) 8370 this.Index = int64(r.Int63()) 8371 if r.Intn(2) == 0 { 8372 this.Index *= -1 8373 } 8374 v16 := r.Intn(100) 8375 this.Key = make([]byte, v16) 8376 for i := 0; i < v16; i++ { 8377 this.Key[i] = byte(r.Intn(256)) 8378 } 8379 v17 := r.Intn(100) 8380 this.Value = make([]byte, v17) 8381 for i := 0; i < v17; i++ { 8382 this.Value[i] = byte(r.Intn(256)) 8383 } 8384 if r.Intn(5) != 0 { 8385 this.Proof = merkle.NewPopulatedProof(r, easy) 8386 } 8387 this.Height = int64(r.Int63()) 8388 if r.Intn(2) == 0 { 8389 this.Height *= -1 8390 } 8391 this.Codespace = string(randStringTypes(r)) 8392 if !easy && r.Intn(10) != 0 { 8393 this.XXX_unrecognized = randUnrecognizedTypes(r, 11) 8394 } 8395 return this 8396 } 8397 8398 func NewPopulatedResponseBeginBlock(r randyTypes, easy bool) *ResponseBeginBlock { 8399 this := &ResponseBeginBlock{} 8400 if r.Intn(5) != 0 { 8401 v18 := r.Intn(5) 8402 this.Events = make([]Event, v18) 8403 for i := 0; i < v18; i++ { 8404 v19 := NewPopulatedEvent(r, easy) 8405 this.Events[i] = *v19 8406 } 8407 } 8408 if !easy && r.Intn(10) != 0 { 8409 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8410 } 8411 return this 8412 } 8413 8414 func NewPopulatedResponseCheckTx(r randyTypes, easy bool) *ResponseCheckTx { 8415 this := &ResponseCheckTx{} 8416 this.Code = uint32(r.Uint32()) 8417 v20 := r.Intn(100) 8418 this.Data = make([]byte, v20) 8419 for i := 0; i < v20; i++ { 8420 this.Data[i] = byte(r.Intn(256)) 8421 } 8422 this.Log = string(randStringTypes(r)) 8423 this.Info = string(randStringTypes(r)) 8424 this.GasWanted = int64(r.Int63()) 8425 if r.Intn(2) == 0 { 8426 this.GasWanted *= -1 8427 } 8428 this.GasUsed = int64(r.Int63()) 8429 if r.Intn(2) == 0 { 8430 this.GasUsed *= -1 8431 } 8432 if r.Intn(5) != 0 { 8433 v21 := r.Intn(5) 8434 this.Events = make([]Event, v21) 8435 for i := 0; i < v21; i++ { 8436 v22 := NewPopulatedEvent(r, easy) 8437 this.Events[i] = *v22 8438 } 8439 } 8440 this.Codespace = string(randStringTypes(r)) 8441 if !easy && r.Intn(10) != 0 { 8442 this.XXX_unrecognized = randUnrecognizedTypes(r, 9) 8443 } 8444 return this 8445 } 8446 8447 func NewPopulatedResponseDeliverTx(r randyTypes, easy bool) *ResponseDeliverTx { 8448 this := &ResponseDeliverTx{} 8449 this.Code = uint32(r.Uint32()) 8450 v23 := r.Intn(100) 8451 this.Data = make([]byte, v23) 8452 for i := 0; i < v23; i++ { 8453 this.Data[i] = byte(r.Intn(256)) 8454 } 8455 this.Log = string(randStringTypes(r)) 8456 this.Info = string(randStringTypes(r)) 8457 this.GasWanted = int64(r.Int63()) 8458 if r.Intn(2) == 0 { 8459 this.GasWanted *= -1 8460 } 8461 this.GasUsed = int64(r.Int63()) 8462 if r.Intn(2) == 0 { 8463 this.GasUsed *= -1 8464 } 8465 if r.Intn(5) != 0 { 8466 v24 := r.Intn(5) 8467 this.Events = make([]Event, v24) 8468 for i := 0; i < v24; i++ { 8469 v25 := NewPopulatedEvent(r, easy) 8470 this.Events[i] = *v25 8471 } 8472 } 8473 this.Codespace = string(randStringTypes(r)) 8474 if !easy && r.Intn(10) != 0 { 8475 this.XXX_unrecognized = randUnrecognizedTypes(r, 9) 8476 } 8477 return this 8478 } 8479 8480 func NewPopulatedResponseEndBlock(r randyTypes, easy bool) *ResponseEndBlock { 8481 this := &ResponseEndBlock{} 8482 if r.Intn(5) != 0 { 8483 v26 := r.Intn(5) 8484 this.ValidatorUpdates = make([]ValidatorUpdate, v26) 8485 for i := 0; i < v26; i++ { 8486 v27 := NewPopulatedValidatorUpdate(r, easy) 8487 this.ValidatorUpdates[i] = *v27 8488 } 8489 } 8490 if r.Intn(5) != 0 { 8491 this.ConsensusParamUpdates = NewPopulatedConsensusParams(r, easy) 8492 } 8493 if r.Intn(5) != 0 { 8494 v28 := r.Intn(5) 8495 this.Events = make([]Event, v28) 8496 for i := 0; i < v28; i++ { 8497 v29 := NewPopulatedEvent(r, easy) 8498 this.Events[i] = *v29 8499 } 8500 } 8501 if !easy && r.Intn(10) != 0 { 8502 this.XXX_unrecognized = randUnrecognizedTypes(r, 4) 8503 } 8504 return this 8505 } 8506 8507 func NewPopulatedResponseCommit(r randyTypes, easy bool) *ResponseCommit { 8508 this := &ResponseCommit{} 8509 v30 := r.Intn(100) 8510 this.Data = make([]byte, v30) 8511 for i := 0; i < v30; i++ { 8512 this.Data[i] = byte(r.Intn(256)) 8513 } 8514 this.RetainHeight = int64(r.Int63()) 8515 if r.Intn(2) == 0 { 8516 this.RetainHeight *= -1 8517 } 8518 if !easy && r.Intn(10) != 0 { 8519 this.XXX_unrecognized = randUnrecognizedTypes(r, 4) 8520 } 8521 return this 8522 } 8523 8524 func NewPopulatedConsensusParams(r randyTypes, easy bool) *ConsensusParams { 8525 this := &ConsensusParams{} 8526 if r.Intn(5) != 0 { 8527 this.Block = NewPopulatedBlockParams(r, easy) 8528 } 8529 if r.Intn(5) != 0 { 8530 this.Evidence = NewPopulatedEvidenceParams(r, easy) 8531 } 8532 if r.Intn(5) != 0 { 8533 this.Validator = NewPopulatedValidatorParams(r, easy) 8534 } 8535 if !easy && r.Intn(10) != 0 { 8536 this.XXX_unrecognized = randUnrecognizedTypes(r, 4) 8537 } 8538 return this 8539 } 8540 8541 func NewPopulatedBlockParams(r randyTypes, easy bool) *BlockParams { 8542 this := &BlockParams{} 8543 this.MaxBytes = int64(r.Int63()) 8544 if r.Intn(2) == 0 { 8545 this.MaxBytes *= -1 8546 } 8547 this.MaxGas = int64(r.Int63()) 8548 if r.Intn(2) == 0 { 8549 this.MaxGas *= -1 8550 } 8551 if !easy && r.Intn(10) != 0 { 8552 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8553 } 8554 return this 8555 } 8556 8557 func NewPopulatedEvidenceParams(r randyTypes, easy bool) *EvidenceParams { 8558 this := &EvidenceParams{} 8559 this.MaxAge = int64(r.Int63()) 8560 if r.Intn(2) == 0 { 8561 this.MaxAge *= -1 8562 } 8563 if !easy && r.Intn(10) != 0 { 8564 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8565 } 8566 return this 8567 } 8568 8569 func NewPopulatedValidatorParams(r randyTypes, easy bool) *ValidatorParams { 8570 this := &ValidatorParams{} 8571 v31 := r.Intn(10) 8572 this.PubKeyTypes = make([]string, v31) 8573 for i := 0; i < v31; i++ { 8574 this.PubKeyTypes[i] = string(randStringTypes(r)) 8575 } 8576 if !easy && r.Intn(10) != 0 { 8577 this.XXX_unrecognized = randUnrecognizedTypes(r, 2) 8578 } 8579 return this 8580 } 8581 8582 func NewPopulatedLastCommitInfo(r randyTypes, easy bool) *LastCommitInfo { 8583 this := &LastCommitInfo{} 8584 this.Round = int32(r.Int31()) 8585 if r.Intn(2) == 0 { 8586 this.Round *= -1 8587 } 8588 if r.Intn(5) != 0 { 8589 v32 := r.Intn(5) 8590 this.Votes = make([]VoteInfo, v32) 8591 for i := 0; i < v32; i++ { 8592 v33 := NewPopulatedVoteInfo(r, easy) 8593 this.Votes[i] = *v33 8594 } 8595 } 8596 if !easy && r.Intn(10) != 0 { 8597 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8598 } 8599 return this 8600 } 8601 8602 func NewPopulatedEvent(r randyTypes, easy bool) *Event { 8603 this := &Event{} 8604 this.Type = string(randStringTypes(r)) 8605 if r.Intn(5) != 0 { 8606 v34 := r.Intn(5) 8607 this.Attributes = make([]kv.Pair, v34) 8608 for i := 0; i < v34; i++ { 8609 v35 := kv.NewPopulatedPair(r, easy) 8610 this.Attributes[i] = *v35 8611 } 8612 } 8613 if !easy && r.Intn(10) != 0 { 8614 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8615 } 8616 return this 8617 } 8618 8619 func NewPopulatedHeader(r randyTypes, easy bool) *Header { 8620 this := &Header{} 8621 v36 := NewPopulatedVersion(r, easy) 8622 this.Version = *v36 8623 this.ChainID = string(randStringTypes(r)) 8624 this.Height = int64(r.Int63()) 8625 if r.Intn(2) == 0 { 8626 this.Height *= -1 8627 } 8628 v37 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) 8629 this.Time = *v37 8630 this.NumTxs = int64(r.Int63()) 8631 if r.Intn(2) == 0 { 8632 this.NumTxs *= -1 8633 } 8634 this.TotalTxs = int64(r.Int63()) 8635 if r.Intn(2) == 0 { 8636 this.TotalTxs *= -1 8637 } 8638 v38 := NewPopulatedBlockID(r, easy) 8639 this.LastBlockId = *v38 8640 v39 := r.Intn(100) 8641 this.LastCommitHash = make([]byte, v39) 8642 for i := 0; i < v39; i++ { 8643 this.LastCommitHash[i] = byte(r.Intn(256)) 8644 } 8645 v40 := r.Intn(100) 8646 this.DataHash = make([]byte, v40) 8647 for i := 0; i < v40; i++ { 8648 this.DataHash[i] = byte(r.Intn(256)) 8649 } 8650 v41 := r.Intn(100) 8651 this.ValidatorsHash = make([]byte, v41) 8652 for i := 0; i < v41; i++ { 8653 this.ValidatorsHash[i] = byte(r.Intn(256)) 8654 } 8655 v42 := r.Intn(100) 8656 this.NextValidatorsHash = make([]byte, v42) 8657 for i := 0; i < v42; i++ { 8658 this.NextValidatorsHash[i] = byte(r.Intn(256)) 8659 } 8660 v43 := r.Intn(100) 8661 this.ConsensusHash = make([]byte, v43) 8662 for i := 0; i < v43; i++ { 8663 this.ConsensusHash[i] = byte(r.Intn(256)) 8664 } 8665 v44 := r.Intn(100) 8666 this.AppHash = make([]byte, v44) 8667 for i := 0; i < v44; i++ { 8668 this.AppHash[i] = byte(r.Intn(256)) 8669 } 8670 v45 := r.Intn(100) 8671 this.LastResultsHash = make([]byte, v45) 8672 for i := 0; i < v45; i++ { 8673 this.LastResultsHash[i] = byte(r.Intn(256)) 8674 } 8675 v46 := r.Intn(100) 8676 this.EvidenceHash = make([]byte, v46) 8677 for i := 0; i < v46; i++ { 8678 this.EvidenceHash[i] = byte(r.Intn(256)) 8679 } 8680 v47 := r.Intn(100) 8681 this.ProposerAddress = make([]byte, v47) 8682 for i := 0; i < v47; i++ { 8683 this.ProposerAddress[i] = byte(r.Intn(256)) 8684 } 8685 if !easy && r.Intn(10) != 0 { 8686 this.XXX_unrecognized = randUnrecognizedTypes(r, 17) 8687 } 8688 return this 8689 } 8690 8691 func NewPopulatedVersion(r randyTypes, easy bool) *Version { 8692 this := &Version{} 8693 this.Block = uint64(uint64(r.Uint32())) 8694 this.App = uint64(uint64(r.Uint32())) 8695 if !easy && r.Intn(10) != 0 { 8696 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8697 } 8698 return this 8699 } 8700 8701 func NewPopulatedBlockID(r randyTypes, easy bool) *BlockID { 8702 this := &BlockID{} 8703 v48 := r.Intn(100) 8704 this.Hash = make([]byte, v48) 8705 for i := 0; i < v48; i++ { 8706 this.Hash[i] = byte(r.Intn(256)) 8707 } 8708 v49 := NewPopulatedPartSetHeader(r, easy) 8709 this.PartsHeader = *v49 8710 if !easy && r.Intn(10) != 0 { 8711 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8712 } 8713 return this 8714 } 8715 8716 func NewPopulatedPartSetHeader(r randyTypes, easy bool) *PartSetHeader { 8717 this := &PartSetHeader{} 8718 this.Total = int32(r.Int31()) 8719 if r.Intn(2) == 0 { 8720 this.Total *= -1 8721 } 8722 v50 := r.Intn(100) 8723 this.Hash = make([]byte, v50) 8724 for i := 0; i < v50; i++ { 8725 this.Hash[i] = byte(r.Intn(256)) 8726 } 8727 if !easy && r.Intn(10) != 0 { 8728 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8729 } 8730 return this 8731 } 8732 8733 func NewPopulatedValidator(r randyTypes, easy bool) *Validator { 8734 this := &Validator{} 8735 v51 := r.Intn(100) 8736 this.Address = make([]byte, v51) 8737 for i := 0; i < v51; i++ { 8738 this.Address[i] = byte(r.Intn(256)) 8739 } 8740 this.Power = int64(r.Int63()) 8741 if r.Intn(2) == 0 { 8742 this.Power *= -1 8743 } 8744 if !easy && r.Intn(10) != 0 { 8745 this.XXX_unrecognized = randUnrecognizedTypes(r, 4) 8746 } 8747 return this 8748 } 8749 8750 func NewPopulatedValidatorUpdate(r randyTypes, easy bool) *ValidatorUpdate { 8751 this := &ValidatorUpdate{} 8752 v52 := NewPopulatedPubKey(r, easy) 8753 this.PubKey = *v52 8754 this.Power = int64(r.Int63()) 8755 if r.Intn(2) == 0 { 8756 this.Power *= -1 8757 } 8758 if !easy && r.Intn(10) != 0 { 8759 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8760 } 8761 return this 8762 } 8763 8764 func NewPopulatedVoteInfo(r randyTypes, easy bool) *VoteInfo { 8765 this := &VoteInfo{} 8766 v53 := NewPopulatedValidator(r, easy) 8767 this.Validator = *v53 8768 this.SignedLastBlock = bool(bool(r.Intn(2) == 0)) 8769 if !easy && r.Intn(10) != 0 { 8770 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8771 } 8772 return this 8773 } 8774 8775 func NewPopulatedPubKey(r randyTypes, easy bool) *PubKey { 8776 this := &PubKey{} 8777 this.Type = string(randStringTypes(r)) 8778 v54 := r.Intn(100) 8779 this.Data = make([]byte, v54) 8780 for i := 0; i < v54; i++ { 8781 this.Data[i] = byte(r.Intn(256)) 8782 } 8783 if !easy && r.Intn(10) != 0 { 8784 this.XXX_unrecognized = randUnrecognizedTypes(r, 3) 8785 } 8786 return this 8787 } 8788 8789 func NewPopulatedEvidence(r randyTypes, easy bool) *Evidence { 8790 this := &Evidence{} 8791 this.Type = string(randStringTypes(r)) 8792 v55 := NewPopulatedValidator(r, easy) 8793 this.Validator = *v55 8794 this.Height = int64(r.Int63()) 8795 if r.Intn(2) == 0 { 8796 this.Height *= -1 8797 } 8798 v56 := github_com_gogo_protobuf_types.NewPopulatedStdTime(r, easy) 8799 this.Time = *v56 8800 this.TotalVotingPower = int64(r.Int63()) 8801 if r.Intn(2) == 0 { 8802 this.TotalVotingPower *= -1 8803 } 8804 if !easy && r.Intn(10) != 0 { 8805 this.XXX_unrecognized = randUnrecognizedTypes(r, 6) 8806 } 8807 return this 8808 } 8809 8810 type randyTypes interface { 8811 Float32() float32 8812 Float64() float64 8813 Int63() int64 8814 Int31() int32 8815 Uint32() uint32 8816 Intn(n int) int 8817 } 8818 8819 func randUTF8RuneTypes(r randyTypes) rune { 8820 ru := r.Intn(62) 8821 if ru < 10 { 8822 return rune(ru + 48) 8823 } else if ru < 36 { 8824 return rune(ru + 55) 8825 } 8826 return rune(ru + 61) 8827 } 8828 func randStringTypes(r randyTypes) string { 8829 v57 := r.Intn(100) 8830 tmps := make([]rune, v57) 8831 for i := 0; i < v57; i++ { 8832 tmps[i] = randUTF8RuneTypes(r) 8833 } 8834 return string(tmps) 8835 } 8836 func randUnrecognizedTypes(r randyTypes, maxFieldNumber int) (dAtA []byte) { 8837 l := r.Intn(5) 8838 for i := 0; i < l; i++ { 8839 wire := r.Intn(4) 8840 if wire == 3 { 8841 wire = 5 8842 } 8843 fieldNumber := maxFieldNumber + r.Intn(100) 8844 dAtA = randFieldTypes(dAtA, r, fieldNumber, wire) 8845 } 8846 return dAtA 8847 } 8848 func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte { 8849 key := uint32(fieldNumber)<<3 | uint32(wire) 8850 switch wire { 8851 case 0: 8852 dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) 8853 v58 := r.Int63() 8854 if r.Intn(2) == 0 { 8855 v58 *= -1 8856 } 8857 dAtA = encodeVarintPopulateTypes(dAtA, uint64(v58)) 8858 case 1: 8859 dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) 8860 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) 8861 case 2: 8862 dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) 8863 ll := r.Intn(100) 8864 dAtA = encodeVarintPopulateTypes(dAtA, uint64(ll)) 8865 for j := 0; j < ll; j++ { 8866 dAtA = append(dAtA, byte(r.Intn(256))) 8867 } 8868 default: 8869 dAtA = encodeVarintPopulateTypes(dAtA, uint64(key)) 8870 dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256))) 8871 } 8872 return dAtA 8873 } 8874 func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte { 8875 for v >= 1<<7 { 8876 dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80)) 8877 v >>= 7 8878 } 8879 dAtA = append(dAtA, uint8(v)) 8880 return dAtA 8881 } 8882 func (m *Request) Size() (n int) { 8883 if m == nil { 8884 return 0 8885 } 8886 var l int 8887 _ = l 8888 if m.Value != nil { 8889 n += m.Value.Size() 8890 } 8891 if m.XXX_unrecognized != nil { 8892 n += len(m.XXX_unrecognized) 8893 } 8894 return n 8895 } 8896 8897 func (m *Request_Echo) Size() (n int) { 8898 if m == nil { 8899 return 0 8900 } 8901 var l int 8902 _ = l 8903 if m.Echo != nil { 8904 l = m.Echo.Size() 8905 n += 1 + l + sovTypes(uint64(l)) 8906 } 8907 return n 8908 } 8909 func (m *Request_Flush) Size() (n int) { 8910 if m == nil { 8911 return 0 8912 } 8913 var l int 8914 _ = l 8915 if m.Flush != nil { 8916 l = m.Flush.Size() 8917 n += 1 + l + sovTypes(uint64(l)) 8918 } 8919 return n 8920 } 8921 func (m *Request_Info) Size() (n int) { 8922 if m == nil { 8923 return 0 8924 } 8925 var l int 8926 _ = l 8927 if m.Info != nil { 8928 l = m.Info.Size() 8929 n += 1 + l + sovTypes(uint64(l)) 8930 } 8931 return n 8932 } 8933 func (m *Request_SetOption) Size() (n int) { 8934 if m == nil { 8935 return 0 8936 } 8937 var l int 8938 _ = l 8939 if m.SetOption != nil { 8940 l = m.SetOption.Size() 8941 n += 1 + l + sovTypes(uint64(l)) 8942 } 8943 return n 8944 } 8945 func (m *Request_InitChain) Size() (n int) { 8946 if m == nil { 8947 return 0 8948 } 8949 var l int 8950 _ = l 8951 if m.InitChain != nil { 8952 l = m.InitChain.Size() 8953 n += 1 + l + sovTypes(uint64(l)) 8954 } 8955 return n 8956 } 8957 func (m *Request_Query) Size() (n int) { 8958 if m == nil { 8959 return 0 8960 } 8961 var l int 8962 _ = l 8963 if m.Query != nil { 8964 l = m.Query.Size() 8965 n += 1 + l + sovTypes(uint64(l)) 8966 } 8967 return n 8968 } 8969 func (m *Request_BeginBlock) Size() (n int) { 8970 if m == nil { 8971 return 0 8972 } 8973 var l int 8974 _ = l 8975 if m.BeginBlock != nil { 8976 l = m.BeginBlock.Size() 8977 n += 1 + l + sovTypes(uint64(l)) 8978 } 8979 return n 8980 } 8981 func (m *Request_CheckTx) Size() (n int) { 8982 if m == nil { 8983 return 0 8984 } 8985 var l int 8986 _ = l 8987 if m.CheckTx != nil { 8988 l = m.CheckTx.Size() 8989 n += 1 + l + sovTypes(uint64(l)) 8990 } 8991 return n 8992 } 8993 func (m *Request_EndBlock) Size() (n int) { 8994 if m == nil { 8995 return 0 8996 } 8997 var l int 8998 _ = l 8999 if m.EndBlock != nil { 9000 l = m.EndBlock.Size() 9001 n += 1 + l + sovTypes(uint64(l)) 9002 } 9003 return n 9004 } 9005 func (m *Request_Commit) Size() (n int) { 9006 if m == nil { 9007 return 0 9008 } 9009 var l int 9010 _ = l 9011 if m.Commit != nil { 9012 l = m.Commit.Size() 9013 n += 1 + l + sovTypes(uint64(l)) 9014 } 9015 return n 9016 } 9017 func (m *Request_DeliverTx) Size() (n int) { 9018 if m == nil { 9019 return 0 9020 } 9021 var l int 9022 _ = l 9023 if m.DeliverTx != nil { 9024 l = m.DeliverTx.Size() 9025 n += 2 + l + sovTypes(uint64(l)) 9026 } 9027 return n 9028 } 9029 func (m *RequestEcho) Size() (n int) { 9030 if m == nil { 9031 return 0 9032 } 9033 var l int 9034 _ = l 9035 l = len(m.Message) 9036 if l > 0 { 9037 n += 1 + l + sovTypes(uint64(l)) 9038 } 9039 if m.XXX_unrecognized != nil { 9040 n += len(m.XXX_unrecognized) 9041 } 9042 return n 9043 } 9044 9045 func (m *RequestFlush) Size() (n int) { 9046 if m == nil { 9047 return 0 9048 } 9049 var l int 9050 _ = l 9051 if m.XXX_unrecognized != nil { 9052 n += len(m.XXX_unrecognized) 9053 } 9054 return n 9055 } 9056 9057 func (m *RequestInfo) Size() (n int) { 9058 if m == nil { 9059 return 0 9060 } 9061 var l int 9062 _ = l 9063 l = len(m.Version) 9064 if l > 0 { 9065 n += 1 + l + sovTypes(uint64(l)) 9066 } 9067 if m.BlockVersion != 0 { 9068 n += 1 + sovTypes(uint64(m.BlockVersion)) 9069 } 9070 if m.P2PVersion != 0 { 9071 n += 1 + sovTypes(uint64(m.P2PVersion)) 9072 } 9073 if m.XXX_unrecognized != nil { 9074 n += len(m.XXX_unrecognized) 9075 } 9076 return n 9077 } 9078 9079 func (m *RequestSetOption) Size() (n int) { 9080 if m == nil { 9081 return 0 9082 } 9083 var l int 9084 _ = l 9085 l = len(m.Key) 9086 if l > 0 { 9087 n += 1 + l + sovTypes(uint64(l)) 9088 } 9089 l = len(m.Value) 9090 if l > 0 { 9091 n += 1 + l + sovTypes(uint64(l)) 9092 } 9093 if m.XXX_unrecognized != nil { 9094 n += len(m.XXX_unrecognized) 9095 } 9096 return n 9097 } 9098 9099 func (m *RequestInitChain) Size() (n int) { 9100 if m == nil { 9101 return 0 9102 } 9103 var l int 9104 _ = l 9105 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time) 9106 n += 1 + l + sovTypes(uint64(l)) 9107 l = len(m.ChainId) 9108 if l > 0 { 9109 n += 1 + l + sovTypes(uint64(l)) 9110 } 9111 if m.ConsensusParams != nil { 9112 l = m.ConsensusParams.Size() 9113 n += 1 + l + sovTypes(uint64(l)) 9114 } 9115 if len(m.Validators) > 0 { 9116 for _, e := range m.Validators { 9117 l = e.Size() 9118 n += 1 + l + sovTypes(uint64(l)) 9119 } 9120 } 9121 l = len(m.AppStateBytes) 9122 if l > 0 { 9123 n += 1 + l + sovTypes(uint64(l)) 9124 } 9125 if m.XXX_unrecognized != nil { 9126 n += len(m.XXX_unrecognized) 9127 } 9128 return n 9129 } 9130 9131 func (m *RequestQuery) Size() (n int) { 9132 if m == nil { 9133 return 0 9134 } 9135 var l int 9136 _ = l 9137 l = len(m.Data) 9138 if l > 0 { 9139 n += 1 + l + sovTypes(uint64(l)) 9140 } 9141 l = len(m.Path) 9142 if l > 0 { 9143 n += 1 + l + sovTypes(uint64(l)) 9144 } 9145 if m.Height != 0 { 9146 n += 1 + sovTypes(uint64(m.Height)) 9147 } 9148 if m.Prove { 9149 n += 2 9150 } 9151 if m.XXX_unrecognized != nil { 9152 n += len(m.XXX_unrecognized) 9153 } 9154 return n 9155 } 9156 9157 func (m *RequestBeginBlock) Size() (n int) { 9158 if m == nil { 9159 return 0 9160 } 9161 var l int 9162 _ = l 9163 l = len(m.Hash) 9164 if l > 0 { 9165 n += 1 + l + sovTypes(uint64(l)) 9166 } 9167 l = m.Header.Size() 9168 n += 1 + l + sovTypes(uint64(l)) 9169 l = m.LastCommitInfo.Size() 9170 n += 1 + l + sovTypes(uint64(l)) 9171 if len(m.ByzantineValidators) > 0 { 9172 for _, e := range m.ByzantineValidators { 9173 l = e.Size() 9174 n += 1 + l + sovTypes(uint64(l)) 9175 } 9176 } 9177 if m.XXX_unrecognized != nil { 9178 n += len(m.XXX_unrecognized) 9179 } 9180 return n 9181 } 9182 9183 func (m *RequestCheckTx) Size() (n int) { 9184 if m == nil { 9185 return 0 9186 } 9187 var l int 9188 _ = l 9189 l = len(m.Tx) 9190 if l > 0 { 9191 n += 1 + l + sovTypes(uint64(l)) 9192 } 9193 if m.Type != 0 { 9194 n += 1 + sovTypes(uint64(m.Type)) 9195 } 9196 if m.XXX_unrecognized != nil { 9197 n += len(m.XXX_unrecognized) 9198 } 9199 return n 9200 } 9201 9202 func (m *RequestDeliverTx) Size() (n int) { 9203 if m == nil { 9204 return 0 9205 } 9206 var l int 9207 _ = l 9208 l = len(m.Tx) 9209 if l > 0 { 9210 n += 1 + l + sovTypes(uint64(l)) 9211 } 9212 if m.XXX_unrecognized != nil { 9213 n += len(m.XXX_unrecognized) 9214 } 9215 return n 9216 } 9217 9218 func (m *RequestEndBlock) Size() (n int) { 9219 if m == nil { 9220 return 0 9221 } 9222 var l int 9223 _ = l 9224 if m.Height != 0 { 9225 n += 1 + sovTypes(uint64(m.Height)) 9226 } 9227 if m.XXX_unrecognized != nil { 9228 n += len(m.XXX_unrecognized) 9229 } 9230 return n 9231 } 9232 9233 func (m *RequestCommit) Size() (n int) { 9234 if m == nil { 9235 return 0 9236 } 9237 var l int 9238 _ = l 9239 if m.XXX_unrecognized != nil { 9240 n += len(m.XXX_unrecognized) 9241 } 9242 return n 9243 } 9244 9245 func (m *Response) Size() (n int) { 9246 if m == nil { 9247 return 0 9248 } 9249 var l int 9250 _ = l 9251 if m.Value != nil { 9252 n += m.Value.Size() 9253 } 9254 if m.XXX_unrecognized != nil { 9255 n += len(m.XXX_unrecognized) 9256 } 9257 return n 9258 } 9259 9260 func (m *Response_Exception) Size() (n int) { 9261 if m == nil { 9262 return 0 9263 } 9264 var l int 9265 _ = l 9266 if m.Exception != nil { 9267 l = m.Exception.Size() 9268 n += 1 + l + sovTypes(uint64(l)) 9269 } 9270 return n 9271 } 9272 func (m *Response_Echo) Size() (n int) { 9273 if m == nil { 9274 return 0 9275 } 9276 var l int 9277 _ = l 9278 if m.Echo != nil { 9279 l = m.Echo.Size() 9280 n += 1 + l + sovTypes(uint64(l)) 9281 } 9282 return n 9283 } 9284 func (m *Response_Flush) Size() (n int) { 9285 if m == nil { 9286 return 0 9287 } 9288 var l int 9289 _ = l 9290 if m.Flush != nil { 9291 l = m.Flush.Size() 9292 n += 1 + l + sovTypes(uint64(l)) 9293 } 9294 return n 9295 } 9296 func (m *Response_Info) Size() (n int) { 9297 if m == nil { 9298 return 0 9299 } 9300 var l int 9301 _ = l 9302 if m.Info != nil { 9303 l = m.Info.Size() 9304 n += 1 + l + sovTypes(uint64(l)) 9305 } 9306 return n 9307 } 9308 func (m *Response_SetOption) Size() (n int) { 9309 if m == nil { 9310 return 0 9311 } 9312 var l int 9313 _ = l 9314 if m.SetOption != nil { 9315 l = m.SetOption.Size() 9316 n += 1 + l + sovTypes(uint64(l)) 9317 } 9318 return n 9319 } 9320 func (m *Response_InitChain) Size() (n int) { 9321 if m == nil { 9322 return 0 9323 } 9324 var l int 9325 _ = l 9326 if m.InitChain != nil { 9327 l = m.InitChain.Size() 9328 n += 1 + l + sovTypes(uint64(l)) 9329 } 9330 return n 9331 } 9332 func (m *Response_Query) Size() (n int) { 9333 if m == nil { 9334 return 0 9335 } 9336 var l int 9337 _ = l 9338 if m.Query != nil { 9339 l = m.Query.Size() 9340 n += 1 + l + sovTypes(uint64(l)) 9341 } 9342 return n 9343 } 9344 func (m *Response_BeginBlock) Size() (n int) { 9345 if m == nil { 9346 return 0 9347 } 9348 var l int 9349 _ = l 9350 if m.BeginBlock != nil { 9351 l = m.BeginBlock.Size() 9352 n += 1 + l + sovTypes(uint64(l)) 9353 } 9354 return n 9355 } 9356 func (m *Response_CheckTx) Size() (n int) { 9357 if m == nil { 9358 return 0 9359 } 9360 var l int 9361 _ = l 9362 if m.CheckTx != nil { 9363 l = m.CheckTx.Size() 9364 n += 1 + l + sovTypes(uint64(l)) 9365 } 9366 return n 9367 } 9368 func (m *Response_DeliverTx) Size() (n int) { 9369 if m == nil { 9370 return 0 9371 } 9372 var l int 9373 _ = l 9374 if m.DeliverTx != nil { 9375 l = m.DeliverTx.Size() 9376 n += 1 + l + sovTypes(uint64(l)) 9377 } 9378 return n 9379 } 9380 func (m *Response_EndBlock) Size() (n int) { 9381 if m == nil { 9382 return 0 9383 } 9384 var l int 9385 _ = l 9386 if m.EndBlock != nil { 9387 l = m.EndBlock.Size() 9388 n += 1 + l + sovTypes(uint64(l)) 9389 } 9390 return n 9391 } 9392 func (m *Response_Commit) Size() (n int) { 9393 if m == nil { 9394 return 0 9395 } 9396 var l int 9397 _ = l 9398 if m.Commit != nil { 9399 l = m.Commit.Size() 9400 n += 1 + l + sovTypes(uint64(l)) 9401 } 9402 return n 9403 } 9404 func (m *ResponseException) Size() (n int) { 9405 if m == nil { 9406 return 0 9407 } 9408 var l int 9409 _ = l 9410 l = len(m.Error) 9411 if l > 0 { 9412 n += 1 + l + sovTypes(uint64(l)) 9413 } 9414 if m.XXX_unrecognized != nil { 9415 n += len(m.XXX_unrecognized) 9416 } 9417 return n 9418 } 9419 9420 func (m *ResponseEcho) Size() (n int) { 9421 if m == nil { 9422 return 0 9423 } 9424 var l int 9425 _ = l 9426 l = len(m.Message) 9427 if l > 0 { 9428 n += 1 + l + sovTypes(uint64(l)) 9429 } 9430 if m.XXX_unrecognized != nil { 9431 n += len(m.XXX_unrecognized) 9432 } 9433 return n 9434 } 9435 9436 func (m *ResponseFlush) Size() (n int) { 9437 if m == nil { 9438 return 0 9439 } 9440 var l int 9441 _ = l 9442 if m.XXX_unrecognized != nil { 9443 n += len(m.XXX_unrecognized) 9444 } 9445 return n 9446 } 9447 9448 func (m *ResponseInfo) Size() (n int) { 9449 if m == nil { 9450 return 0 9451 } 9452 var l int 9453 _ = l 9454 l = len(m.Data) 9455 if l > 0 { 9456 n += 1 + l + sovTypes(uint64(l)) 9457 } 9458 l = len(m.Version) 9459 if l > 0 { 9460 n += 1 + l + sovTypes(uint64(l)) 9461 } 9462 if m.AppVersion != 0 { 9463 n += 1 + sovTypes(uint64(m.AppVersion)) 9464 } 9465 if m.LastBlockHeight != 0 { 9466 n += 1 + sovTypes(uint64(m.LastBlockHeight)) 9467 } 9468 l = len(m.LastBlockAppHash) 9469 if l > 0 { 9470 n += 1 + l + sovTypes(uint64(l)) 9471 } 9472 if m.XXX_unrecognized != nil { 9473 n += len(m.XXX_unrecognized) 9474 } 9475 return n 9476 } 9477 9478 func (m *ResponseSetOption) Size() (n int) { 9479 if m == nil { 9480 return 0 9481 } 9482 var l int 9483 _ = l 9484 if m.Code != 0 { 9485 n += 1 + sovTypes(uint64(m.Code)) 9486 } 9487 l = len(m.Log) 9488 if l > 0 { 9489 n += 1 + l + sovTypes(uint64(l)) 9490 } 9491 l = len(m.Info) 9492 if l > 0 { 9493 n += 1 + l + sovTypes(uint64(l)) 9494 } 9495 if m.XXX_unrecognized != nil { 9496 n += len(m.XXX_unrecognized) 9497 } 9498 return n 9499 } 9500 9501 func (m *ResponseInitChain) Size() (n int) { 9502 if m == nil { 9503 return 0 9504 } 9505 var l int 9506 _ = l 9507 if m.ConsensusParams != nil { 9508 l = m.ConsensusParams.Size() 9509 n += 1 + l + sovTypes(uint64(l)) 9510 } 9511 if len(m.Validators) > 0 { 9512 for _, e := range m.Validators { 9513 l = e.Size() 9514 n += 1 + l + sovTypes(uint64(l)) 9515 } 9516 } 9517 if m.XXX_unrecognized != nil { 9518 n += len(m.XXX_unrecognized) 9519 } 9520 return n 9521 } 9522 9523 func (m *ResponseQuery) Size() (n int) { 9524 if m == nil { 9525 return 0 9526 } 9527 var l int 9528 _ = l 9529 if m.Code != 0 { 9530 n += 1 + sovTypes(uint64(m.Code)) 9531 } 9532 l = len(m.Log) 9533 if l > 0 { 9534 n += 1 + l + sovTypes(uint64(l)) 9535 } 9536 l = len(m.Info) 9537 if l > 0 { 9538 n += 1 + l + sovTypes(uint64(l)) 9539 } 9540 if m.Index != 0 { 9541 n += 1 + sovTypes(uint64(m.Index)) 9542 } 9543 l = len(m.Key) 9544 if l > 0 { 9545 n += 1 + l + sovTypes(uint64(l)) 9546 } 9547 l = len(m.Value) 9548 if l > 0 { 9549 n += 1 + l + sovTypes(uint64(l)) 9550 } 9551 if m.Proof != nil { 9552 l = m.Proof.Size() 9553 n += 1 + l + sovTypes(uint64(l)) 9554 } 9555 if m.Height != 0 { 9556 n += 1 + sovTypes(uint64(m.Height)) 9557 } 9558 l = len(m.Codespace) 9559 if l > 0 { 9560 n += 1 + l + sovTypes(uint64(l)) 9561 } 9562 if m.XXX_unrecognized != nil { 9563 n += len(m.XXX_unrecognized) 9564 } 9565 return n 9566 } 9567 9568 func (m *ResponseBeginBlock) Size() (n int) { 9569 if m == nil { 9570 return 0 9571 } 9572 var l int 9573 _ = l 9574 if len(m.Events) > 0 { 9575 for _, e := range m.Events { 9576 l = e.Size() 9577 n += 1 + l + sovTypes(uint64(l)) 9578 } 9579 } 9580 if m.XXX_unrecognized != nil { 9581 n += len(m.XXX_unrecognized) 9582 } 9583 return n 9584 } 9585 9586 func (m *ResponseCheckTx) Size() (n int) { 9587 if m == nil { 9588 return 0 9589 } 9590 var l int 9591 _ = l 9592 if m.Code != 0 { 9593 n += 1 + sovTypes(uint64(m.Code)) 9594 } 9595 l = len(m.Data) 9596 if l > 0 { 9597 n += 1 + l + sovTypes(uint64(l)) 9598 } 9599 l = len(m.Log) 9600 if l > 0 { 9601 n += 1 + l + sovTypes(uint64(l)) 9602 } 9603 l = len(m.Info) 9604 if l > 0 { 9605 n += 1 + l + sovTypes(uint64(l)) 9606 } 9607 if m.GasWanted != 0 { 9608 n += 1 + sovTypes(uint64(m.GasWanted)) 9609 } 9610 if m.GasUsed != 0 { 9611 n += 1 + sovTypes(uint64(m.GasUsed)) 9612 } 9613 if len(m.Events) > 0 { 9614 for _, e := range m.Events { 9615 l = e.Size() 9616 n += 1 + l + sovTypes(uint64(l)) 9617 } 9618 } 9619 l = len(m.Codespace) 9620 if l > 0 { 9621 n += 1 + l + sovTypes(uint64(l)) 9622 } 9623 if m.XXX_unrecognized != nil { 9624 n += len(m.XXX_unrecognized) 9625 } 9626 return n 9627 } 9628 9629 func (m *ResponseDeliverTx) Size() (n int) { 9630 if m == nil { 9631 return 0 9632 } 9633 var l int 9634 _ = l 9635 if m.Code != 0 { 9636 n += 1 + sovTypes(uint64(m.Code)) 9637 } 9638 l = len(m.Data) 9639 if l > 0 { 9640 n += 1 + l + sovTypes(uint64(l)) 9641 } 9642 l = len(m.Log) 9643 if l > 0 { 9644 n += 1 + l + sovTypes(uint64(l)) 9645 } 9646 l = len(m.Info) 9647 if l > 0 { 9648 n += 1 + l + sovTypes(uint64(l)) 9649 } 9650 if m.GasWanted != 0 { 9651 n += 1 + sovTypes(uint64(m.GasWanted)) 9652 } 9653 if m.GasUsed != 0 { 9654 n += 1 + sovTypes(uint64(m.GasUsed)) 9655 } 9656 if len(m.Events) > 0 { 9657 for _, e := range m.Events { 9658 l = e.Size() 9659 n += 1 + l + sovTypes(uint64(l)) 9660 } 9661 } 9662 l = len(m.Codespace) 9663 if l > 0 { 9664 n += 1 + l + sovTypes(uint64(l)) 9665 } 9666 if m.XXX_unrecognized != nil { 9667 n += len(m.XXX_unrecognized) 9668 } 9669 return n 9670 } 9671 9672 func (m *ResponseEndBlock) Size() (n int) { 9673 if m == nil { 9674 return 0 9675 } 9676 var l int 9677 _ = l 9678 if len(m.ValidatorUpdates) > 0 { 9679 for _, e := range m.ValidatorUpdates { 9680 l = e.Size() 9681 n += 1 + l + sovTypes(uint64(l)) 9682 } 9683 } 9684 if m.ConsensusParamUpdates != nil { 9685 l = m.ConsensusParamUpdates.Size() 9686 n += 1 + l + sovTypes(uint64(l)) 9687 } 9688 if len(m.Events) > 0 { 9689 for _, e := range m.Events { 9690 l = e.Size() 9691 n += 1 + l + sovTypes(uint64(l)) 9692 } 9693 } 9694 if m.XXX_unrecognized != nil { 9695 n += len(m.XXX_unrecognized) 9696 } 9697 return n 9698 } 9699 9700 func (m *ResponseCommit) Size() (n int) { 9701 if m == nil { 9702 return 0 9703 } 9704 var l int 9705 _ = l 9706 l = len(m.Data) 9707 if l > 0 { 9708 n += 1 + l + sovTypes(uint64(l)) 9709 } 9710 if m.RetainHeight != 0 { 9711 n += 1 + sovTypes(uint64(m.RetainHeight)) 9712 } 9713 if m.XXX_unrecognized != nil { 9714 n += len(m.XXX_unrecognized) 9715 } 9716 return n 9717 } 9718 9719 func (m *ConsensusParams) Size() (n int) { 9720 if m == nil { 9721 return 0 9722 } 9723 var l int 9724 _ = l 9725 if m.Block != nil { 9726 l = m.Block.Size() 9727 n += 1 + l + sovTypes(uint64(l)) 9728 } 9729 if m.Evidence != nil { 9730 l = m.Evidence.Size() 9731 n += 1 + l + sovTypes(uint64(l)) 9732 } 9733 if m.Validator != nil { 9734 l = m.Validator.Size() 9735 n += 1 + l + sovTypes(uint64(l)) 9736 } 9737 if m.XXX_unrecognized != nil { 9738 n += len(m.XXX_unrecognized) 9739 } 9740 return n 9741 } 9742 9743 func (m *BlockParams) Size() (n int) { 9744 if m == nil { 9745 return 0 9746 } 9747 var l int 9748 _ = l 9749 if m.MaxBytes != 0 { 9750 n += 1 + sovTypes(uint64(m.MaxBytes)) 9751 } 9752 if m.MaxGas != 0 { 9753 n += 1 + sovTypes(uint64(m.MaxGas)) 9754 } 9755 if m.XXX_unrecognized != nil { 9756 n += len(m.XXX_unrecognized) 9757 } 9758 return n 9759 } 9760 9761 func (m *EvidenceParams) Size() (n int) { 9762 if m == nil { 9763 return 0 9764 } 9765 var l int 9766 _ = l 9767 if m.MaxAge != 0 { 9768 n += 1 + sovTypes(uint64(m.MaxAge)) 9769 } 9770 if m.XXX_unrecognized != nil { 9771 n += len(m.XXX_unrecognized) 9772 } 9773 return n 9774 } 9775 9776 func (m *ValidatorParams) Size() (n int) { 9777 if m == nil { 9778 return 0 9779 } 9780 var l int 9781 _ = l 9782 if len(m.PubKeyTypes) > 0 { 9783 for _, s := range m.PubKeyTypes { 9784 l = len(s) 9785 n += 1 + l + sovTypes(uint64(l)) 9786 } 9787 } 9788 if m.XXX_unrecognized != nil { 9789 n += len(m.XXX_unrecognized) 9790 } 9791 return n 9792 } 9793 9794 func (m *LastCommitInfo) Size() (n int) { 9795 if m == nil { 9796 return 0 9797 } 9798 var l int 9799 _ = l 9800 if m.Round != 0 { 9801 n += 1 + sovTypes(uint64(m.Round)) 9802 } 9803 if len(m.Votes) > 0 { 9804 for _, e := range m.Votes { 9805 l = e.Size() 9806 n += 1 + l + sovTypes(uint64(l)) 9807 } 9808 } 9809 if m.XXX_unrecognized != nil { 9810 n += len(m.XXX_unrecognized) 9811 } 9812 return n 9813 } 9814 9815 func (m *Event) Size() (n int) { 9816 if m == nil { 9817 return 0 9818 } 9819 var l int 9820 _ = l 9821 l = len(m.Type) 9822 if l > 0 { 9823 n += 1 + l + sovTypes(uint64(l)) 9824 } 9825 if len(m.Attributes) > 0 { 9826 for _, e := range m.Attributes { 9827 l = e.Size() 9828 n += 1 + l + sovTypes(uint64(l)) 9829 } 9830 } 9831 if m.XXX_unrecognized != nil { 9832 n += len(m.XXX_unrecognized) 9833 } 9834 return n 9835 } 9836 9837 func (m *Header) Size() (n int) { 9838 if m == nil { 9839 return 0 9840 } 9841 var l int 9842 _ = l 9843 l = m.Version.Size() 9844 n += 1 + l + sovTypes(uint64(l)) 9845 l = len(m.ChainID) 9846 if l > 0 { 9847 n += 1 + l + sovTypes(uint64(l)) 9848 } 9849 if m.Height != 0 { 9850 n += 1 + sovTypes(uint64(m.Height)) 9851 } 9852 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time) 9853 n += 1 + l + sovTypes(uint64(l)) 9854 if m.NumTxs != 0 { 9855 n += 1 + sovTypes(uint64(m.NumTxs)) 9856 } 9857 if m.TotalTxs != 0 { 9858 n += 1 + sovTypes(uint64(m.TotalTxs)) 9859 } 9860 l = m.LastBlockId.Size() 9861 n += 1 + l + sovTypes(uint64(l)) 9862 l = len(m.LastCommitHash) 9863 if l > 0 { 9864 n += 1 + l + sovTypes(uint64(l)) 9865 } 9866 l = len(m.DataHash) 9867 if l > 0 { 9868 n += 1 + l + sovTypes(uint64(l)) 9869 } 9870 l = len(m.ValidatorsHash) 9871 if l > 0 { 9872 n += 1 + l + sovTypes(uint64(l)) 9873 } 9874 l = len(m.NextValidatorsHash) 9875 if l > 0 { 9876 n += 1 + l + sovTypes(uint64(l)) 9877 } 9878 l = len(m.ConsensusHash) 9879 if l > 0 { 9880 n += 1 + l + sovTypes(uint64(l)) 9881 } 9882 l = len(m.AppHash) 9883 if l > 0 { 9884 n += 1 + l + sovTypes(uint64(l)) 9885 } 9886 l = len(m.LastResultsHash) 9887 if l > 0 { 9888 n += 1 + l + sovTypes(uint64(l)) 9889 } 9890 l = len(m.EvidenceHash) 9891 if l > 0 { 9892 n += 1 + l + sovTypes(uint64(l)) 9893 } 9894 l = len(m.ProposerAddress) 9895 if l > 0 { 9896 n += 2 + l + sovTypes(uint64(l)) 9897 } 9898 if m.XXX_unrecognized != nil { 9899 n += len(m.XXX_unrecognized) 9900 } 9901 return n 9902 } 9903 9904 func (m *Version) Size() (n int) { 9905 if m == nil { 9906 return 0 9907 } 9908 var l int 9909 _ = l 9910 if m.Block != 0 { 9911 n += 1 + sovTypes(uint64(m.Block)) 9912 } 9913 if m.App != 0 { 9914 n += 1 + sovTypes(uint64(m.App)) 9915 } 9916 if m.XXX_unrecognized != nil { 9917 n += len(m.XXX_unrecognized) 9918 } 9919 return n 9920 } 9921 9922 func (m *BlockID) Size() (n int) { 9923 if m == nil { 9924 return 0 9925 } 9926 var l int 9927 _ = l 9928 l = len(m.Hash) 9929 if l > 0 { 9930 n += 1 + l + sovTypes(uint64(l)) 9931 } 9932 l = m.PartsHeader.Size() 9933 n += 1 + l + sovTypes(uint64(l)) 9934 if m.XXX_unrecognized != nil { 9935 n += len(m.XXX_unrecognized) 9936 } 9937 return n 9938 } 9939 9940 func (m *PartSetHeader) Size() (n int) { 9941 if m == nil { 9942 return 0 9943 } 9944 var l int 9945 _ = l 9946 if m.Total != 0 { 9947 n += 1 + sovTypes(uint64(m.Total)) 9948 } 9949 l = len(m.Hash) 9950 if l > 0 { 9951 n += 1 + l + sovTypes(uint64(l)) 9952 } 9953 if m.XXX_unrecognized != nil { 9954 n += len(m.XXX_unrecognized) 9955 } 9956 return n 9957 } 9958 9959 func (m *Validator) Size() (n int) { 9960 if m == nil { 9961 return 0 9962 } 9963 var l int 9964 _ = l 9965 l = len(m.Address) 9966 if l > 0 { 9967 n += 1 + l + sovTypes(uint64(l)) 9968 } 9969 if m.Power != 0 { 9970 n += 1 + sovTypes(uint64(m.Power)) 9971 } 9972 if m.XXX_unrecognized != nil { 9973 n += len(m.XXX_unrecognized) 9974 } 9975 return n 9976 } 9977 9978 func (m *ValidatorUpdate) Size() (n int) { 9979 if m == nil { 9980 return 0 9981 } 9982 var l int 9983 _ = l 9984 l = m.PubKey.Size() 9985 n += 1 + l + sovTypes(uint64(l)) 9986 if m.Power != 0 { 9987 n += 1 + sovTypes(uint64(m.Power)) 9988 } 9989 if m.XXX_unrecognized != nil { 9990 n += len(m.XXX_unrecognized) 9991 } 9992 return n 9993 } 9994 9995 func (m *VoteInfo) Size() (n int) { 9996 if m == nil { 9997 return 0 9998 } 9999 var l int 10000 _ = l 10001 l = m.Validator.Size() 10002 n += 1 + l + sovTypes(uint64(l)) 10003 if m.SignedLastBlock { 10004 n += 2 10005 } 10006 if m.XXX_unrecognized != nil { 10007 n += len(m.XXX_unrecognized) 10008 } 10009 return n 10010 } 10011 10012 func (m *PubKey) Size() (n int) { 10013 if m == nil { 10014 return 0 10015 } 10016 var l int 10017 _ = l 10018 l = len(m.Type) 10019 if l > 0 { 10020 n += 1 + l + sovTypes(uint64(l)) 10021 } 10022 l = len(m.Data) 10023 if l > 0 { 10024 n += 1 + l + sovTypes(uint64(l)) 10025 } 10026 if m.XXX_unrecognized != nil { 10027 n += len(m.XXX_unrecognized) 10028 } 10029 return n 10030 } 10031 10032 func (m *Evidence) Size() (n int) { 10033 if m == nil { 10034 return 0 10035 } 10036 var l int 10037 _ = l 10038 l = len(m.Type) 10039 if l > 0 { 10040 n += 1 + l + sovTypes(uint64(l)) 10041 } 10042 l = m.Validator.Size() 10043 n += 1 + l + sovTypes(uint64(l)) 10044 if m.Height != 0 { 10045 n += 1 + sovTypes(uint64(m.Height)) 10046 } 10047 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time) 10048 n += 1 + l + sovTypes(uint64(l)) 10049 if m.TotalVotingPower != 0 { 10050 n += 1 + sovTypes(uint64(m.TotalVotingPower)) 10051 } 10052 if m.XXX_unrecognized != nil { 10053 n += len(m.XXX_unrecognized) 10054 } 10055 return n 10056 } 10057 10058 func sovTypes(x uint64) (n int) { 10059 return (math_bits.Len64(x|1) + 6) / 7 10060 } 10061 func sozTypes(x uint64) (n int) { 10062 return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 10063 } 10064 func (m *Request) Unmarshal(dAtA []byte) error { 10065 l := len(dAtA) 10066 iNdEx := 0 10067 for iNdEx < l { 10068 preIndex := iNdEx 10069 var wire uint64 10070 for shift := uint(0); ; shift += 7 { 10071 if shift >= 64 { 10072 return ErrIntOverflowTypes 10073 } 10074 if iNdEx >= l { 10075 return io.ErrUnexpectedEOF 10076 } 10077 b := dAtA[iNdEx] 10078 iNdEx++ 10079 wire |= uint64(b&0x7F) << shift 10080 if b < 0x80 { 10081 break 10082 } 10083 } 10084 fieldNum := int32(wire >> 3) 10085 wireType := int(wire & 0x7) 10086 if wireType == 4 { 10087 return fmt.Errorf("proto: Request: wiretype end group for non-group") 10088 } 10089 if fieldNum <= 0 { 10090 return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) 10091 } 10092 switch fieldNum { 10093 case 2: 10094 if wireType != 2 { 10095 return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType) 10096 } 10097 var msglen int 10098 for shift := uint(0); ; shift += 7 { 10099 if shift >= 64 { 10100 return ErrIntOverflowTypes 10101 } 10102 if iNdEx >= l { 10103 return io.ErrUnexpectedEOF 10104 } 10105 b := dAtA[iNdEx] 10106 iNdEx++ 10107 msglen |= int(b&0x7F) << shift 10108 if b < 0x80 { 10109 break 10110 } 10111 } 10112 if msglen < 0 { 10113 return ErrInvalidLengthTypes 10114 } 10115 postIndex := iNdEx + msglen 10116 if postIndex < 0 { 10117 return ErrInvalidLengthTypes 10118 } 10119 if postIndex > l { 10120 return io.ErrUnexpectedEOF 10121 } 10122 v := &RequestEcho{} 10123 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10124 return err 10125 } 10126 m.Value = &Request_Echo{v} 10127 iNdEx = postIndex 10128 case 3: 10129 if wireType != 2 { 10130 return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType) 10131 } 10132 var msglen int 10133 for shift := uint(0); ; shift += 7 { 10134 if shift >= 64 { 10135 return ErrIntOverflowTypes 10136 } 10137 if iNdEx >= l { 10138 return io.ErrUnexpectedEOF 10139 } 10140 b := dAtA[iNdEx] 10141 iNdEx++ 10142 msglen |= int(b&0x7F) << shift 10143 if b < 0x80 { 10144 break 10145 } 10146 } 10147 if msglen < 0 { 10148 return ErrInvalidLengthTypes 10149 } 10150 postIndex := iNdEx + msglen 10151 if postIndex < 0 { 10152 return ErrInvalidLengthTypes 10153 } 10154 if postIndex > l { 10155 return io.ErrUnexpectedEOF 10156 } 10157 v := &RequestFlush{} 10158 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10159 return err 10160 } 10161 m.Value = &Request_Flush{v} 10162 iNdEx = postIndex 10163 case 4: 10164 if wireType != 2 { 10165 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 10166 } 10167 var msglen int 10168 for shift := uint(0); ; shift += 7 { 10169 if shift >= 64 { 10170 return ErrIntOverflowTypes 10171 } 10172 if iNdEx >= l { 10173 return io.ErrUnexpectedEOF 10174 } 10175 b := dAtA[iNdEx] 10176 iNdEx++ 10177 msglen |= int(b&0x7F) << shift 10178 if b < 0x80 { 10179 break 10180 } 10181 } 10182 if msglen < 0 { 10183 return ErrInvalidLengthTypes 10184 } 10185 postIndex := iNdEx + msglen 10186 if postIndex < 0 { 10187 return ErrInvalidLengthTypes 10188 } 10189 if postIndex > l { 10190 return io.ErrUnexpectedEOF 10191 } 10192 v := &RequestInfo{} 10193 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10194 return err 10195 } 10196 m.Value = &Request_Info{v} 10197 iNdEx = postIndex 10198 case 5: 10199 if wireType != 2 { 10200 return fmt.Errorf("proto: wrong wireType = %d for field SetOption", wireType) 10201 } 10202 var msglen int 10203 for shift := uint(0); ; shift += 7 { 10204 if shift >= 64 { 10205 return ErrIntOverflowTypes 10206 } 10207 if iNdEx >= l { 10208 return io.ErrUnexpectedEOF 10209 } 10210 b := dAtA[iNdEx] 10211 iNdEx++ 10212 msglen |= int(b&0x7F) << shift 10213 if b < 0x80 { 10214 break 10215 } 10216 } 10217 if msglen < 0 { 10218 return ErrInvalidLengthTypes 10219 } 10220 postIndex := iNdEx + msglen 10221 if postIndex < 0 { 10222 return ErrInvalidLengthTypes 10223 } 10224 if postIndex > l { 10225 return io.ErrUnexpectedEOF 10226 } 10227 v := &RequestSetOption{} 10228 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10229 return err 10230 } 10231 m.Value = &Request_SetOption{v} 10232 iNdEx = postIndex 10233 case 6: 10234 if wireType != 2 { 10235 return fmt.Errorf("proto: wrong wireType = %d for field InitChain", wireType) 10236 } 10237 var msglen int 10238 for shift := uint(0); ; shift += 7 { 10239 if shift >= 64 { 10240 return ErrIntOverflowTypes 10241 } 10242 if iNdEx >= l { 10243 return io.ErrUnexpectedEOF 10244 } 10245 b := dAtA[iNdEx] 10246 iNdEx++ 10247 msglen |= int(b&0x7F) << shift 10248 if b < 0x80 { 10249 break 10250 } 10251 } 10252 if msglen < 0 { 10253 return ErrInvalidLengthTypes 10254 } 10255 postIndex := iNdEx + msglen 10256 if postIndex < 0 { 10257 return ErrInvalidLengthTypes 10258 } 10259 if postIndex > l { 10260 return io.ErrUnexpectedEOF 10261 } 10262 v := &RequestInitChain{} 10263 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10264 return err 10265 } 10266 m.Value = &Request_InitChain{v} 10267 iNdEx = postIndex 10268 case 7: 10269 if wireType != 2 { 10270 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 10271 } 10272 var msglen int 10273 for shift := uint(0); ; shift += 7 { 10274 if shift >= 64 { 10275 return ErrIntOverflowTypes 10276 } 10277 if iNdEx >= l { 10278 return io.ErrUnexpectedEOF 10279 } 10280 b := dAtA[iNdEx] 10281 iNdEx++ 10282 msglen |= int(b&0x7F) << shift 10283 if b < 0x80 { 10284 break 10285 } 10286 } 10287 if msglen < 0 { 10288 return ErrInvalidLengthTypes 10289 } 10290 postIndex := iNdEx + msglen 10291 if postIndex < 0 { 10292 return ErrInvalidLengthTypes 10293 } 10294 if postIndex > l { 10295 return io.ErrUnexpectedEOF 10296 } 10297 v := &RequestQuery{} 10298 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10299 return err 10300 } 10301 m.Value = &Request_Query{v} 10302 iNdEx = postIndex 10303 case 8: 10304 if wireType != 2 { 10305 return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType) 10306 } 10307 var msglen int 10308 for shift := uint(0); ; shift += 7 { 10309 if shift >= 64 { 10310 return ErrIntOverflowTypes 10311 } 10312 if iNdEx >= l { 10313 return io.ErrUnexpectedEOF 10314 } 10315 b := dAtA[iNdEx] 10316 iNdEx++ 10317 msglen |= int(b&0x7F) << shift 10318 if b < 0x80 { 10319 break 10320 } 10321 } 10322 if msglen < 0 { 10323 return ErrInvalidLengthTypes 10324 } 10325 postIndex := iNdEx + msglen 10326 if postIndex < 0 { 10327 return ErrInvalidLengthTypes 10328 } 10329 if postIndex > l { 10330 return io.ErrUnexpectedEOF 10331 } 10332 v := &RequestBeginBlock{} 10333 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10334 return err 10335 } 10336 m.Value = &Request_BeginBlock{v} 10337 iNdEx = postIndex 10338 case 9: 10339 if wireType != 2 { 10340 return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) 10341 } 10342 var msglen int 10343 for shift := uint(0); ; shift += 7 { 10344 if shift >= 64 { 10345 return ErrIntOverflowTypes 10346 } 10347 if iNdEx >= l { 10348 return io.ErrUnexpectedEOF 10349 } 10350 b := dAtA[iNdEx] 10351 iNdEx++ 10352 msglen |= int(b&0x7F) << shift 10353 if b < 0x80 { 10354 break 10355 } 10356 } 10357 if msglen < 0 { 10358 return ErrInvalidLengthTypes 10359 } 10360 postIndex := iNdEx + msglen 10361 if postIndex < 0 { 10362 return ErrInvalidLengthTypes 10363 } 10364 if postIndex > l { 10365 return io.ErrUnexpectedEOF 10366 } 10367 v := &RequestCheckTx{} 10368 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10369 return err 10370 } 10371 m.Value = &Request_CheckTx{v} 10372 iNdEx = postIndex 10373 case 11: 10374 if wireType != 2 { 10375 return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) 10376 } 10377 var msglen int 10378 for shift := uint(0); ; shift += 7 { 10379 if shift >= 64 { 10380 return ErrIntOverflowTypes 10381 } 10382 if iNdEx >= l { 10383 return io.ErrUnexpectedEOF 10384 } 10385 b := dAtA[iNdEx] 10386 iNdEx++ 10387 msglen |= int(b&0x7F) << shift 10388 if b < 0x80 { 10389 break 10390 } 10391 } 10392 if msglen < 0 { 10393 return ErrInvalidLengthTypes 10394 } 10395 postIndex := iNdEx + msglen 10396 if postIndex < 0 { 10397 return ErrInvalidLengthTypes 10398 } 10399 if postIndex > l { 10400 return io.ErrUnexpectedEOF 10401 } 10402 v := &RequestEndBlock{} 10403 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10404 return err 10405 } 10406 m.Value = &Request_EndBlock{v} 10407 iNdEx = postIndex 10408 case 12: 10409 if wireType != 2 { 10410 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) 10411 } 10412 var msglen int 10413 for shift := uint(0); ; shift += 7 { 10414 if shift >= 64 { 10415 return ErrIntOverflowTypes 10416 } 10417 if iNdEx >= l { 10418 return io.ErrUnexpectedEOF 10419 } 10420 b := dAtA[iNdEx] 10421 iNdEx++ 10422 msglen |= int(b&0x7F) << shift 10423 if b < 0x80 { 10424 break 10425 } 10426 } 10427 if msglen < 0 { 10428 return ErrInvalidLengthTypes 10429 } 10430 postIndex := iNdEx + msglen 10431 if postIndex < 0 { 10432 return ErrInvalidLengthTypes 10433 } 10434 if postIndex > l { 10435 return io.ErrUnexpectedEOF 10436 } 10437 v := &RequestCommit{} 10438 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10439 return err 10440 } 10441 m.Value = &Request_Commit{v} 10442 iNdEx = postIndex 10443 case 19: 10444 if wireType != 2 { 10445 return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) 10446 } 10447 var msglen int 10448 for shift := uint(0); ; shift += 7 { 10449 if shift >= 64 { 10450 return ErrIntOverflowTypes 10451 } 10452 if iNdEx >= l { 10453 return io.ErrUnexpectedEOF 10454 } 10455 b := dAtA[iNdEx] 10456 iNdEx++ 10457 msglen |= int(b&0x7F) << shift 10458 if b < 0x80 { 10459 break 10460 } 10461 } 10462 if msglen < 0 { 10463 return ErrInvalidLengthTypes 10464 } 10465 postIndex := iNdEx + msglen 10466 if postIndex < 0 { 10467 return ErrInvalidLengthTypes 10468 } 10469 if postIndex > l { 10470 return io.ErrUnexpectedEOF 10471 } 10472 v := &RequestDeliverTx{} 10473 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10474 return err 10475 } 10476 m.Value = &Request_DeliverTx{v} 10477 iNdEx = postIndex 10478 default: 10479 iNdEx = preIndex 10480 skippy, err := skipTypes(dAtA[iNdEx:]) 10481 if err != nil { 10482 return err 10483 } 10484 if skippy < 0 { 10485 return ErrInvalidLengthTypes 10486 } 10487 if (iNdEx + skippy) < 0 { 10488 return ErrInvalidLengthTypes 10489 } 10490 if (iNdEx + skippy) > l { 10491 return io.ErrUnexpectedEOF 10492 } 10493 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 10494 iNdEx += skippy 10495 } 10496 } 10497 10498 if iNdEx > l { 10499 return io.ErrUnexpectedEOF 10500 } 10501 return nil 10502 } 10503 func (m *RequestEcho) Unmarshal(dAtA []byte) error { 10504 l := len(dAtA) 10505 iNdEx := 0 10506 for iNdEx < l { 10507 preIndex := iNdEx 10508 var wire uint64 10509 for shift := uint(0); ; shift += 7 { 10510 if shift >= 64 { 10511 return ErrIntOverflowTypes 10512 } 10513 if iNdEx >= l { 10514 return io.ErrUnexpectedEOF 10515 } 10516 b := dAtA[iNdEx] 10517 iNdEx++ 10518 wire |= uint64(b&0x7F) << shift 10519 if b < 0x80 { 10520 break 10521 } 10522 } 10523 fieldNum := int32(wire >> 3) 10524 wireType := int(wire & 0x7) 10525 if wireType == 4 { 10526 return fmt.Errorf("proto: RequestEcho: wiretype end group for non-group") 10527 } 10528 if fieldNum <= 0 { 10529 return fmt.Errorf("proto: RequestEcho: illegal tag %d (wire type %d)", fieldNum, wire) 10530 } 10531 switch fieldNum { 10532 case 1: 10533 if wireType != 2 { 10534 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 10535 } 10536 var stringLen uint64 10537 for shift := uint(0); ; shift += 7 { 10538 if shift >= 64 { 10539 return ErrIntOverflowTypes 10540 } 10541 if iNdEx >= l { 10542 return io.ErrUnexpectedEOF 10543 } 10544 b := dAtA[iNdEx] 10545 iNdEx++ 10546 stringLen |= uint64(b&0x7F) << shift 10547 if b < 0x80 { 10548 break 10549 } 10550 } 10551 intStringLen := int(stringLen) 10552 if intStringLen < 0 { 10553 return ErrInvalidLengthTypes 10554 } 10555 postIndex := iNdEx + intStringLen 10556 if postIndex < 0 { 10557 return ErrInvalidLengthTypes 10558 } 10559 if postIndex > l { 10560 return io.ErrUnexpectedEOF 10561 } 10562 m.Message = string(dAtA[iNdEx:postIndex]) 10563 iNdEx = postIndex 10564 default: 10565 iNdEx = preIndex 10566 skippy, err := skipTypes(dAtA[iNdEx:]) 10567 if err != nil { 10568 return err 10569 } 10570 if skippy < 0 { 10571 return ErrInvalidLengthTypes 10572 } 10573 if (iNdEx + skippy) < 0 { 10574 return ErrInvalidLengthTypes 10575 } 10576 if (iNdEx + skippy) > l { 10577 return io.ErrUnexpectedEOF 10578 } 10579 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 10580 iNdEx += skippy 10581 } 10582 } 10583 10584 if iNdEx > l { 10585 return io.ErrUnexpectedEOF 10586 } 10587 return nil 10588 } 10589 func (m *RequestFlush) Unmarshal(dAtA []byte) error { 10590 l := len(dAtA) 10591 iNdEx := 0 10592 for iNdEx < l { 10593 preIndex := iNdEx 10594 var wire uint64 10595 for shift := uint(0); ; shift += 7 { 10596 if shift >= 64 { 10597 return ErrIntOverflowTypes 10598 } 10599 if iNdEx >= l { 10600 return io.ErrUnexpectedEOF 10601 } 10602 b := dAtA[iNdEx] 10603 iNdEx++ 10604 wire |= uint64(b&0x7F) << shift 10605 if b < 0x80 { 10606 break 10607 } 10608 } 10609 fieldNum := int32(wire >> 3) 10610 wireType := int(wire & 0x7) 10611 if wireType == 4 { 10612 return fmt.Errorf("proto: RequestFlush: wiretype end group for non-group") 10613 } 10614 if fieldNum <= 0 { 10615 return fmt.Errorf("proto: RequestFlush: illegal tag %d (wire type %d)", fieldNum, wire) 10616 } 10617 switch fieldNum { 10618 default: 10619 iNdEx = preIndex 10620 skippy, err := skipTypes(dAtA[iNdEx:]) 10621 if err != nil { 10622 return err 10623 } 10624 if skippy < 0 { 10625 return ErrInvalidLengthTypes 10626 } 10627 if (iNdEx + skippy) < 0 { 10628 return ErrInvalidLengthTypes 10629 } 10630 if (iNdEx + skippy) > l { 10631 return io.ErrUnexpectedEOF 10632 } 10633 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 10634 iNdEx += skippy 10635 } 10636 } 10637 10638 if iNdEx > l { 10639 return io.ErrUnexpectedEOF 10640 } 10641 return nil 10642 } 10643 func (m *RequestInfo) Unmarshal(dAtA []byte) error { 10644 l := len(dAtA) 10645 iNdEx := 0 10646 for iNdEx < l { 10647 preIndex := iNdEx 10648 var wire uint64 10649 for shift := uint(0); ; shift += 7 { 10650 if shift >= 64 { 10651 return ErrIntOverflowTypes 10652 } 10653 if iNdEx >= l { 10654 return io.ErrUnexpectedEOF 10655 } 10656 b := dAtA[iNdEx] 10657 iNdEx++ 10658 wire |= uint64(b&0x7F) << shift 10659 if b < 0x80 { 10660 break 10661 } 10662 } 10663 fieldNum := int32(wire >> 3) 10664 wireType := int(wire & 0x7) 10665 if wireType == 4 { 10666 return fmt.Errorf("proto: RequestInfo: wiretype end group for non-group") 10667 } 10668 if fieldNum <= 0 { 10669 return fmt.Errorf("proto: RequestInfo: illegal tag %d (wire type %d)", fieldNum, wire) 10670 } 10671 switch fieldNum { 10672 case 1: 10673 if wireType != 2 { 10674 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 10675 } 10676 var stringLen uint64 10677 for shift := uint(0); ; shift += 7 { 10678 if shift >= 64 { 10679 return ErrIntOverflowTypes 10680 } 10681 if iNdEx >= l { 10682 return io.ErrUnexpectedEOF 10683 } 10684 b := dAtA[iNdEx] 10685 iNdEx++ 10686 stringLen |= uint64(b&0x7F) << shift 10687 if b < 0x80 { 10688 break 10689 } 10690 } 10691 intStringLen := int(stringLen) 10692 if intStringLen < 0 { 10693 return ErrInvalidLengthTypes 10694 } 10695 postIndex := iNdEx + intStringLen 10696 if postIndex < 0 { 10697 return ErrInvalidLengthTypes 10698 } 10699 if postIndex > l { 10700 return io.ErrUnexpectedEOF 10701 } 10702 m.Version = string(dAtA[iNdEx:postIndex]) 10703 iNdEx = postIndex 10704 case 2: 10705 if wireType != 0 { 10706 return fmt.Errorf("proto: wrong wireType = %d for field BlockVersion", wireType) 10707 } 10708 m.BlockVersion = 0 10709 for shift := uint(0); ; shift += 7 { 10710 if shift >= 64 { 10711 return ErrIntOverflowTypes 10712 } 10713 if iNdEx >= l { 10714 return io.ErrUnexpectedEOF 10715 } 10716 b := dAtA[iNdEx] 10717 iNdEx++ 10718 m.BlockVersion |= uint64(b&0x7F) << shift 10719 if b < 0x80 { 10720 break 10721 } 10722 } 10723 case 3: 10724 if wireType != 0 { 10725 return fmt.Errorf("proto: wrong wireType = %d for field P2PVersion", wireType) 10726 } 10727 m.P2PVersion = 0 10728 for shift := uint(0); ; shift += 7 { 10729 if shift >= 64 { 10730 return ErrIntOverflowTypes 10731 } 10732 if iNdEx >= l { 10733 return io.ErrUnexpectedEOF 10734 } 10735 b := dAtA[iNdEx] 10736 iNdEx++ 10737 m.P2PVersion |= uint64(b&0x7F) << shift 10738 if b < 0x80 { 10739 break 10740 } 10741 } 10742 default: 10743 iNdEx = preIndex 10744 skippy, err := skipTypes(dAtA[iNdEx:]) 10745 if err != nil { 10746 return err 10747 } 10748 if skippy < 0 { 10749 return ErrInvalidLengthTypes 10750 } 10751 if (iNdEx + skippy) < 0 { 10752 return ErrInvalidLengthTypes 10753 } 10754 if (iNdEx + skippy) > l { 10755 return io.ErrUnexpectedEOF 10756 } 10757 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 10758 iNdEx += skippy 10759 } 10760 } 10761 10762 if iNdEx > l { 10763 return io.ErrUnexpectedEOF 10764 } 10765 return nil 10766 } 10767 func (m *RequestSetOption) Unmarshal(dAtA []byte) error { 10768 l := len(dAtA) 10769 iNdEx := 0 10770 for iNdEx < l { 10771 preIndex := iNdEx 10772 var wire uint64 10773 for shift := uint(0); ; shift += 7 { 10774 if shift >= 64 { 10775 return ErrIntOverflowTypes 10776 } 10777 if iNdEx >= l { 10778 return io.ErrUnexpectedEOF 10779 } 10780 b := dAtA[iNdEx] 10781 iNdEx++ 10782 wire |= uint64(b&0x7F) << shift 10783 if b < 0x80 { 10784 break 10785 } 10786 } 10787 fieldNum := int32(wire >> 3) 10788 wireType := int(wire & 0x7) 10789 if wireType == 4 { 10790 return fmt.Errorf("proto: RequestSetOption: wiretype end group for non-group") 10791 } 10792 if fieldNum <= 0 { 10793 return fmt.Errorf("proto: RequestSetOption: illegal tag %d (wire type %d)", fieldNum, wire) 10794 } 10795 switch fieldNum { 10796 case 1: 10797 if wireType != 2 { 10798 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 10799 } 10800 var stringLen uint64 10801 for shift := uint(0); ; shift += 7 { 10802 if shift >= 64 { 10803 return ErrIntOverflowTypes 10804 } 10805 if iNdEx >= l { 10806 return io.ErrUnexpectedEOF 10807 } 10808 b := dAtA[iNdEx] 10809 iNdEx++ 10810 stringLen |= uint64(b&0x7F) << shift 10811 if b < 0x80 { 10812 break 10813 } 10814 } 10815 intStringLen := int(stringLen) 10816 if intStringLen < 0 { 10817 return ErrInvalidLengthTypes 10818 } 10819 postIndex := iNdEx + intStringLen 10820 if postIndex < 0 { 10821 return ErrInvalidLengthTypes 10822 } 10823 if postIndex > l { 10824 return io.ErrUnexpectedEOF 10825 } 10826 m.Key = string(dAtA[iNdEx:postIndex]) 10827 iNdEx = postIndex 10828 case 2: 10829 if wireType != 2 { 10830 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 10831 } 10832 var stringLen uint64 10833 for shift := uint(0); ; shift += 7 { 10834 if shift >= 64 { 10835 return ErrIntOverflowTypes 10836 } 10837 if iNdEx >= l { 10838 return io.ErrUnexpectedEOF 10839 } 10840 b := dAtA[iNdEx] 10841 iNdEx++ 10842 stringLen |= uint64(b&0x7F) << shift 10843 if b < 0x80 { 10844 break 10845 } 10846 } 10847 intStringLen := int(stringLen) 10848 if intStringLen < 0 { 10849 return ErrInvalidLengthTypes 10850 } 10851 postIndex := iNdEx + intStringLen 10852 if postIndex < 0 { 10853 return ErrInvalidLengthTypes 10854 } 10855 if postIndex > l { 10856 return io.ErrUnexpectedEOF 10857 } 10858 m.Value = string(dAtA[iNdEx:postIndex]) 10859 iNdEx = postIndex 10860 default: 10861 iNdEx = preIndex 10862 skippy, err := skipTypes(dAtA[iNdEx:]) 10863 if err != nil { 10864 return err 10865 } 10866 if skippy < 0 { 10867 return ErrInvalidLengthTypes 10868 } 10869 if (iNdEx + skippy) < 0 { 10870 return ErrInvalidLengthTypes 10871 } 10872 if (iNdEx + skippy) > l { 10873 return io.ErrUnexpectedEOF 10874 } 10875 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 10876 iNdEx += skippy 10877 } 10878 } 10879 10880 if iNdEx > l { 10881 return io.ErrUnexpectedEOF 10882 } 10883 return nil 10884 } 10885 func (m *RequestInitChain) Unmarshal(dAtA []byte) error { 10886 l := len(dAtA) 10887 iNdEx := 0 10888 for iNdEx < l { 10889 preIndex := iNdEx 10890 var wire uint64 10891 for shift := uint(0); ; shift += 7 { 10892 if shift >= 64 { 10893 return ErrIntOverflowTypes 10894 } 10895 if iNdEx >= l { 10896 return io.ErrUnexpectedEOF 10897 } 10898 b := dAtA[iNdEx] 10899 iNdEx++ 10900 wire |= uint64(b&0x7F) << shift 10901 if b < 0x80 { 10902 break 10903 } 10904 } 10905 fieldNum := int32(wire >> 3) 10906 wireType := int(wire & 0x7) 10907 if wireType == 4 { 10908 return fmt.Errorf("proto: RequestInitChain: wiretype end group for non-group") 10909 } 10910 if fieldNum <= 0 { 10911 return fmt.Errorf("proto: RequestInitChain: illegal tag %d (wire type %d)", fieldNum, wire) 10912 } 10913 switch fieldNum { 10914 case 1: 10915 if wireType != 2 { 10916 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) 10917 } 10918 var msglen int 10919 for shift := uint(0); ; shift += 7 { 10920 if shift >= 64 { 10921 return ErrIntOverflowTypes 10922 } 10923 if iNdEx >= l { 10924 return io.ErrUnexpectedEOF 10925 } 10926 b := dAtA[iNdEx] 10927 iNdEx++ 10928 msglen |= int(b&0x7F) << shift 10929 if b < 0x80 { 10930 break 10931 } 10932 } 10933 if msglen < 0 { 10934 return ErrInvalidLengthTypes 10935 } 10936 postIndex := iNdEx + msglen 10937 if postIndex < 0 { 10938 return ErrInvalidLengthTypes 10939 } 10940 if postIndex > l { 10941 return io.ErrUnexpectedEOF 10942 } 10943 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { 10944 return err 10945 } 10946 iNdEx = postIndex 10947 case 2: 10948 if wireType != 2 { 10949 return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) 10950 } 10951 var stringLen uint64 10952 for shift := uint(0); ; shift += 7 { 10953 if shift >= 64 { 10954 return ErrIntOverflowTypes 10955 } 10956 if iNdEx >= l { 10957 return io.ErrUnexpectedEOF 10958 } 10959 b := dAtA[iNdEx] 10960 iNdEx++ 10961 stringLen |= uint64(b&0x7F) << shift 10962 if b < 0x80 { 10963 break 10964 } 10965 } 10966 intStringLen := int(stringLen) 10967 if intStringLen < 0 { 10968 return ErrInvalidLengthTypes 10969 } 10970 postIndex := iNdEx + intStringLen 10971 if postIndex < 0 { 10972 return ErrInvalidLengthTypes 10973 } 10974 if postIndex > l { 10975 return io.ErrUnexpectedEOF 10976 } 10977 m.ChainId = string(dAtA[iNdEx:postIndex]) 10978 iNdEx = postIndex 10979 case 3: 10980 if wireType != 2 { 10981 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) 10982 } 10983 var msglen int 10984 for shift := uint(0); ; shift += 7 { 10985 if shift >= 64 { 10986 return ErrIntOverflowTypes 10987 } 10988 if iNdEx >= l { 10989 return io.ErrUnexpectedEOF 10990 } 10991 b := dAtA[iNdEx] 10992 iNdEx++ 10993 msglen |= int(b&0x7F) << shift 10994 if b < 0x80 { 10995 break 10996 } 10997 } 10998 if msglen < 0 { 10999 return ErrInvalidLengthTypes 11000 } 11001 postIndex := iNdEx + msglen 11002 if postIndex < 0 { 11003 return ErrInvalidLengthTypes 11004 } 11005 if postIndex > l { 11006 return io.ErrUnexpectedEOF 11007 } 11008 if m.ConsensusParams == nil { 11009 m.ConsensusParams = &ConsensusParams{} 11010 } 11011 if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11012 return err 11013 } 11014 iNdEx = postIndex 11015 case 4: 11016 if wireType != 2 { 11017 return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) 11018 } 11019 var msglen int 11020 for shift := uint(0); ; shift += 7 { 11021 if shift >= 64 { 11022 return ErrIntOverflowTypes 11023 } 11024 if iNdEx >= l { 11025 return io.ErrUnexpectedEOF 11026 } 11027 b := dAtA[iNdEx] 11028 iNdEx++ 11029 msglen |= int(b&0x7F) << shift 11030 if b < 0x80 { 11031 break 11032 } 11033 } 11034 if msglen < 0 { 11035 return ErrInvalidLengthTypes 11036 } 11037 postIndex := iNdEx + msglen 11038 if postIndex < 0 { 11039 return ErrInvalidLengthTypes 11040 } 11041 if postIndex > l { 11042 return io.ErrUnexpectedEOF 11043 } 11044 m.Validators = append(m.Validators, ValidatorUpdate{}) 11045 if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11046 return err 11047 } 11048 iNdEx = postIndex 11049 case 5: 11050 if wireType != 2 { 11051 return fmt.Errorf("proto: wrong wireType = %d for field AppStateBytes", wireType) 11052 } 11053 var byteLen int 11054 for shift := uint(0); ; shift += 7 { 11055 if shift >= 64 { 11056 return ErrIntOverflowTypes 11057 } 11058 if iNdEx >= l { 11059 return io.ErrUnexpectedEOF 11060 } 11061 b := dAtA[iNdEx] 11062 iNdEx++ 11063 byteLen |= int(b&0x7F) << shift 11064 if b < 0x80 { 11065 break 11066 } 11067 } 11068 if byteLen < 0 { 11069 return ErrInvalidLengthTypes 11070 } 11071 postIndex := iNdEx + byteLen 11072 if postIndex < 0 { 11073 return ErrInvalidLengthTypes 11074 } 11075 if postIndex > l { 11076 return io.ErrUnexpectedEOF 11077 } 11078 m.AppStateBytes = append(m.AppStateBytes[:0], dAtA[iNdEx:postIndex]...) 11079 if m.AppStateBytes == nil { 11080 m.AppStateBytes = []byte{} 11081 } 11082 iNdEx = postIndex 11083 default: 11084 iNdEx = preIndex 11085 skippy, err := skipTypes(dAtA[iNdEx:]) 11086 if err != nil { 11087 return err 11088 } 11089 if skippy < 0 { 11090 return ErrInvalidLengthTypes 11091 } 11092 if (iNdEx + skippy) < 0 { 11093 return ErrInvalidLengthTypes 11094 } 11095 if (iNdEx + skippy) > l { 11096 return io.ErrUnexpectedEOF 11097 } 11098 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11099 iNdEx += skippy 11100 } 11101 } 11102 11103 if iNdEx > l { 11104 return io.ErrUnexpectedEOF 11105 } 11106 return nil 11107 } 11108 func (m *RequestQuery) Unmarshal(dAtA []byte) error { 11109 l := len(dAtA) 11110 iNdEx := 0 11111 for iNdEx < l { 11112 preIndex := iNdEx 11113 var wire uint64 11114 for shift := uint(0); ; shift += 7 { 11115 if shift >= 64 { 11116 return ErrIntOverflowTypes 11117 } 11118 if iNdEx >= l { 11119 return io.ErrUnexpectedEOF 11120 } 11121 b := dAtA[iNdEx] 11122 iNdEx++ 11123 wire |= uint64(b&0x7F) << shift 11124 if b < 0x80 { 11125 break 11126 } 11127 } 11128 fieldNum := int32(wire >> 3) 11129 wireType := int(wire & 0x7) 11130 if wireType == 4 { 11131 return fmt.Errorf("proto: RequestQuery: wiretype end group for non-group") 11132 } 11133 if fieldNum <= 0 { 11134 return fmt.Errorf("proto: RequestQuery: illegal tag %d (wire type %d)", fieldNum, wire) 11135 } 11136 switch fieldNum { 11137 case 1: 11138 if wireType != 2 { 11139 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 11140 } 11141 var byteLen int 11142 for shift := uint(0); ; shift += 7 { 11143 if shift >= 64 { 11144 return ErrIntOverflowTypes 11145 } 11146 if iNdEx >= l { 11147 return io.ErrUnexpectedEOF 11148 } 11149 b := dAtA[iNdEx] 11150 iNdEx++ 11151 byteLen |= int(b&0x7F) << shift 11152 if b < 0x80 { 11153 break 11154 } 11155 } 11156 if byteLen < 0 { 11157 return ErrInvalidLengthTypes 11158 } 11159 postIndex := iNdEx + byteLen 11160 if postIndex < 0 { 11161 return ErrInvalidLengthTypes 11162 } 11163 if postIndex > l { 11164 return io.ErrUnexpectedEOF 11165 } 11166 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 11167 if m.Data == nil { 11168 m.Data = []byte{} 11169 } 11170 iNdEx = postIndex 11171 case 2: 11172 if wireType != 2 { 11173 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) 11174 } 11175 var stringLen uint64 11176 for shift := uint(0); ; shift += 7 { 11177 if shift >= 64 { 11178 return ErrIntOverflowTypes 11179 } 11180 if iNdEx >= l { 11181 return io.ErrUnexpectedEOF 11182 } 11183 b := dAtA[iNdEx] 11184 iNdEx++ 11185 stringLen |= uint64(b&0x7F) << shift 11186 if b < 0x80 { 11187 break 11188 } 11189 } 11190 intStringLen := int(stringLen) 11191 if intStringLen < 0 { 11192 return ErrInvalidLengthTypes 11193 } 11194 postIndex := iNdEx + intStringLen 11195 if postIndex < 0 { 11196 return ErrInvalidLengthTypes 11197 } 11198 if postIndex > l { 11199 return io.ErrUnexpectedEOF 11200 } 11201 m.Path = string(dAtA[iNdEx:postIndex]) 11202 iNdEx = postIndex 11203 case 3: 11204 if wireType != 0 { 11205 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 11206 } 11207 m.Height = 0 11208 for shift := uint(0); ; shift += 7 { 11209 if shift >= 64 { 11210 return ErrIntOverflowTypes 11211 } 11212 if iNdEx >= l { 11213 return io.ErrUnexpectedEOF 11214 } 11215 b := dAtA[iNdEx] 11216 iNdEx++ 11217 m.Height |= int64(b&0x7F) << shift 11218 if b < 0x80 { 11219 break 11220 } 11221 } 11222 case 4: 11223 if wireType != 0 { 11224 return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType) 11225 } 11226 var v int 11227 for shift := uint(0); ; shift += 7 { 11228 if shift >= 64 { 11229 return ErrIntOverflowTypes 11230 } 11231 if iNdEx >= l { 11232 return io.ErrUnexpectedEOF 11233 } 11234 b := dAtA[iNdEx] 11235 iNdEx++ 11236 v |= int(b&0x7F) << shift 11237 if b < 0x80 { 11238 break 11239 } 11240 } 11241 m.Prove = bool(v != 0) 11242 default: 11243 iNdEx = preIndex 11244 skippy, err := skipTypes(dAtA[iNdEx:]) 11245 if err != nil { 11246 return err 11247 } 11248 if skippy < 0 { 11249 return ErrInvalidLengthTypes 11250 } 11251 if (iNdEx + skippy) < 0 { 11252 return ErrInvalidLengthTypes 11253 } 11254 if (iNdEx + skippy) > l { 11255 return io.ErrUnexpectedEOF 11256 } 11257 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11258 iNdEx += skippy 11259 } 11260 } 11261 11262 if iNdEx > l { 11263 return io.ErrUnexpectedEOF 11264 } 11265 return nil 11266 } 11267 func (m *RequestBeginBlock) Unmarshal(dAtA []byte) error { 11268 l := len(dAtA) 11269 iNdEx := 0 11270 for iNdEx < l { 11271 preIndex := iNdEx 11272 var wire uint64 11273 for shift := uint(0); ; shift += 7 { 11274 if shift >= 64 { 11275 return ErrIntOverflowTypes 11276 } 11277 if iNdEx >= l { 11278 return io.ErrUnexpectedEOF 11279 } 11280 b := dAtA[iNdEx] 11281 iNdEx++ 11282 wire |= uint64(b&0x7F) << shift 11283 if b < 0x80 { 11284 break 11285 } 11286 } 11287 fieldNum := int32(wire >> 3) 11288 wireType := int(wire & 0x7) 11289 if wireType == 4 { 11290 return fmt.Errorf("proto: RequestBeginBlock: wiretype end group for non-group") 11291 } 11292 if fieldNum <= 0 { 11293 return fmt.Errorf("proto: RequestBeginBlock: illegal tag %d (wire type %d)", fieldNum, wire) 11294 } 11295 switch fieldNum { 11296 case 1: 11297 if wireType != 2 { 11298 return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) 11299 } 11300 var byteLen int 11301 for shift := uint(0); ; shift += 7 { 11302 if shift >= 64 { 11303 return ErrIntOverflowTypes 11304 } 11305 if iNdEx >= l { 11306 return io.ErrUnexpectedEOF 11307 } 11308 b := dAtA[iNdEx] 11309 iNdEx++ 11310 byteLen |= int(b&0x7F) << shift 11311 if b < 0x80 { 11312 break 11313 } 11314 } 11315 if byteLen < 0 { 11316 return ErrInvalidLengthTypes 11317 } 11318 postIndex := iNdEx + byteLen 11319 if postIndex < 0 { 11320 return ErrInvalidLengthTypes 11321 } 11322 if postIndex > l { 11323 return io.ErrUnexpectedEOF 11324 } 11325 m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) 11326 if m.Hash == nil { 11327 m.Hash = []byte{} 11328 } 11329 iNdEx = postIndex 11330 case 2: 11331 if wireType != 2 { 11332 return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) 11333 } 11334 var msglen int 11335 for shift := uint(0); ; shift += 7 { 11336 if shift >= 64 { 11337 return ErrIntOverflowTypes 11338 } 11339 if iNdEx >= l { 11340 return io.ErrUnexpectedEOF 11341 } 11342 b := dAtA[iNdEx] 11343 iNdEx++ 11344 msglen |= int(b&0x7F) << shift 11345 if b < 0x80 { 11346 break 11347 } 11348 } 11349 if msglen < 0 { 11350 return ErrInvalidLengthTypes 11351 } 11352 postIndex := iNdEx + msglen 11353 if postIndex < 0 { 11354 return ErrInvalidLengthTypes 11355 } 11356 if postIndex > l { 11357 return io.ErrUnexpectedEOF 11358 } 11359 if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11360 return err 11361 } 11362 iNdEx = postIndex 11363 case 3: 11364 if wireType != 2 { 11365 return fmt.Errorf("proto: wrong wireType = %d for field LastCommitInfo", wireType) 11366 } 11367 var msglen int 11368 for shift := uint(0); ; shift += 7 { 11369 if shift >= 64 { 11370 return ErrIntOverflowTypes 11371 } 11372 if iNdEx >= l { 11373 return io.ErrUnexpectedEOF 11374 } 11375 b := dAtA[iNdEx] 11376 iNdEx++ 11377 msglen |= int(b&0x7F) << shift 11378 if b < 0x80 { 11379 break 11380 } 11381 } 11382 if msglen < 0 { 11383 return ErrInvalidLengthTypes 11384 } 11385 postIndex := iNdEx + msglen 11386 if postIndex < 0 { 11387 return ErrInvalidLengthTypes 11388 } 11389 if postIndex > l { 11390 return io.ErrUnexpectedEOF 11391 } 11392 if err := m.LastCommitInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11393 return err 11394 } 11395 iNdEx = postIndex 11396 case 4: 11397 if wireType != 2 { 11398 return fmt.Errorf("proto: wrong wireType = %d for field ByzantineValidators", wireType) 11399 } 11400 var msglen int 11401 for shift := uint(0); ; shift += 7 { 11402 if shift >= 64 { 11403 return ErrIntOverflowTypes 11404 } 11405 if iNdEx >= l { 11406 return io.ErrUnexpectedEOF 11407 } 11408 b := dAtA[iNdEx] 11409 iNdEx++ 11410 msglen |= int(b&0x7F) << shift 11411 if b < 0x80 { 11412 break 11413 } 11414 } 11415 if msglen < 0 { 11416 return ErrInvalidLengthTypes 11417 } 11418 postIndex := iNdEx + msglen 11419 if postIndex < 0 { 11420 return ErrInvalidLengthTypes 11421 } 11422 if postIndex > l { 11423 return io.ErrUnexpectedEOF 11424 } 11425 m.ByzantineValidators = append(m.ByzantineValidators, Evidence{}) 11426 if err := m.ByzantineValidators[len(m.ByzantineValidators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11427 return err 11428 } 11429 iNdEx = postIndex 11430 default: 11431 iNdEx = preIndex 11432 skippy, err := skipTypes(dAtA[iNdEx:]) 11433 if err != nil { 11434 return err 11435 } 11436 if skippy < 0 { 11437 return ErrInvalidLengthTypes 11438 } 11439 if (iNdEx + skippy) < 0 { 11440 return ErrInvalidLengthTypes 11441 } 11442 if (iNdEx + skippy) > l { 11443 return io.ErrUnexpectedEOF 11444 } 11445 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11446 iNdEx += skippy 11447 } 11448 } 11449 11450 if iNdEx > l { 11451 return io.ErrUnexpectedEOF 11452 } 11453 return nil 11454 } 11455 func (m *RequestCheckTx) Unmarshal(dAtA []byte) error { 11456 l := len(dAtA) 11457 iNdEx := 0 11458 for iNdEx < l { 11459 preIndex := iNdEx 11460 var wire uint64 11461 for shift := uint(0); ; shift += 7 { 11462 if shift >= 64 { 11463 return ErrIntOverflowTypes 11464 } 11465 if iNdEx >= l { 11466 return io.ErrUnexpectedEOF 11467 } 11468 b := dAtA[iNdEx] 11469 iNdEx++ 11470 wire |= uint64(b&0x7F) << shift 11471 if b < 0x80 { 11472 break 11473 } 11474 } 11475 fieldNum := int32(wire >> 3) 11476 wireType := int(wire & 0x7) 11477 if wireType == 4 { 11478 return fmt.Errorf("proto: RequestCheckTx: wiretype end group for non-group") 11479 } 11480 if fieldNum <= 0 { 11481 return fmt.Errorf("proto: RequestCheckTx: illegal tag %d (wire type %d)", fieldNum, wire) 11482 } 11483 switch fieldNum { 11484 case 1: 11485 if wireType != 2 { 11486 return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) 11487 } 11488 var byteLen int 11489 for shift := uint(0); ; shift += 7 { 11490 if shift >= 64 { 11491 return ErrIntOverflowTypes 11492 } 11493 if iNdEx >= l { 11494 return io.ErrUnexpectedEOF 11495 } 11496 b := dAtA[iNdEx] 11497 iNdEx++ 11498 byteLen |= int(b&0x7F) << shift 11499 if b < 0x80 { 11500 break 11501 } 11502 } 11503 if byteLen < 0 { 11504 return ErrInvalidLengthTypes 11505 } 11506 postIndex := iNdEx + byteLen 11507 if postIndex < 0 { 11508 return ErrInvalidLengthTypes 11509 } 11510 if postIndex > l { 11511 return io.ErrUnexpectedEOF 11512 } 11513 m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) 11514 if m.Tx == nil { 11515 m.Tx = []byte{} 11516 } 11517 iNdEx = postIndex 11518 case 2: 11519 if wireType != 0 { 11520 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 11521 } 11522 m.Type = 0 11523 for shift := uint(0); ; shift += 7 { 11524 if shift >= 64 { 11525 return ErrIntOverflowTypes 11526 } 11527 if iNdEx >= l { 11528 return io.ErrUnexpectedEOF 11529 } 11530 b := dAtA[iNdEx] 11531 iNdEx++ 11532 m.Type |= CheckTxType(b&0x7F) << shift 11533 if b < 0x80 { 11534 break 11535 } 11536 } 11537 default: 11538 iNdEx = preIndex 11539 skippy, err := skipTypes(dAtA[iNdEx:]) 11540 if err != nil { 11541 return err 11542 } 11543 if skippy < 0 { 11544 return ErrInvalidLengthTypes 11545 } 11546 if (iNdEx + skippy) < 0 { 11547 return ErrInvalidLengthTypes 11548 } 11549 if (iNdEx + skippy) > l { 11550 return io.ErrUnexpectedEOF 11551 } 11552 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11553 iNdEx += skippy 11554 } 11555 } 11556 11557 if iNdEx > l { 11558 return io.ErrUnexpectedEOF 11559 } 11560 return nil 11561 } 11562 func (m *RequestDeliverTx) Unmarshal(dAtA []byte) error { 11563 l := len(dAtA) 11564 iNdEx := 0 11565 for iNdEx < l { 11566 preIndex := iNdEx 11567 var wire uint64 11568 for shift := uint(0); ; shift += 7 { 11569 if shift >= 64 { 11570 return ErrIntOverflowTypes 11571 } 11572 if iNdEx >= l { 11573 return io.ErrUnexpectedEOF 11574 } 11575 b := dAtA[iNdEx] 11576 iNdEx++ 11577 wire |= uint64(b&0x7F) << shift 11578 if b < 0x80 { 11579 break 11580 } 11581 } 11582 fieldNum := int32(wire >> 3) 11583 wireType := int(wire & 0x7) 11584 if wireType == 4 { 11585 return fmt.Errorf("proto: RequestDeliverTx: wiretype end group for non-group") 11586 } 11587 if fieldNum <= 0 { 11588 return fmt.Errorf("proto: RequestDeliverTx: illegal tag %d (wire type %d)", fieldNum, wire) 11589 } 11590 switch fieldNum { 11591 case 1: 11592 if wireType != 2 { 11593 return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) 11594 } 11595 var byteLen int 11596 for shift := uint(0); ; shift += 7 { 11597 if shift >= 64 { 11598 return ErrIntOverflowTypes 11599 } 11600 if iNdEx >= l { 11601 return io.ErrUnexpectedEOF 11602 } 11603 b := dAtA[iNdEx] 11604 iNdEx++ 11605 byteLen |= int(b&0x7F) << shift 11606 if b < 0x80 { 11607 break 11608 } 11609 } 11610 if byteLen < 0 { 11611 return ErrInvalidLengthTypes 11612 } 11613 postIndex := iNdEx + byteLen 11614 if postIndex < 0 { 11615 return ErrInvalidLengthTypes 11616 } 11617 if postIndex > l { 11618 return io.ErrUnexpectedEOF 11619 } 11620 m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) 11621 if m.Tx == nil { 11622 m.Tx = []byte{} 11623 } 11624 iNdEx = postIndex 11625 default: 11626 iNdEx = preIndex 11627 skippy, err := skipTypes(dAtA[iNdEx:]) 11628 if err != nil { 11629 return err 11630 } 11631 if skippy < 0 { 11632 return ErrInvalidLengthTypes 11633 } 11634 if (iNdEx + skippy) < 0 { 11635 return ErrInvalidLengthTypes 11636 } 11637 if (iNdEx + skippy) > l { 11638 return io.ErrUnexpectedEOF 11639 } 11640 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11641 iNdEx += skippy 11642 } 11643 } 11644 11645 if iNdEx > l { 11646 return io.ErrUnexpectedEOF 11647 } 11648 return nil 11649 } 11650 func (m *RequestEndBlock) Unmarshal(dAtA []byte) error { 11651 l := len(dAtA) 11652 iNdEx := 0 11653 for iNdEx < l { 11654 preIndex := iNdEx 11655 var wire uint64 11656 for shift := uint(0); ; shift += 7 { 11657 if shift >= 64 { 11658 return ErrIntOverflowTypes 11659 } 11660 if iNdEx >= l { 11661 return io.ErrUnexpectedEOF 11662 } 11663 b := dAtA[iNdEx] 11664 iNdEx++ 11665 wire |= uint64(b&0x7F) << shift 11666 if b < 0x80 { 11667 break 11668 } 11669 } 11670 fieldNum := int32(wire >> 3) 11671 wireType := int(wire & 0x7) 11672 if wireType == 4 { 11673 return fmt.Errorf("proto: RequestEndBlock: wiretype end group for non-group") 11674 } 11675 if fieldNum <= 0 { 11676 return fmt.Errorf("proto: RequestEndBlock: illegal tag %d (wire type %d)", fieldNum, wire) 11677 } 11678 switch fieldNum { 11679 case 1: 11680 if wireType != 0 { 11681 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 11682 } 11683 m.Height = 0 11684 for shift := uint(0); ; shift += 7 { 11685 if shift >= 64 { 11686 return ErrIntOverflowTypes 11687 } 11688 if iNdEx >= l { 11689 return io.ErrUnexpectedEOF 11690 } 11691 b := dAtA[iNdEx] 11692 iNdEx++ 11693 m.Height |= int64(b&0x7F) << shift 11694 if b < 0x80 { 11695 break 11696 } 11697 } 11698 default: 11699 iNdEx = preIndex 11700 skippy, err := skipTypes(dAtA[iNdEx:]) 11701 if err != nil { 11702 return err 11703 } 11704 if skippy < 0 { 11705 return ErrInvalidLengthTypes 11706 } 11707 if (iNdEx + skippy) < 0 { 11708 return ErrInvalidLengthTypes 11709 } 11710 if (iNdEx + skippy) > l { 11711 return io.ErrUnexpectedEOF 11712 } 11713 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11714 iNdEx += skippy 11715 } 11716 } 11717 11718 if iNdEx > l { 11719 return io.ErrUnexpectedEOF 11720 } 11721 return nil 11722 } 11723 func (m *RequestCommit) Unmarshal(dAtA []byte) error { 11724 l := len(dAtA) 11725 iNdEx := 0 11726 for iNdEx < l { 11727 preIndex := iNdEx 11728 var wire uint64 11729 for shift := uint(0); ; shift += 7 { 11730 if shift >= 64 { 11731 return ErrIntOverflowTypes 11732 } 11733 if iNdEx >= l { 11734 return io.ErrUnexpectedEOF 11735 } 11736 b := dAtA[iNdEx] 11737 iNdEx++ 11738 wire |= uint64(b&0x7F) << shift 11739 if b < 0x80 { 11740 break 11741 } 11742 } 11743 fieldNum := int32(wire >> 3) 11744 wireType := int(wire & 0x7) 11745 if wireType == 4 { 11746 return fmt.Errorf("proto: RequestCommit: wiretype end group for non-group") 11747 } 11748 if fieldNum <= 0 { 11749 return fmt.Errorf("proto: RequestCommit: illegal tag %d (wire type %d)", fieldNum, wire) 11750 } 11751 switch fieldNum { 11752 default: 11753 iNdEx = preIndex 11754 skippy, err := skipTypes(dAtA[iNdEx:]) 11755 if err != nil { 11756 return err 11757 } 11758 if skippy < 0 { 11759 return ErrInvalidLengthTypes 11760 } 11761 if (iNdEx + skippy) < 0 { 11762 return ErrInvalidLengthTypes 11763 } 11764 if (iNdEx + skippy) > l { 11765 return io.ErrUnexpectedEOF 11766 } 11767 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 11768 iNdEx += skippy 11769 } 11770 } 11771 11772 if iNdEx > l { 11773 return io.ErrUnexpectedEOF 11774 } 11775 return nil 11776 } 11777 func (m *Response) Unmarshal(dAtA []byte) error { 11778 l := len(dAtA) 11779 iNdEx := 0 11780 for iNdEx < l { 11781 preIndex := iNdEx 11782 var wire uint64 11783 for shift := uint(0); ; shift += 7 { 11784 if shift >= 64 { 11785 return ErrIntOverflowTypes 11786 } 11787 if iNdEx >= l { 11788 return io.ErrUnexpectedEOF 11789 } 11790 b := dAtA[iNdEx] 11791 iNdEx++ 11792 wire |= uint64(b&0x7F) << shift 11793 if b < 0x80 { 11794 break 11795 } 11796 } 11797 fieldNum := int32(wire >> 3) 11798 wireType := int(wire & 0x7) 11799 if wireType == 4 { 11800 return fmt.Errorf("proto: Response: wiretype end group for non-group") 11801 } 11802 if fieldNum <= 0 { 11803 return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) 11804 } 11805 switch fieldNum { 11806 case 1: 11807 if wireType != 2 { 11808 return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType) 11809 } 11810 var msglen int 11811 for shift := uint(0); ; shift += 7 { 11812 if shift >= 64 { 11813 return ErrIntOverflowTypes 11814 } 11815 if iNdEx >= l { 11816 return io.ErrUnexpectedEOF 11817 } 11818 b := dAtA[iNdEx] 11819 iNdEx++ 11820 msglen |= int(b&0x7F) << shift 11821 if b < 0x80 { 11822 break 11823 } 11824 } 11825 if msglen < 0 { 11826 return ErrInvalidLengthTypes 11827 } 11828 postIndex := iNdEx + msglen 11829 if postIndex < 0 { 11830 return ErrInvalidLengthTypes 11831 } 11832 if postIndex > l { 11833 return io.ErrUnexpectedEOF 11834 } 11835 v := &ResponseException{} 11836 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11837 return err 11838 } 11839 m.Value = &Response_Exception{v} 11840 iNdEx = postIndex 11841 case 2: 11842 if wireType != 2 { 11843 return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType) 11844 } 11845 var msglen int 11846 for shift := uint(0); ; shift += 7 { 11847 if shift >= 64 { 11848 return ErrIntOverflowTypes 11849 } 11850 if iNdEx >= l { 11851 return io.ErrUnexpectedEOF 11852 } 11853 b := dAtA[iNdEx] 11854 iNdEx++ 11855 msglen |= int(b&0x7F) << shift 11856 if b < 0x80 { 11857 break 11858 } 11859 } 11860 if msglen < 0 { 11861 return ErrInvalidLengthTypes 11862 } 11863 postIndex := iNdEx + msglen 11864 if postIndex < 0 { 11865 return ErrInvalidLengthTypes 11866 } 11867 if postIndex > l { 11868 return io.ErrUnexpectedEOF 11869 } 11870 v := &ResponseEcho{} 11871 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11872 return err 11873 } 11874 m.Value = &Response_Echo{v} 11875 iNdEx = postIndex 11876 case 3: 11877 if wireType != 2 { 11878 return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType) 11879 } 11880 var msglen int 11881 for shift := uint(0); ; shift += 7 { 11882 if shift >= 64 { 11883 return ErrIntOverflowTypes 11884 } 11885 if iNdEx >= l { 11886 return io.ErrUnexpectedEOF 11887 } 11888 b := dAtA[iNdEx] 11889 iNdEx++ 11890 msglen |= int(b&0x7F) << shift 11891 if b < 0x80 { 11892 break 11893 } 11894 } 11895 if msglen < 0 { 11896 return ErrInvalidLengthTypes 11897 } 11898 postIndex := iNdEx + msglen 11899 if postIndex < 0 { 11900 return ErrInvalidLengthTypes 11901 } 11902 if postIndex > l { 11903 return io.ErrUnexpectedEOF 11904 } 11905 v := &ResponseFlush{} 11906 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11907 return err 11908 } 11909 m.Value = &Response_Flush{v} 11910 iNdEx = postIndex 11911 case 4: 11912 if wireType != 2 { 11913 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 11914 } 11915 var msglen int 11916 for shift := uint(0); ; shift += 7 { 11917 if shift >= 64 { 11918 return ErrIntOverflowTypes 11919 } 11920 if iNdEx >= l { 11921 return io.ErrUnexpectedEOF 11922 } 11923 b := dAtA[iNdEx] 11924 iNdEx++ 11925 msglen |= int(b&0x7F) << shift 11926 if b < 0x80 { 11927 break 11928 } 11929 } 11930 if msglen < 0 { 11931 return ErrInvalidLengthTypes 11932 } 11933 postIndex := iNdEx + msglen 11934 if postIndex < 0 { 11935 return ErrInvalidLengthTypes 11936 } 11937 if postIndex > l { 11938 return io.ErrUnexpectedEOF 11939 } 11940 v := &ResponseInfo{} 11941 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11942 return err 11943 } 11944 m.Value = &Response_Info{v} 11945 iNdEx = postIndex 11946 case 5: 11947 if wireType != 2 { 11948 return fmt.Errorf("proto: wrong wireType = %d for field SetOption", wireType) 11949 } 11950 var msglen int 11951 for shift := uint(0); ; shift += 7 { 11952 if shift >= 64 { 11953 return ErrIntOverflowTypes 11954 } 11955 if iNdEx >= l { 11956 return io.ErrUnexpectedEOF 11957 } 11958 b := dAtA[iNdEx] 11959 iNdEx++ 11960 msglen |= int(b&0x7F) << shift 11961 if b < 0x80 { 11962 break 11963 } 11964 } 11965 if msglen < 0 { 11966 return ErrInvalidLengthTypes 11967 } 11968 postIndex := iNdEx + msglen 11969 if postIndex < 0 { 11970 return ErrInvalidLengthTypes 11971 } 11972 if postIndex > l { 11973 return io.ErrUnexpectedEOF 11974 } 11975 v := &ResponseSetOption{} 11976 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11977 return err 11978 } 11979 m.Value = &Response_SetOption{v} 11980 iNdEx = postIndex 11981 case 6: 11982 if wireType != 2 { 11983 return fmt.Errorf("proto: wrong wireType = %d for field InitChain", wireType) 11984 } 11985 var msglen int 11986 for shift := uint(0); ; shift += 7 { 11987 if shift >= 64 { 11988 return ErrIntOverflowTypes 11989 } 11990 if iNdEx >= l { 11991 return io.ErrUnexpectedEOF 11992 } 11993 b := dAtA[iNdEx] 11994 iNdEx++ 11995 msglen |= int(b&0x7F) << shift 11996 if b < 0x80 { 11997 break 11998 } 11999 } 12000 if msglen < 0 { 12001 return ErrInvalidLengthTypes 12002 } 12003 postIndex := iNdEx + msglen 12004 if postIndex < 0 { 12005 return ErrInvalidLengthTypes 12006 } 12007 if postIndex > l { 12008 return io.ErrUnexpectedEOF 12009 } 12010 v := &ResponseInitChain{} 12011 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12012 return err 12013 } 12014 m.Value = &Response_InitChain{v} 12015 iNdEx = postIndex 12016 case 7: 12017 if wireType != 2 { 12018 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 12019 } 12020 var msglen int 12021 for shift := uint(0); ; shift += 7 { 12022 if shift >= 64 { 12023 return ErrIntOverflowTypes 12024 } 12025 if iNdEx >= l { 12026 return io.ErrUnexpectedEOF 12027 } 12028 b := dAtA[iNdEx] 12029 iNdEx++ 12030 msglen |= int(b&0x7F) << shift 12031 if b < 0x80 { 12032 break 12033 } 12034 } 12035 if msglen < 0 { 12036 return ErrInvalidLengthTypes 12037 } 12038 postIndex := iNdEx + msglen 12039 if postIndex < 0 { 12040 return ErrInvalidLengthTypes 12041 } 12042 if postIndex > l { 12043 return io.ErrUnexpectedEOF 12044 } 12045 v := &ResponseQuery{} 12046 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12047 return err 12048 } 12049 m.Value = &Response_Query{v} 12050 iNdEx = postIndex 12051 case 8: 12052 if wireType != 2 { 12053 return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType) 12054 } 12055 var msglen int 12056 for shift := uint(0); ; shift += 7 { 12057 if shift >= 64 { 12058 return ErrIntOverflowTypes 12059 } 12060 if iNdEx >= l { 12061 return io.ErrUnexpectedEOF 12062 } 12063 b := dAtA[iNdEx] 12064 iNdEx++ 12065 msglen |= int(b&0x7F) << shift 12066 if b < 0x80 { 12067 break 12068 } 12069 } 12070 if msglen < 0 { 12071 return ErrInvalidLengthTypes 12072 } 12073 postIndex := iNdEx + msglen 12074 if postIndex < 0 { 12075 return ErrInvalidLengthTypes 12076 } 12077 if postIndex > l { 12078 return io.ErrUnexpectedEOF 12079 } 12080 v := &ResponseBeginBlock{} 12081 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12082 return err 12083 } 12084 m.Value = &Response_BeginBlock{v} 12085 iNdEx = postIndex 12086 case 9: 12087 if wireType != 2 { 12088 return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) 12089 } 12090 var msglen int 12091 for shift := uint(0); ; shift += 7 { 12092 if shift >= 64 { 12093 return ErrIntOverflowTypes 12094 } 12095 if iNdEx >= l { 12096 return io.ErrUnexpectedEOF 12097 } 12098 b := dAtA[iNdEx] 12099 iNdEx++ 12100 msglen |= int(b&0x7F) << shift 12101 if b < 0x80 { 12102 break 12103 } 12104 } 12105 if msglen < 0 { 12106 return ErrInvalidLengthTypes 12107 } 12108 postIndex := iNdEx + msglen 12109 if postIndex < 0 { 12110 return ErrInvalidLengthTypes 12111 } 12112 if postIndex > l { 12113 return io.ErrUnexpectedEOF 12114 } 12115 v := &ResponseCheckTx{} 12116 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12117 return err 12118 } 12119 m.Value = &Response_CheckTx{v} 12120 iNdEx = postIndex 12121 case 10: 12122 if wireType != 2 { 12123 return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) 12124 } 12125 var msglen int 12126 for shift := uint(0); ; shift += 7 { 12127 if shift >= 64 { 12128 return ErrIntOverflowTypes 12129 } 12130 if iNdEx >= l { 12131 return io.ErrUnexpectedEOF 12132 } 12133 b := dAtA[iNdEx] 12134 iNdEx++ 12135 msglen |= int(b&0x7F) << shift 12136 if b < 0x80 { 12137 break 12138 } 12139 } 12140 if msglen < 0 { 12141 return ErrInvalidLengthTypes 12142 } 12143 postIndex := iNdEx + msglen 12144 if postIndex < 0 { 12145 return ErrInvalidLengthTypes 12146 } 12147 if postIndex > l { 12148 return io.ErrUnexpectedEOF 12149 } 12150 v := &ResponseDeliverTx{} 12151 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12152 return err 12153 } 12154 m.Value = &Response_DeliverTx{v} 12155 iNdEx = postIndex 12156 case 11: 12157 if wireType != 2 { 12158 return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) 12159 } 12160 var msglen int 12161 for shift := uint(0); ; shift += 7 { 12162 if shift >= 64 { 12163 return ErrIntOverflowTypes 12164 } 12165 if iNdEx >= l { 12166 return io.ErrUnexpectedEOF 12167 } 12168 b := dAtA[iNdEx] 12169 iNdEx++ 12170 msglen |= int(b&0x7F) << shift 12171 if b < 0x80 { 12172 break 12173 } 12174 } 12175 if msglen < 0 { 12176 return ErrInvalidLengthTypes 12177 } 12178 postIndex := iNdEx + msglen 12179 if postIndex < 0 { 12180 return ErrInvalidLengthTypes 12181 } 12182 if postIndex > l { 12183 return io.ErrUnexpectedEOF 12184 } 12185 v := &ResponseEndBlock{} 12186 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12187 return err 12188 } 12189 m.Value = &Response_EndBlock{v} 12190 iNdEx = postIndex 12191 case 12: 12192 if wireType != 2 { 12193 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) 12194 } 12195 var msglen int 12196 for shift := uint(0); ; shift += 7 { 12197 if shift >= 64 { 12198 return ErrIntOverflowTypes 12199 } 12200 if iNdEx >= l { 12201 return io.ErrUnexpectedEOF 12202 } 12203 b := dAtA[iNdEx] 12204 iNdEx++ 12205 msglen |= int(b&0x7F) << shift 12206 if b < 0x80 { 12207 break 12208 } 12209 } 12210 if msglen < 0 { 12211 return ErrInvalidLengthTypes 12212 } 12213 postIndex := iNdEx + msglen 12214 if postIndex < 0 { 12215 return ErrInvalidLengthTypes 12216 } 12217 if postIndex > l { 12218 return io.ErrUnexpectedEOF 12219 } 12220 v := &ResponseCommit{} 12221 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12222 return err 12223 } 12224 m.Value = &Response_Commit{v} 12225 iNdEx = postIndex 12226 default: 12227 iNdEx = preIndex 12228 skippy, err := skipTypes(dAtA[iNdEx:]) 12229 if err != nil { 12230 return err 12231 } 12232 if skippy < 0 { 12233 return ErrInvalidLengthTypes 12234 } 12235 if (iNdEx + skippy) < 0 { 12236 return ErrInvalidLengthTypes 12237 } 12238 if (iNdEx + skippy) > l { 12239 return io.ErrUnexpectedEOF 12240 } 12241 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12242 iNdEx += skippy 12243 } 12244 } 12245 12246 if iNdEx > l { 12247 return io.ErrUnexpectedEOF 12248 } 12249 return nil 12250 } 12251 func (m *ResponseException) Unmarshal(dAtA []byte) error { 12252 l := len(dAtA) 12253 iNdEx := 0 12254 for iNdEx < l { 12255 preIndex := iNdEx 12256 var wire uint64 12257 for shift := uint(0); ; shift += 7 { 12258 if shift >= 64 { 12259 return ErrIntOverflowTypes 12260 } 12261 if iNdEx >= l { 12262 return io.ErrUnexpectedEOF 12263 } 12264 b := dAtA[iNdEx] 12265 iNdEx++ 12266 wire |= uint64(b&0x7F) << shift 12267 if b < 0x80 { 12268 break 12269 } 12270 } 12271 fieldNum := int32(wire >> 3) 12272 wireType := int(wire & 0x7) 12273 if wireType == 4 { 12274 return fmt.Errorf("proto: ResponseException: wiretype end group for non-group") 12275 } 12276 if fieldNum <= 0 { 12277 return fmt.Errorf("proto: ResponseException: illegal tag %d (wire type %d)", fieldNum, wire) 12278 } 12279 switch fieldNum { 12280 case 1: 12281 if wireType != 2 { 12282 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 12283 } 12284 var stringLen uint64 12285 for shift := uint(0); ; shift += 7 { 12286 if shift >= 64 { 12287 return ErrIntOverflowTypes 12288 } 12289 if iNdEx >= l { 12290 return io.ErrUnexpectedEOF 12291 } 12292 b := dAtA[iNdEx] 12293 iNdEx++ 12294 stringLen |= uint64(b&0x7F) << shift 12295 if b < 0x80 { 12296 break 12297 } 12298 } 12299 intStringLen := int(stringLen) 12300 if intStringLen < 0 { 12301 return ErrInvalidLengthTypes 12302 } 12303 postIndex := iNdEx + intStringLen 12304 if postIndex < 0 { 12305 return ErrInvalidLengthTypes 12306 } 12307 if postIndex > l { 12308 return io.ErrUnexpectedEOF 12309 } 12310 m.Error = string(dAtA[iNdEx:postIndex]) 12311 iNdEx = postIndex 12312 default: 12313 iNdEx = preIndex 12314 skippy, err := skipTypes(dAtA[iNdEx:]) 12315 if err != nil { 12316 return err 12317 } 12318 if skippy < 0 { 12319 return ErrInvalidLengthTypes 12320 } 12321 if (iNdEx + skippy) < 0 { 12322 return ErrInvalidLengthTypes 12323 } 12324 if (iNdEx + skippy) > l { 12325 return io.ErrUnexpectedEOF 12326 } 12327 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12328 iNdEx += skippy 12329 } 12330 } 12331 12332 if iNdEx > l { 12333 return io.ErrUnexpectedEOF 12334 } 12335 return nil 12336 } 12337 func (m *ResponseEcho) Unmarshal(dAtA []byte) error { 12338 l := len(dAtA) 12339 iNdEx := 0 12340 for iNdEx < l { 12341 preIndex := iNdEx 12342 var wire uint64 12343 for shift := uint(0); ; shift += 7 { 12344 if shift >= 64 { 12345 return ErrIntOverflowTypes 12346 } 12347 if iNdEx >= l { 12348 return io.ErrUnexpectedEOF 12349 } 12350 b := dAtA[iNdEx] 12351 iNdEx++ 12352 wire |= uint64(b&0x7F) << shift 12353 if b < 0x80 { 12354 break 12355 } 12356 } 12357 fieldNum := int32(wire >> 3) 12358 wireType := int(wire & 0x7) 12359 if wireType == 4 { 12360 return fmt.Errorf("proto: ResponseEcho: wiretype end group for non-group") 12361 } 12362 if fieldNum <= 0 { 12363 return fmt.Errorf("proto: ResponseEcho: illegal tag %d (wire type %d)", fieldNum, wire) 12364 } 12365 switch fieldNum { 12366 case 1: 12367 if wireType != 2 { 12368 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 12369 } 12370 var stringLen uint64 12371 for shift := uint(0); ; shift += 7 { 12372 if shift >= 64 { 12373 return ErrIntOverflowTypes 12374 } 12375 if iNdEx >= l { 12376 return io.ErrUnexpectedEOF 12377 } 12378 b := dAtA[iNdEx] 12379 iNdEx++ 12380 stringLen |= uint64(b&0x7F) << shift 12381 if b < 0x80 { 12382 break 12383 } 12384 } 12385 intStringLen := int(stringLen) 12386 if intStringLen < 0 { 12387 return ErrInvalidLengthTypes 12388 } 12389 postIndex := iNdEx + intStringLen 12390 if postIndex < 0 { 12391 return ErrInvalidLengthTypes 12392 } 12393 if postIndex > l { 12394 return io.ErrUnexpectedEOF 12395 } 12396 m.Message = string(dAtA[iNdEx:postIndex]) 12397 iNdEx = postIndex 12398 default: 12399 iNdEx = preIndex 12400 skippy, err := skipTypes(dAtA[iNdEx:]) 12401 if err != nil { 12402 return err 12403 } 12404 if skippy < 0 { 12405 return ErrInvalidLengthTypes 12406 } 12407 if (iNdEx + skippy) < 0 { 12408 return ErrInvalidLengthTypes 12409 } 12410 if (iNdEx + skippy) > l { 12411 return io.ErrUnexpectedEOF 12412 } 12413 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12414 iNdEx += skippy 12415 } 12416 } 12417 12418 if iNdEx > l { 12419 return io.ErrUnexpectedEOF 12420 } 12421 return nil 12422 } 12423 func (m *ResponseFlush) Unmarshal(dAtA []byte) error { 12424 l := len(dAtA) 12425 iNdEx := 0 12426 for iNdEx < l { 12427 preIndex := iNdEx 12428 var wire uint64 12429 for shift := uint(0); ; shift += 7 { 12430 if shift >= 64 { 12431 return ErrIntOverflowTypes 12432 } 12433 if iNdEx >= l { 12434 return io.ErrUnexpectedEOF 12435 } 12436 b := dAtA[iNdEx] 12437 iNdEx++ 12438 wire |= uint64(b&0x7F) << shift 12439 if b < 0x80 { 12440 break 12441 } 12442 } 12443 fieldNum := int32(wire >> 3) 12444 wireType := int(wire & 0x7) 12445 if wireType == 4 { 12446 return fmt.Errorf("proto: ResponseFlush: wiretype end group for non-group") 12447 } 12448 if fieldNum <= 0 { 12449 return fmt.Errorf("proto: ResponseFlush: illegal tag %d (wire type %d)", fieldNum, wire) 12450 } 12451 switch fieldNum { 12452 default: 12453 iNdEx = preIndex 12454 skippy, err := skipTypes(dAtA[iNdEx:]) 12455 if err != nil { 12456 return err 12457 } 12458 if skippy < 0 { 12459 return ErrInvalidLengthTypes 12460 } 12461 if (iNdEx + skippy) < 0 { 12462 return ErrInvalidLengthTypes 12463 } 12464 if (iNdEx + skippy) > l { 12465 return io.ErrUnexpectedEOF 12466 } 12467 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12468 iNdEx += skippy 12469 } 12470 } 12471 12472 if iNdEx > l { 12473 return io.ErrUnexpectedEOF 12474 } 12475 return nil 12476 } 12477 func (m *ResponseInfo) Unmarshal(dAtA []byte) error { 12478 l := len(dAtA) 12479 iNdEx := 0 12480 for iNdEx < l { 12481 preIndex := iNdEx 12482 var wire uint64 12483 for shift := uint(0); ; shift += 7 { 12484 if shift >= 64 { 12485 return ErrIntOverflowTypes 12486 } 12487 if iNdEx >= l { 12488 return io.ErrUnexpectedEOF 12489 } 12490 b := dAtA[iNdEx] 12491 iNdEx++ 12492 wire |= uint64(b&0x7F) << shift 12493 if b < 0x80 { 12494 break 12495 } 12496 } 12497 fieldNum := int32(wire >> 3) 12498 wireType := int(wire & 0x7) 12499 if wireType == 4 { 12500 return fmt.Errorf("proto: ResponseInfo: wiretype end group for non-group") 12501 } 12502 if fieldNum <= 0 { 12503 return fmt.Errorf("proto: ResponseInfo: illegal tag %d (wire type %d)", fieldNum, wire) 12504 } 12505 switch fieldNum { 12506 case 1: 12507 if wireType != 2 { 12508 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 12509 } 12510 var stringLen uint64 12511 for shift := uint(0); ; shift += 7 { 12512 if shift >= 64 { 12513 return ErrIntOverflowTypes 12514 } 12515 if iNdEx >= l { 12516 return io.ErrUnexpectedEOF 12517 } 12518 b := dAtA[iNdEx] 12519 iNdEx++ 12520 stringLen |= uint64(b&0x7F) << shift 12521 if b < 0x80 { 12522 break 12523 } 12524 } 12525 intStringLen := int(stringLen) 12526 if intStringLen < 0 { 12527 return ErrInvalidLengthTypes 12528 } 12529 postIndex := iNdEx + intStringLen 12530 if postIndex < 0 { 12531 return ErrInvalidLengthTypes 12532 } 12533 if postIndex > l { 12534 return io.ErrUnexpectedEOF 12535 } 12536 m.Data = string(dAtA[iNdEx:postIndex]) 12537 iNdEx = postIndex 12538 case 2: 12539 if wireType != 2 { 12540 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 12541 } 12542 var stringLen uint64 12543 for shift := uint(0); ; shift += 7 { 12544 if shift >= 64 { 12545 return ErrIntOverflowTypes 12546 } 12547 if iNdEx >= l { 12548 return io.ErrUnexpectedEOF 12549 } 12550 b := dAtA[iNdEx] 12551 iNdEx++ 12552 stringLen |= uint64(b&0x7F) << shift 12553 if b < 0x80 { 12554 break 12555 } 12556 } 12557 intStringLen := int(stringLen) 12558 if intStringLen < 0 { 12559 return ErrInvalidLengthTypes 12560 } 12561 postIndex := iNdEx + intStringLen 12562 if postIndex < 0 { 12563 return ErrInvalidLengthTypes 12564 } 12565 if postIndex > l { 12566 return io.ErrUnexpectedEOF 12567 } 12568 m.Version = string(dAtA[iNdEx:postIndex]) 12569 iNdEx = postIndex 12570 case 3: 12571 if wireType != 0 { 12572 return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType) 12573 } 12574 m.AppVersion = 0 12575 for shift := uint(0); ; shift += 7 { 12576 if shift >= 64 { 12577 return ErrIntOverflowTypes 12578 } 12579 if iNdEx >= l { 12580 return io.ErrUnexpectedEOF 12581 } 12582 b := dAtA[iNdEx] 12583 iNdEx++ 12584 m.AppVersion |= uint64(b&0x7F) << shift 12585 if b < 0x80 { 12586 break 12587 } 12588 } 12589 case 4: 12590 if wireType != 0 { 12591 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockHeight", wireType) 12592 } 12593 m.LastBlockHeight = 0 12594 for shift := uint(0); ; shift += 7 { 12595 if shift >= 64 { 12596 return ErrIntOverflowTypes 12597 } 12598 if iNdEx >= l { 12599 return io.ErrUnexpectedEOF 12600 } 12601 b := dAtA[iNdEx] 12602 iNdEx++ 12603 m.LastBlockHeight |= int64(b&0x7F) << shift 12604 if b < 0x80 { 12605 break 12606 } 12607 } 12608 case 5: 12609 if wireType != 2 { 12610 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockAppHash", wireType) 12611 } 12612 var byteLen int 12613 for shift := uint(0); ; shift += 7 { 12614 if shift >= 64 { 12615 return ErrIntOverflowTypes 12616 } 12617 if iNdEx >= l { 12618 return io.ErrUnexpectedEOF 12619 } 12620 b := dAtA[iNdEx] 12621 iNdEx++ 12622 byteLen |= int(b&0x7F) << shift 12623 if b < 0x80 { 12624 break 12625 } 12626 } 12627 if byteLen < 0 { 12628 return ErrInvalidLengthTypes 12629 } 12630 postIndex := iNdEx + byteLen 12631 if postIndex < 0 { 12632 return ErrInvalidLengthTypes 12633 } 12634 if postIndex > l { 12635 return io.ErrUnexpectedEOF 12636 } 12637 m.LastBlockAppHash = append(m.LastBlockAppHash[:0], dAtA[iNdEx:postIndex]...) 12638 if m.LastBlockAppHash == nil { 12639 m.LastBlockAppHash = []byte{} 12640 } 12641 iNdEx = postIndex 12642 default: 12643 iNdEx = preIndex 12644 skippy, err := skipTypes(dAtA[iNdEx:]) 12645 if err != nil { 12646 return err 12647 } 12648 if skippy < 0 { 12649 return ErrInvalidLengthTypes 12650 } 12651 if (iNdEx + skippy) < 0 { 12652 return ErrInvalidLengthTypes 12653 } 12654 if (iNdEx + skippy) > l { 12655 return io.ErrUnexpectedEOF 12656 } 12657 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12658 iNdEx += skippy 12659 } 12660 } 12661 12662 if iNdEx > l { 12663 return io.ErrUnexpectedEOF 12664 } 12665 return nil 12666 } 12667 func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { 12668 l := len(dAtA) 12669 iNdEx := 0 12670 for iNdEx < l { 12671 preIndex := iNdEx 12672 var wire uint64 12673 for shift := uint(0); ; shift += 7 { 12674 if shift >= 64 { 12675 return ErrIntOverflowTypes 12676 } 12677 if iNdEx >= l { 12678 return io.ErrUnexpectedEOF 12679 } 12680 b := dAtA[iNdEx] 12681 iNdEx++ 12682 wire |= uint64(b&0x7F) << shift 12683 if b < 0x80 { 12684 break 12685 } 12686 } 12687 fieldNum := int32(wire >> 3) 12688 wireType := int(wire & 0x7) 12689 if wireType == 4 { 12690 return fmt.Errorf("proto: ResponseSetOption: wiretype end group for non-group") 12691 } 12692 if fieldNum <= 0 { 12693 return fmt.Errorf("proto: ResponseSetOption: illegal tag %d (wire type %d)", fieldNum, wire) 12694 } 12695 switch fieldNum { 12696 case 1: 12697 if wireType != 0 { 12698 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 12699 } 12700 m.Code = 0 12701 for shift := uint(0); ; shift += 7 { 12702 if shift >= 64 { 12703 return ErrIntOverflowTypes 12704 } 12705 if iNdEx >= l { 12706 return io.ErrUnexpectedEOF 12707 } 12708 b := dAtA[iNdEx] 12709 iNdEx++ 12710 m.Code |= uint32(b&0x7F) << shift 12711 if b < 0x80 { 12712 break 12713 } 12714 } 12715 case 3: 12716 if wireType != 2 { 12717 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 12718 } 12719 var stringLen uint64 12720 for shift := uint(0); ; shift += 7 { 12721 if shift >= 64 { 12722 return ErrIntOverflowTypes 12723 } 12724 if iNdEx >= l { 12725 return io.ErrUnexpectedEOF 12726 } 12727 b := dAtA[iNdEx] 12728 iNdEx++ 12729 stringLen |= uint64(b&0x7F) << shift 12730 if b < 0x80 { 12731 break 12732 } 12733 } 12734 intStringLen := int(stringLen) 12735 if intStringLen < 0 { 12736 return ErrInvalidLengthTypes 12737 } 12738 postIndex := iNdEx + intStringLen 12739 if postIndex < 0 { 12740 return ErrInvalidLengthTypes 12741 } 12742 if postIndex > l { 12743 return io.ErrUnexpectedEOF 12744 } 12745 m.Log = string(dAtA[iNdEx:postIndex]) 12746 iNdEx = postIndex 12747 case 4: 12748 if wireType != 2 { 12749 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 12750 } 12751 var stringLen uint64 12752 for shift := uint(0); ; shift += 7 { 12753 if shift >= 64 { 12754 return ErrIntOverflowTypes 12755 } 12756 if iNdEx >= l { 12757 return io.ErrUnexpectedEOF 12758 } 12759 b := dAtA[iNdEx] 12760 iNdEx++ 12761 stringLen |= uint64(b&0x7F) << shift 12762 if b < 0x80 { 12763 break 12764 } 12765 } 12766 intStringLen := int(stringLen) 12767 if intStringLen < 0 { 12768 return ErrInvalidLengthTypes 12769 } 12770 postIndex := iNdEx + intStringLen 12771 if postIndex < 0 { 12772 return ErrInvalidLengthTypes 12773 } 12774 if postIndex > l { 12775 return io.ErrUnexpectedEOF 12776 } 12777 m.Info = string(dAtA[iNdEx:postIndex]) 12778 iNdEx = postIndex 12779 default: 12780 iNdEx = preIndex 12781 skippy, err := skipTypes(dAtA[iNdEx:]) 12782 if err != nil { 12783 return err 12784 } 12785 if skippy < 0 { 12786 return ErrInvalidLengthTypes 12787 } 12788 if (iNdEx + skippy) < 0 { 12789 return ErrInvalidLengthTypes 12790 } 12791 if (iNdEx + skippy) > l { 12792 return io.ErrUnexpectedEOF 12793 } 12794 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12795 iNdEx += skippy 12796 } 12797 } 12798 12799 if iNdEx > l { 12800 return io.ErrUnexpectedEOF 12801 } 12802 return nil 12803 } 12804 func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { 12805 l := len(dAtA) 12806 iNdEx := 0 12807 for iNdEx < l { 12808 preIndex := iNdEx 12809 var wire uint64 12810 for shift := uint(0); ; shift += 7 { 12811 if shift >= 64 { 12812 return ErrIntOverflowTypes 12813 } 12814 if iNdEx >= l { 12815 return io.ErrUnexpectedEOF 12816 } 12817 b := dAtA[iNdEx] 12818 iNdEx++ 12819 wire |= uint64(b&0x7F) << shift 12820 if b < 0x80 { 12821 break 12822 } 12823 } 12824 fieldNum := int32(wire >> 3) 12825 wireType := int(wire & 0x7) 12826 if wireType == 4 { 12827 return fmt.Errorf("proto: ResponseInitChain: wiretype end group for non-group") 12828 } 12829 if fieldNum <= 0 { 12830 return fmt.Errorf("proto: ResponseInitChain: illegal tag %d (wire type %d)", fieldNum, wire) 12831 } 12832 switch fieldNum { 12833 case 1: 12834 if wireType != 2 { 12835 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) 12836 } 12837 var msglen int 12838 for shift := uint(0); ; shift += 7 { 12839 if shift >= 64 { 12840 return ErrIntOverflowTypes 12841 } 12842 if iNdEx >= l { 12843 return io.ErrUnexpectedEOF 12844 } 12845 b := dAtA[iNdEx] 12846 iNdEx++ 12847 msglen |= int(b&0x7F) << shift 12848 if b < 0x80 { 12849 break 12850 } 12851 } 12852 if msglen < 0 { 12853 return ErrInvalidLengthTypes 12854 } 12855 postIndex := iNdEx + msglen 12856 if postIndex < 0 { 12857 return ErrInvalidLengthTypes 12858 } 12859 if postIndex > l { 12860 return io.ErrUnexpectedEOF 12861 } 12862 if m.ConsensusParams == nil { 12863 m.ConsensusParams = &ConsensusParams{} 12864 } 12865 if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12866 return err 12867 } 12868 iNdEx = postIndex 12869 case 2: 12870 if wireType != 2 { 12871 return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) 12872 } 12873 var msglen int 12874 for shift := uint(0); ; shift += 7 { 12875 if shift >= 64 { 12876 return ErrIntOverflowTypes 12877 } 12878 if iNdEx >= l { 12879 return io.ErrUnexpectedEOF 12880 } 12881 b := dAtA[iNdEx] 12882 iNdEx++ 12883 msglen |= int(b&0x7F) << shift 12884 if b < 0x80 { 12885 break 12886 } 12887 } 12888 if msglen < 0 { 12889 return ErrInvalidLengthTypes 12890 } 12891 postIndex := iNdEx + msglen 12892 if postIndex < 0 { 12893 return ErrInvalidLengthTypes 12894 } 12895 if postIndex > l { 12896 return io.ErrUnexpectedEOF 12897 } 12898 m.Validators = append(m.Validators, ValidatorUpdate{}) 12899 if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12900 return err 12901 } 12902 iNdEx = postIndex 12903 default: 12904 iNdEx = preIndex 12905 skippy, err := skipTypes(dAtA[iNdEx:]) 12906 if err != nil { 12907 return err 12908 } 12909 if skippy < 0 { 12910 return ErrInvalidLengthTypes 12911 } 12912 if (iNdEx + skippy) < 0 { 12913 return ErrInvalidLengthTypes 12914 } 12915 if (iNdEx + skippy) > l { 12916 return io.ErrUnexpectedEOF 12917 } 12918 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 12919 iNdEx += skippy 12920 } 12921 } 12922 12923 if iNdEx > l { 12924 return io.ErrUnexpectedEOF 12925 } 12926 return nil 12927 } 12928 func (m *ResponseQuery) Unmarshal(dAtA []byte) error { 12929 l := len(dAtA) 12930 iNdEx := 0 12931 for iNdEx < l { 12932 preIndex := iNdEx 12933 var wire uint64 12934 for shift := uint(0); ; shift += 7 { 12935 if shift >= 64 { 12936 return ErrIntOverflowTypes 12937 } 12938 if iNdEx >= l { 12939 return io.ErrUnexpectedEOF 12940 } 12941 b := dAtA[iNdEx] 12942 iNdEx++ 12943 wire |= uint64(b&0x7F) << shift 12944 if b < 0x80 { 12945 break 12946 } 12947 } 12948 fieldNum := int32(wire >> 3) 12949 wireType := int(wire & 0x7) 12950 if wireType == 4 { 12951 return fmt.Errorf("proto: ResponseQuery: wiretype end group for non-group") 12952 } 12953 if fieldNum <= 0 { 12954 return fmt.Errorf("proto: ResponseQuery: illegal tag %d (wire type %d)", fieldNum, wire) 12955 } 12956 switch fieldNum { 12957 case 1: 12958 if wireType != 0 { 12959 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 12960 } 12961 m.Code = 0 12962 for shift := uint(0); ; shift += 7 { 12963 if shift >= 64 { 12964 return ErrIntOverflowTypes 12965 } 12966 if iNdEx >= l { 12967 return io.ErrUnexpectedEOF 12968 } 12969 b := dAtA[iNdEx] 12970 iNdEx++ 12971 m.Code |= uint32(b&0x7F) << shift 12972 if b < 0x80 { 12973 break 12974 } 12975 } 12976 case 3: 12977 if wireType != 2 { 12978 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 12979 } 12980 var stringLen uint64 12981 for shift := uint(0); ; shift += 7 { 12982 if shift >= 64 { 12983 return ErrIntOverflowTypes 12984 } 12985 if iNdEx >= l { 12986 return io.ErrUnexpectedEOF 12987 } 12988 b := dAtA[iNdEx] 12989 iNdEx++ 12990 stringLen |= uint64(b&0x7F) << shift 12991 if b < 0x80 { 12992 break 12993 } 12994 } 12995 intStringLen := int(stringLen) 12996 if intStringLen < 0 { 12997 return ErrInvalidLengthTypes 12998 } 12999 postIndex := iNdEx + intStringLen 13000 if postIndex < 0 { 13001 return ErrInvalidLengthTypes 13002 } 13003 if postIndex > l { 13004 return io.ErrUnexpectedEOF 13005 } 13006 m.Log = string(dAtA[iNdEx:postIndex]) 13007 iNdEx = postIndex 13008 case 4: 13009 if wireType != 2 { 13010 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 13011 } 13012 var stringLen uint64 13013 for shift := uint(0); ; shift += 7 { 13014 if shift >= 64 { 13015 return ErrIntOverflowTypes 13016 } 13017 if iNdEx >= l { 13018 return io.ErrUnexpectedEOF 13019 } 13020 b := dAtA[iNdEx] 13021 iNdEx++ 13022 stringLen |= uint64(b&0x7F) << shift 13023 if b < 0x80 { 13024 break 13025 } 13026 } 13027 intStringLen := int(stringLen) 13028 if intStringLen < 0 { 13029 return ErrInvalidLengthTypes 13030 } 13031 postIndex := iNdEx + intStringLen 13032 if postIndex < 0 { 13033 return ErrInvalidLengthTypes 13034 } 13035 if postIndex > l { 13036 return io.ErrUnexpectedEOF 13037 } 13038 m.Info = string(dAtA[iNdEx:postIndex]) 13039 iNdEx = postIndex 13040 case 5: 13041 if wireType != 0 { 13042 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 13043 } 13044 m.Index = 0 13045 for shift := uint(0); ; shift += 7 { 13046 if shift >= 64 { 13047 return ErrIntOverflowTypes 13048 } 13049 if iNdEx >= l { 13050 return io.ErrUnexpectedEOF 13051 } 13052 b := dAtA[iNdEx] 13053 iNdEx++ 13054 m.Index |= int64(b&0x7F) << shift 13055 if b < 0x80 { 13056 break 13057 } 13058 } 13059 case 6: 13060 if wireType != 2 { 13061 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 13062 } 13063 var byteLen int 13064 for shift := uint(0); ; shift += 7 { 13065 if shift >= 64 { 13066 return ErrIntOverflowTypes 13067 } 13068 if iNdEx >= l { 13069 return io.ErrUnexpectedEOF 13070 } 13071 b := dAtA[iNdEx] 13072 iNdEx++ 13073 byteLen |= int(b&0x7F) << shift 13074 if b < 0x80 { 13075 break 13076 } 13077 } 13078 if byteLen < 0 { 13079 return ErrInvalidLengthTypes 13080 } 13081 postIndex := iNdEx + byteLen 13082 if postIndex < 0 { 13083 return ErrInvalidLengthTypes 13084 } 13085 if postIndex > l { 13086 return io.ErrUnexpectedEOF 13087 } 13088 m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) 13089 if m.Key == nil { 13090 m.Key = []byte{} 13091 } 13092 iNdEx = postIndex 13093 case 7: 13094 if wireType != 2 { 13095 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 13096 } 13097 var byteLen int 13098 for shift := uint(0); ; shift += 7 { 13099 if shift >= 64 { 13100 return ErrIntOverflowTypes 13101 } 13102 if iNdEx >= l { 13103 return io.ErrUnexpectedEOF 13104 } 13105 b := dAtA[iNdEx] 13106 iNdEx++ 13107 byteLen |= int(b&0x7F) << shift 13108 if b < 0x80 { 13109 break 13110 } 13111 } 13112 if byteLen < 0 { 13113 return ErrInvalidLengthTypes 13114 } 13115 postIndex := iNdEx + byteLen 13116 if postIndex < 0 { 13117 return ErrInvalidLengthTypes 13118 } 13119 if postIndex > l { 13120 return io.ErrUnexpectedEOF 13121 } 13122 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 13123 if m.Value == nil { 13124 m.Value = []byte{} 13125 } 13126 iNdEx = postIndex 13127 case 8: 13128 if wireType != 2 { 13129 return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType) 13130 } 13131 var msglen int 13132 for shift := uint(0); ; shift += 7 { 13133 if shift >= 64 { 13134 return ErrIntOverflowTypes 13135 } 13136 if iNdEx >= l { 13137 return io.ErrUnexpectedEOF 13138 } 13139 b := dAtA[iNdEx] 13140 iNdEx++ 13141 msglen |= int(b&0x7F) << shift 13142 if b < 0x80 { 13143 break 13144 } 13145 } 13146 if msglen < 0 { 13147 return ErrInvalidLengthTypes 13148 } 13149 postIndex := iNdEx + msglen 13150 if postIndex < 0 { 13151 return ErrInvalidLengthTypes 13152 } 13153 if postIndex > l { 13154 return io.ErrUnexpectedEOF 13155 } 13156 if m.Proof == nil { 13157 m.Proof = &merkle.Proof{} 13158 } 13159 if err := m.Proof.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13160 return err 13161 } 13162 iNdEx = postIndex 13163 case 9: 13164 if wireType != 0 { 13165 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 13166 } 13167 m.Height = 0 13168 for shift := uint(0); ; shift += 7 { 13169 if shift >= 64 { 13170 return ErrIntOverflowTypes 13171 } 13172 if iNdEx >= l { 13173 return io.ErrUnexpectedEOF 13174 } 13175 b := dAtA[iNdEx] 13176 iNdEx++ 13177 m.Height |= int64(b&0x7F) << shift 13178 if b < 0x80 { 13179 break 13180 } 13181 } 13182 case 10: 13183 if wireType != 2 { 13184 return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) 13185 } 13186 var stringLen uint64 13187 for shift := uint(0); ; shift += 7 { 13188 if shift >= 64 { 13189 return ErrIntOverflowTypes 13190 } 13191 if iNdEx >= l { 13192 return io.ErrUnexpectedEOF 13193 } 13194 b := dAtA[iNdEx] 13195 iNdEx++ 13196 stringLen |= uint64(b&0x7F) << shift 13197 if b < 0x80 { 13198 break 13199 } 13200 } 13201 intStringLen := int(stringLen) 13202 if intStringLen < 0 { 13203 return ErrInvalidLengthTypes 13204 } 13205 postIndex := iNdEx + intStringLen 13206 if postIndex < 0 { 13207 return ErrInvalidLengthTypes 13208 } 13209 if postIndex > l { 13210 return io.ErrUnexpectedEOF 13211 } 13212 m.Codespace = string(dAtA[iNdEx:postIndex]) 13213 iNdEx = postIndex 13214 default: 13215 iNdEx = preIndex 13216 skippy, err := skipTypes(dAtA[iNdEx:]) 13217 if err != nil { 13218 return err 13219 } 13220 if skippy < 0 { 13221 return ErrInvalidLengthTypes 13222 } 13223 if (iNdEx + skippy) < 0 { 13224 return ErrInvalidLengthTypes 13225 } 13226 if (iNdEx + skippy) > l { 13227 return io.ErrUnexpectedEOF 13228 } 13229 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 13230 iNdEx += skippy 13231 } 13232 } 13233 13234 if iNdEx > l { 13235 return io.ErrUnexpectedEOF 13236 } 13237 return nil 13238 } 13239 func (m *ResponseBeginBlock) Unmarshal(dAtA []byte) error { 13240 l := len(dAtA) 13241 iNdEx := 0 13242 for iNdEx < l { 13243 preIndex := iNdEx 13244 var wire uint64 13245 for shift := uint(0); ; shift += 7 { 13246 if shift >= 64 { 13247 return ErrIntOverflowTypes 13248 } 13249 if iNdEx >= l { 13250 return io.ErrUnexpectedEOF 13251 } 13252 b := dAtA[iNdEx] 13253 iNdEx++ 13254 wire |= uint64(b&0x7F) << shift 13255 if b < 0x80 { 13256 break 13257 } 13258 } 13259 fieldNum := int32(wire >> 3) 13260 wireType := int(wire & 0x7) 13261 if wireType == 4 { 13262 return fmt.Errorf("proto: ResponseBeginBlock: wiretype end group for non-group") 13263 } 13264 if fieldNum <= 0 { 13265 return fmt.Errorf("proto: ResponseBeginBlock: illegal tag %d (wire type %d)", fieldNum, wire) 13266 } 13267 switch fieldNum { 13268 case 1: 13269 if wireType != 2 { 13270 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 13271 } 13272 var msglen int 13273 for shift := uint(0); ; shift += 7 { 13274 if shift >= 64 { 13275 return ErrIntOverflowTypes 13276 } 13277 if iNdEx >= l { 13278 return io.ErrUnexpectedEOF 13279 } 13280 b := dAtA[iNdEx] 13281 iNdEx++ 13282 msglen |= int(b&0x7F) << shift 13283 if b < 0x80 { 13284 break 13285 } 13286 } 13287 if msglen < 0 { 13288 return ErrInvalidLengthTypes 13289 } 13290 postIndex := iNdEx + msglen 13291 if postIndex < 0 { 13292 return ErrInvalidLengthTypes 13293 } 13294 if postIndex > l { 13295 return io.ErrUnexpectedEOF 13296 } 13297 m.Events = append(m.Events, Event{}) 13298 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13299 return err 13300 } 13301 iNdEx = postIndex 13302 default: 13303 iNdEx = preIndex 13304 skippy, err := skipTypes(dAtA[iNdEx:]) 13305 if err != nil { 13306 return err 13307 } 13308 if skippy < 0 { 13309 return ErrInvalidLengthTypes 13310 } 13311 if (iNdEx + skippy) < 0 { 13312 return ErrInvalidLengthTypes 13313 } 13314 if (iNdEx + skippy) > l { 13315 return io.ErrUnexpectedEOF 13316 } 13317 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 13318 iNdEx += skippy 13319 } 13320 } 13321 13322 if iNdEx > l { 13323 return io.ErrUnexpectedEOF 13324 } 13325 return nil 13326 } 13327 func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { 13328 l := len(dAtA) 13329 iNdEx := 0 13330 for iNdEx < l { 13331 preIndex := iNdEx 13332 var wire uint64 13333 for shift := uint(0); ; shift += 7 { 13334 if shift >= 64 { 13335 return ErrIntOverflowTypes 13336 } 13337 if iNdEx >= l { 13338 return io.ErrUnexpectedEOF 13339 } 13340 b := dAtA[iNdEx] 13341 iNdEx++ 13342 wire |= uint64(b&0x7F) << shift 13343 if b < 0x80 { 13344 break 13345 } 13346 } 13347 fieldNum := int32(wire >> 3) 13348 wireType := int(wire & 0x7) 13349 if wireType == 4 { 13350 return fmt.Errorf("proto: ResponseCheckTx: wiretype end group for non-group") 13351 } 13352 if fieldNum <= 0 { 13353 return fmt.Errorf("proto: ResponseCheckTx: illegal tag %d (wire type %d)", fieldNum, wire) 13354 } 13355 switch fieldNum { 13356 case 1: 13357 if wireType != 0 { 13358 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 13359 } 13360 m.Code = 0 13361 for shift := uint(0); ; shift += 7 { 13362 if shift >= 64 { 13363 return ErrIntOverflowTypes 13364 } 13365 if iNdEx >= l { 13366 return io.ErrUnexpectedEOF 13367 } 13368 b := dAtA[iNdEx] 13369 iNdEx++ 13370 m.Code |= uint32(b&0x7F) << shift 13371 if b < 0x80 { 13372 break 13373 } 13374 } 13375 case 2: 13376 if wireType != 2 { 13377 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 13378 } 13379 var byteLen int 13380 for shift := uint(0); ; shift += 7 { 13381 if shift >= 64 { 13382 return ErrIntOverflowTypes 13383 } 13384 if iNdEx >= l { 13385 return io.ErrUnexpectedEOF 13386 } 13387 b := dAtA[iNdEx] 13388 iNdEx++ 13389 byteLen |= int(b&0x7F) << shift 13390 if b < 0x80 { 13391 break 13392 } 13393 } 13394 if byteLen < 0 { 13395 return ErrInvalidLengthTypes 13396 } 13397 postIndex := iNdEx + byteLen 13398 if postIndex < 0 { 13399 return ErrInvalidLengthTypes 13400 } 13401 if postIndex > l { 13402 return io.ErrUnexpectedEOF 13403 } 13404 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 13405 if m.Data == nil { 13406 m.Data = []byte{} 13407 } 13408 iNdEx = postIndex 13409 case 3: 13410 if wireType != 2 { 13411 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 13412 } 13413 var stringLen uint64 13414 for shift := uint(0); ; shift += 7 { 13415 if shift >= 64 { 13416 return ErrIntOverflowTypes 13417 } 13418 if iNdEx >= l { 13419 return io.ErrUnexpectedEOF 13420 } 13421 b := dAtA[iNdEx] 13422 iNdEx++ 13423 stringLen |= uint64(b&0x7F) << shift 13424 if b < 0x80 { 13425 break 13426 } 13427 } 13428 intStringLen := int(stringLen) 13429 if intStringLen < 0 { 13430 return ErrInvalidLengthTypes 13431 } 13432 postIndex := iNdEx + intStringLen 13433 if postIndex < 0 { 13434 return ErrInvalidLengthTypes 13435 } 13436 if postIndex > l { 13437 return io.ErrUnexpectedEOF 13438 } 13439 m.Log = string(dAtA[iNdEx:postIndex]) 13440 iNdEx = postIndex 13441 case 4: 13442 if wireType != 2 { 13443 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 13444 } 13445 var stringLen uint64 13446 for shift := uint(0); ; shift += 7 { 13447 if shift >= 64 { 13448 return ErrIntOverflowTypes 13449 } 13450 if iNdEx >= l { 13451 return io.ErrUnexpectedEOF 13452 } 13453 b := dAtA[iNdEx] 13454 iNdEx++ 13455 stringLen |= uint64(b&0x7F) << shift 13456 if b < 0x80 { 13457 break 13458 } 13459 } 13460 intStringLen := int(stringLen) 13461 if intStringLen < 0 { 13462 return ErrInvalidLengthTypes 13463 } 13464 postIndex := iNdEx + intStringLen 13465 if postIndex < 0 { 13466 return ErrInvalidLengthTypes 13467 } 13468 if postIndex > l { 13469 return io.ErrUnexpectedEOF 13470 } 13471 m.Info = string(dAtA[iNdEx:postIndex]) 13472 iNdEx = postIndex 13473 case 5: 13474 if wireType != 0 { 13475 return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) 13476 } 13477 m.GasWanted = 0 13478 for shift := uint(0); ; shift += 7 { 13479 if shift >= 64 { 13480 return ErrIntOverflowTypes 13481 } 13482 if iNdEx >= l { 13483 return io.ErrUnexpectedEOF 13484 } 13485 b := dAtA[iNdEx] 13486 iNdEx++ 13487 m.GasWanted |= int64(b&0x7F) << shift 13488 if b < 0x80 { 13489 break 13490 } 13491 } 13492 case 6: 13493 if wireType != 0 { 13494 return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) 13495 } 13496 m.GasUsed = 0 13497 for shift := uint(0); ; shift += 7 { 13498 if shift >= 64 { 13499 return ErrIntOverflowTypes 13500 } 13501 if iNdEx >= l { 13502 return io.ErrUnexpectedEOF 13503 } 13504 b := dAtA[iNdEx] 13505 iNdEx++ 13506 m.GasUsed |= int64(b&0x7F) << shift 13507 if b < 0x80 { 13508 break 13509 } 13510 } 13511 case 7: 13512 if wireType != 2 { 13513 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 13514 } 13515 var msglen int 13516 for shift := uint(0); ; shift += 7 { 13517 if shift >= 64 { 13518 return ErrIntOverflowTypes 13519 } 13520 if iNdEx >= l { 13521 return io.ErrUnexpectedEOF 13522 } 13523 b := dAtA[iNdEx] 13524 iNdEx++ 13525 msglen |= int(b&0x7F) << shift 13526 if b < 0x80 { 13527 break 13528 } 13529 } 13530 if msglen < 0 { 13531 return ErrInvalidLengthTypes 13532 } 13533 postIndex := iNdEx + msglen 13534 if postIndex < 0 { 13535 return ErrInvalidLengthTypes 13536 } 13537 if postIndex > l { 13538 return io.ErrUnexpectedEOF 13539 } 13540 m.Events = append(m.Events, Event{}) 13541 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13542 return err 13543 } 13544 iNdEx = postIndex 13545 case 8: 13546 if wireType != 2 { 13547 return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) 13548 } 13549 var stringLen uint64 13550 for shift := uint(0); ; shift += 7 { 13551 if shift >= 64 { 13552 return ErrIntOverflowTypes 13553 } 13554 if iNdEx >= l { 13555 return io.ErrUnexpectedEOF 13556 } 13557 b := dAtA[iNdEx] 13558 iNdEx++ 13559 stringLen |= uint64(b&0x7F) << shift 13560 if b < 0x80 { 13561 break 13562 } 13563 } 13564 intStringLen := int(stringLen) 13565 if intStringLen < 0 { 13566 return ErrInvalidLengthTypes 13567 } 13568 postIndex := iNdEx + intStringLen 13569 if postIndex < 0 { 13570 return ErrInvalidLengthTypes 13571 } 13572 if postIndex > l { 13573 return io.ErrUnexpectedEOF 13574 } 13575 m.Codespace = string(dAtA[iNdEx:postIndex]) 13576 iNdEx = postIndex 13577 default: 13578 iNdEx = preIndex 13579 skippy, err := skipTypes(dAtA[iNdEx:]) 13580 if err != nil { 13581 return err 13582 } 13583 if skippy < 0 { 13584 return ErrInvalidLengthTypes 13585 } 13586 if (iNdEx + skippy) < 0 { 13587 return ErrInvalidLengthTypes 13588 } 13589 if (iNdEx + skippy) > l { 13590 return io.ErrUnexpectedEOF 13591 } 13592 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 13593 iNdEx += skippy 13594 } 13595 } 13596 13597 if iNdEx > l { 13598 return io.ErrUnexpectedEOF 13599 } 13600 return nil 13601 } 13602 func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { 13603 l := len(dAtA) 13604 iNdEx := 0 13605 for iNdEx < l { 13606 preIndex := iNdEx 13607 var wire uint64 13608 for shift := uint(0); ; shift += 7 { 13609 if shift >= 64 { 13610 return ErrIntOverflowTypes 13611 } 13612 if iNdEx >= l { 13613 return io.ErrUnexpectedEOF 13614 } 13615 b := dAtA[iNdEx] 13616 iNdEx++ 13617 wire |= uint64(b&0x7F) << shift 13618 if b < 0x80 { 13619 break 13620 } 13621 } 13622 fieldNum := int32(wire >> 3) 13623 wireType := int(wire & 0x7) 13624 if wireType == 4 { 13625 return fmt.Errorf("proto: ResponseDeliverTx: wiretype end group for non-group") 13626 } 13627 if fieldNum <= 0 { 13628 return fmt.Errorf("proto: ResponseDeliverTx: illegal tag %d (wire type %d)", fieldNum, wire) 13629 } 13630 switch fieldNum { 13631 case 1: 13632 if wireType != 0 { 13633 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 13634 } 13635 m.Code = 0 13636 for shift := uint(0); ; shift += 7 { 13637 if shift >= 64 { 13638 return ErrIntOverflowTypes 13639 } 13640 if iNdEx >= l { 13641 return io.ErrUnexpectedEOF 13642 } 13643 b := dAtA[iNdEx] 13644 iNdEx++ 13645 m.Code |= uint32(b&0x7F) << shift 13646 if b < 0x80 { 13647 break 13648 } 13649 } 13650 case 2: 13651 if wireType != 2 { 13652 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 13653 } 13654 var byteLen int 13655 for shift := uint(0); ; shift += 7 { 13656 if shift >= 64 { 13657 return ErrIntOverflowTypes 13658 } 13659 if iNdEx >= l { 13660 return io.ErrUnexpectedEOF 13661 } 13662 b := dAtA[iNdEx] 13663 iNdEx++ 13664 byteLen |= int(b&0x7F) << shift 13665 if b < 0x80 { 13666 break 13667 } 13668 } 13669 if byteLen < 0 { 13670 return ErrInvalidLengthTypes 13671 } 13672 postIndex := iNdEx + byteLen 13673 if postIndex < 0 { 13674 return ErrInvalidLengthTypes 13675 } 13676 if postIndex > l { 13677 return io.ErrUnexpectedEOF 13678 } 13679 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 13680 if m.Data == nil { 13681 m.Data = []byte{} 13682 } 13683 iNdEx = postIndex 13684 case 3: 13685 if wireType != 2 { 13686 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 13687 } 13688 var stringLen uint64 13689 for shift := uint(0); ; shift += 7 { 13690 if shift >= 64 { 13691 return ErrIntOverflowTypes 13692 } 13693 if iNdEx >= l { 13694 return io.ErrUnexpectedEOF 13695 } 13696 b := dAtA[iNdEx] 13697 iNdEx++ 13698 stringLen |= uint64(b&0x7F) << shift 13699 if b < 0x80 { 13700 break 13701 } 13702 } 13703 intStringLen := int(stringLen) 13704 if intStringLen < 0 { 13705 return ErrInvalidLengthTypes 13706 } 13707 postIndex := iNdEx + intStringLen 13708 if postIndex < 0 { 13709 return ErrInvalidLengthTypes 13710 } 13711 if postIndex > l { 13712 return io.ErrUnexpectedEOF 13713 } 13714 m.Log = string(dAtA[iNdEx:postIndex]) 13715 iNdEx = postIndex 13716 case 4: 13717 if wireType != 2 { 13718 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 13719 } 13720 var stringLen uint64 13721 for shift := uint(0); ; shift += 7 { 13722 if shift >= 64 { 13723 return ErrIntOverflowTypes 13724 } 13725 if iNdEx >= l { 13726 return io.ErrUnexpectedEOF 13727 } 13728 b := dAtA[iNdEx] 13729 iNdEx++ 13730 stringLen |= uint64(b&0x7F) << shift 13731 if b < 0x80 { 13732 break 13733 } 13734 } 13735 intStringLen := int(stringLen) 13736 if intStringLen < 0 { 13737 return ErrInvalidLengthTypes 13738 } 13739 postIndex := iNdEx + intStringLen 13740 if postIndex < 0 { 13741 return ErrInvalidLengthTypes 13742 } 13743 if postIndex > l { 13744 return io.ErrUnexpectedEOF 13745 } 13746 m.Info = string(dAtA[iNdEx:postIndex]) 13747 iNdEx = postIndex 13748 case 5: 13749 if wireType != 0 { 13750 return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) 13751 } 13752 m.GasWanted = 0 13753 for shift := uint(0); ; shift += 7 { 13754 if shift >= 64 { 13755 return ErrIntOverflowTypes 13756 } 13757 if iNdEx >= l { 13758 return io.ErrUnexpectedEOF 13759 } 13760 b := dAtA[iNdEx] 13761 iNdEx++ 13762 m.GasWanted |= int64(b&0x7F) << shift 13763 if b < 0x80 { 13764 break 13765 } 13766 } 13767 case 6: 13768 if wireType != 0 { 13769 return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) 13770 } 13771 m.GasUsed = 0 13772 for shift := uint(0); ; shift += 7 { 13773 if shift >= 64 { 13774 return ErrIntOverflowTypes 13775 } 13776 if iNdEx >= l { 13777 return io.ErrUnexpectedEOF 13778 } 13779 b := dAtA[iNdEx] 13780 iNdEx++ 13781 m.GasUsed |= int64(b&0x7F) << shift 13782 if b < 0x80 { 13783 break 13784 } 13785 } 13786 case 7: 13787 if wireType != 2 { 13788 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 13789 } 13790 var msglen int 13791 for shift := uint(0); ; shift += 7 { 13792 if shift >= 64 { 13793 return ErrIntOverflowTypes 13794 } 13795 if iNdEx >= l { 13796 return io.ErrUnexpectedEOF 13797 } 13798 b := dAtA[iNdEx] 13799 iNdEx++ 13800 msglen |= int(b&0x7F) << shift 13801 if b < 0x80 { 13802 break 13803 } 13804 } 13805 if msglen < 0 { 13806 return ErrInvalidLengthTypes 13807 } 13808 postIndex := iNdEx + msglen 13809 if postIndex < 0 { 13810 return ErrInvalidLengthTypes 13811 } 13812 if postIndex > l { 13813 return io.ErrUnexpectedEOF 13814 } 13815 m.Events = append(m.Events, Event{}) 13816 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13817 return err 13818 } 13819 iNdEx = postIndex 13820 case 8: 13821 if wireType != 2 { 13822 return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) 13823 } 13824 var stringLen uint64 13825 for shift := uint(0); ; shift += 7 { 13826 if shift >= 64 { 13827 return ErrIntOverflowTypes 13828 } 13829 if iNdEx >= l { 13830 return io.ErrUnexpectedEOF 13831 } 13832 b := dAtA[iNdEx] 13833 iNdEx++ 13834 stringLen |= uint64(b&0x7F) << shift 13835 if b < 0x80 { 13836 break 13837 } 13838 } 13839 intStringLen := int(stringLen) 13840 if intStringLen < 0 { 13841 return ErrInvalidLengthTypes 13842 } 13843 postIndex := iNdEx + intStringLen 13844 if postIndex < 0 { 13845 return ErrInvalidLengthTypes 13846 } 13847 if postIndex > l { 13848 return io.ErrUnexpectedEOF 13849 } 13850 m.Codespace = string(dAtA[iNdEx:postIndex]) 13851 iNdEx = postIndex 13852 default: 13853 iNdEx = preIndex 13854 skippy, err := skipTypes(dAtA[iNdEx:]) 13855 if err != nil { 13856 return err 13857 } 13858 if skippy < 0 { 13859 return ErrInvalidLengthTypes 13860 } 13861 if (iNdEx + skippy) < 0 { 13862 return ErrInvalidLengthTypes 13863 } 13864 if (iNdEx + skippy) > l { 13865 return io.ErrUnexpectedEOF 13866 } 13867 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 13868 iNdEx += skippy 13869 } 13870 } 13871 13872 if iNdEx > l { 13873 return io.ErrUnexpectedEOF 13874 } 13875 return nil 13876 } 13877 func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { 13878 l := len(dAtA) 13879 iNdEx := 0 13880 for iNdEx < l { 13881 preIndex := iNdEx 13882 var wire uint64 13883 for shift := uint(0); ; shift += 7 { 13884 if shift >= 64 { 13885 return ErrIntOverflowTypes 13886 } 13887 if iNdEx >= l { 13888 return io.ErrUnexpectedEOF 13889 } 13890 b := dAtA[iNdEx] 13891 iNdEx++ 13892 wire |= uint64(b&0x7F) << shift 13893 if b < 0x80 { 13894 break 13895 } 13896 } 13897 fieldNum := int32(wire >> 3) 13898 wireType := int(wire & 0x7) 13899 if wireType == 4 { 13900 return fmt.Errorf("proto: ResponseEndBlock: wiretype end group for non-group") 13901 } 13902 if fieldNum <= 0 { 13903 return fmt.Errorf("proto: ResponseEndBlock: illegal tag %d (wire type %d)", fieldNum, wire) 13904 } 13905 switch fieldNum { 13906 case 1: 13907 if wireType != 2 { 13908 return fmt.Errorf("proto: wrong wireType = %d for field ValidatorUpdates", wireType) 13909 } 13910 var msglen int 13911 for shift := uint(0); ; shift += 7 { 13912 if shift >= 64 { 13913 return ErrIntOverflowTypes 13914 } 13915 if iNdEx >= l { 13916 return io.ErrUnexpectedEOF 13917 } 13918 b := dAtA[iNdEx] 13919 iNdEx++ 13920 msglen |= int(b&0x7F) << shift 13921 if b < 0x80 { 13922 break 13923 } 13924 } 13925 if msglen < 0 { 13926 return ErrInvalidLengthTypes 13927 } 13928 postIndex := iNdEx + msglen 13929 if postIndex < 0 { 13930 return ErrInvalidLengthTypes 13931 } 13932 if postIndex > l { 13933 return io.ErrUnexpectedEOF 13934 } 13935 m.ValidatorUpdates = append(m.ValidatorUpdates, ValidatorUpdate{}) 13936 if err := m.ValidatorUpdates[len(m.ValidatorUpdates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13937 return err 13938 } 13939 iNdEx = postIndex 13940 case 2: 13941 if wireType != 2 { 13942 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParamUpdates", wireType) 13943 } 13944 var msglen int 13945 for shift := uint(0); ; shift += 7 { 13946 if shift >= 64 { 13947 return ErrIntOverflowTypes 13948 } 13949 if iNdEx >= l { 13950 return io.ErrUnexpectedEOF 13951 } 13952 b := dAtA[iNdEx] 13953 iNdEx++ 13954 msglen |= int(b&0x7F) << shift 13955 if b < 0x80 { 13956 break 13957 } 13958 } 13959 if msglen < 0 { 13960 return ErrInvalidLengthTypes 13961 } 13962 postIndex := iNdEx + msglen 13963 if postIndex < 0 { 13964 return ErrInvalidLengthTypes 13965 } 13966 if postIndex > l { 13967 return io.ErrUnexpectedEOF 13968 } 13969 if m.ConsensusParamUpdates == nil { 13970 m.ConsensusParamUpdates = &ConsensusParams{} 13971 } 13972 if err := m.ConsensusParamUpdates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13973 return err 13974 } 13975 iNdEx = postIndex 13976 case 3: 13977 if wireType != 2 { 13978 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 13979 } 13980 var msglen int 13981 for shift := uint(0); ; shift += 7 { 13982 if shift >= 64 { 13983 return ErrIntOverflowTypes 13984 } 13985 if iNdEx >= l { 13986 return io.ErrUnexpectedEOF 13987 } 13988 b := dAtA[iNdEx] 13989 iNdEx++ 13990 msglen |= int(b&0x7F) << shift 13991 if b < 0x80 { 13992 break 13993 } 13994 } 13995 if msglen < 0 { 13996 return ErrInvalidLengthTypes 13997 } 13998 postIndex := iNdEx + msglen 13999 if postIndex < 0 { 14000 return ErrInvalidLengthTypes 14001 } 14002 if postIndex > l { 14003 return io.ErrUnexpectedEOF 14004 } 14005 m.Events = append(m.Events, Event{}) 14006 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14007 return err 14008 } 14009 iNdEx = postIndex 14010 default: 14011 iNdEx = preIndex 14012 skippy, err := skipTypes(dAtA[iNdEx:]) 14013 if err != nil { 14014 return err 14015 } 14016 if skippy < 0 { 14017 return ErrInvalidLengthTypes 14018 } 14019 if (iNdEx + skippy) < 0 { 14020 return ErrInvalidLengthTypes 14021 } 14022 if (iNdEx + skippy) > l { 14023 return io.ErrUnexpectedEOF 14024 } 14025 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14026 iNdEx += skippy 14027 } 14028 } 14029 14030 if iNdEx > l { 14031 return io.ErrUnexpectedEOF 14032 } 14033 return nil 14034 } 14035 func (m *ResponseCommit) Unmarshal(dAtA []byte) error { 14036 l := len(dAtA) 14037 iNdEx := 0 14038 for iNdEx < l { 14039 preIndex := iNdEx 14040 var wire uint64 14041 for shift := uint(0); ; shift += 7 { 14042 if shift >= 64 { 14043 return ErrIntOverflowTypes 14044 } 14045 if iNdEx >= l { 14046 return io.ErrUnexpectedEOF 14047 } 14048 b := dAtA[iNdEx] 14049 iNdEx++ 14050 wire |= uint64(b&0x7F) << shift 14051 if b < 0x80 { 14052 break 14053 } 14054 } 14055 fieldNum := int32(wire >> 3) 14056 wireType := int(wire & 0x7) 14057 if wireType == 4 { 14058 return fmt.Errorf("proto: ResponseCommit: wiretype end group for non-group") 14059 } 14060 if fieldNum <= 0 { 14061 return fmt.Errorf("proto: ResponseCommit: illegal tag %d (wire type %d)", fieldNum, wire) 14062 } 14063 switch fieldNum { 14064 case 2: 14065 if wireType != 2 { 14066 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 14067 } 14068 var byteLen int 14069 for shift := uint(0); ; shift += 7 { 14070 if shift >= 64 { 14071 return ErrIntOverflowTypes 14072 } 14073 if iNdEx >= l { 14074 return io.ErrUnexpectedEOF 14075 } 14076 b := dAtA[iNdEx] 14077 iNdEx++ 14078 byteLen |= int(b&0x7F) << shift 14079 if b < 0x80 { 14080 break 14081 } 14082 } 14083 if byteLen < 0 { 14084 return ErrInvalidLengthTypes 14085 } 14086 postIndex := iNdEx + byteLen 14087 if postIndex < 0 { 14088 return ErrInvalidLengthTypes 14089 } 14090 if postIndex > l { 14091 return io.ErrUnexpectedEOF 14092 } 14093 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 14094 if m.Data == nil { 14095 m.Data = []byte{} 14096 } 14097 iNdEx = postIndex 14098 case 3: 14099 if wireType != 0 { 14100 return fmt.Errorf("proto: wrong wireType = %d for field RetainHeight", wireType) 14101 } 14102 m.RetainHeight = 0 14103 for shift := uint(0); ; shift += 7 { 14104 if shift >= 64 { 14105 return ErrIntOverflowTypes 14106 } 14107 if iNdEx >= l { 14108 return io.ErrUnexpectedEOF 14109 } 14110 b := dAtA[iNdEx] 14111 iNdEx++ 14112 m.RetainHeight |= int64(b&0x7F) << shift 14113 if b < 0x80 { 14114 break 14115 } 14116 } 14117 default: 14118 iNdEx = preIndex 14119 skippy, err := skipTypes(dAtA[iNdEx:]) 14120 if err != nil { 14121 return err 14122 } 14123 if skippy < 0 { 14124 return ErrInvalidLengthTypes 14125 } 14126 if (iNdEx + skippy) < 0 { 14127 return ErrInvalidLengthTypes 14128 } 14129 if (iNdEx + skippy) > l { 14130 return io.ErrUnexpectedEOF 14131 } 14132 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14133 iNdEx += skippy 14134 } 14135 } 14136 14137 if iNdEx > l { 14138 return io.ErrUnexpectedEOF 14139 } 14140 return nil 14141 } 14142 func (m *ConsensusParams) Unmarshal(dAtA []byte) error { 14143 l := len(dAtA) 14144 iNdEx := 0 14145 for iNdEx < l { 14146 preIndex := iNdEx 14147 var wire uint64 14148 for shift := uint(0); ; shift += 7 { 14149 if shift >= 64 { 14150 return ErrIntOverflowTypes 14151 } 14152 if iNdEx >= l { 14153 return io.ErrUnexpectedEOF 14154 } 14155 b := dAtA[iNdEx] 14156 iNdEx++ 14157 wire |= uint64(b&0x7F) << shift 14158 if b < 0x80 { 14159 break 14160 } 14161 } 14162 fieldNum := int32(wire >> 3) 14163 wireType := int(wire & 0x7) 14164 if wireType == 4 { 14165 return fmt.Errorf("proto: ConsensusParams: wiretype end group for non-group") 14166 } 14167 if fieldNum <= 0 { 14168 return fmt.Errorf("proto: ConsensusParams: illegal tag %d (wire type %d)", fieldNum, wire) 14169 } 14170 switch fieldNum { 14171 case 1: 14172 if wireType != 2 { 14173 return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) 14174 } 14175 var msglen int 14176 for shift := uint(0); ; shift += 7 { 14177 if shift >= 64 { 14178 return ErrIntOverflowTypes 14179 } 14180 if iNdEx >= l { 14181 return io.ErrUnexpectedEOF 14182 } 14183 b := dAtA[iNdEx] 14184 iNdEx++ 14185 msglen |= int(b&0x7F) << shift 14186 if b < 0x80 { 14187 break 14188 } 14189 } 14190 if msglen < 0 { 14191 return ErrInvalidLengthTypes 14192 } 14193 postIndex := iNdEx + msglen 14194 if postIndex < 0 { 14195 return ErrInvalidLengthTypes 14196 } 14197 if postIndex > l { 14198 return io.ErrUnexpectedEOF 14199 } 14200 if m.Block == nil { 14201 m.Block = &BlockParams{} 14202 } 14203 if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14204 return err 14205 } 14206 iNdEx = postIndex 14207 case 2: 14208 if wireType != 2 { 14209 return fmt.Errorf("proto: wrong wireType = %d for field Evidence", wireType) 14210 } 14211 var msglen int 14212 for shift := uint(0); ; shift += 7 { 14213 if shift >= 64 { 14214 return ErrIntOverflowTypes 14215 } 14216 if iNdEx >= l { 14217 return io.ErrUnexpectedEOF 14218 } 14219 b := dAtA[iNdEx] 14220 iNdEx++ 14221 msglen |= int(b&0x7F) << shift 14222 if b < 0x80 { 14223 break 14224 } 14225 } 14226 if msglen < 0 { 14227 return ErrInvalidLengthTypes 14228 } 14229 postIndex := iNdEx + msglen 14230 if postIndex < 0 { 14231 return ErrInvalidLengthTypes 14232 } 14233 if postIndex > l { 14234 return io.ErrUnexpectedEOF 14235 } 14236 if m.Evidence == nil { 14237 m.Evidence = &EvidenceParams{} 14238 } 14239 if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14240 return err 14241 } 14242 iNdEx = postIndex 14243 case 3: 14244 if wireType != 2 { 14245 return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) 14246 } 14247 var msglen int 14248 for shift := uint(0); ; shift += 7 { 14249 if shift >= 64 { 14250 return ErrIntOverflowTypes 14251 } 14252 if iNdEx >= l { 14253 return io.ErrUnexpectedEOF 14254 } 14255 b := dAtA[iNdEx] 14256 iNdEx++ 14257 msglen |= int(b&0x7F) << shift 14258 if b < 0x80 { 14259 break 14260 } 14261 } 14262 if msglen < 0 { 14263 return ErrInvalidLengthTypes 14264 } 14265 postIndex := iNdEx + msglen 14266 if postIndex < 0 { 14267 return ErrInvalidLengthTypes 14268 } 14269 if postIndex > l { 14270 return io.ErrUnexpectedEOF 14271 } 14272 if m.Validator == nil { 14273 m.Validator = &ValidatorParams{} 14274 } 14275 if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14276 return err 14277 } 14278 iNdEx = postIndex 14279 default: 14280 iNdEx = preIndex 14281 skippy, err := skipTypes(dAtA[iNdEx:]) 14282 if err != nil { 14283 return err 14284 } 14285 if skippy < 0 { 14286 return ErrInvalidLengthTypes 14287 } 14288 if (iNdEx + skippy) < 0 { 14289 return ErrInvalidLengthTypes 14290 } 14291 if (iNdEx + skippy) > l { 14292 return io.ErrUnexpectedEOF 14293 } 14294 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14295 iNdEx += skippy 14296 } 14297 } 14298 14299 if iNdEx > l { 14300 return io.ErrUnexpectedEOF 14301 } 14302 return nil 14303 } 14304 func (m *BlockParams) Unmarshal(dAtA []byte) error { 14305 l := len(dAtA) 14306 iNdEx := 0 14307 for iNdEx < l { 14308 preIndex := iNdEx 14309 var wire uint64 14310 for shift := uint(0); ; shift += 7 { 14311 if shift >= 64 { 14312 return ErrIntOverflowTypes 14313 } 14314 if iNdEx >= l { 14315 return io.ErrUnexpectedEOF 14316 } 14317 b := dAtA[iNdEx] 14318 iNdEx++ 14319 wire |= uint64(b&0x7F) << shift 14320 if b < 0x80 { 14321 break 14322 } 14323 } 14324 fieldNum := int32(wire >> 3) 14325 wireType := int(wire & 0x7) 14326 if wireType == 4 { 14327 return fmt.Errorf("proto: BlockParams: wiretype end group for non-group") 14328 } 14329 if fieldNum <= 0 { 14330 return fmt.Errorf("proto: BlockParams: illegal tag %d (wire type %d)", fieldNum, wire) 14331 } 14332 switch fieldNum { 14333 case 1: 14334 if wireType != 0 { 14335 return fmt.Errorf("proto: wrong wireType = %d for field MaxBytes", wireType) 14336 } 14337 m.MaxBytes = 0 14338 for shift := uint(0); ; shift += 7 { 14339 if shift >= 64 { 14340 return ErrIntOverflowTypes 14341 } 14342 if iNdEx >= l { 14343 return io.ErrUnexpectedEOF 14344 } 14345 b := dAtA[iNdEx] 14346 iNdEx++ 14347 m.MaxBytes |= int64(b&0x7F) << shift 14348 if b < 0x80 { 14349 break 14350 } 14351 } 14352 case 2: 14353 if wireType != 0 { 14354 return fmt.Errorf("proto: wrong wireType = %d for field MaxGas", wireType) 14355 } 14356 m.MaxGas = 0 14357 for shift := uint(0); ; shift += 7 { 14358 if shift >= 64 { 14359 return ErrIntOverflowTypes 14360 } 14361 if iNdEx >= l { 14362 return io.ErrUnexpectedEOF 14363 } 14364 b := dAtA[iNdEx] 14365 iNdEx++ 14366 m.MaxGas |= int64(b&0x7F) << shift 14367 if b < 0x80 { 14368 break 14369 } 14370 } 14371 default: 14372 iNdEx = preIndex 14373 skippy, err := skipTypes(dAtA[iNdEx:]) 14374 if err != nil { 14375 return err 14376 } 14377 if skippy < 0 { 14378 return ErrInvalidLengthTypes 14379 } 14380 if (iNdEx + skippy) < 0 { 14381 return ErrInvalidLengthTypes 14382 } 14383 if (iNdEx + skippy) > l { 14384 return io.ErrUnexpectedEOF 14385 } 14386 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14387 iNdEx += skippy 14388 } 14389 } 14390 14391 if iNdEx > l { 14392 return io.ErrUnexpectedEOF 14393 } 14394 return nil 14395 } 14396 func (m *EvidenceParams) Unmarshal(dAtA []byte) error { 14397 l := len(dAtA) 14398 iNdEx := 0 14399 for iNdEx < l { 14400 preIndex := iNdEx 14401 var wire uint64 14402 for shift := uint(0); ; shift += 7 { 14403 if shift >= 64 { 14404 return ErrIntOverflowTypes 14405 } 14406 if iNdEx >= l { 14407 return io.ErrUnexpectedEOF 14408 } 14409 b := dAtA[iNdEx] 14410 iNdEx++ 14411 wire |= uint64(b&0x7F) << shift 14412 if b < 0x80 { 14413 break 14414 } 14415 } 14416 fieldNum := int32(wire >> 3) 14417 wireType := int(wire & 0x7) 14418 if wireType == 4 { 14419 return fmt.Errorf("proto: EvidenceParams: wiretype end group for non-group") 14420 } 14421 if fieldNum <= 0 { 14422 return fmt.Errorf("proto: EvidenceParams: illegal tag %d (wire type %d)", fieldNum, wire) 14423 } 14424 switch fieldNum { 14425 case 1: 14426 if wireType != 0 { 14427 return fmt.Errorf("proto: wrong wireType = %d for field MaxAge", wireType) 14428 } 14429 m.MaxAge = 0 14430 for shift := uint(0); ; shift += 7 { 14431 if shift >= 64 { 14432 return ErrIntOverflowTypes 14433 } 14434 if iNdEx >= l { 14435 return io.ErrUnexpectedEOF 14436 } 14437 b := dAtA[iNdEx] 14438 iNdEx++ 14439 m.MaxAge |= int64(b&0x7F) << shift 14440 if b < 0x80 { 14441 break 14442 } 14443 } 14444 default: 14445 iNdEx = preIndex 14446 skippy, err := skipTypes(dAtA[iNdEx:]) 14447 if err != nil { 14448 return err 14449 } 14450 if skippy < 0 { 14451 return ErrInvalidLengthTypes 14452 } 14453 if (iNdEx + skippy) < 0 { 14454 return ErrInvalidLengthTypes 14455 } 14456 if (iNdEx + skippy) > l { 14457 return io.ErrUnexpectedEOF 14458 } 14459 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14460 iNdEx += skippy 14461 } 14462 } 14463 14464 if iNdEx > l { 14465 return io.ErrUnexpectedEOF 14466 } 14467 return nil 14468 } 14469 func (m *ValidatorParams) Unmarshal(dAtA []byte) error { 14470 l := len(dAtA) 14471 iNdEx := 0 14472 for iNdEx < l { 14473 preIndex := iNdEx 14474 var wire uint64 14475 for shift := uint(0); ; shift += 7 { 14476 if shift >= 64 { 14477 return ErrIntOverflowTypes 14478 } 14479 if iNdEx >= l { 14480 return io.ErrUnexpectedEOF 14481 } 14482 b := dAtA[iNdEx] 14483 iNdEx++ 14484 wire |= uint64(b&0x7F) << shift 14485 if b < 0x80 { 14486 break 14487 } 14488 } 14489 fieldNum := int32(wire >> 3) 14490 wireType := int(wire & 0x7) 14491 if wireType == 4 { 14492 return fmt.Errorf("proto: ValidatorParams: wiretype end group for non-group") 14493 } 14494 if fieldNum <= 0 { 14495 return fmt.Errorf("proto: ValidatorParams: illegal tag %d (wire type %d)", fieldNum, wire) 14496 } 14497 switch fieldNum { 14498 case 1: 14499 if wireType != 2 { 14500 return fmt.Errorf("proto: wrong wireType = %d for field PubKeyTypes", wireType) 14501 } 14502 var stringLen uint64 14503 for shift := uint(0); ; shift += 7 { 14504 if shift >= 64 { 14505 return ErrIntOverflowTypes 14506 } 14507 if iNdEx >= l { 14508 return io.ErrUnexpectedEOF 14509 } 14510 b := dAtA[iNdEx] 14511 iNdEx++ 14512 stringLen |= uint64(b&0x7F) << shift 14513 if b < 0x80 { 14514 break 14515 } 14516 } 14517 intStringLen := int(stringLen) 14518 if intStringLen < 0 { 14519 return ErrInvalidLengthTypes 14520 } 14521 postIndex := iNdEx + intStringLen 14522 if postIndex < 0 { 14523 return ErrInvalidLengthTypes 14524 } 14525 if postIndex > l { 14526 return io.ErrUnexpectedEOF 14527 } 14528 m.PubKeyTypes = append(m.PubKeyTypes, string(dAtA[iNdEx:postIndex])) 14529 iNdEx = postIndex 14530 default: 14531 iNdEx = preIndex 14532 skippy, err := skipTypes(dAtA[iNdEx:]) 14533 if err != nil { 14534 return err 14535 } 14536 if skippy < 0 { 14537 return ErrInvalidLengthTypes 14538 } 14539 if (iNdEx + skippy) < 0 { 14540 return ErrInvalidLengthTypes 14541 } 14542 if (iNdEx + skippy) > l { 14543 return io.ErrUnexpectedEOF 14544 } 14545 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14546 iNdEx += skippy 14547 } 14548 } 14549 14550 if iNdEx > l { 14551 return io.ErrUnexpectedEOF 14552 } 14553 return nil 14554 } 14555 func (m *LastCommitInfo) Unmarshal(dAtA []byte) error { 14556 l := len(dAtA) 14557 iNdEx := 0 14558 for iNdEx < l { 14559 preIndex := iNdEx 14560 var wire uint64 14561 for shift := uint(0); ; shift += 7 { 14562 if shift >= 64 { 14563 return ErrIntOverflowTypes 14564 } 14565 if iNdEx >= l { 14566 return io.ErrUnexpectedEOF 14567 } 14568 b := dAtA[iNdEx] 14569 iNdEx++ 14570 wire |= uint64(b&0x7F) << shift 14571 if b < 0x80 { 14572 break 14573 } 14574 } 14575 fieldNum := int32(wire >> 3) 14576 wireType := int(wire & 0x7) 14577 if wireType == 4 { 14578 return fmt.Errorf("proto: LastCommitInfo: wiretype end group for non-group") 14579 } 14580 if fieldNum <= 0 { 14581 return fmt.Errorf("proto: LastCommitInfo: illegal tag %d (wire type %d)", fieldNum, wire) 14582 } 14583 switch fieldNum { 14584 case 1: 14585 if wireType != 0 { 14586 return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) 14587 } 14588 m.Round = 0 14589 for shift := uint(0); ; shift += 7 { 14590 if shift >= 64 { 14591 return ErrIntOverflowTypes 14592 } 14593 if iNdEx >= l { 14594 return io.ErrUnexpectedEOF 14595 } 14596 b := dAtA[iNdEx] 14597 iNdEx++ 14598 m.Round |= int32(b&0x7F) << shift 14599 if b < 0x80 { 14600 break 14601 } 14602 } 14603 case 2: 14604 if wireType != 2 { 14605 return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType) 14606 } 14607 var msglen int 14608 for shift := uint(0); ; shift += 7 { 14609 if shift >= 64 { 14610 return ErrIntOverflowTypes 14611 } 14612 if iNdEx >= l { 14613 return io.ErrUnexpectedEOF 14614 } 14615 b := dAtA[iNdEx] 14616 iNdEx++ 14617 msglen |= int(b&0x7F) << shift 14618 if b < 0x80 { 14619 break 14620 } 14621 } 14622 if msglen < 0 { 14623 return ErrInvalidLengthTypes 14624 } 14625 postIndex := iNdEx + msglen 14626 if postIndex < 0 { 14627 return ErrInvalidLengthTypes 14628 } 14629 if postIndex > l { 14630 return io.ErrUnexpectedEOF 14631 } 14632 m.Votes = append(m.Votes, VoteInfo{}) 14633 if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14634 return err 14635 } 14636 iNdEx = postIndex 14637 default: 14638 iNdEx = preIndex 14639 skippy, err := skipTypes(dAtA[iNdEx:]) 14640 if err != nil { 14641 return err 14642 } 14643 if skippy < 0 { 14644 return ErrInvalidLengthTypes 14645 } 14646 if (iNdEx + skippy) < 0 { 14647 return ErrInvalidLengthTypes 14648 } 14649 if (iNdEx + skippy) > l { 14650 return io.ErrUnexpectedEOF 14651 } 14652 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14653 iNdEx += skippy 14654 } 14655 } 14656 14657 if iNdEx > l { 14658 return io.ErrUnexpectedEOF 14659 } 14660 return nil 14661 } 14662 func (m *Event) Unmarshal(dAtA []byte) error { 14663 l := len(dAtA) 14664 iNdEx := 0 14665 for iNdEx < l { 14666 preIndex := iNdEx 14667 var wire uint64 14668 for shift := uint(0); ; shift += 7 { 14669 if shift >= 64 { 14670 return ErrIntOverflowTypes 14671 } 14672 if iNdEx >= l { 14673 return io.ErrUnexpectedEOF 14674 } 14675 b := dAtA[iNdEx] 14676 iNdEx++ 14677 wire |= uint64(b&0x7F) << shift 14678 if b < 0x80 { 14679 break 14680 } 14681 } 14682 fieldNum := int32(wire >> 3) 14683 wireType := int(wire & 0x7) 14684 if wireType == 4 { 14685 return fmt.Errorf("proto: Event: wiretype end group for non-group") 14686 } 14687 if fieldNum <= 0 { 14688 return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire) 14689 } 14690 switch fieldNum { 14691 case 1: 14692 if wireType != 2 { 14693 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 14694 } 14695 var stringLen uint64 14696 for shift := uint(0); ; shift += 7 { 14697 if shift >= 64 { 14698 return ErrIntOverflowTypes 14699 } 14700 if iNdEx >= l { 14701 return io.ErrUnexpectedEOF 14702 } 14703 b := dAtA[iNdEx] 14704 iNdEx++ 14705 stringLen |= uint64(b&0x7F) << shift 14706 if b < 0x80 { 14707 break 14708 } 14709 } 14710 intStringLen := int(stringLen) 14711 if intStringLen < 0 { 14712 return ErrInvalidLengthTypes 14713 } 14714 postIndex := iNdEx + intStringLen 14715 if postIndex < 0 { 14716 return ErrInvalidLengthTypes 14717 } 14718 if postIndex > l { 14719 return io.ErrUnexpectedEOF 14720 } 14721 m.Type = string(dAtA[iNdEx:postIndex]) 14722 iNdEx = postIndex 14723 case 2: 14724 if wireType != 2 { 14725 return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) 14726 } 14727 var msglen int 14728 for shift := uint(0); ; shift += 7 { 14729 if shift >= 64 { 14730 return ErrIntOverflowTypes 14731 } 14732 if iNdEx >= l { 14733 return io.ErrUnexpectedEOF 14734 } 14735 b := dAtA[iNdEx] 14736 iNdEx++ 14737 msglen |= int(b&0x7F) << shift 14738 if b < 0x80 { 14739 break 14740 } 14741 } 14742 if msglen < 0 { 14743 return ErrInvalidLengthTypes 14744 } 14745 postIndex := iNdEx + msglen 14746 if postIndex < 0 { 14747 return ErrInvalidLengthTypes 14748 } 14749 if postIndex > l { 14750 return io.ErrUnexpectedEOF 14751 } 14752 m.Attributes = append(m.Attributes, kv.Pair{}) 14753 if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14754 return err 14755 } 14756 iNdEx = postIndex 14757 default: 14758 iNdEx = preIndex 14759 skippy, err := skipTypes(dAtA[iNdEx:]) 14760 if err != nil { 14761 return err 14762 } 14763 if skippy < 0 { 14764 return ErrInvalidLengthTypes 14765 } 14766 if (iNdEx + skippy) < 0 { 14767 return ErrInvalidLengthTypes 14768 } 14769 if (iNdEx + skippy) > l { 14770 return io.ErrUnexpectedEOF 14771 } 14772 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 14773 iNdEx += skippy 14774 } 14775 } 14776 14777 if iNdEx > l { 14778 return io.ErrUnexpectedEOF 14779 } 14780 return nil 14781 } 14782 func (m *Header) Unmarshal(dAtA []byte) error { 14783 l := len(dAtA) 14784 iNdEx := 0 14785 for iNdEx < l { 14786 preIndex := iNdEx 14787 var wire uint64 14788 for shift := uint(0); ; shift += 7 { 14789 if shift >= 64 { 14790 return ErrIntOverflowTypes 14791 } 14792 if iNdEx >= l { 14793 return io.ErrUnexpectedEOF 14794 } 14795 b := dAtA[iNdEx] 14796 iNdEx++ 14797 wire |= uint64(b&0x7F) << shift 14798 if b < 0x80 { 14799 break 14800 } 14801 } 14802 fieldNum := int32(wire >> 3) 14803 wireType := int(wire & 0x7) 14804 if wireType == 4 { 14805 return fmt.Errorf("proto: Header: wiretype end group for non-group") 14806 } 14807 if fieldNum <= 0 { 14808 return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire) 14809 } 14810 switch fieldNum { 14811 case 1: 14812 if wireType != 2 { 14813 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 14814 } 14815 var msglen int 14816 for shift := uint(0); ; shift += 7 { 14817 if shift >= 64 { 14818 return ErrIntOverflowTypes 14819 } 14820 if iNdEx >= l { 14821 return io.ErrUnexpectedEOF 14822 } 14823 b := dAtA[iNdEx] 14824 iNdEx++ 14825 msglen |= int(b&0x7F) << shift 14826 if b < 0x80 { 14827 break 14828 } 14829 } 14830 if msglen < 0 { 14831 return ErrInvalidLengthTypes 14832 } 14833 postIndex := iNdEx + msglen 14834 if postIndex < 0 { 14835 return ErrInvalidLengthTypes 14836 } 14837 if postIndex > l { 14838 return io.ErrUnexpectedEOF 14839 } 14840 if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14841 return err 14842 } 14843 iNdEx = postIndex 14844 case 2: 14845 if wireType != 2 { 14846 return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType) 14847 } 14848 var stringLen uint64 14849 for shift := uint(0); ; shift += 7 { 14850 if shift >= 64 { 14851 return ErrIntOverflowTypes 14852 } 14853 if iNdEx >= l { 14854 return io.ErrUnexpectedEOF 14855 } 14856 b := dAtA[iNdEx] 14857 iNdEx++ 14858 stringLen |= uint64(b&0x7F) << shift 14859 if b < 0x80 { 14860 break 14861 } 14862 } 14863 intStringLen := int(stringLen) 14864 if intStringLen < 0 { 14865 return ErrInvalidLengthTypes 14866 } 14867 postIndex := iNdEx + intStringLen 14868 if postIndex < 0 { 14869 return ErrInvalidLengthTypes 14870 } 14871 if postIndex > l { 14872 return io.ErrUnexpectedEOF 14873 } 14874 m.ChainID = string(dAtA[iNdEx:postIndex]) 14875 iNdEx = postIndex 14876 case 3: 14877 if wireType != 0 { 14878 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 14879 } 14880 m.Height = 0 14881 for shift := uint(0); ; shift += 7 { 14882 if shift >= 64 { 14883 return ErrIntOverflowTypes 14884 } 14885 if iNdEx >= l { 14886 return io.ErrUnexpectedEOF 14887 } 14888 b := dAtA[iNdEx] 14889 iNdEx++ 14890 m.Height |= int64(b&0x7F) << shift 14891 if b < 0x80 { 14892 break 14893 } 14894 } 14895 case 4: 14896 if wireType != 2 { 14897 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) 14898 } 14899 var msglen int 14900 for shift := uint(0); ; shift += 7 { 14901 if shift >= 64 { 14902 return ErrIntOverflowTypes 14903 } 14904 if iNdEx >= l { 14905 return io.ErrUnexpectedEOF 14906 } 14907 b := dAtA[iNdEx] 14908 iNdEx++ 14909 msglen |= int(b&0x7F) << shift 14910 if b < 0x80 { 14911 break 14912 } 14913 } 14914 if msglen < 0 { 14915 return ErrInvalidLengthTypes 14916 } 14917 postIndex := iNdEx + msglen 14918 if postIndex < 0 { 14919 return ErrInvalidLengthTypes 14920 } 14921 if postIndex > l { 14922 return io.ErrUnexpectedEOF 14923 } 14924 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { 14925 return err 14926 } 14927 iNdEx = postIndex 14928 case 5: 14929 if wireType != 0 { 14930 return fmt.Errorf("proto: wrong wireType = %d for field NumTxs", wireType) 14931 } 14932 m.NumTxs = 0 14933 for shift := uint(0); ; shift += 7 { 14934 if shift >= 64 { 14935 return ErrIntOverflowTypes 14936 } 14937 if iNdEx >= l { 14938 return io.ErrUnexpectedEOF 14939 } 14940 b := dAtA[iNdEx] 14941 iNdEx++ 14942 m.NumTxs |= int64(b&0x7F) << shift 14943 if b < 0x80 { 14944 break 14945 } 14946 } 14947 case 6: 14948 if wireType != 0 { 14949 return fmt.Errorf("proto: wrong wireType = %d for field TotalTxs", wireType) 14950 } 14951 m.TotalTxs = 0 14952 for shift := uint(0); ; shift += 7 { 14953 if shift >= 64 { 14954 return ErrIntOverflowTypes 14955 } 14956 if iNdEx >= l { 14957 return io.ErrUnexpectedEOF 14958 } 14959 b := dAtA[iNdEx] 14960 iNdEx++ 14961 m.TotalTxs |= int64(b&0x7F) << shift 14962 if b < 0x80 { 14963 break 14964 } 14965 } 14966 case 7: 14967 if wireType != 2 { 14968 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockId", wireType) 14969 } 14970 var msglen int 14971 for shift := uint(0); ; shift += 7 { 14972 if shift >= 64 { 14973 return ErrIntOverflowTypes 14974 } 14975 if iNdEx >= l { 14976 return io.ErrUnexpectedEOF 14977 } 14978 b := dAtA[iNdEx] 14979 iNdEx++ 14980 msglen |= int(b&0x7F) << shift 14981 if b < 0x80 { 14982 break 14983 } 14984 } 14985 if msglen < 0 { 14986 return ErrInvalidLengthTypes 14987 } 14988 postIndex := iNdEx + msglen 14989 if postIndex < 0 { 14990 return ErrInvalidLengthTypes 14991 } 14992 if postIndex > l { 14993 return io.ErrUnexpectedEOF 14994 } 14995 if err := m.LastBlockId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14996 return err 14997 } 14998 iNdEx = postIndex 14999 case 8: 15000 if wireType != 2 { 15001 return fmt.Errorf("proto: wrong wireType = %d for field LastCommitHash", wireType) 15002 } 15003 var byteLen int 15004 for shift := uint(0); ; shift += 7 { 15005 if shift >= 64 { 15006 return ErrIntOverflowTypes 15007 } 15008 if iNdEx >= l { 15009 return io.ErrUnexpectedEOF 15010 } 15011 b := dAtA[iNdEx] 15012 iNdEx++ 15013 byteLen |= int(b&0x7F) << shift 15014 if b < 0x80 { 15015 break 15016 } 15017 } 15018 if byteLen < 0 { 15019 return ErrInvalidLengthTypes 15020 } 15021 postIndex := iNdEx + byteLen 15022 if postIndex < 0 { 15023 return ErrInvalidLengthTypes 15024 } 15025 if postIndex > l { 15026 return io.ErrUnexpectedEOF 15027 } 15028 m.LastCommitHash = append(m.LastCommitHash[:0], dAtA[iNdEx:postIndex]...) 15029 if m.LastCommitHash == nil { 15030 m.LastCommitHash = []byte{} 15031 } 15032 iNdEx = postIndex 15033 case 9: 15034 if wireType != 2 { 15035 return fmt.Errorf("proto: wrong wireType = %d for field DataHash", wireType) 15036 } 15037 var byteLen int 15038 for shift := uint(0); ; shift += 7 { 15039 if shift >= 64 { 15040 return ErrIntOverflowTypes 15041 } 15042 if iNdEx >= l { 15043 return io.ErrUnexpectedEOF 15044 } 15045 b := dAtA[iNdEx] 15046 iNdEx++ 15047 byteLen |= int(b&0x7F) << shift 15048 if b < 0x80 { 15049 break 15050 } 15051 } 15052 if byteLen < 0 { 15053 return ErrInvalidLengthTypes 15054 } 15055 postIndex := iNdEx + byteLen 15056 if postIndex < 0 { 15057 return ErrInvalidLengthTypes 15058 } 15059 if postIndex > l { 15060 return io.ErrUnexpectedEOF 15061 } 15062 m.DataHash = append(m.DataHash[:0], dAtA[iNdEx:postIndex]...) 15063 if m.DataHash == nil { 15064 m.DataHash = []byte{} 15065 } 15066 iNdEx = postIndex 15067 case 10: 15068 if wireType != 2 { 15069 return fmt.Errorf("proto: wrong wireType = %d for field ValidatorsHash", wireType) 15070 } 15071 var byteLen int 15072 for shift := uint(0); ; shift += 7 { 15073 if shift >= 64 { 15074 return ErrIntOverflowTypes 15075 } 15076 if iNdEx >= l { 15077 return io.ErrUnexpectedEOF 15078 } 15079 b := dAtA[iNdEx] 15080 iNdEx++ 15081 byteLen |= int(b&0x7F) << shift 15082 if b < 0x80 { 15083 break 15084 } 15085 } 15086 if byteLen < 0 { 15087 return ErrInvalidLengthTypes 15088 } 15089 postIndex := iNdEx + byteLen 15090 if postIndex < 0 { 15091 return ErrInvalidLengthTypes 15092 } 15093 if postIndex > l { 15094 return io.ErrUnexpectedEOF 15095 } 15096 m.ValidatorsHash = append(m.ValidatorsHash[:0], dAtA[iNdEx:postIndex]...) 15097 if m.ValidatorsHash == nil { 15098 m.ValidatorsHash = []byte{} 15099 } 15100 iNdEx = postIndex 15101 case 11: 15102 if wireType != 2 { 15103 return fmt.Errorf("proto: wrong wireType = %d for field NextValidatorsHash", wireType) 15104 } 15105 var byteLen int 15106 for shift := uint(0); ; shift += 7 { 15107 if shift >= 64 { 15108 return ErrIntOverflowTypes 15109 } 15110 if iNdEx >= l { 15111 return io.ErrUnexpectedEOF 15112 } 15113 b := dAtA[iNdEx] 15114 iNdEx++ 15115 byteLen |= int(b&0x7F) << shift 15116 if b < 0x80 { 15117 break 15118 } 15119 } 15120 if byteLen < 0 { 15121 return ErrInvalidLengthTypes 15122 } 15123 postIndex := iNdEx + byteLen 15124 if postIndex < 0 { 15125 return ErrInvalidLengthTypes 15126 } 15127 if postIndex > l { 15128 return io.ErrUnexpectedEOF 15129 } 15130 m.NextValidatorsHash = append(m.NextValidatorsHash[:0], dAtA[iNdEx:postIndex]...) 15131 if m.NextValidatorsHash == nil { 15132 m.NextValidatorsHash = []byte{} 15133 } 15134 iNdEx = postIndex 15135 case 12: 15136 if wireType != 2 { 15137 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusHash", wireType) 15138 } 15139 var byteLen int 15140 for shift := uint(0); ; shift += 7 { 15141 if shift >= 64 { 15142 return ErrIntOverflowTypes 15143 } 15144 if iNdEx >= l { 15145 return io.ErrUnexpectedEOF 15146 } 15147 b := dAtA[iNdEx] 15148 iNdEx++ 15149 byteLen |= int(b&0x7F) << shift 15150 if b < 0x80 { 15151 break 15152 } 15153 } 15154 if byteLen < 0 { 15155 return ErrInvalidLengthTypes 15156 } 15157 postIndex := iNdEx + byteLen 15158 if postIndex < 0 { 15159 return ErrInvalidLengthTypes 15160 } 15161 if postIndex > l { 15162 return io.ErrUnexpectedEOF 15163 } 15164 m.ConsensusHash = append(m.ConsensusHash[:0], dAtA[iNdEx:postIndex]...) 15165 if m.ConsensusHash == nil { 15166 m.ConsensusHash = []byte{} 15167 } 15168 iNdEx = postIndex 15169 case 13: 15170 if wireType != 2 { 15171 return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType) 15172 } 15173 var byteLen int 15174 for shift := uint(0); ; shift += 7 { 15175 if shift >= 64 { 15176 return ErrIntOverflowTypes 15177 } 15178 if iNdEx >= l { 15179 return io.ErrUnexpectedEOF 15180 } 15181 b := dAtA[iNdEx] 15182 iNdEx++ 15183 byteLen |= int(b&0x7F) << shift 15184 if b < 0x80 { 15185 break 15186 } 15187 } 15188 if byteLen < 0 { 15189 return ErrInvalidLengthTypes 15190 } 15191 postIndex := iNdEx + byteLen 15192 if postIndex < 0 { 15193 return ErrInvalidLengthTypes 15194 } 15195 if postIndex > l { 15196 return io.ErrUnexpectedEOF 15197 } 15198 m.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) 15199 if m.AppHash == nil { 15200 m.AppHash = []byte{} 15201 } 15202 iNdEx = postIndex 15203 case 14: 15204 if wireType != 2 { 15205 return fmt.Errorf("proto: wrong wireType = %d for field LastResultsHash", wireType) 15206 } 15207 var byteLen int 15208 for shift := uint(0); ; shift += 7 { 15209 if shift >= 64 { 15210 return ErrIntOverflowTypes 15211 } 15212 if iNdEx >= l { 15213 return io.ErrUnexpectedEOF 15214 } 15215 b := dAtA[iNdEx] 15216 iNdEx++ 15217 byteLen |= int(b&0x7F) << shift 15218 if b < 0x80 { 15219 break 15220 } 15221 } 15222 if byteLen < 0 { 15223 return ErrInvalidLengthTypes 15224 } 15225 postIndex := iNdEx + byteLen 15226 if postIndex < 0 { 15227 return ErrInvalidLengthTypes 15228 } 15229 if postIndex > l { 15230 return io.ErrUnexpectedEOF 15231 } 15232 m.LastResultsHash = append(m.LastResultsHash[:0], dAtA[iNdEx:postIndex]...) 15233 if m.LastResultsHash == nil { 15234 m.LastResultsHash = []byte{} 15235 } 15236 iNdEx = postIndex 15237 case 15: 15238 if wireType != 2 { 15239 return fmt.Errorf("proto: wrong wireType = %d for field EvidenceHash", wireType) 15240 } 15241 var byteLen int 15242 for shift := uint(0); ; shift += 7 { 15243 if shift >= 64 { 15244 return ErrIntOverflowTypes 15245 } 15246 if iNdEx >= l { 15247 return io.ErrUnexpectedEOF 15248 } 15249 b := dAtA[iNdEx] 15250 iNdEx++ 15251 byteLen |= int(b&0x7F) << shift 15252 if b < 0x80 { 15253 break 15254 } 15255 } 15256 if byteLen < 0 { 15257 return ErrInvalidLengthTypes 15258 } 15259 postIndex := iNdEx + byteLen 15260 if postIndex < 0 { 15261 return ErrInvalidLengthTypes 15262 } 15263 if postIndex > l { 15264 return io.ErrUnexpectedEOF 15265 } 15266 m.EvidenceHash = append(m.EvidenceHash[:0], dAtA[iNdEx:postIndex]...) 15267 if m.EvidenceHash == nil { 15268 m.EvidenceHash = []byte{} 15269 } 15270 iNdEx = postIndex 15271 case 16: 15272 if wireType != 2 { 15273 return fmt.Errorf("proto: wrong wireType = %d for field ProposerAddress", wireType) 15274 } 15275 var byteLen int 15276 for shift := uint(0); ; shift += 7 { 15277 if shift >= 64 { 15278 return ErrIntOverflowTypes 15279 } 15280 if iNdEx >= l { 15281 return io.ErrUnexpectedEOF 15282 } 15283 b := dAtA[iNdEx] 15284 iNdEx++ 15285 byteLen |= int(b&0x7F) << shift 15286 if b < 0x80 { 15287 break 15288 } 15289 } 15290 if byteLen < 0 { 15291 return ErrInvalidLengthTypes 15292 } 15293 postIndex := iNdEx + byteLen 15294 if postIndex < 0 { 15295 return ErrInvalidLengthTypes 15296 } 15297 if postIndex > l { 15298 return io.ErrUnexpectedEOF 15299 } 15300 m.ProposerAddress = append(m.ProposerAddress[:0], dAtA[iNdEx:postIndex]...) 15301 if m.ProposerAddress == nil { 15302 m.ProposerAddress = []byte{} 15303 } 15304 iNdEx = postIndex 15305 default: 15306 iNdEx = preIndex 15307 skippy, err := skipTypes(dAtA[iNdEx:]) 15308 if err != nil { 15309 return err 15310 } 15311 if skippy < 0 { 15312 return ErrInvalidLengthTypes 15313 } 15314 if (iNdEx + skippy) < 0 { 15315 return ErrInvalidLengthTypes 15316 } 15317 if (iNdEx + skippy) > l { 15318 return io.ErrUnexpectedEOF 15319 } 15320 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15321 iNdEx += skippy 15322 } 15323 } 15324 15325 if iNdEx > l { 15326 return io.ErrUnexpectedEOF 15327 } 15328 return nil 15329 } 15330 func (m *Version) Unmarshal(dAtA []byte) error { 15331 l := len(dAtA) 15332 iNdEx := 0 15333 for iNdEx < l { 15334 preIndex := iNdEx 15335 var wire uint64 15336 for shift := uint(0); ; shift += 7 { 15337 if shift >= 64 { 15338 return ErrIntOverflowTypes 15339 } 15340 if iNdEx >= l { 15341 return io.ErrUnexpectedEOF 15342 } 15343 b := dAtA[iNdEx] 15344 iNdEx++ 15345 wire |= uint64(b&0x7F) << shift 15346 if b < 0x80 { 15347 break 15348 } 15349 } 15350 fieldNum := int32(wire >> 3) 15351 wireType := int(wire & 0x7) 15352 if wireType == 4 { 15353 return fmt.Errorf("proto: Version: wiretype end group for non-group") 15354 } 15355 if fieldNum <= 0 { 15356 return fmt.Errorf("proto: Version: illegal tag %d (wire type %d)", fieldNum, wire) 15357 } 15358 switch fieldNum { 15359 case 1: 15360 if wireType != 0 { 15361 return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) 15362 } 15363 m.Block = 0 15364 for shift := uint(0); ; shift += 7 { 15365 if shift >= 64 { 15366 return ErrIntOverflowTypes 15367 } 15368 if iNdEx >= l { 15369 return io.ErrUnexpectedEOF 15370 } 15371 b := dAtA[iNdEx] 15372 iNdEx++ 15373 m.Block |= uint64(b&0x7F) << shift 15374 if b < 0x80 { 15375 break 15376 } 15377 } 15378 case 2: 15379 if wireType != 0 { 15380 return fmt.Errorf("proto: wrong wireType = %d for field App", wireType) 15381 } 15382 m.App = 0 15383 for shift := uint(0); ; shift += 7 { 15384 if shift >= 64 { 15385 return ErrIntOverflowTypes 15386 } 15387 if iNdEx >= l { 15388 return io.ErrUnexpectedEOF 15389 } 15390 b := dAtA[iNdEx] 15391 iNdEx++ 15392 m.App |= uint64(b&0x7F) << shift 15393 if b < 0x80 { 15394 break 15395 } 15396 } 15397 default: 15398 iNdEx = preIndex 15399 skippy, err := skipTypes(dAtA[iNdEx:]) 15400 if err != nil { 15401 return err 15402 } 15403 if skippy < 0 { 15404 return ErrInvalidLengthTypes 15405 } 15406 if (iNdEx + skippy) < 0 { 15407 return ErrInvalidLengthTypes 15408 } 15409 if (iNdEx + skippy) > l { 15410 return io.ErrUnexpectedEOF 15411 } 15412 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15413 iNdEx += skippy 15414 } 15415 } 15416 15417 if iNdEx > l { 15418 return io.ErrUnexpectedEOF 15419 } 15420 return nil 15421 } 15422 func (m *BlockID) Unmarshal(dAtA []byte) error { 15423 l := len(dAtA) 15424 iNdEx := 0 15425 for iNdEx < l { 15426 preIndex := iNdEx 15427 var wire uint64 15428 for shift := uint(0); ; shift += 7 { 15429 if shift >= 64 { 15430 return ErrIntOverflowTypes 15431 } 15432 if iNdEx >= l { 15433 return io.ErrUnexpectedEOF 15434 } 15435 b := dAtA[iNdEx] 15436 iNdEx++ 15437 wire |= uint64(b&0x7F) << shift 15438 if b < 0x80 { 15439 break 15440 } 15441 } 15442 fieldNum := int32(wire >> 3) 15443 wireType := int(wire & 0x7) 15444 if wireType == 4 { 15445 return fmt.Errorf("proto: BlockID: wiretype end group for non-group") 15446 } 15447 if fieldNum <= 0 { 15448 return fmt.Errorf("proto: BlockID: illegal tag %d (wire type %d)", fieldNum, wire) 15449 } 15450 switch fieldNum { 15451 case 1: 15452 if wireType != 2 { 15453 return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) 15454 } 15455 var byteLen int 15456 for shift := uint(0); ; shift += 7 { 15457 if shift >= 64 { 15458 return ErrIntOverflowTypes 15459 } 15460 if iNdEx >= l { 15461 return io.ErrUnexpectedEOF 15462 } 15463 b := dAtA[iNdEx] 15464 iNdEx++ 15465 byteLen |= int(b&0x7F) << shift 15466 if b < 0x80 { 15467 break 15468 } 15469 } 15470 if byteLen < 0 { 15471 return ErrInvalidLengthTypes 15472 } 15473 postIndex := iNdEx + byteLen 15474 if postIndex < 0 { 15475 return ErrInvalidLengthTypes 15476 } 15477 if postIndex > l { 15478 return io.ErrUnexpectedEOF 15479 } 15480 m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) 15481 if m.Hash == nil { 15482 m.Hash = []byte{} 15483 } 15484 iNdEx = postIndex 15485 case 2: 15486 if wireType != 2 { 15487 return fmt.Errorf("proto: wrong wireType = %d for field PartsHeader", wireType) 15488 } 15489 var msglen int 15490 for shift := uint(0); ; shift += 7 { 15491 if shift >= 64 { 15492 return ErrIntOverflowTypes 15493 } 15494 if iNdEx >= l { 15495 return io.ErrUnexpectedEOF 15496 } 15497 b := dAtA[iNdEx] 15498 iNdEx++ 15499 msglen |= int(b&0x7F) << shift 15500 if b < 0x80 { 15501 break 15502 } 15503 } 15504 if msglen < 0 { 15505 return ErrInvalidLengthTypes 15506 } 15507 postIndex := iNdEx + msglen 15508 if postIndex < 0 { 15509 return ErrInvalidLengthTypes 15510 } 15511 if postIndex > l { 15512 return io.ErrUnexpectedEOF 15513 } 15514 if err := m.PartsHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 15515 return err 15516 } 15517 iNdEx = postIndex 15518 default: 15519 iNdEx = preIndex 15520 skippy, err := skipTypes(dAtA[iNdEx:]) 15521 if err != nil { 15522 return err 15523 } 15524 if skippy < 0 { 15525 return ErrInvalidLengthTypes 15526 } 15527 if (iNdEx + skippy) < 0 { 15528 return ErrInvalidLengthTypes 15529 } 15530 if (iNdEx + skippy) > l { 15531 return io.ErrUnexpectedEOF 15532 } 15533 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15534 iNdEx += skippy 15535 } 15536 } 15537 15538 if iNdEx > l { 15539 return io.ErrUnexpectedEOF 15540 } 15541 return nil 15542 } 15543 func (m *PartSetHeader) Unmarshal(dAtA []byte) error { 15544 l := len(dAtA) 15545 iNdEx := 0 15546 for iNdEx < l { 15547 preIndex := iNdEx 15548 var wire uint64 15549 for shift := uint(0); ; shift += 7 { 15550 if shift >= 64 { 15551 return ErrIntOverflowTypes 15552 } 15553 if iNdEx >= l { 15554 return io.ErrUnexpectedEOF 15555 } 15556 b := dAtA[iNdEx] 15557 iNdEx++ 15558 wire |= uint64(b&0x7F) << shift 15559 if b < 0x80 { 15560 break 15561 } 15562 } 15563 fieldNum := int32(wire >> 3) 15564 wireType := int(wire & 0x7) 15565 if wireType == 4 { 15566 return fmt.Errorf("proto: PartSetHeader: wiretype end group for non-group") 15567 } 15568 if fieldNum <= 0 { 15569 return fmt.Errorf("proto: PartSetHeader: illegal tag %d (wire type %d)", fieldNum, wire) 15570 } 15571 switch fieldNum { 15572 case 1: 15573 if wireType != 0 { 15574 return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType) 15575 } 15576 m.Total = 0 15577 for shift := uint(0); ; shift += 7 { 15578 if shift >= 64 { 15579 return ErrIntOverflowTypes 15580 } 15581 if iNdEx >= l { 15582 return io.ErrUnexpectedEOF 15583 } 15584 b := dAtA[iNdEx] 15585 iNdEx++ 15586 m.Total |= int32(b&0x7F) << shift 15587 if b < 0x80 { 15588 break 15589 } 15590 } 15591 case 2: 15592 if wireType != 2 { 15593 return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) 15594 } 15595 var byteLen int 15596 for shift := uint(0); ; shift += 7 { 15597 if shift >= 64 { 15598 return ErrIntOverflowTypes 15599 } 15600 if iNdEx >= l { 15601 return io.ErrUnexpectedEOF 15602 } 15603 b := dAtA[iNdEx] 15604 iNdEx++ 15605 byteLen |= int(b&0x7F) << shift 15606 if b < 0x80 { 15607 break 15608 } 15609 } 15610 if byteLen < 0 { 15611 return ErrInvalidLengthTypes 15612 } 15613 postIndex := iNdEx + byteLen 15614 if postIndex < 0 { 15615 return ErrInvalidLengthTypes 15616 } 15617 if postIndex > l { 15618 return io.ErrUnexpectedEOF 15619 } 15620 m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) 15621 if m.Hash == nil { 15622 m.Hash = []byte{} 15623 } 15624 iNdEx = postIndex 15625 default: 15626 iNdEx = preIndex 15627 skippy, err := skipTypes(dAtA[iNdEx:]) 15628 if err != nil { 15629 return err 15630 } 15631 if skippy < 0 { 15632 return ErrInvalidLengthTypes 15633 } 15634 if (iNdEx + skippy) < 0 { 15635 return ErrInvalidLengthTypes 15636 } 15637 if (iNdEx + skippy) > l { 15638 return io.ErrUnexpectedEOF 15639 } 15640 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15641 iNdEx += skippy 15642 } 15643 } 15644 15645 if iNdEx > l { 15646 return io.ErrUnexpectedEOF 15647 } 15648 return nil 15649 } 15650 func (m *Validator) Unmarshal(dAtA []byte) error { 15651 l := len(dAtA) 15652 iNdEx := 0 15653 for iNdEx < l { 15654 preIndex := iNdEx 15655 var wire uint64 15656 for shift := uint(0); ; shift += 7 { 15657 if shift >= 64 { 15658 return ErrIntOverflowTypes 15659 } 15660 if iNdEx >= l { 15661 return io.ErrUnexpectedEOF 15662 } 15663 b := dAtA[iNdEx] 15664 iNdEx++ 15665 wire |= uint64(b&0x7F) << shift 15666 if b < 0x80 { 15667 break 15668 } 15669 } 15670 fieldNum := int32(wire >> 3) 15671 wireType := int(wire & 0x7) 15672 if wireType == 4 { 15673 return fmt.Errorf("proto: Validator: wiretype end group for non-group") 15674 } 15675 if fieldNum <= 0 { 15676 return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire) 15677 } 15678 switch fieldNum { 15679 case 1: 15680 if wireType != 2 { 15681 return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) 15682 } 15683 var byteLen int 15684 for shift := uint(0); ; shift += 7 { 15685 if shift >= 64 { 15686 return ErrIntOverflowTypes 15687 } 15688 if iNdEx >= l { 15689 return io.ErrUnexpectedEOF 15690 } 15691 b := dAtA[iNdEx] 15692 iNdEx++ 15693 byteLen |= int(b&0x7F) << shift 15694 if b < 0x80 { 15695 break 15696 } 15697 } 15698 if byteLen < 0 { 15699 return ErrInvalidLengthTypes 15700 } 15701 postIndex := iNdEx + byteLen 15702 if postIndex < 0 { 15703 return ErrInvalidLengthTypes 15704 } 15705 if postIndex > l { 15706 return io.ErrUnexpectedEOF 15707 } 15708 m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...) 15709 if m.Address == nil { 15710 m.Address = []byte{} 15711 } 15712 iNdEx = postIndex 15713 case 3: 15714 if wireType != 0 { 15715 return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) 15716 } 15717 m.Power = 0 15718 for shift := uint(0); ; shift += 7 { 15719 if shift >= 64 { 15720 return ErrIntOverflowTypes 15721 } 15722 if iNdEx >= l { 15723 return io.ErrUnexpectedEOF 15724 } 15725 b := dAtA[iNdEx] 15726 iNdEx++ 15727 m.Power |= int64(b&0x7F) << shift 15728 if b < 0x80 { 15729 break 15730 } 15731 } 15732 default: 15733 iNdEx = preIndex 15734 skippy, err := skipTypes(dAtA[iNdEx:]) 15735 if err != nil { 15736 return err 15737 } 15738 if skippy < 0 { 15739 return ErrInvalidLengthTypes 15740 } 15741 if (iNdEx + skippy) < 0 { 15742 return ErrInvalidLengthTypes 15743 } 15744 if (iNdEx + skippy) > l { 15745 return io.ErrUnexpectedEOF 15746 } 15747 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15748 iNdEx += skippy 15749 } 15750 } 15751 15752 if iNdEx > l { 15753 return io.ErrUnexpectedEOF 15754 } 15755 return nil 15756 } 15757 func (m *ValidatorUpdate) Unmarshal(dAtA []byte) error { 15758 l := len(dAtA) 15759 iNdEx := 0 15760 for iNdEx < l { 15761 preIndex := iNdEx 15762 var wire uint64 15763 for shift := uint(0); ; shift += 7 { 15764 if shift >= 64 { 15765 return ErrIntOverflowTypes 15766 } 15767 if iNdEx >= l { 15768 return io.ErrUnexpectedEOF 15769 } 15770 b := dAtA[iNdEx] 15771 iNdEx++ 15772 wire |= uint64(b&0x7F) << shift 15773 if b < 0x80 { 15774 break 15775 } 15776 } 15777 fieldNum := int32(wire >> 3) 15778 wireType := int(wire & 0x7) 15779 if wireType == 4 { 15780 return fmt.Errorf("proto: ValidatorUpdate: wiretype end group for non-group") 15781 } 15782 if fieldNum <= 0 { 15783 return fmt.Errorf("proto: ValidatorUpdate: illegal tag %d (wire type %d)", fieldNum, wire) 15784 } 15785 switch fieldNum { 15786 case 1: 15787 if wireType != 2 { 15788 return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) 15789 } 15790 var msglen int 15791 for shift := uint(0); ; shift += 7 { 15792 if shift >= 64 { 15793 return ErrIntOverflowTypes 15794 } 15795 if iNdEx >= l { 15796 return io.ErrUnexpectedEOF 15797 } 15798 b := dAtA[iNdEx] 15799 iNdEx++ 15800 msglen |= int(b&0x7F) << shift 15801 if b < 0x80 { 15802 break 15803 } 15804 } 15805 if msglen < 0 { 15806 return ErrInvalidLengthTypes 15807 } 15808 postIndex := iNdEx + msglen 15809 if postIndex < 0 { 15810 return ErrInvalidLengthTypes 15811 } 15812 if postIndex > l { 15813 return io.ErrUnexpectedEOF 15814 } 15815 if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 15816 return err 15817 } 15818 iNdEx = postIndex 15819 case 2: 15820 if wireType != 0 { 15821 return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) 15822 } 15823 m.Power = 0 15824 for shift := uint(0); ; shift += 7 { 15825 if shift >= 64 { 15826 return ErrIntOverflowTypes 15827 } 15828 if iNdEx >= l { 15829 return io.ErrUnexpectedEOF 15830 } 15831 b := dAtA[iNdEx] 15832 iNdEx++ 15833 m.Power |= int64(b&0x7F) << shift 15834 if b < 0x80 { 15835 break 15836 } 15837 } 15838 default: 15839 iNdEx = preIndex 15840 skippy, err := skipTypes(dAtA[iNdEx:]) 15841 if err != nil { 15842 return err 15843 } 15844 if skippy < 0 { 15845 return ErrInvalidLengthTypes 15846 } 15847 if (iNdEx + skippy) < 0 { 15848 return ErrInvalidLengthTypes 15849 } 15850 if (iNdEx + skippy) > l { 15851 return io.ErrUnexpectedEOF 15852 } 15853 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15854 iNdEx += skippy 15855 } 15856 } 15857 15858 if iNdEx > l { 15859 return io.ErrUnexpectedEOF 15860 } 15861 return nil 15862 } 15863 func (m *VoteInfo) Unmarshal(dAtA []byte) error { 15864 l := len(dAtA) 15865 iNdEx := 0 15866 for iNdEx < l { 15867 preIndex := iNdEx 15868 var wire uint64 15869 for shift := uint(0); ; shift += 7 { 15870 if shift >= 64 { 15871 return ErrIntOverflowTypes 15872 } 15873 if iNdEx >= l { 15874 return io.ErrUnexpectedEOF 15875 } 15876 b := dAtA[iNdEx] 15877 iNdEx++ 15878 wire |= uint64(b&0x7F) << shift 15879 if b < 0x80 { 15880 break 15881 } 15882 } 15883 fieldNum := int32(wire >> 3) 15884 wireType := int(wire & 0x7) 15885 if wireType == 4 { 15886 return fmt.Errorf("proto: VoteInfo: wiretype end group for non-group") 15887 } 15888 if fieldNum <= 0 { 15889 return fmt.Errorf("proto: VoteInfo: illegal tag %d (wire type %d)", fieldNum, wire) 15890 } 15891 switch fieldNum { 15892 case 1: 15893 if wireType != 2 { 15894 return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) 15895 } 15896 var msglen int 15897 for shift := uint(0); ; shift += 7 { 15898 if shift >= 64 { 15899 return ErrIntOverflowTypes 15900 } 15901 if iNdEx >= l { 15902 return io.ErrUnexpectedEOF 15903 } 15904 b := dAtA[iNdEx] 15905 iNdEx++ 15906 msglen |= int(b&0x7F) << shift 15907 if b < 0x80 { 15908 break 15909 } 15910 } 15911 if msglen < 0 { 15912 return ErrInvalidLengthTypes 15913 } 15914 postIndex := iNdEx + msglen 15915 if postIndex < 0 { 15916 return ErrInvalidLengthTypes 15917 } 15918 if postIndex > l { 15919 return io.ErrUnexpectedEOF 15920 } 15921 if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 15922 return err 15923 } 15924 iNdEx = postIndex 15925 case 2: 15926 if wireType != 0 { 15927 return fmt.Errorf("proto: wrong wireType = %d for field SignedLastBlock", wireType) 15928 } 15929 var v int 15930 for shift := uint(0); ; shift += 7 { 15931 if shift >= 64 { 15932 return ErrIntOverflowTypes 15933 } 15934 if iNdEx >= l { 15935 return io.ErrUnexpectedEOF 15936 } 15937 b := dAtA[iNdEx] 15938 iNdEx++ 15939 v |= int(b&0x7F) << shift 15940 if b < 0x80 { 15941 break 15942 } 15943 } 15944 m.SignedLastBlock = bool(v != 0) 15945 default: 15946 iNdEx = preIndex 15947 skippy, err := skipTypes(dAtA[iNdEx:]) 15948 if err != nil { 15949 return err 15950 } 15951 if skippy < 0 { 15952 return ErrInvalidLengthTypes 15953 } 15954 if (iNdEx + skippy) < 0 { 15955 return ErrInvalidLengthTypes 15956 } 15957 if (iNdEx + skippy) > l { 15958 return io.ErrUnexpectedEOF 15959 } 15960 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 15961 iNdEx += skippy 15962 } 15963 } 15964 15965 if iNdEx > l { 15966 return io.ErrUnexpectedEOF 15967 } 15968 return nil 15969 } 15970 func (m *PubKey) Unmarshal(dAtA []byte) error { 15971 l := len(dAtA) 15972 iNdEx := 0 15973 for iNdEx < l { 15974 preIndex := iNdEx 15975 var wire uint64 15976 for shift := uint(0); ; shift += 7 { 15977 if shift >= 64 { 15978 return ErrIntOverflowTypes 15979 } 15980 if iNdEx >= l { 15981 return io.ErrUnexpectedEOF 15982 } 15983 b := dAtA[iNdEx] 15984 iNdEx++ 15985 wire |= uint64(b&0x7F) << shift 15986 if b < 0x80 { 15987 break 15988 } 15989 } 15990 fieldNum := int32(wire >> 3) 15991 wireType := int(wire & 0x7) 15992 if wireType == 4 { 15993 return fmt.Errorf("proto: PubKey: wiretype end group for non-group") 15994 } 15995 if fieldNum <= 0 { 15996 return fmt.Errorf("proto: PubKey: illegal tag %d (wire type %d)", fieldNum, wire) 15997 } 15998 switch fieldNum { 15999 case 1: 16000 if wireType != 2 { 16001 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 16002 } 16003 var stringLen uint64 16004 for shift := uint(0); ; shift += 7 { 16005 if shift >= 64 { 16006 return ErrIntOverflowTypes 16007 } 16008 if iNdEx >= l { 16009 return io.ErrUnexpectedEOF 16010 } 16011 b := dAtA[iNdEx] 16012 iNdEx++ 16013 stringLen |= uint64(b&0x7F) << shift 16014 if b < 0x80 { 16015 break 16016 } 16017 } 16018 intStringLen := int(stringLen) 16019 if intStringLen < 0 { 16020 return ErrInvalidLengthTypes 16021 } 16022 postIndex := iNdEx + intStringLen 16023 if postIndex < 0 { 16024 return ErrInvalidLengthTypes 16025 } 16026 if postIndex > l { 16027 return io.ErrUnexpectedEOF 16028 } 16029 m.Type = string(dAtA[iNdEx:postIndex]) 16030 iNdEx = postIndex 16031 case 2: 16032 if wireType != 2 { 16033 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 16034 } 16035 var byteLen int 16036 for shift := uint(0); ; shift += 7 { 16037 if shift >= 64 { 16038 return ErrIntOverflowTypes 16039 } 16040 if iNdEx >= l { 16041 return io.ErrUnexpectedEOF 16042 } 16043 b := dAtA[iNdEx] 16044 iNdEx++ 16045 byteLen |= int(b&0x7F) << shift 16046 if b < 0x80 { 16047 break 16048 } 16049 } 16050 if byteLen < 0 { 16051 return ErrInvalidLengthTypes 16052 } 16053 postIndex := iNdEx + byteLen 16054 if postIndex < 0 { 16055 return ErrInvalidLengthTypes 16056 } 16057 if postIndex > l { 16058 return io.ErrUnexpectedEOF 16059 } 16060 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 16061 if m.Data == nil { 16062 m.Data = []byte{} 16063 } 16064 iNdEx = postIndex 16065 default: 16066 iNdEx = preIndex 16067 skippy, err := skipTypes(dAtA[iNdEx:]) 16068 if err != nil { 16069 return err 16070 } 16071 if skippy < 0 { 16072 return ErrInvalidLengthTypes 16073 } 16074 if (iNdEx + skippy) < 0 { 16075 return ErrInvalidLengthTypes 16076 } 16077 if (iNdEx + skippy) > l { 16078 return io.ErrUnexpectedEOF 16079 } 16080 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 16081 iNdEx += skippy 16082 } 16083 } 16084 16085 if iNdEx > l { 16086 return io.ErrUnexpectedEOF 16087 } 16088 return nil 16089 } 16090 func (m *Evidence) Unmarshal(dAtA []byte) error { 16091 l := len(dAtA) 16092 iNdEx := 0 16093 for iNdEx < l { 16094 preIndex := iNdEx 16095 var wire uint64 16096 for shift := uint(0); ; shift += 7 { 16097 if shift >= 64 { 16098 return ErrIntOverflowTypes 16099 } 16100 if iNdEx >= l { 16101 return io.ErrUnexpectedEOF 16102 } 16103 b := dAtA[iNdEx] 16104 iNdEx++ 16105 wire |= uint64(b&0x7F) << shift 16106 if b < 0x80 { 16107 break 16108 } 16109 } 16110 fieldNum := int32(wire >> 3) 16111 wireType := int(wire & 0x7) 16112 if wireType == 4 { 16113 return fmt.Errorf("proto: Evidence: wiretype end group for non-group") 16114 } 16115 if fieldNum <= 0 { 16116 return fmt.Errorf("proto: Evidence: illegal tag %d (wire type %d)", fieldNum, wire) 16117 } 16118 switch fieldNum { 16119 case 1: 16120 if wireType != 2 { 16121 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 16122 } 16123 var stringLen uint64 16124 for shift := uint(0); ; shift += 7 { 16125 if shift >= 64 { 16126 return ErrIntOverflowTypes 16127 } 16128 if iNdEx >= l { 16129 return io.ErrUnexpectedEOF 16130 } 16131 b := dAtA[iNdEx] 16132 iNdEx++ 16133 stringLen |= uint64(b&0x7F) << shift 16134 if b < 0x80 { 16135 break 16136 } 16137 } 16138 intStringLen := int(stringLen) 16139 if intStringLen < 0 { 16140 return ErrInvalidLengthTypes 16141 } 16142 postIndex := iNdEx + intStringLen 16143 if postIndex < 0 { 16144 return ErrInvalidLengthTypes 16145 } 16146 if postIndex > l { 16147 return io.ErrUnexpectedEOF 16148 } 16149 m.Type = string(dAtA[iNdEx:postIndex]) 16150 iNdEx = postIndex 16151 case 2: 16152 if wireType != 2 { 16153 return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) 16154 } 16155 var msglen int 16156 for shift := uint(0); ; shift += 7 { 16157 if shift >= 64 { 16158 return ErrIntOverflowTypes 16159 } 16160 if iNdEx >= l { 16161 return io.ErrUnexpectedEOF 16162 } 16163 b := dAtA[iNdEx] 16164 iNdEx++ 16165 msglen |= int(b&0x7F) << shift 16166 if b < 0x80 { 16167 break 16168 } 16169 } 16170 if msglen < 0 { 16171 return ErrInvalidLengthTypes 16172 } 16173 postIndex := iNdEx + msglen 16174 if postIndex < 0 { 16175 return ErrInvalidLengthTypes 16176 } 16177 if postIndex > l { 16178 return io.ErrUnexpectedEOF 16179 } 16180 if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 16181 return err 16182 } 16183 iNdEx = postIndex 16184 case 3: 16185 if wireType != 0 { 16186 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 16187 } 16188 m.Height = 0 16189 for shift := uint(0); ; shift += 7 { 16190 if shift >= 64 { 16191 return ErrIntOverflowTypes 16192 } 16193 if iNdEx >= l { 16194 return io.ErrUnexpectedEOF 16195 } 16196 b := dAtA[iNdEx] 16197 iNdEx++ 16198 m.Height |= int64(b&0x7F) << shift 16199 if b < 0x80 { 16200 break 16201 } 16202 } 16203 case 4: 16204 if wireType != 2 { 16205 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) 16206 } 16207 var msglen int 16208 for shift := uint(0); ; shift += 7 { 16209 if shift >= 64 { 16210 return ErrIntOverflowTypes 16211 } 16212 if iNdEx >= l { 16213 return io.ErrUnexpectedEOF 16214 } 16215 b := dAtA[iNdEx] 16216 iNdEx++ 16217 msglen |= int(b&0x7F) << shift 16218 if b < 0x80 { 16219 break 16220 } 16221 } 16222 if msglen < 0 { 16223 return ErrInvalidLengthTypes 16224 } 16225 postIndex := iNdEx + msglen 16226 if postIndex < 0 { 16227 return ErrInvalidLengthTypes 16228 } 16229 if postIndex > l { 16230 return io.ErrUnexpectedEOF 16231 } 16232 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { 16233 return err 16234 } 16235 iNdEx = postIndex 16236 case 5: 16237 if wireType != 0 { 16238 return fmt.Errorf("proto: wrong wireType = %d for field TotalVotingPower", wireType) 16239 } 16240 m.TotalVotingPower = 0 16241 for shift := uint(0); ; shift += 7 { 16242 if shift >= 64 { 16243 return ErrIntOverflowTypes 16244 } 16245 if iNdEx >= l { 16246 return io.ErrUnexpectedEOF 16247 } 16248 b := dAtA[iNdEx] 16249 iNdEx++ 16250 m.TotalVotingPower |= int64(b&0x7F) << shift 16251 if b < 0x80 { 16252 break 16253 } 16254 } 16255 default: 16256 iNdEx = preIndex 16257 skippy, err := skipTypes(dAtA[iNdEx:]) 16258 if err != nil { 16259 return err 16260 } 16261 if skippy < 0 { 16262 return ErrInvalidLengthTypes 16263 } 16264 if (iNdEx + skippy) < 0 { 16265 return ErrInvalidLengthTypes 16266 } 16267 if (iNdEx + skippy) > l { 16268 return io.ErrUnexpectedEOF 16269 } 16270 m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...) 16271 iNdEx += skippy 16272 } 16273 } 16274 16275 if iNdEx > l { 16276 return io.ErrUnexpectedEOF 16277 } 16278 return nil 16279 } 16280 func skipTypes(dAtA []byte) (n int, err error) { 16281 l := len(dAtA) 16282 iNdEx := 0 16283 depth := 0 16284 for iNdEx < l { 16285 var wire uint64 16286 for shift := uint(0); ; shift += 7 { 16287 if shift >= 64 { 16288 return 0, ErrIntOverflowTypes 16289 } 16290 if iNdEx >= l { 16291 return 0, io.ErrUnexpectedEOF 16292 } 16293 b := dAtA[iNdEx] 16294 iNdEx++ 16295 wire |= (uint64(b) & 0x7F) << shift 16296 if b < 0x80 { 16297 break 16298 } 16299 } 16300 wireType := int(wire & 0x7) 16301 switch wireType { 16302 case 0: 16303 for shift := uint(0); ; shift += 7 { 16304 if shift >= 64 { 16305 return 0, ErrIntOverflowTypes 16306 } 16307 if iNdEx >= l { 16308 return 0, io.ErrUnexpectedEOF 16309 } 16310 iNdEx++ 16311 if dAtA[iNdEx-1] < 0x80 { 16312 break 16313 } 16314 } 16315 case 1: 16316 iNdEx += 8 16317 case 2: 16318 var length int 16319 for shift := uint(0); ; shift += 7 { 16320 if shift >= 64 { 16321 return 0, ErrIntOverflowTypes 16322 } 16323 if iNdEx >= l { 16324 return 0, io.ErrUnexpectedEOF 16325 } 16326 b := dAtA[iNdEx] 16327 iNdEx++ 16328 length |= (int(b) & 0x7F) << shift 16329 if b < 0x80 { 16330 break 16331 } 16332 } 16333 if length < 0 { 16334 return 0, ErrInvalidLengthTypes 16335 } 16336 iNdEx += length 16337 case 3: 16338 depth++ 16339 case 4: 16340 if depth == 0 { 16341 return 0, ErrUnexpectedEndOfGroupTypes 16342 } 16343 depth-- 16344 case 5: 16345 iNdEx += 4 16346 default: 16347 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 16348 } 16349 if iNdEx < 0 { 16350 return 0, ErrInvalidLengthTypes 16351 } 16352 if depth == 0 { 16353 return iNdEx, nil 16354 } 16355 } 16356 return 0, io.ErrUnexpectedEOF 16357 } 16358 16359 var ( 16360 ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") 16361 ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 16362 ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") 16363 )