Merge branch 'abci_proof' into develop

This commit is contained in:
Jae Kwon
2017-01-27 22:27:32 -08:00
26 changed files with 903 additions and 368 deletions

1
.gitignore vendored
View File

@ -1,3 +1,4 @@
*.swp *.swp
*.swo *.swo
*.pyc *.pyc
vendor

View File

@ -4,6 +4,10 @@ all: protoc install test
NOVENDOR = go list github.com/tendermint/abci/... | grep -v /vendor/ NOVENDOR = go list github.com/tendermint/abci/... | grep -v /vendor/
install-protoc:
# Download: https://github.com/google/protobuf/releases
go get github.com/golang/protobuf/protoc-gen-go
protoc: protoc:
@ protoc --go_out=plugins=grpc:. types/*.proto @ protoc --go_out=plugins=grpc:. types/*.proto
@ -13,8 +17,10 @@ install:
build: build:
@ go build -i github.com/tendermint/abci/cmd/... @ go build -i github.com/tendermint/abci/cmd/...
test: # test.sh requires that we run the installed cmds, must not be out of date
@ go test `${NOVENDOR}` test: install
find . -name test.sock -exec rm {} \;
@ go test -p 1 `${NOVENDOR}`
@ bash tests/test.sh @ bash tests/test.sh
fmt: fmt:

View File

@ -21,51 +21,16 @@ Other implementations:
The [primary specification](https://github.com/tendermint/abci/blob/master/types/types.proto) is made using Protocol Buffers. The [primary specification](https://github.com/tendermint/abci/blob/master/types/types.proto) is made using Protocol Buffers.
As a [Go interface](https://github.com/tendermint/abci/blob/master/types/application.go), it might look like: - The Protobuf file defining ABCI message types, and the optional GRPC interface. To build, run `make protoc`
- See `protoc --help` and [the GRPC docs](https://www.grpc.io/docs) for examples and details of other languages.
TendermintCore runs a client, and the ABCI application runs a server. There are three Golang implementation of ABCI client and server.
``` 1. ABCI-socket: Asynchronous, ordered message passing over Unix or TCP sockets. Messages are serialized using Protobuf and length prefixed.
// Applications 2. GRPC: Synchronous (slow) implementation using GRPC.
type Application interface { 3. Golang in-process: If the ABCI appliation is written in Golang, it is possible to compile both TendermintCore and the application as one binary.
// Latest state _TODO: merge information from https://tendermint.com/blog/tendermint-0-8-release_
Info() ResponseInfo
// Initialization
SetOption(key string, value string) (log string)
InitChain(validators []*Validator)
// Apply a block
BeginBlock(hash []byte, header *Header)
DeliverTx(tx []byte) Result
EndBlock(height uint64) ResponseEndBlock
Commit() Result
// Check validity
CheckTx(tx []byte) Result
// Query for state
Query(query []byte) Result
}
type Result struct {
Code CodeType
Data []byte
Log string // Can be non-deterministic
}
type ResponseInfo struct {
Data string
Version string
LastBlockHeight uint64
LastBlockAppHash []byte
}
type ResponseEndBlock struct {
Diffs []*Validator
}
```
## Message Types ## Message Types
@ -98,7 +63,7 @@ ABCI requests/responses are simple Protobuf messages. Check out the [schema fil
You can make CheckTx semi-stateful and clear the state upon `Commit` or `BeginBlock`, You can make CheckTx semi-stateful and clear the state upon `Commit` or `BeginBlock`,
to allow for dependent sequences of transactions in the same block. to allow for dependent sequences of transactions in the same block.
#### Commit #### Commit
* __Returns__: * __Returns__:
* `Data ([]byte)`: The Merkle root hash * `Data ([]byte)`: The Merkle root hash
* `Log (string)`: Debug or error message * `Log (string)`: Debug or error message
@ -107,11 +72,20 @@ ABCI requests/responses are simple Protobuf messages. Check out the [schema fil
#### Query #### Query
* __Arguments__: * __Arguments__:
* `Data ([]byte)`: The query request bytes * `Data ([]byte)`: Raw query bytes. Can be used with or in lieu of Path.
* `Path (string)`: Path of request, like an HTTP GET path. Can be used with or in liue of Data.
* Apps MUST interpret '/store' as a query by key on the underlying store. The key SHOULD be specified in the Data field.
* Apps SHOULD allow queries over specific types like '/accounts/...' or '/votes/...'
* `Height (uint64)`: The block height for which you want the query (default=0 returns data for the latest committed block)
* `Prove (bool)`: Return Merkle proof with response if possible
* __Returns__: * __Returns__:
* `Code (uint32)`: Response code * `Code (uint32)`: Response code
* `Data ([]byte)`: The query response bytes * `Key ([]byte)`: The key of the matching data
* `Value ([]byte)`: The value of the matching data
* `Proof ([]byte)`: Proof for the data, if requested
* `Height (uint64)`: The block height from which data was derived
* `Log (string)`: Debug or error message * `Log (string)`: Debug or error message
*Please note* The current implementation of go-merkle doesn't support querying proofs from past blocks, so for the present moment, any height other than 0 will return an error. Hopefully this will be improved soon(ish)
#### Info #### Info
* __Returns__: * __Returns__:

View File

@ -20,7 +20,7 @@ type Client interface {
SetOptionAsync(key string, value string) *ReqRes SetOptionAsync(key string, value string) *ReqRes
DeliverTxAsync(tx []byte) *ReqRes DeliverTxAsync(tx []byte) *ReqRes
CheckTxAsync(tx []byte) *ReqRes CheckTxAsync(tx []byte) *ReqRes
QueryAsync(tx []byte) *ReqRes QueryAsync(reqQuery types.RequestQuery) *ReqRes
CommitAsync() *ReqRes CommitAsync() *ReqRes
FlushSync() error FlushSync() error
@ -29,7 +29,7 @@ type Client interface {
SetOptionSync(key string, value string) (res types.Result) SetOptionSync(key string, value string) (res types.Result)
DeliverTxSync(tx []byte) (res types.Result) DeliverTxSync(tx []byte) (res types.Result)
CheckTxSync(tx []byte) (res types.Result) CheckTxSync(tx []byte) (res types.Result)
QuerySync(tx []byte) (res types.Result) QuerySync(reqQuery types.RequestQuery) (resQuery types.ResponseQuery, err error)
CommitSync() (res types.Result) CommitSync() (res types.Result)
InitChainAsync(validators []*types.Validator) *ReqRes InitChainAsync(validators []*types.Validator) *ReqRes

View File

@ -173,8 +173,8 @@ func (cli *grpcClient) CheckTxAsync(tx []byte) *ReqRes {
return cli.finishAsyncCall(req, &types.Response{&types.Response_CheckTx{res}}) return cli.finishAsyncCall(req, &types.Response{&types.Response_CheckTx{res}})
} }
func (cli *grpcClient) QueryAsync(query []byte) *ReqRes { func (cli *grpcClient) QueryAsync(reqQuery types.RequestQuery) *ReqRes {
req := types.ToRequestQuery(query) req := types.ToRequestQuery(reqQuery)
res, err := cli.client.Query(context.Background(), req.GetQuery(), grpc.FailFast(true)) res, err := cli.client.Query(context.Background(), req.GetQuery(), grpc.FailFast(true))
if err != nil { if err != nil {
cli.StopForError(err) cli.StopForError(err)
@ -255,7 +255,7 @@ func (cli *grpcClient) EchoSync(msg string) (res types.Result) {
return res return res
} }
resp := reqres.Response.GetEcho() resp := reqres.Response.GetEcho()
return types.NewResultOK([]byte(resp.Message), LOG) return types.NewResultOK([]byte(resp.Message), "")
} }
func (cli *grpcClient) FlushSync() error { func (cli *grpcClient) FlushSync() error {
@ -300,13 +300,15 @@ func (cli *grpcClient) CheckTxSync(tx []byte) (res types.Result) {
return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log} return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log}
} }
func (cli *grpcClient) QuerySync(query []byte) (res types.Result) { func (cli *grpcClient) QuerySync(reqQuery types.RequestQuery) (resQuery types.ResponseQuery, err error) {
reqres := cli.QueryAsync(query) reqres := cli.QueryAsync(reqQuery)
if res := cli.checkErrGetResult(); res.IsErr() { if err = cli.Error(); err != nil {
return res return resQuery, err
} }
resp := reqres.Response.GetQuery() if resQuery_ := reqres.Response.GetQuery(); resQuery_ != nil {
return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log} return *resQuery_, nil
}
return resQuery, nil
} }
func (cli *grpcClient) CommitSync() (res types.Result) { func (cli *grpcClient) CommitSync() (res types.Result) {

View File

@ -89,13 +89,13 @@ func (app *localClient) CheckTxAsync(tx []byte) *ReqRes {
) )
} }
func (app *localClient) QueryAsync(tx []byte) *ReqRes { func (app *localClient) QueryAsync(reqQuery types.RequestQuery) *ReqRes {
app.mtx.Lock() app.mtx.Lock()
res := app.Application.Query(tx) resQuery := app.Application.Query(reqQuery)
app.mtx.Unlock() app.mtx.Unlock()
return app.callback( return app.callback(
types.ToRequestQuery(tx), types.ToRequestQuery(reqQuery),
types.ToResponseQuery(res.Code, res.Data, res.Log), types.ToResponseQuery(resQuery),
) )
} }
@ -185,11 +185,11 @@ func (app *localClient) CheckTxSync(tx []byte) (res types.Result) {
return res return res
} }
func (app *localClient) QuerySync(query []byte) (res types.Result) { func (app *localClient) QuerySync(reqQuery types.RequestQuery) (resQuery types.ResponseQuery, err error) {
app.mtx.Lock() app.mtx.Lock()
res = app.Application.Query(query) resQuery = app.Application.Query(reqQuery)
app.mtx.Unlock() app.mtx.Unlock()
return res return resQuery, nil
} }
func (app *localClient) CommitSync() (res types.Result) { func (app *localClient) CommitSync() (res types.Result) {

View File

@ -249,8 +249,8 @@ func (cli *socketClient) CheckTxAsync(tx []byte) *ReqRes {
return cli.queueRequest(types.ToRequestCheckTx(tx)) return cli.queueRequest(types.ToRequestCheckTx(tx))
} }
func (cli *socketClient) QueryAsync(query []byte) *ReqRes { func (cli *socketClient) QueryAsync(reqQuery types.RequestQuery) *ReqRes {
return cli.queueRequest(types.ToRequestQuery(query)) return cli.queueRequest(types.ToRequestQuery(reqQuery))
} }
func (cli *socketClient) CommitAsync() *ReqRes { func (cli *socketClient) CommitAsync() *ReqRes {
@ -278,7 +278,7 @@ func (cli *socketClient) EchoSync(msg string) (res types.Result) {
return types.ErrInternalError.SetLog(err.Error()) return types.ErrInternalError.SetLog(err.Error())
} }
resp := reqres.Response.GetEcho() resp := reqres.Response.GetEcho()
return types.Result{Code: OK, Data: []byte(resp.Message), Log: LOG} return types.Result{Code: OK, Data: []byte(resp.Message)}
} }
func (cli *socketClient) FlushSync() error { func (cli *socketClient) FlushSync() error {
@ -296,8 +296,8 @@ func (cli *socketClient) InfoSync() (resInfo types.ResponseInfo, err error) {
if err := cli.Error(); err != nil { if err := cli.Error(); err != nil {
return resInfo, err return resInfo, err
} }
if info := reqres.Response.GetInfo(); info != nil { if resInfo_ := reqres.Response.GetInfo(); resInfo_ != nil {
return *info, nil return *resInfo_, nil
} }
return resInfo, nil return resInfo, nil
} }
@ -332,14 +332,16 @@ func (cli *socketClient) CheckTxSync(tx []byte) (res types.Result) {
return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log} return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log}
} }
func (cli *socketClient) QuerySync(query []byte) (res types.Result) { func (cli *socketClient) QuerySync(reqQuery types.RequestQuery) (resQuery types.ResponseQuery, err error) {
reqres := cli.queueRequest(types.ToRequestQuery(query)) reqres := cli.queueRequest(types.ToRequestQuery(reqQuery))
cli.FlushSync() cli.FlushSync()
if err := cli.Error(); err != nil { if err := cli.Error(); err != nil {
return types.ErrInternalError.SetLog(err.Error()) return resQuery, err
} }
resp := reqres.Response.GetQuery() if resQuery_ := reqres.Response.GetQuery(); resQuery_ != nil {
return types.Result{Code: resp.Code, Data: resp.Data, Log: resp.Log} return *resQuery_, nil
}
return resQuery, nil
} }
func (cli *socketClient) CommitSync() (res types.Result) { func (cli *socketClient) CommitSync() (res types.Result) {

View File

@ -15,28 +15,15 @@ import (
"github.com/urfave/cli" "github.com/urfave/cli"
) )
//structure for data passed to print response // Structure for data passed to print response.
// variables must be exposed for JSON to read
type response struct { type response struct {
Res types.Result Data []byte
Data string Code types.CodeType
PrintCode bool Key []byte
Code string Value []byte
} Log string
Height string
func newResponse(res types.Result, data string, printCode bool) *response { Proof []byte
rsp := &response{
Res: res,
Data: data,
PrintCode: printCode,
Code: "",
}
if printCode {
rsp.Code = res.Code.String()
}
return rsp
} }
// client is a global variable so it can be reused by the console // client is a global variable so it can be reused by the console
@ -220,9 +207,10 @@ func cmdEcho(c *cli.Context) error {
if len(args) != 1 { if len(args) != 1 {
return errors.New("Command echo takes 1 argument") return errors.New("Command echo takes 1 argument")
} }
res := client.EchoSync(args[0]) resEcho := client.EchoSync(args[0])
rsp := newResponse(res, string(res.Data), false) printResponse(c, response{
printResponse(c, rsp) Data: resEcho.Data,
})
return nil return nil
} }
@ -232,8 +220,9 @@ func cmdInfo(c *cli.Context) error {
if err != nil { if err != nil {
return err return err
} }
rsp := newResponse(types.Result{}, string(resInfo.Data), false) printResponse(c, response{
printResponse(c, rsp) Data: []byte(resInfo.Data),
})
return nil return nil
} }
@ -243,9 +232,10 @@ func cmdSetOption(c *cli.Context) error {
if len(args) != 2 { if len(args) != 2 {
return errors.New("Command set_option takes 2 arguments (key, value)") return errors.New("Command set_option takes 2 arguments (key, value)")
} }
res := client.SetOptionSync(args[0], args[1]) resSetOption := client.SetOptionSync(args[0], args[1])
rsp := newResponse(res, fmt.Sprintf("%s=%s", args[0], args[1]), false) printResponse(c, response{
printResponse(c, rsp) Log: resSetOption.Log,
})
return nil return nil
} }
@ -260,8 +250,11 @@ func cmdDeliverTx(c *cli.Context) error {
return err return err
} }
res := client.DeliverTxSync(txBytes) res := client.DeliverTxSync(txBytes)
rsp := newResponse(res, string(res.Data), true) printResponse(c, response{
printResponse(c, rsp) Code: res.Code,
Data: res.Data,
Log: res.Log,
})
return nil return nil
} }
@ -276,20 +269,26 @@ func cmdCheckTx(c *cli.Context) error {
return err return err
} }
res := client.CheckTxSync(txBytes) res := client.CheckTxSync(txBytes)
rsp := newResponse(res, string(res.Data), true) printResponse(c, response{
printResponse(c, rsp) Code: res.Code,
Data: res.Data,
Log: res.Log,
})
return nil return nil
} }
// Get application Merkle root hash // Get application Merkle root hash
func cmdCommit(c *cli.Context) error { func cmdCommit(c *cli.Context) error {
res := client.CommitSync() res := client.CommitSync()
rsp := newResponse(res, fmt.Sprintf("0x%X", res.Data), false) printResponse(c, response{
printResponse(c, rsp) Data: res.Data,
Log: res.Log,
})
return nil return nil
} }
// Query application state // Query application state
// TODO: Make request and response support all fields.
func cmdQuery(c *cli.Context) error { func cmdQuery(c *cli.Context) error {
args := c.Args() args := c.Args()
if len(args) != 1 { if len(args) != 1 {
@ -299,15 +298,29 @@ func cmdQuery(c *cli.Context) error {
if err != nil { if err != nil {
return err return err
} }
res := client.QuerySync(queryBytes) resQuery, err := client.QuerySync(types.RequestQuery{
rsp := newResponse(res, string(res.Data), true) Data: queryBytes,
printResponse(c, rsp) Path: "/store", // TOOD expose
Height: 0, // TODO expose
//Prove: true, // TODO expose
})
if err != nil {
return err
}
printResponse(c, response{
Code: resQuery.Code,
Key: resQuery.Key,
Value: resQuery.Value,
Log: resQuery.Log,
Height: fmt.Sprintf("%v", resQuery.Height),
//Proof: resQuery.Proof,
})
return nil return nil
} }
//-------------------------------------------------------------------------------- //--------------------------------------------------------------------------------
func printResponse(c *cli.Context, rsp *response) { func printResponse(c *cli.Context, rsp response) {
verbose := c.GlobalBool("verbose") verbose := c.GlobalBool("verbose")
@ -315,19 +328,29 @@ func printResponse(c *cli.Context, rsp *response) {
fmt.Println(">", c.Command.Name, strings.Join(c.Args(), " ")) fmt.Println(">", c.Command.Name, strings.Join(c.Args(), " "))
} }
if rsp.PrintCode { if rsp.Code != types.CodeType_OK {
fmt.Printf("-> code: %s\n", rsp.Code) fmt.Printf("-> code: %s\n", rsp.Code.String())
} }
if len(rsp.Data) != 0 {
//if pr.res.Error != "" {
// fmt.Printf("-> error: %s\n", pr.res.Error)
//}
if rsp.Data != "" {
fmt.Printf("-> data: %s\n", rsp.Data) fmt.Printf("-> data: %s\n", rsp.Data)
fmt.Printf("-> data.hex: %X\n", rsp.Data)
} }
if rsp.Res.Log != "" { if len(rsp.Key) != 0 {
fmt.Printf("-> log: %s\n", rsp.Res.Log) fmt.Printf("-> key: %s\n", rsp.Key)
fmt.Printf("-> key.hex: %X\n", rsp.Key)
}
if len(rsp.Value) != 0 {
fmt.Printf("-> value: %s\n", rsp.Value)
fmt.Printf("-> value.hex: %X\n", rsp.Value)
}
if rsp.Log != "" {
fmt.Printf("-> log: %s\n", rsp.Log)
}
if rsp.Height != "" {
fmt.Printf("-> height: %s\n", rsp.Height)
}
if rsp.Proof != nil {
fmt.Printf("-> proof: %X\n", rsp.Proof)
} }
if verbose { if verbose {

View File

@ -2,7 +2,6 @@ package main
import ( import (
"flag" "flag"
"fmt"
"log" "log"
"github.com/tendermint/abci/server" "github.com/tendermint/abci/server"
@ -59,8 +58,10 @@ func (app *ChainAwareApplication) Commit() types.Result {
return types.NewResultOK([]byte("nil"), "") return types.NewResultOK([]byte("nil"), "")
} }
func (app *ChainAwareApplication) Query(query []byte) types.Result { func (app *ChainAwareApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {
return types.NewResultOK([]byte(fmt.Sprintf("%d,%d", app.beginCount, app.endCount)), "") return types.ResponseQuery{
Value: []byte(cmn.Fmt("%d,%d", app.beginCount, app.endCount)),
}
} }
func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) { func (app *ChainAwareApplication) BeginBlock(hash []byte, header *types.Header) {

View File

@ -40,10 +40,10 @@ func TestChainAware(t *testing.T) {
client.CommitSync() client.CommitSync()
} }
r := app.Query(nil) r := app.Query(types.RequestQuery{})
spl := strings.Split(string(r.Data), ",") spl := strings.Split(string(r.Value), ",")
if len(spl) != 2 { if len(spl) != 2 {
t.Fatal("expected %d,%d ; got %s", n, n, string(r.Data)) t.Fatal("expected %d,%d ; got %s", n, n, string(r.Value))
} }
beginCount, _ := strconv.Atoi(spl[0]) beginCount, _ := strconv.Atoi(spl[0])
endCount, _ := strconv.Atoi(spl[1]) endCount, _ := strconv.Atoi(spl[1])

View File

@ -5,6 +5,7 @@ import (
"fmt" "fmt"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
. "github.com/tendermint/go-common"
) )
type CounterApplication struct { type CounterApplication struct {
@ -69,15 +70,13 @@ func (app *CounterApplication) Commit() types.Result {
return types.NewResultOK(hash, "") return types.NewResultOK(hash, "")
} }
func (app *CounterApplication) Query(query []byte) types.Result { func (app *CounterApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {
queryStr := string(query) switch reqQuery.Path {
switch queryStr {
case "hash": case "hash":
return types.NewResultOK(nil, fmt.Sprintf("%v", app.hashCount)) return types.ResponseQuery{Value: []byte(Fmt("%v", app.hashCount))}
case "tx": case "tx":
return types.NewResultOK(nil, fmt.Sprintf("%v", app.txCount)) return types.ResponseQuery{Value: []byte(Fmt("%v", app.txCount))}
default:
return types.ResponseQuery{Log: Fmt("Invalid query path. Expected hash or tx, got %v", reqQuery.Path)}
} }
return types.ErrUnknownRequest.SetLog(fmt.Sprintf("Invalid nonce. Expected hash or tx, got %v", queryStr))
} }

View File

@ -1,13 +1,11 @@
package dummy package dummy
import ( import (
"encoding/hex"
"fmt" "fmt"
"strings" "strings"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
"github.com/tendermint/go-merkle" "github.com/tendermint/go-merkle"
"github.com/tendermint/go-wire"
) )
type DummyApplication struct { type DummyApplication struct {
@ -47,15 +45,28 @@ func (app *DummyApplication) Commit() types.Result {
return types.NewResultOK(hash, "") return types.NewResultOK(hash, "")
} }
func (app *DummyApplication) Query(query []byte) types.Result { func (app *DummyApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {
index, value, exists := app.state.Get(query) if reqQuery.Prove {
queryResult := QueryResult{index, string(value), hex.EncodeToString(value), exists} value, proof, exists := app.state.Proof(reqQuery.Data)
return types.NewResultOK(wire.JSONBytes(queryResult), "") resQuery.Index = -1 // TODO make Proof return index
} resQuery.Key = reqQuery.Data
resQuery.Value = value
type QueryResult struct { resQuery.Proof = proof
Index int `json:"index"` if exists {
Value string `json:"value"` resQuery.Log = "exists"
ValueHex string `json:"valueHex"` } else {
Exists bool `json:"exists"` resQuery.Log = "does not exist"
}
return
} else {
index, value, exists := app.state.Get(reqQuery.Data)
resQuery.Index = int64(index)
resQuery.Value = value
if exists {
resQuery.Log = "exists"
} else {
resQuery.Log = "does not exist"
}
return
}
} }

View File

@ -7,34 +7,41 @@ import (
"sort" "sort"
"testing" "testing"
"github.com/stretchr/testify/require"
abcicli "github.com/tendermint/abci/client"
"github.com/tendermint/abci/server"
"github.com/tendermint/abci/types" "github.com/tendermint/abci/types"
cmn "github.com/tendermint/go-common" cmn "github.com/tendermint/go-common"
"github.com/tendermint/go-crypto" "github.com/tendermint/go-crypto"
"github.com/tendermint/go-wire" merkle "github.com/tendermint/go-merkle"
) )
func testDummy(t *testing.T, dummy types.Application, tx []byte, key, value string) { func testDummy(t *testing.T, app types.Application, tx []byte, key, value string) {
if r := dummy.DeliverTx(tx); r.IsErr() { ar := app.DeliverTx(tx)
t.Fatal(r) require.False(t, ar.IsErr(), ar)
} // repeating tx doesn't raise error
if r := dummy.DeliverTx(tx); r.IsErr() { ar = app.DeliverTx(tx)
t.Fatal(r) require.False(t, ar.IsErr(), ar)
}
r := dummy.Query([]byte(key)) // make sure query is fine
if r.IsErr() { resQuery := app.Query(types.RequestQuery{
t.Fatal(r) Path: "/store",
} Data: []byte(key),
})
q := new(QueryResult) require.Equal(t, types.CodeType_OK, resQuery.Code)
if err := wire.ReadJSONBytes(r.Data, q); err != nil { require.Equal(t, value, string(resQuery.Value))
t.Fatal(err)
}
if q.Value != value {
t.Fatalf("Got %s, expected %s", q.Value, value)
}
// make sure proof is fine
resQuery = app.Query(types.RequestQuery{
Path: "/store",
Data: []byte(key),
Prove: true,
})
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
proof, err := merkle.ReadProof(resQuery.Proof)
require.Nil(t, err)
require.True(t, proof.Verify([]byte(key), resQuery.Value, proof.RootHash)) // NOTE: we have no way to verify the RootHash
} }
func TestDummyKV(t *testing.T) { func TestDummyKV(t *testing.T) {
@ -202,3 +209,102 @@ func valsEqual(t *testing.T, vals1, vals2 []*types.Validator) {
} }
} }
} }
func makeSocketClientServer(app types.Application, name string) (abcicli.Client, cmn.Service, error) {
// Start the listener
socket := cmn.Fmt("unix://%s.sock", name)
server, err := server.NewSocketServer(socket, app)
if err != nil {
return nil, nil, err
}
// Connect to the socket
client, err := abcicli.NewSocketClient(socket, false)
if err != nil {
server.Stop()
return nil, nil, err
}
client.Start()
return client, server, err
}
func makeGRPCClientServer(app types.Application, name string) (abcicli.Client, cmn.Service, error) {
// Start the listener
socket := cmn.Fmt("unix://%s.sock", name)
gapp := types.NewGRPCApplication(app)
server, err := server.NewGRPCServer(socket, gapp)
if err != nil {
return nil, nil, err
}
client, err := abcicli.NewGRPCClient(socket, true)
if err != nil {
server.Stop()
return nil, nil, err
}
return client, server, err
}
func TestClientServer(t *testing.T) {
// set up socket app
dummy := NewDummyApplication()
client, server, err := makeSocketClientServer(dummy, "dummy-socket")
require.Nil(t, err)
defer server.Stop()
defer client.Stop()
runClientTests(t, client)
// set up grpc app
dummy = NewDummyApplication()
gclient, gserver, err := makeGRPCClientServer(dummy, "dummy-grpc")
require.Nil(t, err)
defer gserver.Stop()
defer gclient.Stop()
runClientTests(t, gclient)
}
func runClientTests(t *testing.T, client abcicli.Client) {
// run some tests....
key := "abc"
value := key
tx := []byte(key)
testClient(t, client, tx, key, value)
value = "def"
tx = []byte(key + "=" + value)
testClient(t, client, tx, key, value)
}
func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string) {
ar := app.DeliverTxSync(tx)
require.False(t, ar.IsErr(), ar)
// repeating tx doesn't raise error
ar = app.DeliverTxSync(tx)
require.False(t, ar.IsErr(), ar)
// make sure query is fine
resQuery, err := app.QuerySync(types.RequestQuery{
Path: "/store",
Data: []byte(key),
})
require.Nil(t, err)
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
// make sure proof is fine
resQuery, err = app.QuerySync(types.RequestQuery{
Path: "/store",
Data: []byte(key),
Prove: true,
})
require.Nil(t, err)
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
proof, err := merkle.ReadProof(resQuery.Proof)
require.Nil(t, err)
require.True(t, proof.Verify([]byte(key), resQuery.Value, proof.RootHash)) // NOTE: we have no way to verify the RootHash
}

View File

@ -0,0 +1,321 @@
package dummy
import (
"bytes"
"io/ioutil"
"sort"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
. "github.com/tendermint/go-common"
"github.com/tendermint/go-crypto"
merkle "github.com/tendermint/go-merkle"
"github.com/tendermint/go-wire"
<<<<<<< HEAD
"github.com/tendermint/abci/types"
)
func testDummy(t *testing.T, dummy types.Application, tx []byte, key, value string) {
if r := dummy.DeliverTx(tx); r.IsErr() {
t.Fatal(r)
}
if r := dummy.DeliverTx(tx); r.IsErr() {
t.Fatal(r)
}
r := dummy.Query([]byte(key))
if r.IsErr() {
t.Fatal(r)
}
=======
tmspcli "github.com/tendermint/tmsp/client"
"github.com/tendermint/tmsp/server"
"github.com/tendermint/tmsp/types"
)
func testDummy(t *testing.T, app types.Application, tx []byte, key, value string) {
ar := app.AppendTx(tx)
require.False(t, ar.IsErr(), ar)
// repeating tx doesn't raise error
ar = app.AppendTx(tx)
require.False(t, ar.IsErr(), ar)
>>>>>>> Add tests for client-server proofs over socket and grpc
// make sure query is fine
r := app.Query([]byte(key))
require.False(t, r.IsErr(), r)
q := new(QueryResult)
err := wire.ReadJSONBytes(r.Data, q)
require.Nil(t, err)
require.Equal(t, value, q.Value)
// make sure proof is fine
rp := app.Proof([]byte(key), 0)
require.False(t, rp.IsErr(), rp)
p, err := merkle.LoadProof(rp.Data)
require.Nil(t, err)
require.True(t, p.Valid())
assert.Equal(t, []byte(key), p.Key())
assert.Equal(t, []byte(value), p.Value())
}
func TestDummyKV(t *testing.T) {
dummy := NewDummyApplication()
key := "abc"
value := key
tx := []byte(key)
testDummy(t, dummy, tx, key, value)
value = "def"
tx = []byte(key + "=" + value)
testDummy(t, dummy, tx, key, value)
}
func TestPersistentDummyKV(t *testing.T) {
dir, err := ioutil.TempDir("/tmp", "abci-dummy-test") // TODO
if err != nil {
t.Fatal(err)
}
dummy := NewPersistentDummyApplication(dir)
key := "abc"
value := key
tx := []byte(key)
testDummy(t, dummy, tx, key, value)
value = "def"
tx = []byte(key + "=" + value)
testDummy(t, dummy, tx, key, value)
}
func TestPersistentDummyInfo(t *testing.T) {
dir, err := ioutil.TempDir("/tmp", "abci-dummy-test") // TODO
if err != nil {
t.Fatal(err)
}
dummy := NewPersistentDummyApplication(dir)
height := uint64(0)
resInfo := dummy.Info()
if resInfo.LastBlockHeight != height {
t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
}
// make and apply block
height = uint64(1)
hash := []byte("foo")
header := &types.Header{
Height: uint64(height),
}
dummy.BeginBlock(hash, header)
dummy.EndBlock(height)
dummy.Commit()
resInfo = dummy.Info()
if resInfo.LastBlockHeight != height {
t.Fatalf("expected height of %d, got %d", height, resInfo.LastBlockHeight)
}
}
// add a validator, remove a validator, update a validator
func TestValSetChanges(t *testing.T) {
dir, err := ioutil.TempDir("/tmp", "abci-dummy-test") // TODO
if err != nil {
t.Fatal(err)
}
dummy := NewPersistentDummyApplication(dir)
// init with some validators
total := 10
nInit := 5
vals := make([]*types.Validator, total)
for i := 0; i < total; i++ {
pubkey := crypto.GenPrivKeyEd25519FromSecret([]byte(Fmt("test%d", i))).PubKey().Bytes()
power := RandInt()
vals[i] = &types.Validator{pubkey, uint64(power)}
}
// iniitalize with the first nInit
dummy.InitChain(vals[:nInit])
vals1, vals2 := vals[:nInit], dummy.Validators()
valsEqual(t, vals1, vals2)
var v1, v2, v3 *types.Validator
// add some validators
v1, v2 = vals[nInit], vals[nInit+1]
diff := []*types.Validator{v1, v2}
tx1 := MakeValSetChangeTx(v1.PubKey, v1.Power)
tx2 := MakeValSetChangeTx(v2.PubKey, v2.Power)
makeApplyBlock(t, dummy, 1, diff, tx1, tx2)
vals1, vals2 = vals[:nInit+2], dummy.Validators()
valsEqual(t, vals1, vals2)
// remove some validators
v1, v2, v3 = vals[nInit-2], vals[nInit-1], vals[nInit]
v1.Power = 0
v2.Power = 0
v3.Power = 0
diff = []*types.Validator{v1, v2, v3}
tx1 = MakeValSetChangeTx(v1.PubKey, v1.Power)
tx2 = MakeValSetChangeTx(v2.PubKey, v2.Power)
tx3 := MakeValSetChangeTx(v3.PubKey, v3.Power)
makeApplyBlock(t, dummy, 2, diff, tx1, tx2, tx3)
vals1 = append(vals[:nInit-2], vals[nInit+1])
vals2 = dummy.Validators()
valsEqual(t, vals1, vals2)
// update some validators
v1 = vals[0]
if v1.Power == 5 {
v1.Power = 6
} else {
v1.Power = 5
}
diff = []*types.Validator{v1}
tx1 = MakeValSetChangeTx(v1.PubKey, v1.Power)
makeApplyBlock(t, dummy, 3, diff, tx1)
vals1 = append([]*types.Validator{v1}, vals1[1:len(vals1)]...)
vals2 = dummy.Validators()
valsEqual(t, vals1, vals2)
}
func makeApplyBlock(t *testing.T, dummy types.Application, heightInt int, diff []*types.Validator, txs ...[]byte) {
// make and apply block
height := uint64(heightInt)
hash := []byte("foo")
header := &types.Header{
Height: height,
}
dummyChain := dummy.(types.BlockchainAware) // hmm...
dummyChain.BeginBlock(hash, header)
for _, tx := range txs {
if r := dummy.DeliverTx(tx); r.IsErr() {
t.Fatal(r)
}
}
resEndBlock := dummyChain.EndBlock(height)
dummy.Commit()
valsEqual(t, diff, resEndBlock.Diffs)
}
// order doesn't matter
func valsEqual(t *testing.T, vals1, vals2 []*types.Validator) {
if len(vals1) != len(vals2) {
t.Fatalf("vals dont match in len. got %d, expected %d", len(vals2), len(vals1))
}
sort.Sort(types.Validators(vals1))
sort.Sort(types.Validators(vals2))
for i, v1 := range vals1 {
v2 := vals2[i]
if !bytes.Equal(v1.PubKey, v2.PubKey) ||
v1.Power != v2.Power {
t.Fatalf("vals dont match at index %d. got %X/%d , expected %X/%d", i, v2.PubKey, v2.Power, v1.PubKey, v1.Power)
}
}
}
func makeSocketClientServer(app types.Application, name string) (tmspcli.Client, Service, error) {
// Start the listener
socket := Fmt("unix://%s.sock", name)
server, err := server.NewSocketServer(socket, app)
if err != nil {
return nil, nil, err
}
// Connect to the socket
client, err := tmspcli.NewSocketClient(socket, false)
if err != nil {
server.Stop()
return nil, nil, err
}
client.Start()
return client, server, err
}
func makeGRPCClientServer(app types.Application, name string) (tmspcli.Client, Service, error) {
// Start the listener
socket := Fmt("unix://%s.sock", name)
gapp := types.NewGRPCApplication(app)
server, err := server.NewGRPCServer(socket, gapp)
if err != nil {
return nil, nil, err
}
client, err := tmspcli.NewGRPCClient(socket, true)
if err != nil {
server.Stop()
return nil, nil, err
}
return client, server, err
}
func TestClientServer(t *testing.T) {
// set up socket app
dummy := NewDummyApplication()
client, server, err := makeSocketClientServer(dummy, "dummy-socket")
require.Nil(t, err)
defer server.Stop()
defer client.Stop()
runClientTests(t, client)
// set up grpc app
dummy = NewDummyApplication()
gclient, gserver, err := makeGRPCClientServer(dummy, "dummy-grpc")
require.Nil(t, err)
defer gserver.Stop()
defer gclient.Stop()
runClientTests(t, gclient)
}
func runClientTests(t *testing.T, client tmspcli.Client) {
// run some tests....
key := "abc"
value := key
tx := []byte(key)
testClient(t, client, tx, key, value)
value = "def"
tx = []byte(key + "=" + value)
testClient(t, client, tx, key, value)
}
func testClient(t *testing.T, app tmspcli.Client, tx []byte, key, value string) {
ar := app.AppendTxSync(tx)
require.False(t, ar.IsErr(), ar)
// repeating tx doesn't raise error
ar = app.AppendTxSync(tx)
require.False(t, ar.IsErr(), ar)
// make sure query is fine
r := app.QuerySync([]byte(key))
require.False(t, r.IsErr(), r)
q := new(QueryResult)
err := wire.ReadJSONBytes(r.Data, q)
require.Nil(t, err)
require.Equal(t, value, q.Value)
// make sure proof is fine
rp := app.ProofSync([]byte(key), 0)
require.False(t, rp.IsErr(), rp)
p, err := merkle.LoadProof(rp.Data)
require.Nil(t, err)
require.True(t, p.Valid())
assert.Equal(t, []byte(key), p.Key())
assert.Equal(t, []byte(value), p.Value())
}

View File

@ -90,8 +90,8 @@ func (app *PersistentDummyApplication) Commit() types.Result {
return types.NewResultOK(appHash, "") return types.NewResultOK(appHash, "")
} }
func (app *PersistentDummyApplication) Query(query []byte) types.Result { func (app *PersistentDummyApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {
return app.app.Query(query) return app.app.Query(reqQuery)
} }
// Save the validators in the merkle tree // Save the validators in the merkle tree

View File

@ -31,6 +31,6 @@ func (app *NilApplication) Commit() types.Result {
return types.NewResultOK([]byte("nil"), "") return types.NewResultOK([]byte("nil"), "")
} }
func (app *NilApplication) Query(query []byte) types.Result { func (app *NilApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {
return types.NewResultOK(nil, "") return resQuery
} }

17
glide.lock generated
View File

@ -19,6 +19,11 @@ imports:
version: d228849504861217f796da67fae4f6e347643f15 version: d228849504861217f796da67fae4f6e347643f15
- name: github.com/mattn/go-isatty - name: github.com/mattn/go-isatty
version: 30a891c33c7cde7b02a981314b4228ec99380cca version: 30a891c33c7cde7b02a981314b4228ec99380cca
- name: github.com/stretchr/testify
version: 69483b4bd14f5845b5a1e55bca19e954e827f1d0
subpackages:
- assert
- require
- name: github.com/syndtr/goleveldb - name: github.com/syndtr/goleveldb
version: 23851d93a2292dcc56e71a18ec9e0624d84a0f65 version: 23851d93a2292dcc56e71a18ec9e0624d84a0f65
subpackages: subpackages:
@ -48,7 +53,7 @@ imports:
- name: github.com/tendermint/go-logger - name: github.com/tendermint/go-logger
version: cefb3a45c0bf3c493a04e9bcd9b1540528be59f2 version: cefb3a45c0bf3c493a04e9bcd9b1540528be59f2
- name: github.com/tendermint/go-merkle - name: github.com/tendermint/go-merkle
version: 7a86b4486f2cd84ac885c5bbc609fdee2905f5d1 version: 653cb1f631528351ddbc359b994eb0c96f0341cd
- name: github.com/tendermint/go-process - name: github.com/tendermint/go-process
version: b27edfd189b1a01a0b099f7e9f8263589cf04909 version: b27edfd189b1a01a0b099f7e9f8263589cf04909
- name: github.com/tendermint/go-wire - name: github.com/tendermint/go-wire
@ -102,4 +107,12 @@ imports:
- stats - stats
- tap - tap
- transport - transport
testImports: [] testImports:
- name: github.com/davecgh/go-spew
version: 6d212800a42e8ab5c146b8ace3490ee17e5225f9
subpackages:
- spew
- name: github.com/pmezard/go-difflib
version: d8ed2627bdf02c080bf22230dbb337003b7aba2d
subpackages:
- difflib

View File

@ -15,3 +15,7 @@ import:
subpackages: subpackages:
- context - context
- package: google.golang.org/grpc - package: google.golang.org/grpc
- package: github.com/stretchr/testify
version: ^1.1.4
subpackages:
- require

View File

@ -184,8 +184,8 @@ func (s *SocketServer) handleRequest(req *types.Request, responses chan<- *types
res := s.app.Commit() res := s.app.Commit()
responses <- types.ToResponseCommit(res.Code, res.Data, res.Log) responses <- types.ToResponseCommit(res.Code, res.Data, res.Log)
case *types.Request_Query: case *types.Request_Query:
res := s.app.Query(r.Query.Query) resQuery := s.app.Query(*r.Query)
responses <- types.ToResponseQuery(res.Code, res.Data, res.Log) responses <- types.ToResponseQuery(resQuery)
case *types.Request_InitChain: case *types.Request_InitChain:
if app, ok := s.app.(types.BlockchainAware); ok { if app, ok := s.app.(types.BlockchainAware); ok {
app.InitChain(r.InitChain.Validators) app.InitChain(r.InitChain.Validators)

View File

@ -1,32 +1,38 @@
> echo hello > echo hello
-> data: hello -> data: hello
-> data.hex: 68656C6C6F
> info > info
-> data: {"size":0} -> data: {"size":0}
-> data.hex: 7B2273697A65223A307D
> commit > commit
-> data: 0x
> deliver_tx "abc" > deliver_tx "abc"
-> code: OK
> info > info
-> data: {"size":1} -> data: {"size":1}
-> data.hex: 7B2273697A65223A317D
> commit > commit
-> data: 0x750502FC7E84BBD788ED589624F06CFA871845D1 -> data: u<02>~<7E><>׈<EFBFBD>X<EFBFBD>$<24>l<EFBFBD><6C>E<>
-> data.hex: 750502FC7E84BBD788ED589624F06CFA871845D1
> query "abc" > query "abc"
-> code: OK -> value: abc
-> data: {"index":0,"value":"abc","valueHex":"616263","exists":true} -> value.hex: 616263
-> log: exists
-> height: 0
> deliver_tx "def=xyz" > deliver_tx "def=xyz"
-> code: OK
> commit > commit
-> data: 0x76393B8A182E450286B0694C629ECB51B286EFD5 -> data: v9;<3B>.E<02><>iLb<4C><62>Q<EFBFBD><51><EFBFBD><EFBFBD>
-> data.hex: 76393B8A182E450286B0694C629ECB51B286EFD5
> query "def" > query "def"
-> code: OK -> value: xyz
-> data: {"index":1,"value":"xyz","valueHex":"78797a","exists":true} -> value.hex: 78797A
-> log: exists
-> height: 0

View File

@ -1,21 +1,16 @@
> set_option serial on > set_option serial on
-> data: serial=on
> check_tx 0x00 > check_tx 0x00
-> code: OK
> check_tx 0xff > check_tx 0xff
-> code: OK
> deliver_tx 0x00 > deliver_tx 0x00
-> code: OK
> check_tx 0x00 > check_tx 0x00
-> code: BadNonce -> code: BadNonce
-> log: Invalid nonce. Expected >= 1, got 0 -> log: Invalid nonce. Expected >= 1, got 0
> deliver_tx 0x01 > deliver_tx 0x01
-> code: OK
> deliver_tx 0x04 > deliver_tx 0x04
-> code: BadNonce -> code: BadNonce
@ -23,4 +18,5 @@
> info > info
-> data: {"hashes":0,"txs":2} -> data: {"hashes":0,"txs":2}
-> data.hex: 7B22686173686573223A302C22747873223A327D

View File

@ -20,7 +20,7 @@ type Application interface {
CheckTx(tx []byte) Result CheckTx(tx []byte) Result
// Query for state // Query for state
Query(query []byte) Result Query(reqQuery RequestQuery) ResponseQuery
// Return the application Merkle root hash // Return the application Merkle root hash
Commit() Result Commit() Result
@ -78,8 +78,8 @@ func (app *GRPCApplication) CheckTx(ctx context.Context, req *RequestCheckTx) (*
} }
func (app *GRPCApplication) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) { func (app *GRPCApplication) Query(ctx context.Context, req *RequestQuery) (*ResponseQuery, error) {
r := app.app.Query(req.Query) resQuery := app.app.Query(*req)
return &ResponseQuery{r.Code, r.Data, r.Log}, nil return &resQuery, nil
} }
func (app *GRPCApplication) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) { func (app *GRPCApplication) Commit(ctx context.Context, req *RequestCommit) (*ResponseCommit, error) {

3
types/code.go Normal file
View File

@ -0,0 +1,3 @@
package types
func (c CodeType) IsOK() bool { return c == CodeType_OK }

View File

@ -49,9 +49,9 @@ func ToRequestCommit() *Request {
} }
} }
func ToRequestQuery(queryBytes []byte) *Request { func ToRequestQuery(reqQuery RequestQuery) *Request {
return &Request{ return &Request{
Value: &Request_Query{&RequestQuery{queryBytes}}, Value: &Request_Query{&reqQuery},
} }
} }
@ -123,9 +123,9 @@ func ToResponseCommit(code CodeType, data []byte, log string) *Response {
} }
} }
func ToResponseQuery(code CodeType, data []byte, log string) *Response { func ToResponseQuery(resQuery ResponseQuery) *Response {
return &Response{ return &Response{
Value: &Response_Query{&ResponseQuery{code, data, log}}, Value: &Response_Query{&resQuery},
} }
} }

View File

@ -716,7 +716,10 @@ func (m *RequestCheckTx) GetTx() []byte {
} }
type RequestQuery struct { type RequestQuery struct {
Query []byte `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"` Data []byte `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
Height uint64 `protobuf:"varint,3,opt,name=height" json:"height,omitempty"`
Prove bool `protobuf:"varint,4,opt,name=prove" json:"prove,omitempty"`
} }
func (m *RequestQuery) Reset() { *m = RequestQuery{} } func (m *RequestQuery) Reset() { *m = RequestQuery{} }
@ -724,13 +727,34 @@ func (m *RequestQuery) String() string { return proto.CompactTextStri
func (*RequestQuery) ProtoMessage() {} func (*RequestQuery) ProtoMessage() {}
func (*RequestQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } func (*RequestQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
func (m *RequestQuery) GetQuery() []byte { func (m *RequestQuery) GetData() []byte {
if m != nil { if m != nil {
return m.Query return m.Data
} }
return nil return nil
} }
func (m *RequestQuery) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func (m *RequestQuery) GetHeight() uint64 {
if m != nil {
return m.Height
}
return 0
}
func (m *RequestQuery) GetProve() bool {
if m != nil {
return m.Prove
}
return false
}
type RequestCommit struct { type RequestCommit struct {
} }
@ -1387,9 +1411,13 @@ func (m *ResponseCheckTx) GetLog() string {
} }
type ResponseQuery struct { type ResponseQuery struct {
Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"` Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"` Index int64 `protobuf:"varint,2,opt,name=index" json:"index,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"` Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
Proof []byte `protobuf:"bytes,5,opt,name=proof,proto3" json:"proof,omitempty"`
Height uint64 `protobuf:"varint,6,opt,name=height" json:"height,omitempty"`
Log string `protobuf:"bytes,7,opt,name=log" json:"log,omitempty"`
} }
func (m *ResponseQuery) Reset() { *m = ResponseQuery{} } func (m *ResponseQuery) Reset() { *m = ResponseQuery{} }
@ -1404,13 +1432,41 @@ func (m *ResponseQuery) GetCode() CodeType {
return CodeType_OK return CodeType_OK
} }
func (m *ResponseQuery) GetData() []byte { func (m *ResponseQuery) GetIndex() int64 {
if m != nil { if m != nil {
return m.Data return m.Index
}
return 0
}
func (m *ResponseQuery) GetKey() []byte {
if m != nil {
return m.Key
} }
return nil return nil
} }
func (m *ResponseQuery) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (m *ResponseQuery) GetProof() []byte {
if m != nil {
return m.Proof
}
return nil
}
func (m *ResponseQuery) GetHeight() uint64 {
if m != nil {
return m.Height
}
return 0
}
func (m *ResponseQuery) GetLog() string { func (m *ResponseQuery) GetLog() string {
if m != nil { if m != nil {
return m.Log return m.Log
@ -2073,108 +2129,112 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) } func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{ var fileDescriptor0 = []byte{
// 1642 bytes of a gzipped FileDescriptorProto // 1711 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0xc9, 0x6e, 0xdb, 0xdc, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x58, 0x4b, 0x6f, 0xe4, 0xc6,
0x15, 0x36, 0x35, 0xeb, 0xc8, 0x96, 0xae, 0x8f, 0x65, 0x5b, 0x56, 0xbb, 0x08, 0xd8, 0xa6, 0xb1, 0x11, 0x16, 0xe7, 0x3d, 0x35, 0xd2, 0xa8, 0x55, 0x1a, 0x49, 0xd4, 0x24, 0x87, 0x05, 0x03, 0xc7,
0xdd, 0x34, 0x29, 0x1c, 0xa4, 0x88, 0x9b, 0xa2, 0x80, 0xa7, 0xd8, 0x42, 0x90, 0xc4, 0x65, 0x86, 0xda, 0x8d, 0xb3, 0x1b, 0xc8, 0x70, 0xb0, 0x8a, 0x83, 0x00, 0xd2, 0xae, 0xbc, 0x1a, 0x18, 0xde,
0x45, 0x5b, 0x54, 0xa0, 0xc5, 0x2b, 0x89, 0x35, 0x45, 0x32, 0x1c, 0x1c, 0xbb, 0xcf, 0x90, 0x7d, 0x55, 0xe8, 0xb5, 0x2f, 0x09, 0x32, 0xa0, 0x86, 0x3d, 0x33, 0x8c, 0xa8, 0x26, 0x97, 0x6c, 0xca,
0x1f, 0xa1, 0x4f, 0xd0, 0xd5, 0xbf, 0xff, 0x81, 0x7f, 0x1e, 0x9e, 0xe8, 0xc7, 0x1d, 0x38, 0x9a, 0x52, 0x7e, 0x83, 0xef, 0xf9, 0x09, 0xb9, 0x07, 0xc8, 0x29, 0xf7, 0x00, 0x79, 0x3f, 0x7e, 0x51,
0xcc, 0x2a, 0x1b, 0x81, 0x67, 0xbc, 0xd3, 0x77, 0xbe, 0x7b, 0xae, 0x60, 0x35, 0xb8, 0x71, 0xa9, 0xd0, 0x0f, 0x3e, 0x45, 0x1a, 0x3e, 0xf8, 0x32, 0x60, 0x3d, 0xbb, 0xab, 0xba, 0xea, 0xeb, 0xea,
0xff, 0x90, 0xff, 0x3e, 0x70, 0x3d, 0x27, 0x70, 0xb0, 0xce, 0x05, 0xf5, 0xcb, 0x1a, 0x34, 0x35, 0x81, 0x1d, 0x7e, 0x1f, 0xd2, 0xf8, 0x99, 0xfc, 0x7d, 0x1a, 0x46, 0x01, 0x0f, 0xb0, 0x2b, 0x09,
0xfa, 0x3e, 0xa4, 0x7e, 0x80, 0xdb, 0x50, 0xa3, 0x93, 0xb9, 0x33, 0x50, 0xee, 0x28, 0xdb, 0x9d, 0xeb, 0x2f, 0x1d, 0xe8, 0xdb, 0xf4, 0x5d, 0x42, 0x63, 0x8e, 0x47, 0xd0, 0xa1, 0x8b, 0x75, 0x60,
0x3d, 0x7c, 0x20, 0xdc, 0xa5, 0xf5, 0x64, 0x32, 0x77, 0xce, 0x96, 0x34, 0xee, 0x81, 0xbf, 0x87, 0x1a, 0x8f, 0x8c, 0xa3, 0xd1, 0x31, 0x3e, 0x55, 0xea, 0x5a, 0x7a, 0xbe, 0x58, 0x07, 0x17, 0x1b,
0xfa, 0xd4, 0x0a, 0xfd, 0xf9, 0xa0, 0xc2, 0x5d, 0xd7, 0xb2, 0xae, 0xcf, 0x98, 0xe9, 0x6c, 0x49, 0xb6, 0xd4, 0xc0, 0x1f, 0x41, 0x77, 0xe9, 0x27, 0xf1, 0xda, 0x6c, 0x49, 0xd5, 0xdd, 0xb2, 0xea,
0x13, 0x3e, 0x2c, 0xad, 0x69, 0x4f, 0x9d, 0x41, 0xb5, 0x28, 0xed, 0xc8, 0x9e, 0xf2, 0xb4, 0xcc, 0x27, 0x42, 0x74, 0xb1, 0x61, 0x2b, 0x1d, 0xe1, 0xd6, 0x63, 0xcb, 0xc0, 0x6c, 0xd7, 0xb9, 0x9d,
0x03, 0x9f, 0x00, 0xf8, 0x34, 0x18, 0x3b, 0x6e, 0x60, 0x3a, 0xf6, 0xa0, 0xc6, 0xfd, 0x37, 0xb3, 0xb1, 0xa5, 0x74, 0x2b, 0x34, 0xf0, 0x39, 0x40, 0x4c, 0xf9, 0x3c, 0x08, 0xb9, 0x17, 0x30, 0xb3,
0xfe, 0xaf, 0x69, 0xf0, 0x8a, 0x9b, 0xcf, 0x96, 0xb4, 0xb6, 0x1f, 0x09, 0x2c, 0xd2, 0xa0, 0x96, 0x23, 0xf5, 0x0f, 0xca, 0xfa, 0x9f, 0x53, 0xfe, 0x46, 0x8a, 0x2f, 0x36, 0xec, 0x61, 0x9c, 0x12,
0x79, 0x45, 0xbd, 0x71, 0x70, 0x3d, 0xa8, 0x17, 0x45, 0x1e, 0x0b, 0xfb, 0x9b, 0x6b, 0x16, 0x69, 0xc2, 0xd2, 0xa5, 0xbe, 0x77, 0x4b, 0xa3, 0x39, 0xbf, 0x33, 0xbb, 0x75, 0x96, 0x2f, 0x95, 0xfc,
0x44, 0x02, 0xee, 0x41, 0x6b, 0x32, 0xa7, 0x93, 0x4b, 0x16, 0xd7, 0xe0, 0x71, 0xeb, 0xd9, 0xb8, 0xed, 0x9d, 0xb0, 0x74, 0x53, 0x02, 0x8f, 0x61, 0xb0, 0x58, 0xd3, 0xc5, 0xb5, 0xb0, 0xeb, 0x49,
0x23, 0x66, 0xe5, 0x51, 0xcd, 0x89, 0xf8, 0xc4, 0x07, 0xd0, 0x98, 0x38, 0x8b, 0x85, 0x19, 0x0c, 0xbb, 0xbd, 0xb2, 0xdd, 0x0b, 0x21, 0x95, 0x56, 0xfd, 0x85, 0xfa, 0xc4, 0xa7, 0xd0, 0x5b, 0x04,
0x9a, 0x3c, 0xa2, 0x9f, 0x8b, 0xe0, 0xb6, 0xb3, 0x25, 0x4d, 0x7a, 0xb1, 0xed, 0x7a, 0x1f, 0x52, 0x37, 0x37, 0x1e, 0x37, 0xfb, 0xd2, 0x62, 0x52, 0xb1, 0x90, 0xb2, 0x8b, 0x0d, 0x5b, 0x6b, 0x89,
0xef, 0x66, 0xd0, 0x2a, 0xda, 0xae, 0xbf, 0x31, 0x13, 0xdb, 0x2e, 0xee, 0xc3, 0x96, 0x62, 0xda, 0x74, 0xbd, 0x4b, 0x68, 0x74, 0x6f, 0x0e, 0xea, 0xd2, 0xf5, 0x4b, 0x21, 0x12, 0xe9, 0x92, 0x3a,
0x66, 0x30, 0x9e, 0xcc, 0x75, 0xd3, 0x1e, 0xb4, 0x8b, 0x96, 0x32, 0xb2, 0xcd, 0xe0, 0x88, 0x99, 0x22, 0x14, 0x8f, 0x79, 0x7c, 0xbe, 0x58, 0x3b, 0x1e, 0x33, 0x87, 0x75, 0xa1, 0xcc, 0x98, 0xc7,
0xd9, 0x52, 0xcc, 0x48, 0xc0, 0xa7, 0xd0, 0xb9, 0xa0, 0x33, 0xd3, 0x1e, 0x5f, 0x58, 0xce, 0xe4, 0x5f, 0x08, 0xb1, 0x08, 0xc5, 0x4b, 0x09, 0xfc, 0x18, 0x46, 0x57, 0x74, 0xe5, 0xb1, 0xf9, 0x95,
0x72, 0x00, 0x3c, 0x74, 0x90, 0x0d, 0x3d, 0x64, 0x0e, 0x87, 0xcc, 0x7e, 0xb6, 0xa4, 0xc1, 0x45, 0x1f, 0x2c, 0xae, 0x4d, 0x90, 0xa6, 0x66, 0xd9, 0xf4, 0x4c, 0x28, 0x9c, 0x09, 0xf9, 0xc5, 0x86,
0x2c, 0xe1, 0x63, 0x68, 0x53, 0xdb, 0x90, 0xa1, 0x1d, 0x1e, 0xba, 0x91, 0x43, 0x80, 0x6d, 0x44, 0x0d, 0x57, 0x19, 0x85, 0x1f, 0xc1, 0x90, 0x32, 0x57, 0x9b, 0x8e, 0xa4, 0xe9, 0x7e, 0xa5, 0x02,
0x81, 0x2d, 0x2a, 0xbf, 0x0f, 0x9b, 0x50, 0xbf, 0xd2, 0xad, 0x90, 0xaa, 0xf7, 0xa0, 0x93, 0x42, 0x98, 0x9b, 0x1a, 0x0e, 0xa8, 0xfe, 0x3e, 0xeb, 0x43, 0xf7, 0xd6, 0xf1, 0x13, 0x6a, 0xbd, 0x0f,
0x0a, 0x0e, 0xa0, 0xb9, 0xa0, 0xbe, 0xaf, 0xcf, 0x28, 0x87, 0x53, 0x5b, 0x8b, 0x44, 0xb5, 0x0b, 0xa3, 0x42, 0xa5, 0xa0, 0x09, 0xfd, 0x1b, 0x1a, 0xc7, 0xce, 0x8a, 0xca, 0x72, 0x1a, 0xda, 0x29,
0xcb, 0x69, 0x9c, 0xa8, 0x2b, 0x71, 0x20, 0xc3, 0x82, 0xfa, 0x67, 0x20, 0xf9, 0xa3, 0x46, 0x02, 0x69, 0x8d, 0x61, 0xb3, 0x58, 0x27, 0xd6, 0x56, 0x66, 0x28, 0x6a, 0xc1, 0xfa, 0x19, 0x90, 0xea,
0xd5, 0x4b, 0x7a, 0x23, 0x13, 0xb1, 0x4f, 0xec, 0xcb, 0x61, 0x39, 0x00, 0xdb, 0x9a, 0x9c, 0x83, 0x51, 0x23, 0x81, 0xf6, 0x35, 0xbd, 0xd7, 0x8e, 0xc4, 0x27, 0x4e, 0xf4, 0xb2, 0xb2, 0x00, 0x87,
0x1a, 0xc7, 0xc6, 0x87, 0x8d, 0x5d, 0xa8, 0x04, 0xd7, 0x3c, 0x74, 0x59, 0xab, 0x04, 0xd7, 0xea, 0xb6, 0xde, 0x83, 0x95, 0xd9, 0x66, 0x87, 0x8d, 0x63, 0x68, 0xf1, 0x3b, 0x69, 0xba, 0x69, 0xb7,
0x1d, 0xe8, 0x66, 0x0f, 0xf6, 0x96, 0xc7, 0x6f, 0xe3, 0x09, 0xf2, 0x93, 0x61, 0x63, 0x89, 0xd3, 0xf8, 0x9d, 0xf5, 0x08, 0xc6, 0xe5, 0x83, 0x7d, 0xa0, 0xe1, 0x66, 0x1b, 0x94, 0x27, 0x83, 0x08,
0x13, 0x2e, 0x42, 0x50, 0x7b, 0xb0, 0x92, 0x39, 0x6e, 0xf5, 0x38, 0x1e, 0x3c, 0x3e, 0x1e, 0xfc, 0x1d, 0xd7, 0xe1, 0x8e, 0xd6, 0x90, 0xdf, 0x82, 0x17, 0x3a, 0x7c, 0xad, 0x97, 0x97, 0xdf, 0xb8,
0x23, 0xc0, 0x95, 0x6e, 0x99, 0x86, 0x1e, 0x38, 0x9e, 0x3f, 0x50, 0xee, 0x54, 0xb7, 0x3b, 0x7b, 0x0f, 0xbd, 0x35, 0xf5, 0x56, 0x6b, 0x2e, 0x2b, 0xbd, 0x63, 0x6b, 0x4a, 0xec, 0x35, 0x8c, 0x82,
0x44, 0xee, 0xea, 0xbb, 0xc8, 0xa0, 0xa5, 0x7c, 0xd4, 0x97, 0xb0, 0x7a, 0xeb, 0xa4, 0x10, 0xa1, 0x5b, 0x2a, 0x0b, 0x7a, 0x60, 0x2b, 0xc2, 0xda, 0x86, 0xad, 0x52, 0xb9, 0x58, 0x2f, 0xb3, 0xcd,
0x36, 0xd7, 0xfd, 0xb9, 0x9c, 0x00, 0xff, 0xc6, 0xbb, 0xd0, 0x98, 0x53, 0xdd, 0xa0, 0x9e, 0xac, 0x67, 0xc7, 0x8b, 0x3f, 0x01, 0xb8, 0x75, 0x7c, 0xcf, 0x75, 0x78, 0x10, 0xc5, 0xa6, 0xf1, 0xa8,
0xc1, 0x15, 0x99, 0xf6, 0x8c, 0x2b, 0x35, 0x69, 0x54, 0x77, 0xa0, 0x97, 0x3b, 0x3e, 0xdc, 0x60, 0x7d, 0x34, 0x3a, 0x26, 0xfa, 0x54, 0xbe, 0x4c, 0x05, 0x76, 0x41, 0xc7, 0x7a, 0x0d, 0x3b, 0x0f,
0x91, 0xe6, 0x6c, 0x1e, 0xf0, 0x7c, 0x35, 0x4d, 0x4a, 0xea, 0xc7, 0x3a, 0xb4, 0x34, 0xea, 0xbb, 0x4e, 0x5a, 0xec, 0x76, 0xed, 0xc4, 0xeb, 0x34, 0x02, 0xf1, 0x8d, 0xef, 0x89, 0xdd, 0x3a, 0x2e,
0x8e, 0xed, 0x53, 0x7c, 0x02, 0x6d, 0x7a, 0x3d, 0xa1, 0xa2, 0x12, 0x95, 0x1c, 0x92, 0x84, 0xcf, 0x8d, 0x74, 0x0f, 0x6f, 0x69, 0xb7, 0x17, 0x92, 0x69, 0x6b, 0xa1, 0xf5, 0x18, 0xb6, 0x2b, 0xc7,
0x49, 0x64, 0x67, 0x28, 0x8c, 0x9d, 0x71, 0x47, 0xb2, 0x48, 0x9e, 0x1a, 0x64, 0x50, 0x9a, 0x46, 0x5f, 0x88, 0xd3, 0x28, 0xc6, 0x69, 0x7d, 0xdd, 0x85, 0x81, 0x4d, 0xe3, 0x30, 0x60, 0x31, 0xc5,
0xee, 0x47, 0x34, 0x52, 0xcd, 0x95, 0x91, 0xf0, 0xcd, 0xf1, 0xc8, 0x8e, 0xe4, 0x91, 0x5a, 0x61, 0xe7, 0x30, 0xa4, 0x77, 0x0b, 0xaa, 0x3a, 0xd9, 0xa8, 0x54, 0xa2, 0xd2, 0x39, 0x4f, 0xe5, 0xa2,
0xe2, 0x0c, 0x91, 0xec, 0x67, 0x88, 0xa4, 0x5e, 0x38, 0xfd, 0x12, 0x26, 0xd9, 0xcf, 0x30, 0x49, 0x8a, 0x33, 0x65, 0x7c, 0xac, 0x51, 0xa8, 0x0a, 0x2d, 0xda, 0xa8, 0x08, 0x43, 0x1f, 0xa4, 0x30,
0xa3, 0x30, 0xb4, 0x84, 0x4a, 0x1e, 0xa5, 0xa8, 0xa4, 0x99, 0xab, 0x20, 0x11, 0x58, 0xc0, 0x25, 0xd4, 0xae, 0xb4, 0xa1, 0xd2, 0xad, 0xe0, 0xd0, 0x63, 0x8d, 0x43, 0x9d, 0x5a, 0xc7, 0x25, 0x20,
0x0f, 0x63, 0x2e, 0x69, 0xe5, 0xd8, 0x47, 0x86, 0xe4, 0xc9, 0xe4, 0x7e, 0x04, 0xc7, 0x76, 0xe1, 0x3a, 0x29, 0x01, 0x51, 0xb7, 0x76, 0xfb, 0x0d, 0x48, 0x74, 0x52, 0x42, 0xa2, 0x5e, 0xad, 0x69,
0xa6, 0xe5, 0xd8, 0x64, 0x3f, 0xc3, 0x26, 0x50, 0xb8, 0x9c, 0x12, 0x3a, 0xf9, 0x4b, 0x96, 0x4e, 0x03, 0x14, 0x7d, 0x58, 0x80, 0xa2, 0x7e, 0xa5, 0x03, 0x95, 0x61, 0x0d, 0x16, 0x3d, 0xcb, 0xb0,
0x04, 0x27, 0x6c, 0xe5, 0x62, 0x4b, 0xf9, 0xe4, 0x4f, 0x69, 0x3e, 0x59, 0xce, 0xb1, 0x98, 0xc4, 0x68, 0x50, 0x41, 0x2f, 0x6d, 0x52, 0x05, 0xa3, 0x0f, 0x52, 0x30, 0x1a, 0xd6, 0x26, 0xad, 0x82,
0xc2, 0x27, 0x09, 0x65, 0x87, 0x55, 0x42, 0x0e, 0x69, 0xac, 0x16, 0xa9, 0xe7, 0x39, 0x9e, 0xe4, 0x46, 0x27, 0x25, 0x34, 0x82, 0xda, 0x70, 0x1a, 0xe0, 0xe8, 0xe7, 0x65, 0x38, 0x52, 0x98, 0x72,
0x02, 0x21, 0xa8, 0xdb, 0xac, 0x62, 0x13, 0x7c, 0x7d, 0x82, 0x7c, 0x78, 0xd5, 0xa6, 0xd0, 0xa5, 0x58, 0xb1, 0x6d, 0xc4, 0xa3, 0x9f, 0x16, 0xf1, 0x68, 0xb3, 0x82, 0x82, 0xba, 0x16, 0xbe, 0x11,
0xfe, 0x57, 0x49, 0x62, 0x19, 0x84, 0x58, 0xad, 0x19, 0x7a, 0xa0, 0xcb, 0x40, 0xfe, 0xcd, 0xf2, 0x90, 0x1e, 0x8b, 0x4e, 0xa8, 0x54, 0x9a, 0xe8, 0x45, 0x1a, 0x45, 0x41, 0xa4, 0xb1, 0x44, 0x11,
0x5d, 0x51, 0xcf, 0x67, 0x58, 0x12, 0x7c, 0x13, 0x89, 0xb8, 0x0b, 0xab, 0x96, 0xee, 0x07, 0x62, 0xd6, 0x91, 0xe8, 0xf8, 0xbc, 0xbe, 0xbe, 0x01, 0xbc, 0x64, 0xd7, 0x16, 0xaa, 0xcb, 0xfa, 0xbd,
0x99, 0x63, 0x59, 0x56, 0x55, 0x5e, 0x56, 0x3d, 0x66, 0x10, 0xeb, 0xe3, 0x6a, 0xfc, 0x03, 0xac, 0x91, 0xdb, 0x8a, 0x12, 0x2a, 0xa1, 0xc5, 0x50, 0xa3, 0x85, 0x09, 0xfd, 0x5b, 0x1a, 0xc5, 0xa2,
0xa5, 0x7c, 0x75, 0xd7, 0x1d, 0xf3, 0xa2, 0xae, 0xf1, 0xa2, 0x26, 0xb1, 0xf7, 0x81, 0xeb, 0x9e, 0x96, 0x14, 0x60, 0xa4, 0x24, 0x3e, 0x81, 0x1d, 0xdf, 0x89, 0xb9, 0x0a, 0x73, 0x5e, 0x82, 0x8f,
0xe9, 0xfe, 0x5c, 0xbd, 0x9b, 0xac, 0x3f, 0xc3, 0x84, 0x96, 0x33, 0x8b, 0x98, 0xd0, 0x72, 0x66, 0x6d, 0x21, 0x50, 0xf1, 0x29, 0x1c, 0xf9, 0x31, 0xec, 0x16, 0x74, 0x9d, 0x30, 0x9c, 0xcb, 0xa6,
0xea, 0xbf, 0x12, 0xb7, 0x84, 0xf4, 0x7e, 0x03, 0xb5, 0x89, 0x63, 0x88, 0xd5, 0x77, 0xf7, 0x7a, 0xee, 0xc8, 0xa6, 0x26, 0x99, 0xf6, 0x69, 0x18, 0x5e, 0x38, 0xf1, 0xda, 0x7a, 0x2f, 0x8f, 0xbf,
0x72, 0xdf, 0x8f, 0x1c, 0x83, 0xbe, 0xb9, 0x71, 0xa9, 0xc6, 0x8d, 0xf1, 0x4a, 0x2b, 0x82, 0x55, 0x84, 0xa4, 0x7e, 0xb0, 0x4a, 0x91, 0xd4, 0x0f, 0x56, 0xd6, 0x6f, 0x72, 0xb5, 0x1c, 0x34, 0x7f,
0xf8, 0x4a, 0x65, 0xfe, 0x6a, 0x92, 0xff, 0x9f, 0x8c, 0x40, 0x32, 0xe8, 0xfd, 0x9c, 0xd9, 0xff, 0x00, 0x9d, 0x45, 0xe0, 0xaa, 0xe8, 0xc7, 0xc7, 0xdb, 0x3a, 0xef, 0x2f, 0x02, 0x97, 0xbe, 0xbd,
0x9e, 0x9c, 0x87, 0x20, 0xdb, 0xcf, 0x98, 0xfb, 0x1f, 0x8c, 0xe9, 0xd3, 0x45, 0xf4, 0x39, 0x93, 0x0f, 0xa9, 0x2d, 0x85, 0x59, 0xa4, 0xad, 0x02, 0x2e, 0x6a, 0xff, 0xed, 0xdc, 0xff, 0xaf, 0x05,
0xaf, 0x25, 0xdb, 0x1e, 0x97, 0x8f, 0xda, 0x07, 0xbc, 0x5d, 0x17, 0xe2, 0x46, 0xcb, 0x22, 0x1e, 0x80, 0x94, 0xaa, 0xf7, 0xbb, 0xf4, 0xfe, 0x47, 0x23, 0x3f, 0x10, 0x85, 0xd6, 0xdf, 0xca, 0xf9,
0x7f, 0x07, 0x75, 0xc3, 0x9c, 0x4e, 0xfd, 0x41, 0xad, 0xe4, 0x4e, 0x10, 0x66, 0xf5, 0x7f, 0x15, 0x04, 0xba, 0x1e, 0x73, 0xe9, 0x9d, 0xf4, 0xde, 0xb6, 0x15, 0x91, 0x5e, 0x33, 0x6d, 0xb9, 0x62,
0x68, 0x08, 0x46, 0xc7, 0x2d, 0xc6, 0x2e, 0xba, 0x69, 0x8f, 0x4d, 0x23, 0x42, 0x35, 0x97, 0x47, 0xf9, 0x9a, 0x51, 0x49, 0x56, 0x84, 0x06, 0xf4, 0x60, 0x29, 0x81, 0x61, 0xd3, 0x56, 0x44, 0x01,
0x46, 0x8a, 0xd1, 0x2b, 0x69, 0x46, 0x67, 0x4b, 0x09, 0xcc, 0x05, 0x95, 0x80, 0xe4, 0xdf, 0xb8, 0x16, 0x7b, 0x25, 0xf8, 0xd7, 0x9b, 0xee, 0xe7, 0x9b, 0xfe, 0x95, 0xb8, 0x82, 0x8a, 0xdd, 0xf9,
0x09, 0x4d, 0x3b, 0x5c, 0x8c, 0x83, 0x6b, 0x9f, 0x23, 0xaf, 0xa6, 0x35, 0xec, 0x70, 0xf1, 0xe6, 0x5d, 0x66, 0x64, 0x37, 0x3f, 0xcf, 0xac, 0x2f, 0xad, 0x09, 0xe0, 0xc3, 0x86, 0x53, 0x57, 0x6d,
0xda, 0xc7, 0x3d, 0x58, 0x49, 0xc1, 0xd3, 0x34, 0x24, 0x6d, 0x76, 0xe5, 0xd4, 0xf8, 0xbc, 0x47, 0xb9, 0x95, 0xf0, 0x87, 0xd0, 0x75, 0xbd, 0xe5, 0x32, 0x36, 0x3b, 0x0d, 0x97, 0x8d, 0x12, 0x5b,
0xc7, 0x5a, 0x27, 0x06, 0xea, 0xc8, 0xc0, 0x6d, 0xe0, 0xb8, 0x1d, 0x0b, 0x6a, 0x12, 0x78, 0x6e, 0x7f, 0x68, 0x41, 0x4f, 0x5d, 0x15, 0x78, 0x28, 0x60, 0xcb, 0xf1, 0xd8, 0xdc, 0x73, 0xd3, 0x76,
0xf0, 0x7d, 0xeb, 0x32, 0xbd, 0xe4, 0x2e, 0x76, 0x5d, 0xfd, 0x0a, 0xda, 0x6c, 0x27, 0x85, 0x4b, 0x91, 0xf4, 0xcc, 0x2d, 0xe4, 0xa4, 0x55, 0xca, 0x09, 0x42, 0x87, 0x7b, 0x37, 0x54, 0x57, 0xba,
0x93, 0xbb, 0xb4, 0x98, 0x82, 0x1b, 0xef, 0x41, 0x2f, 0xb9, 0x02, 0x85, 0x4b, 0x4b, 0x64, 0x49, 0xfc, 0xc6, 0x03, 0xe8, 0xb3, 0xe4, 0x66, 0xce, 0xef, 0x62, 0x99, 0xed, 0x8e, 0xdd, 0x63, 0xc9,
0xd4, 0xdc, 0x71, 0x0b, 0x5a, 0x71, 0xdd, 0xb4, 0xb9, 0x47, 0x53, 0x97, 0xe5, 0x32, 0x82, 0xa6, 0xcd, 0xdb, 0xbb, 0x18, 0x8f, 0x61, 0xab, 0x50, 0xf7, 0x9e, 0xab, 0xf1, 0x78, 0xac, 0xb7, 0x26,
0x9c, 0x62, 0xe1, 0x75, 0xb9, 0x0b, 0x75, 0x57, 0xf7, 0x02, 0x5f, 0x5e, 0x4b, 0x11, 0x6b, 0x9e, 0xf7, 0x3d, 0x7b, 0x69, 0x8f, 0xb2, 0x0e, 0x98, 0xb9, 0x78, 0x04, 0xb2, 0x21, 0xe6, 0x0a, 0xf3,
0xeb, 0x1e, 0xeb, 0x33, 0xe4, 0xa5, 0x29, 0x5c, 0xd4, 0x7d, 0x58, 0xc9, 0xe8, 0x19, 0xeb, 0x04, 0x54, 0xa3, 0xf4, 0x64, 0xde, 0xc6, 0x82, 0xaf, 0x41, 0x51, 0xdc, 0x83, 0xdf, 0x83, 0xa1, 0xc8,
0x4e, 0xa0, 0x5b, 0xf2, 0xc2, 0x14, 0x42, 0x3c, 0x4c, 0x25, 0x19, 0x46, 0xdd, 0x87, 0x76, 0x7c, 0xa4, 0x52, 0xe9, 0x4b, 0x95, 0x81, 0x60, 0x48, 0xe1, 0xfb, 0xb0, 0x9d, 0xdf, 0xad, 0x4a, 0x65,
0x86, 0xec, 0x58, 0xdc, 0xf0, 0xe2, 0x39, 0x8d, 0x3a, 0x07, 0x29, 0xb1, 0x74, 0xae, 0xf3, 0x41, 0xa0, 0xbc, 0xe4, 0x6c, 0xa9, 0x78, 0x08, 0x83, 0xac, 0x21, 0x87, 0x52, 0xa3, 0xef, 0xe8, 0x3e,
0xde, 0xdc, 0x35, 0x4d, 0x08, 0xbb, 0x5f, 0x28, 0xd0, 0x79, 0x21, 0x68, 0x8a, 0xa1, 0x11, 0x7b, 0x9c, 0x41, 0x5f, 0x6f, 0xb1, 0xf6, 0x1e, 0x7e, 0x02, 0xdd, 0xd0, 0x89, 0x78, 0xac, 0xef, 0xbb,
0xd0, 0x79, 0x19, 0x5a, 0x96, 0x54, 0x91, 0x25, 0x6c, 0x41, 0x8d, 0xb1, 0x1b, 0x51, 0xb0, 0x0d, 0x14, 0x8e, 0x2f, 0x9d, 0x48, 0x0c, 0x40, 0xfa, 0x36, 0x56, 0x2a, 0xd6, 0x09, 0x6c, 0x95, 0xf8,
0x75, 0xce, 0x5e, 0xa4, 0xc2, 0x94, 0x8c, 0xb6, 0x48, 0x15, 0x57, 0xa0, 0x1d, 0xf3, 0x04, 0xa9, 0xa2, 0x12, 0x79, 0xc0, 0x1d, 0x5f, 0xdf, 0xc4, 0x8a, 0xc8, 0x96, 0x69, 0xe5, 0xcb, 0x58, 0x27,
0x31, 0x31, 0xa6, 0x4d, 0x52, 0x67, 0x62, 0x4c, 0x0f, 0x64, 0x15, 0x3b, 0xd0, 0x94, 0xd5, 0x4c, 0x30, 0xcc, 0xce, 0x50, 0x1c, 0x4b, 0x98, 0x5c, 0x7d, 0xaa, 0x47, 0xaa, 0x4d, 0x5b, 0x53, 0xb2,
0x10, 0x01, 0x1a, 0xe2, 0xa4, 0xc8, 0x1a, 0x4b, 0xcd, 0x0b, 0x91, 0xf4, 0x59, 0x48, 0x0c, 0x6d, 0xb0, 0x83, 0xaf, 0xf4, 0x48, 0xd0, 0xb1, 0x15, 0xf1, 0xe4, 0xcf, 0x06, 0x8c, 0x3e, 0x53, 0xf8,
0xb2, 0x8e, 0x5d, 0x80, 0x04, 0xd4, 0x64, 0x03, 0x97, 0xa1, 0x15, 0xc1, 0x99, 0x6c, 0xee, 0xfe, 0x27, 0xaa, 0x11, 0xb7, 0x61, 0xf4, 0x3a, 0xf1, 0x7d, 0xcd, 0x22, 0x1b, 0x38, 0x80, 0x8e, 0x80,
0xbf, 0x0e, 0xad, 0xa8, 0x90, 0xb0, 0x01, 0x95, 0x57, 0xcf, 0xc9, 0x12, 0xae, 0xc2, 0xca, 0xc8, 0x4d, 0x62, 0xe0, 0x10, 0xba, 0x12, 0x16, 0x49, 0x4b, 0x30, 0x05, 0x1e, 0x92, 0x36, 0x6e, 0xc1,
0x0e, 0xa8, 0x67, 0xeb, 0xd6, 0x09, 0x23, 0x6a, 0xa2, 0x30, 0xd5, 0x89, 0x3d, 0x71, 0x0c, 0xd3, 0x30, 0x03, 0x20, 0xd2, 0x11, 0x64, 0x86, 0xc7, 0xa4, 0x2b, 0xc8, 0x0c, 0x77, 0xc8, 0x0e, 0x8e,
0x9e, 0x09, 0x55, 0x85, 0x25, 0x3a, 0xd4, 0x8d, 0x97, 0x8e, 0x3d, 0xa1, 0xa4, 0x8a, 0x04, 0x96, 0xa0, 0xaf, 0x61, 0x82, 0x20, 0x02, 0xf4, 0xd4, 0x49, 0x91, 0x5d, 0xe1, 0x5a, 0x36, 0x38, 0x99,
0xdf, 0xda, 0x7a, 0x18, 0xcc, 0x1d, 0xcf, 0xfc, 0x0f, 0x35, 0x48, 0x0d, 0xd7, 0x61, 0x75, 0x64, 0x08, 0x93, 0xac, 0xb4, 0xc9, 0x1e, 0x8e, 0x01, 0xf2, 0xa2, 0x26, 0xfb, 0xb8, 0x09, 0x83, 0xb4,
0xfb, 0xe1, 0x74, 0x6a, 0x4e, 0x4c, 0x6a, 0x07, 0xcf, 0x42, 0xdb, 0xf0, 0x49, 0x1d, 0x11, 0xba, 0x9c, 0xc9, 0xc1, 0x93, 0x3f, 0x75, 0x61, 0x90, 0x36, 0x12, 0xf6, 0xa0, 0xf5, 0xe6, 0x53, 0xb2,
0x6f, 0xed, 0x4b, 0xdb, 0xf9, 0x60, 0xcb, 0x06, 0x87, 0x34, 0x70, 0x00, 0xfd, 0x43, 0xdd, 0xa7, 0x81, 0x3b, 0xb0, 0x35, 0x63, 0x9c, 0x46, 0xcc, 0xf1, 0xcf, 0xc5, 0x0d, 0x40, 0x0c, 0xc1, 0x3a,
0xc7, 0xa1, 0x6b, 0x99, 0x13, 0x3d, 0xa0, 0x07, 0x86, 0xe1, 0x51, 0xdf, 0x27, 0x94, 0x25, 0x61, 0x67, 0x8b, 0xc0, 0xf5, 0xd8, 0x4a, 0xb1, 0x5a, 0xc2, 0xd1, 0x99, 0xe3, 0xbe, 0x0e, 0xd8, 0x82,
0x96, 0xec, 0xd8, 0xd3, 0x28, 0x20, 0x93, 0x9f, 0x52, 0x9f, 0xcc, 0x70, 0x0b, 0xd6, 0x6f, 0x59, 0x92, 0x36, 0x12, 0xd8, 0xfc, 0x82, 0x39, 0x09, 0x5f, 0x07, 0x91, 0xf7, 0x3b, 0xea, 0x92, 0x0e,
0xf8, 0xc8, 0x73, 0xfc, 0x35, 0x0c, 0xf2, 0xa6, 0x53, 0xdd, 0x3f, 0xf7, 0xcc, 0x09, 0x25, 0x26, 0xee, 0xc1, 0xce, 0x8c, 0xc5, 0xc9, 0x72, 0xe9, 0x2d, 0x3c, 0xca, 0xf8, 0x27, 0x09, 0x73, 0x63,
0xf6, 0x81, 0x08, 0x2b, 0xc7, 0xee, 0xc8, 0x76, 0xc3, 0x80, 0xfc, 0x3b, 0x1a, 0x5f, 0x6a, 0x5f, 0xd2, 0x45, 0x84, 0xf1, 0x17, 0xec, 0x9a, 0x05, 0x5f, 0x31, 0x3d, 0x39, 0x91, 0x1e, 0x9a, 0x30,
0x85, 0x01, 0x53, 0x5f, 0xe6, 0xd4, 0xe7, 0x1c, 0x1f, 0xc4, 0xc2, 0x4d, 0x58, 0x4b, 0xa9, 0x5f, 0x39, 0x73, 0x62, 0xfa, 0x32, 0x09, 0x7d, 0x6f, 0xe1, 0x70, 0x7a, 0xea, 0xba, 0x11, 0x8d, 0x63,
0xb3, 0xf5, 0xb1, 0xdd, 0x59, 0x24, 0xf3, 0x15, 0x06, 0x73, 0x66, 0xeb, 0x41, 0xe8, 0x51, 0x62, 0x42, 0x85, 0x13, 0x21, 0x29, 0xaf, 0xbd, 0x4c, 0x0d, 0x4a, 0xfe, 0x29, 0x8d, 0xc9, 0x0a, 0x0f,
0xe3, 0x06, 0x20, 0xb3, 0xc8, 0x2d, 0x89, 0x16, 0xee, 0x44, 0x23, 0x48, 0xbd, 0x1c, 0xc1, 0xcd, 0x61, 0xef, 0x81, 0x44, 0xae, 0xbc, 0xc6, 0xef, 0x83, 0x59, 0x15, 0xbd, 0x72, 0xe2, 0xcb, 0xc8,
0xab, 0xad, 0x70, 0x66, 0xda, 0xe4, 0x3d, 0xae, 0x03, 0x39, 0x75, 0xae, 0xa4, 0xf6, 0xc4, 0x0e, 0x5b, 0x50, 0xe2, 0xe1, 0x04, 0x88, 0x92, 0xca, 0xda, 0x9d, 0xb1, 0x30, 0xe1, 0xe4, 0xb7, 0xe9,
0xcc, 0xe0, 0x86, 0x7c, 0xa5, 0x60, 0x1f, 0x7a, 0x89, 0xfa, 0xd4, 0x73, 0x42, 0x97, 0x7c, 0xad, 0xfa, 0x9a, 0xfb, 0x26, 0xe1, 0x82, 0x7d, 0x5d, 0x61, 0x5f, 0xca, 0xfa, 0x20, 0x3e, 0x1e, 0xc0,
0xe0, 0x26, 0x60, 0xa2, 0x3d, 0xf7, 0x1c, 0xd7, 0xf1, 0x75, 0x8b, 0x7c, 0xa3, 0xe0, 0x06, 0xac, 0x6e, 0x81, 0xfd, 0xb9, 0x88, 0x4f, 0x64, 0xe7, 0x26, 0xdf, 0xaf, 0x12, 0x78, 0x2b, 0xe6, 0xf0,
0x9e, 0x3a, 0x57, 0xf1, 0x29, 0x88, 0x80, 0x6f, 0xa3, 0x80, 0x58, 0xff, 0x82, 0x2e, 0x2e, 0xa8, 0x24, 0xa2, 0x84, 0xe1, 0x3e, 0xa0, 0x90, 0xe8, 0x94, 0xa4, 0x81, 0x07, 0xe9, 0x0a, 0x9a, 0xaf,
0x47, 0xbe, 0x53, 0x70, 0x0b, 0xfa, 0x69, 0x43, 0x9c, 0xeb, 0x7b, 0x45, 0xce, 0x28, 0x36, 0xbd, 0x57, 0x08, 0xab, 0x6c, 0x3f, 0x59, 0x79, 0x8c, 0xbc, 0xc3, 0x3d, 0x20, 0xaf, 0x82, 0x5b, 0xcd,
0x73, 0x02, 0x4a, 0x7e, 0x88, 0xd4, 0x72, 0x1f, 0x64, 0xa2, 0x1f, 0x15, 0x5c, 0x83, 0x6e, 0xa2, 0x3d, 0x67, 0xdc, 0xe3, 0xf7, 0xe4, 0xaf, 0x06, 0x4e, 0x60, 0x3b, 0x67, 0xbf, 0x8a, 0x82, 0x24,
0xe6, 0xbe, 0x3f, 0x29, 0x38, 0x84, 0xf5, 0x8c, 0xd2, 0xb4, 0x67, 0xe7, 0xac, 0xe4, 0xc8, 0xcf, 0x24, 0x7f, 0x33, 0xf0, 0x00, 0x30, 0xe7, 0x5e, 0x46, 0x41, 0x18, 0xc4, 0x8e, 0x4f, 0xfe, 0x6e,
0xca, 0xde, 0xc7, 0x3a, 0xf4, 0x0e, 0x0e, 0x8f, 0x46, 0x07, 0xae, 0x18, 0x80, 0x5d, 0xb2, 0x0f, 0xe0, 0x3e, 0xec, 0xbc, 0x0a, 0x6e, 0xb3, 0x53, 0x50, 0x06, 0xff, 0x48, 0x0d, 0x32, 0xfe, 0x67,
0x45, 0xa1, 0x61, 0xc1, 0x0b, 0x78, 0x58, 0xd4, 0xcf, 0xe2, 0x9e, 0xac, 0x47, 0x2c, 0x7a, 0x08, 0xf4, 0xe6, 0x8a, 0x46, 0xe4, 0x9f, 0x06, 0x1e, 0xc2, 0xa4, 0x28, 0xc8, 0x7c, 0xfd, 0xcb, 0xd0,
0x0f, 0x0b, 0xdb, 0x5a, 0x36, 0x88, 0xe8, 0x37, 0x6e, 0xbf, 0x87, 0x87, 0x45, 0xbd, 0x2d, 0xfe, 0x3b, 0xca, 0x44, 0x5f, 0x06, 0x9c, 0x92, 0x7f, 0xa7, 0x6c, 0x9d, 0x07, 0xed, 0xe8, 0x3f, 0x06,
0x35, 0x55, 0xdf, 0x58, 0xf6, 0x2a, 0x1e, 0x96, 0x76, 0xb9, 0x2c, 0x3e, 0x69, 0x10, 0xca, 0xde, 0xee, 0xc2, 0x38, 0x67, 0x4b, 0xdd, 0xff, 0x1a, 0x38, 0x85, 0xbd, 0x12, 0xd3, 0x63, 0xab, 0x4b,
0xc6, 0xc3, 0xd2, 0x56, 0x17, 0x9f, 0xc4, 0x94, 0x81, 0xc5, 0x2f, 0xe4, 0x61, 0x49, 0xb7, 0xcb, 0xd1, 0x72, 0xe4, 0x7f, 0xc6, 0xf1, 0xd7, 0x5d, 0xd8, 0x3e, 0x3d, 0x7b, 0x31, 0x3b, 0x0d, 0xd5,
0xb6, 0x47, 0x5c, 0xee, 0x45, 0x0f, 0xdf, 0x61, 0x61, 0x03, 0x8b, 0x8f, 0x23, 0x4e, 0xc2, 0xc2, 0x02, 0xe2, 0xf6, 0x7e, 0xa6, 0x1a, 0x0d, 0x6b, 0x9e, 0xe6, 0xd3, 0xba, 0x41, 0x19, 0x8f, 0x75,
0xc7, 0xf5, 0xb0, 0xb8, 0x4d, 0x66, 0x8b, 0x4c, 0x5e, 0x5f, 0x65, 0xaf, 0xe6, 0x61, 0x69, 0x03, 0x3f, 0x62, 0xdd, 0x0b, 0x7d, 0x5a, 0x3b, 0x2f, 0x8b, 0x45, 0xd4, 0x20, 0xf3, 0xf0, 0xa1, 0x3e,
0x8c, 0x07, 0x69, 0x92, 0xc3, 0xd2, 0xb7, 0xf3, 0xb0, 0xbc, 0x0d, 0xc6, 0xa7, 0x09, 0x2f, 0x62, 0xad, 0x1b, 0x9a, 0xf1, 0x17, 0x85, 0xfe, 0xc6, 0xa6, 0xe7, 0xfa, 0xb4, 0x71, 0x7c, 0x16, 0xf6,
0xc9, 0x0b, 0x7a, 0x58, 0xd6, 0x09, 0x5f, 0x34, 0xf8, 0x9f, 0x33, 0x8f, 0x7e, 0x09, 0x00, 0x00, 0xf9, 0xe4, 0xd1, 0xf4, 0x68, 0x9f, 0x36, 0xce, 0xd0, 0xf8, 0x3c, 0x83, 0x0c, 0xac, 0x7f, 0xba,
0xff, 0xff, 0x84, 0x7d, 0xd1, 0x2f, 0xb1, 0x11, 0x00, 0x00, 0x4f, 0x1b, 0xc6, 0x68, 0x91, 0x1e, 0x35, 0x34, 0xd4, 0xbd, 0xc8, 0xa7, 0xb5, 0x93, 0x31, 0x7e,
0x94, 0x62, 0x12, 0xd6, 0xbe, 0xfa, 0xa7, 0xf5, 0xf3, 0xb7, 0x08, 0x32, 0x7f, 0xd6, 0x35, 0x3d,
0xe7, 0xa7, 0x8d, 0x93, 0x35, 0x9e, 0x16, 0x41, 0x0e, 0x1b, 0x1f, 0xf5, 0xd3, 0xe6, 0xf9, 0x1a,
0x3f, 0xce, 0x71, 0x11, 0x1b, 0x9e, 0xf6, 0xd3, 0xa6, 0x11, 0xfb, 0xaa, 0x27, 0xff, 0x35, 0xfa,
0xf0, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x73, 0x34, 0x90, 0x2d, 0x4a, 0x12, 0x00, 0x00,
} }

View File

@ -6,67 +6,67 @@ package types;
//---------------------------------------- //----------------------------------------
// Message types // Message types
// Not being used // Not being used
// Could be added to request/response // Could be added to request/response
// so we don't have to type switch // so we don't have to type switch
// (would be twice as fast, but we're talking about 15ns) // (would be twice as fast, but we're talking about 15ns)
enum MessageType { enum MessageType {
NullMessage = 0x00; NullMessage = 0x00;
Echo = 0x01; Echo = 0x01;
Flush = 0x02; Flush = 0x02;
Info = 0x03; Info = 0x03;
SetOption = 0x04; SetOption = 0x04;
Exception = 0x05; Exception = 0x05;
DeliverTx = 0x11; DeliverTx = 0x11;
CheckTx = 0x12; CheckTx = 0x12;
Commit = 0x13; Commit = 0x13;
Query = 0x14; Query = 0x14;
InitChain = 0x15; InitChain = 0x15;
BeginBlock = 0x16; BeginBlock = 0x16;
EndBlock = 0x17; EndBlock = 0x17;
} }
//---------------------------------------- //----------------------------------------
// Code types // Code types
enum CodeType { enum CodeType {
OK = 0; OK = 0;
// General response codes, 0 ~ 99 // General response codes, 0 ~ 99
InternalError = 1; InternalError = 1;
EncodingError = 2; EncodingError = 2;
BadNonce = 3; BadNonce = 3;
Unauthorized = 4; Unauthorized = 4;
InsufficientFunds = 5; InsufficientFunds = 5;
UnknownRequest = 6; UnknownRequest = 6;
// Reserved for basecoin, 100 ~ 199 // Reserved for basecoin, 100 ~ 199
BaseDuplicateAddress = 101; BaseDuplicateAddress = 101;
BaseEncodingError = 102; BaseEncodingError = 102;
BaseInsufficientFees = 103; BaseInsufficientFees = 103;
BaseInsufficientFunds = 104; BaseInsufficientFunds = 104;
BaseInsufficientGasPrice = 105; BaseInsufficientGasPrice = 105;
BaseInvalidInput = 106; BaseInvalidInput = 106;
BaseInvalidOutput = 107; BaseInvalidOutput = 107;
BaseInvalidPubKey = 108; BaseInvalidPubKey = 108;
BaseInvalidSequence = 109; BaseInvalidSequence = 109;
BaseInvalidSignature = 110; BaseInvalidSignature = 110;
BaseUnknownAddress = 111; BaseUnknownAddress = 111;
BaseUnknownPubKey = 112; BaseUnknownPubKey = 112;
BaseUnknownPlugin = 113; BaseUnknownPlugin = 113;
// Reserved for governance, 200 ~ 299 // Reserved for governance, 200 ~ 299
GovUnknownEntity = 201; GovUnknownEntity = 201;
GovUnknownGroup = 202; GovUnknownGroup = 202;
GovUnknownProposal = 203; GovUnknownProposal = 203;
GovDuplicateGroup = 204; GovDuplicateGroup = 204;
GovDuplicateMember = 205; GovDuplicateMember = 205;
GovDuplicateProposal = 206; GovDuplicateProposal = 206;
GovDuplicateVote = 207; GovDuplicateVote = 207;
GovInvalidMember = 208; GovInvalidMember = 208;
GovInvalidVote = 209; GovInvalidVote = 209;
GovInvalidVotingPower = 210; GovInvalidVotingPower = 210;
} }
@ -105,15 +105,18 @@ message RequestSetOption{
} }
message RequestDeliverTx{ message RequestDeliverTx{
bytes tx = 1; bytes tx = 1;
} }
message RequestCheckTx{ message RequestCheckTx{
bytes tx = 1; bytes tx = 1;
} }
message RequestQuery{ message RequestQuery{
bytes query = 1; bytes data = 1;
string path = 2;
uint64 height = 3;
bool prove = 4;
} }
message RequestCommit{ message RequestCommit{
@ -189,8 +192,12 @@ message ResponseCheckTx{
message ResponseQuery{ message ResponseQuery{
CodeType code = 1; CodeType code = 1;
bytes data = 2; int64 index = 2;
string log = 3; bytes key = 3;
bytes value = 4;
bytes proof = 5;
uint64 height = 6;
string log = 7;
} }
message ResponseCommit{ message ResponseCommit{
@ -222,7 +229,7 @@ message Header {
bytes last_commit_hash = 6; bytes last_commit_hash = 6;
bytes data_hash = 7; bytes data_hash = 7;
bytes validators_hash = 8; bytes validators_hash = 8;
bytes app_hash = 9; bytes app_hash = 9;
} }
message BlockID { message BlockID {
@ -236,8 +243,8 @@ message PartSetHeader {
} }
message Validator { message Validator {
bytes pubKey = 1; bytes pubKey = 1;
uint64 power = 2; uint64 power = 2;
} }
//---------------------------------------- //----------------------------------------