add update params message

x/tradeshield/client/cli/tx_update_params.go

@@ -1,40 +1,196 @@
 package cli
 
 import (
-	"strconv"
+	"errors"
 
 	"github.com/cosmos/cosmos-sdk/client"
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/client/tx"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/cosmos/cosmos-sdk/types/address"
+	"github.com/cosmos/cosmos-sdk/x/gov/client/cli"
+	v1 "github.com/cosmos/cosmos-sdk/x/gov/types/v1"
 	"github.com/elys-network/elys/x/tradeshield/types"
 	"github.com/spf13/cobra"
 )
 
-var _ = strconv.Itoa(0)
+const (
+	FlagMarketOrderEnabled   = "market-order-enabled"
+	FlagStakeEnabled         = "stake-enabled"
+	FlagProcessOrdersEnabled = "process-orders-enabled"
+	FlagSwapEnabled          = "swap-enabled"
+	FlagPerpetualEnabled     = "perpetual-enabled"
+	FlagRewardEnabled        = "reward-enabled"
+	FlagLeverageEnabled      = "leverage-enabled"
+	FlagLimitProcessOrder    = "limit-process-order"
+	FlagRewardPercentage     = "reward-percentage"
+	FlagMarginError          = "margin-error"
+	FlagMinimumDeposit       = "minimum-deposit"
+)
 
+// Governance command
 func CmdUpdateParams() *cobra.Command {
 	cmd := &cobra.Command{
 		Use:   "update-params",
-		Short: "Broadcast message update-params",
-		Args:  cobra.ExactArgs(0),
-		RunE: func(cmd *cobra.Command, args []string) (err error) {
-
+		Short: "Update tradeshield params",
+		RunE: func(cmd *cobra.Command, args []string) error {
 			clientCtx, err := client.GetClientTxContext(cmd)
 			if err != nil {
 				return err
 			}
 
+			title, err := cmd.Flags().GetString(cli.FlagTitle)
+			if err != nil {
+				return err
+			}
+
+			summary, err := cmd.Flags().GetString(cli.FlagSummary)
+			if err != nil {
+				return err
+			}
+
+			metadata, err := cmd.Flags().GetString(cli.FlagMetadata)
+			if err != nil {
+				return err
+			}
+
+			marketOrderEnabled, err := cmd.Flags().GetBool(FlagMarketOrderEnabled)
+			if err != nil {
+				return err
+			}
+
+			stakeEnabled, err := cmd.Flags().GetBool(FlagStakeEnabled)
+			if err != nil {
+				return err
+			}
+
+			processOrdersEnabled, err := cmd.Flags().GetBool(FlagProcessOrdersEnabled)
+			if err != nil {
+				return err
+			}
+
+			swapEnabled, err := cmd.Flags().GetBool(FlagSwapEnabled)
+			if err != nil {
+				return err
+			}
+
+			perpetualEnabled, err := cmd.Flags().GetBool(FlagPerpetualEnabled)
+			if err != nil {
+				return err
+			}
+
+			rewardEnabled, err := cmd.Flags().GetBool(FlagRewardEnabled)
+			if err != nil {
+				return err
+			}
+
+			leverageEnabled, err := cmd.Flags().GetBool(FlagLeverageEnabled)
+			if err != nil {
+				return err
+			}
+
+			limitProcessOrder, err := cmd.Flags().GetUint64(FlagLimitProcessOrder)
+			if err != nil {
+				return err
+			}
+
+			rewardPercentage, err := cmd.Flags().GetString(FlagRewardPercentage)
+			if err != nil {
+				return err
+			}
+
+			marginError, err := cmd.Flags().GetString(FlagMarginError)
+			if err != nil {
+				return err
+			}
+
+			minDeposit, err := cmd.Flags().GetString(FlagMinimumDeposit)
+			if err != nil {
+				return err
+			}
+
+			minimumDeposit, ok := sdk.NewIntFromString(minDeposit)
+			if !ok {
+				return errors.New("invalid minimum deposit amount")
+			}
+
+			params := types.Params{
+				MarketOrderEnabled:   marketOrderEnabled,
+				StakeEnabled:         stakeEnabled,
+				ProcessOrdersEnabled: processOrdersEnabled,
+				SwapEnabled:          swapEnabled,
+				PerpetualEnabled:     perpetualEnabled,
+				RewardEnabled:        rewardEnabled,
+				LeverageEnabled:      leverageEnabled,
+				LimitProcessOrder:    limitProcessOrder,
+				RewardPercentage:     sdk.MustNewDecFromStr(rewardPercentage),
+				MarginError:          sdk.MustNewDecFromStr(marginError),
+				MinimumDeposit:       minimumDeposit,
+			}
+
+			signer := clientCtx.GetFromAddress()
+			if signer == nil {
+				return errors.New("signer address is missing")
+			}
+
+			govAddress := sdk.AccAddress(address.Module("gov"))
 			msg := types.NewMsgUpdateParams(
-				clientCtx.GetFromAddress().String(),
+				govAddress.String(),
+				params,
 			)
+
 			if err := msg.ValidateBasic(); err != nil {
 				return err
 			}
-			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
+
+			depositStr, err := cmd.Flags().GetString(cli.FlagDeposit)
+			if err != nil {
+				return err
+			}
+
+			deposit, err := sdk.ParseCoinsNormalized(depositStr)
+			if err != nil {
+				return err
+			}
+
+			govMsg, err := v1.NewMsgSubmitProposal([]sdk.Msg{msg}, deposit, signer.String(), metadata, title, summary)
+			if err != nil {
+				return err
+			}
+			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), govMsg)
 		},
 	}
 
