store: Remove Amino (#6984)
* Update kv pair to proto * updates * fix LastCommitID * lint++ Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>
This commit is contained in:
parent
69cd552260
commit
0f44d1af23
|
@ -1,9 +1,16 @@
|
|||
syntax = "proto3";
|
||||
package cosmos.kv;
|
||||
|
||||
import "gogoproto/gogo.proto";
|
||||
|
||||
option go_package = "github.com/cosmos/cosmos-sdk/types/kv";
|
||||
|
||||
// Key-Value Pair
|
||||
// Pairs defines a repeated slice of Pair objects.
|
||||
message Pairs {
|
||||
repeated Pair pairs = 1 [(gogoproto.nullable) = false];
|
||||
}
|
||||
|
||||
// Pair defines a key/value bytes tuple.
|
||||
message Pair {
|
||||
bytes key = 1;
|
||||
bytes value = 2;
|
||||
|
|
|
@ -0,0 +1,29 @@
|
|||
syntax = "proto3";
|
||||
package cosmos.store;
|
||||
|
||||
import "gogoproto/gogo.proto";
|
||||
|
||||
option go_package = "github.com/cosmos/cosmos-sdk/store/types";
|
||||
|
||||
// CommitInfo defines commit information used by the multi-store when committing
|
||||
// a version/height.
|
||||
message CommitInfo {
|
||||
int64 version = 1;
|
||||
repeated StoreInfo store_infos = 2 [(gogoproto.nullable) = false];
|
||||
}
|
||||
|
||||
// StoreInfo defines store-specific commit information. It contains a reference
|
||||
// between a store name and the commit ID.
|
||||
message StoreInfo {
|
||||
string name = 1;
|
||||
CommitID commit_id = 2 [(gogoproto.nullable) = false, (gogoproto.customname) = "CommitID"];
|
||||
}
|
||||
|
||||
// CommitID defines the committment information when a specific store is
|
||||
// committed.
|
||||
message CommitID {
|
||||
option (gogoproto.goproto_stringer) = false;
|
||||
|
||||
int64 version = 1;
|
||||
bytes hash = 2;
|
||||
}
|
|
@ -270,18 +270,25 @@ func (st *Store) Query(req abci.RequestQuery) (res abci.ResponseQuery) {
|
|||
res.Proof = getProofFromTree(mtree, req.Data, res.Value != nil)
|
||||
|
||||
case "/subspace":
|
||||
var KVs []types.KVPair
|
||||
pairs := kv.Pairs{
|
||||
Pairs: make([]kv.Pair, 0),
|
||||
}
|
||||
|
||||
subspace := req.Data
|
||||
res.Key = subspace
|
||||
|
||||
iterator := types.KVStorePrefixIterator(st, subspace)
|
||||
for ; iterator.Valid(); iterator.Next() {
|
||||
KVs = append(KVs, types.KVPair{Key: iterator.Key(), Value: iterator.Value()})
|
||||
pairs.Pairs = append(pairs.Pairs, kv.Pair{Key: iterator.Key(), Value: iterator.Value()})
|
||||
}
|
||||
iterator.Close()
|
||||
|
||||
bz, err := pairs.Marshal()
|
||||
if err != nil {
|
||||
panic(fmt.Errorf("failed to marshal KV pairs: %w", err))
|
||||
}
|
||||
|
||||
iterator.Close()
|
||||
res.Value = cdc.MustMarshalBinaryBare(KVs)
|
||||
res.Value = bz
|
||||
|
||||
default:
|
||||
return sdkerrors.QueryResult(sdkerrors.Wrapf(sdkerrors.ErrUnknownRequest, "unexpected query path: %v", req.Path))
|
||||
|
|
|
@ -11,6 +11,7 @@ import (
|
|||
dbm "github.com/tendermint/tm-db"
|
||||
|
||||
"github.com/cosmos/cosmos-sdk/store/types"
|
||||
"github.com/cosmos/cosmos-sdk/types/kv"
|
||||
)
|
||||
|
||||
var (
|
||||
|
@ -408,18 +409,28 @@ func TestIAVLStoreQuery(t *testing.T) {
|
|||
v3 := []byte("val3")
|
||||
|
||||
ksub := []byte("key")
|
||||
KVs0 := []types.KVPair{}
|
||||
KVs1 := []types.KVPair{
|
||||
KVs0 := kv.Pairs{}
|
||||
KVs1 := kv.Pairs{
|
||||
Pairs: []kv.Pair{
|
||||
{Key: k1, Value: v1},
|
||||
{Key: k2, Value: v2},
|
||||
},
|
||||
}
|
||||
KVs2 := []types.KVPair{
|
||||
KVs2 := kv.Pairs{
|
||||
Pairs: []kv.Pair{
|
||||
{Key: k1, Value: v3},
|
||||
{Key: k2, Value: v2},
|
||||
},
|
||||
}
|
||||
valExpSubEmpty := cdc.MustMarshalBinaryBare(KVs0)
|
||||
valExpSub1 := cdc.MustMarshalBinaryBare(KVs1)
|
||||
valExpSub2 := cdc.MustMarshalBinaryBare(KVs2)
|
||||
|
||||
valExpSubEmpty, err := KVs0.Marshal()
|
||||
require.NoError(t, err)
|
||||
|
||||
valExpSub1, err := KVs1.Marshal()
|
||||
require.NoError(t, err)
|
||||
|
||||
valExpSub2, err := KVs2.Marshal()
|
||||
require.NoError(t, err)
|
||||
|
||||
cid := iavlStore.Commit()
|
||||
ver := cid.Version
|
||||
|
|
|
@ -1,7 +0,0 @@
|
|||
package iavl
|
||||
|
||||
import (
|
||||
"github.com/cosmos/cosmos-sdk/codec"
|
||||
)
|
||||
|
||||
var cdc = codec.New()
|
|
@ -6,7 +6,6 @@ import (
|
|||
"github.com/tendermint/tendermint/crypto/merkle"
|
||||
"github.com/tendermint/tendermint/crypto/tmhash"
|
||||
|
||||
"github.com/cosmos/cosmos-sdk/store/types"
|
||||
"github.com/cosmos/cosmos-sdk/types/kv"
|
||||
)
|
||||
|
||||
|
@ -19,7 +18,7 @@ type merkleMap struct {
|
|||
|
||||
func newMerkleMap() *merkleMap {
|
||||
return &merkleMap{
|
||||
kvs: nil,
|
||||
kvs: kv.Pairs{},
|
||||
sorted: false,
|
||||
}
|
||||
}
|
||||
|
@ -29,7 +28,7 @@ func newMerkleMap() *merkleMap {
|
|||
// of kv.Pairs. Whenever called, the MerkleMap must be resorted.
|
||||
func (sm *merkleMap) set(key string, value []byte) {
|
||||
byteKey := []byte(key)
|
||||
types.AssertValidKey(byteKey)
|
||||
assertValidKey(byteKey)
|
||||
|
||||
sm.sorted = false
|
||||
|
||||
|
@ -37,7 +36,7 @@ func (sm *merkleMap) set(key string, value []byte) {
|
|||
// and make a determination to fetch or not.
|
||||
vhash := tmhash.Sum(value)
|
||||
|
||||
sm.kvs = append(sm.kvs, kv.Pair{
|
||||
sm.kvs.Pairs = append(sm.kvs.Pairs, kv.Pair{
|
||||
Key: byteKey,
|
||||
Value: vhash,
|
||||
})
|
||||
|
@ -61,8 +60,8 @@ func (sm *merkleMap) sort() {
|
|||
// hashKVPairs hashes a kvPair and creates a merkle tree where the leaves are
|
||||
// byte slices.
|
||||
func hashKVPairs(kvs kv.Pairs) []byte {
|
||||
kvsH := make([][]byte, len(kvs))
|
||||
for i, kvp := range kvs {
|
||||
kvsH := make([][]byte, len(kvs.Pairs))
|
||||
for i, kvp := range kvs.Pairs {
|
||||
kvsH[i] = KVPair(kvp).Bytes()
|
||||
}
|
||||
|
||||
|
@ -81,7 +80,7 @@ type simpleMap struct {
|
|||
|
||||
func newSimpleMap() *simpleMap {
|
||||
return &simpleMap{
|
||||
Kvs: nil,
|
||||
Kvs: kv.Pairs{},
|
||||
sorted: false,
|
||||
}
|
||||
}
|
||||
|
@ -90,7 +89,7 @@ func newSimpleMap() *simpleMap {
|
|||
// and then appends it to SimpleMap's kv pairs.
|
||||
func (sm *simpleMap) Set(key string, value []byte) {
|
||||
byteKey := []byte(key)
|
||||
types.AssertValidKey(byteKey)
|
||||
assertValidKey(byteKey)
|
||||
sm.sorted = false
|
||||
|
||||
// The value is hashed, so you can
|
||||
|
@ -98,7 +97,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, kv.Pair{
|
||||
sm.Kvs.Pairs = append(sm.Kvs.Pairs, kv.Pair{
|
||||
Key: byteKey,
|
||||
Value: vhash,
|
||||
})
|
||||
|
@ -123,8 +122,11 @@ func (sm *simpleMap) Sort() {
|
|||
// NOTE these contain the hashed key and value.
|
||||
func (sm *simpleMap) KVPairs() kv.Pairs {
|
||||
sm.Sort()
|
||||
kvs := make(kv.Pairs, len(sm.Kvs))
|
||||
copy(kvs, sm.Kvs)
|
||||
kvs := kv.Pairs{
|
||||
Pairs: make([]kv.Pair, len(sm.Kvs.Pairs)),
|
||||
}
|
||||
|
||||
copy(kvs.Pairs, sm.Kvs.Pairs)
|
||||
return kvs
|
||||
}
|
||||
|
||||
|
@ -188,18 +190,25 @@ func SimpleProofsFromMap(m map[string][]byte) ([]byte, map[string]*merkle.Simple
|
|||
|
||||
sm.Sort()
|
||||
kvs := sm.Kvs
|
||||
kvsBytes := make([][]byte, len(kvs))
|
||||
for i, kvp := range kvs {
|
||||
kvsBytes := make([][]byte, len(kvs.Pairs))
|
||||
for i, kvp := range kvs.Pairs {
|
||||
kvsBytes[i] = KVPair(kvp).Bytes()
|
||||
}
|
||||
|
||||
rootHash, proofList := merkle.SimpleProofsFromByteSlices(kvsBytes)
|
||||
proofs := make(map[string]*merkle.SimpleProof)
|
||||
keys := make([]string, len(proofList))
|
||||
for i, kvp := range kvs {
|
||||
|
||||
for i, kvp := range kvs.Pairs {
|
||||
proofs[string(kvp.Key)] = proofList[i]
|
||||
keys[i] = string(kvp.Key)
|
||||
}
|
||||
|
||||
return rootHash, proofs, keys
|
||||
}
|
||||
|
||||
func assertValidKey(key []byte) {
|
||||
if len(key) == 0 {
|
||||
panic("key is nil")
|
||||
}
|
||||
}
|
|
@ -6,7 +6,7 @@ import (
|
|||
|
||||
ics23 "github.com/confio/ics23/go"
|
||||
|
||||
sdkmaps "github.com/cosmos/cosmos-sdk/store/rootmulti/internal/maps"
|
||||
sdkmaps "github.com/cosmos/cosmos-sdk/store/internal/maps"
|
||||
)
|
||||
|
||||
// TendermintSpec constrains the format from ics23-tendermint (crypto/merkle SimpleProof)
|
|
@ -1,24 +1,21 @@
|
|||
package rootmulti
|
||||
|
||||
import (
|
||||
"encoding/binary"
|
||||
"fmt"
|
||||
"io"
|
||||
"strings"
|
||||
|
||||
ics23 "github.com/confio/ics23/go"
|
||||
gogotypes "github.com/gogo/protobuf/types"
|
||||
"github.com/pkg/errors"
|
||||
iavltree "github.com/tendermint/iavl"
|
||||
abci "github.com/tendermint/tendermint/abci/types"
|
||||
"github.com/tendermint/tendermint/crypto/merkle"
|
||||
dbm "github.com/tendermint/tm-db"
|
||||
|
||||
"github.com/cosmos/cosmos-sdk/codec"
|
||||
"github.com/cosmos/cosmos-sdk/store/cachemulti"
|
||||
"github.com/cosmos/cosmos-sdk/store/dbadapter"
|
||||
"github.com/cosmos/cosmos-sdk/store/iavl"
|
||||
"github.com/cosmos/cosmos-sdk/store/mem"
|
||||
sdkmaps "github.com/cosmos/cosmos-sdk/store/rootmulti/internal/maps"
|
||||
sdkproofs "github.com/cosmos/cosmos-sdk/store/rootmulti/internal/proofs"
|
||||
"github.com/cosmos/cosmos-sdk/store/tracekv"
|
||||
"github.com/cosmos/cosmos-sdk/store/transient"
|
||||
"github.com/cosmos/cosmos-sdk/store/types"
|
||||
|
@ -31,14 +28,12 @@ const (
|
|||
commitInfoKeyFmt = "s/%d" // s/<version>
|
||||
)
|
||||
|
||||
var cdc = codec.New()
|
||||
|
||||
// Store is composed of many CommitStores. Name contrasts with
|
||||
// cacheMultiStore which is for cache-wrapping other MultiStores. It implements
|
||||
// the CommitMultiStore interface.
|
||||
type Store struct {
|
||||
db dbm.DB
|
||||
lastCommitInfo commitInfo
|
||||
lastCommitInfo *types.CommitInfo
|
||||
pruningOpts types.PruningOptions
|
||||
storesParams map[types.StoreKey]storeParams
|
||||
stores map[types.StoreKey]types.CommitKVStore
|
||||
|
@ -152,8 +147,9 @@ func (rs *Store) LoadVersion(ver int64) error {
|
|||
}
|
||||
|
||||
func (rs *Store) loadVersion(ver int64, upgrades *types.StoreUpgrades) error {
|
||||
infos := make(map[string]storeInfo)
|
||||
var cInfo commitInfo
|
||||
infos := make(map[string]types.StoreInfo)
|
||||
|
||||
cInfo := &types.CommitInfo{}
|
||||
|
||||
// load old data if we are not version 0
|
||||
if ver != 0 {
|
||||
|
@ -217,12 +213,13 @@ func (rs *Store) loadVersion(ver int64, upgrades *types.StoreUpgrades) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
func (rs *Store) getCommitID(infos map[string]storeInfo, name string) types.CommitID {
|
||||
func (rs *Store) getCommitID(infos map[string]types.StoreInfo, name string) types.CommitID {
|
||||
info, ok := infos[name]
|
||||
if !ok {
|
||||
return types.CommitID{}
|
||||
}
|
||||
return info.Core.CommitID
|
||||
|
||||
return info.CommitID
|
||||
}
|
||||
|
||||
func deleteKVStore(kv types.KVStore) error {
|
||||
|
@ -290,11 +287,12 @@ func (rs *Store) TracingEnabled() bool {
|
|||
return rs.traceWriter != nil
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// +CommitStore
|
||||
|
||||
// LastCommitID implements Committer/CommitStore.
|
||||
func (rs *Store) LastCommitID() types.CommitID {
|
||||
if rs.lastCommitInfo == nil {
|
||||
return types.CommitID{}
|
||||
}
|
||||
|
||||
return rs.lastCommitInfo.CommitID()
|
||||
}
|
||||
|
||||
|
@ -365,9 +363,6 @@ func (rs *Store) CacheWrapWithTrace(_ io.Writer, _ types.TraceContext) types.Cac
|
|||
return rs.CacheWrap()
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// +MultiStore
|
||||
|
||||
// CacheMultiStore cache-wraps the multi-store and returns a CacheMultiStore.
|
||||
// It implements the MultiStore interface.
|
||||
func (rs *Store) CacheMultiStore() types.CacheMultiStore {
|
||||
|
@ -453,8 +448,6 @@ func (rs *Store) getStoreByName(name string) types.Store {
|
|||
return rs.GetCommitKVStore(key)
|
||||
}
|
||||
|
||||
//---------------------- Query ------------------
|
||||
|
||||
// Query calls substore.Query with the same `req` where `req.Path` is
|
||||
// modified to remove the substore prefix.
|
||||
// Ie. `req.Path` here is `/<substore>/<path>`, and trimmed to `/<path>` for the substore.
|
||||
|
@ -491,7 +484,7 @@ func (rs *Store) Query(req abci.RequestQuery) abci.ResponseQuery {
|
|||
// If the request's height is the latest height we've committed, then utilize
|
||||
// the store's lastCommitInfo as this commit info may not be flushed to disk.
|
||||
// Otherwise, we query for the commit info from disk.
|
||||
var commitInfo commitInfo
|
||||
var commitInfo *types.CommitInfo
|
||||
|
||||
if res.Height == rs.lastCommitInfo.Version {
|
||||
commitInfo = rs.lastCommitInfo
|
||||
|
@ -578,125 +571,32 @@ func (rs *Store) loadCommitStoreFromParams(key types.StoreKey, id types.CommitID
|
|||
}
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// storeParams
|
||||
|
||||
type storeParams struct {
|
||||
key types.StoreKey
|
||||
db dbm.DB
|
||||
typ types.StoreType
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// commitInfo
|
||||
|
||||
// NOTE: Keep commitInfo a simple immutable struct.
|
||||
type commitInfo struct {
|
||||
|
||||
// Version
|
||||
Version int64
|
||||
|
||||
// Store info for
|
||||
StoreInfos []storeInfo
|
||||
}
|
||||
|
||||
func (ci commitInfo) toMap() map[string][]byte {
|
||||
m := make(map[string][]byte, len(ci.StoreInfos))
|
||||
for _, storeInfo := range ci.StoreInfos {
|
||||
m[storeInfo.Name] = storeInfo.GetHash()
|
||||
}
|
||||
return m
|
||||
}
|
||||
|
||||
// Hash returns the simple merkle root hash of the stores sorted by name.
|
||||
func (ci commitInfo) Hash() []byte {
|
||||
// we need a special case for empty set, as SimpleProofsFromMap requires at least one entry
|
||||
if len(ci.StoreInfos) == 0 {
|
||||
return nil
|
||||
}
|
||||
rootHash, _, _ := sdkmaps.SimpleProofsFromMap(ci.toMap())
|
||||
return rootHash
|
||||
}
|
||||
|
||||
func (ci commitInfo) ProofOp(storeName string) merkle.ProofOp {
|
||||
cmap := ci.toMap()
|
||||
_, proofs, _ := sdkmaps.SimpleProofsFromMap(cmap)
|
||||
proof := proofs[storeName]
|
||||
if proof == nil {
|
||||
panic(fmt.Sprintf("ProofOp for %s but not registered store name", storeName))
|
||||
}
|
||||
// convert merkle.SimpleProof to CommitmentProof
|
||||
existProof, err := sdkproofs.ConvertExistenceProof(proof, []byte(storeName), cmap[storeName])
|
||||
if err != nil {
|
||||
panic(fmt.Errorf("could not convert simple proof to existence proof: %w", err))
|
||||
}
|
||||
commitmentProof := &ics23.CommitmentProof{
|
||||
Proof: &ics23.CommitmentProof_Exist{
|
||||
Exist: existProof,
|
||||
},
|
||||
}
|
||||
|
||||
return types.NewSimpleMerkleCommitmentOp([]byte(storeName), commitmentProof).ProofOp()
|
||||
}
|
||||
|
||||
func (ci commitInfo) CommitID() types.CommitID {
|
||||
return types.CommitID{
|
||||
Version: ci.Version,
|
||||
Hash: ci.Hash(),
|
||||
}
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// storeInfo
|
||||
|
||||
// storeInfo contains the name and core reference for an
|
||||
// underlying store. It is the leaf of the Stores top
|
||||
// level simple merkle tree.
|
||||
type storeInfo struct {
|
||||
Name string
|
||||
Core storeCore
|
||||
}
|
||||
|
||||
type storeCore struct {
|
||||
// StoreType StoreType
|
||||
CommitID types.CommitID
|
||||
// ... maybe add more state
|
||||
}
|
||||
|
||||
// GetHash returns the GetHash from the CommitID.
|
||||
// This is used in CommitInfo.Hash()
|
||||
//
|
||||
// When we commit to this in a merkle proof, we create a map of storeInfo.Name -> storeInfo.GetHash()
|
||||
// and build a merkle proof from that.
|
||||
// This is then chained with the substore proof, so we prove the root hash from the substore before this
|
||||
// and need to pass that (unmodified) as the leaf value of the multistore proof.
|
||||
func (si storeInfo) GetHash() []byte {
|
||||
return si.Core.CommitID.Hash
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// Misc.
|
||||
|
||||
func getLatestVersion(db dbm.DB) int64 {
|
||||
var latest int64
|
||||
latestBytes, err := db.Get([]byte(latestVersionKey))
|
||||
bz, err := db.Get([]byte(latestVersionKey))
|
||||
if err != nil {
|
||||
panic(err)
|
||||
} else if latestBytes == nil {
|
||||
} else if bz == nil {
|
||||
return 0
|
||||
}
|
||||
|
||||
err = cdc.UnmarshalBinaryBare(latestBytes, &latest)
|
||||
if err != nil {
|
||||
var latestVersion int64
|
||||
|
||||
if err := gogotypes.StdInt64Unmarshal(&latestVersion, bz); err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
return latest
|
||||
return latestVersion
|
||||
}
|
||||
|
||||
// Commits each store and returns a new commitInfo.
|
||||
func commitStores(version int64, storeMap map[types.StoreKey]types.CommitKVStore) commitInfo {
|
||||
storeInfos := make([]storeInfo, 0, len(storeMap))
|
||||
func commitStores(version int64, storeMap map[types.StoreKey]types.CommitKVStore) *types.CommitInfo {
|
||||
storeInfos := make([]types.StoreInfo, 0, len(storeMap))
|
||||
|
||||
for key, store := range storeMap {
|
||||
commitID := store.Commit()
|
||||
|
@ -705,52 +605,64 @@ func commitStores(version int64, storeMap map[types.StoreKey]types.CommitKVStore
|
|||
continue
|
||||
}
|
||||
|
||||
si := storeInfo{}
|
||||
si := types.StoreInfo{}
|
||||
si.Name = key.Name()
|
||||
si.Core.CommitID = commitID
|
||||
si.CommitID = commitID
|
||||
storeInfos = append(storeInfos, si)
|
||||
}
|
||||
|
||||
return commitInfo{
|
||||
return &types.CommitInfo{
|
||||
Version: version,
|
||||
StoreInfos: storeInfos,
|
||||
}
|
||||
}
|
||||
|
||||
// Gets commitInfo from disk.
|
||||
func getCommitInfo(db dbm.DB, ver int64) (commitInfo, error) {
|
||||
func getCommitInfo(db dbm.DB, ver int64) (*types.CommitInfo, error) {
|
||||
cInfoKey := fmt.Sprintf(commitInfoKeyFmt, ver)
|
||||
|
||||
cInfoBytes, err := db.Get([]byte(cInfoKey))
|
||||
bz, err := db.Get([]byte(cInfoKey))
|
||||
if err != nil {
|
||||
return commitInfo{}, errors.Wrap(err, "failed to get commit info")
|
||||
} else if cInfoBytes == nil {
|
||||
return commitInfo{}, errors.New("failed to get commit info: no data")
|
||||
return nil, errors.Wrap(err, "failed to get commit info")
|
||||
} else if bz == nil {
|
||||
return nil, errors.New("no commit info found")
|
||||
}
|
||||
|
||||
var cInfo commitInfo
|
||||
|
||||
err = cdc.UnmarshalBinaryBare(cInfoBytes, &cInfo)
|
||||
if err != nil {
|
||||
return commitInfo{}, errors.Wrap(err, "failed to get store")
|
||||
cInfo := &types.CommitInfo{}
|
||||
if err = cInfo.Unmarshal(bz); err != nil {
|
||||
return nil, errors.Wrap(err, "failed unmarshal commit info")
|
||||
}
|
||||
|
||||
return cInfo, nil
|
||||
}
|
||||
|
||||
func setCommitInfo(batch dbm.Batch, version int64, cInfo commitInfo) {
|
||||
cInfoBytes := cdc.MustMarshalBinaryBare(cInfo)
|
||||
func setCommitInfo(batch dbm.Batch, version int64, cInfo *types.CommitInfo) {
|
||||
bz, err := cInfo.Marshal()
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
cInfoKey := fmt.Sprintf(commitInfoKeyFmt, version)
|
||||
batch.Set([]byte(cInfoKey), cInfoBytes)
|
||||
batch.Set([]byte(cInfoKey), bz)
|
||||
}
|
||||
|
||||
func setLatestVersion(batch dbm.Batch, version int64) {
|
||||
latestBytes := cdc.MustMarshalBinaryBare(version)
|
||||
batch.Set([]byte(latestVersionKey), latestBytes)
|
||||
bz, err := gogotypes.StdInt64Marshal(version)
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
|
||||
batch.Set([]byte(latestVersionKey), bz)
|
||||
}
|
||||
|
||||
func setPruningHeights(batch dbm.Batch, pruneHeights []int64) {
|
||||
bz := cdc.MustMarshalBinaryBare(pruneHeights)
|
||||
bz := make([]byte, 0)
|
||||
for _, ph := range pruneHeights {
|
||||
buf := make([]byte, 8)
|
||||
binary.BigEndian.PutUint64(buf, uint64(ph))
|
||||
bz = append(bz, buf...)
|
||||
}
|
||||
|
||||
batch.Set([]byte(pruneHeightsKey), bz)
|
||||
}
|
||||
|
||||
|
@ -763,15 +675,18 @@ func getPruningHeights(db dbm.DB) ([]int64, error) {
|
|||
return nil, errors.New("no pruned heights found")
|
||||
}
|
||||
|
||||
var prunedHeights []int64
|
||||
if err := cdc.UnmarshalBinaryBare(bz, &prunedHeights); err != nil {
|
||||
return nil, fmt.Errorf("failed to unmarshal pruned heights: %w", err)
|
||||
prunedHeights := make([]int64, len(bz)/8)
|
||||
i, offset := 0, 0
|
||||
for offset < len(bz) {
|
||||
prunedHeights[i] = int64(binary.BigEndian.Uint64(bz[offset : offset+8]))
|
||||
i++
|
||||
offset += 8
|
||||
}
|
||||
|
||||
return prunedHeights, nil
|
||||
}
|
||||
|
||||
func flushMetadata(db dbm.DB, version int64, cInfo commitInfo, pruneHeights []int64) {
|
||||
func flushMetadata(db dbm.DB, version int64, cInfo *types.CommitInfo, pruneHeights []int64) {
|
||||
batch := db.NewBatch()
|
||||
defer batch.Close()
|
||||
|
||||
|
|
|
@ -9,7 +9,7 @@ import (
|
|||
dbm "github.com/tendermint/tm-db"
|
||||
|
||||
"github.com/cosmos/cosmos-sdk/store/iavl"
|
||||
sdkmaps "github.com/cosmos/cosmos-sdk/store/rootmulti/internal/maps"
|
||||
sdkmaps "github.com/cosmos/cosmos-sdk/store/internal/maps"
|
||||
"github.com/cosmos/cosmos-sdk/store/types"
|
||||
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
||||
)
|
||||
|
@ -557,7 +557,7 @@ func checkStore(t *testing.T, store *Store, expect, got types.CommitID) {
|
|||
|
||||
}
|
||||
|
||||
func checkContains(t testing.TB, info []storeInfo, wanted []string) {
|
||||
func checkContains(t testing.TB, info []types.StoreInfo, wanted []string) {
|
||||
t.Helper()
|
||||
|
||||
for _, want := range wanted {
|
||||
|
@ -565,7 +565,7 @@ func checkContains(t testing.TB, info []storeInfo, wanted []string) {
|
|||
}
|
||||
}
|
||||
|
||||
func checkHas(t testing.TB, info []storeInfo, want string) {
|
||||
func checkHas(t testing.TB, info []types.StoreInfo, want string) {
|
||||
t.Helper()
|
||||
for _, i := range info {
|
||||
if i.Name == want {
|
||||
|
@ -586,12 +586,9 @@ func hashStores(stores map[types.StoreKey]types.CommitKVStore) []byte {
|
|||
m := make(map[string][]byte, len(stores))
|
||||
for key, store := range stores {
|
||||
name := key.Name()
|
||||
m[name] = storeInfo{
|
||||
m[name] = types.StoreInfo{
|
||||
Name: name,
|
||||
Core: storeCore{
|
||||
CommitID: store.LastCommitID(),
|
||||
// StoreType: store.GetStoreType(),
|
||||
},
|
||||
}.GetHash()
|
||||
}
|
||||
return sdkmaps.SimpleHashFromMap(m)
|
||||
|
|
|
@ -0,0 +1,73 @@
|
|||
package types
|
||||
|
||||
import (
|
||||
fmt "fmt"
|
||||
|
||||
ics23 "github.com/confio/ics23/go"
|
||||
"github.com/tendermint/tendermint/crypto/merkle"
|
||||
|
||||
sdkmaps "github.com/cosmos/cosmos-sdk/store/internal/maps"
|
||||
sdkproofs "github.com/cosmos/cosmos-sdk/store/internal/proofs"
|
||||
)
|
||||
|
||||
// GetHash returns the GetHash from the CommitID.
|
||||
// This is used in CommitInfo.Hash()
|
||||
//
|
||||
// When we commit to this in a merkle proof, we create a map of storeInfo.Name -> storeInfo.GetHash()
|
||||
// and build a merkle proof from that.
|
||||
// This is then chained with the substore proof, so we prove the root hash from the substore before this
|
||||
// and need to pass that (unmodified) as the leaf value of the multistore proof.
|
||||
func (si StoreInfo) GetHash() []byte {
|
||||
return si.CommitID.Hash
|
||||
}
|
||||
|
||||
func (ci CommitInfo) toMap() map[string][]byte {
|
||||
m := make(map[string][]byte, len(ci.StoreInfos))
|
||||
for _, storeInfo := range ci.StoreInfos {
|
||||
m[storeInfo.Name] = storeInfo.GetHash()
|
||||
}
|
||||
|
||||
return m
|
||||
}
|
||||
|
||||
// Hash returns the simple merkle root hash of the stores sorted by name.
|
||||
func (ci CommitInfo) Hash() []byte {
|
||||
// we need a special case for empty set, as SimpleProofsFromMap requires at least one entry
|
||||
if len(ci.StoreInfos) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
rootHash, _, _ := sdkmaps.SimpleProofsFromMap(ci.toMap())
|
||||
return rootHash
|
||||
}
|
||||
|
||||
func (ci CommitInfo) ProofOp(storeName string) merkle.ProofOp {
|
||||
cmap := ci.toMap()
|
||||
_, proofs, _ := sdkmaps.SimpleProofsFromMap(cmap)
|
||||
|
||||
proof := proofs[storeName]
|
||||
if proof == nil {
|
||||
panic(fmt.Sprintf("ProofOp for %s but not registered store name", storeName))
|
||||
}
|
||||
|
||||
// convert merkle.SimpleProof to CommitmentProof
|
||||
existProof, err := sdkproofs.ConvertExistenceProof(proof, []byte(storeName), cmap[storeName])
|
||||
if err != nil {
|
||||
panic(fmt.Errorf("could not convert simple proof to existence proof: %w", err))
|
||||
}
|
||||
|
||||
commitmentProof := &ics23.CommitmentProof{
|
||||
Proof: &ics23.CommitmentProof_Exist{
|
||||
Exist: existProof,
|
||||
},
|
||||
}
|
||||
|
||||
return NewSimpleMerkleCommitmentOp([]byte(storeName), commitmentProof).ProofOp()
|
||||
}
|
||||
|
||||
func (ci CommitInfo) CommitID() CommitID {
|
||||
return CommitID{
|
||||
Version: ci.Version,
|
||||
Hash: ci.Hash(),
|
||||
}
|
||||
}
|
|
@ -0,0 +1,814 @@
|
|||
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
||||
// source: cosmos/store/commit_info.proto
|
||||
|
||||
package types
|
||||
|
||||
import (
|
||||
fmt "fmt"
|
||||
_ "github.com/gogo/protobuf/gogoproto"
|
||||
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
|
||||
|
||||
// CommitInfo defines commit information used by the multi-store when committing
|
||||
// a version/height.
|
||||
type CommitInfo struct {
|
||||
Version int64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
|
||||
StoreInfos []StoreInfo `protobuf:"bytes,2,rep,name=store_infos,json=storeInfos,proto3" json:"store_infos"`
|
||||
}
|
||||
|
||||
func (m *CommitInfo) Reset() { *m = CommitInfo{} }
|
||||
func (m *CommitInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*CommitInfo) ProtoMessage() {}
|
||||
func (*CommitInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_3e3b3900c32110a1, []int{0}
|
||||
}
|
||||
func (m *CommitInfo) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *CommitInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_CommitInfo.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 *CommitInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_CommitInfo.Merge(m, src)
|
||||
}
|
||||
func (m *CommitInfo) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *CommitInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_CommitInfo.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_CommitInfo proto.InternalMessageInfo
|
||||
|
||||
func (m *CommitInfo) GetVersion() int64 {
|
||||
if m != nil {
|
||||
return m.Version
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *CommitInfo) GetStoreInfos() []StoreInfo {
|
||||
if m != nil {
|
||||
return m.StoreInfos
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// StoreInfo defines store-specific commit information. It contains a reference
|
||||
// between a store name and the commit ID.
|
||||
type StoreInfo struct {
|
||||
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
|
||||
CommitID CommitID `protobuf:"bytes,2,opt,name=commit_id,json=commitId,proto3" json:"commit_id"`
|
||||
}
|
||||
|
||||
func (m *StoreInfo) Reset() { *m = StoreInfo{} }
|
||||
func (m *StoreInfo) String() string { return proto.CompactTextString(m) }
|
||||
func (*StoreInfo) ProtoMessage() {}
|
||||
func (*StoreInfo) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_3e3b3900c32110a1, []int{1}
|
||||
}
|
||||
func (m *StoreInfo) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *StoreInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_StoreInfo.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 *StoreInfo) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_StoreInfo.Merge(m, src)
|
||||
}
|
||||
func (m *StoreInfo) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *StoreInfo) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_StoreInfo.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_StoreInfo proto.InternalMessageInfo
|
||||
|
||||
func (m *StoreInfo) GetName() string {
|
||||
if m != nil {
|
||||
return m.Name
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (m *StoreInfo) GetCommitID() CommitID {
|
||||
if m != nil {
|
||||
return m.CommitID
|
||||
}
|
||||
return CommitID{}
|
||||
}
|
||||
|
||||
// CommitID defines the committment information when a specific store is
|
||||
// committed.
|
||||
type CommitID struct {
|
||||
Version int64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
|
||||
Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
|
||||
}
|
||||
|
||||
func (m *CommitID) Reset() { *m = CommitID{} }
|
||||
func (*CommitID) ProtoMessage() {}
|
||||
func (*CommitID) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_3e3b3900c32110a1, []int{2}
|
||||
}
|
||||
func (m *CommitID) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *CommitID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_CommitID.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 *CommitID) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_CommitID.Merge(m, src)
|
||||
}
|
||||
func (m *CommitID) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *CommitID) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_CommitID.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_CommitID proto.InternalMessageInfo
|
||||
|
||||
func (m *CommitID) GetVersion() int64 {
|
||||
if m != nil {
|
||||
return m.Version
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (m *CommitID) GetHash() []byte {
|
||||
if m != nil {
|
||||
return m.Hash
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func init() {
|
||||
proto.RegisterType((*CommitInfo)(nil), "cosmos.store.CommitInfo")
|
||||
proto.RegisterType((*StoreInfo)(nil), "cosmos.store.StoreInfo")
|
||||
proto.RegisterType((*CommitID)(nil), "cosmos.store.CommitID")
|
||||
}
|
||||
|
||||
func init() { proto.RegisterFile("cosmos/store/commit_info.proto", fileDescriptor_3e3b3900c32110a1) }
|
||||
|
||||
var fileDescriptor_3e3b3900c32110a1 = []byte{
|
||||
// 289 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xce, 0x2f, 0xce,
|
||||
0xcd, 0x2f, 0xd6, 0x2f, 0x2e, 0xc9, 0x2f, 0x4a, 0xd5, 0x4f, 0xce, 0xcf, 0xcd, 0xcd, 0x2c, 0x89,
|
||||
0xcf, 0xcc, 0x4b, 0xcb, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x81, 0xc8, 0xeb, 0x81,
|
||||
0xe5, 0xa5, 0x44, 0xd2, 0xf3, 0xd3, 0xf3, 0xc1, 0x12, 0xfa, 0x20, 0x16, 0x44, 0x8d, 0x52, 0x1a,
|
||||
0x17, 0x97, 0x33, 0x58, 0xa3, 0x67, 0x5e, 0x5a, 0xbe, 0x90, 0x04, 0x17, 0x7b, 0x59, 0x6a, 0x51,
|
||||
0x71, 0x66, 0x7e, 0x9e, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x73, 0x10, 0x8c, 0x2b, 0x64, 0xc7, 0xc5,
|
||||
0x0d, 0x36, 0x06, 0x6c, 0x7e, 0xb1, 0x04, 0x93, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0xb8, 0x1e, 0xb2,
|
||||
0x0d, 0x7a, 0xc1, 0x20, 0x12, 0x64, 0x8e, 0x13, 0xcb, 0x89, 0x7b, 0xf2, 0x0c, 0x41, 0x5c, 0xc5,
|
||||
0x30, 0x81, 0x62, 0xa5, 0x34, 0x2e, 0x4e, 0xb8, 0xb4, 0x90, 0x10, 0x17, 0x4b, 0x5e, 0x62, 0x6e,
|
||||
0x2a, 0xd8, 0x0e, 0xce, 0x20, 0x30, 0x5b, 0xc8, 0x95, 0x8b, 0x13, 0xe6, 0x83, 0x14, 0x09, 0x26,
|
||||
0x05, 0x46, 0x0d, 0x6e, 0x23, 0x31, 0x54, 0xe3, 0xa1, 0xee, 0x74, 0x71, 0x12, 0x00, 0x99, 0xfe,
|
||||
0xe8, 0x9e, 0x3c, 0x07, 0x4c, 0x24, 0x88, 0x03, 0xa2, 0xd5, 0x33, 0x45, 0xc9, 0x8e, 0x0b, 0x2e,
|
||||
0x8a, 0xc7, 0x37, 0x42, 0x5c, 0x2c, 0x19, 0x89, 0xc5, 0x19, 0x60, 0x7b, 0x78, 0x82, 0xc0, 0x6c,
|
||||
0x2b, 0x96, 0x19, 0x0b, 0xe4, 0x19, 0x9c, 0x9c, 0x4e, 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, 0x4a, 0x23, 0x3d, 0xb3, 0x24, 0xa3, 0x34, 0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0x1a,
|
||||
0xf0, 0x10, 0x4a, 0xb7, 0x38, 0x25, 0x1b, 0x1a, 0x07, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x49, 0x6c,
|
||||
0xe0, 0xa0, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff, 0xff, 0x2f, 0x20, 0xcc, 0x8d, 0xa0, 0x01, 0x00,
|
||||
0x00,
|
||||
}
|
||||
|
||||
func (m *CommitInfo) 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 *CommitInfo) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *CommitInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
_ = l
|
||||
if len(m.StoreInfos) > 0 {
|
||||
for iNdEx := len(m.StoreInfos) - 1; iNdEx >= 0; iNdEx-- {
|
||||
{
|
||||
size, err := m.StoreInfos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
i -= size
|
||||
i = encodeVarintCommitInfo(dAtA, i, uint64(size))
|
||||
}
|
||||
i--
|
||||
dAtA[i] = 0x12
|
||||
}
|
||||
}
|
||||
if m.Version != 0 {
|
||||
i = encodeVarintCommitInfo(dAtA, i, uint64(m.Version))
|
||||
i--
|
||||
dAtA[i] = 0x8
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *StoreInfo) 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 *StoreInfo) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *StoreInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
_ = l
|
||||
{
|
||||
size, err := m.CommitID.MarshalToSizedBuffer(dAtA[:i])
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
i -= size
|
||||
i = encodeVarintCommitInfo(dAtA, i, uint64(size))
|
||||
}
|
||||
i--
|
||||
dAtA[i] = 0x12
|
||||
if len(m.Name) > 0 {
|
||||
i -= len(m.Name)
|
||||
copy(dAtA[i:], m.Name)
|
||||
i = encodeVarintCommitInfo(dAtA, i, uint64(len(m.Name)))
|
||||
i--
|
||||
dAtA[i] = 0xa
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *CommitID) 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 *CommitID) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *CommitID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
_ = l
|
||||
if len(m.Hash) > 0 {
|
||||
i -= len(m.Hash)
|
||||
copy(dAtA[i:], m.Hash)
|
||||
i = encodeVarintCommitInfo(dAtA, i, uint64(len(m.Hash)))
|
||||
i--
|
||||
dAtA[i] = 0x12
|
||||
}
|
||||
if m.Version != 0 {
|
||||
i = encodeVarintCommitInfo(dAtA, i, uint64(m.Version))
|
||||
i--
|
||||
dAtA[i] = 0x8
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func encodeVarintCommitInfo(dAtA []byte, offset int, v uint64) int {
|
||||
offset -= sovCommitInfo(v)
|
||||
base := offset
|
||||
for v >= 1<<7 {
|
||||
dAtA[offset] = uint8(v&0x7f | 0x80)
|
||||
v >>= 7
|
||||
offset++
|
||||
}
|
||||
dAtA[offset] = uint8(v)
|
||||
return base
|
||||
}
|
||||
func (m *CommitInfo) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
var l int
|
||||
_ = l
|
||||
if m.Version != 0 {
|
||||
n += 1 + sovCommitInfo(uint64(m.Version))
|
||||
}
|
||||
if len(m.StoreInfos) > 0 {
|
||||
for _, e := range m.StoreInfos {
|
||||
l = e.Size()
|
||||
n += 1 + l + sovCommitInfo(uint64(l))
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *StoreInfo) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
var l int
|
||||
_ = l
|
||||
l = len(m.Name)
|
||||
if l > 0 {
|
||||
n += 1 + l + sovCommitInfo(uint64(l))
|
||||
}
|
||||
l = m.CommitID.Size()
|
||||
n += 1 + l + sovCommitInfo(uint64(l))
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *CommitID) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
var l int
|
||||
_ = l
|
||||
if m.Version != 0 {
|
||||
n += 1 + sovCommitInfo(uint64(m.Version))
|
||||
}
|
||||
l = len(m.Hash)
|
||||
if l > 0 {
|
||||
n += 1 + l + sovCommitInfo(uint64(l))
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func sovCommitInfo(x uint64) (n int) {
|
||||
return (math_bits.Len64(x|1) + 6) / 7
|
||||
}
|
||||
func sozCommitInfo(x uint64) (n int) {
|
||||
return sovCommitInfo(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
||||
}
|
||||
func (m *CommitInfo) 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 ErrIntOverflowCommitInfo
|
||||
}
|
||||
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: CommitInfo: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: CommitInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
if wireType != 0 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
|
||||
}
|
||||
m.Version = 0
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowCommitInfo
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
m.Version |= int64(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
case 2:
|
||||
if wireType != 2 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field StoreInfos", wireType)
|
||||
}
|
||||
var msglen int
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowCommitInfo
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
msglen |= int(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
if msglen < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
postIndex := iNdEx + msglen
|
||||
if postIndex < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
m.StoreInfos = append(m.StoreInfos, StoreInfo{})
|
||||
if err := m.StoreInfos[len(m.StoreInfos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
iNdEx = postIndex
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
skippy, err := skipCommitInfo(dAtA[iNdEx:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if skippy < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if (iNdEx + skippy) < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if (iNdEx + skippy) > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
iNdEx += skippy
|
||||
}
|
||||
}
|
||||
|
||||
if iNdEx > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (m *StoreInfo) 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 ErrIntOverflowCommitInfo
|
||||
}
|
||||
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: StoreInfo: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: StoreInfo: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
if wireType != 2 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
|
||||
}
|
||||
var stringLen uint64
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowCommitInfo
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
stringLen |= uint64(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
intStringLen := int(stringLen)
|
||||
if intStringLen < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
postIndex := iNdEx + intStringLen
|
||||
if postIndex < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
m.Name = string(dAtA[iNdEx:postIndex])
|
||||
iNdEx = postIndex
|
||||
case 2:
|
||||
if wireType != 2 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field CommitID", wireType)
|
||||
}
|
||||
var msglen int
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowCommitInfo
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
msglen |= int(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
if msglen < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
postIndex := iNdEx + msglen
|
||||
if postIndex < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
if err := m.CommitID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
iNdEx = postIndex
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
skippy, err := skipCommitInfo(dAtA[iNdEx:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if skippy < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if (iNdEx + skippy) < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if (iNdEx + skippy) > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
iNdEx += skippy
|
||||
}
|
||||
}
|
||||
|
||||
if iNdEx > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (m *CommitID) 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 ErrIntOverflowCommitInfo
|
||||
}
|
||||
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: CommitID: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: CommitID: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
if wireType != 0 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
|
||||
}
|
||||
m.Version = 0
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowCommitInfo
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
m.Version |= int64(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
case 2:
|
||||
if wireType != 2 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
|
||||
}
|
||||
var byteLen int
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowCommitInfo
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
byteLen |= int(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
if byteLen < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
postIndex := iNdEx + byteLen
|
||||
if postIndex < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
m.Hash = append(m.Hash[:0], dAtA[iNdEx:postIndex]...)
|
||||
if m.Hash == nil {
|
||||
m.Hash = []byte{}
|
||||
}
|
||||
iNdEx = postIndex
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
skippy, err := skipCommitInfo(dAtA[iNdEx:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if skippy < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if (iNdEx + skippy) < 0 {
|
||||
return ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if (iNdEx + skippy) > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
iNdEx += skippy
|
||||
}
|
||||
}
|
||||
|
||||
if iNdEx > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func skipCommitInfo(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, ErrIntOverflowCommitInfo
|
||||
}
|
||||
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, ErrIntOverflowCommitInfo
|
||||
}
|
||||
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, ErrIntOverflowCommitInfo
|
||||
}
|
||||
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, ErrInvalidLengthCommitInfo
|
||||
}
|
||||
iNdEx += length
|
||||
case 3:
|
||||
depth++
|
||||
case 4:
|
||||
if depth == 0 {
|
||||
return 0, ErrUnexpectedEndOfGroupCommitInfo
|
||||
}
|
||||
depth--
|
||||
case 5:
|
||||
iNdEx += 4
|
||||
default:
|
||||
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
||||
}
|
||||
if iNdEx < 0 {
|
||||
return 0, ErrInvalidLengthCommitInfo
|
||||
}
|
||||
if depth == 0 {
|
||||
return iNdEx, nil
|
||||
}
|
||||
}
|
||||
return 0, io.ErrUnexpectedEOF
|
||||
}
|
||||
|
||||
var (
|
||||
ErrInvalidLengthCommitInfo = fmt.Errorf("proto: negative length found during unmarshaling")
|
||||
ErrIntOverflowCommitInfo = fmt.Errorf("proto: integer overflow")
|
||||
ErrUnexpectedEndOfGroupCommitInfo = fmt.Errorf("proto: unexpected end of group")
|
||||
)
|
|
@ -247,15 +247,6 @@ type CacheWrapper interface {
|
|||
CacheWrapWithTrace(w io.Writer, tc TraceContext) CacheWrap
|
||||
}
|
||||
|
||||
//----------------------------------------
|
||||
// CommitID
|
||||
|
||||
// CommitID contains the tree version number and its merkle root.
|
||||
type CommitID struct {
|
||||
Version int64
|
||||
Hash []byte
|
||||
}
|
||||
|
||||
func (cid CommitID) IsZero() bool {
|
||||
return cid.Version == 0 && len(cid.Hash) == 0
|
||||
}
|
||||
|
|
|
@ -5,32 +5,22 @@ import (
|
|||
"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) Len() int { return len(kvs.Pairs) }
|
||||
func (kvs Pairs) Less(i, j int) bool {
|
||||
switch bytes.Compare(kvs[i].Key, kvs[j].Key) {
|
||||
switch bytes.Compare(kvs.Pairs[i].Key, kvs.Pairs[j].Key) {
|
||||
case -1:
|
||||
return true
|
||||
|
||||
case 0:
|
||||
return bytes.Compare(kvs[i].Value, kvs[j].Value) < 0
|
||||
return bytes.Compare(kvs.Pairs[i].Value, kvs.Pairs[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) Swap(i, j int) { kvs.Pairs[i], kvs.Pairs[j] = kvs.Pairs[j], kvs.Pairs[i] }
|
||||
func (kvs Pairs) Sort() { sort.Sort(kvs) }
|
||||
|
|
|
@ -5,6 +5,7 @@ package kv
|
|||
|
||||
import (
|
||||
fmt "fmt"
|
||||
_ "github.com/gogo/protobuf/gogoproto"
|
||||
proto "github.com/gogo/protobuf/proto"
|
||||
io "io"
|
||||
math "math"
|
||||
|
@ -22,7 +23,52 @@ var _ = math.Inf
|
|||
// proto package needs to be updated.
|
||||
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
|
||||
|
||||
// Key-Value Pair
|
||||
// Pairs defines a repeated slice of Pair objects.
|
||||
type Pairs struct {
|
||||
Pairs []Pair `protobuf:"bytes,1,rep,name=pairs,proto3" json:"pairs"`
|
||||
}
|
||||
|
||||
func (m *Pairs) Reset() { *m = Pairs{} }
|
||||
func (m *Pairs) String() string { return proto.CompactTextString(m) }
|
||||
func (*Pairs) ProtoMessage() {}
|
||||
func (*Pairs) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_23371bd43b515c6e, []int{0}
|
||||
}
|
||||
func (m *Pairs) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *Pairs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_Pairs.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 *Pairs) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_Pairs.Merge(m, src)
|
||||
}
|
||||
func (m *Pairs) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *Pairs) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_Pairs.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_Pairs proto.InternalMessageInfo
|
||||
|
||||
func (m *Pairs) GetPairs() []Pair {
|
||||
if m != nil {
|
||||
return m.Pairs
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Pair defines a key/value bytes tuple.
|
||||
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"`
|
||||
|
@ -32,7 +78,7 @@ 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}
|
||||
return fileDescriptor_23371bd43b515c6e, []int{1}
|
||||
}
|
||||
func (m *Pair) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
|
@ -76,23 +122,64 @@ func (m *Pair) GetValue() []byte {
|
|||
}
|
||||
|
||||
func init() {
|
||||
proto.RegisterType((*Pairs)(nil), "cosmos.kv.Pairs")
|
||||
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
|
||||
// 200 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,
|
||||
0x84, 0x88, 0xe9, 0x65, 0x97, 0x49, 0x89, 0xa4, 0xe7, 0xa7, 0xe7, 0x83, 0x45, 0xf5, 0x41, 0x2c,
|
||||
0x88, 0x02, 0x25, 0x13, 0x2e, 0xd6, 0x80, 0xc4, 0xcc, 0xa2, 0x62, 0x21, 0x6d, 0x2e, 0xd6, 0x02,
|
||||
0x10, 0x43, 0x82, 0x51, 0x81, 0x59, 0x83, 0xdb, 0x88, 0x5f, 0x0f, 0xae, 0x53, 0x0f, 0xa4, 0xc0,
|
||||
0x89, 0xe5, 0xc4, 0x3d, 0x79, 0x86, 0x20, 0x88, 0x1a, 0x25, 0x3d, 0x2e, 0x16, 0x90, 0xa0, 0x90,
|
||||
0x00, 0x17, 0x73, 0x76, 0x6a, 0xa5, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0x4f, 0x10, 0x88, 0x29, 0x24,
|
||||
0xc2, 0xc5, 0x5a, 0x96, 0x98, 0x53, 0x9a, 0x2a, 0xc1, 0x04, 0x16, 0x83, 0x70, 0x9c, 0xec, 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, 0x4a, 0x35, 0x3d, 0xb3, 0x24, 0xa3, 0x34,
|
||||
0x49, 0x2f, 0x39, 0x3f, 0x57, 0x1f, 0xea, 0x7e, 0x08, 0xa5, 0x5b, 0x9c, 0x92, 0xad, 0x5f, 0x52,
|
||||
0x59, 0x90, 0x0a, 0xf2, 0x50, 0x12, 0x1b, 0xd8, 0xb5, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff,
|
||||
0xce, 0x49, 0x74, 0x20, 0xe4, 0x00, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func (m *Pairs) 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 *Pairs) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *Pairs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
_ = l
|
||||
if len(m.Pairs) > 0 {
|
||||
for iNdEx := len(m.Pairs) - 1; iNdEx >= 0; iNdEx-- {
|
||||
{
|
||||
size, err := m.Pairs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
i -= size
|
||||
i = encodeVarintKv(dAtA, i, uint64(size))
|
||||
}
|
||||
i--
|
||||
dAtA[i] = 0xa
|
||||
}
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *Pair) Marshal() (dAtA []byte, err error) {
|
||||
|
@ -143,6 +230,21 @@ func encodeVarintKv(dAtA []byte, offset int, v uint64) int {
|
|||
dAtA[offset] = uint8(v)
|
||||
return base
|
||||
}
|
||||
func (m *Pairs) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
var l int
|
||||
_ = l
|
||||
if len(m.Pairs) > 0 {
|
||||
for _, e := range m.Pairs {
|
||||
l = e.Size()
|
||||
n += 1 + l + sovKv(uint64(l))
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *Pair) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
|
@ -166,6 +268,93 @@ func sovKv(x uint64) (n int) {
|
|||
func sozKv(x uint64) (n int) {
|
||||
return sovKv(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
||||
}
|
||||
func (m *Pairs) 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: Pairs: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: Pairs: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
if wireType != 2 {
|
||||
return fmt.Errorf("proto: wrong wireType = %d for field Pairs", wireType)
|
||||
}
|
||||
var msglen int
|
||||
for shift := uint(0); ; shift += 7 {
|
||||
if shift >= 64 {
|
||||
return ErrIntOverflowKv
|
||||
}
|
||||
if iNdEx >= l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
b := dAtA[iNdEx]
|
||||
iNdEx++
|
||||
msglen |= int(b&0x7F) << shift
|
||||
if b < 0x80 {
|
||||
break
|
||||
}
|
||||
}
|
||||
if msglen < 0 {
|
||||
return ErrInvalidLengthKv
|
||||
}
|
||||
postIndex := iNdEx + msglen
|
||||
if postIndex < 0 {
|
||||
return ErrInvalidLengthKv
|
||||
}
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
m.Pairs = append(m.Pairs, Pair{})
|
||||
if err := m.Pairs[len(m.Pairs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
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 (m *Pair) Unmarshal(dAtA []byte) error {
|
||||
l := len(dAtA)
|
||||
iNdEx := 0
|
||||
|
|
|
@ -32,18 +32,20 @@ func TestDecodeStore(t *testing.T) {
|
|||
globalAccNumber := gogotypes.UInt64Value{Value: 10}
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: types.AddressStoreKey(delAddr1),
|
||||
Value: accBz,
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: types.GlobalAccountNumberKey,
|
||||
Value: cdc.MustMarshalBinaryBare(&globalAccNumber),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -59,9 +61,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -23,8 +23,10 @@ func TestDecodeStore(t *testing.T) {
|
|||
require.NoError(t, err)
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{Key: types.SupplyKey, Value: supplyBz},
|
||||
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
Pairs: []kv.Pair{
|
||||
{Key: types.SupplyKey, Value: supplyBz},
|
||||
{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
},
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
|
@ -40,9 +42,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -22,18 +22,20 @@ func TestDecodeStore(t *testing.T) {
|
|||
}
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: types.KeyIndex,
|
||||
Value: sdk.Uint64ToBigEndian(10),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: types.KeyPrefixIndexCapability,
|
||||
Value: cdc.MustMarshalBinaryBare(&capOwners),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -49,9 +51,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -36,16 +36,18 @@ func TestDecodeDistributionStore(t *testing.T) {
|
|||
slashEvent := types.NewValidatorSlashEvent(10, sdk.OneDec())
|
||||
|
||||
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(¤tRewards)},
|
||||
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}},
|
||||
Pairs: []kv.Pair{
|
||||
{Key: types.FeePoolKey, Value: cdc.MustMarshalBinaryBare(&feePool)},
|
||||
{Key: types.ProposerKey, Value: consAddr1.Bytes()},
|
||||
{Key: types.GetValidatorOutstandingRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&outstanding)},
|
||||
{Key: types.GetDelegatorWithdrawAddrKey(delAddr1), Value: delAddr1.Bytes()},
|
||||
{Key: types.GetDelegatorStartingInfoKey(valAddr1, delAddr1), Value: cdc.MustMarshalBinaryBare(&info)},
|
||||
{Key: types.GetValidatorHistoricalRewardsKey(valAddr1, 100), Value: cdc.MustMarshalBinaryBare(&historicalRewards)},
|
||||
{Key: types.GetValidatorCurrentRewardsKey(valAddr1), Value: cdc.MustMarshalBinaryBare(¤tRewards)},
|
||||
{Key: types.GetValidatorAccumulatedCommissionKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&commission)},
|
||||
{Key: types.GetValidatorSlashEventKeyPrefix(valAddr1, 13), Value: cdc.MustMarshalBinaryBare(&slashEvent)},
|
||||
{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
},
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
|
@ -68,9 +70,9 @@ func TestDecodeDistributionStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -32,14 +32,16 @@ func TestDecodeStore(t *testing.T) {
|
|||
require.NoError(t, err)
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: types.KeyPrefixEvidence,
|
||||
Value: evBz,
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -54,9 +56,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -40,11 +40,13 @@ func TestDecodeStore(t *testing.T) {
|
|||
require.NoError(t, err)
|
||||
|
||||
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}},
|
||||
Pairs: []kv.Pair{
|
||||
{Key: types.ProposalKey(1), Value: proposalBz},
|
||||
{Key: types.InactiveProposalQueueKey(1, endTime), Value: proposalIDBz},
|
||||
{Key: types.DepositKey(1, delAddr1), Value: cdc.MustMarshalBinaryBare(&deposit)},
|
||||
{Key: types.VoteKey(1, delAddr1), Value: cdc.MustMarshalBinaryBare(&vote)},
|
||||
{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
},
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
|
@ -63,9 +65,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -29,22 +29,24 @@ func TestDecodeStore(t *testing.T) {
|
|||
}
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: host.FullKeyClientPath(clientID, host.KeyClientState()),
|
||||
Value: app.IBCKeeper.ClientKeeper.MustMarshalClientState(clientState),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.FullKeyClientPath(clientID, host.KeyClientType()),
|
||||
Value: []byte(exported.Tendermint.String()),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.FullKeyClientPath(clientID, host.KeyConsensusState(10)),
|
||||
Value: app.IBCKeeper.ClientKeeper.MustMarshalConsensusState(consState),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -59,13 +61,13 @@ func TestDecodeStore(t *testing.T) {
|
|||
for i, tt := range tests {
|
||||
i, tt := i, tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
res, found := simulation.NewDecodeStore(app.IBCKeeper.ClientKeeper, kvPairs[i], kvPairs[i])
|
||||
res, found := simulation.NewDecodeStore(app.IBCKeeper.ClientKeeper, kvPairs.Pairs[i], kvPairs.Pairs[i])
|
||||
if i == len(tests)-1 {
|
||||
require.False(t, found, string(kvPairs[i].Key))
|
||||
require.Empty(t, res, string(kvPairs[i].Key))
|
||||
require.False(t, found, string(kvPairs.Pairs[i].Key))
|
||||
require.Empty(t, res, string(kvPairs.Pairs[i].Key))
|
||||
} else {
|
||||
require.True(t, found, string(kvPairs[i].Key))
|
||||
require.Equal(t, tt.expectedLog, res, string(kvPairs[i].Key))
|
||||
require.True(t, found, string(kvPairs.Pairs[i].Key))
|
||||
require.Equal(t, tt.expectedLog, res, string(kvPairs.Pairs[i].Key))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -29,18 +29,20 @@ func TestDecodeStore(t *testing.T) {
|
|||
}
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: host.KeyClientConnections(connection.ClientID),
|
||||
Value: cdc.MustMarshalBinaryBare(&paths),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyConnection(connectionID),
|
||||
Value: cdc.MustMarshalBinaryBare(&connection),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -54,13 +56,13 @@ func TestDecodeStore(t *testing.T) {
|
|||
for i, tt := range tests {
|
||||
i, tt := i, tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
res, found := simulation.NewDecodeStore(cdc, kvPairs[i], kvPairs[i])
|
||||
res, found := simulation.NewDecodeStore(cdc, kvPairs.Pairs[i], kvPairs.Pairs[i])
|
||||
if i == len(tests)-1 {
|
||||
require.False(t, found, string(kvPairs[i].Key))
|
||||
require.Empty(t, res, string(kvPairs[i].Key))
|
||||
require.False(t, found, string(kvPairs.Pairs[i].Key))
|
||||
require.Empty(t, res, string(kvPairs.Pairs[i].Key))
|
||||
} else {
|
||||
require.True(t, found, string(kvPairs[i].Key))
|
||||
require.Equal(t, tt.expectedLog, res, string(kvPairs[i].Key))
|
||||
require.True(t, found, string(kvPairs.Pairs[i].Key))
|
||||
require.Equal(t, tt.expectedLog, res, string(kvPairs.Pairs[i].Key))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -29,34 +29,36 @@ func TestDecodeStore(t *testing.T) {
|
|||
bz := []byte{0x1, 0x2, 0x3}
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: host.KeyChannel(portID, channelID),
|
||||
Value: cdc.MustMarshalBinaryBare(&channel),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyNextSequenceSend(portID, channelID),
|
||||
Value: sdk.Uint64ToBigEndian(1),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyNextSequenceRecv(portID, channelID),
|
||||
Value: sdk.Uint64ToBigEndian(1),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyNextSequenceAck(portID, channelID),
|
||||
Value: sdk.Uint64ToBigEndian(1),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyPacketCommitment(portID, channelID, 1),
|
||||
Value: bz,
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyPacketAcknowledgement(portID, channelID, 1),
|
||||
Value: bz,
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -74,13 +76,13 @@ func TestDecodeStore(t *testing.T) {
|
|||
for i, tt := range tests {
|
||||
i, tt := i, tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
res, found := simulation.NewDecodeStore(cdc, kvPairs[i], kvPairs[i])
|
||||
res, found := simulation.NewDecodeStore(cdc, kvPairs.Pairs[i], kvPairs.Pairs[i])
|
||||
if i == len(tests)-1 {
|
||||
require.False(t, found, string(kvPairs[i].Key))
|
||||
require.Empty(t, res, string(kvPairs[i].Key))
|
||||
require.False(t, found, string(kvPairs.Pairs[i].Key))
|
||||
require.Empty(t, res, string(kvPairs.Pairs[i].Key))
|
||||
} else {
|
||||
require.True(t, found, string(kvPairs[i].Key))
|
||||
require.Equal(t, tt.expectedLog, res, string(kvPairs[i].Key))
|
||||
require.True(t, found, string(kvPairs.Pairs[i].Key))
|
||||
require.Equal(t, tt.expectedLog, res, string(kvPairs.Pairs[i].Key))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -37,22 +37,24 @@ func TestDecodeStore(t *testing.T) {
|
|||
}
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{
|
||||
Pairs: []kv.Pair{
|
||||
{
|
||||
Key: host.FullKeyClientPath(clientID, host.KeyClientState()),
|
||||
Value: app.IBCKeeper.ClientKeeper.MustMarshalClientState(clientState),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyConnection(connectionID),
|
||||
Value: app.IBCKeeper.Codec().MustMarshalBinaryBare(&connection),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: host.KeyChannel(portID, channelID),
|
||||
Value: app.IBCKeeper.Codec().MustMarshalBinaryBare(&channel),
|
||||
},
|
||||
kv.Pair{
|
||||
{
|
||||
Key: []byte{0x99},
|
||||
Value: []byte{0x99},
|
||||
},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -68,9 +70,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
i, tt := i, tt
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
if i == len(tests)-1 {
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
} else {
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -20,8 +20,10 @@ func TestDecodeStore(t *testing.T) {
|
|||
minter := types.NewMinter(sdk.OneDec(), sdk.NewDec(15))
|
||||
|
||||
kvPairs := kv.Pairs{
|
||||
kv.Pair{Key: types.MinterKey, Value: cdc.MustMarshalBinaryBare(&minter)},
|
||||
kv.Pair{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
Pairs: []kv.Pair{
|
||||
{Key: types.MinterKey, Value: cdc.MustMarshalBinaryBare(&minter)},
|
||||
{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
},
|
||||
}
|
||||
tests := []struct {
|
||||
name string
|
||||
|
@ -36,9 +38,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -33,10 +33,12 @@ func TestDecodeStore(t *testing.T) {
|
|||
missed := gogotypes.BoolValue{Value: true}
|
||||
|
||||
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}},
|
||||
Pairs: []kv.Pair{
|
||||
{Key: types.ValidatorSigningInfoKey(consAddr1), Value: cdc.MustMarshalBinaryBare(&info)},
|
||||
{Key: types.ValidatorMissedBlockBitArrayKey(consAddr1, 6), Value: cdc.MustMarshalBinaryBare(&missed)},
|
||||
{Key: types.AddrPubkeyRelationKey(delAddr1), Value: cdc.MustMarshalBinaryBare(&gogotypes.StringValue{Value: bechPK})},
|
||||
{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
},
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
|
@ -53,9 +55,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
|
@ -43,13 +43,15 @@ func TestDecodeStore(t *testing.T) {
|
|||
red := types.NewRedelegation(delAddr1, valAddr1, valAddr1, 12, bondTime, sdk.OneInt(), sdk.OneDec())
|
||||
|
||||
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}},
|
||||
Pairs: []kv.Pair{
|
||||
{Key: types.LastTotalPowerKey, Value: cdc.MustMarshalBinaryBare(&sdk.IntProto{Int: sdk.OneInt()})},
|
||||
{Key: types.GetValidatorKey(valAddr1), Value: cdc.MustMarshalBinaryBare(&val)},
|
||||
{Key: types.LastValidatorPowerKey, Value: valAddr1.Bytes()},
|
||||
{Key: types.GetDelegationKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&del)},
|
||||
{Key: types.GetUBDKey(delAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&ubd)},
|
||||
{Key: types.GetREDKey(delAddr1, valAddr1, valAddr1), Value: cdc.MustMarshalBinaryBare(&red)},
|
||||
{Key: []byte{0x99}, Value: []byte{0x99}},
|
||||
},
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
|
@ -69,9 +71,9 @@ func TestDecodeStore(t *testing.T) {
|
|||
t.Run(tt.name, func(t *testing.T) {
|
||||
switch i {
|
||||
case len(tests) - 1:
|
||||
require.Panics(t, func() { dec(kvPairs[i], kvPairs[i]) }, tt.name)
|
||||
require.Panics(t, func() { dec(kvPairs.Pairs[i], kvPairs.Pairs[i]) }, tt.name)
|
||||
default:
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs[i], kvPairs[i]), tt.name)
|
||||
require.Equal(t, tt.expectedLog, dec(kvPairs.Pairs[i], kvPairs.Pairs[i]), tt.name)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue