mirrors/tendermint
1
0
Fork 0
mirror of https://github.com/tendermint/tendermint.git synced 2026-04-24 01:30:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

libs/common: refactor libs/common 01 (#4230)

Browse Source 
* libs/common: Refactor libs/common 01

Signed-off-by: Marko Baricevic <marbar3778@yahoo.com>

* regenerate proto files, move intslice to where its used

* update kv.KVPair(s) to kv.Pair(s)

* add changelog entry

* make intInSlice private
This commit is contained in:
Marko
2019-12-10 12:40:01 +01:00
committed by GitHub
parent 6b1fef7f4d
commit dfebac86f7
26 changed files with 428 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG_PENDING.md
View File

@@ -68,6 +68,9 @@ program](https://hackerone.com/tendermint).
- [libs/common] \#3262 Make error the last parameter of `Task` (@PSalant726)
- [cs/types] \#3262 Rename `GotVoteFromUnwantedRoundError` to `ErrGotVoteFromUnwantedRound` (@PSalant726)
- [libs/common] \#3862 Remove `errors.go` from `libs/common`
- [libs/common] \#4230 Move `KV` out of common to its own pkg
- [libs/common] \#4230 Rename `cmn.KVPair(s)` to `kv.Pair(s)`s
- Blockchain Protocol

2
Makefile
View File

@@ -95,7 +95,7 @@ get_deps_bin_size:
########################################
### Libs
protoc_libs: libs/common/types.pb.go
protoc_libs: libs/kv/types.pb.go
# generates certificates for TLS testing in remotedb and RPC server
gen_certs: clean_certs

4
UPGRADING.md
View File

@@ -61,7 +61,7 @@ Prior to the update, suppose your `ResponseDeliverTx` look like:
```go
abci.ResponseDeliverTx{
Tags: []cmn.KVPair{
Tags: []kv.Pair{
{Key: []byte("sender"), Value: []byte("foo")},
{Key: []byte("recipient"), Value: []byte("bar")},
{Key: []byte("amount"), Value: []byte("35")},
@@ -85,7 +85,7 @@ abci.ResponseDeliverTx{
Events: []abci.Event{
{
Type: "transfer",
Attributes: cmn.KVPairs{
Attributes: kv.Pairs{
{Key: []byte("sender"), Value: []byte("foo")},
{Key: []byte("recipient"), Value: []byte("bar")},
{Key: []byte("amount"), Value: []byte("35")},

4
abci/example/kvstore/kvstore.go
View File

@@ -8,7 +8,7 @@ import (
"github.com/tendermint/tendermint/abci/example/code"
"github.com/tendermint/tendermint/abci/types"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
"github.com/tendermint/tendermint/version"
dbm "github.com/tendermint/tm-db"
)
@@ -91,7 +91,7 @@ func (app *Application) DeliverTx(req types.RequestDeliverTx) types.ResponseDeli
events := []types.Event{
{
Type: "app",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("creator"), Value: []byte("Cosmoshi Netowoko")},
{Key: []byte("key"), Value: key},
},

6
abci/types/messages_test.go
View File

@@ -9,7 +9,7 @@ import (
"github.com/gogo/protobuf/proto"
"github.com/stretchr/testify/assert"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
)
func TestMarshalJSON(t *testing.T) {
@@ -24,7 +24,7 @@ func TestMarshalJSON(t *testing.T) {
Events: []Event{
{
Type: "testEvent",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("pho"), Value: []byte("bo")},
},
},
@@ -91,7 +91,7 @@ func TestWriteReadMessage2(t *testing.T) {
Events: []Event{
{
Type: "testEvent",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("abc"), Value: []byte("def")},
},
},

485
abci/types/types.pb.go
View File

@@ -13,7 +13,7 @@ import (
golang_proto "github.com/golang/protobuf/proto"
_ "github.com/golang/protobuf/ptypes/timestamp"
merkle "github.com/tendermint/tendermint/crypto/merkle"
common "github.com/tendermint/tendermint/libs/common"
kv "github.com/tendermint/tendermint/libs/kv"
grpc "google.golang.org/grpc"
codes "google.golang.org/grpc/codes"
status "google.golang.org/grpc/status"
@@ -121,37 +121,37 @@ type isRequest_Value interface {
}
type Request_Echo struct {
Echo *RequestEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof"`
Echo *RequestEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof" json:"echo,omitempty"`
}
type Request_Flush struct {
Flush *RequestFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof"`
Flush *RequestFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"`
}
type Request_Info struct {
Info *RequestInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof"`
Info *RequestInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof" json:"info,omitempty"`
}
type Request_SetOption struct {
SetOption *RequestSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof"`
SetOption *RequestSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof" json:"set_option,omitempty"`
}
type Request_InitChain struct {
InitChain *RequestInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof"`
InitChain *RequestInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof" json:"init_chain,omitempty"`
}
type Request_Query struct {
Query *RequestQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof"`
Query *RequestQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof" json:"query,omitempty"`
}
type Request_BeginBlock struct {
BeginBlock *RequestBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof"`
BeginBlock *RequestBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof" json:"begin_block,omitempty"`
}
type Request_CheckTx struct {
CheckTx *RequestCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof"`
CheckTx *RequestCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof" json:"check_tx,omitempty"`
}
type Request_DeliverTx struct {
DeliverTx *RequestDeliverTx `protobuf:"bytes,19,opt,name=deliver_tx,json=deliverTx,proto3,oneof"`
DeliverTx *RequestDeliverTx `protobuf:"bytes,19,opt,name=deliver_tx,json=deliverTx,proto3,oneof" json:"deliver_tx,omitempty"`
}
type Request_EndBlock struct {
EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof"`
EndBlock *RequestEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof" json:"end_block,omitempty"`
}
type Request_Commit struct {
Commit *RequestCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof"`
Commit *RequestCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"`
}
func (*Request_Echo) isRequest_Value() {}
@@ -942,40 +942,40 @@ type isResponse_Value interface {
}
type Response_Exception struct {
Exception *ResponseException `protobuf:"bytes,1,opt,name=exception,proto3,oneof"`
Exception *ResponseException `protobuf:"bytes,1,opt,name=exception,proto3,oneof" json:"exception,omitempty"`
}
type Response_Echo struct {
Echo *ResponseEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof"`
Echo *ResponseEcho `protobuf:"bytes,2,opt,name=echo,proto3,oneof" json:"echo,omitempty"`
}
type Response_Flush struct {
Flush *ResponseFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof"`
Flush *ResponseFlush `protobuf:"bytes,3,opt,name=flush,proto3,oneof" json:"flush,omitempty"`
}
type Response_Info struct {
Info *ResponseInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof"`
Info *ResponseInfo `protobuf:"bytes,4,opt,name=info,proto3,oneof" json:"info,omitempty"`
}
type Response_SetOption struct {
SetOption *ResponseSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof"`
SetOption *ResponseSetOption `protobuf:"bytes,5,opt,name=set_option,json=setOption,proto3,oneof" json:"set_option,omitempty"`
}
type Response_InitChain struct {
InitChain *ResponseInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof"`
InitChain *ResponseInitChain `protobuf:"bytes,6,opt,name=init_chain,json=initChain,proto3,oneof" json:"init_chain,omitempty"`
}
type Response_Query struct {
Query *ResponseQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof"`
Query *ResponseQuery `protobuf:"bytes,7,opt,name=query,proto3,oneof" json:"query,omitempty"`
}
type Response_BeginBlock struct {
BeginBlock *ResponseBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof"`
BeginBlock *ResponseBeginBlock `protobuf:"bytes,8,opt,name=begin_block,json=beginBlock,proto3,oneof" json:"begin_block,omitempty"`
}
type Response_CheckTx struct {
CheckTx *ResponseCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof"`
CheckTx *ResponseCheckTx `protobuf:"bytes,9,opt,name=check_tx,json=checkTx,proto3,oneof" json:"check_tx,omitempty"`
}
type Response_DeliverTx struct {
DeliverTx *ResponseDeliverTx `protobuf:"bytes,10,opt,name=deliver_tx,json=deliverTx,proto3,oneof"`
DeliverTx *ResponseDeliverTx `protobuf:"bytes,10,opt,name=deliver_tx,json=deliverTx,proto3,oneof" json:"deliver_tx,omitempty"`
}
type Response_EndBlock struct {
EndBlock *ResponseEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof"`
EndBlock *ResponseEndBlock `protobuf:"bytes,11,opt,name=end_block,json=endBlock,proto3,oneof" json:"end_block,omitempty"`
}
type Response_Commit struct {
Commit *ResponseCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof"`
Commit *ResponseCommit `protobuf:"bytes,12,opt,name=commit,proto3,oneof" json:"commit,omitempty"`
}
func (*Response_Exception) isResponse_Value() {}
@@ -2185,11 +2185,11 @@ func (m *LastCommitInfo) GetVotes() []VoteInfo {
}
type Event struct {
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
Attributes []common.KVPair `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
Attributes []kv.Pair `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *Event) Reset() { *m = Event{} }
@@ -2232,7 +2232,7 @@ func (m *Event) GetType() string {
return ""
}
func (m *Event) GetAttributes() []common.KVPair {
func (m *Event) GetAttributes() []kv.Pair {
if m != nil {
return m.Attributes
}
@@ -2952,152 +2952,152 @@ func init() { proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa
func init() { golang_proto.RegisterFile("abci/types/types.proto", fileDescriptor_9f1eaa49c51fa1ac) }
var fileDescriptor_9f1eaa49c51fa1ac = []byte{
// 2317 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x3d, 0x70, 0x1b, 0xc7,
0x15, 0xe6, 0x01, 0x20, 0x80, 0x7b, 0xe0, 0x0f, 0xb4, 0x92, 0x6d, 0x18, 0x91, 0x49, 0xcd, 0xe9,
0x8f, 0x72, 0x6c, 0xc8, 0x51, 0xc6, 0x19, 0x29, 0xd2, 0x38, 0x43, 0x50, 0x72, 0x80, 0x91, 0x6c,
0xd3, 0x27, 0x89, 0x51, 0x7e, 0xc6, 0x37, 0x0b, 0xdc, 0x0a, 0xb8, 0x11, 0x70, 0x77, 0xbe, 0x5b,
0x50, 0x44, 0x26, 0x7d, 0x26, 0x5d, 0x9a, 0x94, 0xe9, 0x53, 0xa6, 0x48, 0xe1, 0x32, 0xa5, 0x8b,
0x14, 0x29, 0x52, 0x2b, 0x09, 0x93, 0x2a, 0xe3, 0x32, 0x93, 0x49, 0x99, 0xd9, 0xb7, 0x7b, 0x7f,
0x20, 0x40, 0x9c, 0x1c, 0x75, 0x6e, 0xc8, 0xdb, 0xc5, 0x7b, 0x6f, 0x77, 0xdf, 0xbe, 0xf7, 0xbe,
0xf7, 0xde, 0xc2, 0xeb, 0xb4, 0xd7, 0x77, 0xae, 0xf3, 0xa9, 0xcf, 0x42, 0xf9, 0xb7, 0xe5, 0x07,
0x1e, 0xf7, 0xc8, 0x6b, 0x9c, 0xb9, 0x36, 0x0b, 0xc6, 0x8e, 0xcb, 0x5b, 0x82, 0xa4, 0x85, 0x3f,
0x36, 0xdf, 0x1d, 0x38, 0x7c, 0x38, 0xe9, 0xb5, 0xfa, 0xde, 0xf8, 0xfa, 0xc0, 0x1b, 0x78, 0xd7,
0x91, 0xba, 0x37, 0x79, 0x8a, 0x23, 0x1c, 0xe0, 0x97, 0x94, 0xd2, 0xbc, 0x9d, 0x22, 0x4f, 0x04,
0xa6, 0x3f, 0xfb, 0xc1, 0xd4, 0xe7, 0xde, 0xf5, 0x31, 0x0b, 0x9e, 0x8d, 0x98, 0xfa, 0xa7, 0x98,
0x6f, 0x2e, 0x65, 0x1e, 0x39, 0xbd, 0xf0, 0x7a, 0xdf, 0x1b, 0x8f, 0x3d, 0x37, 0xbd, 0xf9, 0xe6,
0xf6, 0xc0, 0xf3, 0x06, 0x23, 0x96, 0x6c, 0x8e, 0x3b, 0x63, 0x16, 0x72, 0x3a, 0xf6, 0x25, 0x81,
0xf1, 0x9f, 0x55, 0xa8, 0x98, 0xec, 0xf3, 0x09, 0x0b, 0x39, 0xb9, 0x09, 0x25, 0xd6, 0x1f, 0x7a,
0x8d, 0xc2, 0x05, 0x6d, 0xa7, 0x76, 0xc3, 0x68, 0xcd, 0x3d, 0x78, 0x4b, 0x51, 0xdf, 0xeb, 0x0f,
0xbd, 0xce, 0x8a, 0x89, 0x1c, 0xe4, 0x36, 0xac, 0x3e, 0x1d, 0x4d, 0xc2, 0x61, 0xa3, 0x88, 0xac,
0x17, 0x4f, 0x67, 0xfd, 0x50, 0x90, 0x76, 0x56, 0x4c, 0xc9, 0x23, 0x96, 0x75, 0xdc, 0xa7, 0x5e,
0xa3, 0x94, 0x67, 0xd9, 0xae, 0xfb, 0x14, 0x97, 0x15, 0x1c, 0xa4, 0x03, 0x10, 0x32, 0x6e, 0x79,
0x3e, 0x77, 0x3c, 0xb7, 0xb1, 0x8a, 0xfc, 0x57, 0x4f, 0xe7, 0x7f, 0xc8, 0xf8, 0x27, 0x48, 0xde,
0x59, 0x31, 0xf5, 0x30, 0x1a, 0x08, 0x49, 0x8e, 0xeb, 0x70, 0xab, 0x3f, 0xa4, 0x8e, 0xdb, 0x28,
0xe7, 0x91, 0xd4, 0x75, 0x1d, 0xbe, 0x27, 0xc8, 0x85, 0x24, 0x27, 0x1a, 0x08, 0x55, 0x7c, 0x3e,
0x61, 0xc1, 0xb4, 0x51, 0xc9, 0xa3, 0x8a, 0x4f, 0x05, 0xa9, 0x50, 0x05, 0xf2, 0x90, 0xfb, 0x50,
0xeb, 0xb1, 0x81, 0xe3, 0x5a, 0xbd, 0x91, 0xd7, 0x7f, 0xd6, 0xa8, 0xa2, 0x88, 0x9d, 0xd3, 0x45,
0xb4, 0x05, 0x43, 0x5b, 0xd0, 0x77, 0x56, 0x4c, 0xe8, 0xc5, 0x23, 0xd2, 0x86, 0x6a, 0x7f, 0xc8,
0xfa, 0xcf, 0x2c, 0x7e, 0xd4, 0xd0, 0x51, 0xd2, 0xe5, 0xd3, 0x25, 0xed, 0x09, 0xea, 0x47, 0x47,
0x9d, 0x15, 0xb3, 0xd2, 0x97, 0x9f, 0x42, 0x2f, 0x36, 0x1b, 0x39, 0x87, 0x2c, 0x10, 0x52, 0xce,
0xe6, 0xd1, 0xcb, 0x5d, 0x49, 0x8f, 0x72, 0x74, 0x3b, 0x1a, 0x90, 0x7b, 0xa0, 0x33, 0xd7, 0x56,
0x07, 0xab, 0xa1, 0xa0, 0x2b, 0x4b, 0x2c, 0xcc, 0xb5, 0xa3, 0x63, 0x55, 0x99, 0xfa, 0x26, 0x1f,
0x40, 0x59, 0x98, 0xb9, 0xc3, 0x1b, 0x6b, 0x28, 0xe3, 0xd2, 0x92, 0x23, 0x21, 0x6d, 0x67, 0xc5,
0x54, 0x5c, 0xed, 0x0a, 0xac, 0x1e, 0xd2, 0xd1, 0x84, 0x19, 0x57, 0xa1, 0x96, 0xb2, 0x64, 0xd2,
0x80, 0xca, 0x98, 0x85, 0x21, 0x1d, 0xb0, 0x86, 0x76, 0x41, 0xdb, 0xd1, 0xcd, 0x68, 0x68, 0x6c,
0xc0, 0x5a, 0xda, 0x6e, 0x8d, 0x71, 0xcc, 0x28, 0x6c, 0x51, 0x30, 0x1e, 0xb2, 0x20, 0x14, 0x06,
0xa8, 0x18, 0xd5, 0x90, 0x5c, 0x84, 0x75, 0x3c, 0xad, 0x15, 0xfd, 0x2e, 0xfc, 0xaa, 0x64, 0xae,
0xe1, 0xe4, 0x81, 0x22, 0xda, 0x86, 0x9a, 0x7f, 0xc3, 0x8f, 0x49, 0x8a, 0x48, 0x02, 0xfe, 0x0d,
0x5f, 0x11, 0x18, 0xdf, 0x87, 0xfa, 0xac, 0xe9, 0x92, 0x3a, 0x14, 0x9f, 0xb1, 0xa9, 0x5a, 0x4f,
0x7c, 0x92, 0x73, 0xea, 0x58, 0xb8, 0x86, 0x6e, 0xaa, 0x33, 0xfe, 0xbe, 0x10, 0x33, 0xc7, 0xd6,
0x2a, 0xdc, 0x4d, 0x04, 0x01, 0xe4, 0xae, 0xdd, 0x68, 0xb6, 0x64, 0x84, 0x68, 0x45, 0x11, 0xa2,
0xf5, 0x28, 0x8a, 0x10, 0xed, 0xea, 0x97, 0x2f, 0xb6, 0x57, 0x7e, 0xfd, 0xd7, 0x6d, 0xcd, 0x44,
0x0e, 0xf2, 0xa6, 0x30, 0x28, 0xea, 0xb8, 0x96, 0x63, 0xab, 0x75, 0x2a, 0x38, 0xee, 0xda, 0xe4,
0x53, 0xa8, 0xf7, 0x3d, 0x37, 0x64, 0x6e, 0x38, 0x09, 0x2d, 0x9f, 0x06, 0x74, 0x1c, 0xaa, 0x58,
0xb0, 0xe8, 0x92, 0xf7, 0x22, 0xf2, 0x7d, 0xa4, 0x36, 0x37, 0xfb, 0xd9, 0x09, 0xf2, 0x00, 0xe0,
0x90, 0x8e, 0x1c, 0x9b, 0x72, 0x2f, 0x08, 0x1b, 0xa5, 0x0b, 0xc5, 0x53, 0x84, 0x1d, 0x44, 0x84,
0x8f, 0x7d, 0x9b, 0x72, 0xd6, 0x2e, 0x89, 0x9d, 0x9b, 0x29, 0x7e, 0x72, 0x05, 0x36, 0xa9, 0xef,
0x5b, 0x21, 0xa7, 0x9c, 0x59, 0xbd, 0x29, 0x67, 0x21, 0xc6, 0x8b, 0x35, 0x73, 0x9d, 0xfa, 0xfe,
0x43, 0x31, 0xdb, 0x16, 0x93, 0x86, 0x1d, 0xdf, 0x36, 0xba, 0x26, 0x21, 0x50, 0xb2, 0x29, 0xa7,
0xa8, 0xad, 0x35, 0x13, 0xbf, 0xc5, 0x9c, 0x4f, 0xf9, 0x50, 0xe9, 0x00, 0xbf, 0xc9, 0xeb, 0x50,
0x1e, 0x32, 0x67, 0x30, 0xe4, 0x78, 0xec, 0xa2, 0xa9, 0x46, 0xe2, 0x62, 0xfc, 0xc0, 0x3b, 0x64,
0x18, 0xdd, 0xaa, 0xa6, 0x1c, 0x18, 0xbf, 0x29, 0xc0, 0x99, 0x13, 0xee, 0x2b, 0xe4, 0x0e, 0x69,
0x38, 0x8c, 0xd6, 0x12, 0xdf, 0xe4, 0xb6, 0x90, 0x4b, 0x6d, 0x16, 0xa8, 0xa8, 0xfc, 0xd6, 0x02,
0x0d, 0x74, 0x90, 0x48, 0x1d, 0x5c, 0xb1, 0x90, 0xc7, 0x50, 0x1f, 0xd1, 0x90, 0x5b, 0xd2, 0xf6,
0x2d, 0x8c, 0xb2, 0xc5, 0x53, 0x23, 0xc1, 0x03, 0x1a, 0xf9, 0x8c, 0x30, 0x6e, 0x25, 0x6e, 0x63,
0x94, 0x99, 0x25, 0x4f, 0xe0, 0x5c, 0x6f, 0xfa, 0x73, 0xea, 0x72, 0xc7, 0x65, 0xd6, 0x89, 0x3b,
0xda, 0x5e, 0x20, 0xfa, 0xde, 0xa1, 0x63, 0x33, 0xb7, 0x1f, 0x5d, 0xce, 0xd9, 0x58, 0x44, 0x7c,
0x79, 0xa1, 0xf1, 0x04, 0x36, 0xb2, 0xb1, 0x88, 0x6c, 0x40, 0x81, 0x1f, 0x29, 0x8d, 0x14, 0xf8,
0x11, 0xf9, 0x1e, 0x94, 0x84, 0x38, 0xd4, 0xc6, 0xc6, 0x42, 0xb0, 0x50, 0xdc, 0x8f, 0xa6, 0x3e,
0x33, 0x91, 0xde, 0x30, 0x62, 0x4f, 0x88, 0xe3, 0xd3, 0xac, 0x6c, 0xe3, 0x1a, 0x6c, 0xce, 0x84,
0x9e, 0xd4, 0xb5, 0x6a, 0xe9, 0x6b, 0x35, 0x36, 0x61, 0x3d, 0x13, 0x61, 0x8c, 0x3f, 0x95, 0xa1,
0x6a, 0xb2, 0xd0, 0x17, 0x46, 0x4c, 0x3a, 0xa0, 0xb3, 0xa3, 0x3e, 0x93, 0xb0, 0xa4, 0x2d, 0x09,
0xe2, 0x92, 0xe7, 0x5e, 0x44, 0x2f, 0xa2, 0x66, 0xcc, 0x4c, 0x6e, 0x65, 0x20, 0xf9, 0xe2, 0x32,
0x21, 0x69, 0x4c, 0xbe, 0x93, 0xc5, 0xe4, 0x4b, 0x4b, 0x78, 0x67, 0x40, 0xf9, 0x56, 0x06, 0x94,
0x97, 0x2d, 0x9c, 0x41, 0xe5, 0xee, 0x1c, 0x54, 0x5e, 0x76, 0xfc, 0x05, 0xb0, 0xdc, 0x9d, 0x03,
0xcb, 0x3b, 0x4b, 0xf7, 0x32, 0x17, 0x97, 0xef, 0x64, 0x71, 0x79, 0x99, 0x3a, 0x66, 0x80, 0xf9,
0xc1, 0x3c, 0x60, 0xbe, 0xb6, 0x44, 0xc6, 0x42, 0x64, 0xde, 0x3b, 0x81, 0xcc, 0x57, 0x96, 0x88,
0x9a, 0x03, 0xcd, 0xdd, 0x0c, 0x34, 0x43, 0x2e, 0xdd, 0x2c, 0xc0, 0xe6, 0x0f, 0x4f, 0x62, 0xf3,
0xd5, 0x65, 0xa6, 0x36, 0x0f, 0x9c, 0x7f, 0x30, 0x03, 0xce, 0x97, 0x97, 0x9d, 0x6a, 0x21, 0x3a,
0x5f, 0x13, 0xf1, 0x71, 0xc6, 0x33, 0x44, 0x2c, 0x65, 0x41, 0xe0, 0x05, 0x0a, 0xf8, 0xe4, 0xc0,
0xd8, 0x11, 0x11, 0x3b, 0xb1, 0xff, 0x53, 0x90, 0x1c, 0x9d, 0x36, 0x65, 0xed, 0xc6, 0x17, 0x5a,
0xc2, 0x8b, 0x91, 0x2d, 0x1d, 0xed, 0x75, 0x15, 0xed, 0x53, 0x00, 0x5f, 0xc8, 0x02, 0xfc, 0x36,
0xd4, 0x04, 0xa6, 0xcc, 0x60, 0x37, 0xf5, 0x23, 0xec, 0x26, 0x6f, 0xc3, 0x19, 0x8c, 0xbf, 0x32,
0x0d, 0x50, 0x81, 0xa4, 0x84, 0x81, 0x64, 0x53, 0xfc, 0x20, 0x35, 0x28, 0x81, 0xe2, 0x5d, 0x38,
0x9b, 0xa2, 0x15, 0x72, 0x11, 0x0b, 0x24, 0x48, 0xd5, 0x63, 0xea, 0x5d, 0xdf, 0xef, 0xd0, 0x70,
0x68, 0x7c, 0x94, 0x28, 0x28, 0xc9, 0x0b, 0x08, 0x94, 0xfa, 0x9e, 0x2d, 0xcf, 0xbd, 0x6e, 0xe2,
0xb7, 0xc8, 0x15, 0x46, 0xde, 0x00, 0x37, 0xa7, 0x9b, 0xe2, 0x53, 0x50, 0xc5, 0xae, 0xad, 0x4b,
0x9f, 0x35, 0xfe, 0xa0, 0x25, 0xf2, 0x92, 0x54, 0x61, 0x1e, 0xaa, 0x6b, 0xaf, 0x12, 0xd5, 0x0b,
0xff, 0x1f, 0xaa, 0x1b, 0xff, 0xd6, 0x92, 0x2b, 0x8d, 0xf1, 0xfa, 0xeb, 0xa9, 0x40, 0x58, 0x97,
0xe3, 0xda, 0xec, 0x08, 0x55, 0x5e, 0x34, 0xe5, 0x20, 0x4a, 0xb5, 0xca, 0x78, 0x0d, 0xd9, 0x54,
0xab, 0x82, 0x73, 0x72, 0x40, 0xde, 0x47, 0x9c, 0xf7, 0x9e, 0xaa, 0xd0, 0x90, 0x01, 0x41, 0x59,
0xd9, 0xb5, 0x54, 0x49, 0xb7, 0x2f, 0xc8, 0x4c, 0x49, 0x9d, 0xc2, 0x17, 0x3d, 0x93, 0x36, 0x9c,
0x07, 0x5d, 0x6c, 0x3d, 0xf4, 0x69, 0x9f, 0xa1, 0x6f, 0xeb, 0x66, 0x32, 0x61, 0xd8, 0x40, 0x4e,
0xc6, 0x18, 0xf2, 0x31, 0x94, 0xd9, 0x21, 0x73, 0xb9, 0xb8, 0x23, 0xa1, 0xd6, 0xf3, 0x0b, 0x81,
0x98, 0xb9, 0xbc, 0xdd, 0x10, 0xca, 0xfc, 0xd7, 0x8b, 0xed, 0xba, 0xe4, 0x79, 0xc7, 0x1b, 0x3b,
0x9c, 0x8d, 0x7d, 0x3e, 0x35, 0x95, 0x14, 0xe3, 0x97, 0x05, 0x81, 0x87, 0x99, 0xf8, 0x33, 0x57,
0xbd, 0x91, 0xd3, 0x14, 0x52, 0x29, 0x52, 0x3e, 0x95, 0xbf, 0x05, 0x30, 0xa0, 0xa1, 0xf5, 0x9c,
0xba, 0x9c, 0xd9, 0x4a, 0xef, 0xfa, 0x80, 0x86, 0x3f, 0xc2, 0x09, 0x91, 0x6f, 0x8a, 0x9f, 0x27,
0x21, 0xb3, 0xf1, 0x02, 0x8a, 0x66, 0x65, 0x40, 0xc3, 0xc7, 0x21, 0xb3, 0x53, 0x67, 0xad, 0xbc,
0x8a, 0xb3, 0x66, 0xf5, 0x5d, 0x9d, 0xd5, 0xf7, 0xaf, 0x0a, 0x89, 0x77, 0x24, 0xe9, 0xc3, 0x37,
0x53, 0x17, 0xbf, 0xc5, 0x9a, 0x22, 0x0b, 0x02, 0xe4, 0xc7, 0x70, 0x26, 0xf6, 0x4a, 0x6b, 0x82,
0xde, 0x1a, 0x59, 0xe1, 0xcb, 0x39, 0x77, 0xfd, 0x30, 0x3b, 0x1d, 0x92, 0xcf, 0xe0, 0x8d, 0x99,
0x18, 0x14, 0x2f, 0x50, 0x78, 0xa9, 0x50, 0xf4, 0x5a, 0x36, 0x14, 0x45, 0xf2, 0x13, 0xed, 0x15,
0x5f, 0x89, 0xd7, 0x5c, 0x12, 0x29, 0x6c, 0x1a, 0xde, 0xe6, 0xd9, 0x84, 0xf1, 0x17, 0x0d, 0x36,
0x67, 0x36, 0x48, 0x6e, 0xc2, 0xaa, 0x44, 0x60, 0xed, 0xd4, 0x46, 0x08, 0x6a, 0x5c, 0x9d, 0x49,
0x32, 0x90, 0x5d, 0xa8, 0x32, 0x95, 0x5d, 0x2b, 0xa5, 0x5c, 0x5e, 0x92, 0x84, 0x2b, 0xfe, 0x98,
0x8d, 0xdc, 0x05, 0x3d, 0x56, 0xfd, 0x92, 0xca, 0x2d, 0xbe, 0x39, 0x25, 0x24, 0x61, 0x34, 0xf6,
0xa0, 0x96, 0xda, 0x1e, 0xf9, 0x16, 0xe8, 0x63, 0x7a, 0xa4, 0xca, 0x2d, 0x99, 0x40, 0x57, 0xc7,
0xf4, 0x08, 0x2b, 0x2d, 0xf2, 0x06, 0x54, 0xc4, 0x8f, 0x03, 0x2a, 0x2f, 0xb2, 0x68, 0x96, 0xc7,
0xf4, 0xe8, 0x87, 0x34, 0x34, 0xae, 0xc1, 0x46, 0x76, 0x9b, 0x11, 0x69, 0x04, 0xe9, 0x92, 0x74,
0x77, 0xc0, 0x8c, 0xf7, 0x61, 0x73, 0x66, 0x37, 0xc4, 0x80, 0x75, 0x7f, 0xd2, 0xb3, 0x9e, 0xb1,
0xa9, 0x85, 0xdb, 0x45, 0x33, 0xd4, 0xcd, 0x9a, 0x3f, 0xe9, 0xdd, 0x67, 0x53, 0x51, 0x11, 0x84,
0x46, 0x1f, 0x36, 0xb2, 0x85, 0x8e, 0x08, 0xea, 0x81, 0x37, 0x71, 0x6d, 0x94, 0xbf, 0x6a, 0xca,
0x01, 0xb9, 0x0d, 0xab, 0x87, 0x9e, 0xb4, 0xb4, 0xd3, 0x2a, 0x9b, 0x03, 0x8f, 0xb3, 0x54, 0xb9,
0x24, 0x79, 0x8c, 0x29, 0xac, 0xa2, 0xcd, 0x88, 0xfb, 0xc7, 0x92, 0x45, 0x25, 0x15, 0xe2, 0x9b,
0xfc, 0x0c, 0x80, 0x72, 0x1e, 0x38, 0xbd, 0x49, 0x22, 0x7e, 0x2b, 0x2d, 0x7e, 0xe4, 0xf4, 0xc2,
0x96, 0x6c, 0xe8, 0xb5, 0xee, 0x1f, 0xec, 0x53, 0x27, 0x68, 0x9f, 0x57, 0xb6, 0x77, 0x2e, 0xe1,
0x4c, 0xd9, 0x5f, 0x4a, 0x9e, 0xf1, 0x55, 0x09, 0xca, 0xb2, 0x20, 0x24, 0x1f, 0x64, 0xdb, 0x13,
0x33, 0xab, 0xa4, 0x0f, 0x21, 0xa9, 0xd4, 0x19, 0xe2, 0x1c, 0xe7, 0xca, 0x6c, 0xcd, 0xdf, 0xae,
0x1d, 0xbf, 0xd8, 0xae, 0x60, 0x7e, 0xd0, 0xbd, 0x9b, 0x34, 0x00, 0x16, 0xd5, 0xbf, 0x51, 0xb7,
0xa1, 0xf4, 0xd2, 0xdd, 0x86, 0x0e, 0xac, 0xa7, 0x12, 0x22, 0xc7, 0x56, 0x95, 0xc4, 0xd6, 0x69,
0x6e, 0xd1, 0xbd, 0xab, 0xf6, 0x5f, 0x8b, 0x13, 0xa6, 0xae, 0x4d, 0x76, 0xb2, 0x65, 0x30, 0xe6,
0x55, 0x12, 0xd0, 0x53, 0x95, 0xad, 0xc8, 0xaa, 0x84, 0xc1, 0x0a, 0xf7, 0x94, 0x24, 0x12, 0xdf,
0xab, 0x62, 0x02, 0x7f, 0xbc, 0x0a, 0x9b, 0x49, 0xea, 0x21, 0x49, 0xaa, 0x52, 0x4a, 0x32, 0x8d,
0x84, 0xef, 0xc1, 0x39, 0x97, 0x1d, 0x71, 0x6b, 0x96, 0x5a, 0x47, 0x6a, 0x22, 0x7e, 0x3b, 0xc8,
0x72, 0x5c, 0x86, 0x8d, 0x24, 0xc8, 0x21, 0x2d, 0xc8, 0xe6, 0x44, 0x3c, 0x8b, 0x64, 0x6f, 0x42,
0x35, 0x4e, 0x0c, 0x6b, 0x48, 0x50, 0xa1, 0x32, 0x1f, 0x8c, 0x53, 0xcd, 0x80, 0x85, 0x93, 0x11,
0x57, 0x42, 0xd6, 0x90, 0x06, 0x53, 0x4d, 0x53, 0xce, 0x23, 0xed, 0x45, 0x58, 0x8f, 0xfc, 0x5e,
0xd2, 0xad, 0x23, 0xdd, 0x5a, 0x34, 0x89, 0x44, 0xd7, 0xa0, 0xee, 0x07, 0x9e, 0xef, 0x85, 0x2c,
0xb0, 0xa8, 0x6d, 0x07, 0x2c, 0x0c, 0x1b, 0x1b, 0x52, 0x5e, 0x34, 0xbf, 0x2b, 0xa7, 0x8d, 0xef,
0x40, 0x25, 0xca, 0x78, 0xcf, 0xc1, 0x6a, 0x3b, 0x8e, 0x61, 0x25, 0x53, 0x0e, 0x04, 0x02, 0xee,
0xfa, 0xbe, 0xea, 0x7f, 0x89, 0x4f, 0x63, 0x04, 0x15, 0x75, 0x61, 0x73, 0xbb, 0x1e, 0x1f, 0xc1,
0x9a, 0x4f, 0x03, 0x71, 0x8c, 0x74, 0xef, 0x63, 0x51, 0xcd, 0xb6, 0x4f, 0x03, 0xfe, 0x90, 0xf1,
0x4c, 0x0b, 0xa4, 0x86, 0xfc, 0x72, 0xca, 0xb8, 0x05, 0xeb, 0x19, 0x1a, 0xb1, 0x4d, 0xee, 0x71,
0x3a, 0x8a, 0xdc, 0x1d, 0x07, 0xf1, 0x4e, 0x0a, 0xc9, 0x4e, 0x8c, 0xdb, 0xa0, 0xc7, 0x77, 0x25,
0x4a, 0x81, 0x48, 0x15, 0x9a, 0x52, 0xbf, 0x1c, 0x62, 0x9b, 0xc7, 0x7b, 0xce, 0x02, 0x65, 0xfd,
0x72, 0x60, 0xb0, 0x54, 0x78, 0x92, 0x78, 0x43, 0xee, 0x40, 0x45, 0x85, 0x27, 0xe5, 0x8f, 0x8b,
0x1a, 0x3a, 0xfb, 0x18, 0xaf, 0xa2, 0x86, 0x8e, 0x8c, 0x5e, 0xc9, 0x32, 0x85, 0xf4, 0x32, 0xbf,
0x80, 0x6a, 0x14, 0x82, 0xb2, 0x71, 0x5c, 0xae, 0x70, 0x61, 0x59, 0x1c, 0x57, 0x8b, 0x24, 0x8c,
0xc2, 0x9a, 0x42, 0x67, 0xe0, 0x32, 0xdb, 0x4a, 0x5c, 0x10, 0xd7, 0xac, 0x9a, 0x9b, 0xf2, 0x87,
0x07, 0x91, 0x7f, 0x19, 0xef, 0x41, 0x59, 0xee, 0x75, 0x6e, 0xa0, 0x9b, 0x07, 0x7e, 0xff, 0xd4,
0xa0, 0x1a, 0x45, 0xf8, 0xb9, 0x4c, 0x99, 0x43, 0x14, 0xbe, 0xee, 0x21, 0x5e, 0x7d, 0x48, 0x7a,
0x07, 0x08, 0x5a, 0x8a, 0x75, 0xe8, 0x71, 0xc7, 0x1d, 0x58, 0xf2, 0x2e, 0x64, 0xae, 0x56, 0xc7,
0x5f, 0x0e, 0xf0, 0x87, 0x7d, 0x31, 0xff, 0xf6, 0x45, 0xa8, 0xa5, 0xfa, 0x50, 0xa4, 0x02, 0xc5,
0x8f, 0xd9, 0xf3, 0xfa, 0x0a, 0xa9, 0x41, 0xc5, 0x64, 0x58, 0xc5, 0xd7, 0xb5, 0x1b, 0x5f, 0x55,
0x60, 0x73, 0xb7, 0xbd, 0xd7, 0xdd, 0xf5, 0xfd, 0x91, 0xd3, 0xa7, 0x58, 0xc6, 0x7d, 0x02, 0x25,
0xac, 0x64, 0x73, 0xbc, 0xc0, 0x34, 0xf3, 0xb4, 0x84, 0x88, 0x09, 0xab, 0x58, 0xf0, 0x92, 0x3c,
0x0f, 0x33, 0xcd, 0x5c, 0x9d, 0x22, 0xb1, 0x49, 0x34, 0xb8, 0x1c, 0xef, 0x35, 0xcd, 0x3c, 0xed,
0x23, 0xf2, 0x19, 0xe8, 0x49, 0x25, 0x9b, 0xf7, 0x15, 0xa7, 0x99, 0xbb, 0xb1, 0x24, 0xe4, 0x27,
0xb9, 0x7b, 0xde, 0x37, 0x8c, 0x66, 0xee, 0x8e, 0x0a, 0x79, 0x02, 0x95, 0xa8, 0x4a, 0xca, 0xf7,
0xce, 0xd2, 0xcc, 0xd9, 0xf4, 0x11, 0xd7, 0x27, 0x8b, 0xdb, 0x3c, 0x8f, 0x49, 0xcd, 0x5c, 0x9d,
0x2d, 0xf2, 0x18, 0xca, 0x2a, 0x3d, 0xcd, 0xf5, 0x82, 0xd2, 0xcc, 0xd7, 0xca, 0x11, 0x4a, 0x4e,
0xda, 0x07, 0x79, 0x1f, 0xd0, 0x9a, 0xb9, 0x5b, 0x7a, 0x84, 0x02, 0xa4, 0x2a, 0xde, 0xdc, 0x2f,
0x63, 0xcd, 0xfc, 0xad, 0x3a, 0xf2, 0x53, 0xa8, 0xc6, 0x75, 0x4d, 0xce, 0x17, 0xaa, 0x66, 0xde,
0x6e, 0x59, 0xbb, 0xfb, 0xdf, 0xbf, 0x6f, 0x69, 0xbf, 0x3b, 0xde, 0xd2, 0xbe, 0x38, 0xde, 0xd2,
0xbe, 0x3c, 0xde, 0xd2, 0xfe, 0x7c, 0xbc, 0xa5, 0xfd, 0xed, 0x78, 0x4b, 0xfb, 0xe3, 0x3f, 0xb6,
0xb4, 0x9f, 0x7c, 0x7b, 0xe9, 0x3b, 0x6f, 0xf2, 0x46, 0xdd, 0x2b, 0x63, 0xc0, 0xfa, 0xee, 0xff,
0x02, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x8c, 0x40, 0x9a, 0xb8, 0x1e, 0x00, 0x00,
// 2313 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x59, 0x4d, 0x90, 0x1b, 0x47,
0x15, 0xde, 0x91, 0xb4, 0x92, 0xe6, 0x69, 0x7f, 0xe4, 0xb6, 0x93, 0x28, 0xc2, 0xd9, 0x75, 0x8d,
0xff, 0xd6, 0x21, 0x91, 0xc3, 0x42, 0xa8, 0x18, 0xbb, 0x42, 0xad, 0xd6, 0x0e, 0x52, 0xc5, 0x49,
0x36, 0x63, 0x7b, 0x31, 0x50, 0x95, 0xa9, 0x96, 0xa6, 0x2d, 0x4d, 0xad, 0x34, 0x33, 0x99, 0x69,
0xc9, 0xbb, 0x14, 0x77, 0x8a, 0x1b, 0x17, 0x8e, 0xdc, 0x39, 0x72, 0xe0, 0x90, 0x23, 0xc7, 0x1c,
0x38, 0x70, 0xe0, 0x6c, 0x60, 0xe1, 0x44, 0xe5, 0x48, 0x51, 0x1c, 0xa9, 0x7e, 0xdd, 0xf3, 0x27,
0x4b, 0xab, 0x71, 0xf0, 0x2d, 0x97, 0xdd, 0xe9, 0xd6, 0x7b, 0xaf, 0xbb, 0x5f, 0xbf, 0xf7, 0xbe,
0xf7, 0x5e, 0xc3, 0xab, 0xb4, 0xd7, 0x77, 0x6e, 0xf2, 0x13, 0x9f, 0x85, 0xf2, 0x6f, 0xcb, 0x0f,
0x3c, 0xee, 0x91, 0x57, 0x38, 0x73, 0x6d, 0x16, 0x8c, 0x1d, 0x97, 0xb7, 0x04, 0x49, 0x0b, 0x7f,
0x6c, 0xbe, 0x3d, 0x70, 0xf8, 0x70, 0xd2, 0x6b, 0xf5, 0xbd, 0xf1, 0xcd, 0x81, 0x37, 0xf0, 0x6e,
0x22, 0x75, 0x6f, 0xf2, 0x04, 0x47, 0x38, 0xc0, 0x2f, 0x29, 0xa5, 0x79, 0x3b, 0x45, 0x9e, 0x08,
0x4c, 0x7f, 0xf6, 0x83, 0x13, 0x9f, 0x7b, 0x37, 0xc7, 0x2c, 0x38, 0x1a, 0x31, 0xf5, 0x4f, 0x31,
0x7f, 0x6f, 0x29, 0xf3, 0xc8, 0xe9, 0x85, 0x37, 0x8f, 0xa6, 0xe9, 0x8d, 0x37, 0xb7, 0x07, 0x9e,
0x37, 0x18, 0xb1, 0x64, 0x63, 0xdc, 0x19, 0xb3, 0x90, 0xd3, 0xb1, 0x2f, 0x09, 0x8c, 0xff, 0xac,
0x42, 0xc5, 0x64, 0x9f, 0x4f, 0x58, 0xc8, 0xc9, 0x7b, 0x50, 0x62, 0xfd, 0xa1, 0xd7, 0x28, 0x5c,
0xd2, 0x76, 0x6a, 0xbb, 0x46, 0x6b, 0xee, 0xa1, 0x5b, 0x8a, 0xfa, 0x5e, 0x7f, 0xe8, 0x75, 0x56,
0x4c, 0xe4, 0x20, 0xb7, 0x61, 0xf5, 0xc9, 0x68, 0x12, 0x0e, 0x1b, 0x45, 0x64, 0xbd, 0x7c, 0x36,
0xeb, 0x07, 0x82, 0xb4, 0xb3, 0x62, 0x4a, 0x1e, 0xb1, 0xac, 0xe3, 0x3e, 0xf1, 0x1a, 0xa5, 0x3c,
0xcb, 0x76, 0xdd, 0x27, 0xb8, 0xac, 0xe0, 0x20, 0x1d, 0x80, 0x90, 0x71, 0xcb, 0xf3, 0xb9, 0xe3,
0xb9, 0x8d, 0x55, 0xe4, 0xbf, 0x7e, 0x36, 0xff, 0x03, 0xc6, 0x3f, 0x41, 0xf2, 0xce, 0x8a, 0xa9,
0x87, 0xd1, 0x40, 0x48, 0x72, 0x5c, 0x87, 0x5b, 0xfd, 0x21, 0x75, 0xdc, 0x46, 0x39, 0x8f, 0xa4,
0xae, 0xeb, 0xf0, 0x7d, 0x41, 0x2e, 0x24, 0x39, 0xd1, 0x40, 0xa8, 0xe2, 0xf3, 0x09, 0x0b, 0x4e,
0x1a, 0x95, 0x3c, 0xaa, 0xf8, 0x54, 0x90, 0x0a, 0x55, 0x20, 0x0f, 0xf9, 0x10, 0x6a, 0x3d, 0x36,
0x70, 0x5c, 0xab, 0x37, 0xf2, 0xfa, 0x47, 0x8d, 0x2a, 0x8a, 0xd8, 0x39, 0x5b, 0x44, 0x5b, 0x30,
0xb4, 0x05, 0x7d, 0x67, 0xc5, 0x84, 0x5e, 0x3c, 0x22, 0x6d, 0xa8, 0xf6, 0x87, 0xac, 0x7f, 0x64,
0xf1, 0xe3, 0x86, 0x8e, 0x92, 0xae, 0x9e, 0x2d, 0x69, 0x5f, 0x50, 0x3f, 0x3c, 0xee, 0xac, 0x98,
0x95, 0xbe, 0xfc, 0x14, 0x7a, 0xb1, 0xd9, 0xc8, 0x99, 0xb2, 0x40, 0x48, 0x39, 0x9f, 0x47, 0x2f,
0x77, 0x25, 0x3d, 0xca, 0xd1, 0xed, 0x68, 0x40, 0xee, 0x81, 0xce, 0x5c, 0x5b, 0x1d, 0xac, 0x86,
0x82, 0xae, 0x2d, 0xb1, 0x30, 0xd7, 0x8e, 0x8e, 0x55, 0x65, 0xea, 0x9b, 0xbc, 0x0f, 0xe5, 0xbe,
0x37, 0x1e, 0x3b, 0xbc, 0xb1, 0x86, 0x32, 0xae, 0x2c, 0x39, 0x12, 0xd2, 0x76, 0x56, 0x4c, 0xc5,
0xd5, 0xae, 0xc0, 0xea, 0x94, 0x8e, 0x26, 0xcc, 0xb8, 0x0e, 0xb5, 0x94, 0x25, 0x93, 0x06, 0x54,
0xc6, 0x2c, 0x0c, 0xe9, 0x80, 0x35, 0xb4, 0x4b, 0xda, 0x8e, 0x6e, 0x46, 0x43, 0x63, 0x03, 0xd6,
0xd2, 0x76, 0x6b, 0x8c, 0x63, 0x46, 0x61, 0x8b, 0x82, 0x71, 0xca, 0x82, 0x50, 0x18, 0xa0, 0x62,
0x54, 0x43, 0x72, 0x19, 0xd6, 0xf1, 0xb4, 0x56, 0xf4, 0xbb, 0xf0, 0xab, 0x92, 0xb9, 0x86, 0x93,
0x87, 0x8a, 0x68, 0x1b, 0x6a, 0xfe, 0xae, 0x1f, 0x93, 0x14, 0x91, 0x04, 0xfc, 0x5d, 0x5f, 0x11,
0x18, 0x3f, 0x80, 0xfa, 0xac, 0xe9, 0x92, 0x3a, 0x14, 0x8f, 0xd8, 0x89, 0x5a, 0x4f, 0x7c, 0x92,
0x0b, 0xea, 0x58, 0xb8, 0x86, 0x6e, 0xaa, 0x33, 0xfe, 0xbe, 0x10, 0x33, 0xc7, 0xd6, 0x2a, 0xdc,
0x4d, 0x04, 0x01, 0xe4, 0xae, 0xed, 0x36, 0x5b, 0x32, 0x42, 0xb4, 0xa2, 0x08, 0xd1, 0x7a, 0x18,
0x45, 0x88, 0x76, 0xf5, 0xcb, 0x67, 0xdb, 0x2b, 0xbf, 0xfe, 0xeb, 0xb6, 0x66, 0x22, 0x07, 0x79,
0x5d, 0x18, 0x14, 0x75, 0x5c, 0xcb, 0xb1, 0xd5, 0x3a, 0x15, 0x1c, 0x77, 0x6d, 0xf2, 0x29, 0xd4,
0xfb, 0x9e, 0x1b, 0x32, 0x37, 0x9c, 0x84, 0x96, 0x4f, 0x03, 0x3a, 0x0e, 0x55, 0x2c, 0x58, 0x74,
0xc9, 0xfb, 0x11, 0xf9, 0x01, 0x52, 0x9b, 0x9b, 0xfd, 0xec, 0x04, 0xb9, 0x0f, 0x30, 0xa5, 0x23,
0xc7, 0xa6, 0xdc, 0x0b, 0xc2, 0x46, 0xe9, 0x52, 0xf1, 0x0c, 0x61, 0x87, 0x11, 0xe1, 0x23, 0xdf,
0xa6, 0x9c, 0xb5, 0x4b, 0x62, 0xe7, 0x66, 0x8a, 0x9f, 0x5c, 0x83, 0x4d, 0xea, 0xfb, 0x56, 0xc8,
0x29, 0x67, 0x56, 0xef, 0x84, 0xb3, 0x10, 0xe3, 0xc5, 0x9a, 0xb9, 0x4e, 0x7d, 0xff, 0x81, 0x98,
0x6d, 0x8b, 0x49, 0xc3, 0x8e, 0x6f, 0x1b, 0x5d, 0x93, 0x10, 0x28, 0xd9, 0x94, 0x53, 0xd4, 0xd6,
0x9a, 0x89, 0xdf, 0x62, 0xce, 0xa7, 0x7c, 0xa8, 0x74, 0x80, 0xdf, 0xe4, 0x55, 0x28, 0x0f, 0x99,
0x33, 0x18, 0x72, 0x3c, 0x76, 0xd1, 0x54, 0x23, 0x71, 0x31, 0x7e, 0xe0, 0x4d, 0x19, 0x46, 0xb7,
0xaa, 0x29, 0x07, 0xc6, 0x6f, 0x0a, 0x70, 0xee, 0x39, 0xf7, 0x15, 0x72, 0x87, 0x34, 0x1c, 0x46,
0x6b, 0x89, 0x6f, 0x72, 0x5b, 0xc8, 0xa5, 0x36, 0x0b, 0x54, 0x54, 0x7e, 0x63, 0x81, 0x06, 0x3a,
0x48, 0xa4, 0x0e, 0xae, 0x58, 0xc8, 0x23, 0xa8, 0x8f, 0x68, 0xc8, 0x2d, 0x69, 0xfb, 0x16, 0x46,
0xd9, 0xe2, 0x99, 0x91, 0xe0, 0x3e, 0x8d, 0x7c, 0x46, 0x18, 0xb7, 0x12, 0xb7, 0x31, 0xca, 0xcc,
0x92, 0xc7, 0x70, 0xa1, 0x77, 0xf2, 0x73, 0xea, 0x72, 0xc7, 0x65, 0xd6, 0x73, 0x77, 0xb4, 0xbd,
0x40, 0xf4, 0xbd, 0xa9, 0x63, 0x33, 0xb7, 0x1f, 0x5d, 0xce, 0xf9, 0x58, 0x44, 0x7c, 0x79, 0xa1,
0xf1, 0x18, 0x36, 0xb2, 0xb1, 0x88, 0x6c, 0x40, 0x81, 0x1f, 0x2b, 0x8d, 0x14, 0xf8, 0x31, 0xf9,
0x3e, 0x94, 0x84, 0x38, 0xd4, 0xc6, 0xc6, 0x42, 0xb0, 0x50, 0xdc, 0x0f, 0x4f, 0x7c, 0x66, 0x22,
0xbd, 0x61, 0xc4, 0x9e, 0x10, 0xc7, 0xa7, 0x59, 0xd9, 0xc6, 0x0d, 0xd8, 0x9c, 0x09, 0x3d, 0xa9,
0x6b, 0xd5, 0xd2, 0xd7, 0x6a, 0x6c, 0xc2, 0x7a, 0x26, 0xc2, 0x18, 0x7f, 0x2a, 0x43, 0xd5, 0x64,
0xa1, 0x2f, 0x8c, 0x98, 0x74, 0x40, 0x67, 0xc7, 0x7d, 0x26, 0x61, 0x49, 0x5b, 0x12, 0xc4, 0x25,
0xcf, 0xbd, 0x88, 0x5e, 0x44, 0xcd, 0x98, 0x99, 0xdc, 0xca, 0x40, 0xf2, 0xe5, 0x65, 0x42, 0xd2,
0x98, 0x7c, 0x27, 0x8b, 0xc9, 0x57, 0x96, 0xf0, 0xce, 0x80, 0xf2, 0xad, 0x0c, 0x28, 0x2f, 0x5b,
0x38, 0x83, 0xca, 0xdd, 0x39, 0xa8, 0xbc, 0xec, 0xf8, 0x0b, 0x60, 0xb9, 0x3b, 0x07, 0x96, 0x77,
0x96, 0xee, 0x65, 0x2e, 0x2e, 0xdf, 0xc9, 0xe2, 0xf2, 0x32, 0x75, 0xcc, 0x00, 0xf3, 0xfd, 0x79,
0xc0, 0x7c, 0x63, 0x89, 0x8c, 0x85, 0xc8, 0xbc, 0xff, 0x1c, 0x32, 0x5f, 0x5b, 0x22, 0x6a, 0x0e,
0x34, 0x77, 0x33, 0xd0, 0x0c, 0xb9, 0x74, 0xb3, 0x00, 0x9b, 0x3f, 0x78, 0x1e, 0x9b, 0xaf, 0x2f,
0x33, 0xb5, 0x79, 0xe0, 0xfc, 0xc3, 0x19, 0x70, 0xbe, 0xba, 0xec, 0x54, 0x0b, 0xd1, 0xf9, 0x86,
0x88, 0x8f, 0x33, 0x9e, 0x21, 0x62, 0x29, 0x0b, 0x02, 0x2f, 0x50, 0xc0, 0x27, 0x07, 0xc6, 0x8e,
0x88, 0xd8, 0x89, 0xfd, 0x9f, 0x81, 0xe4, 0xe8, 0xb4, 0x29, 0x6b, 0x37, 0xbe, 0xd0, 0x12, 0x5e,
0x8c, 0x6c, 0xe9, 0x68, 0xaf, 0xab, 0x68, 0x9f, 0x02, 0xf8, 0x42, 0x16, 0xe0, 0xb7, 0xa1, 0x26,
0x30, 0x65, 0x06, 0xbb, 0xa9, 0x1f, 0x61, 0x37, 0x79, 0x13, 0xce, 0x61, 0xfc, 0x95, 0x69, 0x80,
0x0a, 0x24, 0x25, 0x0c, 0x24, 0x9b, 0xe2, 0x07, 0xa9, 0x41, 0x09, 0x14, 0x6f, 0xc3, 0xf9, 0x14,
0xad, 0x90, 0x8b, 0x58, 0x20, 0x41, 0xaa, 0x1e, 0x53, 0xef, 0xf9, 0x7e, 0x87, 0x86, 0x43, 0xe3,
0xa3, 0x44, 0x41, 0x49, 0x5e, 0x40, 0xa0, 0xd4, 0xf7, 0x6c, 0x79, 0xee, 0x75, 0x13, 0xbf, 0x45,
0xae, 0x30, 0xf2, 0x06, 0xb8, 0x39, 0xdd, 0x14, 0x9f, 0x82, 0x2a, 0x76, 0x6d, 0x5d, 0xfa, 0xac,
0xf1, 0x07, 0x2d, 0x91, 0x97, 0xa4, 0x0a, 0xf3, 0x50, 0x5d, 0x7b, 0x99, 0xa8, 0x5e, 0xf8, 0xff,
0x50, 0xdd, 0xf8, 0xb7, 0x96, 0x5c, 0x69, 0x8c, 0xd7, 0x5f, 0x4f, 0x05, 0xc2, 0xba, 0x1c, 0xd7,
0x66, 0xc7, 0xa8, 0xf2, 0xa2, 0x29, 0x07, 0x51, 0xaa, 0x55, 0xc6, 0x6b, 0xc8, 0xa6, 0x5a, 0x15,
0x9c, 0x93, 0x03, 0xf2, 0x2e, 0xe2, 0xbc, 0xf7, 0x44, 0x85, 0x86, 0x0c, 0x08, 0xca, 0xaa, 0xae,
0xa5, 0xca, 0xb9, 0x03, 0x41, 0x66, 0x4a, 0xea, 0x14, 0xbe, 0xe8, 0x99, 0xb4, 0xe1, 0x22, 0xe8,
0x62, 0xeb, 0xa1, 0x4f, 0xfb, 0x0c, 0x7d, 0x5b, 0x37, 0x93, 0x09, 0xc3, 0x06, 0xf2, 0x7c, 0x8c,
0x21, 0x1f, 0x43, 0x99, 0x4d, 0x99, 0xcb, 0xc5, 0x1d, 0x09, 0xb5, 0x5e, 0x5c, 0x08, 0xc4, 0xcc,
0xe5, 0xed, 0x86, 0x50, 0xe6, 0xbf, 0x9e, 0x6d, 0xd7, 0x25, 0xcf, 0x5b, 0xde, 0xd8, 0xe1, 0x6c,
0xec, 0xf3, 0x13, 0x53, 0x49, 0x31, 0x7e, 0x59, 0x10, 0x78, 0x98, 0x89, 0x3f, 0x73, 0xd5, 0x1b,
0x39, 0x4d, 0x21, 0x95, 0x22, 0xe5, 0x53, 0xf9, 0x1b, 0x00, 0x03, 0x1a, 0x5a, 0x4f, 0xa9, 0xcb,
0x99, 0xad, 0xf4, 0xae, 0x0f, 0x68, 0xf8, 0x63, 0x9c, 0x10, 0xf9, 0xa6, 0xf8, 0x79, 0x12, 0x32,
0x1b, 0x2f, 0xa0, 0x68, 0x56, 0x06, 0x34, 0x7c, 0x14, 0x32, 0x3b, 0x75, 0xd6, 0xca, 0xcb, 0x38,
0x6b, 0x56, 0xdf, 0xd5, 0x59, 0x7d, 0xff, 0xaa, 0x90, 0x78, 0x47, 0x92, 0x3e, 0x7c, 0x33, 0x75,
0xf1, 0x5b, 0xac, 0x29, 0xb2, 0x20, 0x40, 0x7e, 0x02, 0xe7, 0x62, 0xaf, 0xb4, 0x26, 0xe8, 0xad,
0x91, 0x15, 0xbe, 0x98, 0x73, 0xd7, 0xa7, 0xd9, 0xe9, 0x90, 0x7c, 0x06, 0xaf, 0xcd, 0xc4, 0xa0,
0x78, 0x81, 0xc2, 0x0b, 0x85, 0xa2, 0x57, 0xb2, 0xa1, 0x28, 0x92, 0x9f, 0x68, 0xaf, 0xf8, 0x52,
0xbc, 0xe6, 0x8a, 0x48, 0x61, 0xd3, 0xf0, 0x36, 0xcf, 0x26, 0x8c, 0xbf, 0x68, 0xb0, 0x39, 0xb3,
0x41, 0xf2, 0x1e, 0xac, 0x4a, 0x04, 0xd6, 0xce, 0x6c, 0x84, 0xa0, 0xc6, 0xd5, 0x99, 0x24, 0x03,
0xd9, 0x83, 0x2a, 0x53, 0xd9, 0xb5, 0x52, 0xca, 0xd5, 0x25, 0x49, 0xb8, 0xe2, 0x8f, 0xd9, 0xc8,
0x5d, 0xd0, 0x63, 0xd5, 0x2f, 0xa9, 0xdc, 0xe2, 0x9b, 0x53, 0x42, 0x12, 0x46, 0x63, 0x1f, 0x6a,
0xa9, 0xed, 0x91, 0x6f, 0x81, 0x3e, 0xa6, 0xc7, 0xaa, 0xdc, 0x92, 0x09, 0x74, 0x75, 0x4c, 0x8f,
0xb1, 0xd2, 0x22, 0xaf, 0x41, 0x45, 0xfc, 0x38, 0xa0, 0xf2, 0x22, 0x8b, 0x66, 0x79, 0x4c, 0x8f,
0x7f, 0x44, 0x43, 0xe3, 0x06, 0x6c, 0x64, 0xb7, 0x19, 0x91, 0x46, 0x90, 0x2e, 0x49, 0xf7, 0x06,
0xcc, 0x78, 0x17, 0x36, 0x67, 0x76, 0x43, 0x0c, 0x58, 0xf7, 0x27, 0x3d, 0xeb, 0x88, 0x9d, 0x58,
0xb8, 0x5d, 0x34, 0x43, 0xdd, 0xac, 0xf9, 0x93, 0xde, 0x87, 0xec, 0x44, 0x54, 0x04, 0xa1, 0xd1,
0x87, 0x8d, 0x6c, 0xa1, 0x23, 0x82, 0x7a, 0xe0, 0x4d, 0x5c, 0x1b, 0xe5, 0xaf, 0x9a, 0x72, 0x40,
0x6e, 0xc3, 0xea, 0xd4, 0x93, 0x96, 0x76, 0x56, 0x65, 0x73, 0xe8, 0x71, 0x96, 0x2a, 0x97, 0x24,
0x8f, 0x11, 0xc2, 0x2a, 0xda, 0x8c, 0xb8, 0x7f, 0x2c, 0x59, 0x54, 0x52, 0x21, 0xbe, 0xc9, 0x21,
0x00, 0xe5, 0x3c, 0x70, 0x7a, 0x93, 0x44, 0x7c, 0x23, 0x2d, 0x7e, 0xe4, 0xf4, 0xc2, 0xd6, 0xd1,
0xb4, 0x75, 0x40, 0x9d, 0xa0, 0x7d, 0x51, 0x59, 0xdd, 0x85, 0x84, 0x27, 0x65, 0x79, 0x29, 0x49,
0xc6, 0x57, 0x25, 0x28, 0xcb, 0x52, 0x90, 0xbc, 0x9f, 0x6d, 0x4c, 0xd4, 0x76, 0xb7, 0x16, 0x6d,
0x5f, 0x52, 0xa9, 0xdd, 0xc7, 0xd9, 0xcd, 0xb5, 0xd9, 0x6a, 0xbf, 0x5d, 0x3b, 0x7d, 0xb6, 0x5d,
0xc1, 0xcc, 0xa0, 0x7b, 0x37, 0x29, 0xfd, 0x17, 0x55, 0xbe, 0x51, 0x9f, 0xa1, 0xf4, 0xc2, 0x7d,
0x86, 0x0e, 0xac, 0xa7, 0x52, 0x21, 0xc7, 0x56, 0x35, 0xc4, 0xd6, 0x59, 0x0e, 0xd1, 0xbd, 0xab,
0xf6, 0x5f, 0x8b, 0x53, 0xa5, 0xae, 0x4d, 0x76, 0xb2, 0x05, 0x30, 0x66, 0x54, 0x12, 0xca, 0x53,
0x35, 0xad, 0xc8, 0xa7, 0x84, 0xa9, 0x0a, 0xc7, 0x94, 0x24, 0x12, 0xd9, 0xab, 0x62, 0x02, 0x7f,
0xbc, 0x0e, 0x9b, 0x49, 0xd2, 0x21, 0x49, 0xaa, 0x52, 0x4a, 0x32, 0x8d, 0x84, 0xef, 0xc0, 0x05,
0x97, 0x1d, 0x73, 0x6b, 0x96, 0x5a, 0x47, 0x6a, 0x22, 0x7e, 0x3b, 0xcc, 0x72, 0x5c, 0x85, 0x8d,
0x24, 0xbc, 0x21, 0x2d, 0xc8, 0xb6, 0x44, 0x3c, 0x8b, 0x64, 0xaf, 0x43, 0x35, 0x4e, 0x09, 0x6b,
0x48, 0x50, 0xa1, 0x32, 0x13, 0x8c, 0x93, 0xcc, 0x80, 0x85, 0x93, 0x11, 0x57, 0x42, 0xd6, 0x90,
0x06, 0x93, 0x4c, 0x53, 0xce, 0x23, 0xed, 0x65, 0x58, 0x8f, 0x3c, 0x5e, 0xd2, 0xad, 0x23, 0xdd,
0x5a, 0x34, 0x89, 0x44, 0x37, 0xa0, 0xee, 0x07, 0x9e, 0xef, 0x85, 0x2c, 0xb0, 0xa8, 0x6d, 0x07,
0x2c, 0x0c, 0x1b, 0x1b, 0x52, 0x5e, 0x34, 0xbf, 0x27, 0xa7, 0x8d, 0xef, 0x40, 0x25, 0xca, 0x75,
0x2f, 0xc0, 0x6a, 0x3b, 0x8e, 0x5e, 0x25, 0x53, 0x0e, 0x04, 0xf6, 0xed, 0xf9, 0xbe, 0xea, 0x7c,
0x89, 0x4f, 0x63, 0x04, 0x15, 0x75, 0x61, 0x73, 0xfb, 0x1d, 0x1f, 0xc1, 0x9a, 0x4f, 0x03, 0x71,
0x8c, 0x74, 0xd7, 0x63, 0x51, 0xb5, 0x76, 0x40, 0x03, 0xfe, 0x80, 0xf1, 0x4c, 0xf3, 0xa3, 0x86,
0xfc, 0x72, 0xca, 0xb8, 0x05, 0xeb, 0x19, 0x1a, 0xb1, 0x4d, 0xee, 0x71, 0x3a, 0x8a, 0x1c, 0x1d,
0x07, 0xf1, 0x4e, 0x0a, 0xc9, 0x4e, 0x8c, 0xdb, 0xa0, 0xc7, 0x77, 0x25, 0x8a, 0x80, 0x48, 0x15,
0x9a, 0x52, 0xbf, 0x1c, 0x62, 0x83, 0xc7, 0x7b, 0xca, 0x02, 0x65, 0xfd, 0x72, 0x60, 0xb0, 0x54,
0x60, 0x92, 0x48, 0x43, 0xee, 0x40, 0x45, 0x05, 0x26, 0xe5, 0x8f, 0x8b, 0x5a, 0x39, 0x07, 0x18,
0xa9, 0xa2, 0x56, 0x8e, 0x8c, 0x5b, 0xc9, 0x32, 0x85, 0xf4, 0x32, 0xbf, 0x80, 0x6a, 0x14, 0x7c,
0xb2, 0x11, 0x5c, 0xae, 0x70, 0x69, 0x59, 0x04, 0x57, 0x8b, 0x24, 0x8c, 0xc2, 0x9a, 0x42, 0x67,
0xe0, 0x32, 0xdb, 0x4a, 0x5c, 0x10, 0xd7, 0xac, 0x9a, 0x9b, 0xf2, 0x87, 0xfb, 0x91, 0x7f, 0x19,
0xef, 0x40, 0x59, 0xee, 0x75, 0x6e, 0x88, 0x9b, 0x07, 0x7b, 0xff, 0xd4, 0xa0, 0x1a, 0xc5, 0xf6,
0xb9, 0x4c, 0x99, 0x43, 0x14, 0xbe, 0xee, 0x21, 0x5e, 0x7e, 0x48, 0x7a, 0x0b, 0x08, 0x5a, 0x8a,
0x35, 0xf5, 0xb8, 0xe3, 0x0e, 0x2c, 0x79, 0x17, 0x32, 0x4b, 0xab, 0xe3, 0x2f, 0x87, 0xf8, 0xc3,
0x81, 0x98, 0x7f, 0xf3, 0x32, 0xd4, 0x52, 0x1d, 0x28, 0x52, 0x81, 0xe2, 0xc7, 0xec, 0x69, 0x7d,
0x85, 0xd4, 0xa0, 0x62, 0x32, 0xac, 0xdf, 0xeb, 0xda, 0xee, 0x57, 0x15, 0xd8, 0xdc, 0x6b, 0xef,
0x77, 0xf7, 0x7c, 0x7f, 0xe4, 0xf4, 0x29, 0x16, 0x70, 0x9f, 0x40, 0x09, 0x6b, 0xd8, 0x1c, 0x6f,
0x2f, 0xcd, 0x3c, 0xcd, 0x20, 0x62, 0xc2, 0x2a, 0x96, 0xba, 0x24, 0xcf, 0x93, 0x4c, 0x33, 0x57,
0x8f, 0x48, 0x6c, 0x12, 0x0d, 0x2e, 0xc7, 0x4b, 0x4d, 0x33, 0x4f, 0xe3, 0x88, 0x7c, 0x06, 0x7a,
0x52, 0xc3, 0xe6, 0x7d, 0xbf, 0x69, 0xe6, 0x6e, 0x29, 0x09, 0xf9, 0x49, 0xd6, 0x9e, 0xf7, 0xf5,
0xa2, 0x99, 0xbb, 0x97, 0x42, 0x1e, 0x43, 0x25, 0xaa, 0x8f, 0xf2, 0xbd, 0xb0, 0x34, 0x73, 0xb6,
0x7b, 0xc4, 0xf5, 0xc9, 0xb2, 0x36, 0xcf, 0x33, 0x52, 0x33, 0x57, 0x4f, 0x8b, 0x3c, 0x82, 0xb2,
0x4a, 0x4c, 0x73, 0xbd, 0x9d, 0x34, 0xf3, 0x35, 0x71, 0x84, 0x92, 0x93, 0xc6, 0x41, 0xde, 0xa7,
0xb3, 0x66, 0xee, 0x66, 0x1e, 0xa1, 0x00, 0xa9, 0x5a, 0x37, 0xf7, 0x9b, 0x58, 0x33, 0x7f, 0x93,
0x8e, 0xfc, 0x0c, 0xaa, 0x71, 0x45, 0x93, 0xf3, 0x6d, 0xaa, 0x99, 0xb7, 0x4f, 0xd6, 0xee, 0xfe,
0xf7, 0xef, 0x5b, 0xda, 0xef, 0x4e, 0xb7, 0xb4, 0x2f, 0x4e, 0xb7, 0xb4, 0x2f, 0x4f, 0xb7, 0xb4,
0x3f, 0x9f, 0x6e, 0x69, 0x7f, 0x3b, 0xdd, 0xd2, 0xfe, 0xf8, 0x8f, 0x2d, 0xed, 0xa7, 0xdf, 0x5e,
0xfa, 0xba, 0x9b, 0xbc, 0x4c, 0xf7, 0xca, 0x18, 0xb0, 0xbe, 0xfb, 0xbf, 0x00, 0x00, 0x00, 0xff,
0xff, 0x83, 0x66, 0x2e, 0x0b, 0xae, 0x1e, 0x00, 0x00,
}
func (this *Request) Equal(that interface{}) bool {
@@ -5490,7 +5490,8 @@ func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
func (m *Request_Echo) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5510,7 +5511,8 @@ func (m *Request_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_Flush) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5530,7 +5532,8 @@ func (m *Request_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_Info) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5550,7 +5553,8 @@ func (m *Request_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_SetOption) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5570,7 +5574,8 @@ func (m *Request_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_InitChain) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5590,7 +5595,8 @@ func (m *Request_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_Query) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5610,7 +5616,8 @@ func (m *Request_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_BeginBlock) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5630,7 +5637,8 @@ func (m *Request_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_CheckTx) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5650,7 +5658,8 @@ func (m *Request_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_EndBlock) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5670,7 +5679,8 @@ func (m *Request_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_Commit) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -5690,7 +5700,8 @@ func (m *Request_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Request_DeliverTx) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Request_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6225,7 +6236,8 @@ func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
}
func (m *Response_Exception) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6245,7 +6257,8 @@ func (m *Response_Exception) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_Echo) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6265,7 +6278,8 @@ func (m *Response_Echo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_Flush) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6285,7 +6299,8 @@ func (m *Response_Flush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_Info) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6305,7 +6320,8 @@ func (m *Response_Info) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_SetOption) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6325,7 +6341,8 @@ func (m *Response_SetOption) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_InitChain) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6345,7 +6362,8 @@ func (m *Response_InitChain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_Query) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6365,7 +6383,8 @@ func (m *Response_Query) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_BeginBlock) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6385,7 +6404,8 @@ func (m *Response_BeginBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_CheckTx) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6405,7 +6425,8 @@ func (m *Response_CheckTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_DeliverTx) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6425,7 +6446,8 @@ func (m *Response_DeliverTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_EndBlock) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -6445,7 +6467,8 @@ func (m *Response_EndBlock) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *Response_Commit) MarshalTo(dAtA []byte) (int, error) {
return m.MarshalToSizedBuffer(dAtA[:m.Size()])
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Response_Commit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
@@ -8522,9 +8545,9 @@ func NewPopulatedEvent(r randyTypes, easy bool) *Event {
this.Type = string(randStringTypes(r))
if r.Intn(5) != 0 {
v34 := r.Intn(5)
this.Attributes = make([]common.KVPair, v34)
this.Attributes = make([]kv.Pair, v34)
for i := 0; i < v34; i++ {
v35 := common.NewPopulatedKVPair(r, easy)
v35 := kv.NewPopulatedPair(r, easy)
this.Attributes[i] = *v35
}
}
@@ -14631,7 +14654,7 @@ func (m *Event) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Attributes = append(m.Attributes, common.KVPair{})
m.Attributes = append(m.Attributes, kv.Pair{})
if err := m.Attributes[len(m.Attributes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
@@ -16124,6 +16147,7 @@ func (m *Evidence) Unmarshal(dAtA []byte) error {
func skipTypes(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -16155,10 +16179,8 @@ func skipTypes(dAtA []byte) (n int, err error) {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -16179,55 +16201,30 @@ func skipTypes(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthTypes
}
iNdEx += length
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowTypes
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipTypes(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
}
return iNdEx, nil
depth++
case 4:
return iNdEx, nil
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupTypes
}
depth--
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
if depth == 0 {
return iNdEx, nil
}
}
panic("unreachable")
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)

4
abci/types/types.proto
View File

@@ -6,7 +6,7 @@ option go_package = "github.com/tendermint/tendermint/abci/types";
// https://github.com/gogo/protobuf/blob/master/extensions.md
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
import "github.com/tendermint/tendermint/crypto/merkle/merkle.proto";
import "github.com/tendermint/tendermint/libs/common/types.proto";
import "github.com/tendermint/tendermint/libs/kv/types.proto";
import "google/protobuf/timestamp.proto";
// This file is copied from http://github.com/tendermint/abci
@@ -245,7 +245,7 @@ message LastCommitInfo {
message Event {
string type = 1;
repeated tendermint.libs.common.KVPair attributes = 2 [(gogoproto.nullable)=false, (gogoproto.jsontag)="attributes,omitempty"];
repeated tendermint.libs.kv.Pair attributes = 2 [(gogoproto.nullable)=false, (gogoproto.jsontag)="attributes,omitempty"];
}
//----------------------------------------

2
abci/types/typespb_test.go
View File

@@ -12,7 +12,7 @@ import (
golang_proto "github.com/golang/protobuf/proto"
_ "github.com/golang/protobuf/ptypes/timestamp"
_ "github.com/tendermint/tendermint/crypto/merkle"
_ "github.com/tendermint/tendermint/libs/common"
_ "github.com/tendermint/tendermint/libs/kv"
math "math"
math_rand "math/rand"
testing "testing"

14
crypto/merkle/simple_map.go
View File

@@ -5,14 +5,14 @@ import (
amino "github.com/tendermint/go-amino"
"github.com/tendermint/tendermint/crypto/tmhash"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
)
// Merkle tree from a map.
// Leaves are `hash(key) | hash(value)`.
// Leaves are sorted before Merkle hashing.
type simpleMap struct {
kvs cmn.KVPairs
kvs kv.Pairs
sorted bool
}
@@ -33,7 +33,7 @@ func (sm *simpleMap) Set(key string, value []byte) {
// and make a determination to fetch or not.
vhash := tmhash.Sum(value)
sm.kvs = append(sm.kvs, cmn.KVPair{
sm.kvs = append(sm.kvs, kv.Pair{
Key: []byte(key),
Value: vhash,
})
@@ -56,9 +56,9 @@ func (sm *simpleMap) Sort() {
// Returns a copy of sorted KVPairs.
// NOTE these contain the hashed key and value.
func (sm *simpleMap) KVPairs() cmn.KVPairs {
func (sm *simpleMap) KVPairs() kv.Pairs {
sm.Sort()
kvs := make(cmn.KVPairs, len(sm.kvs))
kvs := make(kv.Pairs, len(sm.kvs))
copy(kvs, sm.kvs)
return kvs
}
@@ -68,7 +68,7 @@ func (sm *simpleMap) KVPairs() cmn.KVPairs {
// A local extension to KVPair that can be hashed.
// Key and value are length prefixed and concatenated,
// then hashed.
type KVPair cmn.KVPair
type KVPair kv.Pair
// Bytes returns key || value, with both the
// key and value length prefixed.
@@ -85,7 +85,7 @@ func (kv KVPair) Bytes() []byte {
return b.Bytes()
}
func hashKVPairs(kvs cmn.KVPairs) []byte {
func hashKVPairs(kvs kv.Pairs) []byte {
kvsH := make([][]byte, len(kvs))
for i, kvp := range kvs {
kvsH[i] = KVPair(kvp).Bytes()

2
docs/app-dev/app-development.md
View File

@@ -187,7 +187,7 @@ func (app *KVStoreApplication) DeliverTx(req types.RequestDeliverTx) types.Respo
events := []types.Event{
{
Type: "app",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("creator"), Value: []byte("Cosmoshi Netowoko")},
{Key: []byte("key"), Value: key},
},

8
docs/app-dev/indexing-transactions.md
View File

@@ -76,10 +76,10 @@ func (app *KVStoreApplication) DeliverTx(req types.RequestDeliverTx) types.Resul
events := []abci.Event{
{
Type: "transfer",
Attributes: cmn.KVPairs{
cmn.KVPair{Key: []byte("sender"), Value: []byte("Bob")},
cmn.KVPair{Key: []byte("recipient"), Value: []byte("Alice")},
cmn.KVPair{Key: []byte("balance"), Value: []byte("100")},
Attributes: kv.Pairs{
kv.Pair{Key: []byte("sender"), Value: []byte("Bob")},
kv.Pair{Key: []byte("recipient"), Value: []byte("Alice")},
kv.Pair{Key: []byte("balance"), Value: []byte("100")},
},
},
}

2
docs/architecture/adr-037-deliver-block.md
View File

@@ -70,7 +70,7 @@ type RequestDeliverBlock struct {
type ResponseDeliverBlock struct {
ValidatorUpdates []ValidatorUpdate
ConsensusParamUpdates *ConsensusParams
Tags []common.KVPair
Tags []kv.Pair
TxResults []ResponseDeliverTx
}

14
libs/common/int_test.go
View File

@@ -1,14 +0,0 @@
package common
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestIntInSlice(t *testing.T) {
assert.True(t, IntInSlice(1, []int{1, 2, 3}))
assert.False(t, IntInSlice(4, []int{1, 2, 3}))
assert.True(t, IntInSlice(0, []int{0}))
assert.False(t, IntInSlice(0, []int{}))
}

14
libs/common/kvpair.go → libs/kv/kvpair.go
View File

@@ -1,4 +1,4 @@
package common
package kv
import (
"bytes"
@@ -11,17 +11,17 @@ import (
/*
Defined in types.proto
type KVPair struct {
type Pair struct {
Key []byte
Value []byte
}
*/
type KVPairs []KVPair
type Pairs []Pair
// Sorting
func (kvs KVPairs) Len() int { return len(kvs) }
func (kvs KVPairs) Less(i, j int) bool {
func (kvs Pairs) Len() int { return len(kvs) }
func (kvs Pairs) Less(i, j int) bool {
switch bytes.Compare(kvs[i].Key, kvs[j].Key) {
case -1:
return true
@@ -33,8 +33,8 @@ func (kvs KVPairs) Less(i, j int) bool {
panic("invalid comparison result")
}
}
func (kvs KVPairs) Swap(i, j int) { kvs[i], kvs[j] = kvs[j], kvs[i] }
func (kvs KVPairs) Sort() { sort.Sort(kvs) }
func (kvs Pairs) Swap(i, j int) { kvs[i], kvs[j] = kvs[j], kvs[i] }
func (kvs Pairs) Sort() { sort.Sort(kvs) }
//----------------------------------------
// KI64Pair

8
libs/common/result.go → libs/kv/result.go
View File

@@ -1,6 +1,6 @@
// nolint: dupl
// dupl is reading this as the same file as crypto/merkle/result.go
package common
package kv
import (
"bytes"
@@ -20,12 +20,12 @@ var (
jsonpbUnmarshaller = jsonpb.Unmarshaler{}
)
func (r *KVPair) MarshalJSON() ([]byte, error) {
func (r *Pair) MarshalJSON() ([]byte, error) {
s, err := jsonpbMarshaller.MarshalToString(r)
return []byte(s), err
}
func (r *KVPair) UnmarshalJSON(b []byte) error {
func (r *Pair) UnmarshalJSON(b []byte) error {
reader := bytes.NewBuffer(b)
return jsonpbUnmarshaller.Unmarshal(reader, r)
}
@@ -50,5 +50,5 @@ type jsonRoundTripper interface {
json.Unmarshaler
}
var _ jsonRoundTripper = (*KVPair)(nil)
var _ jsonRoundTripper = (*Pair)(nil)
var _ jsonRoundTripper = (*KI64Pair)(nil)

164
libs/common/types.pb.go → libs/kv/types.pb.go
View File

@@ -1,7 +1,7 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: libs/common/types.proto
// source: libs/kv/types.proto
package common
package kv
import (
bytes "bytes"
@@ -27,7 +27,7 @@ var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Define these here for compatibility but use tmlibs/common.KVPair.
type KVPair struct {
type Pair struct {
Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -35,18 +35,18 @@ type KVPair struct {
XXX_sizecache int32 `json:"-"`
}
func (m *KVPair) Reset() { *m = KVPair{} }
func (m *KVPair) String() string { return proto.CompactTextString(m) }
func (*KVPair) ProtoMessage() {}
func (*KVPair) Descriptor() ([]byte, []int) {
return fileDescriptor_28b36ea5054b507d, []int{0}
func (m *Pair) Reset() { *m = Pair{} }
func (m *Pair) String() string { return proto.CompactTextString(m) }
func (*Pair) ProtoMessage() {}
func (*Pair) Descriptor() ([]byte, []int) {
return fileDescriptor_31432671d164f444, []int{0}
}
func (m *KVPair) XXX_Unmarshal(b []byte) error {
func (m *Pair) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *KVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_KVPair.Marshal(b, m, deterministic)
return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
@@ -56,26 +56,26 @@ func (m *KVPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return b[:n], nil
}
}
func (m *KVPair) XXX_Merge(src proto.Message) {
xxx_messageInfo_KVPair.Merge(m, src)
func (m *Pair) XXX_Merge(src proto.Message) {
xxx_messageInfo_Pair.Merge(m, src)
}
func (m *KVPair) XXX_Size() int {
func (m *Pair) XXX_Size() int {
return m.Size()
}
func (m *KVPair) XXX_DiscardUnknown() {
xxx_messageInfo_KVPair.DiscardUnknown(m)
func (m *Pair) XXX_DiscardUnknown() {
xxx_messageInfo_Pair.DiscardUnknown(m)
}
var xxx_messageInfo_KVPair proto.InternalMessageInfo
var xxx_messageInfo_Pair proto.InternalMessageInfo
func (m *KVPair) GetKey() []byte {
func (m *Pair) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *KVPair) GetValue() []byte {
func (m *Pair) GetValue() []byte {
if m != nil {
return m.Value
}
@@ -95,7 +95,7 @@ func (m *KI64Pair) Reset() { *m = KI64Pair{} }
func (m *KI64Pair) String() string { return proto.CompactTextString(m) }
func (*KI64Pair) ProtoMessage() {}
func (*KI64Pair) Descriptor() ([]byte, []int) {
return fileDescriptor_28b36ea5054b507d, []int{1}
return fileDescriptor_31432671d164f444, []int{1}
}
func (m *KI64Pair) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -139,40 +139,40 @@ func (m *KI64Pair) GetValue() int64 {
}
func init() {
proto.RegisterType((*KVPair)(nil), "tendermint.libs.common.KVPair")
golang_proto.RegisterType((*KVPair)(nil), "tendermint.libs.common.KVPair")
proto.RegisterType((*KI64Pair)(nil), "tendermint.libs.common.KI64Pair")
golang_proto.RegisterType((*KI64Pair)(nil), "tendermint.libs.common.KI64Pair")
proto.RegisterType((*Pair)(nil), "tendermint.libs.kv.Pair")
golang_proto.RegisterType((*Pair)(nil), "tendermint.libs.kv.Pair")
proto.RegisterType((*KI64Pair)(nil), "tendermint.libs.kv.KI64Pair")
golang_proto.RegisterType((*KI64Pair)(nil), "tendermint.libs.kv.KI64Pair")
}
func init() { proto.RegisterFile("libs/common/types.proto", fileDescriptor_28b36ea5054b507d) }
func init() { golang_proto.RegisterFile("libs/common/types.proto", fileDescriptor_28b36ea5054b507d) }
func init() { proto.RegisterFile("libs/kv/types.proto", fileDescriptor_31432671d164f444) }
func init() { golang_proto.RegisterFile("libs/kv/types.proto", fileDescriptor_31432671d164f444) }
var fileDescriptor_28b36ea5054b507d = []byte{
// 197 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0xc9, 0x4c, 0x2a,
0xd6, 0x4f, 0xce, 0xcf, 0xcd, 0xcd, 0xcf, 0xd3, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28,
0xca, 0x2f, 0xc9, 0x17, 0x12, 0x2b, 0x49, 0xcd, 0x4b, 0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1,
0x03, 0xa9, 0xd1, 0x83, 0xa8, 0x91, 0xd2, 0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0x02, 0x71, 0xf5,
0xd3, 0xf3, 0xd3, 0xf3, 0xf5, 0xc1, 0xca, 0x93, 0x4a, 0xd3, 0xc0, 0x3c, 0x30, 0x07, 0xcc, 0x82,
0x18, 0xa3, 0x64, 0xc0, 0xc5, 0xe6, 0x1d, 0x16, 0x90, 0x98, 0x59, 0x24, 0x24, 0xc0, 0xc5, 0x9c,
0x9d, 0x5a, 0x29, 0xc1, 0xa8, 0xc0, 0xa8, 0xc1, 0x13, 0x04, 0x62, 0x0a, 0x89, 0x70, 0xb1, 0x96,
0x25, 0xe6, 0x94, 0xa6, 0x4a, 0x30, 0x81, 0xc5, 0x20, 0x1c, 0x25, 0x23, 0x2e, 0x0e, 0x6f, 0x4f,
0x33, 0x13, 0x62, 0xf4, 0x30, 0x43, 0xf5, 0x38, 0x79, 0xfd, 0x78, 0x28, 0xc7, 0xb8, 0xe2, 0x91,
0x1c, 0xe3, 0x8e, 0x47, 0x72, 0x8c, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24, 0xc7, 0xf8, 0xe0,
0x91, 0x1c, 0xe3, 0x81, 0xc7, 0x72, 0x8c, 0x51, 0x3a, 0x48, 0x4e, 0x46, 0xf8, 0x0a, 0x99, 0x89,
0x14, 0x08, 0x49, 0x6c, 0x60, 0x87, 0x1b, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd4, 0xc3, 0x96,
0x94, 0x1a, 0x01, 0x00, 0x00,
var fileDescriptor_31432671d164f444 = []byte{
// 193 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xce, 0xc9, 0x4c, 0x2a,
0xd6, 0xcf, 0x2e, 0xd3, 0x2f, 0xa9, 0x2c, 0x48, 0x2d, 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
0x12, 0x2a, 0x49, 0xcd, 0x4b, 0x49, 0x2d, 0xca, 0xcd, 0xcc, 0x2b, 0xd1, 0x03, 0xc9, 0xeb, 0x65,
0x97, 0x49, 0xe9, 0xa6, 0x67, 0x96, 0x64, 0x94, 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0xa7, 0xe7,
0xa7, 0xe7, 0xeb, 0x83, 0x95, 0x26, 0x95, 0xa6, 0x81, 0x79, 0x60, 0x0e, 0x98, 0x05, 0x31, 0x42,
0x49, 0x8f, 0x8b, 0x25, 0x20, 0x31, 0xb3, 0x48, 0x48, 0x80, 0x8b, 0x39, 0x3b, 0xb5, 0x52, 0x82,
0x51, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc4, 0x14, 0x12, 0xe1, 0x62, 0x2d, 0x4b, 0xcc, 0x29, 0x4d,
0x95, 0x60, 0x02, 0x8b, 0x41, 0x38, 0x4a, 0x46, 0x5c, 0x1c, 0xde, 0x9e, 0x66, 0x26, 0xc4, 0xe8,
0x61, 0x86, 0xea, 0x71, 0x72, 0xfb, 0xf1, 0x50, 0x8e, 0x71, 0xc5, 0x23, 0x39, 0xc6, 0x1d, 0x8f,
0xe4, 0x18, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x03,
0x8f, 0xe5, 0x18, 0xa3, 0x34, 0x90, 0x1c, 0x8c, 0xf0, 0x0f, 0x32, 0x13, 0xea, 0xf5, 0x24, 0x36,
0xb0, 0x93, 0x8d, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0x01, 0x3f, 0x5a, 0xca, 0x0c, 0x01, 0x00,
0x00,
}
func (this *KVPair) Equal(that interface{}) bool {
func (this *Pair) Equal(that interface{}) bool {
if that == nil {
return this == nil
}
that1, ok := that.(*KVPair)
that1, ok := that.(*Pair)
if !ok {
that2, ok := that.(KVPair)
that2, ok := that.(Pair)
if ok {
that1 = &that2
} else {
@@ -225,7 +225,7 @@ func (this *KI64Pair) Equal(that interface{}) bool {
}
return true
}
func (m *KVPair) Marshal() (dAtA []byte, err error) {
func (m *Pair) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -235,12 +235,12 @@ func (m *KVPair) Marshal() (dAtA []byte, err error) {
return dAtA[:n], nil
}
func (m *KVPair) MarshalTo(dAtA []byte) (int, error) {
func (m *Pair) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *KVPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
func (m *Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
@@ -316,8 +316,8 @@ func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func NewPopulatedKVPair(r randyTypes, easy bool) *KVPair {
this := &KVPair{}
func NewPopulatedPair(r randyTypes, easy bool) *Pair {
this := &Pair{}
v1 := r.Intn(100)
this.Key = make([]byte, v1)
for i := 0; i < v1; i++ {
@@ -423,7 +423,7 @@ func encodeVarintPopulateTypes(dAtA []byte, v uint64) []byte {
dAtA = append(dAtA, uint8(v))
return dAtA
}
func (m *KVPair) Size() (n int) {
func (m *Pair) Size() (n int) {
if m == nil {
return 0
}
@@ -468,7 +468,7 @@ func sovTypes(x uint64) (n int) {
func sozTypes(x uint64) (n int) {
return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *KVPair) Unmarshal(dAtA []byte) error {
func (m *Pair) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
@@ -491,10 +491,10 @@ func (m *KVPair) Unmarshal(dAtA []byte) error {
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: KVPair: wiretype end group for non-group")
return fmt.Errorf("proto: Pair: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: KVPair: illegal tag %d (wire type %d)", fieldNum, wire)
return fmt.Errorf("proto: Pair: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
@@ -700,6 +700,7 @@ func (m *KI64Pair) Unmarshal(dAtA []byte) error {
func skipTypes(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
depth := 0
for iNdEx < l {
var wire uint64
for shift := uint(0); ; shift += 7 {
@@ -731,10 +732,8 @@ func skipTypes(dAtA []byte) (n int, err error) {
break
}
}
return iNdEx, nil
case 1:
iNdEx += 8
return iNdEx, nil
case 2:
var length int
for shift := uint(0); ; shift += 7 {
@@ -755,55 +754,30 @@ func skipTypes(dAtA []byte) (n int, err error) {
return 0, ErrInvalidLengthTypes
}
iNdEx += length
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
return iNdEx, nil
case 3:
for {
var innerWire uint64
var start int = iNdEx
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowTypes
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
innerWire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
innerWireType := int(innerWire & 0x7)
if innerWireType == 4 {
break
}
next, err := skipTypes(dAtA[start:])
if err != nil {
return 0, err
}
iNdEx = start + next
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
}
return iNdEx, nil
depth++
case 4:
return iNdEx, nil
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupTypes
}
depth--
case 5:
iNdEx += 4
return iNdEx, nil
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthTypes
}
if depth == 0 {
return iNdEx, nil
}
}
panic("unreachable")
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
ErrInvalidLengthTypes = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowTypes = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)

6
libs/common/types.proto → libs/kv/types.proto
View File

@@ -1,6 +1,6 @@
syntax = "proto3";
package tendermint.libs.common;
option go_package = "github.com/tendermint/tendermint/libs/common";
package tendermint.libs.kv;
option go_package = "github.com/tendermint/tendermint/libs/kv";
import "github.com/gogo/protobuf/gogoproto/gogo.proto";
@@ -17,7 +17,7 @@ option (gogoproto.testgen_all) = true;
// Abstract types
// Define these here for compatibility but use tmlibs/common.KVPair.
message KVPair {
message Pair {
bytes key = 1;
bytes value = 2;
}

38
libs/common/typespb_test.go → libs/kv/typespb_test.go
View File

@@ -1,7 +1,7 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: libs/common/types.proto
// source: libs/kv/types.proto
package common
package kv
import (
fmt "fmt"
@@ -22,15 +22,15 @@ var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
func TestKVPairProto(t *testing.T) {
func TestPairProto(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedKVPair(popr, false)
p := NewPopulatedPair(popr, false)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &KVPair{}
msg := &Pair{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
@@ -53,10 +53,10 @@ func TestKVPairProto(t *testing.T) {
}
}
func TestKVPairMarshalTo(t *testing.T) {
func TestPairMarshalTo(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedKVPair(popr, false)
p := NewPopulatedPair(popr, false)
size := p.Size()
dAtA := make([]byte, size)
for i := range dAtA {
@@ -66,7 +66,7 @@ func TestKVPairMarshalTo(t *testing.T) {
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &KVPair{}
msg := &Pair{}
if err := github_com_gogo_protobuf_proto.Unmarshal(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
@@ -134,16 +134,16 @@ func TestKI64PairMarshalTo(t *testing.T) {
}
}
func TestKVPairJSON(t *testing.T) {
func TestPairJSON(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedKVPair(popr, true)
p := NewPopulatedPair(popr, true)
marshaler := github_com_gogo_protobuf_jsonpb.Marshaler{}
jsondata, err := marshaler.MarshalToString(p)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
msg := &KVPair{}
msg := &Pair{}
err = github_com_gogo_protobuf_jsonpb.UnmarshalString(jsondata, msg)
if err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
@@ -170,12 +170,12 @@ func TestKI64PairJSON(t *testing.T) {
t.Fatalf("seed = %d, %#v !Json Equal %#v", seed, msg, p)
}
}
func TestKVPairProtoText(t *testing.T) {
func TestPairProtoText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedKVPair(popr, true)
p := NewPopulatedPair(popr, true)
dAtA := github_com_gogo_protobuf_proto.MarshalTextString(p)
msg := &KVPair{}
msg := &Pair{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
@@ -184,12 +184,12 @@ func TestKVPairProtoText(t *testing.T) {
}
}
func TestKVPairProtoCompactText(t *testing.T) {
func TestPairProtoCompactText(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedKVPair(popr, true)
p := NewPopulatedPair(popr, true)
dAtA := github_com_gogo_protobuf_proto.CompactTextString(p)
msg := &KVPair{}
msg := &Pair{}
if err := github_com_gogo_protobuf_proto.UnmarshalText(dAtA, msg); err != nil {
t.Fatalf("seed = %d, err = %v", seed, err)
}
@@ -226,10 +226,10 @@ func TestKI64PairProtoCompactText(t *testing.T) {
}
}
func TestKVPairSize(t *testing.T) {
func TestPairSize(t *testing.T) {
seed := time.Now().UnixNano()
popr := math_rand.New(math_rand.NewSource(seed))
p := NewPopulatedKVPair(popr, true)
p := NewPopulatedPair(popr, true)
size2 := github_com_gogo_protobuf_proto.Size(p)
dAtA, err := github_com_gogo_protobuf_proto.Marshal(p)
if err != nil {

28
rpc/swagger/swagger.yaml
View File

@@ -187,28 +187,28 @@ paths:
Events: []abci.Event{
{
Type: "rewards.withdraw",
Attributes: cmn.KVPairs{
cmn.KVPair{Key: []byte("address"), Value: []byte("AddrA")},
cmn.KVPair{Key: []byte("source"), Value: []byte("SrcX")},
cmn.KVPair{Key: []byte("amount"), Value: []byte("...")},
cmn.KVPair{Key: []byte("balance"), Value: []byte("...")},
Attributes: kv.Pairs{
kv.Pair{Key: []byte("address"), Value: []byte("AddrA")},
kv.Pair{Key: []byte("source"), Value: []byte("SrcX")},
kv.Pair{Key: []byte("amount"), Value: []byte("...")},
kv.Pair{Key: []byte("balance"), Value: []byte("...")},
},
},
{
Type: "rewards.withdraw",
Attributes: cmn.KVPairs{
cmn.KVPair{Key: []byte("address"), Value: []byte("AddrB")},
cmn.KVPair{Key: []byte("source"), Value: []byte("SrcY")},
cmn.KVPair{Key: []byte("amount"), Value: []byte("...")},
cmn.KVPair{Key: []byte("balance"), Value: []byte("...")},
Attributes: kv.Pairs{
kv.Pair{Key: []byte("address"), Value: []byte("AddrB")},
kv.Pair{Key: []byte("source"), Value: []byte("SrcY")},
kv.Pair{Key: []byte("amount"), Value: []byte("...")},
kv.Pair{Key: []byte("balance"), Value: []byte("...")},
},
},
{
Type: "transfer",
Attributes: cmn.KVPairs{
cmn.KVPair{Key: []byte("sender"), Value: []byte("AddrC")},
cmn.KVPair{Key: []byte("recipient"), Value: []byte("AddrD")},
cmn.KVPair{Key: []byte("amount"), Value: []byte("...")},
Attributes: kv.Pairs{
kv.Pair{Key: []byte("sender"), Value: []byte("AddrC")},
kv.Pair{Key: []byte("recipient"), Value: []byte("AddrD")},
kv.Pair{Key: []byte("amount"), Value: []byte("...")},
},
},
},

5
state/state_test.go
View File

@@ -13,6 +13,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/ed25519"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
sm "github.com/tendermint/tendermint/state"
dbm "github.com/tendermint/tm-db"
@@ -132,8 +133,8 @@ func TestABCIResponsesSaveLoad2(t *testing.T) {
{
Data: []byte("Gotcha!"),
Events: []abci.Event{
{Type: "type1", Attributes: []cmn.KVPair{{Key: []byte("a"), Value: []byte("1")}}},
{Type: "type2", Attributes: []cmn.KVPair{{Key: []byte("build"), Value: []byte("stuff")}}},
{Type: "type1", Attributes: []kv.Pair{{Key: []byte("a"), Value: []byte("1")}}},
{Type: "type2", Attributes: []kv.Pair{{Key: []byte("build"), Value: []byte("stuff")}}},
},
},
},

2
state/txindex/kv/kv.go
View File

@@ -220,7 +220,7 @@ func (txi *TxIndex) Search(q *query.Query) ([]*types.TxResult, error) {
// for all other conditions
for i, c := range conditions {
if cmn.IntInSlice(i, skipIndexes) {
if intInSlice(i, skipIndexes) {
continue
}

4
state/txindex/kv/kv_bench_test.go
View File

@@ -7,7 +7,7 @@ import (
"testing"
abci "github.com/tendermint/tendermint/abci/types"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
"github.com/tendermint/tendermint/libs/pubsub/query"
"github.com/tendermint/tendermint/types"
dbm "github.com/tendermint/tm-db"
@@ -31,7 +31,7 @@ func BenchmarkTxSearch(b *testing.B) {
events := []abci.Event{
{
Type: "transfer",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("address"), Value: []byte(fmt.Sprintf("address_%d", i%100))},
{Key: []byte("amount"), Value: []byte("50")},
},

25
state/txindex/kv/kv_test.go
View File

@@ -13,6 +13,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
"github.com/tendermint/tendermint/libs/pubsub/query"
"github.com/tendermint/tendermint/state/txindex"
"github.com/tendermint/tendermint/types"
@@ -69,9 +70,9 @@ func TestTxSearch(t *testing.T) {
indexer := NewTxIndex(db.NewMemDB(), IndexEvents(allowedKeys))
txResult := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("owner"), Value: []byte("Ivan")}}},
{Type: "", Attributes: []cmn.KVPair{{Key: []byte("not_allowed"), Value: []byte("Vlad")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("owner"), Value: []byte("Ivan")}}},
{Type: "", Attributes: []kv.Pair{{Key: []byte("not_allowed"), Value: []byte("Vlad")}}},
})
hash := txResult.Tx.Hash()
@@ -137,7 +138,7 @@ func TestTxSearchDeprecatedIndexing(t *testing.T) {
// index tx using events indexing (composite key)
txResult1 := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("1")}}},
})
hash1 := txResult1.Tx.Hash()
@@ -206,8 +207,8 @@ func TestTxSearchOneTxWithMultipleSameTagsButDifferentValues(t *testing.T) {
indexer := NewTxIndex(db.NewMemDB(), IndexEvents(allowedKeys))
txResult := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("2")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("2")}}},
})
err := indexer.Index(txResult)
@@ -226,7 +227,7 @@ func TestTxSearchMultipleTxs(t *testing.T) {
// indexed first, but bigger height (to test the order of transactions)
txResult := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("1")}}},
})
txResult.Tx = types.Tx("Bob's account")
@@ -237,7 +238,7 @@ func TestTxSearchMultipleTxs(t *testing.T) {
// indexed second, but smaller height (to test the order of transactions)
txResult2 := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("2")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("2")}}},
})
txResult2.Tx = types.Tx("Alice's account")
txResult2.Height = 1
@@ -248,7 +249,7 @@ func TestTxSearchMultipleTxs(t *testing.T) {
// indexed third (to test the order of transactions)
txResult3 := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("3")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("3")}}},
})
txResult3.Tx = types.Tx("Jack's account")
txResult3.Height = 1
@@ -259,7 +260,7 @@ func TestTxSearchMultipleTxs(t *testing.T) {
// indexed fourth (to test we don't include txs with similar events)
// https://github.com/tendermint/tendermint/issues/2908
txResult4 := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number.id"), Value: []byte("1")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number.id"), Value: []byte("1")}}},
})
txResult4.Tx = types.Tx("Mike's account")
txResult4.Height = 2
@@ -278,8 +279,8 @@ func TestIndexAllTags(t *testing.T) {
indexer := NewTxIndex(db.NewMemDB(), IndexAllEvents())
txResult := txResultWithEvents([]abci.Event{
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("owner"), Value: []byte("Ivan")}}},
{Type: "account", Attributes: []cmn.KVPair{{Key: []byte("number"), Value: []byte("1")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("owner"), Value: []byte("Ivan")}}},
{Type: "account", Attributes: []kv.Pair{{Key: []byte("number"), Value: []byte("1")}}},
})
err := indexer.Index(txResult)

4
libs/common/int.go → state/txindex/kv/utils.go
View File

@@ -1,7 +1,7 @@
package common
package kv
// IntInSlice returns true if a is found in the list.
func IntInSlice(a int, list []int) bool {
func intInSlice(a int, list []int) bool {
for _, b := range list {
if b == a {
return true

14
state/txindex/kv/utils_test.go Normal file
View File

@@ -0,0 +1,14 @@
package kv
import (
"testing"
"github.com/stretchr/testify/assert"
)
func TestIntInSlice(t *testing.T) {
assert.True(t, intInSlice(1, []int{1, 2, 3}))
assert.False(t, intInSlice(4, []int{1, 2, 3}))
assert.True(t, intInSlice(0, []int{0}))
assert.False(t, intInSlice(0, []int{}))
}

17
types/event_bus_test.go
View File

@@ -11,6 +11,7 @@ import (
abci "github.com/tendermint/tendermint/abci/types"
cmn "github.com/tendermint/tendermint/libs/common"
"github.com/tendermint/tendermint/libs/kv"
tmpubsub "github.com/tendermint/tendermint/libs/pubsub"
tmquery "github.com/tendermint/tendermint/libs/pubsub/query"
)
@@ -25,7 +26,7 @@ func TestEventBusPublishEventTx(t *testing.T) {
result := abci.ResponseDeliverTx{
Data: []byte("bar"),
Events: []abci.Event{
{Type: "testType", Attributes: []cmn.KVPair{{Key: []byte("baz"), Value: []byte("1")}}},
{Type: "testType", Attributes: []kv.Pair{{Key: []byte("baz"), Value: []byte("1")}}},
},
}
@@ -69,12 +70,12 @@ func TestEventBusPublishEventNewBlock(t *testing.T) {
block := MakeBlock(0, []Tx{}, nil, []Evidence{})
resultBeginBlock := abci.ResponseBeginBlock{
Events: []abci.Event{
{Type: "testType", Attributes: []cmn.KVPair{{Key: []byte("baz"), Value: []byte("1")}}},
{Type: "testType", Attributes: []kv.Pair{{Key: []byte("baz"), Value: []byte("1")}}},
},
}
resultEndBlock := abci.ResponseEndBlock{
Events: []abci.Event{
{Type: "testType", Attributes: []cmn.KVPair{{Key: []byte("foz"), Value: []byte("2")}}},
{Type: "testType", Attributes: []kv.Pair{{Key: []byte("foz"), Value: []byte("2")}}},
},
}
@@ -119,7 +120,7 @@ func TestEventBusPublishEventTxDuplicateKeys(t *testing.T) {
Events: []abci.Event{
{
Type: "transfer",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("sender"), Value: []byte("foo")},
{Key: []byte("recipient"), Value: []byte("bar")},
{Key: []byte("amount"), Value: []byte("5")},
@@ -127,7 +128,7 @@ func TestEventBusPublishEventTxDuplicateKeys(t *testing.T) {
},
{
Type: "transfer",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("sender"), Value: []byte("baz")},
{Key: []byte("recipient"), Value: []byte("cat")},
{Key: []byte("amount"), Value: []byte("13")},
@@ -135,7 +136,7 @@ func TestEventBusPublishEventTxDuplicateKeys(t *testing.T) {
},
{
Type: "withdraw.rewards",
Attributes: []cmn.KVPair{
Attributes: []kv.Pair{
{Key: []byte("address"), Value: []byte("bar")},
{Key: []byte("source"), Value: []byte("iceman")},
{Key: []byte("amount"), Value: []byte("33")},
@@ -216,12 +217,12 @@ func TestEventBusPublishEventNewBlockHeader(t *testing.T) {
block := MakeBlock(0, []Tx{}, nil, []Evidence{})
resultBeginBlock := abci.ResponseBeginBlock{
Events: []abci.Event{
{Type: "testType", Attributes: []cmn.KVPair{{Key: []byte("baz"), Value: []byte("1")}}},
{Type: "testType", Attributes: []kv.Pair{{Key: []byte("baz"), Value: []byte("1")}}},
},
}
resultEndBlock := abci.ResponseEndBlock{
Events: []abci.Event{
{Type: "testType", Attributes: []cmn.KVPair{{Key: []byte("foz"), Value: []byte("2")}}},
{Type: "testType", Attributes: []kv.Pair{{Key: []byte("foz"), Value: []byte("2")}}},
},
}