+	cmd.Flags().Bool(FlagMarketOrderEnabled, false, "market order enabled")
+	cmd.Flags().Bool(FlagStakeEnabled, false, "stake enabled")
+	cmd.Flags().Bool(FlagProcessOrdersEnabled, false, "process order enabled")
+	cmd.Flags().Bool(FlagSwapEnabled, false, "swap enabled")
+	cmd.Flags().Bool(FlagPerpetualEnabled, false, "perpetual enabled")
+	cmd.Flags().Bool(FlagRewardEnabled, false, "reward enabled")
+	cmd.Flags().Bool(FlagLeverageEnabled, false, "leverage enabled")
+	cmd.Flags().Uint64(FlagLimitProcessOrder, 10000000, "max limit order processed")
+	cmd.Flags().String(FlagRewardPercentage, "", "percentage of rewards given to watchers (decimal range 0-1)")
+	cmd.Flags().String(FlagMarginError, "", "percentage of margin error on orders triggered by price (decimal range 0-1)")
+	cmd.Flags().String(FlagMinimumDeposit, "", "minimum deposit amount for watchers")
+	cmd.Flags().String(cli.FlagTitle, "", "title of proposal")
+	cmd.Flags().String(cli.FlagSummary, "", "summary of proposal")
+	cmd.Flags().String(cli.FlagMetadata, "", "metadata of proposal")
+	cmd.Flags().String(cli.FlagDeposit, "", "deposit of proposal")
+	_ = cmd.MarkFlagRequired(FlagMarketOrderEnabled)
+	_ = cmd.MarkFlagRequired(FlagStakeEnabled)
+	_ = cmd.MarkFlagRequired(FlagProcessOrdersEnabled)
+	_ = cmd.MarkFlagRequired(FlagSwapEnabled)
+	_ = cmd.MarkFlagRequired(FlagPerpetualEnabled)
+	_ = cmd.MarkFlagRequired(FlagRewardEnabled)
+	_ = cmd.MarkFlagRequired(FlagLeverageEnabled)
+	_ = cmd.MarkFlagRequired(FlagLimitProcessOrder)
+	_ = cmd.MarkFlagRequired(FlagRewardPercentage)
+	_ = cmd.MarkFlagRequired(FlagMarginError)
+	_ = cmd.MarkFlagRequired(FlagMinimumDeposit)
+	_ = cmd.MarkFlagRequired(cli.FlagTitle)
+	_ = cmd.MarkFlagRequired(cli.FlagSummary)
+	_ = cmd.MarkFlagRequired(cli.FlagMetadata)
+	_ = cmd.MarkFlagRequired(cli.FlagDeposit)
 	flags.AddTxFlagsToCmd(cmd)
-
 	return cmd
 }

x/tradeshield/simulation/update_params.go

@@ -19,7 +19,7 @@ func SimulateMsgUpdateParams(
 	) (simtypes.OperationMsg, []simtypes.FutureOperation, error) {
 		simAccount, _ := simtypes.RandomAcc(r, accs)
 		msg := &types.MsgUpdateParams{
-			Creator: simAccount.Address.String(),
+			Authority: simAccount.Address.String(),
 		}
 
 		// TODO: Handling the UpdateParams simulation

x/tradeshield/types/message_update_params.go

@@ -9,9 +9,10 @@ const TypeMsgUpdateParams = "update_params"
 
 var _ sdk.Msg = &MsgUpdateParams{}
 
-func NewMsgUpdateParams(creator string) *MsgUpdateParams {
+func NewMsgUpdateParams(authority string, params Params) *MsgUpdateParams {
 	return &MsgUpdateParams{
-		Creator: creator,
+		Authority: authority,
+		Params:    &params,
 	}
 }
 
@@ -24,7 +25,7 @@ func (msg *MsgUpdateParams) Type() string {
 }
 
 func (msg *MsgUpdateParams) GetSigners() []sdk.AccAddress {
-	creator, err := sdk.AccAddressFromBech32(msg.Creator)
+	creator, err := sdk.AccAddressFromBech32(msg.Authority)
 	if err != nil {
 		panic(err)
 	}
@@ -37,9 +38,11 @@ func (msg *MsgUpdateParams) GetSignBytes() []byte {
 }
 
 func (msg *MsgUpdateParams) ValidateBasic() error {
-	_, err := sdk.AccAddressFromBech32(msg.Creator)
+	_, err := sdk.AccAddressFromBech32(msg.Authority)
 	if err != nil {
 		return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err)
 	}
+
+	// TODO: Validate params
 	return nil
 }

x/tradeshield/types/message_update_params_test.go

@@ -17,13 +17,13 @@ func TestMsgUpdateParams_ValidateBasic(t *testing.T) {
 		{
 			name: "invalid address",
 			msg: MsgUpdateParams{
-				Creator: "invalid_address",
+				Authority: "invalid_address",
 			},
 			err: sdkerrors.ErrInvalidAddress,
 		}, {
 			name: "valid address",
 			msg: MsgUpdateParams{
-				Creator: sample.AccAddress(),
+				Authority: sample.AccAddress(),
 			},
 		},
 	}