zolfa
/
tendermint
1
0
Fork 0
Code Issues 0 Pull Requests 0 Projects 0 Releases 221 Wiki Activity
Browse Source

Merge pull request #42 from tendermint/collapse_info 

Flatten ResponseInfo
pull/1780/head
Ethan Buchman 8 years ago
committed by GitHub
parent
a7b7fe83d6 490a96ef66
commit
2e414ebe6b
19 changed files with 234 additions and 309 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +2
    -2
      client/client.go
  2. +15
    -8
      client/grpc_client.go
  3. +11
    -11
      client/local_client.go
  4. +14
    -7
      client/socket_client.go
  5. +2
    -1
      cmd/counter/main.go
  6. +2
    -1
      cmd/dummy/main.go
  7. +5
    -2
      cmd/tmsp-cli/tmsp-cli.go
  8. +6
    -5
      example/chain_aware/chain_aware_app.go
  9. +2
    -1
      example/chain_aware/chain_aware_test.go
  10. +2
    -2
      example/counter/counter.go
  11. +2
    -2
      example/dummy/dummy.go
  12. +8
    -8
      example/dummy/dummy_test.go
  13. +19
    -12
      example/dummy/persistent_dummy.go
  14. +2
    -2
      example/nil/nil_app.go
  15. +5
    -4
      server/socket_server.go
  16. +6
    -6
      types/application.go
  17. +4
    -4
      types/messages.go
  18. +123
    -208
      types/types.pb.go
  19. +4
    -23
      types/types.proto

+ 2
- 2
client/client.go View File

@ -25,7 +25,7 @@ type Client interface {
FlushSync() error
EchoSync(msg string) (res types.Result)
InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo)
InfoSync() (resInfo types.ResponseInfo, err error)
SetOptionSync(key string, value string) (res types.Result)
AppendTxSync(tx []byte) (res types.Result)
CheckTxSync(tx []byte) (res types.Result)
@ -38,7 +38,7 @@ type Client interface {
InitChainSync(validators []*types.Validator) (err error)
BeginBlockSync(hash []byte, header *types.Header) (err error)
EndBlockSync(height uint64) (changedValidators []*types.Validator, err error)
EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error)
}
//----------------------------------------


+ 15
- 8
client/grpc_client.go View File

