Bump version

hd wallet creation requires a walletpassphrase

.github/workflows/release.yml

@@ -0,0 +1,120 @@
+name: Release
+
+on:
+  push:
+    tags:
+    - 'v*'
+
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+
+    - name: Set up Go 1.x
+      uses: actions/setup-go@v2
+      with:
+        go-version: ^1.13
+      id: go
+
+    - name: Check out code into the Go module directory
+      uses: actions/checkout@v2
+
+    - name: Get dependencies
+      run: |
+       go get -v -t -d ./...
+       if [ -f Gopkg.toml ]; then
+         curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh
+         dep ensure
+       fi
+
+    - name: Set env
+      run: |
+       echo "GO111MODULE=on" >> $GITHUB_ENV
+       # Release tag comes from the github reference.
+       RELEASE_TAG=$(echo ${GITHUB_REF} | sed -e 's!.*/!!')
+       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 "RELEASE_VERSION=${RELEASE_VERSION}" >> $GITHUB_ENV
+       echo "::set-output name=RELEASE_VERSION::${RELEASE_VERSION}"
+
+    - name: Build
+      run: go build -v -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" .
+
+    - name: Test
+      run: go test -v .
+
+    - name: Fetch xgo
+      run: |
+       go get github.com/suburbandad/xgo
+
+    - 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: 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 zip file
+      run: |
+       mv ethdo-windows-4.0-amd64.exe ethdo.exe
+       zip --junk-paths ethdo-${RELEASE_VERSION}-windows-exe.zip ethdo.exe
+
+    - name: Create linux AMD64 tgz file
+      run: |
+       mv ethdo-linux-amd64 ethdo
+       tar zcf ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz ethdo
+
+    - name: Create linux ARM64 tgz file
+      run: |
+       mv ethdo-linux-arm64 ethdo
+       tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz ethdo
+
+    - name: Create release
+      id: create_release
+      uses: actions/create-release@v1
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      with:
+        tag_name: ${{ github.ref }}
+        release_name: Release ${{ env.RELEASE_VERSION }}
+        draft: false
+        prerelease: false
+       
+    - name: Upload windows zip file
+      id: upload-release-asset-windows
+      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-exe.zip
+        asset_name: ethdo-${{ env.RELEASE_VERSION }}-windows-exe.zip
+        asset_content_type: application/zip
+       
+    - name: Upload linux AMD64 tgz file
+      id: upload-release-asset-linux-amd64
+      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.tar.gz
+        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.tar.gz
+        asset_content_type: application/gzip
+       
+    - name: Upload linux ARM64 tgz file
+      id: upload-release-asset-linux-arm64
+      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.tar.gz
+        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.tar.gz
+        asset_content_type: application/gzip

CHANGELOG.md

@@ -0,0 +1,29 @@
+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,12 +5,12 @@
 
 A command-line tool for managing common tasks in Ethereum 2.
 
