certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

types: add kv type (#6897) 

* add kv type

* add changelog entry

* fix build

* replace sdkkv with kv

* revert change

* fix some tests

* proto-gen

* fix tests

Co-authored-by: Aleksandr Bezobchuk <aleks.bezobchuk@gmail.com>
Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
This commit is contained in:
Marko 2020-07-30 16:53:02 +02:00 committed by GitHub
parent c7ad21d162
commit 617b822efa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
46 changed files with 1317 additions and 925 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -305,6 +305,7 @@ pagination.
* (baseapp) [\#6053](https://github.com/cosmos/cosmos-sdk/pull/6053) Customizable panic recovery handling added for `app.runTx()` method (as proposed in the [ADR 22](https://github.com/cosmos/cosmos-sdk/blob/master/docs/architecture/adr-022-custom-panic-handling.md)). Adds ability for developers to register custom panic handlers extending standard ones.
* (store) [\#6481](https://github.com/cosmos/cosmos-sdk/pull/6481) Move `SimpleProofsFromMap` from Tendermint into the SDK.
* (store) [\#6719](https://github.com/cosmos/cosmos-sdk/6754) Add validity checks to stores for nil and empty keys.
* (types) \#6897 Add KV type from tendermint to `types` directory.
## [v0.39.0] - 2020-07-20

14
codec/unknownproto/unknown_fields_test.go
View File

@ -29,7 +29,7 @@ func TestRejectUnknownFieldsRepeated(t *testing.T) {
F: &testdata.TestVersion2{
A: &testdata.TestVersion2{
B: &testdata.TestVersion2{
H: []*testdata.TestVersion2{
H: []*testdata.TestVersion1{
{
X: 0x01,
},
@ -44,7 +44,7 @@ func TestRejectUnknownFieldsRepeated(t *testing.T) {
F: &testdata.TestVersion2{
A: &testdata.TestVersion2{
B: &testdata.TestVersion2{
H: []*testdata.TestVersion2{
H: []*testdata.TestVersion1{
{
X: 0x02,
},
@ -84,7 +84,7 @@ func TestRejectUnknownFieldsRepeated(t *testing.T) {
F: &testdata.TestVersion2{
A: &testdata.TestVersion2{
B: &testdata.TestVersion2{
H: []*testdata.TestVersion2{
H: []*testdata.TestVersion1{
{
X: 0x01,
},
@ -99,7 +99,7 @@ func TestRejectUnknownFieldsRepeated(t *testing.T) {
F: &testdata.TestVersion2{
A: &testdata.TestVersion2{
B: &testdata.TestVersion2{
H: []*testdata.TestVersion2{
H: []*testdata.TestVersion1{
{
X: 0x02,
},
@ -309,13 +309,13 @@ func TestRejectUnknownFieldsNested(t *testing.T) {
Sum: &testdata.TestVersion2_E{
E: 100,
},
H: []*testdata.TestVersion2{
H: []*testdata.TestVersion1{
{X: 999},
{X: -55},
{
X: 102,
Sum: &testdata.TestVersion2_F{
F: &testdata.TestVersion2{
Sum: &testdata.TestVersion1_F{
F: &testdata.TestVersion1{
X: 4,
},
},

10
proto/cosmos/kv/kv.proto Normal file
View File

@ -0,0 +1,10 @@
syntax = "proto3";
package cosmos.kv;
option go_package = "github.com/cosmos/cosmos-sdk/types/kv";
// Key-Value Pair
message Pair {
bytes key = 1;
bytes value = 2;
}

12
proto/ibc/transfer/genesis.proto
View File

@ -4,14 +4,12 @@ package ibc.transfer;
option go_package = "github.com/cosmos/cosmos-sdk/x/ibc-transfer/types";
import "gogoproto/gogo.proto";
import "cosmos/cosmos.proto";
import "ibc/transfer/transfer.proto";
// GenesisState is currently only used to ensure that the InitGenesis gets run
// by the module manager
message GenesisState{
string port_id = 1 [
(gogoproto.customname) = "PortID",
(gogoproto.moretags) = "yaml:\"port_id\""
];
message GenesisState {
string port_id = 1 [
(gogoproto.customname) = "PortID",
(gogoproto.moretags) = "yaml:\"port_id\""
];
}

4
simapp/utils.go
View File

@ -5,13 +5,13 @@ import (
"fmt"
"io/ioutil"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/tendermint/tendermint/libs/log"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/simapp/helpers"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/types/module"
simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
)
@ -109,7 +109,7 @@ func PrintStats(db dbm.DB) {
// GetSimulationLog unmarshals the KVPair's Value to the corresponding type based on the
// each's module store key and the prefix bytes of the KVPair's key.
func GetSimulationLog(storeName string, sdr sdk.StoreDecoderRegistry, kvAs, kvBs []tmkv.Pair) (log string) {
func GetSimulationLog(storeName string, sdr sdk.StoreDecoderRegistry, kvAs, kvBs []kv.Pair) (log string) {
for i := 0; i < len(kvAs); i++ {
if len(kvAs[i].Value) == 0 && len(kvBs[i].Value) == 0 {
// skip if the value doesn't have any bytes

15
simapp/utils_test.go
View File

@ -4,12 +4,11 @@ import (
"fmt"
"testing"
"github.com/cosmos/cosmos-sdk/std"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/std"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
)
@ -17,26 +16,26 @@ func TestGetSimulationLog(t *testing.T) {
cdc := std.MakeCodec(ModuleBasics)
decoders := make(sdk.StoreDecoderRegistry)
decoders[authtypes.StoreKey] = func(kvAs, kvBs tmkv.Pair) string { return "10" }
decoders[authtypes.StoreKey] = func(kvAs, kvBs kv.Pair) string { return "10" }
tests := []struct {
store string
kvPairs []tmkv.Pair
kvPairs []kv.Pair
expectedLog string
}{
{
"Empty",
[]tmkv.Pair{{}},
[]kv.Pair{{}},
"",
},
{
authtypes.StoreKey,
[]tmkv.Pair{{Key: authtypes.GlobalAccountNumberKey, Value: cdc.MustMarshalBinaryBare(uint64(10))}},
[]kv.Pair{{Key: authtypes.GlobalAccountNumberKey, Value: cdc.MustMarshalBinaryBare(uint64(10))}},
"10",
},
{
"OtherStore",
[]tmkv.Pair{{Key: []byte("key"), Value: []byte("value")}},
[]kv.Pair{{Key: []byte("key"), Value: []byte("value")}},
fmt.Sprintf("store A %X => %X\nstore B %X => %X\n", []byte("key"), []byte("value"), []byte("key"), []byte("value")),
},
}

8
store/cachekv/memiterator.go
View File

@ -4,7 +4,7 @@ import (
"container/list"
"errors"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/types/kv"
dbm "github.com/tendermint/tm-db"
)
@ -13,17 +13,17 @@ import (
// Implements Iterator.
type memIterator struct {
start, end []byte
items []*tmkv.Pair
items []*kv.Pair
ascending bool
}
func newMemIterator(start, end []byte, items *list.List, ascending bool) *memIterator {
itemsInDomain := make([]*tmkv.Pair, 0)
itemsInDomain := make([]*kv.Pair, 0)
var entered bool
for e := items.Front(); e != nil; e = e.Next() {
item := e.Value.(*tmkv.Pair)
item := e.Value.(*kv.Pair)
if !dbm.IsKeyInDomain(item.Key, start, end) {
if entered {
break

8
store/cachekv/store.go
View File

@ -8,12 +8,12 @@ import (
"sync"
"time"
tmkv "github.com/tendermint/tendermint/libs/kv"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/store/tracekv"
"github.com/cosmos/cosmos-sdk/store/types"
"github.com/cosmos/cosmos-sdk/telemetry"
"github.com/cosmos/cosmos-sdk/types/kv"
)
// If value is nil but deleted is false, it means the parent doesn't have the
@ -181,13 +181,13 @@ func (store *Store) iterator(start, end []byte, ascending bool) types.Iterator {
// Constructs a slice of dirty items, to use w/ memIterator.
func (store *Store) dirtyItems(start, end []byte) {
unsorted := make([]*tmkv.Pair, 0)
unsorted := make([]*kv.Pair, 0)
for key := range store.unsortedCache {
cacheValue := store.cache[key]
if dbm.IsKeyInDomain([]byte(key), start, end) {
unsorted = append(unsorted, &tmkv.Pair{Key: []byte(key), Value: cacheValue.value})
unsorted = append(unsorted, &kv.Pair{Key: []byte(key), Value: cacheValue.value})
delete(store.unsortedCache, key)
}
@ -199,7 +199,7 @@ func (store *Store) dirtyItems(start, end []byte) {
for e := store.sortedCache.Front(); e != nil && len(unsorted) != 0; {
uitem := unsorted[0]
sitem := e.Value.(*tmkv.Pair)
sitem := e.Value.(*kv.Pair)
comp := bytes.Compare(uitem.Key, sitem.Key)
switch comp {

13
store/firstlast.go
View File

@ -3,28 +3,27 @@ package store
import (
"bytes"
tmkv "github.com/tendermint/tendermint/libs/kv"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkkv "github.com/cosmos/cosmos-sdk/types/kv"
)
// Gets the first item.
func First(st KVStore, start, end []byte) (kv tmkv.Pair, ok bool) {
func First(st KVStore, start, end []byte) (kv sdkkv.Pair, ok bool) {
iter := st.Iterator(start, end)
if !iter.Valid() {
return kv, false
}
defer iter.Close()
return tmkv.Pair{Key: iter.Key(), Value: iter.Value()}, true
return sdkkv.Pair{Key: iter.Key(), Value: iter.Value()}, true
}
// Gets the last item. `end` is exclusive.
func Last(st KVStore, start, end []byte) (kv tmkv.Pair, ok bool) {
func Last(st KVStore, start, end []byte) (kv sdkkv.Pair, ok bool) {
iter := st.ReverseIterator(end, start)
if !iter.Valid() {
if v := st.Get(start); v != nil {
return tmkv.Pair{Key: sdk.CopyBytes(start), Value: sdk.CopyBytes(v)}, true
return sdkkv.Pair{Key: sdk.CopyBytes(start), Value: sdk.CopyBytes(v)}, true
}
return kv, false
}
@ -38,5 +37,5 @@ func Last(st KVStore, start, end []byte) (kv tmkv.Pair, ok bool) {
}
}
return tmkv.Pair{Key: iter.Key(), Value: iter.Value()}, true
return sdkkv.Pair{Key: iter.Key(), Value: iter.Value()}, true
}

8
store/iavl/store.go
View File

@ -11,7 +11,6 @@ import (
"github.com/tendermint/iavl"
abci "github.com/tendermint/tendermint/abci/types"
"github.com/tendermint/tendermint/crypto/merkle"
tmkv "github.com/tendermint/tendermint/libs/kv"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/store/cachekv"
@ -20,6 +19,7 @@ import (
"github.com/cosmos/cosmos-sdk/telemetry"
sdk "github.com/cosmos/cosmos-sdk/types"
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
"github.com/cosmos/cosmos-sdk/types/kv"
)
const (
@ -333,7 +333,7 @@ type iavlIterator struct {
tree *iavl.ImmutableTree
// Channel to push iteration values.
iterCh chan tmkv.Pair
iterCh chan kv.Pair
// Close this to release goroutine.
quitCh chan struct{}
@ -359,7 +359,7 @@ func newIAVLIterator(tree *iavl.ImmutableTree, start, end []byte, ascending bool
start: sdk.CopyBytes(start),
end: sdk.CopyBytes(end),
ascending: ascending,
iterCh: make(chan tmkv.Pair), // Set capacity > 0?
iterCh: make(chan kv.Pair), // Set capacity > 0?
quitCh: make(chan struct{}),
initCh: make(chan struct{}),
}
@ -376,7 +376,7 @@ func (iter *iavlIterator) iterateRoutine() {
select {
case <-iter.quitCh:
return true // done with iteration.
case iter.iterCh <- tmkv.Pair{Key: key, Value: value}:
case iter.iterCh <- kv.Pair{Key: key, Value: value}:
return false // yay.
}
},

2
store/rootmulti/internal/maps/maps.go
View File

@ -5,9 +5,9 @@ import (
"github.com/tendermint/tendermint/crypto/merkle"
"github.com/tendermint/tendermint/crypto/tmhash"
"github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/store/types"
"github.com/cosmos/cosmos-sdk/types/kv"
)
// merkleMap defines a merkle-ized tree from a map. Leave values are treated as

5
store/types/store.go
View File

@ -5,8 +5,9 @@ import (
"io"
abci "github.com/tendermint/tendermint/abci/types"
tmkv "github.com/tendermint/tendermint/libs/kv"
dbm "github.com/tendermint/tm-db"
"github.com/cosmos/cosmos-sdk/types/kv"
)
type Store interface {
@ -381,7 +382,7 @@ func (key *MemoryStoreKey) String() string {
//----------------------------------------
// key-value result for iterator queries
type KVPair tmkv.Pair
type KVPair kv.Pair
//----------------------------------------

10
store/types/utils.go
View File

@ -3,7 +3,7 @@ package types
import (
"bytes"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/types/kv"
)
// Iterator over all the keys with a certain prefix in ascending order
@ -18,7 +18,7 @@ func KVStoreReversePrefixIterator(kvs KVStore, prefix []byte) Iterator {
// DiffKVStores compares two KVstores and returns all the key/value pairs
// that differ from one another. It also skips value comparison for a set of provided prefixes.
func DiffKVStores(a KVStore, b KVStore, prefixesToSkip [][]byte) (kvAs, kvBs []tmkv.Pair) {
func DiffKVStores(a KVStore, b KVStore, prefixesToSkip [][]byte) (kvAs, kvBs []kv.Pair) {
iterA := a.Iterator(nil, nil)
defer iterA.Close()
@ -32,15 +32,15 @@ func DiffKVStores(a KVStore, b KVStore, prefixesToSkip [][]byte) (kvAs, kvBs []t
return kvAs, kvBs
}
var kvA, kvB tmkv.Pair
var kvA, kvB kv.Pair
if iterA.Valid() {
kvA = tmkv.Pair{Key: iterA.Key(), Value: iterA.Value()}
kvA = kv.Pair{Key: iterA.Key(), Value: iterA.Value()}
iterA.Next()
}
if iterB.Valid() {
kvB = tmkv.Pair{Key: iterB.Key(), Value: iterB.Value()}
kvB = kv.Pair{Key: iterB.Key(), Value: iterB.Value()}
iterB.Next()
}

205
testutil/testdata/proto.pb.go vendored
View File

@ -1608,7 +1608,7 @@ type TestVersion2 struct {
// *TestVersion2_F
Sum isTestVersion2_Sum `protobuf_oneof:"sum"`
G *types.Any `protobuf:"bytes,8,opt,name=g,proto3" json:"g,omitempty"`
H []*TestVersion2 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"`
H []*TestVersion1 `protobuf:"bytes,9,rep,name=h,proto3" json:"h,omitempty"`
// google.protobuf.Timestamp i = 10;
// google.protobuf.Timestamp j = 11; // [(gogoproto.stdtime) = true];
*Customer1 `protobuf:"bytes,12,opt,name=k,proto3,embedded=k" json:"k,omitempty"`
@ -1727,7 +1727,7 @@ func (m *TestVersion2) GetG() *types.Any {
return nil
}
func (m *TestVersion2) GetH() []*TestVersion2 {
func (m *TestVersion2) GetH() []*TestVersion1 {
if m != nil {
return m.H
}
@ -3150,112 +3150,111 @@ func init() {
func init() { proto.RegisterFile("proto.proto", fileDescriptor_2fcc84b9998d60d8) }
var fileDescriptor_2fcc84b9998d60d8 = []byte{
// 1669 bytes of a gzipped FileDescriptorProto
// 1664 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x58, 0xcf, 0x6f, 0x23, 0x49,
0x15, 0x4e, 0xb9, 0xed, 0xc4, 0x7e, 0x31, 0x8e, 0x29, 0xc2, 0xd2, 0xe3, 0x65, 0x33, 0xa1, 0x35,
0xec, 0x98, 0xd5, 0x8e, 0x43, 0xda, 0x5e, 0x09, 0xcd, 0x01, 0xad, 0x9d, 0x49, 0x36, 0x23, 0x66,
0xb2, 0xa8, 0x67, 0x35, 0xa0, 0xbd, 0x44, 0xe5, 0xee, 0x72, 0xbb, 0x94, 0x76, 0x55, 0xe8, 0x6a,
0xcf, 0x8c, 0x39, 0xc2, 0x81, 0x2b, 0x17, 0xc4, 0x99, 0x23, 0x27, 0xb4, 0x7f, 0x05, 0x7b, 0x41,
0x9a, 0x0b, 0x12, 0x12, 0xd2, 0x08, 0xcd, 0x5c, 0xf9, 0x0b, 0x40, 0x08, 0x54, 0xdd, 0xd5, 0x3f,
0x92, 0xb1, 0xb3, 0x4e, 0x76, 0xd9, 0x55, 0xa4, 0xbd, 0xd8, 0x55, 0xaf, 0xbf, 0xfa, 0xea, 0xd5,
0xf7, 0xea, 0xbd, 0xae, 0x2e, 0x58, 0x3f, 0x0d, 0x45, 0x24, 0x3a, 0xf1, 0x2f, 0xae, 0x46, 0x54,
0x46, 0x1e, 0x89, 0x48, 0x6b, 0xd3, 0x17, 0xbe, 0x88, 0x8d, 0x3b, 0xaa, 0x95, 0x3c, 0x6f, 0xdd,
0xf0, 0x85, 0xf0, 0x03, 0xba, 0x13, 0xf7, 0x86, 0xd3, 0xd1, 0x0e, 0xe1, 0xb3, 0xe4, 0x91, 0x75,
0x07, 0x8c, 0x7b, 0xc2, 0xc7, 0x18, 0xca, 0x92, 0xfd, 0x92, 0x9a, 0x68, 0x1b, 0xb5, 0x6b, 0x4e,
0xdc, 0x56, 0x36, 0x4e, 0x26, 0xd4, 0x2c, 0x25, 0x36, 0xd5, 0xb6, 0xde, 0x03, 0x63, 0x8f, 0x44,
0xd8, 0x84, 0xb5, 0x89, 0xe0, 0xec, 0x84, 0x86, 0x7a, 0x44, 0xda, 0xc5, 0x9b, 0x50, 0x09, 0xd8,
0x13, 0x2a, 0xe3, 0x51, 0x15, 0x27, 0xe9, 0x58, 0x1f, 0x40, 0xed, 0x90, 0xc8, 0x3e, 0x67, 0x13,
0x12, 0xe0, 0x77, 0x61, 0x95, 0xc4, 0xad, 0x78, 0xec, 0xba, 0xbd, 0xd9, 0x49, 0xdc, 0xeb, 0xa4,
0xee, 0x75, 0xfa, 0x7c, 0xe6, 0x68, 0x0c, 0xae, 0x03, 0x7a, 0x16, 0x93, 0x19, 0x0e, 0x7a, 0x66,
0xed, 0x41, 0xfd, 0x90, 0xc8, 0x9c, 0xab, 0x0b, 0x30, 0x26, 0xf2, 0x78, 0x09, 0xbe, 0xda, 0x38,
0x1d, 0x64, 0x3d, 0x84, 0x8d, 0x84, 0x24, 0xe7, 0xb9, 0x0b, 0x0d, 0xc5, 0xb3, 0x24, 0x57, 0x7d,
0x5c, 0x18, 0x6b, 0xdd, 0x86, 0xf5, 0x7d, 0x77, 0x2c, 0x1c, 0xfa, 0x8b, 0x29, 0x95, 0x89, 0x36,
0x54, 0x4a, 0xe2, 0xd3, 0x4c, 0x9b, 0xa4, 0x6b, 0xb5, 0xa1, 0x9e, 0x00, 0xe5, 0xa9, 0xe0, 0x92,
0x5e, 0x80, 0xfc, 0x3e, 0x6c, 0x3c, 0x22, 0xb3, 0x43, 0x1a, 0x04, 0x19, 0x6d, 0x1a, 0x0d, 0x54,
0x88, 0x46, 0x07, 0x9a, 0x39, 0x4c, 0x93, 0xb6, 0xa0, 0xea, 0x87, 0x94, 0x46, 0x8c, 0xfb, 0x1a,
0x9b, 0xf5, 0xad, 0x7d, 0x68, 0x7c, 0x44, 0x65, 0xa4, 0x96, 0xa0, 0x59, 0xbb, 0x00, 0x84, 0xcf,
0x96, 0xd2, 0x8f, 0xf0, 0x99, 0x5e, 0xf0, 0x3e, 0x6c, 0x64, 0x34, 0x7a, 0x56, 0x7b, 0x4e, 0x1c,
0xbe, 0xd5, 0x49, 0xb7, 0x65, 0x27, 0x13, 0xab, 0x18, 0x86, 0xc7, 0xb0, 0xa6, 0x68, 0x1e, 0x4a,
0x1f, 0xff, 0x04, 0xd6, 0x24, 0xf3, 0x39, 0x0d, 0xa5, 0x89, 0xb6, 0x8d, 0x76, 0x7d, 0xb0, 0xfb,
0xaf, 0x17, 0x37, 0xef, 0xf8, 0x2c, 0x1a, 0x4f, 0x87, 0x1d, 0x57, 0x4c, 0x76, 0x5c, 0x21, 0x27,
0x42, 0xea, 0xbf, 0x3b, 0xd2, 0x3b, 0xd9, 0x89, 0x66, 0xa7, 0x54, 0x76, 0xfa, 0xae, 0xdb, 0xf7,
0xbc, 0x90, 0x4a, 0xe9, 0xa4, 0x0c, 0xd6, 0x10, 0xbe, 0x39, 0x20, 0xde, 0xc3, 0x69, 0x10, 0xb1,
0x47, 0xcc, 0xe7, 0x24, 0x9a, 0x86, 0x14, 0x6f, 0x01, 0xc8, 0xb4, 0xa3, 0x27, 0x71, 0x0a, 0x16,
0x7c, 0x1b, 0x36, 0x26, 0x24, 0x60, 0x2e, 0x13, 0x53, 0x79, 0x3c, 0x62, 0x34, 0xf0, 0xcc, 0xca,
0x36, 0x6a, 0xd7, 0x9d, 0x46, 0x66, 0x3e, 0x50, 0xd6, 0xbb, 0xe5, 0xe7, 0x7f, 0xb8, 0x89, 0xac,
0x08, 0x6a, 0x7b, 0x53, 0x19, 0x89, 0x09, 0x0d, 0x77, 0x71, 0x03, 0x4a, 0xcc, 0x8b, 0x17, 0x5d,
0x71, 0x4a, 0xcc, 0x9b, 0x97, 0x38, 0xf8, 0x07, 0xd0, 0x94, 0xd3, 0xa1, 0x74, 0x43, 0x76, 0x1a,
0x31, 0xc1, 0x8f, 0x47, 0x94, 0x9a, 0xc6, 0x36, 0x6a, 0x97, 0x9c, 0x8d, 0xa2, 0xfd, 0x80, 0xc6,
0xdb, 0xe2, 0x94, 0xcc, 0x26, 0x94, 0x47, 0xe6, 0x5a, 0xb2, 0x2d, 0x74, 0xd7, 0xfa, 0xa4, 0x94,
0x4f, 0x6b, 0xbf, 0x36, 0x6d, 0x0b, 0xaa, 0x8c, 0x7b, 0x53, 0x19, 0x85, 0x33, 0x9d, 0x7d, 0x59,
0x3f, 0x73, 0xc9, 0x28, 0xb8, 0xb4, 0x09, 0x95, 0x11, 0x7d, 0x4a, 0x43, 0xb3, 0x1c, 0xfb, 0x91,
0x74, 0xf0, 0x9b, 0x50, 0x0d, 0xa9, 0xa4, 0xe1, 0x13, 0xea, 0x99, 0xbf, 0xaf, 0xc6, 0x79, 0x97,
0x19, 0xf0, 0xbb, 0x50, 0x76, 0x59, 0x34, 0x33, 0x57, 0xb7, 0x51, 0xbb, 0x61, 0x9b, 0x79, 0x80,
0x33, 0xaf, 0x3a, 0x7b, 0x2c, 0x9a, 0x39, 0x31, 0x0a, 0xdf, 0x85, 0x6f, 0x4c, 0x98, 0x74, 0x69,
0x10, 0x10, 0x4e, 0xc5, 0x54, 0x9a, 0x70, 0xc1, 0xfe, 0x3a, 0x0b, 0xb5, 0x3e, 0x80, 0xb2, 0x62,
0xc2, 0x55, 0x28, 0x3f, 0x20, 0x42, 0x36, 0x57, 0x70, 0x03, 0xe0, 0x81, 0x90, 0x7d, 0xee, 0xd3,
0x80, 0xca, 0x26, 0xc2, 0x75, 0xa8, 0xfe, 0x94, 0x04, 0xa2, 0x1f, 0x44, 0xa2, 0x59, 0xc2, 0x00,
0xab, 0x0f, 0x85, 0x74, 0xc5, 0xd3, 0xa6, 0x81, 0xd7, 0x61, 0xed, 0x88, 0xb0, 0x50, 0x0c, 0x59,
0xb3, 0x6c, 0x75, 0xa0, 0x7a, 0x44, 0x65, 0x44, 0xbd, 0x5e, 0x7f, 0x99, 0x40, 0x59, 0x7f, 0x45,
0xe9, 0x80, 0xee, 0x52, 0x03, 0xb0, 0x05, 0x25, 0xd2, 0x33, 0xcb, 0xdb, 0x46, 0x7b, 0xdd, 0xc6,
0xb9, 0x22, 0xe9, 0xa4, 0x4e, 0x89, 0xf4, 0x70, 0x17, 0x2a, 0x8c, 0x7b, 0xf4, 0x99, 0x59, 0x89,
0x61, 0x6f, 0x9d, 0x87, 0x75, 0xfb, 0x9d, 0xfb, 0xea, 0xf9, 0x3e, 0x8f, 0xc2, 0x99, 0x93, 0x60,
0x5b, 0x0f, 0x00, 0x72, 0x23, 0x6e, 0x82, 0x71, 0x42, 0x67, 0xb1, 0x2f, 0x86, 0xa3, 0x9a, 0xb8,
0x0d, 0x95, 0x27, 0x24, 0x98, 0x26, 0xde, 0xcc, 0x9f, 0x3b, 0x01, 0xdc, 0x2d, 0xfd, 0x08, 0x59,
0x1f, 0xa7, 0xcb, 0xb2, 0x97, 0x5b, 0xd6, 0x3b, 0xb0, 0xca, 0x63, 0x7c, 0xbc, 0x67, 0xe6, 0xd0,
0x77, 0xfb, 0x8e, 0x46, 0x58, 0x07, 0x29, 0xf7, 0xee, 0xeb, 0xdc, 0x39, 0xcf, 0x02, 0x37, 0xed,
0x9c, 0xe7, 0xfd, 0x2c, 0x56, 0x83, 0xd7, 0x78, 0x9a, 0x60, 0xa8, 0x42, 0x99, 0x6c, 0x6c, 0xd5,
0x9c, 0xb7, 0xa7, 0x2d, 0x2f, 0x0b, 0xde, 0x15, 0x19, 0x54, 0x38, 0x87, 0x8b, 0xc3, 0x39, 0x70,
0x4a, 0xc3, 0x9e, 0xc5, 0x33, 0x2d, 0xe7, 0xce, 0xa2, 0x72, 0x5b, 0xcd, 0x82, 0x1c, 0xd5, 0x5c,
0x42, 0xc9, 0x41, 0xaa, 0x80, 0xca, 0xc9, 0x50, 0x4c, 0x23, 0x1a, 0xe7, 0x64, 0xcd, 0x49, 0x3a,
0xd6, 0xcf, 0x33, 0x7d, 0x07, 0x57, 0xd0, 0x37, 0x67, 0xd7, 0x0a, 0x18, 0x99, 0x02, 0xd6, 0xaf,
0x0a, 0x15, 0xa5, 0xbb, 0xd4, 0xbe, 0x68, 0x40, 0x49, 0x8e, 0x74, 0xe9, 0x2a, 0xc9, 0x11, 0xfe,
0x2e, 0xd4, 0xe4, 0x34, 0x74, 0xc7, 0x24, 0xf4, 0xa9, 0xae, 0x24, 0xb9, 0x01, 0x6f, 0xc3, 0xba,
0x47, 0x65, 0xc4, 0x38, 0x51, 0xd5, 0x2d, 0x2e, 0xa9, 0x35, 0xa7, 0x68, 0xc2, 0x6f, 0x43, 0xc3,
0x0d, 0xa9, 0xc7, 0xa2, 0x63, 0x97, 0x84, 0xde, 0x31, 0x17, 0x49, 0xd1, 0x3b, 0x5c, 0x71, 0xea,
0x89, 0x7d, 0x8f, 0x84, 0xde, 0x91, 0xc0, 0x6f, 0x41, 0xcd, 0x1d, 0xab, 0xb7, 0x96, 0x82, 0x54,
0x35, 0xa4, 0x9a, 0x98, 0x8e, 0x04, 0xde, 0x81, 0xaa, 0x08, 0x99, 0xcf, 0x38, 0x09, 0xcc, 0xda,
0xf9, 0xd7, 0x4f, 0x56, 0xaa, 0x9d, 0x0c, 0x34, 0xa8, 0x65, 0x55, 0xd6, 0xfa, 0x67, 0x09, 0xea,
0xea, 0x4d, 0xf4, 0x98, 0x86, 0x92, 0x09, 0xbe, 0x9b, 0x9c, 0x39, 0x90, 0x3e, 0x73, 0xe0, 0x5b,
0x80, 0x88, 0x16, 0xf7, 0x8d, 0x9c, 0xb3, 0x38, 0xc0, 0x41, 0x44, 0xa1, 0x86, 0x3a, 0xc0, 0x0b,
0x51, 0x43, 0x85, 0x72, 0xf5, 0xe6, 0x5a, 0x88, 0x72, 0xf1, 0x3b, 0x80, 0x3c, 0x5d, 0x2a, 0x16,
0xa0, 0x06, 0xe5, 0x4f, 0x5f, 0xdc, 0x5c, 0x71, 0x90, 0x87, 0x1b, 0x80, 0x68, 0x5c, 0x8f, 0x2b,
0x87, 0x2b, 0x0e, 0xa2, 0xf8, 0x6d, 0x40, 0xa3, 0x58, 0xc2, 0x85, 0x63, 0x15, 0x6e, 0x84, 0x2d,
0x40, 0x7e, 0xac, 0xe3, 0xa2, 0x82, 0x8c, 0x7c, 0xe5, 0xed, 0xd8, 0xac, 0x5d, 0xec, 0xed, 0x18,
0xdf, 0x06, 0x74, 0x62, 0xd6, 0x17, 0x6a, 0x3e, 0x28, 0x3f, 0x7f, 0x71, 0x13, 0x39, 0xe8, 0x64,
0x50, 0x01, 0x43, 0x4e, 0x27, 0xd6, 0xaf, 0x8d, 0x33, 0x72, 0xdb, 0x97, 0x95, 0xdb, 0x5e, 0x4a,
0x6e, 0x7b, 0x29, 0xb9, 0x6d, 0x25, 0xf7, 0xad, 0xcf, 0x92, 0xdb, 0xbe, 0x92, 0xd0, 0xf6, 0x17,
0x28, 0xb4, 0x7d, 0x19, 0xa1, 0xf1, 0x9b, 0x50, 0xe3, 0xf4, 0xa9, 0x3e, 0xc6, 0xdc, 0xd8, 0x46,
0xed, 0xb2, 0x53, 0xe5, 0xf4, 0x69, 0x7c, 0x80, 0x49, 0xa3, 0xf0, 0xbb, 0xb3, 0x51, 0xe8, 0x5e,
0x36, 0x0a, 0xdd, 0xa5, 0xa2, 0xd0, 0x5d, 0x2a, 0x0a, 0xdd, 0xa5, 0xa2, 0xd0, 0xbd, 0x52, 0x14,
0xba, 0x5f, 0xd5, 0x76, 0xc7, 0x77, 0x00, 0x73, 0xc1, 0x8f, 0xdd, 0x90, 0x45, 0xcc, 0x25, 0x81,
0x0e, 0xc7, 0x6f, 0xe2, 0xda, 0xe5, 0x34, 0xb9, 0xe0, 0x7b, 0xfa, 0xc9, 0x99, 0xb8, 0xfc, 0xbb,
0x04, 0xad, 0xa2, 0xfb, 0x0f, 0x04, 0xa7, 0x1f, 0x72, 0xfa, 0xe1, 0xe8, 0xb1, 0x7a, 0x95, 0x5f,
0xd3, 0x28, 0x5d, 0x1b, 0xf5, 0xff, 0xb3, 0x0a, 0xdf, 0x39, 0xaf, 0xfe, 0x51, 0xfc, 0xb6, 0xf2,
0xaf, 0x89, 0xf4, 0xbb, 0x79, 0x42, 0x7c, 0x6f, 0x3e, 0xaa, 0xb0, 0xa6, 0x6b, 0x92, 0x1b, 0xf8,
0x7d, 0x58, 0x65, 0x9c, 0xd3, 0x70, 0xd7, 0x6c, 0xc4, 0xe4, 0xed, 0xcf, 0x5c, 0x59, 0xe7, 0x7e,
0x8c, 0x77, 0xf4, 0xb8, 0x8c, 0xc1, 0x36, 0x37, 0x2e, 0xc5, 0x60, 0x6b, 0x06, 0xbb, 0xf5, 0x47,
0x04, 0xab, 0x09, 0x69, 0xe1, 0x9c, 0x64, 0x2c, 0x3c, 0x27, 0xdd, 0x57, 0x47, 0x7e, 0x4e, 0x43,
0x1d, 0xfd, 0xee, 0xb2, 0x1e, 0x27, 0x7f, 0xf1, 0x8f, 0x93, 0x30, 0xb4, 0x7e, 0xa8, 0x3e, 0x04,
0x52, 0x63, 0x61, 0xf2, 0x5a, 0x3a, 0x79, 0xfc, 0x4d, 0xa6, 0x27, 0x57, 0xed, 0xd6, 0x9f, 0x52,
0x5f, 0xed, 0xd7, 0xe0, 0x26, 0xac, 0xb9, 0x62, 0xca, 0xd3, 0x8f, 0xc4, 0x9a, 0x93, 0x76, 0xaf,
0xea, 0xb1, 0xfd, 0x45, 0x78, 0x9c, 0xe6, 0xdf, 0x7f, 0xcf, 0xe6, 0x5f, 0xef, 0xeb, 0xfc, 0xbb,
0x46, 0xf9, 0xd7, 0xfb, 0xdc, 0xf9, 0xd7, 0xfb, 0x92, 0xf3, 0xaf, 0xf7, 0xb9, 0xf2, 0xcf, 0x58,
0x98, 0x7f, 0x9f, 0xfc, 0xdf, 0xf2, 0xaf, 0xb7, 0x54, 0xfe, 0xd9, 0x17, 0xe6, 0xdf, 0x66, 0xf1,
0xe2, 0xc0, 0xd0, 0x97, 0x04, 0x69, 0x06, 0xfe, 0x05, 0x25, 0x97, 0x84, 0x7a, 0xbe, 0x83, 0x7b,
0x57, 0xfb, 0x1c, 0xfa, 0xca, 0x3f, 0x4b, 0xd2, 0xf5, 0xfc, 0x1d, 0x9d, 0x39, 0x4f, 0x1d, 0xdc,
0xdb, 0xfd, 0x19, 0x8b, 0xc6, 0xfb, 0xcf, 0xa2, 0x90, 0xf4, 0xf9, 0xec, 0x4b, 0x5d, 0xdb, 0xad,
0x7c, 0x6d, 0x05, 0x5c, 0x9f, 0xcf, 0x32, 0x8f, 0x2e, 0xbd, 0xba, 0x8f, 0xa0, 0x5e, 0x1c, 0x8f,
0xdb, 0x6a, 0x01, 0x17, 0x5c, 0xe3, 0xa6, 0x15, 0x80, 0xa8, 0x85, 0x27, 0x95, 0xd1, 0x50, 0x15,
0xb0, 0x9e, 0x54, 0xc0, 0xb8, 0xe7, 0xda, 0x7f, 0x46, 0xb0, 0xae, 0x26, 0x7c, 0x44, 0xc3, 0x27,
0xcc, 0xa5, 0xf8, 0x3d, 0x28, 0xef, 0xbb, 0x63, 0x81, 0xbf, 0x9d, 0xfb, 0x53, 0xb8, 0xf1, 0x6e,
0xbd, 0x71, 0xde, 0xac, 0x2f, 0x85, 0xfb, 0x50, 0x4d, 0xaf, 0xa7, 0xf1, 0x8d, 0x1c, 0x73, 0xee,
0x66, 0xbb, 0xd5, 0x9a, 0xf7, 0x48, 0x53, 0xfc, 0x38, 0xb9, 0x23, 0x56, 0x91, 0x32, 0xcf, 0x8a,
0x91, 0x5f, 0x62, 0xb7, 0x6e, 0xcc, 0x79, 0x92, 0x8c, 0x1f, 0x1c, 0x7e, 0xfa, 0x72, 0x0b, 0x3d,
0x7f, 0xb9, 0x85, 0xfe, 0xf1, 0x72, 0x0b, 0xfd, 0xf6, 0xd5, 0xd6, 0xca, 0xf3, 0x57, 0x5b, 0x2b,
0x7f, 0x7b, 0xb5, 0xb5, 0xf2, 0x71, 0xe7, 0xe2, 0xdb, 0x65, 0x2a, 0xa3, 0x69, 0xc4, 0x82, 0x9d,
0x94, 0x79, 0xb8, 0x1a, 0xcb, 0xd8, 0xfd, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x45, 0xa4,
0xce, 0x79, 0x19, 0x00, 0x00,
0x92, 0xb1, 0xb3, 0x4e, 0x16, 0x76, 0x14, 0x89, 0x8b, 0x5d, 0xf5, 0xfa, 0xab, 0xaf, 0x5e, 0x7d,
0xaf, 0xde, 0xeb, 0xea, 0x82, 0xf5, 0xd3, 0x50, 0x44, 0xa2, 0x13, 0xff, 0xe2, 0x6a, 0x44, 0x65,
0xe4, 0x91, 0x88, 0xb4, 0x36, 0x7d, 0xe1, 0x8b, 0xd8, 0xb8, 0xa3, 0x5a, 0xc9, 0xf3, 0xd6, 0x0d,
0x5f, 0x08, 0x3f, 0xa0, 0x3b, 0x71, 0x6f, 0x38, 0x1d, 0xed, 0x10, 0x3e, 0x4b, 0x1e, 0x59, 0x77,
0xc0, 0xb8, 0x27, 0x7c, 0x8c, 0xa1, 0x2c, 0xd9, 0xcf, 0xa9, 0x89, 0xb6, 0x51, 0xbb, 0xe6, 0xc4,
0x6d, 0x65, 0xe3, 0x64, 0x42, 0xcd, 0x52, 0x62, 0x53, 0x6d, 0xeb, 0x03, 0x30, 0xf6, 0x48, 0x84,
0x4d, 0x58, 0x9b, 0x08, 0xce, 0x4e, 0x68, 0xa8, 0x47, 0xa4, 0x5d, 0xbc, 0x09, 0x95, 0x80, 0x3d,
0xa1, 0x32, 0x1e, 0x55, 0x71, 0x92, 0x8e, 0xf5, 0x11, 0xd4, 0x0e, 0x89, 0xec, 0x73, 0x36, 0x21,
0x01, 0x7e, 0x1f, 0x56, 0x49, 0xdc, 0x8a, 0xc7, 0xae, 0xdb, 0x9b, 0x9d, 0xc4, 0xbd, 0x4e, 0xea,
0x5e, 0xa7, 0xcf, 0x67, 0x8e, 0xc6, 0xe0, 0x3a, 0xa0, 0x67, 0x31, 0x99, 0xe1, 0xa0, 0x67, 0xd6,
0x1e, 0xd4, 0x0f, 0x89, 0xcc, 0xb9, 0xba, 0x00, 0x63, 0x22, 0x8f, 0x97, 0xe0, 0xab, 0x8d, 0xd3,
0x41, 0xd6, 0x43, 0xd8, 0x48, 0x48, 0x72, 0x9e, 0xbb, 0xd0, 0x50, 0x3c, 0x4b, 0x72, 0xd5, 0xc7,
0x85, 0xb1, 0xd6, 0x6d, 0x58, 0xdf, 0x77, 0xc7, 0xc2, 0xa1, 0x3f, 0x9b, 0x52, 0x99, 0x68, 0x43,
0xa5, 0x24, 0x3e, 0xcd, 0xb4, 0x49, 0xba, 0x56, 0x1b, 0xea, 0x09, 0x50, 0x9e, 0x0a, 0x2e, 0xe9,
0x05, 0xc8, 0xef, 0xc2, 0xc6, 0x23, 0x32, 0x3b, 0xa4, 0x41, 0x90, 0xd1, 0xa6, 0xd1, 0x40, 0x85,
0x68, 0x74, 0xa0, 0x99, 0xc3, 0x34, 0x69, 0x0b, 0xaa, 0x7e, 0x48, 0x69, 0xc4, 0xb8, 0xaf, 0xb1,
0x59, 0xdf, 0xda, 0x87, 0xc6, 0x27, 0x54, 0x46, 0x6a, 0x09, 0x9a, 0xb5, 0x0b, 0x40, 0xf8, 0x6c,
0x29, 0xfd, 0x08, 0x9f, 0xe9, 0x05, 0xef, 0xc3, 0x46, 0x46, 0xa3, 0x67, 0xb5, 0xe7, 0xc4, 0xe1,
0x1b, 0x9d, 0x74, 0x5b, 0x76, 0x32, 0xb1, 0x8a, 0x61, 0x78, 0x0c, 0x6b, 0x8a, 0xe6, 0xa1, 0xf4,
0xf1, 0x8f, 0x60, 0x4d, 0x32, 0x9f, 0xd3, 0x50, 0x9a, 0x68, 0xdb, 0x68, 0xd7, 0x07, 0xbb, 0xff,
0x78, 0x71, 0xf3, 0x8e, 0xcf, 0xa2, 0xf1, 0x74, 0xd8, 0x71, 0xc5, 0x64, 0xc7, 0x15, 0x72, 0x22,
0xa4, 0xfe, 0xbb, 0x23, 0xbd, 0x93, 0x9d, 0x68, 0x76, 0x4a, 0x65, 0xa7, 0xef, 0xba, 0x7d, 0xcf,
0x0b, 0xa9, 0x94, 0x4e, 0xca, 0x60, 0x0d, 0xe1, 0xeb, 0x03, 0xe2, 0x3d, 0x9c, 0x06, 0x11, 0x7b,
0xc4, 0x7c, 0x4e, 0xa2, 0x69, 0x48, 0xf1, 0x16, 0x80, 0x4c, 0x3b, 0x7a, 0x12, 0xa7, 0x60, 0xc1,
0xb7, 0x61, 0x63, 0x42, 0x02, 0xe6, 0x32, 0x31, 0x95, 0xc7, 0x23, 0x46, 0x03, 0xcf, 0xac, 0x6c,
0xa3, 0x76, 0xdd, 0x69, 0x64, 0xe6, 0x03, 0x65, 0xbd, 0x5b, 0x7e, 0xfe, 0xbb, 0x9b, 0xc8, 0x8a,
0xa0, 0xb6, 0x37, 0x95, 0x91, 0x98, 0xd0, 0x70, 0x17, 0x37, 0xa0, 0xc4, 0xbc, 0x78, 0xd1, 0x15,
0xa7, 0xc4, 0xbc, 0x79, 0x89, 0x83, 0xbf, 0x07, 0x4d, 0x39, 0x1d, 0x4a, 0x37, 0x64, 0xa7, 0x11,
0x13, 0xfc, 0x78, 0x44, 0xa9, 0x69, 0x6c, 0xa3, 0x76, 0xc9, 0xd9, 0x28, 0xda, 0x0f, 0x68, 0xbc,
0x2d, 0x4e, 0xc9, 0x6c, 0x42, 0x79, 0x64, 0xae, 0x25, 0xdb, 0x42, 0x77, 0xad, 0xcf, 0x4a, 0xf9,
0xb4, 0xf6, 0x6b, 0xd3, 0xb6, 0xa0, 0xca, 0xb8, 0x37, 0x95, 0x51, 0x38, 0xd3, 0xd9, 0x97, 0xf5,
0x33, 0x97, 0x8c, 0x82, 0x4b, 0x9b, 0x50, 0x19, 0xd1, 0xa7, 0x34, 0x34, 0xcb, 0xb1, 0x1f, 0x49,
0x07, 0xbf, 0x0d, 0xd5, 0x90, 0x4a, 0x1a, 0x3e, 0xa1, 0x9e, 0xf9, 0xdb, 0x6a, 0x9c, 0x77, 0x99,
0x01, 0xbf, 0x0f, 0x65, 0x97, 0x45, 0x33, 0x73, 0x75, 0x1b, 0xb5, 0x1b, 0xb6, 0x99, 0x07, 0x38,
0xf3, 0xaa, 0xb3, 0xc7, 0xa2, 0x99, 0x13, 0xa3, 0xf0, 0x5d, 0xf8, 0xda, 0x84, 0x49, 0x97, 0x06,
0x01, 0xe1, 0x54, 0x4c, 0xa5, 0x09, 0x17, 0xec, 0xaf, 0xb3, 0x50, 0xeb, 0x23, 0x28, 0x2b, 0x26,
0x5c, 0x85, 0xf2, 0x03, 0x22, 0x64, 0x73, 0x05, 0x37, 0x00, 0x1e, 0x08, 0xd9, 0xe7, 0x3e, 0x0d,
0xa8, 0x6c, 0x22, 0x5c, 0x87, 0xea, 0x8f, 0x49, 0x20, 0xfa, 0x41, 0x24, 0x9a, 0x25, 0x0c, 0xb0,
0xfa, 0x50, 0x48, 0x57, 0x3c, 0x6d, 0x1a, 0x78, 0x1d, 0xd6, 0x8e, 0x08, 0x0b, 0xc5, 0x90, 0x35,
0xcb, 0x56, 0x07, 0xaa, 0x47, 0x54, 0x46, 0xd4, 0xeb, 0xf5, 0x97, 0x09, 0x94, 0xf5, 0x67, 0x94,
0x0e, 0xe8, 0x2e, 0x35, 0x00, 0x5b, 0x50, 0x22, 0x3d, 0xb3, 0xbc, 0x6d, 0xb4, 0xd7, 0x6d, 0x9c,
0x2b, 0x92, 0x4e, 0xea, 0x94, 0x48, 0x0f, 0x77, 0xa1, 0xc2, 0xb8, 0x47, 0x9f, 0x99, 0x95, 0x18,
0xf6, 0xce, 0x79, 0x58, 0xb7, 0xdf, 0xb9, 0xaf, 0x9e, 0xef, 0xf3, 0x28, 0x9c, 0x39, 0x09, 0xb6,
0xf5, 0x00, 0x20, 0x37, 0xe2, 0x26, 0x18, 0x27, 0x74, 0x16, 0xfb, 0x62, 0x38, 0xaa, 0x89, 0xdb,
0x50, 0x79, 0x42, 0x82, 0x69, 0xe2, 0xcd, 0xfc, 0xb9, 0x13, 0xc0, 0xdd, 0xd2, 0x0f, 0x90, 0xf5,
0x69, 0xba, 0x2c, 0x7b, 0xb9, 0x65, 0xbd, 0x07, 0xab, 0x3c, 0xc6, 0xc7, 0x7b, 0x66, 0x0e, 0x7d,
0xb7, 0xef, 0x68, 0x84, 0x75, 0x90, 0x72, 0xef, 0xbe, 0xce, 0x9d, 0xf3, 0x2c, 0x70, 0xd3, 0xce,
0x79, 0x3e, 0xcc, 0x62, 0x35, 0x78, 0x8d, 0xa7, 0x09, 0x86, 0x2a, 0x94, 0xc9, 0xc6, 0x56, 0xcd,
0x79, 0x7b, 0xda, 0xf2, 0xb2, 0xe0, 0x5d, 0x91, 0x41, 0x85, 0x73, 0xb8, 0x38, 0x9c, 0x03, 0xa7,
0x34, 0xec, 0x59, 0x3c, 0xd3, 0x72, 0xee, 0x2c, 0x2a, 0xb7, 0xd5, 0x2c, 0xc8, 0x51, 0xcd, 0x25,
0x94, 0x1c, 0xa4, 0x0a, 0xa8, 0x9c, 0x0c, 0xc5, 0x34, 0xa2, 0x71, 0x4e, 0xd6, 0x9c, 0xa4, 0x63,
0xfd, 0x34, 0xd3, 0x77, 0x70, 0x05, 0x7d, 0x73, 0x76, 0xad, 0x80, 0x91, 0x29, 0x60, 0xfd, 0xa2,
0x50, 0x51, 0xba, 0x4b, 0xed, 0x8b, 0x06, 0x94, 0xe4, 0x48, 0x97, 0xae, 0x92, 0x1c, 0xe1, 0x6f,
0x43, 0x4d, 0x4e, 0x43, 0x77, 0x4c, 0x42, 0x9f, 0xea, 0x4a, 0x92, 0x1b, 0xf0, 0x36, 0xac, 0x7b,
0x54, 0x46, 0x8c, 0x13, 0x55, 0xdd, 0xe2, 0x92, 0x5a, 0x73, 0x8a, 0x26, 0xfc, 0x2e, 0x34, 0xdc,
0x90, 0x7a, 0x2c, 0x3a, 0x76, 0x49, 0xe8, 0x1d, 0x73, 0x91, 0x14, 0xbd, 0xc3, 0x15, 0xa7, 0x9e,
0xd8, 0xf7, 0x48, 0xe8, 0x1d, 0x09, 0xfc, 0x0e, 0xd4, 0xdc, 0xb1, 0x7a, 0x6b, 0x29, 0x48, 0x55,
0x43, 0xaa, 0x89, 0xe9, 0x48, 0xe0, 0x1d, 0xa8, 0x8a, 0x90, 0xf9, 0x8c, 0x93, 0xc0, 0xac, 0x9d,
0x7f, 0xfd, 0x64, 0xa5, 0xda, 0xc9, 0x40, 0x83, 0x5a, 0x56, 0x65, 0xad, 0xbf, 0x97, 0xa0, 0xae,
0xde, 0x44, 0x8f, 0x69, 0x28, 0x99, 0xe0, 0xbb, 0xc9, 0x99, 0x03, 0xe9, 0x33, 0x07, 0xbe, 0x05,
0x88, 0x68, 0x71, 0xdf, 0xca, 0x39, 0x8b, 0x03, 0x1c, 0x44, 0x14, 0x6a, 0xa8, 0x03, 0xbc, 0x10,
0x35, 0x54, 0x28, 0x57, 0x6f, 0xae, 0x85, 0x28, 0x17, 0xbf, 0x07, 0xc8, 0xd3, 0xa5, 0x62, 0x01,
0x6a, 0x50, 0xfe, 0xfc, 0xc5, 0xcd, 0x15, 0x07, 0x79, 0xb8, 0x01, 0x88, 0xc6, 0xf5, 0xb8, 0x72,
0xb8, 0xe2, 0x20, 0x8a, 0xdf, 0x05, 0x34, 0x8a, 0x25, 0x5c, 0x38, 0x56, 0xe1, 0x46, 0xd8, 0x02,
0xe4, 0xc7, 0x3a, 0x2e, 0x2a, 0xc8, 0xc8, 0x57, 0xde, 0x8e, 0xcd, 0xda, 0xc5, 0xde, 0x8e, 0xf1,
0x6d, 0x40, 0x27, 0x66, 0x7d, 0xa1, 0xe6, 0x83, 0xf2, 0xf3, 0x17, 0x37, 0x91, 0x83, 0x4e, 0x06,
0x15, 0x30, 0xe4, 0x74, 0x62, 0xfd, 0xd2, 0x38, 0x23, 0xb7, 0x7d, 0x59, 0xb9, 0xed, 0xa5, 0xe4,
0xb6, 0x97, 0x92, 0xdb, 0x56, 0x72, 0xdf, 0xfa, 0x22, 0xb9, 0xed, 0x2b, 0x09, 0x6d, 0xbf, 0x29,
0xa1, 0xf1, 0xdb, 0x50, 0xe3, 0xf4, 0xa9, 0x3e, 0xc6, 0xdc, 0xd8, 0x46, 0xed, 0xb2, 0x53, 0xe5,
0xf4, 0x69, 0x7c, 0x80, 0x49, 0xa3, 0xf0, 0x9b, 0xb3, 0x51, 0xe8, 0x5e, 0x36, 0x0a, 0xdd, 0xa5,
0xa2, 0xd0, 0x5d, 0x2a, 0x0a, 0xdd, 0xa5, 0xa2, 0xd0, 0xbd, 0x52, 0x14, 0xba, 0x6f, 0x2c, 0x0a,
0x77, 0x00, 0x73, 0xc1, 0x8f, 0xdd, 0x90, 0x45, 0xcc, 0x25, 0x81, 0x0e, 0xc7, 0xaf, 0xe2, 0xda,
0xe5, 0x34, 0xb9, 0xe0, 0x7b, 0xfa, 0xc9, 0x99, 0xb8, 0xfc, 0xb3, 0x04, 0xad, 0xa2, 0xfb, 0x0f,
0x04, 0xa7, 0x1f, 0x73, 0xfa, 0xf1, 0xe8, 0xb1, 0x7a, 0x95, 0x5f, 0xd3, 0x28, 0x5d, 0x1b, 0xf5,
0xff, 0xb5, 0x0a, 0xdf, 0x3a, 0xaf, 0xfe, 0x51, 0xfc, 0xb6, 0xf2, 0xaf, 0x89, 0xf4, 0xbb, 0x79,
0x42, 0x7c, 0x67, 0x3e, 0xaa, 0xb0, 0xa6, 0x6b, 0x92, 0x1b, 0xf8, 0x43, 0x58, 0x65, 0x9c, 0xd3,
0x70, 0xd7, 0x6c, 0xc4, 0xe4, 0xed, 0x2f, 0x5c, 0x59, 0xe7, 0x7e, 0x8c, 0x77, 0xf4, 0xb8, 0x8c,
0xc1, 0x36, 0x37, 0x2e, 0xc5, 0x60, 0x6b, 0x06, 0xbb, 0xf5, 0x7b, 0x04, 0xab, 0x09, 0x69, 0xe1,
0x9c, 0x64, 0x2c, 0x3c, 0x27, 0xdd, 0x57, 0x47, 0x7e, 0x4e, 0x43, 0x1d, 0xfd, 0xee, 0xb2, 0x1e,
0x27, 0x7f, 0xf1, 0x8f, 0x93, 0x30, 0xb4, 0xbe, 0xaf, 0x3e, 0x04, 0x52, 0x63, 0x61, 0xf2, 0x5a,
0x3a, 0x79, 0xfc, 0x4d, 0xa6, 0x27, 0x57, 0xed, 0xd6, 0x1f, 0x52, 0x5f, 0xed, 0xd7, 0xe0, 0x26,
0xac, 0xb9, 0x62, 0xca, 0xd3, 0x8f, 0xc4, 0x9a, 0x93, 0x76, 0xaf, 0xea, 0xb1, 0xfd, 0xdf, 0xf0,
0x38, 0xcd, 0xbf, 0x7f, 0x9f, 0xcd, 0xbf, 0xde, 0xff, 0xf3, 0xef, 0x1a, 0xe5, 0x5f, 0xef, 0x4b,
0xe7, 0x5f, 0xef, 0x2b, 0xce, 0xbf, 0xde, 0x97, 0xca, 0x3f, 0x63, 0x61, 0xfe, 0x7d, 0xf6, 0x3f,
0xcb, 0xbf, 0xde, 0x52, 0xf9, 0x67, 0x5f, 0x98, 0x7f, 0x9b, 0xc5, 0x8b, 0x03, 0x43, 0x5f, 0x12,
0xa4, 0x19, 0xf8, 0x27, 0x94, 0x5c, 0x12, 0xea, 0xf9, 0x0e, 0xee, 0x5d, 0xed, 0x73, 0xe8, 0x8d,
0x7f, 0x96, 0xa4, 0xeb, 0xf9, 0x2b, 0x3a, 0x73, 0x9e, 0x3a, 0xb8, 0xb7, 0xfb, 0x13, 0x16, 0x8d,
0xf7, 0x9f, 0x45, 0x21, 0xe9, 0xf3, 0xd9, 0x57, 0xba, 0xb6, 0x5b, 0xf9, 0xda, 0x0a, 0xb8, 0x3e,
0x9f, 0x65, 0x1e, 0x5d, 0x7a, 0x75, 0x9f, 0x40, 0xbd, 0x38, 0x1e, 0xb7, 0xd5, 0x02, 0x2e, 0xb8,
0xc6, 0x4d, 0x2b, 0x00, 0x51, 0x0b, 0x4f, 0x2a, 0xa3, 0xa1, 0x2a, 0x60, 0x3d, 0xa9, 0x80, 0x71,
0xcf, 0xb5, 0xff, 0x88, 0x60, 0x5d, 0x4d, 0xf8, 0x88, 0x86, 0x4f, 0x98, 0x4b, 0xf1, 0x07, 0x50,
0xde, 0x77, 0xc7, 0x02, 0x7f, 0x33, 0xf7, 0xa7, 0x70, 0xe3, 0xdd, 0x7a, 0xeb, 0xbc, 0x59, 0x5f,
0x0a, 0xf7, 0xa1, 0x9a, 0x5e, 0x4f, 0xe3, 0x1b, 0x39, 0xe6, 0xdc, 0xcd, 0x76, 0xab, 0x35, 0xef,
0x91, 0xa6, 0xf8, 0x61, 0x72, 0x47, 0xac, 0x22, 0x65, 0x9e, 0x15, 0x23, 0xbf, 0xc4, 0x6e, 0xdd,
0x98, 0xf3, 0x24, 0x19, 0x3f, 0x38, 0xfc, 0xfc, 0xe5, 0x16, 0x7a, 0xfe, 0x72, 0x0b, 0xfd, 0xed,
0xe5, 0x16, 0xfa, 0xf5, 0xab, 0xad, 0x95, 0xe7, 0xaf, 0xb6, 0x56, 0xfe, 0xf2, 0x6a, 0x6b, 0xe5,
0xd3, 0xce, 0xc5, 0xb7, 0xcb, 0x54, 0x46, 0xd3, 0x88, 0x05, 0x3b, 0x29, 0xf3, 0x70, 0x35, 0x96,
0xb1, 0xfb, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x62, 0xd0, 0xa8, 0x05, 0x79, 0x19, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -10935,7 +10934,7 @@ func (m *TestVersion2) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.H = append(m.H, &TestVersion2{})
m.H = append(m.H, &TestVersion1{})
if err := m.H[len(m.H)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}

36
types/kv/kv.go Normal file
View File

@ -0,0 +1,36 @@
package kv
import (
"bytes"
"sort"
)
//----------------------------------------
// KVPair
/*
Defined in types.proto
type Pair struct {
Key []byte
Value []byte
}
*/
type Pairs []Pair
// Sorting
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
case 0:
return bytes.Compare(kvs[i].Value, kvs[j].Value) < 0
case 1:
return false
default:
panic("invalid comparison result")
}
}
func (kvs Pairs) Swap(i, j int) { kvs[i], kvs[j] = kvs[j], kvs[i] }
func (kvs Pairs) Sort() { sort.Sort(kvs) }

373
types/kv/kv.pb.go Normal file
View File

@ -0,0 +1,373 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/kv/kv.proto
package kv
import (
fmt "fmt"
proto "github.com/gogo/protobuf/proto"
io "io"
math "math"
math_bits "math/bits"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Key-Value Pair
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"`
}
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_23371bd43b515c6e, []int{0}
}
func (m *Pair) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Pair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Pair.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *Pair) XXX_Merge(src proto.Message) {
xxx_messageInfo_Pair.Merge(m, src)
}
func (m *Pair) XXX_Size() int {
return m.Size()
}
func (m *Pair) XXX_DiscardUnknown() {
xxx_messageInfo_Pair.DiscardUnknown(m)
}
var xxx_messageInfo_Pair proto.InternalMessageInfo
func (m *Pair) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *Pair) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func init() {
proto.RegisterType((*Pair)(nil), "cosmos.kv.Pair")
}
func init() { proto.RegisterFile("cosmos/kv/kv.proto", fileDescriptor_23371bd43b515c6e) }
var fileDescriptor_23371bd43b515c6e = []byte{
// 150 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4a, 0xce, 0x2f, 0xce,
0xcd, 0x2f, 0xd6, 0xcf, 0x2e, 0xd3, 0xcf, 0x2e, 0xd3, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2,
0x84, 0x88, 0xe9, 0x65, 0x97, 0x29, 0xe9, 0x71, 0xb1, 0x04, 0x24, 0x66, 0x16, 0x09, 0x09, 0x70,
0x31, 0x67, 0xa7, 0x56, 0x4a, 0x30, 0x2a, 0x30, 0x6a, 0xf0, 0x04, 0x81, 0x98, 0x42, 0x22, 0x5c,
0xac, 0x65, 0x89, 0x39, 0xa5, 0xa9, 0x12, 0x4c, 0x60, 0x31, 0x08, 0xc7, 0xc9, 0xfe, 0xc4, 0x23,
0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2,
0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0x54, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4,
0x92, 0xf3, 0x73, 0xf5, 0xa1, 0x76, 0x42, 0x28, 0xdd, 0xe2, 0x94, 0x6c, 0xfd, 0x92, 0xca, 0x82,
0x54, 0x90, 0x23, 0x92, 0xd8, 0xc0, 0x4e, 0x30, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0xae, 0xee,
0xa2, 0x4c, 0x98, 0x00, 0x00, 0x00,
}
func (m *Pair) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *Pair) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Value) > 0 {
i -= len(m.Value)
copy(dAtA[i:], m.Value)
i = encodeVarintKv(dAtA, i, uint64(len(m.Value)))
i--
dAtA[i] = 0x12
}
if len(m.Key) > 0 {
i -= len(m.Key)
copy(dAtA[i:], m.Key)
i = encodeVarintKv(dAtA, i, uint64(len(m.Key)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func encodeVarintKv(dAtA []byte, offset int, v uint64) int {
offset -= sovKv(v)
base := offset
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
v >>= 7
offset++
}
dAtA[offset] = uint8(v)
return base
}
func (m *Pair) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Key)
if l > 0 {
n += 1 + l + sovKv(uint64(l))
}
l = len(m.Value)
if l > 0 {
n += 1 + l + sovKv(uint64(l))
}
return n
}
func sovKv(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
func sozKv(x uint64) (n int) {
return sovKv(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Pair) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKv
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: Pair: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Pair: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKv
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKv
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKv
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
if m.Key == nil {
m.Key = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowKv
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthKv
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthKv
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
if m.Value == nil {
m.Value = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipKv(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthKv
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthKv
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipKv(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 {
if shift >= 64 {
return 0, ErrIntOverflowKv
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= (uint64(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
wireType := int(wire & 0x7)
switch wireType {
case 0:
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowKv
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
iNdEx++
if dAtA[iNdEx-1] < 0x80 {
break
}
}
case 1:
iNdEx += 8
case 2:
var length int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return 0, ErrIntOverflowKv
}
if iNdEx >= l {
return 0, io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
length |= (int(b) & 0x7F) << shift
if b < 0x80 {
break
}
}
if length < 0 {
return 0, ErrInvalidLengthKv
}
iNdEx += length
case 3:
depth++
case 4:
if depth == 0 {
return 0, ErrUnexpectedEndOfGroupKv
}
depth--
case 5:
iNdEx += 4
default:
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
}
if iNdEx < 0 {
return 0, ErrInvalidLengthKv
}
if depth == 0 {
return iNdEx, nil
}
}
return 0, io.ErrUnexpectedEOF
}
var (
ErrInvalidLengthKv = fmt.Errorf("proto: negative length found during unmarshaling")
ErrIntOverflowKv = fmt.Errorf("proto: integer overflow")
ErrUnexpectedEndOfGroupKv = fmt.Errorf("proto: unexpected end of group")
)

7
types/store.go
View File

@ -1,9 +1,8 @@
package types
import (
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/store/types"
"github.com/cosmos/cosmos-sdk/types/kv"
)
type (
@ -25,7 +24,7 @@ type (
// StoreDecoderRegistry defines each of the modules store decoders. Used for ImportExport
// simulation.
type StoreDecoderRegistry map[string]func(kvA, kvB tmkv.Pair) string
type StoreDecoderRegistry map[string]func(kvA, kvB kv.Pair) string
// Iterator over all the keys with a certain prefix in ascending order
func KVStorePrefixIterator(kvs KVStore, prefix []byte) Iterator {
@ -51,7 +50,7 @@ func KVStoreReversePrefixIteratorPaginated(kvs KVStore, prefix []byte, page, lim
// DiffKVStores compares two KVstores and returns all the key/value pairs
// that differ from one another. It also skips value comparison for a set of provided prefixes
func DiffKVStores(a KVStore, b KVStore, prefixesToSkip [][]byte) (kvAs, kvBs []tmkv.Pair) {
func DiffKVStores(a KVStore, b KVStore, prefixesToSkip [][]byte) (kvAs, kvBs []kv.Pair) {
return types.DiffKVStores(a, b, prefixesToSkip)
}

6
types/tx/signing/signing.pb.go
View File

@ -113,9 +113,8 @@ func (m *SignatureDescriptors) GetSignatures() []*SignatureDescriptor {
// itself. It is primarily used for coordinating signatures between clients.
type SignatureDescriptor struct {
// public_key is the public key of the signer
PublicKey *types.PublicKey `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
// data represents the signature data
Data *SignatureDescriptor_Data `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
PublicKey *types.PublicKey `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
Data *SignatureDescriptor_Data `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *SignatureDescriptor) Reset() { *m = SignatureDescriptor{} }
@ -165,6 +164,7 @@ func (m *SignatureDescriptor) GetData() *SignatureDescriptor_Data {
return nil
}
// Data represents signature data
type SignatureDescriptor_Data struct {
// sum is the oneof that specifies whether this represents single or multi-signature data
//

6
x/auth/simulation/decoder.go
View File

@ -5,9 +5,9 @@ import (
"fmt"
gogotypes "github.com/gogo/protobuf/types"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/auth/types"
)
@ -18,8 +18,8 @@ type AuthUnmarshaler interface {
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding auth type.
func NewDecodeStore(ak AuthUnmarshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(ak AuthUnmarshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.AddressStoreKeyPrefix):
accA, err := ak.UnmarshalAccount(kvA.Value)

10
x/auth/simulation/decoder_test.go
View File

@ -7,10 +7,10 @@ import (
gogotypes "github.com/gogo/protobuf/types"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/auth/simulation"
"github.com/cosmos/cosmos-sdk/x/auth/types"
)
@ -31,16 +31,16 @@ func TestDecodeStore(t *testing.T) {
globalAccNumber := gogotypes.UInt64Value{Value: 10}
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: types.AddressStoreKey(delAddr1),
Value: accBz,
},
tmkv.Pair{
kv.Pair{
Key: types.GlobalAccountNumberKey,
Value: cdc.MustMarshalBinaryBare(&globalAccNumber),
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

8
x/bank/simulation/decoder.go
View File

@ -4,10 +4,8 @@ import (
"bytes"
"fmt"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/bank/exported"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/x/bank/types"
)
@ -17,8 +15,8 @@ type SupplyUnmarshaller interface {
// NewDecodeStore returns a function closure that unmarshals the KVPair's values
// to the corresponding types.
func NewDecodeStore(cdc SupplyUnmarshaller) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc SupplyUnmarshaller) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.SupplyKey):
supplyA, err := cdc.UnmarshalSupply(kvA.Value)

8
x/bank/simulation/decoder_test.go
View File

@ -5,10 +5,10 @@ import (
"testing"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/bank/simulation"
"github.com/cosmos/cosmos-sdk/x/bank/types"
)
@ -22,9 +22,9 @@ func TestDecodeStore(t *testing.T) {
supplyBz, err := app.BankKeeper.MarshalSupply(totalSupply)
require.NoError(t, err)
kvPairs := tmkv.Pairs{
tmkv.Pair{Key: types.SupplyKey, Value: supplyBz},
tmkv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
kvPairs := kv.Pairs{
kv.Pair{Key: types.SupplyKey, Value: supplyBz},
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
}
tests := []struct {

7
x/capability/simulation/decoder.go
View File

@ -4,17 +4,16 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/capability/types"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding capaility type.
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key, types.KeyIndex):
idxA := sdk.BigEndianToUint64(kvA.Value)

10
x/capability/simulation/decoder_test.go
View File

@ -5,10 +5,10 @@ import (
"testing"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/capability/simulation"
"github.com/cosmos/cosmos-sdk/x/capability/types"
)
@ -21,16 +21,16 @@ func TestDecodeStore(t *testing.T) {
Owners: []types.Owner{{Module: "transfer", Name: "ports/transfer"}},
}
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: types.KeyIndex,
Value: sdk.Uint64ToBigEndian(10),
},
tmkv.Pair{
kv.Pair{
Key: types.KeyPrefixIndexCapability,
Value: cdc.MustMarshalBinaryBare(&capOwners),
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

7
x/distribution/simulation/decoder.go
View File

@ -4,17 +4,16 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding distribution type.
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.FeePoolKey):
var feePoolA, feePoolB types.FeePool

25
x/distribution/simulation/decoder_test.go
View File

@ -5,12 +5,11 @@ import (
"testing"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/distribution/simulation"
"github.com/cosmos/cosmos-sdk/x/distribution/types"
)
@ -36,17 +35,17 @@ func TestDecodeDistributionStore(t *testing.T) {
currentRewards := types.NewValidatorCurrentRewards(decCoins, 5)
slashEvent := types.NewValidatorSlashEvent(10, sdk.OneDec())
kvPairs := tmkv.Pairs{
tmkv.Pair{Key: types.FeePoolKey, Value: cdc.MustMarshalBinaryBare(&feePool)},
tmkv.Pair{Key: types.ProposerKey, Value: consAddr1.Bytes()},
tmkv.Pair{Key: types.GetValidatorOutstandingRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&outstanding)},
tmkv.Pair{Key: types.GetDelegatorWithdrawAddrKey(delAddr1), Value: delAddr1.Bytes()},
tmkv.Pair{Key: types.GetDelegatorStartingInfoKey(valAddr1, delAddr1), Value: cdc.MustMarshalBinaryBare(&info)},
tmkv.Pair{Key: types.GetValidatorHistoricalRewardsKey(valAddr1, 100), Value: cdc.MustMarshalBinaryBare(&historicalRewards)},
tmkv.Pair{Key: types.GetValidatorCurrentRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&currentRewards)},
tmkv.Pair{Key: types.GetValidatorAccumulatedCommissionKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&commission)},
tmkv.Pair{Key: types.GetValidatorSlashEventKeyPrefix(valAddr1, 13), Value: cdc.MustMarshalBinaryBare(&slashEvent)},
tmkv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
kvPairs := kv.Pairs{
kv.Pair{Key: types.FeePoolKey, Value: cdc.MustMarshalBinaryBare(&feePool)},
kv.Pair{Key: types.ProposerKey, Value: consAddr1.Bytes()},
kv.Pair{Key: types.GetValidatorOutstandingRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&outstanding)},
kv.Pair{Key: types.GetDelegatorWithdrawAddrKey(delAddr1), Value: delAddr1.Bytes()},
kv.Pair{Key: types.GetDelegatorStartingInfoKey(valAddr1, delAddr1), Value: cdc.MustMarshalBinaryBare(&info)},
kv.Pair{Key: types.GetValidatorHistoricalRewardsKey(valAddr1, 100), Value: cdc.MustMarshalBinaryBare(&historicalRewards)},
kv.Pair{Key: types.GetValidatorCurrentRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&currentRewards)},
kv.Pair{Key: types.GetValidatorAccumulatedCommissionKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&commission)},
kv.Pair{Key: types.GetValidatorSlashEventKeyPrefix(valAddr1, 13), Value: cdc.MustMarshalBinaryBare(&slashEvent)},
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
}
tests := []struct {

8
x/evidence/simulation/decoder.go
View File

@ -4,10 +4,8 @@ import (
"bytes"
"fmt"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/evidence/exported"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/x/evidence/types"
)
@ -17,8 +15,8 @@ type EvidenceUnmarshaler interface {
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding evidence type.
func NewDecodeStore(cdc EvidenceUnmarshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc EvidenceUnmarshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.KeyPrefixEvidence):
evidenceA, err := cdc.UnmarshalEvidence(kvA.Value)

8
x/evidence/simulation/decoder_test.go
View File

@ -7,10 +7,10 @@ import (
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/evidence/simulation"
"github.com/cosmos/cosmos-sdk/x/evidence/types"
)
@ -31,12 +31,12 @@ func TestDecodeStore(t *testing.T) {
evBz, err := app.EvidenceKeeper.MarshalEvidence(ev)
require.NoError(t, err)
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: types.KeyPrefixEvidence,
Value: evBz,
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

7
x/gov/simulation/decoder.go
View File

@ -5,16 +5,15 @@ import (
"encoding/binary"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/gov/types"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding gov type.
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.ProposalsKeyPrefix):
var proposalA types.Proposal

15
x/gov/simulation/decoder_test.go
View File

@ -7,12 +7,11 @@ import (
"time"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/gov/simulation"
"github.com/cosmos/cosmos-sdk/x/gov/types"
)
@ -40,12 +39,12 @@ func TestDecodeStore(t *testing.T) {
proposalBz, err := cdc.MarshalBinaryBare(&proposal)
require.NoError(t, err)
kvPairs := tmkv.Pairs{
tmkv.Pair{Key: types.ProposalKey(1), Value: proposalBz},
tmkv.Pair{Key: types.InactiveProposalQueueKey(1, endTime), Value: proposalIDBz},
tmkv.Pair{Key: types.DepositKey(1, delAddr1), Value: cdc.MustMarshalBinaryBare(&deposit)},
tmkv.Pair{Key: types.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryBare(&vote)},
tmkv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
kvPairs := kv.Pairs{
kv.Pair{Key: types.ProposalKey(1), Value: proposalBz},
kv.Pair{Key: types.InactiveProposalQueueKey(1, endTime), Value: proposalIDBz},
kv.Pair{Key: types.DepositKey(1, delAddr1), Value: cdc.MustMarshalBinaryBare(&deposit)},
kv.Pair{Key: types.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryBare(&vote)},
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
}
tests := []struct {

24
x/ibc-transfer/types/genesis.pb.go
View File

@ -5,7 +5,6 @@ package types
import (
fmt "fmt"
_ "github.com/cosmos/cosmos-sdk/types"
_ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto"
io "io"
@ -77,21 +76,20 @@ func init() {
func init() { proto.RegisterFile("ibc/transfer/genesis.proto", fileDescriptor_c13b8463155e05c2) }
var fileDescriptor_c13b8463155e05c2 = []byte{
// 218 bytes of a gzipped FileDescriptorProto
// 204 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0xca, 0x4c, 0x4a, 0xd6,
0x2f, 0x29, 0x4a, 0xcc, 0x2b, 0x4e, 0x4b, 0x2d, 0xd2, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c,
0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0xc9, 0x4c, 0x4a, 0xd6, 0x83, 0xc9, 0x49, 0x89,
0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x25, 0xf4, 0x41, 0x2c, 0x88, 0x1a, 0x29, 0xe1, 0xe4, 0xfc, 0xe2,
0xdc, 0xfc, 0x62, 0x7d, 0x08, 0x05, 0x15, 0x94, 0x46, 0x31, 0x14, 0xc6, 0x80, 0x48, 0x2a, 0xb9,
0x72, 0xf1, 0xb8, 0x43, 0xac, 0x09, 0x2e, 0x49, 0x2c, 0x49, 0x15, 0x32, 0xe5, 0x62, 0x2f, 0xc8,
0x2f, 0x2a, 0x89, 0xcf, 0x4c, 0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x74, 0x92, 0x79, 0x74, 0x4f,
0x9e, 0x2d, 0x20, 0xbf, 0xa8, 0xc4, 0xd3, 0xe5, 0xd3, 0x3d, 0x79, 0xbe, 0xca, 0xc4, 0xdc, 0x1c,
0x2b, 0x25, 0xa8, 0x12, 0xa5, 0x20, 0x36, 0x10, 0xcb, 0x33, 0xc5, 0xc9, 0xfb, 0xc4, 0x23, 0x39,
0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58, 0x8e, 0xe1, 0xc2, 0x63,
0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0x0c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92,
0xf3, 0x73, 0xf5, 0x51, 0x5c, 0xa7, 0x5b, 0x9c, 0x92, 0xad, 0x5f, 0xa1, 0x9f, 0x99, 0x94, 0xac,
0x8b, 0x70, 0x5c, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x69, 0xc6, 0x80, 0x00, 0x00, 0x00,
0xff, 0xff, 0x7a, 0xfc, 0xa4, 0xfa, 0x0e, 0x01, 0x00, 0x00,
0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x25, 0xf4, 0x41, 0x2c, 0x88, 0x1a, 0x25, 0x57, 0x2e, 0x1e, 0x77,
0x88, 0xa6, 0xe0, 0x92, 0xc4, 0x92, 0x54, 0x21, 0x53, 0x2e, 0xf6, 0x82, 0xfc, 0xa2, 0x92, 0xf8,
0xcc, 0x14, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x4e, 0x27, 0x99, 0x47, 0xf7, 0xe4, 0xd9, 0x02, 0xf2,
0x8b, 0x4a, 0x3c, 0x5d, 0x3e, 0xdd, 0x93, 0xe7, 0xab, 0x4c, 0xcc, 0xcd, 0xb1, 0x52, 0x82, 0x2a,
0x51, 0x0a, 0x62, 0x03, 0xb1, 0x3c, 0x53, 0x9c, 0xbc, 0x4f, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48,
0x8e, 0xf1, 0xc1, 0x23, 0x39, 0xc6, 0x09, 0x8f, 0xe5, 0x18, 0x2e, 0x3c, 0x96, 0x63, 0xb8, 0xf1,
0x58, 0x8e, 0x21, 0xca, 0x30, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x3f,
0x39, 0xbf, 0x38, 0x37, 0xbf, 0x18, 0x4a, 0xe9, 0x16, 0xa7, 0x64, 0xeb, 0x57, 0xe8, 0x67, 0x26,
0x25, 0xeb, 0xc2, 0xdd, 0x5f, 0x52, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x76, 0x9a, 0x31, 0x20,
0x00, 0x00, 0xff, 0xff, 0x2e, 0x43, 0x78, 0xc7, 0xdc, 0x00, 0x00, 0x00,
}
func (m *GenesisState) Marshal() (dAtA []byte, err error) {

5
x/ibc/02-client/simulation/decoder.go
View File

@ -4,16 +4,15 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding client type.
func NewDecodeStore(cdc *codec.Codec, kvA, kvB tmkv.Pair) (string, bool) {
func NewDecodeStore(cdc *codec.Codec, kvA, kvB kv.Pair) (string, bool) {
switch {
case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.HasSuffix(kvA.Key, host.KeyClientState()):
var clientStateA, clientStateB exported.ClientState

12
x/ibc/02-client/simulation/decoder_test.go
View File

@ -6,9 +6,9 @@ import (
"time"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/ibc/02-client/exported"
"github.com/cosmos/cosmos-sdk/x/ibc/02-client/simulation"
ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types"
@ -29,20 +29,20 @@ func TestDecodeStore(t *testing.T) {
Timestamp: time.Now().UTC(),
}
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: host.FullKeyClientPath(clientID, host.KeyClientState()),
Value: cdc.MustMarshalBinaryBare(clientState),
},
tmkv.Pair{
kv.Pair{
Key: host.FullKeyClientPath(clientID, host.KeyClientType()),
Value: []byte(exported.Tendermint.String()),
},
tmkv.Pair{
kv.Pair{
Key: host.FullKeyClientPath(clientID, host.KeyConsensusState(10)),
Value: cdc.MustMarshalBinaryBare(consState),
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

5
x/ibc/03-connection/simulation/decoder.go
View File

@ -4,16 +4,15 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding connection type.
func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB tmkv.Pair) (string, bool) {
func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB kv.Pair) (string, bool) {
switch {
case bytes.HasPrefix(kvA.Key, host.KeyClientStorePrefix) && bytes.HasSuffix(kvA.Key, host.KeyConnectionPrefix):
var clientConnectionsA, clientConnectionsB types.ClientPaths

10
x/ibc/03-connection/simulation/decoder_test.go
View File

@ -5,9 +5,9 @@ import (
"testing"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/simulation"
"github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
@ -28,16 +28,16 @@ func TestDecodeStore(t *testing.T) {
Paths: []string{connectionID},
}
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: host.KeyClientConnections(connection.ClientID),
Value: cdc.MustMarshalBinaryBare(&paths),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyConnection(connectionID),
Value: cdc.MustMarshalBinaryBare(&connection),
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

5
x/ibc/04-channel/simulation/decoder.go
View File

@ -4,17 +4,16 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding channel type.
func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB tmkv.Pair) (string, bool) {
func NewDecodeStore(cdc codec.BinaryMarshaler, kvA, kvB kv.Pair) (string, bool) {
switch {
case bytes.HasPrefix(kvA.Key, []byte(host.KeyChannelPrefix)):
var channelA, channelB types.Channel

18
x/ibc/04-channel/simulation/decoder_test.go
View File

@ -5,10 +5,10 @@ import (
"testing"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/simulation"
"github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
host "github.com/cosmos/cosmos-sdk/x/ibc/24-host"
@ -28,32 +28,32 @@ func TestDecodeStore(t *testing.T) {
bz := []byte{0x1, 0x2, 0x3}
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: host.KeyChannel(portID, channelID),
Value: cdc.MustMarshalBinaryBare(&channel),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyNextSequenceSend(portID, channelID),
Value: sdk.Uint64ToBigEndian(1),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyNextSequenceRecv(portID, channelID),
Value: sdk.Uint64ToBigEndian(1),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyNextSequenceAck(portID, channelID),
Value: sdk.Uint64ToBigEndian(1),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyPacketCommitment(portID, channelID, 1),
Value: bz,
},
tmkv.Pair{
kv.Pair{
Key: host.KeyPacketAcknowledgement(portID, channelID, 1),
Value: bz,
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

7
x/ibc/simulation/decoder.go
View File

@ -3,9 +3,8 @@ package simulation
import (
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
clientsim "github.com/cosmos/cosmos-sdk/x/ibc/02-client/simulation"
connectionsim "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/simulation"
channelsim "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/simulation"
@ -14,8 +13,8 @@ import (
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding ibc type.
func NewDecodeStore(cdc codec.BinaryMarshaler, aminoCdc *codec.Codec) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.BinaryMarshaler, aminoCdc *codec.Codec) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
if res, found := clientsim.NewDecodeStore(aminoCdc, kvA, kvB); found {
return res
}

12
x/ibc/simulation/decoder_test.go
View File

@ -5,9 +5,9 @@ import (
"testing"
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
"github.com/cosmos/cosmos-sdk/types/kv"
connectiontypes "github.com/cosmos/cosmos-sdk/x/ibc/03-connection/types"
channeltypes "github.com/cosmos/cosmos-sdk/x/ibc/04-channel/types"
ibctmtypes "github.com/cosmos/cosmos-sdk/x/ibc/07-tendermint/types"
@ -39,20 +39,20 @@ func TestDecodeStore(t *testing.T) {
Version: "1.0",
}
kvPairs := tmkv.Pairs{
tmkv.Pair{
kvPairs := kv.Pairs{
kv.Pair{
Key: host.FullKeyClientPath(clientID, host.KeyClientState()),
Value: aminoCdc.MustMarshalBinaryBare(clientState),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyConnection(connectionID),
Value: cdc.MustMarshalBinaryBare(&connection),
},
tmkv.Pair{
kv.Pair{
Key: host.KeyChannel(portID, channelID),
Value: cdc.MustMarshalBinaryBare(&channel),
},
tmkv.Pair{
kv.Pair{
Key: []byte{0x99},
Value: []byte{0x99},
},

7
x/mint/simulation/decoder.go
View File

@ -4,16 +4,15 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/mint/types"
)
// NewDecodeStore returns a decoder function closure that umarshals the KVPair's
// Value to the corresponding mint type.
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key, types.MinterKey):
var minterA, minterB types.Minter

9
x/mint/simulation/decoder_test.go
View File

@ -6,10 +6,9 @@ import (
"github.com/stretchr/testify/require"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/mint/simulation"
"github.com/cosmos/cosmos-sdk/x/mint/types"
)
@ -20,9 +19,9 @@ func TestDecodeStore(t *testing.T) {
minter := types.NewMinter(sdk.OneDec(), sdk.NewDec(15))
kvPairs := tmkv.Pairs{
tmkv.Pair{Key: types.MinterKey, Value: cdc.MustMarshalBinaryBare(&minter)},
tmkv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
kvPairs := kv.Pairs{
kv.Pair{Key: types.MinterKey, Value: cdc.MustMarshalBinaryBare(&minter)},
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
}
tests := []struct {
name string

6
x/slashing/simulation/decoder.go
View File

@ -5,16 +5,16 @@ import (
"fmt"
gogotypes "github.com/gogo/protobuf/types"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/slashing/types"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding slashing type.
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.ValidatorSigningInfoKeyPrefix):
var infoA, infoB types.ValidatorSigningInfo

14
x/slashing/simulation/decoder_test.go
View File

@ -6,14 +6,12 @@ import (
"time"
gogotypes "github.com/gogo/protobuf/types"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/slashing/simulation"
"github.com/cosmos/cosmos-sdk/x/slashing/types"
)
@ -34,11 +32,11 @@ func TestDecodeStore(t *testing.T) {
bechPK := sdk.MustBech32ifyPubKey(sdk.Bech32PubKeyTypeConsPub, delPk1)
missed := gogotypes.BoolValue{Value: true}
kvPairs := tmkv.Pairs{
tmkv.Pair{Key: types.ValidatorSigningInfoKey(consAddr1), Value: cdc.MustMarshalBinaryBare(&info)},
tmkv.Pair{Key: types.ValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryBare(&missed)},
tmkv.Pair{Key: types.AddrPubkeyRelationKey(delAddr1), Value: cdc.MustMarshalBinaryBare(&gogotypes.StringValue{Value: bechPK})},
tmkv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
kvPairs := kv.Pairs{
kv.Pair{Key: types.ValidatorSigningInfoKey(consAddr1), Value: cdc.MustMarshalBinaryBare(&info)},
kv.Pair{Key: types.ValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryBare(&missed)},
kv.Pair{Key: types.AddrPubkeyRelationKey(delAddr1), Value: cdc.MustMarshalBinaryBare(&gogotypes.StringValue{Value: bechPK})},
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
}
tests := []struct {

7
x/staking/simulation/decoder.go
View File

@ -4,17 +4,16 @@ import (
"bytes"
"fmt"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
// NewDecodeStore returns a decoder function closure that unmarshals the KVPair's
// Value to the corresponding staking type.
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB tmkv.Pair) string {
return func(kvA, kvB tmkv.Pair) string {
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.Equal(kvA.Key[:1], types.LastTotalPowerKey):
var powerA, powerB sdk.IntProto

19
x/staking/simulation/decoder_test.go
View File

@ -6,14 +6,13 @@ import (
"time"
"github.com/stretchr/testify/require"
"github.com/tendermint/tendermint/crypto/ed25519"
tmkv "github.com/tendermint/tendermint/libs/kv"
"github.com/cosmos/cosmos-sdk/codec"
cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
"github.com/cosmos/cosmos-sdk/simapp"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/cosmos/cosmos-sdk/x/staking/simulation"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
@ -43,14 +42,14 @@ func TestDecodeStore(t *testing.T) {
ubd := types.NewUnbondingDelegation(delAddr1, valAddr1, 15, bondTime, sdk.OneInt())
red := types.NewRedelegation(delAddr1, valAddr1, valAddr1, 12, bondTime, sdk.OneInt(), sdk.OneDec())
kvPairs := tmkv.Pairs{
tmkv.Pair{Key: types.LastTotalPowerKey, Value: cdc.MustMarshalBinaryBare(&sdk.IntProto{Int: sdk.OneInt()})},
tmkv.Pair{Key: types.GetValidatorKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&val)},
tmkv.Pair{Key: types.LastValidatorPowerKey, Value: valAddr1.Bytes()},
tmkv.Pair{Key: types.GetDelegationKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&del)},
tmkv.Pair{Key: types.GetUBDKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&ubd)},
tmkv.Pair{Key: types.GetREDKey(delAddr1, valAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&red)},
tmkv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
kvPairs := kv.Pairs{
kv.Pair{Key: types.LastTotalPowerKey, Value: cdc.MustMarshalBinaryBare(&sdk.IntProto{Int: sdk.OneInt()})},
kv.Pair{Key: types.GetValidatorKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&val)},
kv.Pair{Key: types.LastValidatorPowerKey, Value: valAddr1.Bytes()},
kv.Pair{Key: types.GetDelegationKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&del)},
kv.Pair{Key: types.GetUBDKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&ubd)},
kv.Pair{Key: types.GetREDKey(delAddr1, valAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&red)},
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
}
tests := []struct {

1226
x/staking/types/staking.pb.go
View File

File diff suppressed because it is too large Load Diff