Update changelog for v1.6.0

Fixed output for "Justified epoch distance"

.github/workflows/release.yml

@@ -0,0 +1,115 @@
+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 '::set-env name=GO111MODULE::on'
+       # Release tag comes from the github reference.
+       RELEASE_TAG=$(echo ${GITHUB_REF} | sed -e 's!.*/!!')
+       echo "::set-env name=RELEASE_TAG::${RELEASE_TAG}"
+       echo "::set-output name=RELEASE_TAG::${RELEASE_TAG}"
+       # Ensure the release tag has expected format.
+       echo ${RELEASE_TAG} | grep -q '^v' || exit 1
+       # Release version is same as release tag without leading 'v'.
+       RELEASE_VERSION=$(echo ${GITHUB_REF} | sed -e 's!.*/v!!')
+       echo "::set-env name=RELEASE_VERSION::${RELEASE_VERSION}"
+       echo "::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
+      run: xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64,linux/arm64,windows/amd64" github.com/wealdtech/ethdo
+
+    - name: 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,14 @@
+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,14 @@
 
 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 **
+**Please note that this tool and its underlying libraries have not yet undergone a security audit; use at your own risk.**
 
 ## Table of Contents
 
 - [Install](#install)
+  - [Binaries](#binaries)
   - [Docker](#docker)
+  - [Source](#source)
 - [Usage](#usage)
 - [Maintainers](#maintainers)
 - [Contribute](#contribute)
@@ -18,6 +20,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 +43,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 .
@@ -118,6 +125,18 @@ 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.
 
+## 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).
@@ -130,6 +149,8 @@ There is a [HOWTO](https://github.com/wealdtech/ethdo/blob/master/docs/howto.md)
 
 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/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
@@ -14,10 +14,15 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
+	"regexp"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var accountCreateCmd = &cobra.Command{
@@ -29,29 +34,63 @@ var accountCreateCmd = &cobra.Command{
 
 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")
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
 
-		w, err := walletFromPath(rootAccount)
+		assert(viper.GetString("account") != "", "--account is required")
+
+		wallet, err := walletFromInput(ctx)
 		errCheck(err, "Failed to access wallet")
-
-		if w.Type() == "hierarchical deterministic" {
-			assert(rootWalletPassphrase != "", "--walletpassphrase is required to create new accounts with hierarchical deterministic wallets")
+		outputIf(debug, fmt.Sprintf("Opened wallet %q of type %s", wallet.Name(), wallet.Type()))
+		if wallet.Type() == "hierarchical deterministic" {
+			assert(getWalletPassphrase() != "", "walletpassphrase is required to create new accounts with hierarchical deterministic wallets")
+		}
+		locker, isLocker := wallet.(e2wtypes.WalletLocker)
+		if isLocker {
+			errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
 		}
-		_, err = accountFromPath(rootAccount)
-		assert(err != nil, "Account already exists")
 
-		err = w.Unlock([]byte(rootWalletPassphrase))
-		errCheck(err, "Failed to unlock wallet")
+		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
+		errCheck(err, "Failed to obtain account name")
 
-		_, accountName, err := walletAndAccountNamesFromPath(rootAccount)
-		errCheck(err, "Failed to obtain accout name")
-
-		account, err := w.CreateAccount(accountName, []byte(rootAccountPassphrase))
+		var account e2wtypes.Account
+		if viper.GetUint("participants") > 0 {
+			// Want a distributed account.
+			distributedCreator, isDistributedCreator := wallet.(e2wtypes.WalletDistributedAccountCreator)
+			assert(isDistributedCreator, "Wallet does not support distributed account creation")
+			outputIf(debug, fmt.Sprintf("Distributed account has %d/%d threshold", viper.GetUint32("signing-threshold"), viper.GetUint32("participants")))
+			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+			defer cancel()
+			account, err = distributedCreator.CreateDistributedAccount(ctx, accountName, viper.GetUint32("participants"), viper.GetUint32("signing-threshold"), []byte(getOptionalPassphrase()))
+		} else {
+			if viper.GetString("path") != "" {
+				// Want a pathed account
+				creator, isCreator := wallet.(e2wtypes.WalletPathedAccountCreator)
+				assert(isCreator, "Wallet does not support account creation with an explicit path")
+				var match bool
+				match, err = regexp.Match("^m/[0-9]+/[0-9]+(/[0-9+])+", []byte(viper.GetString("path")))
+				errCheck(err, "Unable to match path to regular expression")
+				assert(match, "Path does not match expected format m/...")
+				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+				defer cancel()
+				account, err = creator.CreatePathedAccount(ctx, viper.GetString("path"), accountName, []byte(getPassphrase()))
+			} else {
+				// Want a standard account.
+				creator, isCreator := wallet.(e2wtypes.WalletAccountCreator)
+				assert(isCreator, "Wallet does not support account creation")
+				ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+				defer cancel()
+				account, err = creator.CreateAccount(ctx, accountName, []byte(getPassphrase()))
+			}
+		}
 		errCheck(err, "Failed to create account")
 
-		outputIf(verbose, fmt.Sprintf("0x%048x", account.PublicKey().Marshal()))
+		if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+			outputIf(verbose, fmt.Sprintf("%#x", pubKeyProvider.CompositePublicKey().Marshal()))
+		} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
+			outputIf(verbose, fmt.Sprintf("%#x", pubKeyProvider.PublicKey().Marshal()))
+		}
+
 		os.Exit(_exitSuccess)
 	},
 }
@@ -59,4 +98,19 @@ In quiet mode this will return 0 if the account is created successfully, otherwi
 func init() {
 	accountCmd.AddCommand(accountCreateCmd)
 	accountFlags(accountCreateCmd)
+	accountCreateCmd.Flags().Uint32("participants", 0, "Number of participants (for distributed accounts)")
+	accountCreateCmd.Flags().Uint32("signing-threshold", 0, "Signing threshold (for distributed accounts)")
+	accountCreateCmd.Flags().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

@@ -14,12 +14,15 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	"github.com/wealdtech/go-bytesutil"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var accountImportKey string
@@ -34,32 +37,41 @@ var accountImportCmd = &cobra.Command{
 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(viper.GetString("account") != "", "--account is required")
+		passphrase := getPassphrase()
 		assert(accountImportKey != "", "--key is required")
 
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
 		key, err := bytesutil.FromHexString(accountImportKey)
 		errCheck(err, "Invalid key")
 
-		w, err := walletFromPath(rootAccount)
+		w, err := walletFromPath(ctx, viper.GetString("account"))
 		errCheck(err, "Failed to access wallet")
 
-		_, ok := w.(types.WalletAccountImporter)
+		_, ok := w.(e2wtypes.WalletAccountImporter)
 		assert(ok, fmt.Sprintf("wallets of type %q do not allow importing accounts", w.Type()))
 
-		_, err = accountFromPath(rootAccount)
+		_, _, err = walletAndAccountFromPath(ctx, viper.GetString("account"))
 		assert(err != nil, "Account already exists")
 
-		err = w.Unlock([]byte(rootWalletPassphrase))
-		errCheck(err, "Failed to unlock wallet")
+		locker, isLocker := w.(e2wtypes.WalletLocker)
+		if isLocker {
+			errCheck(locker.Unlock(ctx, []byte(getWalletPassphrase())), "Failed to unlock wallet")
+		}
 
-		_, accountName, err := walletAndAccountNamesFromPath(rootAccount)
+		_, accountName, err := e2wallet.WalletAndAccountNames(viper.GetString("account"))
 		errCheck(err, "Failed to obtain account name")
 
-		account, err := w.(types.WalletAccountImporter).ImportAccount(accountName, key, []byte(rootAccountPassphrase))
+		account, err := w.(e2wtypes.WalletAccountImporter).ImportAccount(ctx, accountName, key, []byte(passphrase))
 		errCheck(err, "Failed to create account")
 
-		outputIf(verbose, fmt.Sprintf("0x%048x", account.PublicKey().Marshal()))
+		pubKey, err := bestPublicKey(account)
+		if err == nil {
+			outputIf(verbose, fmt.Sprintf("%#x", pubKey.Marshal()))
+		}
+
 		os.Exit(_exitSuccess)
 	},
 }

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

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

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/attesterinclusion.go

@@ -0,0 +1,156 @@
+// 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"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/grpc"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+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 fo the given epoch, otherwise 1.`,
+	Run: func(cmd *cobra.Command, args []string) {
+		err := connect()
+		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain block")
+
+		// Obtain the epoch.
+		epoch := viper.GetInt64("epoch")
+		if epoch == -1 {
+			outputIf(debug, "No epoch supplied; fetching current epoch")
+			config, err := grpc.FetchChainConfig(eth2GRPCConn)
+			errCheck(err, "Failed to obtain beacon chain configuration")
+			slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
+			secondsPerSlot := config["SecondsPerSlot"].(uint64)
+			genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
+			errCheck(err, "Failed to obtain beacon chain genesis")
+			epoch = int64(time.Since(genesisTime).Seconds()) / int64(secondsPerSlot*slotsPerEpoch)
+		}
+		outputIf(debug, fmt.Sprintf("Epoch is %d", epoch))
+
+		// Obtain the validator.
+		account, err := attesterInclusionAccount()
+		errCheck(err, "Failed to obtain account")
+		validatorIndex, err := grpc.FetchValidatorIndex(eth2GRPCConn, account)
+		errCheck(err, "Failed to obtain validator")
+
+		// Find the attesting slot for the given epoch.
+		committees, err := grpc.FetchValidatorCommittees(eth2GRPCConn, uint64(epoch))
+		errCheck(err, "Failed to obtain validator committees")
+
+		slot := uint64(0)
+		committeeIndex := uint64(0)
+		validatorPositionInCommittee := uint64(0)
+		found := false
+		for searchSlot, committee := range committees {
+			for searchCommitteeIndex, committeeValidatorIndices := range committee {
+				for position, committeeValidatorIndex := range committeeValidatorIndices {
+					if validatorIndex == committeeValidatorIndex {
+						outputIf(verbose, fmt.Sprintf("Validator %d scheduled to attest at slot %d for epoch %d: entry %d in committee %d", validatorIndex, searchSlot, epoch, position, searchCommitteeIndex))
+						slot = searchSlot
+						committeeIndex = uint64(searchCommitteeIndex)
+						validatorPositionInCommittee = uint64(position)
+						found = true
+						break
+					}
+				}
+			}
+		}
+		assert(found, "Failed to find attester duty for validator in the given epoch")
+
+		startSlot := slot + 1
+		endSlot := startSlot + 32
+		for curSlot := startSlot; curSlot < endSlot; curSlot++ {
+			signedBlock, err := grpc.FetchBlock(eth2GRPCConn, curSlot)
+			errCheck(err, "Failed to obtain block")
+			if signedBlock == nil {
+				outputIf(debug, fmt.Sprintf("No block at slot %d", curSlot))
+				continue
+			}
+			outputIf(debug, fmt.Sprintf("Fetched block %d", curSlot))
+			for i, attestation := range signedBlock.Block.Body.Attestations {
+				outputIf(debug, fmt.Sprintf("Attestation %d is for slot %d and committee %d", i, attestation.Data.Slot, attestation.Data.CommitteeIndex))
+				if attestation.Data.Slot == slot &&
+					attestation.Data.CommitteeIndex == committeeIndex &&
+					attestation.AggregationBits.BitAt(validatorPositionInCommittee) {
+					if verbose {
+						fmt.Printf("Attestation included in block %d, attestation %d (inclusion delay %d)\n", curSlot, i, curSlot-slot)
+					} else if !quiet {
+						fmt.Printf("Attestation included in block %d (inclusion delay %d)\n", curSlot, curSlot-slot)
+					}
+					os.Exit(_exitSuccess)
+				}
+			}
+		}
+		outputIf(verbose, "Attestation not included on the chain")
+		os.Exit(_exitFailure)
+	},
+}
+
+// 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 = 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
+}
+
+func init() {
+	attesterCmd.AddCommand(attesterInclusionCmd)
+	attesterFlags(attesterInclusionCmd)
+	attesterInclusionCmd.Flags().Int64("epoch", -1, "the current 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/blockinfo.go

@@ -20,6 +20,7 @@ import (
 	"os"
 	"sort"
 	"strings"
+	"time"
 	"unicode/utf8"
 
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
@@ -45,42 +46,49 @@ In quiet mode this will return 0 if the block information is present and not ski
 		err := connect()
 		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain block")
 
+		config, err := grpc.FetchChainConfig(eth2GRPCConn)
+		errCheck(err, "Failed to obtain beacon chain configuration")
+		slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
+		secondsPerSlot := config["SecondsPerSlot"].(uint64)
+
+		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
+		errCheck(err, "Failed to obtain beacon chain genesis")
+
+		assert(!blockInfoStream || blockInfoSlot == -1, "--slot and --stream are not supported together")
+
+		var slot uint64
+		if blockInfoSlot < 0 {
+			slot, err = grpc.FetchLatestFilledSlot(eth2GRPCConn)
+			errCheck(err, "Failed to obtain slot of latest block")
+		} else {
+			slot = uint64(blockInfoSlot)
+		}
+		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, genesisTime, secondsPerSlot, slotsPerEpoch)
+
 		if blockInfoStream {
 			stream, err := grpc.StreamBlocks(eth2GRPCConn)
 			errCheck(err, "Failed to obtain block stream")
 			for {
+				fmt.Println()
 				signedBlock, err := stream.Recv()
 				errCheck(err, "Failed to obtain block")
 				if signedBlock != nil {
-					fmt.Println("")
-					outputBlock(signedBlock)
+					outputBlock(signedBlock, genesisTime, secondsPerSlot, slotsPerEpoch)
 				}
 			}
-
-		} 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)
 		}
 
 		os.Exit(_exitSuccess)
 	},
 }
 
-func outputBlock(signedBlock *ethpb.SignedBeaconBlock) {
+func outputBlock(signedBlock *ethpb.SignedBeaconBlock, genesisTime time.Time, secondsPerSlot uint64, slotsPerEpoch uint64) {
 	block := signedBlock.Block
 	body := block.Body
 
@@ -88,6 +96,8 @@ func outputBlock(signedBlock *ethpb.SignedBeaconBlock) {
 	bodyRoot, err := ssz.HashTreeRoot(block)
 	errCheck(err, "Failed to calculate block body root")
 	fmt.Printf("Slot: %d\n", block.Slot)
+	fmt.Printf("Epoch: %d\n", block.Slot/slotsPerEpoch)
+	fmt.Printf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(block.Slot*secondsPerSlot), 0))
 	fmt.Printf("Block root: %#x\n", bodyRoot)
 	outputIf(verbose, fmt.Sprintf("Parent root: %#x", block.ParentRoot))
 	outputIf(verbose, fmt.Sprintf("State root: %#x", block.StateRoot))
@@ -105,15 +115,30 @@ func outputBlock(signedBlock *ethpb.SignedBeaconBlock) {
 	outputIf(verbose, fmt.Sprintf("Ethereum 1 deposit root: %#x", eth1Data.DepositRoot))
 	outputIf(verbose, fmt.Sprintf("Ethereum 1 block hash: %#x", eth1Data.BlockHash))
 
+	validatorCommittees := make(map[uint64][][]uint64)
+
 	// Attestations.
 	fmt.Printf("Attestations: %d\n", len(body.Attestations))
 	if verbose {
 		for i, att := range body.Attestations {
 			fmt.Printf("\t%d:\n", i)
 
+			// Fetch committees for this epoch if not already obtained.
+			committees, exists := validatorCommittees[att.Data.Slot]
+			if !exists {
+				attestationEpoch := att.Data.Slot / slotsPerEpoch
+				epochCommittees, err := grpc.FetchValidatorCommittees(eth2GRPCConn, attestationEpoch)
+				errCheck(err, "Failed to obtain committees")
+				for k, v := range epochCommittees {
+					validatorCommittees[k] = v
+				}
+				committees = validatorCommittees[att.Data.Slot]
+			}
+
 			fmt.Printf("\t\tCommittee index: %d\n", att.Data.CommitteeIndex)
 			fmt.Printf("\t\tAttesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len())
 			fmt.Printf("\t\tAggregation bits: %s\n", bitsToString(att.AggregationBits))
+			fmt.Printf("\t\tAttesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.CommitteeIndex]))
 			fmt.Printf("\t\tSlot: %d\n", att.Data.Slot)
 			fmt.Printf("\t\tBeacon block root: %#x\n", att.Data.BeaconBlockRoot)
 			fmt.Printf("\t\tSource epoch: %d\n", att.Data.Source.Epoch)
@@ -157,18 +182,17 @@ func outputBlock(signedBlock *ethpb.SignedBeaconBlock) {
 					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)
-				}
+			} 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.
+	fmt.Printf("Proposer slashings: %d\n", len(body.ProposerSlashings))
+	// TODO verbose proposer slashings.
 
 	// Deposits.
 	fmt.Printf("Deposits: %d\n", len(body.Deposits))
@@ -237,6 +261,17 @@ func bitsToString(input bitfield.Bitlist) string {
 	return strings.TrimSpace(res)
 }
 
+func attestingIndices(input bitfield.Bitlist, indices []uint64) string {
+	bits := int(input.Len())
+	res := ""
+	for i := 0; i < bits; i++ {
+		if input.BitAt(uint64(i)) {
+			res = fmt.Sprintf("%s%d ", res, indices[i])
+		}
+	}
+	return strings.TrimSpace(res)
+}
+
 func init() {
 	blockCmd.AddCommand(blockInfoCmd)
 	blockFlags(blockInfoCmd)

cmd/chaininfo.go

@@ -39,15 +39,23 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
 		errCheck(err, "Failed to obtain genesis time")
 
+		genesisValidatorsRoot, err := grpc.FetchGenesisValidatorsRoot(eth2GRPCConn)
+		errCheck(err, "Failed to obtain genesis validators root")
+
 		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 genesisTime.Unix() == 0 {
+			fmt.Println("Genesis time: undefined")
+		} else {
+			fmt.Printf("Genesis time: %s\n", genesisTime.Format(time.UnixDate))
+			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesisTime.Unix()))
+		}
+		fmt.Printf("Genesis validators root: %#x\n", genesisValidatorsRoot)
+		fmt.Printf("Genesis fork version: %#x\n", config["GenesisForkVersion"].([]byte))
+		fmt.Printf("Seconds per slot: %d\n", config["SecondsPerSlot"].(uint64))
+		fmt.Printf("Slots per epoch: %d\n", config["SlotsPerEpoch"].(uint64))
 
 		os.Exit(_exitSuccess)
 	},
@@ -64,3 +72,11 @@ func timestampToSlot(genesis int64, timestamp int64, secondsPerSlot uint64) uint
 	}
 	return uint64(timestamp-genesis) / secondsPerSlot
 }
+
+func slotToTimestamp(genesis int64, slot uint64, secondsPerSlot uint64) int64 {
+	return genesis + int64(slot*secondsPerSlot)
+}
+
+func epochToTimestamp(genesis int64, slot uint64, secondsPerSlot uint64, slotsPerEpoch uint64) int64 {
+	return genesis + int64(slot*secondsPerSlot*slotsPerEpoch)
+}

cmd/chainstatus.go

@@ -48,7 +48,8 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 			os.Exit(_exitSuccess)
 		}
 
-		slot := timestampToSlot(genesisTime.Unix(), time.Now().Unix(), config["SecondsPerSlot"].(uint64))
+		now := time.Now()
+		slot := timestampToSlot(genesisTime.Unix(), now.Unix(), config["SecondsPerSlot"].(uint64))
 		if chainStatusSlot {
 			fmt.Printf("Current slot: %d\n", slot)
 			fmt.Printf("Justified slot: %d\n", info.GetJustifiedSlot())
@@ -70,12 +71,12 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 			slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
 			epoch := slot / slotsPerEpoch
 			fmt.Printf("Current epoch: %d\n", epoch)
-			fmt.Printf("Justified epoch: %d\n", info.GetJustifiedSlot()/slotsPerEpoch)
+			fmt.Printf("Justified epoch: %d\n", info.GetJustifiedEpoch())
 			if verbose {
 				distance := (slot - info.GetJustifiedSlot()) / slotsPerEpoch
-				fmt.Printf("Justified epoch distance %d\n", distance)
+				fmt.Printf("Justified epoch distance: %d\n", distance)
 			}
-			fmt.Printf("Finalized epoch: %d\n", info.GetFinalizedSlot()/slotsPerEpoch)
+			fmt.Printf("Finalized epoch: %d\n", info.GetFinalizedEpoch())
 			if verbose {
 				distance := (slot - info.GetFinalizedSlot()) / slotsPerEpoch
 				fmt.Printf("Finalized epoch distance: %d\n", distance)
@@ -87,6 +88,18 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 			}
 		}
 
+		if verbose {
+			slotsPerEpoch := config["SlotsPerEpoch"].(uint64)
+			secondsPerSlot := config["SecondsPerSlot"].(uint64)
+			epochStartSlot := (slot / slotsPerEpoch) * slotsPerEpoch
+			fmt.Printf("Epoch slots: %d-%d\n", epochStartSlot, epochStartSlot+slotsPerEpoch-1)
+			nextSlot := slotToTimestamp(genesisTime.Unix(), slot+1, secondsPerSlot)
+			fmt.Printf("Time until next slot: %2.1fs\n", float64(time.Until(time.Unix(nextSlot, 0)).Milliseconds())/1000)
+			nextEpoch := epochToTimestamp(genesisTime.Unix(), slot/slotsPerEpoch+1, secondsPerSlot, slotsPerEpoch)
+			fmt.Printf("Slots until next epoch: %d\n", (slot/slotsPerEpoch+1)*slotsPerEpoch-slot)
+			fmt.Printf("Time until next epoch: %2.1fs\n", float64(time.Until(time.Unix(nextEpoch, 0)).Milliseconds())/1000)
+		}
+
 		os.Exit(_exitSuccess)
 	},
 }

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.Replace(data, []byte("\r\n"), []byte("\n"), -1), []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,138 @@
+// 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"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"strings"
+
+	"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"
+)
+
+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, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
+		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.
+		err = connect()
+		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain node")
+		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, data.ForkVersion, genesisValidatorsRoot)
+		exit := &ethpb.VoluntaryExit{
+			Epoch:          data.Epoch,
+			ValidatorIndex: data.ValidatorIndex,
+		}
+		sig, err := e2types.BLSSignatureFromBytes(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")
+
+		// TODO confirm fork version is valid (once we have a way of obtaining the current fork version).
+
+		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) (*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 := &validatorExitData{}
+	err = json.Unmarshal([]byte(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/networks.go

@@ -0,0 +1,47 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/wealdtech/ethdo/grpc"
+)
+
+// networks is a map of deposit contract addresses to networks.
+var networks = map[string]string{
+	"16e82d77882a663454ef92806b7deca1d394810f": "Altona",
+	"0f0f0fc0530007361933eab5db97d09acdd6c1c8": "Onyx",
+	"07b39f4fde4a38bace212b546dac87c58dfe3fdc": "Medalla",
+}
+
+// network returns the name of the network, if known.
+func network() string {
+	if err := connect(); err != nil {
+		return "Unknown"
+	}
+
+	depositContractAddress, err := grpc.FetchDepositContractAddress(eth2GRPCConn)
+	if err != nil {
+		return "Unknown"
+	}
+	outputIf(debug, fmt.Sprintf("Deposit contract is %x", depositContractAddress))
+
+	depositContract := fmt.Sprintf("%x", depositContractAddress)
+	if network, exists := networks[depositContract]; exists {
+		return network
+	} else {
+		return "Unknown"
+	}
+}

cmd/nodeinfo.go

@@ -55,10 +55,14 @@ In quiet mode this will return 0 if the node information can be obtained, otherw
 		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()))