-** Please note that this library uses standards that are not yet final, and as such may result in changes that alter public and private keys.  Do not use this library for production use just yet **
-
 ## Table of Contents
 
 - [Install](#install)
+  - [Binaries](#binaries)
   - [Docker](#docker)
+  - [Source](#source)
 - [Usage](#usage)
 - [Maintainers](#maintainers)
 - [Contribute](#contribute)
@@ -18,6 +18,19 @@ A command-line tool for managing common tasks in Ethereum 2.
 
 ## Install
 
+### Binaries
+
+Binaries for the latest version of `ethdo` can be obtained from [the releases page](https://github.com/wealdtech/ethdo/releases).
+
+### Docker
+
+You can obtain the latest version of `ethdo` using docker with:
+
+```
+docker pull wealdtech/ethdo
+```
+
+### Source
 `ethdo` is a standard Go program which can be installed with:
 
 ```sh
@@ -28,15 +41,7 @@ Note that `ethdo` requires at least version 1.13 of go to operate.  The version
 
 If this does not work please see the [troubleshooting](https://github.com/wealdtech/ethdo/blob/master/docs/troubleshooting.md) page.
 
-### Docker
-
-You can obtain the latest version of `ethdo` using docker with:
-
-```
-docker pull wealdtech/ethdo
-```
-
-Or build `ethdo` using docker:
+The docker image can be build locally with:
 
 ```sh
 docker build -t ethdo .
@@ -83,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".
 
@@ -118,18 +123,38 @@ 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:
+
+  - commands that require passphrases to operate, for example unlocking an account, can be supplied with multiple passphrases.  If they are, then each passphrase is tried until one succeeds or they all fail
+  - commands that require passphrases to create, for example creating an account, must be supplied with a single passphrase.  If more than one passphrase is supplied the command will fail
+
+In addition, the following rules apply to passphrases supplied on the command line:
+
+  - passphrases **must not** start with `0x`
+  - passphrases **must not** contain the comma (,) character
+
 # Commands
 
 Command information, along with sample outputs and optional arguments, is available in [the usage section](https://github.com/wealdtech/ethdo/blob/master/docs/usage.md).
 
 # 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
 
 Jim McDonald: [@mcdee](https://github.com/mcdee).
 
+Special thanks to [@SuburbanDad](https://github.com/SuburbanDad) for updating xgo to allow for cross-compilation of `ethdo` releaes.
+
 ## Contribute
 
 Contributions welcome. Please check out [the issues](https://github.com/wealdtech/ethdo/issues).

cmd/account/create/input.go

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

cmd/account/create/input_internal_test.go

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

cmd/account/create/output.go

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

cmd/account/create/output_internal_test.go

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

cmd/account/create/process.go

@@ -0,0 +1,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/import/input.go

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

cmd/account/import/input_internal_test.go

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

cmd/account/import/output.go

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

cmd/account/import/output_internal_test.go

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

cmd/account/import/process.go

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

cmd/account/key/input_internal_test.go

@@ -0,0 +1,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

@@ -1,4 +1,4 @@
-// Copyright © 2019 Weald Technology Trading
+// 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
@@ -15,9 +15,10 @@ package cmd
 
 import (
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	accountcreate "github.com/wealdtech/ethdo/cmd/account/create"
 )
 
 var accountCreateCmd = &cobra.Command{
@@ -28,35 +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(!remote, "account create not available with remote wallets")
-		assert(rootAccount != "", "--account is required")
-		assert(rootAccountPassphrase != "", "--passphrase is required")
-
-		w, err := walletFromPath(rootAccount)
-		errCheck(err, "Failed to access wallet")
-
-		if w.Type() == "hierarchical deterministic" {
-			assert(rootWalletPassphrase != "", "--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
 		}
-		_, err = accountFromPath(rootAccount)
-		assert(err != nil, "Account already exists")
-
-		err = w.Unlock([]byte(rootWalletPassphrase))
-		errCheck(err, "Failed to unlock wallet")
-
-		_, accountName, err := walletAndAccountNamesFromPath(rootAccount)
-		errCheck(err, "Failed to obtain accout name")
-
-		account, err := w.CreateAccount(accountName, []byte(rootAccountPassphrase))
-		errCheck(err, "Failed to create account")
-
-		outputIf(verbose, fmt.Sprintf("0x%048x", account.PublicKey().Marshal()))
-		os.Exit(_exitSuccess)
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
 func init() {
 	accountCmd.AddCommand(accountCreateCmd)
 	accountFlags(accountCreateCmd)
+	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)
+	}
+	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/accountimport.go

@@ -15,15 +15,12 @@ package cmd
 
 import (
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/go-bytesutil"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
+	"github.com/spf13/viper"
+	accountimport "github.com/wealdtech/ethdo/cmd/account/import"
 )
 
-var accountImportKey string
-
 var accountImportCmd = &cobra.Command{
 	Use:   "import",
 	Short: "Import an account",
@@ -32,40 +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(rootAccount != "", "--account is required")
-		assert(rootAccountPassphrase != "", "--passphrase is required")
-		assert(accountImportKey != "", "--key is required")
-
-		key, err := bytesutil.FromHexString(accountImportKey)
-		errCheck(err, "Invalid key")
-
-		w, err := walletFromPath(rootAccount)
-		errCheck(err, "Failed to access wallet")
-
-		_, ok := w.(types.WalletAccountImporter)
-		assert(ok, fmt.Sprintf("wallets of type %q do not allow importing accounts", w.Type()))
-
-		_, err = accountFromPath(rootAccount)
-		assert(err != nil, "Account already exists")
-
-		err = w.Unlock([]byte(rootWalletPassphrase))
-		errCheck(err, "Failed to unlock wallet")
-
-		_, accountName, err := walletAndAccountNamesFromPath(rootAccount)
-		errCheck(err, "Failed to obtain account name")
-
-		account, err := w.(types.WalletAccountImporter).ImportAccount(accountName, key, []byte(rootAccountPassphrase))
-		errCheck(err, "Failed to create account")
-
-		outputIf(verbose, fmt.Sprintf("0x%048x", account.PublicKey().Marshal()))
-		os.Exit(_exitSuccess)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountimport.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		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

@@ -19,7 +19,10 @@ import (
 	"os"
 
 	"github.com/spf13/cobra"
-	pb "github.com/wealdtech/eth2-signer-api/pb/v1"
+	"github.com/spf13/viper"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	util "github.com/wealdtech/go-eth2-util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var accountInfoCmd = &cobra.Command{
@@ -31,27 +34,48 @@ 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(rootAccount != "", "--account is required")
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
 
-		if remote {
-			listerClient := pb.NewListerClient(remoteGRPCConn)
-			listAccountsReq := &pb.ListAccountsRequest{
-				Paths: []string{
-					rootAccount,
-				},
+		assert(viper.GetString("account") != "", "--account is required")
+		wallet, account, err := walletAndAccountFromInput(ctx)
+		errCheck(err, "Failed to obtain account")
+
+		// Disallow wildcards (for now)
+		assert(fmt.Sprintf("%s/%s", wallet.Name(), account.Name()) == viper.GetString("account"), "Mismatched account name")
+
+		if quiet {
+			os.Exit(_exitSuccess)
+		}
+
+		outputIf(verbose, fmt.Sprintf("UUID: %v", account.ID()))
+		var withdrawalPubKey e2types.PublicKey
+		if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
+			fmt.Printf("Public key: %#x\n", pubKeyProvider.PublicKey().Marshal())
+			// May be overwritten later, but grab it for now.
+			withdrawalPubKey = pubKeyProvider.PublicKey()
+		}
+		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)
+				}
 			}
-			resp, err := listerClient.ListAccounts(context.Background(), listAccountsReq)
-			errCheck(err, "Failed to access account")
-			assert(resp.State == pb.ResponseState_SUCCEEDED, "No such account")
-			assert(len(resp.Accounts) == 1, "No such account")
-			fmt.Printf("Public key: %#048x\n", resp.Accounts[0].PublicKey)
 
-		} else {
-			account, err := accountFromPath(rootAccount)
-			errCheck(err, "Failed to access wallet")
-			outputIf(verbose, fmt.Sprintf("UUID: %v", account.ID()))
-			outputIf(!quiet, fmt.Sprintf("Public key: %#048x", account.PublicKey().Marshal()))
-			outputIf(verbose && account.Path() != "", fmt.Sprintf("Path: %s", account.Path()))
+			withdrawalPubKey = distributedAccount.CompositePublicKey()
+		}
+		if verbose {
+			withdrawalCredentials := util.SHA256(withdrawalPubKey.Marshal())
+			withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
+			fmt.Printf("Withdrawal credentials: %#x\n", withdrawalCredentials)
+		}
+		if pathProvider, ok := account.(e2wtypes.AccountPathProvider); ok {
+			if pathProvider.Path() != "" {
+				fmt.Printf("Path: %s\n", pathProvider.Path())
+			}
 		}
 
 		os.Exit(_exitSuccess)

cmd/accountkey.go

@@ -15,10 +15,10 @@ package cmd
 
 import (
 	"fmt"
-	"os"
 
 	"github.com/spf13/cobra"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
+	"github.com/spf13/viper"
+	accountkey "github.com/wealdtech/ethdo/cmd/account/key"
 )
 
 // accountKeyCmd represents the account key command
@@ -30,26 +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(rootAccount != "", "--account is required")
-
-		account, err := accountFromPath(rootAccount)
-		errCheck(err, "Failed to access account")
-
-		_, ok := account.(types.AccountPrivateKeyProvider)
-		assert(ok, fmt.Sprintf("account %q does not provide its private key", rootAccount))
-
-		assert(rootAccountPassphrase != "", "--passphrase is required")
-		err = account.Unlock([]byte(rootAccountPassphrase))
-		errCheck(err, "Failed to unlock account to obtain private key")
-		defer account.Lock()
-		privateKey, err := account.(types.AccountPrivateKeyProvider).PrivateKey()
-		errCheck(err, "Failed to obtain private key")
-		account.Lock()
-
-		outputIf(!quiet, fmt.Sprintf("%#064x", privateKey.Marshal()))
-		os.Exit(_exitSuccess)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := accountkey.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 

cmd/accountlock.go

@@ -15,11 +15,10 @@ package cmd
 
 import (
 	"context"
-	"os"
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	pb "github.com/wealdtech/eth2-signer-api/pb/v1"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var accountLockCmd = &cobra.Command{
@@ -31,26 +30,19 @@ 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(remote, "account lock only works with remote wallets")
-		assert(rootAccount != "", "--account is required")
-
-		client := pb.NewAccountManagerClient(remoteGRPCConn)
-		lockReq := &pb.LockAccountRequest{
-			Account: rootAccount,
-		}
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		resp, err := client.Lock(ctx, lockReq)
-		errCheck(err, "Failed in attempt to lock account")
-		switch resp.State {
-		case pb.ResponseState_DENIED:
-			die("Lock request denied")
-		case pb.ResponseState_FAILED:
-			die("Lock request failed")
-		case pb.ResponseState_SUCCEEDED:
-			outputIf(!quiet, "Lock request succeeded")
-			os.Exit(_exitSuccess)
-		}
+
+		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")
+
+		err = locker.Lock(ctx)
+		errCheck(err, "Failed to lock account")
 	},
 }
 

cmd/accountunlock.go

@@ -19,7 +19,7 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	pb "github.com/wealdtech/eth2-signer-api/pb/v1"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var accountUnlockCmd = &cobra.Command{
@@ -31,27 +31,31 @@ 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(remote, "account unlock only works with remote wallets")
-		assert(rootAccount != "", "--account is required")
-
-		client := pb.NewAccountManagerClient(remoteGRPCConn)
-		unlockReq := &pb.UnlockAccountRequest{
-			Account:    rootAccount,
-			Passphrase: []byte(rootAccountPassphrase),
-		}
 		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 		defer cancel()
-		resp, err := client.Unlock(ctx, unlockReq)
-		errCheck(err, "Failed in attempt to unlock account")
-		switch resp.State {
-		case pb.ResponseState_DENIED:
-			die("Unlock request denied")
-		case pb.ResponseState_FAILED:
-			die("Unlock request failed")
-		case pb.ResponseState_SUCCEEDED:
-			outputIf(!quiet, "Unlock request succeeded")
-			os.Exit(_exitSuccess)
+
+		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 unlocking")
+
+		unlocked := false
+		for _, passphrase := range getPassphrases() {
+			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+			err := locker.Unlock(ctx, []byte(passphrase))
+			cancel()
+			if err == nil {
+				// Success.
+				unlocked = true
+				break
+			}
 		}
+
+		assert(unlocked, "Failed to unlock account")
+		os.Exit(_exitSuccess)
 	},
 }
 

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,130 @@
+// 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/core"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// 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")
+	}
+
+	// Epoch
+	epoch := viper.GetInt64("epoch")
+	if epoch == -1 {
+		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)
+		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)
+
+	pubKeys := make([]spec.BLSPubKey, 1)
+	pubKey, err := core.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, fmt.Sprintf("%d", uint64(data.epoch)*data.slotsPerEpoch), pubKeys)
+	if err != nil {
+		return nil, errors.New("failed to obtain validator information")
+	}
+	data.validator = validators[0]
+
+	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 = core.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 nil, errors.New("not found")
+}
+
+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,25 +14,13 @@
 package cmd
 
 import (
-	"bytes"
-	"encoding/hex"
 	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"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",
@@ -41,205 +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")
-
-		if blockInfoStream {
-			stream, err := grpc.StreamBlocks(eth2GRPCConn)
-			errCheck(err, "Failed to obtain block stream")
-			for {
-				signedBlock, err := stream.Recv()
-				errCheck(err, "Failed to obtain block")
-				if signedBlock != nil {
-					fmt.Println("")
-					outputBlock(signedBlock)
-				}
-			}
-
-		} else {
-			assert(blockInfoSlot != 0, "--slot is required")
-			var slot uint64
-			if blockInfoSlot < 0 {
-				slot, err = grpc.FetchLatestFilledSlot(eth2GRPCConn)
-			} else {
-				slot = uint64(blockInfoSlot)
-			}
-			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)
-			}
-			outputBlock(signedBlock)
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := blockinfo.Run(cmd)
+		if err != nil {
+			return err
 		}
-
-		os.Exit(_exitSuccess)
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
 	},
 }
 
-func outputBlock(signedBlock *ethpb.SignedBeaconBlock) {
-	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("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))
-
-	// Attestations.
-	fmt.Printf("Attestations: %d\n", len(body.Attestations))
-	if verbose {
-		for i, att := range body.Attestations {
-			fmt.Printf("\t%d:\n", i)
-
-			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\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)
-				}
-			}
-		}
-	}
-
-	// TODO Proposer slashings once proposer slashings exist.
-
-	// 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 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,23 +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)
 		}
 
-		fmt.Printf("Genesis time: %s\n", genesisTime.Format(time.UnixDate))
-		outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", 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)))
+		if genesis.GenesisTime.Unix() == 0 {
+			fmt.Println("Genesis time: undefined")
+		} else {
+			fmt.Printf("Genesis time: %s\n", genesis.GenesisTime.Format(time.UnixDate))
+			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesis.GenesisTime.Unix()))
+		}
+		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)
 	},
