R4R: Paramstore Subkey

x/distribution/keeper/keeper.go

@@ -26,7 +26,7 @@ func NewKeeper(cdc *codec.Codec, key sdk.StoreKey, paramSpace params.Subspace, c
 	keeper := Keeper{
 		storeKey:            key,
 		cdc:                 cdc,
-		paramSpace:          paramSpace.WithTypeTable(ParamTypeTable()),
+		paramSpace:          paramSpace.WithKeyTable(ParamKeyTable()),
 		bankKeeper:          ck,
 		stakeKeeper:         sk,
 		feeCollectionKeeper: fck,
@@ -109,8 +109,8 @@ func (k Keeper) GetWithdrawContext(ctx sdk.Context,
 // PARAM STORE
 
 // Type declaration for parameters
-func ParamTypeTable() params.TypeTable {
-	return params.NewTypeTable(
+func ParamKeyTable() params.KeyTable {
+	return params.NewKeyTable(
 		ParamStoreKeyCommunityTax, sdk.Dec{},
 		ParamStoreKeyBaseProposerReward, sdk.Dec{},
 		ParamStoreKeyBonusProposerReward, sdk.Dec{},

x/gov/keeper.go

@@ -20,8 +20,8 @@ var (
 )
 
 // Type declaration for parameters
-func ParamTypeTable() params.TypeTable {
-	return params.NewTypeTable(
+func ParamKeyTable() params.KeyTable {
+	return params.NewKeyTable(
 		ParamStoreKeyDepositProcedure, DepositProcedure{},
 		ParamStoreKeyVotingProcedure, VotingProcedure{},
 		ParamStoreKeyTallyingProcedure, TallyingProcedure{},
@@ -64,7 +64,7 @@ func NewKeeper(cdc *codec.Codec, key sdk.StoreKey, paramsKeeper params.Keeper, p
 	return Keeper{
 		storeKey:     key,
 		paramsKeeper: paramsKeeper,
-		paramSpace:   paramSpace.WithTypeTable(ParamTypeTable()),
+		paramSpace:   paramSpace.WithKeyTable(ParamKeyTable()),
 		ck:           ck,
 		ds:           ds,
 		vs:           ds.GetValidatorSet(),

x/mint/keeper.go

@@ -21,7 +21,7 @@ func NewKeeper(cdc *codec.Codec, key sdk.StoreKey,
 	keeper := Keeper{
 		storeKey:   key,
 		cdc:        cdc,
-		paramSpace: paramSpace.WithTypeTable(ParamTypeTable()),
+		paramSpace: paramSpace.WithKeyTable(ParamKeyTable()),
 		sk:         sk,
 		fck:        fck,
 	}
@@ -39,8 +39,8 @@ var (
 )
 
 // ParamTable for stake module
-func ParamTypeTable() params.TypeTable {
-	return params.NewTypeTable(
+func ParamKeyTable() params.KeyTable {
+	return params.NewKeyTable(
 		ParamStoreKeyParams, Params{},
 	)
 }

x/params/keeper_test.go

@@ -53,7 +53,7 @@ func TestKeeper(t *testing.T) {
 		{"key7", 9058701},
 	}
 
-	table := NewTypeTable(
+	table := NewKeyTable(
 		[]byte("key1"), int64(0),
 		[]byte("key2"), int64(0),
 		[]byte("key3"), int64(0),
@@ -70,7 +70,7 @@ func TestKeeper(t *testing.T) {
 	tkey := sdk.NewTransientStoreKey("transient_test")
 	ctx := defaultContext(skey, tkey)
 	keeper := NewKeeper(cdc, skey, tkey)
-	space := keeper.Subspace("test").WithTypeTable(table)
+	space := keeper.Subspace("test").WithKeyTable(table)
 	store := ctx.KVStore(skey).Prefix([]byte("test/"))
 
 	// Set params
@@ -162,7 +162,7 @@ func TestSubspace(t *testing.T) {
 		{"struct", s{1}, s{0}, new(s)},
 	}
 
-	table := NewTypeTable(
+	table := NewKeyTable(
 		[]byte("string"), string(""),
 		[]byte("bool"), bool(false),
 		[]byte("int16"), int16(0),
@@ -178,7 +178,7 @@ func TestSubspace(t *testing.T) {
 	)
 
 	store := ctx.KVStore(key).Prefix([]byte("test/"))
-	space := keeper.Subspace("test").WithTypeTable(table)
+	space := keeper.Subspace("test").WithKeyTable(table)
 
 	// Test space.Set, space.Modified
 	for i, kv := range kvs {

x/params/subspace.go

@@ -1,6 +1,10 @@
 package params
 
 import (
+	"testing"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
 	"github.com/cosmos/cosmos-sdk/x/params/subspace"
 )
 
@@ -9,11 +13,14 @@ type (
 	Subspace         = subspace.Subspace
 	ReadOnlySubspace = subspace.ReadOnlySubspace
 	ParamSet         = subspace.ParamSet
-	KeyValuePairs    = subspace.KeyValuePairs
-	TypeTable        = subspace.TypeTable
+	ParamSetPairs    = subspace.ParamSetPairs
+	KeyTable         = subspace.KeyTable
 )
 
-// re-export functions from subspace
-func NewTypeTable(keytypes ...interface{}) TypeTable {
-	return subspace.NewTypeTable(keytypes...)
+// nolint - re-export functions from subspace
+func NewKeyTable(keytypes ...interface{}) KeyTable {
+	return subspace.NewKeyTable(keytypes...)
+}
+func DefaultTestComponents(t *testing.T) (sdk.Context, Subspace, func() sdk.CommitID) {
+	return subspace.DefaultTestComponents(t)
 }

x/params/subspace/pair.go

@@ -1,15 +1,15 @@
 package subspace
 
 // Used for associating paramsubspace key and field of param structs
-type KeyValuePair struct {
+type ParamSetPair struct {
 	Key   []byte
 	Value interface{}
 }
 
 // Slice of KeyFieldPair
-type KeyValuePairs []KeyValuePair
+type ParamSetPairs []ParamSetPair
 
 // Interface for structs containing parameters for a module
 type ParamSet interface {
-	KeyValuePairs() KeyValuePairs
+	ParamSetPairs() ParamSetPairs
 }

x/params/subspace/subspace.go

@@ -17,7 +17,7 @@ type Subspace struct {
 
 	name []byte
 
-	table TypeTable
+	table KeyTable
 }
 
 // NewSubspace constructs a store with namestore
@@ -27,21 +27,21 @@ func NewSubspace(cdc *codec.Codec, key sdk.StoreKey, tkey sdk.StoreKey, name str
 		key:  key,
 		tkey: tkey,
 		name: []byte(name),
-		table: TypeTable{
-			m: make(map[string]reflect.Type),
+		table: KeyTable{
+			m: make(map[string]attribute),
 		},
 	}
 
 	return
 }
 
-// WithTypeTable initializes TypeTable and returns modified Subspace
-func (s Subspace) WithTypeTable(table TypeTable) Subspace {
+// WithKeyTable initializes KeyTable and returns modified Subspace
+func (s Subspace) WithKeyTable(table KeyTable) Subspace {
 	if table.m == nil {
-		panic("SetTypeTable() called with nil TypeTable")
+		panic("SetKeyTable() called with nil KeyTable")
 	}
 	if len(s.table.m) != 0 {
-		panic("SetTypeTable() called on already initialized Subspace")
+		panic("SetKeyTable() called on already initialized Subspace")
 	}
 
 	for k, v := range table.m {
@@ -64,11 +64,19 @@ func (s Subspace) kvStore(ctx sdk.Context) sdk.KVStore {
 	return ctx.KVStore(s.key).Prefix(append(s.name, '/'))
 }
 
-// Returns a KVStore identical with ctx.TransientStore(s.tkey).Prefix()
+// Returns a transient store for modification
 func (s Subspace) transientStore(ctx sdk.Context) sdk.KVStore {
 	// append here is safe, appends within a function won't cause
 	// weird side effects when its singlethreaded
-	return ctx.TransientStore(s.tkey).Prefix(append(s.name, '/'))
+	return ctx.TransientStore(s.tkey).Prefix(append(s.name, "/m/"...))
+}
+
+func concatKeys(key, subkey []byte) (res []byte) {
+	res = make([]byte, len(key)+1+len(subkey))
+	copy(res, key)
+	res[len(key)] = '/'
+	copy(res[len(key)+1:], subkey)
+	return
 }
 
 // Get parameter from store
@@ -94,6 +102,17 @@ func (s Subspace) GetIfExists(ctx sdk.Context, key []byte, ptr interface{}) {
 	}
 }
 
+// GetWithSubkey returns a parameter with a given key and a subkey.
+func (s Subspace) GetWithSubkey(ctx sdk.Context, key, subkey []byte, ptr interface{}) {
+	s.Get(ctx, concatKeys(key, subkey), ptr)
+}
+
+// GetWithSubkeyIfExists  returns a parameter with a given key and a subkey but does not
+// modify ptr if the stored parameter is nil.
+func (s Subspace) GetWithSubkeyIfExists(ctx sdk.Context, key, subkey []byte, ptr interface{}) {
+	s.GetIfExists(ctx, concatKeys(key, subkey), ptr)
+}
+
 // Get raw bytes of parameter from store
 func (s Subspace) GetRaw(ctx sdk.Context, key []byte) []byte {
 	store := s.kvStore(ctx)
@@ -112,16 +131,13 @@ func (s Subspace) Modified(ctx sdk.Context, key []byte) bool {
 	return tstore.Has(key)
 }
 
-// Set parameter, return error if stored parameter has different type from input
-// Also set to the transient store to record change
-func (s Subspace) Set(ctx sdk.Context, key []byte, param interface{}) {
-	store := s.kvStore(ctx)
-
-	ty, ok := s.table.m[string(key)]
+func (s Subspace) checkType(store sdk.KVStore, key []byte, param interface{}) {
+	attr, ok := s.table.m[string(key)]
 	if !ok {
 		panic("Parameter not registered")
 	}
 
+	ty := attr.ty
 	pty := reflect.TypeOf(param)
 	if pty.Kind() == reflect.Ptr {
 		pty = pty.Elem()
@@ -130,6 +146,14 @@ func (s Subspace) Set(ctx sdk.Context, key []byte, param interface{}) {
 	if pty != ty {
 		panic("Type mismatch with registered table")
 	}
+}
+
+// Set stores the parameter. It returns error if stored parameter has different type from input.
+// It also set to the transient store to record change.
+func (s Subspace) Set(ctx sdk.Context, key []byte, param interface{}) {
+	store := s.kvStore(ctx)
+
+	s.checkType(store, key, param)
 
 	bz, err := s.cdc.MarshalJSON(param)
 	if err != nil {
@@ -142,16 +166,35 @@ func (s Subspace) Set(ctx sdk.Context, key []byte, param interface{}) {
 
 }
 
+// SetWithSubkey set a parameter with a key and subkey
+// Checks parameter type only over the key
+func (s Subspace) SetWithSubkey(ctx sdk.Context, key []byte, subkey []byte, param interface{}) {
+	store := s.kvStore(ctx)
+
+	s.checkType(store, key, param)
+
+	newkey := concatKeys(key, subkey)
+
+	bz, err := s.cdc.MarshalJSON(param)
+	if err != nil {
+		panic(err)
+	}
+	store.Set(newkey, bz)
+
+	tstore := s.transientStore(ctx)
+	tstore.Set(newkey, []byte{})
+}
+
 // Get to ParamSet
 func (s Subspace) GetParamSet(ctx sdk.Context, ps ParamSet) {
-	for _, pair := range ps.KeyValuePairs() {
+	for _, pair := range ps.ParamSetPairs() {
 		s.Get(ctx, pair.Key, pair.Value)
 	}
 }
 
 // Set from ParamSet
 func (s Subspace) SetParamSet(ctx sdk.Context, ps ParamSet) {
-	for _, pair := range ps.KeyValuePairs() {
+	for _, pair := range ps.ParamSetPairs() {
 		// pair.Field is a pointer to the field, so indirecting the ptr.
 		// go-amino automatically handles it but just for sure,
 		// since SetStruct is meant to be used in InitGenesis

x/params/subspace/table.go

@@ -4,19 +4,23 @@ import (
 	"reflect"
 )
 
-// TypeTable subspaces appropriate type for each parameter key
-type TypeTable struct {
-	m map[string]reflect.Type
+type attribute struct {
+	ty reflect.Type
+}
+
+// KeyTable subspaces appropriate type for each parameter key
+type KeyTable struct {
+	m map[string]attribute
 }
 
 // Constructs new table
-func NewTypeTable(keytypes ...interface{}) (res TypeTable) {
+func NewKeyTable(keytypes ...interface{}) (res KeyTable) {
 	if len(keytypes)%2 != 0 {
-		panic("odd number arguments in NewTypeTypeTable")
+		panic("odd number arguments in NewTypeKeyTable")
 	}
 
-	res = TypeTable{
-		m: make(map[string]reflect.Type),
+	res = KeyTable{
+		m: make(map[string]attribute),
 	}
 
 	for i := 0; i < len(keytypes); i += 2 {
@@ -38,7 +42,7 @@ func isAlphaNumeric(key []byte) bool {
 }
 
 // Register single key-type pair
-func (t TypeTable) RegisterType(key []byte, ty interface{}) TypeTable {
+func (t KeyTable) RegisterType(key []byte, ty interface{}) KeyTable {
 	if len(key) == 0 {
 		panic("cannot register empty key")
 	}
@@ -57,20 +61,22 @@ func (t TypeTable) RegisterType(key []byte, ty interface{}) TypeTable {
 		rty = rty.Elem()
 	}
 
-	t.m[keystr] = rty
+	t.m[keystr] = attribute{
+		ty: rty,
+	}
 
 	return t
 }
 
 // Register multiple pairs from ParamSet
-func (t TypeTable) RegisterParamSet(ps ParamSet) TypeTable {
-	for _, kvp := range ps.KeyValuePairs() {
+func (t KeyTable) RegisterParamSet(ps ParamSet) KeyTable {
+	for _, kvp := range ps.ParamSetPairs() {
 		t = t.RegisterType(kvp.Key, kvp.Value)
 	}
 	return t
 }
 
-func (t TypeTable) maxKeyLength() (res int) {
+func (t KeyTable) maxKeyLength() (res int) {
 	for k := range t.m {
 		l := len(k)
 		if l > res {

x/params/subspace/table_test.go

@@ -11,15 +11,15 @@ type testparams struct {
 	b bool
 }
 
-func (tp *testparams) KeyValuePairs() KeyValuePairs {
-	return KeyValuePairs{
+func (tp *testparams) ParamSetPairs() ParamSetPairs {
+	return ParamSetPairs{
 		{[]byte("i"), &tp.i},
 		{[]byte("b"), &tp.b},
 	}
 }
 
-func TestTypeTable(t *testing.T) {
-	table := NewTypeTable()
+func TestKeyTable(t *testing.T) {
+	table := NewKeyTable()
 
 	require.Panics(t, func() { table.RegisterType([]byte(""), nil) })
 	require.Panics(t, func() { table.RegisterType([]byte("!@#$%"), nil) })