github.com/KiraCore/sekai@v0.3.43/x/tokens/client/cli/tx.go (about)

     1  package cli
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  
     7  	appparams "github.com/KiraCore/sekai/app/params"
     8  	govtypes "github.com/KiraCore/sekai/x/gov/types"
     9  	"github.com/KiraCore/sekai/x/tokens/types"
    10  	"github.com/cosmos/cosmos-sdk/client"
    11  	"github.com/cosmos/cosmos-sdk/client/flags"
    12  	"github.com/cosmos/cosmos-sdk/client/tx"
    13  	sdk "github.com/cosmos/cosmos-sdk/types"
    14  	"github.com/spf13/cobra"
    15  )
    16  
    17  // flags for tokens module txs
    18  const (
    19  	FlagSymbol      = "symbol"
    20  	FlagName        = "name"
    21  	FlagIcon        = "icon"
    22  	FlagDecimals    = "decimals"
    23  	FlagDenoms      = "denoms"
    24  	FlagDenom       = "denom"
    25  	FlagRate        = "rate"
    26  	FlagStakeCap    = "stake_cap"
    27  	FlagStakeToken  = "stake_token"
    28  	FlagStakeMin    = "stake_min"
    29  	FlagFeePayments = "fee_payments"
    30  	FlagIsBlacklist = "is_blacklist"
    31  	FlagIsAdd       = "is_add"
    32  	FlagTokens      = "tokens"
    33  	FlagTitle       = "title"
    34  	FlagDescription = "description"
    35  	FlagInvalidated = "invalidated"
    36  )
    37  
    38  // NewTxCmd returns a root CLI command handler for all x/bank transaction commands.
    39  func NewTxCmd() *cobra.Command {
    40  	txCmd := &cobra.Command{
    41  		Use:                        types.ModuleName,
    42  		Short:                      "Tokens sub commands",
    43  		DisableFlagParsing:         true,
    44  		SuggestionsMinimumDistance: 2,
    45  		RunE:                       client.ValidateCmd,
    46  	}
    47  
    48  	txCmd.AddCommand(
    49  		GetTxUpsertTokenAliasCmd(),
    50  		GetTxUpsertTokenRateCmd(),
    51  		GetTxProposalUpsertTokenAliasCmd(),
    52  		GetTxProposalUpsertTokenRatesCmd(),
    53  		GetTxProposalTokensBlackWhiteChangeCmd(),
    54  	)
    55  
    56  	return txCmd
    57  }
    58  
    59  // GetTxUpsertTokenAliasCmd implement cli command for MsgUpsertTokenAlias
    60  func GetTxUpsertTokenAliasCmd() *cobra.Command {
    61  	cmd := &cobra.Command{
    62  		Use:   "upsert-alias",
    63  		Short: "Upsert token alias",
    64  		RunE: func(cmd *cobra.Command, args []string) error {
    65  			clientCtx, err := client.GetClientTxContext(cmd)
    66  
    67  			symbol, err := cmd.Flags().GetString(FlagSymbol)
    68  			if err != nil {
    69  				return fmt.Errorf("invalid symbol")
    70  			}
    71  
    72  			name, err := cmd.Flags().GetString(FlagName)
    73  			if err != nil {
    74  				return fmt.Errorf("invalid name")
    75  			}
    76  
    77  			icon, err := cmd.Flags().GetString(FlagIcon)
    78  			if err != nil {
    79  				return fmt.Errorf("invalid icon")
    80  			}
    81  
    82  			decimals, err := cmd.Flags().GetUint32(FlagDecimals)
    83  			if err != nil {
    84  				return fmt.Errorf("invalid decimals")
    85  			}
    86  
    87  			denomsString, err := cmd.Flags().GetString(FlagDenoms)
    88  			if err != nil {
    89  				return fmt.Errorf("invalid denoms")
    90  			}
    91  
    92  			denoms := strings.Split(denomsString, ",")
    93  			for _, denom := range denoms {
    94  				if err = sdk.ValidateDenom(denom); err != nil {
    95  					return err
    96  				}
    97  			}
    98  
    99  			isInvalidated, err := cmd.Flags().GetBool(FlagInvalidated)
   100  			if err != nil {
   101  				return fmt.Errorf("invalid invalidated flag: %w", err)
   102  			}
   103  
   104  			msg := types.NewMsgUpsertTokenAlias(
   105  				clientCtx.FromAddress,
   106  				symbol,
   107  				name,
   108  				icon,
   109  				decimals,
   110  				denoms,
   111  				isInvalidated,
   112  			)
   113  
   114  			err = msg.ValidateBasic()
   115  			if err != nil {
   116  				return err
   117  			}
   118  
   119  			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
   120  		},
   121  	}
   122  
   123  	cmd.Flags().String(FlagSymbol, "KEX", "Ticker (eg. ATOM, KEX, BTC)")
   124  	cmd.Flags().String(FlagName, "Kira", "Token Name (e.g. Cosmos, Kira, Bitcoin)")
   125  	cmd.Flags().String(FlagIcon, "", "Graphical Symbol (url link to graphics)")
   126  	cmd.Flags().Uint32(FlagDecimals, 6, "Integer number of max decimals")
   127  	cmd.Flags().String(FlagDenoms, "ukex,mkex", "An array of token denoms to be aliased")
   128  	cmd.Flags().Bool(FlagInvalidated, false, "Flag to show token alias is invalidated or not")
   129  
   130  	flags.AddTxFlagsToCmd(cmd)
   131  	_ = cmd.MarkFlagRequired(flags.FlagFrom)
   132  
   133  	return cmd
   134  }
   135  
   136  // GetTxProposalUpsertTokenAliasCmd implement cli command for MsgUpsertTokenAlias
   137  func GetTxProposalUpsertTokenAliasCmd() *cobra.Command {
   138  	cmd := &cobra.Command{
   139  		Use:   "proposal-upsert-alias",
   140  		Short: "Create a proposal to upsert token alias",
   141  		RunE: func(cmd *cobra.Command, args []string) error {
   142  			clientCtx, err := client.GetClientTxContext(cmd)
   143  
   144  			symbol, err := cmd.Flags().GetString(FlagSymbol)
   145  			if err != nil {
   146  				return fmt.Errorf("invalid symbol: %w", err)
   147  			}
   148  
   149  			name, err := cmd.Flags().GetString(FlagName)
   150  			if err != nil {
   151  				return fmt.Errorf("invalid name: %w", err)
   152  			}
   153  
   154  			icon, err := cmd.Flags().GetString(FlagIcon)
   155  			if err != nil {
   156  				return fmt.Errorf("invalid icon: %w", err)
   157  			}
   158  
   159  			decimals, err := cmd.Flags().GetUint32(FlagDecimals)
   160  			if err != nil {
   161  				return fmt.Errorf("invalid decimals: %w", err)
   162  			}
   163  
   164  			denoms, err := cmd.Flags().GetString(FlagDenoms)
   165  			if err != nil {
   166  				return fmt.Errorf("invalid denoms: %w", err)
   167  			}
   168  
   169  			isInvalidated, err := cmd.Flags().GetBool(FlagInvalidated)
   170  			if err != nil {
   171  				return fmt.Errorf("invalid invalidated flag: %w", err)
   172  			}
   173  
   174  			title, err := cmd.Flags().GetString(FlagTitle)
   175  			if err != nil {
   176  				return fmt.Errorf("invalid title: %w", err)
   177  			}
   178  
   179  			description, err := cmd.Flags().GetString(FlagDescription)
   180  			if err != nil {
   181  				return fmt.Errorf("invalid description: %w", err)
   182  			}
   183  
   184  			msg, err := govtypes.NewMsgSubmitProposal(
   185  				clientCtx.FromAddress,
   186  				title,
   187  				description,
   188  				types.NewUpsertTokenAliasProposal(
   189  					symbol,
   190  					name,
   191  					icon,
   192  					decimals,
   193  					strings.Split(denoms, ","),
   194  					isInvalidated,
   195  				),
   196  			)
   197  			if err != nil {
   198  				return err
   199  			}
   200  
   201  			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
   202  		},
   203  	}
   204  
   205  	cmd.Flags().String(FlagSymbol, "KEX", "Ticker (eg. ATOM, KEX, BTC)")
   206  	cmd.MarkFlagRequired(FlagSymbol)
   207  	cmd.Flags().String(FlagName, "Kira", "Token Name (e.g. Cosmos, Kira, Bitcoin)")
   208  	cmd.MarkFlagRequired(FlagName)
   209  	cmd.Flags().String(FlagIcon, "", "Graphical Symbol (url link to graphics)")
   210  	cmd.MarkFlagRequired(FlagIcon)
   211  	cmd.Flags().Uint32(FlagDecimals, 6, "Integer number of max decimals")
   212  	cmd.MarkFlagRequired(FlagDecimals)
   213  	cmd.Flags().String(FlagDenoms, "ukex,mkex", "An array of token denoms to be aliased")
   214  	cmd.MarkFlagRequired(FlagDenoms)
   215  	cmd.Flags().Bool(FlagInvalidated, false, "Flag to show token alias is invalidated or not")
   216  
   217  	cmd.Flags().String(FlagTitle, "", "The title of the proposal.")
   218  	cmd.MarkFlagRequired(FlagTitle)
   219  	cmd.Flags().String(FlagDescription, "", "The description of the proposal, it can be a url, some text, etc.")
   220  	cmd.MarkFlagRequired(FlagDescription)
   221  
   222  	flags.AddTxFlagsToCmd(cmd)
   223  	_ = cmd.MarkFlagRequired(flags.FlagFrom)
   224  
   225  	return cmd
   226  }
   227  
   228  // GetTxProposalUpsertTokenRatesCmd implement cli command for MsgUpsertTokenAlias
   229  func GetTxProposalUpsertTokenRatesCmd() *cobra.Command {
   230  	cmd := &cobra.Command{
   231  		Use:   "proposal-upsert-rate",
   232  		Short: "Create a proposal to upsert token rate",
   233  		RunE: func(cmd *cobra.Command, args []string) error {
   234  			clientCtx, err := client.GetClientTxContext(cmd)
   235  
   236  			denom, err := cmd.Flags().GetString(FlagDenom)
   237  			if err != nil {
   238  				return fmt.Errorf("invalid denom")
   239  			}
   240  			if denom == appparams.DefaultDenom {
   241  				return fmt.Errorf("bond denom rate is read-only")
   242  			}
   243  
   244  			rateString, err := cmd.Flags().GetString(FlagRate)
   245  			if err != nil {
   246  				return fmt.Errorf("invalid rate")
   247  			}
   248  
   249  			rate, err := sdk.NewDecFromStr(rateString)
   250  			if err != nil {
   251  				return err
   252  			}
   253  
   254  			feePayments, err := cmd.Flags().GetBool(FlagFeePayments)
   255  			if err != nil {
   256  				return fmt.Errorf("invalid fee payments")
   257  			}
   258  
   259  			title, err := cmd.Flags().GetString(FlagTitle)
   260  			if err != nil {
   261  				return fmt.Errorf("invalid title: %w", err)
   262  			}
   263  
   264  			description, err := cmd.Flags().GetString(FlagDescription)
   265  			if err != nil {
   266  				return fmt.Errorf("invalid description: %w", err)
   267  			}
   268  
   269  			stakeToken, err := cmd.Flags().GetBool(FlagStakeToken)
   270  			if err != nil {
   271  				return fmt.Errorf("invalid stake token flag")
   272  			}
   273  
   274  			stakeCapStr, err := cmd.Flags().GetString(FlagStakeCap)
   275  			if err != nil {
   276  				return fmt.Errorf("invalid stake cap: %w", err)
   277  			}
   278  
   279  			stakeCap, err := sdk.NewDecFromStr(stakeCapStr)
   280  			if err != nil {
   281  				return fmt.Errorf("invalid stake cap: %w", err)
   282  			}
   283  
   284  			stakeMinStr, err := cmd.Flags().GetString(FlagStakeMin)
   285  			if err != nil {
   286  				return fmt.Errorf("invalid stake min: %w", err)
   287  			}
   288  
   289  			stakeMin, ok := sdk.NewIntFromString(stakeMinStr)
   290  			if !ok {
   291  				return fmt.Errorf("invalid stake min: %s", stakeMinStr)
   292  			}
   293  
   294  			isInvalidated, err := cmd.Flags().GetBool(FlagInvalidated)
   295  			if err != nil {
   296  				return fmt.Errorf("invalid invalidated flag: %w", err)
   297  			}
   298  
   299  			msg, err := govtypes.NewMsgSubmitProposal(
   300  				clientCtx.FromAddress,
   301  				title,
   302  				description,
   303  				types.NewUpsertTokenRatesProposal(
   304  					denom,
   305  					rate,
   306  					feePayments,
   307  					stakeCap,
   308  					stakeMin,
   309  					stakeToken,
   310  					isInvalidated,
   311  				),
   312  			)
   313  			if err != nil {
   314  				return err
   315  			}
   316  
   317  			err = msg.ValidateBasic()
   318  			if err != nil {
   319  				return err
   320  			}
   321  
   322  			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
   323  		},
   324  	}
   325  
   326  	cmd.Flags().String(FlagDenom, "tbtc", "denom - identifier for token rates")
   327  	cmd.MarkFlagRequired(FlagDenom)
   328  	cmd.Flags().String(FlagRate, "1.0", "rate to register, max decimal 9, max value 10^10")
   329  	cmd.MarkFlagRequired(FlagRate)
   330  	cmd.Flags().Bool(FlagFeePayments, true, "use registry as fee payment")
   331  	cmd.MarkFlagRequired(FlagFeePayments)
   332  	cmd.Flags().String(FlagTitle, "", "The title of a proposal.")
   333  	cmd.MarkFlagRequired(FlagTitle)
   334  	cmd.Flags().String(FlagDescription, "", "The description of the proposal, it can be a url, some text, etc.")
   335  	cmd.MarkFlagRequired(FlagDescription)
   336  	cmd.Flags().String(FlagStakeCap, "0.1", "rewards to be allocated for the token.")
   337  	cmd.Flags().String(FlagStakeMin, "1", "min amount to stake at a time.")
   338  	cmd.Flags().Bool(FlagStakeToken, false, "flag of if staking token or not.")
   339  	cmd.Flags().Bool(FlagInvalidated, false, "Flag to show token rate is invalidated or not")
   340  
   341  	flags.AddTxFlagsToCmd(cmd)
   342  	_ = cmd.MarkFlagRequired(flags.FlagFrom)
   343  
   344  	return cmd
   345  }
   346  
   347  // GetTxUpsertTokenRateCmd implement cli command for MsgUpsertTokenRate
   348  func GetTxUpsertTokenRateCmd() *cobra.Command {
   349  	cmd := &cobra.Command{
   350  		Use:   "upsert-rate",
   351  		Short: "Upsert token rate",
   352  		RunE: func(cmd *cobra.Command, args []string) error {
   353  			clientCtx, err := client.GetClientTxContext(cmd)
   354  
   355  			denom, err := cmd.Flags().GetString(FlagDenom)
   356  			if err != nil {
   357  				return fmt.Errorf("invalid denom")
   358  			}
   359  			if denom == appparams.DefaultDenom {
   360  				return fmt.Errorf("bond denom rate is read-only")
   361  			}
   362  
   363  			rateString, err := cmd.Flags().GetString(FlagRate)
   364  			if err != nil {
   365  				return fmt.Errorf("invalid rate")
   366  			}
   367  
   368  			rate, err := sdk.NewDecFromStr(rateString)
   369  			if err != nil {
   370  				return err
   371  			}
   372  
   373  			feePayments, err := cmd.Flags().GetBool(FlagFeePayments)
   374  			if err != nil {
   375  				return fmt.Errorf("invalid fee payments")
   376  			}
   377  
   378  			stakeToken, err := cmd.Flags().GetBool(FlagStakeToken)
   379  			if err != nil {
   380  				return fmt.Errorf("invalid stake token flag")
   381  			}
   382  
   383  			stakeCapStr, err := cmd.Flags().GetString(FlagStakeCap)
   384  			if err != nil {
   385  				return fmt.Errorf("invalid stake cap: %w", err)
   386  			}
   387  
   388  			stakeCap, err := sdk.NewDecFromStr(stakeCapStr)
   389  			if err != nil {
   390  				return fmt.Errorf("invalid stake cap: %w", err)
   391  			}
   392  
   393  			stakeMinStr, err := cmd.Flags().GetString(FlagStakeMin)
   394  			if err != nil {
   395  				return fmt.Errorf("invalid stake min: %w", err)
   396  			}
   397  
   398  			stakeMin, ok := sdk.NewIntFromString(stakeMinStr)
   399  			if !ok {
   400  				return fmt.Errorf("invalid stake min: %s", stakeMinStr)
   401  			}
   402  
   403  			isInvalidated, err := cmd.Flags().GetBool(FlagInvalidated)
   404  			if err != nil {
   405  				return fmt.Errorf("invalid invalidated flag: %w", err)
   406  			}
   407  
   408  			msg := types.NewMsgUpsertTokenRate(
   409  				clientCtx.FromAddress,
   410  				denom,
   411  				rate,
   412  				feePayments,
   413  				stakeCap,
   414  				stakeMin,
   415  				stakeToken,
   416  				isInvalidated,
   417  			)
   418  
   419  			err = msg.ValidateBasic()
   420  			if err != nil {
   421  				return err
   422  			}
   423  
   424  			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
   425  		},
   426  	}
   427  
   428  	cmd.Flags().String(FlagDenom, "tbtc", "denom - identifier for token rates")
   429  	cmd.MarkFlagRequired(FlagDenom)
   430  	cmd.Flags().String(FlagRate, "1.0", "rate to register, max decimal 9, max value 10^10")
   431  	cmd.MarkFlagRequired(FlagRate)
   432  	cmd.Flags().Bool(FlagFeePayments, true, "use registry as fee payment")
   433  	cmd.MarkFlagRequired(FlagFeePayments)
   434  	cmd.Flags().String(FlagStakeCap, "0.1", "rewards to be allocated for the token.")
   435  	cmd.Flags().String(FlagStakeMin, "1", "min amount to stake at a time.")
   436  	cmd.Flags().Bool(FlagStakeToken, false, "flag of if staking token or not.")
   437  	cmd.Flags().Bool(FlagInvalidated, false, "Flag to show token rate is invalidated or not")
   438  
   439  	flags.AddTxFlagsToCmd(cmd)
   440  	_ = cmd.MarkFlagRequired(flags.FlagFrom)
   441  
   442  	return cmd
   443  }
   444  
   445  // GetTxProposalTokensBlackWhiteChangeCmd implement cli command for proposing tokens blacklist / whitelist update
   446  func GetTxProposalTokensBlackWhiteChangeCmd() *cobra.Command {
   447  	cmd := &cobra.Command{
   448  		Use:   "proposal-update-tokens-blackwhite",
   449  		Short: "Create a proposal to update whitelisted and blacklisted tokens",
   450  		RunE: func(cmd *cobra.Command, args []string) error {
   451  			clientCtx, err := client.GetClientTxContext(cmd)
   452  
   453  			isBlacklist, err := cmd.Flags().GetBool(FlagIsBlacklist)
   454  			if err != nil {
   455  				return fmt.Errorf("invalid is_blacklist flag: %w", err)
   456  			}
   457  
   458  			isAdd, err := cmd.Flags().GetBool(FlagIsAdd)
   459  			if err != nil {
   460  				return fmt.Errorf("invalid is_add flag: %w", err)
   461  			}
   462  
   463  			tokens, err := cmd.Flags().GetStringArray(FlagTokens)
   464  			if err != nil {
   465  				return fmt.Errorf("invalid tokens flag: %w", err)
   466  			}
   467  
   468  			title, err := cmd.Flags().GetString(FlagTitle)
   469  			if err != nil {
   470  				return fmt.Errorf("invalid title: %w", err)
   471  			}
   472  
   473  			description, err := cmd.Flags().GetString(FlagDescription)
   474  			if err != nil {
   475  				return fmt.Errorf("invalid description: %w", err)
   476  			}
   477  
   478  			msg, err := govtypes.NewMsgSubmitProposal(
   479  				clientCtx.FromAddress,
   480  				title,
   481  				description,
   482  				types.NewTokensWhiteBlackChangeProposal(
   483  					isBlacklist,
   484  					isAdd,
   485  					tokens,
   486  				),
   487  			)
   488  			if err != nil {
   489  				return err
   490  			}
   491  
   492  			return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg)
   493  		},
   494  	}
   495  
   496  	cmd.Flags().Bool(FlagIsBlacklist, true, "true to modify blacklist otherwise false")
   497  	cmd.Flags().Bool(FlagIsAdd, true, "true to add otherwise false")
   498  	cmd.Flags().StringArray(FlagTokens, []string{}, "tokens array (eg. ATOM, KEX, BTC)")
   499  	cmd.Flags().String(FlagTitle, "", "The title of a proposal.")
   500  	cmd.MarkFlagRequired(FlagTitle)
   501  	cmd.Flags().String(FlagDescription, "", "The description of the proposal, it can be a url, some text, etc.")
   502  	cmd.MarkFlagRequired(FlagDescription)
   503  
   504  	flags.AddTxFlagsToCmd(cmd)
   505  	_ = cmd.MarkFlagRequired(flags.FlagFrom)
   506  
   507  	return cmd
   508  }