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

Merge pull request #29 from tendermint/info_and_header 

Info and header
pull/1780/head
Ethan Buchman 8 years ago
committed by GitHub
parent
eece35eeeb 0bdb3b887e
commit
3a70c07ed1
18 changed files with 596 additions and 155 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -3
      client/client.go
  2. +7
    -7
      client/grpc_client.go
  3. +11
    -11
      client/local_client.go
  4. +7
    -7
      client/socket_client.go
  5. +11
    -1
      cmd/dummy/main.go
  6. +1
    -1
      cmd/tmsp-cli/tmsp-cli.go
  7. +3
    -3
      example/chain_aware/chain_aware_app.go
  8. +4
    -1
      example/chain_aware/chain_aware_test.go
  9. +2
    -2
      example/counter/counter.go
  10. +3
    -2
      example/dummy/dummy.go
  11. +7
    -0
      example/dummy/log.go
  12. +122
    -0
      example/dummy/persistent_dummy.go
  13. +2
    -2
      example/nil/nil_app.go
  14. +4
    -9
      server/socket_server.go
  15. +5
    -4
      types/application.go
  16. +4
    -4
      types/messages.go
  17. +353
    -95
      types/types.pb.go
  18. +47
    -3
      types/types.proto

+ 3
- 3
client/client.go View File

@ -25,7 +25,7 @@ type Client interface {
FlushSync() error
EchoSync(msg string) (res types.Result)
InfoSync() (res types.Result)
InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo)
SetOptionSync(key string, value string) (res types.Result)
AppendTxSync(tx []byte) (res types.Result)
CheckTxSync(tx []byte) (res types.Result)
@ -33,11 +33,11 @@ type Client interface {
CommitSync() (res types.Result)
InitChainAsync(validators []*types.Validator) *ReqRes
BeginBlockAsync(height uint64) *ReqRes
BeginBlockAsync(hash []byte, header *types.Header) *ReqRes
EndBlockAsync(height uint64) *ReqRes
InitChainSync(validators []*types.Validator) (err error)
BeginBlockSync(height uint64) (err error)
BeginBlockSync(hash []byte, header *types.Header) (err error)
EndBlockSync(height uint64) (changedValidators []*types.Validator, err error)
}


+ 7
- 7
client/grpc_client.go View File

