Update version.

Update import/export usage examples to 1.7.0

.github/workflows/release.yml

@@ -30,16 +30,16 @@ jobs:
 
     - name: Set env
       run: |
-       echo '::set-env name=GO111MODULE::on'
+       echo "GO111MODULE=on" >> $GITHUB_ENV
        # Release tag comes from the github reference.
        RELEASE_TAG=$(echo ${GITHUB_REF} | sed -e 's!.*/!!')
-       echo "::set-env name=RELEASE_TAG::${RELEASE_TAG}"
+       echo "RELEASE_TAG=${RELEASE_TAG}" >> $GITHUB_ENV
        echo "::set-output name=RELEASE_TAG::${RELEASE_TAG}"
        # Ensure the release tag has expected format.
        echo ${RELEASE_TAG} | grep -q '^v' || exit 1
        # Release version is same as release tag without leading 'v'.
        RELEASE_VERSION=$(echo ${GITHUB_REF} | sed -e 's!.*/v!!')
-       echo "::set-env name=RELEASE_VERSION::${RELEASE_VERSION}"
+       echo "RELEASE_VERSION=${RELEASE_VERSION}" >> $GITHUB_ENV
        echo "::set-output name=RELEASE_VERSION::${RELEASE_VERSION}"
 
     - name: Build
@@ -52,25 +52,33 @@ jobs:
       run: |
        go get github.com/suburbandad/xgo
 
-    - name: Cross-compile
-      run: xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64,linux/arm64,windows/amd64" github.com/wealdtech/ethdo
+    - name: Cross-compile linux
+      run: |
+        xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64,linux/arm64" github.com/wealdtech/ethdo
 
-    - name: Create windows zip file
+    - name: Cross-compile windows
+      run: |
+        xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION} -s -w -extldflags -static" --targets="windows/amd64" github.com/wealdtech/ethdo
+
+    - name: Create windows release files
       run: |
        mv ethdo-windows-4.0-amd64.exe ethdo.exe
+       sha256sum ethdo.exe >ethdo-${RELEASE_VERSION}-windows.sha256
        zip --junk-paths ethdo-${RELEASE_VERSION}-windows-exe.zip ethdo.exe
 
     - name: Create linux AMD64 tgz file
       run: |
        mv ethdo-linux-amd64 ethdo
+       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-amd64.sha256
        tar zcf ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz ethdo
 
     - name: Create linux ARM64 tgz file
       run: |
        mv ethdo-linux-arm64 ethdo
+       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-arm64.sha256
        tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz ethdo
 
-    - name: Create draft release
+    - name: Create release
       id: create_release
       uses: actions/create-release@v1
       env:
@@ -80,7 +88,18 @@ jobs:
         release_name: Release ${{ env.RELEASE_VERSION }}
         draft: true
         prerelease: false
-       
+
+    - name: Upload windows checksum file
+      id: upload-release-asset-windows-checksum
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-windows.sha256
+        asset_name: ethdo-${{ env.RELEASE_VERSION }}-windows.sha256
+        asset_content_type: text/plain
+
     - name: Upload windows zip file
       id: upload-release-asset-windows
       uses: actions/upload-release-asset@v1
@@ -91,7 +110,18 @@ jobs:
         asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-windows-exe.zip
         asset_name: ethdo-${{ env.RELEASE_VERSION }}-windows-exe.zip
         asset_content_type: application/zip
-       
+
+    - name: Upload linux AMD64 checksum file
+      id: upload-release-asset-linux-amd64-checksum
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.sha256
+        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.sha256
+        asset_content_type: text/plain
+
     - name: Upload linux AMD64 tgz file
       id: upload-release-asset-linux-amd64
       uses: actions/upload-release-asset@v1
@@ -102,7 +132,18 @@ jobs:
         asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.tar.gz
         asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.tar.gz
         asset_content_type: application/gzip
-       
+
+    - name: Upload linux ARM64 checksum file
+      id: upload-release-asset-linux-arm64-checksum
+      uses: actions/upload-release-asset@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        upload_url: ${{ steps.create_release.outputs.upload_url }}
+        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
+        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
+        asset_content_type: text/plain
+
     - name: Upload linux ARM64 tgz file
       id: upload-release-asset-linux-arm64
       uses: actions/upload-release-asset@v1

CHANGELOG.md

@@ -0,0 +1,36 @@
+1.7.3:
+  - fix issue where base directory was ignored for wallet creation
+  - new "validator duties" command to display known duties for a given validator
+  - update go-eth2-client to display correct validator status from prysm
+1.7.2:
+  - new "account derive" command to derive keys directly from a mnemonic and derivation path
+  - add more output to "deposit verify" to explain operation
+1.7.1:
+  - fix "store not set" issue
+1.7.0:
+  - "validator depositdata" now defaults to mainnet, does not silently fetch fork version from chain
+  - update deposit data output to version 3, to allow for better deposit checking
+  - use go-eth2-client for beacon node communications
+  - deprecated "--basedir" in favor of "--base-dir"
+  - deprecated "--storepassphrase" in favor of "--store-passphrase"
+  - deprecated "--walletpassphrsae" in favor of "--wallet-passphrsae"
+  - renamed "--exportpassphrase" and "--importpassphrase" flags to "--passphrase"
+  - reworked internal structure of account-related commands
+  - reject weak passphrases by default
+1.6.1:
+  - "attester inclusion" defaults to previous epoch
+  - output array for launchpad deposit data JSON in all situations
+1.6.0:
+  - update BLS HKDF function to match spec 04
+  - add --launchpad option to "validator depositdata" to output data in launchpad format
+1.5.9:
+  - fix issue where wallet mnemonics were not normalised to NFKD
+  - "block info" supports fetching the gensis block (--slot=0)
+  - "attester inclusion" command finds the inclusion slot for a validator's attestation
+  - "account info" with verbose option now displays participants for distributed accounts
+  - fix issue where distributed account generation without a passphrase was not allowed
+
+1.5.8:
+  - allow raw deposit transactions to be supplied to "deposit verify"
+  - move functionality of "account withdrawalcredentials" to be part of "account info"
+  - add genesis validators root to "chain info"

README.md

@@ -5,8 +5,6 @@
 
 A command-line tool for managing common tasks in Ethereum 2.
 
-**Please note that this tool and its underlying libraries have not yet undergone a security audit; use at your own risk.**
-
 ## Table of Contents
 
 - [Install](#install)
@@ -90,7 +88,7 @@ All ethdo comands take the following parameters:
   - `store`: the name of the storage system for wallets.  This can be one of "filesystem" (for local storage of the wallet) or "s3" (for remote storage of the wallet on [Amazon's S3](https://aws.amazon.com/s3/) storage system), and defaults to "filesystem"
   - `storepassphrase`: the passphrase for the store.  If this is empty the store is unencrypted
   - `walletpassphrase`: the passphrase for the wallet.  This is required for some wallet-centric operations such as creating new accounts
-  - `accountpassphrase`: the passphrase for the account.  This is required for some account-centric operations such as signing data
+  - `passphrase`: the passphrase for the account.  This is required for some account-centric operations such as signing data
 
 Accounts are specified in the standard "<wallet>/<account>" format, for example the account "savings" in the wallet "primary" would be referenced as "primary/savings".
 
@@ -125,6 +123,12 @@ If set, the `--debug` argument will output additional information about the oper
 
 Commands will have an exit status of 0 on success and 1 on failure.  The specific definition of success is specified in the help for each command.
 
+## Passphrase strength
+
+`ethdo` will by default not allow creation or export of accounts or wallets with weak passphrases.  If a weak pasphrase is used then `ethdo` will refuse to continue.
+
+If a weak passphrase is required, `ethdo` can be supplied with the `--allow-weak-passphrases` option which will force it to accept any passphrase, even if it is considered weak.
+
 ## Rules for account passphrases
 
 Account passphrases are used in various places in `ethdo`.  Where they are used, the following rules apply:
@@ -143,7 +147,7 @@ Command information, along with sample outputs and optional arguments, is availa
 
 # HOWTO
 
-There is a [HOWTO](https://github.com/wealdtech/ethdo/blob/master/docs/howto.md) that covers details about how to carry out various common tasks.
+There is a [HOWTO](https://github.com/wealdtech/ethdo/blob/master/docs/howto.md) that covers details about how to carry out various common tasks.  There is also a specific document that provides details of how to carry out [common conversions](docs/conversions.md) from mnemonic, to account, to deposit data, for launchpad-related configurations.
 
 ## Maintainers
 

cmd/account/create/input.go

@@ -0,0 +1,96 @@
+// 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/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 = util.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,147 @@
+// 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 func() {
+			if err := locker.Lock(ctx); err != nil {
+				util.Log.Trace().Err(err).Msg("Failed to lock wallet")
+			}
+		}()
+	}
+	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 {
+		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/derive/input.go

@@ -0,0 +1,58 @@
+// 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 accountderive
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type dataIn struct {
+	quiet bool
+	// Derivation information.
+	mnemonic string
+	path     string
+	// Output options.
+	showPrivateKey            bool
+	showWithdrawalCredentials bool
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	data := &dataIn{}
+
+	// Quiet.
+	data.quiet = viper.GetBool("quiet")
+
+	// Mnemonic.
+	if viper.GetString("mnemonic") == "" {
+		return nil, errors.New("mnemonic is required")
+	}
+	data.mnemonic = viper.GetString("mnemonic")
+
+	// Path.
+	if viper.GetString("path") == "" {
+		return nil, errors.New("path is required")
+	}
+	data.path = viper.GetString("path")
+
+	// Show private key.
+	data.showPrivateKey = viper.GetBool("show-private-key")
+
+	// Show withdrawal credentials.
+	data.showWithdrawalCredentials = viper.GetBool("show-withdrawal-credentials")
+
+	return data, nil
+}

cmd/account/derive/input_internal_test.go

@@ -0,0 +1,78 @@
+// 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 accountderive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "MnemonicMissing",
+			vars: map[string]interface{}{
+				"path": "m/12381/3600/0/0",
+			},
+			err: "mnemonic is required",
+		},
+		{
+			name: "PathMissing",
+			vars: map[string]interface{}{
+				"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",
+			},
+			err: "path is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"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",
+				"path":     "m/12381/3600/0/0",
+			},
+			res: &dataIn{
+				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",
+				path:     "m/12381/3600/0/0",
+			},
+		},
+	}
+
+	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.mnemonic, res.mnemonic)
+				require.Equal(t, test.res.path, res.path)
+			}
+		})
+	}
+}

cmd/account/derive/output.go

@@ -0,0 +1,53 @@
+// 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 accountderive
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/pkg/errors"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	util "github.com/wealdtech/go-eth2-util"
+)
+
+type dataOut struct {
+	showPrivateKey            bool
+	showWithdrawalCredentials bool
+	key                       *e2types.BLSPrivateKey
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+	if data.key == nil {
+		return "", errors.New("no key")
+	}
+
+	builder := strings.Builder{}
+
+	if data.showPrivateKey {
+		builder.WriteString(fmt.Sprintf("Private key: %#x\n", data.key.Marshal()))
+	}
+	builder.WriteString(fmt.Sprintf("Public key: %#x", data.key.PublicKey().Marshal()))
+	if data.showWithdrawalCredentials {
+		withdrawalCredentials := util.SHA256(data.key.PublicKey().Marshal())
+		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
+		builder.WriteString(fmt.Sprintf("\nWithdrawal credentials: %#x", withdrawalCredentials))
+	}
+
+	return builder.String(), nil
+}

cmd/account/derive/output_internal_test.go

@@ -0,0 +1,98 @@
+// 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 accountderive
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func blsPrivateKey(input string) *e2types.BLSPrivateKey {
+	data, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+	key, err := e2types.BLSPrivateKeyFromBytes(data)
+	if err != nil {
+		panic(err)
+	}
+	return key
+}
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		needs   []string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "KeyMissing",
+			dataOut: &dataOut{},
+			err:     "no key",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				key: blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+			},
+			needs: []string{"Public key"},
+		},
+		{
+			name: "PrivatKey",
+			dataOut: &dataOut{
+				key:     blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+				showPrivateKey: true,
+			},
+			needs: []string{"Public key", "Private key"},
+		},
+		{
+			name: "WithdrawalCredentials",
+			dataOut: &dataOut{
+				key:                       blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+				showWithdrawalCredentials: true,
+			},
+			needs: []string{"Public key", "Withdrawal credentials"},
+		},
+		{
+			name: "All",
+			dataOut: &dataOut{
+				key:                       blsPrivateKey("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+				showPrivateKey:                   true,
+				showWithdrawalCredentials: true,
+			},
+			needs: []string{"Public key", "Private key", "Withdrawal credentials"},
+		},
+	}
+
+	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)
+				for _, need := range test.needs {
+					require.Contains(t, res, need)
+				}
+			}
+		})
+	}
+}

cmd/account/derive/process.go

@@ -0,0 +1,72 @@
+// 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 accountderive
+
+import (
+	"context"
+	"regexp"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/tyler-smith/go-bip39"
+	util "github.com/wealdtech/go-eth2-util"
+	"golang.org/x/text/unicode/norm"
+)
+
+// pathRegex is the regular expression that matches an HD path.
+var pathRegex = regexp.MustCompile("^m/[0-9]+/[0-9]+(/[0-9+])+")
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	// If there are more than 24 words we treat the additional characters as the passphrase.
+	mnemonicParts := strings.Split(data.mnemonic, " ")
+	mnemonicPassphrase := ""
+	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)))
+
+	if !bip39.IsMnemonicValid(data.mnemonic) {
+		return nil, errors.New("mnemonic is invalid")
+	}
+
+	// Create seed from mnemonic and passphrase.
+	seed := bip39.NewSeed(data.mnemonic, mnemonicPassphrase)
+
+	// Ensure the path is valid.
+	match := pathRegex.Match([]byte(data.path))
+	if !match {
+		return nil, errors.New("path does not match expected format m/…")
+	}
+
+	// Derive private key from seed and path.
+	key, err := util.PrivateKeyFromSeedAndPath(seed, data.path)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to generate key")
+	}
+
+	results := &dataOut{
+		showPrivateKey:                   data.showPrivateKey,
+		showWithdrawalCredentials: data.showWithdrawalCredentials,
+		key:                       key,
+	}
+
+	return results, nil
+}

cmd/account/derive/process_internal_test.go

@@ -0,0 +1,97 @@
+// 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 accountderive
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	tests := []struct {
+		name    string
+		dataIn  *dataIn
+		privKey []byte
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "MnemonicMissing",
+			dataIn: &dataIn{
+				path: "m/12381/3600/0/0",
+			},
+			err: "mnemonic is invalid",
+		},
+		{
+			name: "MnemonicInvalid",
+			dataIn: &dataIn{
+				mnemonic: "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
+				path:     "m/12381/3600/0/0",
+			},
+			err: "mnemonic is invalid",
+		},
+		{
+			name: "PathMissing",
+			dataIn: &dataIn{
+				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",
+			},
+			err: "path does not match expected format m/…",
+		},
+		{
+			name: "PathInvalid",
+			dataIn: &dataIn{
+				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",
+				path:     "n/12381/3600/0/0",
+			},
+			err: "path does not match expected format m/…",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				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",
+				path:     "m/12381/3600/0/0",
+			},
+			privKey: testutil.HexToBytes("0x068dce0c90cb428ab37a74af0191eac49648035f1aaef077734b91e05985ec55"),
+		},
+		{
+			name: "Extended",
+			dataIn: &dataIn{
+				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 extended",
+				path:     "m/12381/3600/0/0",
+			},
+			privKey: testutil.HexToBytes("0x58c8b280ae035de0452797b52fb62555f27f78541ea2f04b23e7bb0fcd0fc2d6"),
+		},
+	}
+
+	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.privKey, res.key.Marshal())
+			}
+		})
+	}
+}

cmd/account/derive/run.go

@@ -0,0 +1,49 @@
+// 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 accountderive
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+)
+
+// 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 dataIn.quiet {
+		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,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 accountimport
+
+import (
+	"context"
+	"encoding/hex"
+	"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 {
+	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 = util.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,55 @@
+// 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 func() {
+			if err := locker.Lock(ctx); err != nil {
+				util.Log.Trace().Err(err).Msg("Failed to lock wallet")
+			}
+		}()
+	}
+
+	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,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 accountkey
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"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 = util.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,128 @@
+// 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))
+	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,70 @@
+// 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/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 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 func() {
+				if err := locker.Lock(ctx); err != nil {
+					util.Log.Trace().Err(err).Msg("Failed to lock account")
+				}
+			}()
+		}
+	}
+	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,14 +14,11 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	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{
@@ -32,63 +29,37 @@ 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) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		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 {
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			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()
-			account, err = distributedCreator.CreateDistributedAccount(ctx, accountName, viper.GetUint32("participants"), viper.GetUint32("signing-threshold"), []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("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)")
+}
+
+func accountCreateBindings() {
 	if err := viper.BindPFlag("participants", accountCreateCmd.Flags().Lookup("participants")); err != nil {
 		panic(err)
 	}
-	accountCreateCmd.Flags().Uint32("signing-threshold", 0, "Signing threshold (for distributed accounts)")
 	if err := viper.BindPFlag("signing-threshold", accountCreateCmd.Flags().Lookup("signing-threshold")); err != nil {
 		panic(err)
 	}
+	if err := viper.BindPFlag("path", accountCreateCmd.Flags().Lookup("path")); err != nil {
+		panic(err)
+	}
 }

cmd/accountderive.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 cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	accountderive "github.com/wealdtech/ethdo/cmd/account/derive"
+)
+
+var accountDeriveCmd = &cobra.Command{
+	Use:   "derive",
+	Short: "Derive an account",
+	Long: `Derive an account from a mnemonic and path.  For example:
+
+    ethdo account derive --mnemonic="..." --path="m/12381/3600/0/0"
+
+In quiet mode this will return 0 if the inputs can derive an account account, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountderive.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	accountCmd.AddCommand(accountDeriveCmd)
+	accountFlags(accountDeriveCmd)
+	accountDeriveCmd.Flags().String("mnemonic", "", "mnemonic from which to derive the HD seed")
+	accountDeriveCmd.Flags().String("path", "", "path from which to derive the account")
+	accountDeriveCmd.Flags().Bool("show-private-key", false, "show private key for derived account")
+	accountDeriveCmd.Flags().Bool("show-withdrawal-credentials", false, "show withdrawal credentials for derived account")
+}
+
+func accountDeriveBindings() {
+	if err := viper.BindPFlag("mnemonic", accountDeriveCmd.Flags().Lookup("mnemonic")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("path", accountDeriveCmd.Flags().Lookup("path")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("show-private-key", accountDeriveCmd.Flags().Lookup("show-private-key")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("show-withdrawal-credentials", accountDeriveCmd.Flags().Lookup("show-withdrawal-credentials")); err != nil {
+		panic(err)
+	}
+}

cmd/accountimport.go

@@ -14,19 +14,13 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"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",
@@ -35,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")
-		passphrase := getPassphrase()
-		assert(accountImportKey != "", "--key is required")
-
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		key, err := bytesutil.FromHexString(accountImportKey)
-		errCheck(err, "Invalid key")
-
-		w, err := walletFromPath(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 = accountFromPath(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(passphrase))
-		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/accountinfo.go

@@ -17,13 +17,11 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 	util "github.com/wealdtech/go-eth2-util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -36,30 +34,11 @@ var accountInfoCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the account exists, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-		outputIf(debug, fmt.Sprintf("Opened wallet %q of type %s", wallet.Name(), wallet.Type()))
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		if wallet.Type() == "hierarchical deterministic" && strings.HasPrefix(accountName, "m/") {
-			assert(getWalletPassphrase() != "", "walletpassphrase is required to show information about dynamically generated hierarchical deterministic accounts")
-			locker, isLocker := wallet.(e2wtypes.WalletLocker)
-			if isLocker {
-				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-				defer cancel()
-				errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
-			}
-		}
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+
+		assert(viper.GetString("account") != "", "--account is required")
+		wallet, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
 		// Disallow wildcards (for now)
@@ -79,6 +58,13 @@ In quiet mode this will return 0 if the account exists, otherwise 1.`,
 		if distributedAccount, ok := account.(e2wtypes.DistributedAccount); ok {
 			fmt.Printf("Composite public key: %#x\n", distributedAccount.CompositePublicKey().Marshal())
 			fmt.Printf("Signing threshold: %d/%d\n", distributedAccount.SigningThreshold(), len(distributedAccount.Participants()))
+			if verbose {
+				fmt.Printf("Participants:\n")
+				for k, v := range distributedAccount.Participants() {
+					fmt.Printf(" %d: %s\n", k, v)
+				}
+			}
+
 			withdrawalPubKey = distributedAccount.CompositePublicKey()
 		}
 		if verbose {

cmd/accountkey.go

@@ -14,15 +14,11 @@
 package cmd
 
 import (
-	"context"
 	"fmt"
-	"os"
-	"strings"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	accountkey "github.com/wealdtech/ethdo/cmd/account/key"
 )
 
 // accountKeyCmd represents the account key command
@@ -34,57 +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) {
-		assert(!remote, "account keys not available with remote wallets")
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-		outputIf(debug, fmt.Sprintf("Opened wallet %q of type %s", wallet.Name(), wallet.Type()))
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		if wallet.Type() == "hierarchical deterministic" && strings.HasPrefix(accountName, "m/") {
-			assert(getWalletPassphrase() != "", "walletpassphrase is required to show information about dynamically generated hierarchical deterministic accounts")
-			locker, isLocker := wallet.(e2wtypes.WalletLocker)
-			if isLocker {
-				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-				defer cancel()
-				errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
-			}
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountkey.Run(cmd)
+		if err != nil {
+			return err
 		}
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
-		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)
+		if viper.GetBool("quiet") {
+			return nil
 		}
-		privateKey, err := privateKeyProvider.PrivateKey(ctx)
-		errCheck(err, "Failed to obtain private key")
-
-		outputIf(!quiet, fmt.Sprintf("%#x", privateKey.Marshal()))
-		os.Exit(_exitSuccess)
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 

cmd/accountlock.go

@@ -18,7 +18,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -31,27 +30,18 @@ var accountLockCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the account is locked, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+
+		assert(viper.GetString("account") != "", "--account is required")
+
+		_, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
 		locker, isLocker := account.(e2wtypes.AccountLocker)
 		assert(isLocker, "Account does not support locking")
 
-		ctx, cancel = context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		err = locker.Lock(ctx)
-		cancel()
 		errCheck(err, "Failed to lock account")
 	},
 }

cmd/accountunlock.go

@@ -19,7 +19,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -32,19 +31,12 @@ var accountUnlockCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the account is unlocked, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+
+		assert(viper.GetString("account") != "", "--account is required")
+
+		_, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
 		locker, isLocker := account.(e2wtypes.AccountLocker)

cmd/accountwithdrawalcredentials.go

