add cmd packages back in

cmd/kvcli/cmd_keys.go

@@ -0,0 +1,112 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/keys"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+
+	"github.com/kava-labs/kava/app"
+)
+
+/*
+NOTE TO FUTURE IMPLEMENTERS
+This monkey patches the sdk `keys` command, therefore needs to be reviewed on any sdk updates.
+
+The patch adds support for using kava's legacy bip44 coin type to the cli.
+Coin types are used to create a bip44 derivation path, which is used as a mapping from mnemonic to private key.
+
+In cosmos-sdk v0.38.3, all private keys are stored without reference to the mnemonic or bip44 derivation path, except ledger keys.
+Ledger keys are just references to a private key on a ledger device. They contain the bip44 derivation path.
+To patch the cli, we only need to modify:
+- when new ledger references are created
+- anything to do with converting a mnemonic to a private key.
+
+These only happen in `kvcli keys add` cmd.
+For private key generation, use a --legacy-hd-path flag to enable old coin type.
+The current cosmos ledger app (v1.5.3) only supports the legacy coin type. So we only need to ensure ledger reference creation doesn't use the new coin type.
+
+Signing txs:
+- with local keys
+	- the stored the priv key is used to sign, mnemonics or bip44 paths not involved
+- with ledger
+	- the stored bip44 path is used to instruct the ledger which key to sign with
+*/
+
+const flagLegacyHDPath = "legacy-hd-path"
+const flagHDPath = "hd-path" // this is copied from keys add cmd because it's not exported
+
+// getModifiedKeysCmd returns the standard cosmos-sdk/client/keys cmd but modified to support new and old bip44 coin types supported by kava.
+func getModifiedKeysCmd() *cobra.Command {
+	keysCmd := keys.Commands()
+	for _, c := range keysCmd.Commands() {
+		if c.Name() == "add" {
+			monkeyPatchCmdKeysAdd(c)
+		}
+		if c.Name() == "parse" {
+			monkeyPatchCmdKeysParse(c)
+		}
+	}
+	return keysCmd
+}
+
+func monkeyPatchCmdKeysParse(keysParseCmd *cobra.Command) {
+
+	// replace the run function with a wrapped version that sets the old coin type in the global config
+	oldRun := keysParseCmd.RunE
+	keysParseCmd.RunE = func(cmd *cobra.Command, args []string) error {
+
+		sdk.GetConfig().Seal()
+		return oldRun(cmd, args)
+	}
+}
+
+// monkeyPatchCmdKeysAdd modifies the `keys add` command to use the old bip44 coin type when a flag is passed.
+func monkeyPatchCmdKeysAdd(keysAddCmd *cobra.Command) {
+	// add flag
+	keysAddCmd.Flags().Bool(flagLegacyHDPath, false, fmt.Sprintf("Use the old bip44 coin type (%d) to derive addresses from mnemonics.", sdk.CoinType))
+
+	// replace description
+	keysAddCmd.Long = fmt.Sprintf(`Derive a new private key and encrypt to disk.
+	Optionally specify a BIP39 mnemonic, a BIP39 passphrase to further secure the mnemonic,
+	and BIP44 account/index numbers to derive a specific key. The key will be stored under the given name
+	and encrypted with the given password.
+
+	NOTE: This cli defaults to Kava's BIP44 coin type %d. Use the --%s flag to use the old one (%d).
+
+	The flag --recover allows one to recover a key from a seed passphrase.
+	If run with --dry-run, a key would be generated (or recovered) but not stored to the
+	local keystore.
+	Use the --pubkey flag to add arbitrary public keys to the keystore for constructing
+	multisig transactions.
+
+	You can add a multisig key by passing the list of key names you want the public
+	key to be composed of to the --multisig flag and the minimum number of signatures
+	required through --multisig-threshold. The keys are sorted by address, unless
+	the flag --nosort is set.
+	`, app.Bip44CoinType, flagLegacyHDPath, sdk.CoinType)
+
+	// replace the run function with a wrapped version that sets the old coin type in the global config
+	oldRun := keysAddCmd.RunE
+	keysAddCmd.RunE = func(cmd *cobra.Command, args []string) error {
+
+		if !viper.GetBool(flagLegacyHDPath) && viper.GetBool(flags.FlagUseLedger) {
+			return fmt.Errorf("cosmos ledger app only supports legacy bip44 coin type, must use --%s flag when adding ledger key", flagLegacyHDPath)
+		}
+		if viper.GetBool(flagLegacyHDPath) && viper.IsSet(flagHDPath) {
+			return fmt.Errorf("cannot use a custom hd path (--%s) and legacy bip44 coin type (--%s) at the same time", flagHDPath, flagLegacyHDPath)
+		}
+		if viper.GetBool(flagLegacyHDPath) {
+			preExistingCoinType := sdk.GetConfig().GetCoinType()
+			sdk.GetConfig().SetCoinType(sdk.CoinType) // set old coin type
+			err := oldRun(cmd, args)
+			sdk.GetConfig().SetCoinType(preExistingCoinType) // revert to pre-existing coin type
+			return err
+		}
+		return oldRun(cmd, args)
+	}
+}

cmd/kvcli/main.go

