Enter the new keyring interface

client/context/context.go

@@ -25,7 +25,6 @@ type CLIContext struct {
 	Client        rpcclient.Client
 	ChainID       string
 	Marshaler     codec.Marshaler
-	Keybase       keyring.Keybase
 	Input         io.Reader
 	Output        io.Writer
 	OutputFormat  string
@@ -321,20 +320,20 @@ func GetFromFields(input io.Reader, from string, genOnly bool) (sdk.AccAddress,
 		return addr, "", nil
 	}
 
-	keybase, err := keyring.NewKeyring(sdk.KeyringServiceName(),
+	keybase, err := keyring.New(sdk.KeyringServiceName(),
 		viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), input)
 	if err != nil {
 		return nil, "", err
 	}
 
 	var info keyring.Info
 	if addr, err := sdk.AccAddressFromBech32(from); err == nil {
-		info, err = keybase.GetByAddress(addr)
+		info, err = keybase.KeyByAddress(addr)
 		if err != nil {
 			return nil, "", err
 		}
 	} else {
-		info, err = keybase.Get(from)
+		info, err = keybase.Key(from)
 		if err != nil {
 			return nil, "", err
 		}

client/keys/add.go

@@ -8,11 +8,14 @@ import (
 	"io"
 	"sort"
 
+	algo2 "github.com/cosmos/cosmos-sdk/crypto/privkey"
+
 	bip39 "github.com/cosmos/go-bip39"
 
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/client/input"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
+	"github.com/cosmos/cosmos-sdk/crypto/keys/hd"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 
 	"github.com/spf13/cobra"
@@ -27,6 +30,7 @@ const (
 	flagInteractive = "interactive"
 	flagRecover     = "recover"
 	flagNoBackup    = "no-backup"
+	flagCoinType    = "coin-type"
 	flagAccount     = "account"
 	flagIndex       = "index"
 	flagMultisig    = "multisig"
@@ -73,19 +77,20 @@ the flag --nosort is set.
 	cmd.Flags().Bool(flagNoBackup, false, "Don't print out seed phrase (if others are watching the terminal)")
 	cmd.Flags().Bool(flags.FlagDryRun, false, "Perform action, but don't add key to local keystore")
 	cmd.Flags().String(flagHDPath, "", "Manual HD Path derivation (overrides BIP44 config)")
+	cmd.Flags().Uint32(flagCoinType, sdk.CoinType, "coin type number for HD derivation")
 	cmd.Flags().Uint32(flagAccount, 0, "Account number for HD derivation")
 	cmd.Flags().Uint32(flagIndex, 0, "Address index number for HD derivation")
 	cmd.Flags().Bool(flags.FlagIndentResponse, false, "Add indent to JSON response")
-	cmd.Flags().String(flagKeyAlgo, string(keyring.Secp256k1), "Key signing algorithm to generate keys for")
+	cmd.Flags().String(flagKeyAlgo, string(algo2.Secp256k1Type), "Key signing algorithm to generate keys for")
 	return cmd
 }
 
-func getKeybase(transient bool, buf io.Reader) (keyring.Keybase, error) {
+func getKeybase(transient bool, buf io.Reader) (keyring.Keyring, error) {
 	if transient {
-		return keyring.NewKeyring(sdk.KeyringServiceName(), keyring.BackendMemory, viper.GetString(flags.FlagHome), buf)
+		return keyring.New(sdk.KeyringServiceName(), keyring.BackendMemory, viper.GetString(flags.FlagHome), buf)
 	}
 
-	return keyring.NewKeyring(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), buf)
+	return keyring.New(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), buf)
 }
 
 func runAddCmd(cmd *cobra.Command, args []string) error {
@@ -107,24 +112,21 @@ input
 output
 	- armor encrypted private key (saved to file)
 */
-func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keybase, inBuf *bufio.Reader) error {
+func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keyring, inBuf *bufio.Reader) error {
 	var err error
 
 	name := args[0]
 
 	interactive := viper.GetBool(flagInteractive)
 	showMnemonic := !viper.GetBool(flagNoBackup)
 
-	algo := keyring.SigningAlgo(viper.GetString(flagKeyAlgo))
-	if algo == keyring.SigningAlgo("") {
-		algo = keyring.Secp256k1
-	}
-	if !keyring.IsSupportedAlgorithm(kb.SupportedAlgos(), algo) {
-		return keyring.ErrUnsupportedSigningAlgo
+	algo, err := keyring.NewSigningAlgoFromString(viper.GetString(flagKeyAlgo))
+	if err != nil {
+		algo = algo2.Secp256k1
 	}
 
 	if !viper.GetBool(flags.FlagDryRun) {
-		_, err = kb.Get(name)
+		_, err = kb.Key(name)
 		if err == nil {
 			// account exists, ask for user confirmation
 			response, err2 := input.GetConfirmation(fmt.Sprintf("override the existing name %s", name), inBuf)
@@ -146,7 +148,7 @@ func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keybase, inBuf *buf
 			}
 
 			for _, keyname := range multisigKeys {
-				k, err := kb.Get(keyname)
+				k, err := kb.Key(keyname)
 				if err != nil {
 					return err
 				}
@@ -161,7 +163,7 @@ func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keybase, inBuf *buf
 			}
 
 			pk := multisig.NewPubKeyMultisigThreshold(multisigThreshold, pks)
-			if _, err := kb.CreateMulti(name, pk); err != nil {
+			if _, err := kb.SaveMultisig(name, pk); err != nil {
 				return err
 			}
 
@@ -175,21 +177,22 @@ func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keybase, inBuf *buf
 		if err != nil {
 			return err
 		}
-		_, err = kb.CreateOffline(name, pk, algo)
+		_, err = kb.SavePubKey(name, pk, algo.Name())
 		if err != nil {
 			return err
 		}
 		return nil
 	}
 
+	coinType := uint32(viper.GetInt(flagCoinType))
 	account := uint32(viper.GetInt(flagAccount))
 	index := uint32(viper.GetInt(flagIndex))
 
 	useBIP44 := !viper.IsSet(flagHDPath)
 	var hdPath string
 
 	if useBIP44 {
-		hdPath = keyring.CreateHDPath(account, index).String()
+		hdPath = hd.CreateHDPath(coinType, account, index).String()
 	} else {
 		hdPath = viper.GetString(flagHDPath)
 	}
@@ -201,12 +204,8 @@ func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keybase, inBuf *buf
 			return errors.New("cannot set custom bip32 path with ledger")
 		}
 
-		if !keyring.IsSupportedAlgorithm(kb.SupportedAlgosLedger(), algo) {
-			return keyring.ErrUnsupportedSigningAlgo
-		}
-
 		bech32PrefixAccAddr := sdk.GetConfig().GetBech32AccountAddrPrefix()
-		info, err := kb.CreateLedger(name, keyring.Secp256k1, bech32PrefixAccAddr, account, index)
+		info, err := kb.SaveLedgerKey(name, algo2.Secp256k1, bech32PrefixAccAddr, coinType, account, index)
 		if err != nil {
 			return err
 		}
@@ -269,7 +268,7 @@ func RunAddCmd(cmd *cobra.Command, args []string, kb keyring.Keybase, inBuf *buf
 		}
 	}
 
-	info, err := kb.CreateAccount(name, mnemonic, bip39Passphrase, DefaultKeyPass, hdPath, algo)
+	info, err := kb.NewAccount(name, mnemonic, bip39Passphrase, hdPath, algo)
 	if err != nil {
 		return err
 	}

client/keys/add_ledger_test.go

@@ -41,6 +41,9 @@ func Test_runAddCmdLedgerWithCustomCoinType(t *testing.T) {
 	t.Cleanup(kbCleanUp)
 	viper.Set(flags.FlagHome, kbHome)
 	viper.Set(flags.FlagUseLedger, true)
+	viper.Set(flagAccount, "0")
+	viper.Set(flagIndex, "0")
+	viper.Set(flagCoinType, "330")
 
 	/// Test Text
 	viper.Set(cli.OutputFlag, OutputFormatText)
@@ -50,14 +53,14 @@ func Test_runAddCmdLedgerWithCustomCoinType(t *testing.T) {
 	require.NoError(t, runAddCmd(cmd, []string{"keyname1"}))
 
 	// Now check that it has been stored properly
-	kb, err := keyring.NewKeyring(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), mockIn)
+	kb, err := keyring.New(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), mockIn)
 	require.NoError(t, err)
 	require.NotNil(t, kb)
 	t.Cleanup(func() {
-		kb.Delete("keyname1", "", false)
+		kb.Delete("keyname1")
 	})
 	mockIn.Reset("test1234\n")
-	key1, err := kb.Get("keyname1")
+	key1, err := kb.Key("keyname1")
 	require.NoError(t, err)
 	require.NotNil(t, key1)
 
@@ -90,17 +93,18 @@ func Test_runAddCmdLedger(t *testing.T) {
 	viper.Set(cli.OutputFlag, OutputFormatText)
 	// Now enter password
 	mockIn.Reset("test1234\ntest1234\n")
+	viper.Set(flagCoinType, sdk.CoinType)
 	require.NoError(t, runAddCmd(cmd, []string{"keyname1"}))
 
 	// Now check that it has been stored properly
-	kb, err := keyring.NewKeyring(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), kbHome, mockIn)
+	kb, err := keyring.New(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), kbHome, mockIn)
 	require.NoError(t, err)
 	require.NotNil(t, kb)
 	t.Cleanup(func() {
-		kb.Delete("keyname1", "", false)
+		kb.Delete("keyname1")
 	})
 	mockIn.Reset("test1234\n")
-	key1, err := kb.Get("keyname1")
+	key1, err := kb.Key("keyname1")
 	require.NoError(t, err)
 	require.NotNil(t, key1)
 

client/keys/add_test.go

@@ -27,11 +27,11 @@ func Test_runAddCmdBasic(t *testing.T) {
 	viper.Set(cli.OutputFlag, OutputFormatText)
 
 	mockIn.Reset("y\n")
-	kb, err := keyring.NewKeyring(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), kbHome, mockIn)
+	kb, err := keyring.New(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), kbHome, mockIn)
 	require.NoError(t, err)
 	t.Cleanup(func() {
-		kb.Delete("keyname1", "", false) // nolint:errcheck
-		kb.Delete("keyname2", "", false) // nolint:errcheck
+		kb.Delete("keyname1") // nolint:errcheck
+		kb.Delete("keyname2") // nolint:errcheck
 	})
 	assert.NoError(t, runAddCmd(cmd, []string{"keyname1"}))
 

client/keys/codec_test.go

@@ -1,12 +1,12 @@
-package keys
+package keys_test
 
 import (
-	"fmt"
-	"reflect"
+	"bytes"
 	"testing"
 
 	"github.com/stretchr/testify/require"
 
+	"github.com/cosmos/cosmos-sdk/client/keys"
 	"github.com/cosmos/cosmos-sdk/crypto/keyring"
 )
 
@@ -58,15 +58,9 @@ func TestMarshalJSON(t *testing.T) {
 	for _, tt := range tests {
 		tt := tt
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := MarshalJSON(tt.args.o)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("MarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			fmt.Printf("%s\n", got)
-			if !reflect.DeepEqual(got, tt.want) {
-				t.Errorf("MarshalJSON() = %v, want %v", got, tt.want)
-			}
+			got, err := keys.MarshalJSON(tt.args.o)
+			require.Equal(t, tt.wantErr, err != nil)
+			require.True(t, bytes.Equal(got, tt.want))
 		})
 	}
 }