@@ -1,83 +0,0 @@
-// 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 cmd
-
-import (
-	"context"
-	"encoding/hex"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-	util "github.com/wealdtech/go-eth2-util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
-)
-
-var accountWithdrawalCredentialsCmd = &cobra.Command{
-	Use:   "withdrawalcredentials",
-	Short: "Provide withdrawal credentials for an account",
-	Long: `Provide withdrawal credentials for an account.  For example:
-
-    ethdo account withdrawalcredentials --account="Validators/1"
-
-In quiet mode this will return 0 if the account exists, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(viper.GetString("account") != "" || viper.GetString("pubkey") != "", "account or pubkey is required")
-
-		var pubKey []byte
-		if viper.GetString("pubkey") != "" {
-			var err error
-			pubKey, err = hex.DecodeString(strings.TrimPrefix(viper.GetString("pubkey"), "0x"))
-			errCheck(err, "Failed to decode supplied public key")
-		} else {
-			wallet, err := openWallet()
-			errCheck(err, "Failed to access wallet")
-
-			_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-			errCheck(err, "Failed to obtain account name")
-
-			accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-			assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
-			account, err := accountByNameProvider.AccountByName(ctx, accountName)
-			errCheck(err, "Failed to obtain account")
-
-			key, err := bestPublicKey(account)
-			errCheck(err, "Account does not provide a public key")
-			pubKey = key.Marshal()
-		}
-
-		if quiet {
-			os.Exit(_exitSuccess)
-		}
-
-		withdrawalCredentials := util.SHA256(pubKey)
-		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
-		fmt.Printf("%#x\n", withdrawalCredentials)
-	},
-}
-
-func init() {
-	accountCmd.AddCommand(accountWithdrawalCredentialsCmd)
-	accountFlags(accountWithdrawalCredentialsCmd)
-	accountWithdrawalCredentialsCmd.Flags().String("pubkey", "", "Public key (overrides account)")
-	if err := viper.BindPFlag("pubkey", accountCreateCmd.Flags().Lookup("pubkey")); err != nil {
-		panic(err)
-	}
-}

cmd/attester.go

@@ -0,0 +1,32 @@
+// 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 cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// attesterCmd represents the attester command
+var attesterCmd = &cobra.Command{
+	Use:   "attester",
+	Short: "Obtain information about Ethereum 2 attesters",
+	Long:  "Obtain information about Ethereum 2 attesters",
+}
+
+func init() {
+	RootCmd.AddCommand(attesterCmd)
+}
+
+func attesterFlags(cmd *cobra.Command) {
+}

cmd/attester/inclusion/input.go

@@ -0,0 +1,137 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"strings"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"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
+	// Chain information.
+	slotsPerEpoch uint64
+	// Operation.
+	validator  *api.Validator
+	eth2Client eth2client.Service
+	epoch      spec.Epoch
+	account    e2wtypes.Account
+}
+
+func input(ctx context.Context) (*dataIn, 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")
+
+	// Account.
+	var err error
+	data.account, err = attesterInclusionAccount()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain account")
+	}
+
+	// Ethereum 2 client.
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+	}
+
+	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
+	}
+	data.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
+
+	// Epoch.
+	epoch := viper.GetInt64("epoch")
+	if epoch == -1 {
+		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
+		genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain genesis data")
+		}
+		epoch = int64(time.Since(genesis.GenesisTime).Seconds()) / (int64(slotDuration.Seconds()) * int64(data.slotsPerEpoch))
+		if epoch > 0 {
+			epoch--
+		}
+	}
+	data.epoch = spec.Epoch(epoch)
+
+	// Validator.
+	stateID := "head"
+	if viper.GetInt64("epoch") != -1 {
+		stateID = fmt.Sprintf("%d", uint64(data.epoch)*data.slotsPerEpoch)
+	}
+	pubKeys := make([]spec.BLSPubKey, 1)
+	pubKey, err := util.BestPublicKey(data.account)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain public key for account")
+	}
+	copy(pubKeys[0][:], pubKey.Marshal())
+	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, stateID, pubKeys)
+	if err != nil {
+		return nil, errors.New("failed to obtain validator information")
+	}
+	for _, validator := range validators {
+		data.validator = validator
+	}
+
+	return data, nil
+}
+
+// attesterInclusionAccount obtains the account for the attester inclusion command.
+func attesterInclusionAccount() (e2wtypes.Account, error) {
+	var account e2wtypes.Account
+	var err error
+	if viper.GetString("account") != "" {
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+		_, account, err = util.WalletAndAccountFromPath(ctx, viper.GetString("account"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain account")
+		}
+	} else {
+		pubKey := viper.GetString("pubkey")
+		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(pubKey, "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", pubKey))
+		}
+		account, err = util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", pubKey))
+		}
+	}
+	return account, nil
+}

cmd/attester/inclusion/input_internal_test.go

@@ -0,0 +1,96 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	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))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.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{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "failed to obtain account: invalid public key : public key must be 48 bytes",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+		},
+	}
+
+	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/attester/inclusion/output.go

@@ -0,0 +1,46 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"fmt"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	debug            bool
+	quiet            bool
+	verbose          bool
+	slot             spec.Slot
+	attestationIndex uint64
+	inclusionDelay   spec.Slot
+	found            bool
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	if !data.quiet {
+		if data.found {
+			return fmt.Sprintf("Attestation included in block %d, attestation %d (inclusion delay %d)", data.slot, data.attestationIndex, data.inclusionDelay), nil
+		}
+		return "Attestation not found", nil
+	}
+	return "", nil
+}

cmd/attester/inclusion/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 attesterinclusion
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Empty",
+			dataOut: &dataOut{},
+			res:     "Attestation not found",
+		},
+		{
+			name: "Found",
+			dataOut: &dataOut{
+				found:            true,
+				slot:             123,
+				attestationIndex: 456,
+				inclusionDelay:   7,
+			},
+			res: "Attestation included in block 123, attestation 456 (inclusion delay 7)",
+		},
+	}
+
+	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/attester/inclusion/process.go

@@ -0,0 +1,85 @@
+// 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 attesterinclusion
+
+import (
+	"context"
+	"fmt"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	results := &dataOut{
+		debug:   data.debug,
+		quiet:   data.quiet,
+		verbose: data.verbose,
+	}
+
+	duty, err := duty(ctx, data.eth2Client, data.validator, data.epoch, data.slotsPerEpoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain duty for validator")
+	}
+
+	startSlot := duty.Slot + 1
+	endSlot := startSlot + 32
+	for slot := startSlot; slot < endSlot; slot++ {
+		signedBlock, err := data.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain block")
+		}
+		if signedBlock == nil {
+			continue
+		}
+		if signedBlock.Message.Slot != slot {
+			continue
+		}
+		if data.debug {
+			fmt.Printf("Fetched block for slot %d\n", slot)
+		}
+		for i, attestation := range signedBlock.Message.Body.Attestations {
+			if attestation.Data.Slot == duty.Slot &&
+				attestation.Data.Index == duty.CommitteeIndex &&
+				attestation.AggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
+				results.slot = slot
+				results.attestationIndex = uint64(i)
+				results.inclusionDelay = slot - duty.Slot
+				results.found = true
+				return results, nil
+			}
+		}
+	}
+	return results, nil
+}
+
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch spec.Epoch, slotsPerEpoch uint64) (*api.AttesterDuty, error) {
+	// Find the attesting slot for the given epoch.
+	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validator.Index})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain attester duties")
+	}
+
+	if len(duties) == 0 {
+		return nil, errors.New("validator does not have duty for that epoch")
+	}
+
+	return duties[0], nil
+}

cmd/attester/inclusion/process_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 attesterinclusion
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/auto"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+	eth2Client, err := auto.New(context.Background(),
+		auto.WithLogLevel(zerolog.Disabled),
+		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Client",
+			dataIn: &dataIn{
+				eth2Client:    eth2Client,
+				slotsPerEpoch: 32,
+				validator: &api.Validator{
+					Index: 0,
+				},
+				epoch: 100,
+			},
+		},
+	}
+
+	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/attester/inclusion/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 attesterinclusion
+
+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("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/attesterinclusion.go

@@ -0,0 +1,61 @@
+// 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 cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	attesterinclusion "github.com/wealdtech/ethdo/cmd/attester/inclusion"
+)
+
+var attesterInclusionCmd = &cobra.Command{
+	Use:   "inclusion",
+	Short: "Obtain information about attester inclusion",
+	Long: `Obtain information about attester inclusion.  For example:
+
+    ethdo attester inclusion --account=Validators/00001 --epoch=12345
+
+In quiet mode this will return 0 if an attestation from the attester is found on the block of the given epoch, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := attesterinclusion.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	attesterCmd.AddCommand(attesterInclusionCmd)
+	attesterFlags(attesterInclusionCmd)
+	attesterInclusionCmd.Flags().Int64("epoch", -1, "the last complete epoch")
+	attesterInclusionCmd.Flags().String("pubkey", "", "the public key of the attester")
+}
+
+func attesterInclusionBindings() {
+	if err := viper.BindPFlag("epoch", attesterInclusionCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("pubkey", attesterInclusionCmd.Flags().Lookup("pubkey")); err != nil {
+		panic(err)
+	}
+}

cmd/block/info/input.go

@@ -0,0 +1,68 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"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
+	// Operation.
+	eth2Client eth2client.Service
+	jsonOutput bool
+	// Chain information.
+	blockID string
+	stream  bool
+}
+
+func input(ctx context.Context) (*dataIn, 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")
+	data.jsonOutput = viper.GetBool("json")
+
+	data.stream = viper.GetBool("stream")
+
+	var err error
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+	}
+
+	if viper.GetString("blockid") == "" {
+		data.blockID = "head"
+	} else {
+		// Specific slot.
+		data.blockID = viper.GetString("blockid")
+	}
+
+	return data, nil
+}

cmd/block/info/input_internal_test.go

@@ -0,0 +1,126 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	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))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.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{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+		},
+		{
+			name: "ConnectionBad",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": "localhost:1",
+				"blockid":    "justified",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				blockID: "justified",
+			},
+			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+		},
+		{
+			name: "BlockIDNil",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				blockID: "head",
+			},
+		},
+		{
+			name: "BlockIDSpecific",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+				"blockid":    "justified",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				blockID: "justified",
+			},
+		},
+	}
+
+	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.res.blockID, res.blockID)
+			}
+		})
+	}
+}

cmd/block/info/output.go

@@ -0,0 +1,325 @@
+// 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 blockinfo
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"fmt"
+	"sort"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/wealdtech/go-string2eth"
+)
+
+type dataOut struct {
+	debug         bool
+	verbose       bool
+	eth2Client    eth2client.Service
+	genesisTime   time.Time
+	slotDuration  time.Duration
+	slotsPerEpoch uint64
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	return "", nil
+}
+
+func outputBlockGeneral(ctx context.Context, verbose bool, block *spec.BeaconBlock, genesisTime time.Time, slotDuration time.Duration, slotsPerEpoch uint64) (string, error) {
+	bodyRoot, err := block.Body.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate block root")
+	}
+
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("Slot: %d\n", block.Slot))
+	res.WriteString(fmt.Sprintf("Epoch: %d\n", spec.Epoch(uint64(block.Slot)/slotsPerEpoch)))
+	res.WriteString(fmt.Sprintf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(block.Slot)*int64(slotDuration.Seconds()), 0)))
+	res.WriteString(fmt.Sprintf("Block root: %#x\n", bodyRoot))
+	if verbose {
+		res.WriteString(fmt.Sprintf("Parent root: %#x\n", block.ParentRoot))
+		res.WriteString(fmt.Sprintf("State root: %#x\n", block.StateRoot))
+	}
+	if len(block.Body.Graffiti) > 0 && hex.EncodeToString(block.Body.Graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
+		if utf8.Valid(block.Body.Graffiti) {
+			res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(block.Body.Graffiti)))
+		} else {
+			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", block.Body.Graffiti))
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlockETH1Data(ctx context.Context, eth1Data *spec.ETH1Data) (string, error) {
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("Ethereum 1 deposit count: %d\n", eth1Data.DepositCount))
+	res.WriteString(fmt.Sprintf("Ethereum 1 deposit root: %#x\n", eth1Data.DepositRoot))
+	res.WriteString(fmt.Sprintf("Ethereum 1 block hash: %#x\n", eth1Data.BlockHash))
+
+	return res.String(), nil
+}
+
+func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service, verbose bool, attestations []*spec.Attestation) (string, error) {
+	res := strings.Builder{}
+
+	validatorCommittees := make(map[spec.Slot]map[spec.CommitteeIndex][]spec.ValidatorIndex)
+	res.WriteString(fmt.Sprintf("Attestations: %d\n", len(attestations)))
+	if verbose {
+		beaconCommitteesProvider, isProvider := eth2Client.(eth2client.BeaconCommitteesProvider)
+		if isProvider {
+			for i, att := range attestations {
+				res.WriteString(fmt.Sprintf("  %d:\n", i))
+
+				// Fetch committees for this epoch if not already obtained.
+				committees, exists := validatorCommittees[att.Data.Slot]
+				if !exists {
+					beaconCommittees, err := beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", att.Data.Slot))
+					if err != nil {
+						return "", errors.Wrap(err, "failed to obtain beacon committees")
+					}
+					for _, beaconCommittee := range beaconCommittees {
+						if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
+							validatorCommittees[beaconCommittee.Slot] = make(map[spec.CommitteeIndex][]spec.ValidatorIndex)
+						}
+						validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
+					}
+					committees = validatorCommittees[att.Data.Slot]
+				}
+
+				res.WriteString(fmt.Sprintf("    Committee index: %d\n", att.Data.Index))
+				res.WriteString(fmt.Sprintf("    Attesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len()))
+				res.WriteString(fmt.Sprintf("    Aggregation bits: %s\n", bitsToString(att.AggregationBits)))
+				res.WriteString(fmt.Sprintf("    Attesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.Index])))
+				res.WriteString(fmt.Sprintf("    Slot: %d\n", att.Data.Slot))
+				res.WriteString(fmt.Sprintf("    Beacon block root: %#x\n", att.Data.BeaconBlockRoot))
+				res.WriteString(fmt.Sprintf("    Source epoch: %d\n", att.Data.Source.Epoch))
+				res.WriteString(fmt.Sprintf("    Source root: %#x\n", att.Data.Source.Root))
+				res.WriteString(fmt.Sprintf("    Target epoch: %d\n", att.Data.Target.Epoch))
+				res.WriteString(fmt.Sprintf("    Target root: %#x\n", att.Data.Target.Root))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Service, verbose bool, attesterSlashings []*spec.AttesterSlashing) (string, error) {
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("Attester slashings: %d\n", len(attesterSlashings)))
+	if verbose {
+		for i, slashing := range attesterSlashings {
+			// Say what was slashed.
+			att1 := slashing.Attestation1
+			att2 := slashing.Attestation2
+			slashedIndices := intersection(att1.AttestingIndices, att2.AttestingIndices)
+			if len(slashedIndices) == 0 {
+				continue
+			}
+
+			res.WriteString(fmt.Sprintf("  %d:\n", i))
+			res.WriteString(fmt.Sprintln("    Slashed validators:"))
+			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", slashedIndices)
+			if err != nil {
+				return "", errors.Wrap(err, "failed to obtain beacon committees")
+			}
+			for k, v := range validators {
+				res.WriteString(fmt.Sprintf("      %#x (%d)\n", v.Validator.PublicKey[:], k))
+			}
+
+			// Say what caused the slashing.
+			if att1.Data.Target.Epoch == att2.Data.Target.Epoch {
+				res.WriteString(fmt.Sprintf("    Double voted for same target epoch (%d):\n", att1.Data.Target.Epoch))
+				if !bytes.Equal(att1.Data.Target.Root[:], att2.Data.Target.Root[:]) {
+					res.WriteString(fmt.Sprintf("      Attestation 1 target epoch root: %#x\n", att1.Data.Target.Root))
+					res.WriteString(fmt.Sprintf("      Attestation 2target epoch root: %#x\n", att2.Data.Target.Root))
+				}
+				if !bytes.Equal(att1.Data.BeaconBlockRoot[:], att2.Data.BeaconBlockRoot[:]) {
+					res.WriteString(fmt.Sprintf("      Attestation 1 beacon block root: %#x\n", att1.Data.BeaconBlockRoot))
+					res.WriteString(fmt.Sprintf("      Attestation 2 beacon block root: %#x\n", att2.Data.BeaconBlockRoot))
+				}
+			} else if att1.Data.Source.Epoch < att2.Data.Source.Epoch &&
+				att1.Data.Target.Epoch > att2.Data.Target.Epoch {
+				res.WriteString("    Surround voted:\n")
+				res.WriteString(fmt.Sprintf("      Attestation 1 vote: %d->%d\n", att1.Data.Source.Epoch, att1.Data.Target.Epoch))
+				res.WriteString(fmt.Sprintf("      Attestation 2 vote: %d->%d\n", att2.Data.Source.Epoch, att2.Data.Target.Epoch))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*spec.Deposit) (string, error) {
+	res := strings.Builder{}
+
+	// Deposits.
+	res.WriteString(fmt.Sprintf("Deposits: %d\n", len(deposits)))
+	if verbose {
+		for i, deposit := range deposits {
+			data := deposit.Data
+			res.WriteString(fmt.Sprintf("  %d:\n", i))
+			res.WriteString(fmt.Sprintf("    Public key: %#x\n", data.PublicKey))
+			res.WriteString(fmt.Sprintf("    Amount: %s\n", string2eth.GWeiToString(uint64(data.Amount), true)))
+			res.WriteString(fmt.Sprintf("    Withdrawal credentials: %#x\n", data.WithdrawalCredentials))
+			res.WriteString(fmt.Sprintf("    Signature: %#x\n", data.Signature))
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Service, verbose bool, voluntaryExits []*spec.SignedVoluntaryExit) (string, error) {
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("Voluntary exits: %d\n", len(voluntaryExits)))
+	if verbose {
+		for i, voluntaryExit := range voluntaryExits {
+			res.WriteString(fmt.Sprintf("  %d:\n", i))
+			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []spec.ValidatorIndex{voluntaryExit.Message.ValidatorIndex})
+			if err != nil {
+				res.WriteString(fmt.Sprintf("  Error: failed to obtain validators: %v\n", err))
+			} else {
+				res.WriteString(fmt.Sprintf("    Validator: %#x (%d)\n", validators[0].Validator.PublicKey, voluntaryExit.Message.ValidatorIndex))
+				res.WriteString(fmt.Sprintf("    Epoch: %d\n", voluntaryExit.Message.Epoch))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.SignedBeaconBlock) (string, error) {
+	if signedBlock == nil {
+		return "", errors.New("no block supplied")
+	}
+
+	body := signedBlock.Message.Body
+
+	res := strings.Builder{}
+
+	// General info.
+	tmp, err := outputBlockGeneral(ctx, data.verbose, signedBlock.Message, data.genesisTime, data.slotDuration, data.slotsPerEpoch)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Eth1 data.
+	if data.verbose {
+		tmp, err := outputBlockETH1Data(ctx, body.ETH1Data)
+		if err != nil {
+			return "", err
+		}
+		res.WriteString(tmp)
+	}
+
+	// Attestations.
+	tmp, err = outputBlockAttestations(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.Attestations)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attester slashings.
+	tmp, err = outputBlockAttesterSlashings(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.AttesterSlashings)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	res.WriteString(fmt.Sprintf("Proposer slashings: %d\n", len(body.ProposerSlashings)))
+	// Add verbose proposer slashings.
+
+	tmp, err = outputBlockDeposits(ctx, data.verbose, signedBlock.Message.Body.Deposits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Voluntary exits.
+	tmp, err = outputBlockVoluntaryExits(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.VoluntaryExits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	return res.String(), nil
+}
+
+// intersection returns a list of items common between the two sets.
+func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
+	sort.Slice(set1, func(i, j int) bool { return set1[i] < set1[j] })
+	sort.Slice(set2, func(i, j int) bool { return set2[i] < set2[j] })
+	res := make([]spec.ValidatorIndex, 0)
+
+	set1Pos := 0
+	set2Pos := 0
+	for set1Pos < len(set1) && set2Pos < len(set2) {
+		switch {
+		case set1[set1Pos] < set2[set2Pos]:
+			set1Pos++
+		case set2[set2Pos] < set1[set1Pos]:
+			set2Pos++
+		default:
+			res = append(res, spec.ValidatorIndex(set1[set1Pos]))
+			set1Pos++
+			set2Pos++
+		}
+	}
+
+	return res
+}
+
+func bitsToString(input bitfield.Bitlist) string {
+	bits := int(input.Len())
+
+	res := ""
+	for i := 0; i < bits; i++ {
+		if input.BitAt(uint64(i)) {
+			res = fmt.Sprintf("%s✓", res)
+		} else {
+			res = fmt.Sprintf("%s✕", res)
+		}
+		if i%8 == 7 {
+			res = fmt.Sprintf("%s ", res)
+		}
+	}
+	return strings.TrimSpace(res)
+}
+
+func attestingIndices(input bitfield.Bitlist, indices []spec.ValidatorIndex) string {
+	bits := int(input.Len())
+	res := ""
+	for i := 0; i < bits; i++ {
+		if input.BitAt(uint64(i)) {
+			res = fmt.Sprintf("%s%d ", res, indices[i])
+		}
+	}
+	return strings.TrimSpace(res)
+}

cmd/block/info/output_internal_test.go

@@ -0,0 +1,177 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"testing"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		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, test.res, res)
+			}
+		})
+	}
+}
+
+// func TestOutputBlockText(t *testing.T) {
+// 	tests := []struct {
+// 		name              string
+// 		dataOut           *dataOut
+// 		signedBeaconBlock *spec.SignedBeaconBlock
+// 		err               string
+// 	}{
+// 		{
+// 			name: "Nil",
+// 			err:  "no data",
+// 		},
+// 		{
+// 			name:    "Good",
+// 			dataOut: &dataOut{},
+// 		},
+// 	}
+//
+// 	for _, test := range tests {
+// 		t.Run(test.name, func(t *testing.T) {
+// 			res := outputBlockText(context.Background(), test.dataOut, test.signedBeaconBlock)
+// 			if test.err != "" {
+// 				require.EqualError(t, err, test.err)
+// 			} else {
+// 				require.NoError(t, err)
+// 				require.Equal(t, test.res, res)
+// 			}
+// 		})
+// 	}
+// }
+
+func TestOutputBlockDeposits(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataOut  *dataOut
+		verbose  bool
+		deposits []*spec.Deposit
+		res      string
+		err      string
+	}{
+		{
+			name: "Nil",
+			res:  "Deposits: 0\n",
+		},
+		{
+			name: "Empty",
+			res:  "Deposits: 0\n",
+		},
+		{
+			name: "Single",
+			deposits: []*spec.Deposit{
+				{
+					Data: &spec.DepositData{
+						PublicKey:             testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+						WithdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+						Amount:                spec.Gwei(32000000000),
+						Signature:             testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2"),
+					},
+				},
+			},
+			res: "Deposits: 1\n",
+		},
+		{
+			name: "SingleVerbose",
+			deposits: []*spec.Deposit{
+				{
+					Data: &spec.DepositData{
+						PublicKey:             testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+						WithdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+						Amount:                spec.Gwei(32000000000),
+						Signature:             testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2"),
+					},
+				},
+			},
+			verbose: true,
+			res:     "Deposits: 1\n  0:\n    Public key: 0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c\n    Amount: 32 Ether\n    Withdrawal credentials: 0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b\n    Signature: 0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2\n",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := outputBlockDeposits(context.Background(), test.verbose, test.deposits)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}
+
+func TestOutputBlockETH1Data(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataOut  *dataOut
+		verbose  bool
+		eth1Data *spec.ETH1Data
+		res      string
+		err      string
+	}{
+		{
+			name: "Good",
+			eth1Data: &spec.ETH1Data{
+				DepositRoot:  testutil.HexToRoot("0x92407b66d7daf4f30beb84820caae2cbba51add1c4648584101ff3c32151eb83"),
+				DepositCount: 109936,
+				BlockHash:    testutil.HexToBytes("0x77b03ebaf0f2835b491cbd99a7f4649a03a6e7999678603030a014a3c48b32a4"),
+			},
+			res: "Ethereum 1 deposit count: 109936\nEthereum 1 deposit root: 0x92407b66d7daf4f30beb84820caae2cbba51add1c4648584101ff3c32151eb83\nEthereum 1 block hash: 0x77b03ebaf0f2835b491cbd99a7f4649a03a6e7999678603030a014a3c48b32a4\n",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := outputBlockETH1Data(context.Background(), test.eth1Data)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/block/info/process.go

@@ -0,0 +1,107 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+var jsonOutput bool
+var results *dataOut
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	results = &dataOut{
+		debug:      data.debug,
+		verbose:    data.verbose,
+		eth2Client: data.eth2Client,
+	}
+
+	config, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
+	}
+	genesis, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to obtain genesis information")
+	}
+	results.genesisTime = genesis.GenesisTime
+	results.slotDuration = config["SECONDS_PER_SLOT"].(time.Duration)
+	results.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
+
+	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, data.blockID)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain beacon block")
+	}
+
+	if err := outputBlock(ctx, data.jsonOutput, signedBlock); err != nil {
+		return nil, errors.Wrap(err, "failed to output block")
+	}
+
+	if data.stream {
+		jsonOutput = data.jsonOutput
+		err := data.eth2Client.(eth2client.EventsProvider).Events(ctx, []string{"head"}, headEventHandler)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to start block stream")
+		}
+		<-ctx.Done()
+	}
+
+	return &dataOut{}, nil
+}
+
+func headEventHandler(event *api.Event) {
+	// Only interested in head events.
+	if event.Topic != "head" {
+		return
+	}
+
+	blockID := fmt.Sprintf("%#x", event.Data.(*api.HeadEvent).Block[:])
+	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(context.Background(), blockID)
+	if err != nil {
+		fmt.Printf("Failed to obtain block: %v\n", err)
+	}
+	if err := outputBlock(context.Background(), jsonOutput, signedBlock); err != nil {
+		fmt.Printf("Failed to display block: %v\n", err)
+	}
+}
+
+func outputBlock(ctx context.Context, jsonOutput bool, signedBlock *spec.SignedBeaconBlock) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	default:
+		data, err := outputBlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Printf("%s\n", data)
+	}
+	return nil
+}

cmd/block/info/process_internal_test.go

@@ -0,0 +1,64 @@
+// 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 blockinfo
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/attestantio/go-eth2-client/auto"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+	eth2Client, err := auto.New(context.Background(),
+		auto.WithLogLevel(zerolog.Disabled),
+		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Client",
+			dataIn: &dataIn{
+				eth2Client: eth2Client,
+			},
+			err: "failed to output block: failed to generate text: no block supplied",
+		},
+	}
+
+	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/block/info/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 blockinfo
+
+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("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/blockinfo.go

@@ -14,26 +14,13 @@
 package cmd
 
 import (
-	"bytes"
-	"encoding/hex"
 	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"time"
-	"unicode/utf8"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/ethdo/grpc"
-	string2eth "github.com/wealdtech/go-string2eth"
+	"github.com/spf13/viper"
+	blockinfo "github.com/wealdtech/ethdo/cmd/block/info"
 )
 
-var blockInfoSlot int64
-var blockInfoStream bool
-
 var blockInfoCmd = &cobra.Command{
 	Use:   "info",
 	Short: "Obtain information about a block",
@@ -42,242 +29,37 @@ var blockInfoCmd = &cobra.Command{
     ethdo block info --slot=12345
 
 In quiet mode this will return 0 if the block information is present and not skipped, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		err := connect()
-		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain block")
-
-		config, err := grpc.FetchChainConfig(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain configuration")
-		slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
-		secondsPerSlot := config["SecondsPerSlot"].(uint64)
-
-		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain genesis")
-
-		assert(blockInfoStream || blockInfoSlot != 0, "--slot or --stream is required")
-		assert(!blockInfoStream || blockInfoSlot == -1, "--slot and --stream are not supported together")
-
-		var slot uint64
-		if blockInfoSlot < 0 {
-			slot, err = grpc.FetchLatestFilledSlot(eth2GRPCConn)
-			errCheck(err, "Failed to obtain slot of latest block")
-		} else {
-			slot = uint64(blockInfoSlot)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := blockinfo.Run(cmd)
+		if err != nil {
+			return err
 		}
-		assert(slot > 0, "slot must be greater than 0")
-
-		signedBlock, err := grpc.FetchBlock(eth2GRPCConn, slot)
-		errCheck(err, "Failed to obtain block")
-		if signedBlock == nil {
-			outputIf(!quiet, "No block at that slot")
-			os.Exit(_exitFailure)
+		if viper.GetBool("quiet") {
+			return nil
 		}
-		outputBlock(signedBlock, genesisTime, secondsPerSlot, slotsPerEpoch)
-
-		if blockInfoStream {
-			stream, err := grpc.StreamBlocks(eth2GRPCConn)
-			errCheck(err, "Failed to obtain block stream")
-			for {
-				fmt.Println()
-				signedBlock, err := stream.Recv()
-				errCheck(err, "Failed to obtain block")
-				if signedBlock != nil {
-					outputBlock(signedBlock, genesisTime, secondsPerSlot, slotsPerEpoch)
-				}
-			}
+		if res != "" {
+			fmt.Println(res)
 		}
-
-		os.Exit(_exitSuccess)
+		return nil
 	},
 }
 
-func outputBlock(signedBlock *ethpb.SignedBeaconBlock, genesisTime time.Time, secondsPerSlot uint64, slotsPerEpoch uint64) {
-	block := signedBlock.Block
-	body := block.Body
-
-	// General info.
-	bodyRoot, err := ssz.HashTreeRoot(block)
-	errCheck(err, "Failed to calculate block body root")
-	fmt.Printf("Slot: %d\n", block.Slot)
-	fmt.Printf("Epoch: %d\n", block.Slot/slotsPerEpoch)
-	fmt.Printf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(block.Slot*secondsPerSlot), 0))
-	fmt.Printf("Block root: %#x\n", bodyRoot)
-	outputIf(verbose, fmt.Sprintf("Parent root: %#x", block.ParentRoot))
-	outputIf(verbose, fmt.Sprintf("State root: %#x", block.StateRoot))
-	if len(body.Graffiti) > 0 && hex.EncodeToString(body.Graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
-		if utf8.Valid(body.Graffiti) {
-			fmt.Printf("Graffiti: %s\n", string(body.Graffiti))
-		} else {
-			fmt.Printf("Graffiti: %#x\n", body.Graffiti)
-		}
-	}
-
-	// Eth1 data.
-	eth1Data := body.Eth1Data
-	outputIf(verbose, fmt.Sprintf("Ethereum 1 deposit count: %d", eth1Data.DepositCount))
-	outputIf(verbose, fmt.Sprintf("Ethereum 1 deposit root: %#x", eth1Data.DepositRoot))
-	outputIf(verbose, fmt.Sprintf("Ethereum 1 block hash: %#x", eth1Data.BlockHash))
-
-	validatorCommittees := make(map[uint64][][]uint64)
-
-	// Attestations.
-	fmt.Printf("Attestations: %d\n", len(body.Attestations))
-	if verbose {
-		for i, att := range body.Attestations {
-			fmt.Printf("\t%d:\n", i)
-
-			// Fetch committees for this epoch if not already obtained.
-			committees, exists := validatorCommittees[att.Data.Slot]
-			if !exists {
-				attestationEpoch := att.Data.Slot / slotsPerEpoch
-				epochCommittees, err := grpc.FetchValidatorCommittees(eth2GRPCConn, attestationEpoch)
-				errCheck(err, "Failed to obtain committees")
-				for k, v := range epochCommittees {
-					validatorCommittees[k] = v
-				}
-				committees = validatorCommittees[att.Data.Slot]
-			}
-
-			fmt.Printf("\t\tCommittee index: %d\n", att.Data.CommitteeIndex)
-			fmt.Printf("\t\tAttesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len())
-			fmt.Printf("\t\tAggregation bits: %s\n", bitsToString(att.AggregationBits))
-			fmt.Printf("\t\tAttesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.CommitteeIndex]))
-			fmt.Printf("\t\tSlot: %d\n", att.Data.Slot)
-			fmt.Printf("\t\tBeacon block root: %#x\n", att.Data.BeaconBlockRoot)
-			fmt.Printf("\t\tSource epoch: %d\n", att.Data.Source.Epoch)
-			fmt.Printf("\t\tSource root: %#x\n", att.Data.Source.Root)
-			fmt.Printf("\t\tTarget epoch: %d\n", att.Data.Target.Epoch)
-			fmt.Printf("\t\tTarget root: %#x\n", att.Data.Target.Root)
-		}
-	}
-
-	// Attester slashings.
-	fmt.Printf("Attester slashings: %d\n", len(body.AttesterSlashings))
-	if verbose {
-		for i, slashing := range body.AttesterSlashings {
-			// Say what was slashed.
-			att1 := slashing.Attestation_1
-			outputIf(debug, fmt.Sprintf("Attestation 1 attesting indices are %v", att1.AttestingIndices))
-			att2 := slashing.Attestation_2
-			outputIf(debug, fmt.Sprintf("Attestation 2 attesting indices are %v", att2.AttestingIndices))
-			slashedIndices := intersection(att1.AttestingIndices, att2.AttestingIndices)
-			if len(slashedIndices) == 0 {
-				continue
-			}
-
-			fmt.Printf("\t%d:\n", i)
-
-			fmt.Println("\t\tSlashed validators:")
-			for _, slashedIndex := range slashedIndices {
-				validator, err := grpc.FetchValidatorByIndex(eth2GRPCConn, slashedIndex)
-				errCheck(err, "Failed to obtain validator information")
-				fmt.Printf("\t\t\t%#x (%d)\n", validator.PublicKey, slashedIndex)
-			}
-
-			// Say what caused the slashing.
-			if att1.Data.Target.Epoch == att2.Data.Target.Epoch {
-				fmt.Printf("\t\tDouble voted for same target epoch (%d):\n", att1.Data.Target.Epoch)
-				if !bytes.Equal(att1.Data.Target.Root, att2.Data.Target.Root) {
-					fmt.Printf("\t\t\tAttestation 1 target epoch root: %#x\n", att1.Data.Target.Root)
-					fmt.Printf("\t\t\tAttestation 2target epoch root: %#x\n", att2.Data.Target.Root)
-				}
-				if !bytes.Equal(att1.Data.BeaconBlockRoot, att2.Data.BeaconBlockRoot) {
-					fmt.Printf("\t\t\tAttestation 1 beacon block root: %#x\n", att1.Data.BeaconBlockRoot)
-					fmt.Printf("\t\t\tAttestation 2 beacon block root: %#x\n", att2.Data.BeaconBlockRoot)
-				}
-			} else if att1.Data.Source.Epoch < att2.Data.Source.Epoch &&
-				att1.Data.Target.Epoch > att2.Data.Target.Epoch {
-				fmt.Printf("\t\tSurround voted:\n")
-				fmt.Printf("\t\t\tAttestation 1 vote: %d->%d\n", att1.Data.Source.Epoch, att1.Data.Target.Epoch)
-				fmt.Printf("\t\t\tAttestation 2 vote: %d->%d\n", att2.Data.Source.Epoch, att2.Data.Target.Epoch)
-			}
-		}
-	}
-
-	fmt.Printf("Proposer slashings: %d\n", len(body.ProposerSlashings))
-	// TODO verbose proposer slashings.
-
-	// Deposits.
-	fmt.Printf("Deposits: %d\n", len(body.Deposits))
-	if verbose {
-		for i, deposit := range body.Deposits {
-			data := deposit.Data
-			fmt.Printf("\t%d:\n", i)
-			fmt.Printf("\t\tPublic key: %#x\n", data.PublicKey)
-			fmt.Printf("\t\tAmount: %s\n", string2eth.GWeiToString(data.Amount, true))
-			fmt.Printf("\t\tWithdrawal credentials: %#x\n", data.WithdrawalCredentials)
-			fmt.Printf("\t\tSignature: %#x\n", data.Signature)
-		}
-	}
-
-	// Voluntary exits.
-	fmt.Printf("Voluntary exits: %d\n", len(body.VoluntaryExits))
-	if verbose {
-		for i, voluntaryExit := range body.VoluntaryExits {
-			fmt.Printf("\t%d:\n", i)
-			validator, err := grpc.FetchValidatorByIndex(eth2GRPCConn, voluntaryExit.Exit.ValidatorIndex)
-			errCheck(err, "Failed to obtain validator information")
-			fmt.Printf("\t\tValidator: %#x (%d)\n", validator.PublicKey, voluntaryExit.Exit.ValidatorIndex)
-			fmt.Printf("\t\tEpoch: %d\n", voluntaryExit.Exit.Epoch)
-		}
-	}
-}
-
-// intersection returns a list of items common between the two sets.
-func intersection(set1 []uint64, set2 []uint64) []uint64 {
-	sort.Slice(set1, func(i, j int) bool { return set1[i] < set1[j] })
-	sort.Slice(set2, func(i, j int) bool { return set2[i] < set2[j] })
-	res := make([]uint64, 0)
-
-	set1Pos := 0
-	set2Pos := 0
-	for set1Pos < len(set1) && set2Pos < len(set2) {
-		switch {
-		case set1[set1Pos] < set2[set2Pos]:
-			set1Pos++
-		case set2[set2Pos] < set1[set1Pos]:
-			set2Pos++
-		default:
-			res = append(res, set1[set1Pos])
-			set1Pos++
-			set2Pos++
-		}
-	}
-
-	return res
-}
-
-func bitsToString(input bitfield.Bitlist) string {
-	bits := int(input.Len())
-
-	res := ""
-	for i := 0; i < bits; i++ {
-		if input.BitAt(uint64(i)) {
-			res = fmt.Sprintf("%s✓", res)
-		} else {
-			res = fmt.Sprintf("%s✕", res)
-		}
-		if i%8 == 7 {
-			res = fmt.Sprintf("%s ", res)
-		}
-	}
-	return strings.TrimSpace(res)
-}
-
-func attestingIndices(input bitfield.Bitlist, indices []uint64) string {
-	bits := int(input.Len())
-	res := ""
-	for i := 0; i < bits; i++ {
-		if input.BitAt(uint64(i)) {
-			res = fmt.Sprintf("%s%d ", res, indices[i])
-		}
-	}
-	return strings.TrimSpace(res)
-}
-
 func init() {
 	blockCmd.AddCommand(blockInfoCmd)
 	blockFlags(blockInfoCmd)
-	blockInfoCmd.Flags().Int64Var(&blockInfoSlot, "slot", -1, "the latest slot with a block")
-	blockInfoCmd.Flags().BoolVar(&blockInfoStream, "stream", false, "continually stream blocks as they arrive")
+	blockInfoCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
+	blockInfoCmd.Flags().Bool("stream", false, "continually stream blocks as they arrive")
+	blockInfoCmd.Flags().Bool("json", false, "output data in JSON format")
+}
+
+func blockInfoBindings() {
+	if err := viper.BindPFlag("blockid", blockInfoCmd.Flags().Lookup("blockid")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("stream", blockInfoCmd.Flags().Lookup("stream")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", blockInfoCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
 }

cmd/chaininfo.go

@@ -14,12 +14,16 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"time"
 
+	eth2client "github.com/attestantio/go-eth2-client"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/ethdo/grpc"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 )
 
 var chainInfoCmd = &cobra.Command{
@@ -31,27 +35,31 @@ var chainInfoCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the chain information can be obtained, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		err := connect()
-		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain node")
-		config, err := grpc.FetchChainConfig(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain configuration")
+		ctx := context.Background()
 
-		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
-		errCheck(err, "Failed to obtain genesis time")
+		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
+
+		config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		errCheck(err, "Failed to obtain beacon chain specification")
+
+		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+		errCheck(err, "Failed to obtain beacon chain genesis")
 
 		if quiet {
 			os.Exit(_exitSuccess)
 		}
 
-		if genesisTime.Unix() == 0 {
+		if genesis.GenesisTime.Unix() == 0 {
 			fmt.Println("Genesis time: undefined")
 		} else {
-			fmt.Printf("Genesis time: %s\n", genesisTime.Format(time.UnixDate))
-			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesisTime.Unix()))
+			fmt.Printf("Genesis time: %s\n", genesis.GenesisTime.Format(time.UnixDate))
+			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesis.GenesisTime.Unix()))
 		}
-		outputIf(verbose, fmt.Sprintf("Genesis fork version: %0x", config["GenesisForkVersion"].([]byte)))
-		outputIf(verbose, fmt.Sprintf("Seconds per slot: %v", config["SecondsPerSlot"].(uint64)))
-		outputIf(verbose, fmt.Sprintf("Slots per epoch: %v", config["SlotsPerEpoch"].(uint64)))
+		fmt.Printf("Genesis validators root: %#x\n", genesis.GenesisValidatorsRoot)
+		fmt.Printf("Genesis fork version: %#x\n", config["GENESIS_FORK_VERSION"].([]byte))
+		fmt.Printf("Seconds per slot: %d\n", int(config["SECONDS_PER_SLOT"].(time.Duration).Seconds()))
+		fmt.Printf("Slots per epoch: %d\n", config["SLOTS_PER_EPOCH"].(uint64))
 
 		os.Exit(_exitSuccess)
 	},
@@ -62,17 +70,17 @@ func init() {
 	chainFlags(chainInfoCmd)
 }
 
-func timestampToSlot(genesis int64, timestamp int64, secondsPerSlot uint64) uint64 {
-	if timestamp < genesis {
+func timestampToSlot(genesis time.Time, timestamp time.Time, secondsPerSlot time.Duration) spec.Slot {
+	if timestamp.Unix() < genesis.Unix() {
 		return 0
 	}
-	return uint64(timestamp-genesis) / secondsPerSlot
+	return spec.Slot(uint64(timestamp.Unix()-genesis.Unix()) / uint64(secondsPerSlot.Seconds()))
 }
 
-func slotToTimestamp(genesis int64, slot uint64, secondsPerSlot uint64) int64 {
-	return genesis + int64(slot*secondsPerSlot)
+func slotToTimestamp(genesis time.Time, slot spec.Slot, slotDuration time.Duration) int64 {
+	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())
 }
 
-func epochToTimestamp(genesis int64, slot uint64, secondsPerSlot uint64, slotsPerEpoch uint64) int64 {
-	return genesis + int64(slot*secondsPerSlot*slotsPerEpoch)
+func epochToTimestamp(genesis time.Time, slot spec.Slot, slotDuration time.Duration, slotsPerEpoch uint64) int64 {
+	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())*int64(slotsPerEpoch)
 }

cmd/chainstatus.go

@@ -14,16 +14,18 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"time"
 
+	eth2client "github.com/attestantio/go-eth2-client"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/ethdo/grpc"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 )
 
-var chainStatusSlot bool
-
 var chainStatusCmd = &cobra.Command{
 	Use:   "status",
 	Short: "Obtain status about a chain",
@@ -33,70 +35,48 @@ var chainStatusCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the chain status can be obtained, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		err := connect()
-		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain node")
-		config, err := grpc.FetchChainConfig(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain configuration")
+		ctx := context.Background()
 
-		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
-		errCheck(err, "Failed to obtain genesis time")
+		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
-		info, err := grpc.FetchChainInfo(eth2GRPCConn)
-		errCheck(err, "Failed to obtain chain info")
+		config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+		errCheck(err, "Failed to obtain beacon chain specification")
 
-		if quiet {
-			os.Exit(_exitSuccess)
+		finality, err := eth2Client.(eth2client.FinalityProvider).Finality(ctx, "head")
+		errCheck(err, "Failed to obtain finality information")
+
+		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+		errCheck(err, "Failed to obtain genesis information")
+
+		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
+		curSlot := timestampToSlot(genesis.GenesisTime, time.Now(), slotDuration)
+		slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
+		curEpoch := spec.Epoch(uint64(curSlot) / slotsPerEpoch)
+		fmt.Printf("Current epoch: %d\n", curEpoch)
+		fmt.Printf("Justified epoch: %d\n", finality.Justified.Epoch)
+		if verbose {
+			distance := curEpoch - finality.Justified.Epoch
+			fmt.Printf("Justified epoch distance: %d\n", distance)
 		}
-
-		now := time.Now()
-		slot := timestampToSlot(genesisTime.Unix(), now.Unix(), config["SecondsPerSlot"].(uint64))
-		if chainStatusSlot {
-			fmt.Printf("Current slot: %d\n", slot)
-			fmt.Printf("Justified slot: %d\n", info.GetJustifiedSlot())
-			if verbose {
-				distance := slot - info.GetJustifiedSlot()
-				fmt.Printf("Justified slot distance: %d\n", distance)
-			}
-			fmt.Printf("Finalized slot: %d\n", info.GetFinalizedSlot())
-			if verbose {
-				distance := slot - info.GetFinalizedSlot()
-				fmt.Printf("Finalized slot distance: %d\n", distance)
-			}
-			if verbose {
-				fmt.Printf("Prior justified slot: %d\n", info.GetFinalizedSlot())
-				distance := slot - info.GetPreviousJustifiedSlot()
-				fmt.Printf("Prior justified slot distance: %d\n", distance)
-			}
-		} else {
-			slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
-			epoch := slot / slotsPerEpoch
-			fmt.Printf("Current epoch: %d\n", epoch)
-			fmt.Printf("Justified epoch: %d\n", info.GetJustifiedEpoch())
-			if verbose {
-				distance := (slot - info.GetJustifiedSlot()) / slotsPerEpoch
-				fmt.Printf("Justified epoch distance: %d\n", distance)
-			}
-			fmt.Printf("Finalized epoch: %d\n", info.GetFinalizedEpoch())
-			if verbose {
-				distance := (slot - info.GetFinalizedSlot()) / slotsPerEpoch
-				fmt.Printf("Finalized epoch distance: %d\n", distance)
-			}
-			if verbose {
-				fmt.Printf("Prior justified epoch: %d\n", info.GetPreviousJustifiedEpoch())
-				distance := (slot - info.GetPreviousJustifiedSlot()) / slotsPerEpoch
-				fmt.Printf("Prior justified epoch distance: %d\n", distance)
-			}
+		fmt.Printf("Finalized epoch: %d\n", finality.Finalized.Epoch)
+		if verbose {
+			distance := curEpoch - finality.Finalized.Epoch
+			fmt.Printf("Finalized epoch distance: %d\n", distance)
+		}
+		if verbose {
+			fmt.Printf("Prior justified epoch: %d\n", finality.PreviousJustified.Epoch)
+			distance := curEpoch - finality.PreviousJustified.Epoch
+			fmt.Printf("Prior justified epoch distance: %d\n", distance)
 		}
 
 		if verbose {
-			slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
-			secondsPerSlot := config["SecondsPerSlot"].(uint64)
-			epochStartSlot := (slot / slotsPerEpoch) * slotsPerEpoch
+			epochStartSlot := (uint64(curSlot) / slotsPerEpoch) * slotsPerEpoch
 			fmt.Printf("Epoch slots: %d-%d\n", epochStartSlot, epochStartSlot+slotsPerEpoch-1)
-			nextSlot := slotToTimestamp(genesisTime.Unix(), slot+1, secondsPerSlot)
-			fmt.Printf("Time until next slot: %2.1fs\n", float64(time.Until(time.Unix(nextSlot, 0)).Milliseconds())/1000)
-			nextEpoch := epochToTimestamp(genesisTime.Unix(), slot/slotsPerEpoch+1, secondsPerSlot, slotsPerEpoch)
-			fmt.Printf("Slots until next epoch: %d\n", (slot/slotsPerEpoch+1)*slotsPerEpoch-slot)
+			nextSlotTimestamp := slotToTimestamp(genesis.GenesisTime, curSlot+1, slotDuration)
+			fmt.Printf("Time until next slot: %2.1fs\n", float64(time.Until(time.Unix(nextSlotTimestamp, 0)).Milliseconds())/1000)
+			nextEpoch := epochToTimestamp(genesis.GenesisTime, spec.Slot(uint64(curSlot)/slotsPerEpoch+1), slotDuration, slotsPerEpoch)
+			fmt.Printf("Slots until next epoch: %d\n", (uint64(curSlot)/slotsPerEpoch+1)*slotsPerEpoch-uint64(curSlot))
 			fmt.Printf("Time until next epoch: %2.1fs\n", float64(time.Until(time.Unix(nextEpoch, 0)).Milliseconds())/1000)
 		}
 
@@ -107,6 +87,4 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 func init() {
 	chainCmd.AddCommand(chainStatusCmd)
 	chainFlags(chainStatusCmd)
-	chainStatusCmd.Flags().BoolVar(&chainStatusSlot, "slot", false, "Print slot-based values")
-
 }

cmd/depositverify.go

@@ -16,98 +16,105 @@ package cmd
 import (
 	"bytes"
 	"encoding/hex"
-	"encoding/json"
 	"fmt"
 	"io/ioutil"
 	"os"
 	"strings"
 
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/wealdtech/ethdo/util"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
-	util "github.com/wealdtech/go-eth2-util"
+	eth2util "github.com/wealdtech/go-eth2-util"
 	string2eth "github.com/wealdtech/go-string2eth"
 )
 
-type depositData struct {
-	Name                  string `json:"name,omitempty"`
-	Account               string `json:"account,omitempty"`
-	PublicKey             string `json:"pubkey"`
-	WithdrawalCredentials string `json:"withdrawal_credentials"`
-	Signature             string `json:"signature"`
-	DepositDataRoot       string `json:"deposit_data_root"`
-	Value                 uint64 `json:"value"`
-	Version               uint64 `json:"version"`
-}
-
 var depositVerifyData string
 var depositVerifyWithdrawalPubKey string
 var depositVerifyValidatorPubKey string
-var depositVerifyDepositValue string
+var depositVerifyDepositAmount string
+var depositVerifyForkVersion string
 
 var depositVerifyCmd = &cobra.Command{
 	Use:   "verify",
-	Short: "Verify deposit data matches requirements",
-	Long: `Verify deposit data matches requirements.  For example:
+	Short: "Verify deposit data matches the provided data",
+	Long: `Verify deposit data matches the provided input data.  For example:
 
     ethdo deposit verify --data=depositdata.json --withdrawalaccount=primary/current --value="32 Ether"
 
-The information generated can be passed to ethereal to create a deposit from the Ethereum 1 chain.
+The deposit data is compared to the supplied withdrawal account/public key, validator public key, and value to ensure they match.
 
-In quiet mode this will return 0 if the the data can be generated correctly, otherwise 1.`,
+In quiet mode this will return 0 if the the data is verified correctly, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
 		assert(depositVerifyData != "", "--data is required")
-		deposits, err := depositDataFromJSON(depositVerifyData)
+		var data []byte
+		var err error
+		// Input could be JSON or a path to JSON.
+		switch {
+		case strings.HasPrefix(depositVerifyData, "0x"):
+			// Looks like raw binary.
+			data = []byte(depositVerifyData)
+		case strings.HasPrefix(depositVerifyData, "{"):
+			// Looks like JSON.
+			data = []byte("[" + depositVerifyData + "]")
+		case strings.HasPrefix(depositVerifyData, "["):
+			// Looks like JSON array.
+			data = []byte(depositVerifyData)
+		default:
+			// Assume it's a path to JSON.
+			data, err = ioutil.ReadFile(depositVerifyData)
+			errCheck(err, "Failed to read deposit data file")
+			if data[0] == '{' {
+				data = []byte("[" + string(data) + "]")
+			}
+		}
+
+		deposits, err := util.DepositInfoFromJSON(data)
 		errCheck(err, "Failed to fetch deposit data")
 
-		withdrawalCredentials := ""
+		var withdrawalCredentials []byte
 		if depositVerifyWithdrawalPubKey != "" {
 			withdrawalPubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(depositVerifyWithdrawalPubKey, "0x"))
 			errCheck(err, "Invalid withdrawal public key")
 			assert(len(withdrawalPubKeyBytes) == 48, "Public key should be 48 bytes")
 			withdrawalPubKey, err := e2types.BLSPublicKeyFromBytes(withdrawalPubKeyBytes)
 			errCheck(err, "Value supplied with --withdrawalpubkey is not a valid public key")
-			withdrawalBytes := util.SHA256(withdrawalPubKey.Marshal())
-			withdrawalBytes[0] = 0 // BLS_WITHDRAWAL_PREFIX
-			withdrawalCredentials = fmt.Sprintf("%x", withdrawalBytes)
+			withdrawalCredentials = eth2util.SHA256(withdrawalPubKey.Marshal())
+			withdrawalCredentials[0] = 0 // BLS_WITHDRAWAL_PREFIX
 		}
-		outputIf(debug, fmt.Sprintf("Withdrawal credentials are %s", withdrawalCredentials))
+		outputIf(debug, fmt.Sprintf("Withdrawal credentials are %#x", withdrawalCredentials))
 
-		depositValue := uint64(0)
-		if depositVerifyDepositValue != "" {
-			depositValue, err = string2eth.StringToGWei(depositVerifyDepositValue)
+		depositAmount := uint64(0)
+		if depositVerifyDepositAmount != "" {
+			depositAmount, err = string2eth.StringToGWei(depositVerifyDepositAmount)
 			errCheck(err, "Invalid value")
-			// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
-			assert(depositValue >= 1000000000, "deposit value must be at least 1 Ether") // MIN_DEPOSIT_AMOUNT
+			assert(depositAmount >= 1000000000, "deposit amount must be at least 1 Ether") // MIN_DEPOSIT_AMOUNT
 		}
 
-		validatorPubKeys := make(map[string]bool)
+		validatorPubKeys := make(map[[48]byte]bool)
 		if depositVerifyValidatorPubKey != "" {
 			validatorPubKeys, err = validatorPubKeysFromInput(depositVerifyValidatorPubKey)
 			errCheck(err, "Failed to obtain validator public key(s))")
 		}
 
 		failures := false
-		for i, deposit := range deposits {
-			if withdrawalCredentials != "" {
-				if deposit.WithdrawalCredentials != withdrawalCredentials {
-					outputIf(!quiet, fmt.Sprintf("Invalid withdrawal credentials for deposit %d", i))
-					failures = true
-				}
+		for _, deposit := range deposits {
+			if deposit.Amount == 0 {
+				deposit.Amount = depositAmount
 			}
-			if depositValue != 0 {
-				if deposit.Value != depositValue {
-					outputIf(!quiet, fmt.Sprintf("Invalid deposit value for deposit %d", i))
-					failures = true
-				}
+			verified, err := verifyDeposit(deposit, withdrawalCredentials, validatorPubKeys, depositAmount)
+			errCheck(err, fmt.Sprintf("Error attempting to verify deposit %q", deposit.Name))
+			depositName := deposit.Name
+			if depositName == "" {
+				depositName = "Deposit"
 			}
-			if len(validatorPubKeys) != 0 {
-				if _, exists := validatorPubKeys[deposit.PublicKey]; !exists {
-					outputIf(!quiet, fmt.Sprintf("Unknown validator public key for deposit %d", i))
-					failures = true
-				}
+			if !verified {
+				failures = true
+				outputIf(!quiet, fmt.Sprintf("%s failed verification", depositName))
+			} else {
+				outputIf(!quiet, fmt.Sprintf("%s verified", depositName))
 			}
-			outputIf(!quiet, fmt.Sprintf("Deposit %q verified", deposit.Name))
 		}
 
 		if failures {
@@ -117,8 +124,8 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 	},
 }
 
-func validatorPubKeysFromInput(input string) (map[string]bool, error) {
-	pubKeys := make(map[string]bool)
+func validatorPubKeysFromInput(input string) (map[[48]byte]bool, error) {
+	pubKeys := make(map[[48]byte]bool)
 	var err error
 	var data []byte
 	// Input could be a public key or a path to public keys.
@@ -135,14 +142,16 @@ func validatorPubKeysFromInput(input string) (map[string]bool, error) {
 		if err != nil {
 			return nil, errors.Wrap(err, "invalid public key")
 		}
-		pubKeys[fmt.Sprintf("%x", pubKey.Marshal())] = true
+		var key [48]byte
+		copy(key[:], pubKey.Marshal())
+		pubKeys[key] = true
 	} else {
 		// Assume it's a path to a file of public keys.
 		data, err = ioutil.ReadFile(input)
 		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")
 		}
@@ -161,68 +170,92 @@ func validatorPubKeysFromInput(input string) (map[string]bool, error) {
 			if err != nil {
 				return nil, errors.Wrap(err, "invalid public key")
 			}
-			pubKeys[fmt.Sprintf("%x", pubKey.Marshal())] = true
+			var key [48]byte
+			copy(key[:], pubKey.Marshal())
+			pubKeys[key] = true
 		}
 	}
 
 	return pubKeys, nil
 }
 
-func depositDataFromJSON(input string) ([]*depositData, error) {
-	var err error
-	var data []byte
-	// Input could be JSON or a path to JSON
-	switch {
-	case strings.HasPrefix(input, "{"):
-		// Looks like JSON
-		data = []byte("[" + input + "]")
-	case strings.HasPrefix(input, "["):
-		// Looks like JSON array
-		data = []byte(input)
-	default:
-		// Assume it's a path to JSON
-		data, err = ioutil.ReadFile(input)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to find deposit data file")
-		}
-		if data[0] == '{' {
-			data = []byte("[" + string(data) + "]")
+func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, validatorPubKeys map[[48]byte]bool, amount uint64) (bool, error) {
+	if withdrawalCredentials == nil {
+		outputIf(!quiet, "Withdrawal public key not supplied; withdrawal credentials NOT checked")
+	} else {
+		if !bytes.Equal(deposit.WithdrawalCredentials, withdrawalCredentials) {
+			outputIf(!quiet, "Withdrawal public key incorrect")
+			return false, nil
 		}
+		outputIf(!quiet, "Withdrawal credentials verified")
 	}
-	var depositData []*depositData
-	err = json.Unmarshal(data, &depositData)
+	if amount == 0 {
+		outputIf(!quiet, "Amount not supplied; NOT checked")
+	} else {
+		if deposit.Amount != amount {
+			outputIf(!quiet, "Amount incorrect")
+			return false, nil
+		}
+		outputIf(!quiet, "Amount verified")
+	}
+
+	if len(validatorPubKeys) == 0 {
+		outputIf(!quiet, "Validator public key not suppled; NOT checked")
+	} else {
+		var key [48]byte
+		copy(key[:], deposit.PublicKey)
+		if _, exists := validatorPubKeys[key]; !exists {
+			outputIf(!quiet, "Validator public key incorrect")
+			return false, nil
+		}
+		outputIf(!quiet, "Validator public key verified")
+	}
+
+	var pubKey spec.BLSPubKey
+	copy(pubKey[:], deposit.PublicKey)
+	var signature spec.BLSSignature
+	copy(signature[:], deposit.Signature)
+
+	depositData := &spec.DepositData{
+		PublicKey:             pubKey,
+		WithdrawalCredentials: deposit.WithdrawalCredentials,
+		Amount:                spec.Gwei(deposit.Amount),
+		Signature:             signature,
+	}
+	depositDataRoot, err := depositData.HashTreeRoot()
 	if err != nil {
-		return nil, errors.Wrap(err, "data is not valid JSON")
+		return false, errors.Wrap(err, "failed to generate deposit data root")
 	}
-	if len(depositData) == 0 {
-		return nil, errors.New("no deposits supplied")
+
+	if bytes.Equal(deposit.DepositDataRoot, depositDataRoot[:]) {
+		outputIf(!quiet, "Deposit data root verified")
+	} else {
+		outputIf(!quiet, "Deposit data root incorrect")
+		return false, nil
 	}
-	minVersion := depositData[0].Version
-	maxVersion := depositData[0].Version
-	for i := range depositData {
-		if depositData[i].PublicKey == "" {
-			return nil, fmt.Errorf("no public key for deposit %d", i)
+
+	if len(deposit.ForkVersion) == 0 {
+		if depositVerifyForkVersion != "" {
+			outputIf(!quiet, "Data format does not contain fork version for verification; NOT verified")
 		}
-		if depositData[i].DepositDataRoot == "" {
-			return nil, fmt.Errorf("no data root for deposit %d", i)
-		}
-		if depositData[i].Signature == "" {
-			return nil, fmt.Errorf("no signature for deposit %d", i)
-		}
-		if depositData[i].WithdrawalCredentials == "" {
-			return nil, fmt.Errorf("no withdrawal credentials for deposit %d", i)
-		}
-		if depositData[i].Value < 1000000000 {
-			return nil, fmt.Errorf("Deposit amount too small for deposit %d", i)
-		}
-		if depositData[i].Version > maxVersion {
-			maxVersion = depositData[i].Version
-		}
-		if depositData[i].Version < minVersion {
-			minVersion = depositData[i].Version
+	} else {
+		if depositVerifyForkVersion == "" {
+			outputIf(!quiet, "fork version not supplied; NOT checked")
+		} else {
+			forkVersion, err := hex.DecodeString(strings.TrimPrefix(depositVerifyForkVersion, "0x"))
+			if err != nil {
+				return false, errors.Wrap(err, "failed to decode fork version")
+			}
+			if bytes.Equal(deposit.ForkVersion, forkVersion[:]) {
+				outputIf(!quiet, "Fork version verified")
+			} else {
+				outputIf(!quiet, "Fork version incorrect")
+				return false, nil
+			}
 		}
 	}
-	return depositData, nil
+
+	return true, nil
 }
 
 func init() {
@@ -230,6 +263,7 @@ func init() {
 	depositFlags(depositVerifyCmd)
 	depositVerifyCmd.Flags().StringVar(&depositVerifyData, "data", "", "JSON data, or path to JSON data")
 	depositVerifyCmd.Flags().StringVar(&depositVerifyWithdrawalPubKey, "withdrawalpubkey", "", "Public key of the account to which the validator funds will be withdrawn")
-	depositVerifyCmd.Flags().StringVar(&depositVerifyDepositValue, "depositvalue", "", "Value of the amount to be deposited")
+	depositVerifyCmd.Flags().StringVar(&depositVerifyDepositAmount, "depositvalue", "32 Ether", "Value of the amount to be deposited")
 	depositVerifyCmd.Flags().StringVar(&depositVerifyValidatorPubKey, "validatorpubkey", "", "Public key(s) of the account(s) that will be carrying out validation")
+	depositVerifyCmd.Flags().StringVar(&depositVerifyForkVersion, "forkversion", "0x00000000", "Fork version of the chain of the deposit")
 }

cmd/exit.go

@@ -0,0 +1,32 @@
+// Copyright © 2019 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 cmd
+
+import (
+	"github.com/spf13/cobra"
+)
+
+// exitCmd represents the exit command
+var exitCmd = &cobra.Command{
+	Use:   "exit",
+	Short: "Manage Ethereum 2 voluntary exits",
+	Long:  `Manage Ethereum 2 voluntary exits.`,
+}
+
+func init() {
+	RootCmd.AddCommand(exitCmd)
+}
+
+func exitFlags(cmd *cobra.Command) {
+}

cmd/exitverify.go

@@ -0,0 +1,145 @@
+// 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 cmd
+
+import (
+	"bytes"
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+var exitVerifyPubKey string
+
+var exitVerifyCmd = &cobra.Command{
+	Use:   "verify",
+	Short: "Verify exit data is valid",
+	Long: `Verify that exit data generated by "ethdo validator exit" is correct for a given account.  For example:
+
+    ethdo exit verify --data=exitdata.json --account=primary/current
+
+In quiet mode this will return 0 if the the exit is verified correctly, otherwise 1.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		ctx := context.Background()
+
+		assert(viper.GetString("account") != "" || exitVerifyPubKey != "", "account or public key is required")
+		account, err := exitVerifyAccount(ctx)
+		errCheck(err, "Failed to obtain account")
+
+		assert(viper.GetString("exit") != "", "exit is required")
+		data, err := obtainExitData(viper.GetString("exit"))
+		errCheck(err, "Failed to obtain exit data")
+
+		// Confirm signature is good.
+		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
+
+		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+		errCheck(err, "Failed to obtain beacon chain genesis")
+
+		domain := e2types.Domain(e2types.DomainVoluntaryExit, data.ForkVersion[:], genesis.GenesisValidatorsRoot[:])
+		var exitDomain spec.Domain
+		copy(exitDomain[:], domain)
+		exit := &spec.VoluntaryExit{
+			Epoch:          data.Exit.Message.Epoch,
+			ValidatorIndex: data.Exit.Message.ValidatorIndex,
+		}
+		exitRoot, err := exit.HashTreeRoot()
+		errCheck(err, "Failed to obtain exit hash tree root")
+		sig, err := e2types.BLSSignatureFromBytes(data.Exit.Signature[:])
+		errCheck(err, "Invalid signature")
+		verified, err := util.VerifyRoot(account, exitRoot, exitDomain, sig)
+		errCheck(err, "Failed to verify voluntary exit")
+		assert(verified, "Voluntary exit failed to verify")
+
+		fork, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
+		errCheck(err, "Failed to obtain current fork")
+		assert(bytes.Equal(data.ForkVersion[:], fork.CurrentVersion[:]) || bytes.Equal(data.ForkVersion[:], fork.PreviousVersion[:]), "Exit is for an old fork version and is no longer valid")
+
+		outputIf(verbose, "Verified")
+		os.Exit(_exitSuccess)
+	},
+}
+
+// obtainExitData obtains exit data from an input, could be JSON itself or a path to JSON.
+func obtainExitData(input string) (*util.ValidatorExitData, error) {
+	var err error
+	var data []byte
+	// Input could be JSON or a path to JSON
+	if strings.HasPrefix(input, "{") {
+		// Looks like JSON
+		data = []byte(input)
+	} else {
+		// Assume it's a path to JSON
+		data, err = ioutil.ReadFile(input)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to find deposit data file")
+		}
+	}
+	exitData := &util.ValidatorExitData{}
+	err = json.Unmarshal(data, exitData)
+	if err != nil {
+		return nil, errors.Wrap(err, "data is not valid JSON")
+	}
+
+	return exitData, nil
+}
+
+// exitVerifyAccount obtains the account for the exitVerify command.
+func exitVerifyAccount(ctx context.Context) (e2wtypes.Account, error) {
+	var account e2wtypes.Account
+	var err error
+	if viper.GetString("account") != "" {
+		_, account, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain account")
+		}
+	} else {
+		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(exitVerifyPubKey, "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", exitVerifyPubKey))
+		}
+		account, err = util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", exitVerifyPubKey))
+		}
+	}
+	return account, nil
+}
+
+func init() {
+	exitCmd.AddCommand(exitVerifyCmd)
+	exitFlags(exitVerifyCmd)
+	exitVerifyCmd.Flags().String("exit", "", "JSON data, or path to JSON data")
+	exitVerifyCmd.Flags().StringVar(&exitVerifyPubKey, "pubkey", "", "Public key for which to verify exit")
+}
+
+func exitVerifyBindings() {
+	if err := viper.BindPFlag("exit", exitVerifyCmd.Flags().Lookup("exit")); err != nil {
+		panic(err)
+	}
+}

cmd/networks.go

@@ -1,47 +0,0 @@
-// 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 cmd
-
-import (
-	"fmt"
-
-	"github.com/wealdtech/ethdo/grpc"
-)
-
-// networks is a map of deposit contract addresses to networks.
-var networks = map[string]string{
-	"16e82d77882a663454ef92806b7deca1d394810f": "Altona",
-	"0f0f0fc0530007361933eab5db97d09acdd6c1c8": "Onyx",
-	"07b39f4fde4a38bace212b546dac87c58dfe3fdc": "Medalla",
-}
-
-// network returns the name of the network, if known.
-func network() string {
-	if err := connect(); err != nil {
-		return "Unknown"
-	}
-
-	depositContractAddress, err := grpc.FetchDepositContractAddress(eth2GRPCConn)
-	if err != nil {
-		return "Unknown"
-	}
-	outputIf(debug, fmt.Sprintf("Deposit contract is %x", depositContractAddress))
-
-	depositContract := fmt.Sprintf("%x", depositContractAddress)
-	if network, exists := networks[depositContract]; exists {
-		return network
-	} else {
-		return "Unknown"
-	}
-}

cmd/nodeinfo.go

@@ -14,12 +14,14 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
-	"time"
 
+	eth2client "github.com/attestantio/go-eth2-client"
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/ethdo/grpc"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 )
 
 var nodeInfoCmd = &cobra.Command{
@@ -31,38 +33,24 @@ var nodeInfoCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the node information can be obtained, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		err := connect()
-		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain node")
-		config, err := grpc.FetchChainConfig(eth2GRPCConn)
-		errCheck(err, "Failed to obtain beacon chain configuration")
+		ctx := context.Background()
 
-		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
-		errCheck(err, "Failed to obtain genesis time")
+		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
 		if quiet {
 			os.Exit(_exitSuccess)
 		}
 
 		if verbose {
-			version, metadata, err := grpc.FetchVersion(eth2GRPCConn)
-			errCheck(err, "Failed to obtain version")
+			version, err := eth2Client.(eth2client.NodeVersionProvider).NodeVersion(ctx)
+			errCheck(err, "Failed to obtain node version")
 			fmt.Printf("Version: %s\n", version)
-			if metadata != "" {
-				fmt.Printf("Metadata: %s\n", metadata)
-			}
 		}
-		syncing, err := grpc.FetchSyncing(eth2GRPCConn)
-		errCheck(err, "Failed to obtain syncing state")
-		fmt.Printf("Syncing: %v\n", syncing)
 
-		if genesisTime.Unix() == 0 {
-			fmt.Println("Not reached genesis")
-		} else {
-			slot := timestampToSlot(genesisTime.Unix(), time.Now().Unix(), config["SecondsPerSlot"].(uint64))
-			fmt.Printf("Current slot: %d\n", slot)
-			fmt.Printf("Current epoch: %d\n", slot/config["SlotsPerEpoch"].(uint64))
-			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesisTime.Unix()))
-		}
+		syncState, err := eth2Client.(eth2client.NodeSyncingProvider).NodeSyncing(ctx)
+		errCheck(err, "failed to obtain node sync state")
+		fmt.Printf("Syncing: %t\n", syncState.SyncDistance != 0)
 
 		os.Exit(_exitSuccess)
 	},

cmd/passphrases.go

@@ -13,12 +13,9 @@
 
 package cmd
 
-import "github.com/spf13/viper"
-
-// getStorePassphrases() fetches the store passphrase supplied by the user.
-func getStorePassphrase() string {
-	return viper.GetString("store-passphrase")
-}
+import (
+	"github.com/spf13/viper"
+)
 
 // getWalletPassphrases() fetches the wallet passphrase supplied by the user.
 func getWalletPassphrase() string {
@@ -29,11 +26,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]
-}

cmd/root.go

@@ -17,8 +17,6 @@ import (
 	"context"
 	"fmt"
 	"os"
-	"regexp"
-	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -27,13 +25,11 @@ import (
 	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	dirk "github.com/wealdtech/go-eth2-wallet-dirk"
-	filesystem "github.com/wealdtech/go-eth2-wallet-store-filesystem"
-	s3 "github.com/wealdtech/go-eth2-wallet-store-s3"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
-	"google.golang.org/grpc"
 )
 
 var cfgFile string
@@ -41,42 +37,56 @@ var quiet bool
 var verbose bool
 var debug bool
 
-// Root variables, present for all commands.
-var rootStore string
-
-// Store for wallet actions.
-var store e2wtypes.Store
-
-// Remote connection.
-var remote bool
-
-// Prysm connection.
-var eth2GRPCConn *grpc.ClientConn
-
 // RootCmd represents the base command when called without any subcommands
 var RootCmd = &cobra.Command{
-	Use:              "ethdo",
-	Short:            "Ethereum 2 CLI",
-	Long:             `Manage common Ethereum 2 tasks from the command line.`,
-	PersistentPreRun: persistentPreRun,
+	Use:               "ethdo",
+	Short:             "Ethereum 2 CLI",
+	Long:              `Manage common Ethereum 2 tasks from the command line.`,
+	PersistentPreRunE: persistentPreRunE,
 }
 
-func persistentPreRun(cmd *cobra.Command, args []string) {
+func persistentPreRunE(cmd *cobra.Command, args []string) error {
 	if cmd.Name() == "help" {
 		// User just wants help
-		return
+		return nil
 	}
 
 	if cmd.Name() == "version" {
 		// User just wants the version
-		return
+		return nil
 	}
 
-	// We bind viper here so that we bind to the correct command
+	// We bind viper here so that we bind to the correct command.
 	quiet = viper.GetBool("quiet")
 	verbose = viper.GetBool("verbose")
 	debug = viper.GetBool("debug")
-	rootStore = viper.GetString("store")
+	// Command-specific bindings.
+	switch fmt.Sprintf("%s/%s", cmd.Parent().Name(), cmd.Name()) {
+	case "account/create":
+		accountCreateBindings()
+	case "account/derive":
+		accountDeriveBindings()
+	case "account/import":
+		accountImportBindings()
+	case "attester/inclusion":
+		attesterInclusionBindings()
+	case "block/info":
+		blockInfoBindings()
+	case "exit/verify":
+		exitVerifyBindings()
+	case "validator/depositdata":
+		validatorDepositdataBindings()
+	case "validator/duties":
+		validatorDutiesBindings()
+	case "validator/exit":
+		validatorExitBindings()
+	case "validator/info":
+		validatorInfoBindings()
+	case "wallet/create":
+		walletCreateBindings()
+	case "wallet/import":
+		walletImportBindings()
+	}
 
 	if quiet && verbose {
 		fmt.Println("Cannot supply both quiet and verbose flags")
@@ -85,31 +95,11 @@ func persistentPreRun(cmd *cobra.Command, args []string) {
 		fmt.Println("Cannot supply both quiet and debug flags")
 	}
 
-	if viper.GetString("remote") == "" {
-		// Set up our wallet store
-		switch rootStore {
-		case "s3":
-			assert(viper.GetString("base-dir") == "", "--basedir does not apply for the s3 store")
-			var err error
-			store, err = s3.New(s3.WithPassphrase([]byte(getStorePassphrase())))
-			errCheck(err, "Failed to access Amazon S3 wallet store")
-		case "filesystem":
-			opts := make([]filesystem.Option, 0)
-			if getStorePassphrase() != "" {
-				opts = append(opts, filesystem.WithPassphrase([]byte(getStorePassphrase())))
-			}
-			if viper.GetString("base-dir") != "" {
-				opts = append(opts, filesystem.WithLocation(viper.GetString("base-dir")))
-			}
-			store = filesystem.New(opts...)
-		default:
-			die(fmt.Sprintf("Unsupported wallet store %s", rootStore))
-		}
-		err := e2wallet.UseStore(store)
-		errCheck(err, "Failed to use defined wallet store")
-	} else {
-		remote = true
+	if err := util.SetupStore(); err != nil {
+		return err
 	}
+
+	return nil
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -144,15 +134,36 @@ func init() {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().String("basedir", "", "Base directory for filesystem wallets")
-	if err := viper.BindPFlag("base-dir", RootCmd.PersistentFlags().Lookup("basedir")); err != nil {
+	if err := viper.BindPFlag("basedir", RootCmd.PersistentFlags().Lookup("basedir")); err != nil {
+		panic(err)
+	}
+	if err := RootCmd.PersistentFlags().MarkDeprecated("basedir", "use --base-dir"); err != nil {
+		panic(err)
+	}
+	RootCmd.PersistentFlags().String("base-dir", "", "Base directory for filesystem wallets")
+	if err := viper.BindPFlag("base-dir", RootCmd.PersistentFlags().Lookup("base-dir")); err != nil {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().String("storepassphrase", "", "Passphrase for store (if applicable)")
-	if err := viper.BindPFlag("store-passphrase", RootCmd.PersistentFlags().Lookup("storepassphrase")); err != nil {
+	if err := viper.BindPFlag("storepassphrase", RootCmd.PersistentFlags().Lookup("storepassphrase")); err != nil {
+		panic(err)
+	}
+	if err := RootCmd.PersistentFlags().MarkDeprecated("storepassphrase", "use --store-passphrase"); err != nil {
+		panic(err)
+	}
+	RootCmd.PersistentFlags().String("store-passphrase", "", "Passphrase for store (if applicable)")
+	if err := viper.BindPFlag("store-passphrase", RootCmd.PersistentFlags().Lookup("store-passphrase")); err != nil {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().String("walletpassphrase", "", "Passphrase for wallet (if applicable)")
-	if err := viper.BindPFlag("wallet-passphrase", RootCmd.PersistentFlags().Lookup("walletpassphrase")); err != nil {
+	if err := viper.BindPFlag("walletpassphrase", RootCmd.PersistentFlags().Lookup("walletpassphrase")); err != nil {
+		panic(err)
+	}
+	if err := RootCmd.PersistentFlags().MarkDeprecated("walletpassphrase", "use --wallet-passphrase"); err != nil {
+		panic(err)
+	}
+	RootCmd.PersistentFlags().String("wallet-passphrase", "", "Passphrase for wallet (if applicable)")
+	if err := viper.BindPFlag("wallet-passphrase", RootCmd.PersistentFlags().Lookup("wallet-passphrase")); err != nil {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().StringSlice("passphrase", nil, "Passphrase for account (if applicable)")
@@ -171,7 +182,7 @@ func init() {
 	if err := viper.BindPFlag("debug", RootCmd.PersistentFlags().Lookup("debug")); err != nil {
 		panic(err)
 	}
-	RootCmd.PersistentFlags().String("connection", "localhost:4000", "connection to Ethereum 2 node via GRPC")
+	RootCmd.PersistentFlags().String("connection", "localhost:4000", "connection to an Ethereum 2 node")
 	if err := viper.BindPFlag("connection", RootCmd.PersistentFlags().Lookup("connection")); err != nil {
 		panic(err)
 	}
@@ -195,6 +206,14 @@ func init() {
 	if err := viper.BindPFlag("server-ca-cert", RootCmd.PersistentFlags().Lookup("server-ca-cert")); err != nil {
 		panic(err)
 	}
+	RootCmd.PersistentFlags().Bool("allow-weak-passphrases", false, "allow passphrases that use common words, are short, or generally considered weak")
+	if err := viper.BindPFlag("allow-weak-passphrases", RootCmd.PersistentFlags().Lookup("allow-weak-passphrases")); err != nil {
+		panic(err)
+	}
+	RootCmd.PersistentFlags().Bool("allow-insecure-connections", false, "allow insecure connections to remote beacon nodes")
+	if err := viper.BindPFlag("allow-insecure-connections", RootCmd.PersistentFlags().Lookup("allow-insecure-connections")); err != nil {
+		panic(err)
+	}
 }
 
 // initConfig reads in config file and ENV variables if set.
@@ -233,12 +252,36 @@ func outputIf(condition bool, msg string) {
 	}
 }
 
+// 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") != "" {
+		return walletFromPath(ctx, viper.GetString("account"))
+	}
+	return walletFromPath(ctx, viper.GetString("wallet"))
+}
+
 // walletFromPath obtains a wallet given a path specification.
-func walletFromPath(path string) (e2wtypes.Wallet, error) {
+func walletFromPath(ctx context.Context, path string) (e2wtypes.Wallet, error) {
 	walletName, _, err := e2wallet.WalletAndAccountNames(path)
 	if err != nil {
 		return nil, err
 	}
+	if viper.GetString("remote") != "" {
+		assert(viper.GetString("client-cert") != "", "remote connections require client-cert")
+		assert(viper.GetString("client-key") != "", "remote connections require client-key")
+		credentials, err := dirk.ComposeCredentials(ctx, viper.GetString("client-cert"), viper.GetString("client-key"), viper.GetString("server-ca-cert"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to build dirk credentials")
+		}
+
+		endpoints, err := remotesToEndpoints([]string{viper.GetString("remote")})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to parse remote servers")
+		}
+
+		return dirk.OpenWallet(ctx, walletName, credentials, endpoints)
+	}
 	wallet, err := e2wallet.OpenWallet(walletName)
 	if err != nil {
 		if strings.Contains(err.Error(), "failed to decrypt wallet") {
@@ -249,18 +292,23 @@ func walletFromPath(path string) (e2wtypes.Wallet, error) {
 	return wallet, nil
 }
 
-// accountFromPath obtains an account given a path specification.
-func accountFromPath(ctx context.Context, path string) (e2wtypes.Account, error) {
-	wallet, err := walletFromPath(path)
+// walletAndAccountFromInput obtains the wallet and account given the information in the viper variable "account".
+func walletAndAccountFromInput(ctx context.Context) (e2wtypes.Wallet, e2wtypes.Account, error) {
+	return walletAndAccountFromPath(ctx, viper.GetString("account"))
+}
+
+// walletAndAccountFromPath obtains the wallet and account given a path specification.
+func walletAndAccountFromPath(ctx context.Context, path string) (e2wtypes.Wallet, e2wtypes.Account, error) {
+	wallet, err := walletFromPath(ctx, path)
 	if err != nil {
-		return nil, err
+		return nil, nil, errors.Wrap(err, "faild to open wallet for account")
 	}
 	_, accountName, err := e2wallet.WalletAndAccountNames(path)
 	if err != nil {
-		return nil, err
+		return nil, nil, errors.Wrap(err, "failed to obtain accout name")
 	}
 	if accountName == "" {
-		return nil, errors.New("no account name")
+		return nil, nil, errors.New("no account name")
 	}
 
 	if wallet.Type() == "hierarchical deterministic" && strings.HasPrefix(accountName, "m/") {
@@ -268,9 +316,9 @@ func accountFromPath(ctx context.Context, path string) (e2wtypes.Account, error)
 
 		locker, isLocker := wallet.(e2wtypes.WalletLocker)
 		if isLocker {
-			err = locker.Unlock(ctx, []byte(viper.GetString("wallet-passphrase")))
+			err = locker.Unlock(ctx, []byte(util.GetWalletPassphrase()))
 			if err != nil {
-				return nil, errors.New("invalid wallet passphrase")
+				return nil, nil, errors.New("failed to unlock wallet")
 			}
 			defer relockAccount(locker)
 		}
@@ -278,60 +326,13 @@ func accountFromPath(ctx context.Context, path string) (e2wtypes.Account, error)
 
 	accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
 	if !isAccountByNameProvider {
-		return nil, errors.New("wallet cannot obtain accounts by name")
+		return nil, nil, errors.New("wallet cannot obtain accounts by name")
 	}
-	return accountByNameProvider.AccountByName(ctx, accountName)
-}
-
-// accountsFromPath obtains 0 or more accounts given a path specification.
-func accountsFromPath(ctx context.Context, wallet e2wtypes.Wallet, accountSpec string) ([]e2wtypes.Account, error) {
-	accounts := make([]e2wtypes.Account, 0)
-
-	if accountSpec == "" {
-		accountSpec = "^.*$"
-	} else {
-		accountSpec = fmt.Sprintf("^%s$", accountSpec)
+	account, err := accountByNameProvider.AccountByName(ctx, accountName)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to obtain account")
 	}
-	re := regexp.MustCompile(accountSpec)
-
-	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 accounts, nil
-}
-
-// connect connects to an Ethereum 2 endpoint.
-func connect() error {
-	if eth2GRPCConn != nil {
-		// Already connected.
-		return nil
-	}
-
-	connection := ""
-	if viper.GetString("connection") != "" {
-		connection = viper.GetString("connection")
-	}
-
-	if connection == "" {
-		return errors.New("no connection")
-	}
-	outputIf(debug, fmt.Sprintf("Connecting to %s", connection))
-
-	opts := []grpc.DialOption{grpc.WithInsecure()}
-
-	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-	defer cancel()
-	var err error
-	eth2GRPCConn, err = grpc.DialContext(ctx, connection, opts...)
-	return err
+	return wallet, account, nil
 }
 
 // bestPublicKey returns the best public key for operations.
@@ -369,46 +370,6 @@ func remotesToEndpoints(remotes []string) ([]*dirk.Endpoint, error) {
 	return endpoints, nil
 }
 
-// Oepn a wallet, local or remote.
-func openWallet() (e2wtypes.Wallet, error) {
-	var err error
-	// Obtain the name of the wallet.
-	walletName := viper.GetString("wallet")
-	if walletName == "" {
-		walletName, _, err = e2wallet.WalletAndAccountNames(viper.GetString("account"))
-	}
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain wallet name")
-	}
-	if walletName == "" {
-		return nil, errors.New("no wallet name provided")
-	}
-
-	return openNamedWallet(walletName)
-}
-
-// Open a named wallet, local or remote.
-func openNamedWallet(walletName string) (e2wtypes.Wallet, error) {
-	if viper.GetString("remote") != "" {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-		assert(viper.GetString("client-cert") != "", "remote connections require client-cert")
-		assert(viper.GetString("client-key") != "", "remote connections require client-key")
-		credentials, err := dirk.ComposeCredentials(ctx, viper.GetString("client-cert"), viper.GetString("client-key"), viper.GetString("server-ca-cert"))
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to build dirk credentials")
-		}
-
-		endpoints, err := remotesToEndpoints([]string{viper.GetString("remote")})
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to parse remote servers")
-		}
-
-		return dirk.OpenWallet(ctx, walletName, credentials, endpoints)
-	}
-	return walletFromPath(walletName)
-}
-
 // relockAccount locks an account; generally called as a defer after an account is unlocked.
 func relockAccount(locker e2wtypes.AccountLocker) {
 	errCheck(locker.Lock(context.Background()), "failed to re-lock account")

cmd/signaturesign.go

@@ -18,12 +18,12 @@ import (
 	"fmt"
 	"os"
 
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 	"github.com/wealdtech/go-bytesutil"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 // signatureSignCmd represents the signature sign command
@@ -53,22 +53,14 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 		outputIf(debug, fmt.Sprintf("Domain is %#x", domain))
 
 		assert(viper.GetString("account") != "", "--account is required")
-
-		wallet, err := openWallet()
-		errCheck(err, "Failed to access wallet")
-
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		errCheck(err, "Failed to obtain account name")
-
-		accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		assert(isAccountByNameProvider, "wallet does not support obtaining accounts by name")
-
-		account, err := accountByNameProvider.AccountByName(ctx, accountName)
+		_, account, err := walletAndAccountFromInput(ctx)
 		errCheck(err, "Failed to obtain account")
 
+		var specDomain spec.Domain
+		copy(specDomain[:], domain)
 		var fixedSizeData [32]byte
 		copy(fixedSizeData[:], data)
-		signature, err := signRoot(account, fixedSizeData, domain)
+		signature, err := util.SignRoot(account, fixedSizeData, specDomain)
 		errCheck(err, "Failed to sign")
 
 		outputIf(!quiet, fmt.Sprintf("%#x", signature.Marshal()))

cmd/signatureverify.go

@@ -15,15 +15,18 @@ package cmd
 
 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"os"
+	"strings"
 
-	"github.com/prysmaticlabs/go-ssz"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 	"github.com/wealdtech/go-bytesutil"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -58,49 +61,46 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 			assert(len(domain) == 32, "Domain data invalid")
 		}
 
-		var pubKey e2types.PublicKey
-		assert(signatureVerifySigner != "" || viper.GetString("account") != "", "Either --signer or --account should be supplied")
-		if viper.GetString("account") != "" {
-			wallet, err := openWallet()
-			errCheck(err, "Failed to access wallet")
-			_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-			errCheck(err, "Failed to obtain account name")
+		account, err := signatureVerifyAccount()
+		errCheck(err, "Failed to obtain account")
+		outputIf(debug, fmt.Sprintf("Public key is %#x", account.PublicKey().Marshal()))
 
-			accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-			assert(isAccountByNameProvider, "wallet cannot obtain accounts by name")
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			account, err := accountByNameProvider.AccountByName(ctx, accountName)
-			errCheck(err, "Failed to obtain account")
-			pubKey, err = bestPublicKey(account)
-			errCheck(err, "Failed to obtain account's public key")
-		} else {
-			pubKeyBytes, err := bytesutil.FromHexString(signatureVerifySigner)
-			errCheck(err, "Invalid public key")
-			pubKey, err = e2types.BLSPublicKeyFromBytes(pubKeyBytes)
-			errCheck(err, "Invalid public key")
-		}
-		outputIf(debug, fmt.Sprintf("Public key is %#x", pubKey.Marshal()))
-		container := &signingContainer{
-			Root:   data,
-			Domain: domain,
-		}
-		outputIf(debug, fmt.Sprintf("Data root is %#x", data))
-		outputIf(debug, fmt.Sprintf("Domain is %#x", domain))
-		root, err := ssz.HashTreeRoot(container)
-		errCheck(err, "Failed to create signing root")
-		outputIf(debug, fmt.Sprintf("Signing root is %#x", root))
+		var specDomain spec.Domain
+		copy(specDomain[:], domain)
+		var root [32]byte
+		copy(root[:], data)
+		verified, err := util.VerifyRoot(account, root, specDomain, signature)
+		errCheck(err, "Failed to verify data")
+		assert(verified, "Failed to verify")
 
-		verified := signature.Verify(root[:], pubKey)
-		if !verified {
-			outputIf(!quiet, "Not verified")
-			os.Exit(_exitFailure)
-		}
-		outputIf(!quiet, "Verified")
+		outputIf(verbose, "Verified")
 		os.Exit(_exitSuccess)
 	},
 }
 
+// signatureVerifyAccount obtains the account for the signature verify command.
+func signatureVerifyAccount() (e2wtypes.Account, error) {
+	var account e2wtypes.Account
+	var err error
+	if viper.GetString("account") != "" {
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+		_, account, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain account")
+		}
+	} else {
+		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(signatureVerifySigner, "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", signatureVerifySigner))
+		}
+		account, err = util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", signatureVerifySigner))
+		}
+	}
+	return account, nil
+}
 func init() {
 	signatureCmd.AddCommand(signatureVerifyCmd)
 	signatureFlags(signatureVerifyCmd)

cmd/validator/depositdata/input.go

@@ -0,0 +1,145 @@
+// 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 depositdata
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	ethdoutil "github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	util "github.com/wealdtech/go-eth2-util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	string2eth "github.com/wealdtech/go-string2eth"
+)
+
+type dataIn struct {
+	format                string
+	withdrawalCredentials []byte
+	amount                spec.Gwei
+	validatorAccounts     []e2wtypes.Account
+	forkVersion           *spec.Version
+	domain                *spec.Domain
+	passphrases           []string
+}
+
+func input() (*dataIn, error) {
+	var err error
+	data := &dataIn{
+		forkVersion: &spec.Version{},
+		domain:      &spec.Domain{},
+	}
+
+	if viper.GetString("validatoraccount") == "" {
+		return nil, errors.New("validator account is required")
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+	_, data.validatorAccounts, err = ethdoutil.WalletAndAccountsFromPath(ctx, viper.GetString("validatoraccount"))
+	if err != nil {
+		return nil, errors.New("failed to obtain validator account")
+	}
+	if len(data.validatorAccounts) == 0 {
+		return nil, errors.New("unknown validator account")
+	}
+
+	switch {
+	case viper.GetBool("launchpad"):
+		data.format = "launchpad"
+	case viper.GetBool("raw"):
+		data.format = "raw"
+	default:
+		data.format = "json"
+	}
+
+	data.passphrases = ethdoutil.GetPassphrases()
+
+	switch {
+	case viper.GetString("withdrawalaccount") != "":
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+		_, withdrawalAccount, err := ethdoutil.WalletAndAccountFromPath(ctx, viper.GetString("withdrawalaccount"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain withdrawal account")
+		}
+		pubKey, err := ethdoutil.BestPublicKey(withdrawalAccount)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain public key for withdrawal account")
+		}
+		data.withdrawalCredentials = util.SHA256(pubKey.Marshal())
+	case viper.GetString("withdrawalpubkey") != "":
+		withdrawalPubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(viper.GetString("withdrawalpubkey"), "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to decode withdrawal public key")
+		}
+		if len(withdrawalPubKeyBytes) != 48 {
+			return nil, errors.New("withdrawal public key must be exactly 48 bytes in length")
+		}
+		withdrawalPubKey, err := e2types.BLSPublicKeyFromBytes(withdrawalPubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, "withdrawal public key is not valid")
+		}
+		data.withdrawalCredentials = util.SHA256(withdrawalPubKey.Marshal())
+	default:
+		return nil, errors.New("withdrawalaccount or withdrawal public key is required")
+	}
+	// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
+	data.withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
+
+	if viper.GetString("depositvalue") == "" {
+		return nil, errors.New("deposit value is required")
+	}
+	amount, err := string2eth.StringToGWei(viper.GetString("depositvalue"))
+	if err != nil {
+		return nil, errors.Wrap(err, "deposit value is invalid")
+	}
+	data.amount = spec.Gwei(amount)
+	// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
+	if data.amount < 1000000000 { // MIN_DEPOSIT_AMOUNT
+		return nil, errors.New("deposit value must be at least 1 Ether")
+	}
+
+	data.forkVersion, err = inputForkVersion(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain fork version")
+	}
+
+	copy(data.domain[:], e2types.Domain(e2types.DomainDeposit, data.forkVersion[:], e2types.ZeroGenesisValidatorsRoot))
+
+	return data, nil
+}
+
+func inputForkVersion(ctx context.Context) (*spec.Version, error) {
+	// Default to mainnet.
+	forkVersion := &spec.Version{0x00, 0x00, 0x00, 0x00}
+
+	// Override if supplied.
+	if viper.GetString("forkversion") != "" {
+		data, err := hex.DecodeString(strings.TrimPrefix(viper.GetString("forkversion"), "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to decode fork version")
+		}
+		if len(forkVersion) != 4 {
+			return nil, errors.New("fork version must be exactly 4 bytes in length")
+		}
+
+		copy(forkVersion[:], data)
+	}
+	return forkVersion, nil
+}

cmd/validator/depositdata/input_internal_test.go

@@ -0,0 +1,272 @@
+// 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 depositdata
+
+import (
+	"context"
+	"testing"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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", store, 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",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 1",
+		testutil.HexToBytes("0x51d0b65185db6989ab0b560d6deed19c7ead0e24b9b6372cbecb1f26bdfad000"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	var mainnetForkVersion *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x00000000")
+		mainnetForkVersion = &tmp
+	}
+	var mainnetDomain *spec.Domain
+	{
+		tmp := testutil.HexToDomain("0x03000000f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a9")
+		mainnetDomain = &tmp
+	}
+
+	var forkVersion *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x01020304")
+		forkVersion = &tmp
+	}
+	var domain *spec.Domain
+	{
+		tmp := testutil.HexToDomain("0x03000000ffd2fc34e5796a643f749b0b2b908c4ca3ce58ce24a00c49329a2dc0")
+		domain = &tmp
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "Nil",
+			err:  "validator account is required",
+		},
+		{
+			name: "ValidatorAccountMissing",
+			vars: map[string]interface{}{
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "32 Ether",
+				"forkversion":       "0x01020304",
+			},
+			err: "validator account is required",
+		},
+		{
+			name: "ValidatorAccountUnknown",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Unknown",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "32 Ether",
+				"forkversion":       "0x01020304",
+			},
+			err: "unknown validator account",
+		},
+		{
+			name: "WithdrawalAccountMissing",
+			vars: map[string]interface{}{
+				"launchpad":        true,
+				"validatoraccount": "Test/Interop 0",
+				"depositvalue":     "32 Ether",
+				"forkversion":      "0x01020304",
+			},
+			err: "withdrawalaccount or withdrawal public key is required",
+		},
+		{
+			name: "WithdrawalAccountUnknown",
+			vars: map[string]interface{}{
+				"raw":               true,
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Unknown",
+				"depositvalue":      "32 Ether",
+				"forkversion":       "0x01020304",
+			},
+			err: "failed to obtain withdrawal account: failed to obtain account: no account with name \"Unknown\"",
+		},
+		{
+			name: "WithdrawalPubKeyInvalid",
+			vars: map[string]interface{}{
+				"validatoraccount": "Test/Interop 0",
+				"withdrawalpubkey": "invalid",
+				"depositvalue":     "32 Ether",
+				"forkversion":      "0x01020304",
+			},
+			err: "failed to decode withdrawal public key: encoding/hex: invalid byte: U+0069 'i'",
+		},
+		{
+			name: "WithdrawalPubKeyWrongLength",
+			vars: map[string]interface{}{
+				"validatoraccount": "Test/Interop 0",
+				"withdrawalpubkey": "0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0bff",
+				"depositvalue":     "32 Ether",
+				"forkversion":      "0x01020304",
+			},
+			err: "withdrawal public key must be exactly 48 bytes in length",
+		},
+		{
+			name: "WithdrawalPubKeyNotPubKey",
+			vars: map[string]interface{}{
+				"validatoraccount": "Test/Interop 0",
+				"withdrawalpubkey": "0x089bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b",
+				"depositvalue":     "32 Ether",
+				"forkversion":      "0x01020304",
+			},
+			err: "withdrawal public key is not valid: failed to deserialize public key: err blsPublicKeyDeserialize 089bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b",
+		},
+		{
+			name: "DepositValueMissing",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"forkversion":       "0x01020304",
+			},
+			err: "deposit value is required",
+		},
+		{
+			name: "DepositValueTooSmall",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "1000 Wei",
+				"forkversion":       "0x01020304",
+			},
+			err: "deposit value must be at least 1 Ether",
+		},
+		{
+			name: "DepositValueInvalid",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "1 groat",
+				"forkversion":       "0x01020304",
+			},
+			err: "deposit value is invalid: failed to parse unit of 1 groat",
+		},
+		{
+			name: "ForkVersionInvalid",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "32 Ether",
+				"forkversion":       "invalid",
+			},
+			err: "failed to obtain fork version: failed to decode fork version: encoding/hex: invalid byte: U+0069 'i'",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "32 Ether",
+			},
+			res: &dataIn{
+				format:                "json",
+				withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+				amount:                32000000000,
+				validatorAccounts:     []e2wtypes.Account{interop0},
+				forkVersion:           mainnetForkVersion,
+				domain:                mainnetDomain,
+			},
+		},
+		{
+			name: "GoodForkVersionOverride",
+			vars: map[string]interface{}{
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "32 Ether",
+				"forkversion":       "0x01020304",
+			},
+			res: &dataIn{
+				format:                "json",
+				withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+				amount:                32000000000,
+				validatorAccounts:     []e2wtypes.Account{interop0},
+				forkVersion:           forkVersion,
+				domain:                domain,
+			},
+		},
+		{
+			name: "GoodWithdrawalPubKey",
+			vars: map[string]interface{}{
+				"validatoraccount": "Test/Interop 0",
+				"withdrawalpubkey": "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+				"depositvalue":     "32 Ether",
+				"forkversion":      "0x01020304",
+			},
+			res: &dataIn{
+				format:                "json",
+				withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+				amount:                32000000000,
+				validatorAccounts:     []e2wtypes.Account{interop0},
+				forkVersion:           forkVersion,
+				domain:                domain,
+			},
+		},
+	}
+
+	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()
+			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.format, res.format)
+				require.Equal(t, test.res.withdrawalCredentials, res.withdrawalCredentials)
+				require.Equal(t, test.res.amount, res.amount)
+				require.Equal(t, test.res.forkVersion, res.forkVersion)
+				require.Equal(t, test.res.domain, res.domain)
+				require.Equal(t, len(test.res.validatorAccounts), len(res.validatorAccounts))
+				for i := range test.res.validatorAccounts {
+					require.Equal(t, test.res.validatorAccounts[i].ID(), res.validatorAccounts[i].ID())
+				}
+			}
+		})
+	}
+}

cmd/validator/depositdata/output.go

@@ -0,0 +1,188 @@
+// 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 depositdata
+
+import (
+	"fmt"
+	"strings"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	format                string
+	account               string
+	validatorPubKey       *spec.BLSPubKey
+	withdrawalCredentials []byte
+	amount                spec.Gwei
+	signature             *spec.BLSSignature
+	forkVersion           *spec.Version
+	depositDataRoot       *spec.Root
+	depositMessageRoot    *spec.Root
+}
+
+func output(data []*dataOut) (string, error) {
+	outputs := make([]string, 0)
+	for _, datum := range data {
+		if datum == nil {
+			continue
+		}
+		var output string
+		var err error
+		switch datum.format {
+		case "raw":
+			output, err = validatorDepositDataOutputRaw(datum)
+		case "launchpad":
+			output, err = validatorDepositDataOutputLaunchpad(datum)
+		default:
+			output, err = validatorDepositDataOutputJSON(datum)
+		}
+		if err != nil {
+			return "", err
+		}
+		outputs = append(outputs, output)
+	}
+	return fmt.Sprintf("[%s]", strings.Join(outputs, ",")), nil
+}
+
+func validatorDepositDataOutputRaw(datum *dataOut) (string, error) {
+	if datum.validatorPubKey == nil {
+		return "", errors.New("validator public key required")
+	}
+	if len(datum.withdrawalCredentials) != 32 {
+		return "", errors.New("withdrawal credentials must be 32 bytes")
+	}
+	if datum.amount == 0 {
+		return "", errors.New("missing amount")
+	}
+	if datum.signature == nil {
+		return "", errors.New("signature required")
+	}
+	if datum.depositDataRoot == nil {
+		return "", errors.New("deposit data root required")
+	}
+
+	output := fmt.Sprintf(
+		`"`+
+			// Function signature.
+			"0x22895118"+
+			// Pointer to validator public key.
+			"0000000000000000000000000000000000000000000000000000000000000080"+
+			// Pointer to withdrawal credentials.
+			"00000000000000000000000000000000000000000000000000000000000000e0"+
+			// Pointer to validator signature.
+			"0000000000000000000000000000000000000000000000000000000000000120"+
+			// Deposit data root.
+			"%x"+
+			// Validator public key (padded).
+			"0000000000000000000000000000000000000000000000000000000000000030"+
+			"%x00000000000000000000000000000000"+
+			// Withdrawal credentials.
+			"0000000000000000000000000000000000000000000000000000000000000020"+
+			"%x"+
+			// Deposit signature.
+			"0000000000000000000000000000000000000000000000000000000000000060"+
+			"%x"+
+			`"`,
+		*datum.depositDataRoot,
+		*datum.validatorPubKey,
+		datum.withdrawalCredentials,
+		*datum.signature,
+	)
+	return output, nil
+}
+
+func validatorDepositDataOutputLaunchpad(datum *dataOut) (string, error) {
+	// Map of fork version to network name.
+	forkVersionMap := map[spec.Version]string{
+		[4]byte{0x00, 0x00, 0x00, 0x00}: "mainnet",
+		[4]byte{0x00, 0x00, 0x20, 0x09}: "pyrmont",
+	}
+
+	if datum.validatorPubKey == nil {
+		return "", errors.New("validator public key required")
+	}
+	if len(datum.withdrawalCredentials) != 32 {
+		return "", errors.New("withdrawal credentials must be 32 bytes")
+	}
+	if datum.amount == 0 {
+		return "", errors.New("missing amount")
+	}
+	if datum.signature == nil {
+		return "", errors.New("signature required")
+	}
+	if datum.depositMessageRoot == nil {
+		return "", errors.New("deposit message root required")
+	}
+	if datum.depositDataRoot == nil {
+		return "", errors.New("deposit data root required")
+	}
+
+	networkName := "unknown"
+	if network, exists := forkVersionMap[*datum.forkVersion]; exists {
+		networkName = network
+	}
+	output := fmt.Sprintf(`{"pubkey":"%x","withdrawal_credentials":"%x","amount":%d,"signature":"%x","deposit_message_root":"%x","deposit_data_root":"%x","fork_version":"%x","eth2_network_name":"%s","deposit_cli_version":"1.1.0"}`,
+		*datum.validatorPubKey,
+		datum.withdrawalCredentials,
+		datum.amount,
+		*datum.signature,
+		*datum.depositMessageRoot,
+		*datum.depositDataRoot,
+		*datum.forkVersion,
+		networkName,
+	)
+	return output, nil
+}
+
+func validatorDepositDataOutputJSON(datum *dataOut) (string, error) {
+	if datum.account == "" {
+		return "", errors.New("missing account")
+	}
+	if datum.validatorPubKey == nil {
+		return "", errors.New("validator public key required")
+	}
+	if len(datum.withdrawalCredentials) != 32 {
+		return "", errors.New("withdrawal credentials must be 32 bytes")
+	}
+	if datum.signature == nil {
+		return "", errors.New("signature required")
+	}
+	if datum.amount == 0 {
+		return "", errors.New("missing amount")
+	}
+	if datum.depositDataRoot == nil {
+		return "", errors.New("deposit data root required")
+	}
+	if datum.depositDataRoot == nil {
+		return "", errors.New("deposit message root required")
+	}
+	if datum.forkVersion == nil {
+		return "", errors.New("fork version required")
+	}
+
+	output := fmt.Sprintf(`{"name":"Deposit for %s","account":"%s","pubkey":"%#x","withdrawal_credentials":"%#x","signature":"%#x","amount":%d,"deposit_data_root":"%#x","deposit_message_root":"%#x","fork_version":"%#x","version":3}`,
+		datum.account,
+		datum.account,
+		*datum.validatorPubKey,
+		datum.withdrawalCredentials,
+		*datum.signature,
+		datum.amount,
+		*datum.depositDataRoot,
+		*datum.depositMessageRoot,
+		*datum.forkVersion,
+	)
+	return output, nil
+}