@@ -0,0 +1,171 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+
+	"github.com/tendermint/tendermint/libs/cli"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	"github.com/cosmos/cosmos-sdk/client/lcd"
+	"github.com/cosmos/cosmos-sdk/client/rpc"
+	"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"
+	authcmd "github.com/cosmos/cosmos-sdk/x/auth/client/cli"
+	authrest "github.com/cosmos/cosmos-sdk/x/auth/client/rest"
+	"github.com/cosmos/cosmos-sdk/x/bank"
+	bankcmd "github.com/cosmos/cosmos-sdk/x/bank/client/cli"
+
+	"github.com/kava-labs/kava/app"
+	"github.com/kava-labs/kava/migrate/rest_v0_3"
+)
+
+func main() {
+	// Configure cobra to sort commands
+	cobra.EnableCommandSorting = false
+
+	// Instantiate the codec for the command line application
+	cdc := app.MakeCodec()
+
+	// Set the global config
+	// config is not sealed as the cli supports two coin types for legacy reasons.
+	config := sdk.GetConfig()
+	app.SetBech32AddressPrefixes(config)
+	app.SetBip44CoinType(config)
+
+	// TODO: setup keybase, viper object, etc. to be passed into
+	// the below functions and eliminate global vars, like we do
+	// with the cdc
+
+	rootCmd := &cobra.Command{
+		Use:   "kvcli",
+		Short: "Command line interface for interacting with kvd",
+	}
+
+	// Add --chain-id to persistent flags and mark it required
+	rootCmd.PersistentFlags().String(flags.FlagChainID, "", "Chain ID of tendermint node")
+	rootCmd.PersistentPreRunE = func(_ *cobra.Command, _ []string) error {
+		return initConfig(rootCmd)
+	}
+
+	// Construct Root Command
+	rootCmd.AddCommand(
+		rpc.StatusCommand(),
+		client.ConfigCmd(app.DefaultCLIHome),
+		queryCmd(cdc),
+		txCmd(cdc),
+		flags.LineBreak,
+		lcd.ServeCommand(cdc, registerRoutes),
+		flags.LineBreak,
+		getModifiedKeysCmd(),
+		flags.LineBreak,
+		version.Cmd,
+		flags.NewCompletionCmd(rootCmd, true),
+	)
+
+	// Add flags and prefix all env exposed with KA
+	executor := cli.PrepareMainCmd(rootCmd, "KA", app.DefaultCLIHome)
+
+	err := executor.Execute()
+	if err != nil {
+		fmt.Printf("Failed executing CLI command: %s, exiting...\n", err)
+		os.Exit(1)
+	}
+}
+
+func queryCmd(cdc *codec.Codec) *cobra.Command {
+	queryCmd := &cobra.Command{
+		Use:     "query",
+		Aliases: []string{"q"},
+		Short:   "Querying subcommands",
+	}
+
+	queryCmd.AddCommand(
+		authcmd.GetAccountCmd(cdc),
+		flags.LineBreak,
+		rpc.ValidatorCommand(cdc),
+		rpc.BlockCommand(),
+		authcmd.QueryTxsByEventsCmd(cdc),
+		authcmd.QueryTxCmd(cdc),
+		flags.LineBreak,
+	)
+
+	// add modules' query commands
+	app.ModuleBasics.AddQueryCommands(queryCmd, cdc)
+
+	return queryCmd
+}
+
+func txCmd(cdc *codec.Codec) *cobra.Command {
+	txCmd := &cobra.Command{
+		Use:   "tx",
+		Short: "Transactions subcommands",
+	}
+
+	txCmd.AddCommand(
+		bankcmd.SendTxCmd(cdc),
+		flags.LineBreak,
+		authcmd.GetSignCommand(cdc),
+		authcmd.GetMultiSignCommand(cdc),
+		flags.LineBreak,
+		authcmd.GetBroadcastCommand(cdc),
+		authcmd.GetEncodeCommand(cdc),
+		authcmd.GetDecodeCommand(cdc),
+		flags.LineBreak,
+	)
+
+	// add modules' tx commands
+	app.ModuleBasics.AddTxCommands(txCmd, cdc)
+
+	// remove auth and bank commands as they're mounted under the root tx command
+	var cmdsToRemove []*cobra.Command
+	for _, cmd := range txCmd.Commands() {
+		if cmd.Use == auth.ModuleName || cmd.Use == bank.ModuleName {
+			cmdsToRemove = append(cmdsToRemove, cmd)
+		}
+	}
+	txCmd.RemoveCommand(cmdsToRemove...)
+
+	return txCmd
+}
+
+// registerRoutes registers the routes from the different modules for the LCD.
+func registerRoutes(rs *lcd.RestServer) {
+	client.RegisterRoutes(rs.CliCtx, rs.Mux)
+	authrest.RegisterTxRoutes(rs.CliCtx, rs.Mux)
+	app.ModuleBasics.RegisterRESTRoutes(rs.CliCtx, rs.Mux)
+	app.RegisterSimulateRoutes(rs.CliCtx, rs.Mux)
+	// register legacy endpoints compatible with v0.3.x of kava
+	rest_v0_3.RegisterRoutes(rs.CliCtx, rs.Mux)
+}
+
+// initConfig reads in and sets options from a config file (if one exists)
+func initConfig(cmd *cobra.Command) error {
+	home, err := cmd.PersistentFlags().GetString(cli.HomeFlag)
+	if err != nil {
+		return err
+	}
+	cfgFile := path.Join(home, "config", "config.toml")
+
+	if _, err := os.Stat(cfgFile); err == nil {
+		viper.SetConfigFile(cfgFile)
+
+		if err := viper.ReadInConfig(); err != nil {
+			return err
+		}
+	}
+	if err := viper.BindPFlag(flags.FlagChainID, cmd.PersistentFlags().Lookup(flags.FlagChainID)); err != nil {
+		return err
+	}
+	if err := viper.BindPFlag(cli.EncodingFlag, cmd.PersistentFlags().Lookup(cli.EncodingFlag)); err != nil {
+		return err
+	}
+	return viper.BindPFlag(cli.OutputFlag, cmd.PersistentFlags().Lookup(cli.OutputFlag))
+}