@ -262,13 +262,16 @@ func (cli *grpcClient) FlushSync() error {
return nil
}
func (cli *grpcClient) InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
func (cli *grpcClient) InfoSync() (resInfo types.ResponseInfo, err error) {
reqres := cli.InfoAsync()
if res := cli.checkErrGetResult(); res.IsErr() {
return res, nil, nil, nil
if err = cli.Error(); err != nil {
return resInfo, err
}
if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil {
return *resInfo_, nil
} else {
return resInfo, nil
}
resp := reqres.Response.GetInfo()
return types.NewResultOK([]byte(resp.Info), LOG), resp.TmspInfo, resp.LastBlock, resp.Config
}
func (cli *grpcClient) SetOptionSync(key string, value string) (res types.Result) {
@ -326,10 +329,14 @@ func (cli *grpcClient) BeginBlockSync(hash []byte, header *types.Header) (err er
return cli.Error()
}
func (cli *grpcClient) EndBlockSync(height uint64) (validators []*types.Validator, err error) {
func (cli *grpcClient) EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error) {
reqres := cli.EndBlockAsync(height)
if err := cli.Error(); err != nil {
return nil, err
return resEndBlock, err
}
if resEndBlock_ := reqres.Response.GetEndBlock(); resEndBlock_ != nil {
return *resEndBlock_, nil
} else {
return resEndBlock, nil
}
return reqres.Response.GetEndBlock().Diffs, nil
}

+ 11
- 11
client/local_client.go View File

@ -51,11 +51,11 @@ func (app *localClient) EchoAsync(msg string) *ReqRes {
func (app *localClient) InfoAsync() *ReqRes {
app.mtx.Lock()
info, tmspInfo, blockInfo, configInfo := app.Application.Info()
resInfo := app.Application.Info()
app.mtx.Unlock()
return app.callback(
types.ToRequestInfo(),
types.ToResponseInfo(info, tmspInfo, blockInfo, configInfo),
types.ToResponseInfo(resInfo),
)
}
@ -136,14 +136,14 @@ func (app *localClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqR
func (app *localClient) EndBlockAsync(height uint64) *ReqRes {
app.mtx.Lock()
var validators []*types.Validator
var resEndBlock types.ResponseEndBlock
if bcApp, ok := app.Application.(types.BlockchainAware); ok {
validators = bcApp.EndBlock(height)
resEndBlock = bcApp.EndBlock(height)
}
app.mtx.Unlock()
return app.callback(
types.ToRequestEndBlock(height),
types.ToResponseEndBlock(validators),
types.ToResponseEndBlock(resEndBlock),
)
}
@ -157,11 +157,11 @@ func (app *localClient) EchoSync(msg string) (res types.Result) {
return types.OK.SetData([]byte(msg))
}
func (app *localClient) InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
func (app *localClient) InfoSync() (resInfo types.ResponseInfo, err error) {
app.mtx.Lock()
defer app.mtx.Unlock()
info, tmspInfo, blockInfo, configInfo := app.Application.Info()
return types.OK.SetData([]byte(info)), tmspInfo, blockInfo, configInfo
resInfo = app.Application.Info()
return resInfo, nil
}
func (app *localClient) SetOptionSync(key string, value string) (res types.Result) {
@ -217,13 +217,13 @@ func (app *localClient) BeginBlockSync(hash []byte, header *types.Header) (err e
return nil
}
func (app *localClient) EndBlockSync(height uint64) (changedValidators []*types.Validator, err error) {
func (app *localClient) EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error) {
app.mtx.Lock()
if bcApp, ok := app.Application.(types.BlockchainAware); ok {
changedValidators = bcApp.EndBlock(height)
resEndBlock = bcApp.EndBlock(height)
}
app.mtx.Unlock()
return changedValidators, nil
return resEndBlock, nil
}
//-------------------------------------------------------


+ 14
- 7
client/socket_client.go View File

@ -292,14 +292,17 @@ func (cli *socketClient) FlushSync() error {
return cli.Error()
}
func (cli *socketClient) InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
func (cli *socketClient) InfoSync() (resInfo types.ResponseInfo, err error) {
reqres := cli.queueRequest(types.ToRequestInfo())
cli.FlushSync()
if err := cli.Error(); err != nil {
return types.ErrInternalError.SetLog(err.Error()), nil, nil, nil
return resInfo, err
}
if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil {
return *resInfo_, nil
} else {
return resInfo, nil
}
resp := reqres.Response.GetInfo()
return types.Result{Code: OK, Data: []byte(resp.Info), Log: LOG}, resp.TmspInfo, resp.LastBlock, resp.Config
}
func (cli *socketClient) SetOptionSync(key string, value string) (res types.Result) {
@ -370,13 +373,17 @@ func (cli *socketClient) BeginBlockSync(hash []byte, header *types.Header) (err
return nil
}
func (cli *socketClient) EndBlockSync(height uint64) (validators []*types.Validator, err error) {
func (cli *socketClient) EndBlockSync(height uint64) (resEndBlock types.ResponseEndBlock, err error) {
reqres := cli.queueRequest(types.ToRequestEndBlock(height))
cli.FlushSync()
if err := cli.Error(); err != nil {
return nil, err
return resEndBlock, err
}
if resEndBlock_ := reqres.Response.GetEndBlock(); resEndBlock_ != nil {
return *resEndBlock_, nil
} else {
return resEndBlock, nil
}
return reqres.Response.GetEndBlock().Diffs, nil
}
//----------------------------------------


+ 2
- 1
cmd/counter/main.go View File

@ -17,7 +17,7 @@ func main() {
app := counter.NewCounterApplication(*serialPtr)
// Start the listener
_, err := server.NewServer(*addrPtr, *tmspPtr, app)
srv, err := server.NewServer(*addrPtr, *tmspPtr, app)
if err != nil {
Exit(err.Error())
}
@ -25,6 +25,7 @@ func main() {
// Wait forever
TrapSignal(func() {
// Cleanup
srv.Stop()
})
}

+ 2
- 1
cmd/dummy/main.go View File

@ -25,7 +25,7 @@ func main() {
}
// Start the listener
_, err := server.NewServer(*addrPtr, *tmspPtr, app)
srv, err := server.NewServer(*addrPtr, *tmspPtr, app)
if err != nil {
Exit(err.Error())
}
@ -33,6 +33,7 @@ func main() {
// Wait forever
TrapSignal(func() {
// Cleanup
srv.Stop()
})
}

+ 5
- 2
cmd/tmsp-cli/tmsp-cli.go View File

@ -228,8 +228,11 @@ func cmdEcho(c *cli.Context) error {
// Get some info from the application
func cmdInfo(c *cli.Context) error {
res, _, _, _ := client.InfoSync()
rsp := newResponse(res, string(res.Data), false)
resInfo, err := client.InfoSync()
if err != nil {
return err
}
rsp := newResponse(types.Result{}, string(resInfo.Data), false)
printResponse(c, rsp)
return nil
}


+ 6
- 5
example/chain_aware/chain_aware_app.go View File

@ -15,7 +15,7 @@ func main() {
flag.Parse()
// Start the listener
_, err := server.NewServer(*addrPtr, *tmspPtr, NewChainAwareApplication())
srv, err := server.NewServer(*addrPtr, *tmspPtr, NewChainAwareApplication())
if err != nil {
Exit(err.Error())
}
@ -23,6 +23,7 @@ func main() {
// Wait forever
TrapSignal(func() {
// Cleanup
srv.Stop()
})
}
@ -36,8 +37,8 @@ func NewChainAwareApplication() *ChainAwareApplication {
return &ChainAwareApplication{}
}
func (app *ChainAwareApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
return "nil", nil, nil, nil
func (app *ChainAwareApplication) Info() types.ResponseInfo {
return types.ResponseInfo{}
}
func (app *ChainAwareApplication) SetOption(key string, value string) (log string) {
@ -65,9 +66,9 @@ func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header)
return
}
func (app *ChainAwareApplication) EndBlock(height uint64) []*types.Validator {
func (app *ChainAwareApplication) EndBlock(height uint64) (resEndBlock types.ResponseEndBlock) {
app.endCount += 1
return nil
return
}
func (app *ChainAwareApplication) InitChain(vals []*types.Validator) {


+ 2
- 1
example/chain_aware/chain_aware_test.go View File

@ -16,10 +16,11 @@ func TestChainAware(t *testing.T) {
app := NewChainAwareApplication()
// Start the listener
_, err := server.NewServer("unix://test.sock", "socket", app)
srv, err := server.NewServer("unix://test.sock", "socket", app)
if err != nil {
t.Fatal(err)
}
defer srv.Stop()
// Connect to the socket
client, err := tmspcli.NewSocketClient("unix://test.sock", false)


+ 2
- 2
example/counter/counter.go View File

@ -17,8 +17,8 @@ func NewCounterApplication(serial bool) *CounterApplication {
return &CounterApplication{serial: serial}
}
func (app *CounterApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
return Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount), nil, nil, nil
func (app *CounterApplication) Info() types.ResponseInfo {
return types.ResponseInfo{Data: Fmt("{\"hashes\":%v,\"txs\":%v}", app.hashCount, app.txCount)}
}
func (app *CounterApplication) SetOption(key string, value string) (log string) {


+ 2
- 2
example/dummy/dummy.go View File

@ -19,8 +19,8 @@ func NewDummyApplication() *DummyApplication {
return &DummyApplication{state: state}
}
func (app *DummyApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
return Fmt("{\"size\":%v}", app.state.Size()), nil, nil, nil
func (app *DummyApplication) Info() (resInfo types.ResponseInfo) {
return types.ResponseInfo{Data: Fmt("{\"size\":%v}", app.state.Size())}
}
func (app *DummyApplication) SetOption(key string, value string) (log string) {


+ 8
- 8
example/dummy/dummy_test.go View File

@ -72,9 +72,9 @@ func TestPersistentDummyInfo(t *testing.T) {
dummy := NewPersistentDummyApplication(dir)
height := uint64(0)
_, _, lastBlockInfo, _ := dummy.Info()
if lastBlockInfo.BlockHeight != height {
t.Fatalf("expected height of %d, got %d", height, lastBlockInfo.BlockHeight)
resInfo := dummy.Info()
if resInfo.LastBlockHeight != height {
t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
}
// make and apply block
@ -87,9 +87,9 @@ func TestPersistentDummyInfo(t *testing.T) {
dummy.EndBlock(height)
dummy.Commit()
_, _, lastBlockInfo, _ = dummy.Info()
if lastBlockInfo.BlockHeight != height {
t.Fatalf("expected height of %d, got %d", height, lastBlockInfo.BlockHeight)
resInfo = dummy.Info()
if resInfo.LastBlockHeight != height {
t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
}
}
@ -179,10 +179,10 @@ func makeApplyBlock(t *testing.T, dummy types.Application, heightInt int, diff [
t.Fatal(r)
}
}
diff2 := dummyChain.EndBlock(height)
resEndBlock := dummyChain.EndBlock(height)
dummy.Commit()
valsEqual(t, diff, diff2)
valsEqual(t, diff, resEndBlock.Diffs)
}


+ 19
- 12
example/dummy/persistent_dummy.go View File

@ -38,7 +38,7 @@ func NewPersistentDummyApplication(dbDir string) *PersistentDummyApplication {
stateTree := merkle.NewIAVLTree(0, db)
stateTree.Load(lastBlock.AppHash)
log.Notice("Loaded state", "block", lastBlock.BlockHeight, "root", stateTree.Hash())
log.Notice("Loaded state", "block", lastBlock.Height, "root", stateTree.Hash())
return &PersistentDummyApplication{
app: &DummyApplication{state: stateTree},
@ -46,10 +46,12 @@ func NewPersistentDummyApplication(dbDir string) *PersistentDummyApplication {
}
}
func (app *PersistentDummyApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
s, _, _, _ := app.app.Info()
func (app *PersistentDummyApplication) Info() (resInfo types.ResponseInfo) {
resInfo = app.app.Info()
lastBlock := LoadLastBlock(app.db)
return s, nil, &lastBlock, nil
resInfo.LastBlockHeight = lastBlock.Height
resInfo.LastBlockAppHash = lastBlock.AppHash
return resInfo
}
func (app *PersistentDummyApplication) SetOption(key string, value string) (log string) {
@ -79,9 +81,9 @@ func (app *PersistentDummyApplication) Commit() types.Result {
appHash := app.app.state.Save()
log.Info("Saved state", "root", appHash)
lastBlock := types.LastBlockInfo{
BlockHeight: app.blockHeader.Height,
AppHash: appHash, // this hash will be in the next block header
lastBlock := LastBlockInfo{
Height: app.blockHeader.Height,
AppHash: appHash, // this hash will be in the next block header
}
SaveLastBlock(app.db, lastBlock)
return types.NewResultOK(appHash, "")
@ -111,8 +113,8 @@ func (app *PersistentDummyApplication) BeginBlock(hash []byte, header *types.Hea
}
// Update the validator set
func (app *PersistentDummyApplication) EndBlock(height uint64) (diffs []*types.Validator) {
return app.changes
func (app *PersistentDummyApplication) EndBlock(height uint64) (resEndBlock types.ResponseEndBlock) {
return types.ResponseEndBlock{Diffs: app.changes}
}
//-----------------------------------------
@ -120,8 +122,13 @@ func (app *PersistentDummyApplication) EndBlock(height uint64) (diffs []*types.V
var lastBlockKey = []byte("lastblock")
type LastBlockInfo struct {
Height uint64
AppHash []byte
}
// Get the last block from the db
func LoadLastBlock(db dbm.DB) (lastBlock types.LastBlockInfo) {
func LoadLastBlock(db dbm.DB) (lastBlock LastBlockInfo) {
buf := db.Get(lastBlockKey)
if len(buf) != 0 {
r, n, err := bytes.NewReader(buf), new(int), new(error)
@ -136,8 +143,8 @@ func LoadLastBlock(db dbm.DB) (lastBlock types.LastBlockInfo) {
return lastBlock
}
func SaveLastBlock(db dbm.DB, lastBlock types.LastBlockInfo) {
log.Notice("Saving block", "height", lastBlock.BlockHeight, "root", lastBlock.AppHash)
func SaveLastBlock(db dbm.DB, lastBlock LastBlockInfo) {
log.Notice("Saving block", "height", lastBlock.Height, "root", lastBlock.AppHash)
buf, n, err := new(bytes.Buffer), new(int), new(error)
wire.WriteBinary(lastBlock, buf, n, err)
if *err != nil {


+ 2
- 2
example/nil/nil_app.go View File

@ -11,8 +11,8 @@ func NewNilApplication() *NilApplication {
return &NilApplication{}
}
func (app *NilApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
return "nil", nil, nil, nil
func (app *NilApplication) Info() (resInfo types.ResponseInfo) {
return
}
func (app *NilApplication) SetOption(key string, value string) (log string) {


+ 5
- 4
server/socket_server.go View File

@ -168,7 +168,8 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
case *types.Request_Flush:
responses <- types.ToResponseFlush()
case *types.Request_Info:
responses <- types.ToResponseInfo(s.app.Info())
resInfo := s.app.Info()
responses <- types.ToResponseInfo(resInfo)
case *types.Request_SetOption:
so := r.SetOption
logStr := s.app.SetOption(so.Key, so.Value)
@ -197,10 +198,10 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
responses <- types.ToResponseBeginBlock()
case *types.Request_EndBlock:
if app, ok := s.app.(types.BlockchainAware); ok {
validators := app.EndBlock(r.EndBlock.Height)
responses <- types.ToResponseEndBlock(validators)
resEndBlock := app.EndBlock(r.EndBlock.Height)
responses <- types.ToResponseEndBlock(resEndBlock)
} else {
responses <- types.ToResponseEndBlock(nil)
responses <- types.ToResponseEndBlock(types.ResponseEndBlock{})
}
default:
responses <- types.ToResponseException("Unknown request")


+ 6
- 6
types/application.go View File

@ -8,7 +8,7 @@ import (
type Application interface {
// Return application info
Info() (string, *TMSPInfo, *LastBlockInfo, *ConfigInfo)
Info() ResponseInfo
// Set application option (e.g. mode=mempool, mode=consensus)
SetOption(key string, value string) (log string)
@ -38,7 +38,7 @@ type BlockchainAware interface {
// Signals the end of a block
// diffs: changed validators from app to TendermintCore
EndBlock(height uint64) (diffs []*Validator)
EndBlock(height uint64) ResponseEndBlock
}
//------------------------------------
@ -59,8 +59,8 @@ func (app *GRPCApplication) Flush(ctx context.Context, req *RequestFlush) (*Resp
}
func (app *GRPCApplication) Info(ctx context.Context, req *RequestInfo) (*ResponseInfo, error) {
info, tmspInfo, blockInfo, configInfo := app.app.Info()
return &ResponseInfo{info, tmspInfo, blockInfo, configInfo}, nil
resInfo := app.app.Info()
return &resInfo, nil
}
func (app *GRPCApplication) SetOption(ctx context.Context, req *RequestSetOption) (*ResponseSetOption, error) {
@ -103,8 +103,8 @@ func (app *GRPCApplication) BeginBlock(ctx context.Context, req *RequestBeginBlo
func (app *GRPCApplication) EndBlock(ctx context.Context, req *RequestEndBlock) (*ResponseEndBlock, error) {
if chainAware, ok := app.app.(BlockchainAware); ok {
diffs := chainAware.EndBlock(req.Height)
return &ResponseEndBlock{diffs}, nil
resEndBlock := chainAware.EndBlock(req.Height)
return &resEndBlock, nil
}
return &ResponseEndBlock{}, nil
}

+ 4
- 4
types/messages.go View File

@ -93,9 +93,9 @@ func ToResponseFlush() *Response {
}
}
func ToResponseInfo(info string, tmspInfo *TMSPInfo, blockInfo *LastBlockInfo, configInfo *ConfigInfo) *Response {
func ToResponseInfo(resInfo ResponseInfo) *Response {
return &Response{
Value: &Response_Info{&ResponseInfo{info, tmspInfo, blockInfo, configInfo}},
Value: &Response_Info{&resInfo},
}
}
@ -141,9 +141,9 @@ func ToResponseBeginBlock() *Response {
}
}
func ToResponseEndBlock(validators []*Validator) *Response {
func ToResponseEndBlock(resEndBlock ResponseEndBlock) *Response {
return &Response{
Value: &Response_EndBlock{&ResponseEndBlock{validators}},
Value: &Response_EndBlock{&resEndBlock},
}
}


+ 123
- 208
types/types.pb.go View File

@ -34,9 +34,6 @@ It has these top-level messages:
ResponseInitChain
ResponseBeginBlock
ResponseEndBlock
TMSPInfo
LastBlockInfo
ConfigInfo
Header
BlockID
PartSetHeader
@ -1270,10 +1267,10 @@ func (*ResponseFlush) ProtoMessage() {}
func (*ResponseFlush) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
type ResponseInfo struct {
Info string `protobuf:"bytes,1,opt,name=info" json:"info,omitempty"`
TmspInfo *TMSPInfo `protobuf:"bytes,2,opt,name=tmsp_info,json=tmspInfo" json:"tmsp_info,omitempty"`
LastBlock *LastBlockInfo `protobuf:"bytes,3,opt,name=last_block,json=lastBlock" json:"last_block,omitempty"`
Config *ConfigInfo `protobuf:"bytes,4,opt,name=config" json:"config,omitempty"`
Data string `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
Version string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
LastBlockHeight uint64 `protobuf:"varint,3,opt,name=last_block_height,json=lastBlockHeight" json:"last_block_height,omitempty"`
LastBlockAppHash []byte `protobuf:"bytes,4,opt,name=last_block_app_hash,json=lastBlockAppHash,proto3" json:"last_block_app_hash,omitempty"`
}
func (m *ResponseInfo) Reset() { *m = ResponseInfo{} }
@ -1281,30 +1278,30 @@ func (m *ResponseInfo) String() string { return proto.CompactTextStri
func (*ResponseInfo) ProtoMessage() {}
func (*ResponseInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
func (m *ResponseInfo) GetInfo() string {
func (m *ResponseInfo) GetData() string {
if m != nil {
return m.Info
return m.Data
}
return ""
}
func (m *ResponseInfo) GetTmspInfo() *TMSPInfo {
func (m *ResponseInfo) GetVersion() string {
if m != nil {
return m.TmspInfo
return m.Version
}
return nil
return ""
}
func (m *ResponseInfo) GetLastBlock() *LastBlockInfo {
func (m *ResponseInfo) GetLastBlockHeight() uint64 {
if m != nil {
return m.LastBlock
return m.LastBlockHeight
}
return nil
return 0
}
func (m *ResponseInfo) GetConfig() *ConfigInfo {
func (m *ResponseInfo) GetLastBlockAppHash() []byte {
if m != nil {
return m.Config
return m.LastBlockAppHash
}
return nil
}
@ -1485,78 +1482,6 @@ func (m *ResponseEndBlock) GetDiffs() []*Validator {
return nil
}
type TMSPInfo struct {
Version string `protobuf:"bytes,1,opt,name=Version" json:"Version,omitempty"`
}
func (m *TMSPInfo) Reset() { *m = TMSPInfo{} }
func (m *TMSPInfo) String() string { return proto.CompactTextString(m) }
func (*TMSPInfo) ProtoMessage() {}
func (*TMSPInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
func (m *TMSPInfo) GetVersion() string {
if m != nil {
return m.Version
}
return ""
}
type LastBlockInfo struct {
BlockHeight uint64 `protobuf:"varint,1,opt,name=block_height,json=blockHeight" json:"block_height,omitempty"`
AppHash []byte `protobuf:"bytes,2,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
}
func (m *LastBlockInfo) Reset() { *m = LastBlockInfo{} }
func (m *LastBlockInfo) String() string { return proto.CompactTextString(m) }
func (*LastBlockInfo) ProtoMessage() {}
func (*LastBlockInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
func (m *LastBlockInfo) GetBlockHeight() uint64 {
if m != nil {
return m.BlockHeight
}
return 0
}
func (m *LastBlockInfo) GetAppHash() []byte {
if m != nil {
return m.AppHash
}
return nil
}
type ConfigInfo struct {
MaxBlockSizeBytes uint64 `protobuf:"varint,1,opt,name=max_block_size_bytes,json=maxBlockSizeBytes" json:"max_block_size_bytes,omitempty"`
MaxBlockSizeTxs uint64 `protobuf:"varint,2,opt,name=max_block_size_txs,json=maxBlockSizeTxs" json:"max_block_size_txs,omitempty"`
MaxTxSize uint64 `protobuf:"varint,3,opt,name=max_tx_size,json=maxTxSize" json:"max_tx_size,omitempty"`
}
func (m *ConfigInfo) Reset() { *m = ConfigInfo{} }
func (m *ConfigInfo) String() string { return proto.CompactTextString(m) }
func (*ConfigInfo) ProtoMessage() {}
func (*ConfigInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
func (m *ConfigInfo) GetMaxBlockSizeBytes() uint64 {
if m != nil {
return m.MaxBlockSizeBytes
}
return 0
}
func (m *ConfigInfo) GetMaxBlockSizeTxs() uint64 {
if m != nil {
return m.MaxBlockSizeTxs
}
return 0
}
func (m *ConfigInfo) GetMaxTxSize() uint64 {
if m != nil {
return m.MaxTxSize
}
return 0
}
type Header struct {
ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
Height uint64 `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
@ -1572,7 +1497,7 @@ type Header struct {
func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
func (*Header) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} }
func (m *Header) GetChainId() string {
if m != nil {
@ -1645,7 +1570,7 @@ type BlockID struct {
func (m *BlockID) Reset() { *m = BlockID{} }
func (m *BlockID) String() string { return proto.CompactTextString(m) }
func (*BlockID) ProtoMessage() {}
func (*BlockID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} }
func (*BlockID) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} }
func (m *BlockID) GetHash() []byte {
if m != nil {
@ -1669,7 +1594,7 @@ type PartSetHeader struct {
func (m *PartSetHeader) Reset() { *m = PartSetHeader{} }
func (m *PartSetHeader) String() string { return proto.CompactTextString(m) }
func (*PartSetHeader) ProtoMessage() {}
func (*PartSetHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} }
func (*PartSetHeader) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} }
func (m *PartSetHeader) GetTotal() uint64 {
if m != nil {
@ -1693,7 +1618,7 @@ type Validator struct {
func (m *Validator) Reset() { *m = Validator{} }
func (m *Validator) String() string { return proto.CompactTextString(m) }
func (*Validator) ProtoMessage() {}
func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} }
func (m *Validator) GetPubKey() []byte {
if m != nil {
@ -1735,9 +1660,6 @@ func init() {
proto.RegisterType((*ResponseInitChain)(nil), "types.ResponseInitChain")
proto.RegisterType((*ResponseBeginBlock)(nil), "types.ResponseBeginBlock")
proto.RegisterType((*ResponseEndBlock)(nil), "types.ResponseEndBlock")
proto.RegisterType((*TMSPInfo)(nil), "types.TMSPInfo")
proto.RegisterType((*LastBlockInfo)(nil), "types.LastBlockInfo")
proto.RegisterType((*ConfigInfo)(nil), "types.ConfigInfo")
proto.RegisterType((*Header)(nil), "types.Header")
proto.RegisterType((*BlockID)(nil), "types.BlockID")
proto.RegisterType((*PartSetHeader)(nil), "types.PartSetHeader")
@ -2151,116 +2073,109 @@ var _TMSPApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1774 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x4b, 0x73, 0xdb, 0xc8,
0x11, 0x16, 0x24, 0x3e, 0x9b, 0x12, 0x35, 0x6a, 0x51, 0x12, 0xcd, 0xa4, 0x52, 0x5e, 0x64, 0x37,
0x2b, 0x79, 0x5d, 0x76, 0x4a, 0xae, 0xdd, 0xb2, 0xb3, 0xa9, 0x54, 0x59, 0xb6, 0xd6, 0x54, 0x6d,
0x6c, 0x2b, 0xb0, 0xd6, 0x87, 0x3c, 0x8a, 0x05, 0x11, 0x43, 0x12, 0x11, 0x09, 0xc0, 0xc0, 0xc0,
0x4b, 0xf9, 0x1f, 0x6c, 0xfe, 0x48, 0xae, 0xb9, 0xe4, 0x92, 0x6b, 0x4e, 0x79, 0x3f, 0x7e, 0xd1,
0x56, 0xcf, 0x0c, 0x9e, 0x02, 0x7d, 0xf2, 0x85, 0xc5, 0xe9, 0xd7, 0xcc, 0x74, 0x7f, 0xfd, 0xcd,
0x60, 0x60, 0x47, 0x5c, 0x07, 0x3c, 0xba, 0x2f, 0x7f, 0xef, 0x05, 0xa1, 0x2f, 0x7c, 0xac, 0xcb,
0x81, 0xf9, 0xd7, 0x1a, 0x34, 0x2d, 0xfe, 0x26, 0xe6, 0x91, 0xc0, 0x43, 0xa8, 0xf1, 0xf1, 0xcc,
0xef, 0x1b, 0xb7, 0x8d, 0xc3, 0xce, 0x31, 0xde, 0x53, 0xe6, 0x5a, 0x7b, 0x3a, 0x9e, 0xf9, 0xc3,
0x35, 0x4b, 0x5a, 0xe0, 0x67, 0x50, 0x9f, 0xcc, 0xe3, 0x68, 0xd6, 0x5f, 0x97, 0xa6, 0xbb, 0x45,
0xd3, 0xaf, 0x48, 0x35, 0x5c, 0xb3, 0x94, 0x0d, 0x85, 0x75, 0xbd, 0x89, 0xdf, 0xdf, 0xa8, 0x0a,
0x7b, 0xe6, 0x4d, 0x64, 0x58, 0xb2, 0xc0, 0x87, 0x00, 0x11, 0x17, 0x23, 0x3f, 0x10, 0xae, 0xef,
0xf5, 0x6b, 0xd2, 0xfe, 0xa0, 0x68, 0xff, 0x8a, 0x8b, 0x97, 0x52, 0x3d, 0x5c, 0xb3, 0xda, 0x51,
0x32, 0xc0, 0xcf, 0xa1, 0x6d, 0x07, 0x01, 0xf7, 0x9c, 0x91, 0x58, 0xf6, 0xeb, 0xd2, 0x71, 0xbf,
0xe8, 0xf8, 0x58, 0xaa, 0x2f, 0x96, 0xc3, 0x35, 0xab, 0x65, 0xeb, 0xff, 0x78, 0x0c, 0xad, 0xf1,
0x8c, 0x8f, 0xaf, 0xc8, 0xab, 0x21, 0xbd, 0xf6, 0x8a, 0x5e, 0x4f, 0x48, 0x2b, 0x9d, 0x9a, 0x63,
0xf5, 0x17, 0xef, 0x41, 0x63, 0xec, 0x2f, 0x16, 0xae, 0xe8, 0x37, 0xa5, 0x47, 0xaf, 0xe4, 0x21,
0x75, 0xc3, 0x35, 0x4b, 0x5b, 0x51, 0xae, 0xde, 0xc4, 0x3c, 0xbc, 0xee, 0xb7, 0xaa, 0x72, 0xf5,
0x2b, 0x52, 0x51, 0xae, 0xa4, 0x0d, 0x65, 0xc0, 0xf5, 0x5c, 0x31, 0x1a, 0xcf, 0x6c, 0xd7, 0xeb,
0xb7, 0xab, 0x32, 0x70, 0xe6, 0xb9, 0xe2, 0x09, 0xa9, 0x29, 0x03, 0x6e, 0x32, 0xc0, 0x2f, 0xa1,
0x73, 0xc9, 0xa7, 0xae, 0x37, 0xba, 0x9c, 0xfb, 0xe3, 0xab, 0x3e, 0x48, 0xd7, 0x7e, 0xd1, 0xf5,
0x84, 0x0c, 0x4e, 0x48, 0x3f, 0x5c, 0xb3, 0xe0, 0x32, 0x1d, 0x51, 0xfa, 0x28, 0x77, 0xca, 0xb5,
0x53, 0x95, 0xbe, 0x53, 0xcf, 0x49, 0x1c, 0x5b, 0x5c, 0xff, 0x3f, 0x69, 0x42, 0xfd, 0xad, 0x3d,
0x8f, 0xb9, 0xf9, 0x29, 0x74, 0x72, 0x30, 0xc1, 0x3e, 0x34, 0x17, 0x3c, 0x8a, 0xec, 0x29, 0x97,
0x58, 0x6a, 0x5b, 0xc9, 0xd0, 0xec, 0xc2, 0x66, 0x1e, 0x24, 0xe6, 0x56, 0xea, 0x48, 0x40, 0x30,
0x7f, 0x06, 0xac, 0x5c, 0x67, 0x64, 0xb0, 0x71, 0xc5, 0xaf, 0x75, 0x20, 0xfa, 0x8b, 0x3d, 0x3d,
0xad, 0x44, 0x5f, 0xdb, 0xd2, 0x6b, 0xf8, 0x08, 0xb6, 0x4b, 0xa5, 0xc6, 0x2e, 0xac, 0x8b, 0xa5,
0xf4, 0xdc, 0xb4, 0xd6, 0xc5, 0xd2, 0xbc, 0x0d, 0xdd, 0x62, 0x5d, 0x6f, 0x58, 0x7c, 0x9c, 0xae,
0x4f, 0x16, 0x86, 0xa6, 0x52, 0xc5, 0x53, 0x26, 0x6a, 0x60, 0x6e, 0xc3, 0x56, 0xa1, 0xda, 0xe6,
0xd3, 0x74, 0xdd, 0x69, 0x75, 0xf0, 0xa7, 0x00, 0x6f, 0xed, 0xb9, 0xeb, 0xd8, 0xc2, 0x0f, 0xa3,
0xbe, 0x71, 0x7b, 0xe3, 0xb0, 0x73, 0xcc, 0x74, 0x52, 0x5f, 0x27, 0x0a, 0x2b, 0x67, 0x63, 0xbe,
0x80, 0x9d, 0x1b, 0x85, 0x42, 0x84, 0xda, 0xcc, 0x8e, 0x66, 0x7a, 0x01, 0xf2, 0x3f, 0x7e, 0x02,
0x8d, 0x19, 0xb7, 0x1d, 0x1e, 0xea, 0xfe, 0xdb, 0xd2, 0x61, 0x87, 0x52, 0x68, 0x69, 0xa5, 0x79,
0x94, 0x66, 0x24, 0xa9, 0x1e, 0xee, 0x93, 0xa7, 0x3b, 0x9d, 0x09, 0x19, 0xaf, 0x66, 0xe9, 0x91,
0xf9, 0x5d, 0x1d, 0x5a, 0x16, 0x8f, 0x02, 0xdf, 0x8b, 0x38, 0x3e, 0x84, 0x36, 0x5f, 0x8e, 0xb9,
0xea, 0x42, 0xa3, 0x04, 0x24, 0x65, 0x73, 0x9a, 0xe8, 0x09, 0x84, 0xa9, 0x31, 0x1e, 0x69, 0x06,
0x29, 0xd3, 0x82, 0x76, 0xca, 0x53, 0xc8, 0xdd, 0x84, 0x42, 0x36, 0x4a, 0x5d, 0xa4, 0x6c, 0x4b,
0x1c, 0x72, 0xa4, 0x39, 0xa4, 0x56, 0x19, 0xb8, 0x40, 0x22, 0x8f, 0x0a, 0x24, 0x52, 0xaf, 0x5c,
0xfe, 0x0a, 0x16, 0xf9, 0x22, 0xcf, 0x22, 0x8d, 0x52, 0xf3, 0x29, 0xcf, 0x4a, 0x1a, 0x79, 0x90,
0xa3, 0x91, 0x66, 0xa9, 0x7b, 0x94, 0x5b, 0x05, 0x8f, 0xdc, 0x4f, 0x79, 0xa4, 0x55, 0x62, 0x1e,
0xed, 0x52, 0x26, 0x92, 0xbb, 0x09, 0x16, 0xdb, 0x95, 0x19, 0x2b, 0x31, 0xc9, 0xa3, 0x02, 0x93,
0x40, 0x65, 0x1a, 0x56, 0x50, 0xc9, 0xcf, 0x8b, 0x54, 0xa2, 0xf8, 0xe0, 0x56, 0xc9, 0x77, 0x25,
0x97, 0x7c, 0x91, 0xe7, 0x92, 0xcd, 0xca, 0x24, 0xbe, 0x9f, 0x4c, 0x8e, 0xa8, 0x0d, 0x4a, 0x30,
0xa3, 0x46, 0xe4, 0x61, 0xe8, 0x87, 0x9a, 0x07, 0xd4, 0xc0, 0x3c, 0xa4, 0x76, 0xcd, 0xc0, 0xf5,
0x1e, 0xe2, 0x91, 0x2d, 0x9b, 0x83, 0x96, 0xf9, 0x27, 0x23, 0xf3, 0x25, 0xfc, 0x50, 0xa3, 0x49,
0x88, 0x29, 0x47, 0x85, 0xa5, 0xbb, 0xd0, 0x16, 0x8b, 0x28, 0x18, 0x49, 0x85, 0x02, 0xf5, 0xb6,
0xde, 0xcb, 0xc5, 0xf3, 0x57, 0xe7, 0xe4, 0x67, 0xb5, 0xc8, 0x42, 0x46, 0x78, 0x00, 0x30, 0xb7,
0x23, 0xa1, 0xb7, 0x5e, 0xc4, 0xf5, 0x2f, 0xed, 0x48, 0xc8, 0x7d, 0x4a, 0x9f, 0xf6, 0x3c, 0x19,
0xe2, 0x11, 0xc1, 0xc0, 0x9b, 0xb8, 0x53, 0x8d, 0xed, 0x1d, 0xed, 0xf0, 0x44, 0x0a, 0xa5, 0xb5,
0x36, 0x30, 0x3f, 0xc9, 0x12, 0x53, 0xa0, 0xc7, 0xb9, 0x3f, 0x4d, 0xe8, 0x71, 0xee, 0x4f, 0xcd,
0xdf, 0x11, 0x19, 0x15, 0xd1, 0x8a, 0x3f, 0x86, 0xda, 0xd8, 0x77, 0x54, 0x56, 0xba, 0xe9, 0x1e,
0x9e, 0xf8, 0x0e, 0xbf, 0xb8, 0x0e, 0xb8, 0x25, 0x95, 0x94, 0x01, 0xc7, 0x16, 0xb6, 0xdc, 0xe8,
0xa6, 0x25, 0xff, 0x27, 0xe1, 0x37, 0xb2, 0xf0, 0xbf, 0x25, 0x56, 0x29, 0xa0, 0xfa, 0x43, 0x46,
0xff, 0x75, 0x56, 0x27, 0xc5, 0xc0, 0x1f, 0x30, 0xf6, 0x6f, 0x88, 0xfe, 0xf3, 0xcd, 0xf5, 0x21,
0x83, 0xef, 0x66, 0xc5, 0x49, 0xdb, 0xca, 0xec, 0x01, 0xde, 0xec, 0x17, 0x75, 0xca, 0x15, 0x3b,
0x01, 0x7f, 0x02, 0x75, 0xc7, 0x9d, 0x4c, 0xa2, 0x7e, 0x6d, 0xc5, 0x41, 0xa1, 0xd4, 0xe6, 0xc7,
0xd0, 0x4a, 0x90, 0x47, 0x68, 0x7f, 0xcd, 0xc3, 0x28, 0x61, 0xe9, 0xb6, 0x95, 0x0c, 0xcd, 0xe7,
0xb0, 0x55, 0x00, 0x1c, 0x7e, 0x04, 0x9b, 0x12, 0x95, 0xa3, 0x02, 0xfb, 0x77, 0xa4, 0x6c, 0x28,
0x45, 0x78, 0x0b, 0x88, 0xd0, 0x46, 0xf2, 0xb0, 0x51, 0x5b, 0x6d, 0xda, 0x41, 0x30, 0xb4, 0xa3,
0x99, 0xf9, 0x07, 0x03, 0x20, 0xc3, 0x23, 0xde, 0x87, 0xde, 0xc2, 0x5e, 0x2a, 0x98, 0x8f, 0x22,
0xf7, 0x1d, 0x1f, 0x5d, 0x5e, 0x0b, 0x1e, 0xe9, 0xa0, 0x3b, 0x0b, 0x7b, 0x29, 0x27, 0x7e, 0xe5,
0xbe, 0xe3, 0x27, 0xa4, 0xc0, 0xcf, 0x00, 0x4b, 0x0e, 0x62, 0x19, 0xc9, 0x49, 0x6a, 0xd6, 0x76,
0xde, 0xfc, 0x62, 0x19, 0xe1, 0x8f, 0xa0, 0x43, 0xc6, 0x62, 0x29, 0x2d, 0x65, 0x8a, 0x6b, 0x56,
0x7b, 0x61, 0x2f, 0x2f, 0x96, 0x64, 0x62, 0xfe, 0x71, 0x1d, 0x1a, 0xea, 0xa0, 0xa3, 0x25, 0x4b,
0x7a, 0x1b, 0xb9, 0x4e, 0x92, 0x01, 0x39, 0x3e, 0x73, 0x72, 0x07, 0xdd, 0x7a, 0xfe, 0xa0, 0xa3,
0x62, 0x0a, 0x77, 0x91, 0x84, 0x95, 0xff, 0xf1, 0x00, 0x9a, 0x5e, 0xbc, 0x90, 0x6b, 0xaa, 0x29,
0x63, 0x2f, 0x5e, 0xd0, 0x52, 0x8e, 0x61, 0x2b, 0x6b, 0x68, 0x9a, 0x44, 0x9d, 0x26, 0x5d, 0x5d,
0x1c, 0x95, 0xde, 0xa7, 0x56, 0x27, 0xed, 0xe6, 0x33, 0x07, 0x0f, 0x81, 0x49, 0x1f, 0x45, 0xda,
0x2a, 0x9d, 0x0d, 0x99, 0xce, 0x2e, 0xc9, 0x35, 0xab, 0xd3, 0x29, 0xfe, 0x03, 0x68, 0x13, 0x96,
0x94, 0x49, 0x53, 0x9a, 0xb4, 0x48, 0x20, 0x95, 0x9f, 0xc2, 0x76, 0x76, 0x33, 0x50, 0x26, 0x2d,
0x15, 0x25, 0x13, 0x4b, 0xc3, 0x7c, 0xd9, 0xda, 0xc5, 0xb2, 0x9d, 0x41, 0x53, 0x2f, 0xb1, 0xf2,
0x16, 0x71, 0x07, 0xea, 0x81, 0x1d, 0x8a, 0x48, 0x13, 0x5b, 0xc2, 0x54, 0xe7, 0x76, 0x48, 0xb7,
0x2f, 0x7d, 0x97, 0x50, 0x26, 0xe6, 0x23, 0xd8, 0x2a, 0xc8, 0x89, 0x8f, 0x85, 0x2f, 0xec, 0xb9,
0x2e, 0xba, 0x1a, 0xa4, 0xd3, 0xac, 0x67, 0xd3, 0x98, 0x8f, 0xa0, 0x9d, 0xa2, 0x98, 0xca, 0x12,
0xc4, 0x97, 0x5f, 0xf3, 0xe4, 0x42, 0xa5, 0x47, 0x14, 0x2e, 0xf0, 0xbf, 0xd5, 0x17, 0x9a, 0x9a,
0xa5, 0x06, 0x77, 0xfe, 0x62, 0x40, 0xe7, 0xb9, 0x22, 0x70, 0xea, 0x47, 0xdc, 0x86, 0xce, 0x8b,
0x78, 0x3e, 0xd7, 0x22, 0xb6, 0x86, 0x2d, 0xa8, 0x11, 0xef, 0x33, 0x03, 0xdb, 0x50, 0x97, 0xbc,
0xce, 0xd6, 0x49, 0x48, 0x30, 0x65, 0x1b, 0xb8, 0x05, 0xed, 0x94, 0x28, 0x59, 0x8d, 0x86, 0xe9,
0x81, 0xc2, 0xea, 0xb8, 0x09, 0xad, 0x84, 0x1f, 0xd9, 0x0e, 0x76, 0xa0, 0xa9, 0xe9, 0x8c, 0x21,
0x02, 0x34, 0x54, 0xa1, 0xd8, 0x2e, 0x45, 0x96, 0x4c, 0xc4, 0x7a, 0x14, 0x20, 0xed, 0x6d, 0xb6,
0x87, 0x5d, 0x80, 0xac, 0xab, 0xd9, 0x3e, 0x05, 0x4c, 0xfa, 0x99, 0x1d, 0xdc, 0xf9, 0x73, 0x1d,
0x5a, 0x09, 0x93, 0x60, 0x03, 0xd6, 0x5f, 0x7e, 0xcd, 0xd6, 0x70, 0x07, 0xb6, 0xce, 0x3c, 0xc1,
0x43, 0xcf, 0x9e, 0x9f, 0xd2, 0x09, 0xc6, 0x0c, 0x12, 0x9d, 0x7a, 0x63, 0xdf, 0x71, 0xbd, 0xa9,
0x12, 0xad, 0x53, 0xa0, 0x13, 0xdb, 0x79, 0xe1, 0x7b, 0x63, 0xce, 0x36, 0x90, 0xc1, 0xe6, 0x37,
0x9e, 0x1d, 0x8b, 0x99, 0x1f, 0xba, 0xef, 0xb8, 0xc3, 0x6a, 0xb8, 0x07, 0x3b, 0x67, 0x5e, 0x14,
0x4f, 0x26, 0xee, 0xd8, 0xe5, 0x9e, 0xf8, 0x2a, 0xf6, 0x9c, 0x88, 0xd5, 0x11, 0xa1, 0xfb, 0x8d,
0x77, 0xe5, 0xf9, 0xdf, 0x7a, 0xfa, 0xda, 0xc7, 0x1a, 0xd8, 0x87, 0xde, 0x89, 0x1d, 0xf1, 0xa7,
0x71, 0x30, 0x77, 0xc7, 0xb6, 0xe0, 0x8f, 0x1d, 0x27, 0xe4, 0x51, 0xc4, 0x38, 0x05, 0x21, 0x4d,
0x71, 0xee, 0x49, 0xe2, 0x50, 0x88, 0xcf, 0x79, 0xc4, 0xa6, 0x78, 0x0b, 0xf6, 0x6e, 0x68, 0xe4,
0xcc, 0x33, 0xfc, 0x21, 0xf4, 0xcb, 0xaa, 0x67, 0x76, 0x74, 0x1e, 0xba, 0x63, 0xce, 0x5c, 0xec,
0x01, 0x53, 0x5a, 0x09, 0xdd, 0x33, 0x2f, 0x88, 0x05, 0xfb, 0x7d, 0x32, 0xbf, 0x96, 0xbe, 0x8c,
0x05, 0x89, 0xaf, 0x4a, 0xe2, 0x73, 0x09, 0x0f, 0x36, 0xc7, 0x03, 0xd8, 0xcd, 0x89, 0x5f, 0xd1,
0xfe, 0x28, 0x3b, 0x8b, 0x6c, 0xbd, 0x4a, 0xe1, 0x4e, 0x3d, 0x5b, 0xc4, 0x21, 0x67, 0x1e, 0xee,
0x03, 0x92, 0x46, 0xa7, 0x24, 0xd9, 0xb8, 0x9f, 0xcc, 0xa0, 0xe5, 0x7a, 0x86, 0xa0, 0x2c, 0x9e,
0xc7, 0x53, 0xd7, 0x63, 0x6f, 0x70, 0x0f, 0xd8, 0x33, 0xff, 0xad, 0x96, 0x9e, 0x7a, 0xc2, 0x15,
0xd7, 0xec, 0x6f, 0x06, 0xf6, 0x60, 0x3b, 0x13, 0x3f, 0x0b, 0xfd, 0x38, 0x60, 0x7f, 0x37, 0xf0,
0x00, 0x30, 0x93, 0x9e, 0x87, 0x7e, 0xe0, 0x47, 0xf6, 0x9c, 0xfd, 0xc3, 0xc0, 0x7d, 0xd8, 0x79,
0xe6, 0xbf, 0x4d, 0xab, 0xa0, 0x1c, 0xfe, 0x99, 0x38, 0xa4, 0xf2, 0xe7, 0x7c, 0x71, 0xc9, 0x43,
0xf6, 0x2f, 0x03, 0x6f, 0x41, 0x2f, 0xaf, 0x48, 0x63, 0xfd, 0xdb, 0xd0, 0x2b, 0x4a, 0x55, 0xaf,
0x7d, 0xc1, 0xd9, 0x7f, 0x12, 0xb1, 0xce, 0x83, 0x0e, 0xf4, 0x5f, 0x03, 0x77, 0xa1, 0x9b, 0x89,
0xa5, 0xed, 0xff, 0x0c, 0x1c, 0xc0, 0x5e, 0x41, 0xe8, 0x7a, 0xd3, 0x73, 0xea, 0x38, 0xf6, 0x7f,
0xe3, 0xf8, 0xbb, 0x3a, 0x6c, 0xd3, 0x11, 0xf3, 0x38, 0x50, 0x13, 0xd0, 0x25, 0xe3, 0xbe, 0xea,
0x33, 0xac, 0x78, 0x13, 0x18, 0x54, 0xdd, 0xf2, 0xf1, 0x58, 0xb7, 0x23, 0x56, 0x3d, 0x0d, 0x0c,
0x2a, 0x2f, 0xfb, 0x34, 0x89, 0xba, 0x88, 0xdd, 0x7c, 0x21, 0x18, 0x54, 0xdd, 0xf8, 0xf1, 0x17,
0xb9, 0xf6, 0xc6, 0x55, 0xef, 0x04, 0x83, 0x95, 0x77, 0x7f, 0xfc, 0x32, 0x23, 0x00, 0x5c, 0xf1,
0x5a, 0x30, 0x58, 0x75, 0xff, 0xc7, 0x87, 0x29, 0x5f, 0x60, 0xf5, 0x9b, 0xc1, 0x60, 0xc5, 0x37,
0x00, 0xe5, 0x46, 0x5d, 0x6d, 0xaa, 0x9e, 0x02, 0x06, 0x95, 0xd7, 0x7a, 0xfc, 0x3c, 0x21, 0x24,
0xac, 0x7c, 0x6e, 0x18, 0x54, 0x7f, 0x3c, 0x50, 0x86, 0xb2, 0x0f, 0xd2, 0x55, 0xef, 0x08, 0x83,
0x95, 0x9f, 0x05, 0xf8, 0x38, 0xcf, 0x70, 0xb8, 0xf2, 0x35, 0x61, 0xb0, 0xfa, 0xe3, 0x80, 0x92,
0x9c, 0x7d, 0x7d, 0x56, 0xbf, 0x29, 0x0c, 0x56, 0x7d, 0x1f, 0x5c, 0x36, 0xe4, 0x5b, 0xd5, 0x83,
0xef, 0x03, 0x00, 0x00, 0xff, 0xff, 0x7e, 0xa9, 0x42, 0xf7, 0xc0, 0x12, 0x00, 0x00,
// 1654 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x49, 0x73, 0x1b, 0xc7,
0x15, 0xc6, 0x60, 0xc7, 0x03, 0x09, 0x34, 0x1f, 0x41, 0x12, 0x44, 0x72, 0x50, 0x26, 0x71, 0x4c,
0x29, 0x8e, 0x94, 0xa2, 0xcb, 0x2e, 0x31, 0x4e, 0xa5, 0x8a, 0x94, 0x68, 0x02, 0xe5, 0x92, 0xc4,
0x8c, 0x68, 0x1f, 0xb2, 0x14, 0x6a, 0x88, 0x69, 0x00, 0x13, 0x02, 0x33, 0xa3, 0x59, 0x68, 0x32,
0xff, 0xc0, 0xbf, 0x20, 0x3f, 0x21, 0xbf, 0x20, 0x97, 0x5c, 0x73, 0xca, 0xbe, 0xfc, 0x22, 0xd7,
0xeb, 0xee, 0x59, 0x39, 0xf0, 0x49, 0x17, 0xd4, 0xf4, 0xdb, 0xba, 0xfb, 0xf5, 0xf7, 0xbe, 0x7e,
0x0d, 0xd8, 0x09, 0xef, 0x3d, 0x1e, 0x3c, 0x13, 0xbf, 0x4f, 0x3d, 0xdf, 0x0d, 0x5d, 0x6c, 0x88,
0x81, 0xfe, 0xd7, 0x3a, 0xb4, 0x0c, 0xfe, 0x2e, 0xe2, 0x41, 0x88, 0x47, 0x50, 0xe7, 0xb3, 0xa5,
0x3b, 0xd4, 0x1e, 0x69, 0x47, 0xdd, 0x63, 0x7c, 0x2a, 0xcd, 0x95, 0xf6, 0x7c, 0xb6, 0x74, 0xc7,
0x15, 0x43, 0x58, 0xe0, 0x4f, 0xa0, 0x31, 0x5f, 0x45, 0xc1, 0x72, 0x58, 0x15, 0xa6, 0xbb, 0x79,
0xd3, 0xcf, 0x49, 0x35, 0xae, 0x18, 0xd2, 0x86, 0xc2, 0xda, 0xce, 0xdc, 0x1d, 0xd6, 0xca, 0xc2,
0x4e, 0x9c, 0xb9, 0x08, 0x4b, 0x16, 0xf8, 0x1c, 0x20, 0xe0, 0xe1, 0xd4, 0xf5, 0x42, 0xdb, 0x75,
0x86, 0x75, 0x61, 0x7f, 0x90, 0xb7, 0x7f, 0xcb, 0xc3, 0x37, 0x42, 0x3d, 0xae, 0x18, 0x9d, 0x20,
0x1e, 0xe0, 0x27, 0xd0, 0x31, 0x3d, 0x8f, 0x3b, 0xd6, 0x34, 0xbc, 0x1b, 0x36, 0x84, 0xe3, 0x7e,
0xde, 0xf1, 0x54, 0xa8, 0xaf, 0xee, 0xc6, 0x15, 0xa3, 0x6d, 0xaa, 0x6f, 0x3c, 0x86, 0xf6, 0x6c,
0xc9, 0x67, 0x37, 0xe4, 0xd5, 0x14, 0x5e, 0x7b, 0x79, 0xaf, 0x17, 0xa4, 0x15, 0x4e, 0xad, 0x99,
0xfc, 0xc4, 0xa7, 0xd0, 0x9c, 0xb9, 0xeb, 0xb5, 0x1d, 0x0e, 0x5b, 0xc2, 0x63, 0x50, 0xf0, 0x10,
0xba, 0x71, 0xc5, 0x50, 0x56, 0x94, 0xab, 0x77, 0x11, 0xf7, 0xef, 0x87, 0xed, 0xb2, 0x5c, 0xfd,
0x8a, 0x54, 0x94, 0x2b, 0x61, 0x43, 0x19, 0xb0, 0x1d, 0x3b, 0x9c, 0xce, 0x96, 0xa6, 0xed, 0x0c,
0x3b, 0x65, 0x19, 0x98, 0x38, 0x76, 0xf8, 0x82, 0xd4, 0x94, 0x01, 0x3b, 0x1e, 0xe0, 0x67, 0xd0,
0xbd, 0xe6, 0x0b, 0xdb, 0x99, 0x5e, 0xaf, 0xdc, 0xd9, 0xcd, 0x10, 0x84, 0xeb, 0x30, 0xef, 0x7a,
0x46, 0x06, 0x67, 0xa4, 0x1f, 0x57, 0x0c, 0xb8, 0x4e, 0x46, 0x94, 0x3e, 0xca, 0x9d, 0x74, 0xed,
0x96, 0xa5, 0xef, 0xdc, 0xb1, 0x62, 0xc7, 0x36, 0x57, 0xdf, 0x67, 0x2d, 0x68, 0xdc, 0x9a, 0xab,
0x88, 0xeb, 0x1f, 0x42, 0x37, 0x03, 0x13, 0x1c, 0x42, 0x6b, 0xcd, 0x83, 0xc0, 0x5c, 0x70, 0x81,
0xa5, 0x8e, 0x11, 0x0f, 0xf5, 0x1e, 0x6c, 0x65, 0x41, 0xa2, 0x6f, 0x27, 0x8e, 0x04, 0x04, 0xfd,
0xe7, 0xc0, 0x8a, 0xe7, 0x8c, 0x0c, 0x6a, 0x37, 0xfc, 0x5e, 0x05, 0xa2, 0x4f, 0x1c, 0xa8, 0x69,
0x05, 0xfa, 0x3a, 0x86, 0x5a, 0xc3, 0x0f, 0xa0, 0x5f, 0x38, 0x6a, 0xec, 0x41, 0x35, 0xbc, 0x13,
0x9e, 0x5b, 0x46, 0x35, 0xbc, 0xd3, 0x1f, 0x41, 0x2f, 0x7f, 0xae, 0x0f, 0x2c, 0x7e, 0x94, 0xac,
0x4f, 0x1c, 0x0c, 0x4d, 0x25, 0x0f, 0x4f, 0x9a, 0xc8, 0x81, 0xde, 0x87, 0xed, 0xdc, 0x69, 0xeb,
0x2f, 0x93, 0x75, 0x27, 0xa7, 0x83, 0x3f, 0x03, 0xb8, 0x35, 0x57, 0xb6, 0x65, 0x86, 0xae, 0x1f,
0x0c, 0xb5, 0x47, 0xb5, 0xa3, 0xee, 0x31, 0x53, 0x49, 0xfd, 0x2a, 0x56, 0x18, 0x19, 0x1b, 0xfd,
0x35, 0xec, 0x3c, 0x38, 0x28, 0x44, 0xa8, 0x2f, 0xcd, 0x60, 0xa9, 0x16, 0x20, 0xbe, 0xf1, 0x03,
0x68, 0x2e, 0xb9, 0x69, 0x71, 0x5f, 0xd5, 0xdf, 0xb6, 0x0a, 0x3b, 0x16, 0x42, 0x43, 0x29, 0xf5,
0xc7, 0x49, 0x46, 0xe2, 0xd3, 0xc3, 0x7d, 0xf2, 0xb4, 0x17, 0xcb, 0x50, 0xc4, 0xab, 0x1b, 0x6a,
0xa4, 0x7f, 0xd3, 0x80, 0xb6, 0xc1, 0x03, 0xcf, 0x75, 0x02, 0x8e, 0xcf, 0xa1, 0xc3, 0xef, 0x66,
0x5c, 0x56, 0xa1, 0x56, 0x00, 0x92, 0xb4, 0x39, 0x8f, 0xf5, 0x04, 0xc2, 0xc4, 0x18, 0x1f, 0x2b,
0x06, 0x29, 0xd2, 0x82, 0x72, 0xca, 0x52, 0xc8, 0x47, 0x31, 0x85, 0xd4, 0x0a, 0x55, 0x24, 0x6d,
0x0b, 0x1c, 0xf2, 0x58, 0x71, 0x48, 0xbd, 0x34, 0x70, 0x8e, 0x44, 0x4e, 0x72, 0x24, 0xd2, 0x28,
0x5d, 0xfe, 0x06, 0x16, 0xf9, 0x34, 0xcb, 0x22, 0xcd, 0x42, 0xf1, 0x49, 0xcf, 0x52, 0x1a, 0xf9,
0x38, 0x43, 0x23, 0xad, 0x42, 0xf5, 0x48, 0xb7, 0x12, 0x1e, 0x79, 0x96, 0xf0, 0x48, 0xbb, 0xc0,
0x3c, 0xca, 0xa5, 0x48, 0x24, 0x1f, 0xc5, 0x58, 0xec, 0x94, 0x66, 0xac, 0xc0, 0x24, 0x27, 0x39,
0x26, 0x81, 0xd2, 0x34, 0x6c, 0xa0, 0x92, 0x5f, 0xe4, 0xa9, 0x44, 0xf2, 0xc1, 0x61, 0xc1, 0x77,
0x23, 0x97, 0x7c, 0x9a, 0xe5, 0x92, 0xad, 0xd2, 0x24, 0x7e, 0x37, 0x99, 0x3c, 0xa6, 0x32, 0x28,
0xc0, 0x8c, 0x0a, 0x91, 0xfb, 0xbe, 0xeb, 0x2b, 0x1e, 0x90, 0x03, 0xfd, 0x88, 0xca, 0x35, 0x05,
0xd7, 0x77, 0x10, 0x8f, 0x28, 0xd9, 0x0c, 0xb4, 0xf4, 0x3f, 0x6a, 0xa9, 0x2f, 0xe1, 0x87, 0x0a,
0xcd, 0x32, 0x43, 0x53, 0x39, 0x8a, 0x6f, 0x8a, 0x77, 0xcb, 0xfd, 0x80, 0x80, 0x24, 0xb9, 0x26,
0x1e, 0xe2, 0x13, 0xd8, 0x59, 0x99, 0x41, 0x28, 0xb7, 0x39, 0x55, 0x35, 0x55, 0x13, 0x35, 0xd5,
0x27, 0x85, 0xdc, 0x9f, 0x10, 0xe3, 0x4f, 0x61, 0x37, 0x63, 0x6b, 0x7a, 0xde, 0x54, 0x54, 0x74,
0x5d, 0x54, 0x34, 0x4b, 0xac, 0x4f, 0x3d, 0x6f, 0x6c, 0x06, 0x4b, 0xfd, 0x83, 0x74, 0xff, 0x39,
0x16, 0x5c, 0xb9, 0x8b, 0x98, 0x05, 0x57, 0xee, 0x42, 0xff, 0x1d, 0x71, 0x4e, 0x1e, 0x94, 0xf8,
0x43, 0xa8, 0xcf, 0x5c, 0x4b, 0x6e, 0xbe, 0x77, 0xdc, 0x57, 0x69, 0x7f, 0xe1, 0x5a, 0xfc, 0xea,
0xde, 0xe3, 0x86, 0x50, 0x26, 0x1b, 0xad, 0x4a, 0x46, 0x11, 0x1b, 0x55, 0xe1, 0x6b, 0x69, 0xf8,
0xdf, 0x12, 0x79, 0xe4, 0xc0, 0xfb, 0x3e, 0xa3, 0xff, 0x3a, 0x3d, 0x0e, 0x49, 0xb4, 0xef, 0x31,
0xf6, 0x6f, 0x88, 0xe5, 0xb3, 0x35, 0xf4, 0x3e, 0x83, 0xef, 0xa6, 0x87, 0x93, 0x54, 0x8f, 0x3e,
0x00, 0x7c, 0x58, 0x16, 0xf2, 0x32, 0xcb, 0x03, 0x1e, 0x7f, 0x0c, 0x0d, 0xcb, 0x9e, 0xcf, 0x83,
0x61, 0x7d, 0xc3, 0x7d, 0x20, 0xd5, 0xfa, 0x9f, 0xaa, 0xd0, 0x94, 0x6c, 0x8e, 0x87, 0x44, 0x2e,
0xa6, 0xed, 0x4c, 0x6d, 0x2b, 0x06, 0xb5, 0x18, 0x4f, 0xac, 0x0c, 0x9b, 0x57, 0xb3, 0x6c, 0x4e,
0x5b, 0x09, 0xed, 0x35, 0x57, 0x78, 0x14, 0xdf, 0x78, 0x00, 0x2d, 0x27, 0x5a, 0x4f, 0xc3, 0xbb,
0x40, 0x00, 0xaf, 0x6e, 0x34, 0x9d, 0x68, 0x7d, 0x75, 0x17, 0xe0, 0x31, 0x6c, 0x67, 0xd0, 0x69,
0x5b, 0x8a, 0x32, 0x7b, 0x6a, 0x69, 0x62, 0xdd, 0x93, 0x97, 0x46, 0x37, 0xc1, 0xe9, 0xc4, 0xc2,
0x23, 0x10, 0xb0, 0x9d, 0x4a, 0x66, 0x92, 0x70, 0x6e, 0x8a, 0xbc, 0xf5, 0x48, 0xae, 0xa8, 0x8b,
0xae, 0xaa, 0xef, 0x41, 0x87, 0x32, 0x29, 0x4d, 0x5a, 0xc2, 0xa4, 0x4d, 0x02, 0xa1, 0xfc, 0x10,
0xfa, 0xe9, 0xf5, 0x27, 0x4d, 0xda, 0x32, 0x4a, 0x2a, 0x16, 0x86, 0x87, 0xd0, 0x4e, 0xca, 0xa6,
0x23, 0x2c, 0x5a, 0xa6, 0xaa, 0x96, 0x09, 0xb4, 0xd4, 0x12, 0x4b, 0xaf, 0xca, 0x27, 0xd0, 0xf0,
0x4c, 0x3f, 0x0c, 0xd4, 0x95, 0x14, 0x93, 0xe6, 0xa5, 0xe9, 0x53, 0x8b, 0xa1, 0x2e, 0x4c, 0x69,
0xa2, 0x9f, 0xc0, 0x76, 0x4e, 0x4e, 0xa4, 0x13, 0xba, 0xa1, 0xb9, 0x52, 0x97, 0xa5, 0x1c, 0x24,
0xd3, 0x54, 0xd3, 0x69, 0xf4, 0x13, 0xe8, 0x24, 0x67, 0x48, 0xc7, 0xe2, 0x45, 0xd7, 0x5f, 0xf0,
0xb8, 0x6b, 0x50, 0x23, 0x0a, 0xe7, 0xb9, 0x5f, 0xab, 0x5b, 0xbb, 0x6e, 0xc8, 0xc1, 0x93, 0xbf,
0x68, 0xd0, 0x7d, 0x25, 0x59, 0x8a, 0xd0, 0x88, 0x7d, 0xe8, 0xbe, 0x8e, 0x56, 0x2b, 0x25, 0x62,
0x15, 0x6c, 0x43, 0x9d, 0xc8, 0x8d, 0x69, 0xd8, 0x81, 0x86, 0x20, 0x2f, 0x56, 0x25, 0x21, 0xb1,
0x16, 0xab, 0xe1, 0x36, 0x74, 0x12, 0x9a, 0x60, 0x75, 0x1a, 0x26, 0xac, 0xc9, 0x1a, 0xb8, 0x05,
0xed, 0x98, 0x1d, 0xd8, 0x0e, 0x76, 0xa1, 0xa5, 0x8a, 0x99, 0x21, 0x02, 0x34, 0xe5, 0x41, 0xb1,
0x5d, 0x8a, 0x2c, 0xea, 0x90, 0x0d, 0x28, 0x40, 0x82, 0x6c, 0xb6, 0x87, 0x3d, 0x80, 0x14, 0xd3,
0x6c, 0x9f, 0x02, 0xc6, 0x68, 0x66, 0x07, 0x4f, 0xfe, 0xdc, 0x80, 0x76, 0x5c, 0x47, 0xd8, 0x84,
0xea, 0x9b, 0x2f, 0x58, 0x05, 0x77, 0x60, 0x7b, 0xe2, 0x84, 0xdc, 0x77, 0xcc, 0xd5, 0x39, 0xd1,
0x34, 0xd3, 0x48, 0x74, 0xee, 0xcc, 0x5c, 0xcb, 0x76, 0x16, 0x52, 0x54, 0xa5, 0x40, 0x67, 0xa6,
0xf5, 0xda, 0x75, 0x66, 0x9c, 0xd5, 0x90, 0xc1, 0xd6, 0x97, 0x8e, 0x19, 0x85, 0x4b, 0xd7, 0xb7,
0xff, 0xc0, 0x2d, 0x56, 0xc7, 0x3d, 0xd8, 0x99, 0x38, 0x41, 0x34, 0x9f, 0xdb, 0x33, 0x9b, 0x3b,
0xe1, 0xe7, 0x91, 0x63, 0x05, 0xac, 0x81, 0x08, 0xbd, 0x2f, 0x9d, 0x1b, 0xc7, 0xfd, 0xda, 0x51,
0xbd, 0x0d, 0x6b, 0xe2, 0x10, 0x06, 0x67, 0x66, 0xc0, 0x5f, 0x46, 0xde, 0xca, 0x9e, 0x99, 0x21,
0x3f, 0xb5, 0x2c, 0x9f, 0x07, 0x01, 0xe3, 0x14, 0x84, 0x34, 0xf9, 0xb9, 0xe7, 0xb1, 0x43, 0x2e,
0x3e, 0xe7, 0x01, 0x5b, 0xe0, 0x21, 0xec, 0x3d, 0xd0, 0x88, 0x99, 0x97, 0xf8, 0x7d, 0x18, 0x16,
0x55, 0x17, 0x66, 0x70, 0xe9, 0xdb, 0x33, 0xce, 0x6c, 0x1c, 0x00, 0x93, 0x5a, 0x01, 0xdd, 0x89,
0xe3, 0x45, 0x21, 0xfb, 0x7d, 0x3c, 0xbf, 0x92, 0xbe, 0x89, 0x42, 0x12, 0xdf, 0x14, 0xc4, 0x97,
0x02, 0x1e, 0x6c, 0x85, 0x07, 0xb0, 0x9b, 0x11, 0xbf, 0xa5, 0xfd, 0x51, 0x76, 0xd6, 0xe9, 0x7a,
0xa5, 0xc2, 0x5e, 0x38, 0x66, 0x18, 0xf9, 0x9c, 0x39, 0xb8, 0x0f, 0x48, 0x1a, 0x95, 0x92, 0x78,
0xe3, 0x6e, 0x3c, 0x83, 0x92, 0xab, 0x19, 0xbc, 0xa2, 0x78, 0x15, 0x2d, 0x6c, 0x87, 0xbd, 0xc3,
0x3d, 0x60, 0x17, 0xee, 0xad, 0x92, 0x9e, 0x3b, 0xa1, 0x1d, 0xde, 0xb3, 0xbf, 0x69, 0x38, 0x80,
0x7e, 0x2a, 0xbe, 0xf0, 0xdd, 0xc8, 0x63, 0x7f, 0xd7, 0xf0, 0x00, 0x30, 0x95, 0x5e, 0xfa, 0xae,
0xe7, 0x06, 0xe6, 0x8a, 0xfd, 0x43, 0xc3, 0x7d, 0xd8, 0xb9, 0x70, 0x6f, 0x93, 0x53, 0x90, 0x0e,
0xff, 0x8c, 0x1d, 0x12, 0xf9, 0x2b, 0xbe, 0xbe, 0xe6, 0x3e, 0xfb, 0x97, 0x86, 0x87, 0x30, 0xc8,
0x2a, 0x92, 0x58, 0xff, 0xd6, 0xd4, 0x8a, 0x12, 0xd5, 0x57, 0x6e, 0xc8, 0xd9, 0x7f, 0x62, 0xb1,
0xca, 0x83, 0x0a, 0xf4, 0x5f, 0x0d, 0x77, 0xa1, 0x97, 0x8a, 0x85, 0xed, 0xff, 0x34, 0x1c, 0xc1,
0x5e, 0x4e, 0x68, 0x3b, 0x8b, 0x4b, 0xaa, 0x38, 0xf6, 0x7f, 0xed, 0xf8, 0x9b, 0x06, 0xf4, 0xaf,
0x5e, 0xbd, 0xbd, 0x3c, 0xf5, 0xe4, 0x04, 0x74, 0xc5, 0x3e, 0x93, 0x75, 0x86, 0x25, 0x0f, 0xdf,
0x51, 0x59, 0x2b, 0x8b, 0xc7, 0xaa, 0x1c, 0xb1, 0xec, 0xfd, 0x3b, 0x2a, 0xed, 0x68, 0x69, 0x12,
0xd9, 0x6d, 0x3c, 0x7c, 0x06, 0x8f, 0xca, 0xda, 0x5a, 0xfc, 0x65, 0xa6, 0xbc, 0x71, 0xd3, 0x63,
0x78, 0xb4, 0xb1, 0xc1, 0xc5, 0xcf, 0x52, 0x02, 0xc0, 0x0d, 0x4f, 0xe2, 0xd1, 0xa6, 0x26, 0x17,
0x9f, 0x27, 0x7c, 0x81, 0xe5, 0x0f, 0xe3, 0xd1, 0x86, 0x46, 0x97, 0x72, 0x23, 0x2f, 0xf6, 0xb2,
0xf7, 0xee, 0xa8, 0xb4, 0x77, 0xc5, 0x4f, 0x62, 0x42, 0xc2, 0xd2, 0x37, 0xf5, 0xa8, 0xbc, 0x43,
0xa6, 0x0c, 0xa5, 0xaf, 0xae, 0x4d, 0x8f, 0xe5, 0xd1, 0xc6, 0xde, 0x17, 0x4f, 0xb3, 0x0c, 0x87,
0x1b, 0x9f, 0xcc, 0xa3, 0xcd, 0x1d, 0x30, 0x25, 0x39, 0x7d, 0x62, 0x95, 0x3f, 0x9c, 0x47, 0x9b,
0x9a, 0xe0, 0xeb, 0xa6, 0xf8, 0x43, 0xe6, 0xe3, 0x6f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf8, 0xa7,
0x82, 0x8b, 0xa5, 0x11, 0x00, 0x00,
}

+ 4
- 23
types/types.proto View File

@ -165,11 +165,10 @@ message ResponseFlush{
}
message ResponseInfo {
string info = 1; // backwards compatible
TMSPInfo tmsp_info = 2;
LastBlockInfo last_block = 3;
ConfigInfo config = 4;
string data = 1;
string version = 2;
uint64 last_block_height = 3;
bytes last_block_app_hash = 4;
}
message ResponseSetOption{
@ -211,24 +210,6 @@ message ResponseEndBlock{
repeated Validator diffs = 4;
}
//----------------------------------------
// Info types
message TMSPInfo {
string Version = 1;
}
message LastBlockInfo {
uint64 block_height = 1;
bytes app_hash = 2;
}
message ConfigInfo {
uint64 max_block_size_bytes = 1;
uint64 max_block_size_txs = 2;
uint64 max_tx_size = 3;
}
//----------------------------------------
// Blockchain Types


Write Preview
Loading…
Cancel
Save