Additional modular commands.

cmd/account/create/input.go

@@ -0,0 +1,97 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	"github.com/wealdtech/ethdo/util"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	timeout time.Duration
+	// For all accounts.
+	wallet           e2wtypes.Wallet
+	accountName      string
+	passphrase       string
+	walletPassphrase string
+	// For distributed accounts.
+	participants     uint32
+	signingThreshold uint32
+	// For pathed accounts.
+	path string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+
+	// Account name.
+	if viper.GetString("account") == "" {
+		return nil, errors.New("account is required")
+	}
+	_, data.accountName, err = e2wallet.WalletAndAccountNames(viper.GetString("account"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain account name")
+	}
+	if data.accountName == "" {
+		return nil, errors.New("account name is required")
+	}
+
+	// Wallet.
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	data.wallet, err = core.WalletFromInput(ctx)
+	cancel()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain wallet")
+	}
+
+	// Passphrase.
+	data.passphrase, err = util.GetOptionalPassphrase()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain passphrase")
+	}
+
+	// Wallet passphrase.
+	data.walletPassphrase = util.GetWalletPassphrase()
+
+	// Participants.
+	if viper.GetInt32("participants") == 0 {
+		return nil, errors.New("participants must be at least one")
+	}
+	data.participants = viper.GetUint32("participants")
+
+	// Signing threshold.
+	if viper.GetInt32("signing-threshold") == 0 {
+		return nil, errors.New("signing threshold must be at least one")
+	}
+	data.signingThreshold = viper.GetUint32("signing-threshold")
+
+	// Path.
+	data.path = viper.GetString("path")
+
+	return data, nil
+}

cmd/account/create/input_internal_test.go

@@ -0,0 +1,161 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Unknown/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain wallet: wallet not found",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "account is required",
+		},
+		{
+			name: "AccountWalletOnly",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"account":    "Test wallet/",
+			},
+			err: "account name is required",
+		},
+		{
+			name: "AccountMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "//",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain account name: invalid account format",
+		},
+		{
+			name: "MultiplePassphrases",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        []string{"ce%NohGhah4ye5ra", "other"},
+				"participants":      3,
+				"signing-threshold": 2,
+			},
+			err: "failed to obtain passphrase: multiple passphrases supplied",
+		},
+		{
+			name: "ParticipantsZero",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        "ce%NohGhah4ye5ra",
+				"participants":      0,
+				"signing-threshold": 2,
+			},
+			err: "participants must be at least one",
+		},
+		{
+			name: "SigningThresholdZero",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        "ce%NohGhah4ye5ra",
+				"participants":      3,
+				"signing-threshold": 0,
+			},
+			err: "signing threshold must be at least one",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"account":           "Test wallet/Test account",
+				"passphrase":        "ce%NohGhah4ye5ra",
+				"participants":      3,
+				"signing-threshold": 2,
+			},
+			res: &dataIn{
+				timeout:          5 * time.Second,
+				accountName:      "Test account",
+				passphrase:       "ce%NohGhah4ye5ra",
+				participants:     3,
+				signingThreshold: 2,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.accountName, res.accountName)
+				require.Equal(t, test.res.passphrase, res.passphrase)
+				require.Equal(t, test.res.participants, res.participants)
+				require.Equal(t, test.res.signingThreshold, res.signingThreshold)
+			}
+		})
+	}
+}

cmd/account/create/output.go

@@ -0,0 +1,45 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataOut struct {
+	account e2wtypes.Account
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.account == nil {
+		return "", errors.New("no account")
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()), nil
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountPublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()), nil
+	}
+
+	return "", errors.New("no public key available")
+}

cmd/account/create/output_internal_test.go

@@ -0,0 +1,113 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func hexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func TestOutput(t *testing.T) {
+	testWallet, err := nd.CreateWallet(context.Background(), "Test", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	interop0, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	distributedWallet, err := distributed.CreateWallet(context.Background(), "Test distributed", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, distributedWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	distributed0, err := distributedWallet.(e2wtypes.WalletDistributedAccountImporter).ImportDistributedAccount(context.Background(),
+		"Distributed 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		2,
+		[][]byte{
+			hexToBytes("0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268"),
+			hexToBytes("0xaec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d"),
+		},
+		map[uint64]string{
+			1: "localhost-1:12345",
+			2: "localhost-2:12345",
+			3: "localhost-3:12345",
+		},
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "AccountNil",
+			dataOut: &dataOut{},
+			err:     "no account",
+		},
+		{
+			name: "Account",
+			dataOut: &dataOut{
+				account: interop0,
+			},
+			res: "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+		},
+		{
+			name: "DistributedAccount",
+			dataOut: &dataOut{
+				account: distributed0,
+			},
+			res: "0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/account/create/process.go

@@ -0,0 +1,144 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+	"regexp"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase != "" && !util.AcceptablePassphrase(data.passphrase) {
+		return nil, errors.New("supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
+	}
+	locker, isLocker := data.wallet.(e2wtypes.WalletLocker)
+	if isLocker {
+		if err := locker.Unlock(ctx, []byte(data.walletPassphrase)); err != nil {
+			return nil, errors.Wrap(err, "failed to unlock wallet")
+		}
+		defer locker.Lock(ctx)
+	}
+	if data.participants == 0 {
+		return nil, errors.New("participants is required")
+	}
+
+	// Create style of account based on input.
+	switch {
+	case data.participants > 1:
+		return processDistributed(ctx, data)
+	case data.path != "":
+		return processPathed(ctx, data)
+	default:
+		return processStandard(ctx, data)
+	}
+}
+
+func processStandard(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("passphrase is required")
+	}
+
+	results := &dataOut{}
+
+	creator, isCreator := data.wallet.(e2wtypes.WalletAccountCreator)
+	if !isCreator {
+		return nil, errors.New("wallet does not support account creation")
+	}
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	account, err := creator.CreateAccount(ctx, data.accountName, []byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create account")
+	}
+	results.account = account
+	return results, nil
+}
+
+func processPathed(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("passphrase is required")
+	}
+	match, err := regexp.Match("^m/[0-9]+/[0-9]+(/[0-9+])+", []byte(data.path))
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to match path to regular expression")
+	}
+	if !match {
+		// nolint
+		return nil, errors.New("path does not match expected format m/...")
+	}
+
+	results := &dataOut{}
+
+	creator, isCreator := data.wallet.(e2wtypes.WalletPathedAccountCreator)
+	if !isCreator {
+		return nil, errors.New("wallet does not support account creation with an explicit path")
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	account, err := creator.CreatePathedAccount(ctx, data.path, data.accountName, []byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create account")
+	}
+	results.account = account
+	return results, nil
+}
+
+func processDistributed(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.signingThreshold == 0 {
+		return nil, errors.New("signing threshold required")
+	}
+	if data.signingThreshold <= data.participants/2 {
+		return nil, errors.New("signing threshold must be more than half the number of participants")
+	}
+	if data.signingThreshold > data.participants {
+		return nil, errors.New("signing threshold cannot be higher than the number of participants")
+	}
+
+	results := &dataOut{}
+
+	creator, isCreator := data.wallet.(e2wtypes.WalletDistributedAccountCreator)
+	if !isCreator {
+		return nil, errors.New("wallet does not support distributed account creation")
+	}
+
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	account, err := creator.CreateDistributedAccount(ctx,
+		data.accountName,
+		data.participants,
+		data.signingThreshold,
+		[]byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create account")
+	}
+	results.account = account
+	return results, nil
+}

cmd/account/create/process_internal_test.go

@@ -0,0 +1,315 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+	"math/rand"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/attestantio/dirk/testing/daemon"
+	"github.com/attestantio/dirk/testing/resources"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	dirk "github.com/wealdtech/go-eth2-wallet-dirk"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	hd "github.com/wealdtech/go-eth2-wallet-hd/v2"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	"google.golang.org/grpc/credentials"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	testNDWallet, err := nd.CreateWallet(context.Background(),
+		"Test",
+		scratch.New(),
+		keystorev4.New(),
+	)
+	require.NoError(t, err)
+	testHDWallet, err := hd.CreateWallet(context.Background(),
+		"Test",
+		[]byte("pass"),
+		scratch.New(),
+		keystorev4.New(),
+		[]byte{
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+		},
+	)
+	require.NoError(t, err)
+
+	// #nosec G404
+	port1 := uint32(12000 + rand.Intn(4000))
+	// #nosec G404
+	port2 := uint32(12000 + rand.Intn(4000))
+	// #nosec G404
+	port3 := uint32(12000 + rand.Intn(4000))
+	peers := map[uint64]string{
+		1: fmt.Sprintf("signer-test01:%d", port1),
+		2: fmt.Sprintf("signer-test02:%d", port2),
+		3: fmt.Sprintf("signer-test03:%d", port3),
+	}
+	_, path, err := daemon.New(context.Background(), "", 1, port1, peers)
+	require.NoError(t, err)
+	defer os.RemoveAll(path)
+	_, path, err = daemon.New(context.Background(), "", 2, port2, peers)
+	require.NoError(t, err)
+	defer os.RemoveAll(path)
+	_, path, err = daemon.New(context.Background(), "", 3, port3, peers)
+	require.NoError(t, err)
+	defer os.RemoveAll(path)
+	endpoints := []*dirk.Endpoint{
+		dirk.NewEndpoint("signer-test01", port1),
+		dirk.NewEndpoint("signer-test02", port2),
+		dirk.NewEndpoint("signer-test03", port3),
+	}
+	credentials, err := credentialsFromCerts(context.Background(), resources.ClientTest01Crt, resources.ClientTest01Key, resources.CACrt)
+	require.NoError(t, err)
+	testDistributedWallet, err := dirk.OpenWallet(context.Background(), "Wallet 3", credentials, endpoints)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "WalletPassphraseIncorrect",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Good",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "bad",
+				participants:     1,
+				signingThreshold: 1,
+			},
+			err: "failed to unlock wallet: incorrect passphrase",
+		},
+		{
+			name: "PassphraseMissing",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Good",
+				passphrase:       "",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+			},
+			err: "passphrase is required",
+		},
+		{
+			name: "PassphraseWeak",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Good",
+				passphrase:       "poor",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+			},
+			err: "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Good",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+			},
+		},
+		{
+			name: "PathMalformed",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Pathed",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+				path:             "n/12381/3600/1/2/3",
+			},
+			err: "path does not match expected format m/...",
+		},
+		{
+			name: "PathPassphraseMissing",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Pathed",
+				passphrase:       "",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+				path:             "m/12381/3600/1/2/3",
+			},
+			err: "passphrase is required",
+		},
+		{
+			name: "PathNotSupported",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Pathed",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+				path:             "m/12381/3600/1/2/3",
+			},
+			err: "wallet does not support account creation with an explicit path",
+		},
+		{
+			name: "GoodWithPath",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testHDWallet,
+				accountName:      "Pathed",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     1,
+				signingThreshold: 1,
+				path:             "m/12381/3600/1/2/3",
+			},
+		},
+		{
+			name: "DistributedSigningThresholdZero",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testDistributedWallet,
+				accountName:      "Remote",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     3,
+				signingThreshold: 0,
+			},
+			err: "signing threshold required",
+		},
+		{
+			name: "DistributedSigningThresholdNotHalf",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testDistributedWallet,
+				accountName:      "Remote",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     3,
+				signingThreshold: 1,
+			},
+			err: "signing threshold must be more than half the number of participants",
+		},
+		{
+			name: "DistributedSigningThresholdTooHigh",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testDistributedWallet,
+				accountName:      "Remote",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     3,
+				signingThreshold: 4,
+			},
+			err: "signing threshold cannot be higher than the number of participants",
+		},
+		{
+			name: "DistributedNotSupported",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Remote",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     3,
+				signingThreshold: 2,
+			},
+			err: "wallet does not support distributed account creation",
+		},
+		{
+			name: "DistributedGood",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testDistributedWallet,
+				accountName:      "Remote",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				participants:     3,
+				signingThreshold: 2,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.dataIn.accountName, res.account.Name())
+			}
+		})
+	}
+}
+
+func TestNilData(t *testing.T) {
+	_, err := processStandard(context.Background(), nil)
+	require.EqualError(t, err, "no data")
+	_, err = processPathed(context.Background(), nil)
+	require.EqualError(t, err, "no data")
+	_, err = processDistributed(context.Background(), nil)
+	require.EqualError(t, err, "no data")
+}
+
+func credentialsFromCerts(ctx context.Context, clientCert []byte, clientKey []byte, caCert []byte) (credentials.TransportCredentials, error) {
+	clientPair, err := tls.X509KeyPair(clientCert, clientKey)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to load client keypair")
+	}
+
+	tlsCfg := &tls.Config{
+		Certificates: []tls.Certificate{clientPair},
+		MinVersion:   tls.VersionTLS13,
+	}
+
+	if caCert != nil {
+		cp := x509.NewCertPool()
+		if !cp.AppendCertsFromPEM(caCert) {
+			return nil, errors.New("failed to add CA certificate")
+		}
+		tlsCfg.RootCAs = cp
+	}
+
+	return credentials.NewTLS(tlsCfg), nil
+}

cmd/account/create/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountcreate
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the account create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/account/import/input.go

@@ -0,0 +1,88 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	"github.com/wealdtech/ethdo/util"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	timeout          time.Duration
+	wallet           e2wtypes.Wallet
+	key              []byte
+	accountName      string
+	passphrase       string
+	walletPassphrase string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+
+	// Account name.
+	if viper.GetString("account") == "" {
+		return nil, errors.New("account is required")
+	}
+	_, data.accountName, err = e2wallet.WalletAndAccountNames(viper.GetString("account"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain account name")
+	}
+	if data.accountName == "" {
+		return nil, errors.New("account name is required")
+	}
+
+	// Wallet.
+	ctx, cancel := context.WithTimeout(ctx, data.timeout)
+	defer cancel()
+	data.wallet, err = core.WalletFromInput(ctx)
+	cancel()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain wallet")
+	}
+
+	// Passphrase.
+	data.passphrase, err = util.GetOptionalPassphrase()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain passphrase")
+	}
+
+	// Wallet passphrase.
+	data.walletPassphrase = util.GetWalletPassphrase()
+
+	// Key.
+	if viper.GetString("key") == "" {
+		return nil, errors.New("key is required")
+	}
+	data.key, err = hex.DecodeString(strings.TrimPrefix(viper.GetString("key"), "0x"))
+	if err != nil {
+		return nil, errors.Wrap(err, "key is malformed")
+	}
+
+	return data, nil
+}

cmd/account/import/input_internal_test.go

@@ -0,0 +1,152 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Unknown/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain wallet: wallet not found",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "account is required",
+		},
+		{
+			name: "AccountWalletOnly",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"account":    "Test wallet/",
+			},
+			err: "account name is required",
+		},
+		{
+			name: "AccountMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "//",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain account name: invalid account format",
+		},
+		{
+			name: "MultiplePassphrases",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": []string{"ce%NohGhah4ye5ra", "other"},
+			},
+			err: "failed to obtain passphrase: multiple passphrases supplied",
+		},
+		{
+			name: "KeyMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "key is required",
+		},
+		{
+			name: "KeyMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"key":        "invalid",
+			},
+			err: "key is malformed: encoding/hex: invalid byte: U+0069 'i'",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Test account",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"key":        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			res: &dataIn{
+				timeout:     5 * time.Second,
+				accountName: "Test account",
+				passphrase:  "ce%NohGhah4ye5ra",
+				key:         hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.accountName, res.accountName)
+				require.Equal(t, test.res.passphrase, res.passphrase)
+			}
+		})
+	}
+}

cmd/account/import/output.go

@@ -0,0 +1,45 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataOut struct {
+	account e2wtypes.Account
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.account == nil {
+		return "", errors.New("no account")
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()), nil
+	}
+
+	if pubKeyProvider, ok := data.account.(e2wtypes.AccountPublicKeyProvider); ok {
+		return fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()), nil
+	}
+
+	return "", errors.New("no public key available")
+}

cmd/account/import/output_internal_test.go

@@ -0,0 +1,113 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func hexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func TestOutput(t *testing.T) {
+	testWallet, err := nd.CreateWallet(context.Background(), "Test", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	interop0, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	distributedWallet, err := distributed.CreateWallet(context.Background(), "Test distributed", scratch.New(), keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, distributedWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	distributed0, err := distributedWallet.(e2wtypes.WalletDistributedAccountImporter).ImportDistributedAccount(context.Background(),
+		"Distributed 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		2,
+		[][]byte{
+			hexToBytes("0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268"),
+			hexToBytes("0xaec922bd7a9b7b1dc21993133b586b0c3041c1e2e04b513e862227b9d7aecaf9444222f7e78282a449622ffc6278915d"),
+		},
+		map[uint64]string{
+			1: "localhost-1:12345",
+			2: "localhost-2:12345",
+			3: "localhost-3:12345",
+		},
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "AccountNil",
+			dataOut: &dataOut{},
+			err:     "no account",
+		},
+		{
+			name: "Account",
+			dataOut: &dataOut{
+				account: interop0,
+			},
+			res: "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+		},
+		{
+			name: "DistributedAccount",
+			dataOut: &dataOut{
+				account: distributed0,
+			},
+			res: "0x876dd4705157eb66dc71bc2e07fb151ea53e1a62a0bb980a7ce72d15f58944a8a3752d754f52f4a60dbfc7b18169f268",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/account/import/process.go

@@ -0,0 +1,51 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("passphrase is required")
+	}
+	if !util.AcceptablePassphrase(data.passphrase) {
+		return nil, errors.New("supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
+	}
+	locker, isLocker := data.wallet.(e2wtypes.WalletLocker)
+	if isLocker {
+		if err := locker.Unlock(ctx, []byte(data.walletPassphrase)); err != nil {
+			return nil, errors.Wrap(err, "failed to unlock wallet")
+		}
+		defer locker.Lock(ctx)
+	}
+
+	results := &dataOut{}
+
+	account, err := data.wallet.(e2wtypes.WalletAccountImporter).ImportAccount(ctx, data.accountName, data.key, []byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to import account")
+	}
+	results.account = account
+
+	return results, nil
+}

cmd/account/import/process_internal_test.go

@@ -0,0 +1,95 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	testNDWallet, err := nd.CreateWallet(context.Background(),
+		"Test",
+		scratch.New(),
+		keystorev4.New(),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "PassphraseMissing",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Good",
+				passphrase:       "",
+				walletPassphrase: "pass",
+				key:              hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+			err: "passphrase is required",
+		},
+		{
+			name: "PassphraseWeak",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Good",
+				passphrase:       "poor",
+				walletPassphrase: "pass",
+				key:              hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+			err: "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:          5 * time.Second,
+				wallet:           testNDWallet,
+				accountName:      "Good",
+				passphrase:       "ce%NohGhah4ye5ra",
+				walletPassphrase: "pass",
+				key:              hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.dataIn.accountName, res.account.Name())
+			}
+		})
+	}
+}

cmd/account/import/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountimport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the account import data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/account/key/input.go

@@ -0,0 +1,52 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	timeout     time.Duration
+	account     e2wtypes.Account
+	passphrases []string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+
+	// Account.
+	_, data.account, err = core.WalletAndAccountFromInput(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain acount")
+	}
+
+	// Passphrases.
+	data.passphrases = util.GetPassphrases()
+
+	return data, nil
+}

cmd/account/key/input_internal_test.go

@@ -0,0 +1,129 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":    "Test wallet/Interop 0",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Unknown/Interop 0",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain acount: faild to open wallet for account: wallet not found",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain acount: faild to open wallet for account: invalid account format",
+		},
+		{
+			name: "AccountWalletOnly",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"passphrase": "ce%NohGhah4ye5ra",
+				"account":    "Test wallet/",
+			},
+			err: "failed to obtain acount: no account name",
+		},
+		{
+			name: "AccountMalformed",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "//",
+				"passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain acount: faild to open wallet for account: invalid account format",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"account":    "Test wallet/Interop 0",
+				"passphrase": []string{"ce%NohGhah4ye5ra", "pass"},
+				"key":        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			res: &dataIn{
+				timeout:     5 * time.Second,
+				passphrases: []string{"ce%NohGhah4ye5ra", "pass"},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				// Cannot compare accounts directly, so need to check each element individually.
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.res.passphrases, res.passphrases)
+			}
+		})
+	}
+}

cmd/account/key/output.go

@@ -0,0 +1,36 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	key []byte
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if len(data.key) == 0 {
+		return "", errors.New("no account")
+	}
+
+	return fmt.Sprintf("%#x", data.key), nil
+}

cmd/account/key/output_internal_test.go

@@ -0,0 +1,69 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func hexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "AccountNil",
+			dataOut: &dataOut{},
+			err:     "no account",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				key: hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			},
+			res: "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/account/key/process.go

@@ -0,0 +1,65 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if len(data.passphrases) == 0 {
+		return nil, errors.New("passphrase is required")
+	}
+
+	results := &dataOut{}
+
+	privateKeyProvider, isPrivateKeyProvider := data.account.(e2wtypes.AccountPrivateKeyProvider)
+	if !isPrivateKeyProvider {
+		return nil, errors.New("account does not provide its private key")
+	}
+
+	if locker, isLocker := data.account.(e2wtypes.AccountLocker); isLocker {
+		unlocked, err := locker.IsUnlocked(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to find out if account is locked")
+		}
+		if !unlocked {
+			for _, passphrase := range data.passphrases {
+				err = locker.Unlock(ctx, []byte(passphrase))
+				if err == nil {
+					unlocked = true
+					break
+				}
+			}
+			if !unlocked {
+				return nil, errors.New("failed to unlock account")
+			}
+			// Because we unlocked the accout we should re-lock it when we're done.
+			defer locker.Lock(ctx)
+		}
+	}
+	key, err := privateKeyProvider.PrivateKey(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain private key")
+	}
+	results.key = key.Marshal()
+
+	return results, nil
+}

cmd/account/key/process_internal_test.go

@@ -0,0 +1,87 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	testNDWallet, err := nd.CreateWallet(context.Background(),
+		"Test",
+		scratch.New(),
+		keystorev4.New(),
+	)
+	require.NoError(t, err)
+	require.NoError(t, testNDWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	interop0, err := testNDWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		hexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "PassphrasesMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				account: interop0,
+			},
+			err: "passphrase is required",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:     5 * time.Second,
+				account:     interop0,
+				passphrases: []string{"ce%NohGhah4ye5ra", "pass"},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, res)
+				require.NotNil(t, res.key)
+			}
+		})
+	}
+}

cmd/account/key/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package accountkey
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the account import data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/accountcreate.go

@@ -14,16 +14,11 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
-	"regexp"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/ethdo/util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	accountcreate "github.com/wealdtech/ethdo/cmd/account/create"
 )
 
 var accountCreateCmd = &cobra.Command{
@@ -34,77 +29,26 @@ var accountCreateCmd = &cobra.Command{
     ethdo account create --account="primary/operations" --passphrase="my secret"
 
 In quiet mode this will return 0 if the account is created successfully, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := walletFromInput(ctx)
-		errCheck(err, "Failed to access wallet")
-		outputIf(debug, fmt.Sprintf("Opened wallet %q of type %s", wallet.Name(), wallet.Type()))
-		if wallet.Type() == "hierarchical deterministic" {
-			assert(getWalletPassphrase() != "", "walletpassphrase is required to create new accounts with hierarchical deterministic wallets")
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountcreate.Run(cmd)
+		if err != nil {
+			return err
 		}
-		locker, isLocker := wallet.(e2wtypes.WalletLocker)
-		if isLocker {
-			errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
+		if viper.GetBool("quiet") {
+			return nil
 		}
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		var account e2wtypes.Account
-		if viper.GetUint("participants") > 0 {
-			// Want a distributed account.
-			distributedCreator, isDistributedCreator := wallet.(e2wtypes.WalletDistributedAccountCreator)
-			assert(isDistributedCreator, "Wallet does not support distributed account creation")
-			outputIf(debug, fmt.Sprintf("Distributed account has %d/%d threshold", viper.GetUint32("signing-threshold"), viper.GetUint32("participants")))
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			if getOptionalPassphrase() != "" {
-				assert(util.AcceptablePassphrase(getPassphrase()), "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
-			}
-			account, err = distributedCreator.CreateDistributedAccount(ctx, accountName, viper.GetUint32("participants"), viper.GetUint32("signing-threshold"), []byte(getOptionalPassphrase()))
-		} else {
-			assert(util.AcceptablePassphrase(getPassphrase()), "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
-			if viper.GetString("path") != "" {
-				// Want a pathed account
-				creator, isCreator := wallet.(e2wtypes.WalletPathedAccountCreator)
-				assert(isCreator, "Wallet does not support account creation with an explicit path")
-				var match bool
-				match, err = regexp.Match("^m/[0-9]+/[0-9]+(/[0-9+])+", []byte(viper.GetString("path")))
-				errCheck(err, "Unable to match path to regular expression")
-				assert(match, "Path does not match expected format m/...")
-				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-				defer cancel()
-				account, err = creator.CreatePathedAccount(ctx, viper.GetString("path"), accountName, []byte(getPassphrase()))
-			} else {
-				// Want a standard account.
-				creator, isCreator := wallet.(e2wtypes.WalletAccountCreator)
-				assert(isCreator, "Wallet does not support account creation")
-				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-				defer cancel()
-				account, err = creator.CreateAccount(ctx, accountName, []byte(getPassphrase()))
-			}
+		if res != "" {
+			fmt.Println(res)
 		}
-		errCheck(err, "Failed to create account")
-
-		if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
-			outputIf(verbose, fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()))
-		} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
-			outputIf(verbose, fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()))
-		}
-
-		os.Exit(_exitSuccess)
+		return nil
 	},
 }
 
 func init() {
 	accountCmd.AddCommand(accountCreateCmd)
 	accountFlags(accountCreateCmd)
-	accountCreateCmd.Flags().Uint32("participants", 0, "Number of participants (for distributed accounts)")
-	accountCreateCmd.Flags().Uint32("signing-threshold", 0, "Signing threshold (for distributed accounts)")
+	accountCreateCmd.Flags().Uint32("participants", 1, "Number of participants (1 for non-distributed accounts, >1 for distributed accounts)")
+	accountCreateCmd.Flags().Uint32("signing-threshold", 1, "Signing threshold (1 for non-distributed accounts)")
 	accountCreateCmd.Flags().String("path", "", "path of account (for hierarchical deterministic accounts)")
 }
 

cmd/accountimport.go

@@ -14,20 +14,13 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/ethdo/util"
-	"github.com/wealdtech/go-bytesutil"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	accountimport "github.com/wealdtech/ethdo/cmd/account/import"
 )
 
-var accountImportKey string
-
 var accountImportCmd = &cobra.Command{
 	Use:   "import",
 	Short: "Import an account",
@@ -36,49 +29,29 @@ var accountImportCmd = &cobra.Command{
     ethdo account import --account="primary/testing" --key="0x..." --passphrase="my secret"
 
 In quiet mode this will return 0 if the account is imported successfully, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "account import not available with remote wallets")
-		assert(viper.GetString("account") != "", "--account is required")
-		assert(accountImportKey != "", "--key is required")
-		assert(util.AcceptablePassphrase(getPassphrase()), "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
-
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		key, err := bytesutil.FromHexString(accountImportKey)
-		errCheck(err, "Invalid key")
-
-		w, err := walletFromPath(ctx, viper.GetString("account"))
-		errCheck(err, "Failed to access wallet")
-
-		_, ok := w.(e2wtypes.WalletAccountImporter)
-		assert(ok, fmt.Sprintf("wallets of type %q do not allow importing accounts", w.Type()))
-
-		_, _, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
-		assert(err != nil, "Account already exists")
-
-		locker, isLocker := w.(e2wtypes.WalletLocker)
-		if isLocker {
-			errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountimport.Run(cmd)
+		if err != nil {
+			return err
 		}
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		account, err := w.(e2wtypes.WalletAccountImporter).ImportAccount(ctx, accountName, key, []byte(getPassphrase()))
-		errCheck(err, "Failed to create account")
-
-		pubKey, err := bestPublicKey(account)
-		if err == nil {
-			outputIf(verbose, fmt.Sprintf("%#x", pubKey.Marshal()))
+		if viper.GetBool("quiet") {
+			return nil
 		}
-
-		os.Exit(_exitSuccess)
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
 func init() {
 	accountCmd.AddCommand(accountImportCmd)
 	accountFlags(accountImportCmd)
-	accountImportCmd.Flags().StringVar(&accountImportKey, "key", "", "Private key of the account to import (0x...)")
+	accountImportCmd.Flags().String("key", "", "Private key of the account to import (0x...)")
+}
+
+func accountImportBindings() {
+	if err := viper.BindPFlag("key", accountImportCmd.Flags().Lookup("key")); err != nil {
+		panic(err)
+	}
 }

cmd/accountkey.go

@@ -14,13 +14,11 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	accountkey "github.com/wealdtech/ethdo/cmd/account/key"
 )
 
 // accountKeyCmd represents the account key command
@@ -32,39 +30,18 @@ var accountKeyCmd = &cobra.Command{
     ethdo account key --account="Personal wallet/Operations" --passphrase="my account passphrase"
 
 In quiet mode this will return 0 if the key can be obtained, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(!remote, "account keys not available with remote wallets")
-		assert(viper.GetString("account") != "", "--account is required")
-
-		_, account, err := walletAndAccountFromInput(ctx)
-		errCheck(err, "Failed to obtain account")
-
-		privateKeyProvider, isPrivateKeyProvider := account.(e2wtypes.AccountPrivateKeyProvider)
-		assert(isPrivateKeyProvider, fmt.Sprintf("account %q does not provide its private key", viper.GetString("account")))
-
-		if locker, isLocker := account.(e2wtypes.AccountLocker); isLocker {
-			unlocked, err := locker.IsUnlocked(ctx)
-			errCheck(err, "Failed to find out if account is locked")
-			if !unlocked {
-				for _, passphrase := range getPassphrases() {
-					err = locker.Unlock(ctx, []byte(passphrase))
-					if err == nil {
-						unlocked = true
-						break
-					}
-				}
-			}
-			assert(unlocked, "Failed to unlock account to obtain private key")
-			defer relockAccount(locker)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountkey.Run(cmd)
+		if err != nil {
+			return err
 		}
-		privateKey, err := privateKeyProvider.PrivateKey(ctx)
-		errCheck(err, "Failed to obtain private key")
-
-		outputIf(!quiet, fmt.Sprintf("%#x", privateKey.Marshal()))
-		os.Exit(_exitSuccess)
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 

cmd/depositverify.go

@@ -146,7 +146,7 @@ func validatorPubKeysFromInput(input string) (map[[48]byte]bool, error) {
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to find public key file")
 		}
-		lines := bytes.Split(bytes.Replace(data, []byte("\r\n"), []byte("\n"), -1), []byte("\n"))
+		lines := bytes.Split(bytes.ReplaceAll(data, []byte("\r\n"), []byte("\n")), []byte("\n"))
 		if len(lines) == 0 {
 			return nil, errors.New("file has no public keys")
 		}

cmd/exitverify.go

@@ -94,7 +94,7 @@ func obtainExitData(input string) (*validatorExitData, error) {
 		}
 	}
 	exitData := &validatorExitData{}
-	err = json.Unmarshal([]byte(data), exitData)
+	err = json.Unmarshal(data, exitData)
 	if err != nil {
 		return nil, errors.Wrap(err, "data is not valid JSON")
 	}

cmd/networks.go

@@ -41,7 +41,6 @@ func network() string {
 	depositContract := fmt.Sprintf("%x", depositContractAddress)
 	if network, exists := networks[depositContract]; exists {
 		return network
-	} else {
-		return "Unknown"
 	}
+	return "Unknown"
 }

cmd/passphrases.go

@@ -31,21 +31,3 @@ func getWalletPassphrase() string {
 func getPassphrases() []string {
 	return viper.GetStringSlice("passphrase")
 }
-
-// getPassphrase fetches the passphrase supplied by the user.
-func getPassphrase() string {
-	passphrases := getPassphrases()
-	assert(len(passphrases) != 0, "passphrase is required")
-	assert(len(passphrases) == 1, "multiple passphrases supplied; cannot continue")
-	return passphrases[0]
-}
-
-// getOptionalPassphrase fetches the passphrase if supplied by the user.
-func getOptionalPassphrase() string {
-	passphrases := getPassphrases()
-	if len(passphrases) == 0 {
-		return ""
-	}
-	assert(len(passphrases) == 1, "multiple passphrases supplied; cannot continue")
-	return passphrases[0]
-}

cmd/root.go

@@ -17,8 +17,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"regexp"
-	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -47,9 +45,6 @@ var rootStore string
 // Store for wallet actions.
 var store e2wtypes.Store
 
-// Remote connection.
-var remote bool
-
 // Prysm connection.
 var eth2GRPCConn *grpc.ClientConn
 
@@ -81,6 +76,8 @@ func persistentPreRun(cmd *cobra.Command, args []string) {
 	switch fmt.Sprintf("%s/%s", cmd.Parent().Name(), cmd.Name()) {
 	case "account/create":
 		accountCreateBindings()
+	case "account/import":
+		accountImportBindings()
 	case "attester/inclusion":
 		attesterInclusionBindings()
 	case "exit/verify":
@@ -89,6 +86,8 @@ func persistentPreRun(cmd *cobra.Command, args []string) {
 		validatorDepositdataBindings()
 	case "wallet/create":
 		walletCreateBindings()
+	case "wallet/import":
+		walletImportBindings()
 	}
 
 	if quiet && verbose {
@@ -119,9 +118,8 @@ func persistentPreRun(cmd *cobra.Command, args []string) {
 			die(fmt.Sprintf("Unsupported wallet store %s", rootStore))
 		}
 		err := e2wallet.UseStore(store)
+		viper.Set("store", store)
 		errCheck(err, "Failed to use defined wallet store")
-	} else {
-		remote = true
 	}
 }
 
@@ -333,39 +331,6 @@ func walletAndAccountFromPath(ctx context.Context, path string) (e2wtypes.Wallet
 	return wallet, account, nil
 }
 
-// walletAndAccountsFromPath obtains the wallet and matching accounts given a path specification.
-func walletAndAccountsFromPath(ctx context.Context, path string) (e2wtypes.Wallet, []e2wtypes.Account, error) {
-	wallet, err := walletFromPath(ctx, path)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "faild to open wallet for account")
-	}
-
-	_, accountSpec, err := e2wallet.WalletAndAccountNames(path)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "failed to obtain account specification")
-	}
-	if accountSpec == "" {
-		accountSpec = "^.*$"
-	} else {
-		accountSpec = fmt.Sprintf("^%s$", accountSpec)
-	}
-	re := regexp.MustCompile(accountSpec)
-
-	accounts := make([]e2wtypes.Account, 0)
-	for account := range wallet.Accounts(ctx) {
-		if re.Match([]byte(account.Name())) {
-			accounts = append(accounts, account)
-		}
-	}
-
-	// Tidy up accounts by name.
-	sort.Slice(accounts, func(i, j int) bool {
-		return accounts[i].Name() < accounts[j].Name()
-	})
-
-	return wallet, accounts, nil
-}
-
 // connect connects to an Ethereum 2 endpoint.
 func connect() error {
 	if eth2GRPCConn != nil {

cmd/signing.go

@@ -22,11 +22,10 @@ import (
 	"github.com/spf13/viper"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
-	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 // signStruct signs an arbitrary structure.
-func signStruct(account wtypes.Account, data interface{}, domain []byte) (e2types.Signature, error) {
+func signStruct(account e2wtypes.Account, data interface{}, domain []byte) (e2types.Signature, error) {
 	objRoot, err := ssz.HashTreeRoot(data)
 	outputIf(debug, fmt.Sprintf("Object root is %#x", objRoot))
 	if err != nil {
@@ -37,7 +36,7 @@ func signStruct(account wtypes.Account, data interface{}, domain []byte) (e2type
 }
 
 // verifyStruct verifies the signature of an arbitrary structure.
-func verifyStruct(account wtypes.Account, data interface{}, domain []byte, signature e2types.Signature) (bool, error) {
+func verifyStruct(account e2wtypes.Account, data interface{}, domain []byte, signature e2types.Signature) (bool, error) {
 	objRoot, err := ssz.HashTreeRoot(data)
 	outputIf(debug, fmt.Sprintf("Object root is %#x", objRoot))
 	if err != nil {
@@ -55,7 +54,7 @@ type signingContainer struct {
 }
 
 // signRoot signs a root.
-func signRoot(account wtypes.Account, root [32]byte, domain []byte) (e2types.Signature, error) {
+func signRoot(account e2wtypes.Account, root [32]byte, domain []byte) (e2types.Signature, error) {
 	if _, isProtectingSigner := account.(e2wtypes.AccountProtectingSigner); isProtectingSigner {
 		// Signer signs the data to sign itself.
 		return signGeneric(account, root[:], domain)
@@ -75,7 +74,7 @@ func signRoot(account wtypes.Account, root [32]byte, domain []byte) (e2types.Sig
 	return sign(account, signingRoot[:])
 }
 
-func verifyRoot(account wtypes.Account, root [32]byte, domain []byte, signature e2types.Signature) (bool, error) {
+func verifyRoot(account e2wtypes.Account, root [32]byte, domain []byte, signature e2types.Signature) (bool, error) {
 	// Build the signing data manually.
 	container := &signingContainer{
 		Root:   root[:],
@@ -90,7 +89,7 @@ func verifyRoot(account wtypes.Account, root [32]byte, domain []byte, signature
 	return verify(account, signingRoot[:], signature)
 }
 
-func signGeneric(account wtypes.Account, data []byte, domain []byte) (e2types.Signature, error) {
+func signGeneric(account e2wtypes.Account, data []byte, domain []byte) (e2types.Signature, error) {
 	alreadyUnlocked, err := unlock(account)
 	if err != nil {
 		return nil, err
@@ -115,7 +114,7 @@ func signGeneric(account wtypes.Account, data []byte, domain []byte) (e2types.Si
 }
 
 // sign signs arbitrary data, handling unlocking and locking as required.
-func sign(account wtypes.Account, data []byte) (e2types.Signature, error) {
+func sign(account e2wtypes.Account, data []byte) (e2types.Signature, error) {
 	alreadyUnlocked, err := unlock(account)
 	if err != nil {
 		return nil, err
@@ -140,7 +139,7 @@ func sign(account wtypes.Account, data []byte) (e2types.Signature, error) {
 }
 
 // verify the signature of arbitrary data.
-func verify(account wtypes.Account, data []byte, signature e2types.Signature) (bool, error) {
+func verify(account e2wtypes.Account, data []byte, signature e2types.Signature) (bool, error) {
 	pubKey, err := bestPublicKey(account)
 	if err != nil {
 		return false, errors.Wrap(err, "failed to obtain account public key")

cmd/wallet/create/input.go

@@ -0,0 +1,89 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// For all wallets.
+	store      e2wtypes.Store
+	walletType string
+	walletName string
+	// For HD wallets.
+	passphrase string
+	mnemonic   string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	store, isStore := viper.Get("store").(e2wtypes.Store)
+	if !isStore {
+		return nil, errors.New("store is required")
+	}
+	data.store = store
+
+	// Wallet name.
+	if viper.GetString("wallet") == "" {
+		return nil, errors.New("wallet is required")
+	}
+	data.walletName, _, err = e2wallet.WalletAndAccountNames(viper.GetString("wallet"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain wallet name")
+	}
+	if data.walletName == "" {
+		return nil, errors.New("wallet name is required")
+	}
+
+	// Type.
+	data.walletType = strings.ToLower(viper.GetString("type"))
+	if data.walletType == "" {
+		return nil, errors.New("wallet type is required")
+	}
+
+	// Passphrase.
+	data.passphrase = util.GetWalletPassphrase()
+	if data.passphrase == "" {
+		return nil, errors.New("wallet passphrase is required")
+	}
+
+	// Mnemonic.
+	data.mnemonic = viper.GetString("mnemonic")
+
+	return data, nil
+}

cmd/wallet/create/input_internal_test.go

@@ -0,0 +1,134 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"account":           "Test wallet",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+				"type":              "nd",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "StoreMissing",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"wallet":            "Test wallet",
+				"type":              "nd",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "store is required",
+		},
+		{
+			name: "WalletMissing",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"store":             store,
+				"type":              "nd",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "wallet is required",
+		},
+		{
+			name: "WalletInvalid",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"store":             store,
+				"wallet":            "/",
+				"type":              "nd",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "failed to obtain wallet name: invalid account format",
+		},
+		{
+			name: "TypeMissing",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"store":             store,
+				"wallet":            "Test wallet",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+			},
+			err: "wallet type is required",
+		},
+		{
+			name: "WalletPassphraseMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"store":   store,
+				"wallet":  "Test wallet",
+				"type":    "nd",
+			},
+			err: "wallet passphrase is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":           "5s",
+				"store":             store,
+				"wallet":            "Test wallet",
+				"type":              "nd",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+			},
+			res: &dataIn{
+				timeout:    5 * time.Second,
+				store:      store,
+				walletName: "Test account",
+				walletType: "nd",
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+			}
+		})
+	}
+}

cmd/wallet/create/output.go

@@ -0,0 +1,43 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	mnemonic string
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.mnemonic != "" {
+		return fmt.Sprintf(`The following phrase is your mnemonic for this wallet:
+
+%s
+
+Anyone with access to this mnemonic can recreate the accounts in this wallet, so please store this mnemonic safely.  More information about mnemonics can be found at https://support.mycrypto.com/general-knowledge/cryptography/how-do-mnemonic-phrases-work
+
+Please note this mnemonic is not stored within the wallet, so cannot be retrieved or displayed again.  As such, this mnemonic should be stored securely, ideally offline, before proceeding.
+`, data.mnemonic), nil
+	}
+
+	return "", nil
+}

cmd/wallet/create/output_internal_test.go

@@ -0,0 +1,62 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     bool
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Good",
+			dataOut: &dataOut{},
+		},
+		{
+			name: "GoodMnemonic",
+			dataOut: &dataOut{
+				mnemonic: "test mnemonic",
+			},
+			res: true,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				if test.res {
+					require.NotEqual(t, "", res)
+				} else {
+					require.Equal(t, "", res)
+				}
+			}
+		})
+	}
+}

cmd/wallet/create/process.go

@@ -0,0 +1,134 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+	"crypto/rand"
+	"strings"
+
+	"github.com/pkg/errors"
+	bip39 "github.com/tyler-smith/go-bip39"
+	"github.com/wealdtech/ethdo/util"
+	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	hd "github.com/wealdtech/go-eth2-wallet-hd/v2"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	"golang.org/x/text/unicode/norm"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	switch data.walletType {
+	case "nd", "non-deterministic":
+		return processND(ctx, data)
+	case "hd", "hierarchical deterministic":
+		return processHD(ctx, data)
+	case "distributed":
+		return processDistributed(ctx, data)
+	default:
+		return nil, errors.New("wallet type not supported")
+	}
+}
+
+func processND(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	results := &dataOut{}
+
+	if _, err := nd.CreateWallet(ctx, data.walletName, data.store, keystorev4.New()); err != nil {
+		return nil, err
+	}
+	return results, nil
+}
+
+func processHD(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.passphrase == "" {
+		return nil, errors.New("wallet passphrase is required for hierarchical deterministic wallets")
+	}
+	if !util.AcceptablePassphrase(data.passphrase) {
+		return nil, errors.New("supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
+	}
+	if data.quiet {
+		return nil, errors.New("creation of hierarchical deterministic wallets prints its mnemonic, so cannot be run with the --quiet flag")
+	}
+
+	results := &dataOut{}
+
+	// Only show the mnemonic on output if we generate it.
+	printMnemonic := data.mnemonic == ""
+	mnemonicPassphrase := ""
+
+	if data.mnemonic == "" {
+		// Create a new random mnemonic.
+		entropy := make([]byte, 32)
+		_, err := rand.Read(entropy)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to generate entropy for wallet mnemonic")
+		}
+		data.mnemonic, err = bip39.NewMnemonic(entropy)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to generate wallet mnemonic")
+		}
+	} else {
+		// We have an existing mnemonic.  If there are more than 24 words we treat the additional characters as the passphrase.
+		mnemonicParts := strings.Split(data.mnemonic, " ")
+		if len(mnemonicParts) > 24 {
+			data.mnemonic = strings.Join(mnemonicParts[:24], " ")
+			mnemonicPassphrase = strings.Join(mnemonicParts[24:], " ")
+		}
+	}
+	// Normalise the input.
+	data.mnemonic = string(norm.NFKD.Bytes([]byte(data.mnemonic)))
+	mnemonicPassphrase = string(norm.NFKD.Bytes([]byte(mnemonicPassphrase)))
+
+	// Ensure the mnemonic is valid
+	if !bip39.IsMnemonicValid(data.mnemonic) {
+		return nil, errors.New("mnemonic is not valid")
+	}
+
+	// Create seed from mnemonic and passphrase.
+	seed := bip39.NewSeed(data.mnemonic, mnemonicPassphrase)
+
+	if _, err := hd.CreateWallet(ctx, data.walletName, []byte(data.passphrase), data.store, keystorev4.New(), seed); err != nil {
+		return nil, err
+	}
+	if printMnemonic {
+		results.mnemonic = data.mnemonic
+	}
+
+	return results, nil
+}
+
+func processDistributed(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	results := &dataOut{}
+
+	if _, err := distributed.CreateWallet(ctx, data.walletName, data.store, keystorev4.New()); err != nil {
+		return nil, err
+	}
+
+	return results, nil
+}

cmd/wallet/create/process_internal_test.go

@@ -0,0 +1,152 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "TypeUnknown",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "unknown",
+				walletName: "Test wallet",
+			},
+			err: "wallet type not supported",
+		},
+		{
+			name: "NDGood",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "nd",
+				walletName: "Test wallet",
+			},
+		},
+		{
+			name: "HDPassphraseMissing",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "hd",
+				walletName: "Test wallet",
+			},
+			err: "wallet passphrase is required for hierarchical deterministic wallets",
+		},
+		{
+			name: "HDPassphraseWeak",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "hd",
+				walletName: "Test wallet",
+				passphrase: "weak",
+			},
+			err: "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag",
+		},
+		{
+			name: "HDQuiet",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				quiet:      true,
+				store:      scratch.New(),
+				walletType: "hd",
+				walletName: "Test wallet",
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+			err: "creation of hierarchical deterministic wallets prints its mnemonic, so cannot be run with the --quiet flag",
+		},
+		{
+			name: "HDMnemonic",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "hd",
+				walletName: "Test wallet",
+				passphrase: "ce%NohGhah4ye5ra",
+				mnemonic:   "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
+			},
+		},
+		{
+			name: "HDMnemonicExtra",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "hd",
+				walletName: "Test wallet",
+				passphrase: "ce%NohGhah4ye5ra",
+				mnemonic:   "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art extra",
+			},
+		},
+		{
+			name: "HDGood",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "hd",
+				walletName: "Test wallet",
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+		},
+		{
+			name: "DistributedGood",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				store:      scratch.New(),
+				walletType: "distributed",
+				walletName: "Test wallet",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+func TestNilData(t *testing.T) {
+	_, err := processND(context.Background(), nil)
+	require.EqualError(t, err, "no data")
+	_, err = processHD(context.Background(), nil)
+	require.EqualError(t, err, "no data")
+	_, err = processDistributed(context.Background(), nil)
+	require.EqualError(t, err, "no data")
+}

cmd/wallet/create/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletcreate
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/wallet/delete/input.go

@@ -0,0 +1,59 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	wallet  e2wtypes.Wallet
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetString("remote") != "" {
+		return nil, errors.New("wallet delete not available for remote wallets")
+	}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	// Wallet.
+	wallet, err := core.WalletFromInput(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to access wallet")
+	}
+	data.wallet = wallet
+
+	return data, nil
+}

cmd/wallet/delete/input_internal_test.go

@@ -0,0 +1,103 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"wallet": "Test wallet",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "failed to access wallet: cannot determine wallet",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "unknown",
+			},
+			err: "failed to access wallet: wallet not found",
+		},
+		{
+			name: "Remote",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"remote":  "remoteaddress",
+			},
+			err: "wallet delete not available for remote wallets",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "Test wallet",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				wallet:  wallet,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.vars["wallet"], res.wallet.Name())
+			}
+		})
+	}
+}

cmd/wallet/delete/output.go

@@ -0,0 +1,29 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+)
+
+type dataOut struct{}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	return "", nil
+}

cmd/wallet/delete/output_internal_test.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Good",
+			dataOut: &dataOut{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, "", res)
+			}
+		})
+	}
+}

cmd/wallet/delete/process.go

@@ -0,0 +1,48 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+
+	"github.com/pkg/errors"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.wallet == nil {
+		return nil, errors.New("wallet is required")
+	}
+
+	storeProvider, isProvider := data.wallet.(e2wtypes.StoreProvider)
+	if !isProvider {
+		return nil, errors.New("cannot obtain store for the wallet")
+	}
+	store := storeProvider.Store()
+	storeLocationProvider, isProvider := store.(e2wtypes.StoreLocationProvider)
+	if !isProvider {
+		return nil, errors.New("cannot obtain store location for the wallet")
+	}
+	walletLocation := filepath.Join(storeLocationProvider.Location(), data.wallet.ID().String())
+	if err := os.RemoveAll(walletLocation); err != nil {
+		return nil, errors.Wrap(err, "failed to delete wallet")
+	}
+
+	return &dataOut{}, nil
+}

cmd/wallet/delete/process_internal_test.go

@@ -0,0 +1,77 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	filesystem "github.com/wealdtech/go-eth2-wallet-store-filesystem"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	base, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(base)
+	store := filesystem.New(filesystem.WithLocation(base))
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "WalletMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+			},
+			err: "wallet is required",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				wallet:  wallet,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/wallet/delete/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletdelete
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/wallet/export/input.go

@@ -0,0 +1,67 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	// System.
+	timeout    time.Duration
+	quiet      bool
+	verbose    bool
+	debug      bool
+	wallet     e2wtypes.Wallet
+	passphrase string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetString("remote") != "" {
+		return nil, errors.New("wallet export not available for remote wallets")
+	}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	// Wallet.
+	wallet, err := core.WalletFromInput(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to access wallet")
+	}
+	data.wallet = wallet
+
+	// Passphrase.
+	data.passphrase, err = util.GetPassphrase()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain export passphrase")
+	}
+
+	return data, nil
+}

cmd/wallet/export/input_internal_test.go

@@ -0,0 +1,112 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"wallet": "Test wallet",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "WalletMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "failed to access wallet: cannot determine wallet",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "unknown",
+			},
+			err: "failed to access wallet: wallet not found",
+		},
+		{
+			name: "Remote",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"remote":  "remoteaddress",
+			},
+			err: "wallet export not available for remote wallets",
+		},
+		{
+			name: "PassphraseMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "Test wallet",
+			},
+			err: "failed to obtain export passphrase: passphrase is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"wallet":     "Test wallet",
+				"passphrase": "export",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				wallet:  wallet,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.vars["wallet"], res.wallet.Name())
+			}
+		})
+	}
+}

cmd/wallet/export/output.go

@@ -0,0 +1,33 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	export []byte
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	return fmt.Sprintf("%#x", data.export), nil
+}

cmd/wallet/export/output_internal_test.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Good",
+			dataOut: &dataOut{},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, "", res)
+			}
+		})
+	}
+}

cmd/wallet/export/process.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.wallet == nil {
+		return nil, errors.New("wallet is required")
+	}
+	if !util.AcceptablePassphrase(data.passphrase) {
+		return nil, errors.New("supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
+	}
+
+	exporter, isExporter := data.wallet.(e2wtypes.WalletExporter)
+	if !isExporter {
+		return nil, errors.New("wallet does not provide export")
+	}
+
+	export, err := exporter.Export(ctx, []byte(data.passphrase))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to export wallet")
+	}
+
+	results := &dataOut{
+		export: export,
+	}
+
+	return results, nil
+}

cmd/wallet/export/process_internal_test.go

@@ -0,0 +1,88 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	filesystem "github.com/wealdtech/go-eth2-wallet-store-filesystem"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	base, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(base)
+	store := filesystem.New(filesystem.WithLocation(base))
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "WalletMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+			},
+			err: "wallet is required",
+		},
+		{
+			name: "PassphraseWeak",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				wallet:     wallet,
+				passphrase: "weak",
+			},
+			err: "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				wallet:     wallet,
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, res.export)
+			}
+		})
+	}
+}

cmd/wallet/export/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletexport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/wallet/import/input.go

@@ -0,0 +1,82 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+	"encoding/hex"
+	"io/ioutil"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type dataIn struct {
+	// System.
+	timeout    time.Duration
+	quiet      bool
+	verbose    bool
+	debug      bool
+	data       []byte
+	passphrase string
+	verify     bool
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetString("remote") != "" {
+		return nil, errors.New("wallet import not available for remote wallets")
+	}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	// Data.
+	if viper.GetString("data") == "" {
+		return nil, errors.New("data is required")
+	}
+	if !strings.HasPrefix(viper.GetString("data"), "0x") {
+		// Assume this is a path; read the file and replace the path with its contents.
+		fileData, err := ioutil.ReadFile(viper.GetString("data"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to read wallet import data")
+		}
+		viper.Set("data", strings.TrimSpace(string(fileData)))
+	}
+	data.data, err = hex.DecodeString(strings.TrimPrefix(viper.GetString("data"), "0x"))
+	if err != nil {
+		return nil, errors.Wrap(err, "data is invalid")
+	}
+
+	// Passphrase.
+	data.passphrase, err = util.GetPassphrase()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain import passphrase")
+	}
+
+	// Verify.
+	data.verify = viper.GetBool("verify")
+
+	return data, nil
+}

cmd/wallet/import/input_internal_test.go

@@ -0,0 +1,134 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+	"fmt"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	data, err := wallet.(e2wtypes.WalletExporter).Export(context.Background(), []byte("ce%NohGhah4ye5ra"))
+	require.NoError(t, err)
+	require.NoError(t, e2wallet.UseStore(scratch.New()))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"data": fmt.Sprintf("%#x", data),
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "DataMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "data is required",
+		},
+		{
+			name: "DataInvalid",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"data":    "0xinvalid",
+			},
+			err: "data is invalid: encoding/hex: invalid byte: U+0069 'i'",
+		},
+		{
+			name: "DataFileMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"data":    "missing",
+			},
+			err: "failed to read wallet import data: open missing: no such file or directory",
+		},
+		{
+			name: "Remote",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"remote":     "remoteaddress",
+				"data":       fmt.Sprintf("%#x", data),
+				"passphrase": "export",
+			},
+			err: "wallet import not available for remote wallets",
+		},
+		{
+			name: "PassphraseMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"data":    fmt.Sprintf("%#x", data),
+			},
+			err: "failed to obtain import passphrase: passphrase is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"data":       fmt.Sprintf("%#x", data),
+				"passphrase": "export",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+		{
+			name: "Verify",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"data":       fmt.Sprintf("%#x", data),
+				"passphrase": "export",
+				"verify":     true,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, res)
+			}
+		})
+	}
+}

cmd/wallet/import/output.go

@@ -0,0 +1,60 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/gofrs/uuid"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	verify  bool
+	quiet   bool
+	verbose bool
+	export  *export
+}
+
+type accountInfo struct {
+	Name string `json:"name"`
+}
+type walletInfo struct {
+	ID   uuid.UUID `json:"uuid"`
+	Name string    `json:"name"`
+	Type string    `json:"type"`
+}
+type export struct {
+	Wallet   *walletInfo    `json:"wallet"`
+	Accounts []*accountInfo `json:"accounts"`
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	res := ""
+	if data.verify {
+		res = fmt.Sprintf("Wallet name: %s\nWallet type: %s\nWallet UUID: %s\nWallet accounts: %d", data.export.Wallet.Name, data.export.Wallet.Type, data.export.Wallet.ID, len(data.export.Accounts))
+		if data.verbose && len(data.export.Accounts) > 0 {
+			for _, account := range data.export.Accounts {
+				res = fmt.Sprintf("%s\n  %s", res, account.Name)
+			}
+		}
+	}
+
+	return res, nil
+}

cmd/wallet/import/output_internal_test.go

@@ -0,0 +1,90 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+	"testing"
+
+	"github.com/gofrs/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	export := &export{
+		Wallet: &walletInfo{
+			ID: uuid.FromBytesOrNil([]byte{
+				0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+			}),
+			Name: "Test wallet",
+			Type: "non-deterministic",
+		},
+		Accounts: []*accountInfo{
+			{
+				Name: "Account 1",
+			},
+			{
+				Name: "Account 2",
+			},
+		},
+	}
+
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				export: export,
+			},
+			res: "",
+		},
+		{
+			name: "Verify",
+			dataOut: &dataOut{
+				verify: true,
+				export: export,
+			},
+			res: "Wallet name: Test wallet\nWallet type: non-deterministic\nWallet UUID: 00010203-0405-0607-0809-0a0b0c0d0e0f\nWallet accounts: 2",
+		},
+		{
+			name: "VerifyVerbose",
+			dataOut: &dataOut{
+				verify:  true,
+				verbose: true,
+				export:  export,
+			},
+			res: "Wallet name: Test wallet\nWallet type: non-deterministic\nWallet UUID: 00010203-0405-0607-0809-0a0b0c0d0e0f\nWallet accounts: 2\n  Account 1\n  Account 2",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/wallet/import/process.go

@@ -0,0 +1,51 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+	"encoding/json"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/go-ecodec"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.data == nil {
+		return nil, errors.New("import data is required")
+	}
+
+	ext := &export{}
+	if data.verify {
+		data, err := ecodec.Decrypt(data.data, []byte(data.passphrase))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to decrypt export")
+		}
+		if err := json.Unmarshal(data, ext); err != nil {
+			return nil, errors.Wrap(err, "failed to read export")
+		}
+	} else if _, err := e2wallet.ImportWallet(data.data, []byte(data.passphrase)); err != nil {
+		return nil, errors.Wrap(err, "failed to import wallet")
+	}
+
+	results := &dataOut{
+		export: ext,
+	}
+
+	return results, nil
+}

cmd/wallet/import/process_internal_test.go

