feat(store/v2): implement the feature to upgrade the store keys

core/store/upgrade.go

@@ -2,17 +2,8 @@ package store
 
 // StoreUpgrades defines a series of transformations to apply the multistore db upon load
 type StoreUpgrades struct {
-	Added   []string      `json:"added"`
-	Renamed []StoreRename `json:"renamed"`
-	Deleted []string      `json:"deleted"`
-}
-
-// StoreRename defines a name change of a sub-store.
-// All data previously under a PrefixStore with OldKey will be copied
-// to a PrefixStore with NewKey, then deleted from OldKey store.
-type StoreRename struct {
-	OldKey string `json:"old_key"`
-	NewKey string `json:"new_key"`
+	Added   []string `json:"added"`
+	Deleted []string `json:"deleted"`
 }
 
 // IsAdded returns true if the given key should be added
@@ -40,17 +31,3 @@ func (s *StoreUpgrades) IsDeleted(key string) bool {
 	}
 	return false
 }
-
-// RenamedFrom returns the oldKey if it was renamed
-// Returns "" if it was not renamed
-func (s *StoreUpgrades) RenamedFrom(key string) string {
-	if s == nil {
-		return ""
-	}
-	for _, re := range s.Renamed {
-		if re.NewKey == key {
-			return re.OldKey
-		}
-	}
-	return ""
-}

store/v2/README.md

