certusone
/
cosmos-sdk
mirror of https://github.com/certusone/cosmos-sdk.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

address comments

This commit is contained in:
mossid 2018-09-28 03:52:29 +09:00
parent a43a97bf10
commit e7de48e375
12 changed files with 89 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
store/gaskvstore_test.go
View File

@ -13,13 +13,13 @@ import (
func newGasKVStore() KVStore {
meter := sdk.NewGasMeter(1000)
mem := dbStoreAdapter{dbm.NewMemDB()}
return NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
return NewGasKVStore(meter, sdk.KVGasConfig(), mem)
}
func TestGasKVStoreBasic(t *testing.T) {
mem := dbStoreAdapter{dbm.NewMemDB()}
meter := sdk.NewGasMeter(1000)
st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
require.Empty(t, st.Get(keyFmt(1)), "Expected `key1` to be empty")
st.Set(keyFmt(1), valFmt(1))
require.Equal(t, valFmt(1), st.Get(keyFmt(1)))
@ -31,7 +31,7 @@ func TestGasKVStoreBasic(t *testing.T) {
func TestGasKVStoreIterator(t *testing.T) {
mem := dbStoreAdapter{dbm.NewMemDB()}
meter := sdk.NewGasMeter(1000)
st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
require.Empty(t, st.Get(keyFmt(1)), "Expected `key1` to be empty")
require.Empty(t, st.Get(keyFmt(2)), "Expected `key2` to be empty")
st.Set(keyFmt(1), valFmt(1))
@ -55,14 +55,14 @@ func TestGasKVStoreIterator(t *testing.T) {
func TestGasKVStoreOutOfGasSet(t *testing.T) {
mem := dbStoreAdapter{dbm.NewMemDB()}
meter := sdk.NewGasMeter(0)
st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
require.Panics(t, func() { st.Set(keyFmt(1), valFmt(1)) }, "Expected out-of-gas")
}
func TestGasKVStoreOutOfGasIterator(t *testing.T) {
mem := dbStoreAdapter{dbm.NewMemDB()}
meter := sdk.NewGasMeter(200)
st := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
st := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
st.Set(keyFmt(1), valFmt(1))
iterator := st.Iterator(nil, nil)
iterator.Next()

2
store/prefixstore_test.go
View File

@ -81,7 +81,7 @@ func TestCacheKVStorePrefix(t *testing.T) {
func TestGasKVStorePrefix(t *testing.T) {
meter := sdk.NewGasMeter(100000000)
mem := dbStoreAdapter{dbm.NewMemDB()}
gasStore := NewGasKVStore(meter, sdk.DefaultKVGasConfig(), mem)
gasStore := NewGasKVStore(meter, sdk.KVGasConfig(), mem)
testPrefixStore(t, gasStore, []byte("test"))
}

8
x/gov/keeper.go
View File

@ -13,10 +13,10 @@ const (
)
// Parameter store key
const (
ParamStoreKeyDepositProcedure = "depositprocedure"
ParamStoreKeyVotingProcedure = "votingprocedure"
ParamStoreKeyTallyingProcedure = "tallyingprocedure"
var (
ParamStoreKeyDepositProcedure = []byte("depositprocedure")
ParamStoreKeyVotingProcedure = []byte("votingprocedure")
ParamStoreKeyTallyingProcedure = []byte("tallyingprocedure")
)
// Governance Keeper

14
x/gov/keeper_test.go
View File

@ -67,8 +67,8 @@ func TestDeposits(t *testing.T) {
fourSteak := sdk.Coins{sdk.NewInt64Coin("steak", 4)}
fiveSteak := sdk.Coins{sdk.NewInt64Coin("steak", 5)}
addr0Initial := keeper.bk.GetCoins(ctx, addrs[0])
addr1Initial := keeper.bk.GetCoins(ctx, addrs[1])
addr0Initial := keeper.ck.GetCoins(ctx, addrs[0])
addr1Initial := keeper.ck.GetCoins(ctx, addrs[1])
// require.True(t, addr0Initial.IsEqual(sdk.Coins{sdk.NewInt64Coin("steak", 42)}))
require.Equal(t, sdk.Coins{sdk.NewInt64Coin("steak", 42)}, addr0Initial)
@ -90,7 +90,7 @@ func TestDeposits(t *testing.T) {
require.Equal(t, fourSteak, deposit.Amount)
require.Equal(t, addrs[0], deposit.Depositer)
require.Equal(t, fourSteak, keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
require.Equal(t, addr0Initial.Minus(fourSteak), keeper.bk.GetCoins(ctx, addrs[0]))
require.Equal(t, addr0Initial.Minus(fourSteak), keeper.ck.GetCoins(ctx, addrs[0]))
// Check a second deposit from same address
err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[0], fiveSteak)
@ -101,7 +101,7 @@ func TestDeposits(t *testing.T) {
require.Equal(t, fourSteak.Plus(fiveSteak), deposit.Amount)
require.Equal(t, addrs[0], deposit.Depositer)
require.Equal(t, fourSteak.Plus(fiveSteak), keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
require.Equal(t, addr0Initial.Minus(fourSteak).Minus(fiveSteak), keeper.bk.GetCoins(ctx, addrs[0]))
require.Equal(t, addr0Initial.Minus(fourSteak).Minus(fiveSteak), keeper.ck.GetCoins(ctx, addrs[0]))
// Check third deposit from a new address
err, votingStarted = keeper.AddDeposit(ctx, proposalID, addrs[1], fourSteak)
@ -112,7 +112,7 @@ func TestDeposits(t *testing.T) {
require.Equal(t, addrs[1], deposit.Depositer)
require.Equal(t, fourSteak, deposit.Amount)
require.Equal(t, fourSteak.Plus(fiveSteak).Plus(fourSteak), keeper.GetProposal(ctx, proposalID).GetTotalDeposit())
require.Equal(t, addr1Initial.Minus(fourSteak), keeper.bk.GetCoins(ctx, addrs[1]))
require.Equal(t, addr1Initial.Minus(fourSteak), keeper.ck.GetCoins(ctx, addrs[1]))
// Check that proposal moved to voting period
require.True(t, keeper.GetProposal(ctx, proposalID).GetVotingStartTime().Equal(ctx.BlockHeader().Time))
@ -140,8 +140,8 @@ func TestDeposits(t *testing.T) {
keeper.RefundDeposits(ctx, proposalID)
deposit, found = keeper.GetDeposit(ctx, proposalID, addrs[1])
require.False(t, found)
require.Equal(t, addr0Initial, keeper.bk.GetCoins(ctx, addrs[0]))
require.Equal(t, addr1Initial, keeper.bk.GetCoins(ctx, addrs[1]))
require.Equal(t, addr0Initial, keeper.ck.GetCoins(ctx, addrs[0]))
require.Equal(t, addr1Initial, keeper.ck.GetCoins(ctx, addrs[1]))
}

25
x/params/client/utils/utils.go
View File

@ -1,25 +0,0 @@
package utils
import (
"github.com/cosmos/cosmos-sdk/client/context"
"github.com/cosmos/cosmos-sdk/x/params"
)
// TODO: remove hardcoded storename
const storeName = "params"
// Query parameters from node with CLIContext
func QueryParams(cliCtx context.CLIContext, subStoreName string, ps params.ParamStruct) error {
m := make(map[string][]byte)
for _, p := range ps.KeyFieldPairs() {
key := p.Key
bz, err := cliCtx.QueryStore([]byte(subStoreName+"/"+key), storeName)
if err != nil {
return err
}
m[key] = bz
}
return params.UnmarshalParamsFromMap(m, cliCtx.Codec, ps)
}

30
x/params/keeper_test.go
View File

@ -59,19 +59,19 @@ func TestKeeper(t *testing.T) {
store := NewKeeper(codec.New(), skey, tkey).Substore("test")
for i, kv := range kvs {
require.NotPanics(t, func() { store.Set(ctx, kv.key, kv.param) }, "store.Set panics, tc #%d", i)
require.NotPanics(t, func() { store.Set(ctx, []byte(kv.key), kv.param) }, "store.Set panics, tc #%d", i)
}
for i, kv := range kvs {
var param int64
require.NotPanics(t, func() { store.Get(ctx, kv.key, &param) }, "store.Get panics, tc #%d", i)
require.NotPanics(t, func() { store.Get(ctx, []byte(kv.key), &param) }, "store.Get panics, tc #%d", i)
require.Equal(t, kv.param, param, "stored param not equal, tc #%d", i)
}
cdc := codec.New()
for i, kv := range kvs {
var param int64
bz := store.GetRaw(ctx, kv.key)
bz := store.GetRaw(ctx, []byte(kv.key))
err := cdc.UnmarshalJSON(bz, &param)
require.Nil(t, err, "err is not nil, tc #%d", i)
require.Equal(t, kv.param, param, "stored param not equal, tc #%d", i)
@ -79,11 +79,11 @@ func TestKeeper(t *testing.T) {
for i, kv := range kvs {
var param bool
require.Panics(t, func() { store.Get(ctx, kv.key, &param) }, "invalid store.Get not panics, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, []byte(kv.key), &param) }, "invalid store.Get not panics, tc #%d", i)
}
for i, kv := range kvs {
require.Panics(t, func() { store.Set(ctx, kv.key, true) }, "invalid store.Set not panics, tc #%d", i)
require.Panics(t, func() { store.Set(ctx, []byte(kv.key), true) }, "invalid store.Set not panics, tc #%d", i)
}
}
@ -116,26 +116,26 @@ func TestGet(t *testing.T) {
}
for i, kv := range kvs {
require.False(t, store.Modified(ctx, kv.key), "store.Modified returns true before setting, tc #%d", i)
require.NotPanics(t, func() { store.Set(ctx, kv.key, kv.param) }, "store.Set panics, tc #%d", i)
require.True(t, store.Modified(ctx, kv.key), "store.Modified returns false after setting, tc #%d", i)
require.False(t, store.Modified(ctx, []byte(kv.key)), "store.Modified returns true before setting, tc #%d", i)
require.NotPanics(t, func() { store.Set(ctx, []byte(kv.key), kv.param) }, "store.Set panics, tc #%d", i)
require.True(t, store.Modified(ctx, []byte(kv.key)), "store.Modified returns false after setting, tc #%d", i)
}
for i, kv := range kvs {
require.NotPanics(t, func() { store.GetIfExists(ctx, "invalid", kv.ptr) }, "store.GetIfExists panics when no value exists, tc #%d", i)
require.NotPanics(t, func() { store.GetIfExists(ctx, []byte("invalid"), kv.ptr) }, "store.GetIfExists panics when no value exists, tc #%d", i)
require.Equal(t, kv.zero, reflect.ValueOf(kv.ptr).Elem().Interface(), "store.GetIfExists unmarshalls when no value exists, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, "invalid", kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, []byte("invalid"), kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
require.Equal(t, kv.zero, reflect.ValueOf(kv.ptr).Elem().Interface(), "invalid store.Get unmarshalls when no value exists, tc #%d", i)
require.NotPanics(t, func() { store.GetIfExists(ctx, kv.key, kv.ptr) }, "store.GetIfExists panics, tc #%d", i)
require.NotPanics(t, func() { store.GetIfExists(ctx, []byte(kv.key), kv.ptr) }, "store.GetIfExists panics, tc #%d", i)
require.Equal(t, kv.param, reflect.ValueOf(kv.ptr).Elem().Interface(), "stored param not equal, tc #%d", i)
require.NotPanics(t, func() { store.Get(ctx, kv.key, kv.ptr) }, "store.Get panics, tc #%d", i)
require.NotPanics(t, func() { store.Get(ctx, []byte(kv.key), kv.ptr) }, "store.Get panics, tc #%d", i)
require.Equal(t, kv.param, reflect.ValueOf(kv.ptr).Elem().Interface(), "stored param not equal, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, "invalid", kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, []byte("invalid"), kv.ptr) }, "invalid store.Get not panics when no value exists, tc #%d", i)
require.Equal(t, kv.param, reflect.ValueOf(kv.ptr).Elem().Interface(), "invalid store.Get unmarshalls when no value existt, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, kv.key, nil) }, "invalid store.Get not panics when the pointer is nil, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, kv.key, new(invalid)) }, "invalid store.Get not panics when the pointer is different type, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, []byte(kv.key), nil) }, "invalid store.Get not panics when the pointer is nil, tc #%d", i)
require.Panics(t, func() { store.Get(ctx, []byte(kv.key), new(invalid)) }, "invalid store.Get not panics when the pointer is different type, tc #%d", i)
}
}

4
x/params/store/pair.go
View File

@ -6,7 +6,7 @@ import (
// Used for associating paramstore key and field of param structs
type KeyFieldPair struct {
Key string
Key []byte
Field interface{}
}
@ -22,7 +22,7 @@ type ParamStruct interface {
// unmarshalles it to ParamStruct
func UnmarshalParamsFromMap(m map[string][]byte, cdc *codec.Codec, ps ParamStruct) error {
for _, p := range ps.KeyFieldPairs() {
err := cdc.UnmarshalJSON(m[p.Key], p.Field)
err := cdc.UnmarshalJSON(m[string(p.Key)], p.Field)
if err != nil {
return err
}

45
x/params/store/store.go
View File

@ -41,9 +41,9 @@ func (s Store) transientStore(ctx sdk.Context) sdk.KVStore {
}
// Get parameter from store
func (s Store) Get(ctx sdk.Context, key string, ptr interface{}) {
func (s Store) Get(ctx sdk.Context, key []byte, ptr interface{}) {
store := s.kvStore(ctx)
bz := store.Get([]byte(key))
bz := store.Get(key)
err := s.cdc.UnmarshalJSON(bz, ptr)
if err != nil {
panic(err)
@ -51,9 +51,9 @@ func (s Store) Get(ctx sdk.Context, key string, ptr interface{}) {
}
// GetIfExists do not modify ptr if the stored parameter is nil
func (s Store) GetIfExists(ctx sdk.Context, key string, ptr interface{}) {
func (s Store) GetIfExists(ctx sdk.Context, key []byte, ptr interface{}) {
store := s.kvStore(ctx)
bz := store.Get([]byte(key))
bz := store.Get(key)
if bz == nil {
return
}
@ -64,31 +64,30 @@ func (s Store) GetIfExists(ctx sdk.Context, key string, ptr interface{}) {
}
// Get raw bytes of parameter from store
func (s Store) GetRaw(ctx sdk.Context, key string) []byte {
func (s Store) GetRaw(ctx sdk.Context, key []byte) []byte {
store := s.kvStore(ctx)
res := store.Get([]byte(key))
res := store.Get(key)
return res
}
// Check if the parameter is set in the store
func (s Store) Has(ctx sdk.Context, key string) bool {
func (s Store) Has(ctx sdk.Context, key []byte) bool {
store := s.kvStore(ctx)
return store.Has([]byte(key))
return store.Has(key)
}
// Returns true if the parameter is set in the block
func (s Store) Modified(ctx sdk.Context, key string) bool {
func (s Store) Modified(ctx sdk.Context, key []byte) bool {
tstore := s.transientStore(ctx)
return tstore.Has([]byte(key))
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 Store) Set(ctx sdk.Context, key string, param interface{}) {
func (s Store) Set(ctx sdk.Context, key []byte, param interface{}) {
store := s.kvStore(ctx)
keybz := []byte(key)
bz := store.Get(keybz)
bz := store.Get(key)
// To prevent invalid parameter set, we check the type of the stored parameter
// and try to match it with the provided parameter. It continues only if they matches.
@ -106,22 +105,20 @@ func (s Store) Set(ctx sdk.Context, key string, param interface{}) {
if err != nil {
panic(err)
}
store.Set(keybz, bz)
store.Set(key, bz)
tstore := s.transientStore(ctx)
tstore.Set(keybz, []byte{})
tstore.Set(key, []byte{})
}
// Set raw bytes of parameter
// Also set to the transient store to record change
func (s Store) SetRaw(ctx sdk.Context, key string, param []byte) {
keybz := []byte(key)
func (s Store) SetRaw(ctx sdk.Context, key []byte, param []byte) {
store := s.kvStore(ctx)
store.Set(keybz, param)
store.Set(key, param)
tstore := s.transientStore(ctx)
tstore.Set(keybz, []byte{})
tstore.Set(key, []byte{})
}
// Get to ParamStruct
@ -154,22 +151,22 @@ type ReadOnlyStore struct {
}
// Exposes Get
func (ros ReadOnlyStore) Get(ctx sdk.Context, key string, ptr interface{}) {
func (ros ReadOnlyStore) Get(ctx sdk.Context, key []byte, ptr interface{}) {
ros.s.Get(ctx, key, ptr)
}
// Exposes GetRaw
func (ros ReadOnlyStore) GetRaw(ctx sdk.Context, key string) []byte {
func (ros ReadOnlyStore) GetRaw(ctx sdk.Context, key []byte) []byte {
return ros.s.GetRaw(ctx, key)
}
// Exposes Has
func (ros ReadOnlyStore) Has(ctx sdk.Context, key string) bool {
func (ros ReadOnlyStore) Has(ctx sdk.Context, key []byte) bool {
return ros.s.Has(ctx, key)
}
// Exposes Modified
func (ros ReadOnlyStore) Modified(ctx sdk.Context, key string) bool {
func (ros ReadOnlyStore) Modified(ctx sdk.Context, key []byte) bool {
return ros.s.Modified(ctx, key)
}

16
x/slashing/params.go
View File

@ -13,14 +13,14 @@ const (
)
// Parameter store key
const (
KeyMaxEvidenceAge = "MaxEvidenceAge"
KeySignedBlocksWindow = "SignedBlocksWindow"
KeyMinSignedPerWindow = "MinSignedPerWindow"
KeyDoubleSignUnbondDuration = "DoubleSignUnbondDuration"
KeyDowntimeUnbondDuration = "DowntimeUnbondDuration"
KeySlashFractionDoubleSign = "SlashFractionDoubleSign"
KeySlashFractionDowntime = "SlashFractionDowntime"
var (
KeyMaxEvidenceAge = []byte("MaxEvidenceAge")
KeySignedBlocksWindow = []byte("SignedBlocksWindow")
KeyMinSignedPerWindow = []byte("MinSignedPerWindow")
KeyDoubleSignUnbondDuration = []byte("DoubleSignUnbondDuration")
KeyDowntimeUnbondDuration = []byte("DowntimeUnbondDuration")
KeySlashFractionDoubleSign = []byte("SlashFractionDoubleSign")
KeySlashFractionDowntime = []byte("SlashFractionDowntime")
)
// Params - used for initializing default parameter for slashing at genesis

9
x/stake/client/cli/query.go
View File

@ -10,7 +10,6 @@ import (
"github.com/cosmos/cosmos-sdk/client/context"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
paramutils "github.com/cosmos/cosmos-sdk/x/params/client/utils"
"github.com/cosmos/cosmos-sdk/x/stake"
"github.com/cosmos/cosmos-sdk/x/stake/types"
)
@ -466,9 +465,13 @@ func GetCmdQueryParams(storeName string, cdc *codec.Codec) *cobra.Command {
Args: cobra.NoArgs,
RunE: func(cmd *cobra.Command, args []string) error {
cliCtx := context.NewCLIContext().WithCodec(cdc)
bz, err := cliCtx.QueryWithData("custom/stake/"+stake.QueryParameters, nil)
if err != nil {
return err
}
var params types.Params
err := paramutils.QueryParams(cliCtx, storeName, &params)
var params stake.Params
err = cdc.UnmarshalJSON(bz, &params)
if err != nil {
return err
}

12
x/stake/stake.go
View File

@ -90,6 +90,18 @@ var (
NewQuerier = querier.NewQuerier
)
const (
QueryValidators = querier.QueryValidators
QueryValidator = querier.QueryValidator
QueryDelegator = querier.QueryDelegator
QueryDelegation = querier.QueryDelegation
QueryUnbondingDelegation = querier.QueryUnbondingDelegation
QueryDelegatorValidators = querier.QueryDelegatorValidators
QueryDelegatorValidator = querier.QueryDelegatorValidator
QueryPool = querier.QueryPool
QueryParameters = querier.QueryParameters
)
const (
DefaultCodespace = types.DefaultCodespace
CodeInvalidValidator = types.CodeInvalidValidator

16
x/stake/types/params.go
View File

@ -15,14 +15,14 @@ import (
const defaultUnbondingTime time.Duration = 60 * 60 * 24 * 3 * time.Second
// nolint - Keys for parameter access
const (
KeyInflationRateChange = "InflationRateChange"
KeyInflationMax = "InflationMax"
KeyInflationMin = "InflationMin"
KeyGoalBonded = "GoalBonded"
KeyUnbondingTime = "UnbondingTime"
KeyMaxValidators = "MaxValidators"
KeyBondDenom = "BondDenom"
var (
KeyInflationRateChange = []byte("InflationRateChange")
KeyInflationMax = []byte("InflationMax")
KeyInflationMin = []byte("InflationMin")
KeyGoalBonded = []byte("GoalBonded")
KeyUnbondingTime = []byte("UnbondingTime")
KeyMaxValidators = []byte("MaxValidators")
KeyBondDenom = []byte("BondDenom")
)
// Params defines the high level settings for staking