@@ -58,9 +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 time.Time, slot spec.Slot, slotDuration time.Duration) int64 {
+	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())
+}
+
+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,58 +35,49 @@ 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)
+		}
+		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)
 		}
 
-		slot := timestampToSlot(genesisTime.Unix(), time.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.GetJustifiedSlot()/slotsPerEpoch)
-			if verbose {
-				distance := (slot - info.GetJustifiedSlot()) / slotsPerEpoch
-				fmt.Printf("Justified epoch distance %d\n", distance)
-			}
-			fmt.Printf("Finalized epoch: %d\n", info.GetFinalizedSlot()/slotsPerEpoch)
-			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)
-			}
+		if verbose {
+			epochStartSlot := (uint64(curSlot) / slotsPerEpoch) * slotsPerEpoch
+			fmt.Printf("Epoch slots: %d-%d\n", epochStartSlot, epochStartSlot+slotsPerEpoch-1)
+			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)
 		}
 
 		os.Exit(_exitSuccess)
@@ -94,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/deposit.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"
+)
+
+// depositCmd represents the deposit command
+var depositCmd = &cobra.Command{
+	Use:   "deposit",
+	Short: "Manage Ethereum 2 deposits",
+	Long:  `Manage Ethereum 2 deposits.`,
+}
+
+func init() {
+	RootCmd.AddCommand(depositCmd)
+}
+
+func depositFlags(cmd *cobra.Command) {
+}

cmd/depositverify.go

@@ -0,0 +1,227 @@
+// 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 (
+	"bytes"
+	"encoding/hex"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"github.com/pkg/errors"
+	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	"github.com/spf13/cobra"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	eth2util "github.com/wealdtech/go-eth2-util"
+	string2eth "github.com/wealdtech/go-string2eth"
+)
+
+var depositVerifyData string
+var depositVerifyWithdrawalPubKey string
+var depositVerifyValidatorPubKey string
+var depositVerifyDepositAmount string
+
+var depositVerifyCmd = &cobra.Command{
+	Use:   "verify",
+	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 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 is verified correctly, otherwise 1.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		assert(depositVerifyData != "", "--data is required")
+		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")
+
+		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")
+			withdrawalCredentials = eth2util.SHA256(withdrawalPubKey.Marshal())
+			withdrawalCredentials[0] = 0 // BLS_WITHDRAWAL_PREFIX
+		}
+		outputIf(debug, fmt.Sprintf("Withdrawal credentials are %#x", withdrawalCredentials))
+
+		depositAmount := uint64(0)
+		if depositVerifyDepositAmount != "" {
+			depositAmount, err = string2eth.StringToGWei(depositVerifyDepositAmount)
+			errCheck(err, "Invalid value")
+			assert(depositAmount >= 1000000000, "deposit amount must be at least 1 Ether") // MIN_DEPOSIT_AMOUNT
+		}
+
+		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 deposit.Amount == 0 {
+				deposit.Amount = depositAmount
+			}
+			verified, err := verifyDeposit(deposit, withdrawalCredentials, validatorPubKeys, depositAmount)
+			errCheck(err, fmt.Sprintf("Error attempting to verify deposit %d", i))
+			if !verified {
+				failures = true
+				outputIf(!quiet, fmt.Sprintf("Deposit %q failed verification", deposit.Name))
+			} else {
+				outputIf(quiet, fmt.Sprintf("Deposit %q verified", deposit.Name))
+			}
+		}
+
+		if failures {
+			os.Exit(_exitFailure)
+		}
+		os.Exit(_exitSuccess)
+	},
+}
+
+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.
+	if strings.HasPrefix(input, "0x") {
+		// Looks like a public key.
+		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(input, "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, "public key is not a hex string")
+		}
+		if len(pubKeyBytes) != 48 {
+			return nil, errors.New("public key should be 48 bytes")
+		}
+		pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, "invalid public key")
+		}
+		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.ReplaceAll(data, []byte("\r\n"), []byte("\n")), []byte("\n"))
+		if len(lines) == 0 {
+			return nil, errors.New("file has no public keys")
+		}
+		for _, line := range lines {
+			if len(line) == 0 {
+				continue
+			}
+			pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(string(line), "0x"))
+			if err != nil {
+				return nil, errors.Wrap(err, "public key is not a hex string")
+			}
+			if len(pubKeyBytes) != 48 {
+				return nil, errors.New("public key should be 48 bytes")
+			}
+			pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)
+			if err != nil {
+				return nil, errors.Wrap(err, "invalid public key")
+			}
+			var key [48]byte
+			copy(key[:], pubKey.Marshal())
+			pubKeys[key] = true
+		}
+	}
+
+	return pubKeys, nil
+}
+
+func verifyDeposit(deposit *util.DepositInfo, withdrawalCredentials []byte, validatorPubKeys map[[48]byte]bool, amount uint64) (bool, error) {
+	if withdrawalCredentials != nil {
+		if !bytes.Equal(deposit.WithdrawalCredentials, withdrawalCredentials) {
+			return false, errors.New("withdrawal credentials incorrect")
+		}
+		outputIf(verbose, "Withdrawal credentials verified")
+	}
+	if amount != 0 {
+		if deposit.Amount != amount {
+			return false, errors.New("deposit value incorrect")
+		}
+		outputIf(verbose, "Amount verified")
+	}
+
+	if len(validatorPubKeys) != 0 {
+		var key [48]byte
+		copy(key[:], deposit.PublicKey)
+		if _, exists := validatorPubKeys[key]; !exists {
+			return false, errors.New("validator public key incorrect")
+		}
+		outputIf(verbose, "Validator public key verified")
+	}
+
+	depositData := &ethpb.Deposit_Data{
+		PublicKey:             deposit.PublicKey,
+		WithdrawalCredentials: deposit.WithdrawalCredentials,
+		Amount:                deposit.Amount,
+		Signature:             deposit.Signature,
+	}
+	depositDataRoot, err := depositData.HashTreeRoot()
+	if err != nil {
+		return false, errors.Wrap(err, "failed to generate deposit data root")
+	}
+	if !bytes.Equal(deposit.DepositDataRoot, depositDataRoot[:]) {
+		return false, errors.New("deposit data root incorrect")
+	}
+	outputIf(debug, "Deposit data root verified")
+
+	outputIf(verbose, "Deposit verified")
+
+	return true, nil
+}
+
+func init() {
+	depositCmd.AddCommand(depositVerifyCmd)
+	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(&depositVerifyDepositAmount, "depositvalue", "", "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")
+}

cmd/err.go

@@ -57,10 +57,10 @@ func assert(condition bool, msg string) {
 
 // die prints an error and quits
 func die(msg string) {
-	if !quiet {
+	if msg != "" && !quiet {
 		fmt.Fprintf(os.Stderr, "%s\n", msg)
 	}
-	os.Exit(1)
+	os.Exit(_exitFailure)
 }
 
 // warnCheck checks for an error and warns if it is present

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,141 @@
+// 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.data") != "", "exit data is required")
+		data, err := obtainExitData(viper.GetString("exit.Data"))
+		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[:])
+		exit := &spec.VoluntaryExit{
+			Epoch:          data.Data.Message.Epoch,
+			ValidatorIndex: data.Data.Message.ValidatorIndex,
+		}
+		sig, err := e2types.BLSSignatureFromBytes(data.Data.Signature[:])
+		errCheck(err, "Invalid signature")
+		verified, err := verifyStruct(account, exit, domain, 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("data", "", "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("data", exitVerifyCmd.Flags().Lookup("data")); err != nil {
+		panic(err)
+	}
+}

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,34 +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)
 
-		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

@@ -0,0 +1,28 @@
+// 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/viper"
+)
+
+// getWalletPassphrases() fetches the wallet passphrase supplied by the user.
+func getWalletPassphrase() string {
+	return viper.GetString("wallet-passphrase")
+}
+
+// getPassphrases() fetches the passphrases supplied by the user.
+func getPassphrases() []string {
+	return viper.GetStringSlice("passphrase")
+}

cmd/root.go