@@ -94,10 +88,8 @@ func TestUnmarshalJSON(t *testing.T) {
 	for idx, tt := range tests {
 		idx, tt := idx, tt
 		t.Run(tt.name, func(t *testing.T) {
-			if err := UnmarshalJSON(tt.args.bz, tt.args.ptr); (err != nil) != tt.wantErr {
-				t.Errorf("unmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
-			}
-
+			err := keys.UnmarshalJSON(tt.args.bz, tt.args.ptr)
+			require.Equal(t, tt.wantErr, err != nil)
 			// Confirm deserialized objects are the same
 			require.Equal(t, data.Keys[idx], data.Answers[idx])
 		})

client/keys/delete.go

@@ -2,7 +2,6 @@ package keys
 
 import (
 	"bufio"
-	"errors"
 
 	"github.com/cosmos/cosmos-sdk/client/flags"
 	"github.com/cosmos/cosmos-sdk/client/input"
@@ -43,49 +42,36 @@ private keys stored in a ledger device cannot be deleted with the CLI.
 func runDeleteCmd(cmd *cobra.Command, args []string) error {
 	buf := bufio.NewReader(cmd.InOrStdin())
 
-	kb, err := keyring.NewKeyring(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), buf)
+	kb, err := keyring.New(sdk.KeyringServiceName(), viper.GetString(flags.FlagKeyringBackend), viper.GetString(flags.FlagHome), buf)
 	if err != nil {
 		return err
 	}
 
 	for _, name := range args {
-		info, err := kb.Get(name)
+		info, err := kb.Key(name)
 		if err != nil {
 			return err
 		}
 
-		if info.GetType() == keyring.TypeLedger || info.GetType() == keyring.TypeOffline {
-			// confirm deletion, unless -y is passed
-			if !viper.GetBool(flagYes) {
-				if err := confirmDeletion(buf); err != nil {
-					return err
-				}
-			}
-
-			if err := kb.Delete(name, "", true); err != nil {
+		// confirm deletion, unless -y is passed
+		if !viper.GetBool(flagYes) {
+			if yes, err := input.GetConfirmation("Key reference will be deleted. Continue?", buf); err != nil {
 				return err
+			} else if !yes {
+				continue
 			}
-			cmd.PrintErrln("Public key reference deleted")
-			return nil
 		}
 
-		// old password and skip flag arguments are ignored
-		if err := kb.Delete(name, "", true); err != nil {
+		if err := kb.Delete(name); err != nil {
 			return err
 		}
+
+		if info.GetType() == keyring.TypeLedger || info.GetType() == keyring.TypeOffline {
+			cmd.PrintErrln("Public key reference deleted")
+			continue
+		}
 		cmd.PrintErrln("Key deleted forever (uh oh!)")
 	}
 
 	return nil
 }
-
-func confirmDeletion(buf *bufio.Reader) error {
-	answer, err := input.GetConfirmation("Key reference will be deleted. Continue?", buf)
-	if err != nil {
-		return err
-	}
-	if !answer {
-		return errors.New("aborted")
-	}
-	return nil
-}