LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

feat(store/v2): build the migration manager in the root store factory (#22336)

Browse Source 
Co-authored-by: marbar3778 <marbar3778@yahoo.com>
Co-authored-by: Marko <marko@baricevic.me>
Co-authored-by: Alex | Interchain Labs <alex@skip.money>
This commit is contained in:
cool-developer 2025-01-13 05:56:48 -05:00 committed by GitHub
parent c79e19dfc9
commit 064c9ba638
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
25 changed files with 4131 additions and 252 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2048
api/cosmos/store/v2/commit_info.pulsar.go Normal file
View File

File diff suppressed because it is too large Load Diff

2
client/grpc/reflection/reflection.pb.go
View File

@ -114,7 +114,7 @@ func (m *ListAllInterfacesResponse) GetInterfaceNames() []string {
// ListImplementationsRequest is the request type of the ListImplementations
// RPC.
type ListImplementationsRequest struct {
// interface_name defines the interface to query the implementations.
// interface_name defines the interface to query the implementations for.
InterfaceName string `protobuf:"bytes,1,opt,name=interface_name,json=interfaceName,proto3" json:"interface_name,omitempty"`
}

34
proto/cosmos/store/v2/commit_info.proto Normal file
View File

@ -0,0 +1,34 @@
syntax = "proto3";
package cosmos.store.v2;
import "gogoproto/gogo.proto";
import "google/protobuf/timestamp.proto";
option go_package = "cosmossdk.io/store/v2/proof";
// CommitInfo defines commit information used by the multi-store when committing
// a version/height.
message CommitInfo {
int64 version = 1;
repeated StoreInfo store_infos = 2;
google.protobuf.Timestamp timestamp = 3 [(gogoproto.nullable) = false, (gogoproto.stdtime) = true];
bytes commit_hash = 4;
}
// 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;
string structure = 3;
}
// CommitID defines the commitment information when a specific store is
// committed.
message CommitID {
option (gogoproto.goproto_stringer) = false;
int64 version = 1;
bytes hash = 2;
}

3
scripts/init-simapp-v2.sh
View File

@ -11,7 +11,6 @@ $SIMD_BIN config set client keyring-backend test
$SIMD_BIN config set client keyring-default-keyname alice
$SIMD_BIN config set app rest.enable true
$SIMD_BIN config set app telemetry.prometheus-retention-time 600
$SIMD_BIN config set app store.options.sc-type iavl-v2
sed -i '' 's/timeout_commit = "5s"/timeout_commit = "1s"/' "$SIMD_HOME"/config/config.toml
sed -i '' 's/prometheus = false/prometheus = true/' "$SIMD_HOME"/config/config.toml
@ -19,7 +18,7 @@ $SIMD_BIN keys add alice --indiscreet
$SIMD_BIN keys add bob --indiscreet
aliases=""
for i in $(seq 10); do
alias=$(dd if=/dev/urandom bs=16 count=24 2> /dev/null | base32 | head -c 32)
alias=$(dd if=/dev/urandom bs=16 count=24 2> /dev/null | base64 | head -c 32)
$SIMD_BIN keys add "$alias" --indiscreet
aliases="$aliases $alias"
done

2
server/v2/cometbft/abci_test.go
View File

@ -913,7 +913,7 @@ func assertStoreLatestVersion(t *testing.T, store types.Store, target uint64) {
require.Equal(t, target, version)
commitInfo, err := store.GetStateCommitment().GetCommitInfo(version)
require.NoError(t, err)
require.Equal(t, target, commitInfo.Version)
require.Equal(t, target, uint64(commitInfo.Version))
}
func TestOptimisticExecution(t *testing.T) {

4
server/v2/cometbft/internal/mock/mock_store.go
View File

@ -37,7 +37,7 @@ func (s *MockStore) GetLatestVersion() (uint64, error) {
return 0, err
}
return lastCommitID.Version, nil
return uint64(lastCommitID.Version), nil
}
func (s *MockStore) StateLatest() (uint64, corestore.ReaderMap, error) {
@ -99,7 +99,7 @@ func (s *MockStore) LastCommitID() (proof.CommitID, error) {
v, err := s.GetStateCommitment().GetLatestVersion()
bz := sha256.Sum256([]byte{})
return proof.CommitID{
Version: v,
Version: int64(v),
Hash: bz[:],
}, err
}

11
server/v2/server.go
View File

@ -101,8 +101,15 @@ func (s *Server[T]) Start(ctx context.Context) error {
}()
}
if err := <-resCh; err != nil {
return fmt.Errorf("failed to start servers: %w", err)
for i := 0; i < len(s.components); i++ {
select {
case err := <-resCh:
if err != nil {
return fmt.Errorf("failed to start servers: %w", err)
}
case <-ctx.Done():
return nil
}
}
<-ctx.Done()

12
simapp/v2/app_config.go
View File

@ -37,8 +37,6 @@ import (
_ "cosmossdk.io/x/bank" // import for side-effects
banktypes "cosmossdk.io/x/bank/types"
_ "cosmossdk.io/x/bank/v2" // import for side-effects
bankv2types "cosmossdk.io/x/bank/v2/types"
bankmodulev2 "cosmossdk.io/x/bank/v2/types/module"
_ "cosmossdk.io/x/circuit" // import for side-effects
circuittypes "cosmossdk.io/x/circuit/types"
_ "cosmossdk.io/x/consensus" // import for side-effects
@ -156,7 +154,7 @@ var (
accounts.ModuleName,
authtypes.ModuleName,
banktypes.ModuleName,
bankv2types.ModuleName,
// bankv2types.ModuleName,
distrtypes.ModuleName,
stakingtypes.ModuleName,
slashingtypes.ModuleName,
@ -297,10 +295,10 @@ var (
Name: epochstypes.ModuleName,
Config: appconfig.WrapAny(&epochsmodulev1.Module{}),
},
{
Name: bankv2types.ModuleName,
Config: appconfig.WrapAny(&bankmodulev2.Module{}),
},
// {
// Name: bankv2types.ModuleName,
// Config: appconfig.WrapAny(&bankmodulev2.Module{}),
// },
},
}
)

21
simapp/v2/simdv2/cmd/testnet.go
View File

@ -26,7 +26,6 @@ import (
"cosmossdk.io/server/v2/cometbft"
"cosmossdk.io/server/v2/store"
banktypes "cosmossdk.io/x/bank/types"
bankv2types "cosmossdk.io/x/bank/v2/types"
stakingtypes "cosmossdk.io/x/staking/types"
"github.com/cosmos/cosmos-sdk/client"
@ -423,13 +422,6 @@ func initGenFiles[T transaction.Tx](
}
appGenState[banktypes.ModuleName] = clientCtx.Codec.MustMarshalJSON(&bankGenState)
var bankV2GenState bankv2types.GenesisState
clientCtx.Codec.MustUnmarshalJSON(appGenState[bankv2types.ModuleName], &bankV2GenState)
if len(bankV2GenState.Balances) == 0 {
bankV2GenState = getBankV2GenesisFromV1(bankGenState)
}
appGenState[bankv2types.ModuleName] = clientCtx.Codec.MustMarshalJSON(&bankV2GenState)
appGenStateJSON, err := json.MarshalIndent(appGenState, "", " ")
if err != nil {
return err
@ -532,16 +524,3 @@ func writeFile(name, dir string, contents []byte) error {
return os.WriteFile(file, contents, 0o600)
}
// getBankV2GenesisFromV1 clones bank/v1 state to bank/v2
// since we not migrate yet
// TODO: Remove
func getBankV2GenesisFromV1(v1GenesisState banktypes.GenesisState) bankv2types.GenesisState {
var v2GenesisState bankv2types.GenesisState
for _, balance := range v1GenesisState.Balances {
v2Balance := bankv2types.Balance(balance)
v2GenesisState.Balances = append(v2GenesisState.Balances, v2Balance)
v2GenesisState.Supply = v2GenesisState.Supply.Add(balance.Coins...)
}
return v2GenesisState
}

13
store/v2/commitment/iavl/exporter.go
View File

@ -38,3 +38,16 @@ func (e *Exporter) Close() error {
return nil
}
// EmptyExporter is a Exporter for an empty tree.
type EmptyExporter struct{}
// Next returns ExportDone.
func (e *EmptyExporter) Next() (*snapshotstypes.SnapshotIAVLItem, error) {
return nil, commitment.ErrorExportDone
}
// Close does nothing.
func (e *EmptyExporter) Close() error {
return nil
}

18
store/v2/commitment/iavl/tree.go
View File

@ -1,6 +1,7 @@
package iavl
import (
"errors"
"fmt"
"github.com/cosmos/iavl"
@ -21,6 +22,8 @@ var (
// IavlTree is a wrapper around iavl.MutableTree.
type IavlTree struct {
tree *iavl.MutableTree
// it is only used for new store key during the migration process.
initialVersion uint64
}
// NewIavlTree creates a new IavlTree instance.
@ -65,6 +68,17 @@ func (t *IavlTree) WorkingHash() []byte {
// LoadVersion loads the state at the given version.
func (t *IavlTree) LoadVersion(version uint64) error {
if t.initialVersion > 0 {
// If the initial version is set and the tree is empty,
// we don't need to load the version.
latestVersion, err := t.tree.GetLatestVersion()
if err != nil {
return err
}
if latestVersion == 0 {
return nil
}
}
_, err := t.tree.LoadVersion(int64(version))
return err
}
@ -150,6 +164,7 @@ func (t *IavlTree) GetLatestVersion() (uint64, error) {
// SetInitialVersion sets the initial version of the database.
func (t *IavlTree) SetInitialVersion(version uint64) error {
t.tree.SetInitialVersion(version)
t.initialVersion = version
return nil
}
@ -169,6 +184,9 @@ func (t *IavlTree) PausePruning(pause bool) {
// Export exports the tree exporter at the given version.
func (t *IavlTree) Export(version uint64) (commitment.Exporter, error) {
if version < t.initialVersion {
return nil, errors.New("version is less than the initial version")
}
tree, err := t.tree.GetImmutable(int64(version))
if err != nil {
return nil, err

53
store/v2/commitment/metadata.go
View File

@ -1,19 +1,20 @@
package commitment
import (
"bytes"
"errors"
"fmt"
gogotypes "github.com/cosmos/gogoproto/types"
corestore "cosmossdk.io/core/store"
"cosmossdk.io/store/v2/internal/encoding"
"cosmossdk.io/store/v2/proof"
)
const (
commitInfoKeyFmt = "c/%d" // c/<version>
latestVersionKey = "c/latest"
removedStoreKeyPrefix = "c/removed/" // c/removed/<version>/<store-name>
commitInfoKeyFmt = "s/%d" // s/<version>
latestVersionKey = "s/latest"
removedStoreKeyPrefix = "s/removed/" // s/removed/<version>/<store-name>
)
// MetadataStore is a store for metadata related to the commitment store.
@ -39,21 +40,20 @@ func (m *MetadataStore) GetLatestVersion() (uint64, error) {
return 0, nil
}
version, _, err := encoding.DecodeUvarint(value)
if err != nil {
var latestVersion int64
if err := gogotypes.StdInt64Unmarshal(&latestVersion, value); err != nil {
return 0, err
}
return version, nil
return uint64(latestVersion), nil
}
func (m *MetadataStore) setLatestVersion(version uint64) error {
var buf bytes.Buffer
buf.Grow(encoding.EncodeUvarintSize(version))
if err := encoding.EncodeUvarint(&buf, version); err != nil {
bz, err := gogotypes.StdInt64Marshal(int64(version)) // convert uint64 to int64 is safe since there will be no overflow or underflow
if err != nil {
return err
}
return m.kv.Set([]byte(latestVersionKey), buf.Bytes())
return m.kv.Set([]byte(latestVersionKey), bz)
}
// GetCommitInfo returns the commit info for the given version.
@ -72,6 +72,10 @@ func (m *MetadataStore) GetCommitInfo(version uint64) (*proof.CommitInfo, error)
return nil, err
}
if err := migrateStoreInfo(cInfo); err != nil {
return nil, err
}
return cInfo, nil
}
@ -94,12 +98,11 @@ func (m *MetadataStore) flushCommitInfo(version uint64, cInfo *proof.CommitInfo)
return err
}
var buf bytes.Buffer
buf.Grow(encoding.EncodeUvarintSize(version))
if err := encoding.EncodeUvarint(&buf, version); err != nil {
bz, err := gogotypes.StdInt64Marshal(int64(version)) // convert uint64 to int64 is safe since there will be no overflow or underflow
if err != nil {
return err
}
if err := batch.Set([]byte(latestVersionKey), buf.Bytes()); err != nil {
if err := batch.Set([]byte(latestVersionKey), bz); err != nil {
return err
}
@ -172,3 +175,23 @@ func (m *MetadataStore) deleteCommitInfo(version uint64) error {
cInfoKey := []byte(fmt.Sprintf(commitInfoKeyFmt, version))
return m.kv.Delete(cInfoKey)
}
// when in migration mode, we need to add new fields to the store info
// this will only be the case for the storev1 to storev2 migration
func migrateStoreInfo(cInfo *proof.CommitInfo) error {
for _, storeInfo := range cInfo.StoreInfos {
if storeInfo.Structure == "" {
storeInfo.Structure = "iavl"
}
}
if cInfo.CommitHash == nil {
commitHash, _, err := cInfo.GetStoreProof([]byte{})
if err != nil {
return err
}
cInfo.CommitHash = commitHash
}
return nil
}

23
store/v2/commitment/store.go
View File

@ -229,7 +229,7 @@ func (c *CommitStore) Commit(version uint64) (*proof.CommitInfo, error) {
if internal.IsMemoryStoreKey(storeKey) {
continue
}
si := &proof.StoreInfo{Name: []byte(storeKey)}
si := &proof.StoreInfo{Name: storeKey}
storeInfos = append(storeInfos, si)
if tree.IsConcurrentSafe() {
@ -248,9 +248,13 @@ func (c *CommitStore) Commit(version uint64) (*proof.CommitInfo, error) {
}
}
// convert storeInfos to []proof.StoreInfo
sideref := make([]*proof.StoreInfo, 0, len(c.multiTrees))
sideref = append(sideref, storeInfos...)
cInfo := &proof.CommitInfo{
Version: version,
StoreInfos: storeInfos,
Version: int64(version),
StoreInfos: sideref,
}
if err := eg.Wait(); err != nil {
@ -272,8 +276,8 @@ func (c *CommitStore) commit(tree Tree, si *proof.StoreInfo, expected uint64) er
if v != expected {
return fmt.Errorf("commit version %d does not match the target version %d", v, expected)
}
si.CommitID = &proof.CommitID{
Version: v,
si.CommitId = &proof.CommitID{
Version: int64(v),
Hash: h,
}
return nil
@ -596,18 +600,17 @@ func (c *CommitStore) GetCommitInfo(version uint64) (*proof.CommitInfo, error) {
if v != version {
return nil, fmt.Errorf("tree version %d does not match the target version %d", v, version)
}
bz := []byte(storeKey)
storeInfos = append(storeInfos, &proof.StoreInfo{
Name: bz,
CommitID: &proof.CommitID{
Version: v,
Name: storeKey,
CommitId: &proof.CommitID{
Version: int64(v),
Hash: tree.Hash(),
},
})
}
ci = &proof.CommitInfo{
Version: version,
Version: int64(version),
StoreInfos: storeInfos,
}
return ci, nil

6
store/v2/commitment/store_test_suite.go
View File

@ -1,9 +1,9 @@
package commitment
import (
"bytes"
"fmt"
"io"
"strings"
"github.com/stretchr/testify/suite"
@ -134,7 +134,7 @@ func (s *CommitStoreTestSuite) TestStore_Snapshotter() {
for _, storeInfo := range targetCommitInfo.StoreInfos {
matched := false
for _, latestStoreInfo := range cInfo.StoreInfos {
if bytes.Equal(storeInfo.Name, latestStoreInfo.Name) {
if strings.EqualFold(storeInfo.Name, latestStoreInfo.Name) {
s.Require().Equal(latestStoreInfo.GetHash(), storeInfo.GetHash())
matched = true
}
@ -176,7 +176,7 @@ func (s *CommitStoreTestSuite) TestStore_LoadVersion() {
for i := uint64(1); i <= latestVersion; i++ {
commitInfo, _ := targetStore.GetCommitInfo(i)
s.Require().NotNil(commitInfo)
s.Require().Equal(i, commitInfo.Version)
s.Require().Equal(i, uint64(commitInfo.Version))
}
// rollback to a previous version

2
store/v2/go.mod
View File

@ -20,6 +20,7 @@ require (
github.com/syndtr/goleveldb v1.0.1-0.20220721030215-126854af5e6d
go.uber.org/mock v0.5.0
golang.org/x/sync v0.10.0
google.golang.org/protobuf v1.36.2
)
require (
@ -71,6 +72,5 @@ require (
golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
golang.org/x/sys v0.28.0 // indirect
golang.org/x/text v0.21.0 // indirect
google.golang.org/protobuf v1.36.2 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)

5
store/v2/migration/manager.go
View File

@ -200,11 +200,8 @@ func (m *Manager) Sync() error {
}
// Close closes the manager. It should be called after the migration is done.
// It will close the db and notify the snapshotsManager that the migration is done.
// It will notify the snapshotsManager that the migration is done.
func (m *Manager) Close() error {
if err := m.db.Close(); err != nil {
return fmt.Errorf("failed to close db: %w", err)
}
if m.stateCommitment != nil {
m.snapshotsManager.EndMigration(m.stateCommitment)
}

1
store/v2/migration/manager_test.go
View File

@ -70,7 +70,6 @@ func TestMigrateState(t *testing.T) {
// expecting error for conflicting process, since Migrate trigger snapshotter create migration,
// which start a snapshot process already.
_, err = m.snapshotsManager.Create(toVersion - 1)
fmt.Println(1)
require.Error(t, err)
// check the migrated state

155
store/v2/proof/commit_info.go
View File

@ -1,42 +1,13 @@
package proof
import (
"bytes"
"fmt"
"sort"
"time"
"cosmossdk.io/store/v2/internal/encoding"
)
type (
// CommitInfo defines commit information used by the multi-store when committing
// a version/height.
CommitInfo struct {
Version uint64
StoreInfos []*StoreInfo
Timestamp time.Time
CommitHash []byte
}
// StoreInfo defines store-specific commit information. It contains a reference
// between a store name/key and the commit ID.
StoreInfo struct {
Name []byte
CommitID *CommitID
Structure string
}
// CommitID defines the commitment information when a specific store is
// committed.
CommitID struct {
Version uint64
Hash []byte
}
"strings"
)
func (si StoreInfo) GetHash() []byte {
return si.CommitID.Hash
return si.CommitId.Hash
}
// Hash returns the root hash of all committed stores represented by CommitInfo,
@ -57,8 +28,8 @@ func (ci *CommitInfo) Hash() []byte {
// GetStoreCommitID returns the CommitID for the given store key.
func (ci *CommitInfo) GetStoreCommitID(storeKey []byte) *CommitID {
for _, si := range ci.StoreInfos {
if bytes.Equal(si.Name, storeKey) {
return si.CommitID
if strings.EqualFold(si.Name, string(storeKey)) {
return si.CommitId
}
}
return &CommitID{}
@ -69,7 +40,7 @@ func (ci *CommitInfo) GetStoreCommitID(storeKey []byte) *CommitID {
// store based on lexographical ordering will be proved.
func (ci *CommitInfo) GetStoreProof(storeKey []byte) ([]byte, *CommitmentOp, error) {
sort.Slice(ci.StoreInfos, func(i, j int) bool {
return bytes.Compare(ci.StoreInfos[i].Name, ci.StoreInfos[j].Name) < 0
return strings.Compare(ci.StoreInfos[i].Name, ci.StoreInfos[j].Name) < 0
})
isEmpty := len(storeKey) == 0
@ -77,11 +48,11 @@ func (ci *CommitInfo) GetStoreProof(storeKey []byte) ([]byte, *CommitmentOp, err
leaves := make([][]byte, len(ci.StoreInfos))
for i, si := range ci.StoreInfos {
var err error
leaves[i], err = LeafHash(si.Name, si.GetHash())
leaves[i], err = LeafHash([]byte(si.Name), si.GetHash())
if err != nil {
return nil, nil, err
}
if !isEmpty && bytes.Equal(si.Name, storeKey) {
if !isEmpty && strings.EqualFold(si.Name, string(storeKey)) {
index = i
}
}
@ -99,111 +70,6 @@ func (ci *CommitInfo) GetStoreProof(storeKey []byte) ([]byte, *CommitmentOp, err
return rootHash, &commitmentOp, nil
}
// encodedSize returns the encoded size of CommitInfo for preallocation in Marshal.
func (ci *CommitInfo) encodedSize() int {
size := encoding.EncodeUvarintSize(ci.Version)
size += encoding.EncodeVarintSize(ci.Timestamp.UnixNano())
size += encoding.EncodeUvarintSize(uint64(len(ci.StoreInfos)))
for _, storeInfo := range ci.StoreInfos {
size += encoding.EncodeBytesSize(storeInfo.Name)
size += encoding.EncodeBytesSize(storeInfo.CommitID.Hash)
size += encoding.EncodeBytesSize([]byte(storeInfo.Structure))
}
return size
}
// Marshal returns the encoded byte representation of CommitInfo.
// NOTE: CommitInfo is encoded as follows:
// - version (uvarint)
// - timestamp (varint)
// - number of stores (uvarint)
// - for each store:
// - store name (bytes)
// - store hash (bytes)
// - store commit structure (bytes)
func (ci *CommitInfo) Marshal() ([]byte, error) {
var buf bytes.Buffer
buf.Grow(ci.encodedSize())
if err := encoding.EncodeUvarint(&buf, ci.Version); err != nil {
return nil, err
}
if err := encoding.EncodeVarint(&buf, ci.Timestamp.UnixNano()); err != nil {
return nil, err
}
if err := encoding.EncodeUvarint(&buf, uint64(len(ci.StoreInfos))); err != nil {
return nil, err
}
for _, si := range ci.StoreInfos {
if err := encoding.EncodeBytes(&buf, si.Name); err != nil {
return nil, err
}
if err := encoding.EncodeBytes(&buf, si.CommitID.Hash); err != nil {
return nil, err
}
if err := encoding.EncodeBytes(&buf, []byte(si.Structure)); err != nil {
return nil, err
}
}
return buf.Bytes(), nil
}
// Unmarshal unmarshals the encoded byte representation of CommitInfo.
func (ci *CommitInfo) Unmarshal(buf []byte) error {
// Version
version, n, err := encoding.DecodeUvarint(buf)
if err != nil {
return err
}
buf = buf[n:]
ci.Version = version
// Timestamp
timestamp, n, err := encoding.DecodeVarint(buf)
if err != nil {
return err
}
buf = buf[n:]
ci.Timestamp = time.Unix(timestamp/int64(time.Second), timestamp%int64(time.Second))
// StoreInfos
storeInfosLen, n, err := encoding.DecodeUvarint(buf)
if err != nil {
return err
}
buf = buf[n:]
ci.StoreInfos = make([]*StoreInfo, storeInfosLen)
for i := 0; i < int(storeInfosLen); i++ {
ci.StoreInfos[i] = &StoreInfo{}
// Name
name, n, err := encoding.DecodeBytes(buf)
if err != nil {
return err
}
buf = buf[n:]
ci.StoreInfos[i].Name = name
// CommitID
hash, n, err := encoding.DecodeBytes(buf)
if err != nil {
return err
}
buf = buf[n:]
// Structure
structure, n, err := encoding.DecodeBytes(buf)
if err != nil {
return err
}
buf = buf[n:]
ci.StoreInfos[i].Structure = string(structure)
ci.StoreInfos[i].CommitID = &CommitID{
Hash: hash,
Version: ci.Version,
}
}
return nil
}
func (ci *CommitInfo) CommitID() *CommitID {
return &CommitID{
Version: ci.Version,
@ -211,13 +77,6 @@ func (ci *CommitInfo) CommitID() *CommitID {
}
}
func (ci *CommitInfo) GetVersion() uint64 {
if ci != nil {
return ci.Version
}
return 0
}
func (cid *CommitID) String() string {
return fmt.Sprintf("CommitID{%v:%X}", cid.Hash, cid.Version)
}

975
store/v2/proof/commit_info.pb.go Normal file
View File

@ -0,0 +1,975 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/store/v2/commit_info.proto
package proof
import (
fmt "fmt"
_ "github.com/cosmos/gogoproto/gogoproto"
proto "github.com/cosmos/gogoproto/proto"
github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
_ "google.golang.org/protobuf/types/known/timestamppb"
io "io"
math "math"
math_bits "math/bits"
time "time"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen
// 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,omitempty"`
Timestamp time.Time `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
CommitHash []byte `protobuf:"bytes,4,opt,name=commit_hash,json=commitHash,proto3" json:"commit_hash,omitempty"`
}
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_fae1fdc51331137e, []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
}
func (m *CommitInfo) GetTimestamp() time.Time {
if m != nil {
return m.Timestamp
}
return time.Time{}
}
func (m *CommitInfo) GetCommitHash() []byte {
if m != nil {
return m.CommitHash
}
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,omitempty"`
Structure string `protobuf:"bytes,3,opt,name=structure,proto3" json:"structure,omitempty"`
}
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_fae1fdc51331137e, []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 nil
}
func (m *StoreInfo) GetStructure() string {
if m != nil {
return m.Structure
}
return ""
}
// CommitID defines the commitment 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_fae1fdc51331137e, []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.v2.CommitInfo")
proto.RegisterType((*StoreInfo)(nil), "cosmos.store.v2.StoreInfo")
proto.RegisterType((*CommitID)(nil), "cosmos.store.v2.CommitID")
}
func init() { proto.RegisterFile("cosmos/store/v2/commit_info.proto", fileDescriptor_fae1fdc51331137e) }
var fileDescriptor_fae1fdc51331137e = []byte{
// 355 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0x31, 0x4f, 0xc2, 0x50,
0x10, 0xc7, 0xfb, 0xa0, 0x51, 0x7a, 0x98, 0x98, 0xbc, 0x38, 0x54, 0x34, 0x6d, 0x65, 0x62, 0x7a,
0x4d, 0x30, 0x3a, 0x68, 0xe2, 0x80, 0x0e, 0xb2, 0x56, 0x27, 0x17, 0x53, 0xa0, 0x2d, 0x8d, 0xb6,
0x47, 0xfa, 0x5e, 0xf9, 0x1c, 0x8c, 0x8e, 0x7e, 0x1c, 0x46, 0x46, 0x27, 0x35, 0xf0, 0x45, 0x0c,
0xf7, 0x28, 0x24, 0x9a, 0xb8, 0xfd, 0xdf, 0xf5, 0x7f, 0x77, 0xbf, 0xfb, 0xa7, 0x70, 0x36, 0x44,
0x99, 0xa1, 0xf4, 0xa5, 0xc2, 0x22, 0xf2, 0xa7, 0x5d, 0x7f, 0x88, 0x59, 0x96, 0xaa, 0xe7, 0x34,
0x8f, 0x51, 0x4c, 0x0a, 0x54, 0xc8, 0x0f, 0xb5, 0x45, 0x90, 0x45, 0x4c, 0xbb, 0xad, 0xa3, 0x04,
0x13, 0xa4, 0x6f, 0xfe, 0x5a, 0x69, 0x5b, 0xcb, 0x4d, 0x10, 0x93, 0xd7, 0xc8, 0xa7, 0xd7, 0xa0,
0x8c, 0x7d, 0x95, 0x66, 0x91, 0x54, 0x61, 0x36, 0xd1, 0x86, 0xf6, 0x9c, 0x01, 0xdc, 0xd2, 0xf4,
0x7e, 0x1e, 0x23, 0xb7, 0x61, 0x7f, 0x1a, 0x15, 0x32, 0xc5, 0xdc, 0x66, 0x1e, 0xeb, 0xd4, 0x83,
0xea, 0xc9, 0xaf, 0xa1, 0x49, 0xbb, 0x08, 0x42, 0xda, 0x35, 0xaf, 0xde, 0x69, 0x76, 0x5b, 0xe2,
0x17, 0x86, 0x78, 0x58, 0x8b, 0xf5, 0xa8, 0x00, 0x64, 0x25, 0x25, 0xef, 0x81, 0xb5, 0x5d, 0x6c,
0xd7, 0x3d, 0x46, 0xad, 0x1a, 0x4d, 0x54, 0x68, 0xe2, 0xb1, 0x72, 0xf4, 0x1a, 0xf3, 0x4f, 0xd7,
0x98, 0x7d, 0xb9, 0x2c, 0xd8, 0xb5, 0x71, 0x17, 0x9a, 0x9b, 0x18, 0xc6, 0xa1, 0x1c, 0xdb, 0xa6,
0xc7, 0x3a, 0x07, 0x01, 0xe8, 0xd2, 0x7d, 0x28, 0xc7, 0xed, 0x12, 0xac, 0xed, 0x76, 0xce, 0xc1,
0xcc, 0xc3, 0x2c, 0xa2, 0x2b, 0xac, 0x80, 0x34, 0xbf, 0x04, 0xab, 0x0a, 0x72, 0x64, 0xd7, 0x88,
0xe2, 0xf8, 0xcf, 0x01, 0x9b, 0x30, 0xee, 0x82, 0x86, 0xf6, 0xf6, 0x47, 0xfc, 0x14, 0x2c, 0xa9,
0x8a, 0x72, 0xa8, 0xca, 0x22, 0x22, 0x7a, 0x2b, 0xd8, 0x15, 0xda, 0x37, 0xd0, 0xa8, 0x7a, 0xfe,
0x89, 0x8f, 0x83, 0x49, 0xd8, 0x35, 0xc2, 0x26, 0x7d, 0x65, 0xbe, 0xbd, 0xbb, 0x46, 0xef, 0x62,
0xbe, 0x74, 0xd8, 0x62, 0xe9, 0xb0, 0xef, 0xa5, 0xc3, 0x66, 0x2b, 0xc7, 0x58, 0xac, 0x1c, 0xe3,
0x63, 0xe5, 0x18, 0x4f, 0x27, 0x9a, 0x4d, 0x8e, 0x5e, 0x44, 0x8a, 0xbb, 0x9f, 0x61, 0x52, 0x20,
0xc6, 0x83, 0x3d, 0xca, 0xed, 0xfc, 0x27, 0x00, 0x00, 0xff, 0xff, 0x18, 0xd0, 0x41, 0xbe, 0x2c,
0x02, 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.CommitHash) > 0 {
i -= len(m.CommitHash)
copy(dAtA[i:], m.CommitHash)
i = encodeVarintCommitInfo(dAtA, i, uint64(len(m.CommitHash)))
i--
dAtA[i] = 0x22
}
n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
if err1 != nil {
return 0, err1
}
i -= n1
i = encodeVarintCommitInfo(dAtA, i, uint64(n1))
i--
dAtA[i] = 0x1a
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
if len(m.Structure) > 0 {
i -= len(m.Structure)
copy(dAtA[i:], m.Structure)
i = encodeVarintCommitInfo(dAtA, i, uint64(len(m.Structure)))
i--
dAtA[i] = 0x1a
}
if m.CommitId != nil {
{
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))
}
}
l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
n += 1 + l + sovCommitInfo(uint64(l))
l = len(m.CommitHash)
if l > 0 {
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))
}
if m.CommitId != nil {
l = m.CommitId.Size()
n += 1 + l + sovCommitInfo(uint64(l))
}
l = len(m.Structure)
if l > 0 {
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
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", 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 := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CommitHash", 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.CommitHash = append(m.CommitHash[:0], dAtA[iNdEx:postIndex]...)
if m.CommitHash == nil {
m.CommitHash = []byte{}
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipCommitInfo(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (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 m.CommitId == nil {
m.CommitId = &CommitID{}
}
if err := m.CommitId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Structure", 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.Structure = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipCommitInfo(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (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) || (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")
)

32
store/v2/proof/commit_info_test.go
View File

@ -13,27 +13,27 @@ func TestGetStoreProof(t *testing.T) {
storeInfos []*StoreInfo
}{
{[]*StoreInfo{
{[]byte("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{("key1"), &CommitID{1, []byte("value1")}, "iavl"},
}},
{[]*StoreInfo{
{[]byte("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{[]byte("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{("key1"), &CommitID{1, []byte("value1")}, "iavl"},
}},
{[]*StoreInfo{
{[]byte("key3"), &CommitID{1, []byte("value3")}, "iavl"},
{[]byte("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{[]byte("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{("key3"), &CommitID{1, []byte("value3")}, "iavl"},
{("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{("key1"), &CommitID{1, []byte("value1")}, "iavl"},
}},
{[]*StoreInfo{
{[]byte("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{[]byte("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{[]byte("key3"), &CommitID{1, []byte("value3")}, "iavl"},
{("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{("key3"), &CommitID{1, []byte("value3")}, "iavl"},
}},
{[]*StoreInfo{
{[]byte("key4"), &CommitID{1, []byte("value4")}, "iavl"},
{[]byte("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{[]byte("key3"), &CommitID{1, []byte("value3")}, "iavl"},
{[]byte("key2"), &CommitID{1, []byte("value2")}, "iavl"},
{("key4"), &CommitID{1, []byte("value4")}, "iavl"},
{("key1"), &CommitID{1, []byte("value1")}, "iavl"},
{("key3"), &CommitID{1, []byte("value3")}, "iavl"},
{("key2"), &CommitID{1, []byte("value2")}, "iavl"},
}},
}
@ -47,13 +47,13 @@ func TestGetStoreProof(t *testing.T) {
}
commitHash := ci.Hash()
// make sure the store infos are sorted
require.Equal(t, ci.StoreInfos[0].Name, []byte("key1"))
require.Equal(t, ci.StoreInfos[0].Name, "key1")
for _, si := range tc.storeInfos {
// get the proof
_, proof, err := ci.GetStoreProof(si.Name)
_, proof, err := ci.GetStoreProof([]byte(si.Name))
require.NoError(t, err, "test case %d", i)
// verify the proof
expRoots, err := proof.Run([][]byte{si.CommitID.Hash})
expRoots, err := proof.Run([][]byte{si.CommitId.Hash})
require.NoError(t, err, "test case %d", i)
require.Equal(t, commitHash, expRoots[0], "test case %d", i)

859
store/v2/proof/v1/types/commit_info.pb.go Normal file
View File

@ -0,0 +1,859 @@
// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: cosmos/store/v1beta1/commit_info.proto
package types
import (
fmt "fmt"
_ "github.com/cosmos/gogoproto/gogoproto"
proto "github.com/cosmos/gogoproto/proto"
github_com_cosmos_gogoproto_types "github.com/cosmos/gogoproto/types"
_ "google.golang.org/protobuf/types/known/timestamppb"
io "io"
math "math"
math_bits "math/bits"
time "time"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen
// 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"`
Timestamp time.Time `protobuf:"bytes,3,opt,name=timestamp,proto3,stdtime" json:"timestamp"`
}
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_5f8c656cdef8c524, []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
}
func (m *CommitInfo) GetTimestamp() time.Time {
if m != nil {
return m.Timestamp
}
return time.Time{}
}
// 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_5f8c656cdef8c524, []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 commitment 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 (m *CommitID) String() string {
return fmt.Sprintf("CommitID{%v:%X}", m.Hash, m.Version)
}
func (*CommitID) Descriptor() ([]byte, []int) {
return fileDescriptor_5f8c656cdef8c524, []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
}
var fileDescriptor_5f8c656cdef8c524 = []byte{
// 336 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xb1, 0x4e, 0xf2, 0x50,
0x14, 0xc7, 0x7b, 0xa1, 0xf9, 0x3e, 0x7a, 0x70, 0xba, 0x61, 0x68, 0x18, 0x6e, 0x09, 0x83, 0x61,
0xba, 0x0d, 0xb8, 0x39, 0x98, 0x58, 0x8d, 0x09, 0x6b, 0x75, 0x72, 0x31, 0x2d, 0x5c, 0x4a, 0xa3,
0xed, 0x21, 0xdc, 0x2b, 0x89, 0x6f, 0xc1, 0xe8, 0xe8, 0x33, 0xf8, 0x14, 0x8c, 0x8c, 0x4e, 0x6a,
0xe0, 0x45, 0x4c, 0x4f, 0x5b, 0x5c, 0x88, 0xdb, 0x39, 0xed, 0xef, 0x9c, 0xff, 0xaf, 0xa7, 0x70,
0x3a, 0x41, 0x9d, 0xa1, 0xf6, 0xb5, 0xc1, 0xa5, 0xf2, 0x57, 0xc3, 0x58, 0x99, 0x68, 0xe8, 0x4f,
0x30, 0xcb, 0x52, 0xf3, 0x90, 0xe6, 0x33, 0x94, 0x8b, 0x25, 0x1a, 0xe4, 0x9d, 0x92, 0x93, 0xc4,
0xc9, 0x8a, 0xeb, 0x76, 0x12, 0x4c, 0x90, 0x00, 0xbf, 0xa8, 0x4a, 0xb6, 0xeb, 0x25, 0x88, 0xc9,
0x93, 0xf2, 0xa9, 0x8b, 0x9f, 0x67, 0xbe, 0x49, 0x33, 0xa5, 0x4d, 0x94, 0x2d, 0x4a, 0xa0, 0xff,
0xce, 0x00, 0xae, 0x28, 0x62, 0x9c, 0xcf, 0x90, 0xbb, 0xf0, 0x7f, 0xa5, 0x96, 0x3a, 0xc5, 0xdc,
0x65, 0x3d, 0x36, 0x68, 0x86, 0x75, 0xcb, 0x6f, 0xa0, 0x4d, 0x81, 0x64, 0xa2, 0xdd, 0x46, 0xaf,
0x39, 0x68, 0x8f, 0x3c, 0x79, 0xcc, 0x45, 0xde, 0x16, 0x5d, 0xb1, 0x2f, 0xb0, 0x37, 0x9f, 0x9e,
0x15, 0x82, 0xae, 0x1f, 0x68, 0x1e, 0x80, 0x73, 0x70, 0x70, 0x9b, 0x3d, 0x36, 0x68, 0x8f, 0xba,
0xb2, 0xb4, 0x94, 0xb5, 0xa5, 0xbc, 0xab, 0x89, 0xa0, 0x55, 0x2c, 0x58, 0x7f, 0x79, 0x2c, 0xfc,
0x1d, 0xeb, 0xc7, 0xe0, 0x1c, 0x22, 0x38, 0x07, 0x3b, 0x8f, 0x32, 0x45, 0xbe, 0x4e, 0x48, 0x35,
0xbf, 0x04, 0xa7, 0xbe, 0xdb, 0xd4, 0x6d, 0x50, 0x88, 0x38, 0xae, 0x5a, 0x7d, 0xfb, 0x75, 0x65,
0xda, 0x2a, 0xc7, 0xc6, 0xd3, 0xfe, 0x05, 0xb4, 0xea, 0x77, 0x7f, 0x5c, 0x85, 0x83, 0x3d, 0x8f,
0xf4, 0x9c, 0x32, 0x4e, 0x42, 0xaa, 0xcf, 0xed, 0xd7, 0x37, 0xcf, 0x0a, 0x46, 0x9b, 0x9d, 0x60,
0xdb, 0x9d, 0x60, 0xdf, 0x3b, 0xc1, 0xd6, 0x7b, 0x61, 0x6d, 0xf7, 0xc2, 0xfa, 0xd8, 0x0b, 0xeb,
0xde, 0x2d, 0x45, 0xf4, 0xf4, 0x51, 0xa6, 0x58, 0xfd, 0x6d, 0xf3, 0xb2, 0x50, 0x3a, 0xfe, 0x47,
0x07, 0x38, 0xfb, 0x09, 0x00, 0x00, 0xff, 0xff, 0x67, 0xb7, 0x0d, 0x59, 0x0a, 0x02, 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
n1, err1 := github_com_cosmos_gogoproto_types.StdTimeMarshalTo(m.Timestamp, dAtA[i-github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp):])
if err1 != nil {
return 0, err1
}
i -= n1
i = encodeVarintCommitInfo(dAtA, i, uint64(n1))
i--
dAtA[i] = 0x1a
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))
}
}
l = github_com_cosmos_gogoproto_types.SizeOfStdTime(m.Timestamp)
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
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", 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 := github_com_cosmos_gogoproto_types.StdTimeUnmarshal(&m.Timestamp, 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) || (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) || (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) || (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")
)

63
store/v2/root/factory.go
View File

@ -16,7 +16,9 @@ import (
"cosmossdk.io/store/v2/db"
"cosmossdk.io/store/v2/internal"
"cosmossdk.io/store/v2/metrics"
"cosmossdk.io/store/v2/migration"
"cosmossdk.io/store/v2/pruning"
"cosmossdk.io/store/v2/snapshots"
)
type (
@ -28,6 +30,8 @@ const (
SCTypeIavlV2 SCType = "iavl-v2"
)
const storePrefixTpl = "s/k:%s/" // s/k:<storeKey>
// Options are the options for creating a root store.
type Options struct {
SCType SCType `mapstructure:"sc-type" toml:"sc-type" comment:"State commitment database type. Currently we support: \"iavl\" and \"iavl-v2\""`
@ -86,7 +90,7 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
return nil, fmt.Errorf("tried to construct a root store with no store keys specified but no commit info found for version %d", latestVersion)
}
for _, si := range lastCommitInfo.StoreInfos {
opts.StoreKeys = append(opts.StoreKeys, string(si.Name))
opts.StoreKeys = append(opts.StoreKeys, si.Name)
}
}
removedStoreKeys, err := metadata.GetRemovedStoreKeys(latestVersion)
@ -94,13 +98,13 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
return nil, err
}
newTreeFn := func(key string) (commitment.Tree, error) {
newTreeFn := func(key string, scType SCType) (commitment.Tree, error) {
if internal.IsMemoryStoreKey(key) {
return mem.New(), nil
} else {
switch storeOpts.SCType {
switch scType {
case SCTypeIavl:
return iavl.NewIavlTree(db.NewPrefixDB(opts.SCRawDB, []byte(key)), opts.Logger, storeOpts.IavlConfig), nil
return iavl.NewIavlTree(db.NewPrefixDB(opts.SCRawDB, []byte(fmt.Sprintf(storePrefixTpl, key))), opts.Logger, storeOpts.IavlConfig), nil
case SCTypeIavlV2:
dir := fmt.Sprintf("%s/data/iavl-v2/%s", opts.RootDir, key)
return iavlv2.NewTree(opts.Options.IavlV2Config, iavl_v2.SqliteDbOptions{Path: dir}, opts.Logger)
@ -110,17 +114,37 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
}
}
// check if we need to migrate the store
isMigrating := false
scType := storeOpts.SCType
if scType != SCTypeIavl {
isMigrating = true // need to migrate
scType = SCTypeIavl // only support iavl v1 for migration
}
trees := make(map[string]commitment.Tree, len(opts.StoreKeys))
for _, key := range opts.StoreKeys {
tree, err := newTreeFn(key)
tree, err := newTreeFn(key, scType)
if err != nil {
return nil, err
}
if isMigrating {
v, err := tree.GetLatestVersion()
if err != nil {
return nil, err
}
if v == 0 && latestVersion > 0 {
if err := tree.SetInitialVersion(latestVersion + 1); err != nil {
return nil, err
}
}
}
trees[key] = tree
}
oldTrees := make(map[string]commitment.Tree, len(opts.StoreKeys))
for _, key := range removedStoreKeys {
tree, err := newTreeFn(string(key))
tree, err := newTreeFn(string(key), scType)
if err != nil {
return nil, err
}
@ -132,6 +156,31 @@ func CreateRootStore(opts *FactoryOptions) (store.RootStore, error) {
return nil, err
}
var mm *migration.Manager
if isMigrating {
snapshotDB, err := snapshots.NewStore(fmt.Sprintf("%s/data/snapshots/store.db", opts.RootDir))
if err != nil {
return nil, err
}
snapshotMgr := snapshots.NewManager(snapshotDB, snapshots.SnapshotOptions{}, sc, nil, opts.Logger)
var newSC *commitment.CommitStore
if scType != storeOpts.SCType {
newTrees := make(map[string]commitment.Tree, len(opts.StoreKeys))
for _, key := range opts.StoreKeys {
tree, err := newTreeFn(key, storeOpts.SCType)
if err != nil {
return nil, err
}
newTrees[key] = tree
}
newSC, err = commitment.NewCommitStore(newTrees, nil, opts.SCRawDB, opts.Logger)
if err != nil {
return nil, err
}
}
mm = migration.NewManager(opts.SCRawDB, snapshotMgr, newSC, opts.Logger)
}
pm := pruning.NewManager(sc, storeOpts.SCPruningOption)
return New(opts.SCRawDB, opts.Logger, sc, pm, nil, metrics.NoOpMetrics{})
return New(opts.SCRawDB, opts.Logger, sc, pm, mm, metrics.NoOpMetrics{})
}

17
store/v2/root/factory_test.go
View File

@ -3,8 +3,10 @@ package root
import (
"testing"
gogotypes "github.com/cosmos/gogoproto/types"
"github.com/stretchr/testify/require"
corestore "cosmossdk.io/core/store"
coretesting "cosmossdk.io/core/testing"
"cosmossdk.io/store/v2/db"
)
@ -26,4 +28,19 @@ func TestFactory(t *testing.T) {
f, err = CreateRootStore(&fop)
require.NoError(t, err)
require.NotNil(t, f)
require.NoError(t, setLatestVersion(fop.SCRawDB, 1))
fop.Options.SCType = SCTypeIavl
f, err = CreateRootStore(&fop)
require.NoError(t, err)
require.NotNil(t, f)
require.False(t, f.(*Store).isMigrating)
}
func setLatestVersion(db corestore.KVStoreWithBatch, version int64) error {
bz, err := gogotypes.StdInt64Marshal(version)
if err != nil {
panic(err)
}
return db.Set([]byte("s/latest"), bz)
}

22
store/v2/root/store.go
View File

@ -152,7 +152,7 @@ func (s *Store) LastCommitID() (proof.CommitID, error) {
// if the latest version is 0, we return a CommitID with version 0 and a hash of an empty byte slice
bz := sha256.Sum256([]byte{})
return proof.CommitID{Version: latestVersion, Hash: bz[:]}, nil
return proof.CommitID{Version: int64(latestVersion), Hash: bz[:]}, nil
}
// GetLatestVersion returns the latest version based on the latest internal
@ -164,7 +164,7 @@ func (s *Store) GetLatestVersion() (uint64, error) {
return 0, err
}
return lastCommitID.Version, nil
return uint64(lastCommitID.Version), nil
}
func (s *Store) Query(storeKey []byte, version uint64, key []byte, prove bool) (store.QueryResult, error) {
@ -312,13 +312,13 @@ func (s *Store) Commit(cs *corestore.Changeset) ([]byte, error) {
}
s.logger.Warn(fmt.Sprintf("commit version %d write=%s commit=%s", cs.Version, writeDur, time.Since(st)))
if cInfo.Version != cs.Version {
if cInfo.Version != int64(cs.Version) {
return nil, fmt.Errorf("commit version mismatch: got %d, expected %d", cInfo.Version, cs.Version)
}
s.lastCommitInfo = cInfo
// signal to the pruning manager that the commit is done
if err := s.pruningManager.ResumePruning(s.lastCommitInfo.Version); err != nil {
if err := s.pruningManager.ResumePruning(uint64(s.lastCommitInfo.Version)); err != nil {
s.logger.Error("failed to signal commit done to pruning manager", "err", err)
}
@ -344,7 +344,7 @@ func (s *Store) startMigration() {
version := s.lastCommitInfo.Version
s.logger.Info("starting migration", "version", version)
mtx.Unlock()
if err := s.migrationManager.Start(version, s.chChangeset, s.chDone); err != nil {
if err := s.migrationManager.Start(uint64(version), s.chChangeset, s.chDone); err != nil {
s.logger.Error("failed to start migration", "err", err)
}
}()
@ -358,16 +358,16 @@ func (s *Store) handleMigration(cs *corestore.Changeset) error {
if s.isMigrating {
// if the migration manager has already migrated to the version, close the
// channels and replace the state commitment
if s.migrationManager.GetMigratedVersion() == s.lastCommitInfo.Version {
if s.migrationManager.GetMigratedVersion() == uint64(s.lastCommitInfo.Version) {
close(s.chDone)
close(s.chChangeset)
s.isMigrating = false
// close the old state commitment and replace it with the new one
if err := s.stateCommitment.Close(); err != nil {
return fmt.Errorf("failed to close the old SC store: %w", err)
}
newStateCommitment := s.migrationManager.GetStateCommitment()
if newStateCommitment != nil {
// close the old state commitment and replace it with the new one
if err := s.stateCommitment.Close(); err != nil {
return fmt.Errorf("failed to close the old SC store: %w", err)
}
s.stateCommitment = newStateCommitment
}
if err := s.migrationManager.Close(); err != nil {
@ -376,7 +376,7 @@ func (s *Store) handleMigration(cs *corestore.Changeset) error {
s.logger.Info("migration completed", "version", s.lastCommitInfo.Version)
} else {
// queue the next changeset to the migration manager
s.chChangeset <- &migration.VersionedChangeset{Version: s.lastCommitInfo.Version + 1, Changeset: cs}
s.chChangeset <- &migration.VersionedChangeset{Version: uint64(s.lastCommitInfo.Version + 1), Changeset: cs}
}
}
return nil

2
tests/systemtests/bankv2_test.go
View File

@ -13,6 +13,8 @@ import (
)
func TestBankV2SendTxCmd(t *testing.T) {
// bankv2 was removed from simapp
t.Skip()
// scenario: test bank send command
// given a running chain