Wallet Create CLI manager integration (#11331)

* Wallet recover CLI Manager migration * bazel run //:gazelle -- fix * Wallet create CLI Manager migration * Wallet recover CLI Manager migration (#11278) * Wallet recover CLI Manager migration * bazel run //:gazelle -- fix * fix lint and build errors * add TODO to remove duplicate code Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com> Co-authored-by: Radosław Kapka <rkapka@wp.pl> * Wallet recover CLI Manager migration * bazel run //:gazelle -- fix * Wallet recover CLI Manager migration * bazel run //:gazelle -- fix * Wallet recover CLI Manager migration * bazel run //:gazelle -- fix * fix lint and build errors * Wallet recover CLI Manager migration (#11278) * Wallet recover CLI Manager migration * bazel run //:gazelle -- fix * fix lint and build errors * add TODO to remove duplicate code Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com> Co-authored-by: Radosław Kapka <rkapka@wp.pl> * bazel run //:gazelle -- fix * rename to ConstructCLIManagerOpts Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com> Co-authored-by: Radosław Kapka <rkapka@wp.pl>
2026-01-09 15:37:56 -05:00 · 2022-09-02 10:56:47 -04:00
parent 8627fe72e8
commit cbc2153664
24 changed files with 568 additions and 500 deletions
--- a/cmd/validator/accounts/backup_test.go
+++ b/cmd/validator/accounts/backup_test.go
@@ -18,7 +18,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts/iface"
-	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/derived"
 	constant "github.com/prysmaticlabs/prysm/v3/validator/testing"
@@ -53,13 +52,14 @@ func TestBackupAccounts_Noninteractive_Derived(t *testing.T) {
 		backupPasswordFile: backupPasswordFile,
 		backupDir:          backupDir,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Derived,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Derived),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)

 	km, err := w.InitializeKeymanager(cliCtx.Context, iface.InitKeymanagerConfig{ListenForChanges: false})
@@ -170,13 +170,14 @@ func TestBackupAccounts_Noninteractive_Imported(t *testing.T) {
 		backupPasswordFile: backupPasswordFile,
 		backupDir:          backupDir,
 	})
-	_, err = accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	_, err = acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)

 	// We attempt to import accounts we wrote to the keys directory
--- a/cmd/validator/accounts/delete_test.go
+++ b/cmd/validator/accounts/delete_test.go
@@ -21,7 +21,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	prysmTime "github.com/prysmaticlabs/prysm/v3/time"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
-	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/local"
 	"github.com/urfave/cli/v2"
@@ -160,13 +159,14 @@ func TestDeleteAccounts_Noninteractive(t *testing.T) {
 		// Flags required for DeleteAccounts to work.
 		deletePublicKeys: deletePublicKeys,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)

 	// We attempt to import accounts.
--- a/cmd/validator/accounts/exit_test.go
+++ b/cmd/validator/accounts/exit_test.go
@@ -14,7 +14,6 @@ import (
 	mock2 "github.com/prysmaticlabs/prysm/v3/testing/mock"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
-	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
 	"google.golang.org/protobuf/types/known/timestamppb"
 )
@@ -67,13 +66,14 @@ func TestExitAccountsCli_OK(t *testing.T) {
 		// Flag required for ExitAccounts to work.
 		voluntaryExitPublicKeys: keystore.Pubkey,
 	})
-	_, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	_, err = acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)
 	require.NoError(t, accountsImport(cliCtx))

@@ -167,13 +167,14 @@ func TestExitAccountsCli_OK_AllPublicKeys(t *testing.T) {
 		// Exit all public keys.
 		exitAll: true,
 	})
-	_, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	_, err = acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)
 	require.NoError(t, accountsImport(cliCtx))

--- a/cmd/validator/accounts/import.go
+++ b/cmd/validator/accounts/import.go
@@ -6,6 +6,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/cmd"
 	"github.com/prysmaticlabs/prysm/v3/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v3/io/prompt"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts/iface"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts/userprompt"
@@ -93,21 +94,51 @@ func walletImport(c *cli.Context) (*wallet.Wallet, error) {
 			})
 		}

