feat: clean up gnokey add + add coverage

tm2/pkg/crypto/keys/client/add_bech32.go

@@ -0,0 +1,94 @@
+package client
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
+)
+
+type AddBech32Cfg struct {
+	RootCfg *AddCfg
+
+	PublicKey string
+}
+
+// NewAddBech32Cmd creates a gnokey add bech32 command
+func NewAddBech32Cmd(rootCfg *AddCfg, io commands.IO) *commands.Command {
+	cfg := &AddBech32Cfg{
+		RootCfg: rootCfg,
+	}
+
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "bech32",
+			ShortUsage: "add bech32 [flags] <key-name>",
+			ShortHelp:  "adds a public key to the keybase, using the bech32 representation",
+		},
+		cfg,
+		func(_ context.Context, args []string) error {
+			return execAddBech32(cfg, args, io)
+		},
+	)
+}
+
+func (c *AddBech32Cfg) RegisterFlags(fs *flag.FlagSet) {
+	fs.StringVar(
+		&c.PublicKey,
+		"pubkey",
+		"",
+		"parse a public key in bech32 format and save it to disk",
+	)
+}
+
+func execAddBech32(cfg *AddBech32Cfg, args []string, io commands.IO) error {
+	// Validate a key name was provided
+	if len(args) != 1 {
+		return flag.ErrHelp
+	}
+
+	name := args[0]
+
+	// Read the keybase from the home directory
+	kb, err := keys.NewKeyBaseFromDir(cfg.RootCfg.RootCfg.Home)
+	if err != nil {
+		return fmt.Errorf("unable to read keybase, %w", err)
+	}
+
+	// Check if the key exists
+	exists, err := kb.HasByName(name)
+	if err != nil {
+		return fmt.Errorf("unable to fetch key, %w", err)
+	}
+
+	// Get overwrite confirmation, if any
+	if exists {
+		overwrite, err := io.GetConfirmation(fmt.Sprintf("Override the existing name %s", name))
+		if err != nil {
+			return fmt.Errorf("unable to get confirmation, %w", err)
+		}
+
+		if !overwrite {
+			return errOverwriteAborted
+		}
+	}
+
+	// Parse the public key
+	publicKey, err := crypto.PubKeyFromBech32(cfg.PublicKey)
+	if err != nil {
+		return fmt.Errorf("unable to parse public key from bech32, %w", err)
+	}
+
+	// Save it offline in the keybase
+	_, err = kb.CreateOffline(name, publicKey)
+	if err != nil {
+		return fmt.Errorf("unable to save public key, %w", err)
+	}
+
+	io.Printfln("Key %q saved to disk.\n", name)
+
+	return nil
+}

tm2/pkg/crypto/keys/client/add_bech32_test.go