@@ -4,16 +4,6 @@ The `store` package contains the implementation of store/v2, which is the SDK's
 abstraction around managing historical and committed state. See [ADR-065](../docs/architecture/adr-065-store-v2.md)
 and [Store v2 Design](https://docs.google.com/document/d/1l6uXIjTPHOOWM5N4sUUmUfCZvePoa5SNfIEtmgvgQSU/edit#heading=h.nz8dqy6wa4g1) for a high-level overview of the design and rationale.
 
-## Migration
-
-<!-- TODO -->
-
-## Pruning
-
-The `root.Store` is NOT responsible for pruning. Rather, pruning is the responsibility
-of the underlying SS and SC layers. This means pruning can be implementation specific,
-such as being synchronous or asynchronous.
-
 ## Usage
 
 The `store` package contains a `root.Store` type which is intended to act as an
@@ -29,3 +19,45 @@ from the perspective of `root.Store`, there is no notion of multi or single tree
 rather these are implementation details of SS and SC. For SS, we utilize store keys
 to namespace raw key/value pairs. For SC, we utilize an abstraction, `commitment.CommitStore`,
 to map store keys to a commitment trees.
+
+## Upgrades
+
+The `LoadVersionAndUpgrade` API of the `root.store` allows for adding or removing
+store keys. This is useful for upgrading the chain with new modules or removing
+old ones. The `Rename` feature is deprecated and should not be used in store/v2.
+
+```mermaid
+sequenceDiagram
+    participant S as Store
+    participant SS as StateStorage
+    participant SC as StateCommitment
+    alt SC is a UpgradeableStore
+        S->>SC: LoadVersionAndUpgrade
+        SC->>SC: Mount new store keys
+        SC->>SC: Prune removed store keys
+    end
+    SC->>S: LoadVersion Result
+    alt SS is a UpgradableDatabase
+        S->>SS: PruneStoreKeys
+    end
+```
+
+`Prune store keys` does not remove the data from the SC and SS instantly. It only
+marks the store keys as pruned. The actual data removal is done by the pruning
+process of the underlying SS and SC.
+
+## Migration
+
+<!-- TODO -->
+
+## Pruning
+
+The `root.Store` is NOT responsible for pruning. Rather, pruning is the responsibility
+of the underlying SS and SC layers. This means pruning can be implementation specific,
+such as being synchronous or asynchronous.
+
+
+
+## Test Coverage
+
+The test coverage of the following logical components should be over 60%:

store/v2/commitment/iavl/tree.go

@@ -87,8 +87,9 @@ func (t *IavlTree) Get(version uint64, key []byte) ([]byte, error) {
 }
 
 // GetLatestVersion returns the latest version of the tree.
-func (t *IavlTree) GetLatestVersion() uint64 {
-	return uint64(t.tree.Version())
+func (t *IavlTree) GetLatestVersion() (uint64, error) {
+	v, err := t.tree.GetLatestVersion()
+	return uint64(v), err
 }
 
 // SetInitialVersion sets the initial version of the database.

store/v2/commitment/iavl/tree_test.go

@@ -19,11 +19,15 @@ func TestCommitterSuite(t *testing.T) {
 		NewStore: func(db corestore.KVStoreWithBatch, storeKeys []string, logger corelog.Logger) (*commitment.CommitStore, error) {
 			multiTrees := make(map[string]commitment.Tree)
 			cfg := DefaultConfig()
-			for _, storeKey := range storeKeys {
+			mountTreeFn := func(storeKey string) (commitment.Tree, error) {
 				prefixDB := dbm.NewPrefixDB(db, []byte(storeKey))
-				multiTrees[storeKey] = NewIavlTree(prefixDB, logger, cfg)
+				return NewIavlTree(prefixDB, logger, cfg), nil
+			}
+			for _, storeKey := range storeKeys {
+				multiTrees[storeKey], _ = mountTreeFn(storeKey)
 			}
-			return commitment.NewCommitStore(multiTrees, db, logger)
+
+			return commitment.NewCommitStore(multiTrees, db, mountTreeFn, logger)
 		},
 	}
 
@@ -41,7 +45,8 @@ func TestIavlTree(t *testing.T) {
 	tree := generateTree()
 	require.NotNil(t, tree)
 
-	initVersion := tree.GetLatestVersion()
+	initVersion, err := tree.GetLatestVersion()
+	require.NoError(t, err)
 	require.Equal(t, uint64(0), initVersion)
 
 	// write a batch of version 1
@@ -51,14 +56,18 @@ func TestIavlTree(t *testing.T) {
 
 	workingHash := tree.WorkingHash()
 	require.NotNil(t, workingHash)
-	require.Equal(t, uint64(0), tree.GetLatestVersion())
+	v, err := tree.GetLatestVersion()
+	require.NoError(t, err)
+	require.Equal(t, uint64(0), v)
 
 	// commit the batch
 	commitHash, version, err := tree.Commit()
 	require.NoError(t, err)
 	require.Equal(t, version, uint64(1))
 	require.Equal(t, workingHash, commitHash)
-	require.Equal(t, uint64(1), tree.GetLatestVersion())
+	v, err = tree.GetLatestVersion()
+	require.NoError(t, err)
+	require.Equal(t, uint64(1), v)
 
 	// ensure we can get expected values
 	bz, err := tree.Get(1, []byte("key1"))
@@ -100,7 +109,9 @@ func TestIavlTree(t *testing.T) {
 	// prune version 1
 	err = tree.Prune(1)
 	require.NoError(t, err)
-	require.Equal(t, uint64(3), tree.GetLatestVersion())
+	v, err = tree.GetLatestVersion()
+	require.NoError(t, err)
+	require.Equal(t, uint64(3), v)
 	// async pruning check
 	checkErr := func() bool {
 		if _, err := tree.tree.LoadVersion(1); err != nil {

store/v2/commitment/mem/tree.go

@@ -18,8 +18,8 @@ func (t *Tree) Remove(key []byte) error {
 	return t.MemDB.Delete(key)
 }
 
-func (t *Tree) GetLatestVersion() uint64 {
-	return 0
+func (t *Tree) GetLatestVersion() (uint64, error) {
+	return 0, nil
 }
 
 func (t *Tree) Hash() []byte {

store/v2/commitment/metadata.go

@@ -10,20 +10,24 @@ import (
 )
 
 const (
-	commitInfoKeyFmt = "c/%d" // c/<version>
-	latestVersionKey = "c/latest"
+	commitInfoKeyFmt      = "c/%d" // c/<version>
+	latestVersionKey      = "c/latest"
+	removedStoreKeyPrefix = "c/removed/" // c/removed/<version>/<store-name>
 )
 
+// MetadataStore is a store for metadata related to the commitment store.
 type MetadataStore struct {
 	kv corestore.KVStoreWithBatch
 }
 
+// NewMetadataStore creates a new MetadataStore.
 func NewMetadataStore(kv corestore.KVStoreWithBatch) *MetadataStore {
 	return &MetadataStore{
 		kv: kv,
 	}
 }
 
+// GetLatestVersion returns the latest committed version.
 func (m *MetadataStore) GetLatestVersion() (uint64, error) {
 	value, err := m.kv.Get([]byte(latestVersionKey))
 	if err != nil {
@@ -41,6 +45,16 @@ func (m *MetadataStore) GetLatestVersion() (uint64, error) {
 	return version, 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 {
+		return err
+	}
+	return m.kv.Set([]byte(latestVersionKey), buf.Bytes())
+}
+
+// GetCommitInfo returns the commit info for the given version.
 func (m *MetadataStore) GetCommitInfo(version uint64) (*proof.CommitInfo, error) {
 	key := []byte(fmt.Sprintf(commitInfoKeyFmt, version))
 	value, err := m.kv.Get(key)
@@ -90,12 +104,59 @@ func (m *MetadataStore) flushCommitInfo(version uint64, cInfo *proof.CommitInfo)
 		return err
 	}
 
-	if err := batch.WriteSync(); err != nil {
+	if err := batch.Write(); err != nil {
 		return err
 	}
 	return nil
 }
 
+func (m *MetadataStore) flushRemovedStoreKeys(version uint64, storeKeys []string) (err error) {
+	batch := m.kv.NewBatch()
+	defer func() {
+		err = batch.Close()
+	}()
+
+	for _, storeKey := range storeKeys {
+		key := []byte(fmt.Sprintf("%s%s", encoding.BuildPrefixWithVersion(removedStoreKeyPrefix, version), storeKey))
+		if err := batch.Set(key, []byte{}); err != nil {
+			return err
+		}
+	}
+	return batch.Write()
+}
+
+func (m *MetadataStore) deleteRemovedStoreKeys(version uint64, removeStore func(storeKey []byte, version uint64) error) (err error) {
+	batch := m.kv.NewBatch()
+	defer func() {
+		if berr := batch.Close(); berr != nil {
+			err = berr
+		}
+	}()
+
+	end := encoding.BuildPrefixWithVersion(removedStoreKeyPrefix, version+1)
+	iter, err := m.kv.Iterator([]byte(removedStoreKeyPrefix), end)
+	if err != nil {
+		return err
+	}
+	defer func() {
+		if ierr := iter.Close(); ierr != nil {
+			err = ierr
+		}
+	}()
+
+	for ; iter.Valid(); iter.Next() {
+		storeKey := iter.Key()[len(end):]
+		if err := removeStore(storeKey, version); err != nil {
+			return err
+		}
+		if err := batch.Delete(iter.Key()); err != nil {
+			return nil
+		}
+	}
+
+	return batch.Write()
+}
+
 func (m *MetadataStore) deleteCommitInfo(version uint64) error {
 	cInfoKey := []byte(fmt.Sprintf(commitInfoKeyFmt, version))
 	return m.kv.Delete(cInfoKey)