vendor/github.com/tendermint/abci/types/types.pb.go

   1 // Code generated by protoc-gen-go.
   2 // source: types/types.proto
   3 // DO NOT EDIT!
   4
   5 /*
   6 Package types is a generated protocol buffer package.
   7
   8 It is generated from these files:
   9         types/types.proto
  10
  11 It has these top-level messages:
  12         Request
  13         RequestEcho
  14         RequestFlush
  15         RequestInfo
  16         RequestSetOption
  17         RequestDeliverTx
  18         RequestCheckTx
  19         RequestQuery
  20         RequestCommit
  21         RequestInitChain
  22         RequestBeginBlock
  23         RequestEndBlock
  24         Response
  25         ResponseException
  26         ResponseEcho
  27         ResponseFlush
  28         ResponseInfo
  29         ResponseSetOption
  30         ResponseDeliverTx
  31         ResponseCheckTx
  32         ResponseQuery
  33         ResponseCommit
  34         ResponseInitChain
  35         ResponseBeginBlock
  36         ResponseEndBlock
  37         Header
  38         BlockID
  39         PartSetHeader
  40         Validator
  41 */
  42 package types
  43
  44 import proto "github.com/golang/protobuf/proto"
  45 import fmt "fmt"
  46 import math "math"
  47
  48 import (
  49         context "golang.org/x/net/context"
  50         grpc "google.golang.org/grpc"
  51 )
  52
  53 // Reference imports to suppress errors if they are not otherwise used.
  54 var _ = proto.Marshal
  55 var _ = fmt.Errorf
  56 var _ = math.Inf
  57
  58 // This is a compile-time assertion to ensure that this generated file
  59 // is compatible with the proto package it is being compiled against.
  60 // A compilation error at this line likely means your copy of the
  61 // proto package needs to be updated.
  62 const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
  63
  64 type CodeType int32
  65
  66 const (
  67         CodeType_OK CodeType = 0
  68         // General response codes, 0 ~ 99
  69         CodeType_InternalError     CodeType = 1
  70         CodeType_EncodingError     CodeType = 2
  71         CodeType_BadNonce          CodeType = 3
  72         CodeType_Unauthorized      CodeType = 4
  73         CodeType_InsufficientFunds CodeType = 5
  74         CodeType_UnknownRequest    CodeType = 6
  75         // Reserved for basecoin, 100 ~ 199
  76         CodeType_BaseDuplicateAddress     CodeType = 101
  77         CodeType_BaseEncodingError        CodeType = 102
  78         CodeType_BaseInsufficientFees     CodeType = 103
  79         CodeType_BaseInsufficientFunds    CodeType = 104
  80         CodeType_BaseInsufficientGasPrice CodeType = 105
  81         CodeType_BaseInvalidInput         CodeType = 106
  82         CodeType_BaseInvalidOutput        CodeType = 107
  83         CodeType_BaseInvalidPubKey        CodeType = 108
  84         CodeType_BaseInvalidSequence      CodeType = 109
  85         CodeType_BaseInvalidSignature     CodeType = 110
  86         CodeType_BaseUnknownAddress       CodeType = 111
  87         CodeType_BaseUnknownPubKey        CodeType = 112
  88         CodeType_BaseUnknownPlugin        CodeType = 113
  89         // Reserved for governance, 200 ~ 299
  90         CodeType_GovUnknownEntity      CodeType = 201
  91         CodeType_GovUnknownGroup       CodeType = 202
  92         CodeType_GovUnknownProposal    CodeType = 203
  93         CodeType_GovDuplicateGroup     CodeType = 204
  94         CodeType_GovDuplicateMember    CodeType = 205
  95         CodeType_GovDuplicateProposal  CodeType = 206
  96         CodeType_GovDuplicateVote      CodeType = 207
  97         CodeType_GovInvalidMember      CodeType = 208
  98         CodeType_GovInvalidVote        CodeType = 209
  99         CodeType_GovInvalidVotingPower CodeType = 210
 100 )
 101
 102 var CodeType_name = map[int32]string{
 103         0:   "OK",
 104         1:   "InternalError",
 105         2:   "EncodingError",
 106         3:   "BadNonce",
 107         4:   "Unauthorized",
 108         5:   "InsufficientFunds",
 109         6:   "UnknownRequest",
 110         101: "BaseDuplicateAddress",
 111         102: "BaseEncodingError",
 112         103: "BaseInsufficientFees",
 113         104: "BaseInsufficientFunds",
 114         105: "BaseInsufficientGasPrice",
 115         106: "BaseInvalidInput",
 116         107: "BaseInvalidOutput",
 117         108: "BaseInvalidPubKey",
 118         109: "BaseInvalidSequence",
 119         110: "BaseInvalidSignature",
 120         111: "BaseUnknownAddress",
 121         112: "BaseUnknownPubKey",
 122         113: "BaseUnknownPlugin",
 123         201: "GovUnknownEntity",
 124         202: "GovUnknownGroup",
 125         203: "GovUnknownProposal",
 126         204: "GovDuplicateGroup",
 127         205: "GovDuplicateMember",
 128         206: "GovDuplicateProposal",
 129         207: "GovDuplicateVote",
 130         208: "GovInvalidMember",
 131         209: "GovInvalidVote",
 132         210: "GovInvalidVotingPower",
 133 }
 134 var CodeType_value = map[string]int32{
 135         "OK":                       0,
 136         "InternalError":            1,
 137         "EncodingError":            2,
 138         "BadNonce":                 3,
 139         "Unauthorized":             4,
 140         "InsufficientFunds":        5,
 141         "UnknownRequest":           6,
 142         "BaseDuplicateAddress":     101,
 143         "BaseEncodingError":        102,
 144         "BaseInsufficientFees":     103,
 145         "BaseInsufficientFunds":    104,
 146         "BaseInsufficientGasPrice": 105,
 147         "BaseInvalidInput":         106,
 148         "BaseInvalidOutput":        107,
 149         "BaseInvalidPubKey":        108,
 150         "BaseInvalidSequence":      109,
 151         "BaseInvalidSignature":     110,
 152         "BaseUnknownAddress":       111,
 153         "BaseUnknownPubKey":        112,
 154         "BaseUnknownPlugin":        113,
 155         "GovUnknownEntity":         201,
 156         "GovUnknownGroup":          202,
 157         "GovUnknownProposal":       203,
 158         "GovDuplicateGroup":        204,
 159         "GovDuplicateMember":       205,
 160         "GovDuplicateProposal":     206,
 161         "GovDuplicateVote":         207,
 162         "GovInvalidMember":         208,
 163         "GovInvalidVote":           209,
 164         "GovInvalidVotingPower":    210,
 165 }
 166
 167 func (x CodeType) String() string {
 168         return proto.EnumName(CodeType_name, int32(x))
 169 }
 170 func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 171
 172 type Request struct {
 173         // Types that are valid to be assigned to Value:
 174         //      *Request_Echo
 175         //      *Request_Flush
 176         //      *Request_Info
 177         //      *Request_SetOption
 178         //      *Request_DeliverTx
 179         //      *Request_CheckTx
 180         //      *Request_Commit
 181         //      *Request_Query
 182         //      *Request_InitChain
 183         //      *Request_BeginBlock
 184         //      *Request_EndBlock
 185         Value isRequest_Value `protobuf_oneof:"value"`
 186 }
 187
 188 func (m *Request) Reset()                    { *m = Request{} }
 189 func (m *Request) String() string            { return proto.CompactTextString(m) }
 190 func (*Request) ProtoMessage()               {}
 191 func (*Request) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
 192
 193 type isRequest_Value interface {
 194         isRequest_Value()
 195 }
 196
 197 type Request_Echo struct {
 198         Echo *RequestEcho `protobuf:"bytes,1,opt,name=echo,oneof"`
 199 }
 200 type Request_Flush struct {
 201         Flush *RequestFlush `protobuf:"bytes,2,opt,name=flush,oneof"`
 202 }
 203 type Request_Info struct {
 204         Info *RequestInfo `protobuf:"bytes,3,opt,name=info,oneof"`
 205 }
 206 type Request_SetOption struct {
 207         SetOption *RequestSetOption `protobuf:"bytes,4,opt,name=set_option,json=setOption,oneof"`
 208 }
 209 type Request_DeliverTx struct {
 210         DeliverTx *RequestDeliverTx `protobuf:"bytes,5,opt,name=deliver_tx,json=deliverTx,oneof"`
 211 }
 212 type Request_CheckTx struct {
 213         CheckTx *RequestCheckTx `protobuf:"bytes,6,opt,name=check_tx,json=checkTx,oneof"`
 214 }
 215 type Request_Commit struct {
 216         Commit *RequestCommit `protobuf:"bytes,7,opt,name=commit,oneof"`
 217 }
 218 type Request_Query struct {
 219         Query *RequestQuery `protobuf:"bytes,8,opt,name=query,oneof"`
 220 }
 221 type Request_InitChain struct {
 222         InitChain *RequestInitChain `protobuf:"bytes,9,opt,name=init_chain,json=initChain,oneof"`
 223 }
 224 type Request_BeginBlock struct {
 225         BeginBlock *RequestBeginBlock `protobuf:"bytes,10,opt,name=begin_block,json=beginBlock,oneof"`
 226 }
 227 type Request_EndBlock struct {
 228         EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,oneof"`
 229 }
 230
 231 func (*Request_Echo) isRequest_Value()       {}
 232 func (*Request_Flush) isRequest_Value()      {}
 233 func (*Request_Info) isRequest_Value()       {}
 234 func (*Request_SetOption) isRequest_Value()  {}
 235 func (*Request_DeliverTx) isRequest_Value()  {}
 236 func (*Request_CheckTx) isRequest_Value()    {}
 237 func (*Request_Commit) isRequest_Value()     {}
 238 func (*Request_Query) isRequest_Value()      {}
 239 func (*Request_InitChain) isRequest_Value()  {}
 240 func (*Request_BeginBlock) isRequest_Value() {}
 241 func (*Request_EndBlock) isRequest_Value()   {}
 242
 243 func (m *Request) GetValue() isRequest_Value {
 244         if m != nil {
 245                 return m.Value
 246         }
 247         return nil
 248 }
 249
 250 func (m *Request) GetEcho() *RequestEcho {
 251         if x, ok := m.GetValue().(*Request_Echo); ok {
 252                 return x.Echo
 253         }
 254         return nil
 255 }
 256
 257 func (m *Request) GetFlush() *RequestFlush {
 258         if x, ok := m.GetValue().(*Request_Flush); ok {
 259                 return x.Flush
 260         }
 261         return nil
 262 }
 263
 264 func (m *Request) GetInfo() *RequestInfo {
 265         if x, ok := m.GetValue().(*Request_Info); ok {
 266                 return x.Info
 267         }
 268         return nil
 269 }
 270
 271 func (m *Request) GetSetOption() *RequestSetOption {
 272         if x, ok := m.GetValue().(*Request_SetOption); ok {
 273                 return x.SetOption
 274         }
 275         return nil
 276 }
 277
 278 func (m *Request) GetDeliverTx() *RequestDeliverTx {
 279         if x, ok := m.GetValue().(*Request_DeliverTx); ok {
 280                 return x.DeliverTx
 281         }
 282         return nil
 283 }
 284
 285 func (m *Request) GetCheckTx() *RequestCheckTx {
 286         if x, ok := m.GetValue().(*Request_CheckTx); ok {
 287                 return x.CheckTx
 288         }
 289         return nil
 290 }
 291
 292 func (m *Request) GetCommit() *RequestCommit {
 293         if x, ok := m.GetValue().(*Request_Commit); ok {
 294                 return x.Commit
 295         }
 296         return nil
 297 }
 298
 299 func (m *Request) GetQuery() *RequestQuery {
 300         if x, ok := m.GetValue().(*Request_Query); ok {
 301                 return x.Query
 302         }
 303         return nil
 304 }
 305
 306 func (m *Request) GetInitChain() *RequestInitChain {
 307         if x, ok := m.GetValue().(*Request_InitChain); ok {
 308                 return x.InitChain
 309         }
 310         return nil
 311 }
 312
 313 func (m *Request) GetBeginBlock() *RequestBeginBlock {
 314         if x, ok := m.GetValue().(*Request_BeginBlock); ok {
 315                 return x.BeginBlock
 316         }
 317         return nil
 318 }
 319
 320 func (m *Request) GetEndBlock() *RequestEndBlock {
 321         if x, ok := m.GetValue().(*Request_EndBlock); ok {
 322                 return x.EndBlock
 323         }
 324         return nil
 325 }
 326
 327 // XXX_OneofFuncs is for the internal use of the proto package.
 328 func (*Request) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 329         return _Request_OneofMarshaler, _Request_OneofUnmarshaler, _Request_OneofSizer, []interface{}{
 330                 (*Request_Echo)(nil),
 331                 (*Request_Flush)(nil),
 332                 (*Request_Info)(nil),
 333                 (*Request_SetOption)(nil),
 334                 (*Request_DeliverTx)(nil),
 335                 (*Request_CheckTx)(nil),
 336                 (*Request_Commit)(nil),
 337                 (*Request_Query)(nil),
 338                 (*Request_InitChain)(nil),
 339                 (*Request_BeginBlock)(nil),
 340                 (*Request_EndBlock)(nil),
 341         }
 342 }
 343
 344 func _Request_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 345         m := msg.(*Request)
 346         // value
 347         switch x := m.Value.(type) {
 348         case *Request_Echo:
 349                 b.EncodeVarint(1<<3 | proto.WireBytes)
 350                 if err := b.EncodeMessage(x.Echo); err != nil {
 351                         return err
 352                 }
 353         case *Request_Flush:
 354                 b.EncodeVarint(2<<3 | proto.WireBytes)
 355                 if err := b.EncodeMessage(x.Flush); err != nil {
 356                         return err
 357                 }
 358         case *Request_Info:
 359                 b.EncodeVarint(3<<3 | proto.WireBytes)
 360                 if err := b.EncodeMessage(x.Info); err != nil {
 361                         return err
 362                 }
 363         case *Request_SetOption:
 364                 b.EncodeVarint(4<<3 | proto.WireBytes)
 365                 if err := b.EncodeMessage(x.SetOption); err != nil {
 366                         return err
 367                 }
 368         case *Request_DeliverTx:
 369                 b.EncodeVarint(5<<3 | proto.WireBytes)
 370                 if err := b.EncodeMessage(x.DeliverTx); err != nil {
 371                         return err
 372                 }
 373         case *Request_CheckTx:
 374                 b.EncodeVarint(6<<3 | proto.WireBytes)
 375                 if err := b.EncodeMessage(x.CheckTx); err != nil {
 376                         return err
 377                 }
 378         case *Request_Commit:
 379                 b.EncodeVarint(7<<3 | proto.WireBytes)
 380                 if err := b.EncodeMessage(x.Commit); err != nil {
 381                         return err
 382                 }
 383         case *Request_Query:
 384                 b.EncodeVarint(8<<3 | proto.WireBytes)
 385                 if err := b.EncodeMessage(x.Query); err != nil {
 386                         return err
 387                 }
 388         case *Request_InitChain:
 389                 b.EncodeVarint(9<<3 | proto.WireBytes)
 390                 if err := b.EncodeMessage(x.InitChain); err != nil {
 391                         return err
 392                 }
 393         case *Request_BeginBlock:
 394                 b.EncodeVarint(10<<3 | proto.WireBytes)
 395                 if err := b.EncodeMessage(x.BeginBlock); err != nil {
 396                         return err
 397                 }
 398         case *Request_EndBlock:
 399                 b.EncodeVarint(11<<3 | proto.WireBytes)
 400                 if err := b.EncodeMessage(x.EndBlock); err != nil {
 401                         return err
 402                 }
 403         case nil:
 404         default:
 405                 return fmt.Errorf("Request.Value has unexpected type %T", x)
 406         }
 407         return nil
 408 }
 409
 410 func _Request_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 411         m := msg.(*Request)
 412         switch tag {
 413         case 1: // value.echo
 414                 if wire != proto.WireBytes {
 415                         return true, proto.ErrInternalBadWireType
 416                 }
 417                 msg := new(RequestEcho)
 418                 err := b.DecodeMessage(msg)
 419                 m.Value = &Request_Echo{msg}
 420                 return true, err
 421         case 2: // value.flush
 422                 if wire != proto.WireBytes {
 423                         return true, proto.ErrInternalBadWireType
 424                 }
 425                 msg := new(RequestFlush)
 426                 err := b.DecodeMessage(msg)
 427                 m.Value = &Request_Flush{msg}
 428                 return true, err
 429         case 3: // value.info
 430                 if wire != proto.WireBytes {
 431                         return true, proto.ErrInternalBadWireType
 432                 }
 433                 msg := new(RequestInfo)
 434                 err := b.DecodeMessage(msg)
 435                 m.Value = &Request_Info{msg}
 436                 return true, err
 437         case 4: // value.set_option
 438                 if wire != proto.WireBytes {
 439                         return true, proto.ErrInternalBadWireType
 440                 }
 441                 msg := new(RequestSetOption)
 442                 err := b.DecodeMessage(msg)
 443                 m.Value = &Request_SetOption{msg}
 444                 return true, err
 445         case 5: // value.deliver_tx
 446                 if wire != proto.WireBytes {
 447                         return true, proto.ErrInternalBadWireType
 448                 }
 449                 msg := new(RequestDeliverTx)
 450                 err := b.DecodeMessage(msg)
 451                 m.Value = &Request_DeliverTx{msg}
 452                 return true, err
 453         case 6: // value.check_tx
 454                 if wire != proto.WireBytes {
 455                         return true, proto.ErrInternalBadWireType
 456                 }
 457                 msg := new(RequestCheckTx)
 458                 err := b.DecodeMessage(msg)
 459                 m.Value = &Request_CheckTx{msg}
 460                 return true, err
 461         case 7: // value.commit
 462                 if wire != proto.WireBytes {
 463                         return true, proto.ErrInternalBadWireType
 464                 }
 465                 msg := new(RequestCommit)
 466                 err := b.DecodeMessage(msg)
 467                 m.Value = &Request_Commit{msg}
 468                 return true, err
 469         case 8: // value.query
 470                 if wire != proto.WireBytes {
 471                         return true, proto.ErrInternalBadWireType
 472                 }
 473                 msg := new(RequestQuery)
 474                 err := b.DecodeMessage(msg)
 475                 m.Value = &Request_Query{msg}
 476                 return true, err
 477         case 9: // value.init_chain
 478                 if wire != proto.WireBytes {
 479                         return true, proto.ErrInternalBadWireType
 480                 }
 481                 msg := new(RequestInitChain)
 482                 err := b.DecodeMessage(msg)
 483                 m.Value = &Request_InitChain{msg}
 484                 return true, err
 485         case 10: // value.begin_block
 486                 if wire != proto.WireBytes {
 487                         return true, proto.ErrInternalBadWireType
 488                 }
 489                 msg := new(RequestBeginBlock)
 490                 err := b.DecodeMessage(msg)
 491                 m.Value = &Request_BeginBlock{msg}
 492                 return true, err
 493         case 11: // value.end_block
 494                 if wire != proto.WireBytes {
 495                         return true, proto.ErrInternalBadWireType
 496                 }
 497                 msg := new(RequestEndBlock)
 498                 err := b.DecodeMessage(msg)
 499                 m.Value = &Request_EndBlock{msg}
 500                 return true, err
 501         default:
 502                 return false, nil
 503         }
 504 }
 505
 506 func _Request_OneofSizer(msg proto.Message) (n int) {
 507         m := msg.(*Request)
 508         // value
 509         switch x := m.Value.(type) {
 510         case *Request_Echo:
 511                 s := proto.Size(x.Echo)
 512                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 513                 n += proto.SizeVarint(uint64(s))
 514                 n += s
 515         case *Request_Flush:
 516                 s := proto.Size(x.Flush)
 517                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 518                 n += proto.SizeVarint(uint64(s))
 519                 n += s
 520         case *Request_Info:
 521                 s := proto.Size(x.Info)
 522                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 523                 n += proto.SizeVarint(uint64(s))
 524                 n += s
 525         case *Request_SetOption:
 526                 s := proto.Size(x.SetOption)
 527                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 528                 n += proto.SizeVarint(uint64(s))
 529                 n += s
 530         case *Request_DeliverTx:
 531                 s := proto.Size(x.DeliverTx)
 532                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 533                 n += proto.SizeVarint(uint64(s))
 534                 n += s
 535         case *Request_CheckTx:
 536                 s := proto.Size(x.CheckTx)
 537                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
 538                 n += proto.SizeVarint(uint64(s))
 539                 n += s
 540         case *Request_Commit:
 541                 s := proto.Size(x.Commit)
 542                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
 543                 n += proto.SizeVarint(uint64(s))
 544                 n += s
 545         case *Request_Query:
 546                 s := proto.Size(x.Query)
 547                 n += proto.SizeVarint(8<<3 | proto.WireBytes)
 548                 n += proto.SizeVarint(uint64(s))
 549                 n += s
 550         case *Request_InitChain:
 551                 s := proto.Size(x.InitChain)
 552                 n += proto.SizeVarint(9<<3 | proto.WireBytes)
 553                 n += proto.SizeVarint(uint64(s))
 554                 n += s
 555         case *Request_BeginBlock:
 556                 s := proto.Size(x.BeginBlock)
 557                 n += proto.SizeVarint(10<<3 | proto.WireBytes)
 558                 n += proto.SizeVarint(uint64(s))
 559                 n += s
 560         case *Request_EndBlock:
 561                 s := proto.Size(x.EndBlock)
 562                 n += proto.SizeVarint(11<<3 | proto.WireBytes)
 563                 n += proto.SizeVarint(uint64(s))
 564                 n += s
 565         case nil:
 566         default:
 567                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 568         }
 569         return n
 570 }
 571
 572 type RequestEcho struct {
 573         Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
 574 }
 575
 576 func (m *RequestEcho) Reset()                    { *m = RequestEcho{} }
 577 func (m *RequestEcho) String() string            { return proto.CompactTextString(m) }
 578 func (*RequestEcho) ProtoMessage()               {}
 579 func (*RequestEcho) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
 580
 581 func (m *RequestEcho) GetMessage() string {
 582         if m != nil {
 583                 return m.Message
 584         }
 585         return ""
 586 }
 587
 588 type RequestFlush struct {
 589 }
 590
 591 func (m *RequestFlush) Reset()                    { *m = RequestFlush{} }
 592 func (m *RequestFlush) String() string            { return proto.CompactTextString(m) }
 593 func (*RequestFlush) ProtoMessage()               {}
 594 func (*RequestFlush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
 595
 596 type RequestInfo struct {
 597         Version string `protobuf:"bytes,1,opt,name=version" json:"version,omitempty"`
 598 }
 599
 600 func (m *RequestInfo) Reset()                    { *m = RequestInfo{} }
 601 func (m *RequestInfo) String() string            { return proto.CompactTextString(m) }
 602 func (*RequestInfo) ProtoMessage()               {}
 603 func (*RequestInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
 604
 605 func (m *RequestInfo) GetVersion() string {
 606         if m != nil {
 607                 return m.Version
 608         }
 609         return ""
 610 }
 611
 612 type RequestSetOption struct {
 613         Key   string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
 614         Value string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
 615 }
 616
 617 func (m *RequestSetOption) Reset()                    { *m = RequestSetOption{} }
 618 func (m *RequestSetOption) String() string            { return proto.CompactTextString(m) }
 619 func (*RequestSetOption) ProtoMessage()               {}
 620 func (*RequestSetOption) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
 621
 622 func (m *RequestSetOption) GetKey() string {
 623         if m != nil {
 624                 return m.Key
 625         }
 626         return ""
 627 }
 628
 629 func (m *RequestSetOption) GetValue() string {
 630         if m != nil {
 631                 return m.Value
 632         }
 633         return ""
 634 }
 635
 636 type RequestDeliverTx struct {
 637         Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
 638 }
 639
 640 func (m *RequestDeliverTx) Reset()                    { *m = RequestDeliverTx{} }
 641 func (m *RequestDeliverTx) String() string            { return proto.CompactTextString(m) }
 642 func (*RequestDeliverTx) ProtoMessage()               {}
 643 func (*RequestDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
 644
 645 func (m *RequestDeliverTx) GetTx() []byte {
 646         if m != nil {
 647                 return m.Tx
 648         }
 649         return nil
 650 }
 651
 652 type RequestCheckTx struct {
 653         Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
 654 }
 655
 656 func (m *RequestCheckTx) Reset()                    { *m = RequestCheckTx{} }
 657 func (m *RequestCheckTx) String() string            { return proto.CompactTextString(m) }
 658 func (*RequestCheckTx) ProtoMessage()               {}
 659 func (*RequestCheckTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
 660
 661 func (m *RequestCheckTx) GetTx() []byte {
 662         if m != nil {
 663                 return m.Tx
 664         }
 665         return nil
 666 }
 667
 668 type RequestQuery struct {
 669         Data   []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
 670         Path   string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
 671         Height uint64 `protobuf:"varint,3,opt,name=height" json:"height,omitempty"`
 672         Prove  bool   `protobuf:"varint,4,opt,name=prove" json:"prove,omitempty"`
 673 }
 674
 675 func (m *RequestQuery) Reset()                    { *m = RequestQuery{} }
 676 func (m *RequestQuery) String() string            { return proto.CompactTextString(m) }
 677 func (*RequestQuery) ProtoMessage()               {}
 678 func (*RequestQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
 679
 680 func (m *RequestQuery) GetData() []byte {
 681         if m != nil {
 682                 return m.Data
 683         }
 684         return nil
 685 }
 686
 687 func (m *RequestQuery) GetPath() string {
 688         if m != nil {
 689                 return m.Path
 690         }
 691         return ""
 692 }
 693
 694 func (m *RequestQuery) GetHeight() uint64 {
 695         if m != nil {
 696                 return m.Height
 697         }
 698         return 0
 699 }
 700
 701 func (m *RequestQuery) GetProve() bool {
 702         if m != nil {
 703                 return m.Prove
 704         }
 705         return false
 706 }
 707
 708 type RequestCommit struct {
 709 }
 710
 711 func (m *RequestCommit) Reset()                    { *m = RequestCommit{} }
 712 func (m *RequestCommit) String() string            { return proto.CompactTextString(m) }
 713 func (*RequestCommit) ProtoMessage()               {}
 714 func (*RequestCommit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
 715
 716 type RequestInitChain struct {
 717         Validators []*Validator `protobuf:"bytes,1,rep,name=validators" json:"validators,omitempty"`
 718 }
 719
 720 func (m *RequestInitChain) Reset()                    { *m = RequestInitChain{} }
 721 func (m *RequestInitChain) String() string            { return proto.CompactTextString(m) }
 722 func (*RequestInitChain) ProtoMessage()               {}
 723 func (*RequestInitChain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
 724
 725 func (m *RequestInitChain) GetValidators() []*Validator {
 726         if m != nil {
 727                 return m.Validators
 728         }
 729         return nil
 730 }
 731
 732 type RequestBeginBlock struct {
 733         Hash   []byte  `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
 734         Header *Header `protobuf:"bytes,2,opt,name=header" json:"header,omitempty"`
 735 }
 736
 737 func (m *RequestBeginBlock) Reset()                    { *m = RequestBeginBlock{} }
 738 func (m *RequestBeginBlock) String() string            { return proto.CompactTextString(m) }
 739 func (*RequestBeginBlock) ProtoMessage()               {}
 740 func (*RequestBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
 741
 742 func (m *RequestBeginBlock) GetHash() []byte {
 743         if m != nil {
 744                 return m.Hash
 745         }
 746         return nil
 747 }
 748
 749 func (m *RequestBeginBlock) GetHeader() *Header {
 750         if m != nil {
 751                 return m.Header
 752         }
 753         return nil
 754 }
 755
 756 type RequestEndBlock struct {
 757         Height uint64 `protobuf:"varint,1,opt,name=height" json:"height,omitempty"`
 758 }
 759
 760 func (m *RequestEndBlock) Reset()                    { *m = RequestEndBlock{} }
 761 func (m *RequestEndBlock) String() string            { return proto.CompactTextString(m) }
 762 func (*RequestEndBlock) ProtoMessage()               {}
 763 func (*RequestEndBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
 764
 765 func (m *RequestEndBlock) GetHeight() uint64 {
 766         if m != nil {
 767                 return m.Height
 768         }
 769         return 0
 770 }
 771
 772 type Response struct {
 773         // Types that are valid to be assigned to Value:
 774         //      *Response_Exception
 775         //      *Response_Echo
 776         //      *Response_Flush
 777         //      *Response_Info
 778         //      *Response_SetOption
 779         //      *Response_DeliverTx
 780         //      *Response_CheckTx
 781         //      *Response_Commit
 782         //      *Response_Query
 783         //      *Response_InitChain
 784         //      *Response_BeginBlock
 785         //      *Response_EndBlock
 786         Value isResponse_Value `protobuf_oneof:"value"`
 787 }
 788
 789 func (m *Response) Reset()                    { *m = Response{} }
 790 func (m *Response) String() string            { return proto.CompactTextString(m) }
 791 func (*Response) ProtoMessage()               {}
 792 func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
 793
 794 type isResponse_Value interface {
 795         isResponse_Value()
 796 }
 797
 798 type Response_Exception struct {
 799         Exception *ResponseException `protobuf:"bytes,1,opt,name=exception,oneof"`
 800 }
 801 type Response_Echo struct {
 802         Echo *ResponseEcho `protobuf:"bytes,2,opt,name=echo,oneof"`
 803 }
 804 type Response_Flush struct {
 805         Flush *ResponseFlush `protobuf:"bytes,3,opt,name=flush,oneof"`
 806 }
 807 type Response_Info struct {
 808         Info *ResponseInfo `protobuf:"bytes,4,opt,name=info,oneof"`
 809 }
 810 type Response_SetOption struct {
 811         SetOption *ResponseSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,oneof"`
 812 }
 813 type Response_DeliverTx struct {
 814         DeliverTx *ResponseDeliverTx `protobuf:"bytes,6,opt,name=deliver_tx,json=deliverTx,oneof"`
 815 }
 816 type Response_CheckTx struct {
 817         CheckTx *ResponseCheckTx `protobuf:"bytes,7,opt,name=check_tx,json=checkTx,oneof"`
 818 }
 819 type Response_Commit struct {
 820         Commit *ResponseCommit `protobuf:"bytes,8,opt,name=commit,oneof"`
 821 }
 822 type Response_Query struct {
 823         Query *ResponseQuery `protobuf:"bytes,9,opt,name=query,oneof"`
 824 }
 825 type Response_InitChain struct {
 826         InitChain *ResponseInitChain `protobuf:"bytes,10,opt,name=init_chain,json=initChain,oneof"`
 827 }
 828 type Response_BeginBlock struct {
 829         BeginBlock *ResponseBeginBlock `protobuf:"bytes,11,opt,name=begin_block,json=beginBlock,oneof"`
 830 }
 831 type Response_EndBlock struct {
 832         EndBlock *ResponseEndBlock `protobuf:"bytes,12,opt,name=end_block,json=endBlock,oneof"`
 833 }
 834
 835 func (*Response_Exception) isResponse_Value()  {}
 836 func (*Response_Echo) isResponse_Value()       {}
 837 func (*Response_Flush) isResponse_Value()      {}
 838 func (*Response_Info) isResponse_Value()       {}
 839 func (*Response_SetOption) isResponse_Value()  {}
 840 func (*Response_DeliverTx) isResponse_Value()  {}
 841 func (*Response_CheckTx) isResponse_Value()    {}
 842 func (*Response_Commit) isResponse_Value()     {}
 843 func (*Response_Query) isResponse_Value()      {}
 844 func (*Response_InitChain) isResponse_Value()  {}
 845 func (*Response_BeginBlock) isResponse_Value() {}
 846 func (*Response_EndBlock) isResponse_Value()   {}
 847
 848 func (m *Response) GetValue() isResponse_Value {
 849         if m != nil {
 850                 return m.Value
 851         }
 852         return nil
 853 }
 854
 855 func (m *Response) GetException() *ResponseException {
 856         if x, ok := m.GetValue().(*Response_Exception); ok {
 857                 return x.Exception
 858         }
 859         return nil
 860 }
 861
 862 func (m *Response) GetEcho() *ResponseEcho {
 863         if x, ok := m.GetValue().(*Response_Echo); ok {
 864                 return x.Echo
 865         }
 866         return nil
 867 }
 868
 869 func (m *Response) GetFlush() *ResponseFlush {
 870         if x, ok := m.GetValue().(*Response_Flush); ok {
 871                 return x.Flush
 872         }
 873         return nil
 874 }
 875
 876 func (m *Response) GetInfo() *ResponseInfo {
 877         if x, ok := m.GetValue().(*Response_Info); ok {
 878                 return x.Info
 879         }
 880         return nil
 881 }
 882
 883 func (m *Response) GetSetOption() *ResponseSetOption {
 884         if x, ok := m.GetValue().(*Response_SetOption); ok {
 885                 return x.SetOption
 886         }
 887         return nil
 888 }
 889
 890 func (m *Response) GetDeliverTx() *ResponseDeliverTx {
 891         if x, ok := m.GetValue().(*Response_DeliverTx); ok {
 892                 return x.DeliverTx
 893         }
 894         return nil
 895 }
 896
 897 func (m *Response) GetCheckTx() *ResponseCheckTx {
 898         if x, ok := m.GetValue().(*Response_CheckTx); ok {
 899                 return x.CheckTx
 900         }
 901         return nil
 902 }
 903
 904 func (m *Response) GetCommit() *ResponseCommit {
 905         if x, ok := m.GetValue().(*Response_Commit); ok {
 906                 return x.Commit
 907         }
 908         return nil
 909 }
 910
 911 func (m *Response) GetQuery() *ResponseQuery {
 912         if x, ok := m.GetValue().(*Response_Query); ok {
 913                 return x.Query
 914         }
 915         return nil
 916 }
 917
 918 func (m *Response) GetInitChain() *ResponseInitChain {
 919         if x, ok := m.GetValue().(*Response_InitChain); ok {
 920                 return x.InitChain
 921         }
 922         return nil
 923 }
 924
 925 func (m *Response) GetBeginBlock() *ResponseBeginBlock {
 926         if x, ok := m.GetValue().(*Response_BeginBlock); ok {
 927                 return x.BeginBlock
 928         }
 929         return nil
 930 }
 931
 932 func (m *Response) GetEndBlock() *ResponseEndBlock {
 933         if x, ok := m.GetValue().(*Response_EndBlock); ok {
 934                 return x.EndBlock
 935         }
 936         return nil
 937 }
 938
 939 // XXX_OneofFuncs is for the internal use of the proto package.
 940 func (*Response) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 941         return _Response_OneofMarshaler, _Response_OneofUnmarshaler, _Response_OneofSizer, []interface{}{
 942                 (*Response_Exception)(nil),
 943                 (*Response_Echo)(nil),
 944                 (*Response_Flush)(nil),
 945                 (*Response_Info)(nil),
 946                 (*Response_SetOption)(nil),
 947                 (*Response_DeliverTx)(nil),
 948                 (*Response_CheckTx)(nil),
 949                 (*Response_Commit)(nil),
 950                 (*Response_Query)(nil),
 951                 (*Response_InitChain)(nil),
 952                 (*Response_BeginBlock)(nil),
 953                 (*Response_EndBlock)(nil),
 954         }
 955 }
 956
 957 func _Response_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 958         m := msg.(*Response)
 959         // value
 960         switch x := m.Value.(type) {
 961         case *Response_Exception:
 962                 b.EncodeVarint(1<<3 | proto.WireBytes)
 963                 if err := b.EncodeMessage(x.Exception); err != nil {
 964                         return err
 965                 }
 966         case *Response_Echo:
 967                 b.EncodeVarint(2<<3 | proto.WireBytes)
 968                 if err := b.EncodeMessage(x.Echo); err != nil {
 969                         return err
 970                 }
 971         case *Response_Flush:
 972                 b.EncodeVarint(3<<3 | proto.WireBytes)
 973                 if err := b.EncodeMessage(x.Flush); err != nil {
 974                         return err
 975                 }
 976         case *Response_Info:
 977                 b.EncodeVarint(4<<3 | proto.WireBytes)
 978                 if err := b.EncodeMessage(x.Info); err != nil {
 979                         return err
 980                 }
 981         case *Response_SetOption:
 982                 b.EncodeVarint(5<<3 | proto.WireBytes)
 983                 if err := b.EncodeMessage(x.SetOption); err != nil {
 984                         return err
 985                 }
 986         case *Response_DeliverTx:
 987                 b.EncodeVarint(6<<3 | proto.WireBytes)
 988                 if err := b.EncodeMessage(x.DeliverTx); err != nil {
 989                         return err
 990                 }
 991         case *Response_CheckTx:
 992                 b.EncodeVarint(7<<3 | proto.WireBytes)
 993                 if err := b.EncodeMessage(x.CheckTx); err != nil {
 994                         return err
 995                 }
 996         case *Response_Commit:
 997                 b.EncodeVarint(8<<3 | proto.WireBytes)
 998                 if err := b.EncodeMessage(x.Commit); err != nil {
 999                         return err
1000                 }
1001         case *Response_Query:
1002                 b.EncodeVarint(9<<3 | proto.WireBytes)
1003                 if err := b.EncodeMessage(x.Query); err != nil {
1004                         return err
1005                 }
1006         case *Response_InitChain:
1007                 b.EncodeVarint(10<<3 | proto.WireBytes)
1008                 if err := b.EncodeMessage(x.InitChain); err != nil {
1009                         return err
1010                 }
1011         case *Response_BeginBlock:
1012                 b.EncodeVarint(11<<3 | proto.WireBytes)
1013                 if err := b.EncodeMessage(x.BeginBlock); err != nil {
1014                         return err
1015                 }
1016         case *Response_EndBlock:
1017                 b.EncodeVarint(12<<3 | proto.WireBytes)
1018                 if err := b.EncodeMessage(x.EndBlock); err != nil {
1019                         return err
1020                 }
1021         case nil:
1022         default:
1023                 return fmt.Errorf("Response.Value has unexpected type %T", x)
1024         }
1025         return nil
1026 }
1027
1028 func _Response_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1029         m := msg.(*Response)
1030         switch tag {
1031         case 1: // value.exception
1032                 if wire != proto.WireBytes {
1033                         return true, proto.ErrInternalBadWireType
1034                 }
1035                 msg := new(ResponseException)
1036                 err := b.DecodeMessage(msg)
1037                 m.Value = &Response_Exception{msg}
1038                 return true, err
1039         case 2: // value.echo
1040                 if wire != proto.WireBytes {
1041                         return true, proto.ErrInternalBadWireType
1042                 }
1043                 msg := new(ResponseEcho)
1044                 err := b.DecodeMessage(msg)
1045                 m.Value = &Response_Echo{msg}
1046                 return true, err
1047         case 3: // value.flush
1048                 if wire != proto.WireBytes {
1049                         return true, proto.ErrInternalBadWireType
1050                 }
1051                 msg := new(ResponseFlush)
1052                 err := b.DecodeMessage(msg)
1053                 m.Value = &Response_Flush{msg}
1054                 return true, err
1055         case 4: // value.info
1056                 if wire != proto.WireBytes {
1057                         return true, proto.ErrInternalBadWireType
1058                 }
1059                 msg := new(ResponseInfo)
1060                 err := b.DecodeMessage(msg)
1061                 m.Value = &Response_Info{msg}
1062                 return true, err
1063         case 5: // value.set_option
1064                 if wire != proto.WireBytes {
1065                         return true, proto.ErrInternalBadWireType
1066                 }
1067                 msg := new(ResponseSetOption)
1068                 err := b.DecodeMessage(msg)
1069                 m.Value = &Response_SetOption{msg}
1070                 return true, err
1071         case 6: // value.deliver_tx
1072                 if wire != proto.WireBytes {
1073                         return true, proto.ErrInternalBadWireType
1074                 }
1075                 msg := new(ResponseDeliverTx)
1076                 err := b.DecodeMessage(msg)
1077                 m.Value = &Response_DeliverTx{msg}
1078                 return true, err
1079         case 7: // value.check_tx
1080                 if wire != proto.WireBytes {
1081                         return true, proto.ErrInternalBadWireType
1082                 }
1083                 msg := new(ResponseCheckTx)
1084                 err := b.DecodeMessage(msg)
1085                 m.Value = &Response_CheckTx{msg}
1086                 return true, err
1087         case 8: // value.commit
1088                 if wire != proto.WireBytes {
1089                         return true, proto.ErrInternalBadWireType
1090                 }
1091                 msg := new(ResponseCommit)
1092                 err := b.DecodeMessage(msg)
1093                 m.Value = &Response_Commit{msg}
1094                 return true, err
1095         case 9: // value.query
1096                 if wire != proto.WireBytes {
1097                         return true, proto.ErrInternalBadWireType
1098                 }
1099                 msg := new(ResponseQuery)
1100                 err := b.DecodeMessage(msg)
1101                 m.Value = &Response_Query{msg}
1102                 return true, err
1103         case 10: // value.init_chain
1104                 if wire != proto.WireBytes {
1105                         return true, proto.ErrInternalBadWireType
1106                 }
1107                 msg := new(ResponseInitChain)
1108                 err := b.DecodeMessage(msg)
1109                 m.Value = &Response_InitChain{msg}
1110                 return true, err
1111         case 11: // value.begin_block
1112                 if wire != proto.WireBytes {
1113                         return true, proto.ErrInternalBadWireType
1114                 }
1115                 msg := new(ResponseBeginBlock)
1116                 err := b.DecodeMessage(msg)
1117                 m.Value = &Response_BeginBlock{msg}
1118                 return true, err
1119         case 12: // value.end_block
1120                 if wire != proto.WireBytes {
1121                         return true, proto.ErrInternalBadWireType
1122                 }
1123                 msg := new(ResponseEndBlock)
1124                 err := b.DecodeMessage(msg)
1125                 m.Value = &Response_EndBlock{msg}
1126                 return true, err
1127         default:
1128                 return false, nil
1129         }
1130 }
1131
1132 func _Response_OneofSizer(msg proto.Message) (n int) {
1133         m := msg.(*Response)
1134         // value
1135         switch x := m.Value.(type) {
1136         case *Response_Exception:
1137                 s := proto.Size(x.Exception)
1138                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1139                 n += proto.SizeVarint(uint64(s))
1140                 n += s
1141         case *Response_Echo:
1142                 s := proto.Size(x.Echo)
1143                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1144                 n += proto.SizeVarint(uint64(s))
1145                 n += s
1146         case *Response_Flush:
1147                 s := proto.Size(x.Flush)
1148                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1149                 n += proto.SizeVarint(uint64(s))
1150                 n += s
1151         case *Response_Info:
1152                 s := proto.Size(x.Info)
1153                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
1154                 n += proto.SizeVarint(uint64(s))
1155                 n += s
1156         case *Response_SetOption:
1157                 s := proto.Size(x.SetOption)
1158                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
1159                 n += proto.SizeVarint(uint64(s))
1160                 n += s
1161         case *Response_DeliverTx:
1162                 s := proto.Size(x.DeliverTx)
1163                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
1164                 n += proto.SizeVarint(uint64(s))
1165                 n += s
1166         case *Response_CheckTx:
1167                 s := proto.Size(x.CheckTx)
1168                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
1169                 n += proto.SizeVarint(uint64(s))
1170                 n += s
1171         case *Response_Commit:
1172                 s := proto.Size(x.Commit)
1173                 n += proto.SizeVarint(8<<3 | proto.WireBytes)
1174                 n += proto.SizeVarint(uint64(s))
1175                 n += s
1176         case *Response_Query:
1177                 s := proto.Size(x.Query)
1178                 n += proto.SizeVarint(9<<3 | proto.WireBytes)
1179                 n += proto.SizeVarint(uint64(s))
1180                 n += s
1181         case *Response_InitChain:
1182                 s := proto.Size(x.InitChain)
1183                 n += proto.SizeVarint(10<<3 | proto.WireBytes)
1184                 n += proto.SizeVarint(uint64(s))
1185                 n += s
1186         case *Response_BeginBlock:
1187                 s := proto.Size(x.BeginBlock)
1188                 n += proto.SizeVarint(11<<3 | proto.WireBytes)
1189                 n += proto.SizeVarint(uint64(s))
1190                 n += s
1191         case *Response_EndBlock:
1192                 s := proto.Size(x.EndBlock)
1193                 n += proto.SizeVarint(12<<3 | proto.WireBytes)
1194                 n += proto.SizeVarint(uint64(s))
1195                 n += s
1196         case nil:
1197         default:
1198                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1199         }
1200         return n
1201 }
1202
1203 type ResponseException struct {
1204         Error string `protobuf:"bytes,1,opt,name=error" json:"error,omitempty"`
1205 }
1206
1207 func (m *ResponseException) Reset()                    { *m = ResponseException{} }
1208 func (m *ResponseException) String() string            { return proto.CompactTextString(m) }
1209 func (*ResponseException) ProtoMessage()               {}
1210 func (*ResponseException) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
1211
1212 func (m *ResponseException) GetError() string {
1213         if m != nil {
1214                 return m.Error
1215         }
1216         return ""
1217 }
1218
1219 type ResponseEcho struct {
1220         Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
1221 }
1222
1223 func (m *ResponseEcho) Reset()                    { *m = ResponseEcho{} }
1224 func (m *ResponseEcho) String() string            { return proto.CompactTextString(m) }
1225 func (*ResponseEcho) ProtoMessage()               {}
1226 func (*ResponseEcho) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
1227
1228 func (m *ResponseEcho) GetMessage() string {
1229         if m != nil {
1230                 return m.Message
1231         }
1232         return ""
1233 }
1234
1235 type ResponseFlush struct {
1236 }
1237
1238 func (m *ResponseFlush) Reset()                    { *m = ResponseFlush{} }
1239 func (m *ResponseFlush) String() string            { return proto.CompactTextString(m) }
1240 func (*ResponseFlush) ProtoMessage()               {}
1241 func (*ResponseFlush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
1242
1243 type ResponseInfo struct {
1244         Data             string `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
1245         Version          string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
1246         LastBlockHeight  uint64 `protobuf:"varint,3,opt,name=last_block_height,json=lastBlockHeight" json:"last_block_height,omitempty"`
1247         LastBlockAppHash []byte `protobuf:"bytes,4,opt,name=last_block_app_hash,json=lastBlockAppHash,proto3" json:"last_block_app_hash,omitempty"`
1248 }
1249
1250 func (m *ResponseInfo) Reset()                    { *m = ResponseInfo{} }
1251 func (m *ResponseInfo) String() string            { return proto.CompactTextString(m) }
1252 func (*ResponseInfo) ProtoMessage()               {}
1253 func (*ResponseInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
1254
1255 func (m *ResponseInfo) GetData() string {
1256         if m != nil {
1257                 return m.Data
1258         }
1259         return ""
1260 }
1261
1262 func (m *ResponseInfo) GetVersion() string {
1263         if m != nil {
1264                 return m.Version
1265         }
1266         return ""
1267 }
1268
1269 func (m *ResponseInfo) GetLastBlockHeight() uint64 {
1270         if m != nil {
1271                 return m.LastBlockHeight
1272         }
1273         return 0
1274 }
1275
1276 func (m *ResponseInfo) GetLastBlockAppHash() []byte {
1277         if m != nil {
1278                 return m.LastBlockAppHash
1279         }
1280         return nil
1281 }
1282
1283 type ResponseSetOption struct {
1284         Log string `protobuf:"bytes,1,opt,name=log" json:"log,omitempty"`
1285 }
1286
1287 func (m *ResponseSetOption) Reset()                    { *m = ResponseSetOption{} }
1288 func (m *ResponseSetOption) String() string            { return proto.CompactTextString(m) }
1289 func (*ResponseSetOption) ProtoMessage()               {}
1290 func (*ResponseSetOption) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
1291
1292 func (m *ResponseSetOption) GetLog() string {
1293         if m != nil {
1294                 return m.Log
1295         }
1296         return ""
1297 }
1298
1299 type ResponseDeliverTx struct {
1300         Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
1301         Data []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
1302         Log  string   `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
1303 }
1304
1305 func (m *ResponseDeliverTx) Reset()                    { *m = ResponseDeliverTx{} }
1306 func (m *ResponseDeliverTx) String() string            { return proto.CompactTextString(m) }
1307 func (*ResponseDeliverTx) ProtoMessage()               {}
1308 func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
1309
1310 func (m *ResponseDeliverTx) GetCode() CodeType {
1311         if m != nil {
1312                 return m.Code
1313         }
1314         return CodeType_OK
1315 }
1316
1317 func (m *ResponseDeliverTx) GetData() []byte {
1318         if m != nil {
1319                 return m.Data
1320         }
1321         return nil
1322 }
1323
1324 func (m *ResponseDeliverTx) GetLog() string {
1325         if m != nil {
1326                 return m.Log
1327         }
1328         return ""
1329 }
1330
1331 type ResponseCheckTx struct {
1332         Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
1333         Data []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
1334         Log  string   `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
1335 }
1336
1337 func (m *ResponseCheckTx) Reset()                    { *m = ResponseCheckTx{} }
1338 func (m *ResponseCheckTx) String() string            { return proto.CompactTextString(m) }
1339 func (*ResponseCheckTx) ProtoMessage()               {}
1340 func (*ResponseCheckTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
1341
1342 func (m *ResponseCheckTx) GetCode() CodeType {
1343         if m != nil {
1344                 return m.Code
1345         }
1346         return CodeType_OK
1347 }
1348
1349 func (m *ResponseCheckTx) GetData() []byte {
1350         if m != nil {
1351                 return m.Data
1352         }
1353         return nil
1354 }
1355
1356 func (m *ResponseCheckTx) GetLog() string {
1357         if m != nil {
1358                 return m.Log
1359         }
1360         return ""
1361 }
1362
1363 type ResponseQuery struct {
1364         Code   CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
1365         Index  int64    `protobuf:"varint,2,opt,name=index" json:"index,omitempty"`
1366         Key    []byte   `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
1367         Value  []byte   `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
1368         Proof  []byte   `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof,omitempty"`
1369         Height uint64   `protobuf:"varint,6,opt,name=height" json:"height,omitempty"`
1370         Log    string   `protobuf:"bytes,7,opt,name=log" json:"log,omitempty"`
1371 }
1372
1373 func (m *ResponseQuery) Reset()                    { *m = ResponseQuery{} }
1374 func (m *ResponseQuery) String() string            { return proto.CompactTextString(m) }
1375 func (*ResponseQuery) ProtoMessage()               {}
1376 func (*ResponseQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
1377
1378 func (m *ResponseQuery) GetCode() CodeType {
1379         if m != nil {
1380                 return m.Code
1381         }
1382         return CodeType_OK
1383 }
1384
1385 func (m *ResponseQuery) GetIndex() int64 {
1386         if m != nil {
1387                 return m.Index
1388         }
1389         return 0
1390 }
1391
1392 func (m *ResponseQuery) GetKey() []byte {
1393         if m != nil {
1394                 return m.Key
1395         }
1396         return nil
1397 }
1398
1399 func (m *ResponseQuery) GetValue() []byte {
1400         if m != nil {
1401                 return m.Value
1402         }
1403         return nil
1404 }
1405
1406 func (m *ResponseQuery) GetProof() []byte {
1407         if m != nil {
1408                 return m.Proof
1409         }
1410         return nil
1411 }
1412
1413 func (m *ResponseQuery) GetHeight() uint64 {
1414         if m != nil {
1415                 return m.Height
1416         }
1417         return 0
1418 }
1419
1420 func (m *ResponseQuery) GetLog() string {
1421         if m != nil {
1422                 return m.Log
1423         }
1424         return ""
1425 }
1426
1427 type ResponseCommit struct {
1428         Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
1429         Data []byte   `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
1430         Log  string   `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
1431 }
1432
1433 func (m *ResponseCommit) Reset()                    { *m = ResponseCommit{} }
1434 func (m *ResponseCommit) String() string            { return proto.CompactTextString(m) }
1435 func (*ResponseCommit) ProtoMessage()               {}
1436 func (*ResponseCommit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
1437
1438 func (m *ResponseCommit) GetCode() CodeType {
1439         if m != nil {
1440                 return m.Code
1441         }
1442         return CodeType_OK
1443 }
1444
1445 func (m *ResponseCommit) GetData() []byte {
1446         if m != nil {
1447                 return m.Data
1448         }
1449         return nil
1450 }
1451
1452 func (m *ResponseCommit) GetLog() string {
1453         if m != nil {
1454                 return m.Log
1455         }
1456         return ""
1457 }
1458
1459 type ResponseInitChain struct {
1460 }
1461
1462 func (m *ResponseInitChain) Reset()                    { *m = ResponseInitChain{} }
1463 func (m *ResponseInitChain) String() string            { return proto.CompactTextString(m) }
1464 func (*ResponseInitChain) ProtoMessage()               {}
1465 func (*ResponseInitChain) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} }
1466
1467 type ResponseBeginBlock struct {
1468 }
1469
1470 func (m *ResponseBeginBlock) Reset()                    { *m = ResponseBeginBlock{} }
1471 func (m *ResponseBeginBlock) String() string            { return proto.CompactTextString(m) }
1472 func (*ResponseBeginBlock) ProtoMessage()               {}
1473 func (*ResponseBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} }
1474
1475 type ResponseEndBlock struct {
1476         Diffs []*Validator `protobuf:"bytes,1,rep,name=diffs" json:"diffs,omitempty"`
1477 }
1478
1479 func (m *ResponseEndBlock) Reset()                    { *m = ResponseEndBlock{} }
1480 func (m *ResponseEndBlock) String() string            { return proto.CompactTextString(m) }
1481 func (*ResponseEndBlock) ProtoMessage()               {}
1482 func (*ResponseEndBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} }
1483
1484 func (m *ResponseEndBlock) GetDiffs() []*Validator {
1485         if m != nil {
1486                 return m.Diffs
1487         }
1488         return nil
1489 }
1490
1491 type Header struct {
1492         ChainId        string   `protobuf:"bytes,1,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
1493         Height         uint64   `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
1494         Time           uint64   `protobuf:"varint,3,opt,name=time" json:"time,omitempty"`
1495         NumTxs         uint64   `protobuf:"varint,4,opt,name=num_txs,json=numTxs" json:"num_txs,omitempty"`
1496         LastBlockId    *BlockID `protobuf:"bytes,5,opt,name=last_block_id,json=lastBlockId" json:"last_block_id,omitempty"`
1497         LastCommitHash []byte   `protobuf:"bytes,6,opt,name=last_commit_hash,json=lastCommitHash,proto3" json:"last_commit_hash,omitempty"`
1498         DataHash       []byte   `protobuf:"bytes,7,opt,name=data_hash,json=dataHash,proto3" json:"data_hash,omitempty"`
1499         ValidatorsHash []byte   `protobuf:"bytes,8,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"`
1500         AppHash        []byte   `protobuf:"bytes,9,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
1501 }
1502
1503 func (m *Header) Reset()                    { *m = Header{} }
1504 func (m *Header) String() string            { return proto.CompactTextString(m) }
1505 func (*Header) ProtoMessage()               {}
1506 func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
1507
1508 func (m *Header) GetChainId() string {
1509         if m != nil {
1510                 return m.ChainId
1511         }
1512         return ""
1513 }
1514
1515 func (m *Header) GetHeight() uint64 {
1516         if m != nil {
1517                 return m.Height
1518         }
1519         return 0
1520 }
1521
1522 func (m *Header) GetTime() uint64 {
1523         if m != nil {
1524                 return m.Time
1525         }
1526         return 0
1527 }
1528
1529 func (m *Header) GetNumTxs() uint64 {
1530         if m != nil {
1531                 return m.NumTxs
1532         }
1533         return 0
1534 }
1535
1536 func (m *Header) GetLastBlockId() *BlockID {
1537         if m != nil {
1538                 return m.LastBlockId
1539         }
1540         return nil
1541 }
1542
1543 func (m *Header) GetLastCommitHash() []byte {
1544         if m != nil {
1545                 return m.LastCommitHash
1546         }
1547         return nil
1548 }
1549
1550 func (m *Header) GetDataHash() []byte {
1551         if m != nil {
1552                 return m.DataHash
1553         }
1554         return nil
1555 }
1556
1557 func (m *Header) GetValidatorsHash() []byte {
1558         if m != nil {
1559                 return m.ValidatorsHash
1560         }
1561         return nil
1562 }
1563
1564 func (m *Header) GetAppHash() []byte {
1565         if m != nil {
1566                 return m.AppHash
1567         }
1568         return nil
1569 }
1570
1571 type BlockID struct {
1572         Hash  []byte         `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
1573         Parts *PartSetHeader `protobuf:"bytes,2,opt,name=parts" json:"parts,omitempty"`
1574 }
1575
1576 func (m *BlockID) Reset()                    { *m = BlockID{} }
1577 func (m *BlockID) String() string            { return proto.CompactTextString(m) }
1578 func (*BlockID) ProtoMessage()               {}
1579 func (*BlockID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
1580
1581 func (m *BlockID) GetHash() []byte {
1582         if m != nil {
1583                 return m.Hash
1584         }
1585         return nil
1586 }
1587
1588 func (m *BlockID) GetParts() *PartSetHeader {
1589         if m != nil {
1590                 return m.Parts
1591         }
1592         return nil
1593 }
1594
1595 type PartSetHeader struct {
1596         Total uint64 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"`
1597         Hash  []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
1598 }
1599
1600 func (m *PartSetHeader) Reset()                    { *m = PartSetHeader{} }
1601 func (m *PartSetHeader) String() string            { return proto.CompactTextString(m) }
1602 func (*PartSetHeader) ProtoMessage()               {}
1603 func (*PartSetHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
1604
1605 func (m *PartSetHeader) GetTotal() uint64 {
1606         if m != nil {
1607                 return m.Total
1608         }
1609         return 0
1610 }
1611
1612 func (m *PartSetHeader) GetHash() []byte {
1613         if m != nil {
1614                 return m.Hash
1615         }
1616         return nil
1617 }
1618
1619 type Validator struct {
1620         PubKey []byte `protobuf:"bytes,1,opt,name=pubKey,proto3" json:"pubKey,omitempty"`
1621         Power  uint64 `protobuf:"varint,2,opt,name=power" json:"power,omitempty"`
1622 }
1623
1624 func (m *Validator) Reset()                    { *m = Validator{} }
1625 func (m *Validator) String() string            { return proto.CompactTextString(m) }
1626 func (*Validator) ProtoMessage()               {}
1627 func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
1628
1629 func (m *Validator) GetPubKey() []byte {
1630         if m != nil {
1631                 return m.PubKey
1632         }
1633         return nil
1634 }
1635
1636 func (m *Validator) GetPower() uint64 {
1637         if m != nil {
1638                 return m.Power
1639         }
1640         return 0
1641 }
1642
1643 func init() {
1644         proto.RegisterType((*Request)(nil), "types.Request")
1645         proto.RegisterType((*RequestEcho)(nil), "types.RequestEcho")
1646         proto.RegisterType((*RequestFlush)(nil), "types.RequestFlush")
1647         proto.RegisterType((*RequestInfo)(nil), "types.RequestInfo")
1648         proto.RegisterType((*RequestSetOption)(nil), "types.RequestSetOption")
1649         proto.RegisterType((*RequestDeliverTx)(nil), "types.RequestDeliverTx")
1650         proto.RegisterType((*RequestCheckTx)(nil), "types.RequestCheckTx")
1651         proto.RegisterType((*RequestQuery)(nil), "types.RequestQuery")
1652         proto.RegisterType((*RequestCommit)(nil), "types.RequestCommit")
1653         proto.RegisterType((*RequestInitChain)(nil), "types.RequestInitChain")
1654         proto.RegisterType((*RequestBeginBlock)(nil), "types.RequestBeginBlock")
1655         proto.RegisterType((*RequestEndBlock)(nil), "types.RequestEndBlock")
1656         proto.RegisterType((*Response)(nil), "types.Response")
1657         proto.RegisterType((*ResponseException)(nil), "types.ResponseException")
1658         proto.RegisterType((*ResponseEcho)(nil), "types.ResponseEcho")
1659         proto.RegisterType((*ResponseFlush)(nil), "types.ResponseFlush")
1660         proto.RegisterType((*ResponseInfo)(nil), "types.ResponseInfo")
1661         proto.RegisterType((*ResponseSetOption)(nil), "types.ResponseSetOption")
1662         proto.RegisterType((*ResponseDeliverTx)(nil), "types.ResponseDeliverTx")
1663         proto.RegisterType((*ResponseCheckTx)(nil), "types.ResponseCheckTx")
1664         proto.RegisterType((*ResponseQuery)(nil), "types.ResponseQuery")
1665         proto.RegisterType((*ResponseCommit)(nil), "types.ResponseCommit")
1666         proto.RegisterType((*ResponseInitChain)(nil), "types.ResponseInitChain")
1667         proto.RegisterType((*ResponseBeginBlock)(nil), "types.ResponseBeginBlock")
1668         proto.RegisterType((*ResponseEndBlock)(nil), "types.ResponseEndBlock")
1669         proto.RegisterType((*Header)(nil), "types.Header")
1670         proto.RegisterType((*BlockID)(nil), "types.BlockID")
1671         proto.RegisterType((*PartSetHeader)(nil), "types.PartSetHeader")
1672         proto.RegisterType((*Validator)(nil), "types.Validator")
1673         proto.RegisterEnum("types.CodeType", CodeType_name, CodeType_value)
1674 }
1675
1676 // Reference imports to suppress errors if they are not otherwise used.
1677 var _ context.Context
1678 var _ grpc.ClientConn
1679
1680 // This is a compile-time assertion to ensure that this generated file
1681 // is compatible with the grpc package it is being compiled against.
1682 const _ = grpc.SupportPackageIsVersion4
1683
1684 // Client API for ABCIApplication service
1685
1686 type ABCIApplicationClient interface {
1687         Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error)
1688         Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error)
1689         Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error)
1690         SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error)
1691         DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error)
1692         CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error)
1693         Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error)
1694         Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error)
1695         InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error)
1696         BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error)
1697         EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error)
1698 }
1699
1700 type aBCIApplicationClient struct {
1701         cc *grpc.ClientConn
1702 }
1703
1704 func NewABCIApplicationClient(cc *grpc.ClientConn) ABCIApplicationClient {
1705         return &aBCIApplicationClient{cc}
1706 }
1707
1708 func (c *aBCIApplicationClient) Echo(ctx context.Context, in *RequestEcho, opts ...grpc.CallOption) (*ResponseEcho, error) {
1709         out := new(ResponseEcho)
1710         err := grpc.Invoke(ctx, "/types.ABCIApplication/Echo", in, out, c.cc, opts...)
1711         if err != nil {
1712                 return nil, err
1713         }
1714         return out, nil
1715 }
1716
1717 func (c *aBCIApplicationClient) Flush(ctx context.Context, in *RequestFlush, opts ...grpc.CallOption) (*ResponseFlush, error) {
1718         out := new(ResponseFlush)
1719         err := grpc.Invoke(ctx, "/types.ABCIApplication/Flush", in, out, c.cc, opts...)
1720         if err != nil {
1721                 return nil, err
1722         }
1723         return out, nil
1724 }
1725
1726 func (c *aBCIApplicationClient) Info(ctx context.Context, in *RequestInfo, opts ...grpc.CallOption) (*ResponseInfo, error) {
1727         out := new(ResponseInfo)
1728         err := grpc.Invoke(ctx, "/types.ABCIApplication/Info", in, out, c.cc, opts...)
1729         if err != nil {
1730                 return nil, err
1731         }
1732         return out, nil
1733 }
1734
1735 func (c *aBCIApplicationClient) SetOption(ctx context.Context, in *RequestSetOption, opts ...grpc.CallOption) (*ResponseSetOption, error) {
1736         out := new(ResponseSetOption)
1737         err := grpc.Invoke(ctx, "/types.ABCIApplication/SetOption", in, out, c.cc, opts...)
1738         if err != nil {
1739                 return nil, err
1740         }
1741         return out, nil
1742 }
1743
1744 func (c *aBCIApplicationClient) DeliverTx(ctx context.Context, in *RequestDeliverTx, opts ...grpc.CallOption) (*ResponseDeliverTx, error) {
1745         out := new(ResponseDeliverTx)
1746         err := grpc.Invoke(ctx, "/types.ABCIApplication/DeliverTx", in, out, c.cc, opts...)
1747         if err != nil {
1748                 return nil, err
1749         }
1750         return out, nil
1751 }
1752
1753 func (c *aBCIApplicationClient) CheckTx(ctx context.Context, in *RequestCheckTx, opts ...grpc.CallOption) (*ResponseCheckTx, error) {
1754         out := new(ResponseCheckTx)
1755         err := grpc.Invoke(ctx, "/types.ABCIApplication/CheckTx", in, out, c.cc, opts...)
1756         if err != nil {
1757                 return nil, err
1758         }
1759         return out, nil
1760 }
1761
1762 func (c *aBCIApplicationClient) Query(ctx context.Context, in *RequestQuery, opts ...grpc.CallOption) (*ResponseQuery, error) {
1763         out := new(ResponseQuery)
1764         err := grpc.Invoke(ctx, "/types.ABCIApplication/Query", in, out, c.cc, opts...)
1765         if err != nil {
1766                 return nil, err
1767         }
1768         return out, nil
1769 }
1770
1771 func (c *aBCIApplicationClient) Commit(ctx context.Context, in *RequestCommit, opts ...grpc.CallOption) (*ResponseCommit, error) {
1772         out := new(ResponseCommit)
1773         err := grpc.Invoke(ctx, "/types.ABCIApplication/Commit", in, out, c.cc, opts...)
1774         if err != nil {
1775                 return nil, err
1776         }
1777         return out, nil
1778 }
1779
1780 func (c *aBCIApplicationClient) InitChain(ctx context.Context, in *RequestInitChain, opts ...grpc.CallOption) (*ResponseInitChain, error) {
1781         out := new(ResponseInitChain)
1782         err := grpc.Invoke(ctx, "/types.ABCIApplication/InitChain", in, out, c.cc, opts...)
1783         if err != nil {
1784                 return nil, err
1785         }
1786         return out, nil
1787 }
1788
1789 func (c *aBCIApplicationClient) BeginBlock(ctx context.Context, in *RequestBeginBlock, opts ...grpc.CallOption) (*ResponseBeginBlock, error) {
1790         out := new(ResponseBeginBlock)
1791         err := grpc.Invoke(ctx, "/types.ABCIApplication/BeginBlock", in, out, c.cc, opts...)
1792         if err != nil {
1793                 return nil, err
1794         }
1795         return out, nil
1796 }
1797
1798 func (c *aBCIApplicationClient) EndBlock(ctx context.Context, in *RequestEndBlock, opts ...grpc.CallOption) (*ResponseEndBlock, error) {
1799         out := new(ResponseEndBlock)
1800         err := grpc.Invoke(ctx, "/types.ABCIApplication/EndBlock", in, out, c.cc, opts...)
1801         if err != nil {
1802                 return nil, err
1803         }
1804         return out, nil
1805 }
1806
1807 // Server API for ABCIApplication service
1808
1809 type ABCIApplicationServer interface {
1810         Echo(context.Context, *RequestEcho) (*ResponseEcho, error)
1811         Flush(context.Context, *RequestFlush) (*ResponseFlush, error)
1812         Info(context.Context, *RequestInfo) (*ResponseInfo, error)
1813         SetOption(context.Context, *RequestSetOption) (*ResponseSetOption, error)
1814         DeliverTx(context.Context, *RequestDeliverTx) (*ResponseDeliverTx, error)
1815         CheckTx(context.Context, *RequestCheckTx) (*ResponseCheckTx, error)
1816         Query(context.Context, *RequestQuery) (*ResponseQuery, error)
1817         Commit(context.Context, *RequestCommit) (*ResponseCommit, error)
1818         InitChain(context.Context, *RequestInitChain) (*ResponseInitChain, error)
1819         BeginBlock(context.Context, *RequestBeginBlock) (*ResponseBeginBlock, error)
1820         EndBlock(context.Context, *RequestEndBlock) (*ResponseEndBlock, error)
1821 }
1822
1823 func RegisterABCIApplicationServer(s *grpc.Server, srv ABCIApplicationServer) {
1824         s.RegisterService(&_ABCIApplication_serviceDesc, srv)
1825 }
1826
1827 func _ABCIApplication_Echo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1828         in := new(RequestEcho)
1829         if err := dec(in); err != nil {
1830                 return nil, err
1831         }
1832         if interceptor == nil {
1833                 return srv.(ABCIApplicationServer).Echo(ctx, in)
1834         }
1835         info := &grpc.UnaryServerInfo{
1836                 Server:     srv,
1837                 FullMethod: "/types.ABCIApplication/Echo",
1838         }
1839         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1840                 return srv.(ABCIApplicationServer).Echo(ctx, req.(*RequestEcho))
1841         }
1842         return interceptor(ctx, in, info, handler)
1843 }
1844
1845 func _ABCIApplication_Flush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1846         in := new(RequestFlush)
1847         if err := dec(in); err != nil {
1848                 return nil, err
1849         }
1850         if interceptor == nil {
1851                 return srv.(ABCIApplicationServer).Flush(ctx, in)
1852         }
1853         info := &grpc.UnaryServerInfo{
1854                 Server:     srv,
1855                 FullMethod: "/types.ABCIApplication/Flush",
1856         }
1857         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1858                 return srv.(ABCIApplicationServer).Flush(ctx, req.(*RequestFlush))
1859         }
1860         return interceptor(ctx, in, info, handler)
1861 }
1862
1863 func _ABCIApplication_Info_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1864         in := new(RequestInfo)
1865         if err := dec(in); err != nil {
1866                 return nil, err
1867         }
1868         if interceptor == nil {
1869                 return srv.(ABCIApplicationServer).Info(ctx, in)
1870         }
1871         info := &grpc.UnaryServerInfo{
1872                 Server:     srv,
1873                 FullMethod: "/types.ABCIApplication/Info",
1874         }
1875         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1876                 return srv.(ABCIApplicationServer).Info(ctx, req.(*RequestInfo))
1877         }
1878         return interceptor(ctx, in, info, handler)
1879 }
1880
1881 func _ABCIApplication_SetOption_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1882         in := new(RequestSetOption)
1883         if err := dec(in); err != nil {
1884                 return nil, err
1885         }
1886         if interceptor == nil {
1887                 return srv.(ABCIApplicationServer).SetOption(ctx, in)
1888         }
1889         info := &grpc.UnaryServerInfo{
1890                 Server:     srv,
1891                 FullMethod: "/types.ABCIApplication/SetOption",
1892         }
1893         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1894                 return srv.(ABCIApplicationServer).SetOption(ctx, req.(*RequestSetOption))
1895         }
1896         return interceptor(ctx, in, info, handler)
1897 }
1898
1899 func _ABCIApplication_DeliverTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1900         in := new(RequestDeliverTx)
1901         if err := dec(in); err != nil {
1902                 return nil, err
1903         }
1904         if interceptor == nil {
1905                 return srv.(ABCIApplicationServer).DeliverTx(ctx, in)
1906         }
1907         info := &grpc.UnaryServerInfo{
1908                 Server:     srv,
1909                 FullMethod: "/types.ABCIApplication/DeliverTx",
1910         }
1911         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1912                 return srv.(ABCIApplicationServer).DeliverTx(ctx, req.(*RequestDeliverTx))
1913         }
1914         return interceptor(ctx, in, info, handler)
1915 }
1916
1917 func _ABCIApplication_CheckTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1918         in := new(RequestCheckTx)
1919         if err := dec(in); err != nil {
1920                 return nil, err
1921         }
1922         if interceptor == nil {
1923                 return srv.(ABCIApplicationServer).CheckTx(ctx, in)
1924         }
1925         info := &grpc.UnaryServerInfo{
1926                 Server:     srv,
1927                 FullMethod: "/types.ABCIApplication/CheckTx",
1928         }
1929         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1930                 return srv.(ABCIApplicationServer).CheckTx(ctx, req.(*RequestCheckTx))
1931         }
1932         return interceptor(ctx, in, info, handler)
1933 }
1934
1935 func _ABCIApplication_Query_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1936         in := new(RequestQuery)
1937         if err := dec(in); err != nil {
1938                 return nil, err
1939         }
1940         if interceptor == nil {
1941                 return srv.(ABCIApplicationServer).Query(ctx, in)
1942         }
1943         info := &grpc.UnaryServerInfo{
1944                 Server:     srv,
1945                 FullMethod: "/types.ABCIApplication/Query",
1946         }
1947         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1948                 return srv.(ABCIApplicationServer).Query(ctx, req.(*RequestQuery))
1949         }
1950         return interceptor(ctx, in, info, handler)
1951 }
1952
1953 func _ABCIApplication_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1954         in := new(RequestCommit)
1955         if err := dec(in); err != nil {
1956                 return nil, err
1957         }
1958         if interceptor == nil {
1959                 return srv.(ABCIApplicationServer).Commit(ctx, in)
1960         }
1961         info := &grpc.UnaryServerInfo{
1962                 Server:     srv,
1963                 FullMethod: "/types.ABCIApplication/Commit",
1964         }
1965         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1966                 return srv.(ABCIApplicationServer).Commit(ctx, req.(*RequestCommit))
1967         }
1968         return interceptor(ctx, in, info, handler)
1969 }
1970
1971 func _ABCIApplication_InitChain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1972         in := new(RequestInitChain)
1973         if err := dec(in); err != nil {
1974                 return nil, err
1975         }
1976         if interceptor == nil {
1977                 return srv.(ABCIApplicationServer).InitChain(ctx, in)
1978         }
1979         info := &grpc.UnaryServerInfo{
1980                 Server:     srv,
1981                 FullMethod: "/types.ABCIApplication/InitChain",
1982         }
1983         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
1984                 return srv.(ABCIApplicationServer).InitChain(ctx, req.(*RequestInitChain))
1985         }
1986         return interceptor(ctx, in, info, handler)
1987 }
1988
1989 func _ABCIApplication_BeginBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
1990         in := new(RequestBeginBlock)
1991         if err := dec(in); err != nil {
1992                 return nil, err
1993         }
1994         if interceptor == nil {
1995                 return srv.(ABCIApplicationServer).BeginBlock(ctx, in)
1996         }
1997         info := &grpc.UnaryServerInfo{
1998                 Server:     srv,
1999                 FullMethod: "/types.ABCIApplication/BeginBlock",
2000         }
2001         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2002                 return srv.(ABCIApplicationServer).BeginBlock(ctx, req.(*RequestBeginBlock))
2003         }
2004         return interceptor(ctx, in, info, handler)
2005 }
2006
2007 func _ABCIApplication_EndBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
2008         in := new(RequestEndBlock)
2009         if err := dec(in); err != nil {
2010                 return nil, err
2011         }
2012         if interceptor == nil {
2013                 return srv.(ABCIApplicationServer).EndBlock(ctx, in)
2014         }
2015         info := &grpc.UnaryServerInfo{
2016                 Server:     srv,
2017                 FullMethod: "/types.ABCIApplication/EndBlock",
2018         }
2019         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
2020                 return srv.(ABCIApplicationServer).EndBlock(ctx, req.(*RequestEndBlock))
2021         }
2022         return interceptor(ctx, in, info, handler)
2023 }
2024
2025 var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
2026         ServiceName: "types.ABCIApplication",
2027         HandlerType: (*ABCIApplicationServer)(nil),
2028         Methods: []grpc.MethodDesc{
2029                 {
2030                         MethodName: "Echo",
2031                         Handler:    _ABCIApplication_Echo_Handler,
2032                 },
2033                 {
2034                         MethodName: "Flush",
2035                         Handler:    _ABCIApplication_Flush_Handler,
2036                 },
2037                 {
2038                         MethodName: "Info",
2039                         Handler:    _ABCIApplication_Info_Handler,
2040                 },
2041                 {
2042                         MethodName: "SetOption",
2043                         Handler:    _ABCIApplication_SetOption_Handler,
2044                 },
2045                 {
2046                         MethodName: "DeliverTx",
2047                         Handler:    _ABCIApplication_DeliverTx_Handler,
2048                 },
2049                 {
2050                         MethodName: "CheckTx",
2051                         Handler:    _ABCIApplication_CheckTx_Handler,
2052                 },
2053                 {
2054                         MethodName: "Query",
2055                         Handler:    _ABCIApplication_Query_Handler,
2056                 },
2057                 {
2058                         MethodName: "Commit",
2059                         Handler:    _ABCIApplication_Commit_Handler,
2060                 },
2061                 {
2062                         MethodName: "InitChain",
2063                         Handler:    _ABCIApplication_InitChain_Handler,
2064                 },
2065                 {
2066                         MethodName: "BeginBlock",
2067                         Handler:    _ABCIApplication_BeginBlock_Handler,
2068                 },
2069                 {
2070                         MethodName: "EndBlock",
2071                         Handler:    _ABCIApplication_EndBlock_Handler,
2072                 },
2073         },
2074         Streams:  []grpc.StreamDesc{},
2075         Metadata: "types/types.proto",
2076 }
2077
2078 func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }
2079
2080 var fileDescriptor0 = []byte{
2081         // 1625 bytes of a gzipped FileDescriptorProto
2082         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x59, 0x6f, 0xdb, 0xc6,
2083         0x16, 0x36, 0xb5, 0xeb, 0xd8, 0x96, 0xe9, 0xb1, 0x6c, 0xcb, 0xba, 0xf7, 0x21, 0xe0, 0x45, 0x6e,
2084         0xec, 0xdc, 0xdc, 0xa4, 0x70, 0x90, 0x22, 0x6e, 0x8a, 0x02, 0xde, 0x62, 0x0b, 0x41, 0x13, 0x97,
2085         0x59, 0x5e, 0x5a, 0x54, 0xa0, 0xc9, 0x91, 0xc4, 0x5a, 0x9a, 0x61, 0xc8, 0xa1, 0x23, 0xf7, 0x37,
2086         0xe4, 0xbd, 0x3f, 0xa1, 0xef, 0x05, 0xfa, 0x17, 0x0a, 0x74, 0x5f, 0x7e, 0x51, 0x31, 0x0b, 0x57,
2087         0x93, 0x41, 0x1f, 0xf2, 0x22, 0xf0, 0x6c, 0x33, 0x73, 0xce, 0x9c, 0xf3, 0x9d, 0x33, 0x82, 0x55,
2088         0x76, 0xe5, 0xe1, 0xe0, 0x9e, 0xf8, 0xbd, 0xeb, 0xf9, 0x94, 0x51, 0x54, 0x17, 0x84, 0xf1, 0x43,
2089         0x0d, 0x9a, 0x26, 0x7e, 0x1d, 0xe2, 0x80, 0xa1, 0x6d, 0xa8, 0x61, 0x7b, 0x42, 0x7b, 0xda, 0x0d,
2090         0x6d, 0x7b, 0x71, 0x17, 0xdd, 0x95, 0xea, 0x4a, 0x7a, 0x6c, 0x4f, 0xe8, 0xe9, 0x82, 0x29, 0x34,
2091         0xd0, 0xff, 0xa0, 0x3e, 0x9a, 0x86, 0xc1, 0xa4, 0x57, 0x11, 0xaa, 0x6b, 0x59, 0xd5, 0xc7, 0x5c,
2092         0x74, 0xba, 0x60, 0x4a, 0x1d, 0xbe, 0xac, 0x4b, 0x46, 0xb4, 0x57, 0x2d, 0x5a, 0x76, 0x40, 0x46,
2093         0x62, 0x59, 0xae, 0x81, 0x1e, 0x02, 0x04, 0x98, 0x0d, 0xa9, 0xc7, 0x5c, 0x4a, 0x7a, 0x35, 0xa1,
2094         0xbf, 0x99, 0xd5, 0x7f, 0x8e, 0xd9, 0x33, 0x21, 0x3e, 0x5d, 0x30, 0xdb, 0x41, 0x44, 0x70, 0x4b,
2095         0x07, 0x4f, 0xdd, 0x4b, 0xec, 0x0f, 0xd9, 0xbc, 0x57, 0x2f, 0xb2, 0x3c, 0x92, 0xf2, 0x17, 0x73,
2096         0x6e, 0xe9, 0x44, 0x04, 0xda, 0x85, 0x96, 0x3d, 0xc1, 0xf6, 0x05, 0xb7, 0x6b, 0x08, 0xbb, 0xf5,
2097         0xac, 0xdd, 0x21, 0x97, 0x0a, 0xab, 0xa6, 0x2d, 0x3f, 0xd1, 0x5d, 0x68, 0xd8, 0x74, 0x36, 0x73,
2098         0x59, 0xaf, 0x29, 0x2c, 0xba, 0x39, 0x0b, 0x21, 0x3b, 0x5d, 0x30, 0x95, 0x16, 0x0f, 0xd7, 0xeb,
2099         0x10, 0xfb, 0x57, 0xbd, 0x56, 0x51, 0xb8, 0x3e, 0xe3, 0x22, 0x1e, 0x2e, 0xa1, 0xc3, 0x5d, 0x71,
2100         0x89, 0xcb, 0x86, 0xf6, 0xc4, 0x72, 0x49, 0xaf, 0x5d, 0xe4, 0xca, 0x80, 0xb8, 0xec, 0x90, 0x8b,
2101         0xb9, 0x2b, 0x6e, 0x44, 0xa0, 0x47, 0xb0, 0x78, 0x8e, 0xc7, 0x2e, 0x19, 0x9e, 0x4f, 0xa9, 0x7d,
2102         0xd1, 0x03, 0x61, 0xda, 0xcb, 0x9a, 0x1e, 0x70, 0x85, 0x03, 0x2e, 0x3f, 0x5d, 0x30, 0xe1, 0x3c,
2103         0xa6, 0xd0, 0x03, 0x68, 0x63, 0xe2, 0x28, 0xd3, 0x45, 0x61, 0xba, 0x91, 0xcb, 0x00, 0xe2, 0x44,
2104         0x86, 0x2d, 0xac, 0xbe, 0x0f, 0x9a, 0x50, 0xbf, 0xb4, 0xa6, 0x21, 0x36, 0x6e, 0xc1, 0x62, 0x2a,
2105         0x53, 0x50, 0x0f, 0x9a, 0x33, 0x1c, 0x04, 0xd6, 0x18, 0x8b, 0x74, 0x6a, 0x9b, 0x11, 0x69, 0x74,
2106         0x60, 0x29, 0x9d, 0x27, 0x29, 0x43, 0x9e, 0x0b, 0xdc, 0xf0, 0x12, 0xfb, 0x01, 0x4f, 0x00, 0x65,
2107         0xa8, 0x48, 0xe3, 0x23, 0xd0, 0xf3, 0x49, 0x80, 0x74, 0xa8, 0x5e, 0xe0, 0x2b, 0xa5, 0xc9, 0x3f,
2108         0x51, 0x57, 0x1d, 0x48, 0xa4, 0x66, 0xdb, 0x54, 0xa7, 0x33, 0x62, 0xdb, 0x38, 0x0d, 0x50, 0x07,
2109         0x2a, 0x6c, 0x2e, 0x4c, 0x97, 0xcc, 0x0a, 0x9b, 0x1b, 0x37, 0xa0, 0x93, 0xbd, 0xf2, 0x6b, 0x1a,
2110         0x4e, 0x7c, 0x74, 0x71, 0x67, 0x08, 0x41, 0xcd, 0xb1, 0x98, 0xa5, 0x34, 0xc4, 0x37, 0xe7, 0x79,
2111         0x16, 0x9b, 0xa8, 0xed, 0xc5, 0x37, 0xda, 0x80, 0xc6, 0x04, 0xbb, 0xe3, 0x09, 0x13, 0x35, 0x50,
2112         0x33, 0x15, 0xc5, 0xcf, 0xea, 0xf9, 0xf4, 0x12, 0x8b, 0x54, 0x6f, 0x99, 0x92, 0x30, 0x56, 0x60,
2113         0x39, 0x93, 0x48, 0xc6, 0x51, 0x7c, 0xf8, 0xf8, 0xe2, 0xd1, 0x07, 0x00, 0x97, 0xd6, 0xd4, 0x75,
2114         0x2c, 0x46, 0xfd, 0xa0, 0xa7, 0xdd, 0xa8, 0x6e, 0x2f, 0xee, 0xea, 0xea, 0xbe, 0x5e, 0x45, 0x02,
2115         0x33, 0xa5, 0x63, 0x3c, 0x85, 0xd5, 0x6b, 0x39, 0xc0, 0x4f, 0x3b, 0xb1, 0x82, 0x49, 0xe4, 0x01,
2116         0xff, 0x46, 0x37, 0xf9, 0x69, 0x2d, 0x07, 0xfb, 0xaa, 0xba, 0x97, 0xd5, 0xb2, 0xa7, 0x82, 0x69,
2117         0x2a, 0xa1, 0xb1, 0x03, 0x2b, 0xb9, 0xc4, 0x48, 0xf9, 0xa9, 0xa5, 0xfd, 0x34, 0xde, 0xd6, 0xa1,
2118         0x65, 0xe2, 0xc0, 0xa3, 0x24, 0xc0, 0xe8, 0x21, 0xb4, 0xf1, 0xdc, 0xc6, 0xb2, 0xc6, 0xb5, 0x5c,
2119         0x8e, 0x4a, 0x9d, 0xe3, 0x48, 0xce, 0xf3, 0x3b, 0x56, 0x46, 0x3b, 0x0a, 0x9f, 0xf2, 0xa0, 0xa3,
2120         0x8c, 0xd2, 0x00, 0x75, 0x27, 0x02, 0xa8, 0x6a, 0xae, 0x40, 0xa5, 0x6e, 0x0e, 0xa1, 0x76, 0x14,
2121         0x42, 0xd5, 0x0a, 0x17, 0xce, 0x40, 0xd4, 0x5e, 0x06, 0xa2, 0xea, 0x85, 0xc7, 0x2f, 0xc1, 0xa8,
2122         0xbd, 0x0c, 0x46, 0x35, 0x0a, 0x4d, 0x4b, 0x40, 0xea, 0x7e, 0x0a, 0xa4, 0x9a, 0xb9, 0xda, 0x94,
2123         0x86, 0x05, 0x28, 0x75, 0x2f, 0x46, 0xa9, 0x56, 0x0e, 0xd7, 0x94, 0x49, 0x1e, 0xa6, 0xee, 0x44,
2124         0x30, 0xd5, 0x2e, 0x0c, 0x5a, 0x0e, 0xa7, 0xf6, 0x32, 0x38, 0x05, 0x85, 0xee, 0x94, 0x00, 0xd5,
2125         0xc7, 0x59, 0xa0, 0x92, 0x68, 0xb3, 0x95, 0xb3, 0x2d, 0x45, 0xaa, 0x0f, 0xd3, 0x48, 0xb5, 0x94,
2126         0xc3, 0x47, 0x95, 0x0b, 0xef, 0x84, 0xaa, 0x1d, 0x5e, 0x09, 0xb9, 0x4c, 0xe3, 0xb5, 0x88, 0x7d,
2127         0x9f, 0xfa, 0x0a, 0x4b, 0x24, 0x61, 0x6c, 0xf3, 0x8a, 0x4f, 0xf2, 0xeb, 0x1d, 0xb0, 0x26, 0xaa,
2128         0x36, 0x95, 0x5d, 0xc6, 0x37, 0x5a, 0x62, 0x2b, 0x90, 0x2d, 0x8d, 0x16, 0x6d, 0x85, 0x16, 0x29,
2129         0xb4, 0xab, 0x64, 0xd0, 0x0e, 0xdd, 0x86, 0xd5, 0xa9, 0x15, 0x30, 0xe9, 0xe6, 0x30, 0x03, 0x1f,
2130         0x2b, 0x5c, 0x20, 0xfd, 0x93, 0x38, 0xf2, 0x7f, 0x58, 0x4b, 0xe9, 0x5a, 0x9e, 0x37, 0x14, 0x45,
2131         0x5d, 0x13, 0x45, 0xad, 0xc7, 0xda, 0xfb, 0x9e, 0x77, 0x6a, 0x05, 0x13, 0xe3, 0x66, 0xe2, 0x7f,
2132         0x06, 0x49, 0xa7, 0x74, 0x1c, 0x21, 0xe9, 0x94, 0x8e, 0x8d, 0x2f, 0x13, 0xb5, 0x04, 0x34, 0xff,
2133         0x03, 0x35, 0x9b, 0x3a, 0xd2, 0xfb, 0xce, 0xee, 0x8a, 0x8a, 0xfb, 0x21, 0x75, 0xf0, 0x8b, 0x2b,
2134         0x0f, 0x9b, 0x42, 0x18, 0x7b, 0x5a, 0x49, 0xe1, 0xa2, 0x5a, 0xbf, 0x9a, 0xac, 0xff, 0x05, 0x07,
2135         0x90, 0x4c, 0xf6, 0xbe, 0xcf, 0xd5, 0xbf, 0xd3, 0x92, 0x0b, 0x91, 0x68, 0xfd, 0x8f, 0x16, 0xef,
2136         0x42, 0xdd, 0x25, 0x0e, 0x9e, 0x8b, 0xd5, 0xab, 0xa6, 0x24, 0xa2, 0x36, 0x53, 0x15, 0x3b, 0x66,
2137         0xdb, 0x8c, 0x0c, 0xb2, 0x24, 0x14, 0xa0, 0xd3, 0x91, 0x00, 0x86, 0x25, 0x53, 0x12, 0x29, 0x58,
2138         0x6c, 0x64, 0xe0, 0x5f, 0x1d, 0xba, 0x99, 0x1c, 0xfa, 0x73, 0xde, 0x82, 0xd2, 0xd5, 0xf9, 0x3e,
2139         0x23, 0xb2, 0x96, 0xdc, 0x67, 0x5c, 0x97, 0x46, 0x17, 0xd0, 0xf5, 0x82, 0x93, 0xad, 0x36, 0x5b,
2140         0x4a, 0xe8, 0xbf, 0x50, 0x77, 0xdc, 0xd1, 0xa8, 0xbc, 0xd9, 0x48, 0xb1, 0xf1, 0x6d, 0x05, 0x1a,
2141         0xb2, 0x55, 0xa0, 0x2d, 0x0e, 0x5b, 0x96, 0x4b, 0x86, 0xae, 0x13, 0x95, 0x8b, 0xa0, 0x07, 0x4e,
2142         0x2a, 0x26, 0x95, 0x4c, 0x4c, 0x10, 0xd4, 0x98, 0x3b, 0xc3, 0x2a, 0xd3, 0xc5, 0x37, 0xda, 0x84,
2143         0x26, 0x09, 0x67, 0x43, 0x36, 0x0f, 0x44, 0xb4, 0x6b, 0x66, 0x83, 0x84, 0xb3, 0x17, 0xf3, 0x00,
2144         0xed, 0xc2, 0x72, 0x2a, 0xef, 0x5d, 0x47, 0xe1, 0x71, 0x47, 0x1d, 0x4d, 0x9c, 0x7b, 0x70, 0x64,
2145         0x2e, 0xc6, 0x15, 0x30, 0x70, 0xd0, 0x36, 0x88, 0x82, 0x18, 0x4a, 0xcc, 0x93, 0x85, 0xd2, 0x10,
2146         0x71, 0xeb, 0x70, 0xbe, 0x02, 0x45, 0xde, 0x07, 0xff, 0x05, 0x6d, 0x1e, 0x49, 0xa9, 0xd2, 0x14,
2147         0x2a, 0x2d, 0xce, 0x10, 0xc2, 0x5b, 0xb0, 0x92, 0xf4, 0x56, 0xa9, 0xd2, 0x92, 0xab, 0x24, 0x6c,
2148         0xa1, 0xb8, 0x05, 0xad, 0xb8, 0x20, 0xdb, 0x42, 0xa3, 0x69, 0xa9, 0x3a, 0x1c, 0x40, 0x53, 0x1d,
2149         0xb1, 0xb0, 0x0f, 0xdf, 0x86, 0xba, 0x67, 0xf9, 0x2c, 0x50, 0xfd, 0x2e, 0x82, 0xe3, 0x33, 0xcb,
2150         0xe7, 0x03, 0x90, 0xea, 0xc6, 0x52, 0xc5, 0xd8, 0x83, 0xe5, 0x0c, 0x9f, 0x67, 0x22, 0xa3, 0xcc,
2151         0x9a, 0xaa, 0x4e, 0x2c, 0x89, 0x78, 0x9b, 0x4a, 0xb2, 0x8d, 0xb1, 0x07, 0xed, 0xf8, 0x0e, 0xf9,
2152         0xb5, 0x78, 0xe1, 0xf9, 0x13, 0x35, 0x52, 0x2d, 0x99, 0x8a, 0x12, 0x89, 0x4d, 0xdf, 0xa8, 0x91,
2153         0xa0, 0x66, 0x4a, 0xe2, 0xf6, 0xf7, 0x75, 0x68, 0x45, 0xa9, 0x88, 0x1a, 0x50, 0x79, 0xf6, 0x44,
2154         0x5f, 0x40, 0xab, 0xb0, 0x3c, 0x20, 0x0c, 0xfb, 0xc4, 0x9a, 0x1e, 0x73, 0x0c, 0xd5, 0x35, 0xce,
2155         0x3a, 0x26, 0x36, 0x75, 0x5c, 0x32, 0x96, 0xac, 0x0a, 0x5a, 0x82, 0xd6, 0x81, 0xe5, 0x3c, 0xa5,
2156         0xc4, 0xc6, 0x7a, 0x15, 0xe9, 0xb0, 0xf4, 0x92, 0x58, 0x21, 0x9b, 0x50, 0xdf, 0xfd, 0x1a, 0x3b,
2157         0x7a, 0x0d, 0xad, 0xc3, 0xea, 0x80, 0x04, 0xe1, 0x68, 0xe4, 0xda, 0x2e, 0x26, 0xec, 0x71, 0x48,
2158         0x9c, 0x40, 0xaf, 0x23, 0x04, 0x9d, 0x97, 0xe4, 0x82, 0xd0, 0x37, 0x44, 0xcd, 0x1e, 0x7a, 0x03,
2159         0xf5, 0xa0, 0x7b, 0x60, 0x05, 0xf8, 0x28, 0xf4, 0xa6, 0xae, 0x6d, 0x31, 0xbc, 0xef, 0x38, 0x3e,
2160         0x0e, 0x02, 0x1d, 0xf3, 0x45, 0xb8, 0x24, 0xbb, 0xf7, 0x28, 0x32, 0xc8, 0xac, 0x8f, 0x71, 0xa0,
2161         0x8f, 0xd1, 0x16, 0xac, 0x5f, 0x93, 0x88, 0x9d, 0x27, 0xe8, 0xdf, 0xd0, 0xcb, 0x8b, 0x4e, 0xac,
2162         0xe0, 0xcc, 0x77, 0x6d, 0xac, 0xbb, 0xa8, 0x0b, 0xba, 0x94, 0x8a, 0xdb, 0x1f, 0x10, 0x2f, 0x64,
2163         0xfa, 0x57, 0xd1, 0xfe, 0x8a, 0xfb, 0x2c, 0x64, 0x9c, 0x7d, 0x91, 0x63, 0x9f, 0x89, 0x08, 0xeb,
2164         0x53, 0xb4, 0x09, 0x6b, 0x29, 0xf6, 0x73, 0xee, 0x1f, 0x8f, 0xce, 0x2c, 0x39, 0xaf, 0x14, 0xb8,
2165         0x63, 0x62, 0xb1, 0xd0, 0xc7, 0x3a, 0x41, 0x1b, 0x80, 0xb8, 0x44, 0x85, 0x24, 0x72, 0x9c, 0x46,
2166         0x3b, 0x28, 0xbe, 0xda, 0xc1, 0xcb, 0xb3, 0xa7, 0xe1, 0xd8, 0x25, 0xfa, 0x6b, 0xb4, 0x0e, 0xfa,
2167         0x09, 0xbd, 0x54, 0xdc, 0x63, 0xc2, 0x5c, 0x76, 0xa5, 0xff, 0xa8, 0xa1, 0x2e, 0xac, 0x24, 0xec,
2168         0x13, 0x9f, 0x86, 0x9e, 0xfe, 0x93, 0x86, 0x36, 0x01, 0x25, 0xdc, 0x33, 0x9f, 0x7a, 0x34, 0xb0,
2169         0xa6, 0xfa, 0xcf, 0x1a, 0xda, 0x80, 0xd5, 0x13, 0x7a, 0x19, 0xdf, 0x82, 0x34, 0xf8, 0x25, 0x32,
2170         0x88, 0xf9, 0x9f, 0xe2, 0xd9, 0x39, 0xf6, 0xf5, 0x5f, 0x35, 0xb4, 0x05, 0xdd, 0xb4, 0x20, 0x5e,
2171         0xeb, 0x37, 0x4d, 0x9d, 0x28, 0x16, 0xbd, 0xa2, 0x0c, 0xeb, 0xbf, 0x47, 0x6c, 0x15, 0x07, 0xb5,
2172         0xd0, 0x1f, 0x1a, 0x5a, 0x83, 0x4e, 0xc2, 0x16, 0xba, 0x7f, 0x6a, 0xa8, 0x0f, 0xeb, 0x19, 0xa6,
2173         0x4b, 0xc6, 0x67, 0x3c, 0x69, 0xf5, 0xbf, 0xb4, 0xdd, 0xb7, 0x75, 0x58, 0xd9, 0x3f, 0x38, 0x1c,
2174         0xec, 0x7b, 0x72, 0x03, 0xde, 0xff, 0xee, 0x41, 0x4d, 0x74, 0xf8, 0x82, 0x67, 0x6f, 0xbf, 0x68,
2175         0xd4, 0x44, 0xbb, 0x50, 0x17, 0x8d, 0x1e, 0x15, 0xbd, 0x7e, 0xfb, 0x85, 0x13, 0x27, 0xdf, 0x44,
2176         0x8e, 0x02, 0xd7, 0x1f, 0xc1, 0xfd, 0xa2, 0xb1, 0x13, 0x7d, 0x02, 0xed, 0xa4, 0x45, 0x97, 0x3d,
2177         0x85, 0xfb, 0xa5, 0x03, 0x28, 0xb7, 0x4f, 0x7a, 0x77, 0xd9, 0x83, 0xb8, 0x5f, 0x3a, 0x85, 0xa2,
2178         0x87, 0xd0, 0x8c, 0x7a, 0x73, 0xf1, 0xb3, 0xb8, 0x5f, 0x32, 0x88, 0xf2, 0xf0, 0xc8, 0xb6, 0x5b,
2179         0xf4, 0xda, 0xed, 0x17, 0xce, 0x96, 0xe8, 0x01, 0x34, 0x54, 0xdb, 0x2b, 0x7c, 0x51, 0xf7, 0x8b,
2180         0x27, 0x58, 0xee, 0x64, 0xf2, 0x30, 0x2a, 0x7b, 0x2a, 0xf7, 0x4b, 0x67, 0x53, 0xb4, 0x0f, 0x90,
2181         0x7a, 0x12, 0x95, 0x3e, 0x98, 0xfb, 0xe5, 0x13, 0x2a, 0x7a, 0x04, 0xad, 0xe4, 0x15, 0x54, 0xfc,
2182         0x6c, 0xee, 0x97, 0x0d, 0xa9, 0xe7, 0x0d, 0xf1, 0x8f, 0xcc, 0xfd, 0xbf, 0x03, 0x00, 0x00, 0xff,
2183         0xff, 0xbd, 0xb6, 0xa5, 0xad, 0xa6, 0x11, 0x00, 0x00,
2184 }