@@ -15,29 +15,22 @@ package cmd
 
 import (
 	"context"
-	"crypto/tls"
-	"crypto/x509"
 	"fmt"
-	"io/ioutil"
 	"os"
-	"regexp"
-	"sort"
+	"strconv"
 	"strings"
 	"time"
 
 	homedir "github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	"github.com/wealdtech/ethdo/util"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
-	filesystem "github.com/wealdtech/go-eth2-wallet-store-filesystem"
-	s3 "github.com/wealdtech/go-eth2-wallet-store-s3"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-
-	wallet "github.com/wealdtech/go-eth2-wallet"
-	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	dirk "github.com/wealdtech/go-eth2-wallet-dirk"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var cfgFile string
@@ -45,57 +38,52 @@ var quiet bool
 var verbose bool
 var debug bool
 
-// Root variables, present for all commands.
-var rootStore string
-var rootAccount string
-var rootBaseDir string
-var rootStorePassphrase string
-var rootWalletPassphrase string
-var rootAccountPassphrase string
-
-// Store for wallet actions.
-var store wtypes.Store
-
-// Remote connection.
-var remote bool
-var remoteAddr string
-var clientCert string
-var clientKey string
-var serverCACert string
-var remoteGRPCConn *grpc.ClientConn
-
-// 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")
-	rootAccount = viper.GetString("account")
-	rootBaseDir = viper.GetString("basedir")
-	rootStorePassphrase = viper.GetString("storepassphrase")
-	rootWalletPassphrase = viper.GetString("walletpassphrase")
-	rootAccountPassphrase = viper.GetString("passphrase")
+	// Command-specific bindings.
+	switch fmt.Sprintf("%s/%s", cmd.Parent().Name(), cmd.Name()) {
+	case "account/create":
+		accountCreateBindings()
+	case "account/import":
+		accountImportBindings()
+	case "attester/inclusion":
+		attesterInclusionBindings()
+	case "block/info":
+		blockInfoBindings()
+	case "exit/verify":
+		exitVerifyBindings()
+	case "validator/depositdata":
+		validatorDepositdataBindings()
+	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")
@@ -104,32 +92,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(rootBaseDir == "", "--basedir does not apply for the s3 store")
-			var err error
-			store, err = s3.New(s3.WithPassphrase([]byte(rootStorePassphrase)))
-			errCheck(err, "Failed to access Amazon S3 wallet store")
-		case "filesystem":
-			opts := make([]filesystem.Option, 0)
-			if rootStorePassphrase != "" {
-				opts = append(opts, filesystem.WithPassphrase([]byte(rootStorePassphrase)))
-			}
-			if rootBaseDir != "" {
-				opts = append(opts, filesystem.WithLocation(rootBaseDir))
-			}
-			store = filesystem.New(opts...)
-		default:
-			die(fmt.Sprintf("Unsupported wallet store %s", rootStore))
-		}
-		err := wallet.UseStore(store)
-		errCheck(err, "Failed to use defined wallet store")
-	} else {
-		err := initRemote()
-		errCheck(err, "Failed to connect to remote wallet")
+	if err := core.SetupStore(); err != nil {
+		return err
 	}
+
+	return nil
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -167,15 +134,36 @@ func init() {
 	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("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("walletpassphrase", RootCmd.PersistentFlags().Lookup("walletpassphrase")); err != nil {
 		panic(err)
 	}
-	RootCmd.PersistentFlags().String("passphrase", "", "Passphrase for account (if applicable)")
+	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)")
 	if err := viper.BindPFlag("passphrase", RootCmd.PersistentFlags().Lookup("passphrase")); err != nil {
 		panic(err)
 	}
@@ -191,7 +179,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)
 	}
@@ -215,6 +203,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,6 +229,7 @@ func initConfig() {
 	}
 
 	viper.SetEnvPrefix("ETHDO")
+	viper.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
 	viper.AutomaticEnv() // read in environment variables that match
 
 	// If a config file is found, read it in.
@@ -252,209 +249,125 @@ func outputIf(condition bool, msg string) {
 	}
 }
 
-// walletAndAccountNamesFromPath breaks a path in to wallet and account names.
-func walletAndAccountNamesFromPath(path string) (string, string, error) {
-	if len(path) == 0 {
-		return "", "", errors.New("invalid account format")
+// 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"))
 	}
-	index := strings.Index(path, "/")
-	if index == -1 {
-		// Just the wallet
-		return path, "", nil
-	}
-	if index == len(path)-1 {
-		// Trailing /
-		return path[:index], "", nil
-	}
-	return path[:index], path[index+1:], nil
+	return walletFromPath(ctx, viper.GetString("wallet"))
 }
 
 // walletFromPath obtains a wallet given a path specification.
-func walletFromPath(path string) (wtypes.Wallet, error) {
-	walletName, _, err := walletAndAccountNamesFromPath(path)
+func walletFromPath(ctx context.Context, path string) (e2wtypes.Wallet, error) {
+	walletName, _, err := e2wallet.WalletAndAccountNames(path)
 	if err != nil {
 		return nil, err
 	}
-	w, err := wallet.OpenWallet(walletName)
+	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") {
 			return nil, errors.New("Incorrect store passphrase")
 		}
 		return nil, err
 	}
-	return w, nil
+	return wallet, nil
 }
 
-// accountFromPath obtains an account given a path specification.
-func accountFromPath(path string) (wtypes.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 := walletAndAccountNamesFromPath(path)
+	_, 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/") {
-		assert(rootWalletPassphrase != "", "--walletpassphrase is required for direct path derivations")
-		err = wallet.Unlock([]byte(rootWalletPassphrase))
-		if err != nil {
-			return nil, errors.New("invalid wallet passphrase")
+		assert(getWalletPassphrase() != "", "--walletpassphrase is required for direct path derivations")
+
+		locker, isLocker := wallet.(e2wtypes.WalletLocker)
+		if isLocker {
+			err = locker.Unlock(ctx, []byte(util.GetWalletPassphrase()))
+			if err != nil {
+				return nil, nil, errors.New("failed to unlock wallet")
+			}
+			defer relockAccount(locker)
 		}
-		defer wallet.Lock()
 	}
-	return wallet.AccountByName(accountName)
+
+	accountByNameProvider, isAccountByNameProvider := wallet.(e2wtypes.WalletAccountByNameProvider)
+	if !isAccountByNameProvider {
+		return nil, nil, errors.New("wallet cannot obtain accounts by name")
+	}
+	account, err := accountByNameProvider.AccountByName(ctx, accountName)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to obtain account")
+	}
+	return wallet, account, nil
 }
 
