Address PR comments

Author: fastfadingviolets

baseapp/baseapp.go

@@ -620,17 +620,12 @@ func (app *BaseApp) getContextForTx(mode sdk.ExecMode, txBytes []byte) sdk.Conte
 	return ctx
 }
 
-type poolingStore interface {
-	storetypes.MultiStore
-	CacheMultiStorePooled() storetypes.PooledCacheMultiStore
-}
-
 // cacheTxContext returns a new context based off of the provided context with
 // a branched multi-store.
 func (app *BaseApp) cacheTxContext(ctx sdk.Context, txBytes []byte) (sdk.Context, storetypes.CacheMultiStore) {
 	ms := ctx.MultiStore()
 	var msCache storetypes.CacheMultiStore
-	if msPooled, ok := ms.(poolingStore); ok {
+	if msPooled, ok := ms.(storetypes.PoolingMultiStore); ok {
 		msCache = msPooled.CacheMultiStorePooled()
 	} else {
 		msCache = ms.CacheMultiStore()

store/cachekv/internal/btree.go

@@ -36,6 +36,7 @@ func NewBTree() BTree {
 	}
 }
 
+// Clear clears the tree.
 func (bt BTree) Clear() {
 	bt.tree.Clear()
 }

store/cachekv/store.go

@@ -32,6 +32,8 @@ type Store struct {
 	parent        types.KVStore
 }
 
+// PooledStore wraps a Store object and implements the types.PooledCacheKVStore interface,
+// which allows it to be pooled and reused without the overhead of allocation.
 type PooledStore struct {
 	Store
 }
@@ -60,13 +62,15 @@ var storePool = sync.Pool{
 	},
 }
 
+// Release releases the PooledStore object back to the pool.
 func (store *PooledStore) Release() {
 	store.resetCaches()
 	store.parent = nil
 	store.mtx = sync.Mutex{}
 	storePool.Put(store)
 }
 
+// NewPooledStore gets a PooledStore object from the pool.
 func NewPooledStore(parent types.KVStore) *PooledStore {
 	store := storePool.Get().(*PooledStore)
 	store.parent = parent

store/cachemulti/store.go

@@ -34,13 +34,16 @@ type Store struct {
 	traceContext types.TraceContext
 }
 
+// PooledStore is a wrapper around Store that implements the PooledCacheKVStore interface.
+// It's used to avoid allocating new Store instances .
 type PooledStore struct {
 	Store
 }
 
-var _ types.CacheMultiStore = &Store{}
-
-var _ types.PooledCacheMultiStore = &PooledStore{}
+var (
+	_ types.CacheMultiStore       = &Store{}
+	_ types.PooledCacheMultiStore = &PooledStore{}
+)
 
 // NewFromKVStore creates a new Store object from a mapping of store keys to
 // CacheWrapper objects and a KVStore as the database. Each CacheWrapper store
@@ -91,6 +94,8 @@ var storePool = sync.Pool{
 	},
 }
 
+// newFromKVStorePooled returns a PooledStore object, populated with a mapping of store keys to
+// CacheWrapper objects and a KVStore as the database.
 func newFromKVStorePooled(
 	store types.KVStore, stores map[types.StoreKey]types.CacheWrap,
 	traceWriter io.Writer, traceContext types.TraceContext,
@@ -113,6 +118,7 @@ func newFromKVStorePooled(
 	return cms
 }
 
+// Release releases the PooledStore object back to the pool.
 func (cms *PooledStore) Release() {
 	// clear the stores map
 	for k, v := range cms.stores {
@@ -202,6 +208,7 @@ func (cms *Store) CacheMultiStore() types.CacheMultiStore {
 	return newCacheMultiStoreFromCMS(cms)
 }
 
+// CacheMultiStorePooled returns a PooledCacheMultiStore object from a pool.
 func (cms *Store) CacheMultiStorePooled() types.PooledCacheMultiStore {
 	return newFromKVStorePooled(cms.db, cms.stores, cms.traceWriter, cms.traceContext)
 }

store/types/store.go

@@ -146,12 +146,19 @@ type MultiStore interface {
 	LatestVersion() int64
 }
 
+// PoolingMultiStore is a MultiStore that can return CacheMultiStores from a pool, without needing to allocate a new one each time.
+type PoolingMultiStore interface {
+	MultiStore
+	CacheMultiStorePooled() PooledCacheMultiStore
+}
+
 // CacheMultiStore extends MultiStore with a Write() method.
 type CacheMultiStore interface {
 	MultiStore
 	Write() // Writes operations to underlying KVStore
 }
 
+// PooledCacheMultiStore is a CacheMultiStore that can be pooled and reused without the overhead of allocation.
 type PooledCacheMultiStore interface {
 	CacheMultiStore
 	Release() // Releases the cache