-		cfg, err := accounts.ExtractWalletCreationConfigFromCli(cliCtx, keymanager.Local)
+		wCfg, err := ExtractWalletDirPassword(cliCtx)
 		if err != nil {
 			return nil, err
 		}
 		w := wallet.New(&wallet.Config{
-			KeymanagerKind: cfg.WalletCfg.KeymanagerKind,
-			WalletDir:      cfg.WalletCfg.WalletDir,
-			WalletPassword: cfg.WalletCfg.WalletPassword,
+			KeymanagerKind: keymanager.Local,
+			WalletDir:      wCfg.Dir,
+			WalletPassword: wCfg.Password,
 		})
 		if err = accounts.CreateLocalKeymanagerWallet(cliCtx.Context, w); err != nil {
 			return nil, errors.Wrap(err, "could not create keymanager")
 		}
-		log.WithField("wallet-path", cfg.WalletCfg.WalletDir).Info(
+		log.WithField("wallet-path", wCfg.Dir).Info(
 			"Successfully created new wallet",
 		)
 		return w, nil
 	})
 }
+
+// WalletDirPassword holds the directory and password of a wallet.
+type WalletDirPassword struct {
+	Dir      string
+	Password string
+}
+
+// ExtractWalletDirPassword prompts the user for wallet directory and password.
+func ExtractWalletDirPassword(cliCtx *cli.Context) (WalletDirPassword, error) {
+	// Get wallet dir and check that no wallet exists at the location.
+	walletDir, err := userprompt.InputDirectory(cliCtx, userprompt.WalletDirPromptText, flags.WalletDirFlag)
+	if err != nil {
+		return WalletDirPassword{}, err
+	}
+	walletPassword, err := prompt.InputPassword(
+		cliCtx,
+		flags.WalletPasswordFileFlag,
+		wallet.NewWalletPasswordPromptText,
+		wallet.ConfirmPasswordPromptText,
+		true, /* Should confirm password */
+		prompt.ValidatePasswordInput,
+	)
+	if err != nil {
+		return WalletDirPassword{}, err
+	}
+	return WalletDirPassword{
+		Dir:      walletDir,
+		Password: walletPassword,
+	}, nil
+}
--- a/cmd/validator/accounts/import_test.go
+++ b/cmd/validator/accounts/import_test.go
@@ -36,13 +36,14 @@ func TestImport_Noninteractive(t *testing.T) {
 		walletPasswordFile:  passwordFilePath,
 		accountPasswordFile: passwordFilePath,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)
 	newKm, err := local.NewKeymanager(
 		cliCtx.Context,
@@ -93,13 +94,14 @@ func TestImport_DuplicateKeys(t *testing.T) {
 		walletPasswordFile:  passwordFilePath,
 		accountPasswordFile: passwordFilePath,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)

 	// Create a key and then copy it to create a duplicate
@@ -141,13 +143,14 @@ func TestImport_Noninteractive_RandomName(t *testing.T) {
 		walletPasswordFile:  passwordFilePath,
 		accountPasswordFile: passwordFilePath,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)
 	newKm, err := local.NewKeymanager(
 		cliCtx.Context,
@@ -224,13 +227,14 @@ func TestImport_Noninteractive_Filepath(t *testing.T) {
 		walletPasswordFile:  passwordFilePath,
 		accountPasswordFile: passwordFilePath,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Local,
-			WalletPassword: password,
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Local),
+		accounts.WithWalletPassword(password),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)
 	newKm, err := local.NewKeymanager(
 		cliCtx.Context,
--- a/cmd/validator/wallet/BUILD.bazel
+++ b/cmd/validator/wallet/BUILD.bazel
@@ -3,6 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
    name = "go_default_library",
    srcs = [
+        "create.go",
        "edit.go",
        "recover.go",
        "wallet.go",
@@ -20,6 +21,7 @@ go_library(
        "//validator/accounts/wallet:go_default_library",
        "//validator/keymanager:go_default_library",
        "//validator/keymanager/remote:go_default_library",
+        "@com_github_manifoldco_promptui//:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
        "@com_github_sirupsen_logrus//:go_default_library",
        "@com_github_tyler_smith_go_bip39//:go_default_library",
@@ -31,11 +33,13 @@ go_library(
 go_test(
    name = "go_default_test",
    srcs = [
+        "create_test.go",
        "edit_test.go",
        "recover_test.go",
    ],
    embed = [":go_default_library"],
    deps = [
+        "//cmd/validator/accounts:go_default_library",
        "//cmd/validator/flags:go_default_library",
        "//config/params:go_default_library",
        "//testing/assert:go_default_library",
@@ -45,7 +49,11 @@ go_test(
        "//validator/accounts/wallet:go_default_library",
        "//validator/keymanager:go_default_library",
        "//validator/keymanager/derived:go_default_library",
+        "//validator/keymanager/local:go_default_library",
        "//validator/keymanager/remote:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+        "@com_github_sirupsen_logrus//hooks/test:go_default_library",
        "@com_github_urfave_cli_v2//:go_default_library",
    ],
 )
--- a/cmd/validator/wallet/create.go
+++ b/cmd/validator/wallet/create.go
@@ -0,0 +1,171 @@
+package wallet
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/manifoldco/promptui"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v3/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v3/io/prompt"
+	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
+	"github.com/prysmaticlabs/prysm/v3/validator/accounts/userprompt"
+	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
+	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
+	"github.com/urfave/cli/v2"
+)
+
+const (
+	// #nosec G101 -- Not sensitive data
+	newMnemonicPassphraseYesNoText = "(Advanced) Do you want to setup a '25th word' passphrase for your mnemonic? [y/n]"
+	// #nosec G101 -- Not sensitive data
+	newMnemonicPassphrasePromptText = "(Advanced) Setup a passphrase '25th word' for your mnemonic " +
+		"(WARNING: You cannot recover your keys from your mnemonic if you forget this passphrase!)"
+)
+
+func walletCreate(c *cli.Context) error {
+	keymanagerKind, err := inputKeymanagerKind(c)
+	if err != nil {
+		return err
+	}
+
+	opts, err := ConstructCLIManagerOpts(c, keymanagerKind)
+	if err != nil {
+		return err
+	}
+
+	acc, err := accounts.NewCLIManager(opts...)
+	if err != nil {
+		return err
+	}
+	if _, err := acc.WalletCreate(c.Context); err != nil {
+		return errors.Wrap(err, "could not create wallet")
+	}
+	return nil
+}
+
+// ConstructCLIManagerOpts prompts the user for wallet creation input.
+func ConstructCLIManagerOpts(cliCtx *cli.Context, keymanagerKind keymanager.Kind) ([]accounts.Option, error) {
+	cliOpts := []accounts.Option{}
+	// Get wallet dir and check that no wallet exists at the location.
+	walletDir, err := userprompt.InputDirectory(cliCtx, userprompt.WalletDirPromptText, flags.WalletDirFlag)
+	if err != nil {
+		return []accounts.Option{}, err
+	}
+	dirExists, err := wallet.Exists(walletDir)
+	if err != nil {
+		return []accounts.Option{}, err
+	}
+	if dirExists {
+		return []accounts.Option{}, errors.New("a wallet already exists at this location. Please input an" +
+			" alternative location for the new wallet or remove the current wallet")
+	}
+
+	walletPassword, err := prompt.InputPassword(
+		cliCtx,
+		flags.WalletPasswordFileFlag,
+		wallet.NewWalletPasswordPromptText,
+		wallet.ConfirmPasswordPromptText,
+		true, /* Should confirm password */
+		prompt.ValidatePasswordInput,
+	)
+	if err != nil {
+		return []accounts.Option{}, err
+	}
+	cliOpts = append(cliOpts, accounts.WithWalletDir(walletDir))
+	cliOpts = append(cliOpts, accounts.WithWalletPassword(walletPassword))
+	cliOpts = append(cliOpts, accounts.WithKeymanagerType(keymanagerKind))
+	cliOpts = append(cliOpts, accounts.WithSkipMnemonicConfirm(cliCtx.Bool(flags.SkipDepositConfirmationFlag.Name)))
+
+	skipMnemonic25thWord := cliCtx.IsSet(flags.SkipMnemonic25thWordCheckFlag.Name)
+	has25thWordFile := cliCtx.IsSet(flags.Mnemonic25thWordFileFlag.Name)
+	if keymanagerKind == keymanager.Derived {
+		numAccounts, err := inputNumAccounts(cliCtx)
+		if err != nil {
+			return []accounts.Option{}, errors.Wrap(err, "could not get number of accounts to generate")
+		}
+		cliOpts = append(cliOpts, accounts.WithNumAccounts(int(numAccounts)))
+	}
+	if keymanagerKind == keymanager.Derived && !skipMnemonic25thWord && !has25thWordFile {
+		resp, err := prompt.ValidatePrompt(
+			os.Stdin, newMnemonicPassphraseYesNoText, prompt.ValidateYesOrNo,
+		)
+		if err != nil {
+			return []accounts.Option{}, errors.Wrap(err, "could not validate choice")
+		}
+		if strings.EqualFold(resp, "y") {
+			mnemonicPassphrase, err := prompt.InputPassword(
+				cliCtx,
+				flags.Mnemonic25thWordFileFlag,
+				newMnemonicPassphrasePromptText,
+				"Confirm mnemonic passphrase",
+				true, /* Should confirm password */
+				func(input string) error {
+					if strings.TrimSpace(input) == "" {
+						return errors.New("input cannot be empty")
+					}
+					return nil
+				},
+			)
+			if err != nil {
+				return []accounts.Option{}, err
+			}
+			cliOpts = append(cliOpts, accounts.WithMnemonic25thWord(mnemonicPassphrase))
+		}
+	}
+	if keymanagerKind == keymanager.Remote {
+		opts, err := userprompt.InputRemoteKeymanagerConfig(cliCtx)
+		if err != nil {
+			return []accounts.Option{}, errors.Wrap(err, "could not input remote keymanager config")
+		}
+		cliOpts = append(cliOpts, accounts.WithKeymanagerOpts(opts))
+	}
+	if keymanagerKind == keymanager.Web3Signer {
+		return []accounts.Option{}, errors.New("web3signer keymanager does not require persistent wallets.")
+	}
+	return cliOpts, nil
+}
+
+func inputKeymanagerKind(cliCtx *cli.Context) (keymanager.Kind, error) {
+	if cliCtx.IsSet(flags.KeymanagerKindFlag.Name) {
+		return keymanager.ParseKind(cliCtx.String(flags.KeymanagerKindFlag.Name))
+	}
+	promptSelect := promptui.Select{
+		Label: "Select a type of wallet",
+		Items: []string{
+			wallet.KeymanagerKindSelections[keymanager.Local],
+			wallet.KeymanagerKindSelections[keymanager.Derived],
+			wallet.KeymanagerKindSelections[keymanager.Remote],
+			wallet.KeymanagerKindSelections[keymanager.Web3Signer],
+		},
+	}
+	selection, _, err := promptSelect.Run()
+	if err != nil {
+		return keymanager.Local, fmt.Errorf("could not select wallet type: %w", userprompt.FormatPromptError(err))
+	}
+	return keymanager.Kind(selection), nil
+}
+
+// CreateAndSaveWalletCli from user input with a desired keymanager. If a
+// wallet already exists in the path, it suggests the user alternatives
+// such as how to edit their existing wallet configuration.
+func CreateAndSaveWalletCli(cliCtx *cli.Context) (*wallet.Wallet, error) {
+	keymanagerKind, err := inputKeymanagerKind(cliCtx)
+	if err != nil {
+		return nil, err
+	}
+	opts, err := ConstructCLIManagerOpts(cliCtx, keymanagerKind)
+	if err != nil {
+		return nil, err
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	if err != nil {
+		return nil, err
+	}
+	w, err := acc.WalletCreate(cliCtx.Context)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not create wallet")
+	}
+	return w, nil
+}
--- a/cmd/validator/wallet/create_test.go
+++ b/cmd/validator/wallet/create_test.go
@@ -0,0 +1,247 @@
+package wallet
+
+import (
+	"context"
+	"flag"
+	"io"
+	"testing"
+
+	"github.com/pkg/errors"
+	cmdacc "github.com/prysmaticlabs/prysm/v3/cmd/validator/accounts"
+	"github.com/prysmaticlabs/prysm/v3/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v3/testing/assert"
+	"github.com/prysmaticlabs/prysm/v3/testing/require"
+	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
+	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
+	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
+	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/local"
+	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/remote"
+	"github.com/sirupsen/logrus"
+	logTest "github.com/sirupsen/logrus/hooks/test"
+	"github.com/urfave/cli/v2"
+)
+
+func init() {
+	logrus.SetLevel(logrus.DebugLevel)
+	logrus.SetOutput(io.Discard)
+}
+
+func TestCreateOrOpenWallet(t *testing.T) {
+	hook := logTest.NewGlobal()
+	walletDir, passwordsDir, walletPasswordFile := setupWalletAndPasswordsDir(t)
+	cliCtx := setupWalletCtx(t, &testWalletConfig{
+		walletDir:          walletDir,
+		passwordsDir:       passwordsDir,
+		keymanagerKind:     keymanager.Local,
+		walletPasswordFile: walletPasswordFile,
+	})
+	createLocalWallet := func(cliCtx *cli.Context) (*wallet.Wallet, error) {
+		cfg, err := cmdacc.ExtractWalletDirPassword(cliCtx)
+		if err != nil {
+			return nil, err
+		}
+		w := wallet.New(&wallet.Config{
+			KeymanagerKind: keymanager.Local,
+			WalletDir:      cfg.Dir,
+			WalletPassword: cfg.Password,
+		})
+		if err = accounts.CreateLocalKeymanagerWallet(cliCtx.Context, w); err != nil {
+			return nil, errors.Wrap(err, "could not create keymanager")
+		}
+		log.WithField("wallet-path", cfg.Dir).Info(
+			"Successfully created new wallet",
+		)
+		return w, nil
+	}
+	createdWallet, err := wallet.OpenWalletOrElseCli(cliCtx, createLocalWallet)
+	require.NoError(t, err)
+	require.LogsContain(t, hook, "Successfully created new wallet")
+
+	openedWallet, err := wallet.OpenWalletOrElseCli(cliCtx, createLocalWallet)
+	require.NoError(t, err)
+	assert.Equal(t, createdWallet.KeymanagerKind(), openedWallet.KeymanagerKind())
+	assert.Equal(t, createdWallet.AccountsDir(), openedWallet.AccountsDir())
+}
+
+func TestCreateWallet_Local(t *testing.T) {
+	walletDir, passwordsDir, walletPasswordFile := setupWalletAndPasswordsDir(t)
+	cliCtx := setupWalletCtx(t, &testWalletConfig{
+		walletDir:          walletDir,
+		passwordsDir:       passwordsDir,
+		keymanagerKind:     keymanager.Local,
+		walletPasswordFile: walletPasswordFile,
+	})
+
+	// We attempt to create the wallet.
+	_, err := CreateAndSaveWalletCli(cliCtx)
+	require.NoError(t, err)
+
+	// We attempt to open the newly created wallet.
+	w, err := wallet.OpenWallet(cliCtx.Context, &wallet.Config{
+		WalletDir: walletDir,
+	})
+	assert.NoError(t, err)
+	_, err = w.ReadFileAtPath(cliCtx.Context, local.AccountsPath, local.AccountsKeystoreFileName)
+	require.NoError(t, err)
+}
+
+func TestCreateWallet_Derived(t *testing.T) {
+	walletDir, passwordsDir, passwordFile := setupWalletAndPasswordsDir(t)
+	cliCtx := setupWalletCtx(t, &testWalletConfig{
+		walletDir:          walletDir,
+		passwordsDir:       passwordsDir,
+		walletPasswordFile: passwordFile,
+		keymanagerKind:     keymanager.Derived,
+		numAccounts:        1,
+	})
+
+	// We attempt to create the wallet.
+	_, err := CreateAndSaveWalletCli(cliCtx)
+	require.NoError(t, err)
+
+	// We attempt to open the newly created wallet.
+	_, err = wallet.OpenWallet(cliCtx.Context, &wallet.Config{
+		WalletDir: walletDir,
+	})
+	assert.NoError(t, err)
+}
+
+// TestCreateWallet_WalletAlreadyExists checks for expected error if trying to create a wallet when there is one already.
+func TestCreateWallet_WalletAlreadyExists(t *testing.T) {
+	walletDir, passwordsDir, passwordFile := setupWalletAndPasswordsDir(t)
+	cliCtx := setupWalletCtx(t, &testWalletConfig{
+		walletDir:          walletDir,
+		passwordsDir:       passwordsDir,
+		walletPasswordFile: passwordFile,
+		keymanagerKind:     keymanager.Derived,
+		numAccounts:        1,
+	})
+
+	// We attempt to create the wallet.
+	_, err := CreateAndSaveWalletCli(cliCtx)
+	require.NoError(t, err)
+
+	// We attempt to create another wallet of the same type at the same location. We expect an error.
+	_, err = CreateAndSaveWalletCli(cliCtx)
+	require.ErrorContains(t, "already exists", err)
+
+	cliCtx = setupWalletCtx(t, &testWalletConfig{
+		walletDir:          walletDir,
+		passwordsDir:       passwordsDir,
+		walletPasswordFile: passwordFile,
+		keymanagerKind:     keymanager.Local,
+	})
+
+	// We attempt to create another wallet of different type at the same location. We expect an error.
+	_, err = CreateAndSaveWalletCli(cliCtx)
+	require.ErrorContains(t, "already exists", err)
+}
+
+func TestCreateWallet_Remote(t *testing.T) {
+	walletDir, _, walletPasswordFile := setupWalletAndPasswordsDir(t)
+	wantCfg := &remote.KeymanagerOpts{
+		RemoteCertificate: &remote.CertificateConfig{
+			RequireTls:     true,
+			ClientCertPath: "/tmp/client.crt",
+			ClientKeyPath:  "/tmp/client.key",
+			CACertPath:     "/tmp/ca.crt",
+		},
+		RemoteAddr: "host.example.com:4000",
+	}
+	app := cli.App{}
+	set := flag.NewFlagSet("test", 0)
+	keymanagerKind := "remote"
+	set.String(flags.WalletDirFlag.Name, walletDir, "")
+	set.String(flags.WalletPasswordFileFlag.Name, walletDir, "")
+	set.String(flags.KeymanagerKindFlag.Name, keymanagerKind, "")
+	set.String(flags.GrpcRemoteAddressFlag.Name, wantCfg.RemoteAddr, "")
+	set.String(flags.RemoteSignerCertPathFlag.Name, wantCfg.RemoteCertificate.ClientCertPath, "")
+	set.String(flags.RemoteSignerKeyPathFlag.Name, wantCfg.RemoteCertificate.ClientKeyPath, "")
+	set.String(flags.RemoteSignerCACertPathFlag.Name, wantCfg.RemoteCertificate.CACertPath, "")
+	assert.NoError(t, set.Set(flags.WalletDirFlag.Name, walletDir))
+	assert.NoError(t, set.Set(flags.WalletPasswordFileFlag.Name, walletPasswordFile))
+	assert.NoError(t, set.Set(flags.KeymanagerKindFlag.Name, keymanagerKind))
+	assert.NoError(t, set.Set(flags.GrpcRemoteAddressFlag.Name, wantCfg.RemoteAddr))
+	assert.NoError(t, set.Set(flags.RemoteSignerCertPathFlag.Name, wantCfg.RemoteCertificate.ClientCertPath))
+	assert.NoError(t, set.Set(flags.RemoteSignerKeyPathFlag.Name, wantCfg.RemoteCertificate.ClientKeyPath))
+	assert.NoError(t, set.Set(flags.RemoteSignerCACertPathFlag.Name, wantCfg.RemoteCertificate.CACertPath))
+	cliCtx := cli.NewContext(&app, set, nil)
+
+	// We attempt to create the wallet.
+	_, err := CreateAndSaveWalletCli(cliCtx)
+	require.NoError(t, err)
+
+	// We attempt to open the newly created wallet.
+	ctx := context.Background()
+	w, err := wallet.OpenWallet(cliCtx.Context, &wallet.Config{
+		WalletDir: walletDir,
+	})
+	assert.NoError(t, err)
+
+	// We read the keymanager config for the newly created wallet.
+	encoded, err := w.ReadKeymanagerConfigFromDisk(ctx)
+	assert.NoError(t, err)
+	cfg, err := remote.UnmarshalOptionsFile(encoded)
+	assert.NoError(t, err)
+
+	// We assert the created configuration was as desired.
+	assert.DeepEqual(t, wantCfg, cfg)
+}
+
+func TestInputKeymanagerKind(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    string
+		want    keymanager.Kind
+		wantErr bool
+	}{
+		{
+			name:    "local returns local kind",
+			args:    "local",
+			want:    keymanager.Local,
+			wantErr: false,
+		},
+		{
+			name:    "direct returns local kind",
+			args:    "direct",
+			want:    keymanager.Local,
+			wantErr: false,
+		},
+		{
+			name:    "imported returns local kind",
+			args:    "imported",
+			want:    keymanager.Local,
+			wantErr: false,
+		},
+		{
+			name:    "derived returns derived kind",
+			args:    "derived",
+			want:    keymanager.Derived,
+			wantErr: false,
+		},
+		{
+			name:    "remote returns remote kind",
+			args:    "remote",
+			want:    keymanager.Remote,
+			wantErr: false,
+		},
+		{
+			name:    "REMOTE (capitalized) returns remote kind",
+			args:    "REMOTE",
+			want:    keymanager.Remote,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			app := cli.App{}
+			set := flag.NewFlagSet("test", 0)
+			set.String(flags.KeymanagerKindFlag.Name, tt.args, "")
+			assert.NoError(t, set.Set(flags.KeymanagerKindFlag.Name, tt.args))
+			cliCtx := cli.NewContext(&app, set, nil)
+			got, err := inputKeymanagerKind(cliCtx)
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want.String(), got.String())
+		})
+	}
+}
--- a/cmd/validator/wallet/edit_test.go
+++ b/cmd/validator/wallet/edit_test.go
@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
-	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/remote"
 	"github.com/urfave/cli/v2"
@@ -52,6 +51,7 @@ type testWalletConfig struct {
 	keysDir                 string
 	backupDir               string
 	walletDir               string
+	passwordsDir            string
 }

 func setupWalletCtx(
@@ -104,13 +104,14 @@ func TestEditWalletConfiguration(t *testing.T) {
 		walletDir:      walletDir,
 		keymanagerKind: keymanager.Remote,
 	})
-	w, err := accounts.CreateWalletWithKeymanager(cliCtx.Context, &accounts.CreateWalletConfig{
-		WalletCfg: &wallet.Config{
-			WalletDir:      walletDir,
-			KeymanagerKind: keymanager.Remote,
-			WalletPassword: "Passwordz0320$",
-		},
-	})
+	opts := []accounts.Option{
+		accounts.WithWalletDir(walletDir),
+		accounts.WithKeymanagerType(keymanager.Remote),
+		accounts.WithWalletPassword("Passwordz0320$"),
+	}
+	acc, err := accounts.NewCLIManager(opts...)
+	require.NoError(t, err)
+	w, err := acc.WalletCreate(cliCtx.Context)
 	require.NoError(t, err)

 	originalCfg := &remote.KeymanagerOpts{
--- a/cmd/validator/wallet/wallet.go
+++ b/cmd/validator/wallet/wallet.go
@@ -5,7 +5,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/cmd/validator/flags"
 	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/runtime/tos"
-	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
@@ -43,13 +42,13 @@ var Commands = &cli.Command{
 				if err := cmd.LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags); err != nil {
 					return err
 				}
-				return tos.VerifyTosAcceptedOrPrompt(cliCtx)
-			},
-			Action: func(cliCtx *cli.Context) error {
-				if err := features.ConfigureValidator(cliCtx); err != nil {
+				if err := tos.VerifyTosAcceptedOrPrompt(cliCtx); err != nil {
 					return err
 				}
-				if _, err := accounts.CreateAndSaveWalletCli(cliCtx); err != nil {
+				return features.ConfigureValidator(cliCtx)
+			},
+			Action: func(cliCtx *cli.Context) error {
+				if err := walletCreate(cliCtx); err != nil {
 					log.WithError(err).Fatal("Could not create a wallet")
 				}
 				return nil