@@ -0,0 +1,132 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	data, err := wallet.(e2wtypes.WalletExporter).Export(context.Background(), []byte("ce%NohGhah4ye5ra"))
+	require.NoError(t, err)
+	require.NoError(t, e2wallet.UseStore(scratch.New()))
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "DataMissing",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+			err: "import data is required",
+		},
+		{
+			name: "DataBad",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				data:       append([]byte{0x00}, data...),
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+			err: "failed to import wallet: unhandled version 0x00",
+		},
+		{
+			name: "PassphraseMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				data:    data,
+			},
+			err: "failed to import wallet: invalid key",
+		},
+		{
+			name: "PassphraseIncorrect",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				data:       data,
+				passphrase: "weak",
+			},
+			err: "failed to import wallet: invalid key",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				data:       data,
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+		},
+		{
+			name: "VerifyDataBad",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				verify:     true,
+				data:       append([]byte{0x00}, data...),
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+			err: "failed to decrypt export: unhandled version 0x00",
+		},
+		{
+			name: "VerifyPassphraseMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				verify:  true,
+				data:    data,
+			},
+			err: "failed to decrypt export: invalid key",
+		},
+		{
+			name: "Verify",
+			dataIn: &dataIn{
+				timeout:    5 * time.Second,
+				verify:     true,
+				data:       data,
+				passphrase: "ce%NohGhah4ye5ra",
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/wallet/import/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2019, 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package walletimport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if !viper.GetBool("verbose") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/walletcreate.go

@@ -14,22 +14,11 @@
 package cmd
 
 import (
-	"context"
-	"crypto/rand"
 	"fmt"
-	"os"
-	"strings"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	bip39 "github.com/tyler-smith/go-bip39"
-	"github.com/wealdtech/ethdo/util"
-	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
-	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
-	hd "github.com/wealdtech/go-eth2-wallet-hd/v2"
-	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
-	"golang.org/x/text/unicode/norm"
+	walletcreate "github.com/wealdtech/ethdo/cmd/wallet/create"
 )
 
 var walletCreateCmd = &cobra.Command{
@@ -40,103 +29,18 @@ var walletCreateCmd = &cobra.Command{
     ethdo wallet create --wallet="Primary wallet" --type=non-deterministic
 
 In quiet mode this will return 0 if the wallet is created successfully, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(viper.GetString("remote") == "", "wallet create not available with remote wallets")
-		assert(viper.GetString("wallet") != "", "--wallet is required")
-		assert(viper.GetString("type") != "", "--type is required")
-
-		var err error
-		switch strings.ToLower(viper.GetString("type")) {
-		case "non-deterministic", "nd":
-			assert(viper.GetString("mnemonic") == "", "--mnemonic is not allowed with non-deterministic wallets")
-			err = walletCreateND(ctx, viper.GetString("wallet"))
-		case "hierarchical deterministic", "hd":
-			if quiet {
-				fmt.Printf("Creation of hierarchical deterministic wallets prints its mnemonic, so cannot be run with the --quiet flag")
-				os.Exit(_exitFailure)
-			}
-			assert(getWalletPassphrase() != "", "--walletpassphrase is required for hierarchical deterministic wallets")
-			assert(util.AcceptablePassphrase(getWalletPassphrase()), "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
-			err = walletCreateHD(ctx, viper.GetString("wallet"), getWalletPassphrase(), viper.GetString("mnemonic"))
-		case "distributed":
-			assert(viper.GetString("mnemonic") == "", "--mnemonic is not allowed with distributed wallets")
-			err = walletCreateDistributed(ctx, viper.GetString("wallet"))
-		default:
-			die("unknown wallet type")
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletcreate.Run(cmd)
+		if err != nil {
+			return err
 		}
-		errCheck(err, "Failed to create wallet")
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
-// walletCreateND creates a non-deterministic wallet.
-func walletCreateND(ctx context.Context, name string) error {
-	_, err := nd.CreateWallet(ctx, name, store, keystorev4.New())
-	return err
-}
-
-// walletCreateDistributed creates a distributed wallet.
-func walletCreateDistributed(ctx context.Context, name string) error {
-	_, err := distributed.CreateWallet(ctx, name, store, keystorev4.New())
-	return err
-}
-
-// walletCreateHD creates a hierarchical-deterministic wallet.
-func walletCreateHD(ctx context.Context, name string, passphrase string, mnemonic string) error {
-	encryptor := keystorev4.New()
-
-	printMnemonic := mnemonic == ""
-	mnemonicPassphrase := ""
-
-	if mnemonic == "" {
-		// Create a new random mnemonic.
-		entropy := make([]byte, 32)
-		_, err := rand.Read(entropy)
-		if err != nil {
-			return errors.Wrap(err, "failed to generate entropy for wallet mnemonic")
-		}
-		mnemonic, err = bip39.NewMnemonic(entropy)
-		if err != nil {
-			return errors.Wrap(err, "failed to generate wallet mnemonic")
-		}
-	} else {
-		// We have an existing mnemonic.  If there are more than 24 words we treat the additional characters as the passphrase.
-		mnemonicParts := strings.Split(mnemonic, " ")
-		if len(mnemonicParts) > 24 {
-			mnemonic = strings.Join(mnemonicParts[:24], " ")
-			mnemonicPassphrase = strings.Join(mnemonicParts[24:], " ")
-		}
-	}
-	// Normalise the input.
-	mnemonic = string(norm.NFKD.Bytes([]byte(mnemonic)))
-	mnemonicPassphrase = string(norm.NFKD.Bytes([]byte(mnemonicPassphrase)))
-
-	// Ensure the mnemonic is valid
-	if !bip39.IsMnemonicValid(mnemonic) {
-		return errors.New("mnemonic is not valid")
-	}
-
-	// Create seed from mnemonic and passphrase.
-	seed := bip39.NewSeed(mnemonic, mnemonicPassphrase)
-
-	_, err := hd.CreateWallet(ctx, name, []byte(passphrase), store, encryptor, seed)
-
-	if printMnemonic {
-		fmt.Printf(`The following phrase is your mnemonic for this wallet:
-
-%s
-
-Anyone with access to this mnemonic can recreate the accounts in this wallet, so please store this mnemonic safely.  More information about mnemonics can be found at https://support.mycrypto.com/general-knowledge/cryptography/how-do-mnemonic-phrases-work
-
-Please note this mnemonic is not stored within the wallet, so cannot be retrieved or displayed again.  As such, this mnemonic should be written down or otherwise protected before proceeding.
-`, mnemonic)
-	}
-
-	return err
-}
-
 func init() {
 	walletCmd.AddCommand(walletCreateCmd)
 	walletFlags(walletCreateCmd)

cmd/walletdelete.go

@@ -14,13 +14,10 @@
 package cmd
 
 import (
-	"context"
-	"os"
-	"path/filepath"
+	"fmt"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	walletdelete "github.com/wealdtech/ethdo/cmd/wallet/delete"
 )
 
 var walletDeleteCmd = &cobra.Command{
@@ -31,26 +28,15 @@ var walletDeleteCmd = &cobra.Command{
     ethdo wallet delete --wallet=primary
 
 In quiet mode this will return 0 if the wallet has been deleted, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("remote") == "", "wallet delete not available with remote wallets")
-		assert(viper.GetString("wallet") != "", "--wallet is required")
-
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		wallet, err := walletFromPath(ctx, viper.GetString("wallet"))
-		errCheck(err, "Failed to access wallet")
-
-		storeProvider, ok := wallet.(wtypes.StoreProvider)
-		assert(ok, "Cannot obtain store for the wallet")
-		store := storeProvider.Store()
-		storeLocationProvider, ok := store.(wtypes.StoreLocationProvider)
-		assert(ok, "Cannot obtain store location for the wallet")
-		walletLocation := filepath.Join(storeLocationProvider.Location(), wallet.ID().String())
-		err = os.RemoveAll(walletLocation)
-		errCheck(err, "Failed to delete wallet")
-
-		os.Exit(_exitSuccess)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletdelete.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 

cmd/walletexport.go

@@ -14,51 +14,33 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-	"github.com/wealdtech/ethdo/util"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
+	walletexport "github.com/wealdtech/ethdo/cmd/wallet/export"
 )
 
-var walletExportPassphrase string
-
 var walletExportCmd = &cobra.Command{
 	Use:   "export",
 	Short: "Export a wallet",
 	Long: `Export a wallet for backup of transfer.  For example:
 
-    ethdo wallet export --wallet=primary --exportpassphrase="my export secret"
+    ethdo wallet export --wallet=primary --passphrase="my export secret"
 
 In quiet mode this will return 0 if the wallet is able to be exported, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(viper.GetString("remote") == "", "wallet export not available with remote wallets")
-		assert(viper.GetString("wallet") != "", "--wallet is required")
-		assert(walletExportPassphrase != "", "--exportpassphrase is required")
-		assert(util.AcceptablePassphrase(walletExportPassphrase), "supplied passphrase is weak; use a stronger one or run with the --allow-weak-passphrases flag")
-
-		wallet, err := walletFromPath(ctx, viper.GetString("wallet"))
-		errCheck(err, "Failed to access wallet")
-
-		_, ok := wallet.(types.WalletExporter)
-		assert(ok, fmt.Sprintf("wallets of type %q do not allow exporting accounts", wallet.Type()))
-
-		exportData, err := wallet.(types.WalletExporter).Export(ctx, []byte(walletExportPassphrase))
-		errCheck(err, "Failed to export wallet")
-
-		outputIf(!quiet, fmt.Sprintf("0x%x", exportData))
-		os.Exit(_exitSuccess)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletexport.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
 func init() {
 	walletCmd.AddCommand(walletExportCmd)
 	walletFlags(walletExportCmd)
-	walletExportCmd.Flags().StringVar(&walletExportPassphrase, "exportpassphrase", "", "Passphrase to protect the export")
 }

cmd/walletimport.go

@@ -14,24 +14,13 @@
 package cmd
 
 import (
-	"encoding/json"
 	"fmt"
-	"io/ioutil"
-	"os"
-	"strings"
 
-	"github.com/google/uuid"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/go-bytesutil"
-	"github.com/wealdtech/go-ecodec"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	walletimport "github.com/wealdtech/ethdo/cmd/wallet/import"
 )
 
-var walletImportData string
-var walletImportPassphrase string
-var walletImportVerify bool
-
 var walletImportCmd = &cobra.Command{
 	Use:   "import",
 	Short: "Import a wallet",
@@ -40,68 +29,30 @@ var walletImportCmd = &cobra.Command{
     ethdo wallet import --importdata=primary --importpassphrase="my export secret"
 
 In quiet mode this will return 0 if the wallet is imported successfully, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("remote") == "", "wallet import not available with remote wallets")
-		assert(walletImportData != "", "--importdata is required")
-		assert(walletImportPassphrase != "", "--importpassphrase is required")
-		assert(viper.GetString("wallet") == "", "--wallet is not allowed (the wallet will retain its name)")
-
-		if !strings.HasPrefix(walletImportData, "0x") {
-			outputIf(debug, fmt.Sprintf("Reading wallet import from file %s", walletImportData))
-			// Assume this is a path
-			fileData, err := ioutil.ReadFile(walletImportData)
-			errCheck(err, "Failed to read wallet import data")
-			walletImportData = strings.TrimSpace(string(fileData))
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletimport.Run(cmd)
+		if err != nil {
+			return err
 		}
-		outputIf(debug, fmt.Sprintf("Wallet import data is of length %d", len(walletImportData)))
-		importData, err := bytesutil.FromHexString(walletImportData)
-		errCheck(err, "Failed to decode wallet data")
-
-		if walletImportVerify {
-			type accountInfo struct {
-				Name string `json:"name"`
-			}
-			type walletInfo struct {
-				ID   uuid.UUID `json:"uuid"`
-				Name string    `json:"name"`
-				Type string    `json:"type"`
-			}
-			type export struct {
-				Wallet   *walletInfo    `json:"wallet"`
-				Accounts []*accountInfo `json:"accounts"`
-			}
-
-			data, err := ecodec.Decrypt(importData, []byte(walletImportPassphrase))
-			errCheck(err, "Failed to decrypt wallet")
-			ext := &export{}
-			err = json.Unmarshal(data, ext)
-			errCheck(err, "Failed to read wallet")
-
-			outputIf(!quiet, fmt.Sprintf("Wallet name: %s", ext.Wallet.Name))
-			outputIf(!quiet, fmt.Sprintf("Wallet type: %s", ext.Wallet.Type))
-			outputIf(verbose, fmt.Sprintf("Wallet UUID: %s", ext.Wallet.ID))
-			if verbose {
-				fmt.Printf("Wallet accounts:\n")
-				for _, account := range ext.Accounts {
-					outputIf(verbose, fmt.Sprintf("  %s", account.Name))
-				}
-			} else {
-				outputIf(!quiet, fmt.Sprintf("Wallet accounts: %d", len(ext.Accounts)))
-			}
-
-		} else {
-			_, err = e2wallet.ImportWallet(importData, []byte(walletImportPassphrase))
-			errCheck(err, "Failed to import wallet")
+		if res != "" {
+			fmt.Println(res)
 		}
-
-		os.Exit(_exitSuccess)
+		return nil
 	},
 }
 
 func init() {
 	walletCmd.AddCommand(walletImportCmd)
 	walletFlags(walletImportCmd)
-	walletImportCmd.Flags().StringVar(&walletImportData, "importdata", "", "The data to import, or the name of a file to read")
-	walletImportCmd.Flags().StringVar(&walletImportPassphrase, "importpassphrase", "", "Passphrase protecting the data to import")
-	walletImportCmd.Flags().BoolVar(&walletImportVerify, "verify", false, "Verify the wallet can be imported, but do not import it")
+	walletImportCmd.Flags().String("data", "", "The data to import, or the name of a data import file")
+	walletImportCmd.Flags().Bool("verify", false, "Verify the wallet can be imported, but do not import it")
+}
+
+func walletImportBindings() {
+	if err := viper.BindPFlag("data", walletImportCmd.Flags().Lookup("data")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("verify", walletImportCmd.Flags().Lookup("verify")); err != nil {
+		panic(err)
+	}
 }

core/account.go

@@ -71,10 +71,14 @@ func setup() error {
 // WalletFromInput obtains a wallet given the information in the viper variable
 // "account", or if not present the viper variable "wallet".
 func WalletFromInput(ctx context.Context) (e2wtypes.Wallet, error) {
-	if viper.GetString("account") != "" {
+	switch {
+	case viper.GetString("account") != "":
 		return WalletFromPath(ctx, viper.GetString("account"))
+	case viper.GetString("wallet") != "":
+		return WalletFromPath(ctx, viper.GetString("wallet"))
+	default:
+		return nil, errors.New("cannot determine wallet")
 	}
-	return WalletFromPath(ctx, viper.GetString("wallet"))
 }
 
 // WalletFromPath obtains a wallet given a path specification.

docs/usage.md

@@ -51,7 +51,7 @@ $ ethdo wallet delete --wallet="Old wallet"
 
 `ethdo wallet export` exports the wallet and all of its accounts.  Options for exporting a wallet include:
   - `wallet`: the name of the wallet to export (defaults to "primary")
-  - `exportpassphrase`: the passphrase with which to encrypt the wallet backup
+  - `passphrase`: the passphrase with which to encrypt the wallet backup
 
 ```sh
 $ ethdo wallet export --wallet="Personal wallet" --exportpassphrase="my export secret"
@@ -67,8 +67,8 @@ $ ethdo wallet export --wallet="Personal wallet" --exportpassphrase="my export s
 #### `import`
 
 `ethdo wallet import` imports a wallet and all of its accounts exported by `ethdo wallet export`.  Options for importing a wallet include:
-  - `importdata`: the data exported by `ethdo wallet export`
-  - `importpassphrase`: the passphrase that was provided to `ethdo wallet export` to encrypt the data
+  - `data`: the data exported by `ethdo wallet export`
+  - `passphrase`: the passphrase that was provided to `ethdo wallet export` to encrypt the data
   - `verify`: confirm information about the wallet import without importing it
 
 ```sh

go.mod

@@ -4,13 +4,15 @@ go 1.13
 
 require (
 	github.com/OneOfOne/xxhash v1.2.5 // indirect
+	github.com/attestantio/dirk v0.9.1
 	github.com/attestantio/go-eth2-client v0.6.8
 	github.com/ferranbt/fastssz v0.0.0-20201030134205-9b9624098321
 	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/gofrs/uuid v3.3.0+incompatible
 	github.com/gogo/protobuf v1.3.1
 	github.com/google/uuid v1.1.2
 	github.com/grpc-ecosystem/grpc-gateway v1.15.2 // indirect
-	github.com/herumi/bls-eth-go-binary v0.0.0-20201008062400-71567a52ad65
+	github.com/herumi/bls-eth-go-binary v0.0.0-20201019012252-4b463a10c225
 	github.com/magiconair/properties v1.8.4 // indirect
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/mitchellh/mapstructure v1.3.3 // indirect
@@ -32,23 +34,25 @@ require (
 	github.com/tyler-smith/go-bip39 v1.0.2
 	github.com/wealdtech/eth2-signer-api v1.6.0
 	github.com/wealdtech/go-bytesutil v1.1.1
-	github.com/wealdtech/go-ecodec v1.1.0
-	github.com/wealdtech/go-eth2-types/v2 v2.5.0
-	github.com/wealdtech/go-eth2-util v1.6.0
-	github.com/wealdtech/go-eth2-wallet v1.14.1
+	github.com/wealdtech/go-ecodec v1.1.1
+	github.com/wealdtech/go-eth2-types/v2 v2.5.1
+	github.com/wealdtech/go-eth2-util v1.6.1
+	github.com/wealdtech/go-eth2-wallet v1.14.2
 	github.com/wealdtech/go-eth2-wallet-dirk v1.0.4
-	github.com/wealdtech/go-eth2-wallet-distributed v1.1.1
-	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.1
-	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.1
-	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.1
-	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.1
-	github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.0
-	github.com/wealdtech/go-eth2-wallet-store-scratch v1.6.0
-	github.com/wealdtech/go-eth2-wallet-types/v2 v2.8.0
+	github.com/wealdtech/go-eth2-wallet-distributed v1.1.2
+	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.2
+	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.2
+	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.2
+	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.13
+	github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.1
+	github.com/wealdtech/go-eth2-wallet-store-scratch v1.6.1
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.8.1
 	github.com/wealdtech/go-string2eth v1.1.0
 	golang.org/x/text v0.3.3
-	google.golang.org/grpc v1.33.0
+	google.golang.org/grpc v1.33.1
 	gopkg.in/ini.v1 v1.62.0 // indirect
 )
 
 replace github.com/attestantio/go-eth2-client => ../../attestantio/go-eth2-client
+
+replace github.com/attestantio/dirk => ../../attestantio/dirk

signing/signroot.go

@@ -44,9 +44,9 @@ func SignRoot(account e2wtypes.Account, root []byte, domain []byte) ([]byte, err
 	// outputIf(debug, fmt.Sprintf("Signing %x (%d)", data, len(data)))
 	if protectingSigner, isProtectingSigner := account.(e2wtypes.AccountProtectingSigner); isProtectingSigner {
 		// Signer takes root and domain.
-		signature, err = signProtected(protectingSigner, root[:], domain)
+		signature, err = signProtected(protectingSigner, root, domain)
 	} else if signer, isSigner := account.(e2wtypes.AccountSigner); isSigner {
-		signature, err = sign(signer, root[:], domain)
+		signature, err = sign(signer, root, domain)
 	} else {
 		return nil, errors.New("account does not provide signing facility")
 	}

testutil/bytes.go

@@ -0,0 +1,29 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testutil
+
+import (
+	"encoding/hex"
+	"strings"
+)
+
+// HexToBytes converts a hex string to a byte array.
+// This should only be used for pre-defined test strings; it will panic if the input is invalid.
+func HexToBytes(input string) []byte {
+	res, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	if err != nil {
+		panic(err)
+	}
+	return res
+}

util/bls_test.go

@@ -0,0 +1,55 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestBLSID(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name   string
+		in     uint64
+		strRes string
+	}{
+		{
+			name:   "Zero",
+			in:     0,
+			strRes: "0",
+		},
+		{
+			name:   "One",
+			in:     1,
+			strRes: "1",
+		},
+		{
+			name:   "High",
+			in:     0x7fffffff,
+			strRes: "2147483647",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			blsID := util.BLSID(test.in)
+			require.Equal(t, test.strRes, blsID.GetDecString())
+		})
+	}
+}

util/depositinfo.go

@@ -75,9 +75,16 @@ type depositInfoCLI struct {
 }
 
 func DepositInfoFromJSON(input []byte) ([]*DepositInfo, error) {
+	if len(input) == 0 {
+		return nil, errors.New("no data supplied")
+	}
 	// Work out the type of data that we're dealing with, and decode it appropriately.
 	depositInfo, err := tryRawTxData(input)
 	if err != nil {
+		// At this point, ensure we have brackets around the deposit info.
+		if input[0] != '[' {
+			input = []byte(fmt.Sprintf("[%s]", string(input)))
+		}
 		depositInfo, err = tryV3DepositInfoFromJSON(input)
 		if err != nil {
 			depositInfo, err = tryV1DepositInfoFromJSON(input)

util/depositinfo_internal_test.go

@@ -0,0 +1,255 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestRawDepositInfo(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name  string
+		input []byte
+		err   string
+	}{
+		{
+			name: "Nil",
+			err:  "invalid transaction length",
+		},
+		{
+			name:  "Invalid",
+			input: []byte("invalid"),
+			err:   "public key invalid",
+		},
+		{
+			name:  "IncorrectSignature",
+			input: []byte(`0x02895118000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001209e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a35540000000000000000000000000000000000000000000000000000000000000030a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b0000000000000000000000000000000000000000000000000000000000000060b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2`),
+			err:   "invalid function signature",
+		},
+		{
+			name:  "IncorrectSize",
+			input: []byte(`0x22895118`),
+			err:   "invalid transaction length",
+		},
+		{
+			name:  "Good",
+			input: []byte(`0x22895118000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001209e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a35540000000000000000000000000000000000000000000000000000000000000030a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b0000000000000000000000000000000000000000000000000000000000000060b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2`),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			depositInfo, err := tryRawTxData(test.input)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, depositInfo)
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}
+
+func TestCLIDepositInfo(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name  string
+		input []byte
+		err   string
+	}{
+		{
+			name: "Nil",
+			err:  "unexpected end of JSON input",
+		},
+		{
+			name:  "Invalid",
+			input: []byte("invalid"),
+			err:   "invalid character 'i' looking for beginning of value",
+		},
+		{
+			name:  "PubKeyInvalid",
+			input: []byte(`[{"pubkey":"invalid","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"01020304"}]`),
+			err:   "public key invalid",
+		},
+		{
+			name:  "WithdrawalCredentialsInvalid",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"invalid","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"01020304"}]`),
+			err:   "withdrawal credentials invalid",
+		},
+		{
+			name:  "SignatureInvalid",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"invalid","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"01020304"}]`),
+			err:   "signature invalid",
+		},
+		{
+			name:  "DepositMessageRootInvalid",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"invalid","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"01020304"}]`),
+			err:   "deposit message root invalid",
+		},
+		{
+			name:  "DepositDataRootInvalid",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"invalid","fork_version":"01020304"}]`),
+			err:   "deposit data root invalid",
+		},
+		{
+			name:  "ForkVersionInvalid",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"invalid"}]`),
+			err:   "fork version invalid",
+		},
+		{
+			name:  "Good",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"01020304"}]`),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			depositInfo, err := tryCLIDepositInfoFromJSON(test.input)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, depositInfo)
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}
+
+func TestV3DepositInfo(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name  string
+		input []byte
+		err   string
+	}{
+		{
+			name: "Nil",
+			err:  "unexpected end of JSON input",
+		},
+		{
+			name:  "Invalid",
+			input: []byte("invalid"),
+			err:   "invalid character 'i' looking for beginning of value",
+		},
+		{
+			name:  "PubKeyInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"invalid","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","value":32000000000,"signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"0x01020304","version":3}]`),
+			err:   "public key invalid",
+		},
+		{
+			name:  "WithdrawalCredentialsInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"invalid","value":32000000000,"signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"0x01020304","version":3}]`),
+			err:   "withdrawal credentials invalid",
+		},
+		{
+			name:  "SignatureInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","value":32000000000,"signature":"invalid","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"0x01020304","version":3}]`),
+			err:   "signature invalid",
+		},
+		{
+			name:  "DepositMessageRootInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","value":32000000000,"signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"invalid","deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"0x01020304","version":3}]`),
+			err:   "deposit message root invalid",
+		},
+		{
+			name:  "DepositDataRootInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","value":32000000000,"signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"invalid","fork_version":"0x01020304","version":3}]`),
+			err:   "deposit data root invalid",
+		},
+		{
+			name:  "ForkVersionInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","value":32000000000,"signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"invalid","version":3}]`),
+			err:   "fork version invalid",
+		},
+		{
+			name:  "Good",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","value":32000000000,"signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"0x01020304","version":3}]`),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			depositInfo, err := tryV3DepositInfoFromJSON(test.input)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, depositInfo)
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}
+
+func TestV1DepositInfo(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name  string
+		input []byte
+		err   string
+	}{
+		{
+			name: "Nil",
+			err:  "unexpected end of JSON input",
+		},
+		{
+			name:  "Invalid",
+			input: []byte("invalid"),
+			err:   "invalid character 'i' looking for beginning of value",
+		},
+		{
+			name:  "PubKeyInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"invalid","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","value":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","version":2}]`),
+			err:   "public key invalid",
+		},
+		{
+			name:  "WithdrawalCredentialsInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"invalid","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","value":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","version":2}]`),
+			err:   "withdrawal credentials invalid",
+		},
+		{
+			name:  "SignatureInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"invalid","value":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","version":2}]`),
+			err:   "signature invalid",
+		},
+		{
+			name:  "DepositDataRootInvalid",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","value":32000000000,"deposit_data_root":"invalid","version":2}]`),
+			err:   "deposit data root invalid",
+		},
+		{
+			name:  "Good",
+			input: []byte(`[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","value":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","version":2}]`),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			depositInfo, err := tryV1DepositInfoFromJSON(test.input)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, depositInfo)
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}