+		if genesisTime.Unix() == 0 {
+			fmt.Println("Not reached genesis")
+		} else {
+			slot := timestampToSlot(genesisTime.Unix(), time.Now().Unix(), config["SecondsPerSlot"].(uint64))
+			fmt.Printf("Current slot: %d\n", slot)
+			fmt.Printf("Current epoch: %d\n", slot/config["SlotsPerEpoch"].(uint64))
+			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesisTime.Unix()))
+		}
 
 		os.Exit(_exitSuccess)
 	},

cmd/passphrases.go

@@ -0,0 +1,49 @@
+// 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"
+
+// getStorePassphrases() fetches the store passphrase supplied by the user.
+func getStorePassphrase() string {
+	return viper.GetString("store-passphrase")
+}
+
+// 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")
+}
+
+// getPassphrase fetches the passphrase supplied by the user.
+func getPassphrase() string {
+	passphrases := getPassphrases()
+	assert(len(passphrases) != 0, "passphrase is required")
+	assert(len(passphrases) == 1, "multiple passphrases supplied; cannot continue")
+	return passphrases[0]
+}
+
+// getOptionalPassphrase fetches the passphrase if supplied by the user.
+func getOptionalPassphrase() string {
+	passphrases := getPassphrases()
+	if len(passphrases) == 0 {
+		return ""
+	}
+	assert(len(passphrases) == 1, "multiple passphrases supplied; cannot continue")
+	return passphrases[0]
+}

cmd/root.go

@@ -15,29 +15,25 @@ 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"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	dirk "github.com/wealdtech/go-eth2-wallet-dirk"
 	filesystem "github.com/wealdtech/go-eth2-wallet-store-filesystem"
 	s3 "github.com/wealdtech/go-eth2-wallet-store-s3"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-
-	wallet "github.com/wealdtech/go-eth2-wallet"
-	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 var cfgFile string
@@ -47,22 +43,12 @@ 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
+var store e2wtypes.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
@@ -86,16 +72,22 @@ func persistentPreRun(cmd *cobra.Command, args []string) {
 		return
 	}
 
-	// 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 "attester/inclusion":
+		attesterInclusionBindings()
+	case "exit/verify":
+		exitVerifyBindings()
+	case "wallet/create":
+		walletCreateBindings()
+	}
 
 	if quiet && verbose {
 		fmt.Println("Cannot supply both quiet and verbose flags")
@@ -108,27 +100,26 @@ func persistentPreRun(cmd *cobra.Command, args []string) {
 		// Set up our wallet store
 		switch rootStore {
 		case "s3":
-			assert(rootBaseDir == "", "--basedir does not apply for the s3 store")
+			assert(viper.GetString("base-dir") == "", "--basedir does not apply for the s3 store")
 			var err error
-			store, err = s3.New(s3.WithPassphrase([]byte(rootStorePassphrase)))
+			store, err = s3.New(s3.WithPassphrase([]byte(getStorePassphrase())))
 			errCheck(err, "Failed to access Amazon S3 wallet store")
 		case "filesystem":
 			opts := make([]filesystem.Option, 0)
-			if rootStorePassphrase != "" {
-				opts = append(opts, filesystem.WithPassphrase([]byte(rootStorePassphrase)))
+			if getStorePassphrase() != "" {
+				opts = append(opts, filesystem.WithPassphrase([]byte(getStorePassphrase())))
 			}
-			if rootBaseDir != "" {
-				opts = append(opts, filesystem.WithLocation(rootBaseDir))
+			if viper.GetString("base-dir") != "" {
+				opts = append(opts, filesystem.WithLocation(viper.GetString("base-dir")))
 			}
 			store = filesystem.New(opts...)
 		default:
 			die(fmt.Sprintf("Unsupported wallet store %s", rootStore))
 		}
-		err := wallet.UseStore(store)
+		err := e2wallet.UseStore(store)
 		errCheck(err, "Failed to use defined wallet store")
 	} else {
-		err := initRemote()
-		errCheck(err, "Failed to connect to remote wallet")
+		remote = true
 	}
 }
 
@@ -164,18 +155,18 @@ func init() {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().String("basedir", "", "Base directory for filesystem wallets")
-	if err := viper.BindPFlag("basedir", RootCmd.PersistentFlags().Lookup("basedir")); err != nil {
+	if err := viper.BindPFlag("base-dir", RootCmd.PersistentFlags().Lookup("basedir")); err != nil {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().String("storepassphrase", "", "Passphrase for store (if applicable)")
-	if err := viper.BindPFlag("storepassphrase", RootCmd.PersistentFlags().Lookup("storepassphrase")); err != nil {
+	if err := viper.BindPFlag("store-passphrase", RootCmd.PersistentFlags().Lookup("storepassphrase")); err != nil {
 		panic(err)
 	}
 	RootCmd.PersistentFlags().String("walletpassphrase", "", "Passphrase for wallet (if applicable)")
-	if err := viper.BindPFlag("walletpassphrase", RootCmd.PersistentFlags().Lookup("walletpassphrase")); err != nil {
+	if err := viper.BindPFlag("wallet-passphrase", RootCmd.PersistentFlags().Lookup("walletpassphrase")); err != nil {
 		panic(err)
 	}
-	RootCmd.PersistentFlags().String("passphrase", "", "Passphrase for account (if applicable)")
+	RootCmd.PersistentFlags().StringSlice("passphrase", nil, "Passphrase for account (if applicable)")
 	if err := viper.BindPFlag("passphrase", RootCmd.PersistentFlags().Lookup("passphrase")); err != nil {
 		panic(err)
 	}
@@ -233,6 +224,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,84 +244,100 @@ 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(viper.GetString("wallet-passphrase")))
+			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)
+// walletAndAccountsFromPath obtains the wallet and matching accounts given a path specification.
+func walletAndAccountsFromPath(ctx context.Context, path string) (e2wtypes.Wallet, []e2wtypes.Account, error) {
+	wallet, err := walletFromPath(ctx, path)
 	if err != nil {
-		return nil, err
-	}
-	_, accountSpec, err := walletAndAccountNamesFromPath(path)
-	if err != nil {
-		return nil, err
+		return nil, nil, errors.Wrap(err, "faild to open wallet for account")
 	}
 
+	_, accountSpec, err := e2wallet.WalletAndAccountNames(path)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "failed to obtain account specification")
+	}
 	if accountSpec == "" {
 		accountSpec = "^.*$"
 	} else {
@@ -337,7 +345,8 @@ func accountsFromPath(path string) ([]wtypes.Account, error) {
 	}
 	re := regexp.MustCompile(accountSpec)
 
-	for account := range wallet.Accounts() {
+	accounts := make([]e2wtypes.Account, 0)
+	for account := range wallet.Accounts(ctx) {
 		if re.Match([]byte(account.Name())) {
 			accounts = append(accounts, account)
 		}
@@ -348,54 +357,16 @@ func accountsFromPath(path string) ([]wtypes.Account, error) {
 		return accounts[i].Name() < accounts[j].Name()
 	})
 
-	return accounts, 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)
+	return wallet, accounts, nil
 }
 
 // connect connects to an Ethereum 2 endpoint.
 func connect() error {
+	if eth2GRPCConn != nil {
+		// Already connected.
+		return nil
+	}
+
 	connection := ""
 	if viper.GetString("connection") != "" {
 		connection = viper.GetString("connection")
@@ -415,46 +386,42 @@ func connect() error {
 	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)
-		if err != nil {
-			return errors.Wrap(err, "failed to access CA certificate")
+// 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 {
+		publicKeyProvider, isPublicKeyProvider := account.(e2wtypes.AccountPublicKeyProvider)
+		if isPublicKeyProvider {
+			pubKey = publicKeyProvider.PublicKey()
+		} else {
+			return nil, errors.New("account does not provide a public key")
 		}
-		cp := x509.NewCertPool()
-		if !cp.AppendCertsFromPEM(serverCA) {
-			return errors.Wrap(err, "failed to add CA certificate")
-		}
-		tlsCfg.RootCAs = cp
 	}
-
-	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 pubKey, nil
+}
+
+// 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 nil, errors.Wrap(err, fmt.Sprintf("invalid port in remote %q", remote))
+		}
+		endpoints = append(endpoints, dirk.NewEndpoint(parts[0], uint32(port)))
+	}
+	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,195 @@
+// 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"
+	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+// signStruct signs an arbitrary structure.
+func signStruct(account wtypes.Account, data interface{}, domain []byte) (e2types.Signature, error) {
+	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)
+}
+
+// verifyStruct verifies the signature of an arbitrary structure.
+func verifyStruct(account wtypes.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 wtypes.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 wtypes.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 wtypes.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 wtypes.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 wtypes.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/validatordepositdata.go

@@ -14,6 +14,7 @@
 package cmd
 
 import (
+	"context"
 	"encoding/hex"
 	"fmt"
 	"os"
@@ -21,6 +22,7 @@ import (
 
 	"github.com/prysmaticlabs/go-ssz"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/grpc"
 	e2types "github.com/wealdtech/go-eth2-types/v2"
 	util "github.com/wealdtech/go-eth2-util"
@@ -33,6 +35,7 @@ var validatorDepositDataWithdrawalPubKey string
 var validatorDepositDataDepositValue string
 var validatorDepositDataRaw bool
 var validatorDepositDataForkVersion string
+var validatorDepositDataLaunchpad bool
 
 var validatorDepositDataCmd = &cobra.Command{
 	Use:   "depositdata",
@@ -47,28 +50,30 @@ The information generated can be passed to ethereal to create a deposit from the
 
 In quiet mode this will return 0 if the the data can be generated correctly, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
 		assert(validatorDepositDataValidatorAccount != "", "--validatoraccount is required")
-		validatorWallet, err := walletFromPath(validatorDepositDataValidatorAccount)
-		errCheck(err, "Failed to obtain validator wallet")
-		validatorAccounts, err := accountsFromPath(validatorDepositDataValidatorAccount)
-		errCheck(err, "Failed to obtain validator account")
+		validatorWallet, validatorAccounts, err := walletAndAccountsFromPath(ctx, validatorDepositDataValidatorAccount)
+		errCheck(err, "Failed to obtain validator accounts")
 		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()))
-			}
+
+		for _, validatorAccount := range validatorAccounts {
+			outputIf(verbose, fmt.Sprintf("Creating deposit for %s/%s", validatorWallet.Name(), validatorAccount.Name()))
+			pubKey, err := bestPublicKey(validatorAccount)
+			errCheck(err, "Validator account does not provide a public key")
+			outputIf(debug, fmt.Sprintf("Validator public key is %#x", pubKey.Marshal()))
 		}
 
 		assert(validatorDepositDataWithdrawalAccount != "" || validatorDepositDataWithdrawalPubKey != "", "--withdrawalaccount or --withdrawalpubkey is required")
 		var withdrawalCredentials []byte
 		if validatorDepositDataWithdrawalAccount != "" {
-			withdrawalAccount, err := accountFromPath(validatorDepositDataWithdrawalAccount)
+			_, withdrawalAccount, err := walletAndAccountFromPath(ctx, 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())
+			pubKey, err := bestPublicKey(withdrawalAccount)
+			errCheck(err, "Withdrawal account does not provide a public key")
+			outputIf(debug, fmt.Sprintf("Withdrawal public key is %#x", pubKey.Marshal()))
+			withdrawalCredentials = util.SHA256(pubKey.Marshal())
 			errCheck(err, "Failed to hash withdrawal credentials")
 		} else {
 			withdrawalPubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(validatorDepositDataWithdrawalPubKey, "0x"))
@@ -81,7 +86,7 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 		}
 		// 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))
+		outputIf(debug, fmt.Sprintf("Withdrawal credentials are %#x", withdrawalCredentials))
 
 		assert(validatorDepositDataDepositValue != "", "--depositvalue is required")
 		val, err := string2eth.StringToGWei(validatorDepositDataDepositValue)
@@ -92,12 +97,14 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 		// For each key, generate deposit data
 		outputs := make([]string, 0)
 		for _, validatorAccount := range validatorAccounts {
+			validatorPubKey, err := bestPublicKey(validatorAccount)
+			errCheck(err, "Validator account does not provide a public key")
 			depositData := struct {
 				PubKey                []byte `ssz-size:"48"`
 				WithdrawalCredentials []byte `ssz-size:"32"`
 				Value                 uint64
 			}{
-				PubKey:                validatorAccount.PublicKey().Marshal(),
+				PubKey:                validatorPubKey.Marshal(),
 				WithdrawalCredentials: withdrawalCredentials,
 				Value:                 val,
 			}
@@ -112,7 +119,10 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 				err := connect()
 				errCheck(err, "Failed to connect to beacon node")
 				config, err := grpc.FetchChainConfig(eth2GRPCConn)
-				errCheck(err, "Failed to obtain chain configuration")
+				if err != nil {
+					outputIf(!quiet, "Could not connect to beacon node; supply a connection with --connection or provide a fork version with --forkversion to generate a deposit")
+					os.Exit(_exitFailure)
+				}
 				genesisForkVersion, exists := config["GenesisForkVersion"]
 				assert(exists, "Failed to obtain genesis fork version")
 				forkVersion = genesisForkVersion.([]byte)
@@ -121,10 +131,7 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 
 			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 {
@@ -133,18 +140,25 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 				Value                 uint64
 				Signature             []byte `ssz-size:"96"`
 			}{
-				PubKey:                validatorAccount.PublicKey().Marshal(),
+				PubKey:                validatorPubKey.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))
+			if debug {
+				fmt.Printf("Signed deposit data:\n")
+				fmt.Printf(" Public key: %#x\n", signedDepositData.PubKey)
+				fmt.Printf(" Withdrawal credentials: %#x\n", signedDepositData.WithdrawalCredentials)
+				fmt.Printf(" Value: %d\n", signedDepositData.Value)
+				fmt.Printf(" Signature: %#x\n", signedDepositData.Signature)
+			}
 
 			depositDataRoot, err := ssz.HashTreeRoot(signedDepositData)
 			errCheck(err, "Failed to generate deposit data root")
 			outputIf(debug, fmt.Sprintf("Deposit data root is %x", depositDataRoot))
 
-			if validatorDepositDataRaw {
+			switch {
+			case validatorDepositDataRaw:
 				// Build a raw transaction by hand
 				txData := []byte{0x22, 0x89, 0x51, 0x18}
 				// Pointer to validator public key
@@ -157,7 +171,7 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 				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, validatorPubKey.Marshal()...)
 				txData = append(txData, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}...)
 				// Withdrawal credentials
 				txData = append(txData, []byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20}...)
@@ -166,8 +180,21 @@ In quiet mode this will return 0 if the the data can be generated correctly, oth
 				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))
+			case validatorDepositDataLaunchpad:
+				depositMessage := struct {
+					PubKey                []byte `ssz-size:"48"`
+					WithdrawalCredentials []byte `ssz-size:"32"`
+					Value                 uint64
+				}{
+					PubKey:                validatorPubKey.Marshal(),
+					WithdrawalCredentials: withdrawalCredentials,
+					Value:                 val,
+				}
+				depositMessageRoot, err := ssz.HashTreeRoot(depositMessage)
+				errCheck(err, "Failed to generate deposit message root")
+				outputs = append(outputs, fmt.Sprintf(`{"pubkey":"%x","withdrawal_credentials":"%x","amount":%d,"signature":"%x","deposit_message_root":"%x","deposit_data_root":"%x","fork_version":"%x"}`, signedDepositData.PubKey, signedDepositData.WithdrawalCredentials, val, signedDepositData.Signature, depositMessageRoot, depositDataRoot, forkVersion))
+			default:
+				outputs = append(outputs, fmt.Sprintf(`{"name":"Deposit for %s","account":"%s","pubkey":"%#x","withdrawal_credentials":"%#x","signature":"%#x","value":%d,"deposit_data_root":"%#x","version":2}`, fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()), fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()), signedDepositData.PubKey, signedDepositData.WithdrawalCredentials, signedDepositData.Signature, val, depositDataRoot))
 			}
 		}
 
@@ -194,4 +221,5 @@ func init() {
 	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().BoolVar(&validatorDepositDataLaunchpad, "launchpad", false, "Print launchpad-compatible JSON")
 }

cmd/validatorexit.go

@@ -46,36 +46,40 @@ var validatorExitCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the transaction has been generated, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
 		err := connect()
 		errCheck(err, "Failed to obtain connect to Ethereum 2 beacon chain node")
 
-		exit, signature := validatorExitHandleInput()
-		validatorExitHandleExit(exit, signature)
+		exit, signature, forkVersion := validatorExitHandleInput(ctx)
+		validatorExitHandleExit(ctx, exit, signature, forkVersion)
 		os.Exit(_exitSuccess)
 	},
 }
 
-func validatorExitHandleInput() (*ethpb.VoluntaryExit, e2types.Signature) {
+func validatorExitHandleInput(ctx context.Context) (*ethpb.VoluntaryExit, e2types.Signature, []byte) {
 	if validatorExitJSON != "" {
 		return validatorExitHandleJSONInput(validatorExitJSON)
 	}
-	if rootAccount != "" {
-		account, err := accountFromPath(rootAccount)
-		errCheck(err, "Failed to access account")
-		return validatorExitHandleAccountInput(account)
+	if viper.GetString("account") != "" {
+		_, account, err := walletAndAccountFromInput(ctx)
+		errCheck(err, "Failed to obtain account")
+		outputIf(debug, fmt.Sprintf("Account %s obtained", account.Name()))
+		return validatorExitHandleAccountInput(ctx, account)
 	}
 	if validatorExitKey != "" {
 		privKeyBytes, err := hex.DecodeString(strings.TrimPrefix(validatorExitKey, "0x"))
 		errCheck(err, fmt.Sprintf("Failed to decode key %s", validatorExitKey))
 		account, err := util.NewScratchAccount(privKeyBytes, nil)
 		errCheck(err, "Invalid private key")
-		return validatorExitHandleAccountInput(account)
+		return validatorExitHandleAccountInput(ctx, account)
 	}
 	die("one of --json, --account or --key is required")
-	return nil, nil
+	return nil, nil, nil
 }
 
-func validatorExitHandleJSONInput(input string) (*ethpb.VoluntaryExit, e2types.Signature) {
+func validatorExitHandleJSONInput(input string) (*ethpb.VoluntaryExit, e2types.Signature, []byte) {
 	data := &validatorExitData{}
 	err := json.Unmarshal([]byte(input), data)
 	errCheck(err, "Invalid JSON input")
@@ -85,16 +89,20 @@ func validatorExitHandleJSONInput(input string) (*ethpb.VoluntaryExit, e2types.S
 	}
 	signature, err := e2types.BLSSignatureFromBytes(data.Signature)
 	errCheck(err, "Invalid signature")
-	return exit, signature
+	return exit, signature, data.ForkVersion
 }
 
-func validatorExitHandleAccountInput(account e2wtypes.Account) (*ethpb.VoluntaryExit, e2types.Signature) {
+func validatorExitHandleAccountInput(ctx context.Context, account e2wtypes.Account) (*ethpb.VoluntaryExit, e2types.Signature, []byte) {
 	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)
+	secondsPerSlot, ok := config["SecondsPerSlot"].(uint64)
+	assert(ok, "Failed to obtain seconds per slot from chain")
+	slotsPerEpoch, ok := config["SlotsPerEpoch"].(uint64)
+	assert(ok, "Failed to obtain slots per epoch from chain")
+	secondsPerEpoch := secondsPerSlot * slotsPerEpoch
 
 	// Fetch the validator's index.
 	index, err := grpc.FetchValidatorIndex(eth2GRPCConn, account)
@@ -113,7 +121,9 @@ func validatorExitHandleAccountInput(account e2wtypes.Account) (*ethpb.Voluntary
 		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)
+		shardCommitteePeriod, ok := config["ShardCommitteePeriod"].(uint64)
+		assert(ok, "Failed to obtain shard committee period from chain")
+		earliestExitEpoch := validator.ActivationEpoch + shardCommitteePeriod
 
 		genesisTime, err := grpc.FetchGenesisTime(eth2GRPCConn)
 		errCheck(err, "Failed to obtain genesis time")
@@ -128,28 +138,32 @@ func validatorExitHandleAccountInput(account e2wtypes.Account) (*ethpb.Voluntary
 	}
 
 	// 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))
+	forkVersion := config["GenesisForkVersion"].([]byte)
+	outputIf(debug, fmt.Sprintf("Current fork version is %x", forkVersion))
 	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)
+	domain := e2types.Domain(e2types.DomainVoluntaryExit, forkVersion, genesisValidatorsRoot)
 
-	err = account.Unlock([]byte(rootAccountPassphrase))
+	alreadyUnlocked, err := unlock(account)
 	errCheck(err, "Failed to unlock account; please confirm passphrase is correct")
 	signature, err := signStruct(account, exit, domain)
+	if !alreadyUnlocked {
+		errCheck(lock(account), "Failed to re-lock account")
+	}
 	errCheck(err, "Failed to sign exit proposal")
 
-	return exit, signature
+	return exit, signature, forkVersion
 }
 
 // validatorExitHandleExit handles the exit request.
-func validatorExitHandleExit(exit *ethpb.VoluntaryExit, signature e2types.Signature) {
+func validatorExitHandleExit(ctx context.Context, exit *ethpb.VoluntaryExit, signature e2types.Signature, forkVersion []byte) {
 	if validatorExitJSONOutput {
 		data := &validatorExitData{
 			Epoch:          exit.Epoch,
 			ValidatorIndex: exit.ValidatorIndex,
 			Signature:      signature.Marshal(),
+			ForkVersion:    forkVersion,
 		}
 		res, err := json.Marshal(data)
 		errCheck(err, "Failed to generate JSON")
@@ -161,8 +175,6 @@ func validatorExitHandleExit(exit *ethpb.VoluntaryExit, signature e2types.Signat
 		}
 
 		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")
@@ -182,11 +194,12 @@ type validatorExitData struct {
 	Epoch          uint64 `json:"epoch"`
 	ValidatorIndex uint64 `json:"validator_index"`
 	Signature      []byte `json:"signature"`
+	ForkVersion    []byte `json:"fork_version"`
 }
 
 // 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
+	return []byte(fmt.Sprintf(`{"epoch":%d,"validator_index":%d,"signature":"%#x","fork_version":"%#x"}`, d.Epoch, d.ValidatorIndex, d.Signature, d.ForkVersion)), nil
 }
 
 // UnmarshalJSON implements custom JSON unmarshaller.
@@ -232,5 +245,19 @@ func (d *validatorExitData) UnmarshalJSON(data []byte) error {
 		return errors.New("signature missing")
 	}
 
+	if val, exists := v["fork_version"]; exists {
+		forkVersionBytes, ok := val.(string)
+		if !ok {
+			return errors.New("fork version invalid")
+		}
+		forkVersion, err := hex.DecodeString(strings.TrimPrefix(forkVersionBytes, "0x"))
+		if err != nil {
+			return errors.Wrap(err, "fork version invalid")
+		}
+		d.ForkVersion = forkVersion
+	} else {
+		return errors.New("fork version missing")
+	}
+
 	return nil
 }

cmd/validatorinfo.go

@@ -14,17 +14,25 @@
 package cmd
 
 import (
+	"bytes"
+	"context"
 	"encoding/hex"
+	"encoding/json"
 	"fmt"
+	"io/ioutil"
+	"net/http"
 	"os"
+	"strconv"
 	"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"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 	string2eth "github.com/wealdtech/go-string2eth"
 )
 
@@ -39,66 +47,76 @@ 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")
+		assert(viper.GetString("account") != "" || validatorInfoPubKey != "", "--account or --pubkey is required")
 
 		err := connect()
 		errCheck(err, "Failed to obtain connection to Ethereum 2 beacon chain 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")
+
+		if verbose {
+			network := network()
+			outputIf(debug, fmt.Sprintf("Network is %s", network))
+			pubKey, err := bestPublicKey(account)
+			if err == nil {
+				deposits, totalDeposited, err := graphData(network, pubKey.Marshal())
+				if err == nil {
+					fmt.Printf("Number of deposits: %d\n", deposits)
+					fmt.Printf("Total deposited: %s\n", string2eth.GWeiToString(totalDeposited, true))
+				}
+			}
 		}
 
 		validatorInfo, err := grpc.FetchValidatorInfo(eth2GRPCConn, account)
 		errCheck(err, "Failed to obtain validator information")
-		validatorDef, err := grpc.FetchValidator(eth2GRPCConn, account)
+		validator, err := grpc.FetchValidator(eth2GRPCConn, account)
+		if err != nil {
+			// We can live with this.
+			validator = nil
+		}
 		if validatorInfo.Status != ethpb.ValidatorStatus_DEPOSITED &&
 			validatorInfo.Status != ethpb.ValidatorStatus_UNKNOWN_STATUS {
 			errCheck(err, "Failed to obtain validator definition")
 		}
-
 		assert(validatorInfo.Status != ethpb.ValidatorStatus_UNKNOWN_STATUS, "Not known as a validator")
 
 		if quiet {
 			os.Exit(_exitSuccess)
 		}
 
-		outputIf(verbose, fmt.Sprintf("Epoch of data:\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))
+		outputIf(verbose, fmt.Sprintf("Epoch of data: %v", validatorInfo.Epoch))
+		outputIf(verbose && validatorInfo.Status != ethpb.ValidatorStatus_DEPOSITED, fmt.Sprintf("Index: %v", validatorInfo.Index))
+		outputIf(verbose, fmt.Sprintf("Public key: %#x", validatorInfo.PublicKey))
+		fmt.Printf("Status: %s\n", strings.Title(strings.ToLower(validatorInfo.Status.String())))
+		fmt.Printf("Balance: %s\n", string2eth.GWeiToString(validatorInfo.Balance, true))
+
 		if validatorInfo.Status == ethpb.ValidatorStatus_ACTIVE ||
 			validatorInfo.Status == ethpb.ValidatorStatus_EXITING ||
 			validatorInfo.Status == ethpb.ValidatorStatus_SLASHING {
-			fmt.Printf("Effective balance:\t%s\n", string2eth.GWeiToString(validatorInfo.EffectiveBalance, true))
+			fmt.Printf("Effective balance: %s\n", string2eth.GWeiToString(validatorInfo.EffectiveBalance, true))
 		}
-		if validatorDef != nil {
-			outputIf(verbose, fmt.Sprintf("Withdrawal credentials:\t%#x", validatorDef.WithdrawalCredentials))
+
+		if validator != nil {
+			outputIf(verbose, fmt.Sprintf("Withdrawal credentials: %#x", validator.WithdrawalCredentials))
 		}
+
 		transition := time.Unix(int64(validatorInfo.TransitionTimestamp), 0)
 		transitionPassed := int64(validatorInfo.TransitionTimestamp) <= time.Now().Unix()
 		switch validatorInfo.Status {
 		case ethpb.ValidatorStatus_DEPOSITED:
 			if validatorInfo.TransitionTimestamp != 0 {
-				fmt.Printf("Inclusion in chain:\t%s\n", transition)
+				fmt.Printf("Inclusion in chain: %s\n", transition)
 			}
 		case ethpb.ValidatorStatus_PENDING:
-			fmt.Printf("Activation:\t\t%s\n", transition)
+			fmt.Printf("Activation: %s\n", transition)
 		case ethpb.ValidatorStatus_EXITING, ethpb.ValidatorStatus_SLASHING:
-			fmt.Printf("Attesting finishes:\t%s\n", transition)
+			fmt.Printf("Attesting finishes: %s\n", transition)
 		case ethpb.ValidatorStatus_EXITED:
 			if transitionPassed {
-				fmt.Printf("Funds withdrawable:\tNow\n")
+				fmt.Printf("Funds withdrawable: Now\n")
 			} else {
-				fmt.Printf("Funds withdrawable:\t%s\n", transition)
+				fmt.Printf("Funds withdrawable: %s\n", transition)
 			}
 		}
 
@@ -106,6 +124,76 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 	},
 }
 
+// validatorInfoAccount obtains the account for the validator info command.
+func validatorInfoAccount() (e2wtypes.Account, error) {
+	var account e2wtypes.Account
+	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(validatorInfoPubKey, "0x"))
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", validatorInfoPubKey))
+		}
+		account, err = util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", validatorInfoPubKey))
+		}
+	}
+	return account, nil
+}
+
+// graphData returns data from the graph about number and amount of deposits
+func graphData(network string, validatorPubKey []byte) (uint64, uint64, error) {
+	subgraph := fmt.Sprintf("attestantio/eth2deposits-%s", strings.ToLower(network))
+	query := fmt.Sprintf(`{"query": "{deposits(where: {validatorPubKey:\"%#x\"}) { id amount withdrawalCredentials }}"}`, validatorPubKey)
+	url := fmt.Sprintf("https://api.thegraph.com/subgraphs/name/%s", subgraph)
+	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 := uint64(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 += depositAmount
+		}
+	}
+	return deposits, totalDeposited, nil
+}
+
 func init() {
 	validatorCmd.AddCommand(validatorInfoCmd)
 	validatorInfoCmd.Flags().StringVar(&validatorInfoPubKey, "pubkey", "", "Public key for which to obtain status")

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,17 @@ import (
 	"github.com/spf13/viper"
 )
 
+var ReleaseVersion = "local build from v1.6.0"
+
 // 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/walletaccounts.go

@@ -17,10 +17,13 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"sort"
+	"strconv"
+	"strings"
 
 	"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 walletAccountsCmd = &cobra.Command{
@@ -32,52 +35,74 @@ var walletAccountsCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the wallet holds any addresses, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(walletWallet != "", "--wallet is required")
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
 
-		hasAccounts := false
+		assert(viper.GetString("wallet") != "", "wallet is required")
 
-		if remote {
-			listerClient := pb.NewListerClient(remoteGRPCConn)
-			listAccountsReq := &pb.ListAccountsRequest{
-				Paths: []string{
-					walletWallet,
-				},
-			}
-			ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
-			defer cancel()
-			accountsResp, err := listerClient.ListAccounts(ctx, listAccountsReq)
-			errCheck(err, "Failed to access wallet")
-			assert(accountsResp.State == pb.ResponseState_SUCCEEDED, "Request to list wallet accounts failed")
-			walletPrefixLen := len(walletWallet) + 1
-			for _, account := range accountsResp.Accounts {
-				hasAccounts = true
-				if verbose {
-					fmt.Printf("%s\n", account.Name[walletPrefixLen:])
-					fmt.Printf("\tPublic key: %#048x\n", account.PublicKey)
-				} else if !quiet {
-					fmt.Printf("%s\n", account.Name[walletPrefixLen:])
+		wallet, err := walletFromInput(ctx)
+		errCheck(err, "Failed to obtain wallet")
+
+		accounts := make([]e2wtypes.Account, 0, 128)
+		for account := range wallet.Accounts(ctx) {
+			accounts = append(accounts, account)
+		}
+		assert(len(accounts) > 0, "")
+
+		if _, isPathProvider := accounts[0].(e2wtypes.AccountPathProvider); isPathProvider {
+			// Order accounts by their path components.
+			sort.Slice(accounts, func(i int, j int) bool {
+				iBits := strings.Split(accounts[i].(e2wtypes.AccountPathProvider).Path(), "/")
+				jBits := strings.Split(accounts[j].(e2wtypes.AccountPathProvider).Path(), "/")
+				for index := range iBits {
+					if iBits[index] == "m" && jBits[index] == "m" {
+						continue
+					}
+					if len(jBits) <= index {
+						return false
+					}
+					iBit, err := strconv.ParseUint(iBits[index], 10, 64)
+					if err != nil {
+						return true
+					}
+					jBit, err := strconv.ParseUint(jBits[index], 10, 64)
+					if err != nil {
+						return false
+					}
+					if iBit < jBit {
+						return true
+					}
+					if iBit > jBit {
+						return false
+					}
 				}
-			}
+				return len(jBits) > len(iBits)
+			})
 		} else {
-			wallet, err := walletFromPath(walletWallet)
-			errCheck(err, "Failed to access wallet")
+			// Order accounts by their name.
+			sort.Slice(accounts, func(i int, j int) bool {
+				return strings.Compare(accounts[i].Name(), accounts[j].Name()) < 0
+			})
+		}
 
-			for account := range wallet.Accounts() {
-				hasAccounts = true
-				if verbose {
-					fmt.Printf("%s\n\tUUID:\t\t%s\n\tPublic key:\t0x%048x\n", account.Name(), account.ID(), account.PublicKey().Marshal())
-				} else if !quiet {
-					fmt.Printf("%s\n", account.Name())
+		for _, account := range accounts {
+			outputIf(!quiet, account.Name())
+			if verbose {
+				fmt.Printf(" UUID: %v\n", account.ID())
+				if pathProvider, isProvider := account.(e2wtypes.AccountPathProvider); isProvider {
+					if pathProvider.Path() != "" {
+						fmt.Printf("Path: %s\n", pathProvider.Path())
+					}
+				}
+				if pubKeyProvider, isProvider := account.(e2wtypes.AccountPublicKeyProvider); isProvider {
+					fmt.Printf(" Public key: %#x\n", pubKeyProvider.PublicKey().Marshal())
+				}
+				if compositePubKeyProvider, isProvider := account.(e2wtypes.AccountCompositePublicKeyProvider); isProvider {
+					fmt.Printf(" Composite public key: %#x\n", compositePubKeyProvider.CompositePublicKey().Marshal())
 				}
 			}
 		}
-
-		if quiet {
-			if hasAccounts {
-				os.Exit(_exitSuccess)
-			}
-			os.Exit(_exitFailure)
-		}
+		os.Exit(_exitSuccess)
 	},
 }
 

cmd/walletcreate.go

@@ -14,18 +14,23 @@
 package cmd
 
 import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"os"
 	"strings"
 
+	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	bip39 "github.com/tyler-smith/go-bip39"
+	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"
 )
 
-var walletCreateType string
-var walletCreateSeed string
-
 var walletCreateCmd = &cobra.Command{
 	Use:   "create",
 	Short: "Create a wallet",
@@ -35,18 +40,28 @@ var walletCreateCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the wallet is created successfully, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet create not available with remote wallets")
-		assert(walletWallet != "", "--wallet is required")
-		assert(walletCreateType != "", "--type is required")
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
+		assert(viper.GetString("remote") == "", "wallet create not available with remote wallets")
+		assert(viper.GetString("wallet") != "", "--wallet is required")
+		assert(viper.GetString("type") != "", "--type is required")
 
 		var err error
-		switch strings.ToLower(walletCreateType) {
+		switch strings.ToLower(viper.GetString("type")) {
 		case "non-deterministic", "nd":
-			assert(walletCreateSeed == "", "--seed is not allowed with non-deterministic wallets")
-			err = walletCreateND(walletWallet)
+			assert(viper.GetString("mnemonic") == "", "--mnemonic is not allowed with non-deterministic wallets")
+			err = walletCreateND(ctx, viper.GetString("wallet"))
 		case "hierarchical deterministic", "hd":
-			assert(rootWalletPassphrase != "", "--walletpassphrase is required for hierarchical deterministic wallets")
-			err = walletCreateHD(walletWallet, rootWalletPassphrase, walletCreateSeed)
+			if quiet {
+				fmt.Printf("Creation of hierarchical deterministic wallets prints its mnemonic, so cannot be run with the --quiet flag")
+				os.Exit(_exitFailure)
+			}
+			assert(getWalletPassphrase() != "", "--walletpassphrase is required for hierarchical deterministic wallets")
+			err = walletCreateHD(ctx, viper.GetString("wallet"), getWalletPassphrase(), viper.GetString("mnemonic"))
+		case "distributed":
+			assert(viper.GetString("mnemonic") == "", "--mnemonic is not allowed with distributed wallets")
+			err = walletCreateDistributed(ctx, viper.GetString("wallet"))
 		default:
 			die("unknown wallet type")
 		}
@@ -55,33 +70,83 @@ In quiet mode this will return 0 if the wallet is created successfully, otherwis
 }
 
 // walletCreateND creates a non-deterministic wallet.
-func walletCreateND(name string) error {
-	_, err := nd.CreateWallet(name, store, keystorev4.New())
+func walletCreateND(ctx context.Context, name string) error {
+	_, err := nd.CreateWallet(ctx, name, store, keystorev4.New())
 	return err
 }
 
-// walletCreateND creates a hierarchical-deterministic wallet.
-func walletCreateHD(name string, passphrase string, seedPhrase string) error {
+// walletCreateDistributed creates a distributed wallet.
+func walletCreateDistributed(ctx context.Context, name string) error {
+	_, err := distributed.CreateWallet(ctx, name, store, keystorev4.New())
+	return err
+}
+
+// walletCreateHD creates a hierarchical-deterministic wallet.
+func walletCreateHD(ctx context.Context, name string, passphrase string, mnemonic string) error {
 	encryptor := keystorev4.New()
-	if seedPhrase != "" {
-		// Create wallet from a user-supplied seed.
-		var seed []byte
-		seed, err := bip39.MnemonicToByteArray(seedPhrase)
-		errCheck(err, "Failed to decode seed")
-		// Strip checksum; last byte.
-		seed = seed[:len(seed)-1]
-		assert(len(seed) == 32, "Seed must have 24 words")
-		_, err = hd.CreateWalletFromSeed(name, []byte(passphrase), store, encryptor, seed)
-		return err
+
+	printMnemonic := mnemonic == ""
+	mnemonicPassphrase := ""
+
+	if mnemonic == "" {
+		// Create a new random mnemonic.
+		entropy := make([]byte, 32)
+		_, err := rand.Read(entropy)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate entropy for wallet mnemonic")
+		}
+		mnemonic, err = bip39.NewMnemonic(entropy)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate wallet mnemonic")
+		}
+	} else {
+		// We have an existing mnemonic.  If there are more than 24 words we treat the additional characters as the passphrase.
+		mnemonicParts := strings.Split(mnemonic, " ")
+		if len(mnemonicParts) > 24 {
+			mnemonic = strings.Join(mnemonicParts[:24], " ")
+			mnemonicPassphrase = strings.Join(mnemonicParts[24:], " ")
+		}
 	}
-	// Create wallet with a random seed.
-	_, err := hd.CreateWallet(name, []byte(passphrase), store, encryptor)
+	// Normalise the input.
+	mnemonic = string(norm.NFKD.Bytes([]byte(mnemonic)))
+	mnemonicPassphrase = string(norm.NFKD.Bytes([]byte(mnemonicPassphrase)))
+
+	// Ensure the mnemonic is valid
+	if !bip39.IsMnemonicValid(mnemonic) {
+		return errors.New("mnemonic is not valid")
+	}
+
+	// Create seed from mnemonic and passphrase.
+	seed := bip39.NewSeed(mnemonic, mnemonicPassphrase)
+
+	_, err := hd.CreateWallet(ctx, name, []byte(passphrase), store, encryptor, seed)
+
+	if printMnemonic {
+		fmt.Printf(`The following phrase is your mnemonic for this wallet:
+
+%s
+
+Anyone with access to this mnemonic can recreate the accounts in this wallet, so please store this mnemonic safely.  More information about mnemonics can be found at https://support.mycrypto.com/general-knowledge/cryptography/how-do-mnemonic-phrases-work
+
+Please note this mnemonic is not stored within the wallet, so cannot be retrieved or displayed again.  As such, this mnemonic should be written down or otherwise protected before proceeding.
+`, mnemonic)
+	}
+
 	return err
 }
 
 func init() {
 	walletCmd.AddCommand(walletCreateCmd)
 	walletFlags(walletCreateCmd)
-	walletCreateCmd.Flags().StringVar(&walletCreateType, "type", "non-deterministic", "Type of wallet to create (non-deterministic or hierarchical deterministic)")
-	walletCreateCmd.Flags().StringVar(&walletCreateSeed, "seed", "", "The 24-word seed phrase for a hierarchical deterministic wallet")
+	walletCreateCmd.Flags().String("type", "non-deterministic", "Type of wallet to create (non-deterministic or hierarchical deterministic)")
+	walletCreateCmd.Flags().String("mnemonic", "", "The 24-word mnemonic for a hierarchical deterministic wallet")
+}
+
+func walletCreateBindings() {
+	if err := viper.BindPFlag("type", walletCreateCmd.Flags().Lookup("type")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("mnemonic", walletCreateCmd.Flags().Lookup("mnemonic")); err != nil {
+		panic(err)
+	}
 }

cmd/walletdelete.go

@@ -14,10 +14,12 @@
 package cmd
 
 import (
+	"context"
 	"os"
 	"path/filepath"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -30,10 +32,13 @@ var walletDeleteCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the wallet has been deleted, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet delete not available with remote wallets")
-		assert(walletWallet != "", "--wallet is required")
+		assert(viper.GetString("remote") == "", "wallet delete not available with remote wallets")
+		assert(viper.GetString("wallet") != "", "--wallet is required")
 
-		wallet, err := walletFromPath(walletWallet)
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
+		wallet, err := walletFromPath(ctx, viper.GetString("wallet"))
 		errCheck(err, "Failed to access wallet")
 
 		storeProvider, ok := wallet.(wtypes.StoreProvider)

cmd/walletexport.go

@@ -14,10 +14,12 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	types "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -32,17 +34,20 @@ var walletExportCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the wallet is able to be exported, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet export not available with remote wallets")
-		assert(walletWallet != "", "--wallet is required")
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
+
+		assert(viper.GetString("remote") == "", "wallet export not available with remote wallets")
+		assert(viper.GetString("wallet") != "", "--wallet is required")
 		assert(walletExportPassphrase != "", "--exportpassphrase is required")
 
-		wallet, err := walletFromPath(walletWallet)
+		wallet, err := walletFromPath(ctx, viper.GetString("wallet"))
 		errCheck(err, "Failed to access wallet")
 
 		_, ok := wallet.(types.WalletExporter)
 		assert(ok, fmt.Sprintf("wallets of type %q do not allow exporting accounts", wallet.Type()))
 
-		exportData, err := wallet.(types.WalletExporter).Export([]byte(walletExportPassphrase))
+		exportData, err := wallet.(types.WalletExporter).Export(ctx, []byte(walletExportPassphrase))
 		errCheck(err, "Failed to export wallet")
 
 		outputIf(!quiet, fmt.Sprintf("0x%x", exportData))

cmd/walletimport.go

@@ -22,9 +22,10 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	"github.com/wealdtech/go-bytesutil"
 	"github.com/wealdtech/go-ecodec"
-	wallet "github.com/wealdtech/go-eth2-wallet"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
 )
 
 var walletImportData string
@@ -40,10 +41,10 @@ var walletImportCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the wallet is imported successfully, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet import not available with remote wallets")
+		assert(viper.GetString("remote") == "", "wallet import not available with remote wallets")
 		assert(walletImportData != "", "--importdata is required")
 		assert(walletImportPassphrase != "", "--importpassphrase is required")
-		assert(walletWallet == "", "--wallet is not allowed (the wallet will retain its name)")
+		assert(viper.GetString("wallet") == "", "--wallet is not allowed (the wallet will retain its name)")
 
 		if !strings.HasPrefix(walletImportData, "0x") {
 			outputIf(debug, fmt.Sprintf("Reading wallet import from file %s", walletImportData))
@@ -89,7 +90,7 @@ In quiet mode this will return 0 if the wallet is imported successfully, otherwi
 			}
 
 		} else {
-			_, err = wallet.ImportWallet(importData, []byte(walletImportPassphrase))
+			_, err = e2wallet.ImportWallet(importData, []byte(walletImportPassphrase))
 			errCheck(err, "Failed to import wallet")
 		}
 

cmd/walletinfo.go

@@ -14,11 +14,13 @@
 package cmd
 
 import (
+	"context"
 	"fmt"
 	"os"
 	"path/filepath"
 
 	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
 	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
@@ -31,10 +33,13 @@ var walletInfoCmd = &cobra.Command{
 
 In quiet mode this will return 0 if the wallet exists, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet info not available with remote wallets")
-		assert(walletWallet != "", "--wallet is required")
+		ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+		defer cancel()
 
-		wallet, err := walletFromPath(walletWallet)
+		assert(viper.GetString("remote") == "", "wallet info not available with remote wallets")
+		assert(viper.GetString("wallet") != "", "--wallet is required")
+
+		wallet, err := walletFromPath(ctx, viper.GetString("wallet"))
 		errCheck(err, "unknown wallet")
 
 		if quiet {
@@ -55,7 +60,7 @@ In quiet mode this will return 0 if the wallet exists, otherwise 1.`,
 
 		// Count the accounts.
 		accounts := 0
-		for range wallet.Accounts() {
+		for range wallet.Accounts(ctx) {
 			accounts++
 		}
 		fmt.Printf("Accounts: %d\n", accounts)

cmd/walletlist.go

@@ -18,7 +18,8 @@ import (
 	"os"
 
 	"github.com/spf13/cobra"
-	wallet "github.com/wealdtech/go-eth2-wallet"
+	"github.com/spf13/viper"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
 )
 
 var walletListCmd = &cobra.Command{
@@ -30,17 +31,14 @@ var walletListCmd = &cobra.Command{
 
 In quiet mode this will return 0 if any wallets are found, otherwise 1.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet list not available with remote wallets")
+		assert(viper.GetString("remote") == "", "wallet list not available with remote wallets")
+		assert(viper.GetString("wallet") == "", "wallet list does not take a --wallet parameter")
 
 		walletsFound := false
-		if remote {
-			die("Remote wallets cannot be listed")
-		} else {
-			for w := range wallet.Wallets() {
-				walletsFound = true
-				outputIf(!quiet && !verbose, w.Name())
-				outputIf(verbose, fmt.Sprintf("%s\n\tUUID:\t\t%s", w.Name(), w.ID().String()))
-			}
+		for w := range e2wallet.Wallets() {
+			walletsFound = true
+			outputIf(!quiet && !verbose, w.Name())
+			outputIf(verbose, fmt.Sprintf("%s\n UUID: %s", w.Name(), w.ID().String()))
 		}
 
 		if !walletsFound {

cmd/walletseed.go

@@ -1,68 +0,0 @@
-// Copyright © 2019, 2020 Weald Technology Trading
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package cmd
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-
-	"github.com/spf13/cobra"
-	bip39 "github.com/tyler-smith/go-bip39"
-	types "github.com/wealdtech/go-eth2-wallet-types/v2"
-)
-
-var walletSeedCmd = &cobra.Command{
-	Use:   "seed",
-	Short: "Display the seed of a wallet",
-	Long: `Display the seed for an hierarchical deterministic wallet.  For example:
-
-    ethdo wallet seed --wallet=primary
-
-In quiet mode this will return 0 if the wallet is a hierarchical deterministic wallet, otherwise 1.`,
-	Run: func(cmd *cobra.Command, args []string) {
-		assert(!remote, "wallet seed not available with remote wallets")
-		assert(walletWallet != "", "--wallet is required")
-		assert(rootWalletPassphrase != "", "--walletpassphrase is required")
-
-		wallet, err := walletFromPath(walletWallet)
-		errCheck(err, "Failed to access wallet")
-		_, ok := wallet.(types.WalletKeyProvider)
-		assert(ok, fmt.Sprintf("wallets of type %q do not have a seed", wallet.Type()))
-
-		err = wallet.Unlock([]byte(rootWalletPassphrase))
-		errCheck(err, "Failed to unlock wallet")
-		seed, err := wallet.(types.WalletKeyProvider).Key()
-		errCheck(err, "Failed to obtain wallet key")
-		outputIf(debug, fmt.Sprintf("Seed is %#x", seed))
-		seedStr, err := bip39.NewMnemonic(seed)
-		errCheck(err, "Failed to generate seed mnemonic")
-		// Re-read mnemonimc to ensure correctness.
-		recalcSeed, err := bip39.MnemonicToByteArray(seedStr)
-		// Drop checksum (last byte).
-		errCheck(err, "Failed to recalculate seed")
-		recalcSeed = recalcSeed[:len(recalcSeed)-1]
-		outputIf(debug, fmt.Sprintf("Recalc seed is %#x", recalcSeed))
-		errCheck(err, "Failed to recalculate seed mnemonic")
-		assert(bytes.Equal(recalcSeed, seed), "Generated invalid mnemonic")
-
-		outputIf(!quiet, seedStr)
-		os.Exit(_exitSuccess)
-	},
-}
-
-func init() {
-	walletCmd.AddCommand(walletSeedCmd)
-	walletFlags(walletSeedCmd)
-}

docs/howto.md

@@ -65,3 +65,21 @@ ethdo wallet info --verbose --wallet="My wallet"
 ```
 
 This will provide, amongst other information, a `Location` line giving the directory where the wallet information resides.
+
+## Recreate launchpad wallet and accounts
+
+Recreating launchpad accounts requires two steps: recreating the wallet, and recreating the individual accounts.  All that is required is the mnemonic from the launchpad process.
+
+To recreate the wallet with the given mnemonic run the following command (changing the wallet name, passphrase and mnemonic as required):
+
+```sh
+ethdo wallet create --wallet="Launchpad" --type=hd --walletpassphrase=walletsecret --mnemonic="faculty key lamp panel appear choose express off absent dance strike twenty elephant expect swift that resist bicycle kind sun favorite evoke engage thumb"
+```
+
+Launchpad accounts are identified by their path.  The path can be seen in the filename of the keystore, for example the filename `keystore-m_12381_3600_1_0_0-1596891358.json` relates to a path of `m/12381/3600/1/0/0`.  It is also present directly in the keystore under the `path` key.
+
+To create an account corresponding to this key with the account name "Account 1" you would use the command:
+
+```sh
+ethdo account create --account="Launchpad/Account 1" --walletpassphrase=walletsecret --passphrase=secret --path=m/12381/3600/1/0/0
+```

docs/prysm.md

@@ -2,19 +2,7 @@
 
 ## Installing ethdo
 
-1. To install `ethdo`, issue the following command:
-
-```sh
-GO111MODULE=on go get github.com/wealdtech/ethdo@latest
-```
-
-2. Ensure `ethdo` is installed properly by issuing the command:
-
-```sh
-ethdo version
-```
-
-Ensure the output matches the most recent version listed on the repository's [release history](https://github.com/wealdtech/ethdo/releases/).
+1. To install `ethdo`, use the instructions on the [main page](https://github.com/wealdtech/ethdo).
 
 ## Typical validating setups
 

docs/troubleshooting.md

@@ -1,11 +1,11 @@
 # Troubleshooting
 
-## Compilation problems
+## Compilation problems on Linux
 
 ### gcc not found
 ### cannot find -lstdc++
 
-This is usually an error on linux systems.  If you receive errors of this type your computer is missing some files to allow `ethdo` to build.  To resolve this run the following command:
+If you receive errors of this type your computer is missing some files to allow `ethdo` to build.  To resolve this, run the following command:
 
 ```sh
 sudo apt install build-essential libstdc++6
@@ -13,3 +13,27 @@ sudo apt install build-essential libstdc++6
 
 and then try to install `ethdo` again.
 
+## Compilation problems on Windows
+
+### gcc not found
+
+If you receive errors of this type your computer is missing some files to allow `ethdo` to build.  To resolve this install gcc by following the instructions at http://mingw-w64.org/doku.php
+
+## ethdo not found after installing
+
+This is usually due to an incorrectly set path.  Go installs its binaries (such as `ethdo`) in a particular location.  The defaults are:
+
+  - Linux, Mac: `$HOME/go/bin`
+  - Windows: `%USERPROFILE%\go\bin`
+
+You must add these paths to be able to access `ethdo`.  To add the path on linux or OSX type:
+
+```sh
+export PATH=$PATH:$(go env GOPATH)/bin
+```
+
+and on Windows type:
+
+```sh
+setx /M path "%PATH%;%USERPROFILE%\go\bin"
+```

docs/usage.md

@@ -31,7 +31,7 @@ Spending: 0x85dfc6dcee4c9da36f6473ec02fda283d6c920c641fc8e3a76113c5c227d4aeeb100
   - `wallet`: the name of the wallet to create
   - `type`: the type of wallet to create.  This can be either "nd" for a non-deterministic wallet, where private keys are generated randomly, or "hd" for a hierarchical deterministic wallet, where private keys are generated from a seed and path as per [ERC-2333](https://github.com/CarlBeek/EIPs/blob/bls_path/EIPS/eip-2334.md) (defaults to "nd")
   - `walletpassphrase`: the passphrase for of the wallet.  This is required for hierarchical deterministic wallets, to protect the seed
-  - `seed`: for hierarchical deterministic wallets only, use a pre-defined 24-word [BIP-39 seed phrase](https://en.bitcoin.it/wiki/Seed_phrase) to create the wallet.  **Warning** The same seed can be imported in to multiple wallets, in which case they will generate the same keys.  Please ensure that only a single wallet is active with any single seed phrase
+  - `mnemonic`: for hierarchical deterministic wallets only, use a pre-defined 24-word [BIP-39 seed phrase](https://en.bitcoin.it/wiki/Seed_phrase) to create the wallet, along with an additional "seed extension" phrase if required.  **Warning** The same mnemonic can be used to create multiple wallets, in which case they will generate the same keys.
 
 ```sh
 $ ethdo wallet create --wallet="Personal wallet" --type="hd" --walletpassphrase="my wallet secret"
@@ -103,17 +103,6 @@ Personal wallet
 
 **N.B.** encrypted wallets will not show up in this list unless the correct passphrase for the store is supplied.
 
-#### `seed`
-
-`ethdo wallet seed` provides the seed for hierarchical deterministic wallets.  Options include:
-  - `wallet`: the name of the wallet
-  - `walletpassphrase`: the passphrase for the wallet
-
-```sh
-$ ethdo wallet seed --wallet="Personal wallet" --walletpassphrase="my wallet secret"
-decorate false mail domain gain later motion chair tank muffin smoke involve witness bean shell urge team solve share truly shadow decorate jeans hen
-```
-
 ### `account` commands
 
 Account commands focus on information about local accounts, generally those used by Geth and Parity but also those from hardware devices.
@@ -123,9 +112,12 @@ Account commands focus on information about local accounts, generally those used
 `ethdo account create` creates a new account with the given parameters.  Options for creating an account include:
   - `account`: the name of the account to create
   - `passphrase`: the passphrase for the account
+  - `path`: the HD path for the account (only for hierarchical deterministic accounts)
 
 Note that for hierarchical deterministic wallets you will also need to supply `--walletpassphrase` to unlock the wallet seed.
 
+For distributed accounts you will also need to supply `--participants` and `--signing-threshold`.
+
 ```sh
 $ ethdo account create --account="Personal wallet/Operations" --walletpassphrase="my wallet secret" --passphrase="my account secret"
 ```
@@ -211,11 +203,10 @@ $ ethdo signature sign --data="0x08140077a94642919041503caf5cc1c89c7744a2a08d43c
 
 ```sh
 $ ethdo signature verify --data="0x08140077a94642919041503caf5cc1c89c7744a2a08d43cec91df1795b23ecf2" --signature="0x87c83b31081744667406a11170c5585a11195621d0d3f796bd9006ac4cb5f61c10bf8c5b3014cd4f792b143a644cae100cb3155e8b00a961287bd9e7a5e18cb3b80930708bc9074d11ff47f1e8b9dd0b633e71bcea725fc3e550fdc259c3d130" --account="Personal wallet/Operations"
-Verified
 $ ethdo signature verify --data="0x08140077a94642919041503caf5cc1c89c7744a2a08d43cec91df1795b23ecf2" --signature="0x87c83b31081744667406a11170c5585a11195621d0d3f796bd9006ac4cb5f61c10bf8c5b3014cd4f792b143a644cae100cb3155e8b00a961287bd9e7a5e18cb3b80930708bc9074d11ff47f1e8b9dd0b633e71bcea725fc3e550fdc259c3d130" --account="Personal wallet/Auctions"
 Not verified
 $ ethdo signature verify --data="0x08140077a94642919041503caf5cc1c89c7744a2a08d43cec91df1795b23ecf2" --signature="0x89abe2e544ef3eafe397db036103b1d066ba86497f36ed4ab0264162eadc89c7744a2a08d43cec91df128660e70ecbbe11031b4c2e53682d2b91e67b886429bf8fac9bad8c7b63c5f231cc8d66b1377e06e27138b1ddc64b27c6e593e07ebb4b" --signer="0x8e2f9e8cc29658ff37ecc30e95a0807579b224586c185d128cb7a7490784c1ad9b0ab93dbe604ab075b40079931e6670"
-$ ethdo signature verify --data="0x08140077a94642919041503caf5cc1c89c7744a2a08d43cec91df1795b23ecf2" --signature="0x87c83b31081744667406a11170c5585a11195621d0d3f796bd9006ac4cb5f61c10bf8c5b3014cd4f792b143a644cae100cb3155e8b00a961287bd9e7a5e18cb3b80930708bc9074d11ff47f1e8b9dd0b633e71bcea725fc3e550fdc259c3d130" --signer="0xad1868210a0cff7aff22633c003c503d4c199c8dcca13bba5b3232fc784d39d3855936e94ce184c3ce27bf15d4347695"
+$ ethdo signature verify --data="0x08140077a94642919041503caf5cc1c89c7744a2a08d43cec91df1795b23ecf2" --signature="0x87c83b31081744667406a11170c5585a11195621d0d3f796bd9006ac4cb5f61c10bf8c5b3014cd4f792b143a644cae100cb3155e8b00a961287bd9e7a5e18cb3b80930708bc9074d11ff47f1e8b9dd0b633e71bcea725fc3e550fdc259c3d130" --signer="0xad1868210a0cff7aff22633c003c503d4c199c8dcca13bba5b3232fc784d39d3855936e94ce184c3ce27bf15d4347695" --verbose
 Verified
 ```
 
@@ -319,6 +310,37 @@ Prior justified epoch: 3
 Prior justified epoch distance: 4
 ```
 
+### `deposit` comands
+
+Deposit commands focus on information about deposit data information in a JSON file generated by the `ethdo validator depositdata` command.
+
+#### `verify`
+
+`ethdo deposit verify` verifies one or more deposit data information in a JSON file generated by the `ethdo validator depositdata` command.  Options include:
+  - `data`: either a path to the JSON file, the JSON itself, or a hex string representing a deposit transaction
+  - `withdrawalpubkey`: the public key of the withdrawal for the deposit.  If no value is supplied then withdrawal credentials for deposits will not be checked
+  - `validatorpubkey`: the public key of the validator for the deposit.  If no value is supplied then validator public keys will not be checked
+  - `depositvalue`: the value of the Ether being deposited.  If no value is supplied then deposit values will not be checked.
+
+```sh
+$ ethdo deposit verify --data=${HOME}/depositdata.json --withdrawalpubkey=0xad1868210a0cff7aff22633c003c503d4c199c8dcca13bba5b3232fc784d39d3855936e94ce184c3ce27bf15d4347695 --validatorpubkey=0xa951530887ae2494a8cc4f11cf186963b0051ac4f7942375585b9cf98324db1e532a67e521d0fcaab510edad1352394c --depositvalue=32Ether
+```
+
+### `exit` comands
+
+Exit commands focus on information about validator exits generated by the `ethdo validator exit` command.
+
+#### `verify`
+
+`ethdo exit verify` verifies the validator exit information in a JSON file generated by the `ethdo validator exit` command.  Options include:
+  - `data`: either a path to the JSON file or the JSON itself
+  - `account`: the account that generated the exit transaction (if available as an account)
+  - `pubkey`: the public key of the account that generated the exit transaction
+
+```sh
+$ ethdo exit verify --data=${HOME}/exit.json --pubkey=0xa951530887ae2494a8cc4f11cf186963b0051ac4f7942375585b9cf98324db1e532a67e521d0fcaab510edad1352394c
+```
+
 ### `node` commands
 
 Node commands focus on information from an Ethereum 2 node.
@@ -344,6 +366,7 @@ Current slot: 178
 Current epoch: 5
 Genesis timestamp: 1587020563
 ```
+
 ### `validator` commands
 
 Validator commands focus on interaction with Ethereum 2 validators.
@@ -409,6 +432,22 @@ Balance:           3.201850307 Ether
 Effective balance: 3.1 Ether
 ```
 
+### `attester` commands
+
+Attester commands focus on Ethereum 2 validators' actions as attesters.
+
+#### `inclusion`
+
+`ethdo attester inclusion` finds the block with wihch an attestation is included on the chain.  Options include:
+  - `epoch` the epoch in which to obtain the inclusion information (defaults to current epoch)
+  - `account` the account for which to fetch the inclusion information
+  - `pubkey` the public key for which to fetch the inclusion information
+
+```sh
+$ ethdo attester inclusion --account=Validators/1 --epoch=6484
+Attestation included in block 207492 (inclusion delay 1)
+```
+
 ## Maintainers
 
 Jim McDonald: [@mcdee](https://github.com/mcdee).

go.mod

@@ -4,41 +4,48 @@ go 1.13
 
 require (
 	github.com/OneOfOne/xxhash v1.2.5 // indirect
-	github.com/ferranbt/fastssz v0.0.0-20200514094935-99fccaf93472 // indirect
+	github.com/aws/aws-sdk-go v1.34.9 // indirect
+	github.com/ferranbt/fastssz v0.0.0-20200818222714-826c7ef45b30 // indirect
 	github.com/fsnotify/fsnotify v1.4.9 // indirect
 	github.com/gogo/protobuf v1.3.1
 	github.com/google/uuid v1.1.1
-	github.com/grpc-ecosystem/grpc-gateway v1.14.6 // indirect
+	github.com/grpc-ecosystem/grpc-gateway v1.14.7 // indirect
+	github.com/herumi/bls-eth-go-binary v0.0.0-20200722032157-41fc56eba7b4
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/mitchellh/mapstructure v1.3.1 // indirect
+	github.com/mitchellh/mapstructure v1.3.3 // indirect
 	github.com/pelletier/go-toml v1.8.0 // indirect
 	github.com/pkg/errors v0.9.1
-	github.com/prysmaticlabs/ethereumapis v0.0.0-20200528232825-cf963636d24e
-	github.com/prysmaticlabs/go-bitfield v0.0.0-20200322041314-62c2aee71669
-	github.com/prysmaticlabs/go-ssz v0.0.0-20200101200214-e24db4d9e963
+	github.com/prysmaticlabs/ethereumapis v0.0.0-20200812153649-a842fc47c2c3
+	github.com/prysmaticlabs/go-bitfield v0.0.0-20200618145306-2ae0807bef65
+	github.com/prysmaticlabs/go-ssz v0.0.0-20200612203617-6d5c9aa213ae
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/spf13/afero v1.2.2 // indirect
+	github.com/spf13/afero v1.3.4 // indirect
 	github.com/spf13/cast v1.3.1 // indirect
 	github.com/spf13/cobra v1.0.0
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
-	github.com/spf13/viper v1.7.0
+	github.com/spf13/pflag v1.0.5
+	github.com/spf13/viper v1.7.1
 	github.com/tyler-smith/go-bip39 v1.0.2
-	github.com/wealdtech/eth2-signer-api v1.3.0
+	github.com/wealdtech/eth2-signer-api v1.5.2
 	github.com/wealdtech/go-bytesutil v1.1.1
 	github.com/wealdtech/go-ecodec v1.1.0
-	github.com/wealdtech/go-eth2-types/v2 v2.4.0
-	github.com/wealdtech/go-eth2-util v1.2.0
-	github.com/wealdtech/go-eth2-wallet v1.10.0
-	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.0.0
-	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.1.0
-	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.1.0
-	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.15.0
-	github.com/wealdtech/go-eth2-wallet-store-s3 v1.7.0
-	github.com/wealdtech/go-eth2-wallet-types/v2 v2.1.0
+	github.com/wealdtech/go-eth2-types/v2 v2.5.0
+	github.com/wealdtech/go-eth2-util v1.6.0
+	github.com/wealdtech/go-eth2-wallet v1.14.0
+	github.com/wealdtech/go-eth2-wallet-dirk v1.0.3
+	github.com/wealdtech/go-eth2-wallet-distributed v1.1.0
+	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.0
+	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.0
+	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.0
+	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.1
+	github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.0
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.7.0
 	github.com/wealdtech/go-string2eth v1.1.0
-	golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37 // indirect
-	golang.org/x/net v0.0.0-20200528225125-3c3fba18258b // indirect
-	google.golang.org/grpc v1.29.1
-	gopkg.in/ini.v1 v1.57.0 // indirect
+	golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a // indirect
+	golang.org/x/net v0.0.0-20200822124328-c89045814202 // indirect
+	golang.org/x/sys v0.0.0-20200821140526-fda516888d29 // indirect
+	golang.org/x/text v0.3.3
+	google.golang.org/genproto v0.0.0-20200815001618-f69a88009b70 // indirect
+	google.golang.org/grpc v1.31.0
+	gopkg.in/ini.v1 v1.60.1 // indirect
 )

go.sum

@@ -14,7 +14,6 @@ dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7
 github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
-github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
 github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
 github.com/OneOfOne/xxhash v1.2.5 h1:zl/OfRA6nftbBK9qTohYBJ5xvw6C/oNKizR7cZGl3cI=
 github.com/OneOfOne/xxhash v1.2.5/go.mod h1:eZbhyaAYD41SGSSsnmcpxVoRiQ/MPUTjUdIIOT9Um7Q=
@@ -26,12 +25,16 @@ github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hC
 github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
-github.com/aws/aws-sdk-go v1.30.15 h1:Sd8QDVzzE8Sl+xNccmdj0HwMrFowv6uVUx9tGsCE1ZE=
-github.com/aws/aws-sdk-go v1.30.15/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
-github.com/aws/aws-sdk-go v1.30.25 h1:89NXJkfpjnMEnsxkP8MVX+LDsoiLCSqevraLb5y4Mjk=
-github.com/aws/aws-sdk-go v1.30.25/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
-github.com/aws/aws-sdk-go v1.31.7 h1:TCA+pXKvzDMA3vVqhK21cCy5GarC8pTQb/DrVOWI3iY=
-github.com/aws/aws-sdk-go v1.31.7/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go v1.32.6 h1:HoswAabUWgnrUF7X/9dr4WRgrr8DyscxXvTDm7Qw/5c=
+github.com/aws/aws-sdk-go v1.32.6/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go v1.33.5 h1:p2fr1ryvNTU6avUWLI+/H7FGv0TBIjzVM5WDgXBBv4U=
+github.com/aws/aws-sdk-go v1.33.5/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go v1.33.11 h1:A7b3mNKbh/0zrhnNN/KxWD0YZJw2RImnjFXWOquYKB4=
+github.com/aws/aws-sdk-go v1.33.11/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go v1.34.5 h1:FwubVVX9u+kW9qDCjVzyWOdsL+W5wPq683wMk2R2GXk=
+github.com/aws/aws-sdk-go v1.34.5/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
+github.com/aws/aws-sdk-go v1.34.9 h1:cUGBW9CVdi0mS7K1hDzxIqTpfeWhpoQiguq81M1tjK0=
+github.com/aws/aws-sdk-go v1.34.9/go.mod h1:5zCpMtNQVjRREroY7sYe8lOMRSxkhG6MZveU8YkpAk0=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
 github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs=
@@ -55,6 +58,8 @@ github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 github.com/dgraph-io/ristretto v0.0.1/go.mod h1:T40EBc7CJke8TkpiYfGGKAeFjSaxuFXhuXRyumBd6RE=
 github.com/dgraph-io/ristretto v0.0.2 h1:a5WaUrDa0qm0YrAAS1tUykT5El3kt62KNZZeMxQn3po=
 github.com/dgraph-io/ristretto v0.0.2/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
+github.com/dgraph-io/ristretto v0.0.3 h1:jh22xisGBjrEVnRZ1DVTpBVQm0Xndu8sMl0CWDzSIBI=
+github.com/dgraph-io/ristretto v0.0.3/go.mod h1:KPxhHT9ZxKefz+PCeOGsrHpl1qZ7i70dGTu2u+Ahh6E=
 github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
 github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
@@ -64,11 +69,13 @@ github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.m
 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
-github.com/ferranbt/fastssz v0.0.0-20200415074633-b062b680417b h1:CxaMtGnKgr9Ar2xLMVddPhnMwYLDsY56w/LxQ/wnsKA=
-github.com/ferranbt/fastssz v0.0.0-20200415074633-b062b680417b/go.mod h1:LlFXPmgrgVYsuoFDwV8rDJ9tvt1pLQdjKvU1b5IRES0=
 github.com/ferranbt/fastssz v0.0.0-20200514094935-99fccaf93472 h1:maoKvILdMk6CSWHanFcUdxXIZGKD9YpWIaVbUQ/4kfg=
 github.com/ferranbt/fastssz v0.0.0-20200514094935-99fccaf93472/go.mod h1:LlFXPmgrgVYsuoFDwV8rDJ9tvt1pLQdjKvU1b5IRES0=
-github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/ferranbt/fastssz v0.0.0-20200728110133-0b6e349af87a/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM=
+github.com/ferranbt/fastssz v0.0.0-20200803113354-a18be873a4b6 h1:P440pnxSHIQI8gg7lQNNo+/F88EzUzS3Os0Xkhta7OQ=
+github.com/ferranbt/fastssz v0.0.0-20200803113354-a18be873a4b6/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM=
+github.com/ferranbt/fastssz v0.0.0-20200818222714-826c7ef45b30 h1:Sbm5yhPObRc+RCZa9fAR/Px/j1qYwuqawF0X8dR2gAw=
+github.com/ferranbt/fastssz v0.0.0-20200818222714-826c7ef45b30/go.mod h1:DyEu2iuLBnb/T51BlsiO3yLYdJC6UbGMrIkqK1KmQxM=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
 github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
@@ -78,47 +85,37 @@ github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
-github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
-github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE=
 github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
 github.com/gogo/protobuf v1.3.1 h1:DqDEcV5aeaTmdFBePNpYsp3FlcVH/2ISVVM9Qf8PSls=
 github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
-github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
 github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
-github.com/golang/protobuf v1.3.3 h1:gyjaxf+svBWX08ZjK86iN9geUJF0H6gp2IRKX6Nf6/I=
 github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
 github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
 github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
 github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
-github.com/golang/protobuf v1.4.0-rc.4 h1:+EOh4OY6tjM6ZueeUKinl1f0U2820HzQOuf1iqMnsks=
-github.com/golang/protobuf v1.4.0-rc.4/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
 github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
-github.com/golang/protobuf v1.4.0 h1:oOuy+ugB+P/kBdUnG5QaMXSIyJ1q38wWSojYCb3z5VQ=
 github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
-github.com/golang/protobuf v1.4.1 h1:ZFgWrT+bLgsYPirOnRfKLYJLvssAegOj/hgyMFdJZe0=
 github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
 github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
 github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
 github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
 github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
-github.com/google/go-cmp v0.2.0 h1:+dTQ8DZQJz0Mb/HjFlkptS1FeQ4cWSnN941F8aEG4SQ=
 github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
-github.com/google/go-cmp v0.3.1 h1:Xye71clBPdm5HgqGwUkwhbynsUJZhDbS20FvLhQ2izg=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0 h1:xsAVV57WRhGj6kEIi8ReJzQlHHqcBYCElAvkovg3B/4=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/gofuzz v1.1.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
 github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
@@ -134,14 +131,12 @@ github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoA
 github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
-github.com/grpc-ecosystem/grpc-gateway v1.9.0 h1:bM6ZAFZmc/wPFaRDi0d5L7hGEZEx/2u+Tmr2evNHDiI=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/grpc-ecosystem/grpc-gateway v1.12.2/go.mod h1:8XEsbTttt/W+VvjtQhLACqCisSPWTxCZ7sBRjU6iH9c=
 github.com/grpc-ecosystem/grpc-gateway v1.13.0/go.mod h1:8XEsbTttt/W+VvjtQhLACqCisSPWTxCZ7sBRjU6iH9c=
-github.com/grpc-ecosystem/grpc-gateway v1.14.5 h1:aiLxiiVzAXb7wb3lAmubA69IokWOoUNe+E7TdGKh8yw=
-github.com/grpc-ecosystem/grpc-gateway v1.14.5/go.mod h1:UJ0EZAp832vCd54Wev9N1BMKEyvcZ5+IM0AwDrnlkEc=
 github.com/grpc-ecosystem/grpc-gateway v1.14.6 h1:8ERzHx8aj1Sc47mu9n/AksaKCSWrMchFtkdrS4BIj5o=
 github.com/grpc-ecosystem/grpc-gateway v1.14.6/go.mod h1:zdiPV4Yse/1gnckTHtghG4GkDEdKCRJduHpTxT3/jcw=
+github.com/grpc-ecosystem/grpc-gateway v1.14.7 h1:Nk5kuHrnWUTf/0GL1a/vchH/om9Ap2/HnVna+jYZgTY=
+github.com/grpc-ecosystem/grpc-gateway v1.14.7/go.mod h1:oYZKL012gGh6LMyg/xA7Q2yq6j8bu0wa+9w14EEthWU=
 github.com/hashicorp/consul/api v1.1.0/go.mod h1:VmuI/Lkw1nC05EYQWNKwWGbkg+FbDBtguAZLlVdkD9Q=
 github.com/hashicorp/consul/sdk v0.1.1/go.mod h1:VKf9jXwCTEY1QZP2MOLRhb5i/I/ssyNV1vwHyQBF0x8=
 github.com/hashicorp/errwrap v1.0.0/go.mod h1:YH+1FKiLXxHSkmPseP+kNlulaMuP3n2brvKWEqk/Jc4=
@@ -163,14 +158,24 @@ github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO
 github.com/hashicorp/mdns v1.0.0/go.mod h1:tL+uN++7HEJ6SQLQ2/p+z2pH24WQKWjBPkE0mNTz8vQ=
 github.com/hashicorp/memberlist v0.1.3/go.mod h1:ajVTdAv/9Im8oMAAj5G31PhhMCZJV2pPBoIllUwCN7I=
 github.com/hashicorp/serf v0.8.2/go.mod h1:6hOLApaqBFA1NXqRQAsxw9QxuDEvNxSQRwA/JwenrHc=
-github.com/herumi/bls-eth-go-binary v0.0.0-20200428020417-6dd0e5634b87 h1:23l9wMlu3iMRg5PwI4wuA7sbR77GSF+rnwI0Z/Y4IPc=
-github.com/herumi/bls-eth-go-binary v0.0.0-20200428020417-6dd0e5634b87/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
-github.com/herumi/bls-eth-go-binary v0.0.0-20200508110836-07e8f416e478 h1:UMIHMlIgtPmh96SmXdDiEDRbQ2NSroxBQzpEknueoG4=
-github.com/herumi/bls-eth-go-binary v0.0.0-20200508110836-07e8f416e478/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
-github.com/herumi/bls-eth-go-binary v0.0.0-20200522010937-01d282b5380b h1:mu+F5uA3Y68oB6KXZqWlASKMetbNufhQx2stMI+sD+Y=
-github.com/herumi/bls-eth-go-binary v0.0.0-20200522010937-01d282b5380b/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200621110855-298ffb6847bc h1:1ANh6XSZu8Quo4d03TDFhqiFjgUicMdavTtPm6B+RfE=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200621110855-298ffb6847bc/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200624084043-9b7da5962ccb h1:rVlcEzuK/AJKzJp890JoSpJdU3hgak53oMB9mypa05s=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200624084043-9b7da5962ccb/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200703070911-61704dac4ad1 h1:da7FT3Bhp8GCx6TwDPQio/7GLRLR5hcZvoRb89hfc08=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200703070911-61704dac4ad1/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200706085701-832d8c2c0f7d h1:P8yaFmLwc5ZlUx2sHuawcdQvpv5/0GM+WEGJ07ljN3g=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200706085701-832d8c2c0f7d/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200719025738-3e30d132e8f6 h1:xOOHoKwCj0WXm60FqRxQ0u8cLr+kq5DJUlPspEPsu/s=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200719025738-3e30d132e8f6/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200721081051-e31ced8c0204 h1:owpf19DI+vvpSOetnfE1NsLykSxZt8dSag7SDsJd8F0=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200721081051-e31ced8c0204/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200722032157-41fc56eba7b4 h1:TfBVK1MJ9vhrMXWVHu5p/MlVHZTeCGgDAEu5RykVZeI=
+github.com/herumi/bls-eth-go-binary v0.0.0-20200722032157-41fc56eba7b4/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
+github.com/jackc/puddle v1.1.1 h1:PJAw7H/9hoWC4Kf3J8iNmL1SwA6E8vfsLqBiL+F6CtI=
+github.com/jackc/puddle v1.1.1/go.mod h1:m4B5Dj62Y0fbyuIc15OsIqK0+JU8nkqQjsgx7dvjSWk=
 github.com/jmespath/go-jmespath v0.3.0 h1:OS12ieG61fsCg5+qLJ+SsW9NicxNkg3b25OyT2yCeUc=
 github.com/jmespath/go-jmespath v0.3.0/go.mod h1:9QtRXoHjLGCJ5IBSaohpXITPlowMeeYCZ7fLUTSywik=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
@@ -183,6 +188,7 @@ github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvW
 github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -208,27 +214,26 @@ github.com/mitchellh/go-testing-interface v1.0.0/go.mod h1:kRemZodwjscx+RGhAo8eI
 github.com/mitchellh/gox v0.4.0/go.mod h1:Sd9lOJ0+aimLBi73mGofS1ycjY8lL3uZM3JPS42BGNg=
 github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
 github.com/mitchellh/mapstructure v0.0.0-20160808181253-ca63d7c062ee/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
-github.com/mitchellh/mapstructure v1.3.0 h1:iDwIio/3gk2QtLLEsqU5lInaMzos0hDTz8a6lazSFVw=
-github.com/mitchellh/mapstructure v1.3.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/mitchellh/mapstructure v1.3.1 h1:cCBH2gTD2K0OtLlv/Y5H01VQCqmlDxz30kS5Y5bqfLA=
-github.com/mitchellh/mapstructure v1.3.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mitchellh/mapstructure v1.3.2 h1:mRS76wmkOn3KkKAyXDu42V+6ebnXWIztFSYGN7GeoRg=
+github.com/mitchellh/mapstructure v1.3.2/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/mitchellh/mapstructure v1.3.3 h1:SzB1nHZ2Xi+17FP0zVQBHIZqvwRN9408fJO8h+eeNA8=
+github.com/mitchellh/mapstructure v1.3.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
-github.com/pelletier/go-toml v1.7.0 h1:7utD74fnzVc/cpcyy8sjrlFr5vYpypUixARcHIMIGuI=
-github.com/pelletier/go-toml v1.7.0/go.mod h1:vwGMzjaWMwyfHwgIBhI2YUM4fB6nL6lVAvS1LBMMhTE=
 github.com/pelletier/go-toml v1.8.0 h1:Keo9qb7iRJs2voHvunFtuuYFsbWeOBh8/P9v/kVMFtw=
 github.com/pelletier/go-toml v1.8.0/go.mod h1:D6yutnOGMveHEPV7VQOuvI/gXY61bv+9bAOTRnLElKs=
+github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 h1:q2e307iGHPdTGp0hoxKjt1H5pDo6utceo3dQVK3I5XQ=
+github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
@@ -243,22 +248,28 @@ github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R
 github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
 github.com/protolambda/zssz v0.1.3/go.mod h1:a4iwOX5FE7/JkKA+J/PH0Mjo9oXftN6P8NZyL28gpag=
-github.com/protolambda/zssz v0.1.4 h1:4jkt8sqwhOVR8B1JebREU/gVX0Ply4GypsV8+RWrDuw=
-github.com/protolambda/zssz v0.1.4/go.mod h1:a4iwOX5FE7/JkKA+J/PH0Mjo9oXftN6P8NZyL28gpag=
-github.com/prysmaticlabs/ethereumapis v0.0.0-20200511212457-3444ffb75440 h1:plalLbsEdAKKURjR7u+JUsgD2tyxSa/yitdMyqaWY4E=
-github.com/prysmaticlabs/ethereumapis v0.0.0-20200511212457-3444ffb75440/go.mod h1:5OkRN6UmvgtP+kIewitcEKC7S5KOzLOGtya/Tz+HBns=
-github.com/prysmaticlabs/ethereumapis v0.0.0-20200528232825-cf963636d24e h1:AvUpoH1sezZmue9NKyHxk7HpD6ajzLVh9m6YCyFwgSw=
-github.com/prysmaticlabs/ethereumapis v0.0.0-20200528232825-cf963636d24e/go.mod h1:UQrDJAnxOPXPxvzECD1fmiKAw84LIYcoX2Op7KEUfGk=
+github.com/protolambda/zssz v0.1.5 h1:7fjJjissZIIaa2QcvmhS/pZISMX21zVITt49sW1ouek=
+github.com/protolambda/zssz v0.1.5/go.mod h1:a4iwOX5FE7/JkKA+J/PH0Mjo9oXftN6P8NZyL28gpag=
+github.com/prysmaticlabs/ethereumapis v0.0.0-20200619200018-174e3b90d786 h1:bJiOTV2sYykacsxViyRltztQY0DyjT/uFoVRZkEaxsY=
+github.com/prysmaticlabs/ethereumapis v0.0.0-20200619200018-174e3b90d786/go.mod h1:rs05kpTfWKl0KflsBWzBQFstoyPFMTWQTbxSAyGHe78=
+github.com/prysmaticlabs/ethereumapis v0.0.0-20200709024211-e8095222f77b h1:GjYix8Y4VpQhlsjA2ickr3HxjIns4bI36zOmC+lwaNw=
+github.com/prysmaticlabs/ethereumapis v0.0.0-20200709024211-e8095222f77b/go.mod h1:rs05kpTfWKl0KflsBWzBQFstoyPFMTWQTbxSAyGHe78=
+github.com/prysmaticlabs/ethereumapis v0.0.0-20200812153649-a842fc47c2c3 h1:0f++UXRfp4/Mrmlfj3UaCnYj2lPr6El0gWWTBb9MD2Y=
+github.com/prysmaticlabs/ethereumapis v0.0.0-20200812153649-a842fc47c2c3/go.mod h1:k7b2dxy6RppCG6kmOJkNOXzRpEoTdsPygc2aQhsUsZk=
 github.com/prysmaticlabs/go-bitfield v0.0.0-20191017011753-53b773adde52/go.mod h1:hCwmef+4qXWjv0jLDbQdWnL0Ol7cS7/lCSS26WR+u6s=
-github.com/prysmaticlabs/go-bitfield v0.0.0-20200322041314-62c2aee71669 h1:cX6YRZnZ9sgMqM5U14llxUiXVNJ3u07Res1IIjTOgtI=
 github.com/prysmaticlabs/go-bitfield v0.0.0-20200322041314-62c2aee71669/go.mod h1:hCwmef+4qXWjv0jLDbQdWnL0Ol7cS7/lCSS26WR+u6s=
-github.com/prysmaticlabs/go-ssz v0.0.0-20200101200214-e24db4d9e963 h1:Th5ufPIaL5s/7i3gXHTgiTwfsUhWDP/PwFRiI6qV6v0=
+github.com/prysmaticlabs/go-bitfield v0.0.0-20200618145306-2ae0807bef65 h1:hJfAWrlxx7SKpn4S/h2JGl2HHwA1a2wSS3HAzzZ0F+U=
+github.com/prysmaticlabs/go-bitfield v0.0.0-20200618145306-2ae0807bef65/go.mod h1:hCwmef+4qXWjv0jLDbQdWnL0Ol7cS7/lCSS26WR+u6s=
 github.com/prysmaticlabs/go-ssz v0.0.0-20200101200214-e24db4d9e963/go.mod h1:VecIJZrewdAuhVckySLFt2wAAHRME934bSDurP8ftkc=
+github.com/prysmaticlabs/go-ssz v0.0.0-20200612203617-6d5c9aa213ae h1:7qd0Af1ozWKBU3c93YW2RH+/09hJns9+ftqWUZyts9c=
+github.com/prysmaticlabs/go-ssz v0.0.0-20200612203617-6d5c9aa213ae/go.mod h1:VecIJZrewdAuhVckySLFt2wAAHRME934bSDurP8ftkc=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
 github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
+github.com/sasha-s/go-deadlock v0.2.0 h1:lMqc+fUb7RrFS3gQLtoQsJ7/6TV/pAIFvBsqX73DK8Y=
+github.com/sasha-s/go-deadlock v0.2.0/go.mod h1:StQn567HiB1fF2yJ44N9au7wOhrPS3iZqiDbRupzT10=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
@@ -269,14 +280,16 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1
 github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
-github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
 github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
-github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc=
-github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
-github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
+github.com/spf13/afero v1.3.0 h1:Ysnmjh1Di8EaWaBv40CYR4IdaIsBc5996Gh1oZzCBKk=
+github.com/spf13/afero v1.3.0/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4=
+github.com/spf13/afero v1.3.2 h1:GDarE4TJQI52kYSbSAmLiId1Elfj+xgSDqrUZxFhxlU=
+github.com/spf13/afero v1.3.2/go.mod h1:5KUK8ByomD5Ti5Artl0RtHeI5pTF7MIDuXL3yY520V4=
+github.com/spf13/afero v1.3.4 h1:8q6vk3hthlpb2SouZcnBVKboxWQWMDNF38bwholZrJc=
+github.com/spf13/afero v1.3.4/go.mod h1:Ai8FlHk4v/PARR026UzYexafAt9roJ7LcLMAmO6Z93I=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
 github.com/spf13/cast v1.3.1 h1:nFm6S0SMdyzrzcmThSipiEubIDy8WEXKNZ0UOgiRpng=
 github.com/spf13/cast v1.3.1/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
@@ -285,73 +298,123 @@ github.com/spf13/cobra v1.0.0/go.mod h1:/6GTrnGXV9HjY+aR4k0oJ5tcvakLuG6EuKReYlHN
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
 github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
-github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
 github.com/spf13/viper v1.7.0 h1:xVKxvI7ouOI5I+U9s2eeiUfMaWBVoXA3AWskkrqK0VM=
 github.com/spf13/viper v1.7.0/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
+github.com/spf13/viper v1.7.1 h1:pM5oEahlgWv/WnHXpgbKz7iLIxRf65tye2Ci+XFK5sk=
+github.com/spf13/viper v1.7.1/go.mod h1:8WkrPz2fc9jxqZNCJI/76HCieCp4Q8HaLFoCha5qpdg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
+github.com/tj/assert v0.0.3/go.mod h1:Ne6X72Q+TB1AteidzQncjw9PabbMp4PBMZ1k+vd1Pvk=
 github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
 github.com/tyler-smith/go-bip39 v1.0.2 h1:+t3w+KwLXO6154GNJY+qUtIxLTmFjfUmpguQT1OlOT8=
 github.com/tyler-smith/go-bip39 v1.0.2/go.mod h1:sJ5fKU0s6JVwZjjcUEX2zFOnvq0ASQ2K9Zr6cf67kNs=
 github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
-github.com/wealdtech/eth2-signer-api v1.3.0 h1:Fs0GfrdhboBKW7zaMvIvUHJaOB1ibpAmRG3lkB53in4=
-github.com/wealdtech/eth2-signer-api v1.3.0/go.mod h1:H8OpAoTBl6CaBvZEnhxWDjjWXNc3kwVFKWMAZd6sHlk=
-github.com/wealdtech/go-bytesutil v1.0.1 h1:6xzMM+VEHf5WNh1PsIFcRwScgcno+CP8Rw1rGvT6Cew=
+github.com/wealdtech/eth2-signer-api v1.5.0 h1:XkaEk7Y0vFbqUstHcCjVGssoqJy4zYnBcF76em1oWX8=
+github.com/wealdtech/eth2-signer-api v1.5.0/go.mod h1:5wlLQ7NO7nbXo3znJOwIWHN8S4C3xHcZ0uOg9Ue4mvg=
+github.com/wealdtech/eth2-signer-api v1.5.1 h1:RQb1xyZEcHGpVFNpTEKzLbGH/H04Ajb6y99b2sd8gVs=
+github.com/wealdtech/eth2-signer-api v1.5.1/go.mod h1:5wlLQ7NO7nbXo3znJOwIWHN8S4C3xHcZ0uOg9Ue4mvg=
+github.com/wealdtech/eth2-signer-api v1.5.2 h1:3jw8MW0r7KlX9bme0q6j+QMa8osRhEnKLkgkECH6xcU=
+github.com/wealdtech/eth2-signer-api v1.5.2/go.mod h1:5wlLQ7NO7nbXo3znJOwIWHN8S4C3xHcZ0uOg9Ue4mvg=
 github.com/wealdtech/go-bytesutil v1.0.1/go.mod h1:jENeMqeTEU8FNZyDFRVc7KqBdRKSnJ9CCh26TcuNb9s=
 github.com/wealdtech/go-bytesutil v1.1.1 h1:ocEg3Ke2GkZ4vQw5lp46rmO+pfqCCTgq35gqOy8JKVc=
 github.com/wealdtech/go-bytesutil v1.1.1/go.mod h1:jENeMqeTEU8FNZyDFRVc7KqBdRKSnJ9CCh26TcuNb9s=
 github.com/wealdtech/go-ecodec v1.1.0 h1:yggrTSckcPJRaxxOxQF7FPm21kgE8WA6+f5jdq5Kr8o=
 github.com/wealdtech/go-ecodec v1.1.0/go.mod h1:PSdBFEB6cltdT7V4E1jbboufMZTZXcQOKG/2PeEjKK4=
-github.com/wealdtech/go-eth2-types/v2 v2.3.1 h1:2KSUzducArOynCL2prRf4vWU5GjwaPSnSN9oqNgf+dQ=
-github.com/wealdtech/go-eth2-types/v2 v2.3.1/go.mod h1:FubkGSavaa+rvmHDMTUVoPdFh00wKg0k5QPW6G52mhw=
-github.com/wealdtech/go-eth2-types/v2 v2.4.0 h1:1sFuNENHka/BYHY9F6f1gQqE3dCCQxKODEHc+3RK8fI=
-github.com/wealdtech/go-eth2-types/v2 v2.4.0/go.mod h1:azyBA/qeMC5sa3BuNm3spje96rHMmW0dyZkJzog8NIk=
-github.com/wealdtech/go-eth2-util v1.1.5 h1:4OPbf2yaEQmqDmOIU6UKBfhKTPNZ7skU4lPhueBLx8o=
-github.com/wealdtech/go-eth2-util v1.1.5/go.mod h1:wYYmtc9KpQQAaAzWjXSPLgtsJMkoDAmTNN0h6uj3RCA=
-github.com/wealdtech/go-eth2-util v1.2.0 h1:ineLDTrFN8zpb7+R2lWrm1HMmTFxlirtcCsppKoVix0=
-github.com/wealdtech/go-eth2-util v1.2.0/go.mod h1:UNDR21GfVCq429DP+RyFVl2iKkHaMI8B8r7F44NECkU=
-github.com/wealdtech/go-eth2-wallet v1.9.4 h1:9XFM1Y7dsyrgNFFCnE3Gd00PAsrpob70SAQqHSPmsBU=
-github.com/wealdtech/go-eth2-wallet v1.9.4/go.mod h1:UGd1bAPDEtP+UrFjj3HCbip7jggFGDIQoeGw8/XHMvo=
-github.com/wealdtech/go-eth2-wallet v1.10.0 h1:WX6wZQvGwXtu3+L9d9HCW7WWrw6522ur2XiPI6W1lYg=
-github.com/wealdtech/go-eth2-wallet v1.10.0/go.mod h1:vqB02WIpP0SL+Ug8p4Q8BqVkwPyO1SEarOHAqppjqHE=
+github.com/wealdtech/go-eth2-types/v2 v2.4.2 h1:EkOvP8Ma0Ru7WIh0haoST97rc0PYm2AJpuWG1HzgfCI=
+github.com/wealdtech/go-eth2-types/v2 v2.4.2/go.mod h1:hhKa4ZFaNU2fwUjEh8GYr8wKg5D1W4QyxZ3xpsb/2hw=
+github.com/wealdtech/go-eth2-types/v2 v2.4.3 h1:VFYVYw9J2P/HFXi7T9HX7vzM+xx6BZ4od5PlVsUP5OE=
+github.com/wealdtech/go-eth2-types/v2 v2.4.3/go.mod h1:hhKa4ZFaNU2fwUjEh8GYr8wKg5D1W4QyxZ3xpsb/2hw=
+github.com/wealdtech/go-eth2-types/v2 v2.5.0 h1:L8sl3yoICAbn3134CBLNUt0o5h2voe0Es2KD5O9r8YQ=
+github.com/wealdtech/go-eth2-types/v2 v2.5.0/go.mod h1:321w9X26lAnNa/lQJi2A6Lap5IsNORoLwFPoJ1i8QvY=
+github.com/wealdtech/go-eth2-util v1.2.2 h1:LALunpMSJFvu89RHS1zl6RjZ52805utRvd12RtquB54=
+github.com/wealdtech/go-eth2-util v1.2.2/go.mod h1:R3VlTd69B2Jf58s62ChcyXt11ZK1/36CTplTuyR/6dE=
+github.com/wealdtech/go-eth2-util v1.3.0 h1:aX1+PnxB904GIf5JE9GRKYPuGQJsCT+Q7PG9BMeFN40=
+github.com/wealdtech/go-eth2-util v1.3.0/go.mod h1:nSHpt/mdwn1LyLiNzjGPH1DDIYdBENLFaY1fSRr+aKg=
+github.com/wealdtech/go-eth2-util v1.5.0 h1:b3fgyvoq/WocW9LkWT7zcO5VCKzKLCc97rPrk/B9oIc=
+github.com/wealdtech/go-eth2-util v1.5.0/go.mod h1:0PGWeWWc6qjky/aNjdPdguJdZ2HSEHHCA+3cTjvT+Hk=
+github.com/wealdtech/go-eth2-util v1.6.0 h1:l2OR0SqfYdEnb1I1Ggnk0w+B9/LA5aHdQ2KK2FPnGkY=
+github.com/wealdtech/go-eth2-util v1.6.0/go.mod h1:0PGWeWWc6qjky/aNjdPdguJdZ2HSEHHCA+3cTjvT+Hk=
+github.com/wealdtech/go-eth2-wallet v1.10.2 h1:oUgi6Ih5fA9thhIipzXMSaLkiwDQXwT8q3bCOLpCr7s=
+github.com/wealdtech/go-eth2-wallet v1.10.2/go.mod h1:8H9pgp5K7X1kU1cJMS/B3DrMZF74ZlwBThownrcRYgk=
+github.com/wealdtech/go-eth2-wallet v1.11.0 h1:2KfrWDqF4sWGgk4N5+DaYmh0hOnqiCl0P4vCz5mx17U=
+github.com/wealdtech/go-eth2-wallet v1.11.0/go.mod h1:E9ZRNO4JNdi27ys7oc+xWWucXu4IGfV5q1vWC9X3oqg=
+github.com/wealdtech/go-eth2-wallet v1.12.0 h1:nrwI3jPhehUhJGlBtNv/UmIo/57llvuVZZavLnfdQHI=
+github.com/wealdtech/go-eth2-wallet v1.12.0/go.mod h1:ouV+YSMbzk2dyecmofm8jhaMKdSigdIPMSnSqmWEfW8=
+github.com/wealdtech/go-eth2-wallet v1.13.0 h1:ayy/jBcKVZhqU4OMlZDieRzhwSiF3Ozmc3e3LrdpWro=
+github.com/wealdtech/go-eth2-wallet v1.13.0/go.mod h1:O4efkfrSBRRa7Q8vZQ8usUCBRki+/zE531b3JqScIII=
+github.com/wealdtech/go-eth2-wallet v1.14.0 h1:eZjopWDMlCHCE9SLydAXBr0Cqtm2HWL3O56ELfeGK9c=
+github.com/wealdtech/go-eth2-wallet v1.14.0/go.mod h1:HrJ4hLcTPZPjhdkZKZd07OFxA+r7d3i+7XKjYJbxdxk=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.0 h1:1QUcWILF3h4OLCgTPpWklvRSuPu0fqrt15jwSm7CSC4=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.0/go.mod h1:VTzjJ51dedvYPr4huI7g7KXZVTpGR6ZrCDQwBxJpLck=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.1 h1:YUE1QlJPun8b+xbz0JM71/3t1i9zp9KjcZdJvtJQL+E=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.1/go.mod h1:5jK/aEAjYAVRBKKjYAvJWSmOWxiECs4asYXHwloNI+w=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.2 h1:ZxAdF6iTOzYHtQlWd1nzVevZ+HtXS/LLn580t+NXT3A=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.2/go.mod h1:5jK/aEAjYAVRBKKjYAvJWSmOWxiECs4asYXHwloNI+w=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.3 h1:NWwxzYjFG3k7S9mzVOvj02A5S9QOak4uh+MJF2Ae37w=
+github.com/wealdtech/go-eth2-wallet-dirk v1.0.3/go.mod h1:WIy6Xx0FgTNG5bP7IytxsEt8y1Yl46HbsWVFbE4Yc94=
+github.com/wealdtech/go-eth2-wallet-distributed v1.0.1 h1:3BxMII8T6t16g6lWcYWXjfdvaw8rXuwMQx9h0TG5wRg=
+github.com/wealdtech/go-eth2-wallet-distributed v1.0.1/go.mod h1:Ha/8S+SCLEuSfXHdvhTLwnKaEF47o6gzQ+FURKwftvU=
+github.com/wealdtech/go-eth2-wallet-distributed v1.1.0 h1:OZjjuxcIYo+EhAfph7lYP1z+VeNs9ruOI32kqtYe1Jg=
+github.com/wealdtech/go-eth2-wallet-distributed v1.1.0/go.mod h1:8r06Vpg/315/7Hl9CXq0ShQP8/cgUrBGzKKo6ywA4yQ=
 github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.0.0 h1:IcpS4VpXhYz+TVupB5n6C6IQzaKwG+Rc8nvgCa/da4c=
 github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.0.0/go.mod h1:X8WRO5hEwbjx8ZOqoRmtS1ngyflKs25GkP7qGv7yOqE=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.0.3/go.mod h1:nNNZNXCP1BrJCu1hLlFUCAQBvCInD4zwE7eslf2U5XQ=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.0.4 h1:/nBbza+ZPY1dn455AnZRRpIEjeUmTRQCS5QdKf6nhrg=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.0.4/go.mod h1:nNNZNXCP1BrJCu1hLlFUCAQBvCInD4zwE7eslf2U5XQ=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.1.0 h1:gB3wFIovLgS7GVNU81mpCgekfUmGm8H/f6WtG6xqEJw=
-github.com/wealdtech/go-eth2-wallet-hd/v2 v2.1.0/go.mod h1:6voi4JG8G7inZ1bGx41xL2z+YJZc6rr6echT0AUtUdw=
-github.com/wealdtech/go-eth2-wallet-nd/v2 v2.0.3 h1:NfeWHtyjtZt3hmVA7kysNf2w+cB9Y82w6Cv4zWbFRSk=
-github.com/wealdtech/go-eth2-wallet-nd/v2 v2.0.3/go.mod h1:RDXAfay+PL+apCVLnVtWBUb183m4uug93FBZ0c2cVaw=
-github.com/wealdtech/go-eth2-wallet-nd/v2 v2.1.0 h1:d8JOfWRd39c7w3BLud3eErJH4xSa3tdrMOZjeFXXg0c=
-github.com/wealdtech/go-eth2-wallet-nd/v2 v2.1.0/go.mod h1:DTnJWJ5/O56pxqXAR53H4t8K80Rrtop5pmTSOc5tCFA=
-github.com/wealdtech/go-eth2-wallet-store-filesystem v1.7.3 h1:2nMDDRULzSSa6LCk3044d5J4rXi2HX61nRLyGLXGI3M=
-github.com/wealdtech/go-eth2-wallet-store-filesystem v1.7.3/go.mod h1:HE1JcXUhWUtJ7F/APzSI/ZTfXjdxbQ15CDe6L0mjtaQ=
-github.com/wealdtech/go-eth2-wallet-store-filesystem v1.15.0 h1:iNwHjCj9zGpybEO9URx7AmHWET1PrnkfKcpLYUyFFxw=
-github.com/wealdtech/go-eth2-wallet-store-filesystem v1.15.0/go.mod h1:qjU0CZ12duEMCTGORb4bjeUncvy5vUSTVOtwI+/A4A8=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.6.3 h1:SD5tsdj9pRdsfWbhpL09X6gDGO9rJvlI6lz2cxpdfA4=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.6.3/go.mod h1:wS8sqBuIcn9QuLR1VlV7JaSKrFiNOMSPDDBYtWWe98c=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.7.0 h1:aYMCj2WMCLPbXcITrXx22+P5vhfRW0I1Y1NuJxp5XK0=
-github.com/wealdtech/go-eth2-wallet-store-s3 v1.7.0/go.mod h1:dT5tX+uTFI16qdt4On7KCmxx96V7xYn+vdUJUzPDdyo=
-github.com/wealdtech/go-eth2-wallet-store-scratch v1.3.3 h1:0cKttlJ5QONJ2ZndVLUVv3RhbEaSU0TKvOI2BIB9j60=
-github.com/wealdtech/go-eth2-wallet-store-scratch v1.3.3/go.mod h1:/tvALCsQ07lvqlU+IKKAdwYFYyjIO628bu/Ssv0JRv4=
-github.com/wealdtech/go-eth2-wallet-store-scratch v1.4.0/go.mod h1:F+CGazuwGZpxa+2nmr8T1zC3rC0mTTZyO3UFmimNwSs=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.0.2 h1:Lhwne1gRUp961fD+eoWrgDbZF5rHwosI2LS5pIdX4Yc=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.0.2/go.mod h1:d7WZ9WvtL3vGSHtSh/jnVh4YO93verLL1dRW2NK5sN4=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.1.0 h1:Zl36EPHI/4SYgjnx+mmYRVKLDdrFpWkT39ClRKYiL7U=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.1.0/go.mod h1:6mlZXBwEeyeAKj22OF+b3E0RFnwoOBM/BXIdAo5QG2M=
+github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.0 h1:CWb82xeNaZQt1Z829RyDALUy7UZbc6VOfTS+82jRdEQ=
+github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.0/go.mod h1:JelKMM10UzDJNXdIcojMj6SCIsHC8NYn4c1S2FFk7OQ=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.1.3/go.mod h1:STigKib4ZSefVvJjx88V2QpUGaoyUE1TiupcpsHpvKE=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.2.0 h1:L+yrAn8TC9DQUw+S7moOJxQTp2jrHCoAZLpI747Nx2g=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.2.0/go.mod h1:lhSwtkIO/Pfg5kz8k50yrDgj7ZQaElCPsXnixlrQn/I=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.3.0 h1:UORXUYRoUYgYF96Y+QiBq33OKQVtn/nEjnSoQbe1UOA=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.3.0/go.mod h1:Kc/8WcqMTczfH2xy5mDfCRd0NI/ca/j2jXmqJ7gz8yk=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.4.0 h1:bqG/i1fpDpnQFgJ+NBLgOLdmGhXiinwlrFVD1OAgZlo=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.4.0/go.mod h1:xBbzc+aRD06dTL5phnMshpM4sryyWYM8m86sjQKG5u0=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.0 h1:OhJm7hn6vlO+dazs5S1EBrZu/ZVQUQcaNw1ncfy0/xI=
+github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.0/go.mod h1:LfgcOnQeBcqBEoHd4VNqwZhwqzz0Xh1DqnDmjHWONGs=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.1.2/go.mod h1:IssxoHII0ewO1VysMfCmdJP1D00tRhRhXIhhaEXIOVE=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.2.0 h1:h4eePfG0ANOJYMonmIYOvxJ9uLmBEX4APb2O8Vhtv6k=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.2.0/go.mod h1:Un2EtseZWSObmTBjgkt7Qz2am54S/0115jrF83lto1U=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.0 h1:L1aPK9nc+8Ctcw+8I05vM6408weFc4a5RtLQDUeS0eE=
+github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.0/go.mod h1:e2q2uuEdq5+B3GE7jk+Mi9oz9V5nPPKXcXRg1XYavsU=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.15.2 h1:Z4Pw7/Mlp6jJLoJnhgov8M1011HP/Pb3YYqcdYGCy6Q=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.15.2/go.mod h1:GSMbVCewjbxRrw32m6YCd9DOzCRjAXB3qUOQnr58JEs=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.0 h1:sWuSrAKdWSphiQCVcThozaFgTrwemXNXDI5CnFcP02s=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.0/go.mod h1:FvjUHDbBuZrytZGOfhLWgtBoxtrWhvkD47ABrUXvHs4=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.1 h1:l9YV6OBqcxp5fjscK63lzuCUIye8ANACjJdpm5ULGS8=
+github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.1/go.mod h1:Zxhj/4i8nRpk4LTTqFKbfI2KyvO3uqLMerNXqKZKDK0=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.7.2 h1:a7GWfFd139CODvvkuTbRIuRwAAjb55sFDGRh177KXGk=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.7.2/go.mod h1:VWvXScZKUWHbhQpadLX8Yj+mc8U/i4zGthQJee+o3xg=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.8.0 h1:+q7p58NvOEfEDw8NgEoNaSG/s1eFHpyg91NEobA6RF0=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.8.0/go.mod h1:OxYD+d79StAOHigNaI5bWuvjhanEyrD4MqTj8hIvt2Y=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.0 h1:O5211UskLbK1WDecTXwugUlINDBQ26MqtiFn6u66fmA=
+github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.0/go.mod h1:dcQPLsRRYDiMV0DFYzTX6HRpP9WP+gWreAX5SLBOJ0I=
+github.com/wealdtech/go-eth2-wallet-store-scratch v1.4.2 h1:GvG3ZuzxbqFjGUaGoa8Tz7XbPlDA33G6nHQbSZInC3g=
+github.com/wealdtech/go-eth2-wallet-store-scratch v1.4.2/go.mod h1:+TbqLmJuT98PWi/xW1bp5nwZbKz+SIJYVh/+NUkmnb4=
+github.com/wealdtech/go-eth2-wallet-store-scratch v1.5.0/go.mod h1:RMIIV5/N8TgukTVzyumQd7AplpC440ZXDSk8VffeEwQ=
+github.com/wealdtech/go-eth2-wallet-store-scratch v1.6.0/go.mod h1:XtXHbl4OV/XenQsvGmXbh+bVXaGS788oa30DB7kDInA=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.2.0 h1:SfoBlW2LYjW05uHhnTZaezX37gbRsp+VYtxWT6SeAME=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.2.0/go.mod h1:XEvrlKFnHLbg1tj4Dep76XKASeS13TBpvdeXmvLiH+k=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.3.0-beta4 h1:VmpgUSr+aUexFmC2AYlQ7zpeAy0w0mcK58ihpDeMCL8=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.3.0-beta4/go.mod h1:5tVjyWK/jIzKaD+L8SCmHnc/eT9k+Fmm7zd8SwNB7jA=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.3.0 h1:PsCvp/lw7+h8Q0V3jL0f+/w2VmgS7m0mH48lbv/c2LY=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.3.0/go.mod h1:SLST6Pw/2wOEfsMYvIQjWlxbWX+jaZu8jIEbZJc4K5Q=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.5.0 h1:J29mbkSCUMl2xdu8Lg6U+JptFGfmli6xl04DAHtq9aM=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.5.0/go.mod h1:X9kYUH/E5YMqFMZ4xL6MJanABUkJGaH/yPZRT2o+yYA=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.6.0 h1:vBrH5icPPSeb14cdShA7/P2PBZOgZscJ2IhBlTIaFrA=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.6.0/go.mod h1:X9kYUH/E5YMqFMZ4xL6MJanABUkJGaH/yPZRT2o+yYA=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.7.0 h1:pquFQdIWEiSYrpIpFuvsRuialI8t9KhFsPvbIBPnzic=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.7.0/go.mod h1:X9kYUH/E5YMqFMZ4xL6MJanABUkJGaH/yPZRT2o+yYA=
 github.com/wealdtech/go-indexer v1.0.0 h1:/S4rfWQbSOnnYmwnvuTVatDibZ8o1s9bmTCHO16XINg=
 github.com/wealdtech/go-indexer v1.0.0/go.mod h1:u1cjsbsOXsm5jzJDyLmZY7GsrdX8KYXKBXkZcAmk3Zg=
 github.com/wealdtech/go-string2eth v1.1.0 h1:USJQmysUrBYYmZs7d45pMb90hRSyEwizP7lZaOZLDAw=
@@ -369,14 +432,19 @@ golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20190911031432-227b76d455e7 h1:0hQKqeLdqlt5iIwVOBErRisrHJAN57yOiPRQItI20fU=
+golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20190911031432-227b76d455e7/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20191105034135-c7e5f84aec59 h1:PyXRxSVbvzDGuqYXjHndV7xDzJ7w2K8KD9Ef8GB7KOE=
 golang.org/x/crypto v0.0.0-20191105034135-c7e5f84aec59/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200427165652-729f1e841bcc h1:ZGI/fILM2+ueot/UixBSoj9188jCAxVHEZEGhqq67I4=
-golang.org/x/crypto v0.0.0-20200427165652-729f1e841bcc/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37 h1:cg5LA/zNPRzIXIWSCxQW10Rvpy94aQh3LT/ShoCpkHw=
-golang.org/x/crypto v0.0.0-20200510223506-06a226fb4e37/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9 h1:vEg9joUBmeBcK9iSJftGNf3coIG4HqZElCPehJsfAYM=
+golang.org/x/crypto v0.0.0-20200604202706-70a84ac30bf9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899 h1:DZhuSZLsGlFL4CmhA8BcRA0mnthyA/nZ00AqCUo7vHg=
+golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de h1:ikNHVSjEfnvz6sxdSPCaPt572qowuyMDMJLLm3Db3ig=
+golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a h1:vclmkQCjlDX5OydZ9wv8rBCcS0QyQY66Mpf/7BZbInM=
+golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -411,12 +479,16 @@ golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR
 golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191002035440-2ec189313ef0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200202094626-16171245cfb2 h1:CCH4IOTTfewWjGOlSp+zGcjutRKlBEZQ6wTn8ozI/nI=
 golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200506145744-7e3656a0809f h1:QBjCr1Fz5kw158VqdE9JfI9cJnl/ymnJWAdMuinqL7Y=
-golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
-golang.org/x/net v0.0.0-20200528225125-3c3fba18258b h1:IYiJPiJfzktmDAO1HQiwjMjwjlYKHAL7KzeD544RJPs=
 golang.org/x/net v0.0.0-20200528225125-3c3fba18258b/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9 h1:pNX+40auqi2JqRfOP1akLGtYcn15TUbkhwuCO3foqqM=
+golang.org/x/net v0.0.0-20200602114024-627f9648deb9/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381 h1:VXak5I6aEWmAXeQjA+QSZzlgNrpq9mjcfDemuexIKsU=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc h1:zK/HqS5bZxDptfPJNq8v7vJfXtkU7r9TLIoSr1bXaP4=
+golang.org/x/net v0.0.0-20200813134508-3edf25e44fcc/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202 h1:VvcQYSHwXgi7W+TpUR6A9g6Up98WAHf3f/ulnJ62IyA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -425,7 +497,6 @@ golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -443,16 +514,22 @@ golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200427175716-29b57079015a h1:08u6b1caTT9MQY4wSbmsd4Ulm6DmgNYnbImBuZjGJow=
-golang.org/x/sys v0.0.0-20200427175716-29b57079015a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25 h1:OKbAoGs4fGM5cPLlVQLZGYkFC8OnOfgo6tt0Smf9XhM=
-golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200523222454-059865788121 h1:rITEj+UZHYC927n8GT97eC3zrpzXdb/voyeOuVKS46o=
 golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200620081246-981b61492c35 h1:wb/9mP8eUAmHfkM8RmpeLq6nUA7c2i5+bQOtcDftjaE=
+golang.org/x/sys v0.0.0-20200620081246-981b61492c35/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae h1:Ih9Yo4hSPImZOpfGuA4bR/ORKTAbhZo2AbWNRCnevdo=
+golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200722175500-76b94024e4b6 h1:X9xIZ1YU8bLZA3l6gqDUHSFiD0GFI9S548h6C8nDtOY=
+golang.org/x/sys v0.0.0-20200722175500-76b94024e4b6/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed h1:J22ig1FUekjjkmZUM7pTKixYm8DvrYsvrBZdunYeIuQ=
+golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200821140526-fda516888d29 h1:mNuhGagCf3lDDm5C0376C/sxh6V7fy9WbdEu/YDNA04=
+golang.org/x/sys v0.0.0-20200821140526-fda516888d29/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
@@ -486,7 +563,6 @@ google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9Ywl
 google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
 google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
-google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8 h1:Nw54tB0rB7hY/N0NQvRW8DG4Yk3Q6T9cu9RcFQDu1tc=
 google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
 google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
 google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
@@ -498,64 +574,75 @@ google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBr
 google.golang.org/genproto v0.0.0-20190927181202-20e1ac93f88c/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
 google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
 google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
-google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380 h1:xriR1EgvKfkKxIoU2uUvrMVl+H26359loFFUleSMXFo=
-google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
 google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
-google.golang.org/genproto v0.0.0-20200528191852-705c0b31589b h1:nl5tymnV+50ACFZUDAP+xFCe3Zh3SWdMDx+ernZSKNA=
 google.golang.org/genproto v0.0.0-20200528191852-705c0b31589b/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200620020550-bd6e04640131 h1:IXNofpkLhv80L3TJQvj2YQLnMHZgAktycswvtXwQiRk=
+google.golang.org/genproto v0.0.0-20200620020550-bd6e04640131/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200710124503-20a17af7bd0e h1:k+p/u26/lVeNEpdxSeUrm7rTvoFckBKaf7gTzgmHyDA=
+google.golang.org/genproto v0.0.0-20200710124503-20a17af7bd0e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200711021454-869866162049 h1:YFTFpQhgvrLrmxtiIncJxFXeCyq84ixuKWVCaCAi9Oc=
+google.golang.org/genproto v0.0.0-20200711021454-869866162049/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200715011427-11fb19a81f2c h1:6DWnZZ6EY/59QRRQttZKiktVL23UuQYs7uy75MhhLRM=
+google.golang.org/genproto v0.0.0-20200715011427-11fb19a81f2c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200722002428-88e341933a54 h1:ASrBgpl9XvkNTP0m39/j18mid7aoF21npu2ioIBxYnY=
+google.golang.org/genproto v0.0.0-20200722002428-88e341933a54/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200814021100-8c09557e8a18 h1:hjnc4GP1IeBnHi+u3sp8be4ELyIHmFSO5p8DUdJUVt4=
+google.golang.org/genproto v0.0.0-20200814021100-8c09557e8a18/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200815001618-f69a88009b70 h1:wboULUXGF3c5qdUnKp+6gLAccE6PRpa/czkYvQ4UXv8=
+google.golang.org/genproto v0.0.0-20200815001618-f69a88009b70/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
-google.golang.org/grpc v1.21.0 h1:G+97AoqBnmZIT91cLG/EkCoK9NSelj64P8bOHHNmGn0=
 google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
 google.golang.org/grpc v1.24.0/go.mod h1:XDChyiUovWa60DnaeDeZmSW86xtLtjtZbwvSiRnRtcA=
 google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
-google.golang.org/grpc v1.27.0 h1:rRYRFMVgRv6E0D70Skyfsr28tDXIuuPZyWGMPdMcnXg=
 google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
 google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
-google.golang.org/grpc v1.28.0 h1:bO/TA4OxCOummhSf10siHuG7vJOiwh7SpRpFZDkOgl4=
-google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
 google.golang.org/grpc v1.29.1 h1:EC2SB8S04d2r73uptxphDSUG+kTKVgjRPF+N3xpxRB4=
 google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0 h1:M5a8xTlYTxwMn5ZFkwhRabsygDY5G8TYLyQDBxJNAxE=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0 h1:T7P4R73V3SSDPhH7WW7ATbfViLtmamH0DKrP3f9AuDI=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
 google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
-google.golang.org/protobuf v1.20.1 h1:ESRXHgpUBG5D2I5mmsQIyYxB/tQIZfSZ8wLyFDf/N/U=
-google.golang.org/protobuf v1.20.1/go.mod h1:KqelGeouBkcbcuB3HCk4/YH2tmNLk6YSWA5LIWeI/lY=
-google.golang.org/protobuf v1.21.0 h1:qdOKuR/EIArgaWNjetjgTzgVTAZ+S/WXVrq9HW9zimw=
 google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
-google.golang.org/protobuf v1.22.0 h1:cJv5/xdbk1NnMPR1VP9+HU6gupuG9MLBoH1r6RHZ2MY=
 google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
 google.golang.org/protobuf v1.24.0 h1:UhZDfRO8JRQru4/+LlLE0BRKGF8L+PICnvYZmx/fEGA=
 google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-gopkg.in/ini.v1 v1.51.0 h1:AQvPpx3LzTDM0AjnIRlVFwFFGC+npRopjZxLJj6gdno=
 gopkg.in/ini.v1 v1.51.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
-gopkg.in/ini.v1 v1.56.0 h1:DPMeDvGTM54DXbPkVIZsp19fp/I2K7zwA/itHYHKo8Y=
-gopkg.in/ini.v1 v1.56.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/ini.v1 v1.57.0 h1:9unxIsFcTt4I55uWluz+UmL95q4kdJ0buvQ1ZIqVQww=
 gopkg.in/ini.v1 v1.57.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.58.0 h1:VdDvTzv/005R8vEFyQ56bpEnOKTNPbpJhL0VCohxlQw=
+gopkg.in/ini.v1 v1.58.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/ini.v1 v1.60.1 h1:P5y5shSkb0CFe44qEeMBgn8JLow09MP17jlJHanke5g=
+gopkg.in/ini.v1 v1.60.1/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
 gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
 gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
 gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.2.8 h1:obN1ZagJSUGI0Ek/LBmuj4SNLPfIny3KsKFopxRdj10=
-gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
 gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c h1:grhR+C34yXImVGp7EzNk+DTIk+323eIUWOmEevy6bDo=
+gopkg.in/yaml.v3 v3.0.0-20200605160147-a5ece683394c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
 gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
 honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=

grpc/beaconchain.go

@@ -20,11 +20,10 @@ import (
 
 	"github.com/gogo/protobuf/types"
 	"github.com/pkg/errors"
-	"github.com/spf13/viper"
-	"google.golang.org/grpc"
-
 	ethpb "github.com/prysmaticlabs/ethereumapis/eth/v1alpha1"
-	wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	"github.com/spf13/viper"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+	"google.golang.org/grpc"
 )
 
 // FetchChainConfig fetches the chain configuration from the beacon node.
@@ -91,8 +90,8 @@ func FetchLatestFilledSlot(conn *grpc.ClientConn) (uint64, error) {
 	return chainHead.HeadSlot, nil
 }
 
-// FetchValidator fetches the validator definition from the beacon node.
-func FetchValidator(conn *grpc.ClientConn, account wtypes.Account) (*ethpb.Validator, error) {
+// FetchValidatorCommittees fetches the validator committees for a given epoch.
+func FetchValidatorCommittees(conn *grpc.ClientConn, epoch uint64) (map[uint64][][]uint64, error) {
 	if conn == nil {
 		return nil, errors.New("no connection to beacon node")
 	}
@@ -100,9 +99,51 @@ func FetchValidator(conn *grpc.ClientConn, account wtypes.Account) (*ethpb.Valid
 	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 	defer cancel()
 
+	req := &ethpb.ListCommitteesRequest{
+		QueryFilter: &ethpb.ListCommitteesRequest_Epoch{
+			Epoch: epoch,
+		},
+	}
+	resp, err := beaconClient.ListBeaconCommittees(ctx, req)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain committees")
+	}
+
+	res := make(map[uint64][][]uint64)
+	for slot, committees := range resp.Committees {
+		res[slot] = make([][]uint64, len(resp.Committees))
+		for i, committee := range committees.Committees {
+			res[slot][uint64(i)] = make([]uint64, len(committee.ValidatorIndices))
+			indices := make([]uint64, len(committee.ValidatorIndices))
+			copy(indices, committee.ValidatorIndices)
+			res[slot][uint64(i)] = indices
+		}
+	}
+
+	return res, nil
+}
+
+// FetchValidator fetches the validator definition from the beacon node.
+func FetchValidator(conn *grpc.ClientConn, account e2wtypes.Account) (*ethpb.Validator, error) {
+	if conn == nil {
+		return nil, errors.New("no connection to beacon node")
+	}
+	beaconClient := ethpb.NewBeaconChainClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+
+	var pubKey []byte
+	if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		pubKey = pubKeyProvider.CompositePublicKey().Marshal()
+	} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
+		pubKey = pubKeyProvider.PublicKey().Marshal()
+	} else {
+		return nil, errors.New("Unable to obtain public key")
+	}
+
 	req := &ethpb.GetValidatorRequest{
 		QueryFilter: &ethpb.GetValidatorRequest_PublicKey{
-			PublicKey: account.PublicKey().Marshal(),
+			PublicKey: pubKey,
 		},
 	}
 	return beaconClient.GetValidator(ctx, req)
@@ -125,8 +166,74 @@ func FetchValidatorByIndex(conn *grpc.ClientConn, index uint64) (*ethpb.Validato
 	return beaconClient.GetValidator(ctx, req)
 }
 
+// FetchValidatorBalance fetches the validator balance from the beacon node.
+func FetchValidatorBalance(conn *grpc.ClientConn, account e2wtypes.Account) (uint64, error) {
+	if conn == nil {
+		return 0, errors.New("no connection to beacon node")
+	}
+	beaconClient := ethpb.NewBeaconChainClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+
+	var pubKey []byte
+	if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		pubKey = pubKeyProvider.CompositePublicKey().Marshal()
+	} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
+		pubKey = pubKeyProvider.PublicKey().Marshal()
+	} else {
+		return 0, errors.New("Unable to obtain public key")
+	}
+
+	res, err := beaconClient.ListValidatorBalances(ctx, &ethpb.ListValidatorBalancesRequest{
+		PublicKeys: [][]byte{pubKey},
+	})
+	if err != nil {
+		return 0, err
+	}
+	if len(res.Balances) == 0 {
+		return 0, errors.New("unknown validator")
+	}
+	return res.Balances[0].Balance, nil
+}
+
+// FetchValidatorPerformance fetches the validator performance from the beacon node.
+func FetchValidatorPerformance(conn *grpc.ClientConn, account e2wtypes.Account) (bool, bool, bool, uint64, int64, error) {
+	if conn == nil {
+		return false, false, false, 0, 0, errors.New("no connection to beacon node")
+	}
+	beaconClient := ethpb.NewBeaconChainClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+
+	var pubKey []byte
+	if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		pubKey = pubKeyProvider.CompositePublicKey().Marshal()
+	} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
+		pubKey = pubKeyProvider.PublicKey().Marshal()
+	} else {
+		return false, false, false, 0, 0, errors.New("Unable to obtain public key")
+	}
+
+	req := &ethpb.ValidatorPerformanceRequest{
+		PublicKeys: [][]byte{pubKey},
+	}
+	res, err := beaconClient.GetValidatorPerformance(ctx, req)
+	if err != nil {
+		return false, false, false, 0, 0, err
+	}
+	if len(res.InclusionDistances) == 0 {
+		return false, false, false, 0, 0, errors.New("unknown validator")
+	}
+	return res.CorrectlyVotedHead[0],
+		res.CorrectlyVotedSource[0],
+		res.CorrectlyVotedTarget[0],
+		res.InclusionDistances[0],
+		int64(res.BalancesAfterEpochTransition[0]) - int64(res.BalancesBeforeEpochTransition[0]),
+		err
+}
+
 // FetchValidatorInfo fetches current validator info from the beacon node.
-func FetchValidatorInfo(conn *grpc.ClientConn, account wtypes.Account) (*ethpb.ValidatorInfo, error) {
+func FetchValidatorInfo(conn *grpc.ClientConn, account e2wtypes.Account) (*ethpb.ValidatorInfo, error) {
 	if conn == nil {
 		return nil, errors.New("no connection to beacon node")
 	}
@@ -139,9 +246,18 @@ func FetchValidatorInfo(conn *grpc.ClientConn, account wtypes.Account) (*ethpb.V
 		return nil, errors.Wrap(err, "failed to contact beacon node")
 	}
 
+	var pubKey []byte
+	if pubKeyProvider, ok := account.(e2wtypes.AccountCompositePublicKeyProvider); ok {
+		pubKey = pubKeyProvider.CompositePublicKey().Marshal()
+	} else if pubKeyProvider, ok := account.(e2wtypes.AccountPublicKeyProvider); ok {
+		pubKey = pubKeyProvider.PublicKey().Marshal()
+	} else {
+		return nil, errors.New("Unable to obtain public key")
+	}
+
 	changeSet := &ethpb.ValidatorChangeSet{
 		Action:     ethpb.SetAction_SET_VALIDATOR_KEYS,
-		PublicKeys: [][]byte{account.PublicKey().Marshal()},
+		PublicKeys: [][]byte{pubKey},
 	}
 	err = stream.Send(changeSet)
 	if err != nil {
@@ -171,8 +287,11 @@ func FetchBlock(conn *grpc.ClientConn, slot uint64) (*ethpb.SignedBeaconBlock, e
 	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 	defer cancel()
 
-	req := &ethpb.ListBlocksRequest{
-		QueryFilter: &ethpb.ListBlocksRequest_Slot{Slot: slot},
+	req := &ethpb.ListBlocksRequest{}
+	if slot == 0 {
+		req.QueryFilter = &ethpb.ListBlocksRequest_Genesis{Genesis: true}
+	} else {
+		req.QueryFilter = &ethpb.ListBlocksRequest_Slot{Slot: slot}
 	}
 	resp, err := beaconClient.ListBlocks(ctx, req)
 	if err != nil {

grpc/beaconnode.go

@@ -33,9 +33,18 @@ func FetchValidatorIndex(conn *grpc.ClientConn, account wtypes.Account) (uint64,
 	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 	defer cancel()
 
+	var pubKey []byte
+	if pubKeyProvider, ok := account.(wtypes.AccountCompositePublicKeyProvider); ok {
+		pubKey = pubKeyProvider.CompositePublicKey().Marshal()
+	} else if pubKeyProvider, ok := account.(wtypes.AccountPublicKeyProvider); ok {
+		pubKey = pubKeyProvider.PublicKey().Marshal()
+	} else {
+		return 0, errors.New("Unable to obtain public key")
+	}
+
 	// Fetch the account.
 	req := &ethpb.ValidatorIndexRequest{
-		PublicKey: account.PublicKey().Marshal(),
+		PublicKey: pubKey,
 	}
 	resp, err := validatorClient.ValidatorIndex(ctx, req)
 	if err != nil {
@@ -54,9 +63,18 @@ func FetchValidatorState(conn *grpc.ClientConn, account wtypes.Account) (ethpb.V
 	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
 	defer cancel()
 
+	var pubKey []byte
+	if pubKeyProvider, ok := account.(wtypes.AccountCompositePublicKeyProvider); ok {
+		pubKey = pubKeyProvider.CompositePublicKey().Marshal()
+	} else if pubKeyProvider, ok := account.(wtypes.AccountPublicKeyProvider); ok {
+		pubKey = pubKeyProvider.PublicKey().Marshal()
+	} else {
+		return ethpb.ValidatorStatus_UNKNOWN_STATUS, errors.New("Unable to obtain public key")
+	}
+
 	// Fetch the account.
 	req := &ethpb.ValidatorStatusRequest{
-		PublicKey: account.PublicKey().Marshal(),
+		PublicKey: pubKey,
 	}
 	resp, err := validatorClient.ValidatorStatus(ctx, req)
 	if err != nil {

grpc/node.go

@@ -55,6 +55,21 @@ func FetchGenesisValidatorsRoot(conn *grpc.ClientConn) ([]byte, error) {
 	return res.GetGenesisValidatorsRoot(), nil
 }
 
+// FetchDepositContractAddress fetches the address of the deposit contract.
+func FetchDepositContractAddress(conn *grpc.ClientConn) ([]byte, error) {
+	if conn == nil {
+		return nil, errors.New("no connection to beacon node")
+	}
+	client := ethpb.NewNodeClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), viper.GetDuration("timeout"))
+	defer cancel()
+	res, err := client.GetGenesis(ctx, &types.Empty{})
+	if err != nil {
+		return nil, err
+	}
+	return res.DepositContractAddress, nil
+}
+
 // FetchVersion fetches the version and metadata from the server.
 func FetchVersion(conn *grpc.ClientConn) (string, string, error) {
 	if conn == nil {

util/bls.go

@@ -0,0 +1,31 @@
+// Copyright © 2020 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package util
+
+import (
+	"encoding/binary"
+
+	"github.com/herumi/bls-eth-go-binary/bls"
+)
+
+// BLSID turns a uint64 in to a BLS identifier.
+func BLSID(id uint64) *bls.ID {
+	var res bls.ID
+	buf := [8]byte{}
+	binary.LittleEndian.PutUint64(buf[:], id)
+	if err := res.SetLittleEndian(buf[:]); err != nil {
+		panic(err)
+	}
+	return &res
+}

util/depositinfo.go

@@ -0,0 +1,282 @@
+// 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 util
+
+import (
+	"bytes"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+// DepositInfo is a generic deposit structure.
+type DepositInfo struct {
+	Name                  string
+	Account               string
+	PublicKey             []byte
+	WithdrawalCredentials []byte
+	Signature             []byte
+	DepositDataRoot       []byte
+	DepositMessageRoot    []byte
+	ForkVersion           []byte
+	Amount                uint64
+	Version               uint64
+}
+
+// depositInfoV1 is an ethdo V1 deposit structure.
+type depositInfoV1 struct {
+	Name                  string `json:"name,omitempty"`
+	Account               string `json:"account,omitempty"`
+	PublicKey             string `json:"pubkey"`
+	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Signature             string `json:"signature"`
+	DepositDataRoot       string `json:"deposit_data_root"`
+	Value                 uint64 `json:"value"`
+	Version               uint64 `json:"version"`
+}
+
+// depositInfoV3 is an ethdo V3 deposit structure.
+type depositInfoV3 struct {
+	Name                  string `json:"name,omitempty"`
+	Account               string `json:"account,omitempty"`
+	PublicKey             string `json:"pubkey"`
+	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Signature             string `json:"signature"`
+	DepositDataRoot       string `json:"deposit_data_root"`
+	DepositMessageRoot    string `json:"deposit_message_root"`
+	ForkVersion           string `json:"fork_version"`
+	Amount                uint64 `json:"amount"`
+	Version               uint64 `json:"version"`
+}
+
+// depositInfoCLI is a deposit structure from the eth2 deposit CLI.
+type depositInfoCLI struct {
+	PublicKey             string `json:"pubkey"`
+	WithdrawalCredentials string `json:"withdrawal_credentials"`
+	Signature             string `json:"signature"`
+	DepositDataRoot       string `json:"deposit_data_root"`
+	DepositMessageRoot    string `json:"deposit_message_root"`
+	ForkVersion           string `json:"fork_version"`
+	Amount                uint64 `json:"amount"`
+}
+
+func DepositInfoFromJSON(input []byte) ([]*DepositInfo, error) {
+	// Work out the type of data that we're dealing with, and decode it appropriately.
+	depositInfo, err := tryRawTxData(input)
+	if err != nil {
+		depositInfo, err = tryV3DepositInfoFromJSON(input)
+		if err != nil {
+			depositInfo, err = tryV1DepositInfoFromJSON(input)
+			if err != nil {
+				depositInfo, err = tryCLIDepositInfoFromJSON(input)
+				if err != nil {
+					// Give up
+					return nil, errors.New("unknown deposit data format")
+				}
+			}
+		}
+	}
+
+	if len(depositInfo) == 0 {
+		return nil, errors.New("no deposits supplied")
+	}
+
+	for i := range depositInfo {
+		if len(depositInfo[i].PublicKey) == 0 {
+			return nil, fmt.Errorf("no public key for deposit %d", i)
+		}
+		if len(depositInfo[i].DepositDataRoot) == 0 {
+			return nil, fmt.Errorf("no data root for deposit %d", i)
+		}
+		if len(depositInfo[i].Signature) == 0 {
+			return nil, fmt.Errorf("no signature for deposit %d", i)
+		}
+		if len(depositInfo[i].WithdrawalCredentials) == 0 {
+			return nil, fmt.Errorf("no withdrawal credentials for deposit %d", i)
+		}
+	}
+	return depositInfo, nil
+}
+
+func tryV3DepositInfoFromJSON(data []byte) ([]*DepositInfo, error) {
+	var depositData []*depositInfoV3
+	err := json.Unmarshal(data, &depositData)
+	if err != nil {
+		return nil, err
+	}
+
+	depositInfos := make([]*DepositInfo, len(depositData))
+	for i, deposit := range depositData {
+		if deposit.Version != 3 {
+			return nil, errors.New("incorrect V3 deposit version")
+		}
+		publicKey, err := hex.DecodeString(strings.TrimPrefix(deposit.PublicKey, "0x"))
+		if err != nil {
+			return nil, errors.New("public key invalid")
+		}
+		withdrawalCredentials, err := hex.DecodeString(strings.TrimPrefix(deposit.WithdrawalCredentials, "0x"))
+		if err != nil {
+			return nil, errors.New("withdrawal credentials invalid")
+		}
+		signature, err := hex.DecodeString(strings.TrimPrefix(deposit.Signature, "0x"))
+		if err != nil {
+			return nil, errors.New("signature invalid")
+		}
+		depositDataRoot, err := hex.DecodeString(strings.TrimPrefix(deposit.DepositDataRoot, "0x"))
+		if err != nil {
+			return nil, errors.New("deposit data root invalid")
+		}
+		depositMessageRoot, err := hex.DecodeString(strings.TrimPrefix(deposit.DepositMessageRoot, "0x"))
+		if err != nil {
+			return nil, errors.New("deposit message root invalid")
+		}
+		forkVersion, err := hex.DecodeString(strings.TrimPrefix(deposit.ForkVersion, "0x"))
+		if err != nil {
+			return nil, errors.New("fork version invalid")
+		}
+		depositInfos[i] = &DepositInfo{
+			Name:                  deposit.Name,
+			Account:               deposit.Account,
+			PublicKey:             publicKey,
+			WithdrawalCredentials: withdrawalCredentials,
+			Signature:             signature,
+			DepositDataRoot:       depositDataRoot,
+			DepositMessageRoot:    depositMessageRoot,
+			ForkVersion:           forkVersion,
+			Amount:                deposit.Amount,
+			Version:               3,
+		}
+	}
+
+	return depositInfos, nil
+}
+
+func tryCLIDepositInfoFromJSON(data []byte) ([]*DepositInfo, error) {
+	var depositData []*depositInfoCLI
+	err := json.Unmarshal(data, &depositData)
+	if err != nil {
+		return nil, err
+	}
+
+	depositInfos := make([]*DepositInfo, len(depositData))
+	for i, deposit := range depositData {
+		publicKey, err := hex.DecodeString(strings.TrimPrefix(deposit.PublicKey, "0x"))
+		if err != nil {
+			return nil, errors.New("public key invalid")
+		}
+		withdrawalCredentials, err := hex.DecodeString(strings.TrimPrefix(deposit.WithdrawalCredentials, "0x"))
+		if err != nil {
+			return nil, errors.New("withdrawal credentials invalid")
+		}
+		signature, err := hex.DecodeString(strings.TrimPrefix(deposit.Signature, "0x"))
+		if err != nil {
+			return nil, errors.New("signature invalid")
+		}
+		depositDataRoot, err := hex.DecodeString(strings.TrimPrefix(deposit.DepositDataRoot, "0x"))
+		if err != nil {
+			return nil, errors.New("deposit data root invalid")
+		}
+		depositMessageRoot, err := hex.DecodeString(strings.TrimPrefix(deposit.DepositMessageRoot, "0x"))
+		if err != nil {
+			return nil, errors.New("deposit message root invalid")
+		}
+		forkVersion, err := hex.DecodeString(strings.TrimPrefix(deposit.ForkVersion, "0x"))
+		if err != nil {
+			return nil, errors.New("fork version invalid")
+		}
+		depositInfos[i] = &DepositInfo{
+			PublicKey:             publicKey,
+			WithdrawalCredentials: withdrawalCredentials,
+			Signature:             signature,
+			DepositDataRoot:       depositDataRoot,
+			DepositMessageRoot:    depositMessageRoot,
+			ForkVersion:           forkVersion,
+			Amount:                deposit.Amount,
+			Version:               3,
+		}
+	}
+
+	return depositInfos, nil
+}
+
+func tryV1DepositInfoFromJSON(data []byte) ([]*DepositInfo, error) {
+	var depositData []*depositInfoV1
+	err := json.Unmarshal(data, &depositData)
+	if err != nil {
+		return nil, err
+	}
+
+	depositInfos := make([]*DepositInfo, len(depositData))
+	for i, deposit := range depositData {
+		if deposit.Version < 1 || deposit.Version > 2 {
+			return nil, errors.New("incorrect deposit version")
+		}
+		publicKey, err := hex.DecodeString(strings.TrimPrefix(deposit.PublicKey, "0x"))
+		if err != nil {
+			return nil, errors.New("public key invalid")
+		}
+		withdrawalCredentials, err := hex.DecodeString(strings.TrimPrefix(deposit.WithdrawalCredentials, "0x"))
+		if err != nil {
+			return nil, errors.New("withdrawal credentials invalid")
+		}
+		signature, err := hex.DecodeString(strings.TrimPrefix(deposit.Signature, "0x"))
+		if err != nil {
+			return nil, errors.New("signature invalid")
+		}
+		depositDataRoot, err := hex.DecodeString(strings.TrimPrefix(deposit.DepositDataRoot, "0x"))
+		if err != nil {
+			return nil, errors.New("deposit data root invalid")
+		}
+		depositInfos[i] = &DepositInfo{
+			Name:                  deposit.Name,
+			Account:               deposit.Account,
+			PublicKey:             publicKey,
+			WithdrawalCredentials: withdrawalCredentials,
+			Signature:             signature,
+			DepositDataRoot:       depositDataRoot,
+			Amount:                deposit.Value,
+			Version:               3,
+		}
+	}
+
+	return depositInfos, nil
+}
+
+func tryRawTxData(data []byte) ([]*DepositInfo, error) {
+	txData, err := hex.DecodeString(strings.TrimPrefix(string(data), "0x"))
+	if err != nil {
+		return nil, errors.New("public key invalid")
+	}
+
+	depositInfos := make([]*DepositInfo, 1)
+
+	if len(txData) != 420 {
+		return nil, errors.New("invalid transaction length")
+	}
+	if !bytes.Equal(txData[0:4], []byte{0x22, 0x89, 0x51, 0x18}) {
+		return nil, errors.New("invalid function signature")
+	}
+
+	depositInfos[0] = &DepositInfo{
+		PublicKey:             txData[164:212],
+		WithdrawalCredentials: txData[260:292],
+		Signature:             txData[324:420],
+		DepositDataRoot:       txData[100:132],
+	}
+
+	return depositInfos, nil
+}