mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-09-17 05:24:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixing tests...

Browse Source
This commit is contained in:
Jae Kwon
2018-07-10 02:40:34 -07:00
parent ad873c761e
commit 77a51e738c
11 changed files with 236 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Gopkg.lock
Generated
+10 -1
View File
@@ -302,6 +302,15 @@
revision = "2106ca61d91029c931fd54968c2bb02dc96b1412"
version = "0.10.1"
[[projects]]
name = "github.com/tendermint/iavl"
packages = [
".",
"sha256truncated"
]
revision = "8ca620e7e401976d0324938c9a361cf78bca9770"
version = "v0.9.3-rc0"
[[projects]]
name = "github.com/tendermint/tmlibs"
packages = [
@@ -423,6 +432,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
inputs-digest = "c25289282b94abc7f0c390e592e5e1636b7f26cb4773863ac39cde7fdc7b5bdf"
inputs-digest = "e473d5da80b2f997f7b1e42ff6eb0fff055fa0ff9ab1a9f0bd01ed239b479fe3"
solver-name = "gps-cdcl"
solver-version = 1
Gopkg.toml
+4
View File
@@ -73,6 +73,10 @@
name = "github.com/tendermint/go-amino"
version = "~0.10.1"
[[constraint]]
name = "github.com/tendermint/iavl"
version = "0.9.3-rc0"
[[override]]
name = "github.com/tendermint/tmlibs"
version = "~0.9.0"
abci/cmd/abci-cli/abci-cli.go
+2 -1
View File
@@ -22,6 +22,7 @@ import (
servertest "github.com/tendermint/tendermint/abci/tests/server"
"github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/abci/version"
"github.com/tendermint/tendermint/crypto/merkle"
)
// client is a global variable so it can be reused by the console
@@ -100,7 +101,7 @@ type queryResponse struct {
Key []byte
Value []byte
Height int64
Proof []types.ProofOp
Proof *merkle.Proof
}
func Execute() error {
abci/example/code/code.go
+1
View File
@@ -6,4 +6,5 @@ const (
CodeTypeEncodingError uint32 = 1
CodeTypeBadNonce uint32 = 2
CodeTypeUnauthorized uint32 = 3
CodeTypeUnknownError uint32 = 4
)
abci/example/kvstore/kvstore.go
+35 -24
View File
@@ -2,10 +2,10 @@ package kvstore
import (
"bytes"
"encoding/binary"
"encoding/json"
"fmt"
"github.com/tendermint/iavl"
"github.com/tendermint/tendermint/abci/example/code"
"github.com/tendermint/tendermint/abci/types"
cmn "github.com/tendermint/tmlibs/common"
@@ -13,20 +13,21 @@ import (
)
var (
stateKey = []byte("stateKey")
kvPairPrefixKey = []byte("kvPairKey:")
stateKey = []byte("stateKey")
)
type State struct {
db dbm.DB
db dbm.DB
tree *iavl.VersionedTree
Size int64 `json:"size"`
Height int64 `json:"height"`
AppHash []byte `json:"app_hash"`
}
func loadState(db dbm.DB) State {
func loadState(db dbm.DB) *State {
stateBytes := db.Get(stateKey)
var state State
var state = new(State)
if len(stateBytes) != 0 {
err := json.Unmarshal(stateBytes, &state)
if err != nil {
@@ -34,10 +35,22 @@ func loadState(db dbm.DB) State {
}
}
state.db = db
state.tree = iavl.NewVersionedTree(db, 0)
state.tree.LoadVersion(state.Height)
return state
}
func saveState(state State) {
func saveState(state *State) {
hash, version, err := state.tree.SaveVersion()
if err != nil {
panic(err)
}
state.AppHash = hash
if state.Height+1 != version {
panic("should not happen, expected version to be 1+state.Height.")
}
state.Height = version
stateBytes, err := json.Marshal(state)
if err != nil {
panic(err)
@@ -45,10 +58,6 @@ func saveState(state State) {
state.db.Set(stateKey, stateBytes)
}
func prefixKey(key []byte) []byte {
return append(kvPairPrefixKey, key...)
}
//---------------------------------------------------
var _ types.Application = (*KVStoreApplication)(nil)
@@ -56,7 +65,7 @@ var _ types.Application = (*KVStoreApplication)(nil)
type KVStoreApplication struct {
types.BaseApplication
state State
state *State
}
func NewKVStoreApplication() *KVStoreApplication {
@@ -77,11 +86,11 @@ func (app *KVStoreApplication) DeliverTx(tx []byte) types.ResponseDeliverTx {
} else {
key, value = tx, tx
}
app.state.db.Set(prefixKey(key), value)
app.state.tree.Set(key, value)
app.state.Size += 1
tags := []cmn.KVPair{
{[]byte("app.creator"), []byte("jae")},
{[]byte("app.creator"), []byte("Cosmoshi Netowoko")},
{[]byte("app.key"), key},
}
return types.ResponseDeliverTx{Code: code.CodeTypeOK, Tags: tags}
@@ -92,20 +101,20 @@ func (app *KVStoreApplication) CheckTx(tx []byte) types.ResponseCheckTx {
}
func (app *KVStoreApplication) Commit() types.ResponseCommit {
// Using a memdb - just return the big endian size of the db
appHash := make([]byte, 8)
binary.PutVarint(appHash, app.state.Size)
app.state.AppHash = appHash
app.state.Height += 1
saveState(app.state)
return types.ResponseCommit{Data: appHash}
return types.ResponseCommit{Data: app.state.AppHash}
}
func (app *KVStoreApplication) Query(reqQuery types.RequestQuery) (resQuery types.ResponseQuery) {
// NOTE: This isn't proving anything yet.
key := reqQuery.Data
if reqQuery.Prove {
value := app.state.db.Get(prefixKey(reqQuery.Data))
resQuery.Index = -1 // TODO make Proof return index
value, proof, err := app.state.tree.GetWithProof(key)
if err != nil {
resQuery.Code = code.CodeTypeUnknownError
resQuery.Log = err.Error()
return
}
resQuery.Index = proof.LeftIndex() // TODO make Proof return index
resQuery.Key = reqQuery.Data
resQuery.Value = value
if value != nil {
@@ -115,7 +124,9 @@ func (app *KVStoreApplication) Query(reqQuery types.RequestQuery) (resQuery type
}
return
} else {
value := app.state.db.Get(prefixKey(reqQuery.Data))
index, value := app.state.tree.Get64(key)
resQuery.Index = index
resQuery.Key = reqQuery.Data
resQuery.Value = value
if value != nil {
resQuery.Log = "exists"
abci/types/types.pb.go
+133 -166
View File
@@ -37,7 +37,6 @@ It has these top-level messages:
BlockSize
TxSize
BlockGossip
ProofOp
Header
Validator
SigningValidator
@@ -52,6 +51,7 @@ import fmt "fmt"
import math "math"
import _ "github.com/gogo/protobuf/gogoproto"
import common "github.com/tendermint/tmlibs/common"
import merkle "github.com/tendermint/tendermint/crypto/merkle"
import context "golang.org/x/net/context"
import grpc "google.golang.org/grpc"
@@ -1289,13 +1289,13 @@ func (m *ResponseInitChain) GetValidators() []Validator {
type ResponseQuery struct {
Code uint32 `protobuf:"varint,1,opt,name=code,proto3" json:"code,omitempty"`
// bytes data = 2; // use "value" instead.
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
Index int64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"`
Key []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
Proof []ProofOp `protobuf:"bytes,8,rep,name=proof" json:"tags,omitempty"`
Height int64 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"`
Log string `protobuf:"bytes,3,opt,name=log,proto3" json:"log,omitempty"`
Info string `protobuf:"bytes,4,opt,name=info,proto3" json:"info,omitempty"`
Index int64 `protobuf:"varint,5,opt,name=index,proto3" json:"index,omitempty"`
Key []byte `protobuf:"bytes,6,opt,name=key,proto3" json:"key,omitempty"`
Value []byte `protobuf:"bytes,7,opt,name=value,proto3" json:"value,omitempty"`
Proof *merkle.Proof `protobuf:"bytes,8,opt,name=proof" json:"proof,omitempty"`
Height int64 `protobuf:"varint,9,opt,name=height,proto3" json:"height,omitempty"`
}
func (m *ResponseQuery) Reset() { *m = ResponseQuery{} }
@@ -1345,7 +1345,7 @@ func (m *ResponseQuery) GetValue() []byte {
return nil
}
func (m *ResponseQuery) GetProof() []ProofOp {
func (m *ResponseQuery) GetProof() *merkle.Proof {
if m != nil {
return m.Proof
}
@@ -1679,39 +1679,6 @@ func (m *BlockGossip) GetBlockPartSizeBytes() int32 {
return 0
}
// A single Merkle proof operation.
type ProofOp struct {
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
Key string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *ProofOp) Reset() { *m = ProofOp{} }
func (m *ProofOp) String() string { return proto.CompactTextString(m) }
func (*ProofOp) ProtoMessage() {}
func (*ProofOp) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
func (m *ProofOp) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *ProofOp) GetKey() string {
if m != nil {
return m.Key
}
return ""
}
func (m *ProofOp) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
// just the minimum the app might need
type Header struct {
// basics
@@ -1732,7 +1699,7 @@ type Header struct {
func (m *Header) Reset() { *m = Header{} }
func (m *Header) String() string { return proto.CompactTextString(m) }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
func (*Header) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{29} }
func (m *Header) GetChainID() string {
if m != nil {
@@ -1807,7 +1774,7 @@ type Validator struct {
func (m *Validator) Reset() { *m = Validator{} }
func (m *Validator) String() string { return proto.CompactTextString(m) }
func (*Validator) ProtoMessage() {}
func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
func (*Validator) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{30} }
func (m *Validator) GetAddress() []byte {
if m != nil {
@@ -1839,7 +1806,7 @@ type SigningValidator struct {
func (m *SigningValidator) Reset() { *m = SigningValidator{} }
func (m *SigningValidator) String() string { return proto.CompactTextString(m) }
func (*SigningValidator) ProtoMessage() {}
func (*SigningValidator) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
func (*SigningValidator) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{31} }
func (m *SigningValidator) GetValidator() Validator {
if m != nil {
@@ -1863,7 +1830,7 @@ type PubKey struct {
func (m *PubKey) Reset() { *m = PubKey{} }
func (m *PubKey) String() string { return proto.CompactTextString(m) }
func (*PubKey) ProtoMessage() {}
func (*PubKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{33} }
func (*PubKey) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{32} }
func (m *PubKey) GetType() string {
if m != nil {
@@ -1890,7 +1857,7 @@ type Evidence struct {
func (m *Evidence) Reset() { *m = Evidence{} }
func (m *Evidence) String() string { return proto.CompactTextString(m) }
func (*Evidence) ProtoMessage() {}
func (*Evidence) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{34} }
func (*Evidence) Descriptor() ([]byte, []int) { return fileDescriptorTypes, []int{33} }
func (m *Evidence) GetType() string {
if m != nil {
@@ -1957,7 +1924,6 @@ func init() {
proto.RegisterType((*BlockSize)(nil), "types.BlockSize")
proto.RegisterType((*TxSize)(nil), "types.TxSize")
proto.RegisterType((*BlockGossip)(nil), "types.BlockGossip")
proto.RegisterType((*ProofOp)(nil), "types.ProofOp")
proto.RegisterType((*Header)(nil), "types.Header")
proto.RegisterType((*Validator)(nil), "types.Validator")
proto.RegisterType((*SigningValidator)(nil), "types.SigningValidator")
@@ -2370,122 +2336,123 @@ var _ABCIApplication_serviceDesc = grpc.ServiceDesc{
func init() { proto.RegisterFile("types/types.proto", fileDescriptorTypes) }
var fileDescriptorTypes = []byte{
// 1872 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0xcd, 0x72, 0x1b, 0xc7,
0x11, 0x26, 0x7e, 0x17, 0xdb, 0xfc, 0x01, 0x34, 0x94, 0x44, 0x08, 0xae, 0x94, 0x54, 0x5b, 0x29,
0x99, 0x8a, 0x69, 0x22, 0xa1, 0x2d, 0x95, 0x64, 0x3b, 0xae, 0x90, 0xb4, 0x62, 0xb0, 0x9c, 0xc4,
0xcc, 0x4a, 0x56, 0xaa, 0x72, 0x41, 0x0d, 0xb0, 0xc3, 0xc5, 0x96, 0xb0, 0x3f, 0xde, 0x19, 0xd0,
0xa0, 0x6e, 0xb9, 0xbb, 0x72, 0xcd, 0x39, 0x2f, 0x90, 0x43, 0x1e, 0x22, 0x95, 0x97, 0x88, 0x0e,
0x49, 0x4e, 0x79, 0x89, 0xa4, 0xa6, 0x67, 0xf6, 0x97, 0xbb, 0x2a, 0x45, 0x39, 0xe6, 0x42, 0xce,
0x4c, 0x77, 0xcf, 0x76, 0x37, 0xba, 0xbf, 0xee, 0x1e, 0xb8, 0x21, 0xae, 0x22, 0xc6, 0xc7, 0xf8,
0xf7, 0x30, 0x8a, 0x43, 0x11, 0x92, 0x0e, 0x6e, 0x46, 0x1f, 0xba, 0x9e, 0x58, 0xac, 0x66, 0x87,
0xf3, 0xd0, 0x1f, 0xbb, 0xa1, 0x1b, 0x8e, 0x91, 0x3a, 0x5b, 0x5d, 0xe0, 0x0e, 0x37, 0xb8, 0x52,
0x52, 0xa3, 0x71, 0x8e, 0x5d, 0xb0, 0xc0, 0x61, 0xb1, 0xef, 0x05, 0x62, 0x2c, 0xfc, 0xa5, 0x37,
0xe3, 0xe3, 0x79, 0xe8, 0xfb, 0x61, 0x90, 0xff, 0x8c, 0xf5, 0x97, 0x36, 0x18, 0x36, 0xfb, 0x76,
0xc5, 0xb8, 0x20, 0xfb, 0xd0, 0x66, 0xf3, 0x45, 0x38, 0x6c, 0xde, 0x6b, 0xec, 0x6f, 0x1e, 0x91,
0x43, 0xc5, 0xa7, 0xa9, 0x4f, 0xe7, 0x8b, 0x70, 0xb2, 0x61, 0x23, 0x07, 0xf9, 0x00, 0x3a, 0x17,
0xcb, 0x15, 0x5f, 0x0c, 0x5b, 0xc8, 0xba, 0x5b, 0x64, 0xfd, 0xb9, 0x24, 0x4d, 0x36, 0x6c, 0xc5,
0x23, 0xaf, 0xf5, 0x82, 0x8b, 0x70, 0xd8, 0xae, 0xba, 0xf6, 0x2c, 0xb8, 0xc0, 0x6b, 0x25, 0x07,
0x79, 0x0c, 0xc0, 0x99, 0x98, 0x86, 0x91, 0xf0, 0xc2, 0x60, 0xd8, 0x41, 0xfe, 0xbd, 0x22, 0xff,
0x33, 0x26, 0xbe, 0x46, 0xf2, 0x64, 0xc3, 0x36, 0x79, 0xb2, 0x91, 0x92, 0x5e, 0xe0, 0x89, 0xe9,
0x7c, 0x41, 0xbd, 0x60, 0xd8, 0xad, 0x92, 0x3c, 0x0b, 0x3c, 0x71, 0x2a, 0xc9, 0x52, 0xd2, 0x4b,
0x36, 0xd2, 0x94, 0x6f, 0x57, 0x2c, 0xbe, 0x1a, 0x1a, 0x55, 0xa6, 0xfc, 0x5a, 0x92, 0xa4, 0x29,
0xc8, 0x43, 0x3e, 0x85, 0xcd, 0x19, 0x73, 0xbd, 0x60, 0x3a, 0x5b, 0x86, 0xf3, 0x97, 0xc3, 0x1e,
0x8a, 0x0c, 0x8b, 0x22, 0x27, 0x92, 0xe1, 0x44, 0xd2, 0x27, 0x1b, 0x36, 0xcc, 0xd2, 0x1d, 0x39,
0x82, 0xde, 0x7c, 0xc1, 0xe6, 0x2f, 0xa7, 0x62, 0x3d, 0x34, 0x51, 0xf2, 0x56, 0x51, 0xf2, 0x54,
0x52, 0x9f, 0xaf, 0x27, 0x1b, 0xb6, 0x31, 0x57, 0x4b, 0x69, 0x97, 0xc3, 0x96, 0xde, 0x25, 0x8b,
0xa5, 0xd4, 0x6e, 0x95, 0x5d, 0x5f, 0x28, 0x3a, 0xca, 0x99, 0x4e, 0xb2, 0x21, 0x0f, 0xc1, 0x64,
0x81, 0xa3, 0x15, 0xdd, 0x44, 0xc1, 0xdb, 0xa5, 0x5f, 0x34, 0x70, 0x12, 0x35, 0x7b, 0x4c, 0xaf,
0xc9, 0x21, 0x74, 0x65, 0x94, 0x78, 0x62, 0xb8, 0x85, 0x32, 0x37, 0x4b, 0x2a, 0x22, 0x6d, 0xb2,
0x61, 0x6b, 0xae, 0x13, 0x03, 0x3a, 0x97, 0x74, 0xb9, 0x62, 0xd6, 0xfb, 0xb0, 0x99, 0x8b, 0x14,
0x32, 0x04, 0xc3, 0x67, 0x9c, 0x53, 0x97, 0x0d, 0x1b, 0xf7, 0x1a, 0xfb, 0xa6, 0x9d, 0x6c, 0xad,
0x1d, 0xd8, 0xca, 0xc7, 0x49, 0x4e, 0x50, 0xc6, 0x82, 0x14, 0xbc, 0x64, 0x31, 0x97, 0x01, 0xa0,
0x05, 0xf5, 0xd6, 0xfa, 0x04, 0x06, 0xe5, 0x20, 0x20, 0x03, 0x68, 0xbd, 0x64, 0x57, 0x9a, 0x53,
0x2e, 0xc9, 0x4d, 0xad, 0x10, 0x46, 0xb1, 0x69, 0x6b, 0xed, 0xfe, 0xd9, 0x48, 0x85, 0xd3, 0x38,
0x20, 0x04, 0xda, 0xc2, 0xf3, 0x95, 0x82, 0x2d, 0x1b, 0xd7, 0xe4, 0x8e, 0xfc, 0x91, 0xa8, 0x17,
0x4c, 0x3d, 0x47, 0xdf, 0x60, 0xe0, 0xfe, 0xcc, 0x21, 0xc7, 0x30, 0x98, 0x87, 0x01, 0x67, 0x01,
0x5f, 0xf1, 0x69, 0x44, 0x63, 0xea, 0x73, 0x1d, 0xff, 0x89, 0x63, 0x4f, 0x13, 0xf2, 0x39, 0x52,
0xed, 0xfe, 0xbc, 0x78, 0x40, 0x1e, 0x01, 0x5c, 0xd2, 0xa5, 0xe7, 0x50, 0x11, 0xc6, 0x7c, 0xd8,
0xbe, 0xd7, 0xda, 0xdf, 0x3c, 0x1a, 0x68, 0xe1, 0x17, 0x09, 0xe1, 0xa4, 0xfd, 0xd7, 0xd7, 0x77,
0x37, 0xec, 0x1c, 0x27, 0xb9, 0x0f, 0x7d, 0x1a, 0x45, 0x53, 0x2e, 0xa8, 0x60, 0xd3, 0xd9, 0x95,
0x60, 0x1c, 0xb3, 0x63, 0xcb, 0xde, 0xa6, 0x51, 0xf4, 0x4c, 0x9e, 0x9e, 0xc8, 0x43, 0xcb, 0x49,
0x7d, 0x8b, 0x81, 0x2b, 0x2d, 0x74, 0xa8, 0xa0, 0x68, 0xe1, 0x96, 0x8d, 0x6b, 0x79, 0x16, 0x51,
0xb1, 0xd0, 0xd6, 0xe1, 0x9a, 0xdc, 0x86, 0xee, 0x82, 0x79, 0xee, 0x42, 0xa0, 0x41, 0x2d, 0x5b,
0xef, 0xa4, 0x33, 0xa3, 0x38, 0xbc, 0x64, 0x98, 0xbb, 0x3d, 0x5b, 0x6d, 0xac, 0xbf, 0x35, 0xe0,
0xc6, 0xb5, 0x60, 0x97, 0xf7, 0x2e, 0x28, 0x5f, 0x24, 0xdf, 0x92, 0x6b, 0xf2, 0x81, 0xbc, 0x97,
0x3a, 0x2c, 0xd6, 0x98, 0xb2, 0xad, 0x6d, 0x9d, 0xe0, 0xa1, 0x36, 0x54, 0xb3, 0x90, 0x9f, 0x16,
0x9c, 0xd3, 0x42, 0xe7, 0x24, 0xb1, 0xfe, 0xcc, 0x73, 0x03, 0x2f, 0x70, 0xdf, 0xe4, 0xa3, 0x09,
0xdc, 0x9c, 0x5d, 0xbd, 0xa2, 0x81, 0xf0, 0x02, 0x36, 0xbd, 0xe6, 0xe5, 0xbe, 0xbe, 0xe8, 0xe9,
0xa5, 0xe7, 0xb0, 0x60, 0xce, 0xf4, 0x05, 0xbb, 0xa9, 0x48, 0x7a, 0x35, 0xb7, 0xee, 0xc1, 0x4e,
0x31, 0x23, 0xc9, 0x0e, 0x34, 0xc5, 0x5a, 0x5b, 0xd6, 0x14, 0x6b, 0xcb, 0x4a, 0xa3, 0x29, 0xcd,
0xbe, 0x6b, 0x3c, 0x0f, 0xa0, 0x5f, 0x4a, 0xb4, 0x9c, 0x9b, 0x1b, 0x79, 0x37, 0x5b, 0x7d, 0xd8,
0x2e, 0xe4, 0x97, 0xf5, 0x7d, 0x07, 0x7a, 0x36, 0xe3, 0x91, 0x0c, 0x1f, 0xf2, 0x18, 0x4c, 0xb6,
0x9e, 0x33, 0x05, 0x8a, 0x8d, 0x12, 0xe4, 0x28, 0x9e, 0xa7, 0x09, 0x5d, 0x62, 0x40, 0xca, 0x4c,
0x1e, 0x14, 0x00, 0x7d, 0xb7, 0x2c, 0x94, 0x47, 0xf4, 0x83, 0x22, 0xa2, 0xdf, 0x2c, 0xf1, 0x96,
0x20, 0xfd, 0x41, 0x01, 0xd2, 0xcb, 0x17, 0x17, 0x30, 0xfd, 0x49, 0x05, 0xa6, 0x97, 0xd5, 0xaf,
0x01, 0xf5, 0x27, 0x15, 0xa0, 0x3e, 0xbc, 0xf6, 0xad, 0x4a, 0x54, 0x3f, 0x28, 0xa2, 0x7a, 0xd9,
0x9c, 0x12, 0xac, 0x7f, 0x56, 0x05, 0xeb, 0x77, 0x4a, 0x32, 0xb5, 0xb8, 0xfe, 0xd1, 0x35, 0x5c,
0xbf, 0x5d, 0x12, 0xad, 0x00, 0xf6, 0x27, 0x05, 0x60, 0x87, 0x4a, 0xdb, 0x6a, 0x90, 0xfd, 0xd1,
0x75, 0x64, 0xdf, 0x2b, 0xff, 0xb4, 0x55, 0xd0, 0x3e, 0x2e, 0x41, 0xfb, 0xad, 0xb2, 0x96, 0xb5,
0xd8, 0xfe, 0x40, 0xe6, 0x7b, 0x29, 0xd2, 0x24, 0x36, 0xb0, 0x38, 0x0e, 0x63, 0x0d, 0xbe, 0x6a,
0x63, 0xed, 0x4b, 0x04, 0xca, 0xe2, 0xeb, 0x0d, 0x75, 0x00, 0x83, 0x3e, 0x17, 0x5d, 0xd6, 0x1f,
0x1a, 0x99, 0x2c, 0x96, 0x82, 0x3c, 0x7a, 0x99, 0x1a, 0xbd, 0x72, 0xe5, 0xa1, 0x59, 0x28, 0x0f,
0xe4, 0x47, 0x70, 0x63, 0x49, 0xb9, 0x50, 0x7e, 0x99, 0x16, 0xe0, 0xac, 0x2f, 0x09, 0xca, 0x21,
0x0a, 0xd7, 0x3e, 0x84, 0xdd, 0x1c, 0xaf, 0x84, 0x56, 0x84, 0xae, 0x36, 0x26, 0xef, 0x20, 0xe5,
0x3e, 0x8e, 0xa2, 0x09, 0xe5, 0x0b, 0xeb, 0x97, 0x99, 0xfd, 0x59, 0xe9, 0x21, 0xd0, 0x9e, 0x87,
0x8e, 0x32, 0x6b, 0xdb, 0xc6, 0xb5, 0x2c, 0x47, 0xcb, 0xd0, 0xc5, 0xaf, 0x9a, 0xb6, 0x5c, 0x4a,
0xae, 0x34, 0x53, 0x4c, 0x95, 0x12, 0xd6, 0xef, 0x1b, 0xd9, 0x7d, 0x59, 0x35, 0xaa, 0x2a, 0x2f,
0x8d, 0xff, 0xa5, 0xbc, 0x34, 0xdf, 0xb6, 0xbc, 0x48, 0x40, 0xdf, 0x2e, 0xa4, 0xc6, 0xbb, 0x1b,
0x27, 0xc3, 0xc2, 0x0b, 0x1c, 0xb6, 0xc6, 0x54, 0x6f, 0xd9, 0x6a, 0x93, 0xd4, 0xe9, 0x2e, 0x3a,
0xb8, 0x58, 0xa7, 0x0d, 0x3c, 0x53, 0x1b, 0xf2, 0x19, 0x16, 0x9c, 0xf0, 0x62, 0xd8, 0x43, 0xe5,
0x77, 0xb4, 0xf2, 0xe7, 0xf2, 0xec, 0xeb, 0xe8, 0xe4, 0xb6, 0x54, 0xfd, 0x5f, 0xaf, 0xef, 0xee,
0x08, 0xea, 0xf2, 0x83, 0xd0, 0xf7, 0x04, 0xf3, 0x23, 0x71, 0x65, 0x2b, 0xa1, 0x1c, 0xbe, 0x9a,
0x05, 0x7c, 0x3d, 0x07, 0x72, 0x3d, 0x8b, 0xc9, 0x27, 0xd0, 0x96, 0xd7, 0x0c, 0x1b, 0xfa, 0x53,
0xaa, 0x3b, 0x3e, 0xfc, 0xea, 0xc5, 0x39, 0xf5, 0xe2, 0xda, 0x4f, 0xa1, 0x8c, 0xf5, 0xef, 0x86,
0x44, 0xf7, 0x42, 0x76, 0x57, 0xfa, 0x2c, 0x09, 0xe1, 0x66, 0xae, 0x00, 0xbf, 0x9d, 0x1f, 0x7f,
0x00, 0xe0, 0x52, 0x3e, 0xfd, 0x8e, 0x06, 0x82, 0x39, 0xda, 0x99, 0xa6, 0x4b, 0xf9, 0x6f, 0xf0,
0x40, 0xf6, 0x29, 0x92, 0xbc, 0xe2, 0xcc, 0x41, 0xaf, 0xb6, 0x6c, 0xc3, 0xa5, 0xfc, 0x1b, 0xce,
0x9c, 0xd4, 0x2e, 0xe3, 0xbf, 0xb7, 0x8b, 0xec, 0x43, 0xeb, 0x82, 0x31, 0x8d, 0x80, 0x83, 0x54,
0xf4, 0xec, 0xd1, 0xc7, 0x28, 0xac, 0x42, 0x47, 0xb2, 0x58, 0xbf, 0x6b, 0x66, 0x41, 0x9c, 0x15,
0xc1, 0xff, 0x2f, 0x1f, 0xfc, 0x03, 0xbb, 0xca, 0x22, 0xe4, 0x92, 0x53, 0xb8, 0x91, 0xa6, 0xd6,
0x74, 0x15, 0x39, 0x54, 0x76, 0x6b, 0x8d, 0x37, 0xe6, 0xe2, 0x20, 0x15, 0xf8, 0x46, 0xf1, 0x93,
0x5f, 0xc1, 0x5e, 0x09, 0x0c, 0xd2, 0xab, 0x9a, 0x6f, 0xc4, 0x84, 0x5b, 0x45, 0x4c, 0x48, 0xee,
0x4b, 0xfc, 0xd1, 0x7a, 0x87, 0x58, 0xff, 0xa1, 0x6c, 0x87, 0xf2, 0x25, 0xa2, 0xea, 0x17, 0xb5,
0xfe, 0xd8, 0x80, 0x7e, 0x49, 0x19, 0x32, 0x06, 0x50, 0x08, 0xcb, 0xbd, 0x57, 0x4c, 0x83, 0x59,
0xe2, 0x03, 0x74, 0xd6, 0x33, 0xef, 0x15, 0xb3, 0xcd, 0x59, 0xb2, 0x24, 0xf7, 0xc1, 0x10, 0x6b,
0xc5, 0x5d, 0x6c, 0x18, 0x9f, 0xaf, 0x91, 0xb5, 0x2b, 0xf0, 0x3f, 0x79, 0x08, 0x5b, 0xea, 0x62,
0x37, 0xe4, 0xdc, 0x8b, 0x74, 0xd3, 0x42, 0xf2, 0x57, 0x7f, 0x89, 0x14, 0x7b, 0x73, 0x96, 0x6d,
0xac, 0xdf, 0x82, 0x99, 0x7e, 0x96, 0xbc, 0x07, 0xa6, 0x4f, 0xd7, 0xba, 0x9b, 0x96, 0xba, 0x75,
0xec, 0x9e, 0x4f, 0xd7, 0xd8, 0x48, 0x93, 0x3d, 0x30, 0x24, 0x51, 0xac, 0x95, 0xbf, 0x3b, 0x76,
0xd7, 0xa7, 0xeb, 0xe7, 0xeb, 0x94, 0xe0, 0x52, 0x9e, 0xb4, 0xca, 0x3e, 0x5d, 0x7f, 0x49, 0xb9,
0xf5, 0x39, 0x74, 0x95, 0x92, 0x6f, 0x75, 0xb1, 0x94, 0x6f, 0x16, 0xe4, 0x7f, 0x06, 0x9b, 0x39,
0xbd, 0xc9, 0x4f, 0xe0, 0x96, 0xb2, 0x30, 0xa2, 0xb1, 0x40, 0x8f, 0x14, 0x2e, 0x24, 0x48, 0x3c,
0xa7, 0xb1, 0x90, 0x9f, 0x54, 0xcd, 0xff, 0x29, 0x18, 0x1a, 0x27, 0x71, 0xb2, 0xb9, 0x8a, 0x92,
0x92, 0x8b, 0xeb, 0x04, 0x82, 0x9b, 0xd9, 0xa8, 0x94, 0xfc, 0x8c, 0xad, 0xdc, 0xcf, 0xf8, 0xe7,
0x26, 0x74, 0x55, 0x77, 0x4e, 0xee, 0xe7, 0x46, 0x21, 0xbc, 0xe8, 0x64, 0xf3, 0xef, 0xaf, 0xef,
0x1a, 0x58, 0xad, 0xce, 0xbe, 0xc8, 0xe6, 0xa2, 0x0c, 0x75, 0x9b, 0x85, 0xe1, 0x21, 0x19, 0xaf,
0x5a, 0xb9, 0xf1, 0x6a, 0x0f, 0x8c, 0x60, 0xe5, 0xa3, 0x5f, 0xdb, 0xca, 0xaf, 0xc1, 0xca, 0x97,
0x7e, 0x7d, 0x0f, 0x4c, 0x11, 0x0a, 0xba, 0x44, 0x92, 0xca, 0xf4, 0x1e, 0x1e, 0x48, 0xe2, 0x7d,
0xe8, 0xe7, 0x4b, 0xbb, 0x2c, 0xd5, 0xaa, 0x92, 0x6c, 0x67, 0x85, 0x5d, 0x8e, 0x1b, 0xef, 0x43,
0x3f, 0xab, 0x6a, 0x8a, 0x4f, 0x55, 0x97, 0x9d, 0xec, 0x18, 0x19, 0xef, 0x40, 0x2f, 0x2d, 0xfa,
0x3d, 0xe4, 0x30, 0xa8, 0xaa, 0xf5, 0x72, 0x4a, 0x8f, 0xe2, 0x30, 0x0a, 0x39, 0x8b, 0x75, 0x37,
0x57, 0x97, 0xb5, 0x29, 0x9f, 0xe5, 0x81, 0x99, 0x12, 0x65, 0x87, 0x42, 0x1d, 0x27, 0x66, 0x9c,
0xeb, 0x61, 0x20, 0xd9, 0x92, 0x03, 0x30, 0xa2, 0xd5, 0x6c, 0x9a, 0xfc, 0x0a, 0x59, 0x74, 0x9f,
0xaf, 0x66, 0x5f, 0xb1, 0xab, 0x64, 0x1c, 0x8a, 0x70, 0x87, 0xb3, 0x57, 0xf8, 0x1d, 0x8b, 0xb5,
0xff, 0xd4, 0xc6, 0x12, 0x30, 0x28, 0xcf, 0x42, 0xe4, 0x63, 0x30, 0x53, 0xfb, 0x4a, 0x59, 0x56,
0xd6, 0x39, 0x63, 0x94, 0xfd, 0x12, 0xf7, 0xdc, 0x80, 0x39, 0xd3, 0xcc, 0xb7, 0xa8, 0x57, 0xcf,
0xee, 0x2b, 0xc2, 0x2f, 0x12, 0xe7, 0x5a, 0x3f, 0x86, 0xae, 0xd2, 0xb1, 0x32, 0xb2, 0xaa, 0xe0,
0xe0, 0x4f, 0x0d, 0xe8, 0x25, 0xb3, 0x56, 0xa5, 0x50, 0x41, 0xe9, 0xe6, 0xdb, 0x2a, 0x5d, 0x37,
0xa8, 0x26, 0xb1, 0xd6, 0xce, 0xc5, 0xda, 0x01, 0x10, 0x15, 0x52, 0x97, 0xa1, 0xf0, 0x02, 0x77,
0xaa, 0xbc, 0xa9, 0x62, 0x6b, 0x80, 0x94, 0x17, 0x48, 0x38, 0x97, 0xe7, 0x47, 0xdf, 0x77, 0xa0,
0x7f, 0x7c, 0x72, 0x7a, 0x76, 0x1c, 0x45, 0x4b, 0x6f, 0x4e, 0xb1, 0xc5, 0x1b, 0x43, 0x1b, 0x9b,
0xd8, 0x8a, 0xa7, 0xb0, 0x51, 0xd5, 0x34, 0x45, 0x8e, 0xa0, 0x83, 0xbd, 0x2c, 0xa9, 0x7a, 0x11,
0x1b, 0x55, 0x0e, 0x55, 0xf2, 0x23, 0xaa, 0xdb, 0xbd, 0xfe, 0x30, 0x36, 0xaa, 0x9a, 0xac, 0xc8,
0xe7, 0x60, 0x66, 0x5d, 0x68, 0xdd, 0xf3, 0xd8, 0xa8, 0x76, 0xc6, 0x92, 0xf2, 0x59, 0xc1, 0xae,
0x7b, 0x4c, 0x1a, 0xd5, 0x0e, 0x23, 0xe4, 0x31, 0x18, 0x49, 0xcb, 0x53, 0xfd, 0x80, 0x35, 0xaa,
0x99, 0x7f, 0xa4, 0x7b, 0x54, 0x7b, 0x59, 0xf5, 0xca, 0x36, 0xaa, 0x1c, 0xd2, 0xc8, 0x43, 0xe8,
0xea, 0xaa, 0x53, 0xf9, 0x14, 0x35, 0xaa, 0x9e, 0x62, 0xa4, 0x91, 0x59, 0x6b, 0x5d, 0xf7, 0x12,
0x38, 0xaa, 0x9d, 0x26, 0xc9, 0x31, 0x40, 0xae, 0x55, 0xac, 0x7d, 0xe2, 0x1b, 0xd5, 0x4f, 0x89,
0xe4, 0x53, 0xe8, 0x65, 0x93, 0x7f, 0xf5, 0xd3, 0xdb, 0xa8, 0x6e, 0x70, 0x9b, 0x75, 0xf1, 0x79,
0xf6, 0xa3, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x53, 0x66, 0x3c, 0x2d, 0x1a, 0x16, 0x00, 0x00,
// 1874 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x58, 0x4b, 0x93, 0x1b, 0x49,
0x11, 0x1e, 0xbd, 0xd5, 0x39, 0x0f, 0xc9, 0x35, 0xb6, 0x47, 0xd6, 0x06, 0x61, 0x47, 0x43, 0x78,
0xc7, 0xec, 0xec, 0x08, 0x66, 0xd7, 0x0e, 0x7b, 0x0d, 0x1b, 0xcc, 0xcc, 0x9a, 0xd5, 0xc4, 0xf2,
0x18, 0xda, 0x5e, 0x13, 0xc1, 0x45, 0x51, 0x52, 0xd7, 0xb4, 0x3a, 0xac, 0x7e, 0x6c, 0x57, 0x69,
0x56, 0xf2, 0x8d, 0xfb, 0x06, 0x57, 0xce, 0xfc, 0x01, 0x0e, 0xfc, 0x06, 0x82, 0xe0, 0x4f, 0xe0,
0x03, 0x70, 0xe2, 0x4f, 0x40, 0x54, 0x56, 0xf5, 0x53, 0xdd, 0x0e, 0xb3, 0x1c, 0xb9, 0xcc, 0x54,
0x56, 0x66, 0x56, 0x57, 0xa6, 0x32, 0xbf, 0xcc, 0x2c, 0xb8, 0x21, 0xd6, 0x21, 0xe3, 0x23, 0xfc,
0x7b, 0x1c, 0x46, 0x81, 0x08, 0x48, 0x0b, 0x89, 0xe1, 0x87, 0x8e, 0x2b, 0xe6, 0xcb, 0xe9, 0xf1,
0x2c, 0xf0, 0x46, 0x4e, 0xe0, 0x04, 0x23, 0xe4, 0x4e, 0x97, 0x57, 0x48, 0x21, 0x81, 0x2b, 0xa5,
0x35, 0x1c, 0x65, 0xc4, 0x05, 0xf3, 0x6d, 0x16, 0x79, 0xae, 0x2f, 0x46, 0xc2, 0x5b, 0xb8, 0x53,
0x3e, 0x9a, 0x05, 0x9e, 0x17, 0xf8, 0xd9, 0xcf, 0x0c, 0x9f, 0x56, 0x28, 0xa4, 0xcb, 0x59, 0xb4,
0x0e, 0x45, 0x30, 0xf2, 0x58, 0xf4, 0x6a, 0xc1, 0xf4, 0x3f, 0xa5, 0x6c, 0xfe, 0xa5, 0x09, 0x1d,
0x8b, 0x7d, 0xb5, 0x64, 0x5c, 0x90, 0x43, 0x68, 0xb2, 0xd9, 0x3c, 0x18, 0xd4, 0xef, 0xd5, 0x0e,
0xb7, 0x4f, 0xc8, 0xb1, 0xfa, 0x88, 0xe6, 0x3e, 0x9b, 0xcd, 0x83, 0xf1, 0x96, 0x85, 0x12, 0xe4,
0x03, 0x68, 0x5d, 0x2d, 0x96, 0x7c, 0x3e, 0x68, 0xa0, 0xe8, 0x7e, 0x5e, 0xf4, 0xa7, 0x92, 0x35,
0xde, 0xb2, 0x94, 0x8c, 0x3c, 0xd6, 0xf5, 0xaf, 0x82, 0x41, 0xb3, 0xec, 0xd8, 0x0b, 0xff, 0x0a,
0x8f, 0x95, 0x12, 0xe4, 0x31, 0x00, 0x67, 0x62, 0x12, 0x84, 0xc2, 0x0d, 0xfc, 0x41, 0x0b, 0xe5,
0x0f, 0xf2, 0xf2, 0xcf, 0x99, 0xf8, 0x25, 0xb2, 0xc7, 0x5b, 0x96, 0xc1, 0x63, 0x42, 0x6a, 0xba,
0xbe, 0x2b, 0x26, 0xb3, 0x39, 0x75, 0xfd, 0x41, 0xbb, 0x4c, 0xf3, 0xc2, 0x77, 0xc5, 0xb9, 0x64,
0x4b, 0x4d, 0x37, 0x26, 0xa4, 0x29, 0x5f, 0x2d, 0x59, 0xb4, 0x1e, 0x74, 0xca, 0x4c, 0xf9, 0x95,
0x64, 0x49, 0x53, 0x50, 0x86, 0x3c, 0x85, 0xed, 0x29, 0x73, 0x5c, 0x7f, 0x32, 0x5d, 0x04, 0xb3,
0x57, 0x83, 0x2e, 0xaa, 0x0c, 0xf2, 0x2a, 0x67, 0x52, 0xe0, 0x4c, 0xf2, 0xc7, 0x5b, 0x16, 0x4c,
0x13, 0x8a, 0x9c, 0x40, 0x77, 0x36, 0x67, 0xb3, 0x57, 0x13, 0xb1, 0x1a, 0x18, 0xa8, 0x79, 0x2b,
0xaf, 0x79, 0x2e, 0xb9, 0x2f, 0x56, 0xe3, 0x2d, 0xab, 0x33, 0x53, 0x4b, 0x69, 0x97, 0xcd, 0x16,
0xee, 0x35, 0x8b, 0xa4, 0xd6, 0x7e, 0x99, 0x5d, 0x9f, 0x29, 0x3e, 0xea, 0x19, 0x76, 0x4c, 0x90,
0x87, 0x60, 0x30, 0xdf, 0xd6, 0x17, 0xdd, 0x46, 0xc5, 0xdb, 0x85, 0x5f, 0xd4, 0xb7, 0xe3, 0x6b,
0x76, 0x99, 0x5e, 0x93, 0x63, 0x68, 0xcb, 0x10, 0x73, 0xc5, 0x60, 0x07, 0x75, 0x6e, 0x16, 0xae,
0x88, 0xbc, 0xf1, 0x96, 0xa5, 0xa5, 0xce, 0x3a, 0xd0, 0xba, 0xa6, 0x8b, 0x25, 0x33, 0xdf, 0x87,
0xed, 0x4c, 0xa4, 0x90, 0x01, 0x74, 0x3c, 0xc6, 0x39, 0x75, 0xd8, 0xa0, 0x76, 0xaf, 0x76, 0x68,
0x58, 0x31, 0x69, 0xee, 0xc1, 0x4e, 0x36, 0x4e, 0x32, 0x8a, 0x32, 0x16, 0xa4, 0xe2, 0x35, 0x8b,
0xb8, 0x0c, 0x00, 0xad, 0xa8, 0x49, 0xf3, 0x13, 0xe8, 0x17, 0x83, 0x80, 0xf4, 0xa1, 0xf1, 0x8a,
0xad, 0xb5, 0xa4, 0x5c, 0x92, 0x9b, 0xfa, 0x42, 0x18, 0xc5, 0x86, 0xa5, 0x6f, 0xf7, 0xcf, 0x5a,
0xa2, 0x9c, 0xc4, 0x01, 0x21, 0xd0, 0x14, 0xae, 0xa7, 0x2e, 0xd8, 0xb0, 0x70, 0x4d, 0xee, 0xc8,
0x1f, 0x89, 0xba, 0xfe, 0xc4, 0xb5, 0xf5, 0x09, 0x1d, 0xa4, 0x2f, 0x6c, 0x72, 0x0a, 0xfd, 0x59,
0xe0, 0x73, 0xe6, 0xf3, 0x25, 0x9f, 0x84, 0x34, 0xa2, 0x1e, 0xd7, 0xf1, 0x1f, 0x3b, 0xf6, 0x3c,
0x66, 0x5f, 0x22, 0xd7, 0xea, 0xcd, 0xf2, 0x1b, 0xe4, 0x11, 0xc0, 0x35, 0x5d, 0xb8, 0x36, 0x15,
0x41, 0xc4, 0x07, 0xcd, 0x7b, 0x8d, 0xc3, 0xed, 0x93, 0xbe, 0x56, 0x7e, 0x19, 0x33, 0xce, 0x9a,
0x7f, 0x7d, 0x73, 0x77, 0xcb, 0xca, 0x48, 0x92, 0xfb, 0xd0, 0xa3, 0x61, 0x38, 0xe1, 0x82, 0x0a,
0x36, 0x99, 0xae, 0x05, 0xe3, 0x98, 0x1d, 0x3b, 0xd6, 0x2e, 0x0d, 0xc3, 0xe7, 0x72, 0xf7, 0x4c,
0x6e, 0x9a, 0x76, 0xe2, 0x5b, 0x0c, 0x5c, 0x69, 0xa1, 0x4d, 0x05, 0x45, 0x0b, 0x77, 0x2c, 0x5c,
0xcb, 0xbd, 0x90, 0x8a, 0xb9, 0xb6, 0x0e, 0xd7, 0xe4, 0x36, 0xb4, 0xe7, 0xcc, 0x75, 0xe6, 0x02,
0x0d, 0x6a, 0x58, 0x9a, 0x92, 0xce, 0x0c, 0xa3, 0xe0, 0x9a, 0x61, 0xee, 0x76, 0x2d, 0x45, 0x98,
0x7f, 0xab, 0xc1, 0x8d, 0x8d, 0x60, 0x97, 0xe7, 0xce, 0x29, 0x9f, 0xc7, 0xdf, 0x92, 0x6b, 0xf2,
0x81, 0x3c, 0x97, 0xda, 0x2c, 0xd2, 0x98, 0xb2, 0xab, 0x6d, 0x1d, 0xe3, 0xa6, 0x36, 0x54, 0x8b,
0x90, 0x1f, 0xe7, 0x9c, 0xd3, 0x40, 0xe7, 0xc4, 0xb1, 0xfe, 0xdc, 0x75, 0x7c, 0xd7, 0x77, 0xde,
0xe6, 0xa3, 0x31, 0xdc, 0x9c, 0xae, 0x5f, 0x53, 0x5f, 0xb8, 0x3e, 0x9b, 0x6c, 0x78, 0xb9, 0xa7,
0x0f, 0x7a, 0x76, 0xed, 0xda, 0xcc, 0x9f, 0x31, 0x7d, 0xc0, 0x7e, 0xa2, 0x92, 0x1c, 0xcd, 0xcd,
0x7b, 0xb0, 0x97, 0xcf, 0x48, 0xb2, 0x07, 0x75, 0xb1, 0xd2, 0x96, 0xd5, 0xc5, 0xca, 0x34, 0x93,
0x68, 0x4a, 0xb2, 0x6f, 0x43, 0xe6, 0x01, 0xf4, 0x0a, 0x89, 0x96, 0x71, 0x73, 0x2d, 0xeb, 0x66,
0xb3, 0x07, 0xbb, 0xb9, 0xfc, 0x32, 0xbf, 0x69, 0x41, 0xd7, 0x62, 0x3c, 0x94, 0xe1, 0x43, 0x1e,
0x83, 0xc1, 0x56, 0x33, 0xa6, 0x40, 0xb1, 0x56, 0x80, 0x1c, 0x25, 0xf3, 0x2c, 0xe6, 0x4b, 0x0c,
0x48, 0x84, 0xc9, 0x83, 0x1c, 0xa0, 0xef, 0x17, 0x95, 0xb2, 0x88, 0x7e, 0x94, 0x47, 0xf4, 0x9b,
0x05, 0xd9, 0x02, 0xa4, 0x3f, 0xc8, 0x41, 0x7a, 0xf1, 0xe0, 0x1c, 0xa6, 0x3f, 0x29, 0xc1, 0xf4,
0xe2, 0xf5, 0x2b, 0x40, 0xfd, 0x49, 0x09, 0xa8, 0x0f, 0x36, 0xbe, 0x55, 0x8a, 0xea, 0x47, 0x79,
0x54, 0x2f, 0x9a, 0x53, 0x80, 0xf5, 0x1f, 0x95, 0xc1, 0xfa, 0x9d, 0x82, 0x4e, 0x25, 0xae, 0x7f,
0xb4, 0x81, 0xeb, 0xb7, 0x0b, 0xaa, 0x25, 0xc0, 0xfe, 0x24, 0x07, 0xec, 0x50, 0x6a, 0x5b, 0x05,
0xb2, 0x3f, 0xda, 0x44, 0xf6, 0x83, 0xe2, 0x4f, 0x5b, 0x06, 0xed, 0xa3, 0x02, 0xb4, 0xdf, 0x2a,
0xde, 0xb2, 0x12, 0xdb, 0x1f, 0xc8, 0x7c, 0x2f, 0x44, 0x9a, 0xc4, 0x06, 0x16, 0x45, 0x41, 0xa4,
0xc1, 0x57, 0x11, 0xe6, 0xa1, 0x44, 0xa0, 0x34, 0xbe, 0xde, 0x52, 0x07, 0x30, 0xe8, 0x33, 0xd1,
0x65, 0xfe, 0xbe, 0x96, 0xea, 0x62, 0x29, 0xc8, 0xa2, 0x97, 0xa1, 0xd1, 0x2b, 0x53, 0x1e, 0xea,
0xb9, 0xf2, 0x40, 0xbe, 0x0f, 0x37, 0x16, 0x94, 0x0b, 0xe5, 0x97, 0x49, 0x0e, 0xce, 0x7a, 0x92,
0xa1, 0x1c, 0xa2, 0x70, 0xed, 0x43, 0xd8, 0xcf, 0xc8, 0x4a, 0x68, 0x45, 0xe8, 0x6a, 0x62, 0xf2,
0xf6, 0x13, 0xe9, 0xd3, 0x30, 0x1c, 0x53, 0x3e, 0x37, 0x7f, 0x9e, 0xda, 0x9f, 0x96, 0x1e, 0x02,
0xcd, 0x59, 0x60, 0x2b, 0xb3, 0x76, 0x2d, 0x5c, 0xcb, 0x72, 0xb4, 0x08, 0x1c, 0xfc, 0xaa, 0x61,
0xc9, 0xa5, 0x94, 0x4a, 0x32, 0xc5, 0x50, 0x29, 0x61, 0xfe, 0xae, 0x96, 0x9e, 0x97, 0x56, 0xa3,
0xb2, 0xf2, 0x52, 0xfb, 0x5f, 0xca, 0x4b, 0xfd, 0x5d, 0xcb, 0x8b, 0xf9, 0xe7, 0x5a, 0xfa, 0x5b,
0x24, 0x85, 0xe3, 0xdb, 0x19, 0x27, 0xc3, 0xc2, 0xf5, 0x6d, 0xb6, 0xc2, 0x54, 0x6f, 0x58, 0x8a,
0x88, 0xeb, 0x74, 0x1b, 0x1d, 0x9c, 0xaf, 0xd3, 0x1d, 0xdc, 0x53, 0x04, 0xf9, 0x2e, 0x16, 0x9c,
0xe0, 0x4a, 0xe7, 0xe0, 0xee, 0xb1, 0x6e, 0x56, 0x2f, 0xe5, 0xa6, 0xa5, 0x78, 0x19, 0x18, 0x35,
0x72, 0x30, 0x7a, 0x09, 0x64, 0x33, 0x59, 0xc9, 0x27, 0xd0, 0x14, 0xd4, 0x91, 0xbe, 0x94, 0xee,
0xd8, 0x3b, 0x56, 0x1d, 0xf4, 0xf1, 0x17, 0x2f, 0x2f, 0xa9, 0x1b, 0x9d, 0xdd, 0x96, 0xce, 0xf8,
0xd7, 0x9b, 0xbb, 0x7b, 0x52, 0xe6, 0x28, 0xf0, 0x5c, 0xc1, 0xbc, 0x50, 0xac, 0x2d, 0xd4, 0x31,
0xff, 0x5d, 0x93, 0x20, 0x9e, 0x4b, 0xe2, 0x52, 0xd7, 0xc4, 0x91, 0x5a, 0xcf, 0xd4, 0xd9, 0x77,
0x73, 0xd7, 0x77, 0x00, 0x1c, 0xca, 0x27, 0x5f, 0x53, 0x5f, 0x30, 0x5b, 0xfb, 0xcc, 0x70, 0x28,
0xff, 0x35, 0x6e, 0xc8, 0x76, 0x44, 0xb2, 0x97, 0x9c, 0xd9, 0xe8, 0xbc, 0x86, 0xd5, 0x71, 0x28,
0xff, 0x92, 0x33, 0x3b, 0xb1, 0xab, 0xf3, 0xdf, 0xdb, 0x45, 0x0e, 0xa1, 0x71, 0xc5, 0x98, 0x76,
0x72, 0x3f, 0x51, 0xbd, 0x78, 0xf4, 0x31, 0x2a, 0xab, 0x08, 0x91, 0x22, 0xe6, 0x6f, 0xeb, 0x69,
0xac, 0xa6, 0xb5, 0xee, 0xff, 0xcb, 0x07, 0xff, 0xc0, 0xe6, 0x31, 0x8f, 0xac, 0xe4, 0x1c, 0x6e,
0x24, 0x19, 0x34, 0x59, 0x86, 0x36, 0x95, 0x4d, 0x59, 0xed, 0xad, 0x29, 0xd7, 0x4f, 0x14, 0xbe,
0x54, 0xf2, 0xe4, 0x17, 0x70, 0x50, 0xc8, 0xf9, 0xe4, 0xa8, 0xfa, 0x5b, 0x53, 0xff, 0x56, 0x3e,
0xf5, 0xe3, 0xf3, 0x62, 0x7f, 0x34, 0xbe, 0x45, 0xac, 0x7f, 0x4f, 0x76, 0x3d, 0xd9, 0x4a, 0x50,
0xf6, 0x8b, 0x9a, 0x7f, 0xa8, 0x41, 0xaf, 0x70, 0x19, 0x32, 0x02, 0x50, 0x40, 0xca, 0xdd, 0xd7,
0x4c, 0x63, 0x56, 0xec, 0x03, 0x74, 0xd6, 0x73, 0xf7, 0x35, 0xb3, 0x8c, 0x69, 0xbc, 0x24, 0xf7,
0xa1, 0x23, 0x56, 0x4a, 0x3a, 0xdf, 0x17, 0xbe, 0x58, 0xa1, 0x68, 0x5b, 0xe0, 0x7f, 0xf2, 0x10,
0x76, 0xd4, 0xc1, 0x4e, 0xc0, 0xb9, 0x1b, 0xea, 0xde, 0x84, 0x64, 0x8f, 0xfe, 0x1c, 0x39, 0xd6,
0xf6, 0x34, 0x25, 0xcc, 0xdf, 0x80, 0x91, 0x7c, 0x96, 0xbc, 0x07, 0x86, 0x47, 0x57, 0xba, 0x69,
0x96, 0x77, 0x6b, 0x59, 0x5d, 0x8f, 0xae, 0xb0, 0x5f, 0x26, 0x07, 0xd0, 0x91, 0x4c, 0xb1, 0x52,
0xfe, 0x6e, 0x59, 0x6d, 0x8f, 0xae, 0x5e, 0xac, 0x12, 0x86, 0x43, 0x79, 0xdc, 0x11, 0x7b, 0x74,
0xf5, 0x39, 0xe5, 0xe6, 0xa7, 0xd0, 0x56, 0x97, 0x7c, 0xa7, 0x83, 0xa5, 0x7e, 0x3d, 0xa7, 0xff,
0x13, 0xd8, 0xce, 0xdc, 0x9b, 0xfc, 0x10, 0x6e, 0x29, 0x0b, 0x43, 0x1a, 0x09, 0xf4, 0x48, 0xee,
0x40, 0x82, 0xcc, 0x4b, 0x1a, 0x09, 0xf9, 0x49, 0xd5, 0xe3, 0xff, 0xa9, 0x0e, 0x6d, 0xd5, 0x3f,
0x93, 0xfb, 0x99, 0x61, 0x05, 0x8b, 0xe4, 0xd9, 0xf6, 0xdf, 0xdf, 0xdc, 0xed, 0x60, 0x3d, 0xb9,
0xf8, 0x2c, 0x9d, 0x5c, 0x52, 0xc0, 0xac, 0xe7, 0xda, 0xfb, 0x78, 0x00, 0x6a, 0x64, 0x06, 0xa0,
0x03, 0xe8, 0xf8, 0x4b, 0x0f, 0x5d, 0xd2, 0x54, 0x2e, 0xf1, 0x97, 0x9e, 0x74, 0xc9, 0x7b, 0x60,
0x88, 0x40, 0xd0, 0x05, 0xb2, 0x54, 0x92, 0x76, 0x71, 0x43, 0x32, 0xef, 0x43, 0x2f, 0x5b, 0x7c,
0x65, 0x31, 0x55, 0x58, 0xbf, 0x9b, 0x96, 0x5e, 0x39, 0x10, 0xbc, 0x0f, 0xbd, 0xb4, 0xee, 0x28,
0x39, 0x85, 0xff, 0x7b, 0xe9, 0x36, 0x0a, 0xde, 0x81, 0x6e, 0x52, 0x96, 0xbb, 0x28, 0xd1, 0xa1,
0xaa, 0x1a, 0xcb, 0x39, 0x3a, 0x8c, 0x82, 0x30, 0xe0, 0x2c, 0xd2, 0xfd, 0x56, 0x55, 0xc2, 0x25,
0x72, 0xa6, 0x0b, 0x46, 0xc2, 0x94, 0x3d, 0x04, 0xb5, 0xed, 0x88, 0x71, 0xae, 0xdb, 0xf5, 0x98,
0x24, 0x47, 0xd0, 0x09, 0x97, 0xd3, 0x89, 0x2c, 0x55, 0xf9, 0xc0, 0xbc, 0x5c, 0x4e, 0xbf, 0x60,
0xeb, 0x78, 0x60, 0x09, 0x91, 0xc2, 0xe9, 0x28, 0xf8, 0x9a, 0x45, 0xda, 0x7f, 0x8a, 0x30, 0x05,
0xf4, 0x8b, 0xd3, 0x0a, 0xf9, 0x18, 0x8c, 0xc4, 0xbe, 0x42, 0x82, 0x14, 0xef, 0x9c, 0x0a, 0xca,
0x8e, 0x86, 0xbb, 0x8e, 0xcf, 0xec, 0x49, 0xea, 0x5b, 0xbc, 0x57, 0xd7, 0xea, 0x29, 0xc6, 0xcf,
0x62, 0xe7, 0x9a, 0x3f, 0x80, 0xb6, 0xba, 0x23, 0xfe, 0xa8, 0xeb, 0x30, 0x6e, 0xb7, 0x70, 0x5d,
0x9a, 0xc9, 0x7f, 0xac, 0x41, 0x37, 0x9e, 0x86, 0x4a, 0x95, 0x72, 0x97, 0xae, 0xbf, 0xeb, 0xa5,
0xab, 0x46, 0xc9, 0x38, 0xd6, 0x9a, 0x99, 0x58, 0x3b, 0x02, 0xa2, 0x42, 0xea, 0x3a, 0x10, 0xae,
0xef, 0x4c, 0x94, 0x37, 0x55, 0x6c, 0xf5, 0x91, 0xf3, 0x12, 0x19, 0x97, 0x72, 0xff, 0xe4, 0x9b,
0x16, 0xf4, 0x4e, 0xcf, 0xce, 0x2f, 0x4e, 0xc3, 0x70, 0xe1, 0xce, 0x28, 0x36, 0x61, 0x23, 0x68,
0x62, 0x9b, 0x59, 0xf2, 0x58, 0x35, 0x2c, 0x9b, 0x77, 0xc8, 0x09, 0xb4, 0xb0, 0xdb, 0x24, 0x65,
0x6f, 0x56, 0xc3, 0xd2, 0xb1, 0x47, 0x7e, 0x44, 0xf5, 0xa3, 0x9b, 0x4f, 0x57, 0xc3, 0xb2, 0xd9,
0x87, 0x7c, 0x0a, 0x46, 0xda, 0x27, 0x56, 0x3d, 0x60, 0x0d, 0x2b, 0xa7, 0x20, 0xa9, 0x9f, 0xd6,
0xda, 0xaa, 0xe7, 0x9e, 0x61, 0xe5, 0xb8, 0x40, 0x1e, 0x43, 0x27, 0xee, 0x56, 0xca, 0x9f, 0x98,
0x86, 0x15, 0x13, 0x8a, 0x74, 0x8f, 0x6a, 0x00, 0xcb, 0xde, 0xc1, 0x86, 0xa5, 0x63, 0x14, 0x79,
0x08, 0x6d, 0x5d, 0x30, 0x4a, 0x1f, 0x8b, 0x86, 0xe5, 0x73, 0x86, 0x34, 0x32, 0x6d, 0x7e, 0xab,
0xde, 0xea, 0x86, 0x95, 0xf3, 0x1e, 0x39, 0x05, 0xc8, 0x74, 0x79, 0x95, 0x8f, 0x70, 0xc3, 0xea,
0x39, 0x8e, 0x3c, 0x85, 0x6e, 0x3a, 0x9b, 0x97, 0x3f, 0x8e, 0x0d, 0xab, 0x46, 0xab, 0x69, 0x1b,
0x1f, 0x50, 0x3f, 0xfa, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x11, 0x49, 0xc5, 0xab, 0xf9, 0x15,
0x00, 0x00,
}
abci/types/types.proto
+2 -8
View File
@@ -5,6 +5,7 @@ package types;
// https://github.com/gogo/protobuf/blob/master/extensions.md
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/tendermint/tmlibs/common/types.proto";
import "github.com/tendermint/tendermint/crypto/merkle/merkle.proto";
// This file is copied from http://github.com/tendermint/abci
// NOTE: When using custom types, mind the warnings.
@@ -143,7 +144,7 @@ message ResponseQuery {
int64 index = 5;
bytes key = 6;
bytes value = 7;
repeated ProofOp proof = 8 [(gogoproto.nullable)=false, (gogoproto.jsontag)="tags,omitempty"];
merkle.Proof proof = 8;
int64 height = 9;
}
@@ -215,13 +216,6 @@ message BlockGossip {
int32 block_part_size_bytes = 1;
}
// A single Merkle proof operation.
message ProofOp {
string type = 1;
string key = 2;
bytes data = 3;
}
//----------------------------------------
// Blockchain Types
crypto/merkle/proof.go
+4
View File
@@ -114,10 +114,14 @@ func (prt *ProofRuntime) DecodeProof(proof *Proof) (poz ProofOperators, err erro
return
}
// XXX Reorder value/keys, and figure out how to merge keys into a single string
// after figuring out encoding between bytes/string.
func (prt *ProofRuntime) VerifyValue(proof *Proof, root []byte, value []byte, keys ...string) (err error) {
return prt.Verify(proof, root, [][]byte{value}, keys...)
}
// XXX Reorder value/keys, and figure out how to merge keys into a single string
// after figuring out encoding between bytes/string.
func (prt *ProofRuntime) Verify(proof *Proof, root []byte, args [][]byte, keys ...string) (err error) {
poz, err := prt.DecodeProof(proof)
if err != nil {
lite/proxy/query.go
+35 -74
View File
@@ -3,127 +3,88 @@ package proxy
import (
"fmt"
"github.com/pkg/errors"
cmn "github.com/tendermint/tmlibs/common"
"github.com/tendermint/tendermint/crypto/merkle"
"github.com/tendermint/tendermint/lite"
rpcclient "github.com/tendermint/tendermint/rpc/client"
ctypes "github.com/tendermint/tendermint/rpc/core/types"
"github.com/tendermint/tendermint/types"
)
// KeyProof represents a proof of existence or absence of a single key.
// Copied from iavl repo. TODO
type KeyProof interface {
// Verify verfies the proof is valid. To verify absence,
// the value should be nil.
Verify(key, value, root []byte) error
// Root returns the root hash of the proof.
Root() []byte
// Serialize itself
Bytes() []byte
}
// GetWithProof will query the key on the given node, and verify it has
// a valid proof, as defined by the certifier.
//
// If there is any error in checking, returns an error.
// If val is non-empty, proof should be KeyExistsProof
// If val is empty, proof should be KeyMissingProof
func GetWithProof(key []byte, reqHeight int64, node rpcclient.Client,
cert lite.Certifier) (
val cmn.HexBytes, height int64, proof KeyProof, err error) {
val cmn.HexBytes, height int64, proof *merkle.Proof, err error) {
if reqHeight < 0 {
err = errors.Errorf("Height cannot be negative")
err = cmn.NewError("Height cannot be negative")
return
}
_resp, proof, err := GetWithProofOptions("/key", key,
rpcclient.ABCIQueryOptions{Height: int64(reqHeight)},
res, err := GetWithProofOptions("/key", key,
rpcclient.ABCIQueryOptions{Height: int64(reqHeight), Prove: true},
node, cert)
if _resp != nil {
resp := _resp.Response
val, height = resp.Value, resp.Height
if err != nil {
return
}
resp := res.Response
val, height, proof = resp.Value, resp.Height, resp.Proof
return val, height, proof, err
}
// GetWithProofOptions is useful if you want full access to the ABCIQueryOptions
// GetWithProofOptions is useful if you want full access to the ABCIQueryOptions.
func GetWithProofOptions(path string, key []byte, opts rpcclient.ABCIQueryOptions,
node rpcclient.Client, cert lite.Certifier) (
*ctypes.ResultABCIQuery, KeyProof, error) {
*ctypes.ResultABCIQuery, error) {
_resp, err := node.ABCIQueryWithOptions(path, key, opts)
if !opts.Prove {
return nil, cmn.NewError("require ABCIQueryOptions.Prove to be true")
}
res, err := node.ABCIQueryWithOptions(path, key, opts)
if err != nil {
return nil, nil, err
return nil, err
}
resp := _resp.Response
resp := res.Response
// make sure the proof is the proper height
// Validate the response, e.g. height.
if resp.IsErr() {
err = errors.Errorf("Query error for key %d: %d", key, resp.Code)
return nil, nil, err
err = cmn.NewError("Query error for key %d: %d", key, resp.Code)
return nil, err
}
if len(resp.Key) == 0 || len(resp.Proof) == 0 {
return nil, nil, ErrNoData()
if len(resp.Key) == 0 || resp.Proof == nil {
return nil, ErrNoData()
}
if resp.Height == 0 {
return nil, nil, errors.New("Height returned is zero")
return nil, cmn.NewError("Height returned is zero")
}
// AppHash for height H is in header H+1
signedHeader, err := GetCertifiedCommit(resp.Height+1, node, cert)
if err != nil {
return nil, nil, err
return nil, err
}
_ = signedHeader
return &ctypes.ResultABCIQuery{Response: resp}, nil, nil
/* // TODO refactor so iavl stuff is not in tendermint core
// https://github.com/tendermint/tendermint/issues/1183
if len(resp.Value) > 0 {
// The key was found, construct a proof of existence.
proof, err := iavl.ReadKeyProof(resp.Proof)
if err != nil {
return nil, nil, errors.Wrap(err, "Error reading proof")
}
eproof, ok := proof.(*iavl.KeyExistsProof)
if !ok {
return nil, nil, errors.New("Expected KeyExistsProof for non-empty value")
}
// Validate the proof against the certified header to ensure data integrity.
err = eproof.Verify(resp.Key, resp.Value, signedHeader.AppHash)
// XXX Pass this in somehow so iavl can be registered.
// XXX How do we encode the key into a string...
prt := merkle.NewProofRuntime()
err = prt.VerifyValue(resp.Proof, signedHeader.AppHash, resp.Value, string(resp.Key))
if err != nil {
return nil, nil, errors.Wrap(err, "Couldn't verify proof")
return nil, cmn.ErrorWrap(err, "Couldn't verify proof")
}
return &ctypes.ResultABCIQuery{Response: resp}, eproof, nil
return &ctypes.ResultABCIQuery{Response: resp}, nil
} else {
return nil, cmn.NewError("proof of absence not yet supported")
}
// The key wasn't found, construct a proof of non-existence.
proof, err := iavl.ReadKeyProof(resp.Proof)
if err != nil {
return nil, nil, errors.Wrap(err, "Error reading proof")
}
aproof, ok := proof.(*iavl.KeyAbsentProof)
if !ok {
return nil, nil, errors.New("Expected KeyAbsentProof for empty Value")
}
// Validate the proof against the certified header to ensure data integrity.
err = aproof.Verify(resp.Key, nil, signedHeader.AppHash)
if err != nil {
return nil, nil, errors.Wrap(err, "Couldn't verify proof")
}
return &ctypes.ResultABCIQuery{Response: resp}, aproof, ErrNoData()
*/
return &ctypes.ResultABCIQuery{Response: resp}, ErrNoData()
}
// GetCertifiedCommit gets the signed header for a given height and certifies
lite/proxy/query_test.go
+9 -11
View File
@@ -10,6 +10,7 @@ import (
"github.com/tendermint/tendermint/abci/example/kvstore"
"github.com/tendermint/tendermint/crypto/merkle"
"github.com/tendermint/tendermint/lite"
certclient "github.com/tendermint/tendermint/lite/client"
nm "github.com/tendermint/tendermint/node"
@@ -38,7 +39,7 @@ func kvstoreTx(k, v []byte) []byte {
return []byte(fmt.Sprintf("%s=%s", k, v))
}
func _TestAppProofs(t *testing.T) {
func TestAppProofs(t *testing.T) {
assert, require := assert.New(t), require.New(t)
cl := client.NewLocal(node)
@@ -64,11 +65,13 @@ func _TestAppProofs(t *testing.T) {
latest, err := source.LatestFullCommit(chainID, 1, 1<<63-1)
require.NoError(err, "%+v", err)
rootHash := latest.SignedHeader.AppHash
require.NotNil(rootHash)
// verify a query before the tx block has no data (and valid non-exist proof)
bs, height, proof, err := GetWithProof(k, brh-1, cl, cert)
fmt.Println(bs, height, proof, err)
require.NotNil(err)
require.NotNil(proof)
// XXX test proof
require.True(IsErrNoData(err), err.Error())
require.Nil(bs)
@@ -78,15 +81,10 @@ func _TestAppProofs(t *testing.T) {
require.NotNil(proof)
require.True(height >= int64(latest.Height()))
// Alexis there is a bug here, somehow the above code gives us rootHash = nil
// and proof.Verify doesn't care, while proofNotExists.Verify fails.
// I am hacking this in to make it pass, but please investigate further.
rootHash = proof.Root()
prt := merkle.NewProofRuntime()
//err = wire.ReadBinaryBytes(bs, &data)
//require.NoError(err, "%+v", err)
assert.EqualValues(v, bs)
err = proof.Verify(k, bs, rootHash)
err = prt.VerifyValue(proof, rootHash, k, string(bs))
assert.NoError(err, "%+v", err)
// Test non-existing key.
@@ -95,9 +93,9 @@ func _TestAppProofs(t *testing.T) {
require.True(IsErrNoData(err))
require.Nil(bs)
require.NotNil(proof)
err = proof.Verify(missing, nil, rootHash)
err = prt.VerifyValue(proof, rootHash, missing, "") // XXX VerifyAbsence()
assert.NoError(err, "%+v", err)
err = proof.Verify(k, nil, rootHash)
err = prt.VerifyValue(proof, rootHash, k, "") // XXX VerifyAbsence()
assert.Error(err)
}
lite/proxy/wrapper.go
+1 -1
View File
@@ -36,7 +36,7 @@ func SecureClient(c rpcclient.Client, cert *lite.InquiringCertifier) Wrapper {
func (w Wrapper) ABCIQueryWithOptions(path string, data cmn.HexBytes,
opts rpcclient.ABCIQueryOptions) (*ctypes.ResultABCIQuery, error) {
res, _, err := GetWithProofOptions(path, data, opts, w.Client, w.cert)
res, err := GetWithProofOptions(path, data, opts, w.Client, w.cert)
return res, err
}