v2 store additions

* remove iterator read lock; doesn't play with orm tests, so just rely on the stated contract: no store writes while iterator open
* use v2 store in orm tests
* clean up app boilerplate
* update NewCommitMultiStore()
* fix NewUncachedContext

baseapp/options.go

@@ -84,6 +84,25 @@ func SetSubstores(keys ...storetypes.StoreKey) StoreOption {
 	}
 }
 
+func SetSubstoresFromMaps(
+	keys map[string]*storetypes.KVStoreKey,
+	tkeys map[string]*storetypes.TransientStoreKey,
+	memKeys map[string]*storetypes.MemoryStoreKey,
+) StoreOption {
+	return func(params *multi.StoreParams, _ uint64) error {
+		if err := multi.RegisterSubstoresFromMap(params, keys); err != nil {
+			return err
+		}
+		if err := multi.RegisterSubstoresFromMap(params, tkeys); err != nil {
+			return err
+		}
+		if err := multi.RegisterSubstoresFromMap(params, memKeys); err != nil {
+			return err
+		}
+		return nil
+	}
+}
+
 // SetSnapshot sets the snapshot store.
 func SetSnapshot(snapshotStore *snapshots.Store, opts snapshottypes.SnapshotOptions) AppOption {
 	return AppOptionOrdered{

baseapp/test_helpers.go

@@ -3,7 +3,6 @@ package baseapp
 import (
 	tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
 
-	"github.com/cosmos/cosmos-sdk/store/v2alpha1/multi"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 )
@@ -48,7 +47,7 @@ func (app *BaseApp) NewContext(isCheckTx bool, header tmproto.Header) sdk.Contex
 }
 
 func (app *BaseApp) NewUncachedContext(isCheckTx bool, header tmproto.Header) sdk.Context {
-	return sdk.NewContext(multi.CommitAsCacheStore(app.store), header, isCheckTx, app.logger)
+	return sdk.NewContext(app.store, header, isCheckTx, app.logger)
 }
 
 // NewContextAt creates a context using a (read-only) store at a given block height.

simapp/app.go

@@ -33,7 +33,6 @@ import (
 	simappparams "github.com/cosmos/cosmos-sdk/simapp/params"
 	"github.com/cosmos/cosmos-sdk/store/streaming"
 	storetypes "github.com/cosmos/cosmos-sdk/store/v2alpha1"
-	"github.com/cosmos/cosmos-sdk/store/v2alpha1/multi"
 	"github.com/cosmos/cosmos-sdk/testutil/testdata_pulsar"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
@@ -252,40 +251,8 @@ func NewSimApp(
 	)
 	// NOTE: The testingkey is just mounted for testing purposes. Actual applications should
 	// not include this key.
-	app.memKeys = sdk.NewMemoryStoreKeys("testingkey")
-
-	// Store loader which initialized substores
-	setNamespaces := func(config *multi.StoreParams, ver uint64) error {
-		for _, key := range keys {
-			typ, err := storetypes.StoreKeyToType(key)
-			if err != nil {
-				return err
-			}
-			if err = config.RegisterSubstore(key, typ); err != nil {
-				return err
-			}
-		}
-		for _, key := range memKeys {
-			typ, err := storetypes.StoreKeyToType(key)
-			if err != nil {
-				return err
-			}
-			if err = config.RegisterSubstore(key, typ); err != nil {
-				return err
-			}
-		}
-		for _, key := range tkeys {
-			typ, err := storetypes.StoreKeyToType(key)
-			if err != nil {
-				return err
-			}
-			if err = config.RegisterSubstore(key, typ); err != nil {
-				return err
-			}
-		}
-		return nil
-	}
-	baseAppOptions = append(baseAppOptions, baseapp.StoreOption(setNamespaces))
+	app.memKeys = sdk.NewMemoryStoreKeys(capabilitytypes.MemStoreKey, "testingkey")
+	baseAppOptions = append(baseAppOptions, baseapp.SetSubstoresFromMaps(keys, tkeys, memKeys))
 
 	// set the governance module account as the authority for conducting upgrades
 	upgradeKeeper := upgradekeeper.NewKeeper(skipUpgradeHeights, app.keys[upgradetypes.StoreKey], app.appCodec, homePath, nil, authtypes.NewModuleAddress(govtypes.ModuleName).String())
@@ -427,7 +394,6 @@ func (app *SimApp) InitChainer(ctx sdk.Context, req abci.RequestInitChain) abci.
 
 // LoadHeight loads a particular height
 func (app *SimApp) LoadHeight(height int64) error {
-	// return app.LoadVersion(height)
 	return errors.New("cannot load arbitrary height")
 }
 

store/store.go

@@ -1,16 +1,19 @@
 package store
 
 import (
-	"github.com/tendermint/tendermint/libs/log"
-	dbm "github.com/tendermint/tm-db"
+	dbm "github.com/cosmos/cosmos-sdk/db"
 
 	"github.com/cosmos/cosmos-sdk/store/cache"
-	"github.com/cosmos/cosmos-sdk/store/rootmulti"
-	"github.com/cosmos/cosmos-sdk/store/types"
+	types "github.com/cosmos/cosmos-sdk/store/v2alpha1"
+	"github.com/cosmos/cosmos-sdk/store/v2alpha1/multi"
 )
 
-func NewCommitMultiStore(db dbm.DB) types.CommitMultiStore {
-	return rootmulti.NewStore(db, log.NewNopLogger())
+func NewCommitMultiStore(db dbm.DBConnection) types.CommitMultiStore {
+	store, err := multi.NewV1MultiStoreAsV2(db, multi.DefaultStoreParams())
+	if err != nil {
+		panic(err)
+	}
+	return store
 }
 
 func NewCommitKVStoreCacheManager() types.MultiStorePersistentCache {

store/v2alpha1/multi/params.go

@@ -0,0 +1,63 @@
+package multi
+
+import (
+	"fmt"
+
+	pruningtypes "github.com/cosmos/cosmos-sdk/pruning/types"
+	types "github.com/cosmos/cosmos-sdk/store/v2alpha1"
+)
+
+// DefaultStoreParams returns a MultiStore config with an empty schema, a single backing DB,
+// pruning with PruneDefault, no listeners and no tracer.
+func DefaultStoreParams() StoreParams {
+	return StoreParams{
+		Pruning:          pruningtypes.NewPruningOptions(pruningtypes.PruningDefault),
+		SchemaBuilder:    newSchemaBuilder(),
+		storeKeys:        storeKeys{},
+		traceListenMixin: newTraceListenMixin(),
+	}
+}
+
+func (par *StoreParams) RegisterSubstore(skey types.StoreKey, typ types.StoreType) error {
+	if !validSubStoreType(typ) {
+		return fmt.Errorf("StoreType not supported: %v", typ)
+	}
+	var ok bool
+	switch typ {
+	case types.StoreTypePersistent:
+		_, ok = skey.(*types.KVStoreKey)
+	case types.StoreTypeMemory:
+		_, ok = skey.(*types.MemoryStoreKey)
+	case types.StoreTypeTransient:
+		_, ok = skey.(*types.TransientStoreKey)
+	}
+	if !ok {
+		return fmt.Errorf("invalid StoreKey for %v: %T", typ, skey)
+	}
+	if err := par.registerName(skey.Name(), typ); err != nil {
+		return err
+	}
+	par.storeKeys[skey.Name()] = skey
+	return nil
+}
+
+func (par *StoreParams) storeKey(key string) (types.StoreKey, error) {
+	skey, ok := par.storeKeys[key]
+	if !ok {
+		return nil, fmt.Errorf("StoreKey instance not mapped: %s", key)
+	}
+	return skey, nil
+}
+
+func RegisterSubstoresFromMap[T types.StoreKey](par *StoreParams, keys map[string]T) error {
+	for _, key := range keys {
+		typ, err := types.StoreKeyToType(key)
+		if err != nil {
+			return err
+		}
+		if err = par.RegisterSubstore(key, typ); err != nil {
+			return err
+		}
+	}
+	return nil
+}

store/v2alpha1/multi/store.go

@@ -141,48 +141,6 @@ func newSchemaBuilder() SchemaBuilder {
 	return SchemaBuilder{StoreSchema: StoreSchema{}}
 }
 
-// DefaultStoreParams returns a MultiStore config with an empty schema, a single backing DB,
-// pruning with PruneDefault, no listeners and no tracer.
-func DefaultStoreParams() StoreParams {
-	return StoreParams{
-		Pruning:          pruningtypes.NewPruningOptions(pruningtypes.PruningDefault),
-		SchemaBuilder:    newSchemaBuilder(),
-		storeKeys:        storeKeys{},
-		traceListenMixin: newTraceListenMixin(),
-	}
-}
-
-func (par *StoreParams) RegisterSubstore(skey types.StoreKey, typ types.StoreType) error {
-	if !validSubStoreType(typ) {
-		return fmt.Errorf("StoreType not supported: %v", typ)
-	}
-	var ok bool
-	switch typ {
-	case types.StoreTypePersistent:
-		_, ok = skey.(*types.KVStoreKey)
-	case types.StoreTypeMemory:
-		_, ok = skey.(*types.MemoryStoreKey)
-	case types.StoreTypeTransient:
-		_, ok = skey.(*types.TransientStoreKey)
-	}
-	if !ok {
-		return fmt.Errorf("invalid StoreKey for %v: %T", typ, skey)
-	}
-	if err := par.registerName(skey.Name(), typ); err != nil {
-		return err
-	}
-	par.storeKeys[skey.Name()] = skey
-	return nil
-}
-
-func (par *StoreParams) storeKey(key string) (types.StoreKey, error) {
-	skey, ok := par.storeKeys[key]
-	if !ok {
-		return nil, fmt.Errorf("StoreKey instance not mapped: %s", key)
-	}
-	return skey, nil
-}
-
 // Returns true for valid store types for a MultiStore schema
 func validSubStoreType(sst types.StoreType) bool {
 	switch sst {
@@ -279,8 +237,7 @@ func NewStore(db dbm.DBConnection, opts StoreParams) (ret *Store, err error) {
 	// To abide by atomicity constraints, revert the DB to the last saved version, in case it contains
 	// committed data in the "working" version.
 	// This should only happen if Store.Commit previously failed.
-	err = db.Revert()
-	if err != nil {
+	if err = db.Revert(); err != nil {
 		return
 	}
 	stateTxn := db.ReadWriter()
@@ -292,17 +249,15 @@ func NewStore(db dbm.DBConnection, opts StoreParams) (ret *Store, err error) {
 	stateCommitmentTxn := stateTxn
 	if opts.StateCommitmentDB != nil {
 		var scVersions dbm.VersionSet
-		scVersions, err = opts.StateCommitmentDB.Versions()
-		if err != nil {
+		if scVersions, err = opts.StateCommitmentDB.Versions(); err != nil {
 			return
 		}
 		// Version sets of each DB must match
 		if !versions.Equal(scVersions) {
 			err = fmt.Errorf("different version history between Storage and StateCommitment DB ")
 			return
 		}
-		err = opts.StateCommitmentDB.Revert()
-		if err != nil {
+		if err = opts.StateCommitmentDB.Revert(); err != nil {
 			return
 		}
 		stateCommitmentTxn = opts.StateCommitmentDB.ReadWriter()
@@ -333,8 +288,7 @@ func NewStore(db dbm.DBConnection, opts StoreParams) (ret *Store, err error) {
 	writeSchema := func(sch StoreSchema) {
 		schemaWriter := prefixdb.NewWriter(ret.stateTxn, schemaPrefix)
 		var it dbm.Iterator
-		it, err = schemaView.Iterator(nil, nil)
-		if err != nil {
+		if it, err = schemaView.Iterator(nil, nil); err != nil {
 			return
 		}
 		for it.Next() {
@@ -343,12 +297,10 @@ func NewStore(db dbm.DBConnection, opts StoreParams) (ret *Store, err error) {
 				return
 			}
 		}
-		err = it.Close()
-		if err != nil {
+		if err = it.Close(); err != nil {
 			return
 		}
-		err = schemaView.Discard()
-		if err != nil {
+		if err = schemaView.Discard(); err != nil {
 			return
 		}
 		// NB. the migrated contents and schema are not committed until the next store.Commit
@@ -642,9 +594,8 @@ func (s *Store) commit(target uint64) (id *types.CommitID, err error) {
 	}
 	// Update substore Merkle roots
 	for key, storeHash := range storeHashes {
-		pfx := substorePrefix(key)
-		stateW := prefixdb.NewReadWriter(s.stateTxn, pfx)
-		if err = stateW.Set(substoreMerkleRootKey, storeHash); err != nil {
+		w := prefixdb.NewPrefixReadWriter(s.stateTxn, substorePrefix(key))
+		if err = w.Set(substoreMerkleRootKey, storeHash); err != nil {
 			return
 		}
 	}
@@ -660,8 +611,7 @@ func (s *Store) commit(target uint64) (id *types.CommitID, err error) {
 			err = util.CombineErrors(err, s.stateDB.Revert(), "stateDB.Revert also failed")
 		}
 	}()
-	err = s.stateDB.SaveVersion(target)
-	if err != nil {
+	if err = s.stateDB.SaveVersion(target); err != nil {
 		return
 	}
 
@@ -691,8 +641,7 @@ func (s *Store) commit(target uint64) (id *types.CommitID, err error) {
 			}
 		}()
 
-		err = s.StateCommitmentDB.SaveVersion(target)
-		if err != nil {
+		if err = s.StateCommitmentDB.SaveVersion(target); err != nil {
 			return
 		}
 	}

store/v2alpha1/multi/sub_store.go

@@ -2,9 +2,7 @@ package multi
 
 import (
 	"io"
-	"sync"
 
-	dbm "github.com/cosmos/cosmos-sdk/db"
 	dbutil "github.com/cosmos/cosmos-sdk/internal/db"
 	"github.com/cosmos/cosmos-sdk/store/cachekv"
 	"github.com/cosmos/cosmos-sdk/store/listenkv"
@@ -57,29 +55,13 @@ func (s *substore) Delete(key []byte) {
 	_ = s.dataBucket.Delete(key)
 }
 
-type contentsIterator struct {
-	types.Iterator
-	locker sync.Locker
-}
-
-func (s *substore) newSubstoreIterator(source dbm.Iterator) *contentsIterator {
-	locker := s.root.mtx.RLocker()
-	locker.Lock()
-	return &contentsIterator{dbutil.ToStoreIterator(source), locker}
-}
-
-func (it *contentsIterator) Close() error {
-	defer it.locker.Unlock()
-	return it.Iterator.Close()
-}
-
 // Iterator implements KVStore.
 func (s *substore) Iterator(start, end []byte) types.Iterator {
 	iter, err := s.dataBucket.Iterator(start, end)
 	if err != nil {
 		panic(err)
 	}
-	return s.newSubstoreIterator(iter)
+	return dbutil.DBToStoreIterator(iter)
 }
 
 // ReverseIterator implements KVStore.
@@ -88,7 +70,7 @@ func (s *substore) ReverseIterator(start, end []byte) types.Iterator {
 	if err != nil {
 		panic(err)
 	}
-	return s.newSubstoreIterator(iter)
+	return dbutil.DBToStoreIterator(iter)
 }
 
 // GetStoreType implements Store.