@@ -0,0 +1,202 @@
+package client
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	"github.com/gnolang/gno/tm2/pkg/crypto/bip39"
+	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestAdd_Bech32(t *testing.T) {
+	t.Parallel()
+
+	t.Run("valid bech32 addition", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			kbHome      = t.TempDir()
+			baseOptions = BaseOptions{
+				InsecurePasswordStdin: true,
+				Home:                  kbHome,
+			}
+
+			seed    = bip39.NewSeed(generateTestMnemonic(t), "")
+			account = generateKeyFromSeed(seed, "44'/118'/0'/0/0")
+
+			keyName = "key-name"
+		)
+
+		ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancelFn()
+
+		io := commands.NewTestIO()
+		io.SetIn(strings.NewReader("test1234\ntest1234\n"))
+
+		// Create the command
+		cmd := NewRootCmdWithBaseConfig(io, baseOptions)
+
+		args := []string{
+			"add",
+			"bech32",
+			"--insecure-password-stdin",
+			"--home",
+			kbHome,
+			"--pubkey",
+			account.PubKey().String(),
+			keyName,
+		}
+
+		require.NoError(t, cmd.ParseAndRun(ctx, args))
+
+		// Check the keybase
+		kb, err := keys.NewKeyBaseFromDir(kbHome)
+		require.NoError(t, err)
+
+		original, err := kb.GetByName(keyName)
+		require.NoError(t, err)
+		require.NotNil(t, original)
+
+		assert.Equal(t, account.PubKey().Address().String(), original.GetAddress().String())
+	})
+
+	t.Run("valid bech32 addition, overwrite", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			kbHome      = t.TempDir()
+			baseOptions = BaseOptions{
+				InsecurePasswordStdin: true,
+				Home:                  kbHome,
+			}
+
+			seed            = bip39.NewSeed(generateTestMnemonic(t), "")
+			originalAccount = generateKeyFromSeed(seed, "44'/118'/0'/0/0")
+			copyAccount     = generateKeyFromSeed(seed, "44'/118'/0'/0/1")
+
+			keyName = "key-name"
+		)
+
+		ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancelFn()
+
+		io := commands.NewTestIO()
+		io.SetIn(strings.NewReader("test1234\ntest1234\n"))
+
+		// Create the command
+		cmd := NewRootCmdWithBaseConfig(io, baseOptions)
+
+		baseArgs := []string{
+			"add",
+			"bech32",
+			"--insecure-password-stdin",
+			"--home",
+			kbHome,
+			keyName,
+		}
+
+		initialArgs := append(baseArgs, []string{
+			"--pubkey",
+			originalAccount.PubKey().String(),
+		}...)
+
+		require.NoError(t, cmd.ParseAndRun(ctx, initialArgs))
+
+		// Check the keybase
+		kb, err := keys.NewKeyBaseFromDir(kbHome)
+		require.NoError(t, err)
+
+		original, err := kb.GetByName(keyName)
+		require.NoError(t, err)
+
+		require.Equal(t, originalAccount.PubKey().Address().String(), original.GetAddress().String())
+
+		// Overwrite the key
+		io.SetIn(strings.NewReader("y\ntest1234\ntest1234\n"))
+
+		secondaryArgs := append(baseArgs, []string{
+			"--pubkey",
+			copyAccount.PubKey().String(),
+		}...)
+
+		cmd = NewRootCmdWithBaseConfig(io, baseOptions)
+		require.NoError(t, cmd.ParseAndRun(ctx, secondaryArgs))
+
+		newKey, err := kb.GetByName(keyName)
+		require.NoError(t, err)
+
+		require.Equal(t, copyAccount.PubKey().Address().String(), newKey.GetAddress().String())
+	})
+
+	t.Run("no overwrite permission", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			kbHome      = t.TempDir()
+			baseOptions = BaseOptions{
+				InsecurePasswordStdin: true,
+				Home:                  kbHome,
+			}
+
+			seed            = bip39.NewSeed(generateTestMnemonic(t), "")
+			originalAccount = generateKeyFromSeed(seed, "44'/118'/0'/0/0")
+			copyAccount     = generateKeyFromSeed(seed, "44'/118'/0'/0/1")
+
+			keyName = "key-name"
+		)
+
+		ctx, cancelFn := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancelFn()
+
+		io := commands.NewTestIO()
+		io.SetIn(strings.NewReader("test1234\ntest1234\n"))
+
+		// Create the command
+		cmd := NewRootCmdWithBaseConfig(io, baseOptions)
+
+		baseArgs := []string{
+			"add",
+			"bech32",
+			"--insecure-password-stdin",
+			"--home",
+			kbHome,
+			keyName,
+		}
+
+		initialArgs := append(baseArgs, []string{
+			"--pubkey",
+			originalAccount.PubKey().String(),
+		}...)
+
+		require.NoError(t, cmd.ParseAndRun(ctx, initialArgs))
+
+		// Check the keybase
+		kb, err := keys.NewKeyBaseFromDir(kbHome)
+		require.NoError(t, err)
+
+		original, err := kb.GetByName(keyName)
+		require.NoError(t, err)
+
+		io.SetIn(strings.NewReader("n\ntest1234\ntest1234\n"))
+
+		// Confirm overwrite
+		secondaryArgs := append(baseArgs, []string{
+			"--pubkey",
+			copyAccount.PubKey().String(),
+		}...)
+
+		cmd = NewRootCmdWithBaseConfig(io, baseOptions)
+		require.ErrorIs(t, cmd.ParseAndRun(ctx, secondaryArgs), errOverwriteAborted)
+
+		newKey, err := kb.GetByName(keyName)
+		require.NoError(t, err)
+
+		// Make sure the key is not overwritten
+		assert.Equal(t, original.GetAddress(), newKey.GetAddress())
+	})
+}

tm2/pkg/crypto/keys/client/add_ledger.go

@@ -0,0 +1,76 @@
+package client
+
+import (
+	"context"
+	"flag"
+	"fmt"
+
+	"github.com/gnolang/gno/tm2/pkg/commands"
+	"github.com/gnolang/gno/tm2/pkg/crypto"
+	"github.com/gnolang/gno/tm2/pkg/crypto/keys"
+)
+
+// NewAddLedgerCmd creates a gnokey add ledger command
+func NewAddLedgerCmd(cfg *AddCfg, io commands.IO) *commands.Command {
+	return commands.NewCommand(
+		commands.Metadata{
+			Name:       "ledger",
+			ShortUsage: "add ledger [flags] <key-name>",
+			ShortHelp:  "adds a Ledger key reference to the keybase",
+		},
+		commands.NewEmptyConfig(),
+		func(_ context.Context, args []string) error {
+			return execAddLedger(cfg, args, io)
+		},
+	)
+}
+
+func execAddLedger(cfg *AddCfg, args []string, io commands.IO) error {
+	// Validate a key name was provided
+	if len(args) != 1 {
+		return flag.ErrHelp
+	}
+
+	name := args[0]
+
+	// Read the keybase from the home directory
+	kb, err := keys.NewKeyBaseFromDir(cfg.RootCfg.Home)
+	if err != nil {
+		return fmt.Errorf("unable to read keybase, %w", err)
+	}
+
+	// Check if the key exists
+	exists, err := kb.HasByName(name)
+	if err != nil {
+		return fmt.Errorf("unable to fetch key, %w", err)
+	}
+
+	// Get overwrite confirmation, if any
+	if exists {
+		overwrite, err := io.GetConfirmation(fmt.Sprintf("Override the existing name %s", name))
+		if err != nil {
+			return fmt.Errorf("unable to get confirmation, %w", err)
+		}
+
+		if !overwrite {
+			return errOverwriteAborted
+		}
+	}
+
+	// Create the ledger reference
+	info, err := kb.CreateLedger(
+		name,
+		keys.Secp256k1,
+		crypto.Bech32AddrPrefix,
+		uint32(cfg.Account),
+		uint32(cfg.Index),
+	)
+	if err != nil {
+		return fmt.Errorf("unable to create Ledger reference in keybase, %w", err)
+	}
+
+	// Print the information
+	printCreate(info, false, "", io)
+
+	return nil
+}