util/depositinfo_test.go

@@ -0,0 +1,76 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestDepositInfo(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name  string
+		input []byte
+		err   string
+	}{
+		{
+			name: "Nil",
+			err:  "no data supplied",
+		},
+		{
+			name:  "Invalid",
+			input: []byte("bad"),
+			err:   "unknown deposit data format",
+		},
+		{
+			name:  "Incorrect",
+			input: []byte("{}"),
+			err:   "no public key for deposit 0",
+		},
+		{
+			name:  "Empty",
+			input: []byte("[]"),
+			err:   "no deposits supplied",
+		},
+		{
+			name:  "V2",
+			input: []byte(`{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","value":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","version":2}`),
+		},
+		{
+			name:  "Launchpad",
+			input: []byte(`[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"01020304"}]`),
+		},
+		{
+			name:  "Raw",
+			input: []byte(`0x22895118000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001209e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a35540000000000000000000000000000000000000000000000000000000000000030a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b0000000000000000000000000000000000000000000000000000000000000060b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2`),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			depositInfo, err := util.DepositInfoFromJSON(test.input)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, depositInfo)
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}

util/logging_internal_test.go

@@ -0,0 +1,80 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestLogLevel(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name  string
+		input string
+		level zerolog.Level
+	}{
+		{
+			name:  "Unknown",
+			input: "unknown",
+			level: zerolog.DebugLevel,
+		},
+		{
+			name:  "Disabled",
+			input: "None",
+			level: zerolog.Disabled,
+		},
+		{
+			name:  "Trace",
+			input: "Trace",
+			level: zerolog.TraceLevel,
+		},
+		{
+			name:  "Debug",
+			input: "Debug",
+			level: zerolog.DebugLevel,
+		},
+		{
+			name:  "Info",
+			input: "Info",
+			level: zerolog.InfoLevel,
+		},
+		{
+			name:  "Warn",
+			input: "Warn",
+			level: zerolog.WarnLevel,
+		},
+		{
+			name:  "Error",
+			input: "Error",
+			level: zerolog.ErrorLevel,
+		},
+		{
+			name:  "Fatal",
+			input: "Fatal",
+			level: zerolog.FatalLevel,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			level := logLevel(test.input)
+			require.Equal(t, test.level, level)
+		})
+	}
+}

util/scratchaccount.go

@@ -32,9 +32,8 @@ type ScratchAccount struct {
 func NewScratchAccount(privKey []byte, pubKey []byte) (*ScratchAccount, error) {
 	if len(privKey) > 0 {
 		return newScratchAccountFromPrivKey(privKey)
-	} else {
-		return newScratchAccountFromPubKey(pubKey)
 	}
+	return newScratchAccountFromPubKey(pubKey)
 }
 
 func newScratchAccountFromPrivKey(privKey []byte) (*ScratchAccount, error) {

util/scratchaccount_test.go

@@ -0,0 +1,136 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util_test
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestScratchAccountFromPrivKey(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name      string
+		key       []byte
+		err       string
+		sigErr    string
+		signature []byte
+	}{
+		{
+			name: "Nil",
+			err:  "public key must be 48 bytes",
+		},
+		{
+			name: "KeyShort",
+			key:  testutil.HexToBytes("0x295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			err:  "private key must be 32 bytes",
+		},
+		{
+			name: "KeyLong",
+			key:  testutil.HexToBytes("0x2525295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			err:  "private key must be 32 bytes",
+		},
+		{
+			name:      "Good",
+			key:       testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+			signature: testutil.HexToBytes("0x9004c971416fc1e48c0443d5650c4e998ab33b456223a1c3cd24da90e06174c0d66b80f492bc7b24d656a3c2d3051238020a3a4c0fd1fe98d61b97e9e5aa680841c965e8578425df4ce0b0a21270e330437931eadae1a9109336d415aeb420bb"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			account, err := util.NewScratchAccount(test.key, nil)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, account.ID())
+				require.Equal(t, "scratch", account.Name())
+				require.Equal(t, "", account.Path())
+				require.NotNil(t, account.PublicKey())
+				require.False(t, account.IsUnlocked())
+				_, err := account.Sign(testutil.HexToBytes("0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"))
+				require.EqualError(t, err, "locked")
+				require.NoError(t, account.Unlock(nil))
+				require.True(t, account.IsUnlocked())
+				signature, err := account.Sign(testutil.HexToBytes("0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"))
+				if test.sigErr == "" {
+					require.NoError(t, err)
+					require.Equal(t, test.signature, signature.Marshal())
+				} else {
+					require.EqualError(t, err, test.sigErr)
+				}
+				account.Lock()
+				require.False(t, account.IsUnlocked())
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}
+
+func TestScratchAccountFromPublicKey(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name   string
+		pubKey []byte
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "public key must be 48 bytes",
+		},
+		{
+			name:   "KeyShort",
+			pubKey: testutil.HexToBytes("0x9a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+			err:    "public key must be 48 bytes",
+		},
+		{
+			name:   "KeyLong",
+			pubKey: testutil.HexToBytes("0xa9a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+			err:    "public key must be 48 bytes",
+		},
+		{
+			name:   "Good",
+			pubKey: testutil.HexToBytes("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			account, err := util.NewScratchAccount(nil, test.pubKey)
+			if test.err == "" {
+				require.NoError(t, err)
+				require.NotNil(t, account.ID())
+				require.Equal(t, "scratch", account.Name())
+				require.Equal(t, "", account.Path())
+				require.False(t, account.IsUnlocked())
+				_, err := account.Sign(testutil.HexToBytes("0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"))
+				require.EqualError(t, err, "locked")
+				require.NoError(t, account.Unlock(nil))
+				require.True(t, account.IsUnlocked())
+				_, err = account.Sign(testutil.HexToBytes("0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"))
+				require.EqualError(t, err, "no private key")
+				account.Lock()
+				require.False(t, account.IsUnlocked())
+			} else {
+				require.EqualError(t, err, test.err)
+			}
+		})
+	}
+}