@ -200,8 +200,8 @@ func (cli *grpcClient) InitChainAsync(validators []*types.Validator) *ReqRes {
return cli.finishAsyncCall(req, &types.Response{&types.Response_InitChain{res}})
}
func (cli *grpcClient) BeginBlockAsync(height uint64) *ReqRes {
req := types.ToRequestBeginBlock(height)
func (cli *grpcClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqRes {
req := types.ToRequestBeginBlock(hash, header)
res, err := cli.client.BeginBlock(context.Background(), req.GetBeginBlock(), grpc.FailFast(true))
if err != nil {
cli.StopForError(err)
@ -262,13 +262,13 @@ func (cli *grpcClient) FlushSync() error {
return nil
}
func (cli *grpcClient) InfoSync() (res types.Result) {
func (cli *grpcClient) InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
reqres := cli.InfoAsync()
if res := cli.checkErrGetResult(); res.IsErr() {
return res
return res, nil, nil, nil
}
resp := reqres.Response.GetInfo()
return types.NewResultOK([]byte(resp.Info), LOG)
return types.NewResultOK([]byte(resp.Info), LOG), resp.TmspInfo, resp.LastBlock, resp.Config
}
func (cli *grpcClient) SetOptionSync(key string, value string) (res types.Result) {
@ -321,8 +321,8 @@ func (cli *grpcClient) InitChainSync(validators []*types.Validator) (err error)
return cli.Error()
}
func (cli *grpcClient) BeginBlockSync(height uint64) (err error) {
cli.BeginBlockAsync(height)
func (cli *grpcClient) BeginBlockSync(hash []byte, header *types.Header) (err error) {
cli.BeginBlockAsync(hash, header)
return cli.Error()
}


+ 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 := app.Application.Info()
info, tmspInfo, blockInfo, configInfo := app.Application.Info()
app.mtx.Unlock()
return app.callback(
types.ToRequestInfo(),
types.ToResponseInfo(info),
types.ToResponseInfo(info, tmspInfo, blockInfo, configInfo),
)
}
@ -122,14 +122,14 @@ func (app *localClient) InitChainAsync(validators []*types.Validator) *ReqRes {
return reqRes
}
func (app *localClient) BeginBlockAsync(height uint64) *ReqRes {
func (app *localClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqRes {
app.mtx.Lock()
if bcApp, ok := app.Application.(types.BlockchainAware); ok {
bcApp.BeginBlock(height)
bcApp.BeginBlock(hash, header)
}
app.mtx.Unlock()
return app.callback(
types.ToRequestBeginBlock(height),
types.ToRequestBeginBlock(hash, header),
types.ToResponseBeginBlock(),
)
}
@ -157,11 +157,11 @@ func (app *localClient) EchoSync(msg string) (res types.Result) {
return types.OK.SetData([]byte(msg))
}
func (app *localClient) InfoSync() (res types.Result) {
func (app *localClient) InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
app.mtx.Lock()
info := app.Application.Info()
app.mtx.Unlock()
return types.OK.SetData([]byte(info))
defer app.mtx.Unlock()
info, tmspInfo, blockInfo, configInfo := app.Application.Info()
return types.OK.SetData([]byte(info)), tmspInfo, blockInfo, configInfo
}
func (app *localClient) SetOptionSync(key string, value string) (res types.Result) {
@ -208,10 +208,10 @@ func (app *localClient) InitChainSync(validators []*types.Validator) (err error)
return nil
}
func (app *localClient) BeginBlockSync(height uint64) (err error) {
func (app *localClient) BeginBlockSync(hash []byte, header *types.Header) (err error) {
app.mtx.Lock()
if bcApp, ok := app.Application.(types.BlockchainAware); ok {
bcApp.BeginBlock(height)
bcApp.BeginBlock(hash, header)
}
app.mtx.Unlock()
return nil


+ 7
- 7
client/socket_client.go View File

@ -263,8 +263,8 @@ func (cli *socketClient) InitChainAsync(validators []*types.Validator) *ReqRes {
return cli.queueRequest(types.ToRequestInitChain(validators))
}
func (cli *socketClient) BeginBlockAsync(height uint64) *ReqRes {
return cli.queueRequest(types.ToRequestBeginBlock(height))
func (cli *socketClient) BeginBlockAsync(hash []byte, header *types.Header) *ReqRes {
return cli.queueRequest(types.ToRequestBeginBlock(hash, header))
}
func (cli *socketClient) EndBlockAsync(height uint64) *ReqRes {
@ -292,14 +292,14 @@ func (cli *socketClient) FlushSync() error {
return cli.Error()
}
func (cli *socketClient) InfoSync() (res types.Result) {
func (cli *socketClient) InfoSync() (types.Result, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
reqres := cli.queueRequest(types.ToRequestInfo())
cli.FlushSync()
if err := cli.Error(); err != nil {
return types.ErrInternalError.SetLog(err.Error())
return types.ErrInternalError.SetLog(err.Error()), nil, nil, nil
}
resp := reqres.Response.GetInfo()
return types.Result{Code: OK, Data: []byte(resp.Info), Log: LOG}
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) {
@ -361,8 +361,8 @@ func (cli *socketClient) InitChainSync(validators []*types.Validator) (err error
return nil
}
func (cli *socketClient) BeginBlockSync(height uint64) (err error) {
cli.queueRequest(types.ToRequestBeginBlock(height))
func (cli *socketClient) BeginBlockSync(hash []byte, header *types.Header) (err error) {
cli.queueRequest(types.ToRequestBeginBlock(hash, header))
cli.FlushSync()
if err := cli.Error(); err != nil {
return err


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

@ -6,16 +6,26 @@ import (
. "github.com/tendermint/go-common"
"github.com/tendermint/tmsp/example/dummy"
"github.com/tendermint/tmsp/server"
"github.com/tendermint/tmsp/types"
)
func main() {
addrPtr := flag.String("addr", "tcp://0.0.0.0:46658", "Listen address")
tmspPtr := flag.String("tmsp", "socket", "socket | grpc")
persistencePtr := flag.String("persist", "", "directory to use for a database")
flag.Parse()
// Create the application - in memory or persisted to disk
var app types.Application
if *persistencePtr == "" {
app = dummy.NewDummyApplication()
} else {
app = dummy.NewPersistentDummyApplication(*persistencePtr)
}
// Start the listener
_, err := server.NewServer(*addrPtr, *tmspPtr, dummy.NewDummyApplication())
_, err := server.NewServer(*addrPtr, *tmspPtr, app)
if err != nil {
Exit(err.Error())
}


+ 1
- 1
cmd/tmsp-cli/tmsp-cli.go View File

@ -191,7 +191,7 @@ func cmdEcho(c *cli.Context) error {
// Get some info from the application
func cmdInfo(c *cli.Context) error {
res := client.InfoSync()
res, _, _, _ := client.InfoSync()
printResponse(c, res, string(res.Data), false)
return nil
}


+ 3
- 3
example/chain_aware/chain_aware_app.go View File

@ -36,8 +36,8 @@ func NewChainAwareApplication() *ChainAwareApplication {
return &ChainAwareApplication{}
}
func (app *ChainAwareApplication) Info() string {
return "nil"
func (app *ChainAwareApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
return "nil", nil, nil, nil
}
func (app *ChainAwareApplication) SetOption(key string, value string) (log string) {
@ -60,7 +60,7 @@ func (app *ChainAwareApplication) Query(query []byte) types.Result {
return types.NewResultOK([]byte(Fmt("%d,%d", app.beginCount, app.endCount)), "")
}
func (app *ChainAwareApplication) BeginBlock(height uint64) {
func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {
app.beginCount += 1
return
}


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

@ -8,6 +8,7 @@ import (
. "github.com/tendermint/go-common"
"github.com/tendermint/tmsp/client"
"github.com/tendermint/tmsp/server"
"github.com/tendermint/tmsp/types"
)
func TestChainAware(t *testing.T) {
@ -29,8 +30,10 @@ func TestChainAware(t *testing.T) {
defer client.Stop()
n := uint64(5)
hash := []byte("fake block hash")
header := &types.Header{}
for i := uint64(0); i < n; i++ {
client.BeginBlockSync(i)
client.BeginBlockSync(hash, header)
client.EndBlockSync(i)
client.CommitSync()
}


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

@ -18,8 +18,8 @@ func NewCounterApplication(serial bool) *CounterApplication {
return &CounterApplication{serial: serial}
}
func (app *CounterApplication) Info() string {
return Fmt("hashes:%v, txs:%v", app.hashCount, app.txCount)
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) SetOption(key string, value string) (log string) {


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

@ -20,8 +20,8 @@ func NewDummyApplication() *DummyApplication {
return &DummyApplication{state: state}
}
func (app *DummyApplication) Info() string {
return Fmt("size:%v", app.state.Size())
func (app *DummyApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
return Fmt("size:%v", app.state.Size()), nil, nil, nil
}
func (app *DummyApplication) SetOption(key string, value string) (log string) {
@ -50,6 +50,7 @@ func (app *DummyApplication) Commit() types.Result {
func (app *DummyApplication) Query(query []byte) types.Result {
index, value, exists := app.state.Get(query)
resStr := Fmt("Index=%v value=%v exists=%v", index, string(value), exists)
return types.NewResultOK([]byte(resStr), "")
}

+ 7
- 0
example/dummy/log.go View File

@ -0,0 +1,7 @@
package dummy
import (
"github.com/tendermint/go-logger"
)
var log = logger.New("module", "dummy")

+ 122
- 0
example/dummy/persistent_dummy.go View File

@ -0,0 +1,122 @@
package dummy
import (
"bytes"
. "github.com/tendermint/go-common"
dbm "github.com/tendermint/go-db"
"github.com/tendermint/go-merkle"
"github.com/tendermint/go-wire"
"github.com/tendermint/tmsp/types"
)
//-----------------------------------------
type PersistentDummyApplication struct {
app *DummyApplication
db dbm.DB
// latest received
blockHash []byte
blockHeader *types.Header
}
func NewPersistentDummyApplication(dbDir string) *PersistentDummyApplication {
db := dbm.NewDB("dummy", "leveldb", dbDir)
lastBlock := LoadLastBlock(db)
stateTree := merkle.NewIAVLTree(
0,
db,
)
stateTree.Load(lastBlock.AppHash)
log.Notice("Loaded state", "block", lastBlock.BlockHeight, "root", stateTree.Hash())
return &PersistentDummyApplication{
app: &DummyApplication{state: stateTree},
db: db,
}
}
func (app *PersistentDummyApplication) Info() (string, *types.TMSPInfo, *types.LastBlockInfo, *types.ConfigInfo) {
s, _, _, _ := app.app.Info()
lastBlock := LoadLastBlock(app.db)
return s, nil, &lastBlock, nil
}
func (app *PersistentDummyApplication) SetOption(key string, value string) (log string) {
return app.app.SetOption(key, value)
}
// tx is either "key=value" or just arbitrary bytes
func (app *PersistentDummyApplication) AppendTx(tx []byte) types.Result {
return app.app.AppendTx(tx)
}
func (app *PersistentDummyApplication) CheckTx(tx []byte) types.Result {
return app.app.CheckTx(tx)
}
func (app *PersistentDummyApplication) Commit() types.Result {
// Save
appHash := app.app.state.Save()
log.Info("Saved state", "root", appHash)
lastBlock := types.LastBlockInfo{
BlockHeight: app.blockHeader.Height,
BlockHash: app.blockHash,
AppHash: appHash, // this hash will be in the next block header
}
SaveLastBlock(app.db, lastBlock)
return types.NewResultOK(appHash, "")
}
func (app *PersistentDummyApplication) Query(query []byte) types.Result {
return app.app.Query(query)
}
func (app *PersistentDummyApplication) InitChain(validators []*types.Validator) {
return
}
func (app *PersistentDummyApplication) BeginBlock(hash []byte, header *types.Header) {
app.blockHash = hash
app.blockHeader = header
}
func (app *PersistentDummyApplication) EndBlock(height uint64) (diffs []*types.Validator) {
return nil
}
//-----------------------------------------
// persist the last block info
var lastBlockKey = []byte("lastblock")
// Get the last block from the db
func LoadLastBlock(db dbm.DB) (lastBlock types.LastBlockInfo) {
buf := db.Get(lastBlockKey)
if len(buf) != 0 {
r, n, err := bytes.NewReader(buf), new(int), new(error)
wire.ReadBinaryPtr(&lastBlock, r, 0, n, err)
if *err != nil {
// DATA HAS BEEN CORRUPTED OR THE SPEC HAS CHANGED
Exit(Fmt("Data has been corrupted or its spec has changed: %v\n", *err))
}
// TODO: ensure that buf is completely read.
}
return lastBlock
}
func SaveLastBlock(db dbm.DB, lastBlock types.LastBlockInfo) {
log.Notice("Saving block", "height", lastBlock.BlockHeight, "hash", lastBlock.BlockHash, "root", lastBlock.AppHash)
buf, n, err := new(bytes.Buffer), new(int), new(error)
wire.WriteBinary(lastBlock, buf, n, err)
if *err != nil {
// TODO
PanicCrisis(*err)
}
db.Set(lastBlockKey, buf.Bytes())
}

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

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


+ 4
- 9
server/socket_server.go View File

@ -168,8 +168,7 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
case *types.Request_Flush:
responses <- types.ToResponseFlush()
case *types.Request_Info:
data := s.app.Info()
responses <- types.ToResponseInfo(data)
responses <- types.ToResponseInfo(s.app.Info())
case *types.Request_SetOption:
so := r.SetOption
logStr := s.app.SetOption(so.Key, so.Value)
@ -189,17 +188,13 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
case *types.Request_InitChain:
if app, ok := s.app.(types.BlockchainAware); ok {
app.InitChain(r.InitChain.Validators)
responses <- types.ToResponseInitChain()
} else {
responses <- types.ToResponseInitChain()
}
responses <- types.ToResponseInitChain()
case *types.Request_BeginBlock:
if app, ok := s.app.(types.BlockchainAware); ok {
app.BeginBlock(r.BeginBlock.Height)
responses <- types.ToResponseBeginBlock()
} else {
responses <- types.ToResponseBeginBlock()
app.BeginBlock(r.BeginBlock.Hash, r.BeginBlock.Header)
}
responses <- types.ToResponseBeginBlock()
case *types.Request_EndBlock:
if app, ok := s.app.(types.BlockchainAware); ok {
validators := app.EndBlock(r.EndBlock.Height)


+ 5
- 4
types/application.go View File

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


+ 4
- 4
types/messages.go View File

@ -61,9 +61,9 @@ func ToRequestInitChain(validators []*Validator) *Request {
}
}
func ToRequestBeginBlock(height uint64) *Request {
func ToRequestBeginBlock(hash []byte, header *Header) *Request {
return &Request{
Value: &Request_BeginBlock{&RequestBeginBlock{height}},
Value: &Request_BeginBlock{&RequestBeginBlock{hash, header}},
}
}
@ -93,9 +93,9 @@ func ToResponseFlush() *Response {
}
}
func ToResponseInfo(info string) *Response {
func ToResponseInfo(info string, tmspInfo *TMSPInfo, blockInfo *LastBlockInfo, configInfo *ConfigInfo) *Response {
return &Response{
Value: &Response_Info{&ResponseInfo{info}},
Value: &Response_Info{&ResponseInfo{info, tmspInfo, blockInfo, configInfo}},
}
}


+ 353
- 95
types/types.pb.go View File

@ -34,6 +34,12 @@ It has these top-level messages:
ResponseInitChain
ResponseBeginBlock
ResponseEndBlock
TMSPInfo
LastBlockInfo
ConfigInfo
Header
BlockID
PartSetHeader
Validator
*/
package types
@ -753,7 +759,8 @@ func (m *RequestInitChain) GetValidators() []*Validator {
}
type RequestBeginBlock struct {
Height uint64 `protobuf:"varint,1,opt,name=height" json:"height,omitempty"`
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
Header *Header `protobuf:"bytes,2,opt,name=header" json:"header,omitempty"`
}
func (m *RequestBeginBlock) Reset() { *m = RequestBeginBlock{} }
@ -761,11 +768,18 @@ func (m *RequestBeginBlock) String() string { return proto.CompactTex
func (*RequestBeginBlock) ProtoMessage() {}
func (*RequestBeginBlock) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
func (m *RequestBeginBlock) GetHeight() uint64 {
func (m *RequestBeginBlock) GetHash() []byte {
if m != nil {
return m.Height
return m.Hash
}
return 0
return nil
}
func (m *RequestBeginBlock) GetHeader() *Header {
if m != nil {
return m.Header
}
return nil
}
type RequestEndBlock struct {
@ -1256,7 +1270,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"`
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"`
}
func (m *ResponseInfo) Reset() { *m = ResponseInfo{} }
@ -1271,6 +1288,27 @@ func (m *ResponseInfo) GetInfo() string {
return ""
}
func (m *ResponseInfo) GetTmspInfo() *TMSPInfo {
if m != nil {
return m.TmspInfo
}
return nil
}
func (m *ResponseInfo) GetLastBlock() *LastBlockInfo {
if m != nil {
return m.LastBlock
}
return nil
}
func (m *ResponseInfo) GetConfig() *ConfigInfo {
if m != nil {
return m.Config
}
return nil
}
type ResponseSetOption struct {
Log string `protobuf:"bytes,1,opt,name=log" json:"log,omitempty"`
}
@ -1447,6 +1485,198 @@ 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 int32 `protobuf:"varint,1,opt,name=block_height,json=blockHeight" json:"block_height,omitempty"`
BlockHash []byte `protobuf:"bytes,2,opt,name=block_hash,json=blockHash,proto3" json:"block_hash,omitempty"`
AppHash []byte `protobuf:"bytes,3,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() int32 {
if m != nil {
return m.BlockHeight
}
return 0
}
func (m *LastBlockInfo) GetBlockHash() []byte {
if m != nil {
return m.BlockHash
}
return nil
}
func (m *LastBlockInfo) GetAppHash() []byte {
if m != nil {
return m.AppHash
}
return nil
}
type ConfigInfo struct {
MaxBlockSize uint64 `protobuf:"varint,1,opt,name=max_block_size,json=maxBlockSize" json:"max_block_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) GetMaxBlockSize() uint64 {
if m != nil {
return m.MaxBlockSize
}
return 0
}
type Header struct {
ChainId string `protobuf:"bytes,1,opt,name=chain_id,json=chainId" json:"chain_id,omitempty"`
Height int32 `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
Time uint64 `protobuf:"varint,3,opt,name=time" json:"time,omitempty"`
NumTxs uint64 `protobuf:"varint,4,opt,name=num_txs,json=numTxs" json:"num_txs,omitempty"`
LastBlockId *BlockID `protobuf:"bytes,5,opt,name=last_block_id,json=lastBlockId" json:"last_block_id,omitempty"`
LastCommitHash []byte `protobuf:"bytes,6,opt,name=last_commit_hash,json=lastCommitHash,proto3" json:"last_commit_hash,omitempty"`
DataHash []byte `protobuf:"bytes,7,opt,name=data_hash,json=dataHash,proto3" json:"data_hash,omitempty"`
ValidatorsHash []byte `protobuf:"bytes,8,opt,name=validators_hash,json=validatorsHash,proto3" json:"validators_hash,omitempty"`
AppHash []byte `protobuf:"bytes,9,opt,name=app_hash,json=appHash,proto3" json:"app_hash,omitempty"`
}
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 (m *Header) GetChainId() string {
if m != nil {
return m.ChainId
}
return ""
}
func (m *Header) GetHeight() int32 {
if m != nil {
return m.Height
}
return 0
}
func (m *Header) GetTime() uint64 {
if m != nil {
return m.Time
}
return 0
}
func (m *Header) GetNumTxs() uint64 {
if m != nil {
return m.NumTxs
}
return 0
}
func (m *Header) GetLastBlockId() *BlockID {
if m != nil {
return m.LastBlockId
}
return nil
}
func (m *Header) GetLastCommitHash() []byte {
if m != nil {
return m.LastCommitHash
}
return nil
}
func (m *Header) GetDataHash() []byte {
if m != nil {
return m.DataHash
}
return nil
}
func (m *Header) GetValidatorsHash() []byte {
if m != nil {
return m.ValidatorsHash
}
return nil
}
func (m *Header) GetAppHash() []byte {
if m != nil {
return m.AppHash
}
return nil
}
type BlockID struct {
Hash []byte `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
Parts *PartSetHeader `protobuf:"bytes,2,opt,name=parts" json:"parts,omitempty"`
}
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 (m *BlockID) GetHash() []byte {
if m != nil {
return m.Hash
}
return nil
}
func (m *BlockID) GetParts() *PartSetHeader {
if m != nil {
return m.Parts
}
return nil
}
type PartSetHeader struct {
Total uint64 `protobuf:"varint,1,opt,name=total" json:"total,omitempty"`
Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
}
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 (m *PartSetHeader) GetTotal() uint64 {
if m != nil {
return m.Total
}
return 0
}
func (m *PartSetHeader) GetHash() []byte {
if m != nil {
return m.Hash
}
return nil
}
type Validator struct {
PubKey []byte `protobuf:"bytes,1,opt,name=pubKey,proto3" json:"pubKey,omitempty"`
Power uint64 `protobuf:"varint,2,opt,name=power" json:"power,omitempty"`
@ -1455,7 +1685,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{25} }
func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} }
func (m *Validator) GetPubKey() []byte {
if m != nil {
@ -1497,6 +1727,12 @@ 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")
proto.RegisterType((*Validator)(nil), "types.Validator")
proto.RegisterEnum("types.MessageType", MessageType_name, MessageType_value)
proto.RegisterEnum("types.CodeType", CodeType_name, CodeType_value)
@ -1907,93 +2143,115 @@ var _TMSPApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1393 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x57, 0x59, 0x53, 0xdc, 0xc6,
0x16, 0x1e, 0xc1, 0xac, 0x67, 0x60, 0x68, 0x0e, 0x03, 0xc8, 0x53, 0xf7, 0xc1, 0x57, 0xf7, 0x26,
0x01, 0xdb, 0x65, 0xa7, 0x70, 0xd9, 0x65, 0xc7, 0xa9, 0x54, 0x81, 0x8d, 0x81, 0x72, 0xd9, 0x26,
0xf2, 0xf2, 0x90, 0xa5, 0x28, 0xa1, 0xe9, 0x99, 0x51, 0x18, 0xba, 0x65, 0x2d, 0x18, 0xf2, 0x0f,
0xfc, 0x83, 0xf2, 0x92, 0xd7, 0x3c, 0x65, 0x5f, 0x7e, 0x51, 0xaa, 0x17, 0x49, 0x23, 0x21, 0xf9,
0xc9, 0x2f, 0x53, 0xdd, 0x67, 0xeb, 0x9e, 0x73, 0xbe, 0xf3, 0xe9, 0x34, 0x2c, 0x47, 0x17, 0x3e,
0x0d, 0x6f, 0xc9, 0xdf, 0x9b, 0x7e, 0xc0, 0x23, 0x8e, 0x0d, 0xb9, 0xb1, 0x7e, 0xaa, 0x43, 0xcb,
0xa6, 0x6f, 0x62, 0x1a, 0x46, 0xb8, 0x01, 0x75, 0xea, 0x4e, 0xb8, 0x69, 0x5c, 0x35, 0x36, 0xba,
0x5b, 0x78, 0x53, 0x99, 0x6b, 0xed, 0xae, 0x3b, 0xe1, 0xfb, 0x35, 0x5b, 0x5a, 0xe0, 0x75, 0x68,
0x8c, 0xa6, 0x71, 0x38, 0x31, 0xe7, 0xa4, 0xe9, 0x4a, 0xde, 0xf4, 0xb1, 0x50, 0xed, 0xd7, 0x6c,
0x65, 0x23, 0xc2, 0x7a, 0x6c, 0xc4, 0xcd, 0xf9, 0xb2, 0xb0, 0x07, 0x6c, 0x24, 0xc3, 0x0a, 0x0b,
0xbc, 0x07, 0x10, 0xd2, 0xe8, 0x88, 0xfb, 0x91, 0xc7, 0x99, 0x59, 0x97, 0xf6, 0xeb, 0x79, 0xfb,
0x17, 0x34, 0x7a, 0x2e, 0xd5, 0xfb, 0x35, 0xbb, 0x13, 0x26, 0x1b, 0xbc, 0x03, 0x1d, 0xc7, 0xf7,
0x29, 0x1b, 0x1e, 0x45, 0xe7, 0x66, 0x43, 0x3a, 0xae, 0xe5, 0x1d, 0xb7, 0xa5, 0xfa, 0xe5, 0xf9,
0x7e, 0xcd, 0x6e, 0x3b, 0x7a, 0x8d, 0x5b, 0xd0, 0x76, 0x27, 0xd4, 0x3d, 0x11, 0x5e, 0x4d, 0xe9,
0xb5, 0x9a, 0xf7, 0x7a, 0x28, 0xb4, 0xd2, 0xa9, 0xe5, 0xaa, 0x25, 0xde, 0x84, 0xa6, 0xcb, 0x4f,
0x4f, 0xbd, 0xc8, 0x6c, 0x49, 0x8f, 0x7e, 0xc1, 0x43, 0xea, 0xf6, 0x6b, 0xb6, 0xb6, 0x12, 0xb9,
0x7a, 0x13, 0xd3, 0xe0, 0xc2, 0x6c, 0x97, 0xe5, 0xea, 0x4b, 0xa1, 0x12, 0xb9, 0x92, 0x36, 0x22,
0x03, 0x1e, 0xf3, 0xa2, 0x23, 0x77, 0xe2, 0x78, 0xcc, 0xec, 0x94, 0x65, 0xe0, 0x80, 0x79, 0xd1,
0x43, 0xa1, 0x16, 0x19, 0xf0, 0x92, 0x0d, 0x3e, 0x80, 0xee, 0x31, 0x1d, 0x7b, 0xec, 0xe8, 0x78,
0xca, 0xdd, 0x13, 0x13, 0xa4, 0xab, 0x99, 0x77, 0xdd, 0x11, 0x06, 0x3b, 0x42, 0xbf, 0x5f, 0xb3,
0xe1, 0x38, 0xdd, 0x89, 0xf4, 0x89, 0xdc, 0x29, 0xd7, 0x6e, 0x59, 0xfa, 0x76, 0xd9, 0x30, 0x71,
0x6c, 0x53, 0xbd, 0xde, 0x69, 0x41, 0xe3, 0xcc, 0x99, 0xc6, 0xd4, 0xfa, 0x04, 0xba, 0x33, 0x30,
0x41, 0x13, 0x5a, 0xa7, 0x34, 0x0c, 0x9d, 0x31, 0x95, 0x58, 0xea, 0xd8, 0xc9, 0xd6, 0xea, 0xc1,
0xc2, 0x2c, 0x48, 0xac, 0xc5, 0xd4, 0x51, 0x00, 0xc1, 0xfa, 0x0c, 0x48, 0xb1, 0xce, 0x48, 0x60,
0xfe, 0x84, 0x5e, 0xe8, 0x40, 0x62, 0x89, 0x7d, 0x7d, 0xac, 0x44, 0x5f, 0xc7, 0xd6, 0x77, 0xf8,
0x2f, 0x2c, 0x15, 0x4a, 0x8d, 0x3d, 0x98, 0x8b, 0xce, 0xa5, 0xe7, 0x82, 0x3d, 0x17, 0x9d, 0x5b,
0x57, 0xa1, 0x97, 0xaf, 0xeb, 0x25, 0x8b, 0xff, 0xa7, 0xf7, 0x93, 0x85, 0x11, 0x47, 0xa9, 0xe2,
0x29, 0x13, 0xb5, 0xb1, 0x96, 0x60, 0x31, 0x57, 0x6d, 0xeb, 0x51, 0x7a, 0xef, 0xb4, 0x3a, 0xf8,
0x29, 0xc0, 0x99, 0x33, 0xf5, 0x86, 0x4e, 0xc4, 0x83, 0xd0, 0x34, 0xae, 0xce, 0x6f, 0x74, 0xb7,
0x88, 0x4e, 0xea, 0xeb, 0x44, 0x61, 0xcf, 0xd8, 0x58, 0xd7, 0x61, 0xf9, 0x52, 0xa1, 0x70, 0x0d,
0x9a, 0x13, 0xea, 0x8d, 0x27, 0x91, 0xbc, 0x42, 0xdd, 0xd6, 0x3b, 0x6b, 0x33, 0xfd, 0xbb, 0x49,
0x69, 0x2a, 0x4d, 0xdf, 0x35, 0xa0, 0x6d, 0xd3, 0xd0, 0xe7, 0x2c, 0xa4, 0x78, 0x0f, 0x3a, 0xf4,
0xdc, 0xa5, 0xaa, 0xc5, 0x8c, 0x02, 0x4a, 0x94, 0xcd, 0x6e, 0xa2, 0x17, 0x08, 0x4b, 0x8d, 0x71,
0x53, 0xd3, 0x43, 0xb1, 0xe7, 0xb5, 0xd3, 0x2c, 0x3f, 0xdc, 0x48, 0xf8, 0x61, 0xbe, 0xd0, 0x22,
0xca, 0xb6, 0x40, 0x10, 0x9b, 0x9a, 0x20, 0xea, 0xa5, 0x81, 0x73, 0x0c, 0x71, 0x3f, 0xc7, 0x10,
0x8d, 0xd2, 0xeb, 0x57, 0x50, 0xc4, 0xdd, 0x59, 0x8a, 0x68, 0x16, 0x3a, 0x4b, 0x79, 0x96, 0x72,
0xc4, 0xed, 0x19, 0x8e, 0x68, 0x15, 0x5a, 0x43, 0xb9, 0x95, 0x90, 0xc4, 0xad, 0x94, 0x24, 0xda,
0x05, 0x5a, 0xd1, 0x2e, 0x45, 0x96, 0xb8, 0x91, 0x00, 0xad, 0x53, 0x9a, 0xb1, 0x02, 0x4d, 0xdc,
0xcf, 0xd1, 0x04, 0x94, 0xa6, 0xa1, 0x82, 0x27, 0x3e, 0xcf, 0xf3, 0x84, 0x6a, 0xf6, 0x2b, 0x05,
0xdf, 0x4a, 0xa2, 0xb8, 0x3b, 0x4b, 0x14, 0x0b, 0xa5, 0x49, 0x7c, 0x3f, 0x53, 0x6c, 0x0a, 0x8c,
0x17, 0x60, 0x26, 0xba, 0x8c, 0x06, 0x01, 0x0f, 0x74, 0x93, 0xab, 0x8d, 0xb5, 0x21, 0x7a, 0x31,
0x03, 0xd7, 0x7b, 0x58, 0x45, 0xf6, 0xe3, 0x0c, 0xb4, 0x2c, 0x2b, 0x73, 0x15, 0xf0, 0x41, 0xd4,
0x08, 0x53, 0x7e, 0x72, 0x6d, 0x7d, 0x94, 0xdd, 0x24, 0x47, 0x36, 0x53, 0x3e, 0x4e, 0xc8, 0x66,
0xca, 0xc7, 0xd6, 0xb7, 0xa2, 0xb5, 0xf3, 0xf0, 0xc0, 0xff, 0x41, 0xdd, 0xe5, 0x43, 0x75, 0x8d,
0xde, 0xd6, 0x92, 0x4e, 0xc0, 0x43, 0x3e, 0xa4, 0x2f, 0x2f, 0x7c, 0x6a, 0x4b, 0xa5, 0x38, 0x73,
0xe8, 0x44, 0x8e, 0x6c, 0x97, 0x05, 0x5b, 0xae, 0x93, 0xf0, 0xf3, 0x59, 0xf8, 0x6f, 0x44, 0x1b,
0xe7, 0x60, 0xf4, 0x21, 0xa3, 0x7f, 0x95, 0x25, 0x46, 0xf1, 0xd9, 0x07, 0x8c, 0xfd, 0xb5, 0x20,
0xd3, 0x59, 0x34, 0x7f, 0xc8, 0xe0, 0x2b, 0x59, 0x71, 0x52, 0x1c, 0x5b, 0x7d, 0xc0, 0xcb, 0x00,
0x55, 0xdf, 0x8c, 0x3c, 0xf4, 0xf0, 0x63, 0x68, 0x0c, 0xbd, 0xd1, 0x28, 0x34, 0xeb, 0x15, 0xb4,
0xab, 0xd4, 0xd6, 0x7d, 0xe8, 0xa4, 0x32, 0x41, 0x9f, 0x7e, 0x7c, 0xfc, 0x84, 0x26, 0x64, 0xaf,
0x77, 0x02, 0x9d, 0x3e, 0x7f, 0x4b, 0x03, 0x79, 0xe5, 0xba, 0xad, 0x36, 0xd7, 0x7e, 0x34, 0xa0,
0xfb, 0x54, 0xe1, 0x4f, 0xfc, 0x3b, 0x5c, 0x82, 0xee, 0xb3, 0x78, 0x3a, 0xd5, 0x22, 0x52, 0xc3,
0x36, 0xd4, 0x05, 0x6c, 0x89, 0x81, 0x1d, 0x68, 0x48, 0x58, 0x92, 0x39, 0x21, 0x14, 0x80, 0x24,
0xf3, 0xb8, 0x08, 0x9d, 0x14, 0x76, 0xa4, 0x2e, 0xb6, 0x69, 0x3f, 0x90, 0x06, 0x2e, 0x40, 0x3b,
0x41, 0x1b, 0x59, 0xc6, 0x2e, 0xb4, 0x34, 0x38, 0x08, 0x22, 0x40, 0x53, 0xe5, 0x9b, 0xac, 0x88,
0xc8, 0xb2, 0xae, 0xa4, 0x2f, 0x02, 0xa4, 0x99, 0x22, 0xab, 0xd8, 0x03, 0xc8, 0x72, 0x44, 0xd6,
0x44, 0xc0, 0x24, 0x3b, 0x64, 0xfd, 0xda, 0x0f, 0x0d, 0x68, 0x27, 0x75, 0xc1, 0x26, 0xcc, 0x3d,
0x7f, 0x42, 0x6a, 0xb8, 0x0c, 0x8b, 0x07, 0x2c, 0xa2, 0x01, 0x73, 0xa6, 0xbb, 0xa2, 0x01, 0x89,
0x21, 0x44, 0xbb, 0xcc, 0xe5, 0x43, 0x8f, 0x8d, 0x95, 0x68, 0x4e, 0x04, 0xda, 0x71, 0x86, 0xcf,
0x38, 0x73, 0x29, 0x99, 0x47, 0x02, 0x0b, 0xaf, 0x98, 0x13, 0x47, 0x13, 0x1e, 0x78, 0xdf, 0xd3,
0x21, 0xa9, 0xe3, 0x2a, 0x2c, 0x1f, 0xb0, 0x30, 0x1e, 0x8d, 0x3c, 0xd7, 0xa3, 0x2c, 0x7a, 0x1c,
0xb3, 0x61, 0x48, 0x1a, 0x88, 0xd0, 0x7b, 0xc5, 0x4e, 0x18, 0x7f, 0xcb, 0xf4, 0x57, 0x8b, 0x34,
0xd1, 0x84, 0xfe, 0x8e, 0x13, 0xd2, 0x47, 0xb1, 0x3f, 0xf5, 0x5c, 0x27, 0xa2, 0xdb, 0xc3, 0x61,
0x40, 0xc3, 0x90, 0x50, 0x11, 0x44, 0x68, 0xf2, 0x67, 0x8f, 0x12, 0x87, 0x5c, 0x7c, 0x4a, 0x43,
0x32, 0xc6, 0x2b, 0xb0, 0x7a, 0x49, 0x23, 0x4f, 0x9e, 0xe0, 0x7f, 0xc0, 0x2c, 0xaa, 0xf6, 0x9c,
0xf0, 0x30, 0xf0, 0x5c, 0x4a, 0x3c, 0xec, 0x03, 0x51, 0x5a, 0xf9, 0x1d, 0x3e, 0x60, 0x7e, 0x1c,
0x91, 0xef, 0x92, 0xf3, 0xb5, 0xf4, 0x79, 0x1c, 0x09, 0xf1, 0x49, 0x41, 0x7c, 0x28, 0xe1, 0x41,
0xa6, 0xb8, 0x0e, 0x2b, 0x33, 0xe2, 0x17, 0xe2, 0xff, 0x89, 0xec, 0x9c, 0x66, 0xf7, 0x55, 0x0a,
0x6f, 0xcc, 0x9c, 0x28, 0x0e, 0x28, 0x61, 0xb8, 0x06, 0x28, 0x34, 0x3a, 0x25, 0xc9, 0x1f, 0xe7,
0xc9, 0x09, 0x5a, 0xae, 0x4f, 0xf0, 0x8b, 0xe2, 0x69, 0x3c, 0xf6, 0x18, 0x79, 0x83, 0xab, 0x40,
0xf6, 0xf8, 0x99, 0x96, 0xee, 0xb2, 0xc8, 0x8b, 0x2e, 0xc8, 0xcf, 0x06, 0xf6, 0x61, 0x29, 0x13,
0xef, 0x05, 0x3c, 0xf6, 0xc9, 0x2f, 0x06, 0xae, 0x03, 0x66, 0xd2, 0xc3, 0x80, 0xfb, 0x3c, 0x74,
0xa6, 0xe4, 0x57, 0x03, 0xd7, 0x60, 0x79, 0x8f, 0x9f, 0xa5, 0x55, 0x50, 0x0e, 0xbf, 0x25, 0x0e,
0xa9, 0xfc, 0x29, 0x3d, 0x3d, 0xa6, 0x01, 0xf9, 0xdd, 0xc0, 0x2b, 0xd0, 0x9f, 0x55, 0xa4, 0xb1,
0xfe, 0x30, 0xf4, 0x8d, 0x52, 0xd5, 0x6b, 0x1e, 0x51, 0xf2, 0x67, 0x22, 0xd6, 0x79, 0xd0, 0x81,
0xfe, 0x32, 0x70, 0x05, 0x7a, 0x99, 0x58, 0xda, 0xfe, 0x6d, 0xe0, 0x00, 0x56, 0x73, 0x42, 0x8f,
0x8d, 0x0f, 0x45, 0xc7, 0x91, 0x7f, 0x8c, 0xad, 0x77, 0x0d, 0x58, 0x7a, 0xf9, 0xf4, 0xc5, 0xe1,
0xb6, 0xaf, 0x0e, 0x10, 0x94, 0x7d, 0x4b, 0xf5, 0x19, 0x96, 0xbc, 0x57, 0x06, 0x65, 0x43, 0x0a,
0x6e, 0xe9, 0x76, 0xc4, 0xb2, 0x67, 0xcb, 0xa0, 0x74, 0x56, 0x11, 0x87, 0xa8, 0x0f, 0xc9, 0xe5,
0xd7, 0xcb, 0xa0, 0x6c, 0x60, 0xc1, 0x2f, 0x66, 0xda, 0x1b, 0xab, 0xde, 0x30, 0x83, 0xca, 0xd1,
0x05, 0x1f, 0x64, 0x04, 0x80, 0x15, 0x2f, 0x99, 0x41, 0xd5, 0xf8, 0x82, 0xf7, 0x52, 0xbe, 0xc0,
0xf2, 0xf7, 0xcc, 0xa0, 0x62, 0x84, 0x11, 0xb9, 0x51, 0x1f, 0x8a, 0xb2, 0x67, 0xca, 0xa0, 0x74,
0x2a, 0xc1, 0x3b, 0x09, 0x21, 0x61, 0xe9, 0x53, 0x68, 0x50, 0x3e, 0xfb, 0x88, 0x0c, 0x65, 0xc3,
0x72, 0xd5, 0x1b, 0x67, 0x50, 0x39, 0xd5, 0xe0, 0xf6, 0x2c, 0xc3, 0x61, 0xe5, 0x4b, 0x67, 0x50,
0x3d, 0xdb, 0x88, 0x24, 0x67, 0xc3, 0x73, 0xf9, 0x7b, 0x67, 0x50, 0x35, 0xde, 0x1c, 0x37, 0xe5,
0x3b, 0xfa, 0xf6, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9c, 0xac, 0x2d, 0x4b, 0x5c, 0x0f, 0x00,
0x00,
// 1746 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x49, 0x73, 0xdb, 0xc8,
0x15, 0x16, 0x29, 0x6e, 0x78, 0xa4, 0xa8, 0xd6, 0xd3, 0x46, 0x33, 0x49, 0x95, 0x07, 0xf1, 0x64,
0x24, 0xc7, 0x65, 0xa7, 0xe4, 0x9a, 0x29, 0x3b, 0x93, 0x4a, 0x95, 0x65, 0x6b, 0x2c, 0xd5, 0xc4,
0xb6, 0x02, 0x7b, 0x7c, 0xc8, 0x52, 0x2c, 0x88, 0x68, 0x92, 0x88, 0x40, 0x00, 0x06, 0x1a, 0x1a,
0xca, 0xff, 0x60, 0x7e, 0x49, 0xae, 0xb9, 0xe4, 0x92, 0x6b, 0x4e, 0xd9, 0x97, 0x5f, 0x34, 0xf5,
0xba, 0x1b, 0x00, 0x01, 0x81, 0x3e, 0xf9, 0xc2, 0xc2, 0x5b, 0xbb, 0xfb, 0x2d, 0x5f, 0xbf, 0x26,
0x6c, 0x89, 0xeb, 0x90, 0xc7, 0x0f, 0xe4, 0xef, 0xfd, 0x30, 0x0a, 0x44, 0x80, 0x4d, 0x49, 0x98,
0x7f, 0x6d, 0x40, 0xdb, 0xe2, 0xef, 0x12, 0x1e, 0x0b, 0x3c, 0x80, 0x06, 0x1f, 0xcf, 0x82, 0x41,
0xed, 0x76, 0xed, 0xa0, 0x7b, 0x84, 0xf7, 0x95, 0xba, 0x96, 0x9e, 0x8c, 0x67, 0xc1, 0xe9, 0x9a,
0x25, 0x35, 0xf0, 0xa7, 0xd0, 0x9c, 0x78, 0x49, 0x3c, 0x1b, 0xd4, 0xa5, 0xea, 0x76, 0x51, 0xf5,
0x2b, 0x12, 0x9d, 0xae, 0x59, 0x4a, 0x87, 0xdc, 0xba, 0xfe, 0x24, 0x18, 0xac, 0x57, 0xb9, 0x3d,
0xf3, 0x27, 0xd2, 0x2d, 0x69, 0xe0, 0x23, 0x80, 0x98, 0x8b, 0x51, 0x10, 0x0a, 0x37, 0xf0, 0x07,
0x0d, 0xa9, 0xbf, 0x5f, 0xd4, 0x7f, 0xcd, 0xc5, 0x2b, 0x29, 0x3e, 0x5d, 0xb3, 0x8c, 0x38, 0x25,
0xf0, 0x73, 0x30, 0xec, 0x30, 0xe4, 0xbe, 0x33, 0x12, 0x8b, 0x41, 0x53, 0x1a, 0xee, 0x15, 0x0d,
0x9f, 0x48, 0xf1, 0x9b, 0xc5, 0xe9, 0x9a, 0xd5, 0xb1, 0xf5, 0x37, 0x1e, 0x41, 0x67, 0x3c, 0xe3,
0xe3, 0x4b, 0xb2, 0x6a, 0x49, 0xab, 0xdd, 0xa2, 0xd5, 0x53, 0x92, 0x4a, 0xa3, 0xf6, 0x58, 0x7d,
0xe2, 0x7d, 0x68, 0x8d, 0x83, 0xf9, 0xdc, 0x15, 0x83, 0xb6, 0xb4, 0xd8, 0x29, 0x59, 0x48, 0xd9,
0xe9, 0x9a, 0xa5, 0xb5, 0x28, 0x56, 0xef, 0x12, 0x1e, 0x5d, 0x0f, 0x3a, 0x55, 0xb1, 0xfa, 0x35,
0x89, 0x28, 0x56, 0x52, 0x87, 0x22, 0xe0, 0xfa, 0xae, 0x18, 0x8d, 0x67, 0xb6, 0xeb, 0x0f, 0x8c,
0xaa, 0x08, 0x9c, 0xf9, 0xae, 0x78, 0x4a, 0x62, 0x8a, 0x80, 0x9b, 0x12, 0xf8, 0x25, 0x74, 0x2f,
0xf8, 0xd4, 0xf5, 0x47, 0x17, 0x5e, 0x30, 0xbe, 0x1c, 0x80, 0x34, 0x1d, 0x14, 0x4d, 0x8f, 0x49,
0xe1, 0x98, 0xe4, 0xa7, 0x6b, 0x16, 0x5c, 0x64, 0x14, 0x85, 0x8f, 0x62, 0xa7, 0x4c, 0xbb, 0x55,
0xe1, 0x3b, 0xf1, 0x9d, 0xd4, 0xb0, 0xc3, 0xf5, 0xf7, 0x71, 0x1b, 0x9a, 0x57, 0xb6, 0x97, 0x70,
0xf3, 0x33, 0xe8, 0x2e, 0x95, 0x09, 0x0e, 0xa0, 0x3d, 0xe7, 0x71, 0x6c, 0x4f, 0xb9, 0xac, 0x25,
0xc3, 0x4a, 0x49, 0xb3, 0x0f, 0xbd, 0xe5, 0x22, 0x31, 0x37, 0x32, 0x43, 0x2a, 0x04, 0xf3, 0xe7,
0xc0, 0xca, 0x79, 0x46, 0x06, 0xeb, 0x97, 0xfc, 0x5a, 0x3b, 0xa2, 0x4f, 0xdc, 0xd1, 0xcb, 0xca,
0xea, 0x33, 0x2c, 0xbd, 0x87, 0x4f, 0x60, 0xb3, 0x94, 0x6a, 0xec, 0x43, 0x5d, 0x2c, 0xa4, 0x65,
0xcf, 0xaa, 0x8b, 0x85, 0x79, 0x1b, 0xfa, 0xc5, 0xbc, 0xde, 0xd0, 0xb8, 0x93, 0xed, 0x4f, 0x26,
0x86, 0x96, 0x52, 0xc9, 0x53, 0x2a, 0x8a, 0x30, 0x37, 0x61, 0xa3, 0x90, 0x6d, 0xf3, 0x59, 0xb6,
0xef, 0x2c, 0x3b, 0xf8, 0x33, 0x80, 0x2b, 0xdb, 0x73, 0x1d, 0x5b, 0x04, 0x51, 0x3c, 0xa8, 0xdd,
0x5e, 0x3f, 0xe8, 0x1e, 0x31, 0x1d, 0xd4, 0xb7, 0xa9, 0xc0, 0x5a, 0xd2, 0x31, 0x5f, 0xc2, 0xd6,
0x8d, 0x44, 0x21, 0x42, 0x63, 0x66, 0xc7, 0x33, 0xbd, 0x01, 0xf9, 0x8d, 0x9f, 0x42, 0x6b, 0xc6,
0x6d, 0x87, 0x47, 0xba, 0xff, 0x36, 0xb4, 0xdb, 0x53, 0xc9, 0xb4, 0xb4, 0xd0, 0x3c, 0xcc, 0x22,
0x92, 0x66, 0x0f, 0xf7, 0xc8, 0xd2, 0x9d, 0xce, 0x84, 0xf4, 0xd7, 0xb0, 0x34, 0x65, 0x7e, 0xd7,
0x84, 0x8e, 0xc5, 0xe3, 0x30, 0xf0, 0x63, 0x8e, 0x8f, 0xc0, 0xe0, 0x8b, 0x31, 0x57, 0x5d, 0x58,
0x2b, 0x15, 0x92, 0xd2, 0x39, 0x49, 0xe5, 0x54, 0x84, 0x99, 0x32, 0x1e, 0x6a, 0x04, 0x29, 0xc3,
0x82, 0x36, 0x5a, 0x86, 0x90, 0x7b, 0x29, 0x84, 0xac, 0x97, 0xba, 0x48, 0xe9, 0x96, 0x30, 0xe4,
0x50, 0x63, 0x48, 0xa3, 0xd2, 0x71, 0x01, 0x44, 0x1e, 0x17, 0x40, 0xa4, 0x59, 0xb9, 0xfd, 0x15,
0x28, 0xf2, 0xc5, 0x32, 0x8a, 0xb4, 0x4a, 0xcd, 0xa7, 0x2c, 0x2b, 0x61, 0xe4, 0xe1, 0x12, 0x8c,
0xb4, 0x4b, 0xdd, 0xa3, 0xcc, 0x2a, 0x70, 0xe4, 0x41, 0x86, 0x23, 0x9d, 0x12, 0xf2, 0x68, 0x93,
0x32, 0x90, 0xdc, 0x4b, 0x6b, 0xd1, 0xa8, 0x8c, 0x58, 0x09, 0x49, 0x1e, 0x17, 0x90, 0x04, 0x2a,
0xc3, 0xb0, 0x02, 0x4a, 0x7e, 0x51, 0x84, 0x12, 0x85, 0x07, 0xb7, 0x4a, 0xb6, 0x2b, 0xb1, 0xe4,
0x8b, 0x65, 0x2c, 0xe9, 0x55, 0x06, 0xf1, 0xc3, 0x60, 0x72, 0x48, 0x6d, 0x50, 0x2a, 0x33, 0x6a,
0x44, 0x1e, 0x45, 0x41, 0xa4, 0x71, 0x40, 0x11, 0xe6, 0x01, 0xb5, 0x6b, 0x5e, 0x5c, 0x1f, 0x00,
0x1e, 0xd9, 0xb2, 0x4b, 0xa5, 0x65, 0xfe, 0xa9, 0x96, 0xdb, 0x52, 0xfd, 0x50, 0xa3, 0xc9, 0x12,
0x53, 0x86, 0xaa, 0x96, 0xee, 0x81, 0x21, 0xe6, 0x71, 0x38, 0x92, 0x02, 0x55, 0xd4, 0x9b, 0xfa,
0x2c, 0x6f, 0x5e, 0xbc, 0x3e, 0x27, 0x3b, 0xab, 0x43, 0x1a, 0xd2, 0xc3, 0x43, 0x00, 0xcf, 0x8e,
0x85, 0x3e, 0x7a, 0xb1, 0xae, 0x7f, 0x65, 0xc7, 0x42, 0x9e, 0x53, 0xda, 0x18, 0x5e, 0x4a, 0xe2,
0x21, 0x95, 0x81, 0x3f, 0x71, 0xa7, 0xba, 0xb6, 0xb7, 0xb4, 0xc1, 0x53, 0xc9, 0x94, 0xda, 0x5a,
0xc1, 0xfc, 0x34, 0x0f, 0x4c, 0x01, 0x1e, 0xbd, 0x60, 0x9a, 0xc2, 0xa3, 0x17, 0x4c, 0xcd, 0xdf,
0x13, 0x18, 0x15, 0xab, 0x15, 0x7f, 0x0c, 0x8d, 0x71, 0xe0, 0xa8, 0xa8, 0xf4, 0xb3, 0x33, 0x3c,
0x0d, 0x1c, 0xfe, 0xe6, 0x3a, 0xe4, 0x96, 0x14, 0x52, 0x04, 0x1c, 0x5b, 0xd8, 0xf2, 0xa0, 0x3d,
0x4b, 0x7e, 0xa7, 0xee, 0xd7, 0x73, 0xf7, 0xbf, 0x23, 0x54, 0x29, 0x54, 0xf5, 0xc7, 0xf4, 0xfe,
0x9b, 0x3c, 0x4f, 0x0a, 0x81, 0x3f, 0xa2, 0xef, 0xdf, 0x12, 0xfc, 0x2f, 0x37, 0xd7, 0xc7, 0x74,
0xbe, 0x9d, 0x27, 0x27, 0x6b, 0x2b, 0x73, 0x07, 0xf0, 0x66, 0xbf, 0xa8, 0x5b, 0xae, 0xd8, 0x09,
0xf8, 0x13, 0x68, 0x3a, 0xee, 0x64, 0x12, 0x0f, 0x1a, 0x2b, 0x2e, 0x0a, 0x25, 0x36, 0xef, 0x40,
0x27, 0xad, 0x3c, 0xaa, 0xf6, 0xb7, 0x3c, 0x8a, 0x53, 0x94, 0x36, 0xac, 0x94, 0x34, 0x3d, 0xd8,
0x28, 0x14, 0x1c, 0x7e, 0x02, 0x3d, 0x59, 0x95, 0xa3, 0x25, 0xf4, 0x6f, 0x5a, 0x5d, 0xc9, 0x3b,
0x95, 0x2c, 0xfc, 0x11, 0x80, 0x56, 0xb1, 0xf5, 0x60, 0xd7, 0xb3, 0x0c, 0xa5, 0x40, 0x77, 0xce,
0x2d, 0x20, 0xbc, 0x53, 0xc2, 0x75, 0x29, 0x6c, 0xdb, 0x61, 0x48, 0x22, 0xf3, 0x08, 0x20, 0xaf,
0x56, 0xbc, 0x03, 0xfd, 0xb9, 0xbd, 0x50, 0x4d, 0x30, 0x8a, 0xdd, 0xf7, 0x5c, 0x5f, 0x35, 0xbd,
0xb9, 0xbd, 0x90, 0x1b, 0x7a, 0xed, 0xbe, 0xe7, 0xe6, 0x1f, 0xeb, 0xd0, 0x52, 0xd7, 0x15, 0x79,
0x96, 0x20, 0x35, 0x72, 0x9d, 0xf4, 0x1c, 0x92, 0x3e, 0x73, 0x96, 0xae, 0xab, 0xba, 0xdc, 0xb0,
0xa6, 0x28, 0x25, 0xc2, 0x9d, 0x73, 0xb9, 0x91, 0x86, 0x25, 0xbf, 0x71, 0x1f, 0xda, 0x7e, 0x32,
0x1f, 0x89, 0x45, 0x2c, 0x3b, 0xa9, 0x61, 0xb5, 0xfc, 0x64, 0xfe, 0x66, 0x11, 0xe3, 0x11, 0x6c,
0xe4, 0x6d, 0x49, 0x8b, 0xa8, 0x3b, 0xa1, 0xaf, 0x43, 0xac, 0x82, 0xf4, 0xcc, 0xea, 0x66, 0x3d,
0x79, 0xe6, 0xe0, 0x01, 0x30, 0x69, 0xa3, 0xa0, 0x57, 0x9d, 0xba, 0x25, 0x4f, 0xdd, 0x27, 0xbe,
0xc6, 0x66, 0x8a, 0xcb, 0x0f, 0xc0, 0xa0, 0x8a, 0x50, 0x2a, 0x6d, 0xa9, 0xd2, 0x21, 0x86, 0x14,
0x7e, 0x06, 0x9b, 0xf9, 0xfd, 0xae, 0x54, 0x3a, 0xca, 0x4b, 0xce, 0xbe, 0x11, 0x5d, 0xa3, 0x18,
0xdd, 0x33, 0x68, 0xeb, 0x2d, 0x56, 0xce, 0x02, 0x77, 0xa1, 0x19, 0xda, 0x91, 0x88, 0x35, 0x3c,
0xa5, 0x78, 0x73, 0x6e, 0x47, 0x34, 0x43, 0xe9, 0x89, 0x40, 0xa9, 0x98, 0x8f, 0x61, 0xa3, 0xc0,
0x27, 0x54, 0x15, 0x81, 0xb0, 0x3d, 0x9d, 0x22, 0x45, 0x64, 0xcb, 0xd4, 0xf3, 0x65, 0xcc, 0xc7,
0x60, 0x64, 0xb5, 0x48, 0x69, 0x09, 0x93, 0x8b, 0xaf, 0x79, 0x3a, 0x16, 0x69, 0x8a, 0xdc, 0x85,
0xc1, 0xb7, 0x7a, 0x2c, 0x69, 0x58, 0x8a, 0xb8, 0xfb, 0x97, 0x1a, 0x74, 0x5f, 0x28, 0x18, 0xa6,
0xae, 0xc2, 0x4d, 0xe8, 0xbe, 0x4c, 0x3c, 0x4f, 0xb3, 0xd8, 0x1a, 0x76, 0xa0, 0x41, 0xe8, 0xcd,
0x6a, 0x68, 0x40, 0x53, 0xa2, 0x33, 0xab, 0x13, 0x93, 0xca, 0x89, 0xad, 0xe3, 0x06, 0x18, 0x19,
0xdc, 0xb1, 0x06, 0x91, 0xd9, 0xb5, 0xc0, 0x9a, 0xd8, 0x83, 0x4e, 0x8a, 0x72, 0x6c, 0x0b, 0xbb,
0xd0, 0xd6, 0xa0, 0xc4, 0x10, 0x01, 0x5a, 0x2a, 0x51, 0x6c, 0x9b, 0x3c, 0x4b, 0x3c, 0x61, 0x3b,
0xe4, 0x20, 0xeb, 0x50, 0xb6, 0x8b, 0x7d, 0x80, 0xbc, 0x37, 0xd9, 0x1e, 0x39, 0x4c, 0xbb, 0x92,
0xed, 0xdf, 0xfd, 0x73, 0x13, 0x3a, 0x29, 0x1e, 0x60, 0x0b, 0xea, 0xaf, 0xbe, 0x66, 0x6b, 0xb8,
0x05, 0x1b, 0x67, 0xbe, 0xe0, 0x91, 0x6f, 0x7b, 0x27, 0x74, 0x0f, 0xb1, 0x1a, 0xb1, 0x4e, 0xfc,
0x71, 0xe0, 0xb8, 0xfe, 0x54, 0xb1, 0xea, 0xe4, 0xe8, 0xd8, 0x76, 0x5e, 0x06, 0xfe, 0x98, 0xb3,
0x75, 0x64, 0xd0, 0xfb, 0xc6, 0xb7, 0x13, 0x31, 0x0b, 0x22, 0xf7, 0x3d, 0x77, 0x58, 0x03, 0x77,
0x61, 0xeb, 0xcc, 0x8f, 0x93, 0xc9, 0xc4, 0x1d, 0xbb, 0xdc, 0x17, 0x5f, 0x25, 0xbe, 0x13, 0xb3,
0x26, 0x22, 0xf4, 0xbf, 0xf1, 0x2f, 0xfd, 0xe0, 0x5b, 0x5f, 0x0f, 0x6f, 0xac, 0x85, 0x03, 0xd8,
0x39, 0xb6, 0x63, 0xfe, 0x2c, 0x09, 0x3d, 0x77, 0x6c, 0x0b, 0xfe, 0xc4, 0x71, 0x22, 0x1e, 0xc7,
0x8c, 0x93, 0x13, 0x92, 0x14, 0xd7, 0x9e, 0xa4, 0x06, 0x05, 0xff, 0x9c, 0xc7, 0x6c, 0x8a, 0xb7,
0x60, 0xf7, 0x86, 0x44, 0xae, 0x3c, 0xc3, 0x1f, 0xc2, 0xa0, 0x2c, 0x7a, 0x6e, 0xc7, 0xe7, 0x91,
0x3b, 0xe6, 0xcc, 0xc5, 0x1d, 0x60, 0x4a, 0x2a, 0x4b, 0xf7, 0xcc, 0x0f, 0x13, 0xc1, 0xfe, 0x90,
0xae, 0xaf, 0xb9, 0xaf, 0x12, 0x41, 0xec, 0xcb, 0x12, 0xfb, 0x5c, 0x96, 0x07, 0xf3, 0x70, 0x1f,
0xb6, 0x97, 0xd8, 0xaf, 0xe9, 0x7c, 0x14, 0x9d, 0x79, 0xbe, 0x5f, 0x25, 0x70, 0xa7, 0xbe, 0x2d,
0x92, 0x88, 0x33, 0x1f, 0xf7, 0x00, 0x49, 0xa2, 0x43, 0x92, 0x1e, 0x3c, 0x48, 0x57, 0xd0, 0x7c,
0xbd, 0x42, 0x58, 0x66, 0x7b, 0xc9, 0xd4, 0xf5, 0xd9, 0x3b, 0xdc, 0x05, 0xf6, 0x3c, 0xb8, 0xd2,
0xdc, 0x13, 0x5f, 0xb8, 0xe2, 0x9a, 0xfd, 0xad, 0x86, 0x3b, 0xb0, 0x99, 0xb3, 0x9f, 0x47, 0x41,
0x12, 0xb2, 0xbf, 0xd7, 0x70, 0x1f, 0x30, 0xe7, 0x9e, 0x47, 0x41, 0x18, 0xc4, 0xb6, 0xc7, 0xfe,
0x51, 0xc3, 0x3d, 0xd8, 0x7a, 0x1e, 0x5c, 0x65, 0x59, 0x50, 0x06, 0xff, 0x4c, 0x0d, 0x32, 0xfe,
0x0b, 0x3e, 0xbf, 0xe0, 0x11, 0xfb, 0x57, 0x0d, 0x6f, 0xc1, 0xce, 0xb2, 0x20, 0xf3, 0xf5, 0xef,
0x9a, 0xde, 0x51, 0x26, 0x7a, 0x1b, 0x08, 0xce, 0xfe, 0x93, 0xb2, 0x75, 0x1c, 0xb4, 0xa3, 0xff,
0xd6, 0x70, 0x1b, 0xfa, 0x39, 0x5b, 0xea, 0xfe, 0xaf, 0x86, 0x43, 0xd8, 0x2d, 0x30, 0x5d, 0x7f,
0x7a, 0x4e, 0x1d, 0xc7, 0xfe, 0x5f, 0x3b, 0xfa, 0xae, 0x09, 0x9b, 0x74, 0x51, 0x3c, 0x09, 0xd5,
0x02, 0x34, 0x2a, 0x3c, 0x50, 0x7d, 0x86, 0x15, 0x2f, 0xfb, 0x61, 0xd5, 0xac, 0x8e, 0x47, 0xba,
0x1d, 0xb1, 0xea, 0x81, 0x3f, 0xac, 0x1c, 0xd9, 0x69, 0x11, 0x35, 0x4e, 0xdd, 0x7c, 0xe7, 0x0f,
0xab, 0xe6, 0x76, 0xfc, 0xe5, 0x52, 0x7b, 0xe3, 0xaa, 0xd7, 0xfe, 0x70, 0xe5, 0x04, 0x8f, 0x5f,
0xe6, 0x00, 0x80, 0x2b, 0xde, 0xfc, 0xc3, 0x55, 0x53, 0x3c, 0x3e, 0xca, 0xf0, 0x02, 0xab, 0x5f,
0xfe, 0xc3, 0x15, 0x93, 0x3c, 0xc5, 0x46, 0x0d, 0x28, 0x55, 0x0f, 0xfa, 0x61, 0xe5, 0x70, 0x8e,
0x9f, 0xa7, 0x80, 0x84, 0x95, 0x7f, 0x1a, 0x0c, 0xab, 0x9f, 0x00, 0x14, 0xa1, 0xfc, 0x59, 0xb9,
0xea, 0xdf, 0x80, 0xe1, 0xca, 0xe1, 0x1e, 0x9f, 0x2c, 0x23, 0x1c, 0xae, 0xfc, 0x4f, 0x60, 0xb8,
0x7a, 0xc4, 0xa7, 0x20, 0xe7, 0x6f, 0xc8, 0xea, 0x7f, 0x06, 0x86, 0xab, 0xa6, 0xfc, 0x8b, 0x96,
0xfc, 0xc7, 0xe9, 0xe1, 0xf7, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa1, 0x0f, 0x72, 0x7a, 0x86, 0x12,
0x00, 0x00,
}

+ 47
- 3
types/types.proto View File

@ -124,7 +124,8 @@ message RequestInitChain{
}
message RequestBeginBlock{
uint64 height = 1;
bytes hash = 1;
Header header = 2;
}
message RequestEndBlock{
@ -164,7 +165,11 @@ message ResponseFlush{
}
message ResponseInfo {
string info = 1;
string info = 1; // backwards compatible
TMSPInfo tmsp_info = 2;
LastBlockInfo last_block = 3;
ConfigInfo config = 4;
}
message ResponseSetOption{
@ -207,7 +212,46 @@ message ResponseEndBlock{
}
//----------------------------------------
// Misc types
// Info types
message TMSPInfo {
string Version = 1;
}
message LastBlockInfo {
int32 block_height = 1;
bytes block_hash = 2;
bytes app_hash = 3;
}
message ConfigInfo {
uint64 max_block_size = 1;
}
//----------------------------------------
// Blockchain Types
message Header {
string chain_id = 1;
int32 height = 2;
uint64 time = 3;
uint64 num_txs = 4;
BlockID last_block_id = 5;
bytes last_commit_hash = 6;
bytes data_hash = 7;
bytes validators_hash = 8;
bytes app_hash = 9;
}
message BlockID {
bytes hash = 1;
PartSetHeader parts = 2;
}
message PartSetHeader {
uint64 total = 1;
bytes hash = 2;
}
message Validator {
bytes pubKey = 1;


Write Preview
Loading…
Cancel
Save