-// accountsFromPath obtains 0 or more accounts given a path specification.
-func accountsFromPath(path string) ([]wtypes.Account, error) {
-	accounts := make([]wtypes.Account, 0)
-
-	// Quick check to see if it's a single account
-	account, err := accountFromPath(path)
-	if err == nil && account != nil {
-		accounts = append(accounts, account)
-		return accounts, nil
-	}
-
-	wallet, err := walletFromPath(path)
-	if err != nil {
-		return nil, err
-	}
-	_, accountSpec, err := walletAndAccountNamesFromPath(path)
-	if err != nil {
-		return nil, err
-	}
-
-	if accountSpec == "" {
-		accountSpec = "^.*$"
+// bestPublicKey returns the best public key for operations.
+// It prefers the composite public key if present, otherwise the public key.
+func bestPublicKey(account e2wtypes.Account) (e2types.PublicKey, error) {
+	var pubKey e2types.PublicKey
+	publicKeyProvider, isCompositePublicKeyProvider := account.(e2wtypes.AccountCompositePublicKeyProvider)
+	if isCompositePublicKeyProvider {
+		pubKey = publicKeyProvider.CompositePublicKey()
 	} else {
-		accountSpec = fmt.Sprintf("^%s$", accountSpec)
-	}
-	re := regexp.MustCompile(accountSpec)
-
-	for account := range wallet.Accounts() {
-		if re.Match([]byte(account.Name())) {
-			accounts = append(accounts, account)
+		publicKeyProvider, isPublicKeyProvider := account.(e2wtypes.AccountPublicKeyProvider)
+		if isPublicKeyProvider {
+			pubKey = publicKeyProvider.PublicKey()
+		} else {
+			return nil, errors.New("account does not provide a public key")
 		}
 	}
-
-	// Tidy up accounts by name.
-	sort.Slice(accounts, func(i, j int) bool {
-		return accounts[i].Name() < accounts[j].Name()
-	})
-
-	return accounts, nil
+	return pubKey, nil
 }
 
-// signStruct signs an arbitrary structure.
-func signStruct(account wtypes.Account, data interface{}, domain []byte) (e2types.Signature, error) {
-	objRoot, err := ssz.HashTreeRoot(data)
-	outputIf(debug, fmt.Sprintf("Object root is %x", objRoot))
-	if err != nil {
-		return nil, err
-	}
-
-	return signRoot(account, objRoot, domain)
-}
-
-// SigningContainer is the container for signing roots with a domain.
-// Contains SSZ sizes to allow for correct calculation of root.
-type SigningContainer struct {
-	Root   []byte `ssz-size:"32"`
-	Domain []byte `ssz-size:"32"`
-}
-
-// signRoot signs a root.
-func signRoot(account wtypes.Account, root [32]byte, domain []byte) (e2types.Signature, error) {
-	container := &SigningContainer{
-		Root:   root[:],
-		Domain: domain,
-	}
-	outputIf(debug, fmt.Sprintf("Signing container:\n\troot: %x\n\tdomain: %x", container.Root, container.Domain))
-	signingRoot, err := ssz.HashTreeRoot(container)
-	if err != nil {
-		return nil, err
-	}
-	outputIf(debug, fmt.Sprintf("Signing root: %x", signingRoot))
-	return sign(account, signingRoot[:])
-}
-
-// sign signs arbitrary data.
-func sign(account wtypes.Account, data []byte) (e2types.Signature, error) {
-	if !account.IsUnlocked() {
-		return nil, errors.New("account must be unlocked to sign")
-	}
-
-	outputIf(debug, fmt.Sprintf("Signing %x (%d)", data, len(data)))
-	return account.Sign(data)
-}
-
-// connect connects to an Ethereum 2 endpoint.
-func connect() error {
-	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
-}
-
-func initRemote() error {
-	remote = true
-	remoteAddr = viper.GetString("remote")
-	clientCert = viper.GetString("client-cert")
-	assert(clientCert != "", "--remote requires --client-cert")
-	clientKey = viper.GetString("client-key")
-	assert(clientKey != "", "--remote requires --client-key")
-	serverCACert = viper.GetString("server-ca-cert")
-	assert(serverCACert != "", "--remote requires --server-ca-cert")
-
-	// Load the client certificates.
-	clientPair, err := tls.LoadX509KeyPair(clientCert, clientKey)
-	if err != nil {
-		return errors.Wrap(err, "failed to access client certificate/key")
-	}
-
-	tlsCfg := &tls.Config{
-		Certificates: []tls.Certificate{clientPair},
-	}
-	if serverCACert != "" {
-		// Load the CA for the server certificate.
-		serverCA, err := ioutil.ReadFile(serverCACert)
+// remotesToEndpoints generates endpoints from remote addresses.
+func remotesToEndpoints(remotes []string) ([]*dirk.Endpoint, error) {
+	endpoints := make([]*dirk.Endpoint, 0)
+	for _, remote := range remotes {
+		parts := strings.Split(remote, ":")
+		if len(parts) != 2 {
+			return nil, fmt.Errorf("invalid remote %q", remote)
+		}
+		port, err := strconv.ParseUint(parts[1], 10, 32)
 		if err != nil {
-			return errors.Wrap(err, "failed to access CA certificate")
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid port in remote %q", remote))
 		}
-		cp := x509.NewCertPool()
-		if !cp.AppendCertsFromPEM(serverCA) {
-			return errors.Wrap(err, "failed to add CA certificate")
-		}
-		tlsCfg.RootCAs = cp
+		endpoints = append(endpoints, dirk.NewEndpoint(parts[0], uint32(port)))
 	}
-
-	clientCreds := credentials.NewTLS(tlsCfg)
-
-	opts := []grpc.DialOption{
-		// Require TLS.
-		grpc.WithTransportCredentials(clientCreds),
-		// Block until server responds.
-		grpc.WithBlock(),
-	}
-	remoteGRPCConn, err = grpc.Dial(remoteAddr, opts...)
-	return err
+	return endpoints, nil
+}
+
+// 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/signature.go

@@ -15,11 +15,10 @@ package cmd
 
 import (
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
 )
 
-var signatureData string
-var signatureDomain string
-
 // signatureCmd represents the signature command
 var signatureCmd = &cobra.Command{
 	Use:     "signature",
@@ -32,7 +31,23 @@ func init() {
 	RootCmd.AddCommand(signatureCmd)
 }
 
+var dataFlag *pflag.Flag
+var domainFlag *pflag.Flag
+
 func signatureFlags(cmd *cobra.Command) {
-	cmd.Flags().StringVar(&signatureData, "data", "", "the hex string of data")
-	cmd.Flags().StringVar(&signatureDomain, "domain", "", "the hex string of the BLS domain (defaults to 0x0000000000000000)")
+	if dataFlag == nil {
+		cmd.Flags().String("data", "", "the data, as a hex string")
+		dataFlag = cmd.Flags().Lookup("data")
+		if err := viper.BindPFlag("signature-data", dataFlag); err != nil {
+			panic(err)
+		}
+		cmd.Flags().String("domain", "0x0000000000000000000000000000000000000000000000000000000000000000", "the BLS domain, as a hex string")
+		domainFlag = cmd.Flags().Lookup("domain")
+		if err := viper.BindPFlag("signature-domain", domainFlag); err != nil {
+			panic(err)
+		}
+	} else {
+		cmd.Flags().AddFlag(dataFlag)
+		cmd.Flags().AddFlag(domainFlag)
+	}
 }

cmd/signatureaggregate.go

@@ -0,0 +1,110 @@
+// Copyright © 2017-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 (
+	"encoding/hex"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/herumi/bls-eth-go-binary/bls"
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/wealdtech/ethdo/util"
+)
+
+var signatureAggregateSignatures []string
+
+// signatureAggregateCmd represents the signature aggregate command
+var signatureAggregateCmd = &cobra.Command{
+	Use:   "aggregate",
+	Short: "Aggregate signatures",
+	Long: `Aggregate signatures, either threshold or absolute.  For example:
+
+    ethdo signature aggregate --signatures=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7,
+
+Signatures are specified as "signature" for simple aggregation, and as "id:signature" for threshold aggregation.
+
+In quiet mode this will return 0 if the signatures can be aggregated, otherwise 1.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		assert(len(signatureAggregateSignatures) > 1, "multiple signatures required to aggregate")
+		var signature *bls.Sign
+		var err error
+		if strings.Contains(signatureAggregateSignatures[0], ":") {
+			signature, err = generateThresholdSignature()
+		} else {
+			signature, err = generateAggregateSignature()
+		}
+		errCheck(err, "Failed to aggregate signature")
+
+		outputIf(!quiet, fmt.Sprintf("%#x", signature.Serialize()))
+		os.Exit(_exitSuccess)
+	},
+}
+
+func generateThresholdSignature() (*bls.Sign, error) {
+	ids := make([]bls.ID, len(signatureAggregateSignatures))
+	sigs := make([]bls.Sign, len(signatureAggregateSignatures))
+
+	for i := range signatureAggregateSignatures {
+		parts := strings.Split(signatureAggregateSignatures[i], ":")
+		if len(parts) != 2 {
+			return nil, errors.New("invalid threshold signature format")
+		}
+		id, err := strconv.ParseUint(parts[0], 10, 64)
+		if err != nil {
+			return nil, errors.Wrap(err, "invalid threshold signature ID")
+		}
+		ids[i] = *util.BLSID(id)
+		sigBytes, err := hex.DecodeString(strings.TrimPrefix(parts[1], "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, "invalid threshold signature ID")
+		}
+		if err := sigs[i].Deserialize(sigBytes); err != nil {
+			return nil, errors.Wrap(err, "invalid signature")
+		}
+	}
+
+	var compositeSig bls.Sign
+	if err := compositeSig.Recover(sigs, ids); err != nil {
+		return nil, err
+	}
+
+	return &compositeSig, nil
+}
+
+func generateAggregateSignature() (*bls.Sign, error) {
+	sigs := make([]bls.Sign, len(signatureAggregateSignatures))
+	for i := range signatureAggregateSignatures {
+		sigBytes, err := hex.DecodeString(strings.TrimPrefix(signatureAggregateSignatures[i], "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to decode signature")
+		}
+		if err := sigs[i].Deserialize(sigBytes); err != nil {
+			return nil, errors.Wrap(err, "invalid signature")
+		}
+	}
+	var aggregateSig bls.Sign
+	aggregateSig.Aggregate(sigs)
+
+	return &aggregateSig, nil
+}
+
+func init() {
+	signatureCmd.AddCommand(signatureAggregateCmd)
+	signatureAggregateCmd.Flags().StringArrayVar(&signatureAggregateSignatures, "signature", nil, "a signature to aggregate (supply once for each signature)")
+	signatureFlags(signatureAggregateCmd)
+}

cmd/signaturesign.go

@@ -20,7 +20,6 @@ import (
 
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
-	pb "github.com/wealdtech/eth2-signer-api/pb/v1"
 	"github.com/wealdtech/go-bytesutil"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 )
@@ -31,59 +30,36 @@ var signatureSignCmd = &cobra.Command{
 	Short: "Sign a 32-byte piece of data",
 	Long: `Sign presented data.  For example:
 
-    ethereal signature sign --data=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7 --account="Personal wallet/Operations" --passphrase="my account passphrase"
+    ethdo signature sign --data=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7 --account="Personal wallet/Operations" --passphrase="my account passphrase"
 
 In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(signatureData != "", "--data is required")
-		data, err := bytesutil.FromHexString(signatureData)
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
+		assert(viper.GetString("signature-data") != "", "--data is required")
+		data, err := bytesutil.FromHexString(viper.GetString("signature-data"))
 		errCheck(err, "Failed to parse data")
 		assert(len(data) == 32, "data to sign must be 32 bytes")
 
 		domain := e2types.Domain(e2types.DomainType([4]byte{0, 0, 0, 0}), e2types.ZeroForkVersion, e2types.ZeroGenesisValidatorsRoot)
-		if signatureDomain != "" {
-			domainBytes, err := bytesutil.FromHexString(signatureDomain)
+		if viper.GetString("signature-domain") != "" {
+			domain, err = bytesutil.FromHexString(viper.GetString("signature-domain"))
 			errCheck(err, "Failed to parse domain")
-			assert(len(domainBytes) == 32, "Domain data invalid")
-			domain = domainBytes
+			assert(len(domain) == 32, "Domain data invalid")
 		}
+		outputIf(debug, fmt.Sprintf("Domain is %#x", domain))
 
-		assert(rootAccount != "", "--account is required")
+		assert(viper.GetString("account") != "", "--account is required")
+		_, account, err := walletAndAccountFromInput(ctx)
+		errCheck(err, "Failed to obtain account")
 
-		var signature e2types.Signature
-		if remote {
-			signClient := pb.NewSignerClient(remoteGRPCConn)
-			signReq := &pb.SignRequest{
-				Id:     &pb.SignRequest_Account{Account: rootAccount},
-				Data:   data,
-				Domain: domain,
-			}
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			resp, err := signClient.Sign(ctx, signReq)
-			errCheck(err, "Failed to sign")
-			switch resp.State {
-			case pb.ResponseState_DENIED:
-				die("Signing request denied")
-			case pb.ResponseState_FAILED:
-				die("Signing request failed")
-			case pb.ResponseState_SUCCEEDED:
-				signature, err = e2types.BLSSignatureFromBytes(resp.Signature)
-				errCheck(err, "Invalid signature")
-			}
-		} else {
-			account, err := accountFromPath(rootAccount)
-			errCheck(err, "Failed to access account for signing")
-			err = account.Unlock([]byte(rootAccountPassphrase))
-			errCheck(err, "Failed to unlock account for signing")
-			var fixedSizeData [32]byte
-			copy(fixedSizeData[:], data)
-			defer account.Lock()
-			signature, err = signRoot(account, fixedSizeData, domain)
-			errCheck(err, "Failed to sign data")
-		}
+		var fixedSizeData [32]byte
+		copy(fixedSizeData[:], data)
+		signature, err := signRoot(account, fixedSizeData, domain)
+		errCheck(err, "Failed to sign")
 
-		outputIf(!quiet, fmt.Sprintf("0x%096x", signature.Marshal()))
+		outputIf(!quiet, fmt.Sprintf("%#x", signature.Marshal()))
 		os.Exit(_exitSuccess)
 	},
 }

cmd/signatureverify.go

@@ -15,17 +15,22 @@ package cmd
 
 import (
 	"context"
+	"encoding/hex"
+	"fmt"
 	"os"
+	"strings"
 
-	"github.com/prysmaticlabs/go-ssz"
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
-	pb "github.com/wealdtech/eth2-signer-api/pb/v1"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
 	"github.com/wealdtech/go-bytesutil"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var signatureVerifySignature string
-var signatureVerifyPubKey string
+var signatureVerifySigner string
 
 // signatureVerifyCmd represents the signature verify command
 var signatureVerifyCmd = &cobra.Command{
@@ -33,12 +38,12 @@ var signatureVerifyCmd = &cobra.Command{
 	Short: "Verify signed data",
 	Long: `Verify signed data.  For example:
 
-    ethereal signature verify --data=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7 --signature=0x8888... --account="Personal wallet/Operations"
+    ethdo signature verify --data=0x5f24e819400c6a8ee2bfc014343cd971b7eb707320025a7bcd83e621e26c35b7 --signature=0x8888... --account="Personal wallet/Operations"
 
 In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(signatureData != "", "--data is required")
-		data, err := bytesutil.FromHexString(signatureData)
+		assert(viper.GetString("signature-data") != "", "--data is required")
+		data, err := bytesutil.FromHexString(viper.GetString("signature-data"))
 		errCheck(err, "Failed to parse data")
 		assert(len(data) == 32, "data to verify must be 32 bytes")
 
@@ -49,59 +54,53 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 		errCheck(err, "Invalid signature")
 
 		domain := e2types.Domain(e2types.DomainType([4]byte{0, 0, 0, 0}), e2types.ZeroForkVersion, e2types.ZeroGenesisValidatorsRoot)
-		if signatureDomain != "" {
-			domainBytes, err := bytesutil.FromHexString(signatureDomain)
+		if viper.GetString("signature-domain") != "" {
+			domain, err = bytesutil.FromHexString(viper.GetString("signature-domain"))
 			errCheck(err, "Failed to parse domain")
-			assert(len(domainBytes) == 32, "Domain data invalid")
+			assert(len(domain) == 32, "Domain data invalid")
 		}
 
-		var pubKey e2types.PublicKey
-		assert(signatureVerifyPubKey == "" || rootAccount == "", "Either --pubkey or --account should be supplied")
-		if rootAccount != "" {
-			if remote {
-				listerClient := pb.NewListerClient(remoteGRPCConn)
-				listAccountsReq := &pb.ListAccountsRequest{
-					Paths: []string{
-						rootAccount,
-					},
-				}
-				resp, err := listerClient.ListAccounts(context.Background(), listAccountsReq)
-				errCheck(err, "Failed to access account")
-				assert(resp.State == pb.ResponseState_SUCCEEDED, "Failed to obtain account")
-				assert(len(resp.Accounts) == 1, "No such account")
-				pubKey, err = e2types.BLSPublicKeyFromBytes(resp.Accounts[0].PublicKey)
-				errCheck(err, "Invalid public key provided for account")
-			} else {
-				account, err := accountFromPath(rootAccount)
-				errCheck(err, "Unknown account")
-				pubKey = account.PublicKey()
-			}
-		} else {
-			pubKeyBytes, err := bytesutil.FromHexString(signatureVerifyPubKey)
-			errCheck(err, "Invalid public key")
-			pubKey, err = e2types.BLSPublicKeyFromBytes(pubKeyBytes)
-			errCheck(err, "Invalid public key")
-		}
-		container := &SigningContainer{
-			Root:   data,
-			Domain: domain,
-		}
-		root, err := ssz.HashTreeRoot(container)
-		errCheck(err, "Failed to create signing root")
+		account, err := signatureVerifyAccount()
+		errCheck(err, "Failed to obtain account")
+		outputIf(debug, fmt.Sprintf("Public key is %#x", account.PublicKey().Marshal()))
 
-		verified := signature.Verify(root[:], pubKey)
-		if !verified {
-			outputIf(!quiet, "Not verified")
-			os.Exit(_exitFailure)
-		}
-		outputIf(!quiet, "Verified")
+		var root [32]byte
+		copy(root[:], data)
+		verified, err := verifyRoot(account, root, domain, signature)
+		errCheck(err, "Failed to verify data")
+		assert(verified, "Failed to verify")
+
+		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)
 	signatureVerifyCmd.Flags().StringVar(&signatureVerifySignature, "signature", "", "the signature to verify")
-	signatureVerifyCmd.Flags().StringVar(&signatureVerifyPubKey, "signer", "", "the public key of the signer (only if --account is not supplied)")
+	signatureVerifyCmd.Flags().StringVar(&signatureVerifySigner, "signer", "", "the public key of the signer (only if --account is not supplied)")
 }

cmd/signing.go

@@ -0,0 +1,183 @@
+// 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 (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-ssz"
+	"github.com/spf13/viper"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+// verifyStruct verifies the signature of an arbitrary structure.
+func verifyStruct(account e2wtypes.Account, data interface{}, domain []byte, signature e2types.Signature) (bool, error) {
+	objRoot, err := ssz.HashTreeRoot(data)
+	outputIf(debug, fmt.Sprintf("Object root is %#x", objRoot))
+	if err != nil {
+		return false, err
+	}
+
+	return verifyRoot(account, objRoot, domain, signature)
+}
+
+// SigningContainer is the container for signing roots with a domain.
+// Contains SSZ sizes to allow for correct calculation of root.
+type signingContainer struct {
+	Root   []byte `ssz-size:"32"`
+	Domain []byte `ssz-size:"32"`
+}
+
+// signRoot signs a root.
+func signRoot(account e2wtypes.Account, root [32]byte, domain []byte) (e2types.Signature, error) {
+	if _, isProtectingSigner := account.(e2wtypes.AccountProtectingSigner); isProtectingSigner {
+		// Signer signs the data to sign itself.
+		return signGeneric(account, root[:], domain)
+	}
+
+	// Build the signing data manually.
+	container := &signingContainer{
+		Root:   root[:],
+		Domain: domain,
+	}
+	outputIf(debug, fmt.Sprintf("Signing container:\n root: %#x\n domain: %#x", container.Root, container.Domain))
+	signingRoot, err := ssz.HashTreeRoot(container)
+	if err != nil {
+		return nil, err
+	}
+	outputIf(debug, fmt.Sprintf("Signing root: %#x", signingRoot))
+	return sign(account, signingRoot[:])
+}
+
+func verifyRoot(account e2wtypes.Account, root [32]byte, domain []byte, signature e2types.Signature) (bool, error) {
+	// Build the signing data manually.
+	container := &signingContainer{
+		Root:   root[:],
+		Domain: domain,
+	}
+	outputIf(debug, fmt.Sprintf("Signing container:\n root: %#x\n domain: %#x", container.Root, container.Domain))
+	signingRoot, err := ssz.HashTreeRoot(container)
+	if err != nil {
+		return false, err
+	}
+	outputIf(debug, fmt.Sprintf("Signing root: %#x", signingRoot))
+	return verify(account, signingRoot[:], signature)
+}
+
+func signGeneric(account e2wtypes.Account, data []byte, domain []byte) (e2types.Signature, error) {
+	alreadyUnlocked, err := unlock(account)
+	if err != nil {
+		return nil, err
+	}
+	outputIf(debug, fmt.Sprintf("Signing %x (%d)", data, len(data)))
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+
+	signer, isProtectingSigner := account.(e2wtypes.AccountProtectingSigner)
+	if !isProtectingSigner {
+		return nil, errors.New("account does not provide generic signing")
+	}
+
+	signature, err := signer.SignGeneric(ctx, data, domain)
+	errCheck(err, "failed to sign")
+	if !alreadyUnlocked {
+		if err := lock(account); err != nil {
+			return nil, errors.Wrap(err, "failed to lock account")
+		}
+	}
+	return signature, err
+}
+
+// sign signs arbitrary data, handling unlocking and locking as required.
+func sign(account e2wtypes.Account, data []byte) (e2types.Signature, error) {
+	alreadyUnlocked, err := unlock(account)
+	if err != nil {
+		return nil, err
+	}
+	outputIf(debug, fmt.Sprintf("Signing %x (%d)", data, len(data)))
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+
+	signer, isSigner := account.(e2wtypes.AccountSigner)
+	if !isSigner {
+		return nil, errors.New("account does not provide signing")
+	}
+
+	signature, err := signer.Sign(ctx, data)
+	errCheck(err, "failed to sign")
+	if !alreadyUnlocked {
+		if err := lock(account); err != nil {
+			return nil, errors.Wrap(err, "failed to lock account")
+		}
+	}
+	return signature, err
+}
+
+// verify the signature of arbitrary data.
+func verify(account e2wtypes.Account, data []byte, signature e2types.Signature) (bool, error) {
+	pubKey, err := bestPublicKey(account)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain account public key")
+	}
+	return signature.Verify(data, pubKey), nil
+}
+
+// unlock attempts to unlock an account.  It returns true if the account was already unlocked.
+func unlock(account e2wtypes.Account) (bool, error) {
+	locker, isAccountLocker := account.(e2wtypes.AccountLocker)
+	if !isAccountLocker {
+		outputIf(debug, "Account does not support unlocking")
+		// This account doesn't support unlocking; return okay.
+		return true, nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	alreadyUnlocked, err := locker.IsUnlocked(ctx)
+	cancel()
+	if err != nil {
+		return false, errors.Wrap(err, "unable to ascertain if account is unlocked")
+	}
+
+	if alreadyUnlocked {
+		return true, nil
+	}
+
+	// Not already unlocked; attempt to unlock it.
+	for _, passphrase := range getPassphrases() {
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		err = locker.Unlock(ctx, []byte(passphrase))
+		cancel()
+		if err == nil {
+			// Unlocked.
+			return false, nil
+		}
+	}
+
+	// Failed to unlock it.
+	return false, errors.New("failed to unlock account")
+}
+
+// lock attempts to lock an account.
+func lock(account e2wtypes.Account) error {
+	locker, isAccountLocker := account.(e2wtypes.AccountLocker)
+	if !isAccountLocker {
+		return nil
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+	return locker.Lock(ctx)
+}

cmd/validator/depositdata/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 depositdata
+
+import (
+	"context"
+	"encoding/hex"
+	"strings"
+
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
+	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 = core.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 := core.WalletAndAccountFromPath(ctx, viper.GetString("withdrawalaccount"))
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain withdrawal account")
+		}
+		pubKey, err := core.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,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 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) {
+	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")
+	}
+
+	output := fmt.Sprintf(`{"pubkey":"%x","withdrawal_credentials":"%x","amount":%d,"signature":"%x","deposit_message_root":"%x","deposit_data_root":"%x","fork_version":"%x"}`,
+		*datum.validatorPubKey,
+		datum.withdrawalCredentials,
+		datum.amount,
+		*datum.signature,
+		*datum.depositMessageRoot,
+		*datum.depositDataRoot,
+		*datum.forkVersion,
+	)
+	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("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:                "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":"01020304"}]`,
+		},
+		{
+			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":"01020304"},{"pubkey":"b89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","withdrawal_credentials":"00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594","amount":32000000000,"signature":"911fe0766e8b79d711dde46bc2142eb51e35be99e5f7da505af9eaad85707bbb8013f0dea35e30403b3e57bb13054c1d0d389aceeba1d4160a148026212c7e017044e3ea69cd96fbd23b6aa9fd1e6f7e82494fbd5f8fc75856711a6b8998926e","deposit_message_root":"bb4b6184b25873cdf430df3838c8d3e3d16cf3dc3b214e2f3ab7df9e6d5a9b52","deposit_data_root":"3b51670e9f266d44c879682a230d60f0d534c64ab25ee68700fe3adb17ddfcab","fork_version":"01020304"}]`,
+		},
+	}
+
+	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/core"
+	"github.com/wealdtech/ethdo/signing"
+	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 := core.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/exit/input.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 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/core"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// 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.Data
+	return inputChainData(ctx, data)
+}
+
+func inputAccount(ctx context.Context, data *dataIn) (*dataIn, error) {
+	var err error
+	_, data.account, err = core.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,186 @@
+// 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"),
+				"timeout":    "5s",
+				"key":        "0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+		{
+			name: "AccountUnknown",
+			vars: map[string]interface{}{
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+				"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"),
+				"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"),
+				"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"),
+				"timeout":    "5s",
+				"exit":       `{"message":{"epoch":"123","validator_index":"456"},"signature":"0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f"}`,
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+		{
+			name: "ClientBad",
+			vars: map[string]interface{}{
+				"connection": "localhost:1",
+				"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"),
+				"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{
+		Data:        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: `{"data":{"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/core"
+	"github.com/wealdtech/ethdo/signing"
+)
+
+// 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 := core.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,26 +14,13 @@
 package cmd
 
 import (
-	"encoding/hex"
 	"fmt"
-	"os"
-	"strings"
 
-	"github.com/prysmaticlabs/go-ssz"
 	"github.com/spf13/cobra"
-	"github.com/wealdtech/ethdo/grpc"
-	e2types "github.com/wealdtech/go-eth2-types/v2"
-	util "github.com/wealdtech/go-eth2-util"
-	string2eth "github.com/wealdtech/go-string2eth"
+	"github.com/spf13/viper"
+	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",
@@ -46,152 +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) {
-		assert(validatorDepositDataValidatorAccount != "", "--validatoraccount is required")
-		validatorWallet, err := walletFromPath(validatorDepositDataValidatorAccount)
-		errCheck(err, "Failed to obtain validator wallet")
-		validatorAccounts, err := accountsFromPath(validatorDepositDataValidatorAccount)
-		errCheck(err, "Failed to obtain validator account")
-		assert(len(validatorAccounts) > 0, "Failed to obtain validator account")
-		if len(validatorAccounts) == 1 {
-			outputIf(debug, fmt.Sprintf("Validator public key is %048x", validatorAccounts[0].PublicKey().Marshal()))
-		} else {
-			for _, validatorAccount := range validatorAccounts {
-				outputIf(verbose, fmt.Sprintf("Creating deposit for %s/%s", validatorWallet.Name(), validatorAccount.Name()))
-				outputIf(debug, fmt.Sprintf("Validator public key is %048x", validatorAccount.PublicKey().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(validatorDepositDataWithdrawalAccount)
-			errCheck(err, "Failed to obtain withdrawal account")
-			outputIf(debug, fmt.Sprintf("Withdrawal public key is %048x", withdrawalAccount.PublicKey().Marshal()))
-			withdrawalCredentials = util.SHA256(withdrawalAccount.PublicKey().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 %032x", 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 {
-			depositData := struct {
-				PubKey                []byte `ssz-size:"48"`
-				WithdrawalCredentials []byte `ssz-size:"32"`
-				Value                 uint64
-			}{
-				PubKey:                validatorAccount.PublicKey().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)
-				errCheck(err, "Failed to obtain chain configuration")
-				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))
-			err = validatorAccount.Unlock([]byte(rootAccountPassphrase))
-			errCheck(err, "Failed to unlock validator account")
-			signature, err := signStruct(validatorAccount, depositData, domain)
-			validatorAccount.Lock()
-			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:                validatorAccount.PublicKey().Marshal(),
-				WithdrawalCredentials: withdrawalCredentials,
-				Value:                 val,
-				Signature:             signature.Marshal(),
-			}
-			outputIf(debug, fmt.Sprintf("Signed deposit data:\n\tPublic key: %x\n\tWithdrawal credentials: %x\n\tValue: %d\n\tSignature: %x", signedDepositData.PubKey, signedDepositData.WithdrawalCredentials, signedDepositData.Value, 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, validatorAccount.PublicKey().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(`{"account":"%s","pubkey":"%048x","withdrawal_credentials":"%032x","signature":"%096x","value":%d,"deposit_data_root":"%032x","version":1}`, 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/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,192 +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) {
-		err := connect()
-		errCheck(err, "Failed to obtain connect to Ethereum 2 beacon chain node")
-
-		exit, signature := validatorExitHandleInput()
-		validatorExitHandleExit(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() (*ethpb.VoluntaryExit, e2types.Signature) {
-	if validatorExitJSON != "" {
-		return validatorExitHandleJSONInput(validatorExitJSON)
-	}
-	if rootAccount != "" {
-		account, err := accountFromPath(rootAccount)
-		errCheck(err, "Failed to access account")
-		return validatorExitHandleAccountInput(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(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(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")
-	secondsPerEpoch := config["SecondsPerSlot"].(uint64) * config["SlotsPerEpoch"].(uint64)
-
-	// 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))
-		earliestExitEpoch := validator.ActivationEpoch + config["PersistentCommitteePeriod"].(uint64)
-
-		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)
-
-	err = account.Unlock([]byte(rootAccountPassphrase))
-	errCheck(err, "Failed to unlock account; please confirm passphrase is correct")
-	signature, err := signStruct(account, exit, domain)
-	errCheck(err, "Failed to sign exit proposal")
-
-	return exit, signature
-}
-
-// validatorExitHandleExit handles the exit request.
-func validatorExitHandleExit(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)
-		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-		defer cancel()
-		_, 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

@@ -14,22 +14,29 @@
 package cmd
 
 import (
+	"bytes"
+	"context"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"net/http"
 	"os"
+	"strconv"
 	"strings"
-	"time"
 
-	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
+	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/cobra"
-	"github.com/wealdtech/ethdo/grpc"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/core"
 	"github.com/wealdtech/ethdo/util"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
+	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",
@@ -39,75 +46,173 @@ 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) {
-		// Sanity checking and setup.
-		assert(rootAccount != "" || 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")
 
-		var account types.Account
-		if rootAccount != "" {
-			account, err = accountFromPath(rootAccount)
-			errCheck(err, "Failed to access account")
-		} else {
-			pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(validatorInfoPubKey, "0x"))
-			errCheck(err, fmt.Sprintf("Failed to decode public key %s", validatorInfoPubKey))
-			account, err = util.NewScratchAccount(nil, pubKeyBytes)
-			errCheck(err, fmt.Sprintf("Invalid public key %s", validatorInfoPubKey))
-		}
+		account, err := validatorInfoAccount()
+		errCheck(err, "Failed to obtain validator account")
 
-		validatorInfo, err := grpc.FetchValidatorInfo(eth2GRPCConn, account)
+		pubKeys := make([]spec.BLSPubKey, 1)
+		pubKey, err := core.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")
-		validatorDef, err := grpc.FetchValidator(eth2GRPCConn, account)
-		if validatorInfo.Status != ethpb.ValidatorStatus_DEPOSITED &&
-			validatorInfo.Status != ethpb.ValidatorStatus_UNKNOWN_STATUS {
-			errCheck(err, "Failed to obtain validator definition")
+		if len(validators) == 0 {
+			fmt.Println("Validator not known by beacon node")
+			os.Exit(_exitSuccess)
 		}
 
-		assert(validatorInfo.Status != ethpb.ValidatorStatus_UNKNOWN_STATUS, "Not known as a validator")
+		var validator *api.Validator
+		for _, v := range validators {
+			validator = v
+		}
+
+		if verbose {
+			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(uint64(totalDeposited), true))
+				}
+			}
+		}
 
 		if quiet {
 			os.Exit(_exitSuccess)
 		}
 
-		outputIf(verbose, fmt.Sprintf("Epoch of data:\t\t%v", validatorInfo.Epoch))
-		outputIf(verbose && validatorInfo.Status != ethpb.ValidatorStatus_DEPOSITED, fmt.Sprintf("Index:\t\t\t%v", validatorInfo.Index))
-		outputIf(verbose, fmt.Sprintf("Public key:\t\t%#x", validatorInfo.PublicKey))
-		fmt.Printf("Status:\t\t\t%s\n", strings.Title(strings.ToLower(validatorInfo.Status.String())))
-		fmt.Printf("Balance:\t\t%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:\t%s\n", string2eth.GWeiToString(validatorInfo.EffectiveBalance, true))
-		}
-		if validatorDef != nil {
-			outputIf(verbose, fmt.Sprintf("Withdrawal credentials:\t%#x", validatorDef.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:\t%s\n", transition)
-			}
-		case ethpb.ValidatorStatus_PENDING:
-			fmt.Printf("Activation:\t\t%s\n", transition)
-		case ethpb.ValidatorStatus_EXITING, ethpb.ValidatorStatus_SLASHING:
-			fmt.Printf("Attesting finishes:\t%s\n", transition)
-		case ethpb.ValidatorStatus_EXITED:
-			if transitionPassed {
-				fmt.Printf("Funds withdrawable:\tNow\n")
-			} else {
-				fmt.Printf("Funds withdrawable:\t%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)
 	},
 }
 
+// validatorInfoAccount obtains the account for the validator info command.
+func validatorInfoAccount() (e2wtypes.Account, error) {
+	var account e2wtypes.Account
+	var err error
+	switch {
+	case 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")
+		}
+	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", viper.GetString("pubkey")))
+		}
+		account, err = util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			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, 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")
+	}
+	defer graphResp.Body.Close()
+	body, err := ioutil.ReadAll(graphResp.Body)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "bad information returned from existing deposit check")
+	}
+
+	type graphDeposit struct {
+		Index                 string `json:"index"`
+		Amount                string `json:"amount"`
+		WithdrawalCredentials string `json:"withdrawalCredentials"`
+	}
+	type graphData struct {
+		Deposits []*graphDeposit `json:"deposits,omitempty"`
+	}
+	type graphResponse struct {
+		Data *graphData `json:"data,omitempty"`
+	}
+
+	var response graphResponse
+	if err := json.Unmarshal(body, &response); err != nil {
+		return 0, 0, errors.Wrap(err, "invalid data returned from existing deposit check")
+	}
+	deposits := uint64(0)
+	totalDeposited := spec.Gwei(0)
+	if response.Data != nil && len(response.Data.Deposits) > 0 {
+		for _, deposit := range response.Data.Deposits {
+			deposits++
+			depositAmount, err := strconv.ParseUint(deposit.Amount, 10, 64)
+			if err != nil {
+				return 0, 0, errors.Wrap(err, fmt.Sprintf("invalid deposit amount from pre-existing deposit %s", deposit.Amount))
+			}
+			totalDeposited += spec.Gwei(depositAmount)
+		}
+	}
+	return deposits, totalDeposited, nil
+}
+
 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

@@ -1,4 +1,4 @@
-// Copyright © 2019 Weald Technology Trading
+// 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
@@ -22,15 +22,19 @@ import (
 	"github.com/spf13/viper"
 )
 
+// ReleaseVersion is the release version of the codebase.
+// Usually overrideen by tag names when building binaries.
+var ReleaseVersion = "local build from v1.7.1"
+
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{
 	Use:   "version",
-	Short: "Version of Ethdo",
-	Long: `Obtain the version of Ethdo.  For example:
+	Short: "Version of ethdo",
+	Long: `Obtain the version of ethdo.  For example:
 
-    ethdo version.`,
+    ethdo version`,
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("1.4.18")
+		fmt.Println(ReleaseVersion)
 		if viper.GetBool("verbose") {
 			buildInfo, ok := dbg.ReadBuildInfo()
 			if ok {

cmd/wallet.go

@@ -15,10 +15,10 @@ package cmd
 
 import (
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
+	"github.com/spf13/viper"
 )
 
-var walletWallet string
-
 // walletCmd represents the wallet command
 var walletCmd = &cobra.Command{
 	Use:   "wallet",
@@ -30,6 +30,16 @@ func init() {
 	RootCmd.AddCommand(walletCmd)
 }
 
+var walletFlag *pflag.Flag
+
 func walletFlags(cmd *cobra.Command) {
-	cmd.Flags().StringVar(&walletWallet, "wallet", "", "Name of the wallet")
+	if walletFlag == nil {
+		cmd.Flags().String("wallet", "", "Name of the wallet")
+		walletFlag = cmd.Flags().Lookup("wallet")
+		if err := viper.BindPFlag("wallet", walletFlag); err != nil {
+			panic(err)
+		}
+	} else {
+		cmd.Flags().AddFlag(walletFlag)
+	}
 }

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
+}

cmd/wallet/delete/input.go

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

cmd/wallet/delete/input_internal_test.go

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

cmd/wallet/delete/output.go

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

cmd/wallet/delete/output_internal_test.go

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

cmd/wallet/delete/process.go

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

cmd/wallet/delete/process_internal_test.go

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

cmd/wallet/delete/run.go

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

cmd/wallet/export/input.go

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

cmd/wallet/export/input_internal_test.go

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

cmd/wallet/export/output.go

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

cmd/wallet/export/output_internal_test.go

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

cmd/wallet/export/process.go

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