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

remove CodeType

pull/1780/head
Ethan Buchman 7 years ago
parent
22b491bb19
commit
42a8e3240c
19 changed files with 190 additions and 410 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      Makefile
  2. +1
    -1
      client/grpc_client.go
  3. +1
    -1
      client/socket_client.go
  4. +2
    -2
      cmd/abci-cli/abci-cli.go
  5. +9
    -8
      example/counter/counter.go
  6. +3
    -3
      example/dummy/dummy.go
  7. +4
    -4
      example/dummy/dummy_test.go
  8. +9
    -8
      example/dummy/persistent_dummy.go
  9. +1
    -1
      example/example.go
  10. +2
    -2
      example/example_test.go
  11. +2
    -2
      tests/test_app/app.go
  12. +9
    -8
      tests/test_app/main.go
  13. +4
    -4
      types/base_app.go
  14. +0
    -37
      types/code.go
  15. +0
    -12
      types/code_test.go
  16. +13
    -12
      types/result.go
  17. +12
    -12
      types/result_test.go
  18. +113
    -245
      types/types.pb.go
  19. +4
    -47
      types/types.proto

+ 1
- 1
Makefile View File

@ -74,7 +74,6 @@ metalinter_test:
gometalinter --vendor --deadline=600s --disable-all \
--enable=maligned \
--enable=deadcode \
--enable=gas \
--enable=goconst \
--enable=goimports \
--enable=gosimple \
@ -90,6 +89,7 @@ metalinter_test:
--enable=vetshadow \
./...
#--enable=gas \
#--enable=dupl \
#--enable=errcheck \
#--enable=gocyclo \


+ 1
- 1
client/grpc_client.go View File