cmd/validator/depositdata/output_internal_test.go

@@ -0,0 +1,669 @@
+// 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 depositdata
+
+import (
+	"testing"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+)
+
+func TestOutputJSON(t *testing.T) {
+	var validatorPubKey *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c")
+		validatorPubKey = &tmp
+	}
+	var signature *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2")
+		signature = &tmp
+	}
+	var forkVersion *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x01020304")
+		forkVersion = &tmp
+	}
+	var depositDataRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554")
+		depositDataRoot = &tmp
+	}
+	var depositMessageRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6")
+		depositMessageRoot = &tmp
+	}
+
+	var validatorPubKey2 *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b")
+		validatorPubKey2 = &tmp
+	}
+	var signature2 *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0x911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e")
+		signature2 = &tmp
+	}
+	var depositDataRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x3b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab")
+		depositDataRoot2 = &tmp
+	}
+	var depositMessageRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0xbb4b6184b25873cdf430df3838c8d3e3d16cf3dc3b214e2f3ab7df9e6d5a9b52")
+		depositMessageRoot2 = &tmp
+	}
+
+	tests := []struct {
+		name    string
+		dataOut []*dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			res:  "[]",
+		},
+		{
+			name: "NilDatum",
+			dataOut: []*dataOut{
+				nil,
+			},
+			res: "[]",
+		},
+		{
+			name: "AccountMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "missing account",
+		},
+		{
+			name: "MissingValidatorPubKey",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					account:               "interop/00000",
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "validator public key required",
+		},
+		{
+			name: "MissingWithdrawalCredentials",
+			dataOut: []*dataOut{
+				{
+					format:             "json",
+					account:            "interop/00000",
+					validatorPubKey:    validatorPubKey,
+					amount:             32000000000,
+					signature:          signature,
+					forkVersion:        forkVersion,
+					depositDataRoot:    depositDataRoot,
+					depositMessageRoot: depositMessageRoot,
+				},
+			},
+			err: "withdrawal credentials must be 32 bytes",
+		},
+		{
+			name: "SignatureMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "signature required",
+		},
+		{
+			name: "AmountMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "missing amount",
+		},
+		{
+			name: "DepositDataRootMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "deposit data root required",
+		},
+		{
+			name: "Single",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			res: `[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","amount":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","fork_version":"0x01020304","version":3}]`,
+		},
+		{
+			name: "Double",
+			dataOut: []*dataOut{
+				{
+					format:                "json",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+				{
+					format:                "json",
+					account:               "interop/00001",
+					validatorPubKey:       validatorPubKey2,
+					withdrawalCredentials: testutil.HexToBytes("0x00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594"),
+					amount:                32000000000,
+					signature:             signature2,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot2,
+					depositMessageRoot:    depositMessageRoot2,
+				},
+			},
+			res: `[{"name":"Deposit for interop/00000","account":"interop/00000","pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","signature":"0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","amount":32000000000,"deposit_data_root":"0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","deposit_message_root":"0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","fork_version":"0x01020304","version":3},{"name":"Deposit for interop/00001","account":"interop/00001","pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","withdrawal_credentials":"0x00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594","signature":"0x911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e","amount":32000000000,"deposit_data_root":"0x3b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab","deposit_message_root":"0xbb4b6184b25873cdf430df3838c8d3e3d16cf3dc3b214e2f3ab7df9e6d5a9b52","fork_version":"0x01020304","version":3}]`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}
+
+func TestOutputLaunchpad(t *testing.T) {
+	var validatorPubKey *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c")
+		validatorPubKey = &tmp
+	}
+	var signature *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2")
+		signature = &tmp
+	}
+	var forkVersion *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x00002009")
+		forkVersion = &tmp
+	}
+	var depositDataRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554")
+		depositDataRoot = &tmp
+	}
+	var depositMessageRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6")
+		depositMessageRoot = &tmp
+	}
+
+	var validatorPubKey2 *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b")
+		validatorPubKey2 = &tmp
+	}
+	var signature2 *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0x911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e")
+		signature2 = &tmp
+	}
+	var depositDataRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x3b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab")
+		depositDataRoot2 = &tmp
+	}
+	var depositMessageRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0xbb4b6184b25873cdf430df3838c8d3e3d16cf3dc3b214e2f3ab7df9e6d5a9b52")
+		depositMessageRoot2 = &tmp
+	}
+
+	tests := []struct {
+		name    string
+		dataOut []*dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			res:  "[]",
+		},
+		{
+			name: "NilDatum",
+			dataOut: []*dataOut{
+				nil,
+			},
+			res: "[]",
+		},
+		{
+			name: "MissingValidatorPubKey",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "validator public key required",
+		},
+		{
+			name: "MissingWithdrawalCredentials",
+			dataOut: []*dataOut{
+				{
+					format:             "launchpad",
+					account:            "interop/00000",
+					validatorPubKey:    validatorPubKey,
+					amount:             32000000000,
+					signature:          signature,
+					forkVersion:        forkVersion,
+					depositDataRoot:    depositDataRoot,
+					depositMessageRoot: depositMessageRoot,
+				},
+			},
+			err: "withdrawal credentials must be 32 bytes",
+		},
+		{
+			name: "SignatureMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "signature required",
+		},
+		{
+			name: "AmountMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "missing amount",
+		},
+		{
+			name: "DepositDataRootMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "deposit data root required",
+		},
+		{
+			name: "DepositMessageRootMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+				},
+			},
+			err: "deposit message root required",
+		},
+		{
+			name: "Single",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			res: `[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"00002009","eth2_network_name":"pyrmont","deposit_cli_version":"1.1.0"}]`,
+		},
+		{
+			name: "Double",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+				{
+					format:                "launchpad",
+					account:               "interop/00001",
+					validatorPubKey:       validatorPubKey2,
+					withdrawalCredentials: testutil.HexToBytes("0x00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594"),
+					amount:                32000000000,
+					signature:             signature2,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot2,
+					depositMessageRoot:    depositMessageRoot2,
+				},
+			},
+			res: `[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"00002009","eth2_network_name":"pyrmont","deposit_cli_version":"1.1.0"},{"pubkey":"b89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","withdrawal_credentials":"00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594","amount":32000000000,"signature":"911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e","deposit_message_root":"bb4b6184b25873cdf430df3838c8d3e3d16cf3dc3b214e2f3ab7df9e6d5a9b52","deposit_data_root":"3b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab","fork_version":"00002009","eth2_network_name":"pyrmont","deposit_cli_version":"1.1.0"}]`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}
+
+func TestOutputRaw(t *testing.T) {
+	var validatorPubKey *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c")
+		validatorPubKey = &tmp
+	}
+	var signature *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2")
+		signature = &tmp
+	}
+	var forkVersion *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x01020304")
+		forkVersion = &tmp
+	}
+	var depositDataRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554")
+		depositDataRoot = &tmp
+	}
+	var depositMessageRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6")
+		depositMessageRoot = &tmp
+	}
+
+	var validatorPubKey2 *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b")
+		validatorPubKey2 = &tmp
+	}
+	var signature2 *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0x911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e")
+		signature2 = &tmp
+	}
+	var depositDataRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x3b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab")
+		depositDataRoot2 = &tmp
+	}
+	var depositMessageRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0xbb4b6184b25873cdf430df3838c8d3e3d16cf3dc3b214e2f3ab7df9e6d5a9b52")
+		depositMessageRoot2 = &tmp
+	}
+
+	tests := []struct {
+		name    string
+		dataOut []*dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			res:  "[]",
+		},
+		{
+			name: "NilDatum",
+			dataOut: []*dataOut{
+				nil,
+			},
+			res: "[]",
+		},
+		{
+			name: "MissingValidatorPubKey",
+			dataOut: []*dataOut{
+				{
+					format:                "raw",
+					account:               "interop/00000",
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "validator public key required",
+		},
+		{
+			name: "MissingWithdrawalCredentials",
+			dataOut: []*dataOut{
+				{
+					format:             "raw",
+					account:            "interop/00000",
+					validatorPubKey:    validatorPubKey,
+					amount:             32000000000,
+					signature:          signature,
+					forkVersion:        forkVersion,
+					depositDataRoot:    depositDataRoot,
+					depositMessageRoot: depositMessageRoot,
+				},
+			},
+			err: "withdrawal credentials must be 32 bytes",
+		},
+		{
+			name: "SignatureMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "raw",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "signature required",
+		},
+		{
+			name: "AmountMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "raw",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "missing amount",
+		},
+		{
+			name: "DepositDataRootMissing",
+			dataOut: []*dataOut{
+				{
+					format:                "raw",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			err: "deposit data root required",
+		},
+		{
+			name: "Single",
+			dataOut: []*dataOut{
+				{
+					format:                "raw",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			res: `["0x22895118000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001209e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a35540000000000000000000000000000000000000000000000000000000000000030a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b0000000000000000000000000000000000000000000000000000000000000060b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2"]`,
+		},
+		{
+			name: "Double",
+			dataOut: []*dataOut{
+				{
+					format:                "raw",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+				{
+					format:                "raw",
+					account:               "interop/00001",
+					validatorPubKey:       validatorPubKey2,
+					withdrawalCredentials: testutil.HexToBytes("0x00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594"),
+					amount:                32000000000,
+					signature:             signature2,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot2,
+					depositMessageRoot:    depositMessageRoot2,
+				},
+			},
+			res: `["0x22895118000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001209e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a35540000000000000000000000000000000000000000000000000000000000000030a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b0000000000000000000000000000000000000000000000000000000000000060b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","0x22895118000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001203b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab0000000000000000000000000000000000000000000000000000000000000030b89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000002000ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f35940000000000000000000000000000000000000000000000000000000000000060911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e"]`,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/validator/depositdata/process.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 depositdata
+
+import (
+	"context"
+	"fmt"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/signing"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func process(data *dataIn) ([]*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	results := make([]*dataOut, 0)
+
+	for _, validatorAccount := range data.validatorAccounts {
+		validatorPubKey, err := util.BestPublicKey(validatorAccount)
+		if err != nil {
+			return nil, errors.Wrap(err, "validator account does not provide a public key")
+		}
+
+		var pubKey spec.BLSPubKey
+		copy(pubKey[:], validatorPubKey.Marshal())
+		depositMessage := &spec.DepositMessage{
+			PublicKey:             pubKey,
+			WithdrawalCredentials: data.withdrawalCredentials,
+			Amount:                data.amount,
+		}
+		root, err := depositMessage.HashTreeRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to generate deposit message root")
+		}
+		var depositMessageRoot spec.Root
+		copy(depositMessageRoot[:], root[:])
+
+		sig, err := signing.SignRoot(context.Background(), validatorAccount, data.passphrases, depositMessageRoot, *data.domain)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to sign deposit message")
+		}
+
+		depositData := &spec.DepositData{
+			PublicKey:             pubKey,
+			WithdrawalCredentials: data.withdrawalCredentials,
+			Amount:                data.amount,
+			Signature:             sig,
+		}
+
+		root, err = depositData.HashTreeRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to generate deposit data root")
+		}
+		var depositDataRoot spec.Root
+		copy(depositDataRoot[:], root[:])
+
+		validatorWallet := validatorAccount.(e2wtypes.AccountWalletProvider).Wallet()
+		results = append(results, &dataOut{
+			format:                data.format,
+			account:               fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()),
+			validatorPubKey:       &pubKey,
+			withdrawalCredentials: data.withdrawalCredentials,
+			amount:                data.amount,
+			signature:             &sig,
+			forkVersion:           data.forkVersion,
+			depositMessageRoot:    &depositMessageRoot,
+			depositDataRoot:       &depositDataRoot,
+		})
+	}
+	return results, nil
+}

cmd/validator/depositdata/process_internal_test.go

@@ -0,0 +1,188 @@
+// Copyright © 2019, 2020 eald 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 depositdata
+
+import (
+	"context"
+	"testing"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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())
+
+	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",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+	interop1, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 1",
+		testutil.HexToBytes("0x51d0b65185db6989ab0b560d6deed19c7ead0e24b9b6372cbecb1f26bdfad000"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	var validatorPubKey *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c")
+		validatorPubKey = &tmp
+	}
+	var signature *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2")
+		signature = &tmp
+	}
+	var forkVersion *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x01020304")
+		forkVersion = &tmp
+	}
+	var domain *spec.Domain
+	{
+		tmp := testutil.HexToDomain("0x03000000ffd2fc34e5796a643f749b0b2b908c4ca3ce58ce24a00c49329a2dc0")
+		domain = &tmp
+	}
+	var depositDataRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554")
+		depositDataRoot = &tmp
+	}
+	var depositMessageRoot *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6")
+		depositMessageRoot = &tmp
+	}
+
+	var validatorPubKey2 *spec.BLSPubKey
+	{
+		tmp := testutil.HexToPubKey("0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b")
+		validatorPubKey2 = &tmp
+	}
+	var signature2 *spec.BLSSignature
+	{
+		tmp := testutil.HexToSignature("0x939aedb76236c971c21227189c6a3a40d07909d19999798490294d284130a913b6f91d41d875768fb3e2ea4dcec672a316e5951272378f5df80a7c34fadb9a4d8462ee817faf50fe8b1c33e72d884fb17e71e665724f9e17bdf11f48eb6e9bfd")
+		signature2 = &tmp
+	}
+	var depositDataRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x182c7708aad7027bea2f6251eddf62431fae4876ee3e55339082219ae7014443")
+		depositDataRoot2 = &tmp
+	}
+	var depositMessageRoot2 *spec.Root
+	{
+		tmp := testutil.HexToRoot("0x1dc5053486d74f5c91fa90e1e86d718d3fb42bb92e5cfdce98e994eb2bff2c46")
+		depositMessageRoot2 = &tmp
+	}
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		res    []*dataOut
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Single",
+			dataIn: &dataIn{
+				format:                "raw",
+				passphrases:           []string{"pass"},
+				withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+				amount:                32000000000,
+				validatorAccounts:     []e2wtypes.Account{interop0},
+				forkVersion:           forkVersion,
+				domain:                domain,
+			},
+			res: []*dataOut{
+				{
+					format:                "raw",
+					account:               "Test/Interop 0",
+					validatorPubKey:       validatorPubKey,
+					amount:                32000000000,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+		},
+		{
+			name: "Double",
+			dataIn: &dataIn{
+				format:                "raw",
+				passphrases:           []string{"pass"},
+				withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+				amount:                32000000000,
+				validatorAccounts:     []e2wtypes.Account{interop0, interop1},
+				forkVersion:           forkVersion,
+				domain:                domain,
+			},
+			res: []*dataOut{
+				{
+					format:                "raw",
+					account:               "Test/Interop 0",
+					validatorPubKey:       validatorPubKey,
+					amount:                32000000000,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					signature:             signature,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+				{
+					format:                "raw",
+					account:               "Test/Interop 1",
+					validatorPubKey:       validatorPubKey2,
+					amount:                32000000000,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					signature:             signature2,
+					forkVersion:           forkVersion,
+					depositDataRoot:       depositDataRoot2,
+					depositMessageRoot:    depositMessageRoot2,
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := process(test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/validator/depositdata/run.go

@@ -0,0 +1,47 @@
+// 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 depositdata
+
+import (
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the validator deposit data command.
+func Run(cmd *cobra.Command) (string, error) {
+	dataIn, err := input()
+	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(dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/validator/duties/input.go

@@ -0,0 +1,71 @@
+// 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 validatorduties
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// Ethereum 2 connection.
+	eth2Client    string
+	allowInsecure bool
+	// Operation.
+	account string
+	pubKey  string
+	index   string
+}
+
+func input(ctx context.Context) (*dataIn, 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")
+
+	// Ethereum 2 connection.
+	data.eth2Client = viper.GetString("connection")
+	if data.eth2Client == "" {
+		return nil, errors.New("connection is required")
+	}
+	data.allowInsecure = viper.GetBool("allow-insecure-connections")
+
+	// Account.
+	data.account = viper.GetString("account")
+
+	// PubKey.
+	data.pubKey = viper.GetString("pubkey")
+
+	// ID.
+	data.index = viper.GetString("index")
+
+	if data.account == "" && data.pubKey == "" && data.index == "" {
+		return nil, errors.New("account, pubkey or index required")
+	}
+
+	return data, nil
+}

cmd/validator/duties/input_internal_test.go

@@ -0,0 +1,100 @@
+// 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 validatorduties
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	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))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.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{}{
+				"connection": "http://locahost:4000",
+				"pubkey":     "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "AccountMissing",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": "http://locahost:4000",
+			},
+			err: "account, pubkey or index required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
+			},
+			err: "connection is required",
+		},
+	}
+
+	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/validator/duties/output.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 validatorduties
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	debug                   bool
+	quiet                   bool
+	verbose                 bool
+	genesisTime             time.Time
+	slotDuration            time.Duration
+	slotsPerEpoch           uint64
+	thisEpochAttesterDuty   *api.AttesterDuty
+	thisEpochProposerDuties []*api.ProposerDuty
+	nextEpochAttesterDuty   *api.AttesterDuty
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	if data.quiet {
+		return "", nil
+	}
+
+	builder := strings.Builder{}
+
+	now := time.Now()
+	builder.WriteString("Current time: ")
+	builder.WriteString(now.Format("15:04:05\n"))
+
+	if data.thisEpochAttesterDuty != nil {
+		thisEpochAttesterSlot := data.thisEpochAttesterDuty.Slot
+		thisSlotStart := data.genesisTime.Add(time.Duration(thisEpochAttesterSlot) * data.slotDuration)
+		thisSlotEnd := thisSlotStart.Add(data.slotDuration)
+		if thisSlotEnd.After(now) {
+			builder.WriteString("Upcoming attestation slot this epoch: ")
+			builder.WriteString(thisSlotStart.Format("15:04:05"))
+			builder.WriteString(" - ")
+			builder.WriteString(thisSlotEnd.Format("15:04:05 ("))
+			until := thisSlotStart.Sub(now)
+			if until > 0 {
+				builder.WriteString(fmt.Sprintf("%ds until start of slot)\n", int(until.Seconds())))
+			} else {
+				builder.WriteString("\n")
+			}
+
+		}
+	}
+
+	for _, proposerDuty := range data.thisEpochProposerDuties {
+		proposerSlot := proposerDuty.Slot
+		proposerSlotStart := data.genesisTime.Add(time.Duration(proposerSlot) * data.slotDuration)
+		proposerSlotEnd := proposerSlotStart.Add(data.slotDuration)
+		builder.WriteString("Upcoming proposer slot this epoch: ")
+		builder.WriteString(proposerSlotStart.Format("15:04:05"))
+		builder.WriteString(" - ")
+		builder.WriteString(proposerSlotEnd.Format("15:04:05 ("))
+		until := proposerSlotStart.Sub(now)
+		if until > 0 {
+			builder.WriteString(fmt.Sprintf("%ds until start of slot)\n", int(until.Seconds())))
+		} else {
+			builder.WriteString("\n")
+		}
+	}
+
+	if data.nextEpochAttesterDuty != nil {
+		nextEpochAttesterSlot := data.nextEpochAttesterDuty.Slot
+		nextSlotStart := data.genesisTime.Add(time.Duration(nextEpochAttesterSlot) * data.slotDuration)
+		nextSlotEnd := nextSlotStart.Add(data.slotDuration)
+		builder.WriteString("Upcoming attestation slot next epoch: ")
+		builder.WriteString(nextSlotStart.Format("15:04:05"))
+		builder.WriteString(" - ")
+		builder.WriteString(nextSlotEnd.Format("15:04:05 ("))
+		until := nextSlotStart.Sub(now)
+		builder.WriteString(fmt.Sprintf("%ds until start of slot)\n", int(until.Seconds())))
+
+		nextEpoch := uint64(data.nextEpochAttesterDuty.Slot) / data.slotsPerEpoch
+		nextEpochStart := data.genesisTime.Add(time.Duration(nextEpoch*data.slotsPerEpoch) * data.slotDuration)
+		builder.WriteString("Next epoch starts ")
+		builder.WriteString(nextEpochStart.Format("15:04:05 ("))
+		until = nextEpochStart.Sub(now)
+		if until > 0 {
+			builder.WriteString(fmt.Sprintf("%ds until start of epoch)\n", int(until.Seconds())))
+		} else {
+			builder.WriteString("\n")
+		}
+	}
+
+	return builder.String(), nil
+}

cmd/validator/duties/output_internal_test.go

@@ -0,0 +1,83 @@
+// 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 validatorduties
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataOut  *dataOut
+		expected []string
+		err      string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:     "Empty",
+			dataOut:  &dataOut{},
+			expected: []string{"Current time"},
+		},
+		{
+			name: "Found",
+			dataOut: &dataOut{
+				genesisTime:   time.Unix(16000000000, 0),
+				slotDuration:  12 * time.Second,
+				slotsPerEpoch: 32,
+				thisEpochAttesterDuty: &api.AttesterDuty{
+					Slot: spec.Slot(1),
+				},
+				thisEpochProposerDuties: []*api.ProposerDuty{
+					{
+						Slot: spec.Slot(2),
+					},
+				},
+				nextEpochAttesterDuty: &api.AttesterDuty{
+					Slot: spec.Slot(40),
+				},
+			},
+			expected: []string{
+				"Current time",
+				"Upcoming attestation slot this epoch",
+				"Upcoming proposer slot this epoch",
+				"Upcoming attestation slot next epoch",
+			},
+		},
+	}
+
+	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)
+				for _, expected := range test.expected {
+					require.True(t, strings.Contains(res, expected))
+				}
+			}
+		})
+	}
+}

