fluencelabs/tendermint
1
0
Fork 0
mirror of https://github.com/fluencelabs/tendermint synced 2025-06-16 14:41:21 +00:00
Code Issues Projects Releases Wiki Activity

ABCI message updates (code/log/info)

Browse Source 
* Add info to Response[CheckTx/DeliverTx/Query]
* Remove code and log from Response[SetOption/Commit]
This commit is contained in:
Jae Kwon
2017-12-26 15:46:06 -08:00
parent 66580408f8
commit 8f87efd7f8
14 changed files with 229 additions and 311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
cmd/abci-cli/abci-cli.go
View File

@ -92,6 +92,7 @@ type response struct {
// generic abci response // generic abci response
Data []byte Data []byte
Code uint32 Code uint32
Info string
Log string Log string
Query *queryResponse Query *queryResponse
@ -508,14 +509,11 @@ func cmdSetOption(cmd *cobra.Command, args []string) error {
} }
key, val := args[0], args[1] key, val := args[0], args[1]
res, err := client.SetOptionSync(types.RequestSetOption{key, val}) _, err := client.SetOptionSync(types.RequestSetOption{key, val})
if err != nil { if err != nil {
return err return err
} }
printResponse(cmd, args, response{ printResponse(cmd, args, response{Log: "OK (SetOption doesn't return anything.)"}) // NOTE: Nothing to show...
Code: res.Code,
Log: res.Log,
})
return nil return nil
} }
@ -539,6 +537,7 @@ func cmdDeliverTx(cmd *cobra.Command, args []string) error {
printResponse(cmd, args, response{ printResponse(cmd, args, response{
Code: res.Code, Code: res.Code,
Data: res.Data, Data: res.Data,
Info: res.Info,
Log: res.Log, Log: res.Log,
}) })
return nil return nil
@ -549,7 +548,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {
if len(args) == 0 { if len(args) == 0 {
printResponse(cmd, args, response{ printResponse(cmd, args, response{
Code: codeBad, Code: codeBad,
Log: "want the tx", Info: "want the tx",
}) })
return nil return nil
} }
@ -564,6 +563,7 @@ func cmdCheckTx(cmd *cobra.Command, args []string) error {
printResponse(cmd, args, response{ printResponse(cmd, args, response{
Code: res.Code, Code: res.Code,
Data: res.Data, Data: res.Data,
Info: res.Info,
Log: res.Log, Log: res.Log,
}) })
return nil return nil
@ -576,9 +576,7 @@ func cmdCommit(cmd *cobra.Command, args []string) error {
return err return err
} }
printResponse(cmd, args, response{ printResponse(cmd, args, response{
Code: res.Code,
Data: res.Data, Data: res.Data,
Log: res.Log,
}) })
return nil return nil
} }
@ -588,7 +586,8 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
if len(args) == 0 { if len(args) == 0 {
printResponse(cmd, args, response{ printResponse(cmd, args, response{
Code: codeBad, Code: codeBad,
Log: "want the query", Info: "want the query",
Log: "",
}) })
return nil return nil
} }
@ -608,6 +607,7 @@ func cmdQuery(cmd *cobra.Command, args []string) error {
} }
printResponse(cmd, args, response{ printResponse(cmd, args, response{
Code: resQuery.Code, Code: resQuery.Code,
Info: resQuery.Info,
Log: resQuery.Log, Log: resQuery.Log,
Query: &queryResponse{ Query: &queryResponse{
Key: resQuery.Key, Key: resQuery.Key,

2
example/code/code.go
View File

@ -6,6 +6,4 @@ const (
CodeTypeEncodingError uint32 = 1 CodeTypeEncodingError uint32 = 1
CodeTypeBadNonce uint32 = 2 CodeTypeBadNonce uint32 = 2
CodeTypeUnauthorized uint32 = 3 CodeTypeUnauthorized uint32 = 3
CodeTypeBadOption uint32 = 101
) )

16
example/counter/counter.go
View File

@ -30,15 +30,17 @@ func (app *CounterApplication) SetOption(req types.RequestSetOption) types.Respo
if key == "serial" && value == "on" { if key == "serial" && value == "on" {
app.serial = true app.serial = true
} else { } else {
/*
TODO Panic and have the ABCI server pass an exception.
The client can call SetOptionSync() and get an `error`.
return types.ResponseSetOption{ return types.ResponseSetOption{
Code: code.CodeTypeBadOption, Error: cmn.Fmt("Unknown key (%s) or value (%s)", key, value),
Log: cmn.Fmt("Unknown key (%s) or value (%s)", key, value),
} }
*/
return types.ResponseSetOption{}
} }
return types.ResponseSetOption{ return types.ResponseSetOption{}
Code: code.CodeTypeOK,
}
} }
func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx { func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
@ -83,11 +85,11 @@ func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx {
func (app *CounterApplication) Commit() (resp types.ResponseCommit) { func (app *CounterApplication) Commit() (resp types.ResponseCommit) {
app.hashCount++ app.hashCount++
if app.txCount == 0 { if app.txCount == 0 {
return types.ResponseCommit{Code: code.CodeTypeOK} return types.ResponseCommit{}
} }
hash := make([]byte, 8) hash := make([]byte, 8)
binary.BigEndian.PutUint64(hash, uint64(app.txCount)) binary.BigEndian.PutUint64(hash, uint64(app.txCount))
return types.ResponseCommit{Code: code.CodeTypeOK, Data: hash} return types.ResponseCommit{Data: hash}
} }
func (app *CounterApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery { func (app *CounterApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {

2
example/dummy/dummy.go
View File

@ -63,7 +63,7 @@ func (app *DummyApplication) Commit() types.ResponseCommit {
} }
} }
return types.ResponseCommit{Code: code.CodeTypeOK, Data: hash} return types.ResponseCommit{Data: hash}
} }
func (app *DummyApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) { func (app *DummyApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {

2
example/dummy/persistent_dummy.go
View File

@ -97,7 +97,7 @@ func (app *PersistentDummyApplication) Commit() types.ResponseCommit {
} }
app.logger.Info("Commit block", "height", height, "root", appHash) app.logger.Info("Commit block", "height", height, "root", appHash)
return types.ResponseCommit{Code: code.CodeTypeOK, Data: appHash} return types.ResponseCommit{Data: appHash}
} }
func (app *PersistentDummyApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery { func (app *PersistentDummyApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {

10
tests/server/client.go
View File

@ -29,12 +29,10 @@ func InitChain(client abcicli.Client) error {
} }
func SetOption(client abcicli.Client, key, value string) error { func SetOption(client abcicli.Client, key, value string) error {
res, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: value}) _, err := client.SetOptionSync(types.RequestSetOption{Key: key, Value: value})
log := res.GetLog()
if err != nil { if err != nil {
fmt.Println("Failed test: SetOption") fmt.Println("Failed test: SetOption")
fmt.Printf("setting %v=%v: \nlog: %v\n", key, value, log) fmt.Printf("error while setting %v=%v: \nerror: %v\n", key, value)
fmt.Println("Failed test: SetOption")
return err return err
} }
fmt.Println("Passed test: SetOption") fmt.Println("Passed test: SetOption")
@ -43,10 +41,10 @@ func SetOption(client abcicli.Client, key, value string) error {
func Commit(client abcicli.Client, hashExp []byte) error { func Commit(client abcicli.Client, hashExp []byte) error {
res, err := client.CommitSync() res, err := client.CommitSync()
_, data := res.Code, res.Data data := res.Data
if err != nil { if err != nil {
fmt.Println("Failed test: Commit") fmt.Println("Failed test: Commit")
fmt.Printf("committing %v\nlog: %v\n", res.GetLog(), err) fmt.Printf("error while committing: %v\n", err)
return err return err
} }
if !bytes.Equal(data, hashExp) { if !bytes.Equal(data, hashExp) {

3
tests/test_app/app.go
View File

@ -37,9 +37,6 @@ func commit(client abcicli.Client, hashExp []byte) {
if err != nil { if err != nil {
panicf("client error: %v", err) panicf("client error: %v", err)
} }
if res.IsErr() {
panicf("committing err %v\n", res)
}
if !bytes.Equal(res.Data, hashExp) { if !bytes.Equal(res.Data, hashExp) {
panicf("Commit hash was unexpected. Got %X expected %X", res.Data, hashExp) panicf("Commit hash was unexpected. Got %X expected %X", res.Data, hashExp)
} }

4
types/application.go
View File

@ -42,7 +42,7 @@ func (BaseApplication) Info(req RequestInfo) ResponseInfo {
} }
func (BaseApplication) SetOption(req RequestSetOption) ResponseSetOption { func (BaseApplication) SetOption(req RequestSetOption) ResponseSetOption {
return ResponseSetOption{Code: CodeTypeOK} return ResponseSetOption{}
} }
func (BaseApplication) DeliverTx(tx []byte) ResponseDeliverTx { func (BaseApplication) DeliverTx(tx []byte) ResponseDeliverTx {
@ -54,7 +54,7 @@ func (BaseApplication) CheckTx(tx []byte) ResponseCheckTx {
} }
func (BaseApplication) Commit() ResponseCommit { func (BaseApplication) Commit() ResponseCommit {
return ResponseCommit{Code: CodeTypeOK} return ResponseCommit{}
} }
func (BaseApplication) Query(req RequestQuery) ResponseQuery { func (BaseApplication) Query(req RequestQuery) ResponseQuery {

3
types/messages_test.go
View File

@ -14,7 +14,8 @@ import (
func TestMarshalJSON(t *testing.T) { func TestMarshalJSON(t *testing.T) {
b, err := json.Marshal(&ResponseDeliverTx{}) b, err := json.Marshal(&ResponseDeliverTx{})
assert.Nil(t, err) assert.Nil(t, err)
assert.True(t, strings.Contains(string(b), "code")) // Do not include empty fields.
assert.False(t, strings.Contains(string(b), "code"))
r1 := ResponseCheckTx{ r1 := ResponseCheckTx{
Code: 1, Code: 1,

37
types/result.go
View File

@ -3,7 +3,6 @@ package types
import ( import (
"bytes" "bytes"
"encoding/json" "encoding/json"
"fmt"
"github.com/gogo/protobuf/jsonpb" "github.com/gogo/protobuf/jsonpb"
) )
@ -22,11 +21,6 @@ func (r ResponseCheckTx) IsErr() bool {
return r.Code != CodeTypeOK return r.Code != CodeTypeOK
} }
// Error implements error interface by formatting response as string.
func (r ResponseCheckTx) Error() string {
return fmtError(r.Code, r.Log)
}
// IsOK returns true if Code is OK. // IsOK returns true if Code is OK.
func (r ResponseDeliverTx) IsOK() bool { func (r ResponseDeliverTx) IsOK() bool {
return r.Code == CodeTypeOK return r.Code == CodeTypeOK
@ -37,26 +31,6 @@ func (r ResponseDeliverTx) IsErr() bool {
return r.Code != CodeTypeOK return r.Code != CodeTypeOK
} }
// Error implements error interface by formatting response as string.
func (r ResponseDeliverTx) Error() string {
return fmtError(r.Code, r.Log)
}
// IsOK returns true if Code is OK.
func (r ResponseCommit) IsOK() bool {
return r.Code == CodeTypeOK
}
// IsErr returns true if Code is something other than OK.
func (r ResponseCommit) IsErr() bool {
return r.Code != CodeTypeOK
}
// Error implements error interface by formatting response as string.
func (r ResponseCommit) Error() string {
return fmtError(r.Code, r.Log)
}
// IsOK returns true if Code is OK. // IsOK returns true if Code is OK.
func (r ResponseQuery) IsOK() bool { func (r ResponseQuery) IsOK() bool {
return r.Code == CodeTypeOK return r.Code == CodeTypeOK
@ -67,15 +41,6 @@ func (r ResponseQuery) IsErr() bool {
return r.Code != CodeTypeOK return r.Code != CodeTypeOK
} }
// Error implements error interface by formatting response as string.
func (r ResponseQuery) Error() string {
return fmtError(r.Code, r.Log)
}
func fmtError(code uint32, log string) string {
return fmt.Sprintf("Error code (%d): %s", code, log)
}
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
// override JSON marshalling so we dont emit defaults (ie. disable omitempty) // override JSON marshalling so we dont emit defaults (ie. disable omitempty)
// note we need Unmarshal functions too because protobuf had the bright idea // note we need Unmarshal functions too because protobuf had the bright idea
@ -84,7 +49,7 @@ func fmtError(code uint32, log string) string {
var ( var (
jsonpbMarshaller = jsonpb.Marshaler{ jsonpbMarshaller = jsonpb.Marshaler{
EnumsAsInts: true, EnumsAsInts: true,
EmitDefaults: true, EmitDefaults: false,
} }
jsonpbUnmarshaller = jsonpb.Unmarshaler{} jsonpbUnmarshaller = jsonpb.Unmarshaler{}
) )

74
types/result_test.go
View File

@ -1,74 +0,0 @@
package types
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestResponseQuery(t *testing.T) {
res := ResponseQuery{
Code: CodeTypeOK,
Index: 0,
Key: []byte("hello"),
Value: []byte("world"),
Height: 1,
}
assert.False(t, res.IsErr())
res = ResponseQuery{
Code: 1,
Index: 0,
Key: []byte("hello"),
Value: []byte("world"),
Height: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Error code (1): bad", res.Error())
}
func TestResponseDeliverTx(t *testing.T) {
res := ResponseDeliverTx{
Code: CodeTypeOK,
Data: []byte("Victor Mancha"),
}
assert.False(t, res.IsErr())
res = ResponseDeliverTx{
Code: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Error code (1): bad", res.Error())
}
func TestResponseCheckTx(t *testing.T) {
res := ResponseCheckTx{
Code: CodeTypeOK,
Data: []byte("Talos"),
}
assert.False(t, res.IsErr())
res = ResponseCheckTx{
Code: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Error code (1): bad", res.Error())
}
func TestResponseCommit(t *testing.T) {
res := ResponseCommit{
Code: CodeTypeOK,
Data: []byte("Old Lace"),
}
assert.False(t, res.IsErr())
res = ResponseCommit{
Code: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Error code (1): bad", res.Error())
}

315
types/types.pb.go
View File

@ -506,6 +506,7 @@ func (m *RequestInfo) GetVersion() string {
return "" return ""
} }
// nondeterministic
type RequestSetOption struct { type RequestSetOption struct {
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
@ -1113,6 +1114,7 @@ func _Response_OneofSizer(msg proto.Message) (n int) {
return n return n
} }
// nondeterministic
type ResponseException struct { type ResponseException struct {
Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"` Error string `protobuf:"bytes,1,opt,name=error,proto3" json:"error,omitempty"`
} }
@ -1193,9 +1195,12 @@ func (m *ResponseInfo) GetLastBlockAppHash() []byte {
return nil return nil
} }
// nondeterministic
type ResponseSetOption struct { type ResponseSetOption struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Log string `protobuf:"bytes,2,opt,name=log,proto3" json:"log,omitempty"` // bytes data = 2;
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
} }
func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} } func (m *ResponseSetOption) Reset() { *m = ResponseSetOption{} }
@ -1217,6 +1222,13 @@ func (m *ResponseSetOption) GetLog() string {
return "" return ""
} }
func (m *ResponseSetOption) GetInfo() string {
if m != nil {
return m.Info
}
return ""
}
type ResponseInitChain struct { type ResponseInitChain struct {
} }
@ -1227,12 +1239,14 @@ func (*ResponseInitChain) Descriptor() ([]byte, []int) { return fileDescriptorTy
type ResponseQuery struct { type ResponseQuery struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Index int64 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` // bytes data = 2; // use "value" instead.
Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"` Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"` Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
Proof []byte `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof,omitempty"` Index int64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"`
Height int64 `protobuf:"varint,6,opt,name=height,proto3" json:"height,omitempty"` Key []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
Log string `protobuf:"bytes,7,opt,name=log,proto3" json:"log,omitempty"` Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
Proof []byte `protobuf:"bytes,8,opt,name=proof,proto3" json:"proof,omitempty"`
Height int64 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"`
} }
func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } func (m *ResponseQuery) Reset() { *m = ResponseQuery{} }
@ -1247,6 +1261,20 @@ func (m *ResponseQuery) GetCode() uint32 {
return 0 return 0
} }
func (m *ResponseQuery) GetLog() string {
if m != nil {
return m.Log
}
return ""
}
func (m *ResponseQuery) GetInfo() string {
if m != nil {
return m.Info
}
return ""
}
func (m *ResponseQuery) GetIndex() int64 { func (m *ResponseQuery) GetIndex() int64 {
if m != nil { if m != nil {
return m.Index return m.Index
@ -1282,13 +1310,6 @@ func (m *ResponseQuery) GetHeight() int64 {
return 0 return 0
} }
func (m *ResponseQuery) GetLog() string {
if m != nil {
return m.Log
}
return ""
}
type ResponseBeginBlock struct { type ResponseBeginBlock struct {
} }
@ -1301,10 +1322,11 @@ type ResponseCheckTx struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
GasWanted int64 `protobuf:"varint,4,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"` Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
// int64 gas_used = 5; GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"`
Tags []common.KVPair `protobuf:"bytes,6,rep,name=tags" json:"tags,omitempty"` // int64 gas_used = 6;
Fee common.KI64Pair `protobuf:"bytes,7,opt,name=fee" json:"fee"` Tags []common.KVPair `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
Fee common.KI64Pair `protobuf:"bytes,8,opt,name=fee" json:"fee"`
} }
func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} } func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} }
@ -1333,6 +1355,13 @@ func (m *ResponseCheckTx) GetLog() string {
return "" return ""
} }
func (m *ResponseCheckTx) GetInfo() string {
if m != nil {
return m.Info
}
return ""
}
func (m *ResponseCheckTx) GetGasWanted() int64 { func (m *ResponseCheckTx) GetGasWanted() int64 {
if m != nil { if m != nil {
return m.GasWanted return m.GasWanted
@ -1358,9 +1387,10 @@ type ResponseDeliverTx struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"` Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
GasWanted int64 `protobuf:"varint,4,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"` Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
GasUsed int64 `protobuf:"varint,5,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"` GasWanted int64 `protobuf:"varint,5,opt,name=gas_wanted,json=gasWanted,proto3" json:"gas_wanted,omitempty"`
Tags []common.KVPair `protobuf:"bytes,6,rep,name=tags" json:"tags,omitempty"` GasUsed int64 `protobuf:"varint,6,opt,name=gas_used,json=gasUsed,proto3" json:"gas_used,omitempty"`
Tags []common.KVPair `protobuf:"bytes,7,rep,name=tags" json:"tags,omitempty"`
} }
func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} } func (m *ResponseDeliverTx) Reset() { *m = ResponseDeliverTx{} }
@ -1389,6 +1419,13 @@ func (m *ResponseDeliverTx) GetLog() string {
return "" return ""
} }
func (m *ResponseDeliverTx) GetInfo() string {
if m != nil {
return m.Info
}
return ""
}
func (m *ResponseDeliverTx) GetGasWanted() int64 { func (m *ResponseDeliverTx) GetGasWanted() int64 {
if m != nil { if m != nil {
return m.GasWanted return m.GasWanted
@ -1435,9 +1472,8 @@ func (m *ResponseEndBlock) GetConsensusParamUpdates() *ConsensusParams {
} }
type ResponseCommit struct { type ResponseCommit struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"` // reserve 1
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
} }
func (m *ResponseCommit) Reset() { *m = ResponseCommit{} } func (m *ResponseCommit) Reset() { *m = ResponseCommit{} }
@ -1445,13 +1481,6 @@ func (m *ResponseCommit) String() string { return proto.CompactTextSt
func (*ResponseCommit) ProtoMessage() {} func (*ResponseCommit) ProtoMessage() {}
func (*ResponseCommit) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{24} } func (*ResponseCommit) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{24} }
func (m *ResponseCommit) GetCode() uint32 {
if m != nil {
return m.Code
}
return 0
}
func (m *ResponseCommit) GetData() []byte { func (m *ResponseCommit) GetData() []byte {
if m != nil { if m != nil {
return m.Data return m.Data
@ -1459,13 +1488,6 @@ func (m *ResponseCommit) GetData() []byte {
return nil return nil
} }
func (m *ResponseCommit) GetLog() string {
if m != nil {
return m.Log
}
return ""
}
// ConsensusParams contains all consensus-relevant parameters // ConsensusParams contains all consensus-relevant parameters
// that can be adjusted by the abci app // that can be adjusted by the abci app
type ConsensusParams struct { type ConsensusParams struct {
@ -2195,113 +2217,114 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptorTypes) } func init() { proto.RegisterFile("types/types.proto", fileDescriptorTypes) }
var fileDescriptorTypes = []byte{ var fileDescriptorTypes = []byte{
// 1726 bytes of a gzipped FileDescriptorProto // 1732 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x58, 0x4b, 0x6f, 0x1b, 0xbf, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0xdb, 0x6e, 0x1b, 0xbd,
0x11, 0xb7, 0xde, 0xda, 0x91, 0x9f, 0xf4, 0x4b, 0x51, 0x50, 0xd8, 0xd8, 0x43, 0x22, 0x37, 0x89, 0x11, 0xb6, 0xce, 0xda, 0x91, 0x2d, 0xdb, 0xf4, 0x49, 0xd1, 0x8f, 0xc2, 0xc6, 0xa2, 0x48, 0xe4,
0xd5, 0x3a, 0x4d, 0x10, 0x27, 0x45, 0x50, 0xcb, 0x4e, 0x23, 0x25, 0x45, 0x93, 0x6e, 0x1e, 0x05, 0x26, 0xb1, 0x5a, 0xa7, 0x09, 0xe2, 0xa4, 0x08, 0x6a, 0xd9, 0x69, 0xa4, 0xa6, 0x6d, 0xd2, 0xcd,
0x7a, 0x11, 0x28, 0x2d, 0x2d, 0x2d, 0xa2, 0x7d, 0x44, 0x4b, 0x39, 0x72, 0x3e, 0x43, 0xee, 0x3d, 0xa1, 0x40, 0x6f, 0x04, 0x4a, 0x4b, 0x4b, 0x8b, 0x68, 0x0f, 0xd1, 0x52, 0x8e, 0x9c, 0x67, 0xc8,
0xf7, 0xd4, 0x0f, 0x52, 0xa0, 0x68, 0xd1, 0x4b, 0x3f, 0x81, 0x0f, 0x39, 0xf6, 0x53, 0x14, 0x43, 0x7d, 0xaf, 0x7b, 0xd5, 0x27, 0xe8, 0x2b, 0x14, 0x2d, 0xfa, 0x00, 0xbd, 0xf3, 0x45, 0xd0, 0xab,
0x72, 0x9f, 0xda, 0x6d, 0x8b, 0xfe, 0xf1, 0xbf, 0xd8, 0x9c, 0x9d, 0xdf, 0x90, 0x33, 0xe4, 0xf0, 0x3e, 0x45, 0x31, 0x24, 0xf7, 0xe8, 0xdd, 0x36, 0x68, 0x81, 0xff, 0xc6, 0xe6, 0xec, 0x7c, 0x33,
0x37, 0x43, 0xc1, 0x16, 0xbf, 0xf6, 0x98, 0xdf, 0x11, 0x7f, 0x8f, 0xbd, 0x99, 0xcb, 0x5d, 0x52, 0xe4, 0x90, 0xc3, 0x6f, 0x46, 0x84, 0x4d, 0x7e, 0xe5, 0x31, 0xbf, 0x2b, 0xfe, 0x1e, 0x79, 0x73,
0x11, 0x42, 0xeb, 0xc1, 0xd8, 0xe2, 0x93, 0xf9, 0xf0, 0x78, 0xe4, 0xda, 0x9d, 0xb1, 0x3b, 0x76, 0x97, 0xbb, 0xa4, 0x22, 0x84, 0xf6, 0xfd, 0x89, 0xc5, 0xa7, 0x8b, 0xd1, 0xd1, 0xd8, 0xb5, 0xbb,
0x3b, 0x42, 0x3b, 0x9c, 0x5f, 0x0a, 0x49, 0x08, 0x62, 0x24, 0xad, 0x5a, 0x9d, 0x18, 0x9c, 0x33, 0x13, 0x77, 0xe2, 0x76, 0x85, 0x76, 0xb4, 0xb8, 0x10, 0x92, 0x10, 0xc4, 0x48, 0x5a, 0xb5, 0xbb,
0xc7, 0x64, 0x33, 0xdb, 0x72, 0x78, 0x87, 0xdb, 0x53, 0x6b, 0xe8, 0x77, 0x46, 0xae, 0x6d, 0xbb, 0x31, 0x38, 0x67, 0x8e, 0xc9, 0xe6, 0xb6, 0xe5, 0xf0, 0x2e, 0xb7, 0x67, 0xd6, 0xc8, 0xef, 0x8e,
0x4e, 0x7c, 0x19, 0xfd, 0xaf, 0x65, 0xa8, 0x19, 0xec, 0xf3, 0x9c, 0xf9, 0x9c, 0xb4, 0xa1, 0xcc, 0x5d, 0xdb, 0x76, 0x9d, 0xf8, 0x34, 0xfa, 0x5f, 0xca, 0x50, 0x33, 0xd8, 0xc7, 0x05, 0xf3, 0x39,
0x46, 0x13, 0xb7, 0x59, 0x3c, 0x2c, 0xb4, 0x1b, 0x27, 0xe4, 0x58, 0xe2, 0x94, 0xf6, 0xc5, 0x68, 0xe9, 0x40, 0x99, 0x8d, 0xa7, 0x6e, 0xab, 0x78, 0x50, 0xe8, 0x34, 0x8e, 0xc9, 0x91, 0xc4, 0x29,
0xe2, 0xf6, 0x56, 0x0c, 0x81, 0x20, 0xf7, 0xa0, 0x72, 0x39, 0x9d, 0xfb, 0x93, 0x66, 0x49, 0x40, 0xed, 0xf3, 0xf1, 0xd4, 0xed, 0xaf, 0x18, 0x02, 0x41, 0xee, 0x42, 0xe5, 0x62, 0xb6, 0xf0, 0xa7,
0xb7, 0x93, 0xd0, 0x5f, 0xa3, 0xaa, 0xb7, 0x62, 0x48, 0x0c, 0x4e, 0x6b, 0x39, 0x97, 0x6e, 0xb3, 0xad, 0x92, 0x80, 0x6e, 0x25, 0xa1, 0xbf, 0x40, 0x55, 0x7f, 0xc5, 0x90, 0x18, 0x74, 0x6b, 0x39,
0x9c, 0x35, 0x6d, 0xdf, 0xb9, 0x14, 0xd3, 0x22, 0x82, 0x3c, 0x01, 0xf0, 0x19, 0x1f, 0xb8, 0x1e, 0x17, 0x6e, 0xab, 0x9c, 0xe5, 0x76, 0xe0, 0x5c, 0x08, 0xb7, 0x88, 0x20, 0x8f, 0x01, 0x7c, 0xc6,
0xb7, 0x5c, 0xa7, 0x59, 0x11, 0xf8, 0xfd, 0x24, 0xfe, 0x1d, 0xe3, 0x6f, 0x84, 0xba, 0xb7, 0x62, 0x87, 0xae, 0xc7, 0x2d, 0xd7, 0x69, 0x55, 0x04, 0x7e, 0x2f, 0x89, 0x7f, 0xc3, 0xf8, 0x2b, 0xa1,
0x68, 0x7e, 0x20, 0xa0, 0xa5, 0xe5, 0x58, 0x7c, 0x30, 0x9a, 0x50, 0xcb, 0x69, 0x56, 0xb3, 0x2c, 0xee, 0xaf, 0x18, 0x9a, 0x1f, 0x08, 0x68, 0x69, 0x39, 0x16, 0x1f, 0x8e, 0xa7, 0xd4, 0x72, 0x5a,
0xfb, 0x8e, 0xc5, 0xcf, 0x51, 0x8d, 0x96, 0x56, 0x20, 0x60, 0x28, 0x9f, 0xe7, 0x6c, 0x76, 0xdd, 0xd5, 0x2c, 0xcb, 0x81, 0x63, 0xf1, 0x33, 0x54, 0xa3, 0xa5, 0x15, 0x08, 0x18, 0xca, 0xc7, 0x05,
0xac, 0x65, 0x85, 0xf2, 0x3b, 0x54, 0x61, 0x28, 0x02, 0x43, 0x9e, 0x41, 0x63, 0xc8, 0xc6, 0x96, 0x9b, 0x5f, 0xb5, 0x6a, 0x59, 0xa1, 0xfc, 0x16, 0x55, 0x18, 0x8a, 0xc0, 0x90, 0xa7, 0xd0, 0x18,
0x33, 0x18, 0x4e, 0xdd, 0xd1, 0xa7, 0x66, 0x5d, 0x98, 0x34, 0x93, 0x26, 0x5d, 0x04, 0x74, 0x51, 0xb1, 0x89, 0xe5, 0x0c, 0x47, 0x33, 0x77, 0xfc, 0xa1, 0x55, 0x17, 0x26, 0xad, 0xa4, 0x49, 0x0f,
0xdf, 0x5b, 0x31, 0x60, 0x18, 0x4a, 0xe4, 0x04, 0xea, 0xa3, 0x09, 0x1b, 0x7d, 0x1a, 0xf0, 0x45, 0x01, 0x3d, 0xd4, 0xf7, 0x57, 0x0c, 0x18, 0x85, 0x12, 0x39, 0x86, 0xfa, 0x78, 0xca, 0xc6, 0x1f,
0x53, 0x13, 0x96, 0xbb, 0x49, 0xcb, 0x73, 0xd4, 0xbe, 0x5f, 0xf4, 0x56, 0x8c, 0xda, 0x48, 0x0e, 0x86, 0x7c, 0xd9, 0xd2, 0x84, 0xe5, 0x4e, 0xd2, 0xf2, 0x0c, 0xb5, 0x6f, 0x97, 0xfd, 0x15, 0xa3,
0x31, 0x2e, 0x93, 0x4d, 0xad, 0x2b, 0x36, 0x43, 0xab, 0xed, 0xac, 0xb8, 0x2e, 0xa4, 0x5e, 0xd8, 0x36, 0x96, 0x43, 0x8c, 0xcb, 0x64, 0x33, 0xeb, 0x92, 0xcd, 0xd1, 0x6a, 0x2b, 0x2b, 0xae, 0x73,
0x69, 0x66, 0x20, 0x90, 0x47, 0xa0, 0x31, 0xc7, 0x54, 0x8e, 0x36, 0x84, 0xe1, 0x5e, 0xea, 0x44, 0xa9, 0x17, 0x76, 0x9a, 0x19, 0x08, 0xe4, 0x21, 0x68, 0xcc, 0x31, 0xd5, 0x42, 0x1b, 0xc2, 0x70,
0x1d, 0x33, 0x70, 0xb3, 0xce, 0xd4, 0x98, 0x1c, 0x43, 0x15, 0xb3, 0xc4, 0xe2, 0xcd, 0x55, 0x61, 0x37, 0x75, 0xa2, 0x8e, 0x19, 0x2c, 0xb3, 0xce, 0xd4, 0x98, 0x1c, 0x41, 0x15, 0xb3, 0xc4, 0xe2,
0xb3, 0x93, 0x72, 0x51, 0xe8, 0x7a, 0x2b, 0x86, 0x42, 0x75, 0x6b, 0x50, 0xb9, 0xa2, 0xd3, 0x39, 0xad, 0x55, 0x61, 0xb3, 0x9d, 0x5a, 0xa2, 0xd0, 0xf5, 0x57, 0x0c, 0x85, 0xea, 0xd5, 0xa0, 0x72,
0xd3, 0xef, 0x42, 0x23, 0x96, 0x29, 0xa4, 0x09, 0x35, 0x9b, 0xf9, 0x3e, 0x1d, 0xb3, 0x66, 0xe1, 0x49, 0x67, 0x0b, 0xa6, 0xdf, 0x81, 0x46, 0x2c, 0x53, 0x48, 0x0b, 0x6a, 0x36, 0xf3, 0x7d, 0x3a,
0xb0, 0xd0, 0xd6, 0x8c, 0x40, 0xd4, 0xd7, 0x61, 0x35, 0x9e, 0x27, 0x31, 0x43, 0xcc, 0x05, 0x34, 0x61, 0xad, 0xc2, 0x41, 0xa1, 0xa3, 0x19, 0x81, 0xa8, 0x37, 0x61, 0x35, 0x9e, 0x27, 0x31, 0x43,
0xbc, 0x62, 0x33, 0x1f, 0x13, 0x40, 0x19, 0x2a, 0x51, 0x7f, 0x0a, 0x9b, 0xe9, 0x24, 0x20, 0x9b, 0xcc, 0x05, 0x34, 0xbc, 0x64, 0x73, 0x1f, 0x13, 0x40, 0x19, 0x2a, 0x51, 0x7f, 0x02, 0x1b, 0xe9,
0x50, 0xfa, 0xc4, 0xae, 0x15, 0x12, 0x87, 0x64, 0x47, 0x39, 0x24, 0xb2, 0x58, 0x33, 0x94, 0x77, 0x24, 0x20, 0x1b, 0x50, 0xfa, 0xc0, 0xae, 0x14, 0x12, 0x87, 0x64, 0x5b, 0x2d, 0x48, 0x64, 0xb1,
0xaf, 0x42, 0xdb, 0x30, 0x0d, 0xc8, 0x63, 0x80, 0x2b, 0x3a, 0xb5, 0x4c, 0xca, 0xdd, 0x99, 0xdf, 0x66, 0xa8, 0xd5, 0xfd, 0x32, 0xb4, 0x0d, 0xd3, 0x80, 0x3c, 0x02, 0xb8, 0xa4, 0x33, 0xcb, 0xa4,
0x2c, 0x1c, 0x96, 0xda, 0x8d, 0x93, 0x4d, 0x15, 0xee, 0xc7, 0x40, 0xd1, 0x2d, 0xff, 0xed, 0xe6, 0xdc, 0x9d, 0xfb, 0xad, 0xc2, 0x41, 0xa9, 0xd3, 0x38, 0xde, 0x50, 0xe1, 0xbe, 0x0f, 0x14, 0xbd,
0x60, 0xc5, 0x88, 0x21, 0x75, 0x33, 0x0c, 0x40, 0x64, 0x07, 0x21, 0x50, 0x36, 0x29, 0xa7, 0xc2, 0xf2, 0x5f, 0xaf, 0xf7, 0x57, 0x8c, 0x18, 0x52, 0x37, 0xc3, 0x00, 0x44, 0x76, 0x10, 0x02, 0x65,
0x89, 0x55, 0x43, 0x8c, 0xf1, 0x9b, 0x47, 0xf9, 0x44, 0x39, 0x21, 0xc6, 0x64, 0x0f, 0xaa, 0x13, 0x93, 0x72, 0x2a, 0x16, 0xb1, 0x6a, 0x88, 0x31, 0x7e, 0xf3, 0x28, 0x9f, 0xaa, 0x45, 0x88, 0x31,
0x66, 0x8d, 0x27, 0x5c, 0xdc, 0x9a, 0x92, 0xa1, 0x24, 0xf4, 0xd8, 0x9b, 0xb9, 0x57, 0x4c, 0x5c, 0xd9, 0x85, 0xea, 0x94, 0x59, 0x93, 0x29, 0x17, 0xb7, 0xa6, 0x64, 0x28, 0x09, 0x57, 0xec, 0xcd,
0x90, 0xba, 0x21, 0x05, 0xfd, 0x1f, 0x05, 0xd8, 0x5a, 0xca, 0x28, 0x9c, 0x77, 0x42, 0xfd, 0x49, 0xdd, 0x4b, 0x26, 0x2e, 0x48, 0xdd, 0x90, 0x82, 0xfe, 0xf7, 0x02, 0x6c, 0xde, 0xc8, 0x28, 0xf4,
0xb0, 0x16, 0x8e, 0xc9, 0x3d, 0x9c, 0x97, 0x9a, 0x6c, 0xa6, 0x2e, 0xee, 0x9a, 0x8a, 0xa1, 0x27, 0x3b, 0xa5, 0xfe, 0x34, 0x98, 0x0b, 0xc7, 0xe4, 0x2e, 0xfa, 0xa5, 0x26, 0x9b, 0xab, 0x8b, 0xbb,
0x3e, 0xaa, 0x00, 0x14, 0x84, 0xdc, 0x83, 0x2d, 0x3a, 0xf4, 0x99, 0xc3, 0x07, 0xb1, 0xd8, 0x4b, 0xa6, 0x62, 0xe8, 0x8b, 0x8f, 0x2a, 0x00, 0x05, 0x21, 0x77, 0x61, 0x93, 0x8e, 0x7c, 0xe6, 0xf0,
0x87, 0xa5, 0x76, 0xc5, 0xd8, 0x94, 0x8a, 0x30, 0x74, 0x9f, 0xf4, 0x60, 0x67, 0x78, 0xfd, 0x95, 0x61, 0x2c, 0xf6, 0xd2, 0x41, 0xa9, 0x53, 0x31, 0x36, 0xa4, 0x22, 0x0c, 0xdd, 0x27, 0x7d, 0xd8,
0x3a, 0xdc, 0x72, 0x58, 0x1c, 0x5f, 0x16, 0x7b, 0xb5, 0xa1, 0xd6, 0x79, 0x71, 0x65, 0x99, 0xcc, 0x1e, 0x5d, 0x7d, 0xa6, 0x0e, 0xb7, 0x1c, 0x16, 0xc7, 0x97, 0xc5, 0x5e, 0xad, 0xab, 0x79, 0x9e,
0x19, 0x31, 0xb5, 0xd2, 0x76, 0x68, 0x12, 0xcd, 0xa4, 0x1f, 0xc2, 0x7a, 0x32, 0xc9, 0xc9, 0x3a, 0x5f, 0x5a, 0x26, 0x73, 0xc6, 0x4c, 0xcd, 0xb4, 0x15, 0x9a, 0x44, 0x9e, 0xf4, 0x03, 0x68, 0x26,
0x14, 0xf9, 0x42, 0xc5, 0x51, 0xe4, 0x0b, 0x5d, 0x0f, 0x4f, 0x28, 0x4c, 0xe8, 0x25, 0xcc, 0x11, 0x93, 0x9c, 0x34, 0xa1, 0xc8, 0x97, 0x2a, 0x8e, 0x22, 0x5f, 0xea, 0x7a, 0x78, 0x42, 0x61, 0x42,
0x6c, 0xa4, 0x72, 0x37, 0xb6, 0xa9, 0x85, 0xf8, 0xa6, 0xea, 0x1b, 0xb0, 0x96, 0x48, 0x59, 0xfd, 0xdf, 0xc0, 0x1c, 0xc2, 0x7a, 0x2a, 0x77, 0x63, 0x9b, 0x5a, 0x88, 0x6f, 0xaa, 0xbe, 0x0e, 0x6b,
0x5b, 0x05, 0xea, 0x06, 0xf3, 0x3d, 0xd7, 0xf1, 0x19, 0x79, 0x02, 0x1a, 0x5b, 0x8c, 0x98, 0xe4, 0x89, 0x94, 0xd5, 0xbf, 0x54, 0xa0, 0x6e, 0x30, 0xdf, 0x73, 0x1d, 0x9f, 0x91, 0xc7, 0xa0, 0xb1,
0x99, 0x42, 0xea, 0x16, 0x4b, 0xcc, 0x8b, 0x40, 0x8f, 0xd7, 0x2a, 0x04, 0x93, 0xa3, 0x04, 0x47, 0xe5, 0x98, 0x49, 0x9e, 0x29, 0xa4, 0x6e, 0xb1, 0xc4, 0x3c, 0x0f, 0xf4, 0x78, 0xad, 0x42, 0x30,
0x6e, 0xa7, 0x8d, 0xe2, 0x24, 0x79, 0x3f, 0x49, 0x92, 0x3b, 0x29, 0x6c, 0x8a, 0x25, 0x8f, 0x12, 0x39, 0x4c, 0x70, 0xe4, 0x56, 0xda, 0x28, 0x4e, 0x92, 0xf7, 0x92, 0x24, 0xb9, 0x9d, 0xc2, 0xa6,
0x2c, 0x99, 0x9e, 0x38, 0x41, 0x93, 0xa7, 0x19, 0x34, 0x99, 0x76, 0x3f, 0x87, 0x27, 0x4f, 0x33, 0x58, 0xf2, 0x30, 0xc1, 0x92, 0x69, 0xc7, 0x09, 0x9a, 0x3c, 0xc9, 0xa0, 0xc9, 0xf4, 0xf2, 0x73,
0x78, 0xb2, 0xb9, 0xb4, 0x56, 0x26, 0x51, 0xde, 0x4f, 0x12, 0x65, 0x3a, 0x9c, 0x14, 0x53, 0xfe, 0x78, 0xf2, 0x24, 0x83, 0x27, 0x5b, 0x37, 0xe6, 0xca, 0x24, 0xca, 0x7b, 0x49, 0xa2, 0x4c, 0x87,
0x32, 0x8b, 0x29, 0x6f, 0xa5, 0x6c, 0x72, 0xa9, 0xf2, 0xe1, 0x12, 0x55, 0xee, 0xa5, 0x4c, 0x33, 0x93, 0x62, 0xca, 0x9f, 0x65, 0x31, 0xe5, 0xad, 0x94, 0x4d, 0x2e, 0x55, 0x3e, 0xb8, 0x41, 0x95,
0xb8, 0xf2, 0x34, 0xc1, 0x95, 0x90, 0x19, 0x5b, 0x0e, 0x59, 0x3e, 0x5e, 0x26, 0xcb, 0xfd, 0xf4, 0xbb, 0x29, 0xd3, 0x0c, 0xae, 0x3c, 0x49, 0x70, 0x25, 0x64, 0xc6, 0x96, 0x43, 0x96, 0x8f, 0x6e,
0xd1, 0x66, 0xb1, 0x65, 0x27, 0xc5, 0x96, 0xbb, 0x69, 0x2f, 0x73, 0xe9, 0xf2, 0x08, 0x6f, 0x77, 0x92, 0xe5, 0x5e, 0xfa, 0x68, 0xb3, 0xd8, 0xb2, 0x9b, 0x62, 0xcb, 0x9d, 0xf4, 0x2a, 0x73, 0xe9,
0x2a, 0xd3, 0x90, 0x09, 0xd8, 0x6c, 0xe6, 0xce, 0x14, 0x9f, 0x49, 0x41, 0x6f, 0x23, 0xdf, 0x44, 0xf2, 0x10, 0x6f, 0x77, 0x2a, 0xd3, 0x90, 0x09, 0xd8, 0x7c, 0xee, 0xce, 0x15, 0x9f, 0x49, 0x41,
0xf9, 0xf5, 0x1f, 0xa8, 0x55, 0x24, 0x7d, 0x2c, 0xbb, 0xf4, 0x3f, 0x16, 0x22, 0x5b, 0xc1, 0xae, 0xef, 0x20, 0xdf, 0x44, 0xf9, 0xf5, 0x1f, 0xa8, 0x55, 0x24, 0x7d, 0x2c, 0xbb, 0xf4, 0x3f, 0x14,
0x71, 0xae, 0xd2, 0x14, 0x57, 0xc5, 0x18, 0xb7, 0x98, 0x60, 0x5c, 0xf2, 0x53, 0xd8, 0x9a, 0x52, 0x22, 0x5b, 0xc1, 0xae, 0x71, 0xae, 0xd2, 0x14, 0x57, 0xc5, 0x18, 0xb7, 0x98, 0x60, 0x5c, 0xf2,
0x9f, 0xcb, 0x7d, 0x19, 0x24, 0xc8, 0x6b, 0x03, 0x15, 0x72, 0x43, 0x24, 0x8b, 0x3d, 0x80, 0xed, 0x23, 0xd8, 0x9c, 0x51, 0x9f, 0xcb, 0x7d, 0x19, 0x26, 0xc8, 0x6b, 0x1d, 0x15, 0x72, 0x43, 0x24,
0x18, 0x96, 0x7a, 0xde, 0x40, 0x10, 0x55, 0x59, 0x5c, 0xde, 0xcd, 0x10, 0x7d, 0xe6, 0x79, 0x3d, 0x8b, 0xdd, 0x87, 0xad, 0x18, 0x96, 0x7a, 0xde, 0x50, 0x10, 0x55, 0x59, 0x5c, 0xde, 0x8d, 0x10,
0xea, 0x4f, 0xf4, 0xd3, 0x28, 0xfe, 0x88, 0xcd, 0x09, 0x94, 0x47, 0xae, 0x29, 0xc3, 0x5a, 0x33, 0x7d, 0xea, 0x79, 0x7d, 0xea, 0x4f, 0xf5, 0x5f, 0x47, 0xf1, 0x47, 0x6c, 0x4e, 0xa0, 0x3c, 0x76,
0xc4, 0x18, 0x19, 0x7e, 0xea, 0x8e, 0x95, 0x67, 0x38, 0xd4, 0xb7, 0x23, 0xd3, 0x30, 0x55, 0xf5, 0x4d, 0x19, 0xd6, 0x9a, 0x21, 0xc6, 0xc8, 0xf0, 0x33, 0x77, 0x22, 0x66, 0xd5, 0x0c, 0x1c, 0x22,
0x3f, 0x15, 0xa2, 0xd8, 0x43, 0x5a, 0x5e, 0x9a, 0x6c, 0x07, 0x2a, 0x96, 0x63, 0xb2, 0x85, 0x98, 0x2a, 0xbc, 0x29, 0x9a, 0xbc, 0x12, 0xfa, 0x56, 0xe4, 0x2e, 0x4c, 0x5f, 0xfd, 0xcf, 0x85, 0x68,
0xae, 0x64, 0x48, 0x21, 0x28, 0x22, 0x25, 0xe1, 0x6a, 0xb2, 0x88, 0x48, 0xf7, 0xa5, 0xa0, 0x88, 0x3f, 0x42, 0xaa, 0xfe, 0xdf, 0x26, 0xc0, 0xa3, 0xb1, 0x1c, 0x93, 0x2d, 0xc5, 0x75, 0x2b, 0x19,
0xda, 0xbd, 0x14, 0x57, 0x6e, 0xd5, 0x90, 0x42, 0x8c, 0x81, 0xaa, 0x09, 0x5a, 0x57, 0x8e, 0xd7, 0x52, 0x08, 0xca, 0x4f, 0x55, 0x04, 0x99, 0x2c, 0x3f, 0x35, 0xf1, 0x4d, 0x0a, 0x8a, 0xe2, 0xdd,
0x22, 0xc7, 0x77, 0x80, 0x2c, 0x67, 0xbe, 0xfe, 0xcf, 0x02, 0xb2, 0x5a, 0x22, 0xab, 0x33, 0x7d, 0x0b, 0x71, 0x0f, 0x56, 0x0d, 0x29, 0xc4, 0xb8, 0x4b, 0x4b, 0x70, 0xd7, 0x36, 0x90, 0x9b, 0x37,
0x0f, 0x8e, 0xae, 0x18, 0x2b, 0x33, 0x6a, 0x8d, 0x52, 0xb8, 0x06, 0xf9, 0x09, 0xc0, 0x98, 0xfa, 0x44, 0xff, 0x67, 0x01, 0xd9, 0x2f, 0x91, 0xfd, 0x99, 0xf1, 0x04, 0x47, 0x5c, 0x8c, 0x95, 0xa3,
0x83, 0x2f, 0xd4, 0xe1, 0xcc, 0x14, 0xee, 0x97, 0x0c, 0x6d, 0x4c, 0xfd, 0xdf, 0x8b, 0x0f, 0xe4, 0x6f, 0x8b, 0xf1, 0x07, 0x00, 0x13, 0xea, 0x0f, 0x3f, 0x51, 0x87, 0x33, 0x53, 0x05, 0xaa, 0x4d,
0x29, 0x94, 0x39, 0x1d, 0xfb, 0xcd, 0xaa, 0x60, 0xf0, 0xf5, 0x63, 0xd9, 0x11, 0x1e, 0xbf, 0xfe, 0xa8, 0xff, 0x3b, 0xf1, 0x81, 0x3c, 0x81, 0x32, 0xa7, 0x13, 0xbf, 0x55, 0x13, 0xec, 0xdf, 0x3c,
0xf8, 0x96, 0x5a, 0xb3, 0xee, 0x1e, 0x12, 0xf8, 0xbf, 0x6e, 0x0e, 0xd6, 0x11, 0x73, 0xdf, 0xb5, 0x92, 0xdd, 0xe4, 0xd1, 0xcb, 0xf7, 0xaf, 0xa9, 0x35, 0xef, 0xed, 0x22, 0xf9, 0xff, 0xeb, 0x7a,
0x2d, 0xce, 0x6c, 0x8f, 0x5f, 0x1b, 0xc2, 0x86, 0xb4, 0xa1, 0x74, 0xc9, 0x98, 0xba, 0xfe, 0x9b, 0xbf, 0x89, 0x98, 0x7b, 0xae, 0x6d, 0x71, 0x66, 0x7b, 0xfc, 0xca, 0x10, 0x36, 0xa4, 0x03, 0xa5,
0xa1, 0x69, 0xff, 0xf1, 0x2f, 0x84, 0xb1, 0x64, 0x7f, 0x84, 0xe8, 0x7f, 0x29, 0x44, 0x47, 0x14, 0x0b, 0xc6, 0x14, 0x0d, 0x6c, 0x84, 0xa6, 0x83, 0x47, 0x3f, 0x15, 0xc6, 0xb2, 0x72, 0x20, 0x44,
0xb1, 0xf9, 0x8f, 0x16, 0xd4, 0x2d, 0xa8, 0xa3, 0x7a, 0xee, 0x33, 0x53, 0x1c, 0x4d, 0xc9, 0xa8, 0xff, 0x47, 0x21, 0x3a, 0xca, 0xa8, 0x12, 0x7c, 0xaf, 0x81, 0xde, 0x82, 0x3a, 0xaa, 0x17, 0x3e,
0x8d, 0xa9, 0xff, 0xc1, 0xff, 0x61, 0xf1, 0xea, 0x7f, 0x2e, 0x60, 0x49, 0x4a, 0xde, 0x7e, 0x72, 0x33, 0xc5, 0xd1, 0x96, 0x8c, 0xda, 0x84, 0xfa, 0xef, 0xfc, 0xff, 0x6f, 0x0f, 0xf4, 0x3f, 0x15,
0x0e, 0x5b, 0x61, 0x21, 0x1c, 0xcc, 0x3d, 0x93, 0x72, 0xf6, 0xdf, 0x7a, 0x87, 0xcd, 0xd0, 0xe0, 0xb0, 0xc4, 0x25, 0xd9, 0x84, 0x9c, 0xc1, 0x66, 0x58, 0x58, 0x87, 0x0b, 0xcf, 0xa4, 0x9c, 0xfd,
0x83, 0xc4, 0x93, 0xdf, 0xc2, 0xfe, 0x08, 0x67, 0x75, 0xfc, 0xb9, 0x3f, 0xf0, 0xe8, 0x8c, 0xda, 0xb7, 0x5e, 0x64, 0x23, 0x34, 0x78, 0x27, 0xf1, 0xe4, 0x37, 0xb0, 0x37, 0x46, 0xaf, 0x8e, 0xbf,
0xe1, 0x54, 0xc5, 0x04, 0xdb, 0x9d, 0x07, 0xa8, 0xb7, 0x08, 0xf2, 0x8d, 0xdd, 0x51, 0xe2, 0x83, 0xf0, 0x87, 0x1e, 0x9d, 0x53, 0x3b, 0x74, 0x55, 0x4c, 0xb0, 0xe7, 0x59, 0x80, 0x7a, 0x8d, 0x20,
0x9a, 0x4f, 0x7f, 0x85, 0xd5, 0x35, 0xce, 0x38, 0xff, 0xff, 0x5e, 0xe3, 0x45, 0xda, 0x48, 0x2d, 0xdf, 0xd8, 0x19, 0x27, 0x3e, 0x28, 0x7f, 0xfa, 0x0f, 0xb1, 0x5a, 0xc7, 0x19, 0x2c, 0x6b, 0xaf,
0x4b, 0x3a, 0x00, 0xf2, 0x5a, 0xfb, 0xd6, 0x57, 0xa6, 0xea, 0x65, 0x10, 0xad, 0xd8, 0x96, 0x77, 0xf5, 0x3f, 0x16, 0x60, 0x3d, 0xe5, 0x90, 0x74, 0x01, 0x24, 0x01, 0xf8, 0xd6, 0x67, 0xa6, 0x2a,
0xd6, 0x57, 0x66, 0x68, 0xc3, 0x60, 0x48, 0xee, 0x40, 0x8d, 0x2f, 0x24, 0x3a, 0xd9, 0x93, 0xbc, 0x6b, 0x10, 0x87, 0x08, 0xf8, 0x8d, 0xf5, 0x99, 0x19, 0xda, 0x28, 0x18, 0x92, 0xdb, 0x50, 0xe3,
0x5f, 0x08, 0x68, 0x95, 0x8b, 0xff, 0xe4, 0x11, 0xac, 0xca, 0x89, 0xc7, 0xae, 0xef, 0x5b, 0x9e, 0x4b, 0x89, 0x4e, 0x76, 0x2f, 0x6f, 0x97, 0x02, 0x5a, 0xe5, 0xe2, 0x3f, 0x79, 0x08, 0xab, 0xd2,
0xaa, 0x94, 0x24, 0x3e, 0xf5, 0x4b, 0xa1, 0x31, 0x1a, 0xc3, 0x48, 0xd0, 0xff, 0x00, 0x5a, 0xb8, 0xf1, 0xc4, 0xf5, 0x7d, 0xcb, 0x53, 0x35, 0x95, 0xc4, 0x5d, 0xbf, 0x10, 0x1a, 0xa3, 0x31, 0x8a,
0x2c, 0xb9, 0x0d, 0x9a, 0x4d, 0x17, 0x83, 0xe1, 0xb5, 0x3c, 0x89, 0x42, 0xbb, 0x62, 0xd4, 0x6d, 0x04, 0xfd, 0xf7, 0xa0, 0x85, 0xd3, 0x92, 0xef, 0x40, 0xb3, 0xe9, 0x72, 0x38, 0xba, 0x92, 0x7b,
0xba, 0xe8, 0xa2, 0x4c, 0xf6, 0xa1, 0x86, 0x4a, 0xbe, 0x90, 0x3b, 0x5b, 0x31, 0xaa, 0x36, 0x5d, 0x5c, 0xe8, 0x54, 0x8c, 0xba, 0x4d, 0x97, 0x3d, 0x94, 0xc9, 0x1e, 0xd4, 0x50, 0xc9, 0x97, 0x72,
0xbc, 0x5f, 0x84, 0x8a, 0x31, 0xf5, 0x83, 0x6e, 0xcc, 0xa6, 0x8b, 0x97, 0xd4, 0xd7, 0x9f, 0x43, 0xcf, 0x2a, 0x46, 0xd5, 0xa6, 0xcb, 0xb7, 0xcb, 0x50, 0x31, 0xa1, 0x7e, 0xd0, 0xb7, 0xd9, 0x74,
0x55, 0x3a, 0xf9, 0x3f, 0x4d, 0x8c, 0xf6, 0xc5, 0x84, 0xfd, 0xaf, 0xa0, 0x11, 0xf3, 0x9b, 0xfc, 0xf9, 0x82, 0xfa, 0xfa, 0x33, 0xa8, 0xca, 0x45, 0x7e, 0x93, 0x63, 0xb4, 0x2f, 0x26, 0xec, 0x7f,
0x1c, 0x76, 0x65, 0x84, 0x1e, 0x9d, 0x71, 0xb1, 0x23, 0x89, 0x09, 0x89, 0x50, 0xbe, 0xa5, 0x33, 0x0e, 0x8d, 0xd8, 0xba, 0xc9, 0x4f, 0x60, 0x47, 0x46, 0xe8, 0xd1, 0x39, 0x17, 0x3b, 0x92, 0x70,
0x8e, 0x4b, 0x8a, 0xa9, 0xf5, 0xbf, 0x17, 0xa1, 0x2a, 0x7b, 0x37, 0x72, 0x07, 0xeb, 0x20, 0xb5, 0x48, 0x84, 0xf2, 0x35, 0x9d, 0x73, 0x9c, 0x52, 0xb8, 0xd6, 0xff, 0x56, 0x84, 0xaa, 0xec, 0xf2,
0x9c, 0x81, 0x65, 0x4a, 0xca, 0xee, 0x36, 0xbe, 0xdf, 0x1c, 0xd4, 0x04, 0xe5, 0xf5, 0x2f, 0xb0, 0xc8, 0x6d, 0xac, 0x98, 0xd4, 0x72, 0x86, 0x96, 0x29, 0xc9, 0xbd, 0xd7, 0xf8, 0x7a, 0xbd, 0x5f,
0xf4, 0xe1, 0xc0, 0x8c, 0x71, 0x50, 0x31, 0xc1, 0x41, 0x04, 0xca, 0xdc, 0xb2, 0x99, 0x0a, 0x51, 0x13, 0x44, 0x38, 0x38, 0xc7, 0x22, 0x89, 0x03, 0x33, 0xc6, 0x39, 0xc5, 0x44, 0x13, 0x4a, 0xa0,
0x8c, 0xd1, 0x73, 0x67, 0x6e, 0x8b, 0x2d, 0x29, 0xcb, 0x2d, 0x71, 0xe6, 0x36, 0x6e, 0xc9, 0x4b, 0xcc, 0x2d, 0x9b, 0xa9, 0x10, 0xc5, 0x18, 0x57, 0xee, 0x2c, 0x6c, 0xb1, 0x25, 0x65, 0xb9, 0x25,
0x58, 0x8b, 0x31, 0xb8, 0x65, 0xaa, 0xce, 0x62, 0x3d, 0x7e, 0x1a, 0xfd, 0x8b, 0xee, 0x36, 0x26, 0xce, 0xc2, 0xc6, 0x2d, 0x79, 0x01, 0x6b, 0x31, 0xae, 0xb7, 0x4c, 0xd5, 0x83, 0x34, 0xe3, 0xa7,
0xf5, 0xf7, 0x9b, 0x83, 0xc6, 0x6f, 0x02, 0x4e, 0xef, 0x5f, 0x18, 0x8d, 0x90, 0xe0, 0xfb, 0x26, 0x31, 0x38, 0xef, 0x6d, 0x61, 0xba, 0x7e, 0xbd, 0xde, 0x6f, 0xfc, 0x2a, 0x60, 0xff, 0xc1, 0xb9,
0x69, 0x83, 0xe0, 0xfb, 0x81, 0xac, 0x79, 0xb2, 0x0e, 0x54, 0x45, 0xd2, 0xad, 0xe3, 0x77, 0x55, 0xd1, 0x08, 0x4b, 0xc1, 0xc0, 0x24, 0x1d, 0x10, 0x95, 0x61, 0x28, 0xab, 0xa3, 0xac, 0x18, 0x92,
0x14, 0xb1, 0x75, 0xbd, 0x0d, 0x1a, 0xa6, 0xa1, 0x84, 0xd4, 0x04, 0xa4, 0x8e, 0x1f, 0x84, 0xf2, 0x4c, 0x9b, 0xf8, 0x5d, 0x95, 0x4f, 0x6c, 0x72, 0xbf, 0x03, 0x0d, 0x93, 0x4e, 0x42, 0x24, 0xb7,
0x2e, 0x6c, 0x44, 0x3d, 0xa7, 0x84, 0xd4, 0xe5, 0x2c, 0xd1, 0x67, 0x01, 0xbc, 0x05, 0xf5, 0xb0, 0xd6, 0xf1, 0x83, 0x50, 0xde, 0x81, 0xf5, 0xa8, 0x3b, 0x95, 0x10, 0x49, 0xb4, 0xcd, 0xe8, 0xb3,
0xde, 0x68, 0x02, 0x51, 0xa3, 0xaa, 0xcc, 0xbc, 0x81, 0x9a, 0x72, 0x31, 0xb3, 0x75, 0xfe, 0x19, 0x00, 0xde, 0x82, 0x7a, 0x58, 0x99, 0x34, 0x81, 0xa8, 0x51, 0x55, 0x90, 0x5e, 0x41, 0x4d, 0x2d,
0x54, 0xf0, 0x5c, 0x82, 0x6b, 0x17, 0xf4, 0x34, 0xe2, 0x3c, 0x18, 0x4f, 0x34, 0xd0, 0x12, 0xa8, 0x31, 0xb3, 0xc9, 0xfe, 0x31, 0x54, 0xf0, 0x5c, 0x82, 0x0b, 0x15, 0x74, 0x3f, 0xe2, 0x3c, 0x18,
0x9f, 0xc2, 0x5a, 0x42, 0x8b, 0x45, 0x81, 0xbb, 0x9c, 0x4e, 0xd5, 0x81, 0x4a, 0x21, 0x5c, 0xac, 0x4f, 0xb4, 0xda, 0x12, 0xa8, 0x9f, 0xc0, 0x5a, 0x42, 0x8b, 0x45, 0x80, 0xbb, 0x9c, 0xce, 0xd4,
0x18, 0x2d, 0xa6, 0x3f, 0x05, 0x2d, 0xa4, 0x06, 0x3c, 0x05, 0x6f, 0x3e, 0x1c, 0x04, 0x8f, 0x97, 0x81, 0x4a, 0x21, 0x9c, 0xac, 0x18, 0x4d, 0xa6, 0x3f, 0x01, 0x2d, 0xbc, 0xf4, 0x78, 0x0a, 0xde,
0x55, 0xa3, 0xea, 0xcd, 0x87, 0xaf, 0x65, 0xe9, 0xf1, 0xdc, 0x2f, 0xaa, 0x99, 0x2f, 0x19, 0x52, 0x62, 0x34, 0x0c, 0x7e, 0xe6, 0xac, 0x1a, 0x55, 0x6f, 0x31, 0x7a, 0x29, 0x4b, 0x8d, 0xe7, 0x7e,
0xd0, 0x9f, 0x41, 0x3d, 0x68, 0xb3, 0xf3, 0x4d, 0x73, 0xb2, 0xe0, 0xe4, 0x5b, 0x05, 0x36, 0xce, 0x52, 0x6d, 0x7f, 0xc9, 0x90, 0x82, 0xfe, 0x14, 0xea, 0x41, 0x43, 0x9e, 0x6f, 0x9a, 0x93, 0x05,
0xba, 0xe7, 0xfd, 0x33, 0xcf, 0x9b, 0x5a, 0x23, 0x2a, 0x4a, 0x6d, 0x07, 0xca, 0xa2, 0x99, 0xc8, 0xc7, 0x5f, 0x2a, 0xb0, 0x7e, 0xda, 0x3b, 0x1b, 0x9c, 0x7a, 0xde, 0xcc, 0x1a, 0x53, 0x51, 0x94,
0x78, 0xe5, 0xb7, 0xb2, 0xba, 0x5a, 0x72, 0x02, 0x15, 0xd1, 0x53, 0x90, 0xac, 0xc7, 0x7e, 0x2b, 0xbb, 0x50, 0x16, 0x6d, 0x47, 0xc6, 0x7b, 0x40, 0x3b, 0xab, 0xff, 0x25, 0xc7, 0x50, 0x11, 0xdd,
0xb3, 0xb9, 0xc5, 0x45, 0x64, 0xd7, 0xb1, 0xfc, 0xe6, 0x6f, 0x65, 0x75, 0xb8, 0xe4, 0x39, 0x68, 0x07, 0xc9, 0x7a, 0x16, 0x68, 0x67, 0xb6, 0xc1, 0x38, 0x89, 0xec, 0x4f, 0x6e, 0xbe, 0x0e, 0xb4,
0x51, 0x37, 0x90, 0xf7, 0xf2, 0x6f, 0xe5, 0xf6, 0xba, 0x68, 0x1f, 0xd5, 0x9b, 0xbc, 0x77, 0x72, 0xb3, 0x7a, 0x61, 0xf2, 0x0c, 0xb4, 0xa8, 0x6f, 0xc8, 0x7b, 0x23, 0x68, 0xe7, 0x76, 0xc5, 0x68,
0x2b, 0xb7, 0x29, 0x24, 0x4f, 0xa0, 0x16, 0x94, 0xe0, 0xec, 0xb7, 0x79, 0x2b, 0xa7, 0x0f, 0xc5, 0x1f, 0x55, 0x97, 0xbc, 0x5f, 0xd4, 0xed, 0xdc, 0xf6, 0x91, 0x3c, 0x86, 0x5a, 0x50, 0x84, 0xb3,
0xed, 0x91, 0x6d, 0x47, 0xd6, 0x0f, 0x08, 0xad, 0xcc, 0x66, 0x99, 0x3c, 0x82, 0xaa, 0xa2, 0xeb, 0x7f, 0xc5, 0xb7, 0x73, 0x3a, 0x56, 0xdc, 0x1e, 0xd9, 0x8c, 0x64, 0x3d, 0x35, 0xb4, 0x33, 0xdb,
0xcc, 0x57, 0x76, 0x2b, 0xbb, 0x9b, 0xc4, 0x20, 0xa3, 0x47, 0x6c, 0xde, 0x8f, 0x1c, 0xad, 0xdc, 0x6a, 0xf2, 0x10, 0xaa, 0x8a, 0x88, 0x33, 0x7f, 0x8f, 0xb7, 0xb3, 0xfb, 0x4e, 0x0c, 0x32, 0xfa,
0xae, 0x9e, 0x9c, 0x01, 0xc4, 0x5e, 0x94, 0xb9, 0xbf, 0x5e, 0xb4, 0xf2, 0xbb, 0x75, 0x82, 0xe9, 0xb9, 0x9b, 0xf7, 0x1c, 0xd2, 0xce, 0xed, 0xff, 0xc9, 0x29, 0x40, 0xec, 0xb7, 0x67, 0xee, 0x3b,
0x18, 0xbe, 0xc0, 0xb2, 0x7f, 0x55, 0x68, 0xe5, 0x35, 0xd0, 0xc3, 0xaa, 0xf8, 0xe5, 0xe9, 0xe1, 0x47, 0x3b, 0xbf, 0xaf, 0x27, 0x98, 0x8e, 0xe1, 0x6f, 0xb5, 0xec, 0xf7, 0x87, 0x76, 0x5e, 0xab,
0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe2, 0x9f, 0x37, 0xee, 0xf5, 0x12, 0x00, 0x00, 0x3d, 0xaa, 0x8a, 0x37, 0xaa, 0x07, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x13, 0xc6, 0x62, 0xb1,
0x1f, 0x13, 0x00, 0x00,
} }

46
types/types.proto
View File

@ -40,6 +40,7 @@ message RequestInfo {
string version = 1; string version = 1;
} }
// nondeterministic
message RequestSetOption { message RequestSetOption {
string key = 1; string key = 1;
string value = 2; string value = 2;
@ -98,6 +99,7 @@ message Response {
} }
} }
// nondeterministic
message ResponseException { message ResponseException {
string error = 1; string error = 1;
} }
@ -116,9 +118,12 @@ message ResponseInfo {
bytes last_block_app_hash = 4; bytes last_block_app_hash = 4;
} }
// nondeterministic
message ResponseSetOption { message ResponseSetOption {
uint32 code = 1; uint32 code = 1;
string log = 2; // bytes data = 2;
string log = 3;
string info = 4;
} }
message ResponseInitChain { message ResponseInitChain {
@ -126,12 +131,14 @@ message ResponseInitChain {
message ResponseQuery { message ResponseQuery {
uint32 code = 1; uint32 code = 1;
int64 index = 2; // bytes data = 2; // use "value" instead.
bytes key = 3; string log = 3; // nondeterministic
bytes value = 4; string info = 4; // nondeterministic
bytes proof = 5; int64 index = 5;
int64 height = 6; bytes key = 6;
string log = 7; bytes value = 7;
bytes proof = 8;
int64 height = 9;
} }
message ResponseBeginBlock { message ResponseBeginBlock {
@ -140,21 +147,23 @@ message ResponseBeginBlock {
message ResponseCheckTx { message ResponseCheckTx {
uint32 code = 1; uint32 code = 1;
bytes data = 2; bytes data = 2;
string log = 3; string log = 3; // nondeterministic
int64 gas_wanted = 4; string info = 4; // nondeterministic
// int64 gas_used = 5; int64 gas_wanted = 5;
repeated common.KVPair tags = 6 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"]; // int64 gas_used = 6;
common.KI64Pair fee = 7 [(gogoproto.nullable)=false]; repeated common.KVPair tags = 7 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
common.KI64Pair fee = 8 [(gogoproto.nullable)=false];
} }
message ResponseDeliverTx { message ResponseDeliverTx {
uint32 code = 1; uint32 code = 1;
bytes data = 2; bytes data = 2;
string log = 3; string log = 3; // nondeterministic
int64 gas_wanted = 4; string info = 4; // nondeterministic
int64 gas_used = 5; int64 gas_wanted = 5;
repeated common.KVPair tags = 6 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"]; int64 gas_used = 6;
// common.KI64Pair fee = 7; repeated common.KVPair tags = 7 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
// common.KI64Pair fee = 8;
} }
message ResponseEndBlock { message ResponseEndBlock {
@ -163,9 +172,8 @@ message ResponseEndBlock {
} }
message ResponseCommit { message ResponseCommit {
uint32 code = 1; // reserve 1
bytes data = 2; bytes data = 2;
string log = 3;
} }
//---------------------------------------- //----------------------------------------

2
types/util.go
View File

@ -28,7 +28,7 @@ func (v Validators) Swap(i, j int) {
func ValidatorsString(vs Validators) string { func ValidatorsString(vs Validators) string {
s := make([]validatorPretty, len(vs)) s := make([]validatorPretty, len(vs))
for i, v := range vs { for i, v := range vs {
s[i] = validatorPretty{v.PubKey, v.Power} s[i] = validatorPretty(v)
} }
b, err := json.Marshal(s) b, err := json.Marshal(s)
if err != nil { if err != nil {