@ -104,7 +104,7 @@ func (cli *grpcClient) StopForError(err error) {
func (cli *grpcClient) Error() error {
cli.mtx.Lock()
defer cli.mtx.Unlock()
return errors.Wrap(cli.err, types.HumanCode(types.CodeType_InternalError))
return errors.Wrap(cli.err, "grpc client error")
}
// Set listener for all responses


+ 1
- 1
client/socket_client.go View File

@ -111,7 +111,7 @@ func (cli *socketClient) StopForError(err error) {
func (cli *socketClient) Error() error {
cli.mtx.Lock()
defer cli.mtx.Unlock()
return errors.Wrap(cli.err, types.HumanCode(types.CodeType_InternalError))
return errors.Wrap(cli.err, "socket client error")
}
// Set listener for all responses


+ 2
- 2
cmd/abci-cli/abci-cli.go View File

@ -26,7 +26,7 @@ import (
type response struct {
// generic abci response
Data []byte
Code types.CodeType
Code uint32
Log string
Query *queryResponse
@ -508,7 +508,7 @@ func printResponse(cmd *cobra.Command, args []string, rsp response) {
}
// Always print the status code.
fmt.Printf("-> code: %s\n", rsp.Code.String())
fmt.Printf("-> code: %d\n", rsp.Code)
if len(rsp.Data) != 0 {
// Do no print this line when using the commit command


+ 9
- 8
example/counter/counter.go View File

@ -4,6 +4,7 @@ import (
"encoding/binary"
"fmt"
"github.com/tendermint/abci/example/code"
"github.com/tendermint/abci/types"
cmn "github.com/tendermint/tmlibs/common"
)
@ -36,7 +37,7 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
if app.serial {
if len(tx) > 8 {
return types.ResponseDeliverTx{
Code: types.CodeType_EncodingError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx))}
}
tx8 := make([]byte, 8)
@ -44,19 +45,19 @@ func (app *CounterApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
txValue := binary.BigEndian.Uint64(tx8)
if txValue != uint64(app.txCount) {
return types.ResponseDeliverTx{
Code: types.CodeType_BadNonce,
Code: code.CodeTypeBadNonce,
Log: fmt.Sprintf("Invalid nonce. Expected %v, got %v", app.txCount, txValue)}
}
}
app.txCount++
return types.ResponseDeliverTx{Code: types.CodeType_OK}
return types.ResponseDeliverTx{Code: types.CodeTypeOK}
}
func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx {
if app.serial {
if len(tx) > 8 {
return types.ResponseCheckTx{
Code: types.CodeType_EncodingError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Max tx size is 8 bytes, got %d", len(tx))}
}
tx8 := make([]byte, 8)
@ -64,21 +65,21 @@ func (app *CounterApplication) CheckTx(tx []byte) types.ResponseCheckTx {
txValue := binary.BigEndian.Uint64(tx8)
if txValue < uint64(app.txCount) {
return types.ResponseCheckTx{
Code: types.CodeType_BadNonce,
Code: code.CodeTypeBadNonce,
Log: fmt.Sprintf("Invalid nonce. Expected >= %v, got %v", app.txCount, txValue)}
}
}
return types.ResponseCheckTx{Code: types.CodeType_OK}
return types.ResponseCheckTx{Code: types.CodeTypeOK}
}
func (app *CounterApplication) Commit() (resp types.ResponseCommit) {
app.hashCount++
if app.txCount == 0 {
return types.ResponseCommit{Code: types.CodeType_OK}
return types.ResponseCommit{Code: types.CodeTypeOK}
}
hash := make([]byte, 8)
binary.BigEndian.PutUint64(hash, uint64(app.txCount))
return types.ResponseCommit{Code: types.CodeType_OK, Data: hash}
return types.ResponseCommit{Code: types.CodeTypeOK, Data: hash}
}
func (app *CounterApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {


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

@ -42,11 +42,11 @@ func (app *DummyApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
{Key: "app.creator", ValueType: types.KVPair_STRING, ValueString: "jae"},
{Key: "app.key", ValueType: types.KVPair_STRING, ValueString: string(key)},
}
return types.ResponseDeliverTx{Code: types.CodeType_OK, Tags: tags}
return types.ResponseDeliverTx{Code: types.CodeTypeOK, Tags: tags}
}
func (app *DummyApplication) CheckTx(tx []byte) types.ResponseCheckTx {
return types.ResponseCheckTx{Code: types.CodeType_OK}
return types.ResponseCheckTx{Code: types.CodeTypeOK}
}
func (app *DummyApplication) Commit() types.ResponseCommit {
@ -64,7 +64,7 @@ func (app *DummyApplication) Commit() types.ResponseCommit {
}
}
return types.ResponseCommit{Code: types.CodeType_OK, Data: hash}
return types.ResponseCommit{Code: types.CodeTypeOK, Data: hash}
}
func (app *DummyApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {


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

@ -27,7 +27,7 @@ func testDummy(t *testing.T, app types.Application, tx []byte, key, value string
Path: "/store",
Data: []byte(key),
})
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.Equal(t, types.CodeTypeOK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
// make sure proof is fine
@ -36,7 +36,7 @@ func testDummy(t *testing.T, app types.Application, tx []byte, key, value string
Data: []byte(key),
Prove: true,
})
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.EqualValues(t, types.CodeTypeOK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
proof, err := iavl.ReadKeyExistsProof(resQuery.Proof)
require.Nil(t, err)
@ -295,7 +295,7 @@ func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string)
Data: []byte(key),
})
require.Nil(t, err)
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.Equal(t, types.CodeTypeOK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
// make sure proof is fine
@ -305,7 +305,7 @@ func testClient(t *testing.T, app abcicli.Client, tx []byte, key, value string)
Prove: true,
})
require.Nil(t, err)
require.Equal(t, types.CodeType_OK, resQuery.Code)
require.Equal(t, types.CodeTypeOK, resQuery.Code)
require.Equal(t, value, string(resQuery.Value))
proof, err := iavl.ReadKeyExistsProof(resQuery.Proof)
require.Nil(t, err)


+ 9
- 8
example/dummy/persistent_dummy.go View File

@ -7,6 +7,7 @@ import (
"strconv"
"strings"
"github.com/tendermint/abci/example/code"
"github.com/tendermint/abci/types"
crypto "github.com/tendermint/go-crypto"
"github.com/tendermint/iavl"
@ -96,7 +97,7 @@ func (app *PersistentDummyApplication) Commit() types.ResponseCommit {
}
app.logger.Info("Commit block", "height", height, "root", appHash)
return types.ResponseCommit{Code: types.CodeType_OK, Data: appHash}
return types.ResponseCommit{Code: types.CodeTypeOK, Data: appHash}
}
func (app *PersistentDummyApplication) Query(reqQuery types.RequestQuery) types.ResponseQuery {
@ -160,7 +161,7 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Response
pubKeyAndPower := strings.Split(string(tx), "/")
if len(pubKeyAndPower) != 2 {
return types.ResponseDeliverTx{
Code: types.CodeType_EncodingError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Expected 'pubkey/power'. Got %v", pubKeyAndPower)}
}
pubkeyS, powerS := pubKeyAndPower[0], pubKeyAndPower[1]
@ -169,13 +170,13 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Response
pubkey, err := hex.DecodeString(pubkeyS)
if err != nil {
return types.ResponseDeliverTx{
Code: types.CodeType_EncodingError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Pubkey (%s) is invalid hex", pubkeyS)}
}
_, err = crypto.PubKeyFromBytes(pubkey)
if err != nil {
return types.ResponseDeliverTx{
Code: types.CodeType_EncodingError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Pubkey (%X) is invalid go-crypto encoded", pubkey)}
}
@ -183,7 +184,7 @@ func (app *PersistentDummyApplication) execValidatorTx(tx []byte) types.Response
power, err := strconv.Atoi(powerS)
if err != nil {
return types.ResponseDeliverTx{
Code: types.CodeType_EncodingError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Power (%s) is not an int", powerS)}
}
@ -198,7 +199,7 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
// remove validator
if !app.app.state.Has(key) {
return types.ResponseDeliverTx{
Code: types.CodeType_Unauthorized,
Code: code.CodeTypeUnauthorized,
Log: fmt.Sprintf("Cannot remove non-existent validator %X", key)}
}
app.app.state.Remove(key)
@ -207,7 +208,7 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
value := bytes.NewBuffer(make([]byte, 0))
if err := types.WriteMessage(v, value); err != nil {
return types.ResponseDeliverTx{
Code: types.CodeType_InternalError,
Code: code.CodeTypeEncodingError,
Log: fmt.Sprintf("Error encoding validator: %v", err)}
}
app.app.state.Set(key, value.Bytes())
@ -216,5 +217,5 @@ func (app *PersistentDummyApplication) updateValidator(v *types.Validator) types
// we only update the changes array if we successfully updated the tree
app.changes = append(app.changes, v)
return types.ResponseDeliverTx{Code: types.CodeType_OK}
return types.ResponseDeliverTx{Code: types.CodeTypeOK}
}

+ 1
- 1
example/example.go View File

@ -1,3 +1,3 @@
package example
// so the go tool doesn't return errors about no buildable go files ...
// so go get doesnt complain

+ 2
- 2
example/example_test.go View File

@ -60,7 +60,7 @@ func testStream(t *testing.T, app types.Application) {
switch r := res.Value.(type) {
case *types.Response_DeliverTx:
counter++
if r.DeliverTx.Code != types.CodeType_OK {
if r.DeliverTx.Code != types.CodeTypeOK {
t.Error("DeliverTx failed with ret_code", r.DeliverTx.Code)
}
if counter > numDeliverTxs {
@ -135,7 +135,7 @@ func testGRPCSync(t *testing.T, app *types.GRPCApplication) {
t.Fatalf("Error in GRPC DeliverTx: %v", err.Error())
}
counter++
if response.Code != types.CodeType_OK {
if response.Code != types.CodeTypeOK {
t.Error("DeliverTx failed with ret_code", response.Code)
}
if counter > numDeliverTxs {


+ 2
- 2
tests/test_app/app.go View File

@ -45,7 +45,7 @@ func commit(client abcicli.Client, hashExp []byte) {
}
}
func deliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
func deliverTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) {
res, err := client.DeliverTxSync(txBytes)
if err != nil {
panicf("client error: %v", err)
@ -58,7 +58,7 @@ func deliverTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, da
}
}
/*func checkTx(client abcicli.Client, txBytes []byte, codeExp types.CodeType, dataExp []byte) {
/*func checkTx(client abcicli.Client, txBytes []byte, codeExp uint32, dataExp []byte) {
res, err := client.CheckTxSync(txBytes)
if err != nil {
panicf("client error: %v", err)


+ 9
- 8
tests/test_app/main.go View File

@ -7,6 +7,7 @@ import (
"os/exec"
"time"
"github.com/tendermint/abci/example/code"
"github.com/tendermint/abci/types"
)
@ -69,15 +70,15 @@ func testCounter() {
setOption(client, "serial", "on")
commit(client, nil)
deliverTx(client, []byte("abc"), types.CodeType_BadNonce, nil)
deliverTx(client, []byte("abc"), code.CodeTypeBadNonce, nil)
commit(client, nil)
deliverTx(client, []byte{0x00}, types.CodeType_OK, nil)
deliverTx(client, []byte{0x00}, types.CodeTypeOK, nil)
commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 1})
deliverTx(client, []byte{0x00}, types.CodeType_BadNonce, nil)
deliverTx(client, []byte{0x01}, types.CodeType_OK, nil)
deliverTx(client, []byte{0x00, 0x02}, types.CodeType_OK, nil)
deliverTx(client, []byte{0x00, 0x03}, types.CodeType_OK, nil)
deliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeType_OK, nil)
deliverTx(client, []byte{0x00, 0x00, 0x06}, types.CodeType_BadNonce, nil)
deliverTx(client, []byte{0x00}, code.CodeTypeBadNonce, nil)
deliverTx(client, []byte{0x01}, types.CodeTypeOK, nil)
deliverTx(client, []byte{0x00, 0x02}, types.CodeTypeOK, nil)
deliverTx(client, []byte{0x00, 0x03}, types.CodeTypeOK, nil)
deliverTx(client, []byte{0x00, 0x00, 0x04}, types.CodeTypeOK, nil)
deliverTx(client, []byte{0x00, 0x00, 0x06}, code.CodeTypeBadNonce, nil)
commit(client, []byte{0, 0, 0, 0, 0, 0, 0, 5})
}

+ 4
- 4
types/base_app.go View File

@ -16,19 +16,19 @@ func (BaseApplication) SetOption(req RequestSetOption) ResponseSetOption {
}
func (BaseApplication) DeliverTx(tx []byte) ResponseDeliverTx {
return ResponseDeliverTx{Code: CodeType_OK}
return ResponseDeliverTx{Code: CodeTypeOK}
}
func (BaseApplication) CheckTx(tx []byte) ResponseCheckTx {
return ResponseCheckTx{Code: CodeType_OK}
return ResponseCheckTx{Code: CodeTypeOK}
}
func (BaseApplication) Commit() ResponseCommit {
return ResponseCommit{Code: CodeType_OK, Data: []byte("nil")}
return ResponseCommit{Code: CodeTypeOK, Data: []byte("nil")}
}
func (BaseApplication) Query(req RequestQuery) ResponseQuery {
return ResponseQuery{Code: CodeType_OK}
return ResponseQuery{Code: CodeTypeOK}
}
func (BaseApplication) InitChain(req RequestInitChain) ResponseInitChain {


+ 0
- 37
types/code.go View File

@ -1,37 +0,0 @@
package types
var (
code2string = map[CodeType]string{
CodeType_InternalError: "Internal error",
CodeType_EncodingError: "Encoding error",
CodeType_BadNonce: "Error bad nonce",
CodeType_Unauthorized: "Unauthorized",
CodeType_InsufficientFunds: "Insufficient funds",
CodeType_UnknownRequest: "Unknown request",
CodeType_BaseDuplicateAddress: "Error (base) duplicate address",
CodeType_BaseEncodingError: "Error (base) encoding error",
CodeType_BaseInsufficientFees: "Error (base) insufficient fees",
CodeType_BaseInsufficientFunds: "Error (base) insufficient funds",
CodeType_BaseInsufficientGasPrice: "Error (base) insufficient gas price",
CodeType_BaseInvalidInput: "Error (base) invalid input",
CodeType_BaseInvalidOutput: "Error (base) invalid output",
CodeType_BaseInvalidPubKey: "Error (base) invalid pubkey",
CodeType_BaseInvalidSequence: "Error (base) invalid sequence",
CodeType_BaseInvalidSignature: "Error (base) invalid signature",
CodeType_BaseUnknownAddress: "Error (base) unknown address",
CodeType_BaseUnknownPlugin: "Error (base) unknown plugin",
CodeType_BaseUnknownPubKey: "Error (base) unknown pubkey",
}
)
func (c CodeType) IsOK() bool { return c == CodeType_OK }
// HumanCode transforms code into a more humane format, such as "Internal error" instead of 0.
func HumanCode(code CodeType) string {
s, ok := code2string[code]
if !ok {
return "Unknown code"
}
return s
}

+ 0
- 12
types/code_test.go View File

@ -1,12 +0,0 @@
package types
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestHumanCode(t *testing.T) {
assert.Equal(t, "Internal error", HumanCode(CodeType_InternalError))
assert.Equal(t, "Unknown code", HumanCode(-1))
}

+ 13
- 12
types/result.go View File

@ -6,9 +6,15 @@ import (
"github.com/tendermint/go-wire/data"
)
// type CodeType uint32
const (
CodeTypeOK uint32 = 0
)
// IsErr returns true if Code is something other than OK.
func (r ResponseCheckTx) IsErr() bool {
return r.Code != CodeType_OK
return r.Code != CodeTypeOK
}
// Error implements error interface by formatting response as string.
@ -18,7 +24,7 @@ func (r ResponseCheckTx) Error() string {
// IsErr returns true if Code is something other than OK.
func (r ResponseDeliverTx) IsErr() bool {
return r.Code != CodeType_OK
return r.Code != CodeTypeOK
}
// Error implements error interface by formatting response as string.
@ -28,7 +34,7 @@ func (r ResponseDeliverTx) Error() string {
// IsErr returns true if Code is something other than OK.
func (r ResponseCommit) IsErr() bool {
return r.Code != CodeType_OK
return r.Code != CodeTypeOK
}
// Error implements error interface by formatting response as string.
@ -36,19 +42,14 @@ func (r ResponseCommit) Error() string {
return fmtError(r.Code, r.Log)
}
func fmtError(code CodeType, log string) string {
codeAsStr, ok := code2string[code]
if ok {
return fmt.Sprintf("%s (%d): %s", codeAsStr, code, log)
} else {
return fmt.Sprintf("Unknown error (%d): %s", code, log)
}
func fmtError(code uint32, log string) string {
return fmt.Sprintf("Error code (%d): %s", code, log)
}
// ResultQuery is a wrapper around ResponseQuery using data.Bytes instead of
// raw byte slices.
type ResultQuery struct {
Code CodeType `json:"code"`
Code uint32 `json:"code"`
Index int64 `json:"index"`
Key data.Bytes `json:"key"`
Value data.Bytes `json:"value"`
@ -72,7 +73,7 @@ func (r *ResponseQuery) Result() *ResultQuery {
// IsErr returns true if Code is something other than OK.
func (r *ResultQuery) IsErr() bool {
return r.Code != CodeType_OK
return r.Code != CodeTypeOK
}
// Error implements error interface by formatting result as string.


+ 12
- 12
types/result_test.go View File

@ -8,7 +8,7 @@ import (
func TestResultQuery(t *testing.T) {
orig := &ResponseQuery{
Code: CodeType_OK,
Code: CodeTypeOK,
Index: 0,
Key: []byte("hello"),
Value: []byte("world"),
@ -18,7 +18,7 @@ func TestResultQuery(t *testing.T) {
assert.False(t, res.IsErr())
orig = &ResponseQuery{
Code: CodeType_BadNonce,
Code: 1,
Index: 0,
Key: []byte("hello"),
Value: []byte("world"),
@ -27,50 +27,50 @@ func TestResultQuery(t *testing.T) {
}
res = orig.Result()
assert.True(t, res.IsErr())
assert.Equal(t, "Error bad nonce (3): bad", res.Error())
assert.Equal(t, "Error code (1): bad", res.Error())
}
func TestResponseDeliverTx(t *testing.T) {
res := ResponseDeliverTx{
Code: CodeType_OK,
Code: CodeTypeOK,
Data: []byte("Victor Mancha"),
}
assert.False(t, res.IsErr())
res = ResponseDeliverTx{
Code: CodeType_InternalError,
Code: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Internal error (1): bad", res.Error())
assert.Equal(t, "Error code (1): bad", res.Error())
}
func TestResponseCheckTx(t *testing.T) {
res := ResponseCheckTx{
Code: CodeType_OK,
Code: CodeTypeOK,
Data: []byte("Talos"),
}
assert.False(t, res.IsErr())
res = ResponseCheckTx{
Code: CodeType_InternalError,
Code: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Internal error (1): bad", res.Error())
assert.Equal(t, "Error code (1): bad", res.Error())
}
func TestResponseCommit(t *testing.T) {
res := ResponseCommit{
Code: CodeType_OK,
Code: CodeTypeOK,
Data: []byte("Old Lace"),
}
assert.False(t, res.IsErr())
res = ResponseCommit{
Code: CodeType_Unauthorized,
Code: 1,
Log: "bad",
}
assert.True(t, res.IsErr())
assert.Equal(t, "Unauthorized (4): bad", res.Error())
assert.Equal(t, "Error code (1): bad", res.Error())
}

+ 113
- 245
types/types.pb.go View File

@ -40,7 +40,6 @@ It has these top-level messages:
Validator
KVPair
*/
//nolint: gas
package types
import proto "github.com/golang/protobuf/proto"
@ -63,114 +62,6 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type CodeType int32
const (
CodeType_OK CodeType = 0
// General response codes, 0 ~ 99
CodeType_InternalError CodeType = 1
CodeType_EncodingError CodeType = 2
CodeType_BadNonce CodeType = 3
CodeType_Unauthorized CodeType = 4
CodeType_InsufficientFunds CodeType = 5
CodeType_UnknownRequest CodeType = 6
// Reserved for basecoin, 100 ~ 199
CodeType_BaseDuplicateAddress CodeType = 101
CodeType_BaseEncodingError CodeType = 102
CodeType_BaseInsufficientFees CodeType = 103
CodeType_BaseInsufficientFunds CodeType = 104
CodeType_BaseInsufficientGasPrice CodeType = 105
CodeType_BaseInvalidInput CodeType = 106
CodeType_BaseInvalidOutput CodeType = 107
CodeType_BaseInvalidPubKey CodeType = 108
CodeType_BaseInvalidSequence CodeType = 109
CodeType_BaseInvalidSignature CodeType = 110
CodeType_BaseUnknownAddress CodeType = 111
CodeType_BaseUnknownPubKey CodeType = 112
CodeType_BaseUnknownPlugin CodeType = 113
// Reserved for governance, 200 ~ 299
CodeType_GovUnknownEntity CodeType = 201
CodeType_GovUnknownGroup CodeType = 202
CodeType_GovUnknownProposal CodeType = 203
CodeType_GovDuplicateGroup CodeType = 204
CodeType_GovDuplicateMember CodeType = 205
CodeType_GovDuplicateProposal CodeType = 206
CodeType_GovDuplicateVote CodeType = 207
CodeType_GovInvalidMember CodeType = 208
CodeType_GovInvalidVote CodeType = 209
CodeType_GovInvalidVotingPower CodeType = 210
)
var CodeType_name = map[int32]string{
0: "OK",
1: "InternalError",
2: "EncodingError",
3: "BadNonce",
4: "Unauthorized",
5: "InsufficientFunds",
6: "UnknownRequest",
101: "BaseDuplicateAddress",
102: "BaseEncodingError",
103: "BaseInsufficientFees",
104: "BaseInsufficientFunds",
105: "BaseInsufficientGasPrice",
106: "BaseInvalidInput",
107: "BaseInvalidOutput",
108: "BaseInvalidPubKey",
109: "BaseInvalidSequence",
110: "BaseInvalidSignature",
111: "BaseUnknownAddress",
112: "BaseUnknownPubKey",
113: "BaseUnknownPlugin",
201: "GovUnknownEntity",
202: "GovUnknownGroup",
203: "GovUnknownProposal",
204: "GovDuplicateGroup",
205: "GovDuplicateMember",
206: "GovDuplicateProposal",
207: "GovDuplicateVote",
208: "GovInvalidMember",
209: "GovInvalidVote",
210: "GovInvalidVotingPower",
}
var CodeType_value = map[string]int32{
"OK": 0,
"InternalError": 1,
"EncodingError": 2,
"BadNonce": 3,
"Unauthorized": 4,
"InsufficientFunds": 5,
"UnknownRequest": 6,
"BaseDuplicateAddress": 101,
"BaseEncodingError": 102,
"BaseInsufficientFees": 103,
"BaseInsufficientFunds": 104,
"BaseInsufficientGasPrice": 105,
"BaseInvalidInput": 106,
"BaseInvalidOutput": 107,
"BaseInvalidPubKey": 108,
"BaseInvalidSequence": 109,
"BaseInvalidSignature": 110,
"BaseUnknownAddress": 111,
"BaseUnknownPubKey": 112,
"BaseUnknownPlugin": 113,
"GovUnknownEntity": 201,
"GovUnknownGroup": 202,
"GovUnknownProposal": 203,
"GovDuplicateGroup": 204,
"GovDuplicateMember": 205,
"GovDuplicateProposal": 206,
"GovDuplicateVote": 207,
"GovInvalidMember": 208,
"GovInvalidVote": 209,
"GovInvalidVotingPower": 210,
}
func (x CodeType) String() string {
return proto.EnumName(CodeType_name, int32(x))
}
func (CodeType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
type KVPair_Type int32
const (
@ -1320,7 +1211,7 @@ func (m *ResponseSetOption) GetLog() string {
}
type ResponseDeliverTx struct {
Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
Tags []*KVPair `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"`
@ -1331,11 +1222,11 @@ func (m *ResponseDeliverTx) String() string { return proto.CompactTex
func (*ResponseDeliverTx) ProtoMessage() {}
func (*ResponseDeliverTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
func (m *ResponseDeliverTx) GetCode() CodeType {
func (m *ResponseDeliverTx) GetCode() uint32 {
if m != nil {
return m.Code
}
return CodeType_OK
return 0
}
func (m *ResponseDeliverTx) GetData() []byte {
@ -1360,11 +1251,11 @@ func (m *ResponseDeliverTx) GetTags() []*KVPair {
}
type ResponseCheckTx struct {
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"`
Log string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
Gas uint64 `protobuf:"varint,4,opt,name=gas" json:"gas,omitempty"`
Fee uint64 `protobuf:"varint,5,opt,name=fee" json:"fee,omitempty"`
Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
Gas uint64 `protobuf:"varint,4,opt,name=gas" json:"gas,omitempty"`
Fee uint64 `protobuf:"varint,5,opt,name=fee" json:"fee,omitempty"`
}
func (m *ResponseCheckTx) Reset() { *m = ResponseCheckTx{} }
@ -1372,11 +1263,11 @@ func (m *ResponseCheckTx) String() string { return proto.CompactTextS
func (*ResponseCheckTx) ProtoMessage() {}
func (*ResponseCheckTx) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} }
func (m *ResponseCheckTx) GetCode() CodeType {
func (m *ResponseCheckTx) GetCode() uint32 {
if m != nil {
return m.Code
}
return CodeType_OK
return 0
}
func (m *ResponseCheckTx) GetData() []byte {
@ -1408,13 +1299,13 @@ func (m *ResponseCheckTx) GetFee() uint64 {
}
type ResponseQuery struct {
Code CodeType `protobuf:"varint,1,opt,name=code,enum=types.CodeType" json:"code,omitempty"`
Index int64 `protobuf:"varint,2,opt,name=index" json:"index,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"`
Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
Index int64 `protobuf:"varint,2,opt,name=index" json:"index,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{} }
@ -1422,11 +1313,11 @@ func (m *ResponseQuery) String() string { return proto.CompactTextStr
func (*ResponseQuery) ProtoMessage() {}
func (*ResponseQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} }
func (m *ResponseQuery) GetCode() CodeType {
func (m *ResponseQuery) GetCode() uint32 {
if m != nil {
return m.Code
}
return CodeType_OK
return 0
}
func (m *ResponseQuery) GetIndex() int64 {
@ -1472,9 +1363,9 @@ func (m *ResponseQuery) GetLog() string {
}
type ResponseCommit struct {
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"`
Log string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
Code uint32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log" json:"log,omitempty"`
}
func (m *ResponseCommit) Reset() { *m = ResponseCommit{} }
@ -1482,11 +1373,11 @@ func (m *ResponseCommit) String() string { return proto.CompactTextSt
func (*ResponseCommit) ProtoMessage() {}
func (*ResponseCommit) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} }
func (m *ResponseCommit) GetCode() CodeType {
func (m *ResponseCommit) GetCode() uint32 {
if m != nil {
return m.Code
}
return CodeType_OK
return 0
}
func (m *ResponseCommit) GetData() []byte {
@ -1758,7 +1649,6 @@ func init() {
proto.RegisterType((*PartSetHeader)(nil), "types.PartSetHeader")
proto.RegisterType((*Validator)(nil), "types.Validator")
proto.RegisterType((*KVPair)(nil), "types.KVPair")
proto.RegisterEnum("types.CodeType", CodeType_name, CodeType_value)
proto.RegisterEnum("types.KVPair_Type", KVPair_Type_name, KVPair_Type_value)
}
@ -2167,115 +2057,93 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 1755 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x58, 0x49, 0x6f, 0xdb, 0xce,
0x15, 0x37, 0x25, 0x6a, 0x7b, 0x96, 0x65, 0x7a, 0x2c, 0xdb, 0xb2, 0xd2, 0x43, 0xc2, 0x22, 0x8d,
0x9d, 0xa6, 0x4e, 0xeb, 0x20, 0x45, 0xdc, 0x14, 0x05, 0xbc, 0xc5, 0x16, 0x82, 0x3a, 0x2e, 0xed,
0xe4, 0xd2, 0x83, 0x40, 0x8b, 0x23, 0x69, 0x6a, 0x69, 0xc8, 0x90, 0x43, 0x47, 0xee, 0xa9, 0xbd,
0xe7, 0xde, 0x8f, 0x50, 0xa0, 0xc7, 0x02, 0xfd, 0x0a, 0x05, 0xfe, 0xfb, 0xf2, 0x89, 0xfe, 0x98,
0x85, 0xab, 0xa9, 0xe0, 0x7f, 0xc8, 0x85, 0x98, 0xb7, 0xcd, 0xbc, 0x99, 0x79, 0xef, 0xf7, 0x1e,
0x07, 0x56, 0xd8, 0xad, 0x87, 0x83, 0xa7, 0xe2, 0xbb, 0xe3, 0xf9, 0x2e, 0x73, 0x51, 0x45, 0x10,
0xe6, 0xff, 0x75, 0xa8, 0x59, 0xf8, 0x7d, 0x88, 0x03, 0x86, 0xb6, 0x40, 0xc7, 0x83, 0xb1, 0xdb,
0xd1, 0xee, 0x6b, 0x5b, 0x8b, 0xbb, 0x68, 0x47, 0xaa, 0x2b, 0xe9, 0xf1, 0x60, 0xec, 0x9e, 0x2e,
0x58, 0x42, 0x03, 0xfd, 0x1a, 0x2a, 0xc3, 0x49, 0x18, 0x8c, 0x3b, 0x25, 0xa1, 0xba, 0x9a, 0x55,
0x7d, 0xc5, 0x45, 0xa7, 0x0b, 0x96, 0xd4, 0xe1, 0xd3, 0x12, 0x3a, 0x74, 0x3b, 0xe5, 0xa2, 0x69,
0x7b, 0x74, 0x28, 0xa6, 0xe5, 0x1a, 0xe8, 0x05, 0x40, 0x80, 0x59, 0xdf, 0xf5, 0x18, 0x71, 0x69,
0x47, 0x17, 0xfa, 0x1b, 0x59, 0xfd, 0x0b, 0xcc, 0xde, 0x08, 0xf1, 0xe9, 0x82, 0xd5, 0x08, 0x22,
0x82, 0x5b, 0x3a, 0x78, 0x42, 0x6e, 0xb0, 0xdf, 0x67, 0xb3, 0x4e, 0xa5, 0xc8, 0xf2, 0x48, 0xca,
0x2f, 0x67, 0xdc, 0xd2, 0x89, 0x08, 0xb4, 0x0b, 0xf5, 0xc1, 0x18, 0x0f, 0xae, 0xb9, 0x5d, 0x55,
0xd8, 0xad, 0x65, 0xed, 0x0e, 0xb9, 0x54, 0x58, 0xd5, 0x06, 0x72, 0x88, 0x76, 0xa0, 0x3a, 0x70,
0xa7, 0x53, 0xc2, 0x3a, 0x35, 0x61, 0xd1, 0xce, 0x59, 0x08, 0xd9, 0xe9, 0x82, 0xa5, 0xb4, 0xf8,
0x71, 0xbd, 0x0f, 0xb1, 0x7f, 0xdb, 0xa9, 0x17, 0x1d, 0xd7, 0x5f, 0xb8, 0x88, 0x1f, 0x97, 0xd0,
0xe1, 0x5b, 0x21, 0x94, 0xb0, 0xfe, 0x60, 0x6c, 0x13, 0xda, 0x69, 0x14, 0x6d, 0xa5, 0x47, 0x09,
0x3b, 0xe4, 0x62, 0xbe, 0x15, 0x12, 0x11, 0xe8, 0x25, 0x2c, 0x5e, 0xe1, 0x11, 0xa1, 0xfd, 0xab,
0x89, 0x3b, 0xb8, 0xee, 0x80, 0x30, 0xed, 0x64, 0x4d, 0x0f, 0xb8, 0xc2, 0x01, 0x97, 0x9f, 0x2e,
0x58, 0x70, 0x15, 0x53, 0xe8, 0x39, 0x34, 0x30, 0x75, 0x94, 0xe9, 0xa2, 0x30, 0x5d, 0xcf, 0x45,
0x00, 0x75, 0x22, 0xc3, 0x3a, 0x56, 0xe3, 0x83, 0x1a, 0x54, 0x6e, 0xec, 0x49, 0x88, 0xcd, 0x47,
0xb0, 0x98, 0x8a, 0x14, 0xd4, 0x81, 0xda, 0x14, 0x07, 0x81, 0x3d, 0xc2, 0x22, 0x9c, 0x1a, 0x56,
0x44, 0x9a, 0x2d, 0x68, 0xa6, 0xe3, 0x24, 0x65, 0xc8, 0x63, 0x81, 0x1b, 0xde, 0x60, 0x3f, 0xe0,
0x01, 0xa0, 0x0c, 0x15, 0x69, 0xfe, 0x01, 0x8c, 0x7c, 0x10, 0x20, 0x03, 0xca, 0xd7, 0xf8, 0x56,
0x69, 0xf2, 0x21, 0x6a, 0x2b, 0x87, 0x44, 0x68, 0x36, 0x2c, 0xe5, 0x9d, 0x19, 0xdb, 0xc6, 0x61,
0x80, 0x5a, 0x50, 0x62, 0x33, 0x61, 0xda, 0xb4, 0x4a, 0x6c, 0x66, 0xde, 0x87, 0x56, 0xf6, 0xca,
0xef, 0x68, 0x38, 0xb1, 0xeb, 0xe2, 0xce, 0x10, 0x02, 0xdd, 0xb1, 0x99, 0xad, 0x34, 0xc4, 0x98,
0xf3, 0x3c, 0x9b, 0x8d, 0xd5, 0xf2, 0x62, 0x8c, 0xd6, 0xa1, 0x3a, 0xc6, 0x64, 0x34, 0x66, 0x22,
0x07, 0x74, 0x4b, 0x51, 0xdc, 0x57, 0xcf, 0x77, 0x6f, 0xb0, 0x08, 0xf5, 0xba, 0x25, 0x09, 0x73,
0x19, 0x96, 0x32, 0x81, 0x64, 0x1e, 0xc5, 0xce, 0xc7, 0x17, 0x8f, 0x7e, 0x0b, 0x70, 0x63, 0x4f,
0x88, 0x63, 0x33, 0xd7, 0x0f, 0x3a, 0xda, 0xfd, 0xf2, 0xd6, 0xe2, 0xae, 0xa1, 0xee, 0xeb, 0x5d,
0x24, 0xb0, 0x52, 0x3a, 0xe6, 0x19, 0xac, 0xdc, 0x89, 0x01, 0xee, 0xed, 0xd8, 0x0e, 0xc6, 0xd1,
0x0e, 0xf8, 0x18, 0x3d, 0xe4, 0xde, 0xda, 0x0e, 0xf6, 0x55, 0x76, 0x2f, 0xa9, 0x69, 0x4f, 0x05,
0xd3, 0x52, 0x42, 0x73, 0x1b, 0x96, 0x73, 0x81, 0x91, 0xda, 0xa7, 0x96, 0xde, 0xa7, 0xf9, 0xb1,
0x02, 0x75, 0x0b, 0x07, 0x9e, 0x4b, 0x03, 0x8c, 0x5e, 0x40, 0x03, 0xcf, 0x06, 0x58, 0xe6, 0xb8,
0x96, 0x8b, 0x51, 0xa9, 0x73, 0x1c, 0xc9, 0x79, 0x7c, 0xc7, 0xca, 0x68, 0x5b, 0xe1, 0x53, 0x1e,
0x74, 0x94, 0x51, 0x1a, 0xa0, 0x9e, 0x44, 0x00, 0x55, 0xce, 0x25, 0xa8, 0xd4, 0xcd, 0x21, 0xd4,
0xb6, 0x42, 0x28, 0xbd, 0x70, 0xe2, 0x0c, 0x44, 0xed, 0x65, 0x20, 0xaa, 0x52, 0xe8, 0xfe, 0x1c,
0x8c, 0xda, 0xcb, 0x60, 0x54, 0xb5, 0xd0, 0x74, 0x0e, 0x48, 0x3d, 0x4b, 0x81, 0x54, 0x2d, 0x97,
0x9b, 0xd2, 0xb0, 0x00, 0xa5, 0x9e, 0xc6, 0x28, 0x55, 0xcf, 0xe1, 0x9a, 0x32, 0xc9, 0xc3, 0xd4,
0x93, 0x08, 0xa6, 0x1a, 0x85, 0x87, 0x96, 0xc3, 0xa9, 0xbd, 0x0c, 0x4e, 0x41, 0xe1, 0x76, 0xe6,
0x00, 0xd5, 0x1f, 0xb3, 0x40, 0x25, 0xd1, 0x66, 0x33, 0x67, 0x3b, 0x17, 0xa9, 0x7e, 0x9f, 0x46,
0xaa, 0x66, 0x0e, 0x1f, 0x55, 0x2c, 0x7c, 0x12, 0xaa, 0xb6, 0x79, 0x26, 0xe4, 0x22, 0x8d, 0xe7,
0x22, 0xf6, 0x7d, 0xd7, 0x57, 0x58, 0x22, 0x09, 0x73, 0x8b, 0x67, 0x7c, 0x12, 0x5f, 0x9f, 0x80,
0x35, 0x91, 0xb5, 0xa9, 0xe8, 0x32, 0xff, 0xa5, 0x25, 0xb6, 0x02, 0xd9, 0xd2, 0x68, 0xd1, 0x50,
0x68, 0x91, 0x42, 0xbb, 0x52, 0x06, 0xed, 0xd0, 0x63, 0x58, 0x99, 0xd8, 0x01, 0x93, 0xdb, 0xec,
0x67, 0xe0, 0x63, 0x99, 0x0b, 0xe4, 0xfe, 0x24, 0x8e, 0xfc, 0x06, 0x56, 0x53, 0xba, 0xb6, 0xe7,
0xf5, 0x45, 0x52, 0xeb, 0x22, 0xa9, 0x8d, 0x58, 0x7b, 0xdf, 0xf3, 0x4e, 0xed, 0x60, 0x6c, 0x3e,
0x4c, 0xf6, 0x9f, 0x41, 0xd2, 0x89, 0x3b, 0x8a, 0x90, 0x74, 0xe2, 0x8e, 0xcc, 0x7f, 0x6a, 0x89,
0x5e, 0x82, 0x9a, 0xbf, 0x04, 0x7d, 0xe0, 0x3a, 0x72, 0xfb, 0xad, 0xdd, 0x65, 0x75, 0xf0, 0x87,
0xae, 0x83, 0x2f, 0x6f, 0x3d, 0x6c, 0x09, 0x61, 0xbc, 0xd5, 0x52, 0x0a, 0x18, 0xd5, 0x02, 0xe5,
0x78, 0x01, 0xf4, 0x00, 0x74, 0x66, 0x8f, 0x82, 0x8e, 0x2e, 0xd0, 0x2b, 0x82, 0x99, 0xd7, 0xef,
0xce, 0x6d, 0xe2, 0x5b, 0x42, 0x64, 0xfe, 0x43, 0xe3, 0x28, 0x93, 0x09, 0xf1, 0xcf, 0xe9, 0x81,
0x01, 0xe5, 0x91, 0x1d, 0x88, 0x83, 0xd2, 0x2d, 0x3e, 0xe4, 0x9c, 0x21, 0xc6, 0x22, 0xb1, 0x75,
0x8b, 0x0f, 0xcd, 0xff, 0x6a, 0xc9, 0xcd, 0x4a, 0xd8, 0xff, 0x59, 0x0e, 0xb4, 0xa1, 0x42, 0xa8,
0x83, 0x67, 0xc2, 0x83, 0xb2, 0x25, 0x89, 0xa8, 0x5e, 0x95, 0x85, 0x57, 0xd9, 0x7a, 0x25, 0x6f,
0x4b, 0x12, 0xaa, 0x32, 0xb8, 0x43, 0xe1, 0x48, 0xd3, 0x92, 0x44, 0x0a, 0x5f, 0xab, 0x99, 0x3a,
0xa2, 0x36, 0x56, 0x4b, 0xee, 0xee, 0xaf, 0xbc, 0x96, 0xa5, 0xd3, 0xfc, 0x33, 0x9e, 0x9a, 0xb9,
0x9a, 0xc4, 0x45, 0x9c, 0xe0, 0x66, 0x1b, 0xd0, 0xdd, 0xcc, 0x95, 0x35, 0x3b, 0x9b, 0x93, 0xe8,
0x57, 0x50, 0x71, 0xc8, 0x70, 0x38, 0xbf, 0x6a, 0x49, 0xb1, 0xf9, 0xef, 0x12, 0x54, 0x65, 0xcd,
0x41, 0x9b, 0x1c, 0xff, 0x6c, 0x42, 0xfb, 0xc4, 0x89, 0xf2, 0x4e, 0xd0, 0x3d, 0x27, 0x75, 0x26,
0xa5, 0xcc, 0x99, 0x20, 0xd0, 0x19, 0x99, 0x62, 0x95, 0x32, 0x62, 0x8c, 0x36, 0xa0, 0x46, 0xc3,
0x69, 0x9f, 0xcd, 0xa2, 0x2b, 0xaf, 0xd2, 0x70, 0x7a, 0x39, 0x0b, 0xd0, 0x2e, 0x2c, 0xa5, 0x12,
0x88, 0x38, 0x0a, 0xd8, 0x5b, 0xca, 0x35, 0xe1, 0x77, 0xef, 0xc8, 0x5a, 0x8c, 0x53, 0xa9, 0xe7,
0xa0, 0x2d, 0x10, 0x99, 0xd5, 0x97, 0xe0, 0x29, 0x33, 0xae, 0x2a, 0xce, 0xad, 0xc5, 0xf9, 0x0a,
0x5d, 0x79, 0x41, 0xbd, 0x07, 0x0d, 0x7e, 0x92, 0x52, 0xa5, 0x26, 0x54, 0xea, 0x9c, 0x21, 0x84,
0x8f, 0x60, 0x39, 0x29, 0xd2, 0x52, 0xa5, 0x2e, 0x67, 0x49, 0xd8, 0x42, 0x71, 0x13, 0xea, 0x71,
0x66, 0x37, 0x84, 0x46, 0xcd, 0x56, 0x09, 0xdd, 0x83, 0x9a, 0x72, 0xb1, 0xb0, 0xa0, 0x3f, 0x86,
0x8a, 0x67, 0xfb, 0x2c, 0x50, 0x85, 0x33, 0xc2, 0xf5, 0x73, 0xdb, 0xe7, 0x9d, 0x94, 0x2a, 0xeb,
0x52, 0xc5, 0xdc, 0x83, 0xa5, 0x0c, 0x9f, 0x47, 0x22, 0x73, 0x99, 0x3d, 0x51, 0x25, 0x5d, 0x12,
0xf1, 0x32, 0xa5, 0x64, 0x19, 0x73, 0x0f, 0x1a, 0xf1, 0x1d, 0xf2, 0x6b, 0xf1, 0xc2, 0xab, 0xd7,
0xaa, 0x37, 0x6b, 0x5a, 0x8a, 0x12, 0x81, 0xed, 0x7e, 0x50, 0xbd, 0x85, 0x6e, 0x49, 0xc2, 0xfc,
0x8f, 0x06, 0x55, 0x99, 0xf7, 0x05, 0x1d, 0xdd, 0xef, 0x44, 0xab, 0x13, 0xe2, 0x3e, 0x77, 0x5b,
0xd8, 0xb5, 0xe2, 0xbf, 0x08, 0x69, 0xb4, 0x23, 0x42, 0xb8, 0x21, 0xb4, 0xf8, 0x10, 0x3d, 0x80,
0xa6, 0x34, 0x09, 0x98, 0x4f, 0x68, 0x14, 0xbc, 0x8b, 0x82, 0x77, 0x21, 0x58, 0xfc, 0x52, 0xa4,
0x0a, 0xa1, 0x4c, 0x44, 0x43, 0xd9, 0xaa, 0x0b, 0x46, 0x8f, 0x32, 0xf3, 0x1e, 0xe8, 0x62, 0x1e,
0x80, 0xea, 0xc5, 0xa5, 0xd5, 0x3b, 0x3b, 0x31, 0x16, 0x50, 0x0d, 0xca, 0xbd, 0xb3, 0x4b, 0x43,
0x7b, 0xfc, 0xbf, 0x0a, 0xd4, 0xa3, 0xbc, 0x41, 0x55, 0x28, 0xbd, 0x79, 0x6d, 0x2c, 0xa0, 0x15,
0x58, 0xea, 0x51, 0x86, 0x7d, 0x6a, 0x4f, 0x8e, 0x79, 0xe5, 0x30, 0x34, 0xce, 0x3a, 0xa6, 0x03,
0xd7, 0x21, 0x74, 0x24, 0x59, 0x25, 0xd4, 0x84, 0xfa, 0x81, 0xed, 0x9c, 0xb9, 0x74, 0x80, 0x8d,
0x32, 0x32, 0xa0, 0xf9, 0x96, 0xda, 0x21, 0x1b, 0xbb, 0x3e, 0xf9, 0x3b, 0x76, 0x0c, 0x1d, 0xad,
0xc1, 0x4a, 0x8f, 0x06, 0xe1, 0x70, 0x48, 0x06, 0x04, 0x53, 0xf6, 0x2a, 0xa4, 0x4e, 0x60, 0x54,
0x10, 0x82, 0xd6, 0x5b, 0x7a, 0x4d, 0xdd, 0x0f, 0x54, 0x75, 0x5c, 0x46, 0x15, 0x75, 0xa0, 0x7d,
0x60, 0x07, 0xf8, 0x28, 0xf4, 0x26, 0x64, 0x60, 0x33, 0xbc, 0xef, 0x38, 0x3e, 0x0e, 0x02, 0x03,
0xf3, 0x49, 0xb8, 0x24, 0xbb, 0xf6, 0x30, 0x32, 0xc8, 0xcc, 0x8f, 0x71, 0x60, 0x8c, 0xd0, 0x26,
0xac, 0xdd, 0x91, 0x88, 0x95, 0xc7, 0xe8, 0x17, 0xd0, 0xc9, 0x8b, 0x4e, 0xec, 0xe0, 0xdc, 0x27,
0x03, 0x6c, 0x10, 0xd4, 0x06, 0x43, 0x4a, 0x45, 0xa8, 0xf6, 0xa8, 0x17, 0x32, 0xe3, 0x6f, 0xd1,
0xfa, 0x8a, 0xfb, 0x26, 0x64, 0x9c, 0x7d, 0x9d, 0x63, 0x9f, 0x8b, 0x70, 0x30, 0x26, 0x68, 0x03,
0x56, 0x53, 0xec, 0x0b, 0xbe, 0x3f, 0x7e, 0x3a, 0xd3, 0xc4, 0x5f, 0x29, 0x20, 0x23, 0x6a, 0xb3,
0xd0, 0xc7, 0x06, 0x45, 0xeb, 0x80, 0xb8, 0x44, 0x1d, 0x49, 0xb4, 0x71, 0x37, 0x5a, 0x41, 0xf1,
0xd5, 0x0a, 0x5e, 0x9e, 0x3d, 0x09, 0x47, 0x84, 0x1a, 0xef, 0xd1, 0x1a, 0x18, 0x27, 0xee, 0x8d,
0xe2, 0x1e, 0x53, 0x46, 0xd8, 0xad, 0xf1, 0x85, 0x86, 0xda, 0xb0, 0x9c, 0xb0, 0x4f, 0x7c, 0x37,
0xf4, 0x8c, 0x2f, 0x35, 0xb4, 0x01, 0x28, 0xe1, 0x9e, 0xfb, 0xae, 0xe7, 0x06, 0xf6, 0xc4, 0xf8,
0x4a, 0x43, 0xeb, 0xb0, 0x72, 0xe2, 0xde, 0xc4, 0xb7, 0x20, 0x0d, 0xbe, 0x8e, 0x0c, 0x62, 0xfe,
0x9f, 0xf1, 0xf4, 0x0a, 0xfb, 0xc6, 0x37, 0x1a, 0xda, 0x84, 0x76, 0x5a, 0x10, 0xcf, 0xf5, 0xad,
0xa6, 0x3c, 0x8a, 0x45, 0xef, 0x5c, 0x86, 0x8d, 0xef, 0x22, 0xb6, 0x3a, 0x07, 0x35, 0xd1, 0xf7,
0x1a, 0x5a, 0x85, 0x56, 0xc2, 0x16, 0xba, 0x3f, 0x68, 0xa8, 0x0b, 0x6b, 0x19, 0x26, 0xa1, 0xa3,
0x73, 0x9e, 0x61, 0xc6, 0x8f, 0xda, 0xee, 0xc7, 0x0a, 0x2c, 0xef, 0x1f, 0x1c, 0xf6, 0xf6, 0x3d,
0xb9, 0x00, 0xaf, 0xfa, 0x4f, 0x41, 0x17, 0x7d, 0x4d, 0xc1, 0xcf, 0x7e, 0xb7, 0xa8, 0xc1, 0x46,
0xbb, 0x50, 0x11, 0xed, 0x0d, 0x2a, 0xfa, 0xe7, 0xef, 0x16, 0xf6, 0xd9, 0x7c, 0x11, 0xd9, 0x00,
0xdd, 0xfd, 0xf5, 0xef, 0x16, 0x35, 0xdb, 0xe8, 0x4f, 0xd0, 0x48, 0x1a, 0x93, 0x79, 0x0f, 0x00,
0xdd, 0xb9, 0x6d, 0x37, 0xb7, 0x4f, 0x1a, 0x96, 0x79, 0xcf, 0x00, 0xdd, 0xb9, 0xbd, 0x37, 0x7a,
0x01, 0xb5, 0xa8, 0xd9, 0x28, 0x7e, 0x0c, 0xe8, 0xce, 0x69, 0xbf, 0xf9, 0xf1, 0xc8, 0x1e, 0xa1,
0xe8, 0x1f, 0xbf, 0x5b, 0xd8, 0x51, 0xa3, 0xe7, 0x50, 0x55, 0x35, 0xba, 0xf0, 0x1d, 0xa1, 0x5b,
0xdc, 0xb7, 0xf3, 0x4d, 0x26, 0xbf, 0x83, 0xf3, 0x1e, 0x08, 0xba, 0x73, 0x3b, 0x72, 0xb4, 0x0f,
0x90, 0xfa, 0x11, 0x9c, 0xfb, 0x4c, 0xd0, 0x9d, 0xdf, 0x97, 0xa3, 0x97, 0x50, 0x4f, 0xfe, 0xfd,
0x8a, 0x1f, 0x0b, 0xba, 0xf3, 0x5a, 0xf3, 0xab, 0xaa, 0x78, 0x87, 0x7a, 0xf6, 0x53, 0x00, 0x00,
0x00, 0xff, 0xff, 0x3c, 0xa1, 0xc6, 0x00, 0x9c, 0x12, 0x00, 0x00,
// 1395 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x97, 0x4b, 0x6f, 0xdb, 0x46,
0x10, 0x80, 0x2d, 0x89, 0x7a, 0x70, 0xe4, 0x87, 0xb2, 0x71, 0x13, 0x46, 0xb9, 0x24, 0x04, 0xd2,
0xd8, 0x69, 0xea, 0xb4, 0x0e, 0x52, 0xc4, 0x4d, 0x51, 0xc0, 0x4e, 0xd2, 0x4a, 0x0d, 0x90, 0xa6,
0x1b, 0x23, 0x57, 0x81, 0x16, 0x57, 0x12, 0x61, 0x99, 0x64, 0xc8, 0x95, 0x2b, 0xff, 0x87, 0xdc,
0x7b, 0xee, 0xa9, 0x40, 0x7f, 0x48, 0x7f, 0x57, 0x31, 0xb3, 0xcb, 0xa7, 0xc9, 0x1c, 0xda, 0x0b,
0xb1, 0xb3, 0x33, 0xb3, 0xdc, 0xc7, 0xcc, 0xb7, 0xb3, 0x70, 0x43, 0x5e, 0x85, 0x22, 0x7e, 0x42,
0xdf, 0x83, 0x30, 0x0a, 0x64, 0xc0, 0xda, 0x24, 0xd8, 0xff, 0x18, 0xd0, 0xe5, 0xe2, 0xe3, 0x4a,
0xc4, 0x92, 0xed, 0x81, 0x21, 0xa6, 0x8b, 0xc0, 0x6a, 0xdc, 0x6b, 0xec, 0xf5, 0x0f, 0xd9, 0x81,
0x32, 0xd7, 0xda, 0xd7, 0xd3, 0x45, 0x30, 0xda, 0xe0, 0x64, 0xc1, 0xbe, 0x82, 0xf6, 0x6c, 0xb9,
0x8a, 0x17, 0x56, 0x93, 0x4c, 0x6f, 0x16, 0x4d, 0x7f, 0x42, 0xd5, 0x68, 0x83, 0x2b, 0x1b, 0x1c,
0xd6, 0xf3, 0x67, 0x81, 0xd5, 0xaa, 0x1a, 0x76, 0xec, 0xcf, 0x68, 0x58, 0xb4, 0x60, 0xcf, 0x01,
0x62, 0x21, 0x27, 0x41, 0x28, 0xbd, 0xc0, 0xb7, 0x0c, 0xb2, 0xbf, 0x5d, 0xb4, 0x7f, 0x2f, 0xe4,
0xaf, 0xa4, 0x1e, 0x6d, 0x70, 0x33, 0x4e, 0x04, 0xf4, 0x74, 0xc5, 0xd2, 0xbb, 0x14, 0xd1, 0x44,
0xae, 0xad, 0x76, 0x95, 0xe7, 0x2b, 0xa5, 0x3f, 0x5d, 0xa3, 0xa7, 0x9b, 0x08, 0xec, 0x10, 0x7a,
0xd3, 0x85, 0x98, 0x9e, 0xa3, 0x5f, 0x87, 0xfc, 0xbe, 0x28, 0xfa, 0xbd, 0x44, 0x2d, 0x79, 0x75,
0xa7, 0xaa, 0xc9, 0x0e, 0xa0, 0x33, 0x0d, 0x2e, 0x2e, 0x3c, 0x69, 0x75, 0xc9, 0x63, 0xb7, 0xe4,
0x41, 0xba, 0xd1, 0x06, 0xd7, 0x56, 0xb8, 0x5d, 0x1f, 0x57, 0x22, 0xba, 0xb2, 0x7a, 0x55, 0xdb,
0xf5, 0x1b, 0xaa, 0x70, 0xbb, 0xc8, 0x06, 0x97, 0xe2, 0xf9, 0x9e, 0x9c, 0x4c, 0x17, 0x8e, 0xe7,
0x5b, 0x66, 0xd5, 0x52, 0xc6, 0xbe, 0x27, 0x5f, 0xa2, 0x1a, 0x97, 0xe2, 0x25, 0x02, 0x7b, 0x01,
0xfd, 0x33, 0x31, 0xf7, 0xfc, 0xc9, 0xd9, 0x32, 0x98, 0x9e, 0x5b, 0x40, 0xae, 0x56, 0xd1, 0xf5,
0x04, 0x0d, 0x4e, 0x50, 0x3f, 0xda, 0xe0, 0x70, 0x96, 0x4a, 0xec, 0x19, 0x98, 0xc2, 0x77, 0xb5,
0x6b, 0x9f, 0x5c, 0x6f, 0x95, 0x22, 0xc0, 0x77, 0x13, 0xc7, 0x9e, 0xd0, 0xed, 0x93, 0x2e, 0xb4,
0x2f, 0x9d, 0xe5, 0x4a, 0xd8, 0x0f, 0xa1, 0x9f, 0x8b, 0x14, 0x66, 0x41, 0xf7, 0x42, 0xc4, 0xb1,
0x33, 0x17, 0x14, 0x4e, 0x26, 0x4f, 0x44, 0x7b, 0x1b, 0x36, 0xf3, 0x71, 0x92, 0x73, 0xc4, 0x58,
0x40, 0xc7, 0x4b, 0x11, 0xc5, 0x18, 0x00, 0xda, 0x51, 0x8b, 0xf6, 0xf7, 0x30, 0x28, 0x07, 0x01,
0x1b, 0x40, 0xeb, 0x5c, 0x5c, 0x69, 0x4b, 0x6c, 0xb2, 0x5d, 0x3d, 0x21, 0x0a, 0x4d, 0x93, 0xeb,
0xd9, 0xd9, 0xa9, 0x6f, 0x1a, 0x06, 0x6c, 0x1b, 0x9a, 0x72, 0x4d, 0xae, 0x9b, 0xbc, 0x29, 0xd7,
0xf6, 0x3d, 0xd8, 0x2e, 0x1e, 0xf9, 0x35, 0x0b, 0x37, 0x9d, 0x3a, 0x9d, 0x19, 0x63, 0x60, 0xb8,
0x8e, 0x74, 0xb4, 0x05, 0xb5, 0xb1, 0x2f, 0x74, 0xe4, 0x42, 0xff, 0x9e, 0xda, 0xec, 0x16, 0x74,
0x16, 0xc2, 0x9b, 0x2f, 0x24, 0xe5, 0x80, 0xc1, 0xb5, 0x84, 0x73, 0x0d, 0xa3, 0xe0, 0x52, 0x50,
0xa8, 0xf7, 0xb8, 0x12, 0xec, 0x1d, 0xd8, 0x2a, 0x04, 0x92, 0xfd, 0x2a, 0x9d, 0x7c, 0x7a, 0xf0,
0xec, 0x1b, 0x80, 0x4b, 0x67, 0xe9, 0xb9, 0x8e, 0x0c, 0xa2, 0xd8, 0x6a, 0xdc, 0x6b, 0xed, 0xf5,
0x0f, 0x07, 0xfa, 0xbc, 0x3e, 0x24, 0x0a, 0x9e, 0xb3, 0xb1, 0xdf, 0xc2, 0x8d, 0x6b, 0x31, 0x80,
0xb3, 0x5d, 0x38, 0xf1, 0x22, 0x59, 0x01, 0xb6, 0xd9, 0x03, 0x9c, 0xad, 0xe3, 0x8a, 0x48, 0x67,
0xf7, 0x96, 0x1e, 0x76, 0x44, 0x9d, 0x5c, 0x2b, 0xed, 0x7d, 0xd8, 0x29, 0x05, 0x46, 0x6e, 0x9d,
0x8d, 0xfc, 0x3a, 0xed, 0x4f, 0x6d, 0xe8, 0x71, 0x11, 0x87, 0x81, 0x1f, 0x0b, 0xf6, 0x1c, 0x4c,
0xb1, 0x9e, 0x0a, 0x95, 0xe3, 0x8d, 0x52, 0x8c, 0x2a, 0x9b, 0xd7, 0x89, 0x1e, 0xe3, 0x3b, 0x35,
0x66, 0xfb, 0x9a, 0x4f, 0x65, 0xe8, 0x68, 0xa7, 0x3c, 0xa0, 0x1e, 0x27, 0x80, 0x6a, 0x95, 0x12,
0x54, 0xd9, 0x96, 0x08, 0xb5, 0xaf, 0x09, 0x65, 0x54, 0x0e, 0x5c, 0x40, 0xd4, 0x51, 0x01, 0x51,
0xed, 0xca, 0xe9, 0xd7, 0x30, 0xea, 0xa8, 0xc0, 0xa8, 0x4e, 0xa5, 0x6b, 0x0d, 0xa4, 0x9e, 0xe6,
0x20, 0xd5, 0x2d, 0xe5, 0xa6, 0x72, 0xac, 0xa0, 0xd4, 0x93, 0x94, 0x52, 0xbd, 0x12, 0xd7, 0xb4,
0x4b, 0x19, 0x53, 0x8f, 0x13, 0x4c, 0x99, 0x95, 0x9b, 0x56, 0xe2, 0xd4, 0x51, 0x81, 0x53, 0x50,
0xb9, 0x9c, 0x1a, 0x50, 0xfd, 0x50, 0x04, 0x95, 0xa2, 0xcd, 0x9d, 0x92, 0x6f, 0x2d, 0xa9, 0xbe,
0xcb, 0x93, 0x6a, 0xb3, 0xc4, 0x47, 0x1d, 0x0b, 0x9f, 0x45, 0xd5, 0x3e, 0x66, 0x42, 0x29, 0xd2,
0x30, 0x17, 0x45, 0x14, 0x05, 0x91, 0x66, 0x89, 0x12, 0xec, 0x3d, 0xcc, 0xf8, 0x2c, 0xbe, 0x3e,
0x83, 0x35, 0xca, 0xda, 0x5c, 0x74, 0xd9, 0x7f, 0x34, 0x32, 0x5f, 0x22, 0x5b, 0x9e, 0x16, 0xa6,
0xa6, 0x45, 0x8e, 0x76, 0xcd, 0x02, 0xed, 0xd8, 0x23, 0xb8, 0xb1, 0x74, 0x62, 0xa9, 0x96, 0x39,
0x29, 0xe0, 0x63, 0x07, 0x15, 0x6a, 0x7d, 0x8a, 0x23, 0x5f, 0xc3, 0xcd, 0x9c, 0xad, 0x13, 0x86,
0x13, 0x4a, 0x6a, 0x83, 0x92, 0x7a, 0x90, 0x5a, 0x1f, 0x87, 0xe1, 0xc8, 0x89, 0x17, 0xf6, 0x83,
0x6c, 0xfd, 0x05, 0x92, 0x2e, 0x83, 0x79, 0x42, 0xd2, 0x65, 0x30, 0xb7, 0xc3, 0xcc, 0x2c, 0x83,
0x26, 0x03, 0x63, 0x1a, 0xb8, 0x6a, 0xf5, 0x5b, 0x9c, 0xda, 0xe9, 0xc2, 0x9a, 0x39, 0x0c, 0xea,
0xe1, 0x5a, 0xe9, 0x70, 0xec, 0x3e, 0x18, 0xd2, 0x99, 0xc7, 0x96, 0x41, 0xac, 0x4a, 0xa0, 0xf2,
0xe6, 0xc3, 0x3b, 0xc7, 0x8b, 0x38, 0xa9, 0xec, 0x00, 0x91, 0x52, 0x88, 0xe7, 0xff, 0xf1, 0xbf,
0x01, 0xb4, 0xe6, 0x4e, 0x4c, 0x9b, 0x60, 0x70, 0x6c, 0x62, 0xcf, 0x4c, 0x08, 0x4a, 0x5a, 0x83,
0x63, 0xd3, 0xfe, 0xb3, 0x91, 0x9d, 0x5a, 0x8a, 0xf4, 0x6b, 0xff, 0xdb, 0x85, 0xb6, 0xe7, 0xbb,
0x62, 0x4d, 0x3f, 0x6c, 0x71, 0x25, 0x24, 0x57, 0x4f, 0x8b, 0x26, 0x51, 0xbc, 0x7a, 0xd4, 0xc6,
0x2b, 0x41, 0x43, 0x3e, 0x98, 0xd1, 0x7f, 0x37, 0xb9, 0x12, 0x72, 0xa8, 0xec, 0x14, 0xae, 0x04,
0xbd, 0x8e, 0x6e, 0x76, 0x0c, 0xbf, 0xe0, 0xb5, 0x94, 0xcf, 0xd8, 0xff, 0xbe, 0x27, 0xf6, 0xcd,
0xec, 0x48, 0xd3, 0xd4, 0xb4, 0x77, 0x81, 0x5d, 0xcf, 0x39, 0x75, 0xdb, 0x16, 0xb3, 0x89, 0x7d,
0x09, 0x6d, 0xd7, 0x9b, 0xcd, 0xea, 0xef, 0x1b, 0xa5, 0xb6, 0xff, 0x6a, 0x42, 0x47, 0xdd, 0x16,
0xec, 0x0e, 0x92, 0xcb, 0xf1, 0xfc, 0x89, 0xe7, 0x26, 0x19, 0x43, 0xf2, 0xd8, 0xcd, 0x6d, 0x41,
0xb3, 0xb0, 0x05, 0x0c, 0x0c, 0xe9, 0x5d, 0x08, 0x1d, 0xec, 0xd4, 0x66, 0xb7, 0xa1, 0xeb, 0xaf,
0x2e, 0x26, 0x72, 0x9d, 0x1c, 0x68, 0xc7, 0x5f, 0x5d, 0x9c, 0xae, 0x63, 0x76, 0x08, 0x5b, 0xb9,
0xd0, 0xf7, 0x5c, 0x8d, 0xe4, 0x6d, 0x3d, 0x35, 0x9a, 0xf7, 0xf8, 0x15, 0xef, 0xa7, 0x49, 0x30,
0x76, 0xd9, 0x1e, 0x50, 0x4e, 0x4c, 0x14, 0xf6, 0x54, 0xae, 0x74, 0x68, 0xdf, 0xb6, 0xb1, 0x5f,
0x73, 0x11, 0xaf, 0xc2, 0xbb, 0x60, 0xe2, 0x4e, 0x2a, 0x93, 0x2e, 0x99, 0xf4, 0xb0, 0x83, 0x94,
0x0f, 0x61, 0x27, 0xbb, 0x5e, 0x95, 0x49, 0x4f, 0x8d, 0x92, 0x75, 0x93, 0xe1, 0x1d, 0xe8, 0xa5,
0x39, 0x69, 0x92, 0x45, 0xd7, 0xd1, 0xa9, 0x38, 0x86, 0xae, 0x9e, 0x62, 0xe5, 0x55, 0xfc, 0x08,
0xda, 0xa1, 0x13, 0xc9, 0x58, 0x5f, 0x79, 0x09, 0x91, 0xdf, 0x39, 0x11, 0xd6, 0x40, 0xfa, 0x42,
0x56, 0x26, 0xf6, 0x11, 0x6c, 0x15, 0xfa, 0x31, 0xf0, 0x64, 0x20, 0x9d, 0xa5, 0xbe, 0x8c, 0x95,
0x90, 0xfe, 0xa6, 0x99, 0xfd, 0xc6, 0x3e, 0x02, 0x33, 0x3d, 0x43, 0x3c, 0x96, 0x70, 0x75, 0xf6,
0x46, 0x57, 0x55, 0x9b, 0x5c, 0x4b, 0x14, 0xc7, 0xc1, 0xef, 0xba, 0x2a, 0x30, 0xb8, 0x12, 0xec,
0xbf, 0x1b, 0xd0, 0x51, 0x39, 0x5c, 0x51, 0x8b, 0x7d, 0x4b, 0x45, 0xca, 0x4a, 0x4c, 0x70, 0xda,
0xe4, 0xb7, 0x9d, 0xd6, 0xff, 0xca, 0xe9, 0xe0, 0xf4, 0x2a, 0x14, 0xdc, 0x24, 0x2b, 0x6c, 0xb2,
0xfb, 0xb0, 0xa9, 0x5c, 0x62, 0x19, 0x79, 0x7e, 0x12, 0xbc, 0x7d, 0xea, 0x7b, 0x4f, 0x5d, 0x78,
0x28, 0xca, 0xc4, 0xf3, 0x25, 0x45, 0x43, 0x8b, 0xf7, 0xa8, 0x63, 0xec, 0x4b, 0xfb, 0x2e, 0x18,
0x34, 0x0e, 0x40, 0xe7, 0xfd, 0x29, 0x1f, 0xbf, 0xfd, 0x79, 0xb0, 0xc1, 0xba, 0xd0, 0x1a, 0xbf,
0x3d, 0x1d, 0x34, 0x0e, 0x3f, 0xb5, 0x61, 0xe7, 0xf8, 0xe4, 0xe5, 0xf8, 0x38, 0x0c, 0x97, 0xde,
0xd4, 0x21, 0xee, 0x3d, 0x01, 0x83, 0xc8, 0x5e, 0xf1, 0xdc, 0x19, 0x56, 0x95, 0x18, 0xec, 0x10,
0xda, 0x04, 0x78, 0x56, 0xf5, 0xea, 0x19, 0x56, 0x56, 0x1a, 0xf8, 0x13, 0x75, 0x05, 0x5c, 0x7f,
0xfc, 0x0c, 0xab, 0xca, 0x0d, 0xf6, 0x23, 0x98, 0x19, 0x9a, 0xeb, 0x9e, 0x40, 0xc3, 0xda, 0xc2,
0x03, 0xfd, 0x33, 0x66, 0xd7, 0x3d, 0x84, 0x86, 0xb5, 0xd5, 0x07, 0x7b, 0x0e, 0xdd, 0x84, 0xc0,
0xd5, 0xcf, 0xa1, 0x61, 0x4d, 0x01, 0x82, 0xdb, 0xa3, 0x48, 0x5a, 0xf5, 0xca, 0x19, 0x56, 0xd6,
0x14, 0xec, 0x19, 0x74, 0x34, 0xda, 0x2a, 0x5f, 0x52, 0xc3, 0xea, 0xca, 0x05, 0x17, 0x99, 0x15,
0xc4, 0x75, 0x4f, 0xa4, 0x61, 0x6d, 0x4d, 0xc2, 0x8e, 0x01, 0x72, 0xa5, 0x70, 0xed, 0x43, 0x69,
0x58, 0x5f, 0x99, 0xb0, 0x17, 0xd0, 0xcb, 0xaa, 0xdf, 0xea, 0xe7, 0xd2, 0xb0, 0xae, 0x38, 0x39,
0xeb, 0xd0, 0x4b, 0xfc, 0xe9, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x90, 0x66, 0x37, 0xca, 0x9e,
0x0f, 0x00, 0x00,
}

+ 4
- 47
types/types.proto View File

@ -3,49 +3,6 @@ package types;
// This file is copied from http://github.com/tendermint/abci
//----------------------------------------
// Code types
enum CodeType {
OK = 0;
// General response codes, 0 ~ 99
InternalError = 1;
EncodingError = 2;
BadNonce = 3;
Unauthorized = 4;
InsufficientFunds = 5;
UnknownRequest = 6;
// Reserved for basecoin, 100 ~ 199
BaseDuplicateAddress = 101;
BaseEncodingError = 102;
BaseInsufficientFees = 103;
BaseInsufficientFunds = 104;
BaseInsufficientGasPrice = 105;
BaseInvalidInput = 106;
BaseInvalidOutput = 107;
BaseInvalidPubKey = 108;
BaseInvalidSequence = 109;
BaseInvalidSignature = 110;
BaseUnknownAddress = 111;
BaseUnknownPubKey = 112;
BaseUnknownPlugin = 113;
// Reserved for governance, 200 ~ 299
GovUnknownEntity = 201;
GovUnknownGroup = 202;
GovUnknownProposal = 203;
GovDuplicateGroup = 204;
GovDuplicateMember = 205;
GovDuplicateProposal = 206;
GovDuplicateVote = 207;
GovInvalidMember = 208;
GovInvalidVote = 209;
GovInvalidVotingPower = 210;
}
//----------------------------------------
// Request types
@ -156,14 +113,14 @@ message ResponseSetOption{
}
message ResponseDeliverTx{
CodeType code = 1;
uint32 code = 1;
bytes data = 2;
string log = 3;
repeated KVPair tags = 4;
}
message ResponseCheckTx{
CodeType code = 1;
uint32 code = 1;
bytes data = 2;
string log = 3;
uint64 gas = 4;
@ -171,7 +128,7 @@ message ResponseCheckTx{
}
message ResponseQuery{
CodeType code = 1;
uint32 code = 1;
int64 index = 2;
bytes key = 3;
bytes value = 4;
@ -181,7 +138,7 @@ message ResponseQuery{
}
message ResponseCommit{
CodeType code = 1;
uint32 code = 1;
bytes data = 2;
string log = 3;
}


Write Preview
Loading…
Cancel
Save