LaconicNetwork/cosmos-sdk
7
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

reduce module interdependancy, /client refactor (#4415)

Browse Source 
* abstract staking BuildCreateValidatorMsg, genutil defines its own flags

* client/ refactor

* staking move keys from keeper to types
This commit is contained in:
frog power 4000
2019-05-28 09:44:04 +01:00
committed by Alessio Treglia
parent 91e75cb74a
commit 73e5ef7c13
72 changed files with 854 additions and 659 deletions
Download Patch File Download Diff File Expand all files Collapse all files
x/staking/client/cli/query.go
+31 -31
View File
@@ -10,7 +10,7 @@ import (
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/version"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/cosmos/cosmos-sdk/x/staking/querier"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
@@ -37,7 +37,7 @@ $ %s query staking validator cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhff
return err
}
res, err := cliCtx.QueryStore(staking.GetValidatorKey(addr), storeName)
res, err := cliCtx.QueryStore(types.GetValidatorKey(addr), storeName)
if err != nil {
return err
}
@@ -69,12 +69,12 @@ $ %s query staking validators
RunE: func(cmd *cobra.Command, args []string) error {
cliCtx := context.NewCLIContext().WithCodec(cdc)
resKVs, err := cliCtx.QuerySubspace(staking.ValidatorsKey, storeName)
resKVs, err := cliCtx.QuerySubspace(types.ValidatorsKey, storeName)
if err != nil {
return err
}
var validators staking.Validators
var validators types.Validators
for _, kv := range resKVs {
validators = append(validators, types.MustUnmarshalValidator(cdc, kv.Value))
}
@@ -107,18 +107,18 @@ $ %s query staking unbonding-delegations-from cosmosvaloper1gghjut3ccd8ay0zduzj6
return err
}
bz, err := cdc.MarshalJSON(staking.NewQueryValidatorParams(valAddr))
bz, err := cdc.MarshalJSON(querier.NewQueryValidatorParams(valAddr))
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryValidatorUnbondingDelegations)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryValidatorUnbondingDelegations)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var ubds staking.UnbondingDelegations
var ubds types.UnbondingDelegations
cdc.MustUnmarshalJSON(res, &ubds)
return cliCtx.PrintOutput(ubds)
},
@@ -149,18 +149,18 @@ $ %s query staking redelegations-from cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fx
return err
}
bz, err := cdc.MarshalJSON(staking.QueryRedelegationParams{SrcValidatorAddr: valSrcAddr})
bz, err := cdc.MarshalJSON(querier.QueryRedelegationParams{SrcValidatorAddr: valSrcAddr})
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryRedelegations)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryRedelegations)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var resp staking.RedelegationResponses
var resp types.RedelegationResponses
if err := cdc.UnmarshalJSON(res, &resp); err != nil {
return err
}
@@ -198,18 +198,18 @@ $ %s query staking delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosm
return err
}
bz, err := cdc.MarshalJSON(staking.NewQueryBondsParams(delAddr, valAddr))
bz, err := cdc.MarshalJSON(querier.NewQueryBondsParams(delAddr, valAddr))
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryDelegation)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryDelegation)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var resp staking.DelegationResponse
var resp types.DelegationResponse
if err := cdc.UnmarshalJSON(res, &resp); err != nil {
return err
}
@@ -243,18 +243,18 @@ $ %s query staking delegations cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p
return err
}
bz, err := cdc.MarshalJSON(staking.NewQueryDelegatorParams(delAddr))
bz, err := cdc.MarshalJSON(querier.NewQueryDelegatorParams(delAddr))
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryDelegatorDelegations)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryDelegatorDelegations)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var resp staking.DelegationResponses
var resp types.DelegationResponses
if err := cdc.UnmarshalJSON(res, &resp); err != nil {
return err
}
@@ -288,18 +288,18 @@ $ %s query staking delegations-to cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ld
return err
}
bz, err := cdc.MarshalJSON(staking.NewQueryValidatorParams(valAddr))
bz, err := cdc.MarshalJSON(querier.NewQueryValidatorParams(valAddr))
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryValidatorDelegations)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryValidatorDelegations)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var resp staking.DelegationResponses
var resp types.DelegationResponses
if err := cdc.UnmarshalJSON(res, &resp); err != nil {
return err
}
@@ -338,7 +338,7 @@ $ %s query staking unbonding-delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld7
return err
}
res, err := cliCtx.QueryStore(staking.GetUBDKey(delAddr, valAddr), storeName)
res, err := cliCtx.QueryStore(types.GetUBDKey(delAddr, valAddr), storeName)
if err != nil {
return err
}
@@ -373,12 +373,12 @@ $ %s query staking unbonding-delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld7
return err
}
resKVs, err := cliCtx.QuerySubspace(staking.GetUBDsKey(delegatorAddr), storeName)
resKVs, err := cliCtx.QuerySubspace(types.GetUBDsKey(delegatorAddr), storeName)
if err != nil {
return err
}
var ubds staking.UnbondingDelegations
var ubds types.UnbondingDelegations
for _, kv := range resKVs {
ubds = append(ubds, types.MustUnmarshalUBD(cdc, kv.Value))
}
@@ -422,18 +422,18 @@ $ %s query staking redelegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p co
return err
}
bz, err := cdc.MarshalJSON(staking.NewQueryRedelegationParams(delAddr, valSrcAddr, valDstAddr))
bz, err := cdc.MarshalJSON(querier.NewQueryRedelegationParams(delAddr, valSrcAddr, valDstAddr))
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryRedelegations)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryRedelegations)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var resp staking.RedelegationResponses
var resp types.RedelegationResponses
if err := cdc.UnmarshalJSON(res, &resp); err != nil {
return err
}
@@ -467,18 +467,18 @@ $ %s query staking redelegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p
return err
}
bz, err := cdc.MarshalJSON(staking.QueryRedelegationParams{DelegatorAddr: delAddr})
bz, err := cdc.MarshalJSON(querier.QueryRedelegationParams{DelegatorAddr: delAddr})
if err != nil {
return err
}
route := fmt.Sprintf("custom/%s/%s", storeKey, staking.QueryRedelegations)
route := fmt.Sprintf("custom/%s/%s", storeKey, querier.QueryRedelegations)
res, err := cliCtx.QueryWithData(route, bz)
if err != nil {
return err
}
var resp staking.RedelegationResponses
var resp types.RedelegationResponses
if err := cdc.UnmarshalJSON(res, &resp); err != nil {
return err
}
@@ -506,7 +506,7 @@ $ %s query staking pool
RunE: func(cmd *cobra.Command, args []string) error {
cliCtx := context.NewCLIContext().WithCodec(cdc)
res, err := cliCtx.QueryStore(staking.PoolKey, storeName)
res, err := cliCtx.QueryStore(types.PoolKey, storeName)
if err != nil {
return err
}
@@ -534,13 +534,13 @@ $ %s query staking params
RunE: func(cmd *cobra.Command, args []string) error {
cliCtx := context.NewCLIContext().WithCodec(cdc)
route := fmt.Sprintf("custom/%s/%s", storeName, staking.QueryParameters)
route := fmt.Sprintf("custom/%s/%s", storeName, querier.QueryParameters)
bz, err := cliCtx.QueryWithData(route, nil)
if err != nil {
return err
}
var params staking.Params
var params types.Params
cdc.MustUnmarshalJSON(bz, &params)
return cliCtx.PrintOutput(params)
},
x/staking/client/cli/tx.go
+103 -16
View File
@@ -2,25 +2,28 @@ package cli
import (
"fmt"
"os"
"strings"
"github.com/cosmos/cosmos-sdk/version"
"github.com/cosmos/cosmos-sdk/x/auth"
"github.com/spf13/cobra"
flag "github.com/spf13/pflag"
"github.com/spf13/viper"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/context"
"github.com/cosmos/cosmos-sdk/client/utils"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/version"
"github.com/cosmos/cosmos-sdk/x/auth"
authtxb "github.com/cosmos/cosmos-sdk/x/auth/client/txbuilder"
"github.com/cosmos/cosmos-sdk/x/staking"
"github.com/spf13/cobra"
"github.com/spf13/viper"
"github.com/cosmos/cosmos-sdk/x/staking/types"
)
// GetCmdCreateValidator implements the create validator command handler.
// TODO: Add full description
func GetCmdCreateValidator(cdc *codec.Codec) *cobra.Command {
cmd := &cobra.Command{
Use: "create-validator",
@@ -70,7 +73,7 @@ func GetCmdEditValidator(cdc *codec.Codec) *cobra.Command {
WithAccountDecoder(cdc)
valAddr := cliCtx.GetFromAddress()
description := staking.Description{
description := types.Description{
Moniker: viper.GetString(FlagMoniker),
Identity: viper.GetString(FlagIdentity),
Website: viper.GetString(FlagWebsite),
@@ -95,12 +98,12 @@ func GetCmdEditValidator(cdc *codec.Codec) *cobra.Command {
if minSelfDelegationString != "" {
msb, ok := sdk.NewIntFromString(minSelfDelegationString)
if !ok {
return fmt.Errorf(staking.ErrMinSelfDelegationInvalid(staking.DefaultCodespace).Error())
return fmt.Errorf(types.ErrMinSelfDelegationInvalid(types.DefaultCodespace).Error())
}
newMinSelfDelegation = &msb
}
msg := staking.NewMsgEditValidator(sdk.ValAddress(valAddr), description, newRate, newMinSelfDelegation)
msg := types.NewMsgEditValidator(sdk.ValAddress(valAddr), description, newRate, newMinSelfDelegation)
// build and sign the transaction, then broadcast to Tendermint
return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
@@ -145,7 +148,7 @@ $ %s tx staking delegate cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm 10
return err
}
msg := staking.NewMsgDelegate(delAddr, valAddr, amount)
msg := types.NewMsgDelegate(delAddr, valAddr, amount)
return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
},
}
@@ -188,7 +191,7 @@ $ %s tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj
return err
}
msg := staking.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, amount)
msg := types.NewMsgBeginRedelegate(delAddr, valSrcAddr, valDstAddr, amount)
return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
},
}
@@ -226,12 +229,96 @@ $ %s tx staking unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100s
return err
}
msg := staking.NewMsgUndelegate(delAddr, valAddr, amount)
msg := types.NewMsgUndelegate(delAddr, valAddr, amount)
return utils.GenerateOrBroadcastMsgs(cliCtx, txBldr, []sdk.Msg{msg})
},
}
}
//__________________________________________________________
var (
defaultTokens = sdk.TokensFromTendermintPower(100)
defaultAmount = defaultTokens.String() + sdk.DefaultBondDenom
defaultCommissionRate = "0.1"
defaultCommissionMaxRate = "0.2"
defaultCommissionMaxChangeRate = "0.01"
defaultMinSelfDelegation = "1"
)
// Return the flagset, particular flags, and a description of defaults
// this is anticipated to be used with the gen-tx
func CreateValidatorMsgHelpers(ipDefault string) (fs *flag.FlagSet, nodeIDFlag, pubkeyFlag, amountFlag, defaultsDesc string) {
fsCreateValidator := flag.NewFlagSet("", flag.ContinueOnError)
fsCreateValidator.String(FlagIP, ipDefault, "The node's public IP")
fsCreateValidator.String(FlagNodeID, "", "The node's NodeID")
fsCreateValidator.String(FlagWebsite, "", "The validator's (optional) website")
fsCreateValidator.String(FlagDetails, "", "The validator's (optional) details")
fsCreateValidator.String(FlagIdentity, "", "The (optional) identity signature (ex. UPort or Keybase)")
fsCreateValidator.AddFlagSet(FsCommissionCreate)
fsCreateValidator.AddFlagSet(FsMinSelfDelegation)
fsCreateValidator.AddFlagSet(FsAmount)
fsCreateValidator.AddFlagSet(FsPk)
defaultsDesc = fmt.Sprintf(`
delegation amount: %s
commission rate: %s
commission max rate: %s
commission max change rate: %s
minimum self delegation: %s
`, defaultAmount, defaultCommissionRate,
defaultCommissionMaxRate, defaultCommissionMaxChangeRate,
defaultMinSelfDelegation)
return fsCreateValidator, FlagNodeID, FlagPubKey, FlagAmount, defaultsDesc
}
// prepare flags in config
func PrepareFlagsForTxCreateValidator(
config *cfg.Config, nodeID, chainID string, valPubKey crypto.PubKey,
) {
ip := viper.GetString(FlagIP)
if ip == "" {
fmt.Fprintf(os.Stderr, "couldn't retrieve an external IP; "+
"the tx's memo field will be unset")
}
website := viper.GetString(FlagWebsite)
details := viper.GetString(FlagDetails)
identity := viper.GetString(FlagIdentity)
viper.Set(client.FlagChainID, chainID)
viper.Set(client.FlagFrom, viper.GetString(client.FlagName))
viper.Set(FlagNodeID, nodeID)
viper.Set(FlagIP, ip)
viper.Set(FlagPubKey, sdk.MustBech32ifyConsPub(valPubKey))
viper.Set(FlagMoniker, config.Moniker)
viper.Set(FlagWebsite, website)
viper.Set(FlagDetails, details)
viper.Set(FlagIdentity, identity)
if config.Moniker == "" {
viper.Set(FlagMoniker, viper.GetString(client.FlagName))
}
if viper.GetString(FlagAmount) == "" {
viper.Set(FlagAmount, defaultAmount)
}
if viper.GetString(FlagCommissionRate) == "" {
viper.Set(FlagCommissionRate, defaultCommissionRate)
}
if viper.GetString(FlagCommissionMaxRate) == "" {
viper.Set(FlagCommissionMaxRate, defaultCommissionMaxRate)
}
if viper.GetString(FlagCommissionMaxChangeRate) == "" {
viper.Set(FlagCommissionMaxChangeRate, defaultCommissionMaxChangeRate)
}
if viper.GetString(FlagMinSelfDelegation) == "" {
viper.Set(FlagMinSelfDelegation, defaultMinSelfDelegation)
}
}
// BuildCreateValidatorMsg makes a new MsgCreateValidator.
func BuildCreateValidatorMsg(cliCtx context.CLIContext, txBldr authtxb.TxBuilder) (authtxb.TxBuilder, sdk.Msg, error) {
amounstStr := viper.GetString(FlagAmount)
@@ -248,7 +335,7 @@ func BuildCreateValidatorMsg(cliCtx context.CLIContext, txBldr authtxb.TxBuilder
return txBldr, nil, err
}
description := staking.NewDescription(
description := types.NewDescription(
viper.GetString(FlagMoniker),
viper.GetString(FlagIdentity),
viper.GetString(FlagWebsite),
@@ -268,10 +355,10 @@ func BuildCreateValidatorMsg(cliCtx context.CLIContext, txBldr authtxb.TxBuilder
msbStr := viper.GetString(FlagMinSelfDelegation)
minSelfDelegation, ok := sdk.NewIntFromString(msbStr)
if !ok {
return txBldr, nil, fmt.Errorf(staking.ErrMinSelfDelegationInvalid(staking.DefaultCodespace).Error())
return txBldr, nil, fmt.Errorf(types.ErrMinSelfDelegationInvalid(types.DefaultCodespace).Error())
}
msg := staking.NewMsgCreateValidator(
msg := types.NewMsgCreateValidator(
sdk.ValAddress(valAddr), pk, amount, description, commissionMsg, minSelfDelegation,
)
x/staking/client/cli/tx_test.go
+84
View File
@@ -0,0 +1,84 @@
package cli
import (
"testing"
"github.com/spf13/viper"
"github.com/stretchr/testify/require"
tcmd "github.com/tendermint/tendermint/cmd/tendermint/commands"
cfg "github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/crypto"
"github.com/tendermint/tendermint/libs/log"
"github.com/cosmos/cosmos-sdk/server"
sdk "github.com/cosmos/cosmos-sdk/types"
)
func TestPrepareFlagsForTxCreateValidator(t *testing.T) {
defer server.SetupViper(t)()
config, err := tcmd.ParseConfig()
require.Nil(t, err)
logger := log.NewNopLogger()
ctx := server.NewContext(config, logger)
valPubKey, _ := sdk.GetConsPubKeyBech32("cosmosvalconspub1zcjduepq7jsrkl9fgqk0wj3ahmfr8pgxj6vakj2wzn656s8pehh0zhv2w5as5gd80a")
type args struct {
config *cfg.Config
nodeID string
chainID string
valPubKey crypto.PubKey
}
type extraParams struct {
amount string
commissionRate string
commissionMaxRate string
commissionMaxChangeRate string
minSelfDelegation string
}
type testcase struct {
name string
args args
}
runTest := func(t *testing.T, tt testcase, params extraParams) {
PrepareFlagsForTxCreateValidator(tt.args.config, tt.args.nodeID,
tt.args.chainID, tt.args.valPubKey)
require.Equal(t, params.amount, viper.GetString(FlagAmount))
require.Equal(t, params.commissionRate, viper.GetString(FlagCommissionRate))
require.Equal(t, params.commissionMaxRate, viper.GetString(FlagCommissionMaxRate))
require.Equal(t, params.commissionMaxChangeRate, viper.GetString(FlagCommissionMaxChangeRate))
require.Equal(t, params.minSelfDelegation, viper.GetString(FlagMinSelfDelegation))
}
tests := []testcase{
{"No parameters", args{ctx.Config, "X", "chainId", valPubKey}},
}
defaultParams := extraParams{
defaultAmount,
defaultCommissionRate,
defaultCommissionMaxRate,
defaultCommissionMaxChangeRate,
defaultMinSelfDelegation,
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Run(tt.name, func(t *testing.T) { runTest(t, tt, defaultParams) })
})
}
// Override default params
params := extraParams{"5stake", "1.0", "1.0", "1.0", "1.0"}
viper.Set(FlagAmount, params.amount)
viper.Set(FlagCommissionRate, params.commissionRate)
viper.Set(FlagCommissionMaxRate, params.commissionMaxRate)
viper.Set(FlagCommissionMaxChangeRate, params.commissionMaxChangeRate)
viper.Set(FlagMinSelfDelegation, params.minSelfDelegation)
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) { runTest(t, tt, params) })
}
}