cmd/validator/duties/process.go

@@ -0,0 +1,182 @@
+// 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 validatorduties
+
+import (
+	"context"
+	"encoding/hex"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"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")
+	}
+
+	// Ethereum 2 client.
+	eth2Client, err := util.ConnectToBeaconNode(ctx, data.eth2Client, data.timeout, data.allowInsecure)
+	if err != nil {
+		return nil, err
+	}
+
+	results := &dataOut{
+		debug:   data.debug,
+		quiet:   data.quiet,
+		verbose: data.verbose,
+	}
+
+	validatorIndex, err := validatorIndex(ctx, eth2Client, data)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain validator index")
+	}
+
+	// Fetch duties for this and next epoch.
+	thisEpoch, err := currentEpoch(ctx, eth2Client)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to calculate current epoch")
+	}
+	thisEpochAttesterDuty, err := attesterDuty(ctx, eth2Client, validatorIndex, thisEpoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain this epoch duty for validator")
+	}
+	results.thisEpochAttesterDuty = thisEpochAttesterDuty
+
+	thisEpochProposerDuties, err := proposerDuties(ctx, eth2Client, validatorIndex, thisEpoch)
+	results.thisEpochProposerDuties = thisEpochProposerDuties
+
+	nextEpoch := thisEpoch + 1
+	nextEpochAttesterDuty, err := attesterDuty(ctx, eth2Client, validatorIndex, nextEpoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain next epoch duty for validator")
+	}
+	results.nextEpochAttesterDuty = nextEpochAttesterDuty
+
+	genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain genesis data")
+	}
+	results.genesisTime = genesis.GenesisTime
+
+	config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
+	}
+	results.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
+	results.slotDuration = config["SECONDS_PER_SLOT"].(time.Duration)
+
+	return results, nil
+}
+
+func attesterDuty(ctx context.Context, eth2Client eth2client.Service, validatorIndex spec.ValidatorIndex, epoch spec.Epoch) (*api.AttesterDuty, error) {
+	// Find the attesting slot for the given epoch.
+	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validatorIndex})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain attester duties")
+	}
+
+	if len(duties) == 0 {
+		return nil, errors.New("validator does not have duty for that epoch")
+	}
+
+	return duties[0], nil
+}
+
+func proposerDuties(ctx context.Context, eth2Client eth2client.Service, validatorIndex spec.ValidatorIndex, epoch spec.Epoch) ([]*api.ProposerDuty, error) {
+	// Fetch the proposer duties for this epoch.
+	proposerDuties, err := eth2Client.(eth2client.ProposerDutiesProvider).ProposerDuties(ctx, epoch, []spec.ValidatorIndex{validatorIndex})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain proposer duties")
+	}
+
+	return proposerDuties, nil
+}
+
+func currentEpoch(ctx context.Context, eth2Client eth2client.Service) (spec.Epoch, error) {
+	config, err := eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return 0, errors.Wrap(err, "failed to obtain beacon chain configuration")
+	}
+	slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
+	slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
+	genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	if err != nil {
+		return 0, errors.Wrap(err, "failed to obtain genesis data")
+	}
+
+	if genesis.GenesisTime.After(time.Now()) {
+		return spec.Epoch(0), nil
+	}
+	return spec.Epoch(uint64(time.Since(genesis.GenesisTime).Seconds()) / (uint64(slotDuration.Seconds()) * slotsPerEpoch)), nil
+}
+
+// validatorIndex obtains the index of a validator
+func validatorIndex(ctx context.Context, eth2Client eth2client.Service, data *dataIn) (spec.ValidatorIndex, error) {
+	switch {
+	case data.account != "":
+		ctx, cancel := context.WithTimeout(context.Background(), data.timeout)
+		defer cancel()
+		_, account, err := util.WalletAndAccountFromPath(ctx, data.account)
+		if err != nil {
+			return 0, errors.Wrap(err, "failed to obtain account")
+		}
+		return accountToIndex(ctx, account, eth2Client)
+	case data.pubKey != "":
+		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(data.pubKey, "0x"))
+		if err != nil {
+			return 0, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", data.pubKey))
+		}
+		account, err := util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			return 0, errors.Wrap(err, fmt.Sprintf("invalid public key %s", data.pubKey))
+		}
+		return accountToIndex(ctx, account, eth2Client)
+	case data.index != "":
+		val, err := strconv.ParseUint(data.index, 10, 64)
+		if err != nil {
+			return 0, err
+		}
+		return spec.ValidatorIndex(val), nil
+	default:
+		return 0, errors.New("no validator")
+	}
+}
+
+func accountToIndex(ctx context.Context, account e2wtypes.Account, eth2Client eth2client.Service) (spec.ValidatorIndex, error) {
+	pubKey, err := util.BestPublicKey(account)
+	if err != nil {
+		return 0, err
+	}
+
+	pubKeys := make([]spec.BLSPubKey, 1)
+	copy(pubKeys[0][:], pubKey.Marshal())
+	validators, err := eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, "head", pubKeys)
+	if err != nil {
+		return 0, err
+	}
+
+	for index := range validators {
+		return index, nil
+	}
+	return 0, errors.New("validator not found")
+}

