github.com/supragya/TendermintConnector@v0.0.0-20210619045051-113e32b84fb1/chains/tm34/proto/tendermint/abci/types.pb.go (about) 1 // Code generated by protoc-gen-gogo. DO NOT EDIT. 2 // source: tendermint/abci/types.proto 3 4 package types 5 6 import ( 7 context "context" 8 fmt "fmt" 9 _ "github.com/gogo/protobuf/gogoproto" 10 proto "github.com/gogo/protobuf/proto" 11 _ "github.com/gogo/protobuf/types" 12 github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" 13 crypto "github.com/supragya/TendermintConnector/chains/tm34/proto/tendermint/crypto" 14 types1 "github.com/supragya/TendermintConnector/chains/tm34/proto/tendermint/types" 15 grpc "google.golang.org/grpc" 16 codes "google.golang.org/grpc/codes" 17 status "google.golang.org/grpc/status" 18 io "io" 19 math "math" 20 math_bits "math/bits" 21 time "time" 22 ) 23 24 // Reference imports to suppress errors if they are not otherwise used. 25 var _ = proto.Marshal 26 var _ = fmt.Errorf 27 var _ = math.Inf 28 var _ = time.Kitchen 29 30 // This is a compile-time assertion to ensure that this generated file 31 // is compatible with the proto package it is being compiled against. 32 // A compilation error at this line likely means your copy of the 33 // proto package needs to be updated. 34 const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package 35 36 type CheckTxType int32 37 38 const ( 39 CheckTxType_New CheckTxType = 0 40 CheckTxType_Recheck CheckTxType = 1 41 ) 42 43 var CheckTxType_name = map[int32]string{ 44 0: "NEW", 45 1: "RECHECK", 46 } 47 48 var CheckTxType_value = map[string]int32{ 49 "NEW": 0, 50 "RECHECK": 1, 51 } 52 53 func (x CheckTxType) String() string { 54 return proto.EnumName(CheckTxType_name, int32(x)) 55 } 56 57 func (CheckTxType) EnumDescriptor() ([]byte, []int) { 58 return fileDescriptor_252557cfdd89a31a, []int{0} 59 } 60 61 type EvidenceType int32 62 63 const ( 64 EvidenceType_UNKNOWN EvidenceType = 0 65 EvidenceType_DUPLICATE_VOTE EvidenceType = 1 66 EvidenceType_LIGHT_CLIENT_ATTACK EvidenceType = 2 67 ) 68 69 var EvidenceType_name = map[int32]string{ 70 0: "UNKNOWN", 71 1: "DUPLICATE_VOTE", 72 2: "LIGHT_CLIENT_ATTACK", 73 } 74 75 var EvidenceType_value = map[string]int32{ 76 "UNKNOWN": 0, 77 "DUPLICATE_VOTE": 1, 78 "LIGHT_CLIENT_ATTACK": 2, 79 } 80 81 func (x EvidenceType) String() string { 82 return proto.EnumName(EvidenceType_name, int32(x)) 83 } 84 85 func (EvidenceType) EnumDescriptor() ([]byte, []int) { 86 return fileDescriptor_252557cfdd89a31a, []int{1} 87 } 88 89 type ResponseOfferSnapshot_Result int32 90 91 const ( 92 ResponseOfferSnapshot_UNKNOWN ResponseOfferSnapshot_Result = 0 93 ResponseOfferSnapshot_ACCEPT ResponseOfferSnapshot_Result = 1 94 ResponseOfferSnapshot_ABORT ResponseOfferSnapshot_Result = 2 95 ResponseOfferSnapshot_REJECT ResponseOfferSnapshot_Result = 3 96 ResponseOfferSnapshot_REJECT_FORMAT ResponseOfferSnapshot_Result = 4 97 ResponseOfferSnapshot_REJECT_SENDER ResponseOfferSnapshot_Result = 5 98 ) 99 100 var ResponseOfferSnapshot_Result_name = map[int32]string{ 101 0: "UNKNOWN", 102 1: "ACCEPT", 103 2: "ABORT", 104 3: "REJECT", 105 4: "REJECT_FORMAT", 106 5: "REJECT_SENDER", 107 } 108 109 var ResponseOfferSnapshot_Result_value = map[string]int32{ 110 "UNKNOWN": 0, 111 "ACCEPT": 1, 112 "ABORT": 2, 113 "REJECT": 3, 114 "REJECT_FORMAT": 4, 115 "REJECT_SENDER": 5, 116 } 117 118 func (x ResponseOfferSnapshot_Result) String() string { 119 return proto.EnumName(ResponseOfferSnapshot_Result_name, int32(x)) 120 } 121 122 func (ResponseOfferSnapshot_Result) EnumDescriptor() ([]byte, []int) { 123 return fileDescriptor_252557cfdd89a31a, []int{30, 0} 124 } 125 126 type ResponseApplySnapshotChunk_Result int32 127 128 const ( 129 ResponseApplySnapshotChunk_UNKNOWN ResponseApplySnapshotChunk_Result = 0 130 ResponseApplySnapshotChunk_ACCEPT ResponseApplySnapshotChunk_Result = 1 131 ResponseApplySnapshotChunk_ABORT ResponseApplySnapshotChunk_Result = 2 132 ResponseApplySnapshotChunk_RETRY ResponseApplySnapshotChunk_Result = 3 133 ResponseApplySnapshotChunk_RETRY_SNAPSHOT ResponseApplySnapshotChunk_Result = 4 134 ResponseApplySnapshotChunk_REJECT_SNAPSHOT ResponseApplySnapshotChunk_Result = 5 135 ) 136 137 var ResponseApplySnapshotChunk_Result_name = map[int32]string{ 138 0: "UNKNOWN", 139 1: "ACCEPT", 140 2: "ABORT", 141 3: "RETRY", 142 4: "RETRY_SNAPSHOT", 143 5: "REJECT_SNAPSHOT", 144 } 145 146 var ResponseApplySnapshotChunk_Result_value = map[string]int32{ 147 "UNKNOWN": 0, 148 "ACCEPT": 1, 149 "ABORT": 2, 150 "RETRY": 3, 151 "RETRY_SNAPSHOT": 4, 152 "REJECT_SNAPSHOT": 5, 153 } 154 155 func (x ResponseApplySnapshotChunk_Result) String() string { 156 return proto.EnumName(ResponseApplySnapshotChunk_Result_name, int32(x)) 157 } 158 159 func (ResponseApplySnapshotChunk_Result) EnumDescriptor() ([]byte, []int) { 160 return fileDescriptor_252557cfdd89a31a, []int{32, 0} 161 } 162 163 type Request struct { 164 // Types that are valid to be assigned to Value: 165 // *Request_Echo 166 // *Request_Flush 167 // *Request_Info 168 // *Request_SetOption 169 // *Request_InitChain 170 // *Request_Query 171 // *Request_BeginBlock 172 // *Request_CheckTx 173 // *Request_DeliverTx 174 // *Request_EndBlock 175 // *Request_Commit 176 // *Request_ListSnapshots 177 // *Request_OfferSnapshot 178 // *Request_LoadSnapshotChunk 179 // *Request_ApplySnapshotChunk 180 Value isRequest_Value `protobuf_oneof:"value"` 181 } 182 183 func (m *Request) Reset() { *m = Request{} } 184 func (m *Request) String() string { return proto.CompactTextString(m) } 185 func (*Request) ProtoMessage() {} 186 func (*Request) Descriptor() ([]byte, []int) { 187 return fileDescriptor_252557cfdd89a31a, []int{0} 188 } 189 func (m *Request) XXX_Unmarshal(b []byte) error { 190 return m.Unmarshal(b) 191 } 192 func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 193 if deterministic { 194 return xxx_messageInfo_Request.Marshal(b, m, deterministic) 195 } else { 196 b = b[:cap(b)] 197 n, err := m.MarshalToSizedBuffer(b) 198 if err != nil { 199 return nil, err 200 } 201 return b[:n], nil 202 } 203 } 204 func (m *Request) XXX_Merge(src proto.Message) { 205 xxx_messageInfo_Request.Merge(m, src) 206 } 207 func (m *Request) XXX_Size() int { 208 return m.Size() 209 } 210 func (m *Request) XXX_DiscardUnknown() { 211 xxx_messageInfo_Request.DiscardUnknown(m) 212 } 213 214 var xxx_messageInfo_Request proto.InternalMessageInfo 215 216 type isRequest_Value interface { 217 isRequest_Value() 218 MarshalTo([]byte) (int, error) 219 Size() int 220 } 221 222 type Request_Echo struct { 223 Echo *RequestEcho `protobuf:"bytes,1,opt,name=echo,proto3,oneof" json:"echo,omitempty"` 224 } 225 type Request_Flush struct { 226 Flush *RequestFlush `protobuf:"bytes,2,opt,name=flush,proto3,oneof" json:"flush,omitempty"` 227 } 228 type Request_Info struct { 229 Info *RequestInfo `protobuf:"bytes,3,opt,name=info,proto3,oneof" json:"info,omitempty"` 230 } 231 type Request_SetOption struct { 232 SetOption *RequestSetOption `protobuf:"bytes,4,opt,name=set_option,json=setOption,proto3,oneof" json:"set_option,omitempty"` 233 } 234 type Request_InitChain struct { 235 InitChain *RequestInitChain `protobuf:"bytes,5,opt,name=init_chain,json=initChain,proto3,oneof" json:"init_chain,omitempty"` 236 } 237 type Request_Query struct { 238 Query *RequestQuery `protobuf:"bytes,6,opt,name=query,proto3,oneof" json:"query,omitempty"` 239 } 240 type Request_BeginBlock struct { 241 BeginBlock *RequestBeginBlock `protobuf:"bytes,7,opt,name=begin_block,json=beginBlock,proto3,oneof" json:"begin_block,omitempty"` 242 } 243 type Request_CheckTx struct { 244 CheckTx *RequestCheckTx `protobuf:"bytes,8,opt,name=check_tx,json=checkTx,proto3,oneof" json:"check_tx,omitempty"` 245 } 246 type Request_DeliverTx struct { 247 DeliverTx *RequestDeliverTx `protobuf:"bytes,9,opt,name=deliver_tx,json=deliverTx,proto3,oneof" json:"deliver_tx,omitempty"` 248 } 249 type Request_EndBlock struct { 250 EndBlock *RequestEndBlock `protobuf:"bytes,10,opt,name=end_block,json=endBlock,proto3,oneof" json:"end_block,omitempty"` 251 } 252 type Request_Commit struct { 253 Commit *RequestCommit `protobuf:"bytes,11,opt,name=commit,proto3,oneof" json:"commit,omitempty"` 254 } 255 type Request_ListSnapshots struct { 256 ListSnapshots *RequestListSnapshots `protobuf:"bytes,12,opt,name=list_snapshots,json=listSnapshots,proto3,oneof" json:"list_snapshots,omitempty"` 257 } 258 type Request_OfferSnapshot struct { 259 OfferSnapshot *RequestOfferSnapshot `protobuf:"bytes,13,opt,name=offer_snapshot,json=offerSnapshot,proto3,oneof" json:"offer_snapshot,omitempty"` 260 } 261 type Request_LoadSnapshotChunk struct { 262 LoadSnapshotChunk *RequestLoadSnapshotChunk `protobuf:"bytes,14,opt,name=load_snapshot_chunk,json=loadSnapshotChunk,proto3,oneof" json:"load_snapshot_chunk,omitempty"` 263 } 264 type Request_ApplySnapshotChunk struct { 265 ApplySnapshotChunk *RequestApplySnapshotChunk `protobuf:"bytes,15,opt,name=apply_snapshot_chunk,json=applySnapshotChunk,proto3,oneof" json:"apply_snapshot_chunk,omitempty"` 266 } 267 268 func (*Request_Echo) isRequest_Value() {} 269 func (*Request_Flush) isRequest_Value() {} 270 func (*Request_Info) isRequest_Value() {} 271 func (*Request_SetOption) isRequest_Value() {} 272 func (*Request_InitChain) isRequest_Value() {} 273 func (*Request_Query) isRequest_Value() {} 274 func (*Request_BeginBlock) isRequest_Value() {} 275 func (*Request_CheckTx) isRequest_Value() {} 276 func (*Request_DeliverTx) isRequest_Value() {} 277 func (*Request_EndBlock) isRequest_Value() {} 278 func (*Request_Commit) isRequest_Value() {} 279 func (*Request_ListSnapshots) isRequest_Value() {} 280 func (*Request_OfferSnapshot) isRequest_Value() {} 281 func (*Request_LoadSnapshotChunk) isRequest_Value() {} 282 func (*Request_ApplySnapshotChunk) isRequest_Value() {} 283 284 func (m *Request) GetValue() isRequest_Value { 285 if m != nil { 286 return m.Value 287 } 288 return nil 289 } 290 291 func (m *Request) GetEcho() *RequestEcho { 292 if x, ok := m.GetValue().(*Request_Echo); ok { 293 return x.Echo 294 } 295 return nil 296 } 297 298 func (m *Request) GetFlush() *RequestFlush { 299 if x, ok := m.GetValue().(*Request_Flush); ok { 300 return x.Flush 301 } 302 return nil 303 } 304 305 func (m *Request) GetInfo() *RequestInfo { 306 if x, ok := m.GetValue().(*Request_Info); ok { 307 return x.Info 308 } 309 return nil 310 } 311 312 func (m *Request) GetSetOption() *RequestSetOption { 313 if x, ok := m.GetValue().(*Request_SetOption); ok { 314 return x.SetOption 315 } 316 return nil 317 } 318 319 func (m *Request) GetInitChain() *RequestInitChain { 320 if x, ok := m.GetValue().(*Request_InitChain); ok { 321 return x.InitChain 322 } 323 return nil 324 } 325 326 func (m *Request) GetQuery() *RequestQuery { 327 if x, ok := m.GetValue().(*Request_Query); ok { 328 return x.Query 329 } 330 return nil 331 } 332 333 func (m *Request) GetBeginBlock() *RequestBeginBlock { 334 if x, ok := m.GetValue().(*Request_BeginBlock); ok { 335 return x.BeginBlock 336 } 337 return nil 338 } 339 340 func (m *Request) GetCheckTx() *RequestCheckTx { 341 if x, ok := m.GetValue().(*Request_CheckTx); ok { 342 return x.CheckTx 343 } 344 return nil 345 } 346 347 func (m *Request) GetDeliverTx() *RequestDeliverTx { 348 if x, ok := m.GetValue().(*Request_DeliverTx); ok { 349 return x.DeliverTx 350 } 351 return nil 352 } 353 354 func (m *Request) GetEndBlock() *RequestEndBlock { 355 if x, ok := m.GetValue().(*Request_EndBlock); ok { 356 return x.EndBlock 357 } 358 return nil 359 } 360 361 func (m *Request) GetCommit() *RequestCommit { 362 if x, ok := m.GetValue().(*Request_Commit); ok { 363 return x.Commit 364 } 365 return nil 366 } 367 368 func (m *Request) GetListSnapshots() *RequestListSnapshots { 369 if x, ok := m.GetValue().(*Request_ListSnapshots); ok { 370 return x.ListSnapshots 371 } 372 return nil 373 } 374 375 func (m *Request) GetOfferSnapshot() *RequestOfferSnapshot { 376 if x, ok := m.GetValue().(*Request_OfferSnapshot); ok { 377 return x.OfferSnapshot 378 } 379 return nil 380 } 381 382 func (m *Request) GetLoadSnapshotChunk() *RequestLoadSnapshotChunk { 383 if x, ok := m.GetValue().(*Request_LoadSnapshotChunk); ok { 384 return x.LoadSnapshotChunk 385 } 386 return nil 387 } 388 389 func (m *Request) GetApplySnapshotChunk() *RequestApplySnapshotChunk { 390 if x, ok := m.GetValue().(*Request_ApplySnapshotChunk); ok { 391 return x.ApplySnapshotChunk 392 } 393 return nil 394 } 395 396 // XXX_OneofWrappers is for the internal use of the proto package. 397 func (*Request) XXX_OneofWrappers() []interface{} { 398 return []interface{}{ 399 (*Request_Echo)(nil), 400 (*Request_Flush)(nil), 401 (*Request_Info)(nil), 402 (*Request_SetOption)(nil), 403 (*Request_InitChain)(nil), 404 (*Request_Query)(nil), 405 (*Request_BeginBlock)(nil), 406 (*Request_CheckTx)(nil), 407 (*Request_DeliverTx)(nil), 408 (*Request_EndBlock)(nil), 409 (*Request_Commit)(nil), 410 (*Request_ListSnapshots)(nil), 411 (*Request_OfferSnapshot)(nil), 412 (*Request_LoadSnapshotChunk)(nil), 413 (*Request_ApplySnapshotChunk)(nil), 414 } 415 } 416 417 type RequestEcho struct { 418 Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` 419 } 420 421 func (m *RequestEcho) Reset() { *m = RequestEcho{} } 422 func (m *RequestEcho) String() string { return proto.CompactTextString(m) } 423 func (*RequestEcho) ProtoMessage() {} 424 func (*RequestEcho) Descriptor() ([]byte, []int) { 425 return fileDescriptor_252557cfdd89a31a, []int{1} 426 } 427 func (m *RequestEcho) XXX_Unmarshal(b []byte) error { 428 return m.Unmarshal(b) 429 } 430 func (m *RequestEcho) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 431 if deterministic { 432 return xxx_messageInfo_RequestEcho.Marshal(b, m, deterministic) 433 } else { 434 b = b[:cap(b)] 435 n, err := m.MarshalToSizedBuffer(b) 436 if err != nil { 437 return nil, err 438 } 439 return b[:n], nil 440 } 441 } 442 func (m *RequestEcho) XXX_Merge(src proto.Message) { 443 xxx_messageInfo_RequestEcho.Merge(m, src) 444 } 445 func (m *RequestEcho) XXX_Size() int { 446 return m.Size() 447 } 448 func (m *RequestEcho) XXX_DiscardUnknown() { 449 xxx_messageInfo_RequestEcho.DiscardUnknown(m) 450 } 451 452 var xxx_messageInfo_RequestEcho proto.InternalMessageInfo 453 454 func (m *RequestEcho) GetMessage() string { 455 if m != nil { 456 return m.Message 457 } 458 return "" 459 } 460 461 type RequestFlush struct { 462 } 463 464 func (m *RequestFlush) Reset() { *m = RequestFlush{} } 465 func (m *RequestFlush) String() string { return proto.CompactTextString(m) } 466 func (*RequestFlush) ProtoMessage() {} 467 func (*RequestFlush) Descriptor() ([]byte, []int) { 468 return fileDescriptor_252557cfdd89a31a, []int{2} 469 } 470 func (m *RequestFlush) XXX_Unmarshal(b []byte) error { 471 return m.Unmarshal(b) 472 } 473 func (m *RequestFlush) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 474 if deterministic { 475 return xxx_messageInfo_RequestFlush.Marshal(b, m, deterministic) 476 } else { 477 b = b[:cap(b)] 478 n, err := m.MarshalToSizedBuffer(b) 479 if err != nil { 480 return nil, err 481 } 482 return b[:n], nil 483 } 484 } 485 func (m *RequestFlush) XXX_Merge(src proto.Message) { 486 xxx_messageInfo_RequestFlush.Merge(m, src) 487 } 488 func (m *RequestFlush) XXX_Size() int { 489 return m.Size() 490 } 491 func (m *RequestFlush) XXX_DiscardUnknown() { 492 xxx_messageInfo_RequestFlush.DiscardUnknown(m) 493 } 494 495 var xxx_messageInfo_RequestFlush proto.InternalMessageInfo 496 497 type RequestInfo struct { 498 Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` 499 BlockVersion uint64 `protobuf:"varint,2,opt,name=block_version,json=blockVersion,proto3" json:"block_version,omitempty"` 500 P2PVersion uint64 `protobuf:"varint,3,opt,name=p2p_version,json=p2pVersion,proto3" json:"p2p_version,omitempty"` 501 } 502 503 func (m *RequestInfo) Reset() { *m = RequestInfo{} } 504 func (m *RequestInfo) String() string { return proto.CompactTextString(m) } 505 func (*RequestInfo) ProtoMessage() {} 506 func (*RequestInfo) Descriptor() ([]byte, []int) { 507 return fileDescriptor_252557cfdd89a31a, []int{3} 508 } 509 func (m *RequestInfo) XXX_Unmarshal(b []byte) error { 510 return m.Unmarshal(b) 511 } 512 func (m *RequestInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 513 if deterministic { 514 return xxx_messageInfo_RequestInfo.Marshal(b, m, deterministic) 515 } else { 516 b = b[:cap(b)] 517 n, err := m.MarshalToSizedBuffer(b) 518 if err != nil { 519 return nil, err 520 } 521 return b[:n], nil 522 } 523 } 524 func (m *RequestInfo) XXX_Merge(src proto.Message) { 525 xxx_messageInfo_RequestInfo.Merge(m, src) 526 } 527 func (m *RequestInfo) XXX_Size() int { 528 return m.Size() 529 } 530 func (m *RequestInfo) XXX_DiscardUnknown() { 531 xxx_messageInfo_RequestInfo.DiscardUnknown(m) 532 } 533 534 var xxx_messageInfo_RequestInfo proto.InternalMessageInfo 535 536 func (m *RequestInfo) GetVersion() string { 537 if m != nil { 538 return m.Version 539 } 540 return "" 541 } 542 543 func (m *RequestInfo) GetBlockVersion() uint64 { 544 if m != nil { 545 return m.BlockVersion 546 } 547 return 0 548 } 549 550 func (m *RequestInfo) GetP2PVersion() uint64 { 551 if m != nil { 552 return m.P2PVersion 553 } 554 return 0 555 } 556 557 // nondeterministic 558 type RequestSetOption struct { 559 Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 560 Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 561 } 562 563 func (m *RequestSetOption) Reset() { *m = RequestSetOption{} } 564 func (m *RequestSetOption) String() string { return proto.CompactTextString(m) } 565 func (*RequestSetOption) ProtoMessage() {} 566 func (*RequestSetOption) Descriptor() ([]byte, []int) { 567 return fileDescriptor_252557cfdd89a31a, []int{4} 568 } 569 func (m *RequestSetOption) XXX_Unmarshal(b []byte) error { 570 return m.Unmarshal(b) 571 } 572 func (m *RequestSetOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 573 if deterministic { 574 return xxx_messageInfo_RequestSetOption.Marshal(b, m, deterministic) 575 } else { 576 b = b[:cap(b)] 577 n, err := m.MarshalToSizedBuffer(b) 578 if err != nil { 579 return nil, err 580 } 581 return b[:n], nil 582 } 583 } 584 func (m *RequestSetOption) XXX_Merge(src proto.Message) { 585 xxx_messageInfo_RequestSetOption.Merge(m, src) 586 } 587 func (m *RequestSetOption) XXX_Size() int { 588 return m.Size() 589 } 590 func (m *RequestSetOption) XXX_DiscardUnknown() { 591 xxx_messageInfo_RequestSetOption.DiscardUnknown(m) 592 } 593 594 var xxx_messageInfo_RequestSetOption proto.InternalMessageInfo 595 596 func (m *RequestSetOption) GetKey() string { 597 if m != nil { 598 return m.Key 599 } 600 return "" 601 } 602 603 func (m *RequestSetOption) GetValue() string { 604 if m != nil { 605 return m.Value 606 } 607 return "" 608 } 609 610 type RequestInitChain struct { 611 Time time.Time `protobuf:"bytes,1,opt,name=time,proto3,stdtime" json:"time"` 612 ChainId string `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3" json:"chain_id,omitempty"` 613 ConsensusParams *ConsensusParams `protobuf:"bytes,3,opt,name=consensus_params,json=consensusParams,proto3" json:"consensus_params,omitempty"` 614 Validators []ValidatorUpdate `protobuf:"bytes,4,rep,name=validators,proto3" json:"validators"` 615 AppStateBytes []byte `protobuf:"bytes,5,opt,name=app_state_bytes,json=appStateBytes,proto3" json:"app_state_bytes,omitempty"` 616 InitialHeight int64 `protobuf:"varint,6,opt,name=initial_height,json=initialHeight,proto3" json:"initial_height,omitempty"` 617 } 618 619 func (m *RequestInitChain) Reset() { *m = RequestInitChain{} } 620 func (m *RequestInitChain) String() string { return proto.CompactTextString(m) } 621 func (*RequestInitChain) ProtoMessage() {} 622 func (*RequestInitChain) Descriptor() ([]byte, []int) { 623 return fileDescriptor_252557cfdd89a31a, []int{5} 624 } 625 func (m *RequestInitChain) XXX_Unmarshal(b []byte) error { 626 return m.Unmarshal(b) 627 } 628 func (m *RequestInitChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 629 if deterministic { 630 return xxx_messageInfo_RequestInitChain.Marshal(b, m, deterministic) 631 } else { 632 b = b[:cap(b)] 633 n, err := m.MarshalToSizedBuffer(b) 634 if err != nil { 635 return nil, err 636 } 637 return b[:n], nil 638 } 639 } 640 func (m *RequestInitChain) XXX_Merge(src proto.Message) { 641 xxx_messageInfo_RequestInitChain.Merge(m, src) 642 } 643 func (m *RequestInitChain) XXX_Size() int { 644 return m.Size() 645 } 646 func (m *RequestInitChain) XXX_DiscardUnknown() { 647 xxx_messageInfo_RequestInitChain.DiscardUnknown(m) 648 } 649 650 var xxx_messageInfo_RequestInitChain proto.InternalMessageInfo 651 652 func (m *RequestInitChain) GetTime() time.Time { 653 if m != nil { 654 return m.Time 655 } 656 return time.Time{} 657 } 658 659 func (m *RequestInitChain) GetChainId() string { 660 if m != nil { 661 return m.ChainId 662 } 663 return "" 664 } 665 666 func (m *RequestInitChain) GetConsensusParams() *ConsensusParams { 667 if m != nil { 668 return m.ConsensusParams 669 } 670 return nil 671 } 672 673 func (m *RequestInitChain) GetValidators() []ValidatorUpdate { 674 if m != nil { 675 return m.Validators 676 } 677 return nil 678 } 679 680 func (m *RequestInitChain) GetAppStateBytes() []byte { 681 if m != nil { 682 return m.AppStateBytes 683 } 684 return nil 685 } 686 687 func (m *RequestInitChain) GetInitialHeight() int64 { 688 if m != nil { 689 return m.InitialHeight 690 } 691 return 0 692 } 693 694 type RequestQuery struct { 695 Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 696 Path string `protobuf:"bytes,2,opt,name=path,proto3" json:"path,omitempty"` 697 Height int64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` 698 Prove bool `protobuf:"varint,4,opt,name=prove,proto3" json:"prove,omitempty"` 699 } 700 701 func (m *RequestQuery) Reset() { *m = RequestQuery{} } 702 func (m *RequestQuery) String() string { return proto.CompactTextString(m) } 703 func (*RequestQuery) ProtoMessage() {} 704 func (*RequestQuery) Descriptor() ([]byte, []int) { 705 return fileDescriptor_252557cfdd89a31a, []int{6} 706 } 707 func (m *RequestQuery) XXX_Unmarshal(b []byte) error { 708 return m.Unmarshal(b) 709 } 710 func (m *RequestQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 711 if deterministic { 712 return xxx_messageInfo_RequestQuery.Marshal(b, m, deterministic) 713 } else { 714 b = b[:cap(b)] 715 n, err := m.MarshalToSizedBuffer(b) 716 if err != nil { 717 return nil, err 718 } 719 return b[:n], nil 720 } 721 } 722 func (m *RequestQuery) XXX_Merge(src proto.Message) { 723 xxx_messageInfo_RequestQuery.Merge(m, src) 724 } 725 func (m *RequestQuery) XXX_Size() int { 726 return m.Size() 727 } 728 func (m *RequestQuery) XXX_DiscardUnknown() { 729 xxx_messageInfo_RequestQuery.DiscardUnknown(m) 730 } 731 732 var xxx_messageInfo_RequestQuery proto.InternalMessageInfo 733 734 func (m *RequestQuery) GetData() []byte { 735 if m != nil { 736 return m.Data 737 } 738 return nil 739 } 740 741 func (m *RequestQuery) GetPath() string { 742 if m != nil { 743 return m.Path 744 } 745 return "" 746 } 747 748 func (m *RequestQuery) GetHeight() int64 { 749 if m != nil { 750 return m.Height 751 } 752 return 0 753 } 754 755 func (m *RequestQuery) GetProve() bool { 756 if m != nil { 757 return m.Prove 758 } 759 return false 760 } 761 762 type RequestBeginBlock struct { 763 Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"` 764 Header types1.Header `protobuf:"bytes,2,opt,name=header,proto3" json:"header"` 765 LastCommitInfo LastCommitInfo `protobuf:"bytes,3,opt,name=last_commit_info,json=lastCommitInfo,proto3" json:"last_commit_info"` 766 ByzantineValidators []Evidence `protobuf:"bytes,4,rep,name=byzantine_validators,json=byzantineValidators,proto3" json:"byzantine_validators"` 767 } 768 769 func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} } 770 func (m *RequestBeginBlock) String() string { return proto.CompactTextString(m) } 771 func (*RequestBeginBlock) ProtoMessage() {} 772 func (*RequestBeginBlock) Descriptor() ([]byte, []int) { 773 return fileDescriptor_252557cfdd89a31a, []int{7} 774 } 775 func (m *RequestBeginBlock) XXX_Unmarshal(b []byte) error { 776 return m.Unmarshal(b) 777 } 778 func (m *RequestBeginBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 779 if deterministic { 780 return xxx_messageInfo_RequestBeginBlock.Marshal(b, m, deterministic) 781 } else { 782 b = b[:cap(b)] 783 n, err := m.MarshalToSizedBuffer(b) 784 if err != nil { 785 return nil, err 786 } 787 return b[:n], nil 788 } 789 } 790 func (m *RequestBeginBlock) XXX_Merge(src proto.Message) { 791 xxx_messageInfo_RequestBeginBlock.Merge(m, src) 792 } 793 func (m *RequestBeginBlock) XXX_Size() int { 794 return m.Size() 795 } 796 func (m *RequestBeginBlock) XXX_DiscardUnknown() { 797 xxx_messageInfo_RequestBeginBlock.DiscardUnknown(m) 798 } 799 800 var xxx_messageInfo_RequestBeginBlock proto.InternalMessageInfo 801 802 func (m *RequestBeginBlock) GetHash() []byte { 803 if m != nil { 804 return m.Hash 805 } 806 return nil 807 } 808 809 func (m *RequestBeginBlock) GetHeader() types1.Header { 810 if m != nil { 811 return m.Header 812 } 813 return types1.Header{} 814 } 815 816 func (m *RequestBeginBlock) GetLastCommitInfo() LastCommitInfo { 817 if m != nil { 818 return m.LastCommitInfo 819 } 820 return LastCommitInfo{} 821 } 822 823 func (m *RequestBeginBlock) GetByzantineValidators() []Evidence { 824 if m != nil { 825 return m.ByzantineValidators 826 } 827 return nil 828 } 829 830 type RequestCheckTx struct { 831 Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` 832 Type CheckTxType `protobuf:"varint,2,opt,name=type,proto3,enum=tendermint.abci.CheckTxType" json:"type,omitempty"` 833 } 834 835 func (m *RequestCheckTx) Reset() { *m = RequestCheckTx{} } 836 func (m *RequestCheckTx) String() string { return proto.CompactTextString(m) } 837 func (*RequestCheckTx) ProtoMessage() {} 838 func (*RequestCheckTx) Descriptor() ([]byte, []int) { 839 return fileDescriptor_252557cfdd89a31a, []int{8} 840 } 841 func (m *RequestCheckTx) XXX_Unmarshal(b []byte) error { 842 return m.Unmarshal(b) 843 } 844 func (m *RequestCheckTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 845 if deterministic { 846 return xxx_messageInfo_RequestCheckTx.Marshal(b, m, deterministic) 847 } else { 848 b = b[:cap(b)] 849 n, err := m.MarshalToSizedBuffer(b) 850 if err != nil { 851 return nil, err 852 } 853 return b[:n], nil 854 } 855 } 856 func (m *RequestCheckTx) XXX_Merge(src proto.Message) { 857 xxx_messageInfo_RequestCheckTx.Merge(m, src) 858 } 859 func (m *RequestCheckTx) XXX_Size() int { 860 return m.Size() 861 } 862 func (m *RequestCheckTx) XXX_DiscardUnknown() { 863 xxx_messageInfo_RequestCheckTx.DiscardUnknown(m) 864 } 865 866 var xxx_messageInfo_RequestCheckTx proto.InternalMessageInfo 867 868 func (m *RequestCheckTx) GetTx() []byte { 869 if m != nil { 870 return m.Tx 871 } 872 return nil 873 } 874 875 func (m *RequestCheckTx) GetType() CheckTxType { 876 if m != nil { 877 return m.Type 878 } 879 return CheckTxType_New 880 } 881 882 type RequestDeliverTx struct { 883 Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` 884 } 885 886 func (m *RequestDeliverTx) Reset() { *m = RequestDeliverTx{} } 887 func (m *RequestDeliverTx) String() string { return proto.CompactTextString(m) } 888 func (*RequestDeliverTx) ProtoMessage() {} 889 func (*RequestDeliverTx) Descriptor() ([]byte, []int) { 890 return fileDescriptor_252557cfdd89a31a, []int{9} 891 } 892 func (m *RequestDeliverTx) XXX_Unmarshal(b []byte) error { 893 return m.Unmarshal(b) 894 } 895 func (m *RequestDeliverTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 896 if deterministic { 897 return xxx_messageInfo_RequestDeliverTx.Marshal(b, m, deterministic) 898 } else { 899 b = b[:cap(b)] 900 n, err := m.MarshalToSizedBuffer(b) 901 if err != nil { 902 return nil, err 903 } 904 return b[:n], nil 905 } 906 } 907 func (m *RequestDeliverTx) XXX_Merge(src proto.Message) { 908 xxx_messageInfo_RequestDeliverTx.Merge(m, src) 909 } 910 func (m *RequestDeliverTx) XXX_Size() int { 911 return m.Size() 912 } 913 func (m *RequestDeliverTx) XXX_DiscardUnknown() { 914 xxx_messageInfo_RequestDeliverTx.DiscardUnknown(m) 915 } 916 917 var xxx_messageInfo_RequestDeliverTx proto.InternalMessageInfo 918 919 func (m *RequestDeliverTx) GetTx() []byte { 920 if m != nil { 921 return m.Tx 922 } 923 return nil 924 } 925 926 type RequestEndBlock struct { 927 Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` 928 } 929 930 func (m *RequestEndBlock) Reset() { *m = RequestEndBlock{} } 931 func (m *RequestEndBlock) String() string { return proto.CompactTextString(m) } 932 func (*RequestEndBlock) ProtoMessage() {} 933 func (*RequestEndBlock) Descriptor() ([]byte, []int) { 934 return fileDescriptor_252557cfdd89a31a, []int{10} 935 } 936 func (m *RequestEndBlock) XXX_Unmarshal(b []byte) error { 937 return m.Unmarshal(b) 938 } 939 func (m *RequestEndBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 940 if deterministic { 941 return xxx_messageInfo_RequestEndBlock.Marshal(b, m, deterministic) 942 } else { 943 b = b[:cap(b)] 944 n, err := m.MarshalToSizedBuffer(b) 945 if err != nil { 946 return nil, err 947 } 948 return b[:n], nil 949 } 950 } 951 func (m *RequestEndBlock) XXX_Merge(src proto.Message) { 952 xxx_messageInfo_RequestEndBlock.Merge(m, src) 953 } 954 func (m *RequestEndBlock) XXX_Size() int { 955 return m.Size() 956 } 957 func (m *RequestEndBlock) XXX_DiscardUnknown() { 958 xxx_messageInfo_RequestEndBlock.DiscardUnknown(m) 959 } 960 961 var xxx_messageInfo_RequestEndBlock proto.InternalMessageInfo 962 963 func (m *RequestEndBlock) GetHeight() int64 { 964 if m != nil { 965 return m.Height 966 } 967 return 0 968 } 969 970 type RequestCommit struct { 971 } 972 973 func (m *RequestCommit) Reset() { *m = RequestCommit{} } 974 func (m *RequestCommit) String() string { return proto.CompactTextString(m) } 975 func (*RequestCommit) ProtoMessage() {} 976 func (*RequestCommit) Descriptor() ([]byte, []int) { 977 return fileDescriptor_252557cfdd89a31a, []int{11} 978 } 979 func (m *RequestCommit) XXX_Unmarshal(b []byte) error { 980 return m.Unmarshal(b) 981 } 982 func (m *RequestCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 983 if deterministic { 984 return xxx_messageInfo_RequestCommit.Marshal(b, m, deterministic) 985 } else { 986 b = b[:cap(b)] 987 n, err := m.MarshalToSizedBuffer(b) 988 if err != nil { 989 return nil, err 990 } 991 return b[:n], nil 992 } 993 } 994 func (m *RequestCommit) XXX_Merge(src proto.Message) { 995 xxx_messageInfo_RequestCommit.Merge(m, src) 996 } 997 func (m *RequestCommit) XXX_Size() int { 998 return m.Size() 999 } 1000 func (m *RequestCommit) XXX_DiscardUnknown() { 1001 xxx_messageInfo_RequestCommit.DiscardUnknown(m) 1002 } 1003 1004 var xxx_messageInfo_RequestCommit proto.InternalMessageInfo 1005 1006 // lists available snapshots 1007 type RequestListSnapshots struct { 1008 } 1009 1010 func (m *RequestListSnapshots) Reset() { *m = RequestListSnapshots{} } 1011 func (m *RequestListSnapshots) String() string { return proto.CompactTextString(m) } 1012 func (*RequestListSnapshots) ProtoMessage() {} 1013 func (*RequestListSnapshots) Descriptor() ([]byte, []int) { 1014 return fileDescriptor_252557cfdd89a31a, []int{12} 1015 } 1016 func (m *RequestListSnapshots) XXX_Unmarshal(b []byte) error { 1017 return m.Unmarshal(b) 1018 } 1019 func (m *RequestListSnapshots) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1020 if deterministic { 1021 return xxx_messageInfo_RequestListSnapshots.Marshal(b, m, deterministic) 1022 } else { 1023 b = b[:cap(b)] 1024 n, err := m.MarshalToSizedBuffer(b) 1025 if err != nil { 1026 return nil, err 1027 } 1028 return b[:n], nil 1029 } 1030 } 1031 func (m *RequestListSnapshots) XXX_Merge(src proto.Message) { 1032 xxx_messageInfo_RequestListSnapshots.Merge(m, src) 1033 } 1034 func (m *RequestListSnapshots) XXX_Size() int { 1035 return m.Size() 1036 } 1037 func (m *RequestListSnapshots) XXX_DiscardUnknown() { 1038 xxx_messageInfo_RequestListSnapshots.DiscardUnknown(m) 1039 } 1040 1041 var xxx_messageInfo_RequestListSnapshots proto.InternalMessageInfo 1042 1043 // offers a snapshot to the application 1044 type RequestOfferSnapshot struct { 1045 Snapshot *Snapshot `protobuf:"bytes,1,opt,name=snapshot,proto3" json:"snapshot,omitempty"` 1046 AppHash []byte `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` 1047 } 1048 1049 func (m *RequestOfferSnapshot) Reset() { *m = RequestOfferSnapshot{} } 1050 func (m *RequestOfferSnapshot) String() string { return proto.CompactTextString(m) } 1051 func (*RequestOfferSnapshot) ProtoMessage() {} 1052 func (*RequestOfferSnapshot) Descriptor() ([]byte, []int) { 1053 return fileDescriptor_252557cfdd89a31a, []int{13} 1054 } 1055 func (m *RequestOfferSnapshot) XXX_Unmarshal(b []byte) error { 1056 return m.Unmarshal(b) 1057 } 1058 func (m *RequestOfferSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1059 if deterministic { 1060 return xxx_messageInfo_RequestOfferSnapshot.Marshal(b, m, deterministic) 1061 } else { 1062 b = b[:cap(b)] 1063 n, err := m.MarshalToSizedBuffer(b) 1064 if err != nil { 1065 return nil, err 1066 } 1067 return b[:n], nil 1068 } 1069 } 1070 func (m *RequestOfferSnapshot) XXX_Merge(src proto.Message) { 1071 xxx_messageInfo_RequestOfferSnapshot.Merge(m, src) 1072 } 1073 func (m *RequestOfferSnapshot) XXX_Size() int { 1074 return m.Size() 1075 } 1076 func (m *RequestOfferSnapshot) XXX_DiscardUnknown() { 1077 xxx_messageInfo_RequestOfferSnapshot.DiscardUnknown(m) 1078 } 1079 1080 var xxx_messageInfo_RequestOfferSnapshot proto.InternalMessageInfo 1081 1082 func (m *RequestOfferSnapshot) GetSnapshot() *Snapshot { 1083 if m != nil { 1084 return m.Snapshot 1085 } 1086 return nil 1087 } 1088 1089 func (m *RequestOfferSnapshot) GetAppHash() []byte { 1090 if m != nil { 1091 return m.AppHash 1092 } 1093 return nil 1094 } 1095 1096 // loads a snapshot chunk 1097 type RequestLoadSnapshotChunk struct { 1098 Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` 1099 Format uint32 `protobuf:"varint,2,opt,name=format,proto3" json:"format,omitempty"` 1100 Chunk uint32 `protobuf:"varint,3,opt,name=chunk,proto3" json:"chunk,omitempty"` 1101 } 1102 1103 func (m *RequestLoadSnapshotChunk) Reset() { *m = RequestLoadSnapshotChunk{} } 1104 func (m *RequestLoadSnapshotChunk) String() string { return proto.CompactTextString(m) } 1105 func (*RequestLoadSnapshotChunk) ProtoMessage() {} 1106 func (*RequestLoadSnapshotChunk) Descriptor() ([]byte, []int) { 1107 return fileDescriptor_252557cfdd89a31a, []int{14} 1108 } 1109 func (m *RequestLoadSnapshotChunk) XXX_Unmarshal(b []byte) error { 1110 return m.Unmarshal(b) 1111 } 1112 func (m *RequestLoadSnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1113 if deterministic { 1114 return xxx_messageInfo_RequestLoadSnapshotChunk.Marshal(b, m, deterministic) 1115 } else { 1116 b = b[:cap(b)] 1117 n, err := m.MarshalToSizedBuffer(b) 1118 if err != nil { 1119 return nil, err 1120 } 1121 return b[:n], nil 1122 } 1123 } 1124 func (m *RequestLoadSnapshotChunk) XXX_Merge(src proto.Message) { 1125 xxx_messageInfo_RequestLoadSnapshotChunk.Merge(m, src) 1126 } 1127 func (m *RequestLoadSnapshotChunk) XXX_Size() int { 1128 return m.Size() 1129 } 1130 func (m *RequestLoadSnapshotChunk) XXX_DiscardUnknown() { 1131 xxx_messageInfo_RequestLoadSnapshotChunk.DiscardUnknown(m) 1132 } 1133 1134 var xxx_messageInfo_RequestLoadSnapshotChunk proto.InternalMessageInfo 1135 1136 func (m *RequestLoadSnapshotChunk) GetHeight() uint64 { 1137 if m != nil { 1138 return m.Height 1139 } 1140 return 0 1141 } 1142 1143 func (m *RequestLoadSnapshotChunk) GetFormat() uint32 { 1144 if m != nil { 1145 return m.Format 1146 } 1147 return 0 1148 } 1149 1150 func (m *RequestLoadSnapshotChunk) GetChunk() uint32 { 1151 if m != nil { 1152 return m.Chunk 1153 } 1154 return 0 1155 } 1156 1157 // Applies a snapshot chunk 1158 type RequestApplySnapshotChunk struct { 1159 Index uint32 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"` 1160 Chunk []byte `protobuf:"bytes,2,opt,name=chunk,proto3" json:"chunk,omitempty"` 1161 Sender string `protobuf:"bytes,3,opt,name=sender,proto3" json:"sender,omitempty"` 1162 } 1163 1164 func (m *RequestApplySnapshotChunk) Reset() { *m = RequestApplySnapshotChunk{} } 1165 func (m *RequestApplySnapshotChunk) String() string { return proto.CompactTextString(m) } 1166 func (*RequestApplySnapshotChunk) ProtoMessage() {} 1167 func (*RequestApplySnapshotChunk) Descriptor() ([]byte, []int) { 1168 return fileDescriptor_252557cfdd89a31a, []int{15} 1169 } 1170 func (m *RequestApplySnapshotChunk) XXX_Unmarshal(b []byte) error { 1171 return m.Unmarshal(b) 1172 } 1173 func (m *RequestApplySnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1174 if deterministic { 1175 return xxx_messageInfo_RequestApplySnapshotChunk.Marshal(b, m, deterministic) 1176 } else { 1177 b = b[:cap(b)] 1178 n, err := m.MarshalToSizedBuffer(b) 1179 if err != nil { 1180 return nil, err 1181 } 1182 return b[:n], nil 1183 } 1184 } 1185 func (m *RequestApplySnapshotChunk) XXX_Merge(src proto.Message) { 1186 xxx_messageInfo_RequestApplySnapshotChunk.Merge(m, src) 1187 } 1188 func (m *RequestApplySnapshotChunk) XXX_Size() int { 1189 return m.Size() 1190 } 1191 func (m *RequestApplySnapshotChunk) XXX_DiscardUnknown() { 1192 xxx_messageInfo_RequestApplySnapshotChunk.DiscardUnknown(m) 1193 } 1194 1195 var xxx_messageInfo_RequestApplySnapshotChunk proto.InternalMessageInfo 1196 1197 func (m *RequestApplySnapshotChunk) GetIndex() uint32 { 1198 if m != nil { 1199 return m.Index 1200 } 1201 return 0 1202 } 1203 1204 func (m *RequestApplySnapshotChunk) GetChunk() []byte { 1205 if m != nil { 1206 return m.Chunk 1207 } 1208 return nil 1209 } 1210 1211 func (m *RequestApplySnapshotChunk) GetSender() string { 1212 if m != nil { 1213 return m.Sender 1214 } 1215 return "" 1216 } 1217 1218 type Response struct { 1219 // Types that are valid to be assigned to Value: 1220 // *Response_Exception 1221 // *Response_Echo 1222 // *Response_Flush 1223 // *Response_Info 1224 // *Response_SetOption 1225 // *Response_InitChain 1226 // *Response_Query 1227 // *Response_BeginBlock 1228 // *Response_CheckTx 1229 // *Response_DeliverTx 1230 // *Response_EndBlock 1231 // *Response_Commit 1232 // *Response_ListSnapshots 1233 // *Response_OfferSnapshot 1234 // *Response_LoadSnapshotChunk 1235 // *Response_ApplySnapshotChunk 1236 Value isResponse_Value `protobuf_oneof:"value"` 1237 } 1238 1239 func (m *Response) Reset() { *m = Response{} } 1240 func (m *Response) String() string { return proto.CompactTextString(m) } 1241 func (*Response) ProtoMessage() {} 1242 func (*Response) Descriptor() ([]byte, []int) { 1243 return fileDescriptor_252557cfdd89a31a, []int{16} 1244 } 1245 func (m *Response) XXX_Unmarshal(b []byte) error { 1246 return m.Unmarshal(b) 1247 } 1248 func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1249 if deterministic { 1250 return xxx_messageInfo_Response.Marshal(b, m, deterministic) 1251 } else { 1252 b = b[:cap(b)] 1253 n, err := m.MarshalToSizedBuffer(b) 1254 if err != nil { 1255 return nil, err 1256 } 1257 return b[:n], nil 1258 } 1259 } 1260 func (m *Response) XXX_Merge(src proto.Message) { 1261 xxx_messageInfo_Response.Merge(m, src) 1262 } 1263 func (m *Response) XXX_Size() int { 1264 return m.Size() 1265 } 1266 func (m *Response) XXX_DiscardUnknown() { 1267 xxx_messageInfo_Response.DiscardUnknown(m) 1268 } 1269 1270 var xxx_messageInfo_Response proto.InternalMessageInfo 1271 1272 type isResponse_Value interface { 1273 isResponse_Value() 1274 MarshalTo([]byte) (int, error) 1275 Size() int 1276 } 1277 1278 type Response_Exception struct { 1279 Exception *ResponseException `protobuf:"bytes,1,opt,name=exception,proto3,oneof" json:"exception,omitempty"` 1280 } 1281 type Response_Echo struct { 1282 Echo *ResponseEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof" json:"echo,omitempty"` 1283 } 1284 type Response_Flush struct { 1285 Flush *ResponseFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"` 1286 } 1287 type Response_Info struct { 1288 Info *ResponseInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof" json:"info,omitempty"` 1289 } 1290 type Response_SetOption struct { 1291 SetOption *ResponseSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof" json:"set_option,omitempty"` 1292 } 1293 type Response_InitChain struct { 1294 InitChain *ResponseInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof" json:"init_chain,omitempty"` 1295 } 1296 type Response_Query struct { 1297 Query *ResponseQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof" json:"query,omitempty"` 1298 } 1299 type Response_BeginBlock struct { 1300 BeginBlock *ResponseBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof" json:"begin_block,omitempty"` 1301 } 1302 type Response_CheckTx struct { 1303 CheckTx *ResponseCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof" json:"check_tx,omitempty"` 1304 } 1305 type Response_DeliverTx struct { 1306 DeliverTx *ResponseDeliverTx `protobuf:"bytes,10,opt,name=deliver_tx,json=deliverTx,proto3,oneof" json:"deliver_tx,omitempty"` 1307 } 1308 type Response_EndBlock struct { 1309 EndBlock *ResponseEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof" json:"end_block,omitempty"` 1310 } 1311 type Response_Commit struct { 1312 Commit *ResponseCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"` 1313 } 1314 type Response_ListSnapshots struct { 1315 ListSnapshots *ResponseListSnapshots `protobuf:"bytes,13,opt,name=list_snapshots,json=listSnapshots,proto3,oneof" json:"list_snapshots,omitempty"` 1316 } 1317 type Response_OfferSnapshot struct { 1318 OfferSnapshot *ResponseOfferSnapshot `protobuf:"bytes,14,opt,name=offer_snapshot,json=offerSnapshot,proto3,oneof" json:"offer_snapshot,omitempty"` 1319 } 1320 type Response_LoadSnapshotChunk struct { 1321 LoadSnapshotChunk *ResponseLoadSnapshotChunk `protobuf:"bytes,15,opt,name=load_snapshot_chunk,json=loadSnapshotChunk,proto3,oneof" json:"load_snapshot_chunk,omitempty"` 1322 } 1323 type Response_ApplySnapshotChunk struct { 1324 ApplySnapshotChunk *ResponseApplySnapshotChunk `protobuf:"bytes,16,opt,name=apply_snapshot_chunk,json=applySnapshotChunk,proto3,oneof" json:"apply_snapshot_chunk,omitempty"` 1325 } 1326 1327 func (*Response_Exception) isResponse_Value() {} 1328 func (*Response_Echo) isResponse_Value() {} 1329 func (*Response_Flush) isResponse_Value() {} 1330 func (*Response_Info) isResponse_Value() {} 1331 func (*Response_SetOption) isResponse_Value() {} 1332 func (*Response_InitChain) isResponse_Value() {} 1333 func (*Response_Query) isResponse_Value() {} 1334 func (*Response_BeginBlock) isResponse_Value() {} 1335 func (*Response_CheckTx) isResponse_Value() {} 1336 func (*Response_DeliverTx) isResponse_Value() {} 1337 func (*Response_EndBlock) isResponse_Value() {} 1338 func (*Response_Commit) isResponse_Value() {} 1339 func (*Response_ListSnapshots) isResponse_Value() {} 1340 func (*Response_OfferSnapshot) isResponse_Value() {} 1341 func (*Response_LoadSnapshotChunk) isResponse_Value() {} 1342 func (*Response_ApplySnapshotChunk) isResponse_Value() {} 1343 1344 func (m *Response) GetValue() isResponse_Value { 1345 if m != nil { 1346 return m.Value 1347 } 1348 return nil 1349 } 1350 1351 func (m *Response) GetException() *ResponseException { 1352 if x, ok := m.GetValue().(*Response_Exception); ok { 1353 return x.Exception 1354 } 1355 return nil 1356 } 1357 1358 func (m *Response) GetEcho() *ResponseEcho { 1359 if x, ok := m.GetValue().(*Response_Echo); ok { 1360 return x.Echo 1361 } 1362 return nil 1363 } 1364 1365 func (m *Response) GetFlush() *ResponseFlush { 1366 if x, ok := m.GetValue().(*Response_Flush); ok { 1367 return x.Flush 1368 } 1369 return nil 1370 } 1371 1372 func (m *Response) GetInfo() *ResponseInfo { 1373 if x, ok := m.GetValue().(*Response_Info); ok { 1374 return x.Info 1375 } 1376 return nil 1377 } 1378 1379 func (m *Response) GetSetOption() *ResponseSetOption { 1380 if x, ok := m.GetValue().(*Response_SetOption); ok { 1381 return x.SetOption 1382 } 1383 return nil 1384 } 1385 1386 func (m *Response) GetInitChain() *ResponseInitChain { 1387 if x, ok := m.GetValue().(*Response_InitChain); ok { 1388 return x.InitChain 1389 } 1390 return nil 1391 } 1392 1393 func (m *Response) GetQuery() *ResponseQuery { 1394 if x, ok := m.GetValue().(*Response_Query); ok { 1395 return x.Query 1396 } 1397 return nil 1398 } 1399 1400 func (m *Response) GetBeginBlock() *ResponseBeginBlock { 1401 if x, ok := m.GetValue().(*Response_BeginBlock); ok { 1402 return x.BeginBlock 1403 } 1404 return nil 1405 } 1406 1407 func (m *Response) GetCheckTx() *ResponseCheckTx { 1408 if x, ok := m.GetValue().(*Response_CheckTx); ok { 1409 return x.CheckTx 1410 } 1411 return nil 1412 } 1413 1414 func (m *Response) GetDeliverTx() *ResponseDeliverTx { 1415 if x, ok := m.GetValue().(*Response_DeliverTx); ok { 1416 return x.DeliverTx 1417 } 1418 return nil 1419 } 1420 1421 func (m *Response) GetEndBlock() *ResponseEndBlock { 1422 if x, ok := m.GetValue().(*Response_EndBlock); ok { 1423 return x.EndBlock 1424 } 1425 return nil 1426 } 1427 1428 func (m *Response) GetCommit() *ResponseCommit { 1429 if x, ok := m.GetValue().(*Response_Commit); ok { 1430 return x.Commit 1431 } 1432 return nil 1433 } 1434 1435 func (m *Response) GetListSnapshots() *ResponseListSnapshots { 1436 if x, ok := m.GetValue().(*Response_ListSnapshots); ok { 1437 return x.ListSnapshots 1438 } 1439 return nil 1440 } 1441 1442 func (m *Response) GetOfferSnapshot() *ResponseOfferSnapshot { 1443 if x, ok := m.GetValue().(*Response_OfferSnapshot); ok { 1444 return x.OfferSnapshot 1445 } 1446 return nil 1447 } 1448 1449 func (m *Response) GetLoadSnapshotChunk() *ResponseLoadSnapshotChunk { 1450 if x, ok := m.GetValue().(*Response_LoadSnapshotChunk); ok { 1451 return x.LoadSnapshotChunk 1452 } 1453 return nil 1454 } 1455 1456 func (m *Response) GetApplySnapshotChunk() *ResponseApplySnapshotChunk { 1457 if x, ok := m.GetValue().(*Response_ApplySnapshotChunk); ok { 1458 return x.ApplySnapshotChunk 1459 } 1460 return nil 1461 } 1462 1463 // XXX_OneofWrappers is for the internal use of the proto package. 1464 func (*Response) XXX_OneofWrappers() []interface{} { 1465 return []interface{}{ 1466 (*Response_Exception)(nil), 1467 (*Response_Echo)(nil), 1468 (*Response_Flush)(nil), 1469 (*Response_Info)(nil), 1470 (*Response_SetOption)(nil), 1471 (*Response_InitChain)(nil), 1472 (*Response_Query)(nil), 1473 (*Response_BeginBlock)(nil), 1474 (*Response_CheckTx)(nil), 1475 (*Response_DeliverTx)(nil), 1476 (*Response_EndBlock)(nil), 1477 (*Response_Commit)(nil), 1478 (*Response_ListSnapshots)(nil), 1479 (*Response_OfferSnapshot)(nil), 1480 (*Response_LoadSnapshotChunk)(nil), 1481 (*Response_ApplySnapshotChunk)(nil), 1482 } 1483 } 1484 1485 // nondeterministic 1486 type ResponseException struct { 1487 Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` 1488 } 1489 1490 func (m *ResponseException) Reset() { *m = ResponseException{} } 1491 func (m *ResponseException) String() string { return proto.CompactTextString(m) } 1492 func (*ResponseException) ProtoMessage() {} 1493 func (*ResponseException) Descriptor() ([]byte, []int) { 1494 return fileDescriptor_252557cfdd89a31a, []int{17} 1495 } 1496 func (m *ResponseException) XXX_Unmarshal(b []byte) error { 1497 return m.Unmarshal(b) 1498 } 1499 func (m *ResponseException) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1500 if deterministic { 1501 return xxx_messageInfo_ResponseException.Marshal(b, m, deterministic) 1502 } else { 1503 b = b[:cap(b)] 1504 n, err := m.MarshalToSizedBuffer(b) 1505 if err != nil { 1506 return nil, err 1507 } 1508 return b[:n], nil 1509 } 1510 } 1511 func (m *ResponseException) XXX_Merge(src proto.Message) { 1512 xxx_messageInfo_ResponseException.Merge(m, src) 1513 } 1514 func (m *ResponseException) XXX_Size() int { 1515 return m.Size() 1516 } 1517 func (m *ResponseException) XXX_DiscardUnknown() { 1518 xxx_messageInfo_ResponseException.DiscardUnknown(m) 1519 } 1520 1521 var xxx_messageInfo_ResponseException proto.InternalMessageInfo 1522 1523 func (m *ResponseException) GetError() string { 1524 if m != nil { 1525 return m.Error 1526 } 1527 return "" 1528 } 1529 1530 type ResponseEcho struct { 1531 Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` 1532 } 1533 1534 func (m *ResponseEcho) Reset() { *m = ResponseEcho{} } 1535 func (m *ResponseEcho) String() string { return proto.CompactTextString(m) } 1536 func (*ResponseEcho) ProtoMessage() {} 1537 func (*ResponseEcho) Descriptor() ([]byte, []int) { 1538 return fileDescriptor_252557cfdd89a31a, []int{18} 1539 } 1540 func (m *ResponseEcho) XXX_Unmarshal(b []byte) error { 1541 return m.Unmarshal(b) 1542 } 1543 func (m *ResponseEcho) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1544 if deterministic { 1545 return xxx_messageInfo_ResponseEcho.Marshal(b, m, deterministic) 1546 } else { 1547 b = b[:cap(b)] 1548 n, err := m.MarshalToSizedBuffer(b) 1549 if err != nil { 1550 return nil, err 1551 } 1552 return b[:n], nil 1553 } 1554 } 1555 func (m *ResponseEcho) XXX_Merge(src proto.Message) { 1556 xxx_messageInfo_ResponseEcho.Merge(m, src) 1557 } 1558 func (m *ResponseEcho) XXX_Size() int { 1559 return m.Size() 1560 } 1561 func (m *ResponseEcho) XXX_DiscardUnknown() { 1562 xxx_messageInfo_ResponseEcho.DiscardUnknown(m) 1563 } 1564 1565 var xxx_messageInfo_ResponseEcho proto.InternalMessageInfo 1566 1567 func (m *ResponseEcho) GetMessage() string { 1568 if m != nil { 1569 return m.Message 1570 } 1571 return "" 1572 } 1573 1574 type ResponseFlush struct { 1575 } 1576 1577 func (m *ResponseFlush) Reset() { *m = ResponseFlush{} } 1578 func (m *ResponseFlush) String() string { return proto.CompactTextString(m) } 1579 func (*ResponseFlush) ProtoMessage() {} 1580 func (*ResponseFlush) Descriptor() ([]byte, []int) { 1581 return fileDescriptor_252557cfdd89a31a, []int{19} 1582 } 1583 func (m *ResponseFlush) XXX_Unmarshal(b []byte) error { 1584 return m.Unmarshal(b) 1585 } 1586 func (m *ResponseFlush) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1587 if deterministic { 1588 return xxx_messageInfo_ResponseFlush.Marshal(b, m, deterministic) 1589 } else { 1590 b = b[:cap(b)] 1591 n, err := m.MarshalToSizedBuffer(b) 1592 if err != nil { 1593 return nil, err 1594 } 1595 return b[:n], nil 1596 } 1597 } 1598 func (m *ResponseFlush) XXX_Merge(src proto.Message) { 1599 xxx_messageInfo_ResponseFlush.Merge(m, src) 1600 } 1601 func (m *ResponseFlush) XXX_Size() int { 1602 return m.Size() 1603 } 1604 func (m *ResponseFlush) XXX_DiscardUnknown() { 1605 xxx_messageInfo_ResponseFlush.DiscardUnknown(m) 1606 } 1607 1608 var xxx_messageInfo_ResponseFlush proto.InternalMessageInfo 1609 1610 type ResponseInfo struct { 1611 Data string `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"` 1612 Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` 1613 AppVersion uint64 `protobuf:"varint,3,opt,name=app_version,json=appVersion,proto3" json:"app_version,omitempty"` 1614 LastBlockHeight int64 `protobuf:"varint,4,opt,name=last_block_height,json=lastBlockHeight,proto3" json:"last_block_height,omitempty"` 1615 LastBlockAppHash []byte `protobuf:"bytes,5,opt,name=last_block_app_hash,json=lastBlockAppHash,proto3" json:"last_block_app_hash,omitempty"` 1616 } 1617 1618 func (m *ResponseInfo) Reset() { *m = ResponseInfo{} } 1619 func (m *ResponseInfo) String() string { return proto.CompactTextString(m) } 1620 func (*ResponseInfo) ProtoMessage() {} 1621 func (*ResponseInfo) Descriptor() ([]byte, []int) { 1622 return fileDescriptor_252557cfdd89a31a, []int{20} 1623 } 1624 func (m *ResponseInfo) XXX_Unmarshal(b []byte) error { 1625 return m.Unmarshal(b) 1626 } 1627 func (m *ResponseInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1628 if deterministic { 1629 return xxx_messageInfo_ResponseInfo.Marshal(b, m, deterministic) 1630 } else { 1631 b = b[:cap(b)] 1632 n, err := m.MarshalToSizedBuffer(b) 1633 if err != nil { 1634 return nil, err 1635 } 1636 return b[:n], nil 1637 } 1638 } 1639 func (m *ResponseInfo) XXX_Merge(src proto.Message) { 1640 xxx_messageInfo_ResponseInfo.Merge(m, src) 1641 } 1642 func (m *ResponseInfo) XXX_Size() int { 1643 return m.Size() 1644 } 1645 func (m *ResponseInfo) XXX_DiscardUnknown() { 1646 xxx_messageInfo_ResponseInfo.DiscardUnknown(m) 1647 } 1648 1649 var xxx_messageInfo_ResponseInfo proto.InternalMessageInfo 1650 1651 func (m *ResponseInfo) GetData() string { 1652 if m != nil { 1653 return m.Data 1654 } 1655 return "" 1656 } 1657 1658 func (m *ResponseInfo) GetVersion() string { 1659 if m != nil { 1660 return m.Version 1661 } 1662 return "" 1663 } 1664 1665 func (m *ResponseInfo) GetAppVersion() uint64 { 1666 if m != nil { 1667 return m.AppVersion 1668 } 1669 return 0 1670 } 1671 1672 func (m *ResponseInfo) GetLastBlockHeight() int64 { 1673 if m != nil { 1674 return m.LastBlockHeight 1675 } 1676 return 0 1677 } 1678 1679 func (m *ResponseInfo) GetLastBlockAppHash() []byte { 1680 if m != nil { 1681 return m.LastBlockAppHash 1682 } 1683 return nil 1684 } 1685 1686 // nondeterministic 1687 type ResponseSetOption struct { 1688 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1689 // bytes data = 2; 1690 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1691 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1692 } 1693 1694 func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} } 1695 func (m *ResponseSetOption) String() string { return proto.CompactTextString(m) } 1696 func (*ResponseSetOption) ProtoMessage() {} 1697 func (*ResponseSetOption) Descriptor() ([]byte, []int) { 1698 return fileDescriptor_252557cfdd89a31a, []int{21} 1699 } 1700 func (m *ResponseSetOption) XXX_Unmarshal(b []byte) error { 1701 return m.Unmarshal(b) 1702 } 1703 func (m *ResponseSetOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1704 if deterministic { 1705 return xxx_messageInfo_ResponseSetOption.Marshal(b, m, deterministic) 1706 } else { 1707 b = b[:cap(b)] 1708 n, err := m.MarshalToSizedBuffer(b) 1709 if err != nil { 1710 return nil, err 1711 } 1712 return b[:n], nil 1713 } 1714 } 1715 func (m *ResponseSetOption) XXX_Merge(src proto.Message) { 1716 xxx_messageInfo_ResponseSetOption.Merge(m, src) 1717 } 1718 func (m *ResponseSetOption) XXX_Size() int { 1719 return m.Size() 1720 } 1721 func (m *ResponseSetOption) XXX_DiscardUnknown() { 1722 xxx_messageInfo_ResponseSetOption.DiscardUnknown(m) 1723 } 1724 1725 var xxx_messageInfo_ResponseSetOption proto.InternalMessageInfo 1726 1727 func (m *ResponseSetOption) GetCode() uint32 { 1728 if m != nil { 1729 return m.Code 1730 } 1731 return 0 1732 } 1733 1734 func (m *ResponseSetOption) GetLog() string { 1735 if m != nil { 1736 return m.Log 1737 } 1738 return "" 1739 } 1740 1741 func (m *ResponseSetOption) GetInfo() string { 1742 if m != nil { 1743 return m.Info 1744 } 1745 return "" 1746 } 1747 1748 type ResponseInitChain struct { 1749 ConsensusParams *ConsensusParams `protobuf:"bytes,1,opt,name=consensus_params,json=consensusParams,proto3" json:"consensus_params,omitempty"` 1750 Validators []ValidatorUpdate `protobuf:"bytes,2,rep,name=validators,proto3" json:"validators"` 1751 AppHash []byte `protobuf:"bytes,3,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"` 1752 } 1753 1754 func (m *ResponseInitChain) Reset() { *m = ResponseInitChain{} } 1755 func (m *ResponseInitChain) String() string { return proto.CompactTextString(m) } 1756 func (*ResponseInitChain) ProtoMessage() {} 1757 func (*ResponseInitChain) Descriptor() ([]byte, []int) { 1758 return fileDescriptor_252557cfdd89a31a, []int{22} 1759 } 1760 func (m *ResponseInitChain) XXX_Unmarshal(b []byte) error { 1761 return m.Unmarshal(b) 1762 } 1763 func (m *ResponseInitChain) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1764 if deterministic { 1765 return xxx_messageInfo_ResponseInitChain.Marshal(b, m, deterministic) 1766 } else { 1767 b = b[:cap(b)] 1768 n, err := m.MarshalToSizedBuffer(b) 1769 if err != nil { 1770 return nil, err 1771 } 1772 return b[:n], nil 1773 } 1774 } 1775 func (m *ResponseInitChain) XXX_Merge(src proto.Message) { 1776 xxx_messageInfo_ResponseInitChain.Merge(m, src) 1777 } 1778 func (m *ResponseInitChain) XXX_Size() int { 1779 return m.Size() 1780 } 1781 func (m *ResponseInitChain) XXX_DiscardUnknown() { 1782 xxx_messageInfo_ResponseInitChain.DiscardUnknown(m) 1783 } 1784 1785 var xxx_messageInfo_ResponseInitChain proto.InternalMessageInfo 1786 1787 func (m *ResponseInitChain) GetConsensusParams() *ConsensusParams { 1788 if m != nil { 1789 return m.ConsensusParams 1790 } 1791 return nil 1792 } 1793 1794 func (m *ResponseInitChain) GetValidators() []ValidatorUpdate { 1795 if m != nil { 1796 return m.Validators 1797 } 1798 return nil 1799 } 1800 1801 func (m *ResponseInitChain) GetAppHash() []byte { 1802 if m != nil { 1803 return m.AppHash 1804 } 1805 return nil 1806 } 1807 1808 type ResponseQuery struct { 1809 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1810 // bytes data = 2; // use "value" instead. 1811 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1812 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1813 Index int64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"` 1814 Key []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"` 1815 Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"` 1816 ProofOps *crypto.ProofOps `protobuf:"bytes,8,opt,name=proof_ops,json=proofOps,proto3" json:"proof_ops,omitempty"` 1817 Height int64 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"` 1818 Codespace string `protobuf:"bytes,10,opt,name=codespace,proto3" json:"codespace,omitempty"` 1819 } 1820 1821 func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } 1822 func (m *ResponseQuery) String() string { return proto.CompactTextString(m) } 1823 func (*ResponseQuery) ProtoMessage() {} 1824 func (*ResponseQuery) Descriptor() ([]byte, []int) { 1825 return fileDescriptor_252557cfdd89a31a, []int{23} 1826 } 1827 func (m *ResponseQuery) XXX_Unmarshal(b []byte) error { 1828 return m.Unmarshal(b) 1829 } 1830 func (m *ResponseQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1831 if deterministic { 1832 return xxx_messageInfo_ResponseQuery.Marshal(b, m, deterministic) 1833 } else { 1834 b = b[:cap(b)] 1835 n, err := m.MarshalToSizedBuffer(b) 1836 if err != nil { 1837 return nil, err 1838 } 1839 return b[:n], nil 1840 } 1841 } 1842 func (m *ResponseQuery) XXX_Merge(src proto.Message) { 1843 xxx_messageInfo_ResponseQuery.Merge(m, src) 1844 } 1845 func (m *ResponseQuery) XXX_Size() int { 1846 return m.Size() 1847 } 1848 func (m *ResponseQuery) XXX_DiscardUnknown() { 1849 xxx_messageInfo_ResponseQuery.DiscardUnknown(m) 1850 } 1851 1852 var xxx_messageInfo_ResponseQuery proto.InternalMessageInfo 1853 1854 func (m *ResponseQuery) GetCode() uint32 { 1855 if m != nil { 1856 return m.Code 1857 } 1858 return 0 1859 } 1860 1861 func (m *ResponseQuery) GetLog() string { 1862 if m != nil { 1863 return m.Log 1864 } 1865 return "" 1866 } 1867 1868 func (m *ResponseQuery) GetInfo() string { 1869 if m != nil { 1870 return m.Info 1871 } 1872 return "" 1873 } 1874 1875 func (m *ResponseQuery) GetIndex() int64 { 1876 if m != nil { 1877 return m.Index 1878 } 1879 return 0 1880 } 1881 1882 func (m *ResponseQuery) GetKey() []byte { 1883 if m != nil { 1884 return m.Key 1885 } 1886 return nil 1887 } 1888 1889 func (m *ResponseQuery) GetValue() []byte { 1890 if m != nil { 1891 return m.Value 1892 } 1893 return nil 1894 } 1895 1896 func (m *ResponseQuery) GetProofOps() *crypto.ProofOps { 1897 if m != nil { 1898 return m.ProofOps 1899 } 1900 return nil 1901 } 1902 1903 func (m *ResponseQuery) GetHeight() int64 { 1904 if m != nil { 1905 return m.Height 1906 } 1907 return 0 1908 } 1909 1910 func (m *ResponseQuery) GetCodespace() string { 1911 if m != nil { 1912 return m.Codespace 1913 } 1914 return "" 1915 } 1916 1917 type ResponseBeginBlock struct { 1918 Events []Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` 1919 } 1920 1921 func (m *ResponseBeginBlock) Reset() { *m = ResponseBeginBlock{} } 1922 func (m *ResponseBeginBlock) String() string { return proto.CompactTextString(m) } 1923 func (*ResponseBeginBlock) ProtoMessage() {} 1924 func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { 1925 return fileDescriptor_252557cfdd89a31a, []int{24} 1926 } 1927 func (m *ResponseBeginBlock) XXX_Unmarshal(b []byte) error { 1928 return m.Unmarshal(b) 1929 } 1930 func (m *ResponseBeginBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1931 if deterministic { 1932 return xxx_messageInfo_ResponseBeginBlock.Marshal(b, m, deterministic) 1933 } else { 1934 b = b[:cap(b)] 1935 n, err := m.MarshalToSizedBuffer(b) 1936 if err != nil { 1937 return nil, err 1938 } 1939 return b[:n], nil 1940 } 1941 } 1942 func (m *ResponseBeginBlock) XXX_Merge(src proto.Message) { 1943 xxx_messageInfo_ResponseBeginBlock.Merge(m, src) 1944 } 1945 func (m *ResponseBeginBlock) XXX_Size() int { 1946 return m.Size() 1947 } 1948 func (m *ResponseBeginBlock) XXX_DiscardUnknown() { 1949 xxx_messageInfo_ResponseBeginBlock.DiscardUnknown(m) 1950 } 1951 1952 var xxx_messageInfo_ResponseBeginBlock proto.InternalMessageInfo 1953 1954 func (m *ResponseBeginBlock) GetEvents() []Event { 1955 if m != nil { 1956 return m.Events 1957 } 1958 return nil 1959 } 1960 1961 type ResponseCheckTx struct { 1962 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 1963 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 1964 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 1965 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 1966 GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,proto3" json:"gas_wanted,omitempty"` 1967 GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,proto3" json:"gas_used,omitempty"` 1968 Events []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"` 1969 Codespace string `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"` 1970 } 1971 1972 func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } 1973 func (m *ResponseCheckTx) String() string { return proto.CompactTextString(m) } 1974 func (*ResponseCheckTx) ProtoMessage() {} 1975 func (*ResponseCheckTx) Descriptor() ([]byte, []int) { 1976 return fileDescriptor_252557cfdd89a31a, []int{25} 1977 } 1978 func (m *ResponseCheckTx) XXX_Unmarshal(b []byte) error { 1979 return m.Unmarshal(b) 1980 } 1981 func (m *ResponseCheckTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 1982 if deterministic { 1983 return xxx_messageInfo_ResponseCheckTx.Marshal(b, m, deterministic) 1984 } else { 1985 b = b[:cap(b)] 1986 n, err := m.MarshalToSizedBuffer(b) 1987 if err != nil { 1988 return nil, err 1989 } 1990 return b[:n], nil 1991 } 1992 } 1993 func (m *ResponseCheckTx) XXX_Merge(src proto.Message) { 1994 xxx_messageInfo_ResponseCheckTx.Merge(m, src) 1995 } 1996 func (m *ResponseCheckTx) XXX_Size() int { 1997 return m.Size() 1998 } 1999 func (m *ResponseCheckTx) XXX_DiscardUnknown() { 2000 xxx_messageInfo_ResponseCheckTx.DiscardUnknown(m) 2001 } 2002 2003 var xxx_messageInfo_ResponseCheckTx proto.InternalMessageInfo 2004 2005 func (m *ResponseCheckTx) GetCode() uint32 { 2006 if m != nil { 2007 return m.Code 2008 } 2009 return 0 2010 } 2011 2012 func (m *ResponseCheckTx) GetData() []byte { 2013 if m != nil { 2014 return m.Data 2015 } 2016 return nil 2017 } 2018 2019 func (m *ResponseCheckTx) GetLog() string { 2020 if m != nil { 2021 return m.Log 2022 } 2023 return "" 2024 } 2025 2026 func (m *ResponseCheckTx) GetInfo() string { 2027 if m != nil { 2028 return m.Info 2029 } 2030 return "" 2031 } 2032 2033 func (m *ResponseCheckTx) GetGasWanted() int64 { 2034 if m != nil { 2035 return m.GasWanted 2036 } 2037 return 0 2038 } 2039 2040 func (m *ResponseCheckTx) GetGasUsed() int64 { 2041 if m != nil { 2042 return m.GasUsed 2043 } 2044 return 0 2045 } 2046 2047 func (m *ResponseCheckTx) GetEvents() []Event { 2048 if m != nil { 2049 return m.Events 2050 } 2051 return nil 2052 } 2053 2054 func (m *ResponseCheckTx) GetCodespace() string { 2055 if m != nil { 2056 return m.Codespace 2057 } 2058 return "" 2059 } 2060 2061 type ResponseDeliverTx struct { 2062 Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` 2063 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 2064 Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` 2065 Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"` 2066 GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,proto3" json:"gas_wanted,omitempty"` 2067 GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,proto3" json:"gas_used,omitempty"` 2068 Events []Event `protobuf:"bytes,7,rep,name=events,proto3" json:"events,omitempty"` 2069 Codespace string `protobuf:"bytes,8,opt,name=codespace,proto3" json:"codespace,omitempty"` 2070 } 2071 2072 func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } 2073 func (m *ResponseDeliverTx) String() string { return proto.CompactTextString(m) } 2074 func (*ResponseDeliverTx) ProtoMessage() {} 2075 func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { 2076 return fileDescriptor_252557cfdd89a31a, []int{26} 2077 } 2078 func (m *ResponseDeliverTx) XXX_Unmarshal(b []byte) error { 2079 return m.Unmarshal(b) 2080 } 2081 func (m *ResponseDeliverTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2082 if deterministic { 2083 return xxx_messageInfo_ResponseDeliverTx.Marshal(b, m, deterministic) 2084 } else { 2085 b = b[:cap(b)] 2086 n, err := m.MarshalToSizedBuffer(b) 2087 if err != nil { 2088 return nil, err 2089 } 2090 return b[:n], nil 2091 } 2092 } 2093 func (m *ResponseDeliverTx) XXX_Merge(src proto.Message) { 2094 xxx_messageInfo_ResponseDeliverTx.Merge(m, src) 2095 } 2096 func (m *ResponseDeliverTx) XXX_Size() int { 2097 return m.Size() 2098 } 2099 func (m *ResponseDeliverTx) XXX_DiscardUnknown() { 2100 xxx_messageInfo_ResponseDeliverTx.DiscardUnknown(m) 2101 } 2102 2103 var xxx_messageInfo_ResponseDeliverTx proto.InternalMessageInfo 2104 2105 func (m *ResponseDeliverTx) GetCode() uint32 { 2106 if m != nil { 2107 return m.Code 2108 } 2109 return 0 2110 } 2111 2112 func (m *ResponseDeliverTx) GetData() []byte { 2113 if m != nil { 2114 return m.Data 2115 } 2116 return nil 2117 } 2118 2119 func (m *ResponseDeliverTx) GetLog() string { 2120 if m != nil { 2121 return m.Log 2122 } 2123 return "" 2124 } 2125 2126 func (m *ResponseDeliverTx) GetInfo() string { 2127 if m != nil { 2128 return m.Info 2129 } 2130 return "" 2131 } 2132 2133 func (m *ResponseDeliverTx) GetGasWanted() int64 { 2134 if m != nil { 2135 return m.GasWanted 2136 } 2137 return 0 2138 } 2139 2140 func (m *ResponseDeliverTx) GetGasUsed() int64 { 2141 if m != nil { 2142 return m.GasUsed 2143 } 2144 return 0 2145 } 2146 2147 func (m *ResponseDeliverTx) GetEvents() []Event { 2148 if m != nil { 2149 return m.Events 2150 } 2151 return nil 2152 } 2153 2154 func (m *ResponseDeliverTx) GetCodespace() string { 2155 if m != nil { 2156 return m.Codespace 2157 } 2158 return "" 2159 } 2160 2161 type ResponseEndBlock struct { 2162 ValidatorUpdates []ValidatorUpdate `protobuf:"bytes,1,rep,name=validator_updates,json=validatorUpdates,proto3" json:"validator_updates"` 2163 ConsensusParamUpdates *ConsensusParams `protobuf:"bytes,2,opt,name=consensus_param_updates,json=consensusParamUpdates,proto3" json:"consensus_param_updates,omitempty"` 2164 Events []Event `protobuf:"bytes,3,rep,name=events,proto3" json:"events,omitempty"` 2165 } 2166 2167 func (m *ResponseEndBlock) Reset() { *m = ResponseEndBlock{} } 2168 func (m *ResponseEndBlock) String() string { return proto.CompactTextString(m) } 2169 func (*ResponseEndBlock) ProtoMessage() {} 2170 func (*ResponseEndBlock) Descriptor() ([]byte, []int) { 2171 return fileDescriptor_252557cfdd89a31a, []int{27} 2172 } 2173 func (m *ResponseEndBlock) XXX_Unmarshal(b []byte) error { 2174 return m.Unmarshal(b) 2175 } 2176 func (m *ResponseEndBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2177 if deterministic { 2178 return xxx_messageInfo_ResponseEndBlock.Marshal(b, m, deterministic) 2179 } else { 2180 b = b[:cap(b)] 2181 n, err := m.MarshalToSizedBuffer(b) 2182 if err != nil { 2183 return nil, err 2184 } 2185 return b[:n], nil 2186 } 2187 } 2188 func (m *ResponseEndBlock) XXX_Merge(src proto.Message) { 2189 xxx_messageInfo_ResponseEndBlock.Merge(m, src) 2190 } 2191 func (m *ResponseEndBlock) XXX_Size() int { 2192 return m.Size() 2193 } 2194 func (m *ResponseEndBlock) XXX_DiscardUnknown() { 2195 xxx_messageInfo_ResponseEndBlock.DiscardUnknown(m) 2196 } 2197 2198 var xxx_messageInfo_ResponseEndBlock proto.InternalMessageInfo 2199 2200 func (m *ResponseEndBlock) GetValidatorUpdates() []ValidatorUpdate { 2201 if m != nil { 2202 return m.ValidatorUpdates 2203 } 2204 return nil 2205 } 2206 2207 func (m *ResponseEndBlock) GetConsensusParamUpdates() *ConsensusParams { 2208 if m != nil { 2209 return m.ConsensusParamUpdates 2210 } 2211 return nil 2212 } 2213 2214 func (m *ResponseEndBlock) GetEvents() []Event { 2215 if m != nil { 2216 return m.Events 2217 } 2218 return nil 2219 } 2220 2221 type ResponseCommit struct { 2222 // reserve 1 2223 Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` 2224 RetainHeight int64 `protobuf:"varint,3,opt,name=retain_height,json=retainHeight,proto3" json:"retain_height,omitempty"` 2225 } 2226 2227 func (m *ResponseCommit) Reset() { *m = ResponseCommit{} } 2228 func (m *ResponseCommit) String() string { return proto.CompactTextString(m) } 2229 func (*ResponseCommit) ProtoMessage() {} 2230 func (*ResponseCommit) Descriptor() ([]byte, []int) { 2231 return fileDescriptor_252557cfdd89a31a, []int{28} 2232 } 2233 func (m *ResponseCommit) XXX_Unmarshal(b []byte) error { 2234 return m.Unmarshal(b) 2235 } 2236 func (m *ResponseCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2237 if deterministic { 2238 return xxx_messageInfo_ResponseCommit.Marshal(b, m, deterministic) 2239 } else { 2240 b = b[:cap(b)] 2241 n, err := m.MarshalToSizedBuffer(b) 2242 if err != nil { 2243 return nil, err 2244 } 2245 return b[:n], nil 2246 } 2247 } 2248 func (m *ResponseCommit) XXX_Merge(src proto.Message) { 2249 xxx_messageInfo_ResponseCommit.Merge(m, src) 2250 } 2251 func (m *ResponseCommit) XXX_Size() int { 2252 return m.Size() 2253 } 2254 func (m *ResponseCommit) XXX_DiscardUnknown() { 2255 xxx_messageInfo_ResponseCommit.DiscardUnknown(m) 2256 } 2257 2258 var xxx_messageInfo_ResponseCommit proto.InternalMessageInfo 2259 2260 func (m *ResponseCommit) GetData() []byte { 2261 if m != nil { 2262 return m.Data 2263 } 2264 return nil 2265 } 2266 2267 func (m *ResponseCommit) GetRetainHeight() int64 { 2268 if m != nil { 2269 return m.RetainHeight 2270 } 2271 return 0 2272 } 2273 2274 type ResponseListSnapshots struct { 2275 Snapshots []*Snapshot `protobuf:"bytes,1,rep,name=snapshots,proto3" json:"snapshots,omitempty"` 2276 } 2277 2278 func (m *ResponseListSnapshots) Reset() { *m = ResponseListSnapshots{} } 2279 func (m *ResponseListSnapshots) String() string { return proto.CompactTextString(m) } 2280 func (*ResponseListSnapshots) ProtoMessage() {} 2281 func (*ResponseListSnapshots) Descriptor() ([]byte, []int) { 2282 return fileDescriptor_252557cfdd89a31a, []int{29} 2283 } 2284 func (m *ResponseListSnapshots) XXX_Unmarshal(b []byte) error { 2285 return m.Unmarshal(b) 2286 } 2287 func (m *ResponseListSnapshots) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2288 if deterministic { 2289 return xxx_messageInfo_ResponseListSnapshots.Marshal(b, m, deterministic) 2290 } else { 2291 b = b[:cap(b)] 2292 n, err := m.MarshalToSizedBuffer(b) 2293 if err != nil { 2294 return nil, err 2295 } 2296 return b[:n], nil 2297 } 2298 } 2299 func (m *ResponseListSnapshots) XXX_Merge(src proto.Message) { 2300 xxx_messageInfo_ResponseListSnapshots.Merge(m, src) 2301 } 2302 func (m *ResponseListSnapshots) XXX_Size() int { 2303 return m.Size() 2304 } 2305 func (m *ResponseListSnapshots) XXX_DiscardUnknown() { 2306 xxx_messageInfo_ResponseListSnapshots.DiscardUnknown(m) 2307 } 2308 2309 var xxx_messageInfo_ResponseListSnapshots proto.InternalMessageInfo 2310 2311 func (m *ResponseListSnapshots) GetSnapshots() []*Snapshot { 2312 if m != nil { 2313 return m.Snapshots 2314 } 2315 return nil 2316 } 2317 2318 type ResponseOfferSnapshot struct { 2319 Result ResponseOfferSnapshot_Result `protobuf:"varint,1,opt,name=result,proto3,enum=tendermint.abci.ResponseOfferSnapshot_Result" json:"result,omitempty"` 2320 } 2321 2322 func (m *ResponseOfferSnapshot) Reset() { *m = ResponseOfferSnapshot{} } 2323 func (m *ResponseOfferSnapshot) String() string { return proto.CompactTextString(m) } 2324 func (*ResponseOfferSnapshot) ProtoMessage() {} 2325 func (*ResponseOfferSnapshot) Descriptor() ([]byte, []int) { 2326 return fileDescriptor_252557cfdd89a31a, []int{30} 2327 } 2328 func (m *ResponseOfferSnapshot) XXX_Unmarshal(b []byte) error { 2329 return m.Unmarshal(b) 2330 } 2331 func (m *ResponseOfferSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2332 if deterministic { 2333 return xxx_messageInfo_ResponseOfferSnapshot.Marshal(b, m, deterministic) 2334 } else { 2335 b = b[:cap(b)] 2336 n, err := m.MarshalToSizedBuffer(b) 2337 if err != nil { 2338 return nil, err 2339 } 2340 return b[:n], nil 2341 } 2342 } 2343 func (m *ResponseOfferSnapshot) XXX_Merge(src proto.Message) { 2344 xxx_messageInfo_ResponseOfferSnapshot.Merge(m, src) 2345 } 2346 func (m *ResponseOfferSnapshot) XXX_Size() int { 2347 return m.Size() 2348 } 2349 func (m *ResponseOfferSnapshot) XXX_DiscardUnknown() { 2350 xxx_messageInfo_ResponseOfferSnapshot.DiscardUnknown(m) 2351 } 2352 2353 var xxx_messageInfo_ResponseOfferSnapshot proto.InternalMessageInfo 2354 2355 func (m *ResponseOfferSnapshot) GetResult() ResponseOfferSnapshot_Result { 2356 if m != nil { 2357 return m.Result 2358 } 2359 return ResponseOfferSnapshot_UNKNOWN 2360 } 2361 2362 type ResponseLoadSnapshotChunk struct { 2363 Chunk []byte `protobuf:"bytes,1,opt,name=chunk,proto3" json:"chunk,omitempty"` 2364 } 2365 2366 func (m *ResponseLoadSnapshotChunk) Reset() { *m = ResponseLoadSnapshotChunk{} } 2367 func (m *ResponseLoadSnapshotChunk) String() string { return proto.CompactTextString(m) } 2368 func (*ResponseLoadSnapshotChunk) ProtoMessage() {} 2369 func (*ResponseLoadSnapshotChunk) Descriptor() ([]byte, []int) { 2370 return fileDescriptor_252557cfdd89a31a, []int{31} 2371 } 2372 func (m *ResponseLoadSnapshotChunk) XXX_Unmarshal(b []byte) error { 2373 return m.Unmarshal(b) 2374 } 2375 func (m *ResponseLoadSnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2376 if deterministic { 2377 return xxx_messageInfo_ResponseLoadSnapshotChunk.Marshal(b, m, deterministic) 2378 } else { 2379 b = b[:cap(b)] 2380 n, err := m.MarshalToSizedBuffer(b) 2381 if err != nil { 2382 return nil, err 2383 } 2384 return b[:n], nil 2385 } 2386 } 2387 func (m *ResponseLoadSnapshotChunk) XXX_Merge(src proto.Message) { 2388 xxx_messageInfo_ResponseLoadSnapshotChunk.Merge(m, src) 2389 } 2390 func (m *ResponseLoadSnapshotChunk) XXX_Size() int { 2391 return m.Size() 2392 } 2393 func (m *ResponseLoadSnapshotChunk) XXX_DiscardUnknown() { 2394 xxx_messageInfo_ResponseLoadSnapshotChunk.DiscardUnknown(m) 2395 } 2396 2397 var xxx_messageInfo_ResponseLoadSnapshotChunk proto.InternalMessageInfo 2398 2399 func (m *ResponseLoadSnapshotChunk) GetChunk() []byte { 2400 if m != nil { 2401 return m.Chunk 2402 } 2403 return nil 2404 } 2405 2406 type ResponseApplySnapshotChunk struct { 2407 Result ResponseApplySnapshotChunk_Result `protobuf:"varint,1,opt,name=result,proto3,enum=tendermint.abci.ResponseApplySnapshotChunk_Result" json:"result,omitempty"` 2408 RefetchChunks []uint32 `protobuf:"varint,2,rep,packed,name=refetch_chunks,json=refetchChunks,proto3" json:"refetch_chunks,omitempty"` 2409 RejectSenders []string `protobuf:"bytes,3,rep,name=reject_senders,json=rejectSenders,proto3" json:"reject_senders,omitempty"` 2410 } 2411 2412 func (m *ResponseApplySnapshotChunk) Reset() { *m = ResponseApplySnapshotChunk{} } 2413 func (m *ResponseApplySnapshotChunk) String() string { return proto.CompactTextString(m) } 2414 func (*ResponseApplySnapshotChunk) ProtoMessage() {} 2415 func (*ResponseApplySnapshotChunk) Descriptor() ([]byte, []int) { 2416 return fileDescriptor_252557cfdd89a31a, []int{32} 2417 } 2418 func (m *ResponseApplySnapshotChunk) XXX_Unmarshal(b []byte) error { 2419 return m.Unmarshal(b) 2420 } 2421 func (m *ResponseApplySnapshotChunk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2422 if deterministic { 2423 return xxx_messageInfo_ResponseApplySnapshotChunk.Marshal(b, m, deterministic) 2424 } else { 2425 b = b[:cap(b)] 2426 n, err := m.MarshalToSizedBuffer(b) 2427 if err != nil { 2428 return nil, err 2429 } 2430 return b[:n], nil 2431 } 2432 } 2433 func (m *ResponseApplySnapshotChunk) XXX_Merge(src proto.Message) { 2434 xxx_messageInfo_ResponseApplySnapshotChunk.Merge(m, src) 2435 } 2436 func (m *ResponseApplySnapshotChunk) XXX_Size() int { 2437 return m.Size() 2438 } 2439 func (m *ResponseApplySnapshotChunk) XXX_DiscardUnknown() { 2440 xxx_messageInfo_ResponseApplySnapshotChunk.DiscardUnknown(m) 2441 } 2442 2443 var xxx_messageInfo_ResponseApplySnapshotChunk proto.InternalMessageInfo 2444 2445 func (m *ResponseApplySnapshotChunk) GetResult() ResponseApplySnapshotChunk_Result { 2446 if m != nil { 2447 return m.Result 2448 } 2449 return ResponseApplySnapshotChunk_UNKNOWN 2450 } 2451 2452 func (m *ResponseApplySnapshotChunk) GetRefetchChunks() []uint32 { 2453 if m != nil { 2454 return m.RefetchChunks 2455 } 2456 return nil 2457 } 2458 2459 func (m *ResponseApplySnapshotChunk) GetRejectSenders() []string { 2460 if m != nil { 2461 return m.RejectSenders 2462 } 2463 return nil 2464 } 2465 2466 // ConsensusParams contains all consensus-relevant parameters 2467 // that can be adjusted by the abci app 2468 type ConsensusParams struct { 2469 Block *BlockParams `protobuf:"bytes,1,opt,name=block,proto3" json:"block,omitempty"` 2470 Evidence *types1.EvidenceParams `protobuf:"bytes,2,opt,name=evidence,proto3" json:"evidence,omitempty"` 2471 Validator *types1.ValidatorParams `protobuf:"bytes,3,opt,name=validator,proto3" json:"validator,omitempty"` 2472 Version *types1.VersionParams `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"` 2473 } 2474 2475 func (m *ConsensusParams) Reset() { *m = ConsensusParams{} } 2476 func (m *ConsensusParams) String() string { return proto.CompactTextString(m) } 2477 func (*ConsensusParams) ProtoMessage() {} 2478 func (*ConsensusParams) Descriptor() ([]byte, []int) { 2479 return fileDescriptor_252557cfdd89a31a, []int{33} 2480 } 2481 func (m *ConsensusParams) XXX_Unmarshal(b []byte) error { 2482 return m.Unmarshal(b) 2483 } 2484 func (m *ConsensusParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2485 if deterministic { 2486 return xxx_messageInfo_ConsensusParams.Marshal(b, m, deterministic) 2487 } else { 2488 b = b[:cap(b)] 2489 n, err := m.MarshalToSizedBuffer(b) 2490 if err != nil { 2491 return nil, err 2492 } 2493 return b[:n], nil 2494 } 2495 } 2496 func (m *ConsensusParams) XXX_Merge(src proto.Message) { 2497 xxx_messageInfo_ConsensusParams.Merge(m, src) 2498 } 2499 func (m *ConsensusParams) XXX_Size() int { 2500 return m.Size() 2501 } 2502 func (m *ConsensusParams) XXX_DiscardUnknown() { 2503 xxx_messageInfo_ConsensusParams.DiscardUnknown(m) 2504 } 2505 2506 var xxx_messageInfo_ConsensusParams proto.InternalMessageInfo 2507 2508 func (m *ConsensusParams) GetBlock() *BlockParams { 2509 if m != nil { 2510 return m.Block 2511 } 2512 return nil 2513 } 2514 2515 func (m *ConsensusParams) GetEvidence() *types1.EvidenceParams { 2516 if m != nil { 2517 return m.Evidence 2518 } 2519 return nil 2520 } 2521 2522 func (m *ConsensusParams) GetValidator() *types1.ValidatorParams { 2523 if m != nil { 2524 return m.Validator 2525 } 2526 return nil 2527 } 2528 2529 func (m *ConsensusParams) GetVersion() *types1.VersionParams { 2530 if m != nil { 2531 return m.Version 2532 } 2533 return nil 2534 } 2535 2536 // BlockParams contains limits on the block size. 2537 type BlockParams struct { 2538 // Note: must be greater than 0 2539 MaxBytes int64 `protobuf:"varint,1,opt,name=max_bytes,json=maxBytes,proto3" json:"max_bytes,omitempty"` 2540 // Note: must be greater or equal to -1 2541 MaxGas int64 `protobuf:"varint,2,opt,name=max_gas,json=maxGas,proto3" json:"max_gas,omitempty"` 2542 } 2543 2544 func (m *BlockParams) Reset() { *m = BlockParams{} } 2545 func (m *BlockParams) String() string { return proto.CompactTextString(m) } 2546 func (*BlockParams) ProtoMessage() {} 2547 func (*BlockParams) Descriptor() ([]byte, []int) { 2548 return fileDescriptor_252557cfdd89a31a, []int{34} 2549 } 2550 func (m *BlockParams) XXX_Unmarshal(b []byte) error { 2551 return m.Unmarshal(b) 2552 } 2553 func (m *BlockParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2554 if deterministic { 2555 return xxx_messageInfo_BlockParams.Marshal(b, m, deterministic) 2556 } else { 2557 b = b[:cap(b)] 2558 n, err := m.MarshalToSizedBuffer(b) 2559 if err != nil { 2560 return nil, err 2561 } 2562 return b[:n], nil 2563 } 2564 } 2565 func (m *BlockParams) XXX_Merge(src proto.Message) { 2566 xxx_messageInfo_BlockParams.Merge(m, src) 2567 } 2568 func (m *BlockParams) XXX_Size() int { 2569 return m.Size() 2570 } 2571 func (m *BlockParams) XXX_DiscardUnknown() { 2572 xxx_messageInfo_BlockParams.DiscardUnknown(m) 2573 } 2574 2575 var xxx_messageInfo_BlockParams proto.InternalMessageInfo 2576 2577 func (m *BlockParams) GetMaxBytes() int64 { 2578 if m != nil { 2579 return m.MaxBytes 2580 } 2581 return 0 2582 } 2583 2584 func (m *BlockParams) GetMaxGas() int64 { 2585 if m != nil { 2586 return m.MaxGas 2587 } 2588 return 0 2589 } 2590 2591 type LastCommitInfo struct { 2592 Round int32 `protobuf:"varint,1,opt,name=round,proto3" json:"round,omitempty"` 2593 Votes []VoteInfo `protobuf:"bytes,2,rep,name=votes,proto3" json:"votes"` 2594 } 2595 2596 func (m *LastCommitInfo) Reset() { *m = LastCommitInfo{} } 2597 func (m *LastCommitInfo) String() string { return proto.CompactTextString(m) } 2598 func (*LastCommitInfo) ProtoMessage() {} 2599 func (*LastCommitInfo) Descriptor() ([]byte, []int) { 2600 return fileDescriptor_252557cfdd89a31a, []int{35} 2601 } 2602 func (m *LastCommitInfo) XXX_Unmarshal(b []byte) error { 2603 return m.Unmarshal(b) 2604 } 2605 func (m *LastCommitInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2606 if deterministic { 2607 return xxx_messageInfo_LastCommitInfo.Marshal(b, m, deterministic) 2608 } else { 2609 b = b[:cap(b)] 2610 n, err := m.MarshalToSizedBuffer(b) 2611 if err != nil { 2612 return nil, err 2613 } 2614 return b[:n], nil 2615 } 2616 } 2617 func (m *LastCommitInfo) XXX_Merge(src proto.Message) { 2618 xxx_messageInfo_LastCommitInfo.Merge(m, src) 2619 } 2620 func (m *LastCommitInfo) XXX_Size() int { 2621 return m.Size() 2622 } 2623 func (m *LastCommitInfo) XXX_DiscardUnknown() { 2624 xxx_messageInfo_LastCommitInfo.DiscardUnknown(m) 2625 } 2626 2627 var xxx_messageInfo_LastCommitInfo proto.InternalMessageInfo 2628 2629 func (m *LastCommitInfo) GetRound() int32 { 2630 if m != nil { 2631 return m.Round 2632 } 2633 return 0 2634 } 2635 2636 func (m *LastCommitInfo) GetVotes() []VoteInfo { 2637 if m != nil { 2638 return m.Votes 2639 } 2640 return nil 2641 } 2642 2643 // Event allows application developers to attach additional information to 2644 // ResponseBeginBlock, ResponseEndBlock, ResponseCheckTx and ResponseDeliverTx. 2645 // Later, transactions may be queried using these events. 2646 type Event struct { 2647 Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` 2648 Attributes []EventAttribute `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"` 2649 } 2650 2651 func (m *Event) Reset() { *m = Event{} } 2652 func (m *Event) String() string { return proto.CompactTextString(m) } 2653 func (*Event) ProtoMessage() {} 2654 func (*Event) Descriptor() ([]byte, []int) { 2655 return fileDescriptor_252557cfdd89a31a, []int{36} 2656 } 2657 func (m *Event) XXX_Unmarshal(b []byte) error { 2658 return m.Unmarshal(b) 2659 } 2660 func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2661 if deterministic { 2662 return xxx_messageInfo_Event.Marshal(b, m, deterministic) 2663 } else { 2664 b = b[:cap(b)] 2665 n, err := m.MarshalToSizedBuffer(b) 2666 if err != nil { 2667 return nil, err 2668 } 2669 return b[:n], nil 2670 } 2671 } 2672 func (m *Event) XXX_Merge(src proto.Message) { 2673 xxx_messageInfo_Event.Merge(m, src) 2674 } 2675 func (m *Event) XXX_Size() int { 2676 return m.Size() 2677 } 2678 func (m *Event) XXX_DiscardUnknown() { 2679 xxx_messageInfo_Event.DiscardUnknown(m) 2680 } 2681 2682 var xxx_messageInfo_Event proto.InternalMessageInfo 2683 2684 func (m *Event) GetType() string { 2685 if m != nil { 2686 return m.Type 2687 } 2688 return "" 2689 } 2690 2691 func (m *Event) GetAttributes() []EventAttribute { 2692 if m != nil { 2693 return m.Attributes 2694 } 2695 return nil 2696 } 2697 2698 // EventAttribute is a single key-value pair, associated with an event. 2699 type EventAttribute struct { 2700 Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 2701 Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 2702 Index bool `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"` 2703 } 2704 2705 func (m *EventAttribute) Reset() { *m = EventAttribute{} } 2706 func (m *EventAttribute) String() string { return proto.CompactTextString(m) } 2707 func (*EventAttribute) ProtoMessage() {} 2708 func (*EventAttribute) Descriptor() ([]byte, []int) { 2709 return fileDescriptor_252557cfdd89a31a, []int{37} 2710 } 2711 func (m *EventAttribute) XXX_Unmarshal(b []byte) error { 2712 return m.Unmarshal(b) 2713 } 2714 func (m *EventAttribute) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2715 if deterministic { 2716 return xxx_messageInfo_EventAttribute.Marshal(b, m, deterministic) 2717 } else { 2718 b = b[:cap(b)] 2719 n, err := m.MarshalToSizedBuffer(b) 2720 if err != nil { 2721 return nil, err 2722 } 2723 return b[:n], nil 2724 } 2725 } 2726 func (m *EventAttribute) XXX_Merge(src proto.Message) { 2727 xxx_messageInfo_EventAttribute.Merge(m, src) 2728 } 2729 func (m *EventAttribute) XXX_Size() int { 2730 return m.Size() 2731 } 2732 func (m *EventAttribute) XXX_DiscardUnknown() { 2733 xxx_messageInfo_EventAttribute.DiscardUnknown(m) 2734 } 2735 2736 var xxx_messageInfo_EventAttribute proto.InternalMessageInfo 2737 2738 func (m *EventAttribute) GetKey() []byte { 2739 if m != nil { 2740 return m.Key 2741 } 2742 return nil 2743 } 2744 2745 func (m *EventAttribute) GetValue() []byte { 2746 if m != nil { 2747 return m.Value 2748 } 2749 return nil 2750 } 2751 2752 func (m *EventAttribute) GetIndex() bool { 2753 if m != nil { 2754 return m.Index 2755 } 2756 return false 2757 } 2758 2759 // TxResult contains results of executing the transaction. 2760 // 2761 // One usage is indexing transaction results. 2762 type TxResult struct { 2763 Height int64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` 2764 Index uint32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` 2765 Tx []byte `protobuf:"bytes,3,opt,name=tx,proto3" json:"tx,omitempty"` 2766 Result ResponseDeliverTx `protobuf:"bytes,4,opt,name=result,proto3" json:"result"` 2767 } 2768 2769 func (m *TxResult) Reset() { *m = TxResult{} } 2770 func (m *TxResult) String() string { return proto.CompactTextString(m) } 2771 func (*TxResult) ProtoMessage() {} 2772 func (*TxResult) Descriptor() ([]byte, []int) { 2773 return fileDescriptor_252557cfdd89a31a, []int{38} 2774 } 2775 func (m *TxResult) XXX_Unmarshal(b []byte) error { 2776 return m.Unmarshal(b) 2777 } 2778 func (m *TxResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2779 if deterministic { 2780 return xxx_messageInfo_TxResult.Marshal(b, m, deterministic) 2781 } else { 2782 b = b[:cap(b)] 2783 n, err := m.MarshalToSizedBuffer(b) 2784 if err != nil { 2785 return nil, err 2786 } 2787 return b[:n], nil 2788 } 2789 } 2790 func (m *TxResult) XXX_Merge(src proto.Message) { 2791 xxx_messageInfo_TxResult.Merge(m, src) 2792 } 2793 func (m *TxResult) XXX_Size() int { 2794 return m.Size() 2795 } 2796 func (m *TxResult) XXX_DiscardUnknown() { 2797 xxx_messageInfo_TxResult.DiscardUnknown(m) 2798 } 2799 2800 var xxx_messageInfo_TxResult proto.InternalMessageInfo 2801 2802 func (m *TxResult) GetHeight() int64 { 2803 if m != nil { 2804 return m.Height 2805 } 2806 return 0 2807 } 2808 2809 func (m *TxResult) GetIndex() uint32 { 2810 if m != nil { 2811 return m.Index 2812 } 2813 return 0 2814 } 2815 2816 func (m *TxResult) GetTx() []byte { 2817 if m != nil { 2818 return m.Tx 2819 } 2820 return nil 2821 } 2822 2823 func (m *TxResult) GetResult() ResponseDeliverTx { 2824 if m != nil { 2825 return m.Result 2826 } 2827 return ResponseDeliverTx{} 2828 } 2829 2830 // Validator 2831 type Validator struct { 2832 Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` 2833 // PubKey pub_key = 2 [(gogoproto.nullable)=false]; 2834 Power int64 `protobuf:"varint,3,opt,name=power,proto3" json:"power,omitempty"` 2835 } 2836 2837 func (m *Validator) Reset() { *m = Validator{} } 2838 func (m *Validator) String() string { return proto.CompactTextString(m) } 2839 func (*Validator) ProtoMessage() {} 2840 func (*Validator) Descriptor() ([]byte, []int) { 2841 return fileDescriptor_252557cfdd89a31a, []int{39} 2842 } 2843 func (m *Validator) XXX_Unmarshal(b []byte) error { 2844 return m.Unmarshal(b) 2845 } 2846 func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2847 if deterministic { 2848 return xxx_messageInfo_Validator.Marshal(b, m, deterministic) 2849 } else { 2850 b = b[:cap(b)] 2851 n, err := m.MarshalToSizedBuffer(b) 2852 if err != nil { 2853 return nil, err 2854 } 2855 return b[:n], nil 2856 } 2857 } 2858 func (m *Validator) XXX_Merge(src proto.Message) { 2859 xxx_messageInfo_Validator.Merge(m, src) 2860 } 2861 func (m *Validator) XXX_Size() int { 2862 return m.Size() 2863 } 2864 func (m *Validator) XXX_DiscardUnknown() { 2865 xxx_messageInfo_Validator.DiscardUnknown(m) 2866 } 2867 2868 var xxx_messageInfo_Validator proto.InternalMessageInfo 2869 2870 func (m *Validator) GetAddress() []byte { 2871 if m != nil { 2872 return m.Address 2873 } 2874 return nil 2875 } 2876 2877 func (m *Validator) GetPower() int64 { 2878 if m != nil { 2879 return m.Power 2880 } 2881 return 0 2882 } 2883 2884 // ValidatorUpdate 2885 type ValidatorUpdate struct { 2886 PubKey crypto.PublicKey `protobuf:"bytes,1,opt,name=pub_key,json=pubKey,proto3" json:"pub_key"` 2887 Power int64 `protobuf:"varint,2,opt,name=power,proto3" json:"power,omitempty"` 2888 } 2889 2890 func (m *ValidatorUpdate) Reset() { *m = ValidatorUpdate{} } 2891 func (m *ValidatorUpdate) String() string { return proto.CompactTextString(m) } 2892 func (*ValidatorUpdate) ProtoMessage() {} 2893 func (*ValidatorUpdate) Descriptor() ([]byte, []int) { 2894 return fileDescriptor_252557cfdd89a31a, []int{40} 2895 } 2896 func (m *ValidatorUpdate) XXX_Unmarshal(b []byte) error { 2897 return m.Unmarshal(b) 2898 } 2899 func (m *ValidatorUpdate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2900 if deterministic { 2901 return xxx_messageInfo_ValidatorUpdate.Marshal(b, m, deterministic) 2902 } else { 2903 b = b[:cap(b)] 2904 n, err := m.MarshalToSizedBuffer(b) 2905 if err != nil { 2906 return nil, err 2907 } 2908 return b[:n], nil 2909 } 2910 } 2911 func (m *ValidatorUpdate) XXX_Merge(src proto.Message) { 2912 xxx_messageInfo_ValidatorUpdate.Merge(m, src) 2913 } 2914 func (m *ValidatorUpdate) XXX_Size() int { 2915 return m.Size() 2916 } 2917 func (m *ValidatorUpdate) XXX_DiscardUnknown() { 2918 xxx_messageInfo_ValidatorUpdate.DiscardUnknown(m) 2919 } 2920 2921 var xxx_messageInfo_ValidatorUpdate proto.InternalMessageInfo 2922 2923 func (m *ValidatorUpdate) GetPubKey() crypto.PublicKey { 2924 if m != nil { 2925 return m.PubKey 2926 } 2927 return crypto.PublicKey{} 2928 } 2929 2930 func (m *ValidatorUpdate) GetPower() int64 { 2931 if m != nil { 2932 return m.Power 2933 } 2934 return 0 2935 } 2936 2937 // VoteInfo 2938 type VoteInfo struct { 2939 Validator Validator `protobuf:"bytes,1,opt,name=validator,proto3" json:"validator"` 2940 SignedLastBlock bool `protobuf:"varint,2,opt,name=signed_last_block,json=signedLastBlock,proto3" json:"signed_last_block,omitempty"` 2941 } 2942 2943 func (m *VoteInfo) Reset() { *m = VoteInfo{} } 2944 func (m *VoteInfo) String() string { return proto.CompactTextString(m) } 2945 func (*VoteInfo) ProtoMessage() {} 2946 func (*VoteInfo) Descriptor() ([]byte, []int) { 2947 return fileDescriptor_252557cfdd89a31a, []int{41} 2948 } 2949 func (m *VoteInfo) XXX_Unmarshal(b []byte) error { 2950 return m.Unmarshal(b) 2951 } 2952 func (m *VoteInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 2953 if deterministic { 2954 return xxx_messageInfo_VoteInfo.Marshal(b, m, deterministic) 2955 } else { 2956 b = b[:cap(b)] 2957 n, err := m.MarshalToSizedBuffer(b) 2958 if err != nil { 2959 return nil, err 2960 } 2961 return b[:n], nil 2962 } 2963 } 2964 func (m *VoteInfo) XXX_Merge(src proto.Message) { 2965 xxx_messageInfo_VoteInfo.Merge(m, src) 2966 } 2967 func (m *VoteInfo) XXX_Size() int { 2968 return m.Size() 2969 } 2970 func (m *VoteInfo) XXX_DiscardUnknown() { 2971 xxx_messageInfo_VoteInfo.DiscardUnknown(m) 2972 } 2973 2974 var xxx_messageInfo_VoteInfo proto.InternalMessageInfo 2975 2976 func (m *VoteInfo) GetValidator() Validator { 2977 if m != nil { 2978 return m.Validator 2979 } 2980 return Validator{} 2981 } 2982 2983 func (m *VoteInfo) GetSignedLastBlock() bool { 2984 if m != nil { 2985 return m.SignedLastBlock 2986 } 2987 return false 2988 } 2989 2990 type Evidence struct { 2991 Type EvidenceType `protobuf:"varint,1,opt,name=type,proto3,enum=tendermint.abci.EvidenceType" json:"type,omitempty"` 2992 // The offending validator 2993 Validator Validator `protobuf:"bytes,2,opt,name=validator,proto3" json:"validator"` 2994 // The height when the offense occurred 2995 Height int64 `protobuf:"varint,3,opt,name=height,proto3" json:"height,omitempty"` 2996 // The corresponding time where the offense occurred 2997 Time time.Time `protobuf:"bytes,4,opt,name=time,proto3,stdtime" json:"time"` 2998 // Total voting power of the validator set in case the ABCI application does 2999 // not store historical validators. 3000 // https://github.com/tendermint/tendermint/issues/4581 3001 TotalVotingPower int64 `protobuf:"varint,5,opt,name=total_voting_power,json=totalVotingPower,proto3" json:"total_voting_power,omitempty"` 3002 } 3003 3004 func (m *Evidence) Reset() { *m = Evidence{} } 3005 func (m *Evidence) String() string { return proto.CompactTextString(m) } 3006 func (*Evidence) ProtoMessage() {} 3007 func (*Evidence) Descriptor() ([]byte, []int) { 3008 return fileDescriptor_252557cfdd89a31a, []int{42} 3009 } 3010 func (m *Evidence) XXX_Unmarshal(b []byte) error { 3011 return m.Unmarshal(b) 3012 } 3013 func (m *Evidence) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 3014 if deterministic { 3015 return xxx_messageInfo_Evidence.Marshal(b, m, deterministic) 3016 } else { 3017 b = b[:cap(b)] 3018 n, err := m.MarshalToSizedBuffer(b) 3019 if err != nil { 3020 return nil, err 3021 } 3022 return b[:n], nil 3023 } 3024 } 3025 func (m *Evidence) XXX_Merge(src proto.Message) { 3026 xxx_messageInfo_Evidence.Merge(m, src) 3027 } 3028 func (m *Evidence) XXX_Size() int { 3029 return m.Size() 3030 } 3031 func (m *Evidence) XXX_DiscardUnknown() { 3032 xxx_messageInfo_Evidence.DiscardUnknown(m) 3033 } 3034 3035 var xxx_messageInfo_Evidence proto.InternalMessageInfo 3036 3037 func (m *Evidence) GetType() EvidenceType { 3038 if m != nil { 3039 return m.Type 3040 } 3041 return EvidenceType_UNKNOWN 3042 } 3043 3044 func (m *Evidence) GetValidator() Validator { 3045 if m != nil { 3046 return m.Validator 3047 } 3048 return Validator{} 3049 } 3050 3051 func (m *Evidence) GetHeight() int64 { 3052 if m != nil { 3053 return m.Height 3054 } 3055 return 0 3056 } 3057 3058 func (m *Evidence) GetTime() time.Time { 3059 if m != nil { 3060 return m.Time 3061 } 3062 return time.Time{} 3063 } 3064 3065 func (m *Evidence) GetTotalVotingPower() int64 { 3066 if m != nil { 3067 return m.TotalVotingPower 3068 } 3069 return 0 3070 } 3071 3072 type Snapshot struct { 3073 Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"` 3074 Format uint32 `protobuf:"varint,2,opt,name=format,proto3" json:"format,omitempty"` 3075 Chunks uint32 `protobuf:"varint,3,opt,name=chunks,proto3" json:"chunks,omitempty"` 3076 Hash []byte `protobuf:"bytes,4,opt,name=hash,proto3" json:"hash,omitempty"` 3077 Metadata []byte `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"` 3078 } 3079 3080 func (m *Snapshot) Reset() { *m = Snapshot{} } 3081 func (m *Snapshot) String() string { return proto.CompactTextString(m) } 3082 func (*Snapshot) ProtoMessage() {} 3083 func (*Snapshot) Descriptor() ([]byte, []int) { 3084 return fileDescriptor_252557cfdd89a31a, []int{43} 3085 } 3086 func (m *Snapshot) XXX_Unmarshal(b []byte) error { 3087 return m.Unmarshal(b) 3088 } 3089 func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { 3090 if deterministic { 3091 return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic) 3092 } else { 3093 b = b[:cap(b)] 3094 n, err := m.MarshalToSizedBuffer(b) 3095 if err != nil { 3096 return nil, err 3097 } 3098 return b[:n], nil 3099 } 3100 } 3101 func (m *Snapshot) XXX_Merge(src proto.Message) { 3102 xxx_messageInfo_Snapshot.Merge(m, src) 3103 } 3104 func (m *Snapshot) XXX_Size() int { 3105 return m.Size() 3106 } 3107 func (m *Snapshot) XXX_DiscardUnknown() { 3108 xxx_messageInfo_Snapshot.DiscardUnknown(m) 3109 } 3110 3111 var xxx_messageInfo_Snapshot proto.InternalMessageInfo 3112 3113 func (m *Snapshot) GetHeight() uint64 { 3114 if m != nil { 3115 return m.Height 3116 } 3117 return 0 3118 } 3119 3120 func (m *Snapshot) GetFormat() uint32 { 3121 if m != nil { 3122 return m.Format 3123 } 3124 return 0 3125 } 3126 3127 func (m *Snapshot) GetChunks() uint32 { 3128 if m != nil { 3129 return m.Chunks 3130 } 3131 return 0 3132 } 3133 3134 func (m *Snapshot) GetHash() []byte { 3135 if m != nil { 3136 return m.Hash 3137 } 3138 return nil 3139 } 3140 3141 func (m *Snapshot) GetMetadata() []byte { 3142 if m != nil { 3143 return m.Metadata 3144 } 3145 return nil 3146 } 3147 3148 func init() { 3149 proto.RegisterEnum("tendermint.abci.CheckTxType", CheckTxType_name, CheckTxType_value) 3150 proto.RegisterEnum("tendermint.abci.EvidenceType", EvidenceType_name, EvidenceType_value) 3151 proto.RegisterEnum("tendermint.abci.ResponseOfferSnapshot_Result", ResponseOfferSnapshot_Result_name, ResponseOfferSnapshot_Result_value) 3152 proto.RegisterEnum("tendermint.abci.ResponseApplySnapshotChunk_Result", ResponseApplySnapshotChunk_Result_name, ResponseApplySnapshotChunk_Result_value) 3153 proto.RegisterType((*Request)(nil), "tendermint.abci.Request") 3154 proto.RegisterType((*RequestEcho)(nil), "tendermint.abci.RequestEcho") 3155 proto.RegisterType((*RequestFlush)(nil), "tendermint.abci.RequestFlush") 3156 proto.RegisterType((*RequestInfo)(nil), "tendermint.abci.RequestInfo") 3157 proto.RegisterType((*RequestSetOption)(nil), "tendermint.abci.RequestSetOption") 3158 proto.RegisterType((*RequestInitChain)(nil), "tendermint.abci.RequestInitChain") 3159 proto.RegisterType((*RequestQuery)(nil), "tendermint.abci.RequestQuery") 3160 proto.RegisterType((*RequestBeginBlock)(nil), "tendermint.abci.RequestBeginBlock") 3161 proto.RegisterType((*RequestCheckTx)(nil), "tendermint.abci.RequestCheckTx") 3162 proto.RegisterType((*RequestDeliverTx)(nil), "tendermint.abci.RequestDeliverTx") 3163 proto.RegisterType((*RequestEndBlock)(nil), "tendermint.abci.RequestEndBlock") 3164 proto.RegisterType((*RequestCommit)(nil), "tendermint.abci.RequestCommit") 3165 proto.RegisterType((*RequestListSnapshots)(nil), "tendermint.abci.RequestListSnapshots") 3166 proto.RegisterType((*RequestOfferSnapshot)(nil), "tendermint.abci.RequestOfferSnapshot") 3167 proto.RegisterType((*RequestLoadSnapshotChunk)(nil), "tendermint.abci.RequestLoadSnapshotChunk") 3168 proto.RegisterType((*RequestApplySnapshotChunk)(nil), "tendermint.abci.RequestApplySnapshotChunk") 3169 proto.RegisterType((*Response)(nil), "tendermint.abci.Response") 3170 proto.RegisterType((*ResponseException)(nil), "tendermint.abci.ResponseException") 3171 proto.RegisterType((*ResponseEcho)(nil), "tendermint.abci.ResponseEcho") 3172 proto.RegisterType((*ResponseFlush)(nil), "tendermint.abci.ResponseFlush") 3173 proto.RegisterType((*ResponseInfo)(nil), "tendermint.abci.ResponseInfo") 3174 proto.RegisterType((*ResponseSetOption)(nil), "tendermint.abci.ResponseSetOption") 3175 proto.RegisterType((*ResponseInitChain)(nil), "tendermint.abci.ResponseInitChain") 3176 proto.RegisterType((*ResponseQuery)(nil), "tendermint.abci.ResponseQuery") 3177 proto.RegisterType((*ResponseBeginBlock)(nil), "tendermint.abci.ResponseBeginBlock") 3178 proto.RegisterType((*ResponseCheckTx)(nil), "tendermint.abci.ResponseCheckTx") 3179 proto.RegisterType((*ResponseDeliverTx)(nil), "tendermint.abci.ResponseDeliverTx") 3180 proto.RegisterType((*ResponseEndBlock)(nil), "tendermint.abci.ResponseEndBlock") 3181 proto.RegisterType((*ResponseCommit)(nil), "tendermint.abci.ResponseCommit") 3182 proto.RegisterType((*ResponseListSnapshots)(nil), "tendermint.abci.ResponseListSnapshots") 3183 proto.RegisterType((*ResponseOfferSnapshot)(nil), "tendermint.abci.ResponseOfferSnapshot") 3184 proto.RegisterType((*ResponseLoadSnapshotChunk)(nil), "tendermint.abci.ResponseLoadSnapshotChunk") 3185 proto.RegisterType((*ResponseApplySnapshotChunk)(nil), "tendermint.abci.ResponseApplySnapshotChunk") 3186 proto.RegisterType((*ConsensusParams)(nil), "tendermint.abci.ConsensusParams") 3187 proto.RegisterType((*BlockParams)(nil), "tendermint.abci.BlockParams") 3188 proto.RegisterType((*LastCommitInfo)(nil), "tendermint.abci.LastCommitInfo") 3189 proto.RegisterType((*Event)(nil), "tendermint.abci.Event") 3190 proto.RegisterType((*EventAttribute)(nil), "tendermint.abci.EventAttribute") 3191 proto.RegisterType((*TxResult)(nil), "tendermint.abci.TxResult") 3192 proto.RegisterType((*Validator)(nil), "tendermint.abci.Validator") 3193 proto.RegisterType((*ValidatorUpdate)(nil), "tendermint.abci.ValidatorUpdate") 3194 proto.RegisterType((*VoteInfo)(nil), "tendermint.abci.VoteInfo") 3195 proto.RegisterType((*Evidence)(nil), "tendermint.abci.Evidence") 3196 proto.RegisterType((*Snapshot)(nil), "tendermint.abci.Snapshot") 3197 } 3198 3199 func init() { proto.RegisterFile("tendermint/abci/types.proto", fileDescriptor_252557cfdd89a31a) } 3200 3201 var fileDescriptor_252557cfdd89a31a = []byte{ 3202 // 2741 bytes of a gzipped FileDescriptorProto 3203 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x5a, 0x4b, 0x73, 0x1b, 0xc7, 3204 0x11, 0xc6, 0xfb, 0xd1, 0x24, 0x1e, 0x1c, 0xd1, 0x12, 0xb4, 0x92, 0x48, 0x79, 0x55, 0x72, 0x2c, 3205 0xd9, 0x26, 0x63, 0xaa, 0xa4, 0x48, 0xb1, 0x13, 0x9b, 0x80, 0x20, 0x83, 0x26, 0x4d, 0x30, 0x4b, 3206 0x48, 0xce, 0xcb, 0x5a, 0x2f, 0xb0, 0x43, 0x60, 0x2d, 0x60, 0x77, 0x8d, 0x1d, 0x50, 0xa4, 0x8f, 3207 0x71, 0x72, 0x51, 0x2e, 0xce, 0x2d, 0x17, 0xff, 0x8f, 0x9c, 0x72, 0xc9, 0xc5, 0x55, 0xb9, 0xf8, 3208 0x98, 0x93, 0x93, 0x92, 0x2a, 0x97, 0xfc, 0x81, 0x9c, 0x52, 0x49, 0xcd, 0x63, 0x5f, 0x00, 0x16, 3209 0x00, 0xed, 0xdc, 0x7c, 0x9b, 0x99, 0xed, 0xee, 0xc5, 0xf4, 0x4e, 0x7f, 0xfd, 0x75, 0x0f, 0xe0, 3210 0x12, 0xc1, 0xa6, 0x8e, 0x87, 0x03, 0xc3, 0x24, 0x9b, 0x5a, 0xbb, 0x63, 0x6c, 0x92, 0x53, 0x1b, 3211 0x3b, 0x1b, 0xf6, 0xd0, 0x22, 0x16, 0x2a, 0xf9, 0x0f, 0x37, 0xe8, 0x43, 0xe9, 0x4a, 0x40, 0xba, 3212 0x33, 0x3c, 0xb5, 0x89, 0xb5, 0x69, 0x0f, 0x2d, 0xeb, 0x88, 0xcb, 0x4b, 0x97, 0x03, 0x8f, 0x99, 3213 0x9d, 0xa0, 0xb5, 0xd0, 0x53, 0xa1, 0xfc, 0x04, 0x9f, 0xba, 0x4f, 0xaf, 0x4c, 0xe8, 0xda, 0xda, 3214 0x50, 0x1b, 0xb8, 0x8f, 0xd7, 0xbb, 0x96, 0xd5, 0xed, 0xe3, 0x4d, 0x36, 0x6b, 0x8f, 0x8e, 0x36, 3215 0x89, 0x31, 0xc0, 0x0e, 0xd1, 0x06, 0xb6, 0x10, 0x58, 0xed, 0x5a, 0x5d, 0x8b, 0x0d, 0x37, 0xe9, 3216 0x88, 0xaf, 0xca, 0x7f, 0xc8, 0x41, 0x56, 0xc1, 0x9f, 0x8e, 0xb0, 0x43, 0xd0, 0x16, 0xa4, 0x70, 3217 0xa7, 0x67, 0x55, 0xe2, 0x57, 0xe3, 0xaf, 0x2e, 0x6d, 0x5d, 0xde, 0x18, 0xdb, 0xdc, 0x86, 0x90, 3218 0xab, 0x77, 0x7a, 0x56, 0x23, 0xa6, 0x30, 0x59, 0x74, 0x1b, 0xd2, 0x47, 0xfd, 0x91, 0xd3, 0xab, 3219 0x24, 0x98, 0xd2, 0x95, 0x28, 0xa5, 0x07, 0x54, 0xa8, 0x11, 0x53, 0xb8, 0x34, 0x7d, 0x95, 0x61, 3220 0x1e, 0x59, 0x95, 0xe4, 0xec, 0x57, 0xed, 0x98, 0x47, 0xec, 0x55, 0x54, 0x16, 0x55, 0x01, 0x1c, 3221 0x4c, 0x54, 0xcb, 0x26, 0x86, 0x65, 0x56, 0x52, 0x4c, 0xf3, 0xe5, 0x28, 0xcd, 0x43, 0x4c, 0x9a, 3222 0x4c, 0xb0, 0x11, 0x53, 0xf2, 0x8e, 0x3b, 0xa1, 0x36, 0x0c, 0xd3, 0x20, 0x6a, 0xa7, 0xa7, 0x19, 3223 0x66, 0x25, 0x3d, 0xdb, 0xc6, 0x8e, 0x69, 0x90, 0x1a, 0x15, 0xa4, 0x36, 0x0c, 0x77, 0x42, 0xb7, 3224 0xfc, 0xe9, 0x08, 0x0f, 0x4f, 0x2b, 0x99, 0xd9, 0x5b, 0xfe, 0x19, 0x15, 0xa2, 0x5b, 0x66, 0xd2, 3225 0xa8, 0x0e, 0x4b, 0x6d, 0xdc, 0x35, 0x4c, 0xb5, 0xdd, 0xb7, 0x3a, 0x4f, 0x2a, 0x59, 0xa6, 0x2c, 3226 0x47, 0x29, 0x57, 0xa9, 0x68, 0x95, 0x4a, 0x36, 0x62, 0x0a, 0xb4, 0xbd, 0x19, 0x7a, 0x1b, 0x72, 3227 0x9d, 0x1e, 0xee, 0x3c, 0x51, 0xc9, 0x49, 0x25, 0xc7, 0x6c, 0xac, 0x47, 0xd9, 0xa8, 0x51, 0xb9, 3228 0xd6, 0x49, 0x23, 0xa6, 0x64, 0x3b, 0x7c, 0x48, 0xf7, 0xaf, 0xe3, 0xbe, 0x71, 0x8c, 0x87, 0x54, 3229 0x3f, 0x3f, 0x7b, 0xff, 0xf7, 0xb9, 0x24, 0xb3, 0x90, 0xd7, 0xdd, 0x09, 0x7a, 0x07, 0xf2, 0xd8, 3230 0xd4, 0xc5, 0x36, 0x80, 0x99, 0xb8, 0x1a, 0x79, 0x56, 0x4c, 0xdd, 0xdd, 0x44, 0x0e, 0x8b, 0x31, 3231 0xba, 0x0b, 0x99, 0x8e, 0x35, 0x18, 0x18, 0xa4, 0xb2, 0xc4, 0xb4, 0xd7, 0x22, 0x37, 0xc0, 0xa4, 3232 0x1a, 0x31, 0x45, 0xc8, 0xa3, 0x7d, 0x28, 0xf6, 0x0d, 0x87, 0xa8, 0x8e, 0xa9, 0xd9, 0x4e, 0xcf, 3233 0x22, 0x4e, 0x65, 0x99, 0x59, 0xb8, 0x1e, 0x65, 0x61, 0xcf, 0x70, 0xc8, 0xa1, 0x2b, 0xdc, 0x88, 3234 0x29, 0x85, 0x7e, 0x70, 0x81, 0xda, 0xb3, 0x8e, 0x8e, 0xf0, 0xd0, 0x33, 0x58, 0x29, 0xcc, 0xb6, 3235 0xd7, 0xa4, 0xd2, 0xae, 0x3e, 0xb5, 0x67, 0x05, 0x17, 0xd0, 0xaf, 0xe0, 0x5c, 0xdf, 0xd2, 0x74, 3236 0xcf, 0x9c, 0xda, 0xe9, 0x8d, 0xcc, 0x27, 0x95, 0x22, 0x33, 0x7a, 0x23, 0xf2, 0x47, 0x5a, 0x9a, 3237 0xee, 0x9a, 0xa8, 0x51, 0x85, 0x46, 0x4c, 0x59, 0xe9, 0x8f, 0x2f, 0xa2, 0xc7, 0xb0, 0xaa, 0xd9, 3238 0x76, 0xff, 0x74, 0xdc, 0x7a, 0x89, 0x59, 0xbf, 0x19, 0x65, 0x7d, 0x9b, 0xea, 0x8c, 0x9b, 0x47, 3239 0xda, 0xc4, 0x6a, 0x35, 0x0b, 0xe9, 0x63, 0xad, 0x3f, 0xc2, 0xf2, 0x0f, 0x60, 0x29, 0x10, 0xea, 3240 0xa8, 0x02, 0xd9, 0x01, 0x76, 0x1c, 0xad, 0x8b, 0x19, 0x32, 0xe4, 0x15, 0x77, 0x2a, 0x17, 0x61, 3241 0x39, 0x18, 0xde, 0xf2, 0xc0, 0x53, 0xa4, 0x81, 0x4b, 0x15, 0x8f, 0xf1, 0xd0, 0xa1, 0xd1, 0x2a, 3242 0x14, 0xc5, 0x14, 0x5d, 0x83, 0x02, 0x3b, 0x3e, 0xaa, 0xfb, 0x9c, 0xa2, 0x47, 0x4a, 0x59, 0x66, 3243 0x8b, 0x8f, 0x84, 0xd0, 0x3a, 0x2c, 0xd9, 0x5b, 0xb6, 0x27, 0x92, 0x64, 0x22, 0x60, 0x6f, 0xd9, 3244 0x42, 0x40, 0xfe, 0x31, 0x94, 0xc7, 0xa3, 0x1d, 0x95, 0x21, 0xf9, 0x04, 0x9f, 0x8a, 0xf7, 0xd1, 3245 0x21, 0x5a, 0x15, 0xdb, 0x62, 0xef, 0xc8, 0x2b, 0x62, 0x8f, 0x7f, 0x4d, 0x78, 0xca, 0x5e, 0x98, 3246 0xa3, 0xbb, 0x90, 0xa2, 0xa8, 0x29, 0x00, 0x50, 0xda, 0xe0, 0x90, 0xba, 0xe1, 0x42, 0xea, 0x46, 3247 0xcb, 0x85, 0xd4, 0x6a, 0xee, 0xab, 0x6f, 0xd6, 0x63, 0x5f, 0xfc, 0x7d, 0x3d, 0xae, 0x30, 0x0d, 3248 0x74, 0x91, 0x46, 0xa5, 0x66, 0x98, 0xaa, 0xa1, 0x8b, 0xf7, 0x64, 0xd9, 0x7c, 0x47, 0x47, 0xbb, 3249 0x50, 0xee, 0x58, 0xa6, 0x83, 0x4d, 0x67, 0xe4, 0xa8, 0x1c, 0xb2, 0x05, 0xec, 0x4d, 0x46, 0x4d, 3250 0xcd, 0x15, 0x3c, 0x60, 0x72, 0x4a, 0xa9, 0x13, 0x5e, 0x40, 0x0f, 0x00, 0x8e, 0xb5, 0xbe, 0xa1, 3251 0x6b, 0xc4, 0x1a, 0x3a, 0x95, 0xd4, 0xd5, 0xe4, 0x54, 0x33, 0x8f, 0x5c, 0x91, 0x87, 0xb6, 0xae, 3252 0x11, 0x5c, 0x4d, 0xd1, 0x5f, 0xab, 0x04, 0x34, 0xd1, 0x2b, 0x50, 0xd2, 0x6c, 0x5b, 0x75, 0x88, 3253 0x46, 0xb0, 0xda, 0x3e, 0x25, 0xd8, 0x61, 0x60, 0xb8, 0xac, 0x14, 0x34, 0xdb, 0x3e, 0xa4, 0xab, 3254 0x55, 0xba, 0x88, 0xae, 0x43, 0x91, 0x02, 0x9f, 0xa1, 0xf5, 0xd5, 0x1e, 0x36, 0xba, 0x3d, 0xc2, 3255 0x40, 0x2f, 0xa9, 0x14, 0xc4, 0x6a, 0x83, 0x2d, 0xca, 0xba, 0x77, 0x10, 0x18, 0xe8, 0x21, 0x04, 3256 0x29, 0x5d, 0x23, 0x1a, 0x73, 0xe4, 0xb2, 0xc2, 0xc6, 0x74, 0xcd, 0xd6, 0x48, 0x4f, 0xb8, 0x87, 3257 0x8d, 0xd1, 0x79, 0xc8, 0x08, 0xb3, 0x49, 0x66, 0x56, 0xcc, 0xe8, 0x37, 0xb3, 0x87, 0xd6, 0x31, 3258 0x66, 0x28, 0x9f, 0x53, 0xf8, 0x44, 0xfe, 0x6d, 0x02, 0x56, 0x26, 0xe0, 0x91, 0xda, 0xed, 0x69, 3259 0x4e, 0xcf, 0x7d, 0x17, 0x1d, 0xa3, 0x3b, 0xd4, 0xae, 0xa6, 0xe3, 0xa1, 0x48, 0x4b, 0x95, 0xa0, 3260 0x8b, 0x78, 0xca, 0x6d, 0xb0, 0xe7, 0xc2, 0x35, 0x42, 0x1a, 0x35, 0xa1, 0xdc, 0xd7, 0x1c, 0xa2, 3261 0x72, 0xb8, 0x51, 0x03, 0x29, 0x6a, 0x12, 0x64, 0xf7, 0x34, 0x17, 0xa0, 0xe8, 0x61, 0x17, 0x86, 3262 0x8a, 0xfd, 0xd0, 0x2a, 0x52, 0x60, 0xb5, 0x7d, 0xfa, 0x99, 0x66, 0x12, 0xc3, 0xc4, 0xea, 0xc4, 3263 0x97, 0xbb, 0x38, 0x61, 0xb4, 0x7e, 0x6c, 0xe8, 0xd8, 0xec, 0xb8, 0x9f, 0xec, 0x9c, 0xa7, 0xec, 3264 0x7d, 0x52, 0x47, 0x56, 0xa0, 0x18, 0x06, 0x78, 0x54, 0x84, 0x04, 0x39, 0x11, 0x0e, 0x48, 0x90, 3265 0x13, 0xf4, 0x43, 0x48, 0xd1, 0x4d, 0xb2, 0xcd, 0x17, 0xa7, 0x64, 0x57, 0xa1, 0xd7, 0x3a, 0xb5, 3266 0xb1, 0xc2, 0x24, 0x65, 0xd9, 0x8b, 0x06, 0x0f, 0xf4, 0xc7, 0xad, 0xca, 0x37, 0xa0, 0x34, 0x86, 3267 0xea, 0x81, 0xef, 0x17, 0x0f, 0x7e, 0x3f, 0xb9, 0x04, 0x85, 0x10, 0x84, 0xcb, 0xe7, 0x61, 0x75, 3268 0x1a, 0x22, 0xcb, 0x3d, 0x6f, 0x3d, 0x84, 0xac, 0xe8, 0x36, 0xe4, 0x3c, 0x48, 0xe6, 0xd1, 0x38, 3269 0xe9, 0x2b, 0x57, 0x58, 0xf1, 0x44, 0x69, 0x18, 0xd2, 0x63, 0xcd, 0xce, 0x43, 0x82, 0xfd, 0xf0, 3270 0xac, 0x66, 0xdb, 0x0d, 0xcd, 0xe9, 0xc9, 0x1f, 0x43, 0x25, 0x0a, 0x6e, 0xc7, 0xb6, 0x91, 0xf2, 3271 0x8e, 0xe1, 0x79, 0xc8, 0x1c, 0x59, 0xc3, 0x81, 0x46, 0x98, 0xb1, 0x82, 0x22, 0x66, 0xf4, 0x78, 3272 0x72, 0xe8, 0x4d, 0xb2, 0x65, 0x3e, 0x91, 0x55, 0xb8, 0x18, 0x09, 0xb9, 0x54, 0xc5, 0x30, 0x75, 3273 0xcc, 0xfd, 0x59, 0x50, 0xf8, 0xc4, 0x37, 0xc4, 0x7f, 0x2c, 0x9f, 0xd0, 0xd7, 0x3a, 0x6c, 0xaf, 3274 0xcc, 0x7e, 0x5e, 0x11, 0x33, 0xf9, 0x9f, 0x39, 0xc8, 0x29, 0xd8, 0xb1, 0x29, 0x26, 0xa0, 0x2a, 3275 0xe4, 0xf1, 0x49, 0x07, 0x73, 0x32, 0x14, 0x8f, 0x24, 0x13, 0x5c, 0xba, 0xee, 0x4a, 0xd2, 0x4c, 3276 0xee, 0xa9, 0xa1, 0x5b, 0x82, 0xf0, 0x45, 0x73, 0x37, 0xa1, 0x1e, 0x64, 0x7c, 0x77, 0x5c, 0xc6, 3277 0x97, 0x8c, 0x4c, 0xde, 0x5c, 0x6b, 0x8c, 0xf2, 0xdd, 0x12, 0x94, 0x2f, 0x35, 0xe7, 0x65, 0x21, 3278 0xce, 0x57, 0x0b, 0x71, 0xbe, 0xf4, 0x9c, 0x6d, 0x46, 0x90, 0xbe, 0x5a, 0x88, 0xf4, 0x65, 0xe6, 3279 0x18, 0x89, 0x60, 0x7d, 0x77, 0x5c, 0xd6, 0x97, 0x9d, 0xb3, 0xed, 0x31, 0xda, 0xf7, 0x20, 0x4c, 3280 0xfb, 0x38, 0x65, 0xbb, 0x16, 0xa9, 0x1d, 0xc9, 0xfb, 0x7e, 0x12, 0xe0, 0x7d, 0xf9, 0x48, 0xd2, 3281 0xc5, 0x8d, 0x4c, 0x21, 0x7e, 0xb5, 0x10, 0xf1, 0x83, 0x39, 0x3e, 0x88, 0x60, 0x7e, 0xef, 0x06, 3282 0x99, 0xdf, 0x52, 0x24, 0x79, 0x14, 0x87, 0x66, 0x1a, 0xf5, 0xbb, 0xe7, 0x51, 0xbf, 0xe5, 0x48, 3283 0xee, 0x2a, 0xf6, 0x30, 0xce, 0xfd, 0x9a, 0x13, 0xdc, 0x8f, 0x73, 0xb5, 0x57, 0x22, 0x4d, 0xcc, 3284 0x21, 0x7f, 0xcd, 0x09, 0xf2, 0x57, 0x9c, 0x63, 0x70, 0x0e, 0xfb, 0xfb, 0xf5, 0x74, 0xf6, 0x17, 3285 0xcd, 0xcf, 0xc4, 0xcf, 0x5c, 0x8c, 0xfe, 0xa9, 0x11, 0xf4, 0xaf, 0xcc, 0xcc, 0xbf, 0x16, 0x69, 3286 0xfe, 0xec, 0xfc, 0xef, 0x06, 0x4d, 0xb3, 0x63, 0xc0, 0x41, 0xa1, 0x0a, 0x0f, 0x87, 0xd6, 0x50, 3287 0x50, 0x2b, 0x3e, 0x91, 0x5f, 0xa5, 0x89, 0xdf, 0x07, 0x89, 0x19, 0x5c, 0x91, 0xa5, 0x84, 0x00, 3288 0x30, 0xc8, 0x7f, 0x8a, 0xfb, 0xba, 0x2c, 0x57, 0x06, 0x49, 0x43, 0x5e, 0x90, 0x86, 0x00, 0x85, 3289 0x4c, 0x84, 0x29, 0xe4, 0x3a, 0x2c, 0x51, 0xa8, 0x1f, 0x63, 0x87, 0x9a, 0xed, 0xb2, 0x43, 0x74, 3290 0x13, 0x56, 0x58, 0x2e, 0xe7, 0x44, 0x53, 0xe0, 0x7b, 0x8a, 0xa5, 0xa9, 0x12, 0x7d, 0xc0, 0x0f, 3291 0x27, 0x07, 0xfa, 0x37, 0xe0, 0x5c, 0x40, 0xd6, 0x4b, 0x21, 0x9c, 0x12, 0x95, 0x3d, 0xe9, 0x6d, 3292 0x91, 0x4b, 0x3e, 0xf0, 0x1d, 0xe4, 0x33, 0x4f, 0x04, 0xa9, 0x8e, 0xa5, 0x63, 0x01, 0xf0, 0x6c, 3293 0x4c, 0xd9, 0x68, 0xdf, 0xea, 0x0a, 0x18, 0xa7, 0x43, 0x2a, 0xe5, 0xa1, 0x60, 0x9e, 0x83, 0x9c, 3294 0xfc, 0x97, 0xb8, 0x6f, 0xcf, 0x27, 0xa3, 0xd3, 0x78, 0x63, 0xfc, 0xff, 0xc3, 0x1b, 0x13, 0xdf, 3295 0x9a, 0x37, 0x06, 0x13, 0x6c, 0x32, 0x9c, 0x60, 0xff, 0x1d, 0xf7, 0xbf, 0xb0, 0xc7, 0x02, 0xbf, 3296 0x9d, 0x47, 0xfc, 0x6c, 0x99, 0x66, 0xdf, 0x4b, 0x64, 0x4b, 0xc1, 0xed, 0x33, 0xec, 0xbd, 0x61, 3297 0x6e, 0x9f, 0xe5, 0xf9, 0x93, 0x4d, 0xd0, 0x5d, 0xc8, 0xb3, 0xa6, 0x8b, 0x6a, 0xd9, 0x8e, 0x00, 3298 0xdc, 0x4b, 0xc1, 0xbd, 0xf2, 0xde, 0xca, 0xc6, 0x01, 0x95, 0x69, 0xda, 0x8e, 0x92, 0xb3, 0xc5, 3299 0x28, 0x40, 0x04, 0xf2, 0x21, 0x3e, 0x7a, 0x19, 0xf2, 0xf4, 0xd7, 0x3b, 0xb6, 0xd6, 0xc1, 0x0c, 3300 0x3c, 0xf3, 0x8a, 0xbf, 0x20, 0x3f, 0x06, 0x34, 0x09, 0xdf, 0xa8, 0x01, 0x19, 0x7c, 0x8c, 0x4d, 3301 0x42, 0xbf, 0x1a, 0x75, 0xf7, 0xf9, 0x29, 0x64, 0x0f, 0x9b, 0xa4, 0x5a, 0xa1, 0x4e, 0xfe, 0xd7, 3302 0x37, 0xeb, 0x65, 0x2e, 0xfd, 0xba, 0x35, 0x30, 0x08, 0x1e, 0xd8, 0xe4, 0x54, 0x11, 0xfa, 0xf2, 3303 0xe7, 0x09, 0xca, 0xbc, 0x42, 0xd0, 0x3e, 0xd5, 0xb7, 0x6e, 0x00, 0x25, 0x02, 0xac, 0x7b, 0x31, 3304 0x7f, 0xaf, 0x01, 0x74, 0x35, 0x47, 0x7d, 0xaa, 0x99, 0x04, 0xeb, 0xc2, 0xe9, 0x81, 0x15, 0x24, 3305 0x41, 0x8e, 0xce, 0x46, 0x0e, 0xd6, 0x45, 0x01, 0xe0, 0xcd, 0x03, 0xfb, 0xcc, 0x7e, 0xb7, 0x7d, 3306 0x86, 0xbd, 0x9c, 0x1b, 0xf7, 0xf2, 0xef, 0x12, 0x7e, 0x94, 0xf8, 0x24, 0xf5, 0xfb, 0xe7, 0x87, 3307 0xdf, 0xb3, 0xca, 0x35, 0x9c, 0x63, 0xd1, 0x21, 0xac, 0x78, 0x51, 0xaa, 0x8e, 0x58, 0xf4, 0xba, 3308 0xe7, 0x6e, 0xd1, 0x30, 0x2f, 0x1f, 0x87, 0x97, 0x1d, 0xf4, 0x73, 0xb8, 0x30, 0x86, 0x40, 0x9e, 3309 0xe9, 0xc4, 0x82, 0x40, 0xf4, 0x52, 0x18, 0x88, 0x5c, 0xcb, 0xbe, 0xaf, 0x92, 0xdf, 0x31, 0x36, 3310 0x76, 0x68, 0x31, 0x14, 0x64, 0x0c, 0x53, 0xbf, 0xfe, 0x35, 0x28, 0x0c, 0x31, 0xa1, 0xf5, 0x79, 3311 0xa8, 0xdc, 0x5c, 0xe6, 0x8b, 0xa2, 0x88, 0x3d, 0x80, 0x97, 0xa6, 0x32, 0x07, 0xf4, 0x23, 0xc8, 3312 0xfb, 0xa4, 0x23, 0x1e, 0x51, 0xb9, 0x79, 0xd5, 0x88, 0x2f, 0x2b, 0xff, 0x39, 0xee, 0x9b, 0x0c, 3313 0xd7, 0x37, 0x75, 0xc8, 0x0c, 0xb1, 0x33, 0xea, 0xf3, 0x8a, 0xa3, 0xb8, 0xf5, 0xc6, 0x62, 0x9c, 3314 0x83, 0xae, 0x8e, 0xfa, 0x44, 0x11, 0xca, 0xf2, 0x63, 0xc8, 0xf0, 0x15, 0xb4, 0x04, 0xd9, 0x87, 3315 0xfb, 0xbb, 0xfb, 0xcd, 0x0f, 0xf7, 0xcb, 0x31, 0x04, 0x90, 0xd9, 0xae, 0xd5, 0xea, 0x07, 0xad, 3316 0x72, 0x1c, 0xe5, 0x21, 0xbd, 0x5d, 0x6d, 0x2a, 0xad, 0x72, 0x82, 0x2e, 0x2b, 0xf5, 0xf7, 0xeb, 3317 0xb5, 0x56, 0x39, 0x89, 0x56, 0xa0, 0xc0, 0xc7, 0xea, 0x83, 0xa6, 0xf2, 0xc1, 0x76, 0xab, 0x9c, 3318 0x0a, 0x2c, 0x1d, 0xd6, 0xf7, 0xef, 0xd7, 0x95, 0x72, 0x5a, 0x7e, 0x93, 0x96, 0x34, 0x11, 0x2c, 3319 0xc5, 0x2f, 0x5e, 0xe2, 0x81, 0xe2, 0x45, 0xfe, 0x63, 0x02, 0xa4, 0x68, 0xea, 0x81, 0xde, 0x1f, 3320 0xdb, 0xf8, 0xd6, 0x19, 0x78, 0xcb, 0xd8, 0xee, 0xd1, 0x75, 0x28, 0x0e, 0xf1, 0x11, 0x26, 0x9d, 3321 0x1e, 0xa7, 0x42, 0x3c, 0xb1, 0x15, 0x94, 0x82, 0x58, 0x65, 0x4a, 0x0e, 0x17, 0xfb, 0x04, 0x77, 3322 0x88, 0xca, 0xeb, 0x28, 0x7e, 0xe8, 0xf2, 0x54, 0x8c, 0xae, 0x1e, 0xf2, 0x45, 0xf9, 0xe3, 0x33, 3323 0xf9, 0x32, 0x0f, 0x69, 0xa5, 0xde, 0x52, 0x7e, 0x51, 0x4e, 0x22, 0x04, 0x45, 0x36, 0x54, 0x0f, 3324 0xf7, 0xb7, 0x0f, 0x0e, 0x1b, 0x4d, 0xea, 0xcb, 0x73, 0x50, 0x72, 0x7d, 0xe9, 0x2e, 0xa6, 0xe5, 3325 0xff, 0xc6, 0xa1, 0x34, 0x16, 0x20, 0x68, 0x0b, 0xd2, 0x9c, 0x4e, 0x47, 0x35, 0xdd, 0x59, 0x7c, 3326 0x8b, 0x68, 0xe2, 0xa2, 0xe8, 0x6d, 0xc8, 0x61, 0xd1, 0x27, 0x98, 0x16, 0x88, 0xbc, 0xbf, 0xe1, 3327 0x76, 0x12, 0x84, 0xaa, 0xa7, 0x81, 0xde, 0x81, 0xbc, 0x17, 0xe9, 0xa2, 0x86, 0x7b, 0x79, 0x52, 3328 0xdd, 0xc3, 0x08, 0xa1, 0xef, 0xeb, 0xa0, 0x7b, 0x3e, 0x27, 0x4b, 0x4d, 0x92, 0x78, 0xa1, 0xce, 3329 0x05, 0x84, 0xb2, 0x2b, 0x2f, 0xd7, 0x60, 0x29, 0xb0, 0x1f, 0x74, 0x09, 0xf2, 0x03, 0xed, 0x44, 3330 0xf4, 0x9f, 0x78, 0x07, 0x21, 0x37, 0xd0, 0x4e, 0x78, 0xeb, 0xe9, 0x02, 0x64, 0xe9, 0xc3, 0xae, 3331 0xc6, 0xd1, 0x26, 0xa9, 0x64, 0x06, 0xda, 0xc9, 0x7b, 0x9a, 0x23, 0x7f, 0x04, 0xc5, 0x70, 0xef, 3332 0x85, 0x9e, 0xc4, 0xa1, 0x35, 0x32, 0x75, 0x66, 0x23, 0xad, 0xf0, 0x09, 0xba, 0x0d, 0xe9, 0x63, 3333 0x8b, 0x83, 0xd5, 0xf4, 0x90, 0x7d, 0x64, 0x11, 0x1c, 0xe8, 0xdd, 0x70, 0x69, 0xf9, 0x33, 0x48, 3334 0x33, 0xf0, 0xa1, 0x40, 0xc2, 0xba, 0x28, 0x82, 0x8f, 0xd2, 0x31, 0xfa, 0x08, 0x40, 0x23, 0x64, 3335 0x68, 0xb4, 0x47, 0xbe, 0xe1, 0xf5, 0xe9, 0xe0, 0xb5, 0xed, 0xca, 0x55, 0x2f, 0x0b, 0x14, 0x5b, 3336 0xf5, 0x55, 0x03, 0x48, 0x16, 0x30, 0x28, 0xef, 0x43, 0x31, 0xac, 0x1b, 0xec, 0x67, 0x2e, 0x4f, 3337 0xe9, 0x67, 0x7a, 0x9c, 0xc7, 0x63, 0x4c, 0x49, 0xde, 0x31, 0x63, 0x13, 0xf9, 0x59, 0x1c, 0x72, 3338 0xad, 0x13, 0x71, 0xac, 0x23, 0x9a, 0x35, 0xbe, 0x6a, 0x22, 0xd8, 0x9a, 0xe0, 0xdd, 0x9f, 0xa4, 3339 0xd7, 0x53, 0x7a, 0xd7, 0x0b, 0xdc, 0xd4, 0xa2, 0xc5, 0xa3, 0xdb, 0x5c, 0x13, 0x60, 0xf5, 0x16, 3340 0xe4, 0xbd, 0x53, 0x45, 0x89, 0xbd, 0xa6, 0xeb, 0x43, 0xec, 0x38, 0x62, 0x6f, 0xee, 0x94, 0xf5, 3341 0xfe, 0xac, 0xa7, 0xa2, 0xf9, 0x91, 0x54, 0xf8, 0x44, 0xd6, 0xa1, 0x34, 0x96, 0xb6, 0xd0, 0x5b, 3342 0x90, 0xb5, 0x47, 0x6d, 0xd5, 0x75, 0xcf, 0x58, 0xf0, 0xb8, 0x24, 0x6f, 0xd4, 0xee, 0x1b, 0x9d, 3343 0x5d, 0x7c, 0xea, 0xfe, 0x18, 0x7b, 0xd4, 0xde, 0xe5, 0x5e, 0xe4, 0x6f, 0x49, 0x04, 0xdf, 0x72, 3344 0x0c, 0x39, 0xf7, 0x50, 0xa0, 0x9f, 0x06, 0xe3, 0xc4, 0xed, 0x08, 0x47, 0xa6, 0x52, 0x61, 0x3e, 3345 0x10, 0x26, 0x37, 0x61, 0xc5, 0x31, 0xba, 0x26, 0xd6, 0x55, 0xbf, 0xb4, 0x60, 0x6f, 0xcb, 0x29, 3346 0x25, 0xfe, 0x60, 0xcf, 0xad, 0x2b, 0xe4, 0xff, 0xc4, 0x21, 0xe7, 0x06, 0x2c, 0x7a, 0x33, 0x70, 3347 0xee, 0x8a, 0x53, 0x1a, 0x25, 0xae, 0xa0, 0xdf, 0xbe, 0x0b, 0xff, 0xd6, 0xc4, 0xd9, 0x7f, 0x6b, 3348 0x54, 0x1f, 0xd6, 0x6d, 0x88, 0xa7, 0xce, 0xdc, 0x10, 0x7f, 0x1d, 0x10, 0xb1, 0x88, 0xd6, 0x57, 3349 0x8f, 0x2d, 0x62, 0x98, 0x5d, 0x95, 0x3b, 0x9b, 0x33, 0xaa, 0x32, 0x7b, 0xf2, 0x88, 0x3d, 0x38, 3350 0x60, 0x7e, 0xff, 0x4d, 0x1c, 0x72, 0x5e, 0x6e, 0x3c, 0x6b, 0x37, 0xee, 0x3c, 0x64, 0x04, 0xfc, 3351 0xf3, 0x76, 0x9c, 0x98, 0x79, 0x8d, 0xe1, 0x54, 0xa0, 0x31, 0x2c, 0x41, 0x6e, 0x80, 0x89, 0xc6, 3352 0x08, 0x02, 0xaf, 0xee, 0xbc, 0xf9, 0xcd, 0x7b, 0xb0, 0x14, 0x68, 0x8c, 0xd2, 0xc8, 0xdb, 0xaf, 3353 0x7f, 0x58, 0x8e, 0x49, 0xd9, 0x67, 0x5f, 0x5e, 0x4d, 0xee, 0xe3, 0xa7, 0xf4, 0xcc, 0x2a, 0xf5, 3354 0x5a, 0xa3, 0x5e, 0xdb, 0x2d, 0xc7, 0xa5, 0xa5, 0x67, 0x5f, 0x5e, 0xcd, 0x2a, 0x98, 0xf5, 0x57, 3355 0x6e, 0x36, 0x60, 0x39, 0xf8, 0x55, 0xc2, 0x19, 0x04, 0x41, 0xf1, 0xfe, 0xc3, 0x83, 0xbd, 0x9d, 3356 0xda, 0x76, 0xab, 0xae, 0x3e, 0x6a, 0xb6, 0xea, 0xe5, 0x38, 0xba, 0x00, 0xe7, 0xf6, 0x76, 0xde, 3357 0x6b, 0xb4, 0xd4, 0xda, 0xde, 0x4e, 0x7d, 0xbf, 0xa5, 0x6e, 0xb7, 0x5a, 0xdb, 0xb5, 0xdd, 0x72, 3358 0x62, 0xeb, 0x73, 0x80, 0xd2, 0x76, 0xb5, 0xb6, 0x43, 0xb3, 0x9f, 0xd1, 0xd1, 0x44, 0xff, 0x2a, 3359 0xc5, 0x8a, 0xeb, 0x99, 0x37, 0xb2, 0xd2, 0xec, 0xf6, 0x1d, 0x7a, 0x00, 0x69, 0x56, 0x77, 0xa3, 3360 0xd9, 0x57, 0xb4, 0xd2, 0x9c, 0x7e, 0x1e, 0xfd, 0x31, 0x2c, 0x3c, 0x66, 0xde, 0xd9, 0x4a, 0xb3, 3361 0xdb, 0x7b, 0x48, 0x81, 0xbc, 0x5f, 0x38, 0xcf, 0xbf, 0xc3, 0x95, 0x16, 0x68, 0xf9, 0x51, 0x9b, 3362 0x7e, 0x59, 0x30, 0xff, 0x4e, 0x53, 0x5a, 0x00, 0xc0, 0xd0, 0x1e, 0x64, 0xdd, 0x82, 0x6b, 0xde, 3363 0x2d, 0xab, 0x34, 0xb7, 0x1d, 0x47, 0x3f, 0x01, 0x2f, 0x8c, 0x67, 0x5f, 0x19, 0x4b, 0x73, 0x7a, 3364 0x8b, 0x68, 0x07, 0x32, 0x82, 0xeb, 0xce, 0xb9, 0x39, 0x95, 0xe6, 0xb5, 0xd7, 0xa8, 0xd3, 0xfc, 3365 0x8e, 0xc3, 0xfc, 0x8b, 0x70, 0x69, 0x81, 0xb6, 0x29, 0x7a, 0x08, 0x10, 0x28, 0x83, 0x17, 0xb8, 3366 0xe1, 0x96, 0x16, 0x69, 0x87, 0xa2, 0x26, 0xe4, 0xbc, 0x72, 0x67, 0xee, 0x7d, 0xb3, 0x34, 0xbf, 3367 0x2f, 0x89, 0x1e, 0x43, 0x21, 0xcc, 0xf3, 0x17, 0xbb, 0x45, 0x96, 0x16, 0x6c, 0x38, 0x52, 0xfb, 3368 0x61, 0xd2, 0xbf, 0xd8, 0xad, 0xb2, 0xb4, 0x60, 0xff, 0x11, 0x7d, 0x02, 0x2b, 0x93, 0xa4, 0x7c, 3369 0xf1, 0x4b, 0x66, 0xe9, 0x0c, 0x1d, 0x49, 0x34, 0x00, 0x34, 0x85, 0xcc, 0x9f, 0xe1, 0xce, 0x59, 3370 0x3a, 0x4b, 0x83, 0xb2, 0x5a, 0xff, 0xea, 0xf9, 0x5a, 0xfc, 0xeb, 0xe7, 0x6b, 0xf1, 0x7f, 0x3c, 3371 0x5f, 0x8b, 0x7f, 0xf1, 0x62, 0x2d, 0xf6, 0xf5, 0x8b, 0xb5, 0xd8, 0xdf, 0x5e, 0xac, 0xc5, 0x7e, 3372 0xf9, 0x5a, 0xd7, 0x20, 0xbd, 0x51, 0x7b, 0xa3, 0x63, 0x0d, 0x36, 0x83, 0x7f, 0x88, 0x99, 0xf6, 3373 0x27, 0x9d, 0x76, 0x86, 0x25, 0xaa, 0x5b, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x3b, 0xae, 0x48, 3374 0xb4, 0xc4, 0x23, 0x00, 0x00, 3375 } 3376 3377 // Reference imports to suppress errors if they are not otherwise used. 3378 var _ context.Context 3379 var _ grpc.ClientConn 3380 3381 // This is a compile-time assertion to ensure that this generated file 3382 // is compatible with the grpc package it is being compiled against. 3383 const _ = grpc.SupportPackageIsVersion4 3384 3385 // ABCIApplicationClient is the client API for ABCIApplication service. 3386 // 3387 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. 3388 type ABCIApplicationClient interface { 3389 Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) 3390 Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) 3391 Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) 3392 SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) 3393 DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) 3394 CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) 3395 Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) 3396 Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) 3397 InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) 3398 BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) 3399 EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) 3400 ListSnapshots(ctx context.Context, in *RequestListSnapshots, opts ...grpc.CallOption) (*ResponseListSnapshots, error) 3401 OfferSnapshot(ctx context.Context, in *RequestOfferSnapshot, opts ...grpc.CallOption) (*ResponseOfferSnapshot, error) 3402 LoadSnapshotChunk(ctx context.Context, in *RequestLoadSnapshotChunk, opts ...grpc.CallOption) (*ResponseLoadSnapshotChunk, error) 3403 ApplySnapshotChunk(ctx context.Context, in *RequestApplySnapshotChunk, opts ...grpc.CallOption) (*ResponseApplySnapshotChunk, error) 3404 } 3405 3406 type aBCIApplicationClient struct { 3407 cc *grpc.ClientConn 3408 } 3409 3410 func NewABCIApplicationClient(cc *grpc.ClientConn) ABCIApplicationClient { 3411 return &aBCIApplicationClient{cc} 3412 } 3413 3414 func (c *aBCIApplicationClient) Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) { 3415 out := new(ResponseEcho) 3416 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/Echo", in, out, opts...) 3417 if err != nil { 3418 return nil, err 3419 } 3420 return out, nil 3421 } 3422 3423 func (c *aBCIApplicationClient) Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) { 3424 out := new(ResponseFlush) 3425 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/Flush", in, out, opts...) 3426 if err != nil { 3427 return nil, err 3428 } 3429 return out, nil 3430 } 3431 3432 func (c *aBCIApplicationClient) Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) { 3433 out := new(ResponseInfo) 3434 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/Info", in, out, opts...) 3435 if err != nil { 3436 return nil, err 3437 } 3438 return out, nil 3439 } 3440 3441 func (c *aBCIApplicationClient) SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) { 3442 out := new(ResponseSetOption) 3443 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/SetOption", in, out, opts...) 3444 if err != nil { 3445 return nil, err 3446 } 3447 return out, nil 3448 } 3449 3450 func (c *aBCIApplicationClient) DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) { 3451 out := new(ResponseDeliverTx) 3452 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/DeliverTx", in, out, opts...) 3453 if err != nil { 3454 return nil, err 3455 } 3456 return out, nil 3457 } 3458 3459 func (c *aBCIApplicationClient) CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) { 3460 out := new(ResponseCheckTx) 3461 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/CheckTx", in, out, opts...) 3462 if err != nil { 3463 return nil, err 3464 } 3465 return out, nil 3466 } 3467 3468 func (c *aBCIApplicationClient) Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) { 3469 out := new(ResponseQuery) 3470 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/Query", in, out, opts...) 3471 if err != nil { 3472 return nil, err 3473 } 3474 return out, nil 3475 } 3476 3477 func (c *aBCIApplicationClient) Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) { 3478 out := new(ResponseCommit) 3479 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/Commit", in, out, opts...) 3480 if err != nil { 3481 return nil, err 3482 } 3483 return out, nil 3484 } 3485 3486 func (c *aBCIApplicationClient) InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) { 3487 out := new(ResponseInitChain) 3488 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/InitChain", in, out, opts...) 3489 if err != nil { 3490 return nil, err 3491 } 3492 return out, nil 3493 } 3494 3495 func (c *aBCIApplicationClient) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) { 3496 out := new(ResponseBeginBlock) 3497 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/BeginBlock", in, out, opts...) 3498 if err != nil { 3499 return nil, err 3500 } 3501 return out, nil 3502 } 3503 3504 func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) { 3505 out := new(ResponseEndBlock) 3506 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/EndBlock", in, out, opts...) 3507 if err != nil { 3508 return nil, err 3509 } 3510 return out, nil 3511 } 3512 3513 func (c *aBCIApplicationClient) ListSnapshots(ctx context.Context, in *RequestListSnapshots, opts ...grpc.CallOption) (*ResponseListSnapshots, error) { 3514 out := new(ResponseListSnapshots) 3515 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/ListSnapshots", in, out, opts...) 3516 if err != nil { 3517 return nil, err 3518 } 3519 return out, nil 3520 } 3521 3522 func (c *aBCIApplicationClient) OfferSnapshot(ctx context.Context, in *RequestOfferSnapshot, opts ...grpc.CallOption) (*ResponseOfferSnapshot, error) { 3523 out := new(ResponseOfferSnapshot) 3524 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/OfferSnapshot", in, out, opts...) 3525 if err != nil { 3526 return nil, err 3527 } 3528 return out, nil 3529 } 3530 3531 func (c *aBCIApplicationClient) LoadSnapshotChunk(ctx context.Context, in *RequestLoadSnapshotChunk, opts ...grpc.CallOption) (*ResponseLoadSnapshotChunk, error) { 3532 out := new(ResponseLoadSnapshotChunk) 3533 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/LoadSnapshotChunk", in, out, opts...) 3534 if err != nil { 3535 return nil, err 3536 } 3537 return out, nil 3538 } 3539 3540 func (c *aBCIApplicationClient) ApplySnapshotChunk(ctx context.Context, in *RequestApplySnapshotChunk, opts ...grpc.CallOption) (*ResponseApplySnapshotChunk, error) { 3541 out := new(ResponseApplySnapshotChunk) 3542 err := c.cc.Invoke(ctx, "/tendermint.abci.ABCIApplication/ApplySnapshotChunk", in, out, opts...) 3543 if err != nil { 3544 return nil, err 3545 } 3546 return out, nil 3547 } 3548 3549 // ABCIApplicationServer is the server API for ABCIApplication service. 3550 type ABCIApplicationServer interface { 3551 Echo(context.Context, *RequestEcho) (*ResponseEcho, error) 3552 Flush(context.Context, *RequestFlush) (*ResponseFlush, error) 3553 Info(context.Context, *RequestInfo) (*ResponseInfo, error) 3554 SetOption(context.Context, *RequestSetOption) (*ResponseSetOption, error) 3555 DeliverTx(context.Context, *RequestDeliverTx) (*ResponseDeliverTx, error) 3556 CheckTx(context.Context, *RequestCheckTx) (*ResponseCheckTx, error) 3557 Query(context.Context, *RequestQuery) (*ResponseQuery, error) 3558 Commit(context.Context, *RequestCommit) (*ResponseCommit, error) 3559 InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error) 3560 BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error) 3561 EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error) 3562 ListSnapshots(context.Context, *RequestListSnapshots) (*ResponseListSnapshots, error) 3563 OfferSnapshot(context.Context, *RequestOfferSnapshot) (*ResponseOfferSnapshot, error) 3564 LoadSnapshotChunk(context.Context, *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error) 3565 ApplySnapshotChunk(context.Context, *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error) 3566 } 3567 3568 // UnimplementedABCIApplicationServer can be embedded to have forward compatible implementations. 3569 type UnimplementedABCIApplicationServer struct { 3570 } 3571 3572 func (*UnimplementedABCIApplicationServer) Echo(ctx context.Context, req *RequestEcho) (*ResponseEcho, error) { 3573 return nil, status.Errorf(codes.Unimplemented, "method Echo not implemented") 3574 } 3575 func (*UnimplementedABCIApplicationServer) Flush(ctx context.Context, req *RequestFlush) (*ResponseFlush, error) { 3576 return nil, status.Errorf(codes.Unimplemented, "method Flush not implemented") 3577 } 3578 func (*UnimplementedABCIApplicationServer) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) { 3579 return nil, status.Errorf(codes.Unimplemented, "method Info not implemented") 3580 } 3581 func (*UnimplementedABCIApplicationServer) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) { 3582 return nil, status.Errorf(codes.Unimplemented, "method SetOption not implemented") 3583 } 3584 func (*UnimplementedABCIApplicationServer) DeliverTx(ctx context.Context, req *RequestDeliverTx) (*ResponseDeliverTx, error) { 3585 return nil, status.Errorf(codes.Unimplemented, "method DeliverTx not implemented") 3586 } 3587 func (*UnimplementedABCIApplicationServer) CheckTx(ctx context.Context, req *RequestCheckTx) (*ResponseCheckTx, error) { 3588 return nil, status.Errorf(codes.Unimplemented, "method CheckTx not implemented") 3589 } 3590 func (*UnimplementedABCIApplicationServer) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) { 3591 return nil, status.Errorf(codes.Unimplemented, "method Query not implemented") 3592 } 3593 func (*UnimplementedABCIApplicationServer) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) { 3594 return nil, status.Errorf(codes.Unimplemented, "method Commit not implemented") 3595 } 3596 func (*UnimplementedABCIApplicationServer) InitChain(ctx context.Context, req *RequestInitChain) (*ResponseInitChain, error) { 3597 return nil, status.Errorf(codes.Unimplemented, "method InitChain not implemented") 3598 } 3599 func (*UnimplementedABCIApplicationServer) BeginBlock(ctx context.Context, req *RequestBeginBlock) (*ResponseBeginBlock, error) { 3600 return nil, status.Errorf(codes.Unimplemented, "method BeginBlock not implemented") 3601 } 3602 func (*UnimplementedABCIApplicationServer) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) { 3603 return nil, status.Errorf(codes.Unimplemented, "method EndBlock not implemented") 3604 } 3605 func (*UnimplementedABCIApplicationServer) ListSnapshots(ctx context.Context, req *RequestListSnapshots) (*ResponseListSnapshots, error) { 3606 return nil, status.Errorf(codes.Unimplemented, "method ListSnapshots not implemented") 3607 } 3608 func (*UnimplementedABCIApplicationServer) OfferSnapshot(ctx context.Context, req *RequestOfferSnapshot) (*ResponseOfferSnapshot, error) { 3609 return nil, status.Errorf(codes.Unimplemented, "method OfferSnapshot not implemented") 3610 } 3611 func (*UnimplementedABCIApplicationServer) LoadSnapshotChunk(ctx context.Context, req *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error) { 3612 return nil, status.Errorf(codes.Unimplemented, "method LoadSnapshotChunk not implemented") 3613 } 3614 func (*UnimplementedABCIApplicationServer) ApplySnapshotChunk(ctx context.Context, req *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error) { 3615 return nil, status.Errorf(codes.Unimplemented, "method ApplySnapshotChunk not implemented") 3616 } 3617 3618 func RegisterABCIApplicationServer(s *grpc.Server, srv ABCIApplicationServer) { 3619 s.RegisterService(&_ABCIApplication_serviceDesc, srv) 3620 } 3621 3622 func _ABCIApplication_Echo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3623 in := new(RequestEcho) 3624 if err := dec(in); err != nil { 3625 return nil, err 3626 } 3627 if interceptor == nil { 3628 return srv.(ABCIApplicationServer).Echo(ctx, in) 3629 } 3630 info := &grpc.UnaryServerInfo{ 3631 Server: srv, 3632 FullMethod: "/tendermint.abci.ABCIApplication/Echo", 3633 } 3634 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3635 return srv.(ABCIApplicationServer).Echo(ctx, req.(*RequestEcho)) 3636 } 3637 return interceptor(ctx, in, info, handler) 3638 } 3639 3640 func _ABCIApplication_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3641 in := new(RequestFlush) 3642 if err := dec(in); err != nil { 3643 return nil, err 3644 } 3645 if interceptor == nil { 3646 return srv.(ABCIApplicationServer).Flush(ctx, in) 3647 } 3648 info := &grpc.UnaryServerInfo{ 3649 Server: srv, 3650 FullMethod: "/tendermint.abci.ABCIApplication/Flush", 3651 } 3652 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3653 return srv.(ABCIApplicationServer).Flush(ctx, req.(*RequestFlush)) 3654 } 3655 return interceptor(ctx, in, info, handler) 3656 } 3657 3658 func _ABCIApplication_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3659 in := new(RequestInfo) 3660 if err := dec(in); err != nil { 3661 return nil, err 3662 } 3663 if interceptor == nil { 3664 return srv.(ABCIApplicationServer).Info(ctx, in) 3665 } 3666 info := &grpc.UnaryServerInfo{ 3667 Server: srv, 3668 FullMethod: "/tendermint.abci.ABCIApplication/Info", 3669 } 3670 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3671 return srv.(ABCIApplicationServer).Info(ctx, req.(*RequestInfo)) 3672 } 3673 return interceptor(ctx, in, info, handler) 3674 } 3675 3676 func _ABCIApplication_SetOption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3677 in := new(RequestSetOption) 3678 if err := dec(in); err != nil { 3679 return nil, err 3680 } 3681 if interceptor == nil { 3682 return srv.(ABCIApplicationServer).SetOption(ctx, in) 3683 } 3684 info := &grpc.UnaryServerInfo{ 3685 Server: srv, 3686 FullMethod: "/tendermint.abci.ABCIApplication/SetOption", 3687 } 3688 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3689 return srv.(ABCIApplicationServer).SetOption(ctx, req.(*RequestSetOption)) 3690 } 3691 return interceptor(ctx, in, info, handler) 3692 } 3693 3694 func _ABCIApplication_DeliverTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3695 in := new(RequestDeliverTx) 3696 if err := dec(in); err != nil { 3697 return nil, err 3698 } 3699 if interceptor == nil { 3700 return srv.(ABCIApplicationServer).DeliverTx(ctx, in) 3701 } 3702 info := &grpc.UnaryServerInfo{ 3703 Server: srv, 3704 FullMethod: "/tendermint.abci.ABCIApplication/DeliverTx", 3705 } 3706 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3707 return srv.(ABCIApplicationServer).DeliverTx(ctx, req.(*RequestDeliverTx)) 3708 } 3709 return interceptor(ctx, in, info, handler) 3710 } 3711 3712 func _ABCIApplication_CheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3713 in := new(RequestCheckTx) 3714 if err := dec(in); err != nil { 3715 return nil, err 3716 } 3717 if interceptor == nil { 3718 return srv.(ABCIApplicationServer).CheckTx(ctx, in) 3719 } 3720 info := &grpc.UnaryServerInfo{ 3721 Server: srv, 3722 FullMethod: "/tendermint.abci.ABCIApplication/CheckTx", 3723 } 3724 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3725 return srv.(ABCIApplicationServer).CheckTx(ctx, req.(*RequestCheckTx)) 3726 } 3727 return interceptor(ctx, in, info, handler) 3728 } 3729 3730 func _ABCIApplication_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3731 in := new(RequestQuery) 3732 if err := dec(in); err != nil { 3733 return nil, err 3734 } 3735 if interceptor == nil { 3736 return srv.(ABCIApplicationServer).Query(ctx, in) 3737 } 3738 info := &grpc.UnaryServerInfo{ 3739 Server: srv, 3740 FullMethod: "/tendermint.abci.ABCIApplication/Query", 3741 } 3742 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3743 return srv.(ABCIApplicationServer).Query(ctx, req.(*RequestQuery)) 3744 } 3745 return interceptor(ctx, in, info, handler) 3746 } 3747 3748 func _ABCIApplication_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3749 in := new(RequestCommit) 3750 if err := dec(in); err != nil { 3751 return nil, err 3752 } 3753 if interceptor == nil { 3754 return srv.(ABCIApplicationServer).Commit(ctx, in) 3755 } 3756 info := &grpc.UnaryServerInfo{ 3757 Server: srv, 3758 FullMethod: "/tendermint.abci.ABCIApplication/Commit", 3759 } 3760 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3761 return srv.(ABCIApplicationServer).Commit(ctx, req.(*RequestCommit)) 3762 } 3763 return interceptor(ctx, in, info, handler) 3764 } 3765 3766 func _ABCIApplication_InitChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3767 in := new(RequestInitChain) 3768 if err := dec(in); err != nil { 3769 return nil, err 3770 } 3771 if interceptor == nil { 3772 return srv.(ABCIApplicationServer).InitChain(ctx, in) 3773 } 3774 info := &grpc.UnaryServerInfo{ 3775 Server: srv, 3776 FullMethod: "/tendermint.abci.ABCIApplication/InitChain", 3777 } 3778 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3779 return srv.(ABCIApplicationServer).InitChain(ctx, req.(*RequestInitChain)) 3780 } 3781 return interceptor(ctx, in, info, handler) 3782 } 3783 3784 func _ABCIApplication_BeginBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3785 in := new(RequestBeginBlock) 3786 if err := dec(in); err != nil { 3787 return nil, err 3788 } 3789 if interceptor == nil { 3790 return srv.(ABCIApplicationServer).BeginBlock(ctx, in) 3791 } 3792 info := &grpc.UnaryServerInfo{ 3793 Server: srv, 3794 FullMethod: "/tendermint.abci.ABCIApplication/BeginBlock", 3795 } 3796 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3797 return srv.(ABCIApplicationServer).BeginBlock(ctx, req.(*RequestBeginBlock)) 3798 } 3799 return interceptor(ctx, in, info, handler) 3800 } 3801 3802 func _ABCIApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3803 in := new(RequestEndBlock) 3804 if err := dec(in); err != nil { 3805 return nil, err 3806 } 3807 if interceptor == nil { 3808 return srv.(ABCIApplicationServer).EndBlock(ctx, in) 3809 } 3810 info := &grpc.UnaryServerInfo{ 3811 Server: srv, 3812 FullMethod: "/tendermint.abci.ABCIApplication/EndBlock", 3813 } 3814 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3815 return srv.(ABCIApplicationServer).EndBlock(ctx, req.(*RequestEndBlock)) 3816 } 3817 return interceptor(ctx, in, info, handler) 3818 } 3819 3820 func _ABCIApplication_ListSnapshots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3821 in := new(RequestListSnapshots) 3822 if err := dec(in); err != nil { 3823 return nil, err 3824 } 3825 if interceptor == nil { 3826 return srv.(ABCIApplicationServer).ListSnapshots(ctx, in) 3827 } 3828 info := &grpc.UnaryServerInfo{ 3829 Server: srv, 3830 FullMethod: "/tendermint.abci.ABCIApplication/ListSnapshots", 3831 } 3832 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3833 return srv.(ABCIApplicationServer).ListSnapshots(ctx, req.(*RequestListSnapshots)) 3834 } 3835 return interceptor(ctx, in, info, handler) 3836 } 3837 3838 func _ABCIApplication_OfferSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3839 in := new(RequestOfferSnapshot) 3840 if err := dec(in); err != nil { 3841 return nil, err 3842 } 3843 if interceptor == nil { 3844 return srv.(ABCIApplicationServer).OfferSnapshot(ctx, in) 3845 } 3846 info := &grpc.UnaryServerInfo{ 3847 Server: srv, 3848 FullMethod: "/tendermint.abci.ABCIApplication/OfferSnapshot", 3849 } 3850 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3851 return srv.(ABCIApplicationServer).OfferSnapshot(ctx, req.(*RequestOfferSnapshot)) 3852 } 3853 return interceptor(ctx, in, info, handler) 3854 } 3855 3856 func _ABCIApplication_LoadSnapshotChunk_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3857 in := new(RequestLoadSnapshotChunk) 3858 if err := dec(in); err != nil { 3859 return nil, err 3860 } 3861 if interceptor == nil { 3862 return srv.(ABCIApplicationServer).LoadSnapshotChunk(ctx, in) 3863 } 3864 info := &grpc.UnaryServerInfo{ 3865 Server: srv, 3866 FullMethod: "/tendermint.abci.ABCIApplication/LoadSnapshotChunk", 3867 } 3868 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3869 return srv.(ABCIApplicationServer).LoadSnapshotChunk(ctx, req.(*RequestLoadSnapshotChunk)) 3870 } 3871 return interceptor(ctx, in, info, handler) 3872 } 3873 3874 func _ABCIApplication_ApplySnapshotChunk_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { 3875 in := new(RequestApplySnapshotChunk) 3876 if err := dec(in); err != nil { 3877 return nil, err 3878 } 3879 if interceptor == nil { 3880 return srv.(ABCIApplicationServer).ApplySnapshotChunk(ctx, in) 3881 } 3882 info := &grpc.UnaryServerInfo{ 3883 Server: srv, 3884 FullMethod: "/tendermint.abci.ABCIApplication/ApplySnapshotChunk", 3885 } 3886 handler := func(ctx context.Context, req interface{}) (interface{}, error) { 3887 return srv.(ABCIApplicationServer).ApplySnapshotChunk(ctx, req.(*RequestApplySnapshotChunk)) 3888 } 3889 return interceptor(ctx, in, info, handler) 3890 } 3891 3892 var _ABCIApplication_serviceDesc = grpc.ServiceDesc{ 3893 ServiceName: "tendermint.abci.ABCIApplication", 3894 HandlerType: (*ABCIApplicationServer)(nil), 3895 Methods: []grpc.MethodDesc{ 3896 { 3897 MethodName: "Echo", 3898 Handler: _ABCIApplication_Echo_Handler, 3899 }, 3900 { 3901 MethodName: "Flush", 3902 Handler: _ABCIApplication_Flush_Handler, 3903 }, 3904 { 3905 MethodName: "Info", 3906 Handler: _ABCIApplication_Info_Handler, 3907 }, 3908 { 3909 MethodName: "SetOption", 3910 Handler: _ABCIApplication_SetOption_Handler, 3911 }, 3912 { 3913 MethodName: "DeliverTx", 3914 Handler: _ABCIApplication_DeliverTx_Handler, 3915 }, 3916 { 3917 MethodName: "CheckTx", 3918 Handler: _ABCIApplication_CheckTx_Handler, 3919 }, 3920 { 3921 MethodName: "Query", 3922 Handler: _ABCIApplication_Query_Handler, 3923 }, 3924 { 3925 MethodName: "Commit", 3926 Handler: _ABCIApplication_Commit_Handler, 3927 }, 3928 { 3929 MethodName: "InitChain", 3930 Handler: _ABCIApplication_InitChain_Handler, 3931 }, 3932 { 3933 MethodName: "BeginBlock", 3934 Handler: _ABCIApplication_BeginBlock_Handler, 3935 }, 3936 { 3937 MethodName: "EndBlock", 3938 Handler: _ABCIApplication_EndBlock_Handler, 3939 }, 3940 { 3941 MethodName: "ListSnapshots", 3942 Handler: _ABCIApplication_ListSnapshots_Handler, 3943 }, 3944 { 3945 MethodName: "OfferSnapshot", 3946 Handler: _ABCIApplication_OfferSnapshot_Handler, 3947 }, 3948 { 3949 MethodName: "LoadSnapshotChunk", 3950 Handler: _ABCIApplication_LoadSnapshotChunk_Handler, 3951 }, 3952 { 3953 MethodName: "ApplySnapshotChunk", 3954 Handler: _ABCIApplication_ApplySnapshotChunk_Handler, 3955 }, 3956 }, 3957 Streams: []grpc.StreamDesc{}, 3958 Metadata: "tendermint/abci/types.proto", 3959 } 3960 3961 func (m *Request) Marshal() (dAtA []byte, err error) { 3962 size := m.Size() 3963 dAtA = make([]byte, size) 3964 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 3965 if err != nil { 3966 return nil, err 3967 } 3968 return dAtA[:n], nil 3969 } 3970 3971 func (m *Request) MarshalTo(dAtA []byte) (int, error) { 3972 size := m.Size() 3973 return m.MarshalToSizedBuffer(dAtA[:size]) 3974 } 3975 3976 func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3977 i := len(dAtA) 3978 _ = i 3979 var l int 3980 _ = l 3981 if m.Value != nil { 3982 { 3983 size := m.Value.Size() 3984 i -= size 3985 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { 3986 return 0, err 3987 } 3988 } 3989 } 3990 return len(dAtA) - i, nil 3991 } 3992 3993 func (m *Request_Echo) MarshalTo(dAtA []byte) (int, error) { 3994 size := m.Size() 3995 return m.MarshalToSizedBuffer(dAtA[:size]) 3996 } 3997 3998 func (m *Request_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 3999 i := len(dAtA) 4000 if m.Echo != nil { 4001 { 4002 size, err := m.Echo.MarshalToSizedBuffer(dAtA[:i]) 4003 if err != nil { 4004 return 0, err 4005 } 4006 i -= size 4007 i = encodeVarintTypes(dAtA, i, uint64(size)) 4008 } 4009 i-- 4010 dAtA[i] = 0xa 4011 } 4012 return len(dAtA) - i, nil 4013 } 4014 func (m *Request_Flush) MarshalTo(dAtA []byte) (int, error) { 4015 size := m.Size() 4016 return m.MarshalToSizedBuffer(dAtA[:size]) 4017 } 4018 4019 func (m *Request_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4020 i := len(dAtA) 4021 if m.Flush != nil { 4022 { 4023 size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i]) 4024 if err != nil { 4025 return 0, err 4026 } 4027 i -= size 4028 i = encodeVarintTypes(dAtA, i, uint64(size)) 4029 } 4030 i-- 4031 dAtA[i] = 0x12 4032 } 4033 return len(dAtA) - i, nil 4034 } 4035 func (m *Request_Info) MarshalTo(dAtA []byte) (int, error) { 4036 size := m.Size() 4037 return m.MarshalToSizedBuffer(dAtA[:size]) 4038 } 4039 4040 func (m *Request_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4041 i := len(dAtA) 4042 if m.Info != nil { 4043 { 4044 size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) 4045 if err != nil { 4046 return 0, err 4047 } 4048 i -= size 4049 i = encodeVarintTypes(dAtA, i, uint64(size)) 4050 } 4051 i-- 4052 dAtA[i] = 0x1a 4053 } 4054 return len(dAtA) - i, nil 4055 } 4056 func (m *Request_SetOption) MarshalTo(dAtA []byte) (int, error) { 4057 size := m.Size() 4058 return m.MarshalToSizedBuffer(dAtA[:size]) 4059 } 4060 4061 func (m *Request_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4062 i := len(dAtA) 4063 if m.SetOption != nil { 4064 { 4065 size, err := m.SetOption.MarshalToSizedBuffer(dAtA[:i]) 4066 if err != nil { 4067 return 0, err 4068 } 4069 i -= size 4070 i = encodeVarintTypes(dAtA, i, uint64(size)) 4071 } 4072 i-- 4073 dAtA[i] = 0x22 4074 } 4075 return len(dAtA) - i, nil 4076 } 4077 func (m *Request_InitChain) MarshalTo(dAtA []byte) (int, error) { 4078 size := m.Size() 4079 return m.MarshalToSizedBuffer(dAtA[:size]) 4080 } 4081 4082 func (m *Request_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4083 i := len(dAtA) 4084 if m.InitChain != nil { 4085 { 4086 size, err := m.InitChain.MarshalToSizedBuffer(dAtA[:i]) 4087 if err != nil { 4088 return 0, err 4089 } 4090 i -= size 4091 i = encodeVarintTypes(dAtA, i, uint64(size)) 4092 } 4093 i-- 4094 dAtA[i] = 0x2a 4095 } 4096 return len(dAtA) - i, nil 4097 } 4098 func (m *Request_Query) MarshalTo(dAtA []byte) (int, error) { 4099 size := m.Size() 4100 return m.MarshalToSizedBuffer(dAtA[:size]) 4101 } 4102 4103 func (m *Request_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4104 i := len(dAtA) 4105 if m.Query != nil { 4106 { 4107 size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) 4108 if err != nil { 4109 return 0, err 4110 } 4111 i -= size 4112 i = encodeVarintTypes(dAtA, i, uint64(size)) 4113 } 4114 i-- 4115 dAtA[i] = 0x32 4116 } 4117 return len(dAtA) - i, nil 4118 } 4119 func (m *Request_BeginBlock) MarshalTo(dAtA []byte) (int, error) { 4120 size := m.Size() 4121 return m.MarshalToSizedBuffer(dAtA[:size]) 4122 } 4123 4124 func (m *Request_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4125 i := len(dAtA) 4126 if m.BeginBlock != nil { 4127 { 4128 size, err := m.BeginBlock.MarshalToSizedBuffer(dAtA[:i]) 4129 if err != nil { 4130 return 0, err 4131 } 4132 i -= size 4133 i = encodeVarintTypes(dAtA, i, uint64(size)) 4134 } 4135 i-- 4136 dAtA[i] = 0x3a 4137 } 4138 return len(dAtA) - i, nil 4139 } 4140 func (m *Request_CheckTx) MarshalTo(dAtA []byte) (int, error) { 4141 size := m.Size() 4142 return m.MarshalToSizedBuffer(dAtA[:size]) 4143 } 4144 4145 func (m *Request_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4146 i := len(dAtA) 4147 if m.CheckTx != nil { 4148 { 4149 size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i]) 4150 if err != nil { 4151 return 0, err 4152 } 4153 i -= size 4154 i = encodeVarintTypes(dAtA, i, uint64(size)) 4155 } 4156 i-- 4157 dAtA[i] = 0x42 4158 } 4159 return len(dAtA) - i, nil 4160 } 4161 func (m *Request_DeliverTx) MarshalTo(dAtA []byte) (int, error) { 4162 size := m.Size() 4163 return m.MarshalToSizedBuffer(dAtA[:size]) 4164 } 4165 4166 func (m *Request_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4167 i := len(dAtA) 4168 if m.DeliverTx != nil { 4169 { 4170 size, err := m.DeliverTx.MarshalToSizedBuffer(dAtA[:i]) 4171 if err != nil { 4172 return 0, err 4173 } 4174 i -= size 4175 i = encodeVarintTypes(dAtA, i, uint64(size)) 4176 } 4177 i-- 4178 dAtA[i] = 0x4a 4179 } 4180 return len(dAtA) - i, nil 4181 } 4182 func (m *Request_EndBlock) MarshalTo(dAtA []byte) (int, error) { 4183 size := m.Size() 4184 return m.MarshalToSizedBuffer(dAtA[:size]) 4185 } 4186 4187 func (m *Request_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4188 i := len(dAtA) 4189 if m.EndBlock != nil { 4190 { 4191 size, err := m.EndBlock.MarshalToSizedBuffer(dAtA[:i]) 4192 if err != nil { 4193 return 0, err 4194 } 4195 i -= size 4196 i = encodeVarintTypes(dAtA, i, uint64(size)) 4197 } 4198 i-- 4199 dAtA[i] = 0x52 4200 } 4201 return len(dAtA) - i, nil 4202 } 4203 func (m *Request_Commit) MarshalTo(dAtA []byte) (int, error) { 4204 size := m.Size() 4205 return m.MarshalToSizedBuffer(dAtA[:size]) 4206 } 4207 4208 func (m *Request_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4209 i := len(dAtA) 4210 if m.Commit != nil { 4211 { 4212 size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) 4213 if err != nil { 4214 return 0, err 4215 } 4216 i -= size 4217 i = encodeVarintTypes(dAtA, i, uint64(size)) 4218 } 4219 i-- 4220 dAtA[i] = 0x5a 4221 } 4222 return len(dAtA) - i, nil 4223 } 4224 func (m *Request_ListSnapshots) MarshalTo(dAtA []byte) (int, error) { 4225 size := m.Size() 4226 return m.MarshalToSizedBuffer(dAtA[:size]) 4227 } 4228 4229 func (m *Request_ListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4230 i := len(dAtA) 4231 if m.ListSnapshots != nil { 4232 { 4233 size, err := m.ListSnapshots.MarshalToSizedBuffer(dAtA[:i]) 4234 if err != nil { 4235 return 0, err 4236 } 4237 i -= size 4238 i = encodeVarintTypes(dAtA, i, uint64(size)) 4239 } 4240 i-- 4241 dAtA[i] = 0x62 4242 } 4243 return len(dAtA) - i, nil 4244 } 4245 func (m *Request_OfferSnapshot) MarshalTo(dAtA []byte) (int, error) { 4246 size := m.Size() 4247 return m.MarshalToSizedBuffer(dAtA[:size]) 4248 } 4249 4250 func (m *Request_OfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4251 i := len(dAtA) 4252 if m.OfferSnapshot != nil { 4253 { 4254 size, err := m.OfferSnapshot.MarshalToSizedBuffer(dAtA[:i]) 4255 if err != nil { 4256 return 0, err 4257 } 4258 i -= size 4259 i = encodeVarintTypes(dAtA, i, uint64(size)) 4260 } 4261 i-- 4262 dAtA[i] = 0x6a 4263 } 4264 return len(dAtA) - i, nil 4265 } 4266 func (m *Request_LoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 4267 size := m.Size() 4268 return m.MarshalToSizedBuffer(dAtA[:size]) 4269 } 4270 4271 func (m *Request_LoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4272 i := len(dAtA) 4273 if m.LoadSnapshotChunk != nil { 4274 { 4275 size, err := m.LoadSnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) 4276 if err != nil { 4277 return 0, err 4278 } 4279 i -= size 4280 i = encodeVarintTypes(dAtA, i, uint64(size)) 4281 } 4282 i-- 4283 dAtA[i] = 0x72 4284 } 4285 return len(dAtA) - i, nil 4286 } 4287 func (m *Request_ApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 4288 size := m.Size() 4289 return m.MarshalToSizedBuffer(dAtA[:size]) 4290 } 4291 4292 func (m *Request_ApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4293 i := len(dAtA) 4294 if m.ApplySnapshotChunk != nil { 4295 { 4296 size, err := m.ApplySnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) 4297 if err != nil { 4298 return 0, err 4299 } 4300 i -= size 4301 i = encodeVarintTypes(dAtA, i, uint64(size)) 4302 } 4303 i-- 4304 dAtA[i] = 0x7a 4305 } 4306 return len(dAtA) - i, nil 4307 } 4308 func (m *RequestEcho) Marshal() (dAtA []byte, err error) { 4309 size := m.Size() 4310 dAtA = make([]byte, size) 4311 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4312 if err != nil { 4313 return nil, err 4314 } 4315 return dAtA[:n], nil 4316 } 4317 4318 func (m *RequestEcho) MarshalTo(dAtA []byte) (int, error) { 4319 size := m.Size() 4320 return m.MarshalToSizedBuffer(dAtA[:size]) 4321 } 4322 4323 func (m *RequestEcho) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4324 i := len(dAtA) 4325 _ = i 4326 var l int 4327 _ = l 4328 if len(m.Message) > 0 { 4329 i -= len(m.Message) 4330 copy(dAtA[i:], m.Message) 4331 i = encodeVarintTypes(dAtA, i, uint64(len(m.Message))) 4332 i-- 4333 dAtA[i] = 0xa 4334 } 4335 return len(dAtA) - i, nil 4336 } 4337 4338 func (m *RequestFlush) Marshal() (dAtA []byte, err error) { 4339 size := m.Size() 4340 dAtA = make([]byte, size) 4341 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4342 if err != nil { 4343 return nil, err 4344 } 4345 return dAtA[:n], nil 4346 } 4347 4348 func (m *RequestFlush) MarshalTo(dAtA []byte) (int, error) { 4349 size := m.Size() 4350 return m.MarshalToSizedBuffer(dAtA[:size]) 4351 } 4352 4353 func (m *RequestFlush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4354 i := len(dAtA) 4355 _ = i 4356 var l int 4357 _ = l 4358 return len(dAtA) - i, nil 4359 } 4360 4361 func (m *RequestInfo) Marshal() (dAtA []byte, err error) { 4362 size := m.Size() 4363 dAtA = make([]byte, size) 4364 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4365 if err != nil { 4366 return nil, err 4367 } 4368 return dAtA[:n], nil 4369 } 4370 4371 func (m *RequestInfo) MarshalTo(dAtA []byte) (int, error) { 4372 size := m.Size() 4373 return m.MarshalToSizedBuffer(dAtA[:size]) 4374 } 4375 4376 func (m *RequestInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4377 i := len(dAtA) 4378 _ = i 4379 var l int 4380 _ = l 4381 if m.P2PVersion != 0 { 4382 i = encodeVarintTypes(dAtA, i, uint64(m.P2PVersion)) 4383 i-- 4384 dAtA[i] = 0x18 4385 } 4386 if m.BlockVersion != 0 { 4387 i = encodeVarintTypes(dAtA, i, uint64(m.BlockVersion)) 4388 i-- 4389 dAtA[i] = 0x10 4390 } 4391 if len(m.Version) > 0 { 4392 i -= len(m.Version) 4393 copy(dAtA[i:], m.Version) 4394 i = encodeVarintTypes(dAtA, i, uint64(len(m.Version))) 4395 i-- 4396 dAtA[i] = 0xa 4397 } 4398 return len(dAtA) - i, nil 4399 } 4400 4401 func (m *RequestSetOption) Marshal() (dAtA []byte, err error) { 4402 size := m.Size() 4403 dAtA = make([]byte, size) 4404 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4405 if err != nil { 4406 return nil, err 4407 } 4408 return dAtA[:n], nil 4409 } 4410 4411 func (m *RequestSetOption) MarshalTo(dAtA []byte) (int, error) { 4412 size := m.Size() 4413 return m.MarshalToSizedBuffer(dAtA[:size]) 4414 } 4415 4416 func (m *RequestSetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4417 i := len(dAtA) 4418 _ = i 4419 var l int 4420 _ = l 4421 if len(m.Value) > 0 { 4422 i -= len(m.Value) 4423 copy(dAtA[i:], m.Value) 4424 i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) 4425 i-- 4426 dAtA[i] = 0x12 4427 } 4428 if len(m.Key) > 0 { 4429 i -= len(m.Key) 4430 copy(dAtA[i:], m.Key) 4431 i = encodeVarintTypes(dAtA, i, uint64(len(m.Key))) 4432 i-- 4433 dAtA[i] = 0xa 4434 } 4435 return len(dAtA) - i, nil 4436 } 4437 4438 func (m *RequestInitChain) Marshal() (dAtA []byte, err error) { 4439 size := m.Size() 4440 dAtA = make([]byte, size) 4441 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4442 if err != nil { 4443 return nil, err 4444 } 4445 return dAtA[:n], nil 4446 } 4447 4448 func (m *RequestInitChain) MarshalTo(dAtA []byte) (int, error) { 4449 size := m.Size() 4450 return m.MarshalToSizedBuffer(dAtA[:size]) 4451 } 4452 4453 func (m *RequestInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4454 i := len(dAtA) 4455 _ = i 4456 var l int 4457 _ = l 4458 if m.InitialHeight != 0 { 4459 i = encodeVarintTypes(dAtA, i, uint64(m.InitialHeight)) 4460 i-- 4461 dAtA[i] = 0x30 4462 } 4463 if len(m.AppStateBytes) > 0 { 4464 i -= len(m.AppStateBytes) 4465 copy(dAtA[i:], m.AppStateBytes) 4466 i = encodeVarintTypes(dAtA, i, uint64(len(m.AppStateBytes))) 4467 i-- 4468 dAtA[i] = 0x2a 4469 } 4470 if len(m.Validators) > 0 { 4471 for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { 4472 { 4473 size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 4474 if err != nil { 4475 return 0, err 4476 } 4477 i -= size 4478 i = encodeVarintTypes(dAtA, i, uint64(size)) 4479 } 4480 i-- 4481 dAtA[i] = 0x22 4482 } 4483 } 4484 if m.ConsensusParams != nil { 4485 { 4486 size, err := m.ConsensusParams.MarshalToSizedBuffer(dAtA[:i]) 4487 if err != nil { 4488 return 0, err 4489 } 4490 i -= size 4491 i = encodeVarintTypes(dAtA, i, uint64(size)) 4492 } 4493 i-- 4494 dAtA[i] = 0x1a 4495 } 4496 if len(m.ChainId) > 0 { 4497 i -= len(m.ChainId) 4498 copy(dAtA[i:], m.ChainId) 4499 i = encodeVarintTypes(dAtA, i, uint64(len(m.ChainId))) 4500 i-- 4501 dAtA[i] = 0x12 4502 } 4503 n17, err17 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) 4504 if err17 != nil { 4505 return 0, err17 4506 } 4507 i -= n17 4508 i = encodeVarintTypes(dAtA, i, uint64(n17)) 4509 i-- 4510 dAtA[i] = 0xa 4511 return len(dAtA) - i, nil 4512 } 4513 4514 func (m *RequestQuery) Marshal() (dAtA []byte, err error) { 4515 size := m.Size() 4516 dAtA = make([]byte, size) 4517 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4518 if err != nil { 4519 return nil, err 4520 } 4521 return dAtA[:n], nil 4522 } 4523 4524 func (m *RequestQuery) MarshalTo(dAtA []byte) (int, error) { 4525 size := m.Size() 4526 return m.MarshalToSizedBuffer(dAtA[:size]) 4527 } 4528 4529 func (m *RequestQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4530 i := len(dAtA) 4531 _ = i 4532 var l int 4533 _ = l 4534 if m.Prove { 4535 i-- 4536 if m.Prove { 4537 dAtA[i] = 1 4538 } else { 4539 dAtA[i] = 0 4540 } 4541 i-- 4542 dAtA[i] = 0x20 4543 } 4544 if m.Height != 0 { 4545 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 4546 i-- 4547 dAtA[i] = 0x18 4548 } 4549 if len(m.Path) > 0 { 4550 i -= len(m.Path) 4551 copy(dAtA[i:], m.Path) 4552 i = encodeVarintTypes(dAtA, i, uint64(len(m.Path))) 4553 i-- 4554 dAtA[i] = 0x12 4555 } 4556 if len(m.Data) > 0 { 4557 i -= len(m.Data) 4558 copy(dAtA[i:], m.Data) 4559 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 4560 i-- 4561 dAtA[i] = 0xa 4562 } 4563 return len(dAtA) - i, nil 4564 } 4565 4566 func (m *RequestBeginBlock) Marshal() (dAtA []byte, err error) { 4567 size := m.Size() 4568 dAtA = make([]byte, size) 4569 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4570 if err != nil { 4571 return nil, err 4572 } 4573 return dAtA[:n], nil 4574 } 4575 4576 func (m *RequestBeginBlock) MarshalTo(dAtA []byte) (int, error) { 4577 size := m.Size() 4578 return m.MarshalToSizedBuffer(dAtA[:size]) 4579 } 4580 4581 func (m *RequestBeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4582 i := len(dAtA) 4583 _ = i 4584 var l int 4585 _ = l 4586 if len(m.ByzantineValidators) > 0 { 4587 for iNdEx := len(m.ByzantineValidators) - 1; iNdEx >= 0; iNdEx-- { 4588 { 4589 size, err := m.ByzantineValidators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 4590 if err != nil { 4591 return 0, err 4592 } 4593 i -= size 4594 i = encodeVarintTypes(dAtA, i, uint64(size)) 4595 } 4596 i-- 4597 dAtA[i] = 0x22 4598 } 4599 } 4600 { 4601 size, err := m.LastCommitInfo.MarshalToSizedBuffer(dAtA[:i]) 4602 if err != nil { 4603 return 0, err 4604 } 4605 i -= size 4606 i = encodeVarintTypes(dAtA, i, uint64(size)) 4607 } 4608 i-- 4609 dAtA[i] = 0x1a 4610 { 4611 size, err := m.Header.MarshalToSizedBuffer(dAtA[:i]) 4612 if err != nil { 4613 return 0, err 4614 } 4615 i -= size 4616 i = encodeVarintTypes(dAtA, i, uint64(size)) 4617 } 4618 i-- 4619 dAtA[i] = 0x12 4620 if len(m.Hash) > 0 { 4621 i -= len(m.Hash) 4622 copy(dAtA[i:], m.Hash) 4623 i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) 4624 i-- 4625 dAtA[i] = 0xa 4626 } 4627 return len(dAtA) - i, nil 4628 } 4629 4630 func (m *RequestCheckTx) Marshal() (dAtA []byte, err error) { 4631 size := m.Size() 4632 dAtA = make([]byte, size) 4633 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4634 if err != nil { 4635 return nil, err 4636 } 4637 return dAtA[:n], nil 4638 } 4639 4640 func (m *RequestCheckTx) MarshalTo(dAtA []byte) (int, error) { 4641 size := m.Size() 4642 return m.MarshalToSizedBuffer(dAtA[:size]) 4643 } 4644 4645 func (m *RequestCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4646 i := len(dAtA) 4647 _ = i 4648 var l int 4649 _ = l 4650 if m.Type != 0 { 4651 i = encodeVarintTypes(dAtA, i, uint64(m.Type)) 4652 i-- 4653 dAtA[i] = 0x10 4654 } 4655 if len(m.Tx) > 0 { 4656 i -= len(m.Tx) 4657 copy(dAtA[i:], m.Tx) 4658 i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) 4659 i-- 4660 dAtA[i] = 0xa 4661 } 4662 return len(dAtA) - i, nil 4663 } 4664 4665 func (m *RequestDeliverTx) Marshal() (dAtA []byte, err error) { 4666 size := m.Size() 4667 dAtA = make([]byte, size) 4668 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4669 if err != nil { 4670 return nil, err 4671 } 4672 return dAtA[:n], nil 4673 } 4674 4675 func (m *RequestDeliverTx) MarshalTo(dAtA []byte) (int, error) { 4676 size := m.Size() 4677 return m.MarshalToSizedBuffer(dAtA[:size]) 4678 } 4679 4680 func (m *RequestDeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4681 i := len(dAtA) 4682 _ = i 4683 var l int 4684 _ = l 4685 if len(m.Tx) > 0 { 4686 i -= len(m.Tx) 4687 copy(dAtA[i:], m.Tx) 4688 i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) 4689 i-- 4690 dAtA[i] = 0xa 4691 } 4692 return len(dAtA) - i, nil 4693 } 4694 4695 func (m *RequestEndBlock) Marshal() (dAtA []byte, err error) { 4696 size := m.Size() 4697 dAtA = make([]byte, size) 4698 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4699 if err != nil { 4700 return nil, err 4701 } 4702 return dAtA[:n], nil 4703 } 4704 4705 func (m *RequestEndBlock) MarshalTo(dAtA []byte) (int, error) { 4706 size := m.Size() 4707 return m.MarshalToSizedBuffer(dAtA[:size]) 4708 } 4709 4710 func (m *RequestEndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4711 i := len(dAtA) 4712 _ = i 4713 var l int 4714 _ = l 4715 if m.Height != 0 { 4716 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 4717 i-- 4718 dAtA[i] = 0x8 4719 } 4720 return len(dAtA) - i, nil 4721 } 4722 4723 func (m *RequestCommit) Marshal() (dAtA []byte, err error) { 4724 size := m.Size() 4725 dAtA = make([]byte, size) 4726 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4727 if err != nil { 4728 return nil, err 4729 } 4730 return dAtA[:n], nil 4731 } 4732 4733 func (m *RequestCommit) MarshalTo(dAtA []byte) (int, error) { 4734 size := m.Size() 4735 return m.MarshalToSizedBuffer(dAtA[:size]) 4736 } 4737 4738 func (m *RequestCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4739 i := len(dAtA) 4740 _ = i 4741 var l int 4742 _ = l 4743 return len(dAtA) - i, nil 4744 } 4745 4746 func (m *RequestListSnapshots) Marshal() (dAtA []byte, err error) { 4747 size := m.Size() 4748 dAtA = make([]byte, size) 4749 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4750 if err != nil { 4751 return nil, err 4752 } 4753 return dAtA[:n], nil 4754 } 4755 4756 func (m *RequestListSnapshots) MarshalTo(dAtA []byte) (int, error) { 4757 size := m.Size() 4758 return m.MarshalToSizedBuffer(dAtA[:size]) 4759 } 4760 4761 func (m *RequestListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4762 i := len(dAtA) 4763 _ = i 4764 var l int 4765 _ = l 4766 return len(dAtA) - i, nil 4767 } 4768 4769 func (m *RequestOfferSnapshot) Marshal() (dAtA []byte, err error) { 4770 size := m.Size() 4771 dAtA = make([]byte, size) 4772 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4773 if err != nil { 4774 return nil, err 4775 } 4776 return dAtA[:n], nil 4777 } 4778 4779 func (m *RequestOfferSnapshot) MarshalTo(dAtA []byte) (int, error) { 4780 size := m.Size() 4781 return m.MarshalToSizedBuffer(dAtA[:size]) 4782 } 4783 4784 func (m *RequestOfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4785 i := len(dAtA) 4786 _ = i 4787 var l int 4788 _ = l 4789 if len(m.AppHash) > 0 { 4790 i -= len(m.AppHash) 4791 copy(dAtA[i:], m.AppHash) 4792 i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) 4793 i-- 4794 dAtA[i] = 0x12 4795 } 4796 if m.Snapshot != nil { 4797 { 4798 size, err := m.Snapshot.MarshalToSizedBuffer(dAtA[:i]) 4799 if err != nil { 4800 return 0, err 4801 } 4802 i -= size 4803 i = encodeVarintTypes(dAtA, i, uint64(size)) 4804 } 4805 i-- 4806 dAtA[i] = 0xa 4807 } 4808 return len(dAtA) - i, nil 4809 } 4810 4811 func (m *RequestLoadSnapshotChunk) Marshal() (dAtA []byte, err error) { 4812 size := m.Size() 4813 dAtA = make([]byte, size) 4814 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4815 if err != nil { 4816 return nil, err 4817 } 4818 return dAtA[:n], nil 4819 } 4820 4821 func (m *RequestLoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 4822 size := m.Size() 4823 return m.MarshalToSizedBuffer(dAtA[:size]) 4824 } 4825 4826 func (m *RequestLoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4827 i := len(dAtA) 4828 _ = i 4829 var l int 4830 _ = l 4831 if m.Chunk != 0 { 4832 i = encodeVarintTypes(dAtA, i, uint64(m.Chunk)) 4833 i-- 4834 dAtA[i] = 0x18 4835 } 4836 if m.Format != 0 { 4837 i = encodeVarintTypes(dAtA, i, uint64(m.Format)) 4838 i-- 4839 dAtA[i] = 0x10 4840 } 4841 if m.Height != 0 { 4842 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 4843 i-- 4844 dAtA[i] = 0x8 4845 } 4846 return len(dAtA) - i, nil 4847 } 4848 4849 func (m *RequestApplySnapshotChunk) Marshal() (dAtA []byte, err error) { 4850 size := m.Size() 4851 dAtA = make([]byte, size) 4852 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4853 if err != nil { 4854 return nil, err 4855 } 4856 return dAtA[:n], nil 4857 } 4858 4859 func (m *RequestApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 4860 size := m.Size() 4861 return m.MarshalToSizedBuffer(dAtA[:size]) 4862 } 4863 4864 func (m *RequestApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4865 i := len(dAtA) 4866 _ = i 4867 var l int 4868 _ = l 4869 if len(m.Sender) > 0 { 4870 i -= len(m.Sender) 4871 copy(dAtA[i:], m.Sender) 4872 i = encodeVarintTypes(dAtA, i, uint64(len(m.Sender))) 4873 i-- 4874 dAtA[i] = 0x1a 4875 } 4876 if len(m.Chunk) > 0 { 4877 i -= len(m.Chunk) 4878 copy(dAtA[i:], m.Chunk) 4879 i = encodeVarintTypes(dAtA, i, uint64(len(m.Chunk))) 4880 i-- 4881 dAtA[i] = 0x12 4882 } 4883 if m.Index != 0 { 4884 i = encodeVarintTypes(dAtA, i, uint64(m.Index)) 4885 i-- 4886 dAtA[i] = 0x8 4887 } 4888 return len(dAtA) - i, nil 4889 } 4890 4891 func (m *Response) Marshal() (dAtA []byte, err error) { 4892 size := m.Size() 4893 dAtA = make([]byte, size) 4894 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 4895 if err != nil { 4896 return nil, err 4897 } 4898 return dAtA[:n], nil 4899 } 4900 4901 func (m *Response) MarshalTo(dAtA []byte) (int, error) { 4902 size := m.Size() 4903 return m.MarshalToSizedBuffer(dAtA[:size]) 4904 } 4905 4906 func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4907 i := len(dAtA) 4908 _ = i 4909 var l int 4910 _ = l 4911 if m.Value != nil { 4912 { 4913 size := m.Value.Size() 4914 i -= size 4915 if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil { 4916 return 0, err 4917 } 4918 } 4919 } 4920 return len(dAtA) - i, nil 4921 } 4922 4923 func (m *Response_Exception) MarshalTo(dAtA []byte) (int, error) { 4924 size := m.Size() 4925 return m.MarshalToSizedBuffer(dAtA[:size]) 4926 } 4927 4928 func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4929 i := len(dAtA) 4930 if m.Exception != nil { 4931 { 4932 size, err := m.Exception.MarshalToSizedBuffer(dAtA[:i]) 4933 if err != nil { 4934 return 0, err 4935 } 4936 i -= size 4937 i = encodeVarintTypes(dAtA, i, uint64(size)) 4938 } 4939 i-- 4940 dAtA[i] = 0xa 4941 } 4942 return len(dAtA) - i, nil 4943 } 4944 func (m *Response_Echo) MarshalTo(dAtA []byte) (int, error) { 4945 size := m.Size() 4946 return m.MarshalToSizedBuffer(dAtA[:size]) 4947 } 4948 4949 func (m *Response_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4950 i := len(dAtA) 4951 if m.Echo != nil { 4952 { 4953 size, err := m.Echo.MarshalToSizedBuffer(dAtA[:i]) 4954 if err != nil { 4955 return 0, err 4956 } 4957 i -= size 4958 i = encodeVarintTypes(dAtA, i, uint64(size)) 4959 } 4960 i-- 4961 dAtA[i] = 0x12 4962 } 4963 return len(dAtA) - i, nil 4964 } 4965 func (m *Response_Flush) MarshalTo(dAtA []byte) (int, error) { 4966 size := m.Size() 4967 return m.MarshalToSizedBuffer(dAtA[:size]) 4968 } 4969 4970 func (m *Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4971 i := len(dAtA) 4972 if m.Flush != nil { 4973 { 4974 size, err := m.Flush.MarshalToSizedBuffer(dAtA[:i]) 4975 if err != nil { 4976 return 0, err 4977 } 4978 i -= size 4979 i = encodeVarintTypes(dAtA, i, uint64(size)) 4980 } 4981 i-- 4982 dAtA[i] = 0x1a 4983 } 4984 return len(dAtA) - i, nil 4985 } 4986 func (m *Response_Info) MarshalTo(dAtA []byte) (int, error) { 4987 size := m.Size() 4988 return m.MarshalToSizedBuffer(dAtA[:size]) 4989 } 4990 4991 func (m *Response_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) { 4992 i := len(dAtA) 4993 if m.Info != nil { 4994 { 4995 size, err := m.Info.MarshalToSizedBuffer(dAtA[:i]) 4996 if err != nil { 4997 return 0, err 4998 } 4999 i -= size 5000 i = encodeVarintTypes(dAtA, i, uint64(size)) 5001 } 5002 i-- 5003 dAtA[i] = 0x22 5004 } 5005 return len(dAtA) - i, nil 5006 } 5007 func (m *Response_SetOption) MarshalTo(dAtA []byte) (int, error) { 5008 size := m.Size() 5009 return m.MarshalToSizedBuffer(dAtA[:size]) 5010 } 5011 5012 func (m *Response_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5013 i := len(dAtA) 5014 if m.SetOption != nil { 5015 { 5016 size, err := m.SetOption.MarshalToSizedBuffer(dAtA[:i]) 5017 if err != nil { 5018 return 0, err 5019 } 5020 i -= size 5021 i = encodeVarintTypes(dAtA, i, uint64(size)) 5022 } 5023 i-- 5024 dAtA[i] = 0x2a 5025 } 5026 return len(dAtA) - i, nil 5027 } 5028 func (m *Response_InitChain) MarshalTo(dAtA []byte) (int, error) { 5029 size := m.Size() 5030 return m.MarshalToSizedBuffer(dAtA[:size]) 5031 } 5032 5033 func (m *Response_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5034 i := len(dAtA) 5035 if m.InitChain != nil { 5036 { 5037 size, err := m.InitChain.MarshalToSizedBuffer(dAtA[:i]) 5038 if err != nil { 5039 return 0, err 5040 } 5041 i -= size 5042 i = encodeVarintTypes(dAtA, i, uint64(size)) 5043 } 5044 i-- 5045 dAtA[i] = 0x32 5046 } 5047 return len(dAtA) - i, nil 5048 } 5049 func (m *Response_Query) MarshalTo(dAtA []byte) (int, error) { 5050 size := m.Size() 5051 return m.MarshalToSizedBuffer(dAtA[:size]) 5052 } 5053 5054 func (m *Response_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5055 i := len(dAtA) 5056 if m.Query != nil { 5057 { 5058 size, err := m.Query.MarshalToSizedBuffer(dAtA[:i]) 5059 if err != nil { 5060 return 0, err 5061 } 5062 i -= size 5063 i = encodeVarintTypes(dAtA, i, uint64(size)) 5064 } 5065 i-- 5066 dAtA[i] = 0x3a 5067 } 5068 return len(dAtA) - i, nil 5069 } 5070 func (m *Response_BeginBlock) MarshalTo(dAtA []byte) (int, error) { 5071 size := m.Size() 5072 return m.MarshalToSizedBuffer(dAtA[:size]) 5073 } 5074 5075 func (m *Response_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5076 i := len(dAtA) 5077 if m.BeginBlock != nil { 5078 { 5079 size, err := m.BeginBlock.MarshalToSizedBuffer(dAtA[:i]) 5080 if err != nil { 5081 return 0, err 5082 } 5083 i -= size 5084 i = encodeVarintTypes(dAtA, i, uint64(size)) 5085 } 5086 i-- 5087 dAtA[i] = 0x42 5088 } 5089 return len(dAtA) - i, nil 5090 } 5091 func (m *Response_CheckTx) MarshalTo(dAtA []byte) (int, error) { 5092 size := m.Size() 5093 return m.MarshalToSizedBuffer(dAtA[:size]) 5094 } 5095 5096 func (m *Response_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5097 i := len(dAtA) 5098 if m.CheckTx != nil { 5099 { 5100 size, err := m.CheckTx.MarshalToSizedBuffer(dAtA[:i]) 5101 if err != nil { 5102 return 0, err 5103 } 5104 i -= size 5105 i = encodeVarintTypes(dAtA, i, uint64(size)) 5106 } 5107 i-- 5108 dAtA[i] = 0x4a 5109 } 5110 return len(dAtA) - i, nil 5111 } 5112 func (m *Response_DeliverTx) MarshalTo(dAtA []byte) (int, error) { 5113 size := m.Size() 5114 return m.MarshalToSizedBuffer(dAtA[:size]) 5115 } 5116 5117 func (m *Response_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5118 i := len(dAtA) 5119 if m.DeliverTx != nil { 5120 { 5121 size, err := m.DeliverTx.MarshalToSizedBuffer(dAtA[:i]) 5122 if err != nil { 5123 return 0, err 5124 } 5125 i -= size 5126 i = encodeVarintTypes(dAtA, i, uint64(size)) 5127 } 5128 i-- 5129 dAtA[i] = 0x52 5130 } 5131 return len(dAtA) - i, nil 5132 } 5133 func (m *Response_EndBlock) MarshalTo(dAtA []byte) (int, error) { 5134 size := m.Size() 5135 return m.MarshalToSizedBuffer(dAtA[:size]) 5136 } 5137 5138 func (m *Response_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5139 i := len(dAtA) 5140 if m.EndBlock != nil { 5141 { 5142 size, err := m.EndBlock.MarshalToSizedBuffer(dAtA[:i]) 5143 if err != nil { 5144 return 0, err 5145 } 5146 i -= size 5147 i = encodeVarintTypes(dAtA, i, uint64(size)) 5148 } 5149 i-- 5150 dAtA[i] = 0x5a 5151 } 5152 return len(dAtA) - i, nil 5153 } 5154 func (m *Response_Commit) MarshalTo(dAtA []byte) (int, error) { 5155 size := m.Size() 5156 return m.MarshalToSizedBuffer(dAtA[:size]) 5157 } 5158 5159 func (m *Response_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5160 i := len(dAtA) 5161 if m.Commit != nil { 5162 { 5163 size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i]) 5164 if err != nil { 5165 return 0, err 5166 } 5167 i -= size 5168 i = encodeVarintTypes(dAtA, i, uint64(size)) 5169 } 5170 i-- 5171 dAtA[i] = 0x62 5172 } 5173 return len(dAtA) - i, nil 5174 } 5175 func (m *Response_ListSnapshots) MarshalTo(dAtA []byte) (int, error) { 5176 size := m.Size() 5177 return m.MarshalToSizedBuffer(dAtA[:size]) 5178 } 5179 5180 func (m *Response_ListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5181 i := len(dAtA) 5182 if m.ListSnapshots != nil { 5183 { 5184 size, err := m.ListSnapshots.MarshalToSizedBuffer(dAtA[:i]) 5185 if err != nil { 5186 return 0, err 5187 } 5188 i -= size 5189 i = encodeVarintTypes(dAtA, i, uint64(size)) 5190 } 5191 i-- 5192 dAtA[i] = 0x6a 5193 } 5194 return len(dAtA) - i, nil 5195 } 5196 func (m *Response_OfferSnapshot) MarshalTo(dAtA []byte) (int, error) { 5197 size := m.Size() 5198 return m.MarshalToSizedBuffer(dAtA[:size]) 5199 } 5200 5201 func (m *Response_OfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5202 i := len(dAtA) 5203 if m.OfferSnapshot != nil { 5204 { 5205 size, err := m.OfferSnapshot.MarshalToSizedBuffer(dAtA[:i]) 5206 if err != nil { 5207 return 0, err 5208 } 5209 i -= size 5210 i = encodeVarintTypes(dAtA, i, uint64(size)) 5211 } 5212 i-- 5213 dAtA[i] = 0x72 5214 } 5215 return len(dAtA) - i, nil 5216 } 5217 func (m *Response_LoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 5218 size := m.Size() 5219 return m.MarshalToSizedBuffer(dAtA[:size]) 5220 } 5221 5222 func (m *Response_LoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5223 i := len(dAtA) 5224 if m.LoadSnapshotChunk != nil { 5225 { 5226 size, err := m.LoadSnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) 5227 if err != nil { 5228 return 0, err 5229 } 5230 i -= size 5231 i = encodeVarintTypes(dAtA, i, uint64(size)) 5232 } 5233 i-- 5234 dAtA[i] = 0x7a 5235 } 5236 return len(dAtA) - i, nil 5237 } 5238 func (m *Response_ApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 5239 size := m.Size() 5240 return m.MarshalToSizedBuffer(dAtA[:size]) 5241 } 5242 5243 func (m *Response_ApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5244 i := len(dAtA) 5245 if m.ApplySnapshotChunk != nil { 5246 { 5247 size, err := m.ApplySnapshotChunk.MarshalToSizedBuffer(dAtA[:i]) 5248 if err != nil { 5249 return 0, err 5250 } 5251 i -= size 5252 i = encodeVarintTypes(dAtA, i, uint64(size)) 5253 } 5254 i-- 5255 dAtA[i] = 0x1 5256 i-- 5257 dAtA[i] = 0x82 5258 } 5259 return len(dAtA) - i, nil 5260 } 5261 func (m *ResponseException) Marshal() (dAtA []byte, err error) { 5262 size := m.Size() 5263 dAtA = make([]byte, size) 5264 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5265 if err != nil { 5266 return nil, err 5267 } 5268 return dAtA[:n], nil 5269 } 5270 5271 func (m *ResponseException) MarshalTo(dAtA []byte) (int, error) { 5272 size := m.Size() 5273 return m.MarshalToSizedBuffer(dAtA[:size]) 5274 } 5275 5276 func (m *ResponseException) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5277 i := len(dAtA) 5278 _ = i 5279 var l int 5280 _ = l 5281 if len(m.Error) > 0 { 5282 i -= len(m.Error) 5283 copy(dAtA[i:], m.Error) 5284 i = encodeVarintTypes(dAtA, i, uint64(len(m.Error))) 5285 i-- 5286 dAtA[i] = 0xa 5287 } 5288 return len(dAtA) - i, nil 5289 } 5290 5291 func (m *ResponseEcho) Marshal() (dAtA []byte, err error) { 5292 size := m.Size() 5293 dAtA = make([]byte, size) 5294 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5295 if err != nil { 5296 return nil, err 5297 } 5298 return dAtA[:n], nil 5299 } 5300 5301 func (m *ResponseEcho) MarshalTo(dAtA []byte) (int, error) { 5302 size := m.Size() 5303 return m.MarshalToSizedBuffer(dAtA[:size]) 5304 } 5305 5306 func (m *ResponseEcho) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5307 i := len(dAtA) 5308 _ = i 5309 var l int 5310 _ = l 5311 if len(m.Message) > 0 { 5312 i -= len(m.Message) 5313 copy(dAtA[i:], m.Message) 5314 i = encodeVarintTypes(dAtA, i, uint64(len(m.Message))) 5315 i-- 5316 dAtA[i] = 0xa 5317 } 5318 return len(dAtA) - i, nil 5319 } 5320 5321 func (m *ResponseFlush) Marshal() (dAtA []byte, err error) { 5322 size := m.Size() 5323 dAtA = make([]byte, size) 5324 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5325 if err != nil { 5326 return nil, err 5327 } 5328 return dAtA[:n], nil 5329 } 5330 5331 func (m *ResponseFlush) MarshalTo(dAtA []byte) (int, error) { 5332 size := m.Size() 5333 return m.MarshalToSizedBuffer(dAtA[:size]) 5334 } 5335 5336 func (m *ResponseFlush) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5337 i := len(dAtA) 5338 _ = i 5339 var l int 5340 _ = l 5341 return len(dAtA) - i, nil 5342 } 5343 5344 func (m *ResponseInfo) Marshal() (dAtA []byte, err error) { 5345 size := m.Size() 5346 dAtA = make([]byte, size) 5347 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5348 if err != nil { 5349 return nil, err 5350 } 5351 return dAtA[:n], nil 5352 } 5353 5354 func (m *ResponseInfo) MarshalTo(dAtA []byte) (int, error) { 5355 size := m.Size() 5356 return m.MarshalToSizedBuffer(dAtA[:size]) 5357 } 5358 5359 func (m *ResponseInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5360 i := len(dAtA) 5361 _ = i 5362 var l int 5363 _ = l 5364 if len(m.LastBlockAppHash) > 0 { 5365 i -= len(m.LastBlockAppHash) 5366 copy(dAtA[i:], m.LastBlockAppHash) 5367 i = encodeVarintTypes(dAtA, i, uint64(len(m.LastBlockAppHash))) 5368 i-- 5369 dAtA[i] = 0x2a 5370 } 5371 if m.LastBlockHeight != 0 { 5372 i = encodeVarintTypes(dAtA, i, uint64(m.LastBlockHeight)) 5373 i-- 5374 dAtA[i] = 0x20 5375 } 5376 if m.AppVersion != 0 { 5377 i = encodeVarintTypes(dAtA, i, uint64(m.AppVersion)) 5378 i-- 5379 dAtA[i] = 0x18 5380 } 5381 if len(m.Version) > 0 { 5382 i -= len(m.Version) 5383 copy(dAtA[i:], m.Version) 5384 i = encodeVarintTypes(dAtA, i, uint64(len(m.Version))) 5385 i-- 5386 dAtA[i] = 0x12 5387 } 5388 if len(m.Data) > 0 { 5389 i -= len(m.Data) 5390 copy(dAtA[i:], m.Data) 5391 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 5392 i-- 5393 dAtA[i] = 0xa 5394 } 5395 return len(dAtA) - i, nil 5396 } 5397 5398 func (m *ResponseSetOption) Marshal() (dAtA []byte, err error) { 5399 size := m.Size() 5400 dAtA = make([]byte, size) 5401 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5402 if err != nil { 5403 return nil, err 5404 } 5405 return dAtA[:n], nil 5406 } 5407 5408 func (m *ResponseSetOption) MarshalTo(dAtA []byte) (int, error) { 5409 size := m.Size() 5410 return m.MarshalToSizedBuffer(dAtA[:size]) 5411 } 5412 5413 func (m *ResponseSetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5414 i := len(dAtA) 5415 _ = i 5416 var l int 5417 _ = l 5418 if len(m.Info) > 0 { 5419 i -= len(m.Info) 5420 copy(dAtA[i:], m.Info) 5421 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 5422 i-- 5423 dAtA[i] = 0x22 5424 } 5425 if len(m.Log) > 0 { 5426 i -= len(m.Log) 5427 copy(dAtA[i:], m.Log) 5428 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 5429 i-- 5430 dAtA[i] = 0x1a 5431 } 5432 if m.Code != 0 { 5433 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 5434 i-- 5435 dAtA[i] = 0x8 5436 } 5437 return len(dAtA) - i, nil 5438 } 5439 5440 func (m *ResponseInitChain) Marshal() (dAtA []byte, err error) { 5441 size := m.Size() 5442 dAtA = make([]byte, size) 5443 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5444 if err != nil { 5445 return nil, err 5446 } 5447 return dAtA[:n], nil 5448 } 5449 5450 func (m *ResponseInitChain) MarshalTo(dAtA []byte) (int, error) { 5451 size := m.Size() 5452 return m.MarshalToSizedBuffer(dAtA[:size]) 5453 } 5454 5455 func (m *ResponseInitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5456 i := len(dAtA) 5457 _ = i 5458 var l int 5459 _ = l 5460 if len(m.AppHash) > 0 { 5461 i -= len(m.AppHash) 5462 copy(dAtA[i:], m.AppHash) 5463 i = encodeVarintTypes(dAtA, i, uint64(len(m.AppHash))) 5464 i-- 5465 dAtA[i] = 0x1a 5466 } 5467 if len(m.Validators) > 0 { 5468 for iNdEx := len(m.Validators) - 1; iNdEx >= 0; iNdEx-- { 5469 { 5470 size, err := m.Validators[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5471 if err != nil { 5472 return 0, err 5473 } 5474 i -= size 5475 i = encodeVarintTypes(dAtA, i, uint64(size)) 5476 } 5477 i-- 5478 dAtA[i] = 0x12 5479 } 5480 } 5481 if m.ConsensusParams != nil { 5482 { 5483 size, err := m.ConsensusParams.MarshalToSizedBuffer(dAtA[:i]) 5484 if err != nil { 5485 return 0, err 5486 } 5487 i -= size 5488 i = encodeVarintTypes(dAtA, i, uint64(size)) 5489 } 5490 i-- 5491 dAtA[i] = 0xa 5492 } 5493 return len(dAtA) - i, nil 5494 } 5495 5496 func (m *ResponseQuery) Marshal() (dAtA []byte, err error) { 5497 size := m.Size() 5498 dAtA = make([]byte, size) 5499 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5500 if err != nil { 5501 return nil, err 5502 } 5503 return dAtA[:n], nil 5504 } 5505 5506 func (m *ResponseQuery) MarshalTo(dAtA []byte) (int, error) { 5507 size := m.Size() 5508 return m.MarshalToSizedBuffer(dAtA[:size]) 5509 } 5510 5511 func (m *ResponseQuery) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5512 i := len(dAtA) 5513 _ = i 5514 var l int 5515 _ = l 5516 if len(m.Codespace) > 0 { 5517 i -= len(m.Codespace) 5518 copy(dAtA[i:], m.Codespace) 5519 i = encodeVarintTypes(dAtA, i, uint64(len(m.Codespace))) 5520 i-- 5521 dAtA[i] = 0x52 5522 } 5523 if m.Height != 0 { 5524 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 5525 i-- 5526 dAtA[i] = 0x48 5527 } 5528 if m.ProofOps != nil { 5529 { 5530 size, err := m.ProofOps.MarshalToSizedBuffer(dAtA[:i]) 5531 if err != nil { 5532 return 0, err 5533 } 5534 i -= size 5535 i = encodeVarintTypes(dAtA, i, uint64(size)) 5536 } 5537 i-- 5538 dAtA[i] = 0x42 5539 } 5540 if len(m.Value) > 0 { 5541 i -= len(m.Value) 5542 copy(dAtA[i:], m.Value) 5543 i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) 5544 i-- 5545 dAtA[i] = 0x3a 5546 } 5547 if len(m.Key) > 0 { 5548 i -= len(m.Key) 5549 copy(dAtA[i:], m.Key) 5550 i = encodeVarintTypes(dAtA, i, uint64(len(m.Key))) 5551 i-- 5552 dAtA[i] = 0x32 5553 } 5554 if m.Index != 0 { 5555 i = encodeVarintTypes(dAtA, i, uint64(m.Index)) 5556 i-- 5557 dAtA[i] = 0x28 5558 } 5559 if len(m.Info) > 0 { 5560 i -= len(m.Info) 5561 copy(dAtA[i:], m.Info) 5562 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 5563 i-- 5564 dAtA[i] = 0x22 5565 } 5566 if len(m.Log) > 0 { 5567 i -= len(m.Log) 5568 copy(dAtA[i:], m.Log) 5569 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 5570 i-- 5571 dAtA[i] = 0x1a 5572 } 5573 if m.Code != 0 { 5574 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 5575 i-- 5576 dAtA[i] = 0x8 5577 } 5578 return len(dAtA) - i, nil 5579 } 5580 5581 func (m *ResponseBeginBlock) Marshal() (dAtA []byte, err error) { 5582 size := m.Size() 5583 dAtA = make([]byte, size) 5584 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5585 if err != nil { 5586 return nil, err 5587 } 5588 return dAtA[:n], nil 5589 } 5590 5591 func (m *ResponseBeginBlock) MarshalTo(dAtA []byte) (int, error) { 5592 size := m.Size() 5593 return m.MarshalToSizedBuffer(dAtA[:size]) 5594 } 5595 5596 func (m *ResponseBeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5597 i := len(dAtA) 5598 _ = i 5599 var l int 5600 _ = l 5601 if len(m.Events) > 0 { 5602 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 5603 { 5604 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5605 if err != nil { 5606 return 0, err 5607 } 5608 i -= size 5609 i = encodeVarintTypes(dAtA, i, uint64(size)) 5610 } 5611 i-- 5612 dAtA[i] = 0xa 5613 } 5614 } 5615 return len(dAtA) - i, nil 5616 } 5617 5618 func (m *ResponseCheckTx) Marshal() (dAtA []byte, err error) { 5619 size := m.Size() 5620 dAtA = make([]byte, size) 5621 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5622 if err != nil { 5623 return nil, err 5624 } 5625 return dAtA[:n], nil 5626 } 5627 5628 func (m *ResponseCheckTx) MarshalTo(dAtA []byte) (int, error) { 5629 size := m.Size() 5630 return m.MarshalToSizedBuffer(dAtA[:size]) 5631 } 5632 5633 func (m *ResponseCheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5634 i := len(dAtA) 5635 _ = i 5636 var l int 5637 _ = l 5638 if len(m.Codespace) > 0 { 5639 i -= len(m.Codespace) 5640 copy(dAtA[i:], m.Codespace) 5641 i = encodeVarintTypes(dAtA, i, uint64(len(m.Codespace))) 5642 i-- 5643 dAtA[i] = 0x42 5644 } 5645 if len(m.Events) > 0 { 5646 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 5647 { 5648 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5649 if err != nil { 5650 return 0, err 5651 } 5652 i -= size 5653 i = encodeVarintTypes(dAtA, i, uint64(size)) 5654 } 5655 i-- 5656 dAtA[i] = 0x3a 5657 } 5658 } 5659 if m.GasUsed != 0 { 5660 i = encodeVarintTypes(dAtA, i, uint64(m.GasUsed)) 5661 i-- 5662 dAtA[i] = 0x30 5663 } 5664 if m.GasWanted != 0 { 5665 i = encodeVarintTypes(dAtA, i, uint64(m.GasWanted)) 5666 i-- 5667 dAtA[i] = 0x28 5668 } 5669 if len(m.Info) > 0 { 5670 i -= len(m.Info) 5671 copy(dAtA[i:], m.Info) 5672 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 5673 i-- 5674 dAtA[i] = 0x22 5675 } 5676 if len(m.Log) > 0 { 5677 i -= len(m.Log) 5678 copy(dAtA[i:], m.Log) 5679 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 5680 i-- 5681 dAtA[i] = 0x1a 5682 } 5683 if len(m.Data) > 0 { 5684 i -= len(m.Data) 5685 copy(dAtA[i:], m.Data) 5686 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 5687 i-- 5688 dAtA[i] = 0x12 5689 } 5690 if m.Code != 0 { 5691 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 5692 i-- 5693 dAtA[i] = 0x8 5694 } 5695 return len(dAtA) - i, nil 5696 } 5697 5698 func (m *ResponseDeliverTx) Marshal() (dAtA []byte, err error) { 5699 size := m.Size() 5700 dAtA = make([]byte, size) 5701 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5702 if err != nil { 5703 return nil, err 5704 } 5705 return dAtA[:n], nil 5706 } 5707 5708 func (m *ResponseDeliverTx) MarshalTo(dAtA []byte) (int, error) { 5709 size := m.Size() 5710 return m.MarshalToSizedBuffer(dAtA[:size]) 5711 } 5712 5713 func (m *ResponseDeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5714 i := len(dAtA) 5715 _ = i 5716 var l int 5717 _ = l 5718 if len(m.Codespace) > 0 { 5719 i -= len(m.Codespace) 5720 copy(dAtA[i:], m.Codespace) 5721 i = encodeVarintTypes(dAtA, i, uint64(len(m.Codespace))) 5722 i-- 5723 dAtA[i] = 0x42 5724 } 5725 if len(m.Events) > 0 { 5726 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 5727 { 5728 size, err := m.Events[iNdEx].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] = 0x3a 5737 } 5738 } 5739 if m.GasUsed != 0 { 5740 i = encodeVarintTypes(dAtA, i, uint64(m.GasUsed)) 5741 i-- 5742 dAtA[i] = 0x30 5743 } 5744 if m.GasWanted != 0 { 5745 i = encodeVarintTypes(dAtA, i, uint64(m.GasWanted)) 5746 i-- 5747 dAtA[i] = 0x28 5748 } 5749 if len(m.Info) > 0 { 5750 i -= len(m.Info) 5751 copy(dAtA[i:], m.Info) 5752 i = encodeVarintTypes(dAtA, i, uint64(len(m.Info))) 5753 i-- 5754 dAtA[i] = 0x22 5755 } 5756 if len(m.Log) > 0 { 5757 i -= len(m.Log) 5758 copy(dAtA[i:], m.Log) 5759 i = encodeVarintTypes(dAtA, i, uint64(len(m.Log))) 5760 i-- 5761 dAtA[i] = 0x1a 5762 } 5763 if len(m.Data) > 0 { 5764 i -= len(m.Data) 5765 copy(dAtA[i:], m.Data) 5766 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 5767 i-- 5768 dAtA[i] = 0x12 5769 } 5770 if m.Code != 0 { 5771 i = encodeVarintTypes(dAtA, i, uint64(m.Code)) 5772 i-- 5773 dAtA[i] = 0x8 5774 } 5775 return len(dAtA) - i, nil 5776 } 5777 5778 func (m *ResponseEndBlock) Marshal() (dAtA []byte, err error) { 5779 size := m.Size() 5780 dAtA = make([]byte, size) 5781 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5782 if err != nil { 5783 return nil, err 5784 } 5785 return dAtA[:n], nil 5786 } 5787 5788 func (m *ResponseEndBlock) MarshalTo(dAtA []byte) (int, error) { 5789 size := m.Size() 5790 return m.MarshalToSizedBuffer(dAtA[:size]) 5791 } 5792 5793 func (m *ResponseEndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5794 i := len(dAtA) 5795 _ = i 5796 var l int 5797 _ = l 5798 if len(m.Events) > 0 { 5799 for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- { 5800 { 5801 size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5802 if err != nil { 5803 return 0, err 5804 } 5805 i -= size 5806 i = encodeVarintTypes(dAtA, i, uint64(size)) 5807 } 5808 i-- 5809 dAtA[i] = 0x1a 5810 } 5811 } 5812 if m.ConsensusParamUpdates != nil { 5813 { 5814 size, err := m.ConsensusParamUpdates.MarshalToSizedBuffer(dAtA[:i]) 5815 if err != nil { 5816 return 0, err 5817 } 5818 i -= size 5819 i = encodeVarintTypes(dAtA, i, uint64(size)) 5820 } 5821 i-- 5822 dAtA[i] = 0x12 5823 } 5824 if len(m.ValidatorUpdates) > 0 { 5825 for iNdEx := len(m.ValidatorUpdates) - 1; iNdEx >= 0; iNdEx-- { 5826 { 5827 size, err := m.ValidatorUpdates[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5828 if err != nil { 5829 return 0, err 5830 } 5831 i -= size 5832 i = encodeVarintTypes(dAtA, i, uint64(size)) 5833 } 5834 i-- 5835 dAtA[i] = 0xa 5836 } 5837 } 5838 return len(dAtA) - i, nil 5839 } 5840 5841 func (m *ResponseCommit) Marshal() (dAtA []byte, err error) { 5842 size := m.Size() 5843 dAtA = make([]byte, size) 5844 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5845 if err != nil { 5846 return nil, err 5847 } 5848 return dAtA[:n], nil 5849 } 5850 5851 func (m *ResponseCommit) MarshalTo(dAtA []byte) (int, error) { 5852 size := m.Size() 5853 return m.MarshalToSizedBuffer(dAtA[:size]) 5854 } 5855 5856 func (m *ResponseCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5857 i := len(dAtA) 5858 _ = i 5859 var l int 5860 _ = l 5861 if m.RetainHeight != 0 { 5862 i = encodeVarintTypes(dAtA, i, uint64(m.RetainHeight)) 5863 i-- 5864 dAtA[i] = 0x18 5865 } 5866 if len(m.Data) > 0 { 5867 i -= len(m.Data) 5868 copy(dAtA[i:], m.Data) 5869 i = encodeVarintTypes(dAtA, i, uint64(len(m.Data))) 5870 i-- 5871 dAtA[i] = 0x12 5872 } 5873 return len(dAtA) - i, nil 5874 } 5875 5876 func (m *ResponseListSnapshots) Marshal() (dAtA []byte, err error) { 5877 size := m.Size() 5878 dAtA = make([]byte, size) 5879 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5880 if err != nil { 5881 return nil, err 5882 } 5883 return dAtA[:n], nil 5884 } 5885 5886 func (m *ResponseListSnapshots) MarshalTo(dAtA []byte) (int, error) { 5887 size := m.Size() 5888 return m.MarshalToSizedBuffer(dAtA[:size]) 5889 } 5890 5891 func (m *ResponseListSnapshots) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5892 i := len(dAtA) 5893 _ = i 5894 var l int 5895 _ = l 5896 if len(m.Snapshots) > 0 { 5897 for iNdEx := len(m.Snapshots) - 1; iNdEx >= 0; iNdEx-- { 5898 { 5899 size, err := m.Snapshots[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 5900 if err != nil { 5901 return 0, err 5902 } 5903 i -= size 5904 i = encodeVarintTypes(dAtA, i, uint64(size)) 5905 } 5906 i-- 5907 dAtA[i] = 0xa 5908 } 5909 } 5910 return len(dAtA) - i, nil 5911 } 5912 5913 func (m *ResponseOfferSnapshot) Marshal() (dAtA []byte, err error) { 5914 size := m.Size() 5915 dAtA = make([]byte, size) 5916 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5917 if err != nil { 5918 return nil, err 5919 } 5920 return dAtA[:n], nil 5921 } 5922 5923 func (m *ResponseOfferSnapshot) MarshalTo(dAtA []byte) (int, error) { 5924 size := m.Size() 5925 return m.MarshalToSizedBuffer(dAtA[:size]) 5926 } 5927 5928 func (m *ResponseOfferSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5929 i := len(dAtA) 5930 _ = i 5931 var l int 5932 _ = l 5933 if m.Result != 0 { 5934 i = encodeVarintTypes(dAtA, i, uint64(m.Result)) 5935 i-- 5936 dAtA[i] = 0x8 5937 } 5938 return len(dAtA) - i, nil 5939 } 5940 5941 func (m *ResponseLoadSnapshotChunk) Marshal() (dAtA []byte, err error) { 5942 size := m.Size() 5943 dAtA = make([]byte, size) 5944 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5945 if err != nil { 5946 return nil, err 5947 } 5948 return dAtA[:n], nil 5949 } 5950 5951 func (m *ResponseLoadSnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 5952 size := m.Size() 5953 return m.MarshalToSizedBuffer(dAtA[:size]) 5954 } 5955 5956 func (m *ResponseLoadSnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5957 i := len(dAtA) 5958 _ = i 5959 var l int 5960 _ = l 5961 if len(m.Chunk) > 0 { 5962 i -= len(m.Chunk) 5963 copy(dAtA[i:], m.Chunk) 5964 i = encodeVarintTypes(dAtA, i, uint64(len(m.Chunk))) 5965 i-- 5966 dAtA[i] = 0xa 5967 } 5968 return len(dAtA) - i, nil 5969 } 5970 5971 func (m *ResponseApplySnapshotChunk) Marshal() (dAtA []byte, err error) { 5972 size := m.Size() 5973 dAtA = make([]byte, size) 5974 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 5975 if err != nil { 5976 return nil, err 5977 } 5978 return dAtA[:n], nil 5979 } 5980 5981 func (m *ResponseApplySnapshotChunk) MarshalTo(dAtA []byte) (int, error) { 5982 size := m.Size() 5983 return m.MarshalToSizedBuffer(dAtA[:size]) 5984 } 5985 5986 func (m *ResponseApplySnapshotChunk) MarshalToSizedBuffer(dAtA []byte) (int, error) { 5987 i := len(dAtA) 5988 _ = i 5989 var l int 5990 _ = l 5991 if len(m.RejectSenders) > 0 { 5992 for iNdEx := len(m.RejectSenders) - 1; iNdEx >= 0; iNdEx-- { 5993 i -= len(m.RejectSenders[iNdEx]) 5994 copy(dAtA[i:], m.RejectSenders[iNdEx]) 5995 i = encodeVarintTypes(dAtA, i, uint64(len(m.RejectSenders[iNdEx]))) 5996 i-- 5997 dAtA[i] = 0x1a 5998 } 5999 } 6000 if len(m.RefetchChunks) > 0 { 6001 dAtA41 := make([]byte, len(m.RefetchChunks)*10) 6002 var j40 int 6003 for _, num := range m.RefetchChunks { 6004 for num >= 1<<7 { 6005 dAtA41[j40] = uint8(uint64(num)&0x7f | 0x80) 6006 num >>= 7 6007 j40++ 6008 } 6009 dAtA41[j40] = uint8(num) 6010 j40++ 6011 } 6012 i -= j40 6013 copy(dAtA[i:], dAtA41[:j40]) 6014 i = encodeVarintTypes(dAtA, i, uint64(j40)) 6015 i-- 6016 dAtA[i] = 0x12 6017 } 6018 if m.Result != 0 { 6019 i = encodeVarintTypes(dAtA, i, uint64(m.Result)) 6020 i-- 6021 dAtA[i] = 0x8 6022 } 6023 return len(dAtA) - i, nil 6024 } 6025 6026 func (m *ConsensusParams) Marshal() (dAtA []byte, err error) { 6027 size := m.Size() 6028 dAtA = make([]byte, size) 6029 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6030 if err != nil { 6031 return nil, err 6032 } 6033 return dAtA[:n], nil 6034 } 6035 6036 func (m *ConsensusParams) MarshalTo(dAtA []byte) (int, error) { 6037 size := m.Size() 6038 return m.MarshalToSizedBuffer(dAtA[:size]) 6039 } 6040 6041 func (m *ConsensusParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6042 i := len(dAtA) 6043 _ = i 6044 var l int 6045 _ = l 6046 if m.Version != nil { 6047 { 6048 size, err := m.Version.MarshalToSizedBuffer(dAtA[:i]) 6049 if err != nil { 6050 return 0, err 6051 } 6052 i -= size 6053 i = encodeVarintTypes(dAtA, i, uint64(size)) 6054 } 6055 i-- 6056 dAtA[i] = 0x22 6057 } 6058 if m.Validator != nil { 6059 { 6060 size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) 6061 if err != nil { 6062 return 0, err 6063 } 6064 i -= size 6065 i = encodeVarintTypes(dAtA, i, uint64(size)) 6066 } 6067 i-- 6068 dAtA[i] = 0x1a 6069 } 6070 if m.Evidence != nil { 6071 { 6072 size, err := m.Evidence.MarshalToSizedBuffer(dAtA[:i]) 6073 if err != nil { 6074 return 0, err 6075 } 6076 i -= size 6077 i = encodeVarintTypes(dAtA, i, uint64(size)) 6078 } 6079 i-- 6080 dAtA[i] = 0x12 6081 } 6082 if m.Block != nil { 6083 { 6084 size, err := m.Block.MarshalToSizedBuffer(dAtA[:i]) 6085 if err != nil { 6086 return 0, err 6087 } 6088 i -= size 6089 i = encodeVarintTypes(dAtA, i, uint64(size)) 6090 } 6091 i-- 6092 dAtA[i] = 0xa 6093 } 6094 return len(dAtA) - i, nil 6095 } 6096 6097 func (m *BlockParams) Marshal() (dAtA []byte, err error) { 6098 size := m.Size() 6099 dAtA = make([]byte, size) 6100 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6101 if err != nil { 6102 return nil, err 6103 } 6104 return dAtA[:n], nil 6105 } 6106 6107 func (m *BlockParams) MarshalTo(dAtA []byte) (int, error) { 6108 size := m.Size() 6109 return m.MarshalToSizedBuffer(dAtA[:size]) 6110 } 6111 6112 func (m *BlockParams) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6113 i := len(dAtA) 6114 _ = i 6115 var l int 6116 _ = l 6117 if m.MaxGas != 0 { 6118 i = encodeVarintTypes(dAtA, i, uint64(m.MaxGas)) 6119 i-- 6120 dAtA[i] = 0x10 6121 } 6122 if m.MaxBytes != 0 { 6123 i = encodeVarintTypes(dAtA, i, uint64(m.MaxBytes)) 6124 i-- 6125 dAtA[i] = 0x8 6126 } 6127 return len(dAtA) - i, nil 6128 } 6129 6130 func (m *LastCommitInfo) Marshal() (dAtA []byte, err error) { 6131 size := m.Size() 6132 dAtA = make([]byte, size) 6133 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6134 if err != nil { 6135 return nil, err 6136 } 6137 return dAtA[:n], nil 6138 } 6139 6140 func (m *LastCommitInfo) MarshalTo(dAtA []byte) (int, error) { 6141 size := m.Size() 6142 return m.MarshalToSizedBuffer(dAtA[:size]) 6143 } 6144 6145 func (m *LastCommitInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6146 i := len(dAtA) 6147 _ = i 6148 var l int 6149 _ = l 6150 if len(m.Votes) > 0 { 6151 for iNdEx := len(m.Votes) - 1; iNdEx >= 0; iNdEx-- { 6152 { 6153 size, err := m.Votes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 6154 if err != nil { 6155 return 0, err 6156 } 6157 i -= size 6158 i = encodeVarintTypes(dAtA, i, uint64(size)) 6159 } 6160 i-- 6161 dAtA[i] = 0x12 6162 } 6163 } 6164 if m.Round != 0 { 6165 i = encodeVarintTypes(dAtA, i, uint64(m.Round)) 6166 i-- 6167 dAtA[i] = 0x8 6168 } 6169 return len(dAtA) - i, nil 6170 } 6171 6172 func (m *Event) Marshal() (dAtA []byte, err error) { 6173 size := m.Size() 6174 dAtA = make([]byte, size) 6175 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6176 if err != nil { 6177 return nil, err 6178 } 6179 return dAtA[:n], nil 6180 } 6181 6182 func (m *Event) MarshalTo(dAtA []byte) (int, error) { 6183 size := m.Size() 6184 return m.MarshalToSizedBuffer(dAtA[:size]) 6185 } 6186 6187 func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6188 i := len(dAtA) 6189 _ = i 6190 var l int 6191 _ = l 6192 if len(m.Attributes) > 0 { 6193 for iNdEx := len(m.Attributes) - 1; iNdEx >= 0; iNdEx-- { 6194 { 6195 size, err := m.Attributes[iNdEx].MarshalToSizedBuffer(dAtA[:i]) 6196 if err != nil { 6197 return 0, err 6198 } 6199 i -= size 6200 i = encodeVarintTypes(dAtA, i, uint64(size)) 6201 } 6202 i-- 6203 dAtA[i] = 0x12 6204 } 6205 } 6206 if len(m.Type) > 0 { 6207 i -= len(m.Type) 6208 copy(dAtA[i:], m.Type) 6209 i = encodeVarintTypes(dAtA, i, uint64(len(m.Type))) 6210 i-- 6211 dAtA[i] = 0xa 6212 } 6213 return len(dAtA) - i, nil 6214 } 6215 6216 func (m *EventAttribute) Marshal() (dAtA []byte, err error) { 6217 size := m.Size() 6218 dAtA = make([]byte, size) 6219 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6220 if err != nil { 6221 return nil, err 6222 } 6223 return dAtA[:n], nil 6224 } 6225 6226 func (m *EventAttribute) MarshalTo(dAtA []byte) (int, error) { 6227 size := m.Size() 6228 return m.MarshalToSizedBuffer(dAtA[:size]) 6229 } 6230 6231 func (m *EventAttribute) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6232 i := len(dAtA) 6233 _ = i 6234 var l int 6235 _ = l 6236 if m.Index { 6237 i-- 6238 if m.Index { 6239 dAtA[i] = 1 6240 } else { 6241 dAtA[i] = 0 6242 } 6243 i-- 6244 dAtA[i] = 0x18 6245 } 6246 if len(m.Value) > 0 { 6247 i -= len(m.Value) 6248 copy(dAtA[i:], m.Value) 6249 i = encodeVarintTypes(dAtA, i, uint64(len(m.Value))) 6250 i-- 6251 dAtA[i] = 0x12 6252 } 6253 if len(m.Key) > 0 { 6254 i -= len(m.Key) 6255 copy(dAtA[i:], m.Key) 6256 i = encodeVarintTypes(dAtA, i, uint64(len(m.Key))) 6257 i-- 6258 dAtA[i] = 0xa 6259 } 6260 return len(dAtA) - i, nil 6261 } 6262 6263 func (m *TxResult) Marshal() (dAtA []byte, err error) { 6264 size := m.Size() 6265 dAtA = make([]byte, size) 6266 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6267 if err != nil { 6268 return nil, err 6269 } 6270 return dAtA[:n], nil 6271 } 6272 6273 func (m *TxResult) MarshalTo(dAtA []byte) (int, error) { 6274 size := m.Size() 6275 return m.MarshalToSizedBuffer(dAtA[:size]) 6276 } 6277 6278 func (m *TxResult) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6279 i := len(dAtA) 6280 _ = i 6281 var l int 6282 _ = l 6283 { 6284 size, err := m.Result.MarshalToSizedBuffer(dAtA[:i]) 6285 if err != nil { 6286 return 0, err 6287 } 6288 i -= size 6289 i = encodeVarintTypes(dAtA, i, uint64(size)) 6290 } 6291 i-- 6292 dAtA[i] = 0x22 6293 if len(m.Tx) > 0 { 6294 i -= len(m.Tx) 6295 copy(dAtA[i:], m.Tx) 6296 i = encodeVarintTypes(dAtA, i, uint64(len(m.Tx))) 6297 i-- 6298 dAtA[i] = 0x1a 6299 } 6300 if m.Index != 0 { 6301 i = encodeVarintTypes(dAtA, i, uint64(m.Index)) 6302 i-- 6303 dAtA[i] = 0x10 6304 } 6305 if m.Height != 0 { 6306 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 6307 i-- 6308 dAtA[i] = 0x8 6309 } 6310 return len(dAtA) - i, nil 6311 } 6312 6313 func (m *Validator) Marshal() (dAtA []byte, err error) { 6314 size := m.Size() 6315 dAtA = make([]byte, size) 6316 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6317 if err != nil { 6318 return nil, err 6319 } 6320 return dAtA[:n], nil 6321 } 6322 6323 func (m *Validator) MarshalTo(dAtA []byte) (int, error) { 6324 size := m.Size() 6325 return m.MarshalToSizedBuffer(dAtA[:size]) 6326 } 6327 6328 func (m *Validator) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6329 i := len(dAtA) 6330 _ = i 6331 var l int 6332 _ = l 6333 if m.Power != 0 { 6334 i = encodeVarintTypes(dAtA, i, uint64(m.Power)) 6335 i-- 6336 dAtA[i] = 0x18 6337 } 6338 if len(m.Address) > 0 { 6339 i -= len(m.Address) 6340 copy(dAtA[i:], m.Address) 6341 i = encodeVarintTypes(dAtA, i, uint64(len(m.Address))) 6342 i-- 6343 dAtA[i] = 0xa 6344 } 6345 return len(dAtA) - i, nil 6346 } 6347 6348 func (m *ValidatorUpdate) Marshal() (dAtA []byte, err error) { 6349 size := m.Size() 6350 dAtA = make([]byte, size) 6351 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6352 if err != nil { 6353 return nil, err 6354 } 6355 return dAtA[:n], nil 6356 } 6357 6358 func (m *ValidatorUpdate) MarshalTo(dAtA []byte) (int, error) { 6359 size := m.Size() 6360 return m.MarshalToSizedBuffer(dAtA[:size]) 6361 } 6362 6363 func (m *ValidatorUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6364 i := len(dAtA) 6365 _ = i 6366 var l int 6367 _ = l 6368 if m.Power != 0 { 6369 i = encodeVarintTypes(dAtA, i, uint64(m.Power)) 6370 i-- 6371 dAtA[i] = 0x10 6372 } 6373 { 6374 size, err := m.PubKey.MarshalToSizedBuffer(dAtA[:i]) 6375 if err != nil { 6376 return 0, err 6377 } 6378 i -= size 6379 i = encodeVarintTypes(dAtA, i, uint64(size)) 6380 } 6381 i-- 6382 dAtA[i] = 0xa 6383 return len(dAtA) - i, nil 6384 } 6385 6386 func (m *VoteInfo) Marshal() (dAtA []byte, err error) { 6387 size := m.Size() 6388 dAtA = make([]byte, size) 6389 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6390 if err != nil { 6391 return nil, err 6392 } 6393 return dAtA[:n], nil 6394 } 6395 6396 func (m *VoteInfo) MarshalTo(dAtA []byte) (int, error) { 6397 size := m.Size() 6398 return m.MarshalToSizedBuffer(dAtA[:size]) 6399 } 6400 6401 func (m *VoteInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6402 i := len(dAtA) 6403 _ = i 6404 var l int 6405 _ = l 6406 if m.SignedLastBlock { 6407 i-- 6408 if m.SignedLastBlock { 6409 dAtA[i] = 1 6410 } else { 6411 dAtA[i] = 0 6412 } 6413 i-- 6414 dAtA[i] = 0x10 6415 } 6416 { 6417 size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) 6418 if err != nil { 6419 return 0, err 6420 } 6421 i -= size 6422 i = encodeVarintTypes(dAtA, i, uint64(size)) 6423 } 6424 i-- 6425 dAtA[i] = 0xa 6426 return len(dAtA) - i, nil 6427 } 6428 6429 func (m *Evidence) Marshal() (dAtA []byte, err error) { 6430 size := m.Size() 6431 dAtA = make([]byte, size) 6432 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6433 if err != nil { 6434 return nil, err 6435 } 6436 return dAtA[:n], nil 6437 } 6438 6439 func (m *Evidence) MarshalTo(dAtA []byte) (int, error) { 6440 size := m.Size() 6441 return m.MarshalToSizedBuffer(dAtA[:size]) 6442 } 6443 6444 func (m *Evidence) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6445 i := len(dAtA) 6446 _ = i 6447 var l int 6448 _ = l 6449 if m.TotalVotingPower != 0 { 6450 i = encodeVarintTypes(dAtA, i, uint64(m.TotalVotingPower)) 6451 i-- 6452 dAtA[i] = 0x28 6453 } 6454 n49, err49 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Time):]) 6455 if err49 != nil { 6456 return 0, err49 6457 } 6458 i -= n49 6459 i = encodeVarintTypes(dAtA, i, uint64(n49)) 6460 i-- 6461 dAtA[i] = 0x22 6462 if m.Height != 0 { 6463 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 6464 i-- 6465 dAtA[i] = 0x18 6466 } 6467 { 6468 size, err := m.Validator.MarshalToSizedBuffer(dAtA[:i]) 6469 if err != nil { 6470 return 0, err 6471 } 6472 i -= size 6473 i = encodeVarintTypes(dAtA, i, uint64(size)) 6474 } 6475 i-- 6476 dAtA[i] = 0x12 6477 if m.Type != 0 { 6478 i = encodeVarintTypes(dAtA, i, uint64(m.Type)) 6479 i-- 6480 dAtA[i] = 0x8 6481 } 6482 return len(dAtA) - i, nil 6483 } 6484 6485 func (m *Snapshot) Marshal() (dAtA []byte, err error) { 6486 size := m.Size() 6487 dAtA = make([]byte, size) 6488 n, err := m.MarshalToSizedBuffer(dAtA[:size]) 6489 if err != nil { 6490 return nil, err 6491 } 6492 return dAtA[:n], nil 6493 } 6494 6495 func (m *Snapshot) MarshalTo(dAtA []byte) (int, error) { 6496 size := m.Size() 6497 return m.MarshalToSizedBuffer(dAtA[:size]) 6498 } 6499 6500 func (m *Snapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) { 6501 i := len(dAtA) 6502 _ = i 6503 var l int 6504 _ = l 6505 if len(m.Metadata) > 0 { 6506 i -= len(m.Metadata) 6507 copy(dAtA[i:], m.Metadata) 6508 i = encodeVarintTypes(dAtA, i, uint64(len(m.Metadata))) 6509 i-- 6510 dAtA[i] = 0x2a 6511 } 6512 if len(m.Hash) > 0 { 6513 i -= len(m.Hash) 6514 copy(dAtA[i:], m.Hash) 6515 i = encodeVarintTypes(dAtA, i, uint64(len(m.Hash))) 6516 i-- 6517 dAtA[i] = 0x22 6518 } 6519 if m.Chunks != 0 { 6520 i = encodeVarintTypes(dAtA, i, uint64(m.Chunks)) 6521 i-- 6522 dAtA[i] = 0x18 6523 } 6524 if m.Format != 0 { 6525 i = encodeVarintTypes(dAtA, i, uint64(m.Format)) 6526 i-- 6527 dAtA[i] = 0x10 6528 } 6529 if m.Height != 0 { 6530 i = encodeVarintTypes(dAtA, i, uint64(m.Height)) 6531 i-- 6532 dAtA[i] = 0x8 6533 } 6534 return len(dAtA) - i, nil 6535 } 6536 6537 func encodeVarintTypes(dAtA []byte, offset int, v uint64) int { 6538 offset -= sovTypes(v) 6539 base := offset 6540 for v >= 1<<7 { 6541 dAtA[offset] = uint8(v&0x7f | 0x80) 6542 v >>= 7 6543 offset++ 6544 } 6545 dAtA[offset] = uint8(v) 6546 return base 6547 } 6548 func (m *Request) Size() (n int) { 6549 if m == nil { 6550 return 0 6551 } 6552 var l int 6553 _ = l 6554 if m.Value != nil { 6555 n += m.Value.Size() 6556 } 6557 return n 6558 } 6559 6560 func (m *Request_Echo) Size() (n int) { 6561 if m == nil { 6562 return 0 6563 } 6564 var l int 6565 _ = l 6566 if m.Echo != nil { 6567 l = m.Echo.Size() 6568 n += 1 + l + sovTypes(uint64(l)) 6569 } 6570 return n 6571 } 6572 func (m *Request_Flush) Size() (n int) { 6573 if m == nil { 6574 return 0 6575 } 6576 var l int 6577 _ = l 6578 if m.Flush != nil { 6579 l = m.Flush.Size() 6580 n += 1 + l + sovTypes(uint64(l)) 6581 } 6582 return n 6583 } 6584 func (m *Request_Info) Size() (n int) { 6585 if m == nil { 6586 return 0 6587 } 6588 var l int 6589 _ = l 6590 if m.Info != nil { 6591 l = m.Info.Size() 6592 n += 1 + l + sovTypes(uint64(l)) 6593 } 6594 return n 6595 } 6596 func (m *Request_SetOption) Size() (n int) { 6597 if m == nil { 6598 return 0 6599 } 6600 var l int 6601 _ = l 6602 if m.SetOption != nil { 6603 l = m.SetOption.Size() 6604 n += 1 + l + sovTypes(uint64(l)) 6605 } 6606 return n 6607 } 6608 func (m *Request_InitChain) Size() (n int) { 6609 if m == nil { 6610 return 0 6611 } 6612 var l int 6613 _ = l 6614 if m.InitChain != nil { 6615 l = m.InitChain.Size() 6616 n += 1 + l + sovTypes(uint64(l)) 6617 } 6618 return n 6619 } 6620 func (m *Request_Query) Size() (n int) { 6621 if m == nil { 6622 return 0 6623 } 6624 var l int 6625 _ = l 6626 if m.Query != nil { 6627 l = m.Query.Size() 6628 n += 1 + l + sovTypes(uint64(l)) 6629 } 6630 return n 6631 } 6632 func (m *Request_BeginBlock) Size() (n int) { 6633 if m == nil { 6634 return 0 6635 } 6636 var l int 6637 _ = l 6638 if m.BeginBlock != nil { 6639 l = m.BeginBlock.Size() 6640 n += 1 + l + sovTypes(uint64(l)) 6641 } 6642 return n 6643 } 6644 func (m *Request_CheckTx) Size() (n int) { 6645 if m == nil { 6646 return 0 6647 } 6648 var l int 6649 _ = l 6650 if m.CheckTx != nil { 6651 l = m.CheckTx.Size() 6652 n += 1 + l + sovTypes(uint64(l)) 6653 } 6654 return n 6655 } 6656 func (m *Request_DeliverTx) Size() (n int) { 6657 if m == nil { 6658 return 0 6659 } 6660 var l int 6661 _ = l 6662 if m.DeliverTx != nil { 6663 l = m.DeliverTx.Size() 6664 n += 1 + l + sovTypes(uint64(l)) 6665 } 6666 return n 6667 } 6668 func (m *Request_EndBlock) Size() (n int) { 6669 if m == nil { 6670 return 0 6671 } 6672 var l int 6673 _ = l 6674 if m.EndBlock != nil { 6675 l = m.EndBlock.Size() 6676 n += 1 + l + sovTypes(uint64(l)) 6677 } 6678 return n 6679 } 6680 func (m *Request_Commit) Size() (n int) { 6681 if m == nil { 6682 return 0 6683 } 6684 var l int 6685 _ = l 6686 if m.Commit != nil { 6687 l = m.Commit.Size() 6688 n += 1 + l + sovTypes(uint64(l)) 6689 } 6690 return n 6691 } 6692 func (m *Request_ListSnapshots) Size() (n int) { 6693 if m == nil { 6694 return 0 6695 } 6696 var l int 6697 _ = l 6698 if m.ListSnapshots != nil { 6699 l = m.ListSnapshots.Size() 6700 n += 1 + l + sovTypes(uint64(l)) 6701 } 6702 return n 6703 } 6704 func (m *Request_OfferSnapshot) Size() (n int) { 6705 if m == nil { 6706 return 0 6707 } 6708 var l int 6709 _ = l 6710 if m.OfferSnapshot != nil { 6711 l = m.OfferSnapshot.Size() 6712 n += 1 + l + sovTypes(uint64(l)) 6713 } 6714 return n 6715 } 6716 func (m *Request_LoadSnapshotChunk) Size() (n int) { 6717 if m == nil { 6718 return 0 6719 } 6720 var l int 6721 _ = l 6722 if m.LoadSnapshotChunk != nil { 6723 l = m.LoadSnapshotChunk.Size() 6724 n += 1 + l + sovTypes(uint64(l)) 6725 } 6726 return n 6727 } 6728 func (m *Request_ApplySnapshotChunk) Size() (n int) { 6729 if m == nil { 6730 return 0 6731 } 6732 var l int 6733 _ = l 6734 if m.ApplySnapshotChunk != nil { 6735 l = m.ApplySnapshotChunk.Size() 6736 n += 1 + l + sovTypes(uint64(l)) 6737 } 6738 return n 6739 } 6740 func (m *RequestEcho) Size() (n int) { 6741 if m == nil { 6742 return 0 6743 } 6744 var l int 6745 _ = l 6746 l = len(m.Message) 6747 if l > 0 { 6748 n += 1 + l + sovTypes(uint64(l)) 6749 } 6750 return n 6751 } 6752 6753 func (m *RequestFlush) Size() (n int) { 6754 if m == nil { 6755 return 0 6756 } 6757 var l int 6758 _ = l 6759 return n 6760 } 6761 6762 func (m *RequestInfo) Size() (n int) { 6763 if m == nil { 6764 return 0 6765 } 6766 var l int 6767 _ = l 6768 l = len(m.Version) 6769 if l > 0 { 6770 n += 1 + l + sovTypes(uint64(l)) 6771 } 6772 if m.BlockVersion != 0 { 6773 n += 1 + sovTypes(uint64(m.BlockVersion)) 6774 } 6775 if m.P2PVersion != 0 { 6776 n += 1 + sovTypes(uint64(m.P2PVersion)) 6777 } 6778 return n 6779 } 6780 6781 func (m *RequestSetOption) Size() (n int) { 6782 if m == nil { 6783 return 0 6784 } 6785 var l int 6786 _ = l 6787 l = len(m.Key) 6788 if l > 0 { 6789 n += 1 + l + sovTypes(uint64(l)) 6790 } 6791 l = len(m.Value) 6792 if l > 0 { 6793 n += 1 + l + sovTypes(uint64(l)) 6794 } 6795 return n 6796 } 6797 6798 func (m *RequestInitChain) Size() (n int) { 6799 if m == nil { 6800 return 0 6801 } 6802 var l int 6803 _ = l 6804 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time) 6805 n += 1 + l + sovTypes(uint64(l)) 6806 l = len(m.ChainId) 6807 if l > 0 { 6808 n += 1 + l + sovTypes(uint64(l)) 6809 } 6810 if m.ConsensusParams != nil { 6811 l = m.ConsensusParams.Size() 6812 n += 1 + l + sovTypes(uint64(l)) 6813 } 6814 if len(m.Validators) > 0 { 6815 for _, e := range m.Validators { 6816 l = e.Size() 6817 n += 1 + l + sovTypes(uint64(l)) 6818 } 6819 } 6820 l = len(m.AppStateBytes) 6821 if l > 0 { 6822 n += 1 + l + sovTypes(uint64(l)) 6823 } 6824 if m.InitialHeight != 0 { 6825 n += 1 + sovTypes(uint64(m.InitialHeight)) 6826 } 6827 return n 6828 } 6829 6830 func (m *RequestQuery) Size() (n int) { 6831 if m == nil { 6832 return 0 6833 } 6834 var l int 6835 _ = l 6836 l = len(m.Data) 6837 if l > 0 { 6838 n += 1 + l + sovTypes(uint64(l)) 6839 } 6840 l = len(m.Path) 6841 if l > 0 { 6842 n += 1 + l + sovTypes(uint64(l)) 6843 } 6844 if m.Height != 0 { 6845 n += 1 + sovTypes(uint64(m.Height)) 6846 } 6847 if m.Prove { 6848 n += 2 6849 } 6850 return n 6851 } 6852 6853 func (m *RequestBeginBlock) Size() (n int) { 6854 if m == nil { 6855 return 0 6856 } 6857 var l int 6858 _ = l 6859 l = len(m.Hash) 6860 if l > 0 { 6861 n += 1 + l + sovTypes(uint64(l)) 6862 } 6863 l = m.Header.Size() 6864 n += 1 + l + sovTypes(uint64(l)) 6865 l = m.LastCommitInfo.Size() 6866 n += 1 + l + sovTypes(uint64(l)) 6867 if len(m.ByzantineValidators) > 0 { 6868 for _, e := range m.ByzantineValidators { 6869 l = e.Size() 6870 n += 1 + l + sovTypes(uint64(l)) 6871 } 6872 } 6873 return n 6874 } 6875 6876 func (m *RequestCheckTx) Size() (n int) { 6877 if m == nil { 6878 return 0 6879 } 6880 var l int 6881 _ = l 6882 l = len(m.Tx) 6883 if l > 0 { 6884 n += 1 + l + sovTypes(uint64(l)) 6885 } 6886 if m.Type != 0 { 6887 n += 1 + sovTypes(uint64(m.Type)) 6888 } 6889 return n 6890 } 6891 6892 func (m *RequestDeliverTx) Size() (n int) { 6893 if m == nil { 6894 return 0 6895 } 6896 var l int 6897 _ = l 6898 l = len(m.Tx) 6899 if l > 0 { 6900 n += 1 + l + sovTypes(uint64(l)) 6901 } 6902 return n 6903 } 6904 6905 func (m *RequestEndBlock) Size() (n int) { 6906 if m == nil { 6907 return 0 6908 } 6909 var l int 6910 _ = l 6911 if m.Height != 0 { 6912 n += 1 + sovTypes(uint64(m.Height)) 6913 } 6914 return n 6915 } 6916 6917 func (m *RequestCommit) Size() (n int) { 6918 if m == nil { 6919 return 0 6920 } 6921 var l int 6922 _ = l 6923 return n 6924 } 6925 6926 func (m *RequestListSnapshots) Size() (n int) { 6927 if m == nil { 6928 return 0 6929 } 6930 var l int 6931 _ = l 6932 return n 6933 } 6934 6935 func (m *RequestOfferSnapshot) Size() (n int) { 6936 if m == nil { 6937 return 0 6938 } 6939 var l int 6940 _ = l 6941 if m.Snapshot != nil { 6942 l = m.Snapshot.Size() 6943 n += 1 + l + sovTypes(uint64(l)) 6944 } 6945 l = len(m.AppHash) 6946 if l > 0 { 6947 n += 1 + l + sovTypes(uint64(l)) 6948 } 6949 return n 6950 } 6951 6952 func (m *RequestLoadSnapshotChunk) Size() (n int) { 6953 if m == nil { 6954 return 0 6955 } 6956 var l int 6957 _ = l 6958 if m.Height != 0 { 6959 n += 1 + sovTypes(uint64(m.Height)) 6960 } 6961 if m.Format != 0 { 6962 n += 1 + sovTypes(uint64(m.Format)) 6963 } 6964 if m.Chunk != 0 { 6965 n += 1 + sovTypes(uint64(m.Chunk)) 6966 } 6967 return n 6968 } 6969 6970 func (m *RequestApplySnapshotChunk) Size() (n int) { 6971 if m == nil { 6972 return 0 6973 } 6974 var l int 6975 _ = l 6976 if m.Index != 0 { 6977 n += 1 + sovTypes(uint64(m.Index)) 6978 } 6979 l = len(m.Chunk) 6980 if l > 0 { 6981 n += 1 + l + sovTypes(uint64(l)) 6982 } 6983 l = len(m.Sender) 6984 if l > 0 { 6985 n += 1 + l + sovTypes(uint64(l)) 6986 } 6987 return n 6988 } 6989 6990 func (m *Response) Size() (n int) { 6991 if m == nil { 6992 return 0 6993 } 6994 var l int 6995 _ = l 6996 if m.Value != nil { 6997 n += m.Value.Size() 6998 } 6999 return n 7000 } 7001 7002 func (m *Response_Exception) Size() (n int) { 7003 if m == nil { 7004 return 0 7005 } 7006 var l int 7007 _ = l 7008 if m.Exception != nil { 7009 l = m.Exception.Size() 7010 n += 1 + l + sovTypes(uint64(l)) 7011 } 7012 return n 7013 } 7014 func (m *Response_Echo) Size() (n int) { 7015 if m == nil { 7016 return 0 7017 } 7018 var l int 7019 _ = l 7020 if m.Echo != nil { 7021 l = m.Echo.Size() 7022 n += 1 + l + sovTypes(uint64(l)) 7023 } 7024 return n 7025 } 7026 func (m *Response_Flush) Size() (n int) { 7027 if m == nil { 7028 return 0 7029 } 7030 var l int 7031 _ = l 7032 if m.Flush != nil { 7033 l = m.Flush.Size() 7034 n += 1 + l + sovTypes(uint64(l)) 7035 } 7036 return n 7037 } 7038 func (m *Response_Info) Size() (n int) { 7039 if m == nil { 7040 return 0 7041 } 7042 var l int 7043 _ = l 7044 if m.Info != nil { 7045 l = m.Info.Size() 7046 n += 1 + l + sovTypes(uint64(l)) 7047 } 7048 return n 7049 } 7050 func (m *Response_SetOption) Size() (n int) { 7051 if m == nil { 7052 return 0 7053 } 7054 var l int 7055 _ = l 7056 if m.SetOption != nil { 7057 l = m.SetOption.Size() 7058 n += 1 + l + sovTypes(uint64(l)) 7059 } 7060 return n 7061 } 7062 func (m *Response_InitChain) Size() (n int) { 7063 if m == nil { 7064 return 0 7065 } 7066 var l int 7067 _ = l 7068 if m.InitChain != nil { 7069 l = m.InitChain.Size() 7070 n += 1 + l + sovTypes(uint64(l)) 7071 } 7072 return n 7073 } 7074 func (m *Response_Query) Size() (n int) { 7075 if m == nil { 7076 return 0 7077 } 7078 var l int 7079 _ = l 7080 if m.Query != nil { 7081 l = m.Query.Size() 7082 n += 1 + l + sovTypes(uint64(l)) 7083 } 7084 return n 7085 } 7086 func (m *Response_BeginBlock) Size() (n int) { 7087 if m == nil { 7088 return 0 7089 } 7090 var l int 7091 _ = l 7092 if m.BeginBlock != nil { 7093 l = m.BeginBlock.Size() 7094 n += 1 + l + sovTypes(uint64(l)) 7095 } 7096 return n 7097 } 7098 func (m *Response_CheckTx) Size() (n int) { 7099 if m == nil { 7100 return 0 7101 } 7102 var l int 7103 _ = l 7104 if m.CheckTx != nil { 7105 l = m.CheckTx.Size() 7106 n += 1 + l + sovTypes(uint64(l)) 7107 } 7108 return n 7109 } 7110 func (m *Response_DeliverTx) Size() (n int) { 7111 if m == nil { 7112 return 0 7113 } 7114 var l int 7115 _ = l 7116 if m.DeliverTx != nil { 7117 l = m.DeliverTx.Size() 7118 n += 1 + l + sovTypes(uint64(l)) 7119 } 7120 return n 7121 } 7122 func (m *Response_EndBlock) Size() (n int) { 7123 if m == nil { 7124 return 0 7125 } 7126 var l int 7127 _ = l 7128 if m.EndBlock != nil { 7129 l = m.EndBlock.Size() 7130 n += 1 + l + sovTypes(uint64(l)) 7131 } 7132 return n 7133 } 7134 func (m *Response_Commit) Size() (n int) { 7135 if m == nil { 7136 return 0 7137 } 7138 var l int 7139 _ = l 7140 if m.Commit != nil { 7141 l = m.Commit.Size() 7142 n += 1 + l + sovTypes(uint64(l)) 7143 } 7144 return n 7145 } 7146 func (m *Response_ListSnapshots) Size() (n int) { 7147 if m == nil { 7148 return 0 7149 } 7150 var l int 7151 _ = l 7152 if m.ListSnapshots != nil { 7153 l = m.ListSnapshots.Size() 7154 n += 1 + l + sovTypes(uint64(l)) 7155 } 7156 return n 7157 } 7158 func (m *Response_OfferSnapshot) Size() (n int) { 7159 if m == nil { 7160 return 0 7161 } 7162 var l int 7163 _ = l 7164 if m.OfferSnapshot != nil { 7165 l = m.OfferSnapshot.Size() 7166 n += 1 + l + sovTypes(uint64(l)) 7167 } 7168 return n 7169 } 7170 func (m *Response_LoadSnapshotChunk) Size() (n int) { 7171 if m == nil { 7172 return 0 7173 } 7174 var l int 7175 _ = l 7176 if m.LoadSnapshotChunk != nil { 7177 l = m.LoadSnapshotChunk.Size() 7178 n += 1 + l + sovTypes(uint64(l)) 7179 } 7180 return n 7181 } 7182 func (m *Response_ApplySnapshotChunk) Size() (n int) { 7183 if m == nil { 7184 return 0 7185 } 7186 var l int 7187 _ = l 7188 if m.ApplySnapshotChunk != nil { 7189 l = m.ApplySnapshotChunk.Size() 7190 n += 2 + l + sovTypes(uint64(l)) 7191 } 7192 return n 7193 } 7194 func (m *ResponseException) Size() (n int) { 7195 if m == nil { 7196 return 0 7197 } 7198 var l int 7199 _ = l 7200 l = len(m.Error) 7201 if l > 0 { 7202 n += 1 + l + sovTypes(uint64(l)) 7203 } 7204 return n 7205 } 7206 7207 func (m *ResponseEcho) Size() (n int) { 7208 if m == nil { 7209 return 0 7210 } 7211 var l int 7212 _ = l 7213 l = len(m.Message) 7214 if l > 0 { 7215 n += 1 + l + sovTypes(uint64(l)) 7216 } 7217 return n 7218 } 7219 7220 func (m *ResponseFlush) Size() (n int) { 7221 if m == nil { 7222 return 0 7223 } 7224 var l int 7225 _ = l 7226 return n 7227 } 7228 7229 func (m *ResponseInfo) Size() (n int) { 7230 if m == nil { 7231 return 0 7232 } 7233 var l int 7234 _ = l 7235 l = len(m.Data) 7236 if l > 0 { 7237 n += 1 + l + sovTypes(uint64(l)) 7238 } 7239 l = len(m.Version) 7240 if l > 0 { 7241 n += 1 + l + sovTypes(uint64(l)) 7242 } 7243 if m.AppVersion != 0 { 7244 n += 1 + sovTypes(uint64(m.AppVersion)) 7245 } 7246 if m.LastBlockHeight != 0 { 7247 n += 1 + sovTypes(uint64(m.LastBlockHeight)) 7248 } 7249 l = len(m.LastBlockAppHash) 7250 if l > 0 { 7251 n += 1 + l + sovTypes(uint64(l)) 7252 } 7253 return n 7254 } 7255 7256 func (m *ResponseSetOption) Size() (n int) { 7257 if m == nil { 7258 return 0 7259 } 7260 var l int 7261 _ = l 7262 if m.Code != 0 { 7263 n += 1 + sovTypes(uint64(m.Code)) 7264 } 7265 l = len(m.Log) 7266 if l > 0 { 7267 n += 1 + l + sovTypes(uint64(l)) 7268 } 7269 l = len(m.Info) 7270 if l > 0 { 7271 n += 1 + l + sovTypes(uint64(l)) 7272 } 7273 return n 7274 } 7275 7276 func (m *ResponseInitChain) Size() (n int) { 7277 if m == nil { 7278 return 0 7279 } 7280 var l int 7281 _ = l 7282 if m.ConsensusParams != nil { 7283 l = m.ConsensusParams.Size() 7284 n += 1 + l + sovTypes(uint64(l)) 7285 } 7286 if len(m.Validators) > 0 { 7287 for _, e := range m.Validators { 7288 l = e.Size() 7289 n += 1 + l + sovTypes(uint64(l)) 7290 } 7291 } 7292 l = len(m.AppHash) 7293 if l > 0 { 7294 n += 1 + l + sovTypes(uint64(l)) 7295 } 7296 return n 7297 } 7298 7299 func (m *ResponseQuery) Size() (n int) { 7300 if m == nil { 7301 return 0 7302 } 7303 var l int 7304 _ = l 7305 if m.Code != 0 { 7306 n += 1 + sovTypes(uint64(m.Code)) 7307 } 7308 l = len(m.Log) 7309 if l > 0 { 7310 n += 1 + l + sovTypes(uint64(l)) 7311 } 7312 l = len(m.Info) 7313 if l > 0 { 7314 n += 1 + l + sovTypes(uint64(l)) 7315 } 7316 if m.Index != 0 { 7317 n += 1 + sovTypes(uint64(m.Index)) 7318 } 7319 l = len(m.Key) 7320 if l > 0 { 7321 n += 1 + l + sovTypes(uint64(l)) 7322 } 7323 l = len(m.Value) 7324 if l > 0 { 7325 n += 1 + l + sovTypes(uint64(l)) 7326 } 7327 if m.ProofOps != nil { 7328 l = m.ProofOps.Size() 7329 n += 1 + l + sovTypes(uint64(l)) 7330 } 7331 if m.Height != 0 { 7332 n += 1 + sovTypes(uint64(m.Height)) 7333 } 7334 l = len(m.Codespace) 7335 if l > 0 { 7336 n += 1 + l + sovTypes(uint64(l)) 7337 } 7338 return n 7339 } 7340 7341 func (m *ResponseBeginBlock) Size() (n int) { 7342 if m == nil { 7343 return 0 7344 } 7345 var l int 7346 _ = l 7347 if len(m.Events) > 0 { 7348 for _, e := range m.Events { 7349 l = e.Size() 7350 n += 1 + l + sovTypes(uint64(l)) 7351 } 7352 } 7353 return n 7354 } 7355 7356 func (m *ResponseCheckTx) Size() (n int) { 7357 if m == nil { 7358 return 0 7359 } 7360 var l int 7361 _ = l 7362 if m.Code != 0 { 7363 n += 1 + sovTypes(uint64(m.Code)) 7364 } 7365 l = len(m.Data) 7366 if l > 0 { 7367 n += 1 + l + sovTypes(uint64(l)) 7368 } 7369 l = len(m.Log) 7370 if l > 0 { 7371 n += 1 + l + sovTypes(uint64(l)) 7372 } 7373 l = len(m.Info) 7374 if l > 0 { 7375 n += 1 + l + sovTypes(uint64(l)) 7376 } 7377 if m.GasWanted != 0 { 7378 n += 1 + sovTypes(uint64(m.GasWanted)) 7379 } 7380 if m.GasUsed != 0 { 7381 n += 1 + sovTypes(uint64(m.GasUsed)) 7382 } 7383 if len(m.Events) > 0 { 7384 for _, e := range m.Events { 7385 l = e.Size() 7386 n += 1 + l + sovTypes(uint64(l)) 7387 } 7388 } 7389 l = len(m.Codespace) 7390 if l > 0 { 7391 n += 1 + l + sovTypes(uint64(l)) 7392 } 7393 return n 7394 } 7395 7396 func (m *ResponseDeliverTx) Size() (n int) { 7397 if m == nil { 7398 return 0 7399 } 7400 var l int 7401 _ = l 7402 if m.Code != 0 { 7403 n += 1 + sovTypes(uint64(m.Code)) 7404 } 7405 l = len(m.Data) 7406 if l > 0 { 7407 n += 1 + l + sovTypes(uint64(l)) 7408 } 7409 l = len(m.Log) 7410 if l > 0 { 7411 n += 1 + l + sovTypes(uint64(l)) 7412 } 7413 l = len(m.Info) 7414 if l > 0 { 7415 n += 1 + l + sovTypes(uint64(l)) 7416 } 7417 if m.GasWanted != 0 { 7418 n += 1 + sovTypes(uint64(m.GasWanted)) 7419 } 7420 if m.GasUsed != 0 { 7421 n += 1 + sovTypes(uint64(m.GasUsed)) 7422 } 7423 if len(m.Events) > 0 { 7424 for _, e := range m.Events { 7425 l = e.Size() 7426 n += 1 + l + sovTypes(uint64(l)) 7427 } 7428 } 7429 l = len(m.Codespace) 7430 if l > 0 { 7431 n += 1 + l + sovTypes(uint64(l)) 7432 } 7433 return n 7434 } 7435 7436 func (m *ResponseEndBlock) Size() (n int) { 7437 if m == nil { 7438 return 0 7439 } 7440 var l int 7441 _ = l 7442 if len(m.ValidatorUpdates) > 0 { 7443 for _, e := range m.ValidatorUpdates { 7444 l = e.Size() 7445 n += 1 + l + sovTypes(uint64(l)) 7446 } 7447 } 7448 if m.ConsensusParamUpdates != nil { 7449 l = m.ConsensusParamUpdates.Size() 7450 n += 1 + l + sovTypes(uint64(l)) 7451 } 7452 if len(m.Events) > 0 { 7453 for _, e := range m.Events { 7454 l = e.Size() 7455 n += 1 + l + sovTypes(uint64(l)) 7456 } 7457 } 7458 return n 7459 } 7460 7461 func (m *ResponseCommit) Size() (n int) { 7462 if m == nil { 7463 return 0 7464 } 7465 var l int 7466 _ = l 7467 l = len(m.Data) 7468 if l > 0 { 7469 n += 1 + l + sovTypes(uint64(l)) 7470 } 7471 if m.RetainHeight != 0 { 7472 n += 1 + sovTypes(uint64(m.RetainHeight)) 7473 } 7474 return n 7475 } 7476 7477 func (m *ResponseListSnapshots) Size() (n int) { 7478 if m == nil { 7479 return 0 7480 } 7481 var l int 7482 _ = l 7483 if len(m.Snapshots) > 0 { 7484 for _, e := range m.Snapshots { 7485 l = e.Size() 7486 n += 1 + l + sovTypes(uint64(l)) 7487 } 7488 } 7489 return n 7490 } 7491 7492 func (m *ResponseOfferSnapshot) Size() (n int) { 7493 if m == nil { 7494 return 0 7495 } 7496 var l int 7497 _ = l 7498 if m.Result != 0 { 7499 n += 1 + sovTypes(uint64(m.Result)) 7500 } 7501 return n 7502 } 7503 7504 func (m *ResponseLoadSnapshotChunk) Size() (n int) { 7505 if m == nil { 7506 return 0 7507 } 7508 var l int 7509 _ = l 7510 l = len(m.Chunk) 7511 if l > 0 { 7512 n += 1 + l + sovTypes(uint64(l)) 7513 } 7514 return n 7515 } 7516 7517 func (m *ResponseApplySnapshotChunk) Size() (n int) { 7518 if m == nil { 7519 return 0 7520 } 7521 var l int 7522 _ = l 7523 if m.Result != 0 { 7524 n += 1 + sovTypes(uint64(m.Result)) 7525 } 7526 if len(m.RefetchChunks) > 0 { 7527 l = 0 7528 for _, e := range m.RefetchChunks { 7529 l += sovTypes(uint64(e)) 7530 } 7531 n += 1 + sovTypes(uint64(l)) + l 7532 } 7533 if len(m.RejectSenders) > 0 { 7534 for _, s := range m.RejectSenders { 7535 l = len(s) 7536 n += 1 + l + sovTypes(uint64(l)) 7537 } 7538 } 7539 return n 7540 } 7541 7542 func (m *ConsensusParams) Size() (n int) { 7543 if m == nil { 7544 return 0 7545 } 7546 var l int 7547 _ = l 7548 if m.Block != nil { 7549 l = m.Block.Size() 7550 n += 1 + l + sovTypes(uint64(l)) 7551 } 7552 if m.Evidence != nil { 7553 l = m.Evidence.Size() 7554 n += 1 + l + sovTypes(uint64(l)) 7555 } 7556 if m.Validator != nil { 7557 l = m.Validator.Size() 7558 n += 1 + l + sovTypes(uint64(l)) 7559 } 7560 if m.Version != nil { 7561 l = m.Version.Size() 7562 n += 1 + l + sovTypes(uint64(l)) 7563 } 7564 return n 7565 } 7566 7567 func (m *BlockParams) Size() (n int) { 7568 if m == nil { 7569 return 0 7570 } 7571 var l int 7572 _ = l 7573 if m.MaxBytes != 0 { 7574 n += 1 + sovTypes(uint64(m.MaxBytes)) 7575 } 7576 if m.MaxGas != 0 { 7577 n += 1 + sovTypes(uint64(m.MaxGas)) 7578 } 7579 return n 7580 } 7581 7582 func (m *LastCommitInfo) Size() (n int) { 7583 if m == nil { 7584 return 0 7585 } 7586 var l int 7587 _ = l 7588 if m.Round != 0 { 7589 n += 1 + sovTypes(uint64(m.Round)) 7590 } 7591 if len(m.Votes) > 0 { 7592 for _, e := range m.Votes { 7593 l = e.Size() 7594 n += 1 + l + sovTypes(uint64(l)) 7595 } 7596 } 7597 return n 7598 } 7599 7600 func (m *Event) Size() (n int) { 7601 if m == nil { 7602 return 0 7603 } 7604 var l int 7605 _ = l 7606 l = len(m.Type) 7607 if l > 0 { 7608 n += 1 + l + sovTypes(uint64(l)) 7609 } 7610 if len(m.Attributes) > 0 { 7611 for _, e := range m.Attributes { 7612 l = e.Size() 7613 n += 1 + l + sovTypes(uint64(l)) 7614 } 7615 } 7616 return n 7617 } 7618 7619 func (m *EventAttribute) Size() (n int) { 7620 if m == nil { 7621 return 0 7622 } 7623 var l int 7624 _ = l 7625 l = len(m.Key) 7626 if l > 0 { 7627 n += 1 + l + sovTypes(uint64(l)) 7628 } 7629 l = len(m.Value) 7630 if l > 0 { 7631 n += 1 + l + sovTypes(uint64(l)) 7632 } 7633 if m.Index { 7634 n += 2 7635 } 7636 return n 7637 } 7638 7639 func (m *TxResult) Size() (n int) { 7640 if m == nil { 7641 return 0 7642 } 7643 var l int 7644 _ = l 7645 if m.Height != 0 { 7646 n += 1 + sovTypes(uint64(m.Height)) 7647 } 7648 if m.Index != 0 { 7649 n += 1 + sovTypes(uint64(m.Index)) 7650 } 7651 l = len(m.Tx) 7652 if l > 0 { 7653 n += 1 + l + sovTypes(uint64(l)) 7654 } 7655 l = m.Result.Size() 7656 n += 1 + l + sovTypes(uint64(l)) 7657 return n 7658 } 7659 7660 func (m *Validator) Size() (n int) { 7661 if m == nil { 7662 return 0 7663 } 7664 var l int 7665 _ = l 7666 l = len(m.Address) 7667 if l > 0 { 7668 n += 1 + l + sovTypes(uint64(l)) 7669 } 7670 if m.Power != 0 { 7671 n += 1 + sovTypes(uint64(m.Power)) 7672 } 7673 return n 7674 } 7675 7676 func (m *ValidatorUpdate) Size() (n int) { 7677 if m == nil { 7678 return 0 7679 } 7680 var l int 7681 _ = l 7682 l = m.PubKey.Size() 7683 n += 1 + l + sovTypes(uint64(l)) 7684 if m.Power != 0 { 7685 n += 1 + sovTypes(uint64(m.Power)) 7686 } 7687 return n 7688 } 7689 7690 func (m *VoteInfo) Size() (n int) { 7691 if m == nil { 7692 return 0 7693 } 7694 var l int 7695 _ = l 7696 l = m.Validator.Size() 7697 n += 1 + l + sovTypes(uint64(l)) 7698 if m.SignedLastBlock { 7699 n += 2 7700 } 7701 return n 7702 } 7703 7704 func (m *Evidence) Size() (n int) { 7705 if m == nil { 7706 return 0 7707 } 7708 var l int 7709 _ = l 7710 if m.Type != 0 { 7711 n += 1 + sovTypes(uint64(m.Type)) 7712 } 7713 l = m.Validator.Size() 7714 n += 1 + l + sovTypes(uint64(l)) 7715 if m.Height != 0 { 7716 n += 1 + sovTypes(uint64(m.Height)) 7717 } 7718 l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time) 7719 n += 1 + l + sovTypes(uint64(l)) 7720 if m.TotalVotingPower != 0 { 7721 n += 1 + sovTypes(uint64(m.TotalVotingPower)) 7722 } 7723 return n 7724 } 7725 7726 func (m *Snapshot) Size() (n int) { 7727 if m == nil { 7728 return 0 7729 } 7730 var l int 7731 _ = l 7732 if m.Height != 0 { 7733 n += 1 + sovTypes(uint64(m.Height)) 7734 } 7735 if m.Format != 0 { 7736 n += 1 + sovTypes(uint64(m.Format)) 7737 } 7738 if m.Chunks != 0 { 7739 n += 1 + sovTypes(uint64(m.Chunks)) 7740 } 7741 l = len(m.Hash) 7742 if l > 0 { 7743 n += 1 + l + sovTypes(uint64(l)) 7744 } 7745 l = len(m.Metadata) 7746 if l > 0 { 7747 n += 1 + l + sovTypes(uint64(l)) 7748 } 7749 return n 7750 } 7751 7752 func sovTypes(x uint64) (n int) { 7753 return (math_bits.Len64(x|1) + 6) / 7 7754 } 7755 func sozTypes(x uint64) (n int) { 7756 return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63)))) 7757 } 7758 func (m *Request) Unmarshal(dAtA []byte) error { 7759 l := len(dAtA) 7760 iNdEx := 0 7761 for iNdEx < l { 7762 preIndex := iNdEx 7763 var wire uint64 7764 for shift := uint(0); ; shift += 7 { 7765 if shift >= 64 { 7766 return ErrIntOverflowTypes 7767 } 7768 if iNdEx >= l { 7769 return io.ErrUnexpectedEOF 7770 } 7771 b := dAtA[iNdEx] 7772 iNdEx++ 7773 wire |= uint64(b&0x7F) << shift 7774 if b < 0x80 { 7775 break 7776 } 7777 } 7778 fieldNum := int32(wire >> 3) 7779 wireType := int(wire & 0x7) 7780 if wireType == 4 { 7781 return fmt.Errorf("proto: Request: wiretype end group for non-group") 7782 } 7783 if fieldNum <= 0 { 7784 return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire) 7785 } 7786 switch fieldNum { 7787 case 1: 7788 if wireType != 2 { 7789 return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType) 7790 } 7791 var msglen int 7792 for shift := uint(0); ; shift += 7 { 7793 if shift >= 64 { 7794 return ErrIntOverflowTypes 7795 } 7796 if iNdEx >= l { 7797 return io.ErrUnexpectedEOF 7798 } 7799 b := dAtA[iNdEx] 7800 iNdEx++ 7801 msglen |= int(b&0x7F) << shift 7802 if b < 0x80 { 7803 break 7804 } 7805 } 7806 if msglen < 0 { 7807 return ErrInvalidLengthTypes 7808 } 7809 postIndex := iNdEx + msglen 7810 if postIndex < 0 { 7811 return ErrInvalidLengthTypes 7812 } 7813 if postIndex > l { 7814 return io.ErrUnexpectedEOF 7815 } 7816 v := &RequestEcho{} 7817 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7818 return err 7819 } 7820 m.Value = &Request_Echo{v} 7821 iNdEx = postIndex 7822 case 2: 7823 if wireType != 2 { 7824 return fmt.Errorf("proto: wrong wireType = %d for field Flush", wireType) 7825 } 7826 var msglen int 7827 for shift := uint(0); ; shift += 7 { 7828 if shift >= 64 { 7829 return ErrIntOverflowTypes 7830 } 7831 if iNdEx >= l { 7832 return io.ErrUnexpectedEOF 7833 } 7834 b := dAtA[iNdEx] 7835 iNdEx++ 7836 msglen |= int(b&0x7F) << shift 7837 if b < 0x80 { 7838 break 7839 } 7840 } 7841 if msglen < 0 { 7842 return ErrInvalidLengthTypes 7843 } 7844 postIndex := iNdEx + msglen 7845 if postIndex < 0 { 7846 return ErrInvalidLengthTypes 7847 } 7848 if postIndex > l { 7849 return io.ErrUnexpectedEOF 7850 } 7851 v := &RequestFlush{} 7852 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7853 return err 7854 } 7855 m.Value = &Request_Flush{v} 7856 iNdEx = postIndex 7857 case 3: 7858 if wireType != 2 { 7859 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 7860 } 7861 var msglen int 7862 for shift := uint(0); ; shift += 7 { 7863 if shift >= 64 { 7864 return ErrIntOverflowTypes 7865 } 7866 if iNdEx >= l { 7867 return io.ErrUnexpectedEOF 7868 } 7869 b := dAtA[iNdEx] 7870 iNdEx++ 7871 msglen |= int(b&0x7F) << shift 7872 if b < 0x80 { 7873 break 7874 } 7875 } 7876 if msglen < 0 { 7877 return ErrInvalidLengthTypes 7878 } 7879 postIndex := iNdEx + msglen 7880 if postIndex < 0 { 7881 return ErrInvalidLengthTypes 7882 } 7883 if postIndex > l { 7884 return io.ErrUnexpectedEOF 7885 } 7886 v := &RequestInfo{} 7887 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7888 return err 7889 } 7890 m.Value = &Request_Info{v} 7891 iNdEx = postIndex 7892 case 4: 7893 if wireType != 2 { 7894 return fmt.Errorf("proto: wrong wireType = %d for field SetOption", wireType) 7895 } 7896 var msglen int 7897 for shift := uint(0); ; shift += 7 { 7898 if shift >= 64 { 7899 return ErrIntOverflowTypes 7900 } 7901 if iNdEx >= l { 7902 return io.ErrUnexpectedEOF 7903 } 7904 b := dAtA[iNdEx] 7905 iNdEx++ 7906 msglen |= int(b&0x7F) << shift 7907 if b < 0x80 { 7908 break 7909 } 7910 } 7911 if msglen < 0 { 7912 return ErrInvalidLengthTypes 7913 } 7914 postIndex := iNdEx + msglen 7915 if postIndex < 0 { 7916 return ErrInvalidLengthTypes 7917 } 7918 if postIndex > l { 7919 return io.ErrUnexpectedEOF 7920 } 7921 v := &RequestSetOption{} 7922 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7923 return err 7924 } 7925 m.Value = &Request_SetOption{v} 7926 iNdEx = postIndex 7927 case 5: 7928 if wireType != 2 { 7929 return fmt.Errorf("proto: wrong wireType = %d for field InitChain", wireType) 7930 } 7931 var msglen int 7932 for shift := uint(0); ; shift += 7 { 7933 if shift >= 64 { 7934 return ErrIntOverflowTypes 7935 } 7936 if iNdEx >= l { 7937 return io.ErrUnexpectedEOF 7938 } 7939 b := dAtA[iNdEx] 7940 iNdEx++ 7941 msglen |= int(b&0x7F) << shift 7942 if b < 0x80 { 7943 break 7944 } 7945 } 7946 if msglen < 0 { 7947 return ErrInvalidLengthTypes 7948 } 7949 postIndex := iNdEx + msglen 7950 if postIndex < 0 { 7951 return ErrInvalidLengthTypes 7952 } 7953 if postIndex > l { 7954 return io.ErrUnexpectedEOF 7955 } 7956 v := &RequestInitChain{} 7957 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7958 return err 7959 } 7960 m.Value = &Request_InitChain{v} 7961 iNdEx = postIndex 7962 case 6: 7963 if wireType != 2 { 7964 return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType) 7965 } 7966 var msglen int 7967 for shift := uint(0); ; shift += 7 { 7968 if shift >= 64 { 7969 return ErrIntOverflowTypes 7970 } 7971 if iNdEx >= l { 7972 return io.ErrUnexpectedEOF 7973 } 7974 b := dAtA[iNdEx] 7975 iNdEx++ 7976 msglen |= int(b&0x7F) << shift 7977 if b < 0x80 { 7978 break 7979 } 7980 } 7981 if msglen < 0 { 7982 return ErrInvalidLengthTypes 7983 } 7984 postIndex := iNdEx + msglen 7985 if postIndex < 0 { 7986 return ErrInvalidLengthTypes 7987 } 7988 if postIndex > l { 7989 return io.ErrUnexpectedEOF 7990 } 7991 v := &RequestQuery{} 7992 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 7993 return err 7994 } 7995 m.Value = &Request_Query{v} 7996 iNdEx = postIndex 7997 case 7: 7998 if wireType != 2 { 7999 return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType) 8000 } 8001 var msglen int 8002 for shift := uint(0); ; shift += 7 { 8003 if shift >= 64 { 8004 return ErrIntOverflowTypes 8005 } 8006 if iNdEx >= l { 8007 return io.ErrUnexpectedEOF 8008 } 8009 b := dAtA[iNdEx] 8010 iNdEx++ 8011 msglen |= int(b&0x7F) << shift 8012 if b < 0x80 { 8013 break 8014 } 8015 } 8016 if msglen < 0 { 8017 return ErrInvalidLengthTypes 8018 } 8019 postIndex := iNdEx + msglen 8020 if postIndex < 0 { 8021 return ErrInvalidLengthTypes 8022 } 8023 if postIndex > l { 8024 return io.ErrUnexpectedEOF 8025 } 8026 v := &RequestBeginBlock{} 8027 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8028 return err 8029 } 8030 m.Value = &Request_BeginBlock{v} 8031 iNdEx = postIndex 8032 case 8: 8033 if wireType != 2 { 8034 return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", wireType) 8035 } 8036 var msglen int 8037 for shift := uint(0); ; shift += 7 { 8038 if shift >= 64 { 8039 return ErrIntOverflowTypes 8040 } 8041 if iNdEx >= l { 8042 return io.ErrUnexpectedEOF 8043 } 8044 b := dAtA[iNdEx] 8045 iNdEx++ 8046 msglen |= int(b&0x7F) << shift 8047 if b < 0x80 { 8048 break 8049 } 8050 } 8051 if msglen < 0 { 8052 return ErrInvalidLengthTypes 8053 } 8054 postIndex := iNdEx + msglen 8055 if postIndex < 0 { 8056 return ErrInvalidLengthTypes 8057 } 8058 if postIndex > l { 8059 return io.ErrUnexpectedEOF 8060 } 8061 v := &RequestCheckTx{} 8062 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8063 return err 8064 } 8065 m.Value = &Request_CheckTx{v} 8066 iNdEx = postIndex 8067 case 9: 8068 if wireType != 2 { 8069 return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", wireType) 8070 } 8071 var msglen int 8072 for shift := uint(0); ; shift += 7 { 8073 if shift >= 64 { 8074 return ErrIntOverflowTypes 8075 } 8076 if iNdEx >= l { 8077 return io.ErrUnexpectedEOF 8078 } 8079 b := dAtA[iNdEx] 8080 iNdEx++ 8081 msglen |= int(b&0x7F) << shift 8082 if b < 0x80 { 8083 break 8084 } 8085 } 8086 if msglen < 0 { 8087 return ErrInvalidLengthTypes 8088 } 8089 postIndex := iNdEx + msglen 8090 if postIndex < 0 { 8091 return ErrInvalidLengthTypes 8092 } 8093 if postIndex > l { 8094 return io.ErrUnexpectedEOF 8095 } 8096 v := &RequestDeliverTx{} 8097 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8098 return err 8099 } 8100 m.Value = &Request_DeliverTx{v} 8101 iNdEx = postIndex 8102 case 10: 8103 if wireType != 2 { 8104 return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType) 8105 } 8106 var msglen int 8107 for shift := uint(0); ; shift += 7 { 8108 if shift >= 64 { 8109 return ErrIntOverflowTypes 8110 } 8111 if iNdEx >= l { 8112 return io.ErrUnexpectedEOF 8113 } 8114 b := dAtA[iNdEx] 8115 iNdEx++ 8116 msglen |= int(b&0x7F) << shift 8117 if b < 0x80 { 8118 break 8119 } 8120 } 8121 if msglen < 0 { 8122 return ErrInvalidLengthTypes 8123 } 8124 postIndex := iNdEx + msglen 8125 if postIndex < 0 { 8126 return ErrInvalidLengthTypes 8127 } 8128 if postIndex > l { 8129 return io.ErrUnexpectedEOF 8130 } 8131 v := &RequestEndBlock{} 8132 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8133 return err 8134 } 8135 m.Value = &Request_EndBlock{v} 8136 iNdEx = postIndex 8137 case 11: 8138 if wireType != 2 { 8139 return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType) 8140 } 8141 var msglen int 8142 for shift := uint(0); ; shift += 7 { 8143 if shift >= 64 { 8144 return ErrIntOverflowTypes 8145 } 8146 if iNdEx >= l { 8147 return io.ErrUnexpectedEOF 8148 } 8149 b := dAtA[iNdEx] 8150 iNdEx++ 8151 msglen |= int(b&0x7F) << shift 8152 if b < 0x80 { 8153 break 8154 } 8155 } 8156 if msglen < 0 { 8157 return ErrInvalidLengthTypes 8158 } 8159 postIndex := iNdEx + msglen 8160 if postIndex < 0 { 8161 return ErrInvalidLengthTypes 8162 } 8163 if postIndex > l { 8164 return io.ErrUnexpectedEOF 8165 } 8166 v := &RequestCommit{} 8167 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8168 return err 8169 } 8170 m.Value = &Request_Commit{v} 8171 iNdEx = postIndex 8172 case 12: 8173 if wireType != 2 { 8174 return fmt.Errorf("proto: wrong wireType = %d for field ListSnapshots", wireType) 8175 } 8176 var msglen int 8177 for shift := uint(0); ; shift += 7 { 8178 if shift >= 64 { 8179 return ErrIntOverflowTypes 8180 } 8181 if iNdEx >= l { 8182 return io.ErrUnexpectedEOF 8183 } 8184 b := dAtA[iNdEx] 8185 iNdEx++ 8186 msglen |= int(b&0x7F) << shift 8187 if b < 0x80 { 8188 break 8189 } 8190 } 8191 if msglen < 0 { 8192 return ErrInvalidLengthTypes 8193 } 8194 postIndex := iNdEx + msglen 8195 if postIndex < 0 { 8196 return ErrInvalidLengthTypes 8197 } 8198 if postIndex > l { 8199 return io.ErrUnexpectedEOF 8200 } 8201 v := &RequestListSnapshots{} 8202 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8203 return err 8204 } 8205 m.Value = &Request_ListSnapshots{v} 8206 iNdEx = postIndex 8207 case 13: 8208 if wireType != 2 { 8209 return fmt.Errorf("proto: wrong wireType = %d for field OfferSnapshot", wireType) 8210 } 8211 var msglen int 8212 for shift := uint(0); ; shift += 7 { 8213 if shift >= 64 { 8214 return ErrIntOverflowTypes 8215 } 8216 if iNdEx >= l { 8217 return io.ErrUnexpectedEOF 8218 } 8219 b := dAtA[iNdEx] 8220 iNdEx++ 8221 msglen |= int(b&0x7F) << shift 8222 if b < 0x80 { 8223 break 8224 } 8225 } 8226 if msglen < 0 { 8227 return ErrInvalidLengthTypes 8228 } 8229 postIndex := iNdEx + msglen 8230 if postIndex < 0 { 8231 return ErrInvalidLengthTypes 8232 } 8233 if postIndex > l { 8234 return io.ErrUnexpectedEOF 8235 } 8236 v := &RequestOfferSnapshot{} 8237 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8238 return err 8239 } 8240 m.Value = &Request_OfferSnapshot{v} 8241 iNdEx = postIndex 8242 case 14: 8243 if wireType != 2 { 8244 return fmt.Errorf("proto: wrong wireType = %d for field LoadSnapshotChunk", wireType) 8245 } 8246 var msglen int 8247 for shift := uint(0); ; shift += 7 { 8248 if shift >= 64 { 8249 return ErrIntOverflowTypes 8250 } 8251 if iNdEx >= l { 8252 return io.ErrUnexpectedEOF 8253 } 8254 b := dAtA[iNdEx] 8255 iNdEx++ 8256 msglen |= int(b&0x7F) << shift 8257 if b < 0x80 { 8258 break 8259 } 8260 } 8261 if msglen < 0 { 8262 return ErrInvalidLengthTypes 8263 } 8264 postIndex := iNdEx + msglen 8265 if postIndex < 0 { 8266 return ErrInvalidLengthTypes 8267 } 8268 if postIndex > l { 8269 return io.ErrUnexpectedEOF 8270 } 8271 v := &RequestLoadSnapshotChunk{} 8272 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8273 return err 8274 } 8275 m.Value = &Request_LoadSnapshotChunk{v} 8276 iNdEx = postIndex 8277 case 15: 8278 if wireType != 2 { 8279 return fmt.Errorf("proto: wrong wireType = %d for field ApplySnapshotChunk", wireType) 8280 } 8281 var msglen int 8282 for shift := uint(0); ; shift += 7 { 8283 if shift >= 64 { 8284 return ErrIntOverflowTypes 8285 } 8286 if iNdEx >= l { 8287 return io.ErrUnexpectedEOF 8288 } 8289 b := dAtA[iNdEx] 8290 iNdEx++ 8291 msglen |= int(b&0x7F) << shift 8292 if b < 0x80 { 8293 break 8294 } 8295 } 8296 if msglen < 0 { 8297 return ErrInvalidLengthTypes 8298 } 8299 postIndex := iNdEx + msglen 8300 if postIndex < 0 { 8301 return ErrInvalidLengthTypes 8302 } 8303 if postIndex > l { 8304 return io.ErrUnexpectedEOF 8305 } 8306 v := &RequestApplySnapshotChunk{} 8307 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8308 return err 8309 } 8310 m.Value = &Request_ApplySnapshotChunk{v} 8311 iNdEx = postIndex 8312 default: 8313 iNdEx = preIndex 8314 skippy, err := skipTypes(dAtA[iNdEx:]) 8315 if err != nil { 8316 return err 8317 } 8318 if (skippy < 0) || (iNdEx+skippy) < 0 { 8319 return ErrInvalidLengthTypes 8320 } 8321 if (iNdEx + skippy) > l { 8322 return io.ErrUnexpectedEOF 8323 } 8324 iNdEx += skippy 8325 } 8326 } 8327 8328 if iNdEx > l { 8329 return io.ErrUnexpectedEOF 8330 } 8331 return nil 8332 } 8333 func (m *RequestEcho) Unmarshal(dAtA []byte) error { 8334 l := len(dAtA) 8335 iNdEx := 0 8336 for iNdEx < l { 8337 preIndex := iNdEx 8338 var wire uint64 8339 for shift := uint(0); ; shift += 7 { 8340 if shift >= 64 { 8341 return ErrIntOverflowTypes 8342 } 8343 if iNdEx >= l { 8344 return io.ErrUnexpectedEOF 8345 } 8346 b := dAtA[iNdEx] 8347 iNdEx++ 8348 wire |= uint64(b&0x7F) << shift 8349 if b < 0x80 { 8350 break 8351 } 8352 } 8353 fieldNum := int32(wire >> 3) 8354 wireType := int(wire & 0x7) 8355 if wireType == 4 { 8356 return fmt.Errorf("proto: RequestEcho: wiretype end group for non-group") 8357 } 8358 if fieldNum <= 0 { 8359 return fmt.Errorf("proto: RequestEcho: illegal tag %d (wire type %d)", fieldNum, wire) 8360 } 8361 switch fieldNum { 8362 case 1: 8363 if wireType != 2 { 8364 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 8365 } 8366 var stringLen uint64 8367 for shift := uint(0); ; shift += 7 { 8368 if shift >= 64 { 8369 return ErrIntOverflowTypes 8370 } 8371 if iNdEx >= l { 8372 return io.ErrUnexpectedEOF 8373 } 8374 b := dAtA[iNdEx] 8375 iNdEx++ 8376 stringLen |= uint64(b&0x7F) << shift 8377 if b < 0x80 { 8378 break 8379 } 8380 } 8381 intStringLen := int(stringLen) 8382 if intStringLen < 0 { 8383 return ErrInvalidLengthTypes 8384 } 8385 postIndex := iNdEx + intStringLen 8386 if postIndex < 0 { 8387 return ErrInvalidLengthTypes 8388 } 8389 if postIndex > l { 8390 return io.ErrUnexpectedEOF 8391 } 8392 m.Message = string(dAtA[iNdEx:postIndex]) 8393 iNdEx = postIndex 8394 default: 8395 iNdEx = preIndex 8396 skippy, err := skipTypes(dAtA[iNdEx:]) 8397 if err != nil { 8398 return err 8399 } 8400 if (skippy < 0) || (iNdEx+skippy) < 0 { 8401 return ErrInvalidLengthTypes 8402 } 8403 if (iNdEx + skippy) > l { 8404 return io.ErrUnexpectedEOF 8405 } 8406 iNdEx += skippy 8407 } 8408 } 8409 8410 if iNdEx > l { 8411 return io.ErrUnexpectedEOF 8412 } 8413 return nil 8414 } 8415 func (m *RequestFlush) Unmarshal(dAtA []byte) error { 8416 l := len(dAtA) 8417 iNdEx := 0 8418 for iNdEx < l { 8419 preIndex := iNdEx 8420 var wire uint64 8421 for shift := uint(0); ; shift += 7 { 8422 if shift >= 64 { 8423 return ErrIntOverflowTypes 8424 } 8425 if iNdEx >= l { 8426 return io.ErrUnexpectedEOF 8427 } 8428 b := dAtA[iNdEx] 8429 iNdEx++ 8430 wire |= uint64(b&0x7F) << shift 8431 if b < 0x80 { 8432 break 8433 } 8434 } 8435 fieldNum := int32(wire >> 3) 8436 wireType := int(wire & 0x7) 8437 if wireType == 4 { 8438 return fmt.Errorf("proto: RequestFlush: wiretype end group for non-group") 8439 } 8440 if fieldNum <= 0 { 8441 return fmt.Errorf("proto: RequestFlush: illegal tag %d (wire type %d)", fieldNum, wire) 8442 } 8443 switch fieldNum { 8444 default: 8445 iNdEx = preIndex 8446 skippy, err := skipTypes(dAtA[iNdEx:]) 8447 if err != nil { 8448 return err 8449 } 8450 if (skippy < 0) || (iNdEx+skippy) < 0 { 8451 return ErrInvalidLengthTypes 8452 } 8453 if (iNdEx + skippy) > l { 8454 return io.ErrUnexpectedEOF 8455 } 8456 iNdEx += skippy 8457 } 8458 } 8459 8460 if iNdEx > l { 8461 return io.ErrUnexpectedEOF 8462 } 8463 return nil 8464 } 8465 func (m *RequestInfo) Unmarshal(dAtA []byte) error { 8466 l := len(dAtA) 8467 iNdEx := 0 8468 for iNdEx < l { 8469 preIndex := iNdEx 8470 var wire uint64 8471 for shift := uint(0); ; shift += 7 { 8472 if shift >= 64 { 8473 return ErrIntOverflowTypes 8474 } 8475 if iNdEx >= l { 8476 return io.ErrUnexpectedEOF 8477 } 8478 b := dAtA[iNdEx] 8479 iNdEx++ 8480 wire |= uint64(b&0x7F) << shift 8481 if b < 0x80 { 8482 break 8483 } 8484 } 8485 fieldNum := int32(wire >> 3) 8486 wireType := int(wire & 0x7) 8487 if wireType == 4 { 8488 return fmt.Errorf("proto: RequestInfo: wiretype end group for non-group") 8489 } 8490 if fieldNum <= 0 { 8491 return fmt.Errorf("proto: RequestInfo: illegal tag %d (wire type %d)", fieldNum, wire) 8492 } 8493 switch fieldNum { 8494 case 1: 8495 if wireType != 2 { 8496 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 8497 } 8498 var stringLen uint64 8499 for shift := uint(0); ; shift += 7 { 8500 if shift >= 64 { 8501 return ErrIntOverflowTypes 8502 } 8503 if iNdEx >= l { 8504 return io.ErrUnexpectedEOF 8505 } 8506 b := dAtA[iNdEx] 8507 iNdEx++ 8508 stringLen |= uint64(b&0x7F) << shift 8509 if b < 0x80 { 8510 break 8511 } 8512 } 8513 intStringLen := int(stringLen) 8514 if intStringLen < 0 { 8515 return ErrInvalidLengthTypes 8516 } 8517 postIndex := iNdEx + intStringLen 8518 if postIndex < 0 { 8519 return ErrInvalidLengthTypes 8520 } 8521 if postIndex > l { 8522 return io.ErrUnexpectedEOF 8523 } 8524 m.Version = string(dAtA[iNdEx:postIndex]) 8525 iNdEx = postIndex 8526 case 2: 8527 if wireType != 0 { 8528 return fmt.Errorf("proto: wrong wireType = %d for field BlockVersion", wireType) 8529 } 8530 m.BlockVersion = 0 8531 for shift := uint(0); ; shift += 7 { 8532 if shift >= 64 { 8533 return ErrIntOverflowTypes 8534 } 8535 if iNdEx >= l { 8536 return io.ErrUnexpectedEOF 8537 } 8538 b := dAtA[iNdEx] 8539 iNdEx++ 8540 m.BlockVersion |= uint64(b&0x7F) << shift 8541 if b < 0x80 { 8542 break 8543 } 8544 } 8545 case 3: 8546 if wireType != 0 { 8547 return fmt.Errorf("proto: wrong wireType = %d for field P2PVersion", wireType) 8548 } 8549 m.P2PVersion = 0 8550 for shift := uint(0); ; shift += 7 { 8551 if shift >= 64 { 8552 return ErrIntOverflowTypes 8553 } 8554 if iNdEx >= l { 8555 return io.ErrUnexpectedEOF 8556 } 8557 b := dAtA[iNdEx] 8558 iNdEx++ 8559 m.P2PVersion |= uint64(b&0x7F) << shift 8560 if b < 0x80 { 8561 break 8562 } 8563 } 8564 default: 8565 iNdEx = preIndex 8566 skippy, err := skipTypes(dAtA[iNdEx:]) 8567 if err != nil { 8568 return err 8569 } 8570 if (skippy < 0) || (iNdEx+skippy) < 0 { 8571 return ErrInvalidLengthTypes 8572 } 8573 if (iNdEx + skippy) > l { 8574 return io.ErrUnexpectedEOF 8575 } 8576 iNdEx += skippy 8577 } 8578 } 8579 8580 if iNdEx > l { 8581 return io.ErrUnexpectedEOF 8582 } 8583 return nil 8584 } 8585 func (m *RequestSetOption) Unmarshal(dAtA []byte) error { 8586 l := len(dAtA) 8587 iNdEx := 0 8588 for iNdEx < l { 8589 preIndex := iNdEx 8590 var wire uint64 8591 for shift := uint(0); ; shift += 7 { 8592 if shift >= 64 { 8593 return ErrIntOverflowTypes 8594 } 8595 if iNdEx >= l { 8596 return io.ErrUnexpectedEOF 8597 } 8598 b := dAtA[iNdEx] 8599 iNdEx++ 8600 wire |= uint64(b&0x7F) << shift 8601 if b < 0x80 { 8602 break 8603 } 8604 } 8605 fieldNum := int32(wire >> 3) 8606 wireType := int(wire & 0x7) 8607 if wireType == 4 { 8608 return fmt.Errorf("proto: RequestSetOption: wiretype end group for non-group") 8609 } 8610 if fieldNum <= 0 { 8611 return fmt.Errorf("proto: RequestSetOption: illegal tag %d (wire type %d)", fieldNum, wire) 8612 } 8613 switch fieldNum { 8614 case 1: 8615 if wireType != 2 { 8616 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 8617 } 8618 var stringLen uint64 8619 for shift := uint(0); ; shift += 7 { 8620 if shift >= 64 { 8621 return ErrIntOverflowTypes 8622 } 8623 if iNdEx >= l { 8624 return io.ErrUnexpectedEOF 8625 } 8626 b := dAtA[iNdEx] 8627 iNdEx++ 8628 stringLen |= uint64(b&0x7F) << shift 8629 if b < 0x80 { 8630 break 8631 } 8632 } 8633 intStringLen := int(stringLen) 8634 if intStringLen < 0 { 8635 return ErrInvalidLengthTypes 8636 } 8637 postIndex := iNdEx + intStringLen 8638 if postIndex < 0 { 8639 return ErrInvalidLengthTypes 8640 } 8641 if postIndex > l { 8642 return io.ErrUnexpectedEOF 8643 } 8644 m.Key = string(dAtA[iNdEx:postIndex]) 8645 iNdEx = postIndex 8646 case 2: 8647 if wireType != 2 { 8648 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 8649 } 8650 var stringLen uint64 8651 for shift := uint(0); ; shift += 7 { 8652 if shift >= 64 { 8653 return ErrIntOverflowTypes 8654 } 8655 if iNdEx >= l { 8656 return io.ErrUnexpectedEOF 8657 } 8658 b := dAtA[iNdEx] 8659 iNdEx++ 8660 stringLen |= uint64(b&0x7F) << shift 8661 if b < 0x80 { 8662 break 8663 } 8664 } 8665 intStringLen := int(stringLen) 8666 if intStringLen < 0 { 8667 return ErrInvalidLengthTypes 8668 } 8669 postIndex := iNdEx + intStringLen 8670 if postIndex < 0 { 8671 return ErrInvalidLengthTypes 8672 } 8673 if postIndex > l { 8674 return io.ErrUnexpectedEOF 8675 } 8676 m.Value = string(dAtA[iNdEx:postIndex]) 8677 iNdEx = postIndex 8678 default: 8679 iNdEx = preIndex 8680 skippy, err := skipTypes(dAtA[iNdEx:]) 8681 if err != nil { 8682 return err 8683 } 8684 if (skippy < 0) || (iNdEx+skippy) < 0 { 8685 return ErrInvalidLengthTypes 8686 } 8687 if (iNdEx + skippy) > l { 8688 return io.ErrUnexpectedEOF 8689 } 8690 iNdEx += skippy 8691 } 8692 } 8693 8694 if iNdEx > l { 8695 return io.ErrUnexpectedEOF 8696 } 8697 return nil 8698 } 8699 func (m *RequestInitChain) Unmarshal(dAtA []byte) error { 8700 l := len(dAtA) 8701 iNdEx := 0 8702 for iNdEx < l { 8703 preIndex := iNdEx 8704 var wire uint64 8705 for shift := uint(0); ; shift += 7 { 8706 if shift >= 64 { 8707 return ErrIntOverflowTypes 8708 } 8709 if iNdEx >= l { 8710 return io.ErrUnexpectedEOF 8711 } 8712 b := dAtA[iNdEx] 8713 iNdEx++ 8714 wire |= uint64(b&0x7F) << shift 8715 if b < 0x80 { 8716 break 8717 } 8718 } 8719 fieldNum := int32(wire >> 3) 8720 wireType := int(wire & 0x7) 8721 if wireType == 4 { 8722 return fmt.Errorf("proto: RequestInitChain: wiretype end group for non-group") 8723 } 8724 if fieldNum <= 0 { 8725 return fmt.Errorf("proto: RequestInitChain: illegal tag %d (wire type %d)", fieldNum, wire) 8726 } 8727 switch fieldNum { 8728 case 1: 8729 if wireType != 2 { 8730 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) 8731 } 8732 var msglen int 8733 for shift := uint(0); ; shift += 7 { 8734 if shift >= 64 { 8735 return ErrIntOverflowTypes 8736 } 8737 if iNdEx >= l { 8738 return io.ErrUnexpectedEOF 8739 } 8740 b := dAtA[iNdEx] 8741 iNdEx++ 8742 msglen |= int(b&0x7F) << shift 8743 if b < 0x80 { 8744 break 8745 } 8746 } 8747 if msglen < 0 { 8748 return ErrInvalidLengthTypes 8749 } 8750 postIndex := iNdEx + msglen 8751 if postIndex < 0 { 8752 return ErrInvalidLengthTypes 8753 } 8754 if postIndex > l { 8755 return io.ErrUnexpectedEOF 8756 } 8757 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { 8758 return err 8759 } 8760 iNdEx = postIndex 8761 case 2: 8762 if wireType != 2 { 8763 return fmt.Errorf("proto: wrong wireType = %d for field ChainId", wireType) 8764 } 8765 var stringLen uint64 8766 for shift := uint(0); ; shift += 7 { 8767 if shift >= 64 { 8768 return ErrIntOverflowTypes 8769 } 8770 if iNdEx >= l { 8771 return io.ErrUnexpectedEOF 8772 } 8773 b := dAtA[iNdEx] 8774 iNdEx++ 8775 stringLen |= uint64(b&0x7F) << shift 8776 if b < 0x80 { 8777 break 8778 } 8779 } 8780 intStringLen := int(stringLen) 8781 if intStringLen < 0 { 8782 return ErrInvalidLengthTypes 8783 } 8784 postIndex := iNdEx + intStringLen 8785 if postIndex < 0 { 8786 return ErrInvalidLengthTypes 8787 } 8788 if postIndex > l { 8789 return io.ErrUnexpectedEOF 8790 } 8791 m.ChainId = string(dAtA[iNdEx:postIndex]) 8792 iNdEx = postIndex 8793 case 3: 8794 if wireType != 2 { 8795 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) 8796 } 8797 var msglen int 8798 for shift := uint(0); ; shift += 7 { 8799 if shift >= 64 { 8800 return ErrIntOverflowTypes 8801 } 8802 if iNdEx >= l { 8803 return io.ErrUnexpectedEOF 8804 } 8805 b := dAtA[iNdEx] 8806 iNdEx++ 8807 msglen |= int(b&0x7F) << shift 8808 if b < 0x80 { 8809 break 8810 } 8811 } 8812 if msglen < 0 { 8813 return ErrInvalidLengthTypes 8814 } 8815 postIndex := iNdEx + msglen 8816 if postIndex < 0 { 8817 return ErrInvalidLengthTypes 8818 } 8819 if postIndex > l { 8820 return io.ErrUnexpectedEOF 8821 } 8822 if m.ConsensusParams == nil { 8823 m.ConsensusParams = &ConsensusParams{} 8824 } 8825 if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8826 return err 8827 } 8828 iNdEx = postIndex 8829 case 4: 8830 if wireType != 2 { 8831 return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) 8832 } 8833 var msglen int 8834 for shift := uint(0); ; shift += 7 { 8835 if shift >= 64 { 8836 return ErrIntOverflowTypes 8837 } 8838 if iNdEx >= l { 8839 return io.ErrUnexpectedEOF 8840 } 8841 b := dAtA[iNdEx] 8842 iNdEx++ 8843 msglen |= int(b&0x7F) << shift 8844 if b < 0x80 { 8845 break 8846 } 8847 } 8848 if msglen < 0 { 8849 return ErrInvalidLengthTypes 8850 } 8851 postIndex := iNdEx + msglen 8852 if postIndex < 0 { 8853 return ErrInvalidLengthTypes 8854 } 8855 if postIndex > l { 8856 return io.ErrUnexpectedEOF 8857 } 8858 m.Validators = append(m.Validators, ValidatorUpdate{}) 8859 if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 8860 return err 8861 } 8862 iNdEx = postIndex 8863 case 5: 8864 if wireType != 2 { 8865 return fmt.Errorf("proto: wrong wireType = %d for field AppStateBytes", wireType) 8866 } 8867 var byteLen int 8868 for shift := uint(0); ; shift += 7 { 8869 if shift >= 64 { 8870 return ErrIntOverflowTypes 8871 } 8872 if iNdEx >= l { 8873 return io.ErrUnexpectedEOF 8874 } 8875 b := dAtA[iNdEx] 8876 iNdEx++ 8877 byteLen |= int(b&0x7F) << shift 8878 if b < 0x80 { 8879 break 8880 } 8881 } 8882 if byteLen < 0 { 8883 return ErrInvalidLengthTypes 8884 } 8885 postIndex := iNdEx + byteLen 8886 if postIndex < 0 { 8887 return ErrInvalidLengthTypes 8888 } 8889 if postIndex > l { 8890 return io.ErrUnexpectedEOF 8891 } 8892 m.AppStateBytes = append(m.AppStateBytes[:0], dAtA[iNdEx:postIndex]...) 8893 if m.AppStateBytes == nil { 8894 m.AppStateBytes = []byte{} 8895 } 8896 iNdEx = postIndex 8897 case 6: 8898 if wireType != 0 { 8899 return fmt.Errorf("proto: wrong wireType = %d for field InitialHeight", wireType) 8900 } 8901 m.InitialHeight = 0 8902 for shift := uint(0); ; shift += 7 { 8903 if shift >= 64 { 8904 return ErrIntOverflowTypes 8905 } 8906 if iNdEx >= l { 8907 return io.ErrUnexpectedEOF 8908 } 8909 b := dAtA[iNdEx] 8910 iNdEx++ 8911 m.InitialHeight |= int64(b&0x7F) << shift 8912 if b < 0x80 { 8913 break 8914 } 8915 } 8916 default: 8917 iNdEx = preIndex 8918 skippy, err := skipTypes(dAtA[iNdEx:]) 8919 if err != nil { 8920 return err 8921 } 8922 if (skippy < 0) || (iNdEx+skippy) < 0 { 8923 return ErrInvalidLengthTypes 8924 } 8925 if (iNdEx + skippy) > l { 8926 return io.ErrUnexpectedEOF 8927 } 8928 iNdEx += skippy 8929 } 8930 } 8931 8932 if iNdEx > l { 8933 return io.ErrUnexpectedEOF 8934 } 8935 return nil 8936 } 8937 func (m *RequestQuery) Unmarshal(dAtA []byte) error { 8938 l := len(dAtA) 8939 iNdEx := 0 8940 for iNdEx < l { 8941 preIndex := iNdEx 8942 var wire uint64 8943 for shift := uint(0); ; shift += 7 { 8944 if shift >= 64 { 8945 return ErrIntOverflowTypes 8946 } 8947 if iNdEx >= l { 8948 return io.ErrUnexpectedEOF 8949 } 8950 b := dAtA[iNdEx] 8951 iNdEx++ 8952 wire |= uint64(b&0x7F) << shift 8953 if b < 0x80 { 8954 break 8955 } 8956 } 8957 fieldNum := int32(wire >> 3) 8958 wireType := int(wire & 0x7) 8959 if wireType == 4 { 8960 return fmt.Errorf("proto: RequestQuery: wiretype end group for non-group") 8961 } 8962 if fieldNum <= 0 { 8963 return fmt.Errorf("proto: RequestQuery: illegal tag %d (wire type %d)", fieldNum, wire) 8964 } 8965 switch fieldNum { 8966 case 1: 8967 if wireType != 2 { 8968 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 8969 } 8970 var byteLen int 8971 for shift := uint(0); ; shift += 7 { 8972 if shift >= 64 { 8973 return ErrIntOverflowTypes 8974 } 8975 if iNdEx >= l { 8976 return io.ErrUnexpectedEOF 8977 } 8978 b := dAtA[iNdEx] 8979 iNdEx++ 8980 byteLen |= int(b&0x7F) << shift 8981 if b < 0x80 { 8982 break 8983 } 8984 } 8985 if byteLen < 0 { 8986 return ErrInvalidLengthTypes 8987 } 8988 postIndex := iNdEx + byteLen 8989 if postIndex < 0 { 8990 return ErrInvalidLengthTypes 8991 } 8992 if postIndex > l { 8993 return io.ErrUnexpectedEOF 8994 } 8995 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 8996 if m.Data == nil { 8997 m.Data = []byte{} 8998 } 8999 iNdEx = postIndex 9000 case 2: 9001 if wireType != 2 { 9002 return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType) 9003 } 9004 var stringLen uint64 9005 for shift := uint(0); ; shift += 7 { 9006 if shift >= 64 { 9007 return ErrIntOverflowTypes 9008 } 9009 if iNdEx >= l { 9010 return io.ErrUnexpectedEOF 9011 } 9012 b := dAtA[iNdEx] 9013 iNdEx++ 9014 stringLen |= uint64(b&0x7F) << shift 9015 if b < 0x80 { 9016 break 9017 } 9018 } 9019 intStringLen := int(stringLen) 9020 if intStringLen < 0 { 9021 return ErrInvalidLengthTypes 9022 } 9023 postIndex := iNdEx + intStringLen 9024 if postIndex < 0 { 9025 return ErrInvalidLengthTypes 9026 } 9027 if postIndex > l { 9028 return io.ErrUnexpectedEOF 9029 } 9030 m.Path = string(dAtA[iNdEx:postIndex]) 9031 iNdEx = postIndex 9032 case 3: 9033 if wireType != 0 { 9034 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 9035 } 9036 m.Height = 0 9037 for shift := uint(0); ; shift += 7 { 9038 if shift >= 64 { 9039 return ErrIntOverflowTypes 9040 } 9041 if iNdEx >= l { 9042 return io.ErrUnexpectedEOF 9043 } 9044 b := dAtA[iNdEx] 9045 iNdEx++ 9046 m.Height |= int64(b&0x7F) << shift 9047 if b < 0x80 { 9048 break 9049 } 9050 } 9051 case 4: 9052 if wireType != 0 { 9053 return fmt.Errorf("proto: wrong wireType = %d for field Prove", wireType) 9054 } 9055 var v int 9056 for shift := uint(0); ; shift += 7 { 9057 if shift >= 64 { 9058 return ErrIntOverflowTypes 9059 } 9060 if iNdEx >= l { 9061 return io.ErrUnexpectedEOF 9062 } 9063 b := dAtA[iNdEx] 9064 iNdEx++ 9065 v |= int(b&0x7F) << shift 9066 if b < 0x80 { 9067 break 9068 } 9069 } 9070 m.Prove = bool(v != 0) 9071 default: 9072 iNdEx = preIndex 9073 skippy, err := skipTypes(dAtA[iNdEx:]) 9074 if err != nil { 9075 return err 9076 } 9077 if (skippy < 0) || (iNdEx+skippy) < 0 { 9078 return ErrInvalidLengthTypes 9079 } 9080 if (iNdEx + skippy) > l { 9081 return io.ErrUnexpectedEOF 9082 } 9083 iNdEx += skippy 9084 } 9085 } 9086 9087 if iNdEx > l { 9088 return io.ErrUnexpectedEOF 9089 } 9090 return nil 9091 } 9092 func (m *RequestBeginBlock) Unmarshal(dAtA []byte) error { 9093 l := len(dAtA) 9094 iNdEx := 0 9095 for iNdEx < l { 9096 preIndex := iNdEx 9097 var wire uint64 9098 for shift := uint(0); ; shift += 7 { 9099 if shift >= 64 { 9100 return ErrIntOverflowTypes 9101 } 9102 if iNdEx >= l { 9103 return io.ErrUnexpectedEOF 9104 } 9105 b := dAtA[iNdEx] 9106 iNdEx++ 9107 wire |= uint64(b&0x7F) << shift 9108 if b < 0x80 { 9109 break 9110 } 9111 } 9112 fieldNum := int32(wire >> 3) 9113 wireType := int(wire & 0x7) 9114 if wireType == 4 { 9115 return fmt.Errorf("proto: RequestBeginBlock: wiretype end group for non-group") 9116 } 9117 if fieldNum <= 0 { 9118 return fmt.Errorf("proto: RequestBeginBlock: illegal tag %d (wire type %d)", fieldNum, wire) 9119 } 9120 switch fieldNum { 9121 case 1: 9122 if wireType != 2 { 9123 return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) 9124 } 9125 var byteLen int 9126 for shift := uint(0); ; shift += 7 { 9127 if shift >= 64 { 9128 return ErrIntOverflowTypes 9129 } 9130 if iNdEx >= l { 9131 return io.ErrUnexpectedEOF 9132 } 9133 b := dAtA[iNdEx] 9134 iNdEx++ 9135 byteLen |= int(b&0x7F) << shift 9136 if b < 0x80 { 9137 break 9138 } 9139 } 9140 if byteLen < 0 { 9141 return ErrInvalidLengthTypes 9142 } 9143 postIndex := iNdEx + byteLen 9144 if postIndex < 0 { 9145 return ErrInvalidLengthTypes 9146 } 9147 if postIndex > l { 9148 return io.ErrUnexpectedEOF 9149 } 9150 m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) 9151 if m.Hash == nil { 9152 m.Hash = []byte{} 9153 } 9154 iNdEx = postIndex 9155 case 2: 9156 if wireType != 2 { 9157 return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType) 9158 } 9159 var msglen int 9160 for shift := uint(0); ; shift += 7 { 9161 if shift >= 64 { 9162 return ErrIntOverflowTypes 9163 } 9164 if iNdEx >= l { 9165 return io.ErrUnexpectedEOF 9166 } 9167 b := dAtA[iNdEx] 9168 iNdEx++ 9169 msglen |= int(b&0x7F) << shift 9170 if b < 0x80 { 9171 break 9172 } 9173 } 9174 if msglen < 0 { 9175 return ErrInvalidLengthTypes 9176 } 9177 postIndex := iNdEx + msglen 9178 if postIndex < 0 { 9179 return ErrInvalidLengthTypes 9180 } 9181 if postIndex > l { 9182 return io.ErrUnexpectedEOF 9183 } 9184 if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9185 return err 9186 } 9187 iNdEx = postIndex 9188 case 3: 9189 if wireType != 2 { 9190 return fmt.Errorf("proto: wrong wireType = %d for field LastCommitInfo", wireType) 9191 } 9192 var msglen int 9193 for shift := uint(0); ; shift += 7 { 9194 if shift >= 64 { 9195 return ErrIntOverflowTypes 9196 } 9197 if iNdEx >= l { 9198 return io.ErrUnexpectedEOF 9199 } 9200 b := dAtA[iNdEx] 9201 iNdEx++ 9202 msglen |= int(b&0x7F) << shift 9203 if b < 0x80 { 9204 break 9205 } 9206 } 9207 if msglen < 0 { 9208 return ErrInvalidLengthTypes 9209 } 9210 postIndex := iNdEx + msglen 9211 if postIndex < 0 { 9212 return ErrInvalidLengthTypes 9213 } 9214 if postIndex > l { 9215 return io.ErrUnexpectedEOF 9216 } 9217 if err := m.LastCommitInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9218 return err 9219 } 9220 iNdEx = postIndex 9221 case 4: 9222 if wireType != 2 { 9223 return fmt.Errorf("proto: wrong wireType = %d for field ByzantineValidators", wireType) 9224 } 9225 var msglen int 9226 for shift := uint(0); ; shift += 7 { 9227 if shift >= 64 { 9228 return ErrIntOverflowTypes 9229 } 9230 if iNdEx >= l { 9231 return io.ErrUnexpectedEOF 9232 } 9233 b := dAtA[iNdEx] 9234 iNdEx++ 9235 msglen |= int(b&0x7F) << shift 9236 if b < 0x80 { 9237 break 9238 } 9239 } 9240 if msglen < 0 { 9241 return ErrInvalidLengthTypes 9242 } 9243 postIndex := iNdEx + msglen 9244 if postIndex < 0 { 9245 return ErrInvalidLengthTypes 9246 } 9247 if postIndex > l { 9248 return io.ErrUnexpectedEOF 9249 } 9250 m.ByzantineValidators = append(m.ByzantineValidators, Evidence{}) 9251 if err := m.ByzantineValidators[len(m.ByzantineValidators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9252 return err 9253 } 9254 iNdEx = postIndex 9255 default: 9256 iNdEx = preIndex 9257 skippy, err := skipTypes(dAtA[iNdEx:]) 9258 if err != nil { 9259 return err 9260 } 9261 if (skippy < 0) || (iNdEx+skippy) < 0 { 9262 return ErrInvalidLengthTypes 9263 } 9264 if (iNdEx + skippy) > l { 9265 return io.ErrUnexpectedEOF 9266 } 9267 iNdEx += skippy 9268 } 9269 } 9270 9271 if iNdEx > l { 9272 return io.ErrUnexpectedEOF 9273 } 9274 return nil 9275 } 9276 func (m *RequestCheckTx) Unmarshal(dAtA []byte) error { 9277 l := len(dAtA) 9278 iNdEx := 0 9279 for iNdEx < l { 9280 preIndex := iNdEx 9281 var wire uint64 9282 for shift := uint(0); ; shift += 7 { 9283 if shift >= 64 { 9284 return ErrIntOverflowTypes 9285 } 9286 if iNdEx >= l { 9287 return io.ErrUnexpectedEOF 9288 } 9289 b := dAtA[iNdEx] 9290 iNdEx++ 9291 wire |= uint64(b&0x7F) << shift 9292 if b < 0x80 { 9293 break 9294 } 9295 } 9296 fieldNum := int32(wire >> 3) 9297 wireType := int(wire & 0x7) 9298 if wireType == 4 { 9299 return fmt.Errorf("proto: RequestCheckTx: wiretype end group for non-group") 9300 } 9301 if fieldNum <= 0 { 9302 return fmt.Errorf("proto: RequestCheckTx: illegal tag %d (wire type %d)", fieldNum, wire) 9303 } 9304 switch fieldNum { 9305 case 1: 9306 if wireType != 2 { 9307 return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) 9308 } 9309 var byteLen int 9310 for shift := uint(0); ; shift += 7 { 9311 if shift >= 64 { 9312 return ErrIntOverflowTypes 9313 } 9314 if iNdEx >= l { 9315 return io.ErrUnexpectedEOF 9316 } 9317 b := dAtA[iNdEx] 9318 iNdEx++ 9319 byteLen |= int(b&0x7F) << shift 9320 if b < 0x80 { 9321 break 9322 } 9323 } 9324 if byteLen < 0 { 9325 return ErrInvalidLengthTypes 9326 } 9327 postIndex := iNdEx + byteLen 9328 if postIndex < 0 { 9329 return ErrInvalidLengthTypes 9330 } 9331 if postIndex > l { 9332 return io.ErrUnexpectedEOF 9333 } 9334 m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) 9335 if m.Tx == nil { 9336 m.Tx = []byte{} 9337 } 9338 iNdEx = postIndex 9339 case 2: 9340 if wireType != 0 { 9341 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 9342 } 9343 m.Type = 0 9344 for shift := uint(0); ; shift += 7 { 9345 if shift >= 64 { 9346 return ErrIntOverflowTypes 9347 } 9348 if iNdEx >= l { 9349 return io.ErrUnexpectedEOF 9350 } 9351 b := dAtA[iNdEx] 9352 iNdEx++ 9353 m.Type |= CheckTxType(b&0x7F) << shift 9354 if b < 0x80 { 9355 break 9356 } 9357 } 9358 default: 9359 iNdEx = preIndex 9360 skippy, err := skipTypes(dAtA[iNdEx:]) 9361 if err != nil { 9362 return err 9363 } 9364 if (skippy < 0) || (iNdEx+skippy) < 0 { 9365 return ErrInvalidLengthTypes 9366 } 9367 if (iNdEx + skippy) > l { 9368 return io.ErrUnexpectedEOF 9369 } 9370 iNdEx += skippy 9371 } 9372 } 9373 9374 if iNdEx > l { 9375 return io.ErrUnexpectedEOF 9376 } 9377 return nil 9378 } 9379 func (m *RequestDeliverTx) Unmarshal(dAtA []byte) error { 9380 l := len(dAtA) 9381 iNdEx := 0 9382 for iNdEx < l { 9383 preIndex := iNdEx 9384 var wire uint64 9385 for shift := uint(0); ; shift += 7 { 9386 if shift >= 64 { 9387 return ErrIntOverflowTypes 9388 } 9389 if iNdEx >= l { 9390 return io.ErrUnexpectedEOF 9391 } 9392 b := dAtA[iNdEx] 9393 iNdEx++ 9394 wire |= uint64(b&0x7F) << shift 9395 if b < 0x80 { 9396 break 9397 } 9398 } 9399 fieldNum := int32(wire >> 3) 9400 wireType := int(wire & 0x7) 9401 if wireType == 4 { 9402 return fmt.Errorf("proto: RequestDeliverTx: wiretype end group for non-group") 9403 } 9404 if fieldNum <= 0 { 9405 return fmt.Errorf("proto: RequestDeliverTx: illegal tag %d (wire type %d)", fieldNum, wire) 9406 } 9407 switch fieldNum { 9408 case 1: 9409 if wireType != 2 { 9410 return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) 9411 } 9412 var byteLen int 9413 for shift := uint(0); ; shift += 7 { 9414 if shift >= 64 { 9415 return ErrIntOverflowTypes 9416 } 9417 if iNdEx >= l { 9418 return io.ErrUnexpectedEOF 9419 } 9420 b := dAtA[iNdEx] 9421 iNdEx++ 9422 byteLen |= int(b&0x7F) << shift 9423 if b < 0x80 { 9424 break 9425 } 9426 } 9427 if byteLen < 0 { 9428 return ErrInvalidLengthTypes 9429 } 9430 postIndex := iNdEx + byteLen 9431 if postIndex < 0 { 9432 return ErrInvalidLengthTypes 9433 } 9434 if postIndex > l { 9435 return io.ErrUnexpectedEOF 9436 } 9437 m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) 9438 if m.Tx == nil { 9439 m.Tx = []byte{} 9440 } 9441 iNdEx = postIndex 9442 default: 9443 iNdEx = preIndex 9444 skippy, err := skipTypes(dAtA[iNdEx:]) 9445 if err != nil { 9446 return err 9447 } 9448 if (skippy < 0) || (iNdEx+skippy) < 0 { 9449 return ErrInvalidLengthTypes 9450 } 9451 if (iNdEx + skippy) > l { 9452 return io.ErrUnexpectedEOF 9453 } 9454 iNdEx += skippy 9455 } 9456 } 9457 9458 if iNdEx > l { 9459 return io.ErrUnexpectedEOF 9460 } 9461 return nil 9462 } 9463 func (m *RequestEndBlock) Unmarshal(dAtA []byte) error { 9464 l := len(dAtA) 9465 iNdEx := 0 9466 for iNdEx < l { 9467 preIndex := iNdEx 9468 var wire uint64 9469 for shift := uint(0); ; shift += 7 { 9470 if shift >= 64 { 9471 return ErrIntOverflowTypes 9472 } 9473 if iNdEx >= l { 9474 return io.ErrUnexpectedEOF 9475 } 9476 b := dAtA[iNdEx] 9477 iNdEx++ 9478 wire |= uint64(b&0x7F) << shift 9479 if b < 0x80 { 9480 break 9481 } 9482 } 9483 fieldNum := int32(wire >> 3) 9484 wireType := int(wire & 0x7) 9485 if wireType == 4 { 9486 return fmt.Errorf("proto: RequestEndBlock: wiretype end group for non-group") 9487 } 9488 if fieldNum <= 0 { 9489 return fmt.Errorf("proto: RequestEndBlock: illegal tag %d (wire type %d)", fieldNum, wire) 9490 } 9491 switch fieldNum { 9492 case 1: 9493 if wireType != 0 { 9494 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 9495 } 9496 m.Height = 0 9497 for shift := uint(0); ; shift += 7 { 9498 if shift >= 64 { 9499 return ErrIntOverflowTypes 9500 } 9501 if iNdEx >= l { 9502 return io.ErrUnexpectedEOF 9503 } 9504 b := dAtA[iNdEx] 9505 iNdEx++ 9506 m.Height |= int64(b&0x7F) << shift 9507 if b < 0x80 { 9508 break 9509 } 9510 } 9511 default: 9512 iNdEx = preIndex 9513 skippy, err := skipTypes(dAtA[iNdEx:]) 9514 if err != nil { 9515 return err 9516 } 9517 if (skippy < 0) || (iNdEx+skippy) < 0 { 9518 return ErrInvalidLengthTypes 9519 } 9520 if (iNdEx + skippy) > l { 9521 return io.ErrUnexpectedEOF 9522 } 9523 iNdEx += skippy 9524 } 9525 } 9526 9527 if iNdEx > l { 9528 return io.ErrUnexpectedEOF 9529 } 9530 return nil 9531 } 9532 func (m *RequestCommit) Unmarshal(dAtA []byte) error { 9533 l := len(dAtA) 9534 iNdEx := 0 9535 for iNdEx < l { 9536 preIndex := iNdEx 9537 var wire uint64 9538 for shift := uint(0); ; shift += 7 { 9539 if shift >= 64 { 9540 return ErrIntOverflowTypes 9541 } 9542 if iNdEx >= l { 9543 return io.ErrUnexpectedEOF 9544 } 9545 b := dAtA[iNdEx] 9546 iNdEx++ 9547 wire |= uint64(b&0x7F) << shift 9548 if b < 0x80 { 9549 break 9550 } 9551 } 9552 fieldNum := int32(wire >> 3) 9553 wireType := int(wire & 0x7) 9554 if wireType == 4 { 9555 return fmt.Errorf("proto: RequestCommit: wiretype end group for non-group") 9556 } 9557 if fieldNum <= 0 { 9558 return fmt.Errorf("proto: RequestCommit: illegal tag %d (wire type %d)", fieldNum, wire) 9559 } 9560 switch fieldNum { 9561 default: 9562 iNdEx = preIndex 9563 skippy, err := skipTypes(dAtA[iNdEx:]) 9564 if err != nil { 9565 return err 9566 } 9567 if (skippy < 0) || (iNdEx+skippy) < 0 { 9568 return ErrInvalidLengthTypes 9569 } 9570 if (iNdEx + skippy) > l { 9571 return io.ErrUnexpectedEOF 9572 } 9573 iNdEx += skippy 9574 } 9575 } 9576 9577 if iNdEx > l { 9578 return io.ErrUnexpectedEOF 9579 } 9580 return nil 9581 } 9582 func (m *RequestListSnapshots) Unmarshal(dAtA []byte) error { 9583 l := len(dAtA) 9584 iNdEx := 0 9585 for iNdEx < l { 9586 preIndex := iNdEx 9587 var wire uint64 9588 for shift := uint(0); ; shift += 7 { 9589 if shift >= 64 { 9590 return ErrIntOverflowTypes 9591 } 9592 if iNdEx >= l { 9593 return io.ErrUnexpectedEOF 9594 } 9595 b := dAtA[iNdEx] 9596 iNdEx++ 9597 wire |= uint64(b&0x7F) << shift 9598 if b < 0x80 { 9599 break 9600 } 9601 } 9602 fieldNum := int32(wire >> 3) 9603 wireType := int(wire & 0x7) 9604 if wireType == 4 { 9605 return fmt.Errorf("proto: RequestListSnapshots: wiretype end group for non-group") 9606 } 9607 if fieldNum <= 0 { 9608 return fmt.Errorf("proto: RequestListSnapshots: illegal tag %d (wire type %d)", fieldNum, wire) 9609 } 9610 switch fieldNum { 9611 default: 9612 iNdEx = preIndex 9613 skippy, err := skipTypes(dAtA[iNdEx:]) 9614 if err != nil { 9615 return err 9616 } 9617 if (skippy < 0) || (iNdEx+skippy) < 0 { 9618 return ErrInvalidLengthTypes 9619 } 9620 if (iNdEx + skippy) > l { 9621 return io.ErrUnexpectedEOF 9622 } 9623 iNdEx += skippy 9624 } 9625 } 9626 9627 if iNdEx > l { 9628 return io.ErrUnexpectedEOF 9629 } 9630 return nil 9631 } 9632 func (m *RequestOfferSnapshot) Unmarshal(dAtA []byte) error { 9633 l := len(dAtA) 9634 iNdEx := 0 9635 for iNdEx < l { 9636 preIndex := iNdEx 9637 var wire uint64 9638 for shift := uint(0); ; shift += 7 { 9639 if shift >= 64 { 9640 return ErrIntOverflowTypes 9641 } 9642 if iNdEx >= l { 9643 return io.ErrUnexpectedEOF 9644 } 9645 b := dAtA[iNdEx] 9646 iNdEx++ 9647 wire |= uint64(b&0x7F) << shift 9648 if b < 0x80 { 9649 break 9650 } 9651 } 9652 fieldNum := int32(wire >> 3) 9653 wireType := int(wire & 0x7) 9654 if wireType == 4 { 9655 return fmt.Errorf("proto: RequestOfferSnapshot: wiretype end group for non-group") 9656 } 9657 if fieldNum <= 0 { 9658 return fmt.Errorf("proto: RequestOfferSnapshot: illegal tag %d (wire type %d)", fieldNum, wire) 9659 } 9660 switch fieldNum { 9661 case 1: 9662 if wireType != 2 { 9663 return fmt.Errorf("proto: wrong wireType = %d for field Snapshot", wireType) 9664 } 9665 var msglen int 9666 for shift := uint(0); ; shift += 7 { 9667 if shift >= 64 { 9668 return ErrIntOverflowTypes 9669 } 9670 if iNdEx >= l { 9671 return io.ErrUnexpectedEOF 9672 } 9673 b := dAtA[iNdEx] 9674 iNdEx++ 9675 msglen |= int(b&0x7F) << shift 9676 if b < 0x80 { 9677 break 9678 } 9679 } 9680 if msglen < 0 { 9681 return ErrInvalidLengthTypes 9682 } 9683 postIndex := iNdEx + msglen 9684 if postIndex < 0 { 9685 return ErrInvalidLengthTypes 9686 } 9687 if postIndex > l { 9688 return io.ErrUnexpectedEOF 9689 } 9690 if m.Snapshot == nil { 9691 m.Snapshot = &Snapshot{} 9692 } 9693 if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 9694 return err 9695 } 9696 iNdEx = postIndex 9697 case 2: 9698 if wireType != 2 { 9699 return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType) 9700 } 9701 var byteLen int 9702 for shift := uint(0); ; shift += 7 { 9703 if shift >= 64 { 9704 return ErrIntOverflowTypes 9705 } 9706 if iNdEx >= l { 9707 return io.ErrUnexpectedEOF 9708 } 9709 b := dAtA[iNdEx] 9710 iNdEx++ 9711 byteLen |= int(b&0x7F) << shift 9712 if b < 0x80 { 9713 break 9714 } 9715 } 9716 if byteLen < 0 { 9717 return ErrInvalidLengthTypes 9718 } 9719 postIndex := iNdEx + byteLen 9720 if postIndex < 0 { 9721 return ErrInvalidLengthTypes 9722 } 9723 if postIndex > l { 9724 return io.ErrUnexpectedEOF 9725 } 9726 m.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) 9727 if m.AppHash == nil { 9728 m.AppHash = []byte{} 9729 } 9730 iNdEx = postIndex 9731 default: 9732 iNdEx = preIndex 9733 skippy, err := skipTypes(dAtA[iNdEx:]) 9734 if err != nil { 9735 return err 9736 } 9737 if (skippy < 0) || (iNdEx+skippy) < 0 { 9738 return ErrInvalidLengthTypes 9739 } 9740 if (iNdEx + skippy) > l { 9741 return io.ErrUnexpectedEOF 9742 } 9743 iNdEx += skippy 9744 } 9745 } 9746 9747 if iNdEx > l { 9748 return io.ErrUnexpectedEOF 9749 } 9750 return nil 9751 } 9752 func (m *RequestLoadSnapshotChunk) Unmarshal(dAtA []byte) error { 9753 l := len(dAtA) 9754 iNdEx := 0 9755 for iNdEx < l { 9756 preIndex := iNdEx 9757 var wire uint64 9758 for shift := uint(0); ; shift += 7 { 9759 if shift >= 64 { 9760 return ErrIntOverflowTypes 9761 } 9762 if iNdEx >= l { 9763 return io.ErrUnexpectedEOF 9764 } 9765 b := dAtA[iNdEx] 9766 iNdEx++ 9767 wire |= uint64(b&0x7F) << shift 9768 if b < 0x80 { 9769 break 9770 } 9771 } 9772 fieldNum := int32(wire >> 3) 9773 wireType := int(wire & 0x7) 9774 if wireType == 4 { 9775 return fmt.Errorf("proto: RequestLoadSnapshotChunk: wiretype end group for non-group") 9776 } 9777 if fieldNum <= 0 { 9778 return fmt.Errorf("proto: RequestLoadSnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) 9779 } 9780 switch fieldNum { 9781 case 1: 9782 if wireType != 0 { 9783 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 9784 } 9785 m.Height = 0 9786 for shift := uint(0); ; shift += 7 { 9787 if shift >= 64 { 9788 return ErrIntOverflowTypes 9789 } 9790 if iNdEx >= l { 9791 return io.ErrUnexpectedEOF 9792 } 9793 b := dAtA[iNdEx] 9794 iNdEx++ 9795 m.Height |= uint64(b&0x7F) << shift 9796 if b < 0x80 { 9797 break 9798 } 9799 } 9800 case 2: 9801 if wireType != 0 { 9802 return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType) 9803 } 9804 m.Format = 0 9805 for shift := uint(0); ; shift += 7 { 9806 if shift >= 64 { 9807 return ErrIntOverflowTypes 9808 } 9809 if iNdEx >= l { 9810 return io.ErrUnexpectedEOF 9811 } 9812 b := dAtA[iNdEx] 9813 iNdEx++ 9814 m.Format |= uint32(b&0x7F) << shift 9815 if b < 0x80 { 9816 break 9817 } 9818 } 9819 case 3: 9820 if wireType != 0 { 9821 return fmt.Errorf("proto: wrong wireType = %d for field Chunk", wireType) 9822 } 9823 m.Chunk = 0 9824 for shift := uint(0); ; shift += 7 { 9825 if shift >= 64 { 9826 return ErrIntOverflowTypes 9827 } 9828 if iNdEx >= l { 9829 return io.ErrUnexpectedEOF 9830 } 9831 b := dAtA[iNdEx] 9832 iNdEx++ 9833 m.Chunk |= uint32(b&0x7F) << shift 9834 if b < 0x80 { 9835 break 9836 } 9837 } 9838 default: 9839 iNdEx = preIndex 9840 skippy, err := skipTypes(dAtA[iNdEx:]) 9841 if err != nil { 9842 return err 9843 } 9844 if (skippy < 0) || (iNdEx+skippy) < 0 { 9845 return ErrInvalidLengthTypes 9846 } 9847 if (iNdEx + skippy) > l { 9848 return io.ErrUnexpectedEOF 9849 } 9850 iNdEx += skippy 9851 } 9852 } 9853 9854 if iNdEx > l { 9855 return io.ErrUnexpectedEOF 9856 } 9857 return nil 9858 } 9859 func (m *RequestApplySnapshotChunk) Unmarshal(dAtA []byte) error { 9860 l := len(dAtA) 9861 iNdEx := 0 9862 for iNdEx < l { 9863 preIndex := iNdEx 9864 var wire uint64 9865 for shift := uint(0); ; shift += 7 { 9866 if shift >= 64 { 9867 return ErrIntOverflowTypes 9868 } 9869 if iNdEx >= l { 9870 return io.ErrUnexpectedEOF 9871 } 9872 b := dAtA[iNdEx] 9873 iNdEx++ 9874 wire |= uint64(b&0x7F) << shift 9875 if b < 0x80 { 9876 break 9877 } 9878 } 9879 fieldNum := int32(wire >> 3) 9880 wireType := int(wire & 0x7) 9881 if wireType == 4 { 9882 return fmt.Errorf("proto: RequestApplySnapshotChunk: wiretype end group for non-group") 9883 } 9884 if fieldNum <= 0 { 9885 return fmt.Errorf("proto: RequestApplySnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) 9886 } 9887 switch fieldNum { 9888 case 1: 9889 if wireType != 0 { 9890 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 9891 } 9892 m.Index = 0 9893 for shift := uint(0); ; shift += 7 { 9894 if shift >= 64 { 9895 return ErrIntOverflowTypes 9896 } 9897 if iNdEx >= l { 9898 return io.ErrUnexpectedEOF 9899 } 9900 b := dAtA[iNdEx] 9901 iNdEx++ 9902 m.Index |= uint32(b&0x7F) << shift 9903 if b < 0x80 { 9904 break 9905 } 9906 } 9907 case 2: 9908 if wireType != 2 { 9909 return fmt.Errorf("proto: wrong wireType = %d for field Chunk", wireType) 9910 } 9911 var byteLen int 9912 for shift := uint(0); ; shift += 7 { 9913 if shift >= 64 { 9914 return ErrIntOverflowTypes 9915 } 9916 if iNdEx >= l { 9917 return io.ErrUnexpectedEOF 9918 } 9919 b := dAtA[iNdEx] 9920 iNdEx++ 9921 byteLen |= int(b&0x7F) << shift 9922 if b < 0x80 { 9923 break 9924 } 9925 } 9926 if byteLen < 0 { 9927 return ErrInvalidLengthTypes 9928 } 9929 postIndex := iNdEx + byteLen 9930 if postIndex < 0 { 9931 return ErrInvalidLengthTypes 9932 } 9933 if postIndex > l { 9934 return io.ErrUnexpectedEOF 9935 } 9936 m.Chunk = append(m.Chunk[:0], dAtA[iNdEx:postIndex]...) 9937 if m.Chunk == nil { 9938 m.Chunk = []byte{} 9939 } 9940 iNdEx = postIndex 9941 case 3: 9942 if wireType != 2 { 9943 return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType) 9944 } 9945 var stringLen uint64 9946 for shift := uint(0); ; shift += 7 { 9947 if shift >= 64 { 9948 return ErrIntOverflowTypes 9949 } 9950 if iNdEx >= l { 9951 return io.ErrUnexpectedEOF 9952 } 9953 b := dAtA[iNdEx] 9954 iNdEx++ 9955 stringLen |= uint64(b&0x7F) << shift 9956 if b < 0x80 { 9957 break 9958 } 9959 } 9960 intStringLen := int(stringLen) 9961 if intStringLen < 0 { 9962 return ErrInvalidLengthTypes 9963 } 9964 postIndex := iNdEx + intStringLen 9965 if postIndex < 0 { 9966 return ErrInvalidLengthTypes 9967 } 9968 if postIndex > l { 9969 return io.ErrUnexpectedEOF 9970 } 9971 m.Sender = string(dAtA[iNdEx:postIndex]) 9972 iNdEx = postIndex 9973 default: 9974 iNdEx = preIndex 9975 skippy, err := skipTypes(dAtA[iNdEx:]) 9976 if err != nil { 9977 return err 9978 } 9979 if (skippy < 0) || (iNdEx+skippy) < 0 { 9980 return ErrInvalidLengthTypes 9981 } 9982 if (iNdEx + skippy) > l { 9983 return io.ErrUnexpectedEOF 9984 } 9985 iNdEx += skippy 9986 } 9987 } 9988 9989 if iNdEx > l { 9990 return io.ErrUnexpectedEOF 9991 } 9992 return nil 9993 } 9994 func (m *Response) Unmarshal(dAtA []byte) error { 9995 l := len(dAtA) 9996 iNdEx := 0 9997 for iNdEx < l { 9998 preIndex := iNdEx 9999 var wire uint64 10000 for shift := uint(0); ; shift += 7 { 10001 if shift >= 64 { 10002 return ErrIntOverflowTypes 10003 } 10004 if iNdEx >= l { 10005 return io.ErrUnexpectedEOF 10006 } 10007 b := dAtA[iNdEx] 10008 iNdEx++ 10009 wire |= uint64(b&0x7F) << shift 10010 if b < 0x80 { 10011 break 10012 } 10013 } 10014 fieldNum := int32(wire >> 3) 10015 wireType := int(wire & 0x7) 10016 if wireType == 4 { 10017 return fmt.Errorf("proto: Response: wiretype end group for non-group") 10018 } 10019 if fieldNum <= 0 { 10020 return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire) 10021 } 10022 switch fieldNum { 10023 case 1: 10024 if wireType != 2 { 10025 return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType) 10026 } 10027 var msglen int 10028 for shift := uint(0); ; shift += 7 { 10029 if shift >= 64 { 10030 return ErrIntOverflowTypes 10031 } 10032 if iNdEx >= l { 10033 return io.ErrUnexpectedEOF 10034 } 10035 b := dAtA[iNdEx] 10036 iNdEx++ 10037 msglen |= int(b&0x7F) << shift 10038 if b < 0x80 { 10039 break 10040 } 10041 } 10042 if msglen < 0 { 10043 return ErrInvalidLengthTypes 10044 } 10045 postIndex := iNdEx + msglen 10046 if postIndex < 0 { 10047 return ErrInvalidLengthTypes 10048 } 10049 if postIndex > l { 10050 return io.ErrUnexpectedEOF 10051 } 10052 v := &ResponseException{} 10053 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10054 return err 10055 } 10056 m.Value = &Response_Exception{v} 10057 iNdEx = postIndex 10058 case 2: 10059 if wireType != 2 { 10060 return fmt.Errorf("proto: wrong wireType = %d for field Echo", wireType) 10061 } 10062 var msglen int 10063 for shift := uint(0); ; shift += 7 { 10064 if shift >= 64 { 10065 return ErrIntOverflowTypes 10066 } 10067 if iNdEx >= l { 10068 return io.ErrUnexpectedEOF 10069 } 10070 b := dAtA[iNdEx] 10071 iNdEx++ 10072 msglen |= int(b&0x7F) << shift 10073 if b < 0x80 { 10074 break 10075 } 10076 } 10077 if msglen < 0 { 10078 return ErrInvalidLengthTypes 10079 } 10080 postIndex := iNdEx + msglen 10081 if postIndex < 0 { 10082 return ErrInvalidLengthTypes 10083 } 10084 if postIndex > l { 10085 return io.ErrUnexpectedEOF 10086 } 10087 v := &ResponseEcho{} 10088 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10089 return err 10090 } 10091 m.Value = &Response_Echo{v} 10092 iNdEx = postIndex 10093 case 3: 10094 if wireType != 2 { 10095 return fmt.Errorf("proto: wrong wireType = %d for field Flush", 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 := &ResponseFlush{} 10123 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10124 return err 10125 } 10126 m.Value = &Response_Flush{v} 10127 iNdEx = postIndex 10128 case 4: 10129 if wireType != 2 { 10130 return fmt.Errorf("proto: wrong wireType = %d for field Info", 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 := &ResponseInfo{} 10158 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10159 return err 10160 } 10161 m.Value = &Response_Info{v} 10162 iNdEx = postIndex 10163 case 5: 10164 if wireType != 2 { 10165 return fmt.Errorf("proto: wrong wireType = %d for field SetOption", 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 := &ResponseSetOption{} 10193 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10194 return err 10195 } 10196 m.Value = &Response_SetOption{v} 10197 iNdEx = postIndex 10198 case 6: 10199 if wireType != 2 { 10200 return fmt.Errorf("proto: wrong wireType = %d for field InitChain", 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 := &ResponseInitChain{} 10228 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10229 return err 10230 } 10231 m.Value = &Response_InitChain{v} 10232 iNdEx = postIndex 10233 case 7: 10234 if wireType != 2 { 10235 return fmt.Errorf("proto: wrong wireType = %d for field Query", 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 := &ResponseQuery{} 10263 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10264 return err 10265 } 10266 m.Value = &Response_Query{v} 10267 iNdEx = postIndex 10268 case 8: 10269 if wireType != 2 { 10270 return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", 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 := &ResponseBeginBlock{} 10298 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10299 return err 10300 } 10301 m.Value = &Response_BeginBlock{v} 10302 iNdEx = postIndex 10303 case 9: 10304 if wireType != 2 { 10305 return fmt.Errorf("proto: wrong wireType = %d for field CheckTx", 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 := &ResponseCheckTx{} 10333 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10334 return err 10335 } 10336 m.Value = &Response_CheckTx{v} 10337 iNdEx = postIndex 10338 case 10: 10339 if wireType != 2 { 10340 return fmt.Errorf("proto: wrong wireType = %d for field DeliverTx", 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 := &ResponseDeliverTx{} 10368 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10369 return err 10370 } 10371 m.Value = &Response_DeliverTx{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 := &ResponseEndBlock{} 10403 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10404 return err 10405 } 10406 m.Value = &Response_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 := &ResponseCommit{} 10438 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10439 return err 10440 } 10441 m.Value = &Response_Commit{v} 10442 iNdEx = postIndex 10443 case 13: 10444 if wireType != 2 { 10445 return fmt.Errorf("proto: wrong wireType = %d for field ListSnapshots", 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 := &ResponseListSnapshots{} 10473 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10474 return err 10475 } 10476 m.Value = &Response_ListSnapshots{v} 10477 iNdEx = postIndex 10478 case 14: 10479 if wireType != 2 { 10480 return fmt.Errorf("proto: wrong wireType = %d for field OfferSnapshot", wireType) 10481 } 10482 var msglen int 10483 for shift := uint(0); ; shift += 7 { 10484 if shift >= 64 { 10485 return ErrIntOverflowTypes 10486 } 10487 if iNdEx >= l { 10488 return io.ErrUnexpectedEOF 10489 } 10490 b := dAtA[iNdEx] 10491 iNdEx++ 10492 msglen |= int(b&0x7F) << shift 10493 if b < 0x80 { 10494 break 10495 } 10496 } 10497 if msglen < 0 { 10498 return ErrInvalidLengthTypes 10499 } 10500 postIndex := iNdEx + msglen 10501 if postIndex < 0 { 10502 return ErrInvalidLengthTypes 10503 } 10504 if postIndex > l { 10505 return io.ErrUnexpectedEOF 10506 } 10507 v := &ResponseOfferSnapshot{} 10508 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10509 return err 10510 } 10511 m.Value = &Response_OfferSnapshot{v} 10512 iNdEx = postIndex 10513 case 15: 10514 if wireType != 2 { 10515 return fmt.Errorf("proto: wrong wireType = %d for field LoadSnapshotChunk", wireType) 10516 } 10517 var msglen int 10518 for shift := uint(0); ; shift += 7 { 10519 if shift >= 64 { 10520 return ErrIntOverflowTypes 10521 } 10522 if iNdEx >= l { 10523 return io.ErrUnexpectedEOF 10524 } 10525 b := dAtA[iNdEx] 10526 iNdEx++ 10527 msglen |= int(b&0x7F) << shift 10528 if b < 0x80 { 10529 break 10530 } 10531 } 10532 if msglen < 0 { 10533 return ErrInvalidLengthTypes 10534 } 10535 postIndex := iNdEx + msglen 10536 if postIndex < 0 { 10537 return ErrInvalidLengthTypes 10538 } 10539 if postIndex > l { 10540 return io.ErrUnexpectedEOF 10541 } 10542 v := &ResponseLoadSnapshotChunk{} 10543 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10544 return err 10545 } 10546 m.Value = &Response_LoadSnapshotChunk{v} 10547 iNdEx = postIndex 10548 case 16: 10549 if wireType != 2 { 10550 return fmt.Errorf("proto: wrong wireType = %d for field ApplySnapshotChunk", wireType) 10551 } 10552 var msglen int 10553 for shift := uint(0); ; shift += 7 { 10554 if shift >= 64 { 10555 return ErrIntOverflowTypes 10556 } 10557 if iNdEx >= l { 10558 return io.ErrUnexpectedEOF 10559 } 10560 b := dAtA[iNdEx] 10561 iNdEx++ 10562 msglen |= int(b&0x7F) << shift 10563 if b < 0x80 { 10564 break 10565 } 10566 } 10567 if msglen < 0 { 10568 return ErrInvalidLengthTypes 10569 } 10570 postIndex := iNdEx + msglen 10571 if postIndex < 0 { 10572 return ErrInvalidLengthTypes 10573 } 10574 if postIndex > l { 10575 return io.ErrUnexpectedEOF 10576 } 10577 v := &ResponseApplySnapshotChunk{} 10578 if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 10579 return err 10580 } 10581 m.Value = &Response_ApplySnapshotChunk{v} 10582 iNdEx = postIndex 10583 default: 10584 iNdEx = preIndex 10585 skippy, err := skipTypes(dAtA[iNdEx:]) 10586 if err != nil { 10587 return err 10588 } 10589 if (skippy < 0) || (iNdEx+skippy) < 0 { 10590 return ErrInvalidLengthTypes 10591 } 10592 if (iNdEx + skippy) > l { 10593 return io.ErrUnexpectedEOF 10594 } 10595 iNdEx += skippy 10596 } 10597 } 10598 10599 if iNdEx > l { 10600 return io.ErrUnexpectedEOF 10601 } 10602 return nil 10603 } 10604 func (m *ResponseException) Unmarshal(dAtA []byte) error { 10605 l := len(dAtA) 10606 iNdEx := 0 10607 for iNdEx < l { 10608 preIndex := iNdEx 10609 var wire uint64 10610 for shift := uint(0); ; shift += 7 { 10611 if shift >= 64 { 10612 return ErrIntOverflowTypes 10613 } 10614 if iNdEx >= l { 10615 return io.ErrUnexpectedEOF 10616 } 10617 b := dAtA[iNdEx] 10618 iNdEx++ 10619 wire |= uint64(b&0x7F) << shift 10620 if b < 0x80 { 10621 break 10622 } 10623 } 10624 fieldNum := int32(wire >> 3) 10625 wireType := int(wire & 0x7) 10626 if wireType == 4 { 10627 return fmt.Errorf("proto: ResponseException: wiretype end group for non-group") 10628 } 10629 if fieldNum <= 0 { 10630 return fmt.Errorf("proto: ResponseException: illegal tag %d (wire type %d)", fieldNum, wire) 10631 } 10632 switch fieldNum { 10633 case 1: 10634 if wireType != 2 { 10635 return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType) 10636 } 10637 var stringLen uint64 10638 for shift := uint(0); ; shift += 7 { 10639 if shift >= 64 { 10640 return ErrIntOverflowTypes 10641 } 10642 if iNdEx >= l { 10643 return io.ErrUnexpectedEOF 10644 } 10645 b := dAtA[iNdEx] 10646 iNdEx++ 10647 stringLen |= uint64(b&0x7F) << shift 10648 if b < 0x80 { 10649 break 10650 } 10651 } 10652 intStringLen := int(stringLen) 10653 if intStringLen < 0 { 10654 return ErrInvalidLengthTypes 10655 } 10656 postIndex := iNdEx + intStringLen 10657 if postIndex < 0 { 10658 return ErrInvalidLengthTypes 10659 } 10660 if postIndex > l { 10661 return io.ErrUnexpectedEOF 10662 } 10663 m.Error = string(dAtA[iNdEx:postIndex]) 10664 iNdEx = postIndex 10665 default: 10666 iNdEx = preIndex 10667 skippy, err := skipTypes(dAtA[iNdEx:]) 10668 if err != nil { 10669 return err 10670 } 10671 if (skippy < 0) || (iNdEx+skippy) < 0 { 10672 return ErrInvalidLengthTypes 10673 } 10674 if (iNdEx + skippy) > l { 10675 return io.ErrUnexpectedEOF 10676 } 10677 iNdEx += skippy 10678 } 10679 } 10680 10681 if iNdEx > l { 10682 return io.ErrUnexpectedEOF 10683 } 10684 return nil 10685 } 10686 func (m *ResponseEcho) Unmarshal(dAtA []byte) error { 10687 l := len(dAtA) 10688 iNdEx := 0 10689 for iNdEx < l { 10690 preIndex := iNdEx 10691 var wire uint64 10692 for shift := uint(0); ; shift += 7 { 10693 if shift >= 64 { 10694 return ErrIntOverflowTypes 10695 } 10696 if iNdEx >= l { 10697 return io.ErrUnexpectedEOF 10698 } 10699 b := dAtA[iNdEx] 10700 iNdEx++ 10701 wire |= uint64(b&0x7F) << shift 10702 if b < 0x80 { 10703 break 10704 } 10705 } 10706 fieldNum := int32(wire >> 3) 10707 wireType := int(wire & 0x7) 10708 if wireType == 4 { 10709 return fmt.Errorf("proto: ResponseEcho: wiretype end group for non-group") 10710 } 10711 if fieldNum <= 0 { 10712 return fmt.Errorf("proto: ResponseEcho: illegal tag %d (wire type %d)", fieldNum, wire) 10713 } 10714 switch fieldNum { 10715 case 1: 10716 if wireType != 2 { 10717 return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) 10718 } 10719 var stringLen uint64 10720 for shift := uint(0); ; shift += 7 { 10721 if shift >= 64 { 10722 return ErrIntOverflowTypes 10723 } 10724 if iNdEx >= l { 10725 return io.ErrUnexpectedEOF 10726 } 10727 b := dAtA[iNdEx] 10728 iNdEx++ 10729 stringLen |= uint64(b&0x7F) << shift 10730 if b < 0x80 { 10731 break 10732 } 10733 } 10734 intStringLen := int(stringLen) 10735 if intStringLen < 0 { 10736 return ErrInvalidLengthTypes 10737 } 10738 postIndex := iNdEx + intStringLen 10739 if postIndex < 0 { 10740 return ErrInvalidLengthTypes 10741 } 10742 if postIndex > l { 10743 return io.ErrUnexpectedEOF 10744 } 10745 m.Message = string(dAtA[iNdEx:postIndex]) 10746 iNdEx = postIndex 10747 default: 10748 iNdEx = preIndex 10749 skippy, err := skipTypes(dAtA[iNdEx:]) 10750 if err != nil { 10751 return err 10752 } 10753 if (skippy < 0) || (iNdEx+skippy) < 0 { 10754 return ErrInvalidLengthTypes 10755 } 10756 if (iNdEx + skippy) > l { 10757 return io.ErrUnexpectedEOF 10758 } 10759 iNdEx += skippy 10760 } 10761 } 10762 10763 if iNdEx > l { 10764 return io.ErrUnexpectedEOF 10765 } 10766 return nil 10767 } 10768 func (m *ResponseFlush) Unmarshal(dAtA []byte) error { 10769 l := len(dAtA) 10770 iNdEx := 0 10771 for iNdEx < l { 10772 preIndex := iNdEx 10773 var wire uint64 10774 for shift := uint(0); ; shift += 7 { 10775 if shift >= 64 { 10776 return ErrIntOverflowTypes 10777 } 10778 if iNdEx >= l { 10779 return io.ErrUnexpectedEOF 10780 } 10781 b := dAtA[iNdEx] 10782 iNdEx++ 10783 wire |= uint64(b&0x7F) << shift 10784 if b < 0x80 { 10785 break 10786 } 10787 } 10788 fieldNum := int32(wire >> 3) 10789 wireType := int(wire & 0x7) 10790 if wireType == 4 { 10791 return fmt.Errorf("proto: ResponseFlush: wiretype end group for non-group") 10792 } 10793 if fieldNum <= 0 { 10794 return fmt.Errorf("proto: ResponseFlush: illegal tag %d (wire type %d)", fieldNum, wire) 10795 } 10796 switch fieldNum { 10797 default: 10798 iNdEx = preIndex 10799 skippy, err := skipTypes(dAtA[iNdEx:]) 10800 if err != nil { 10801 return err 10802 } 10803 if (skippy < 0) || (iNdEx+skippy) < 0 { 10804 return ErrInvalidLengthTypes 10805 } 10806 if (iNdEx + skippy) > l { 10807 return io.ErrUnexpectedEOF 10808 } 10809 iNdEx += skippy 10810 } 10811 } 10812 10813 if iNdEx > l { 10814 return io.ErrUnexpectedEOF 10815 } 10816 return nil 10817 } 10818 func (m *ResponseInfo) Unmarshal(dAtA []byte) error { 10819 l := len(dAtA) 10820 iNdEx := 0 10821 for iNdEx < l { 10822 preIndex := iNdEx 10823 var wire uint64 10824 for shift := uint(0); ; shift += 7 { 10825 if shift >= 64 { 10826 return ErrIntOverflowTypes 10827 } 10828 if iNdEx >= l { 10829 return io.ErrUnexpectedEOF 10830 } 10831 b := dAtA[iNdEx] 10832 iNdEx++ 10833 wire |= uint64(b&0x7F) << shift 10834 if b < 0x80 { 10835 break 10836 } 10837 } 10838 fieldNum := int32(wire >> 3) 10839 wireType := int(wire & 0x7) 10840 if wireType == 4 { 10841 return fmt.Errorf("proto: ResponseInfo: wiretype end group for non-group") 10842 } 10843 if fieldNum <= 0 { 10844 return fmt.Errorf("proto: ResponseInfo: illegal tag %d (wire type %d)", fieldNum, wire) 10845 } 10846 switch fieldNum { 10847 case 1: 10848 if wireType != 2 { 10849 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 10850 } 10851 var stringLen uint64 10852 for shift := uint(0); ; shift += 7 { 10853 if shift >= 64 { 10854 return ErrIntOverflowTypes 10855 } 10856 if iNdEx >= l { 10857 return io.ErrUnexpectedEOF 10858 } 10859 b := dAtA[iNdEx] 10860 iNdEx++ 10861 stringLen |= uint64(b&0x7F) << shift 10862 if b < 0x80 { 10863 break 10864 } 10865 } 10866 intStringLen := int(stringLen) 10867 if intStringLen < 0 { 10868 return ErrInvalidLengthTypes 10869 } 10870 postIndex := iNdEx + intStringLen 10871 if postIndex < 0 { 10872 return ErrInvalidLengthTypes 10873 } 10874 if postIndex > l { 10875 return io.ErrUnexpectedEOF 10876 } 10877 m.Data = string(dAtA[iNdEx:postIndex]) 10878 iNdEx = postIndex 10879 case 2: 10880 if wireType != 2 { 10881 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 10882 } 10883 var stringLen uint64 10884 for shift := uint(0); ; shift += 7 { 10885 if shift >= 64 { 10886 return ErrIntOverflowTypes 10887 } 10888 if iNdEx >= l { 10889 return io.ErrUnexpectedEOF 10890 } 10891 b := dAtA[iNdEx] 10892 iNdEx++ 10893 stringLen |= uint64(b&0x7F) << shift 10894 if b < 0x80 { 10895 break 10896 } 10897 } 10898 intStringLen := int(stringLen) 10899 if intStringLen < 0 { 10900 return ErrInvalidLengthTypes 10901 } 10902 postIndex := iNdEx + intStringLen 10903 if postIndex < 0 { 10904 return ErrInvalidLengthTypes 10905 } 10906 if postIndex > l { 10907 return io.ErrUnexpectedEOF 10908 } 10909 m.Version = string(dAtA[iNdEx:postIndex]) 10910 iNdEx = postIndex 10911 case 3: 10912 if wireType != 0 { 10913 return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType) 10914 } 10915 m.AppVersion = 0 10916 for shift := uint(0); ; shift += 7 { 10917 if shift >= 64 { 10918 return ErrIntOverflowTypes 10919 } 10920 if iNdEx >= l { 10921 return io.ErrUnexpectedEOF 10922 } 10923 b := dAtA[iNdEx] 10924 iNdEx++ 10925 m.AppVersion |= uint64(b&0x7F) << shift 10926 if b < 0x80 { 10927 break 10928 } 10929 } 10930 case 4: 10931 if wireType != 0 { 10932 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockHeight", wireType) 10933 } 10934 m.LastBlockHeight = 0 10935 for shift := uint(0); ; shift += 7 { 10936 if shift >= 64 { 10937 return ErrIntOverflowTypes 10938 } 10939 if iNdEx >= l { 10940 return io.ErrUnexpectedEOF 10941 } 10942 b := dAtA[iNdEx] 10943 iNdEx++ 10944 m.LastBlockHeight |= int64(b&0x7F) << shift 10945 if b < 0x80 { 10946 break 10947 } 10948 } 10949 case 5: 10950 if wireType != 2 { 10951 return fmt.Errorf("proto: wrong wireType = %d for field LastBlockAppHash", wireType) 10952 } 10953 var byteLen int 10954 for shift := uint(0); ; shift += 7 { 10955 if shift >= 64 { 10956 return ErrIntOverflowTypes 10957 } 10958 if iNdEx >= l { 10959 return io.ErrUnexpectedEOF 10960 } 10961 b := dAtA[iNdEx] 10962 iNdEx++ 10963 byteLen |= int(b&0x7F) << shift 10964 if b < 0x80 { 10965 break 10966 } 10967 } 10968 if byteLen < 0 { 10969 return ErrInvalidLengthTypes 10970 } 10971 postIndex := iNdEx + byteLen 10972 if postIndex < 0 { 10973 return ErrInvalidLengthTypes 10974 } 10975 if postIndex > l { 10976 return io.ErrUnexpectedEOF 10977 } 10978 m.LastBlockAppHash = append(m.LastBlockAppHash[:0], dAtA[iNdEx:postIndex]...) 10979 if m.LastBlockAppHash == nil { 10980 m.LastBlockAppHash = []byte{} 10981 } 10982 iNdEx = postIndex 10983 default: 10984 iNdEx = preIndex 10985 skippy, err := skipTypes(dAtA[iNdEx:]) 10986 if err != nil { 10987 return err 10988 } 10989 if (skippy < 0) || (iNdEx+skippy) < 0 { 10990 return ErrInvalidLengthTypes 10991 } 10992 if (iNdEx + skippy) > l { 10993 return io.ErrUnexpectedEOF 10994 } 10995 iNdEx += skippy 10996 } 10997 } 10998 10999 if iNdEx > l { 11000 return io.ErrUnexpectedEOF 11001 } 11002 return nil 11003 } 11004 func (m *ResponseSetOption) Unmarshal(dAtA []byte) error { 11005 l := len(dAtA) 11006 iNdEx := 0 11007 for iNdEx < l { 11008 preIndex := iNdEx 11009 var wire uint64 11010 for shift := uint(0); ; shift += 7 { 11011 if shift >= 64 { 11012 return ErrIntOverflowTypes 11013 } 11014 if iNdEx >= l { 11015 return io.ErrUnexpectedEOF 11016 } 11017 b := dAtA[iNdEx] 11018 iNdEx++ 11019 wire |= uint64(b&0x7F) << shift 11020 if b < 0x80 { 11021 break 11022 } 11023 } 11024 fieldNum := int32(wire >> 3) 11025 wireType := int(wire & 0x7) 11026 if wireType == 4 { 11027 return fmt.Errorf("proto: ResponseSetOption: wiretype end group for non-group") 11028 } 11029 if fieldNum <= 0 { 11030 return fmt.Errorf("proto: ResponseSetOption: illegal tag %d (wire type %d)", fieldNum, wire) 11031 } 11032 switch fieldNum { 11033 case 1: 11034 if wireType != 0 { 11035 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 11036 } 11037 m.Code = 0 11038 for shift := uint(0); ; shift += 7 { 11039 if shift >= 64 { 11040 return ErrIntOverflowTypes 11041 } 11042 if iNdEx >= l { 11043 return io.ErrUnexpectedEOF 11044 } 11045 b := dAtA[iNdEx] 11046 iNdEx++ 11047 m.Code |= uint32(b&0x7F) << shift 11048 if b < 0x80 { 11049 break 11050 } 11051 } 11052 case 3: 11053 if wireType != 2 { 11054 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 11055 } 11056 var stringLen uint64 11057 for shift := uint(0); ; shift += 7 { 11058 if shift >= 64 { 11059 return ErrIntOverflowTypes 11060 } 11061 if iNdEx >= l { 11062 return io.ErrUnexpectedEOF 11063 } 11064 b := dAtA[iNdEx] 11065 iNdEx++ 11066 stringLen |= uint64(b&0x7F) << shift 11067 if b < 0x80 { 11068 break 11069 } 11070 } 11071 intStringLen := int(stringLen) 11072 if intStringLen < 0 { 11073 return ErrInvalidLengthTypes 11074 } 11075 postIndex := iNdEx + intStringLen 11076 if postIndex < 0 { 11077 return ErrInvalidLengthTypes 11078 } 11079 if postIndex > l { 11080 return io.ErrUnexpectedEOF 11081 } 11082 m.Log = string(dAtA[iNdEx:postIndex]) 11083 iNdEx = postIndex 11084 case 4: 11085 if wireType != 2 { 11086 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 11087 } 11088 var stringLen uint64 11089 for shift := uint(0); ; shift += 7 { 11090 if shift >= 64 { 11091 return ErrIntOverflowTypes 11092 } 11093 if iNdEx >= l { 11094 return io.ErrUnexpectedEOF 11095 } 11096 b := dAtA[iNdEx] 11097 iNdEx++ 11098 stringLen |= uint64(b&0x7F) << shift 11099 if b < 0x80 { 11100 break 11101 } 11102 } 11103 intStringLen := int(stringLen) 11104 if intStringLen < 0 { 11105 return ErrInvalidLengthTypes 11106 } 11107 postIndex := iNdEx + intStringLen 11108 if postIndex < 0 { 11109 return ErrInvalidLengthTypes 11110 } 11111 if postIndex > l { 11112 return io.ErrUnexpectedEOF 11113 } 11114 m.Info = string(dAtA[iNdEx:postIndex]) 11115 iNdEx = postIndex 11116 default: 11117 iNdEx = preIndex 11118 skippy, err := skipTypes(dAtA[iNdEx:]) 11119 if err != nil { 11120 return err 11121 } 11122 if (skippy < 0) || (iNdEx+skippy) < 0 { 11123 return ErrInvalidLengthTypes 11124 } 11125 if (iNdEx + skippy) > l { 11126 return io.ErrUnexpectedEOF 11127 } 11128 iNdEx += skippy 11129 } 11130 } 11131 11132 if iNdEx > l { 11133 return io.ErrUnexpectedEOF 11134 } 11135 return nil 11136 } 11137 func (m *ResponseInitChain) Unmarshal(dAtA []byte) error { 11138 l := len(dAtA) 11139 iNdEx := 0 11140 for iNdEx < l { 11141 preIndex := iNdEx 11142 var wire uint64 11143 for shift := uint(0); ; shift += 7 { 11144 if shift >= 64 { 11145 return ErrIntOverflowTypes 11146 } 11147 if iNdEx >= l { 11148 return io.ErrUnexpectedEOF 11149 } 11150 b := dAtA[iNdEx] 11151 iNdEx++ 11152 wire |= uint64(b&0x7F) << shift 11153 if b < 0x80 { 11154 break 11155 } 11156 } 11157 fieldNum := int32(wire >> 3) 11158 wireType := int(wire & 0x7) 11159 if wireType == 4 { 11160 return fmt.Errorf("proto: ResponseInitChain: wiretype end group for non-group") 11161 } 11162 if fieldNum <= 0 { 11163 return fmt.Errorf("proto: ResponseInitChain: illegal tag %d (wire type %d)", fieldNum, wire) 11164 } 11165 switch fieldNum { 11166 case 1: 11167 if wireType != 2 { 11168 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParams", wireType) 11169 } 11170 var msglen int 11171 for shift := uint(0); ; shift += 7 { 11172 if shift >= 64 { 11173 return ErrIntOverflowTypes 11174 } 11175 if iNdEx >= l { 11176 return io.ErrUnexpectedEOF 11177 } 11178 b := dAtA[iNdEx] 11179 iNdEx++ 11180 msglen |= int(b&0x7F) << shift 11181 if b < 0x80 { 11182 break 11183 } 11184 } 11185 if msglen < 0 { 11186 return ErrInvalidLengthTypes 11187 } 11188 postIndex := iNdEx + msglen 11189 if postIndex < 0 { 11190 return ErrInvalidLengthTypes 11191 } 11192 if postIndex > l { 11193 return io.ErrUnexpectedEOF 11194 } 11195 if m.ConsensusParams == nil { 11196 m.ConsensusParams = &ConsensusParams{} 11197 } 11198 if err := m.ConsensusParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11199 return err 11200 } 11201 iNdEx = postIndex 11202 case 2: 11203 if wireType != 2 { 11204 return fmt.Errorf("proto: wrong wireType = %d for field Validators", wireType) 11205 } 11206 var msglen int 11207 for shift := uint(0); ; shift += 7 { 11208 if shift >= 64 { 11209 return ErrIntOverflowTypes 11210 } 11211 if iNdEx >= l { 11212 return io.ErrUnexpectedEOF 11213 } 11214 b := dAtA[iNdEx] 11215 iNdEx++ 11216 msglen |= int(b&0x7F) << shift 11217 if b < 0x80 { 11218 break 11219 } 11220 } 11221 if msglen < 0 { 11222 return ErrInvalidLengthTypes 11223 } 11224 postIndex := iNdEx + msglen 11225 if postIndex < 0 { 11226 return ErrInvalidLengthTypes 11227 } 11228 if postIndex > l { 11229 return io.ErrUnexpectedEOF 11230 } 11231 m.Validators = append(m.Validators, ValidatorUpdate{}) 11232 if err := m.Validators[len(m.Validators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11233 return err 11234 } 11235 iNdEx = postIndex 11236 case 3: 11237 if wireType != 2 { 11238 return fmt.Errorf("proto: wrong wireType = %d for field AppHash", wireType) 11239 } 11240 var byteLen int 11241 for shift := uint(0); ; shift += 7 { 11242 if shift >= 64 { 11243 return ErrIntOverflowTypes 11244 } 11245 if iNdEx >= l { 11246 return io.ErrUnexpectedEOF 11247 } 11248 b := dAtA[iNdEx] 11249 iNdEx++ 11250 byteLen |= int(b&0x7F) << shift 11251 if b < 0x80 { 11252 break 11253 } 11254 } 11255 if byteLen < 0 { 11256 return ErrInvalidLengthTypes 11257 } 11258 postIndex := iNdEx + byteLen 11259 if postIndex < 0 { 11260 return ErrInvalidLengthTypes 11261 } 11262 if postIndex > l { 11263 return io.ErrUnexpectedEOF 11264 } 11265 m.AppHash = append(m.AppHash[:0], dAtA[iNdEx:postIndex]...) 11266 if m.AppHash == nil { 11267 m.AppHash = []byte{} 11268 } 11269 iNdEx = postIndex 11270 default: 11271 iNdEx = preIndex 11272 skippy, err := skipTypes(dAtA[iNdEx:]) 11273 if err != nil { 11274 return err 11275 } 11276 if (skippy < 0) || (iNdEx+skippy) < 0 { 11277 return ErrInvalidLengthTypes 11278 } 11279 if (iNdEx + skippy) > l { 11280 return io.ErrUnexpectedEOF 11281 } 11282 iNdEx += skippy 11283 } 11284 } 11285 11286 if iNdEx > l { 11287 return io.ErrUnexpectedEOF 11288 } 11289 return nil 11290 } 11291 func (m *ResponseQuery) Unmarshal(dAtA []byte) error { 11292 l := len(dAtA) 11293 iNdEx := 0 11294 for iNdEx < l { 11295 preIndex := iNdEx 11296 var wire uint64 11297 for shift := uint(0); ; shift += 7 { 11298 if shift >= 64 { 11299 return ErrIntOverflowTypes 11300 } 11301 if iNdEx >= l { 11302 return io.ErrUnexpectedEOF 11303 } 11304 b := dAtA[iNdEx] 11305 iNdEx++ 11306 wire |= uint64(b&0x7F) << shift 11307 if b < 0x80 { 11308 break 11309 } 11310 } 11311 fieldNum := int32(wire >> 3) 11312 wireType := int(wire & 0x7) 11313 if wireType == 4 { 11314 return fmt.Errorf("proto: ResponseQuery: wiretype end group for non-group") 11315 } 11316 if fieldNum <= 0 { 11317 return fmt.Errorf("proto: ResponseQuery: illegal tag %d (wire type %d)", fieldNum, wire) 11318 } 11319 switch fieldNum { 11320 case 1: 11321 if wireType != 0 { 11322 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 11323 } 11324 m.Code = 0 11325 for shift := uint(0); ; shift += 7 { 11326 if shift >= 64 { 11327 return ErrIntOverflowTypes 11328 } 11329 if iNdEx >= l { 11330 return io.ErrUnexpectedEOF 11331 } 11332 b := dAtA[iNdEx] 11333 iNdEx++ 11334 m.Code |= uint32(b&0x7F) << shift 11335 if b < 0x80 { 11336 break 11337 } 11338 } 11339 case 3: 11340 if wireType != 2 { 11341 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 11342 } 11343 var stringLen uint64 11344 for shift := uint(0); ; shift += 7 { 11345 if shift >= 64 { 11346 return ErrIntOverflowTypes 11347 } 11348 if iNdEx >= l { 11349 return io.ErrUnexpectedEOF 11350 } 11351 b := dAtA[iNdEx] 11352 iNdEx++ 11353 stringLen |= uint64(b&0x7F) << shift 11354 if b < 0x80 { 11355 break 11356 } 11357 } 11358 intStringLen := int(stringLen) 11359 if intStringLen < 0 { 11360 return ErrInvalidLengthTypes 11361 } 11362 postIndex := iNdEx + intStringLen 11363 if postIndex < 0 { 11364 return ErrInvalidLengthTypes 11365 } 11366 if postIndex > l { 11367 return io.ErrUnexpectedEOF 11368 } 11369 m.Log = string(dAtA[iNdEx:postIndex]) 11370 iNdEx = postIndex 11371 case 4: 11372 if wireType != 2 { 11373 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 11374 } 11375 var stringLen uint64 11376 for shift := uint(0); ; shift += 7 { 11377 if shift >= 64 { 11378 return ErrIntOverflowTypes 11379 } 11380 if iNdEx >= l { 11381 return io.ErrUnexpectedEOF 11382 } 11383 b := dAtA[iNdEx] 11384 iNdEx++ 11385 stringLen |= uint64(b&0x7F) << shift 11386 if b < 0x80 { 11387 break 11388 } 11389 } 11390 intStringLen := int(stringLen) 11391 if intStringLen < 0 { 11392 return ErrInvalidLengthTypes 11393 } 11394 postIndex := iNdEx + intStringLen 11395 if postIndex < 0 { 11396 return ErrInvalidLengthTypes 11397 } 11398 if postIndex > l { 11399 return io.ErrUnexpectedEOF 11400 } 11401 m.Info = string(dAtA[iNdEx:postIndex]) 11402 iNdEx = postIndex 11403 case 5: 11404 if wireType != 0 { 11405 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 11406 } 11407 m.Index = 0 11408 for shift := uint(0); ; shift += 7 { 11409 if shift >= 64 { 11410 return ErrIntOverflowTypes 11411 } 11412 if iNdEx >= l { 11413 return io.ErrUnexpectedEOF 11414 } 11415 b := dAtA[iNdEx] 11416 iNdEx++ 11417 m.Index |= int64(b&0x7F) << shift 11418 if b < 0x80 { 11419 break 11420 } 11421 } 11422 case 6: 11423 if wireType != 2 { 11424 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 11425 } 11426 var byteLen int 11427 for shift := uint(0); ; shift += 7 { 11428 if shift >= 64 { 11429 return ErrIntOverflowTypes 11430 } 11431 if iNdEx >= l { 11432 return io.ErrUnexpectedEOF 11433 } 11434 b := dAtA[iNdEx] 11435 iNdEx++ 11436 byteLen |= int(b&0x7F) << shift 11437 if b < 0x80 { 11438 break 11439 } 11440 } 11441 if byteLen < 0 { 11442 return ErrInvalidLengthTypes 11443 } 11444 postIndex := iNdEx + byteLen 11445 if postIndex < 0 { 11446 return ErrInvalidLengthTypes 11447 } 11448 if postIndex > l { 11449 return io.ErrUnexpectedEOF 11450 } 11451 m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) 11452 if m.Key == nil { 11453 m.Key = []byte{} 11454 } 11455 iNdEx = postIndex 11456 case 7: 11457 if wireType != 2 { 11458 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 11459 } 11460 var byteLen int 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 byteLen |= int(b&0x7F) << shift 11471 if b < 0x80 { 11472 break 11473 } 11474 } 11475 if byteLen < 0 { 11476 return ErrInvalidLengthTypes 11477 } 11478 postIndex := iNdEx + byteLen 11479 if postIndex < 0 { 11480 return ErrInvalidLengthTypes 11481 } 11482 if postIndex > l { 11483 return io.ErrUnexpectedEOF 11484 } 11485 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 11486 if m.Value == nil { 11487 m.Value = []byte{} 11488 } 11489 iNdEx = postIndex 11490 case 8: 11491 if wireType != 2 { 11492 return fmt.Errorf("proto: wrong wireType = %d for field ProofOps", wireType) 11493 } 11494 var msglen int 11495 for shift := uint(0); ; shift += 7 { 11496 if shift >= 64 { 11497 return ErrIntOverflowTypes 11498 } 11499 if iNdEx >= l { 11500 return io.ErrUnexpectedEOF 11501 } 11502 b := dAtA[iNdEx] 11503 iNdEx++ 11504 msglen |= int(b&0x7F) << shift 11505 if b < 0x80 { 11506 break 11507 } 11508 } 11509 if msglen < 0 { 11510 return ErrInvalidLengthTypes 11511 } 11512 postIndex := iNdEx + msglen 11513 if postIndex < 0 { 11514 return ErrInvalidLengthTypes 11515 } 11516 if postIndex > l { 11517 return io.ErrUnexpectedEOF 11518 } 11519 if m.ProofOps == nil { 11520 m.ProofOps = &crypto.ProofOps{} 11521 } 11522 if err := m.ProofOps.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11523 return err 11524 } 11525 iNdEx = postIndex 11526 case 9: 11527 if wireType != 0 { 11528 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 11529 } 11530 m.Height = 0 11531 for shift := uint(0); ; shift += 7 { 11532 if shift >= 64 { 11533 return ErrIntOverflowTypes 11534 } 11535 if iNdEx >= l { 11536 return io.ErrUnexpectedEOF 11537 } 11538 b := dAtA[iNdEx] 11539 iNdEx++ 11540 m.Height |= int64(b&0x7F) << shift 11541 if b < 0x80 { 11542 break 11543 } 11544 } 11545 case 10: 11546 if wireType != 2 { 11547 return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) 11548 } 11549 var stringLen uint64 11550 for shift := uint(0); ; shift += 7 { 11551 if shift >= 64 { 11552 return ErrIntOverflowTypes 11553 } 11554 if iNdEx >= l { 11555 return io.ErrUnexpectedEOF 11556 } 11557 b := dAtA[iNdEx] 11558 iNdEx++ 11559 stringLen |= uint64(b&0x7F) << shift 11560 if b < 0x80 { 11561 break 11562 } 11563 } 11564 intStringLen := int(stringLen) 11565 if intStringLen < 0 { 11566 return ErrInvalidLengthTypes 11567 } 11568 postIndex := iNdEx + intStringLen 11569 if postIndex < 0 { 11570 return ErrInvalidLengthTypes 11571 } 11572 if postIndex > l { 11573 return io.ErrUnexpectedEOF 11574 } 11575 m.Codespace = string(dAtA[iNdEx:postIndex]) 11576 iNdEx = postIndex 11577 default: 11578 iNdEx = preIndex 11579 skippy, err := skipTypes(dAtA[iNdEx:]) 11580 if err != nil { 11581 return err 11582 } 11583 if (skippy < 0) || (iNdEx+skippy) < 0 { 11584 return ErrInvalidLengthTypes 11585 } 11586 if (iNdEx + skippy) > l { 11587 return io.ErrUnexpectedEOF 11588 } 11589 iNdEx += skippy 11590 } 11591 } 11592 11593 if iNdEx > l { 11594 return io.ErrUnexpectedEOF 11595 } 11596 return nil 11597 } 11598 func (m *ResponseBeginBlock) Unmarshal(dAtA []byte) error { 11599 l := len(dAtA) 11600 iNdEx := 0 11601 for iNdEx < l { 11602 preIndex := iNdEx 11603 var wire uint64 11604 for shift := uint(0); ; shift += 7 { 11605 if shift >= 64 { 11606 return ErrIntOverflowTypes 11607 } 11608 if iNdEx >= l { 11609 return io.ErrUnexpectedEOF 11610 } 11611 b := dAtA[iNdEx] 11612 iNdEx++ 11613 wire |= uint64(b&0x7F) << shift 11614 if b < 0x80 { 11615 break 11616 } 11617 } 11618 fieldNum := int32(wire >> 3) 11619 wireType := int(wire & 0x7) 11620 if wireType == 4 { 11621 return fmt.Errorf("proto: ResponseBeginBlock: wiretype end group for non-group") 11622 } 11623 if fieldNum <= 0 { 11624 return fmt.Errorf("proto: ResponseBeginBlock: illegal tag %d (wire type %d)", fieldNum, wire) 11625 } 11626 switch fieldNum { 11627 case 1: 11628 if wireType != 2 { 11629 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 11630 } 11631 var msglen int 11632 for shift := uint(0); ; shift += 7 { 11633 if shift >= 64 { 11634 return ErrIntOverflowTypes 11635 } 11636 if iNdEx >= l { 11637 return io.ErrUnexpectedEOF 11638 } 11639 b := dAtA[iNdEx] 11640 iNdEx++ 11641 msglen |= int(b&0x7F) << shift 11642 if b < 0x80 { 11643 break 11644 } 11645 } 11646 if msglen < 0 { 11647 return ErrInvalidLengthTypes 11648 } 11649 postIndex := iNdEx + msglen 11650 if postIndex < 0 { 11651 return ErrInvalidLengthTypes 11652 } 11653 if postIndex > l { 11654 return io.ErrUnexpectedEOF 11655 } 11656 m.Events = append(m.Events, Event{}) 11657 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11658 return err 11659 } 11660 iNdEx = postIndex 11661 default: 11662 iNdEx = preIndex 11663 skippy, err := skipTypes(dAtA[iNdEx:]) 11664 if err != nil { 11665 return err 11666 } 11667 if (skippy < 0) || (iNdEx+skippy) < 0 { 11668 return ErrInvalidLengthTypes 11669 } 11670 if (iNdEx + skippy) > l { 11671 return io.ErrUnexpectedEOF 11672 } 11673 iNdEx += skippy 11674 } 11675 } 11676 11677 if iNdEx > l { 11678 return io.ErrUnexpectedEOF 11679 } 11680 return nil 11681 } 11682 func (m *ResponseCheckTx) Unmarshal(dAtA []byte) error { 11683 l := len(dAtA) 11684 iNdEx := 0 11685 for iNdEx < l { 11686 preIndex := iNdEx 11687 var wire uint64 11688 for shift := uint(0); ; shift += 7 { 11689 if shift >= 64 { 11690 return ErrIntOverflowTypes 11691 } 11692 if iNdEx >= l { 11693 return io.ErrUnexpectedEOF 11694 } 11695 b := dAtA[iNdEx] 11696 iNdEx++ 11697 wire |= uint64(b&0x7F) << shift 11698 if b < 0x80 { 11699 break 11700 } 11701 } 11702 fieldNum := int32(wire >> 3) 11703 wireType := int(wire & 0x7) 11704 if wireType == 4 { 11705 return fmt.Errorf("proto: ResponseCheckTx: wiretype end group for non-group") 11706 } 11707 if fieldNum <= 0 { 11708 return fmt.Errorf("proto: ResponseCheckTx: illegal tag %d (wire type %d)", fieldNum, wire) 11709 } 11710 switch fieldNum { 11711 case 1: 11712 if wireType != 0 { 11713 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 11714 } 11715 m.Code = 0 11716 for shift := uint(0); ; shift += 7 { 11717 if shift >= 64 { 11718 return ErrIntOverflowTypes 11719 } 11720 if iNdEx >= l { 11721 return io.ErrUnexpectedEOF 11722 } 11723 b := dAtA[iNdEx] 11724 iNdEx++ 11725 m.Code |= uint32(b&0x7F) << shift 11726 if b < 0x80 { 11727 break 11728 } 11729 } 11730 case 2: 11731 if wireType != 2 { 11732 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 11733 } 11734 var byteLen int 11735 for shift := uint(0); ; shift += 7 { 11736 if shift >= 64 { 11737 return ErrIntOverflowTypes 11738 } 11739 if iNdEx >= l { 11740 return io.ErrUnexpectedEOF 11741 } 11742 b := dAtA[iNdEx] 11743 iNdEx++ 11744 byteLen |= int(b&0x7F) << shift 11745 if b < 0x80 { 11746 break 11747 } 11748 } 11749 if byteLen < 0 { 11750 return ErrInvalidLengthTypes 11751 } 11752 postIndex := iNdEx + byteLen 11753 if postIndex < 0 { 11754 return ErrInvalidLengthTypes 11755 } 11756 if postIndex > l { 11757 return io.ErrUnexpectedEOF 11758 } 11759 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 11760 if m.Data == nil { 11761 m.Data = []byte{} 11762 } 11763 iNdEx = postIndex 11764 case 3: 11765 if wireType != 2 { 11766 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 11767 } 11768 var stringLen uint64 11769 for shift := uint(0); ; shift += 7 { 11770 if shift >= 64 { 11771 return ErrIntOverflowTypes 11772 } 11773 if iNdEx >= l { 11774 return io.ErrUnexpectedEOF 11775 } 11776 b := dAtA[iNdEx] 11777 iNdEx++ 11778 stringLen |= uint64(b&0x7F) << shift 11779 if b < 0x80 { 11780 break 11781 } 11782 } 11783 intStringLen := int(stringLen) 11784 if intStringLen < 0 { 11785 return ErrInvalidLengthTypes 11786 } 11787 postIndex := iNdEx + intStringLen 11788 if postIndex < 0 { 11789 return ErrInvalidLengthTypes 11790 } 11791 if postIndex > l { 11792 return io.ErrUnexpectedEOF 11793 } 11794 m.Log = string(dAtA[iNdEx:postIndex]) 11795 iNdEx = postIndex 11796 case 4: 11797 if wireType != 2 { 11798 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 11799 } 11800 var stringLen uint64 11801 for shift := uint(0); ; shift += 7 { 11802 if shift >= 64 { 11803 return ErrIntOverflowTypes 11804 } 11805 if iNdEx >= l { 11806 return io.ErrUnexpectedEOF 11807 } 11808 b := dAtA[iNdEx] 11809 iNdEx++ 11810 stringLen |= uint64(b&0x7F) << shift 11811 if b < 0x80 { 11812 break 11813 } 11814 } 11815 intStringLen := int(stringLen) 11816 if intStringLen < 0 { 11817 return ErrInvalidLengthTypes 11818 } 11819 postIndex := iNdEx + intStringLen 11820 if postIndex < 0 { 11821 return ErrInvalidLengthTypes 11822 } 11823 if postIndex > l { 11824 return io.ErrUnexpectedEOF 11825 } 11826 m.Info = string(dAtA[iNdEx:postIndex]) 11827 iNdEx = postIndex 11828 case 5: 11829 if wireType != 0 { 11830 return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) 11831 } 11832 m.GasWanted = 0 11833 for shift := uint(0); ; shift += 7 { 11834 if shift >= 64 { 11835 return ErrIntOverflowTypes 11836 } 11837 if iNdEx >= l { 11838 return io.ErrUnexpectedEOF 11839 } 11840 b := dAtA[iNdEx] 11841 iNdEx++ 11842 m.GasWanted |= int64(b&0x7F) << shift 11843 if b < 0x80 { 11844 break 11845 } 11846 } 11847 case 6: 11848 if wireType != 0 { 11849 return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) 11850 } 11851 m.GasUsed = 0 11852 for shift := uint(0); ; shift += 7 { 11853 if shift >= 64 { 11854 return ErrIntOverflowTypes 11855 } 11856 if iNdEx >= l { 11857 return io.ErrUnexpectedEOF 11858 } 11859 b := dAtA[iNdEx] 11860 iNdEx++ 11861 m.GasUsed |= int64(b&0x7F) << shift 11862 if b < 0x80 { 11863 break 11864 } 11865 } 11866 case 7: 11867 if wireType != 2 { 11868 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 11869 } 11870 var msglen int 11871 for shift := uint(0); ; shift += 7 { 11872 if shift >= 64 { 11873 return ErrIntOverflowTypes 11874 } 11875 if iNdEx >= l { 11876 return io.ErrUnexpectedEOF 11877 } 11878 b := dAtA[iNdEx] 11879 iNdEx++ 11880 msglen |= int(b&0x7F) << shift 11881 if b < 0x80 { 11882 break 11883 } 11884 } 11885 if msglen < 0 { 11886 return ErrInvalidLengthTypes 11887 } 11888 postIndex := iNdEx + msglen 11889 if postIndex < 0 { 11890 return ErrInvalidLengthTypes 11891 } 11892 if postIndex > l { 11893 return io.ErrUnexpectedEOF 11894 } 11895 m.Events = append(m.Events, Event{}) 11896 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 11897 return err 11898 } 11899 iNdEx = postIndex 11900 case 8: 11901 if wireType != 2 { 11902 return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) 11903 } 11904 var stringLen uint64 11905 for shift := uint(0); ; shift += 7 { 11906 if shift >= 64 { 11907 return ErrIntOverflowTypes 11908 } 11909 if iNdEx >= l { 11910 return io.ErrUnexpectedEOF 11911 } 11912 b := dAtA[iNdEx] 11913 iNdEx++ 11914 stringLen |= uint64(b&0x7F) << shift 11915 if b < 0x80 { 11916 break 11917 } 11918 } 11919 intStringLen := int(stringLen) 11920 if intStringLen < 0 { 11921 return ErrInvalidLengthTypes 11922 } 11923 postIndex := iNdEx + intStringLen 11924 if postIndex < 0 { 11925 return ErrInvalidLengthTypes 11926 } 11927 if postIndex > l { 11928 return io.ErrUnexpectedEOF 11929 } 11930 m.Codespace = string(dAtA[iNdEx:postIndex]) 11931 iNdEx = postIndex 11932 default: 11933 iNdEx = preIndex 11934 skippy, err := skipTypes(dAtA[iNdEx:]) 11935 if err != nil { 11936 return err 11937 } 11938 if (skippy < 0) || (iNdEx+skippy) < 0 { 11939 return ErrInvalidLengthTypes 11940 } 11941 if (iNdEx + skippy) > l { 11942 return io.ErrUnexpectedEOF 11943 } 11944 iNdEx += skippy 11945 } 11946 } 11947 11948 if iNdEx > l { 11949 return io.ErrUnexpectedEOF 11950 } 11951 return nil 11952 } 11953 func (m *ResponseDeliverTx) Unmarshal(dAtA []byte) error { 11954 l := len(dAtA) 11955 iNdEx := 0 11956 for iNdEx < l { 11957 preIndex := iNdEx 11958 var wire uint64 11959 for shift := uint(0); ; shift += 7 { 11960 if shift >= 64 { 11961 return ErrIntOverflowTypes 11962 } 11963 if iNdEx >= l { 11964 return io.ErrUnexpectedEOF 11965 } 11966 b := dAtA[iNdEx] 11967 iNdEx++ 11968 wire |= uint64(b&0x7F) << shift 11969 if b < 0x80 { 11970 break 11971 } 11972 } 11973 fieldNum := int32(wire >> 3) 11974 wireType := int(wire & 0x7) 11975 if wireType == 4 { 11976 return fmt.Errorf("proto: ResponseDeliverTx: wiretype end group for non-group") 11977 } 11978 if fieldNum <= 0 { 11979 return fmt.Errorf("proto: ResponseDeliverTx: illegal tag %d (wire type %d)", fieldNum, wire) 11980 } 11981 switch fieldNum { 11982 case 1: 11983 if wireType != 0 { 11984 return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType) 11985 } 11986 m.Code = 0 11987 for shift := uint(0); ; shift += 7 { 11988 if shift >= 64 { 11989 return ErrIntOverflowTypes 11990 } 11991 if iNdEx >= l { 11992 return io.ErrUnexpectedEOF 11993 } 11994 b := dAtA[iNdEx] 11995 iNdEx++ 11996 m.Code |= uint32(b&0x7F) << shift 11997 if b < 0x80 { 11998 break 11999 } 12000 } 12001 case 2: 12002 if wireType != 2 { 12003 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 12004 } 12005 var byteLen int 12006 for shift := uint(0); ; shift += 7 { 12007 if shift >= 64 { 12008 return ErrIntOverflowTypes 12009 } 12010 if iNdEx >= l { 12011 return io.ErrUnexpectedEOF 12012 } 12013 b := dAtA[iNdEx] 12014 iNdEx++ 12015 byteLen |= int(b&0x7F) << shift 12016 if b < 0x80 { 12017 break 12018 } 12019 } 12020 if byteLen < 0 { 12021 return ErrInvalidLengthTypes 12022 } 12023 postIndex := iNdEx + byteLen 12024 if postIndex < 0 { 12025 return ErrInvalidLengthTypes 12026 } 12027 if postIndex > l { 12028 return io.ErrUnexpectedEOF 12029 } 12030 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 12031 if m.Data == nil { 12032 m.Data = []byte{} 12033 } 12034 iNdEx = postIndex 12035 case 3: 12036 if wireType != 2 { 12037 return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType) 12038 } 12039 var stringLen uint64 12040 for shift := uint(0); ; shift += 7 { 12041 if shift >= 64 { 12042 return ErrIntOverflowTypes 12043 } 12044 if iNdEx >= l { 12045 return io.ErrUnexpectedEOF 12046 } 12047 b := dAtA[iNdEx] 12048 iNdEx++ 12049 stringLen |= uint64(b&0x7F) << shift 12050 if b < 0x80 { 12051 break 12052 } 12053 } 12054 intStringLen := int(stringLen) 12055 if intStringLen < 0 { 12056 return ErrInvalidLengthTypes 12057 } 12058 postIndex := iNdEx + intStringLen 12059 if postIndex < 0 { 12060 return ErrInvalidLengthTypes 12061 } 12062 if postIndex > l { 12063 return io.ErrUnexpectedEOF 12064 } 12065 m.Log = string(dAtA[iNdEx:postIndex]) 12066 iNdEx = postIndex 12067 case 4: 12068 if wireType != 2 { 12069 return fmt.Errorf("proto: wrong wireType = %d for field Info", wireType) 12070 } 12071 var stringLen uint64 12072 for shift := uint(0); ; shift += 7 { 12073 if shift >= 64 { 12074 return ErrIntOverflowTypes 12075 } 12076 if iNdEx >= l { 12077 return io.ErrUnexpectedEOF 12078 } 12079 b := dAtA[iNdEx] 12080 iNdEx++ 12081 stringLen |= uint64(b&0x7F) << shift 12082 if b < 0x80 { 12083 break 12084 } 12085 } 12086 intStringLen := int(stringLen) 12087 if intStringLen < 0 { 12088 return ErrInvalidLengthTypes 12089 } 12090 postIndex := iNdEx + intStringLen 12091 if postIndex < 0 { 12092 return ErrInvalidLengthTypes 12093 } 12094 if postIndex > l { 12095 return io.ErrUnexpectedEOF 12096 } 12097 m.Info = string(dAtA[iNdEx:postIndex]) 12098 iNdEx = postIndex 12099 case 5: 12100 if wireType != 0 { 12101 return fmt.Errorf("proto: wrong wireType = %d for field GasWanted", wireType) 12102 } 12103 m.GasWanted = 0 12104 for shift := uint(0); ; shift += 7 { 12105 if shift >= 64 { 12106 return ErrIntOverflowTypes 12107 } 12108 if iNdEx >= l { 12109 return io.ErrUnexpectedEOF 12110 } 12111 b := dAtA[iNdEx] 12112 iNdEx++ 12113 m.GasWanted |= int64(b&0x7F) << shift 12114 if b < 0x80 { 12115 break 12116 } 12117 } 12118 case 6: 12119 if wireType != 0 { 12120 return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType) 12121 } 12122 m.GasUsed = 0 12123 for shift := uint(0); ; shift += 7 { 12124 if shift >= 64 { 12125 return ErrIntOverflowTypes 12126 } 12127 if iNdEx >= l { 12128 return io.ErrUnexpectedEOF 12129 } 12130 b := dAtA[iNdEx] 12131 iNdEx++ 12132 m.GasUsed |= int64(b&0x7F) << shift 12133 if b < 0x80 { 12134 break 12135 } 12136 } 12137 case 7: 12138 if wireType != 2 { 12139 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 12140 } 12141 var msglen int 12142 for shift := uint(0); ; shift += 7 { 12143 if shift >= 64 { 12144 return ErrIntOverflowTypes 12145 } 12146 if iNdEx >= l { 12147 return io.ErrUnexpectedEOF 12148 } 12149 b := dAtA[iNdEx] 12150 iNdEx++ 12151 msglen |= int(b&0x7F) << shift 12152 if b < 0x80 { 12153 break 12154 } 12155 } 12156 if msglen < 0 { 12157 return ErrInvalidLengthTypes 12158 } 12159 postIndex := iNdEx + msglen 12160 if postIndex < 0 { 12161 return ErrInvalidLengthTypes 12162 } 12163 if postIndex > l { 12164 return io.ErrUnexpectedEOF 12165 } 12166 m.Events = append(m.Events, Event{}) 12167 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12168 return err 12169 } 12170 iNdEx = postIndex 12171 case 8: 12172 if wireType != 2 { 12173 return fmt.Errorf("proto: wrong wireType = %d for field Codespace", wireType) 12174 } 12175 var stringLen uint64 12176 for shift := uint(0); ; shift += 7 { 12177 if shift >= 64 { 12178 return ErrIntOverflowTypes 12179 } 12180 if iNdEx >= l { 12181 return io.ErrUnexpectedEOF 12182 } 12183 b := dAtA[iNdEx] 12184 iNdEx++ 12185 stringLen |= uint64(b&0x7F) << shift 12186 if b < 0x80 { 12187 break 12188 } 12189 } 12190 intStringLen := int(stringLen) 12191 if intStringLen < 0 { 12192 return ErrInvalidLengthTypes 12193 } 12194 postIndex := iNdEx + intStringLen 12195 if postIndex < 0 { 12196 return ErrInvalidLengthTypes 12197 } 12198 if postIndex > l { 12199 return io.ErrUnexpectedEOF 12200 } 12201 m.Codespace = string(dAtA[iNdEx:postIndex]) 12202 iNdEx = postIndex 12203 default: 12204 iNdEx = preIndex 12205 skippy, err := skipTypes(dAtA[iNdEx:]) 12206 if err != nil { 12207 return err 12208 } 12209 if (skippy < 0) || (iNdEx+skippy) < 0 { 12210 return ErrInvalidLengthTypes 12211 } 12212 if (iNdEx + skippy) > l { 12213 return io.ErrUnexpectedEOF 12214 } 12215 iNdEx += skippy 12216 } 12217 } 12218 12219 if iNdEx > l { 12220 return io.ErrUnexpectedEOF 12221 } 12222 return nil 12223 } 12224 func (m *ResponseEndBlock) Unmarshal(dAtA []byte) error { 12225 l := len(dAtA) 12226 iNdEx := 0 12227 for iNdEx < l { 12228 preIndex := iNdEx 12229 var wire uint64 12230 for shift := uint(0); ; shift += 7 { 12231 if shift >= 64 { 12232 return ErrIntOverflowTypes 12233 } 12234 if iNdEx >= l { 12235 return io.ErrUnexpectedEOF 12236 } 12237 b := dAtA[iNdEx] 12238 iNdEx++ 12239 wire |= uint64(b&0x7F) << shift 12240 if b < 0x80 { 12241 break 12242 } 12243 } 12244 fieldNum := int32(wire >> 3) 12245 wireType := int(wire & 0x7) 12246 if wireType == 4 { 12247 return fmt.Errorf("proto: ResponseEndBlock: wiretype end group for non-group") 12248 } 12249 if fieldNum <= 0 { 12250 return fmt.Errorf("proto: ResponseEndBlock: illegal tag %d (wire type %d)", fieldNum, wire) 12251 } 12252 switch fieldNum { 12253 case 1: 12254 if wireType != 2 { 12255 return fmt.Errorf("proto: wrong wireType = %d for field ValidatorUpdates", wireType) 12256 } 12257 var msglen int 12258 for shift := uint(0); ; shift += 7 { 12259 if shift >= 64 { 12260 return ErrIntOverflowTypes 12261 } 12262 if iNdEx >= l { 12263 return io.ErrUnexpectedEOF 12264 } 12265 b := dAtA[iNdEx] 12266 iNdEx++ 12267 msglen |= int(b&0x7F) << shift 12268 if b < 0x80 { 12269 break 12270 } 12271 } 12272 if msglen < 0 { 12273 return ErrInvalidLengthTypes 12274 } 12275 postIndex := iNdEx + msglen 12276 if postIndex < 0 { 12277 return ErrInvalidLengthTypes 12278 } 12279 if postIndex > l { 12280 return io.ErrUnexpectedEOF 12281 } 12282 m.ValidatorUpdates = append(m.ValidatorUpdates, ValidatorUpdate{}) 12283 if err := m.ValidatorUpdates[len(m.ValidatorUpdates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12284 return err 12285 } 12286 iNdEx = postIndex 12287 case 2: 12288 if wireType != 2 { 12289 return fmt.Errorf("proto: wrong wireType = %d for field ConsensusParamUpdates", wireType) 12290 } 12291 var msglen int 12292 for shift := uint(0); ; shift += 7 { 12293 if shift >= 64 { 12294 return ErrIntOverflowTypes 12295 } 12296 if iNdEx >= l { 12297 return io.ErrUnexpectedEOF 12298 } 12299 b := dAtA[iNdEx] 12300 iNdEx++ 12301 msglen |= int(b&0x7F) << shift 12302 if b < 0x80 { 12303 break 12304 } 12305 } 12306 if msglen < 0 { 12307 return ErrInvalidLengthTypes 12308 } 12309 postIndex := iNdEx + msglen 12310 if postIndex < 0 { 12311 return ErrInvalidLengthTypes 12312 } 12313 if postIndex > l { 12314 return io.ErrUnexpectedEOF 12315 } 12316 if m.ConsensusParamUpdates == nil { 12317 m.ConsensusParamUpdates = &ConsensusParams{} 12318 } 12319 if err := m.ConsensusParamUpdates.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12320 return err 12321 } 12322 iNdEx = postIndex 12323 case 3: 12324 if wireType != 2 { 12325 return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType) 12326 } 12327 var msglen int 12328 for shift := uint(0); ; shift += 7 { 12329 if shift >= 64 { 12330 return ErrIntOverflowTypes 12331 } 12332 if iNdEx >= l { 12333 return io.ErrUnexpectedEOF 12334 } 12335 b := dAtA[iNdEx] 12336 iNdEx++ 12337 msglen |= int(b&0x7F) << shift 12338 if b < 0x80 { 12339 break 12340 } 12341 } 12342 if msglen < 0 { 12343 return ErrInvalidLengthTypes 12344 } 12345 postIndex := iNdEx + msglen 12346 if postIndex < 0 { 12347 return ErrInvalidLengthTypes 12348 } 12349 if postIndex > l { 12350 return io.ErrUnexpectedEOF 12351 } 12352 m.Events = append(m.Events, Event{}) 12353 if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12354 return err 12355 } 12356 iNdEx = postIndex 12357 default: 12358 iNdEx = preIndex 12359 skippy, err := skipTypes(dAtA[iNdEx:]) 12360 if err != nil { 12361 return err 12362 } 12363 if (skippy < 0) || (iNdEx+skippy) < 0 { 12364 return ErrInvalidLengthTypes 12365 } 12366 if (iNdEx + skippy) > l { 12367 return io.ErrUnexpectedEOF 12368 } 12369 iNdEx += skippy 12370 } 12371 } 12372 12373 if iNdEx > l { 12374 return io.ErrUnexpectedEOF 12375 } 12376 return nil 12377 } 12378 func (m *ResponseCommit) Unmarshal(dAtA []byte) error { 12379 l := len(dAtA) 12380 iNdEx := 0 12381 for iNdEx < l { 12382 preIndex := iNdEx 12383 var wire uint64 12384 for shift := uint(0); ; shift += 7 { 12385 if shift >= 64 { 12386 return ErrIntOverflowTypes 12387 } 12388 if iNdEx >= l { 12389 return io.ErrUnexpectedEOF 12390 } 12391 b := dAtA[iNdEx] 12392 iNdEx++ 12393 wire |= uint64(b&0x7F) << shift 12394 if b < 0x80 { 12395 break 12396 } 12397 } 12398 fieldNum := int32(wire >> 3) 12399 wireType := int(wire & 0x7) 12400 if wireType == 4 { 12401 return fmt.Errorf("proto: ResponseCommit: wiretype end group for non-group") 12402 } 12403 if fieldNum <= 0 { 12404 return fmt.Errorf("proto: ResponseCommit: illegal tag %d (wire type %d)", fieldNum, wire) 12405 } 12406 switch fieldNum { 12407 case 2: 12408 if wireType != 2 { 12409 return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType) 12410 } 12411 var byteLen int 12412 for shift := uint(0); ; shift += 7 { 12413 if shift >= 64 { 12414 return ErrIntOverflowTypes 12415 } 12416 if iNdEx >= l { 12417 return io.ErrUnexpectedEOF 12418 } 12419 b := dAtA[iNdEx] 12420 iNdEx++ 12421 byteLen |= int(b&0x7F) << shift 12422 if b < 0x80 { 12423 break 12424 } 12425 } 12426 if byteLen < 0 { 12427 return ErrInvalidLengthTypes 12428 } 12429 postIndex := iNdEx + byteLen 12430 if postIndex < 0 { 12431 return ErrInvalidLengthTypes 12432 } 12433 if postIndex > l { 12434 return io.ErrUnexpectedEOF 12435 } 12436 m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...) 12437 if m.Data == nil { 12438 m.Data = []byte{} 12439 } 12440 iNdEx = postIndex 12441 case 3: 12442 if wireType != 0 { 12443 return fmt.Errorf("proto: wrong wireType = %d for field RetainHeight", wireType) 12444 } 12445 m.RetainHeight = 0 12446 for shift := uint(0); ; shift += 7 { 12447 if shift >= 64 { 12448 return ErrIntOverflowTypes 12449 } 12450 if iNdEx >= l { 12451 return io.ErrUnexpectedEOF 12452 } 12453 b := dAtA[iNdEx] 12454 iNdEx++ 12455 m.RetainHeight |= int64(b&0x7F) << shift 12456 if b < 0x80 { 12457 break 12458 } 12459 } 12460 default: 12461 iNdEx = preIndex 12462 skippy, err := skipTypes(dAtA[iNdEx:]) 12463 if err != nil { 12464 return err 12465 } 12466 if (skippy < 0) || (iNdEx+skippy) < 0 { 12467 return ErrInvalidLengthTypes 12468 } 12469 if (iNdEx + skippy) > l { 12470 return io.ErrUnexpectedEOF 12471 } 12472 iNdEx += skippy 12473 } 12474 } 12475 12476 if iNdEx > l { 12477 return io.ErrUnexpectedEOF 12478 } 12479 return nil 12480 } 12481 func (m *ResponseListSnapshots) Unmarshal(dAtA []byte) error { 12482 l := len(dAtA) 12483 iNdEx := 0 12484 for iNdEx < l { 12485 preIndex := iNdEx 12486 var wire uint64 12487 for shift := uint(0); ; shift += 7 { 12488 if shift >= 64 { 12489 return ErrIntOverflowTypes 12490 } 12491 if iNdEx >= l { 12492 return io.ErrUnexpectedEOF 12493 } 12494 b := dAtA[iNdEx] 12495 iNdEx++ 12496 wire |= uint64(b&0x7F) << shift 12497 if b < 0x80 { 12498 break 12499 } 12500 } 12501 fieldNum := int32(wire >> 3) 12502 wireType := int(wire & 0x7) 12503 if wireType == 4 { 12504 return fmt.Errorf("proto: ResponseListSnapshots: wiretype end group for non-group") 12505 } 12506 if fieldNum <= 0 { 12507 return fmt.Errorf("proto: ResponseListSnapshots: illegal tag %d (wire type %d)", fieldNum, wire) 12508 } 12509 switch fieldNum { 12510 case 1: 12511 if wireType != 2 { 12512 return fmt.Errorf("proto: wrong wireType = %d for field Snapshots", wireType) 12513 } 12514 var msglen int 12515 for shift := uint(0); ; shift += 7 { 12516 if shift >= 64 { 12517 return ErrIntOverflowTypes 12518 } 12519 if iNdEx >= l { 12520 return io.ErrUnexpectedEOF 12521 } 12522 b := dAtA[iNdEx] 12523 iNdEx++ 12524 msglen |= int(b&0x7F) << shift 12525 if b < 0x80 { 12526 break 12527 } 12528 } 12529 if msglen < 0 { 12530 return ErrInvalidLengthTypes 12531 } 12532 postIndex := iNdEx + msglen 12533 if postIndex < 0 { 12534 return ErrInvalidLengthTypes 12535 } 12536 if postIndex > l { 12537 return io.ErrUnexpectedEOF 12538 } 12539 m.Snapshots = append(m.Snapshots, &Snapshot{}) 12540 if err := m.Snapshots[len(m.Snapshots)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12541 return err 12542 } 12543 iNdEx = postIndex 12544 default: 12545 iNdEx = preIndex 12546 skippy, err := skipTypes(dAtA[iNdEx:]) 12547 if err != nil { 12548 return err 12549 } 12550 if (skippy < 0) || (iNdEx+skippy) < 0 { 12551 return ErrInvalidLengthTypes 12552 } 12553 if (iNdEx + skippy) > l { 12554 return io.ErrUnexpectedEOF 12555 } 12556 iNdEx += skippy 12557 } 12558 } 12559 12560 if iNdEx > l { 12561 return io.ErrUnexpectedEOF 12562 } 12563 return nil 12564 } 12565 func (m *ResponseOfferSnapshot) Unmarshal(dAtA []byte) error { 12566 l := len(dAtA) 12567 iNdEx := 0 12568 for iNdEx < l { 12569 preIndex := iNdEx 12570 var wire uint64 12571 for shift := uint(0); ; shift += 7 { 12572 if shift >= 64 { 12573 return ErrIntOverflowTypes 12574 } 12575 if iNdEx >= l { 12576 return io.ErrUnexpectedEOF 12577 } 12578 b := dAtA[iNdEx] 12579 iNdEx++ 12580 wire |= uint64(b&0x7F) << shift 12581 if b < 0x80 { 12582 break 12583 } 12584 } 12585 fieldNum := int32(wire >> 3) 12586 wireType := int(wire & 0x7) 12587 if wireType == 4 { 12588 return fmt.Errorf("proto: ResponseOfferSnapshot: wiretype end group for non-group") 12589 } 12590 if fieldNum <= 0 { 12591 return fmt.Errorf("proto: ResponseOfferSnapshot: illegal tag %d (wire type %d)", fieldNum, wire) 12592 } 12593 switch fieldNum { 12594 case 1: 12595 if wireType != 0 { 12596 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 12597 } 12598 m.Result = 0 12599 for shift := uint(0); ; shift += 7 { 12600 if shift >= 64 { 12601 return ErrIntOverflowTypes 12602 } 12603 if iNdEx >= l { 12604 return io.ErrUnexpectedEOF 12605 } 12606 b := dAtA[iNdEx] 12607 iNdEx++ 12608 m.Result |= ResponseOfferSnapshot_Result(b&0x7F) << shift 12609 if b < 0x80 { 12610 break 12611 } 12612 } 12613 default: 12614 iNdEx = preIndex 12615 skippy, err := skipTypes(dAtA[iNdEx:]) 12616 if err != nil { 12617 return err 12618 } 12619 if (skippy < 0) || (iNdEx+skippy) < 0 { 12620 return ErrInvalidLengthTypes 12621 } 12622 if (iNdEx + skippy) > l { 12623 return io.ErrUnexpectedEOF 12624 } 12625 iNdEx += skippy 12626 } 12627 } 12628 12629 if iNdEx > l { 12630 return io.ErrUnexpectedEOF 12631 } 12632 return nil 12633 } 12634 func (m *ResponseLoadSnapshotChunk) Unmarshal(dAtA []byte) error { 12635 l := len(dAtA) 12636 iNdEx := 0 12637 for iNdEx < l { 12638 preIndex := iNdEx 12639 var wire uint64 12640 for shift := uint(0); ; shift += 7 { 12641 if shift >= 64 { 12642 return ErrIntOverflowTypes 12643 } 12644 if iNdEx >= l { 12645 return io.ErrUnexpectedEOF 12646 } 12647 b := dAtA[iNdEx] 12648 iNdEx++ 12649 wire |= uint64(b&0x7F) << shift 12650 if b < 0x80 { 12651 break 12652 } 12653 } 12654 fieldNum := int32(wire >> 3) 12655 wireType := int(wire & 0x7) 12656 if wireType == 4 { 12657 return fmt.Errorf("proto: ResponseLoadSnapshotChunk: wiretype end group for non-group") 12658 } 12659 if fieldNum <= 0 { 12660 return fmt.Errorf("proto: ResponseLoadSnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) 12661 } 12662 switch fieldNum { 12663 case 1: 12664 if wireType != 2 { 12665 return fmt.Errorf("proto: wrong wireType = %d for field Chunk", wireType) 12666 } 12667 var byteLen int 12668 for shift := uint(0); ; shift += 7 { 12669 if shift >= 64 { 12670 return ErrIntOverflowTypes 12671 } 12672 if iNdEx >= l { 12673 return io.ErrUnexpectedEOF 12674 } 12675 b := dAtA[iNdEx] 12676 iNdEx++ 12677 byteLen |= int(b&0x7F) << shift 12678 if b < 0x80 { 12679 break 12680 } 12681 } 12682 if byteLen < 0 { 12683 return ErrInvalidLengthTypes 12684 } 12685 postIndex := iNdEx + byteLen 12686 if postIndex < 0 { 12687 return ErrInvalidLengthTypes 12688 } 12689 if postIndex > l { 12690 return io.ErrUnexpectedEOF 12691 } 12692 m.Chunk = append(m.Chunk[:0], dAtA[iNdEx:postIndex]...) 12693 if m.Chunk == nil { 12694 m.Chunk = []byte{} 12695 } 12696 iNdEx = postIndex 12697 default: 12698 iNdEx = preIndex 12699 skippy, err := skipTypes(dAtA[iNdEx:]) 12700 if err != nil { 12701 return err 12702 } 12703 if (skippy < 0) || (iNdEx+skippy) < 0 { 12704 return ErrInvalidLengthTypes 12705 } 12706 if (iNdEx + skippy) > l { 12707 return io.ErrUnexpectedEOF 12708 } 12709 iNdEx += skippy 12710 } 12711 } 12712 12713 if iNdEx > l { 12714 return io.ErrUnexpectedEOF 12715 } 12716 return nil 12717 } 12718 func (m *ResponseApplySnapshotChunk) Unmarshal(dAtA []byte) error { 12719 l := len(dAtA) 12720 iNdEx := 0 12721 for iNdEx < l { 12722 preIndex := iNdEx 12723 var wire uint64 12724 for shift := uint(0); ; shift += 7 { 12725 if shift >= 64 { 12726 return ErrIntOverflowTypes 12727 } 12728 if iNdEx >= l { 12729 return io.ErrUnexpectedEOF 12730 } 12731 b := dAtA[iNdEx] 12732 iNdEx++ 12733 wire |= uint64(b&0x7F) << shift 12734 if b < 0x80 { 12735 break 12736 } 12737 } 12738 fieldNum := int32(wire >> 3) 12739 wireType := int(wire & 0x7) 12740 if wireType == 4 { 12741 return fmt.Errorf("proto: ResponseApplySnapshotChunk: wiretype end group for non-group") 12742 } 12743 if fieldNum <= 0 { 12744 return fmt.Errorf("proto: ResponseApplySnapshotChunk: illegal tag %d (wire type %d)", fieldNum, wire) 12745 } 12746 switch fieldNum { 12747 case 1: 12748 if wireType != 0 { 12749 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 12750 } 12751 m.Result = 0 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 m.Result |= ResponseApplySnapshotChunk_Result(b&0x7F) << shift 12762 if b < 0x80 { 12763 break 12764 } 12765 } 12766 case 2: 12767 if wireType == 0 { 12768 var v uint32 12769 for shift := uint(0); ; shift += 7 { 12770 if shift >= 64 { 12771 return ErrIntOverflowTypes 12772 } 12773 if iNdEx >= l { 12774 return io.ErrUnexpectedEOF 12775 } 12776 b := dAtA[iNdEx] 12777 iNdEx++ 12778 v |= uint32(b&0x7F) << shift 12779 if b < 0x80 { 12780 break 12781 } 12782 } 12783 m.RefetchChunks = append(m.RefetchChunks, v) 12784 } else if wireType == 2 { 12785 var packedLen int 12786 for shift := uint(0); ; shift += 7 { 12787 if shift >= 64 { 12788 return ErrIntOverflowTypes 12789 } 12790 if iNdEx >= l { 12791 return io.ErrUnexpectedEOF 12792 } 12793 b := dAtA[iNdEx] 12794 iNdEx++ 12795 packedLen |= int(b&0x7F) << shift 12796 if b < 0x80 { 12797 break 12798 } 12799 } 12800 if packedLen < 0 { 12801 return ErrInvalidLengthTypes 12802 } 12803 postIndex := iNdEx + packedLen 12804 if postIndex < 0 { 12805 return ErrInvalidLengthTypes 12806 } 12807 if postIndex > l { 12808 return io.ErrUnexpectedEOF 12809 } 12810 var elementCount int 12811 var count int 12812 for _, integer := range dAtA[iNdEx:postIndex] { 12813 if integer < 128 { 12814 count++ 12815 } 12816 } 12817 elementCount = count 12818 if elementCount != 0 && len(m.RefetchChunks) == 0 { 12819 m.RefetchChunks = make([]uint32, 0, elementCount) 12820 } 12821 for iNdEx < postIndex { 12822 var v uint32 12823 for shift := uint(0); ; shift += 7 { 12824 if shift >= 64 { 12825 return ErrIntOverflowTypes 12826 } 12827 if iNdEx >= l { 12828 return io.ErrUnexpectedEOF 12829 } 12830 b := dAtA[iNdEx] 12831 iNdEx++ 12832 v |= uint32(b&0x7F) << shift 12833 if b < 0x80 { 12834 break 12835 } 12836 } 12837 m.RefetchChunks = append(m.RefetchChunks, v) 12838 } 12839 } else { 12840 return fmt.Errorf("proto: wrong wireType = %d for field RefetchChunks", wireType) 12841 } 12842 case 3: 12843 if wireType != 2 { 12844 return fmt.Errorf("proto: wrong wireType = %d for field RejectSenders", wireType) 12845 } 12846 var stringLen uint64 12847 for shift := uint(0); ; shift += 7 { 12848 if shift >= 64 { 12849 return ErrIntOverflowTypes 12850 } 12851 if iNdEx >= l { 12852 return io.ErrUnexpectedEOF 12853 } 12854 b := dAtA[iNdEx] 12855 iNdEx++ 12856 stringLen |= uint64(b&0x7F) << shift 12857 if b < 0x80 { 12858 break 12859 } 12860 } 12861 intStringLen := int(stringLen) 12862 if intStringLen < 0 { 12863 return ErrInvalidLengthTypes 12864 } 12865 postIndex := iNdEx + intStringLen 12866 if postIndex < 0 { 12867 return ErrInvalidLengthTypes 12868 } 12869 if postIndex > l { 12870 return io.ErrUnexpectedEOF 12871 } 12872 m.RejectSenders = append(m.RejectSenders, string(dAtA[iNdEx:postIndex])) 12873 iNdEx = postIndex 12874 default: 12875 iNdEx = preIndex 12876 skippy, err := skipTypes(dAtA[iNdEx:]) 12877 if err != nil { 12878 return err 12879 } 12880 if (skippy < 0) || (iNdEx+skippy) < 0 { 12881 return ErrInvalidLengthTypes 12882 } 12883 if (iNdEx + skippy) > l { 12884 return io.ErrUnexpectedEOF 12885 } 12886 iNdEx += skippy 12887 } 12888 } 12889 12890 if iNdEx > l { 12891 return io.ErrUnexpectedEOF 12892 } 12893 return nil 12894 } 12895 func (m *ConsensusParams) Unmarshal(dAtA []byte) error { 12896 l := len(dAtA) 12897 iNdEx := 0 12898 for iNdEx < l { 12899 preIndex := iNdEx 12900 var wire uint64 12901 for shift := uint(0); ; shift += 7 { 12902 if shift >= 64 { 12903 return ErrIntOverflowTypes 12904 } 12905 if iNdEx >= l { 12906 return io.ErrUnexpectedEOF 12907 } 12908 b := dAtA[iNdEx] 12909 iNdEx++ 12910 wire |= uint64(b&0x7F) << shift 12911 if b < 0x80 { 12912 break 12913 } 12914 } 12915 fieldNum := int32(wire >> 3) 12916 wireType := int(wire & 0x7) 12917 if wireType == 4 { 12918 return fmt.Errorf("proto: ConsensusParams: wiretype end group for non-group") 12919 } 12920 if fieldNum <= 0 { 12921 return fmt.Errorf("proto: ConsensusParams: illegal tag %d (wire type %d)", fieldNum, wire) 12922 } 12923 switch fieldNum { 12924 case 1: 12925 if wireType != 2 { 12926 return fmt.Errorf("proto: wrong wireType = %d for field Block", wireType) 12927 } 12928 var msglen int 12929 for shift := uint(0); ; shift += 7 { 12930 if shift >= 64 { 12931 return ErrIntOverflowTypes 12932 } 12933 if iNdEx >= l { 12934 return io.ErrUnexpectedEOF 12935 } 12936 b := dAtA[iNdEx] 12937 iNdEx++ 12938 msglen |= int(b&0x7F) << shift 12939 if b < 0x80 { 12940 break 12941 } 12942 } 12943 if msglen < 0 { 12944 return ErrInvalidLengthTypes 12945 } 12946 postIndex := iNdEx + msglen 12947 if postIndex < 0 { 12948 return ErrInvalidLengthTypes 12949 } 12950 if postIndex > l { 12951 return io.ErrUnexpectedEOF 12952 } 12953 if m.Block == nil { 12954 m.Block = &BlockParams{} 12955 } 12956 if err := m.Block.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12957 return err 12958 } 12959 iNdEx = postIndex 12960 case 2: 12961 if wireType != 2 { 12962 return fmt.Errorf("proto: wrong wireType = %d for field Evidence", wireType) 12963 } 12964 var msglen int 12965 for shift := uint(0); ; shift += 7 { 12966 if shift >= 64 { 12967 return ErrIntOverflowTypes 12968 } 12969 if iNdEx >= l { 12970 return io.ErrUnexpectedEOF 12971 } 12972 b := dAtA[iNdEx] 12973 iNdEx++ 12974 msglen |= int(b&0x7F) << shift 12975 if b < 0x80 { 12976 break 12977 } 12978 } 12979 if msglen < 0 { 12980 return ErrInvalidLengthTypes 12981 } 12982 postIndex := iNdEx + msglen 12983 if postIndex < 0 { 12984 return ErrInvalidLengthTypes 12985 } 12986 if postIndex > l { 12987 return io.ErrUnexpectedEOF 12988 } 12989 if m.Evidence == nil { 12990 m.Evidence = &types1.EvidenceParams{} 12991 } 12992 if err := m.Evidence.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 12993 return err 12994 } 12995 iNdEx = postIndex 12996 case 3: 12997 if wireType != 2 { 12998 return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) 12999 } 13000 var msglen int 13001 for shift := uint(0); ; shift += 7 { 13002 if shift >= 64 { 13003 return ErrIntOverflowTypes 13004 } 13005 if iNdEx >= l { 13006 return io.ErrUnexpectedEOF 13007 } 13008 b := dAtA[iNdEx] 13009 iNdEx++ 13010 msglen |= int(b&0x7F) << shift 13011 if b < 0x80 { 13012 break 13013 } 13014 } 13015 if msglen < 0 { 13016 return ErrInvalidLengthTypes 13017 } 13018 postIndex := iNdEx + msglen 13019 if postIndex < 0 { 13020 return ErrInvalidLengthTypes 13021 } 13022 if postIndex > l { 13023 return io.ErrUnexpectedEOF 13024 } 13025 if m.Validator == nil { 13026 m.Validator = &types1.ValidatorParams{} 13027 } 13028 if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13029 return err 13030 } 13031 iNdEx = postIndex 13032 case 4: 13033 if wireType != 2 { 13034 return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) 13035 } 13036 var msglen int 13037 for shift := uint(0); ; shift += 7 { 13038 if shift >= 64 { 13039 return ErrIntOverflowTypes 13040 } 13041 if iNdEx >= l { 13042 return io.ErrUnexpectedEOF 13043 } 13044 b := dAtA[iNdEx] 13045 iNdEx++ 13046 msglen |= int(b&0x7F) << shift 13047 if b < 0x80 { 13048 break 13049 } 13050 } 13051 if msglen < 0 { 13052 return ErrInvalidLengthTypes 13053 } 13054 postIndex := iNdEx + msglen 13055 if postIndex < 0 { 13056 return ErrInvalidLengthTypes 13057 } 13058 if postIndex > l { 13059 return io.ErrUnexpectedEOF 13060 } 13061 if m.Version == nil { 13062 m.Version = &types1.VersionParams{} 13063 } 13064 if err := m.Version.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13065 return err 13066 } 13067 iNdEx = postIndex 13068 default: 13069 iNdEx = preIndex 13070 skippy, err := skipTypes(dAtA[iNdEx:]) 13071 if err != nil { 13072 return err 13073 } 13074 if (skippy < 0) || (iNdEx+skippy) < 0 { 13075 return ErrInvalidLengthTypes 13076 } 13077 if (iNdEx + skippy) > l { 13078 return io.ErrUnexpectedEOF 13079 } 13080 iNdEx += skippy 13081 } 13082 } 13083 13084 if iNdEx > l { 13085 return io.ErrUnexpectedEOF 13086 } 13087 return nil 13088 } 13089 func (m *BlockParams) Unmarshal(dAtA []byte) error { 13090 l := len(dAtA) 13091 iNdEx := 0 13092 for iNdEx < l { 13093 preIndex := iNdEx 13094 var wire uint64 13095 for shift := uint(0); ; shift += 7 { 13096 if shift >= 64 { 13097 return ErrIntOverflowTypes 13098 } 13099 if iNdEx >= l { 13100 return io.ErrUnexpectedEOF 13101 } 13102 b := dAtA[iNdEx] 13103 iNdEx++ 13104 wire |= uint64(b&0x7F) << shift 13105 if b < 0x80 { 13106 break 13107 } 13108 } 13109 fieldNum := int32(wire >> 3) 13110 wireType := int(wire & 0x7) 13111 if wireType == 4 { 13112 return fmt.Errorf("proto: BlockParams: wiretype end group for non-group") 13113 } 13114 if fieldNum <= 0 { 13115 return fmt.Errorf("proto: BlockParams: illegal tag %d (wire type %d)", fieldNum, wire) 13116 } 13117 switch fieldNum { 13118 case 1: 13119 if wireType != 0 { 13120 return fmt.Errorf("proto: wrong wireType = %d for field MaxBytes", wireType) 13121 } 13122 m.MaxBytes = 0 13123 for shift := uint(0); ; shift += 7 { 13124 if shift >= 64 { 13125 return ErrIntOverflowTypes 13126 } 13127 if iNdEx >= l { 13128 return io.ErrUnexpectedEOF 13129 } 13130 b := dAtA[iNdEx] 13131 iNdEx++ 13132 m.MaxBytes |= int64(b&0x7F) << shift 13133 if b < 0x80 { 13134 break 13135 } 13136 } 13137 case 2: 13138 if wireType != 0 { 13139 return fmt.Errorf("proto: wrong wireType = %d for field MaxGas", wireType) 13140 } 13141 m.MaxGas = 0 13142 for shift := uint(0); ; shift += 7 { 13143 if shift >= 64 { 13144 return ErrIntOverflowTypes 13145 } 13146 if iNdEx >= l { 13147 return io.ErrUnexpectedEOF 13148 } 13149 b := dAtA[iNdEx] 13150 iNdEx++ 13151 m.MaxGas |= int64(b&0x7F) << shift 13152 if b < 0x80 { 13153 break 13154 } 13155 } 13156 default: 13157 iNdEx = preIndex 13158 skippy, err := skipTypes(dAtA[iNdEx:]) 13159 if err != nil { 13160 return err 13161 } 13162 if (skippy < 0) || (iNdEx+skippy) < 0 { 13163 return ErrInvalidLengthTypes 13164 } 13165 if (iNdEx + skippy) > l { 13166 return io.ErrUnexpectedEOF 13167 } 13168 iNdEx += skippy 13169 } 13170 } 13171 13172 if iNdEx > l { 13173 return io.ErrUnexpectedEOF 13174 } 13175 return nil 13176 } 13177 func (m *LastCommitInfo) Unmarshal(dAtA []byte) error { 13178 l := len(dAtA) 13179 iNdEx := 0 13180 for iNdEx < l { 13181 preIndex := iNdEx 13182 var wire uint64 13183 for shift := uint(0); ; shift += 7 { 13184 if shift >= 64 { 13185 return ErrIntOverflowTypes 13186 } 13187 if iNdEx >= l { 13188 return io.ErrUnexpectedEOF 13189 } 13190 b := dAtA[iNdEx] 13191 iNdEx++ 13192 wire |= uint64(b&0x7F) << shift 13193 if b < 0x80 { 13194 break 13195 } 13196 } 13197 fieldNum := int32(wire >> 3) 13198 wireType := int(wire & 0x7) 13199 if wireType == 4 { 13200 return fmt.Errorf("proto: LastCommitInfo: wiretype end group for non-group") 13201 } 13202 if fieldNum <= 0 { 13203 return fmt.Errorf("proto: LastCommitInfo: illegal tag %d (wire type %d)", fieldNum, wire) 13204 } 13205 switch fieldNum { 13206 case 1: 13207 if wireType != 0 { 13208 return fmt.Errorf("proto: wrong wireType = %d for field Round", wireType) 13209 } 13210 m.Round = 0 13211 for shift := uint(0); ; shift += 7 { 13212 if shift >= 64 { 13213 return ErrIntOverflowTypes 13214 } 13215 if iNdEx >= l { 13216 return io.ErrUnexpectedEOF 13217 } 13218 b := dAtA[iNdEx] 13219 iNdEx++ 13220 m.Round |= int32(b&0x7F) << shift 13221 if b < 0x80 { 13222 break 13223 } 13224 } 13225 case 2: 13226 if wireType != 2 { 13227 return fmt.Errorf("proto: wrong wireType = %d for field Votes", wireType) 13228 } 13229 var msglen int 13230 for shift := uint(0); ; shift += 7 { 13231 if shift >= 64 { 13232 return ErrIntOverflowTypes 13233 } 13234 if iNdEx >= l { 13235 return io.ErrUnexpectedEOF 13236 } 13237 b := dAtA[iNdEx] 13238 iNdEx++ 13239 msglen |= int(b&0x7F) << shift 13240 if b < 0x80 { 13241 break 13242 } 13243 } 13244 if msglen < 0 { 13245 return ErrInvalidLengthTypes 13246 } 13247 postIndex := iNdEx + msglen 13248 if postIndex < 0 { 13249 return ErrInvalidLengthTypes 13250 } 13251 if postIndex > l { 13252 return io.ErrUnexpectedEOF 13253 } 13254 m.Votes = append(m.Votes, VoteInfo{}) 13255 if err := m.Votes[len(m.Votes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13256 return err 13257 } 13258 iNdEx = postIndex 13259 default: 13260 iNdEx = preIndex 13261 skippy, err := skipTypes(dAtA[iNdEx:]) 13262 if err != nil { 13263 return err 13264 } 13265 if (skippy < 0) || (iNdEx+skippy) < 0 { 13266 return ErrInvalidLengthTypes 13267 } 13268 if (iNdEx + skippy) > l { 13269 return io.ErrUnexpectedEOF 13270 } 13271 iNdEx += skippy 13272 } 13273 } 13274 13275 if iNdEx > l { 13276 return io.ErrUnexpectedEOF 13277 } 13278 return nil 13279 } 13280 func (m *Event) Unmarshal(dAtA []byte) error { 13281 l := len(dAtA) 13282 iNdEx := 0 13283 for iNdEx < l { 13284 preIndex := iNdEx 13285 var wire uint64 13286 for shift := uint(0); ; shift += 7 { 13287 if shift >= 64 { 13288 return ErrIntOverflowTypes 13289 } 13290 if iNdEx >= l { 13291 return io.ErrUnexpectedEOF 13292 } 13293 b := dAtA[iNdEx] 13294 iNdEx++ 13295 wire |= uint64(b&0x7F) << shift 13296 if b < 0x80 { 13297 break 13298 } 13299 } 13300 fieldNum := int32(wire >> 3) 13301 wireType := int(wire & 0x7) 13302 if wireType == 4 { 13303 return fmt.Errorf("proto: Event: wiretype end group for non-group") 13304 } 13305 if fieldNum <= 0 { 13306 return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire) 13307 } 13308 switch fieldNum { 13309 case 1: 13310 if wireType != 2 { 13311 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 13312 } 13313 var stringLen uint64 13314 for shift := uint(0); ; shift += 7 { 13315 if shift >= 64 { 13316 return ErrIntOverflowTypes 13317 } 13318 if iNdEx >= l { 13319 return io.ErrUnexpectedEOF 13320 } 13321 b := dAtA[iNdEx] 13322 iNdEx++ 13323 stringLen |= uint64(b&0x7F) << shift 13324 if b < 0x80 { 13325 break 13326 } 13327 } 13328 intStringLen := int(stringLen) 13329 if intStringLen < 0 { 13330 return ErrInvalidLengthTypes 13331 } 13332 postIndex := iNdEx + intStringLen 13333 if postIndex < 0 { 13334 return ErrInvalidLengthTypes 13335 } 13336 if postIndex > l { 13337 return io.ErrUnexpectedEOF 13338 } 13339 m.Type = string(dAtA[iNdEx:postIndex]) 13340 iNdEx = postIndex 13341 case 2: 13342 if wireType != 2 { 13343 return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) 13344 } 13345 var msglen int 13346 for shift := uint(0); ; shift += 7 { 13347 if shift >= 64 { 13348 return ErrIntOverflowTypes 13349 } 13350 if iNdEx >= l { 13351 return io.ErrUnexpectedEOF 13352 } 13353 b := dAtA[iNdEx] 13354 iNdEx++ 13355 msglen |= int(b&0x7F) << shift 13356 if b < 0x80 { 13357 break 13358 } 13359 } 13360 if msglen < 0 { 13361 return ErrInvalidLengthTypes 13362 } 13363 postIndex := iNdEx + msglen 13364 if postIndex < 0 { 13365 return ErrInvalidLengthTypes 13366 } 13367 if postIndex > l { 13368 return io.ErrUnexpectedEOF 13369 } 13370 m.Attributes = append(m.Attributes, EventAttribute{}) 13371 if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13372 return err 13373 } 13374 iNdEx = postIndex 13375 default: 13376 iNdEx = preIndex 13377 skippy, err := skipTypes(dAtA[iNdEx:]) 13378 if err != nil { 13379 return err 13380 } 13381 if (skippy < 0) || (iNdEx+skippy) < 0 { 13382 return ErrInvalidLengthTypes 13383 } 13384 if (iNdEx + skippy) > l { 13385 return io.ErrUnexpectedEOF 13386 } 13387 iNdEx += skippy 13388 } 13389 } 13390 13391 if iNdEx > l { 13392 return io.ErrUnexpectedEOF 13393 } 13394 return nil 13395 } 13396 func (m *EventAttribute) Unmarshal(dAtA []byte) error { 13397 l := len(dAtA) 13398 iNdEx := 0 13399 for iNdEx < l { 13400 preIndex := iNdEx 13401 var wire uint64 13402 for shift := uint(0); ; shift += 7 { 13403 if shift >= 64 { 13404 return ErrIntOverflowTypes 13405 } 13406 if iNdEx >= l { 13407 return io.ErrUnexpectedEOF 13408 } 13409 b := dAtA[iNdEx] 13410 iNdEx++ 13411 wire |= uint64(b&0x7F) << shift 13412 if b < 0x80 { 13413 break 13414 } 13415 } 13416 fieldNum := int32(wire >> 3) 13417 wireType := int(wire & 0x7) 13418 if wireType == 4 { 13419 return fmt.Errorf("proto: EventAttribute: wiretype end group for non-group") 13420 } 13421 if fieldNum <= 0 { 13422 return fmt.Errorf("proto: EventAttribute: illegal tag %d (wire type %d)", fieldNum, wire) 13423 } 13424 switch fieldNum { 13425 case 1: 13426 if wireType != 2 { 13427 return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) 13428 } 13429 var byteLen int 13430 for shift := uint(0); ; shift += 7 { 13431 if shift >= 64 { 13432 return ErrIntOverflowTypes 13433 } 13434 if iNdEx >= l { 13435 return io.ErrUnexpectedEOF 13436 } 13437 b := dAtA[iNdEx] 13438 iNdEx++ 13439 byteLen |= int(b&0x7F) << shift 13440 if b < 0x80 { 13441 break 13442 } 13443 } 13444 if byteLen < 0 { 13445 return ErrInvalidLengthTypes 13446 } 13447 postIndex := iNdEx + byteLen 13448 if postIndex < 0 { 13449 return ErrInvalidLengthTypes 13450 } 13451 if postIndex > l { 13452 return io.ErrUnexpectedEOF 13453 } 13454 m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...) 13455 if m.Key == nil { 13456 m.Key = []byte{} 13457 } 13458 iNdEx = postIndex 13459 case 2: 13460 if wireType != 2 { 13461 return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) 13462 } 13463 var byteLen int 13464 for shift := uint(0); ; shift += 7 { 13465 if shift >= 64 { 13466 return ErrIntOverflowTypes 13467 } 13468 if iNdEx >= l { 13469 return io.ErrUnexpectedEOF 13470 } 13471 b := dAtA[iNdEx] 13472 iNdEx++ 13473 byteLen |= int(b&0x7F) << shift 13474 if b < 0x80 { 13475 break 13476 } 13477 } 13478 if byteLen < 0 { 13479 return ErrInvalidLengthTypes 13480 } 13481 postIndex := iNdEx + byteLen 13482 if postIndex < 0 { 13483 return ErrInvalidLengthTypes 13484 } 13485 if postIndex > l { 13486 return io.ErrUnexpectedEOF 13487 } 13488 m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...) 13489 if m.Value == nil { 13490 m.Value = []byte{} 13491 } 13492 iNdEx = postIndex 13493 case 3: 13494 if wireType != 0 { 13495 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 13496 } 13497 var v int 13498 for shift := uint(0); ; shift += 7 { 13499 if shift >= 64 { 13500 return ErrIntOverflowTypes 13501 } 13502 if iNdEx >= l { 13503 return io.ErrUnexpectedEOF 13504 } 13505 b := dAtA[iNdEx] 13506 iNdEx++ 13507 v |= int(b&0x7F) << shift 13508 if b < 0x80 { 13509 break 13510 } 13511 } 13512 m.Index = bool(v != 0) 13513 default: 13514 iNdEx = preIndex 13515 skippy, err := skipTypes(dAtA[iNdEx:]) 13516 if err != nil { 13517 return err 13518 } 13519 if (skippy < 0) || (iNdEx+skippy) < 0 { 13520 return ErrInvalidLengthTypes 13521 } 13522 if (iNdEx + skippy) > l { 13523 return io.ErrUnexpectedEOF 13524 } 13525 iNdEx += skippy 13526 } 13527 } 13528 13529 if iNdEx > l { 13530 return io.ErrUnexpectedEOF 13531 } 13532 return nil 13533 } 13534 func (m *TxResult) Unmarshal(dAtA []byte) error { 13535 l := len(dAtA) 13536 iNdEx := 0 13537 for iNdEx < l { 13538 preIndex := iNdEx 13539 var wire uint64 13540 for shift := uint(0); ; shift += 7 { 13541 if shift >= 64 { 13542 return ErrIntOverflowTypes 13543 } 13544 if iNdEx >= l { 13545 return io.ErrUnexpectedEOF 13546 } 13547 b := dAtA[iNdEx] 13548 iNdEx++ 13549 wire |= uint64(b&0x7F) << shift 13550 if b < 0x80 { 13551 break 13552 } 13553 } 13554 fieldNum := int32(wire >> 3) 13555 wireType := int(wire & 0x7) 13556 if wireType == 4 { 13557 return fmt.Errorf("proto: TxResult: wiretype end group for non-group") 13558 } 13559 if fieldNum <= 0 { 13560 return fmt.Errorf("proto: TxResult: illegal tag %d (wire type %d)", fieldNum, wire) 13561 } 13562 switch fieldNum { 13563 case 1: 13564 if wireType != 0 { 13565 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 13566 } 13567 m.Height = 0 13568 for shift := uint(0); ; shift += 7 { 13569 if shift >= 64 { 13570 return ErrIntOverflowTypes 13571 } 13572 if iNdEx >= l { 13573 return io.ErrUnexpectedEOF 13574 } 13575 b := dAtA[iNdEx] 13576 iNdEx++ 13577 m.Height |= int64(b&0x7F) << shift 13578 if b < 0x80 { 13579 break 13580 } 13581 } 13582 case 2: 13583 if wireType != 0 { 13584 return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType) 13585 } 13586 m.Index = 0 13587 for shift := uint(0); ; shift += 7 { 13588 if shift >= 64 { 13589 return ErrIntOverflowTypes 13590 } 13591 if iNdEx >= l { 13592 return io.ErrUnexpectedEOF 13593 } 13594 b := dAtA[iNdEx] 13595 iNdEx++ 13596 m.Index |= uint32(b&0x7F) << shift 13597 if b < 0x80 { 13598 break 13599 } 13600 } 13601 case 3: 13602 if wireType != 2 { 13603 return fmt.Errorf("proto: wrong wireType = %d for field Tx", wireType) 13604 } 13605 var byteLen int 13606 for shift := uint(0); ; shift += 7 { 13607 if shift >= 64 { 13608 return ErrIntOverflowTypes 13609 } 13610 if iNdEx >= l { 13611 return io.ErrUnexpectedEOF 13612 } 13613 b := dAtA[iNdEx] 13614 iNdEx++ 13615 byteLen |= int(b&0x7F) << shift 13616 if b < 0x80 { 13617 break 13618 } 13619 } 13620 if byteLen < 0 { 13621 return ErrInvalidLengthTypes 13622 } 13623 postIndex := iNdEx + byteLen 13624 if postIndex < 0 { 13625 return ErrInvalidLengthTypes 13626 } 13627 if postIndex > l { 13628 return io.ErrUnexpectedEOF 13629 } 13630 m.Tx = append(m.Tx[:0], dAtA[iNdEx:postIndex]...) 13631 if m.Tx == nil { 13632 m.Tx = []byte{} 13633 } 13634 iNdEx = postIndex 13635 case 4: 13636 if wireType != 2 { 13637 return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType) 13638 } 13639 var msglen int 13640 for shift := uint(0); ; shift += 7 { 13641 if shift >= 64 { 13642 return ErrIntOverflowTypes 13643 } 13644 if iNdEx >= l { 13645 return io.ErrUnexpectedEOF 13646 } 13647 b := dAtA[iNdEx] 13648 iNdEx++ 13649 msglen |= int(b&0x7F) << shift 13650 if b < 0x80 { 13651 break 13652 } 13653 } 13654 if msglen < 0 { 13655 return ErrInvalidLengthTypes 13656 } 13657 postIndex := iNdEx + msglen 13658 if postIndex < 0 { 13659 return ErrInvalidLengthTypes 13660 } 13661 if postIndex > l { 13662 return io.ErrUnexpectedEOF 13663 } 13664 if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13665 return err 13666 } 13667 iNdEx = postIndex 13668 default: 13669 iNdEx = preIndex 13670 skippy, err := skipTypes(dAtA[iNdEx:]) 13671 if err != nil { 13672 return err 13673 } 13674 if (skippy < 0) || (iNdEx+skippy) < 0 { 13675 return ErrInvalidLengthTypes 13676 } 13677 if (iNdEx + skippy) > l { 13678 return io.ErrUnexpectedEOF 13679 } 13680 iNdEx += skippy 13681 } 13682 } 13683 13684 if iNdEx > l { 13685 return io.ErrUnexpectedEOF 13686 } 13687 return nil 13688 } 13689 func (m *Validator) Unmarshal(dAtA []byte) error { 13690 l := len(dAtA) 13691 iNdEx := 0 13692 for iNdEx < l { 13693 preIndex := iNdEx 13694 var wire uint64 13695 for shift := uint(0); ; shift += 7 { 13696 if shift >= 64 { 13697 return ErrIntOverflowTypes 13698 } 13699 if iNdEx >= l { 13700 return io.ErrUnexpectedEOF 13701 } 13702 b := dAtA[iNdEx] 13703 iNdEx++ 13704 wire |= uint64(b&0x7F) << shift 13705 if b < 0x80 { 13706 break 13707 } 13708 } 13709 fieldNum := int32(wire >> 3) 13710 wireType := int(wire & 0x7) 13711 if wireType == 4 { 13712 return fmt.Errorf("proto: Validator: wiretype end group for non-group") 13713 } 13714 if fieldNum <= 0 { 13715 return fmt.Errorf("proto: Validator: illegal tag %d (wire type %d)", fieldNum, wire) 13716 } 13717 switch fieldNum { 13718 case 1: 13719 if wireType != 2 { 13720 return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType) 13721 } 13722 var byteLen int 13723 for shift := uint(0); ; shift += 7 { 13724 if shift >= 64 { 13725 return ErrIntOverflowTypes 13726 } 13727 if iNdEx >= l { 13728 return io.ErrUnexpectedEOF 13729 } 13730 b := dAtA[iNdEx] 13731 iNdEx++ 13732 byteLen |= int(b&0x7F) << shift 13733 if b < 0x80 { 13734 break 13735 } 13736 } 13737 if byteLen < 0 { 13738 return ErrInvalidLengthTypes 13739 } 13740 postIndex := iNdEx + byteLen 13741 if postIndex < 0 { 13742 return ErrInvalidLengthTypes 13743 } 13744 if postIndex > l { 13745 return io.ErrUnexpectedEOF 13746 } 13747 m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...) 13748 if m.Address == nil { 13749 m.Address = []byte{} 13750 } 13751 iNdEx = postIndex 13752 case 3: 13753 if wireType != 0 { 13754 return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) 13755 } 13756 m.Power = 0 13757 for shift := uint(0); ; shift += 7 { 13758 if shift >= 64 { 13759 return ErrIntOverflowTypes 13760 } 13761 if iNdEx >= l { 13762 return io.ErrUnexpectedEOF 13763 } 13764 b := dAtA[iNdEx] 13765 iNdEx++ 13766 m.Power |= int64(b&0x7F) << shift 13767 if b < 0x80 { 13768 break 13769 } 13770 } 13771 default: 13772 iNdEx = preIndex 13773 skippy, err := skipTypes(dAtA[iNdEx:]) 13774 if err != nil { 13775 return err 13776 } 13777 if (skippy < 0) || (iNdEx+skippy) < 0 { 13778 return ErrInvalidLengthTypes 13779 } 13780 if (iNdEx + skippy) > l { 13781 return io.ErrUnexpectedEOF 13782 } 13783 iNdEx += skippy 13784 } 13785 } 13786 13787 if iNdEx > l { 13788 return io.ErrUnexpectedEOF 13789 } 13790 return nil 13791 } 13792 func (m *ValidatorUpdate) Unmarshal(dAtA []byte) error { 13793 l := len(dAtA) 13794 iNdEx := 0 13795 for iNdEx < l { 13796 preIndex := iNdEx 13797 var wire uint64 13798 for shift := uint(0); ; shift += 7 { 13799 if shift >= 64 { 13800 return ErrIntOverflowTypes 13801 } 13802 if iNdEx >= l { 13803 return io.ErrUnexpectedEOF 13804 } 13805 b := dAtA[iNdEx] 13806 iNdEx++ 13807 wire |= uint64(b&0x7F) << shift 13808 if b < 0x80 { 13809 break 13810 } 13811 } 13812 fieldNum := int32(wire >> 3) 13813 wireType := int(wire & 0x7) 13814 if wireType == 4 { 13815 return fmt.Errorf("proto: ValidatorUpdate: wiretype end group for non-group") 13816 } 13817 if fieldNum <= 0 { 13818 return fmt.Errorf("proto: ValidatorUpdate: illegal tag %d (wire type %d)", fieldNum, wire) 13819 } 13820 switch fieldNum { 13821 case 1: 13822 if wireType != 2 { 13823 return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType) 13824 } 13825 var msglen int 13826 for shift := uint(0); ; shift += 7 { 13827 if shift >= 64 { 13828 return ErrIntOverflowTypes 13829 } 13830 if iNdEx >= l { 13831 return io.ErrUnexpectedEOF 13832 } 13833 b := dAtA[iNdEx] 13834 iNdEx++ 13835 msglen |= int(b&0x7F) << shift 13836 if b < 0x80 { 13837 break 13838 } 13839 } 13840 if msglen < 0 { 13841 return ErrInvalidLengthTypes 13842 } 13843 postIndex := iNdEx + msglen 13844 if postIndex < 0 { 13845 return ErrInvalidLengthTypes 13846 } 13847 if postIndex > l { 13848 return io.ErrUnexpectedEOF 13849 } 13850 if err := m.PubKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13851 return err 13852 } 13853 iNdEx = postIndex 13854 case 2: 13855 if wireType != 0 { 13856 return fmt.Errorf("proto: wrong wireType = %d for field Power", wireType) 13857 } 13858 m.Power = 0 13859 for shift := uint(0); ; shift += 7 { 13860 if shift >= 64 { 13861 return ErrIntOverflowTypes 13862 } 13863 if iNdEx >= l { 13864 return io.ErrUnexpectedEOF 13865 } 13866 b := dAtA[iNdEx] 13867 iNdEx++ 13868 m.Power |= int64(b&0x7F) << shift 13869 if b < 0x80 { 13870 break 13871 } 13872 } 13873 default: 13874 iNdEx = preIndex 13875 skippy, err := skipTypes(dAtA[iNdEx:]) 13876 if err != nil { 13877 return err 13878 } 13879 if (skippy < 0) || (iNdEx+skippy) < 0 { 13880 return ErrInvalidLengthTypes 13881 } 13882 if (iNdEx + skippy) > l { 13883 return io.ErrUnexpectedEOF 13884 } 13885 iNdEx += skippy 13886 } 13887 } 13888 13889 if iNdEx > l { 13890 return io.ErrUnexpectedEOF 13891 } 13892 return nil 13893 } 13894 func (m *VoteInfo) Unmarshal(dAtA []byte) error { 13895 l := len(dAtA) 13896 iNdEx := 0 13897 for iNdEx < l { 13898 preIndex := iNdEx 13899 var wire uint64 13900 for shift := uint(0); ; shift += 7 { 13901 if shift >= 64 { 13902 return ErrIntOverflowTypes 13903 } 13904 if iNdEx >= l { 13905 return io.ErrUnexpectedEOF 13906 } 13907 b := dAtA[iNdEx] 13908 iNdEx++ 13909 wire |= uint64(b&0x7F) << shift 13910 if b < 0x80 { 13911 break 13912 } 13913 } 13914 fieldNum := int32(wire >> 3) 13915 wireType := int(wire & 0x7) 13916 if wireType == 4 { 13917 return fmt.Errorf("proto: VoteInfo: wiretype end group for non-group") 13918 } 13919 if fieldNum <= 0 { 13920 return fmt.Errorf("proto: VoteInfo: illegal tag %d (wire type %d)", fieldNum, wire) 13921 } 13922 switch fieldNum { 13923 case 1: 13924 if wireType != 2 { 13925 return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) 13926 } 13927 var msglen int 13928 for shift := uint(0); ; shift += 7 { 13929 if shift >= 64 { 13930 return ErrIntOverflowTypes 13931 } 13932 if iNdEx >= l { 13933 return io.ErrUnexpectedEOF 13934 } 13935 b := dAtA[iNdEx] 13936 iNdEx++ 13937 msglen |= int(b&0x7F) << shift 13938 if b < 0x80 { 13939 break 13940 } 13941 } 13942 if msglen < 0 { 13943 return ErrInvalidLengthTypes 13944 } 13945 postIndex := iNdEx + msglen 13946 if postIndex < 0 { 13947 return ErrInvalidLengthTypes 13948 } 13949 if postIndex > l { 13950 return io.ErrUnexpectedEOF 13951 } 13952 if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 13953 return err 13954 } 13955 iNdEx = postIndex 13956 case 2: 13957 if wireType != 0 { 13958 return fmt.Errorf("proto: wrong wireType = %d for field SignedLastBlock", wireType) 13959 } 13960 var v int 13961 for shift := uint(0); ; shift += 7 { 13962 if shift >= 64 { 13963 return ErrIntOverflowTypes 13964 } 13965 if iNdEx >= l { 13966 return io.ErrUnexpectedEOF 13967 } 13968 b := dAtA[iNdEx] 13969 iNdEx++ 13970 v |= int(b&0x7F) << shift 13971 if b < 0x80 { 13972 break 13973 } 13974 } 13975 m.SignedLastBlock = bool(v != 0) 13976 default: 13977 iNdEx = preIndex 13978 skippy, err := skipTypes(dAtA[iNdEx:]) 13979 if err != nil { 13980 return err 13981 } 13982 if (skippy < 0) || (iNdEx+skippy) < 0 { 13983 return ErrInvalidLengthTypes 13984 } 13985 if (iNdEx + skippy) > l { 13986 return io.ErrUnexpectedEOF 13987 } 13988 iNdEx += skippy 13989 } 13990 } 13991 13992 if iNdEx > l { 13993 return io.ErrUnexpectedEOF 13994 } 13995 return nil 13996 } 13997 func (m *Evidence) Unmarshal(dAtA []byte) error { 13998 l := len(dAtA) 13999 iNdEx := 0 14000 for iNdEx < l { 14001 preIndex := iNdEx 14002 var wire uint64 14003 for shift := uint(0); ; shift += 7 { 14004 if shift >= 64 { 14005 return ErrIntOverflowTypes 14006 } 14007 if iNdEx >= l { 14008 return io.ErrUnexpectedEOF 14009 } 14010 b := dAtA[iNdEx] 14011 iNdEx++ 14012 wire |= uint64(b&0x7F) << shift 14013 if b < 0x80 { 14014 break 14015 } 14016 } 14017 fieldNum := int32(wire >> 3) 14018 wireType := int(wire & 0x7) 14019 if wireType == 4 { 14020 return fmt.Errorf("proto: Evidence: wiretype end group for non-group") 14021 } 14022 if fieldNum <= 0 { 14023 return fmt.Errorf("proto: Evidence: illegal tag %d (wire type %d)", fieldNum, wire) 14024 } 14025 switch fieldNum { 14026 case 1: 14027 if wireType != 0 { 14028 return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) 14029 } 14030 m.Type = 0 14031 for shift := uint(0); ; shift += 7 { 14032 if shift >= 64 { 14033 return ErrIntOverflowTypes 14034 } 14035 if iNdEx >= l { 14036 return io.ErrUnexpectedEOF 14037 } 14038 b := dAtA[iNdEx] 14039 iNdEx++ 14040 m.Type |= EvidenceType(b&0x7F) << shift 14041 if b < 0x80 { 14042 break 14043 } 14044 } 14045 case 2: 14046 if wireType != 2 { 14047 return fmt.Errorf("proto: wrong wireType = %d for field Validator", wireType) 14048 } 14049 var msglen int 14050 for shift := uint(0); ; shift += 7 { 14051 if shift >= 64 { 14052 return ErrIntOverflowTypes 14053 } 14054 if iNdEx >= l { 14055 return io.ErrUnexpectedEOF 14056 } 14057 b := dAtA[iNdEx] 14058 iNdEx++ 14059 msglen |= int(b&0x7F) << shift 14060 if b < 0x80 { 14061 break 14062 } 14063 } 14064 if msglen < 0 { 14065 return ErrInvalidLengthTypes 14066 } 14067 postIndex := iNdEx + msglen 14068 if postIndex < 0 { 14069 return ErrInvalidLengthTypes 14070 } 14071 if postIndex > l { 14072 return io.ErrUnexpectedEOF 14073 } 14074 if err := m.Validator.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 14075 return err 14076 } 14077 iNdEx = postIndex 14078 case 3: 14079 if wireType != 0 { 14080 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 14081 } 14082 m.Height = 0 14083 for shift := uint(0); ; shift += 7 { 14084 if shift >= 64 { 14085 return ErrIntOverflowTypes 14086 } 14087 if iNdEx >= l { 14088 return io.ErrUnexpectedEOF 14089 } 14090 b := dAtA[iNdEx] 14091 iNdEx++ 14092 m.Height |= int64(b&0x7F) << shift 14093 if b < 0x80 { 14094 break 14095 } 14096 } 14097 case 4: 14098 if wireType != 2 { 14099 return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType) 14100 } 14101 var msglen int 14102 for shift := uint(0); ; shift += 7 { 14103 if shift >= 64 { 14104 return ErrIntOverflowTypes 14105 } 14106 if iNdEx >= l { 14107 return io.ErrUnexpectedEOF 14108 } 14109 b := dAtA[iNdEx] 14110 iNdEx++ 14111 msglen |= int(b&0x7F) << shift 14112 if b < 0x80 { 14113 break 14114 } 14115 } 14116 if msglen < 0 { 14117 return ErrInvalidLengthTypes 14118 } 14119 postIndex := iNdEx + msglen 14120 if postIndex < 0 { 14121 return ErrInvalidLengthTypes 14122 } 14123 if postIndex > l { 14124 return io.ErrUnexpectedEOF 14125 } 14126 if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil { 14127 return err 14128 } 14129 iNdEx = postIndex 14130 case 5: 14131 if wireType != 0 { 14132 return fmt.Errorf("proto: wrong wireType = %d for field TotalVotingPower", wireType) 14133 } 14134 m.TotalVotingPower = 0 14135 for shift := uint(0); ; shift += 7 { 14136 if shift >= 64 { 14137 return ErrIntOverflowTypes 14138 } 14139 if iNdEx >= l { 14140 return io.ErrUnexpectedEOF 14141 } 14142 b := dAtA[iNdEx] 14143 iNdEx++ 14144 m.TotalVotingPower |= int64(b&0x7F) << shift 14145 if b < 0x80 { 14146 break 14147 } 14148 } 14149 default: 14150 iNdEx = preIndex 14151 skippy, err := skipTypes(dAtA[iNdEx:]) 14152 if err != nil { 14153 return err 14154 } 14155 if (skippy < 0) || (iNdEx+skippy) < 0 { 14156 return ErrInvalidLengthTypes 14157 } 14158 if (iNdEx + skippy) > l { 14159 return io.ErrUnexpectedEOF 14160 } 14161 iNdEx += skippy 14162 } 14163 } 14164 14165 if iNdEx > l { 14166 return io.ErrUnexpectedEOF 14167 } 14168 return nil 14169 } 14170 func (m *Snapshot) Unmarshal(dAtA []byte) error { 14171 l := len(dAtA) 14172 iNdEx := 0 14173 for iNdEx < l { 14174 preIndex := iNdEx 14175 var wire uint64 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 wire |= uint64(b&0x7F) << shift 14186 if b < 0x80 { 14187 break 14188 } 14189 } 14190 fieldNum := int32(wire >> 3) 14191 wireType := int(wire & 0x7) 14192 if wireType == 4 { 14193 return fmt.Errorf("proto: Snapshot: wiretype end group for non-group") 14194 } 14195 if fieldNum <= 0 { 14196 return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire) 14197 } 14198 switch fieldNum { 14199 case 1: 14200 if wireType != 0 { 14201 return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType) 14202 } 14203 m.Height = 0 14204 for shift := uint(0); ; shift += 7 { 14205 if shift >= 64 { 14206 return ErrIntOverflowTypes 14207 } 14208 if iNdEx >= l { 14209 return io.ErrUnexpectedEOF 14210 } 14211 b := dAtA[iNdEx] 14212 iNdEx++ 14213 m.Height |= uint64(b&0x7F) << shift 14214 if b < 0x80 { 14215 break 14216 } 14217 } 14218 case 2: 14219 if wireType != 0 { 14220 return fmt.Errorf("proto: wrong wireType = %d for field Format", wireType) 14221 } 14222 m.Format = 0 14223 for shift := uint(0); ; shift += 7 { 14224 if shift >= 64 { 14225 return ErrIntOverflowTypes 14226 } 14227 if iNdEx >= l { 14228 return io.ErrUnexpectedEOF 14229 } 14230 b := dAtA[iNdEx] 14231 iNdEx++ 14232 m.Format |= uint32(b&0x7F) << shift 14233 if b < 0x80 { 14234 break 14235 } 14236 } 14237 case 3: 14238 if wireType != 0 { 14239 return fmt.Errorf("proto: wrong wireType = %d for field Chunks", wireType) 14240 } 14241 m.Chunks = 0 14242 for shift := uint(0); ; shift += 7 { 14243 if shift >= 64 { 14244 return ErrIntOverflowTypes 14245 } 14246 if iNdEx >= l { 14247 return io.ErrUnexpectedEOF 14248 } 14249 b := dAtA[iNdEx] 14250 iNdEx++ 14251 m.Chunks |= uint32(b&0x7F) << shift 14252 if b < 0x80 { 14253 break 14254 } 14255 } 14256 case 4: 14257 if wireType != 2 { 14258 return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType) 14259 } 14260 var byteLen int 14261 for shift := uint(0); ; shift += 7 { 14262 if shift >= 64 { 14263 return ErrIntOverflowTypes 14264 } 14265 if iNdEx >= l { 14266 return io.ErrUnexpectedEOF 14267 } 14268 b := dAtA[iNdEx] 14269 iNdEx++ 14270 byteLen |= int(b&0x7F) << shift 14271 if b < 0x80 { 14272 break 14273 } 14274 } 14275 if byteLen < 0 { 14276 return ErrInvalidLengthTypes 14277 } 14278 postIndex := iNdEx + byteLen 14279 if postIndex < 0 { 14280 return ErrInvalidLengthTypes 14281 } 14282 if postIndex > l { 14283 return io.ErrUnexpectedEOF 14284 } 14285 m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...) 14286 if m.Hash == nil { 14287 m.Hash = []byte{} 14288 } 14289 iNdEx = postIndex 14290 case 5: 14291 if wireType != 2 { 14292 return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) 14293 } 14294 var byteLen int 14295 for shift := uint(0); ; shift += 7 { 14296 if shift >= 64 { 14297 return ErrIntOverflowTypes 14298 } 14299 if iNdEx >= l { 14300 return io.ErrUnexpectedEOF 14301 } 14302 b := dAtA[iNdEx] 14303 iNdEx++ 14304 byteLen |= int(b&0x7F) << shift 14305 if b < 0x80 { 14306 break 14307 } 14308 } 14309 if byteLen < 0 { 14310 return ErrInvalidLengthTypes 14311 } 14312 postIndex := iNdEx + byteLen 14313 if postIndex < 0 { 14314 return ErrInvalidLengthTypes 14315 } 14316 if postIndex > l { 14317 return io.ErrUnexpectedEOF 14318 } 14319 m.Metadata = append(m.Metadata[:0], dAtA[iNdEx:postIndex]...) 14320 if m.Metadata == nil { 14321 m.Metadata = []byte{} 14322 } 14323 iNdEx = postIndex 14324 default: 14325 iNdEx = preIndex 14326 skippy, err := skipTypes(dAtA[iNdEx:]) 14327 if err != nil { 14328 return err 14329 } 14330 if (skippy < 0) || (iNdEx+skippy) < 0 { 14331 return ErrInvalidLengthTypes 14332 } 14333 if (iNdEx + skippy) > l { 14334 return io.ErrUnexpectedEOF 14335 } 14336 iNdEx += skippy 14337 } 14338 } 14339 14340 if iNdEx > l { 14341 return io.ErrUnexpectedEOF 14342 } 14343 return nil 14344 } 14345 func skipTypes(dAtA []byte) (n int, err error) { 14346 l := len(dAtA) 14347 iNdEx := 0 14348 depth := 0 14349 for iNdEx < l { 14350 var wire uint64 14351 for shift := uint(0); ; shift += 7 { 14352 if shift >= 64 { 14353 return 0, ErrIntOverflowTypes 14354 } 14355 if iNdEx >= l { 14356 return 0, io.ErrUnexpectedEOF 14357 } 14358 b := dAtA[iNdEx] 14359 iNdEx++ 14360 wire |= (uint64(b) & 0x7F) << shift 14361 if b < 0x80 { 14362 break 14363 } 14364 } 14365 wireType := int(wire & 0x7) 14366 switch wireType { 14367 case 0: 14368 for shift := uint(0); ; shift += 7 { 14369 if shift >= 64 { 14370 return 0, ErrIntOverflowTypes 14371 } 14372 if iNdEx >= l { 14373 return 0, io.ErrUnexpectedEOF 14374 } 14375 iNdEx++ 14376 if dAtA[iNdEx-1] < 0x80 { 14377 break 14378 } 14379 } 14380 case 1: 14381 iNdEx += 8 14382 case 2: 14383 var length int 14384 for shift := uint(0); ; shift += 7 { 14385 if shift >= 64 { 14386 return 0, ErrIntOverflowTypes 14387 } 14388 if iNdEx >= l { 14389 return 0, io.ErrUnexpectedEOF 14390 } 14391 b := dAtA[iNdEx] 14392 iNdEx++ 14393 length |= (int(b) & 0x7F) << shift 14394 if b < 0x80 { 14395 break 14396 } 14397 } 14398 if length < 0 { 14399 return 0, ErrInvalidLengthTypes 14400 } 14401 iNdEx += length 14402 case 3: 14403 depth++ 14404 case 4: 14405 if depth == 0 { 14406 return 0, ErrUnexpectedEndOfGroupTypes 14407 } 14408 depth-- 14409 case 5: 14410 iNdEx += 4 14411 default: 14412 return 0, fmt.Errorf("proto: illegal wireType %d", wireType) 14413 } 14414 if iNdEx < 0 { 14415 return 0, ErrInvalidLengthTypes 14416 } 14417 if depth == 0 { 14418 return iNdEx, nil 14419 } 14420 } 14421 return 0, io.ErrUnexpectedEOF 14422 } 14423 14424 var ( 14425 ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling") 14426 ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow") 14427 ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group") 14428 )