cmd/validator/duties/process_internal_test.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 validatorduties
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Client",
+			dataIn: &dataIn{
+				timeout:       5 * time.Second,
+				eth2Client:    os.Getenv("ETHDO_TEST_CONNECTION"),
+				allowInsecure: true,
+				index:         "1",
+			},
+		},
+	}
+
+	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/validator/duties/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 validatorduties
+
+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("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/validator/exit/input.go

@@ -0,0 +1,146 @@
+// 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 validatorexit
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"strings"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"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
+	// Operation.
+	eth2Client eth2client.Service
+	jsonOutput bool
+	// Chain information.
+	fork         *spec.Fork
+	currentEpoch spec.Epoch
+	// Exit information.
+	account             e2wtypes.Account
+	passphrases         []string
+	epoch               spec.Epoch
+	domain              spec.Domain
+	signedVoluntaryExit *spec.SignedVoluntaryExit
+}
+
+func input(ctx context.Context) (*dataIn, 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")
+	data.passphrases = util.GetPassphrases()
+	data.jsonOutput = viper.GetBool("json")
+
+	switch {
+	case viper.GetString("exit") != "":
+		return inputJSON(ctx, data)
+	case viper.GetString("account") != "":
+		return inputAccount(ctx, data)
+	case viper.GetString("key") != "":
+		return inputKey(ctx, data)
+	default:
+		return nil, errors.New("must supply account, key, or pre-constructed JSON")
+	}
+}
+
+func inputJSON(ctx context.Context, data *dataIn) (*dataIn, error) {
+	validatorData := &util.ValidatorExitData{}
+	err := json.Unmarshal([]byte(viper.GetString("exit")), validatorData)
+	if err != nil {
+		return nil, err
+	}
+	data.signedVoluntaryExit = validatorData.Exit
+	return inputChainData(ctx, data)
+}
+
+func inputAccount(ctx context.Context, data *dataIn) (*dataIn, error) {
+	var err error
+	_, data.account, err = util.WalletAndAccountFromInput(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain acount")
+	}
+	return inputChainData(ctx, data)
+}
+
+func inputKey(ctx context.Context, data *dataIn) (*dataIn, error) {
+	privKeyBytes, err := hex.DecodeString(strings.TrimPrefix(viper.GetString("key"), "0x"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to decode key")
+	}
+	data.account, err = util.NewScratchAccount(privKeyBytes, nil)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create acount from key")
+	}
+	return inputChainData(ctx, data)
+}
+
+func inputChainData(ctx context.Context, data *dataIn) (*dataIn, error) {
+	var err error
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+	}
+
+	// Current fork.
+	data.fork, err = data.eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to obtain fork information")
+	}
+
+	// Calculate current epoch.
+	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
+	}
+	genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to obtain genesis information")
+	}
+	data.currentEpoch = spec.Epoch(uint64(time.Since(genesis.GenesisTime).Seconds()) / (uint64(config["SECONDS_PER_SLOT"].(time.Duration).Seconds()) * config["SLOTS_PER_EPOCH"].(uint64)))
+
+	// Epoch.
+	if viper.GetInt64("epoch") == -1 {
+		data.epoch = data.currentEpoch
+	} else {
+		data.epoch = spec.Epoch(viper.GetUint64("epoch"))
+	}
+
+	// Domain.
+	domain, err := data.eth2Client.(eth2client.DomainProvider).Domain(ctx, config["DOMAIN_VOLUNTARY_EXIT"].(spec.DomainType), data.epoch)
+	if err != nil {
+		return nil, errors.New("failed to calculate domain")
+	}
+	data.domain = domain
+
+	return data, nil
+}

cmd/validator/exit/input_internal_test.go

@@ -0,0 +1,193 @@
+// 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 validatorexit
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	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))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.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",
+				"wallet-passphrase": "ce%NohGhah4ye5ra",
+				"type":              "nd",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "NoMethod",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "must supply account, key, or pre-constructed JSON",
+		},
+		{
+			name: "KeyInvalid",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"key":     "0xinvalid",
+			},
+			err: "failed to decode key: encoding/hex: invalid byte: U+0069 'i'",
+		},
+		{
+			name: "KeyBad",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"key":     "0x00",
+			},
+			err: "failed to create acount from key: private key must be 32 bytes",
+		},
+		{
+			name: "KeyGood",
+			vars: map[string]interface{}{
+				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+		{
+			name: "AccountUnknown",
+			vars: map[string]interface{}{
+				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"account":                    "Test wallet/unknown",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+			err: "failed to obtain acount: failed to obtain account: no account with name \"unknown\"",
+		},
+		{
+			name: "AccountGood",
+			vars: map[string]interface{}{
+				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"account":                    "Test wallet/Interop 0",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+		{
+			name: "JSONInvalid",
+			vars: map[string]interface{}{
+				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"exit":                       `invalid`,
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+			err: "invalid character 'i' looking for beginning of value",
+		},
+		{
+			name: "JSONGood",
+			vars: map[string]interface{}{
+				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"exit":                       `{"exit":{"message":{"epoch":"123","validator_index":"456"},"signature":"0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"},"fork_version":"0x00002009"}`,
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+		{
+			name: "ClientBad",
+			vars: map[string]interface{}{
+				"connection":                 "localhost:1",
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+		},
+		{
+			name: "EpochProvided",
+			vars: map[string]interface{}{
+				"connection":                 os.Getenv("ETHDO_TEST_CONNECTION"),
+				"allow-insecure-connections": true,
+				"timeout":                    "5s",
+				"key":                        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+				"epoch":                      "123",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+	}
+
+	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/validator/exit/output.go

@@ -0,0 +1,57 @@
+// 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 validatorexit
+
+import (
+	"context"
+	"encoding/json"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type dataOut struct {
+	jsonOutput          bool
+	forkVersion         spec.Version
+	signedVoluntaryExit *spec.SignedVoluntaryExit
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	if data.signedVoluntaryExit == nil {
+		return "", errors.New("no signed voluntary exit")
+	}
+
+	if data.jsonOutput {
+		return outputJSON(ctx, data)
+	}
+
+	return "", nil
+}
+
+func outputJSON(ctx context.Context, data *dataOut) (string, error) {
+	validatorExitData := &util.ValidatorExitData{
+		Exit:        data.signedVoluntaryExit,
+		ForkVersion: data.forkVersion,
+	}
+	bytes, err := json.Marshal(validatorExitData)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate JSON")
+	}
+	return string(bytes), nil
+}

cmd/validator/exit/output_internal_test.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 validatorexit
+
+import (
+	"context"
+	"testing"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "SignedVoluntaryExitNil",
+			dataOut: &dataOut{
+				jsonOutput: true,
+			},
+			err: "no signed voluntary exit",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				forkVersion: spec.Version{0x01, 0x02, 0x03, 0x04},
+				signedVoluntaryExit: &spec.SignedVoluntaryExit{
+					Message: &spec.VoluntaryExit{
+						Epoch:          spec.Epoch(123),
+						ValidatorIndex: spec.ValidatorIndex(456),
+					},
+					Signature: spec.BLSSignature{
+						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+					},
+				},
+			},
+		},
+		{
+			name: "JSON",
+			dataOut: &dataOut{
+				jsonOutput:  true,
+				forkVersion: spec.Version{0x01, 0x02, 0x03, 0x04},
+				signedVoluntaryExit: &spec.SignedVoluntaryExit{
+					Message: &spec.VoluntaryExit{
+						Epoch:          spec.Epoch(123),
+						ValidatorIndex: spec.ValidatorIndex(456),
+					},
+					Signature: spec.BLSSignature{
+						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+					},
+				},
+			},
+			res: `{"exit":{"message":{"epoch":"123","validator_index":"456"},"signature":"0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"},"fork_version":"0x01020304"}`,
+		},
+	}
+
+	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/validator/exit/process.go

@@ -0,0 +1,133 @@
+// 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 validatorexit
+
+import (
+	"context"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/signing"
+	"github.com/wealdtech/ethdo/util"
+)
+
+// maxFutureEpochs is the farthest in the future for which an exit will be created.
+var maxFutureEpochs = spec.Epoch(1024)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	if data.epoch > data.currentEpoch {
+		if data.epoch-data.currentEpoch > maxFutureEpochs {
+			return nil, errors.New("not generating exit for an epoch in the far future")
+		}
+	}
+	results := &dataOut{
+		forkVersion: data.fork.CurrentVersion,
+		jsonOutput:  data.jsonOutput,
+	}
+
+	validator, err := fetchValidator(ctx, data)
+	if err != nil {
+		return nil, err
+	}
+
+	exit, err := generateExit(ctx, data, validator)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to generate voluntary exit")
+	}
+	root, err := exit.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to generate root for voluntary exit")
+	}
+
+	if data.account != nil {
+		signature, err := signing.SignRoot(ctx, data.account, data.passphrases, root, data.domain)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to sign voluntary exit")
+		}
+
+		results.signedVoluntaryExit = &spec.SignedVoluntaryExit{
+			Message:   exit,
+			Signature: signature,
+		}
+	} else {
+		results.signedVoluntaryExit = data.signedVoluntaryExit
+	}
+
+	if !data.jsonOutput {
+		if err := broadcastExit(ctx, data, results); err != nil {
+			return nil, errors.Wrap(err, "failed to broadcast voluntary exit")
+		}
+	}
+
+	return results, nil
+}
+
+func generateExit(ctx context.Context, data *dataIn, validator *api.Validator) (*spec.VoluntaryExit, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	if data.signedVoluntaryExit != nil {
+		return data.signedVoluntaryExit.Message, nil
+	}
+
+	if validator == nil {
+		return nil, errors.New("no validator")
+	}
+
+	exit := &spec.VoluntaryExit{
+		Epoch:          data.epoch,
+		ValidatorIndex: validator.Index,
+	}
+	return exit, nil
+}
+
+func broadcastExit(ctx context.Context, data *dataIn, results *dataOut) error {
+	return data.eth2Client.(eth2client.VoluntaryExitSubmitter).SubmitVoluntaryExit(ctx, results.signedVoluntaryExit)
+}
+
+func fetchValidator(ctx context.Context, data *dataIn) (*api.Validator, error) {
+	// Validator.
+	if data.account == nil {
+		return nil, nil
+	}
+
+	var validator *api.Validator
+	validatorPubKeys := make([]spec.BLSPubKey, 1)
+	pubKey, err := util.BestPublicKey(data.account)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain public key for account")
+	}
+	copy(validatorPubKeys[0][:], pubKey.Marshal())
+	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, "head", validatorPubKeys)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain validator from beacon node")
+	}
+	if len(validators) == 0 {
+		return nil, errors.New("validator not known by beacon node")
+	}
+	for _, v := range validators {
+		validator = v
+	}
+	if validator.Status != api.ValidatorStateActiveOngoing {
+		return nil, errors.New("validator is not active; cannot exit")
+	}
+	return validator, nil
+}

cmd/validator/exit/process_internal_test.go

@@ -0,0 +1,234 @@
+// 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 validatorexit
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/auto"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	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) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	require.NoError(t, e2types.InitBLS())
+
+	eth2Client, err := auto.New(context.Background(),
+		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+	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))
+	viper.Set("passphrase", "pass")
+	interop0, err := testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	//		activeValidator := &api.Validator{
+	//			Index:   123,
+	//			Balance: 32123456789,
+	//			Status:  api.ValidatorStateActiveOngoing,
+	//			Validator: &spec.Validator{
+	//				PublicKey:                  testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+	//				WithdrawalCredentials:      nil,
+	//				EffectiveBalance:           32000000000,
+	//				Slashed:                    false,
+	//				ActivationEligibilityEpoch: 0,
+	//				ActivationEpoch:            0,
+	//				ExitEpoch:                  0,
+	//				WithdrawableEpoch:          0,
+	//			},
+	//		}
+
+	epochFork := &spec.Fork{
+		PreviousVersion: spec.Version{0x00, 0x00, 0x00, 0x00},
+		CurrentVersion:  spec.Version{0x00, 0x00, 0x00, 0x00},
+		Epoch:           0,
+	}
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "EpochTooLate",
+			dataIn: &dataIn{
+				timeout:      5 * time.Second,
+				eth2Client:   eth2Client,
+				fork:         epochFork,
+				currentEpoch: 10,
+				account:      interop0,
+				passphrases:  []string{"pass"},
+				epoch:        9999999,
+				domain:       spec.Domain{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+			},
+			err: "not generating exit for an epoch in the far future",
+		},
+		{
+			name: "AccountUnknown",
+			dataIn: &dataIn{
+				timeout:      5 * time.Second,
+				eth2Client:   eth2Client,
+				fork:         epochFork,
+				currentEpoch: 10,
+				account:      interop0,
+				passphrases:  []string{"pass"},
+				epoch:        10,
+				domain:       spec.Domain{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+			},
+			err: "validator not known by beacon node",
+		},
+		// {
+		// 	name: "Good",
+		// 	dataIn: &dataIn{
+		// 		timeout:      5 * time.Second,
+		// 		eth2Client:   eth2Client,
+		// 		fork:         epochFork,
+		// 		currentEpoch: 10,
+		// 		account:      interop0,
+		// 		passphrases:  []string{"pass"},
+		// 		epoch:        10,
+		// 		domain:       spec.Domain{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f},
+		// 	},
+		// },
+	}
+
+	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 TestGenerateExit(t *testing.T) {
+	activeValidator := &api.Validator{
+		Index:   123,
+		Balance: 32123456789,
+		Status:  api.ValidatorStateActiveOngoing,
+		Validator: &spec.Validator{
+			PublicKey:                  testutil.HexToPubKey("0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c"),
+			WithdrawalCredentials:      nil,
+			EffectiveBalance:           32000000000,
+			Slashed:                    false,
+			ActivationEligibilityEpoch: 0,
+			ActivationEpoch:            0,
+			ExitEpoch:                  0,
+			WithdrawableEpoch:          0,
+		},
+	}
+
+	tests := []struct {
+		name      string
+		validator *api.Validator
+		dataIn    *dataIn
+		err       string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "SignedVoluntaryExitGood",
+			dataIn: &dataIn{
+				signedVoluntaryExit: &spec.SignedVoluntaryExit{
+					Message: &spec.VoluntaryExit{
+						Epoch:          spec.Epoch(123),
+						ValidatorIndex: spec.ValidatorIndex(456),
+					},
+					Signature: spec.BLSSignature{
+						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+					},
+				},
+			},
+		},
+		{
+			name:   "ValidatorMissing",
+			dataIn: &dataIn{},
+			err:    "no validator",
+		},
+		{
+			name:      "ValidatorGood",
+			dataIn:    &dataIn{},
+			validator: activeValidator,
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				signedVoluntaryExit: &spec.SignedVoluntaryExit{
+					Message: &spec.VoluntaryExit{
+						Epoch:          spec.Epoch(123),
+						ValidatorIndex: spec.ValidatorIndex(456),
+					},
+					Signature: spec.BLSSignature{
+						0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+						0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+						0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
+						0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f,
+						0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f,
+						0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
+					},
+				},
+			},
+			validator: activeValidator,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := generateExit(context.Background(), test.dataIn, test.validator)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/validator/exit/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 validatorexit
+
+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("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/validatordepositdata.go

@@ -14,29 +14,13 @@
 package cmd
 
 import (
-	"context"
-	"encoding/hex"
 	"fmt"
-	"os"
-	"strings"
 
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/ethdo/grpc"
-	e2types "github.com/wealdtech/go-eth2-types/v2"
-	util "github.com/wealdtech/go-eth2-util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
-	string2eth "github.com/wealdtech/go-string2eth"
+	validatordepositdata "github.com/wealdtech/ethdo/cmd/validator/depositdata"
 )
 
-var validatorDepositDataValidatorAccount string
-var validatorDepositDataWithdrawalAccount string
-var validatorDepositDataWithdrawalPubKey string
-var validatorDepositDataDepositValue string
-var validatorDepositDataRaw bool
-var validatorDepositDataForkVersion string
-
 var validatorDepositDataCmd = &cobra.Command{
 	Use:   "depositdata",
 	Short: "Generate deposit data for one or more validators",
@@ -49,166 +33,51 @@ If validatoraccount is provided with an account path it will generate deposit da
 The information generated can be passed to ethereal to create a deposit from the Ethereum 1 chain.
 
 In quiet mode this will return 0 if the the data can be generated correctly, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		assert(validatorDepositDataValidatorAccount != "", "--validatoraccount is required")
-		validatorWalletName, validatorAccountSpec, err := e2wallet.WalletAndAccountNames(validatorDepositDataValidatorAccount)
-		errCheck(err, "Failed to obtain wallet and account names")
-		validatorWallet, err := openNamedWallet(validatorWalletName)
-		errCheck(err, "Failed to obtain validator wallet")
-		validatorAccounts, err := accountsFromPath(ctx, validatorWallet, validatorAccountSpec)
-		errCheck(err, "Failed to obtain validator account")
-		assert(len(validatorAccounts) > 0, "Failed to obtain validator account")
-
-		for _, validatorAccount := range validatorAccounts {
-			outputIf(verbose, fmt.Sprintf("Creating deposit for %s/%s", validatorWallet.Name(), validatorAccount.Name()))
-			pubKey, err := bestPublicKey(validatorAccount)
-			errCheck(err, "Validator account does not provide a public key")
-			outputIf(debug, fmt.Sprintf("Validator public key is %#x", pubKey.Marshal()))
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := validatordepositdata.Run(cmd)
+		if err != nil {
+			return err
 		}
-
-		assert(validatorDepositDataWithdrawalAccount != "" || validatorDepositDataWithdrawalPubKey != "", "--withdrawalaccount or --withdrawalpubkey is required")
-		var withdrawalCredentials []byte
-		if validatorDepositDataWithdrawalAccount != "" {
-			withdrawalAccount, err := accountFromPath(ctx, validatorDepositDataWithdrawalAccount)
-			errCheck(err, "Failed to obtain withdrawal account")
-			pubKey, err := bestPublicKey(withdrawalAccount)
-			errCheck(err, "Withdrawal account does not provide a public key")
-			outputIf(debug, fmt.Sprintf("Withdrawal public key is %#x", pubKey.Marshal()))
-			withdrawalCredentials = util.SHA256(pubKey.Marshal())
-			errCheck(err, "Failed to hash withdrawal credentials")
-		} else {
-			withdrawalPubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(validatorDepositDataWithdrawalPubKey, "0x"))
-			errCheck(err, "Invalid withdrawal public key")
-			assert(len(withdrawalPubKeyBytes) == 48, "Public key should be 48 bytes")
-			withdrawalPubKey, err := e2types.BLSPublicKeyFromBytes(withdrawalPubKeyBytes)
-			errCheck(err, "Value supplied with --withdrawalpubkey is not a valid public key")
-			withdrawalCredentials = util.SHA256(withdrawalPubKey.Marshal())
-			errCheck(err, "Failed to hash withdrawal credentials")
-		}
-		// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
-		withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
-		outputIf(debug, fmt.Sprintf("Withdrawal credentials are %#x", withdrawalCredentials))
-
-		assert(validatorDepositDataDepositValue != "", "--depositvalue is required")
-		val, err := string2eth.StringToGWei(validatorDepositDataDepositValue)
-		errCheck(err, "Invalid value")
-		// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
-		assert(val >= 1000000000, "deposit value must be at least 1 Ether") // MIN_DEPOSIT_AMOUNT
-
-		// For each key, generate deposit data
-		outputs := make([]string, 0)
-		for _, validatorAccount := range validatorAccounts {
-			validatorPubKey, err := bestPublicKey(validatorAccount)
-			errCheck(err, "Validator account does not provide a public key")
-			depositData := struct {
-				PubKey                []byte `ssz-size:"48"`
-				WithdrawalCredentials []byte `ssz-size:"32"`
-				Value                 uint64
-			}{
-				PubKey:                validatorPubKey.Marshal(),
-				WithdrawalCredentials: withdrawalCredentials,
-				Value:                 val,
-			}
-			outputIf(debug, fmt.Sprintf("Deposit data:\n\tPublic key: %x\n\tWithdrawal credentials: %x\n\tValue: %d", depositData.PubKey, depositData.WithdrawalCredentials, depositData.Value))
-
-			var forkVersion []byte
-			if validatorDepositDataForkVersion != "" {
-				forkVersion, err = hex.DecodeString(strings.TrimPrefix(validatorDepositDataForkVersion, "0x"))
-				errCheck(err, fmt.Sprintf("Failed to decode fork version %s", validatorDepositDataForkVersion))
-				assert(len(forkVersion) == 4, "Fork version must be exactly four bytes")
-			} else {
-				err := connect()
-				errCheck(err, "Failed to connect to beacon node")
-				config, err := grpc.FetchChainConfig(eth2GRPCConn)
-				if err != nil {
-					outputIf(!quiet, "Could not connect to beacon node; supply a connection with --connection or provide a fork version with --forkversion to generate a deposit")
-					os.Exit(_exitFailure)
-				}
-				genesisForkVersion, exists := config["GenesisForkVersion"]
-				assert(exists, "Failed to obtain genesis fork version")
-				forkVersion = genesisForkVersion.([]byte)
-			}
-			outputIf(debug, fmt.Sprintf("Fork version is %x", forkVersion))
-
-			domain := e2types.Domain(e2types.DomainDeposit, forkVersion, e2types.ZeroGenesisValidatorsRoot)
-			outputIf(debug, fmt.Sprintf("Domain is %x", domain))
-			signature, err := signStruct(validatorAccount, depositData, domain)
-			errCheck(err, "Failed to generate deposit data signature")
-
-			signedDepositData := struct {
-				PubKey                []byte `ssz-size:"48"`
-				WithdrawalCredentials []byte `ssz-size:"32"`
-				Value                 uint64
-				Signature             []byte `ssz-size:"96"`
-			}{
-				PubKey:                validatorPubKey.Marshal(),
-				WithdrawalCredentials: withdrawalCredentials,
-				Value:                 val,
-				Signature:             signature.Marshal(),
-			}
-			if debug {
-				fmt.Printf("Signed deposit data:\n")
-				fmt.Printf(" Public key: %#x\n", signedDepositData.PubKey)
-				fmt.Printf(" Withdrawal credentials: %#x\n", signedDepositData.WithdrawalCredentials)
-				fmt.Printf(" Value: %d\n", signedDepositData.Value)
-				fmt.Printf(" Signature: %#x\n", signedDepositData.Signature)
-			}
-
-			depositDataRoot, err := ssz.HashTreeRoot(signedDepositData)
-			errCheck(err, "Failed to generate deposit data root")
-			outputIf(debug, fmt.Sprintf("Deposit data root is %x", depositDataRoot))
-
-			if validatorDepositDataRaw {
-				// Build a raw transaction by hand
-				txData := []byte{0x22, 0x89, 0x51, 0x18}
-				// Pointer to validator public key
-				txData = append(txData, []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, 0x80}...)
-				// Pointer to withdrawal credentials
-				txData = append(txData, []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, 0xe0}...)
-				// Pointer to validator signature
-				txData = append(txData, []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, 0x01, 0x20}...)
-				// Deposit data root
-				txData = append(txData, depositDataRoot[:]...)
-				// Validator public key (pad to 32-byte boundary)
-				txData = append(txData, []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, 0x30}...)
-				txData = append(txData, validatorPubKey.Marshal()...)
-				txData = append(txData, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}...)
-				// Withdrawal credentials
-				txData = append(txData, []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, 0x20}...)
-				txData = append(txData, withdrawalCredentials...)
-				// Deposit signature
-				txData = append(txData, []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, 0x60}...)
-				txData = append(txData, signedDepositData.Signature...)
-				outputs = append(outputs, fmt.Sprintf("%#x", txData))
-			} else {
-				outputs = append(outputs, fmt.Sprintf(`{"name":"Deposit for %s","account":"%s","pubkey":"%#x","withdrawal_credentials":"%#x","signature":"%#x","value":%d,"deposit_data_root":"%#x","version":2}`, fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()), fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()), signedDepositData.PubKey, signedDepositData.WithdrawalCredentials, signedDepositData.Signature, val, depositDataRoot))
-			}
-		}
-
-		if quiet {
-			os.Exit(0)
-		}
-
-		if len(outputs) == 1 {
-			fmt.Printf("%s\n", outputs[0])
-		} else {
-			fmt.Printf("[")
-			fmt.Print(strings.Join(outputs, ","))
-			fmt.Println("]")
+		if viper.GetBool("quiet") {
+			return nil
 		}
+		fmt.Println(res)
+		return nil
 	},
 }
 
 func init() {
 	validatorCmd.AddCommand(validatorDepositDataCmd)
 	validatorFlags(validatorDepositDataCmd)
-	validatorDepositDataCmd.Flags().StringVar(&validatorDepositDataValidatorAccount, "validatoraccount", "", "Account of the account carrying out the validation")
-	validatorDepositDataCmd.Flags().StringVar(&validatorDepositDataWithdrawalAccount, "withdrawalaccount", "", "Account of the account to which the validator funds will be withdrawn")
-	validatorDepositDataCmd.Flags().StringVar(&validatorDepositDataWithdrawalPubKey, "withdrawalpubkey", "", "Public key of the account to which the validator funds will be withdrawn")
-	validatorDepositDataCmd.Flags().StringVar(&validatorDepositDataDepositValue, "depositvalue", "", "Value of the amount to be deposited")
-	validatorDepositDataCmd.Flags().BoolVar(&validatorDepositDataRaw, "raw", false, "Print raw deposit data transaction data")
-	validatorDepositDataCmd.Flags().StringVar(&validatorDepositDataForkVersion, "forkversion", "", "Use a hard-coded fork version (default is to fetch it from the node)")
+	validatorDepositDataCmd.Flags().String("validatoraccount", "", "Account of the account carrying out the validation")
+	validatorDepositDataCmd.Flags().String("withdrawalaccount", "", "Account of the account to which the validator funds will be withdrawn")
+	validatorDepositDataCmd.Flags().String("withdrawalpubkey", "", "Public key of the account to which the validator funds will be withdrawn")
+	validatorDepositDataCmd.Flags().String("depositvalue", "", "Value of the amount to be deposited")
+	validatorDepositDataCmd.Flags().Bool("raw", false, "Print raw deposit data transaction data")
+	validatorDepositDataCmd.Flags().String("forkversion", "", "Use a hard-coded fork version (default is to fetch it from the node)")
+	validatorDepositDataCmd.Flags().Bool("launchpad", false, "Print launchpad-compatible JSON")
+}
+
+func validatorDepositdataBindings() {
+	if err := viper.BindPFlag("validatoraccount", validatorDepositDataCmd.Flags().Lookup("validatoraccount")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("withdrawalaccount", validatorDepositDataCmd.Flags().Lookup("withdrawalaccount")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("withdrawalpubkey", validatorDepositDataCmd.Flags().Lookup("withdrawalpubkey")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("depositvalue", validatorDepositDataCmd.Flags().Lookup("depositvalue")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("raw", validatorDepositDataCmd.Flags().Lookup("raw")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("forkversion", validatorDepositDataCmd.Flags().Lookup("forkversion")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("launchpad", validatorDepositDataCmd.Flags().Lookup("launchpad")); err != nil {
+		panic(err)
+	}
 }

cmd/validatorduties.go

@@ -0,0 +1,61 @@
+// 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 cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	validatorduties "github.com/wealdtech/ethdo/cmd/validator/duties"
+)
+
+var validatorDutiesCmd = &cobra.Command{
+	Use:   "duties",
+	Short: "List known duties for a validator",
+	Long: `List known duties for a validator. For example:
+
+    ethdo validator duties --account=Validators/One
+
+Attester duties are known for the current and next epoch.  Proposer duties are known for the current epoch.
+
+In quiet mode this will return 0 if the the duties have been obtained, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := validatorduties.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		fmt.Printf(res)
+		return nil
+	},
+}
+
+func init() {
+	validatorCmd.AddCommand(validatorDutiesCmd)
+	validatorFlags(validatorDutiesCmd)
+	validatorDutiesCmd.Flags().String("pubkey", "", "validator public key for duties")
+	validatorDutiesCmd.Flags().String("index", "", "validator index for duties")
+}
+
+func validatorDutiesBindings() {
+	if err := viper.BindPFlag("pubkey", validatorDutiesCmd.Flags().Lookup("pubkey")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("index", validatorDutiesCmd.Flags().Lookup("index")); err != nil {
+		panic(err)
+	}
+}

cmd/validatorexit.go

@@ -14,29 +14,13 @@
 package cmd
 
 import (
-	"context"
-	"encoding/hex"
-	"encoding/json"
 	"fmt"
-	"os"
-	"strings"
-	"time"
 
-	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/ethdo/grpc"
-	"github.com/wealdtech/ethdo/util"
-	e2types "github.com/wealdtech/go-eth2-types/v2"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	validatorexit "github.com/wealdtech/ethdo/cmd/validator/exit"
 )
 
-var validatorExitEpoch int64
-var validatorExitKey string
-var validatorExitJSON string
-var validatorExitJSONOutput bool
-
 var validatorExitCmd = &cobra.Command{
 	Use:   "exit",
 	Short: "Send an exit request for a validator",
@@ -45,202 +29,41 @@ var validatorExitCmd = &cobra.Command{
     ethdo validator exit --account=primary/validator --passphrase=secret
 
 In quiet mode this will return 0 if the transaction has been generated, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-
-		err := connect()
-		errCheck(err, "Failed to obtain connect to Ethereum 2 beacon chain node")
-
-		exit, signature := validatorExitHandleInput(ctx)
-		validatorExitHandleExit(ctx, exit, signature)
-		os.Exit(_exitSuccess)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := validatorexit.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
-func validatorExitHandleInput(ctx context.Context) (*ethpb.VoluntaryExit, e2types.Signature) {
-	if validatorExitJSON != "" {
-		return validatorExitHandleJSONInput(validatorExitJSON)
-	}
-	if viper.GetString("account") != "" {
-		account, err := accountFromPath(ctx, viper.GetString("account"))
-		errCheck(err, "Failed to access account")
-		return validatorExitHandleAccountInput(ctx, account)
-	}
-	if validatorExitKey != "" {
-		privKeyBytes, err := hex.DecodeString(strings.TrimPrefix(validatorExitKey, "0x"))
-		errCheck(err, fmt.Sprintf("Failed to decode key %s", validatorExitKey))
-		account, err := util.NewScratchAccount(privKeyBytes, nil)
-		errCheck(err, "Invalid private key")
-		return validatorExitHandleAccountInput(ctx, account)
-	}
-	die("one of --json, --account or --key is required")
-	return nil, nil
-}
-
-func validatorExitHandleJSONInput(input string) (*ethpb.VoluntaryExit, e2types.Signature) {
-	data := &validatorExitData{}
-	err := json.Unmarshal([]byte(input), data)
-	errCheck(err, "Invalid JSON input")
-	exit := &ethpb.VoluntaryExit{
-		Epoch:          data.Epoch,
-		ValidatorIndex: data.ValidatorIndex,
-	}
-	signature, err := e2types.BLSSignatureFromBytes(data.Signature)
-	errCheck(err, "Invalid signature")
-	return exit, signature
-}
-
-func validatorExitHandleAccountInput(ctx context.Context, account e2wtypes.Account) (*ethpb.VoluntaryExit, e2types.Signature) {
-	exit := &ethpb.VoluntaryExit{}
-
-	// Beacon chain config required for later work.
-	config, err := grpc.FetchChainConfig(eth2GRPCConn)
-	errCheck(err, "Failed to obtain beacon chain configuration")
-	secondsPerSlot, ok := config["SecondsPerSlot"].(uint64)
-	assert(ok, "Failed to obtain seconds per slot from chain")
-	slotsPerEpoch, ok := config["SlotsPerEpoch"].(uint64)
-	assert(ok, "Failed to obtain slots per epoch from chain")
-	secondsPerEpoch := secondsPerSlot * slotsPerEpoch
-
-	// Fetch the validator's index.
-	index, err := grpc.FetchValidatorIndex(eth2GRPCConn, account)
-	errCheck(err, "Failed to obtain validator index")
-	outputIf(debug, fmt.Sprintf("Validator index is %d", index))
-	exit.ValidatorIndex = index
-
-	// Ensure the validator is active.
-	state, err := grpc.FetchValidatorState(eth2GRPCConn, account)
-	errCheck(err, "Failed to obtain validator state")
-	outputIf(debug, fmt.Sprintf("Validator state is %v", state))
-	assert(state == ethpb.ValidatorStatus_ACTIVE, "Validator must be active to exit")
-
-	if validatorExitEpoch < 0 {
-		// Ensure the validator has been active long enough to exit.
-		validator, err := grpc.FetchValidator(eth2GRPCConn, account)
-		errCheck(err, "Failed to obtain validator information")
-		outputIf(debug, fmt.Sprintf("Activation epoch is %v", validator.ActivationEpoch))
-		shardCommitteePeriod, ok := config["ShardCommitteePeriod"].(uint64)
-		assert(ok, "Failed to obtain shard committee period from chain")
-		earliestExitEpoch := validator.ActivationEpoch + shardCommitteePeriod
-
-		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
-		errCheck(err, "Failed to obtain genesis time")
-
-		currentEpoch := uint64(time.Since(genesisTime).Seconds()) / secondsPerEpoch
-		assert(currentEpoch >= earliestExitEpoch, fmt.Sprintf("Validator cannot exit until %s ( epoch %d); transaction not sent", genesisTime.Add(time.Duration(secondsPerEpoch*earliestExitEpoch)*time.Second).Format(time.UnixDate), earliestExitEpoch))
-		outputIf(verbose, "Validator confirmed to be in a suitable state")
-		exit.Epoch = currentEpoch
-	} else {
-		// User-specified epoch; no checks.
-		exit.Epoch = uint64(validatorExitEpoch)
-	}
-
-	// TODO fetch current fork version from config (currently using genesis fork version)
-	currentForkVersion := config["GenesisForkVersion"].([]byte)
-	outputIf(debug, fmt.Sprintf("Current fork version is %x", currentForkVersion))
-	genesisValidatorsRoot, err := grpc.FetchGenesisValidatorsRoot(eth2GRPCConn)
-	outputIf(debug, fmt.Sprintf("Genesis validators root is %x", genesisValidatorsRoot))
-	errCheck(err, "Failed to obtain genesis validators root")
-	domain := e2types.Domain(e2types.DomainVoluntaryExit, currentForkVersion, genesisValidatorsRoot)
-
-	alreadyUnlocked, err := unlock(account)
-	errCheck(err, "Failed to unlock account; please confirm passphrase is correct")
-	signature, err := signStruct(account, exit, domain)
-	if !alreadyUnlocked {
-		errCheck(lock(account), "Failed to re-lock account")
-	}
-	errCheck(err, "Failed to sign exit proposal")
-
-	return exit, signature
-}
-
-// validatorExitHandleExit handles the exit request.
-func validatorExitHandleExit(ctx context.Context, exit *ethpb.VoluntaryExit, signature e2types.Signature) {
-	if validatorExitJSONOutput {
-		data := &validatorExitData{
-			Epoch:          exit.Epoch,
-			ValidatorIndex: exit.ValidatorIndex,
-			Signature:      signature.Marshal(),
-		}
-		res, err := json.Marshal(data)
-		errCheck(err, "Failed to generate JSON")
-		outputIf(!quiet, string(res))
-	} else {
-		proposal := &ethpb.SignedVoluntaryExit{
-			Exit:      exit,
-			Signature: signature.Marshal(),
-		}
-
-		validatorClient := ethpb.NewBeaconNodeValidatorClient(eth2GRPCConn)
-		_, err := validatorClient.ProposeExit(ctx, proposal)
-		errCheck(err, "Failed to propose exit")
-		outputIf(!quiet, "Validator exit transaction sent")
-	}
-}
-
 func init() {
 	validatorCmd.AddCommand(validatorExitCmd)
 	validatorFlags(validatorExitCmd)
-	validatorExitCmd.Flags().Int64Var(&validatorExitEpoch, "epoch", -1, "Epoch at which to exit (defaults to current epoch)")
-	validatorExitCmd.Flags().StringVar(&validatorExitKey, "key", "", "Private key if account not known by ethdo")
-	validatorExitCmd.Flags().BoolVar(&validatorExitJSONOutput, "json-output", false, "Print JSON transaction; do not broadcast to network")
-	validatorExitCmd.Flags().StringVar(&validatorExitJSON, "json", "", "Use JSON as created by --json-output to exit")
+	validatorExitCmd.Flags().Int64("epoch", -1, "Epoch at which to exit (defaults to current epoch)")
+	validatorExitCmd.Flags().String("key", "", "Private key if validator not known by ethdo")
+	validatorExitCmd.Flags().String("exit", "", "Use pre-defined JSON data as created by --json to exit")
+	validatorExitCmd.Flags().Bool("json", false, "Generate JSON data for an exit; do not broadcast to network")
 }
 
-type validatorExitData struct {
-	Epoch          uint64 `json:"epoch"`
-	ValidatorIndex uint64 `json:"validator_index"`
-	Signature      []byte `json:"signature"`
-}
-
-// MarshalJSON implements custom JSON marshaller.
-func (d *validatorExitData) MarshalJSON() ([]byte, error) {
-	return []byte(fmt.Sprintf(`{"epoch":%d,"validator_index":%d,"signature":"%#x"}`, d.Epoch, d.ValidatorIndex, d.Signature)), nil
-}
-
-// UnmarshalJSON implements custom JSON unmarshaller.
-func (d *validatorExitData) UnmarshalJSON(data []byte) error {
-	var v map[string]interface{}
-	if err := json.Unmarshal(data, &v); err != nil {
-		return err
-	}
-
-	if val, exists := v["epoch"]; exists {
-		var ok bool
-		epoch, ok := val.(float64)
-		if !ok {
-			return errors.New("epoch invalid")
-		}
-		d.Epoch = uint64(epoch)
-	} else {
-		return errors.New("epoch missing")
-	}
-
-	if val, exists := v["validator_index"]; exists {
-		var ok bool
-		validatorIndex, ok := val.(float64)
-		if !ok {
-			return errors.New("validator_index invalid")
-		}
-		d.ValidatorIndex = uint64(validatorIndex)
-	} else {
-		return errors.New("validator_index missing")
-	}
-
-	if val, exists := v["signature"]; exists {
-		signatureBytes, ok := val.(string)
-		if !ok {
-			return errors.New("signature invalid")
-		}
-		signature, err := hex.DecodeString(strings.TrimPrefix(signatureBytes, "0x"))
-		if err != nil {
-			return errors.Wrap(err, "signature invalid")
-		}
-		d.Signature = signature
-	} else {
-		return errors.New("signature missing")
-	}
-
-	return nil
+func validatorExitBindings() {
+	if err := viper.BindPFlag("epoch", validatorExitCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("key", validatorExitCmd.Flags().Lookup("key")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("exit", validatorExitCmd.Flags().Lookup("exit")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", validatorExitCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
 }

cmd/validatorinfo.go

@@ -24,21 +24,18 @@ import (
 	"os"
 	"strconv"
 	"strings"
-	"time"
 
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	"github.com/wealdtech/ethdo/grpc"
 	"github.com/wealdtech/ethdo/util"
-	e2wallet "github.com/wealdtech/go-eth2-wallet"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 	string2eth "github.com/wealdtech/go-string2eth"
 )
 
-var validatorInfoPubKey string
-
 var validatorInfoCmd = &cobra.Command{
 	Use:   "info",
 	Short: "Obtain information about a validator",
@@ -48,78 +45,81 @@ var validatorInfoCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the validator information can be obtained, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(viper.GetString("account") != "" || validatorInfoPubKey != "", "--account or --pubkey is required")
+		ctx := context.Background()
 
-		err := connect()
-		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain node")
+		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
 		account, err := validatorInfoAccount()
 		errCheck(err, "Failed to obtain validator account")
 
+		pubKeys := make([]spec.BLSPubKey, 1)
+		pubKey, err := util.BestPublicKey(account)
+		errCheck(err, "Failed to obtain validator public key")
+		copy(pubKeys[0][:], pubKey.Marshal())
+		validators, err := eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, "head", pubKeys)
+		errCheck(err, "Failed to obtain validator information")
+		if len(validators) == 0 {
+			fmt.Println("Validator not known by beacon node")
+			os.Exit(_exitSuccess)
+		}
+
+		var validator *api.Validator
+		for _, v := range validators {
+			validator = v
+		}
+
 		if verbose {
-			network := network()
+			network, err := util.Network(ctx, eth2Client)
+			errCheck(err, "Failed to obtain network")
 			outputIf(debug, fmt.Sprintf("Network is %s", network))
 			pubKey, err := bestPublicKey(account)
 			if err == nil {
 				deposits, totalDeposited, err := graphData(network, pubKey.Marshal())
 				if err == nil {
 					fmt.Printf("Number of deposits: %d\n", deposits)
-					fmt.Printf("Total deposited: %s\n", string2eth.GWeiToString(totalDeposited, true))
+					fmt.Printf("Total deposited: %s\n", string2eth.GWeiToString(uint64(totalDeposited), true))
 				}
 			}
 		}
 
-		validatorInfo, err := grpc.FetchValidatorInfo(eth2GRPCConn, account)
-		errCheck(err, "Failed to obtain validator information")
-		validator, err := grpc.FetchValidator(eth2GRPCConn, account)
-		if err != nil {
-			// We can live with this.
-			validator = nil
-		}
-		if validatorInfo.Status != ethpb.ValidatorStatus_DEPOSITED &&
-			validatorInfo.Status != ethpb.ValidatorStatus_UNKNOWN_STATUS {
-			errCheck(err, "Failed to obtain validator definition")
-		}
-		assert(validatorInfo.Status != ethpb.ValidatorStatus_UNKNOWN_STATUS, "Not known as a validator")
-
 		if quiet {
 			os.Exit(_exitSuccess)
 		}
 
-		outputIf(verbose, fmt.Sprintf("Epoch of data: %v", validatorInfo.Epoch))
-		outputIf(verbose && validatorInfo.Status != ethpb.ValidatorStatus_DEPOSITED, fmt.Sprintf("Index: %v", validatorInfo.Index))
-		outputIf(verbose, fmt.Sprintf("Public key: %#x", validatorInfo.PublicKey))
-		fmt.Printf("Status: %s\n", strings.Title(strings.ToLower(validatorInfo.Status.String())))
-		fmt.Printf("Balance: %s\n", string2eth.GWeiToString(validatorInfo.Balance, true))
-
-		if validatorInfo.Status == ethpb.ValidatorStatus_ACTIVE ||
-			validatorInfo.Status == ethpb.ValidatorStatus_EXITING ||
-			validatorInfo.Status == ethpb.ValidatorStatus_SLASHING {
-			fmt.Printf("Effective balance: %s\n", string2eth.GWeiToString(validatorInfo.EffectiveBalance, true))
-		}
-
-		if validator != nil {
-			outputIf(verbose, fmt.Sprintf("Withdrawal credentials: %#x", validator.WithdrawalCredentials))
-		}
-
-		transition := time.Unix(int64(validatorInfo.TransitionTimestamp), 0)
-		transitionPassed := int64(validatorInfo.TransitionTimestamp) <= time.Now().Unix()
-		switch validatorInfo.Status {
-		case ethpb.ValidatorStatus_DEPOSITED:
-			if validatorInfo.TransitionTimestamp != 0 {
-				fmt.Printf("Inclusion in chain: %s\n", transition)
-			}
-		case ethpb.ValidatorStatus_PENDING:
-			fmt.Printf("Activation: %s\n", transition)
-		case ethpb.ValidatorStatus_EXITING, ethpb.ValidatorStatus_SLASHING:
-			fmt.Printf("Attesting finishes: %s\n", transition)
-		case ethpb.ValidatorStatus_EXITED:
-			if transitionPassed {
-				fmt.Printf("Funds withdrawable: Now\n")
-			} else {
-				fmt.Printf("Funds withdrawable: %s\n", transition)
+		if verbose {
+			if validator.Status.HasActivated() {
+				fmt.Printf("Index: %d\n", validator.Index)
 			}
+			fmt.Printf("Public key: %#x\n", validator.Validator.PublicKey)
 		}
+		fmt.Printf("Status: %v\n", validator.Status)
+		fmt.Printf("Balance: %s\n", string2eth.GWeiToString(uint64(validator.Balance), true))
+		if validator.Status.IsActive() {
+			fmt.Printf("Effective balance: %s\n", string2eth.GWeiToString(uint64(validator.Validator.EffectiveBalance), true))
+		}
+		if verbose {
+			fmt.Printf("Withdrawal credentials: %#x\n", validator.Validator.WithdrawalCredentials)
+		}
+
+		//		transition := time.Unix(int64(validatorInfo.TransitionTimestamp), 0)
+		//		transitionPassed := int64(validatorInfo.TransitionTimestamp) <= time.Now().Unix()
+		//		switch validatorInfo.Status {
+		//		case ethpb.ValidatorStatus_DEPOSITED:
+		//			if validatorInfo.TransitionTimestamp != 0 {
+		//				fmt.Printf("Inclusion in chain: %s\n", transition)
+		//			}
+		//		case ethpb.ValidatorStatus_PENDING:
+		//			fmt.Printf("Activation: %s\n", transition)
+		//		case ethpb.ValidatorStatus_EXITING, ethpb.ValidatorStatus_SLASHING:
+		//			fmt.Printf("Attesting finishes: %s\n", transition)
+		//		case ethpb.ValidatorStatus_EXITED:
+		//			if transitionPassed {
+		//				fmt.Printf("Funds withdrawable: Now\n")
+		//			} else {
+		//				fmt.Printf("Funds withdrawable: %s\n", transition)
+		//			}
+		//		}
 
 		os.Exit(_exitSuccess)
 	},
@@ -128,54 +128,41 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 // validatorInfoAccount obtains the account for the validator info command.
 func validatorInfoAccount() (e2wtypes.Account, error) {
 	var account e2wtypes.Account
-	if viper.GetString("account") != "" {
-		wallet, err := openWallet()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to open wallet")
-		}
-		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain account name")
-		}
-
-		if wallet.Type() == "hierarchical deterministic" && strings.HasPrefix(accountName, "m/") {
-			assert(getWalletPassphrase() != "", "walletpassphrase is required to obtain information about validators with dynamically generated hierarchical deterministic accounts")
-			locker, isLocker := wallet.(e2wtypes.WalletLocker)
-			if isLocker {
-				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-				defer cancel()
-				errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
-			}
-		}
-
-		accountByNameProvider, isProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
-		if !isProvider {
-			return nil, errors.New("failed to ask wallet for account by name")
-		}
+	var err error
+	switch {
+	case viper.GetString("account") != "":
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		account, err = accountByNameProvider.AccountByName(ctx, accountName)
+		_, account, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to obtain account")
 		}
-	} else {
-		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(validatorInfoPubKey, "0x"))
+	case viper.GetString("pubkey") != "":
+		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(viper.GetString("pubkey"), "0x"))
 		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", validatorInfoPubKey))
+			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", viper.GetString("pubkey")))
 		}
 		account, err = util.NewScratchAccount(nil, pubKeyBytes)
 		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", validatorInfoPubKey))
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", viper.GetString("pubkey")))
 		}
+	default:
+		return nil, errors.New("neither account nor public key supplied")
 	}
 	return account, nil
 }
 
 // graphData returns data from the graph about number and amount of deposits
-func graphData(network string, validatorPubKey []byte) (uint64, uint64, error) {
-	subgraph := fmt.Sprintf("attestantio/eth2deposits-%s", strings.ToLower(network))
+func graphData(network string, validatorPubKey []byte) (uint64, spec.Gwei, error) {
+	subgraph := ""
+	if network == "Mainnet" {
+		subgraph = "attestantio/eth2deposits"
+	} else {
+		subgraph = fmt.Sprintf("attestantio/eth2deposits-%s", strings.ToLower(network))
+	}
 	query := fmt.Sprintf(`{"query": "{deposits(where: {validatorPubKey:\"%#x\"}) { id amount withdrawalCredentials }}"}`, validatorPubKey)
 	url := fmt.Sprintf("https://api.thegraph.com/subgraphs/name/%s", subgraph)
+	// #nosec G107
 	graphResp, err := http.Post(url, "application/json", bytes.NewBufferString(query))
 	if err != nil {
 		return 0, 0, errors.Wrap(err, "failed to check if there is already a deposit for this validator")
@@ -203,7 +190,7 @@ func graphData(network string, validatorPubKey []byte) (uint64, uint64, error) {
 		return 0, 0, errors.Wrap(err, "invalid data returned from existing deposit check")
 	}
 	deposits := uint64(0)
-	totalDeposited := uint64(0)
+	totalDeposited := spec.Gwei(0)
 	if response.Data != nil && len(response.Data.Deposits) > 0 {
 		for _, deposit := range response.Data.Deposits {
 			deposits++
@@ -211,7 +198,7 @@ func graphData(network string, validatorPubKey []byte) (uint64, uint64, error) {
 			if err != nil {
 				return 0, 0, errors.Wrap(err, fmt.Sprintf("invalid deposit amount from pre-existing deposit %s", deposit.Amount))
 			}
-			totalDeposited += depositAmount
+			totalDeposited += spec.Gwei(depositAmount)
 		}
 	}
 	return deposits, totalDeposited, nil
@@ -219,6 +206,12 @@ func graphData(network string, validatorPubKey []byte) (uint64, uint64, error) {
 
 func init() {
 	validatorCmd.AddCommand(validatorInfoCmd)
-	validatorInfoCmd.Flags().StringVar(&validatorInfoPubKey, "pubkey", "", "Public key for which to obtain status")
+	validatorInfoCmd.Flags().String("pubkey", "", "Public key for which to obtain status")
 	validatorFlags(validatorInfoCmd)
 }
+
+func validatorInfoBindings() {
+	if err := viper.BindPFlag("pubkey", validatorInfoCmd.Flags().Lookup("pubkey")); err != nil {
+		panic(err)
+	}
+}

cmd/version.go

@@ -22,7 +22,9 @@ import (
 	"github.com/spf13/viper"
 )
 
-var ReleaseVersion = "local build from v1.5.3"
+// ReleaseVersion is the release version of the codebase.
+// Usually overrideen by tag names when building binaries.
+var ReleaseVersion = "local build (latest release 1.7.3)"
 
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{

cmd/wallet/create/input.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 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.GetString("remote") != "" {
+		return nil, errors.New("cannot create 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")
+
+	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()
+
+	// Mnemonic.
+	data.mnemonic = viper.GetString("mnemonic")
+
+	return data, nil
+}

cmd/wallet/create/input_internal_test.go

@@ -0,0 +1,124 @@
+// 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: "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("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}