Bump version.

Output "prater" as network name in launchpad format

.github/workflows/release.yml

@@ -14,7 +14,7 @@ jobs:
     - name: Set up Go 1.x
       uses: actions/setup-go@v2
       with:
-        go-version: ^1.13
+        go-version: ^1.16
       id: go
 
     - name: Check out code into the Go module directory
@@ -50,11 +50,11 @@ jobs:
 
     - name: Fetch xgo
       run: |
-       go get github.com/suburbandad/xgo
+       go install github.com/wealdtech/xgo@latest
 
     - name: Cross-compile linux
       run: |
-        xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64,linux/arm64" github.com/wealdtech/ethdo
+        xgo -v -x -ldflags="-X github.com/wealdtech/ethdo/cmd.ReleaseVersion=${RELEASE_VERSION}" --targets="linux/amd64" github.com/wealdtech/ethdo
 
     - name: Cross-compile windows
       run: |
@@ -63,20 +63,20 @@ jobs:
     - name: Create windows release files
       run: |
        mv ethdo-windows-4.0-amd64.exe ethdo.exe
-       sha256sum ethdo.exe >ethdo-${RELEASE_VERSION}-windows.sha256
        zip --junk-paths ethdo-${RELEASE_VERSION}-windows-exe.zip ethdo.exe
+       sha256sum ethdo-${RELEASE_VERSION}-windows-exe.zip >ethdo-${RELEASE_VERSION}-windows.sha256
 
     - name: Create linux AMD64 tgz file
       run: |
        mv ethdo-linux-amd64 ethdo
-       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-amd64.sha256
        tar zcf ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz ethdo
+       sha256sum ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz >ethdo-${RELEASE_VERSION}-linux-amd64.sha256
 
-    - name: Create linux ARM64 tgz file
-      run: |
-       mv ethdo-linux-arm64 ethdo
-       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-arm64.sha256
-       tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz ethdo
+       # - name: Create linux ARM64 tgz file
+       #   run: |
+       #    mv ethdo-linux-arm64 ethdo
+       #    tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz ethdo
+       #    sha256sum ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz >ethdo-${RELEASE_VERSION}-linux-arm64.sha256
 
     - name: Create release
       id: create_release
@@ -133,24 +133,24 @@ jobs:
         asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-amd64.tar.gz
         asset_content_type: application/gzip
 
-    - name: Upload linux ARM64 checksum file
-      id: upload-release-asset-linux-arm64-checksum
-      uses: actions/upload-release-asset@v1
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      with:
-        upload_url: ${{ steps.create_release.outputs.upload_url }}
-        asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
-        asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
-        asset_content_type: text/plain
+          # - name: Upload linux ARM64 checksum file
+          #   id: upload-release-asset-linux-arm64-checksum
+          #   uses: actions/upload-release-asset@v1
+          #   env:
+          #     GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          #   with:
+          #     upload_url: ${{ steps.create_release.outputs.upload_url }}
+          #     asset_path: ./ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
+          #     asset_name: ethdo-${{ env.RELEASE_VERSION }}-linux-arm64.sha256
+          #     asset_content_type: text/plain
 
-    - name: Upload linux ARM64 tgz file
-      id: upload-release-asset-linux-arm64
-      uses: actions/upload-release-asset@v1
-      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
+          # - 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

@@ -1,8 +1,46 @@
+1.18.0:
+  - add "-ssz" option to "block info"
+  - add "block analyze" command
+  - support bellatrix
+
+1.17.0:
+  - add sync committee information to "chain time"
+  - add details of vote success to "attester inclusion --verbose"
+  - add "synccommittee inclusion"
+
+1.15.1:
+  - provide sync committee slots in "chain status"
+  - clarify that --connection should be a URL
+
+1.15.0:
+  - add --period to "synccommittee members", can be "current", "next"
+  - add "validator expectation"
+
+1.14.0:
+  - add "chain verify signedcontributionandproof"
+  - show both block and body root in "block info"
+  - add exit / withdrawable epoch to "validator info"
+
+1.13.0:
+  - rework and provide additional information to "chain status" output
+
+1.12.0:
+  - add "synccommittee members"
+
+1.11.0
+  - add Altair information to "block info"
+  - add more information to "chain info"
+
+1.10.2
+  - use local shamir code (copied from github.com/hashicorp/vault)
+
+1.10.0
+  - add "wallet sharedexport" and "wallet sharedimport"
+
 1.9.1
   - Avoid crash when required interfaces for chain status command are not supported
   - Avoid crash with latest version of herumi/go-bls
 
-
 1.9.0
   - allow use of Ethereum 1 address as withdrawal credentials
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.14-buster as builder
+FROM golang:1.17-bullseye as builder
 
 WORKDIR /app
 
@@ -10,10 +10,12 @@ COPY . .
 
 RUN go build
 
-FROM debian:buster-slim
+FROM debian:bullseye-slim
+
+RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt install -y ca-certificates && apt-get clean && rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 
 COPY --from=builder /app/ethdo /app
 
-ENTRYPOINT ["/app/ethdo"]
+ENTRYPOINT ["/app/ethdo"]

cmd/attester/duties/input.go

@@ -63,17 +63,19 @@ func input(ctx context.Context) (*dataIn, error) {
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
+	// Required data.
+	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
+	}
+	data.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
+
 	// Epoch
 	epoch := viper.GetInt64("epoch")
 	if epoch == -1 {
-		config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain beacon chain configuration")
-		}
-		data.slotsPerEpoch = config["SLOTS_PER_EPOCH"].(uint64)
 		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
 		genesis, err := data.eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
 		if err != nil {

cmd/attester/duties/input_internal_test.go

@@ -73,7 +73,7 @@ func TestInput(t *testing.T) {
 				"timeout": "5s",
 				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 	}
 

cmd/attester/inclusion/input.go

@@ -15,12 +15,14 @@ package attesterinclusion
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
 	"github.com/wealdtech/ethdo/util"
 )
 
@@ -34,9 +36,11 @@ type dataIn struct {
 	slotsPerEpoch uint64
 	// Operation.
 	eth2Client eth2client.Service
+	chainTime  chaintime.Service
 	epoch      spec.Epoch
 	account    string
 	pubKey     string
+	index      string
 }
 
 func input(ctx context.Context) (*dataIn, error) {
@@ -50,18 +54,24 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.verbose = viper.GetBool("verbose")
 	data.debug = viper.GetBool("debug")
 
-	// Account or pubkey.
-	if viper.GetString("account") == "" && viper.GetString("pubkey") == "" {
-		return nil, errors.New("account or pubkey is required")
-	}
+	// Account.
 	data.account = viper.GetString("account")
+
+	// PubKey.
 	data.pubKey = viper.GetString("pubkey")
 
+	// ID.
+	data.index = viper.GetString("index")
+
+	if viper.GetString("account") == "" && viper.GetString("index") == "" && viper.GetString("pubkey") == "" {
+		return nil, errors.New("account, index or pubkey is required")
+	}
+
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
 	config, err := data.eth2Client.(eth2client.SpecProvider).Spec(ctx)
@@ -84,6 +94,9 @@ func input(ctx context.Context) (*dataIn, error) {
 		}
 	}
 	data.epoch = spec.Epoch(epoch)
+	if data.debug {
+		fmt.Printf("Epoch is %d\n", data.epoch)
+	}
 
 	return data, nil
 }

cmd/attester/inclusion/input_internal_test.go

@@ -61,11 +61,11 @@ func TestInput(t *testing.T) {
 			err:  "timeout is required",
 		},
 		{
-			name: "AccountMissing",
+			name: "IndexMissing",
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "account or pubkey is required",
+			err: "account, index or pubkey is required",
 		},
 		{
 			name: "ConnectionMissing",
@@ -73,7 +73,7 @@ func TestInput(t *testing.T) {
 				"timeout": "5s",
 				"pubkey":  "0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 	}
 

cmd/attester/inclusion/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2022 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
@@ -16,8 +16,9 @@ package attesterinclusion
 import (
 	"context"
 	"fmt"
+	"strings"
 
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 )
 
@@ -25,22 +26,67 @@ type dataOut struct {
 	debug            bool
 	quiet            bool
 	verbose          bool
-	slot             spec.Slot
+	attestation      *phase0.Attestation
+	slot             phase0.Slot
 	attestationIndex uint64
-	inclusionDelay   spec.Slot
+	inclusionDelay   phase0.Slot
 	found            bool
+	headCorrect      bool
+	headTimely       bool
+	sourceTimely     bool
+	targetCorrect    bool
+	targetTimely     bool
 }
 
 func output(ctx context.Context, data *dataOut) (string, error) {
+	buf := strings.Builder{}
 	if data == nil {
-		return "", errors.New("no data")
+		return buf.String(), errors.New("no data")
 	}
 
 	if !data.quiet {
 		if data.found {
-			return fmt.Sprintf("Attestation included in block %d, attestation %d (inclusion delay %d)", data.slot, data.attestationIndex, data.inclusionDelay), nil
+			buf.WriteString("Attestation included in block ")
+			buf.WriteString(fmt.Sprintf("%d", data.slot))
+			buf.WriteString(", index ")
+			buf.WriteString(fmt.Sprintf("%d", data.attestationIndex))
+			if data.verbose {
+				buf.WriteString("\nInclusion delay: ")
+				buf.WriteString(fmt.Sprintf("%d", data.inclusionDelay))
+				buf.WriteString("\nHead correct: ")
+				if data.headCorrect {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nHead timely: ")
+				if data.headTimely {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nSource timely: ")
+				if data.sourceTimely {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nTarget correct: ")
+				if data.targetCorrect {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+				buf.WriteString("\nTarget timely: ")
+				if data.targetTimely {
+					buf.WriteString("✓")
+				} else {
+					buf.WriteString("✕")
+				}
+			}
+		} else {
+			buf.WriteString("Attestation not found")
 		}
-		return "Attestation not found", nil
 	}
-	return "", nil
+	return buf.String(), nil
 }

cmd/attester/inclusion/output_internal_test.go

@@ -44,7 +44,29 @@ func TestOutput(t *testing.T) {
 				attestationIndex: 456,
 				inclusionDelay:   7,
 			},
-			res: "Attestation included in block 123, attestation 456 (inclusion delay 7)",
+			res: `Attestation included in block 123, index 456`,
+		},
+		{
+			name: "Verbose",
+			dataOut: &dataOut{
+				verbose:          true,
+				found:            true,
+				slot:             123,
+				attestationIndex: 456,
+				inclusionDelay:   7,
+				headCorrect:      true,
+				headTimely:       false,
+				sourceTimely:     false,
+				targetCorrect:    true,
+				targetTimely:     true,
+			},
+			res: `Attestation included in block 123, index 456
+Inclusion delay: 7
+Head correct: ✓
+Head timely: ✕
+Source timely: ✕
+Target correct: ✓
+Target timely: ✓`,
 		},
 	}
 

cmd/attester/inclusion/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2022 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,17 +14,16 @@
 package attesterinclusion
 
 import (
+	"bytes"
 	"context"
-	"encoding/hex"
 	"fmt"
-	"strings"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	api "github.com/attestantio/go-eth2-client/api/v1"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
@@ -32,34 +31,23 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return nil, errors.New("no data")
 	}
 
-	var account e2wtypes.Account
 	var err error
-	if data.account != "" {
-		ctx, cancel := context.WithTimeout(ctx, data.timeout)
-		defer cancel()
-		_, account, err = util.WalletAndAccountFromPath(ctx, data.account)
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to obtain account")
-		}
-	} else {
-		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(data.pubKey, "0x"))
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", data.pubKey))
-		}
-		account, err = util.NewScratchAccount(nil, pubKeyBytes)
-		if err != nil {
-			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", data.pubKey))
-		}
+
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithForkScheduleProvider(data.eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to set up chaintime service")
 	}
 
-	// Fetch validator
-	pubKeys := make([]spec.BLSPubKey, 1)
-	pubKey, err := util.BestPublicKey(account)
+	validatorIndex, err := util.ValidatorIndex(ctx, data.eth2Client, data.account, data.pubKey, data.index)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to obtain public key for account")
+		return nil, errors.Wrap(err, "failed to obtain validator index")
 	}
-	copy(pubKeys[0][:], pubKey.Marshal())
-	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, fmt.Sprintf("%d", uint64(data.epoch)*data.slotsPerEpoch), pubKeys)
+
+	validators, err := data.eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, fmt.Sprintf("%d", uint64(data.epoch)*data.slotsPerEpoch), []phase0.ValidatorIndex{validatorIndex})
 	if err != nil {
 		return nil, errors.New("failed to obtain validator information")
 	}
@@ -81,6 +69,9 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain duty for validator")
 	}
+	if data.debug {
+		fmt.Printf("Duty is %s\n", duty.String())
+	}
 
 	startSlot := duty.Slot + 1
 	endSlot := startSlot + 32
@@ -92,20 +83,50 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if signedBlock == nil {
 			continue
 		}
-		if signedBlock.Message.Slot != slot {
+		blockSlot, err := signedBlock.Slot()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain block slot")
+		}
+		if blockSlot != slot {
 			continue
 		}
 		if data.debug {
 			fmt.Printf("Fetched block for slot %d\n", slot)
 		}
-		for i, attestation := range signedBlock.Message.Body.Attestations {
+		attestations, err := signedBlock.Attestations()
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain block attestations")
+		}
+		for i, attestation := range attestations {
 			if attestation.Data.Slot == duty.Slot &&
 				attestation.Data.Index == duty.CommitteeIndex &&
 				attestation.AggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
+
+				headCorrect := false
+				targetCorrect := false
+				if data.verbose {
+					headCorrect, err = calcHeadCorrect(ctx, data, attestation)
+					if err != nil {
+						return nil, errors.Wrap(err, "failed to obtain head correct result")
+					}
+					targetCorrect, err = calcTargetCorrect(ctx, data, attestation)
+					if err != nil {
+						return nil, errors.Wrap(err, "failed to obtain target correct result")
+					}
+				}
+				results.found = true
+				results.attestation = attestation
 				results.slot = slot
 				results.attestationIndex = uint64(i)
 				results.inclusionDelay = slot - duty.Slot
-				results.found = true
+				results.sourceTimely = results.inclusionDelay <= 5 // sqrt(32)
+				results.targetCorrect = targetCorrect
+				results.targetTimely = targetCorrect && results.inclusionDelay <= 32
+				results.headCorrect = headCorrect
+				results.headTimely = headCorrect && results.inclusionDelay == 1
+				if data.debug {
+					fmt.Printf("Attestation is %s\n", attestation.String())
+				}
 				return results, nil
 			}
 		}
@@ -113,9 +134,52 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return results, nil
 }
 
-func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch spec.Epoch, slotsPerEpoch uint64) (*api.AttesterDuty, error) {
+func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
+	for {
+		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return false, nil
+		}
+		if header == nil {
+			// No block.
+			slot--
+			continue
+		}
+		if !header.Canonical {
+			// Not canonical.
+			slot--
+			continue
+		}
+		return bytes.Equal(header.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+	}
+}
+
+func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
+	// Start with first slot of the target epoch.
+	slot := data.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+	for {
+		header, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+		if err != nil {
+			return false, nil
+		}
+		if header == nil {
+			// No block.
+			slot--
+			continue
+		}
+		if !header.Canonical {
+			// Not canonical.
+			slot--
+			continue
+		}
+		return bytes.Equal(header.Root[:], attestation.Data.Target.Root[:]), nil
+	}
+}
+
+func duty(ctx context.Context, eth2Client eth2client.Service, validator *api.Validator, epoch phase0.Epoch, slotsPerEpoch uint64) (*api.AttesterDuty, error) {
 	// Find the attesting slot for the given epoch.
-	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []spec.ValidatorIndex{validator.Index})
+	duties, err := eth2Client.(eth2client.AttesterDutiesProvider).AttesterDuties(ctx, epoch, []phase0.ValidatorIndex{validator.Index})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain attester duties")
 	}

cmd/attesterinclusion.go

@@ -49,6 +49,7 @@ func init() {
 	attesterFlags(attesterInclusionCmd)
 	attesterInclusionCmd.Flags().Int64("epoch", -1, "the last complete epoch")
 	attesterInclusionCmd.Flags().String("pubkey", "", "the public key of the attester")
+	attesterInclusionCmd.Flags().Int64("index", -1, "the index of the attester")
 }
 
 func attesterInclusionBindings() {
@@ -58,4 +59,7 @@ func attesterInclusionBindings() {
 	if err := viper.BindPFlag("pubkey", attesterInclusionCmd.Flags().Lookup("pubkey")); err != nil {
 		panic(err)
 	}
+	if err := viper.BindPFlag("index", attesterInclusionCmd.Flags().Lookup("index")); err != nil {
+		panic(err)
+	}
 }

cmd/block/analyze/command.go

@@ -0,0 +1,136 @@
+// Copyright © 2022 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 blockanalyze
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Operation.
+	blockID    string
+	stream     bool
+	jsonOutput bool
+
+	// Data access.
+	eth2Client           eth2client.Service
+	chainTime            chaintime.Service
+	blocksProvider       eth2client.SignedBeaconBlockProvider
+	blockHeadersProvider eth2client.BeaconBlockHeadersProvider
+
+	// Constants.
+	timelySourceWeight uint64
+	timelyTargetWeight uint64
+	timelyHeadWeight   uint64
+	syncRewardWeight   uint64
+	proposerWeight     uint64
+	weightDenominator  uint64
+
+	// Processing.
+	priorAttestations map[string]*attestationData
+	// Head roots provides the root of the head slot at given slots.
+	headRoots map[phase0.Slot]phase0.Root
+	// Target roots provides the root of the target epoch at given slots.
+	targetRoots map[phase0.Slot]phase0.Root
+
+	// Block info.
+	// Map is slot -> committee index -> validator committee index -> votes.
+	votes map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist
+
+	// Results.
+	analysis *blockAnalysis
+}
+
+type blockAnalysis struct {
+	Slot         phase0.Slot            `json:"slot"`
+	Attestations []*attestationAnalysis `json:"attestations"`
+	SyncCommitee *syncCommitteeAnalysis `json:"sync_committee"`
+	Value        float64                `json:"value"`
+}
+
+type attestationAnalysis struct {
+	Head          phase0.Root      `json:"head"`
+	Target        phase0.Root      `json:"target"`
+	Distance      int              `json:"distance"`
+	Duplicate     *attestationData `json:"duplicate,omitempty"`
+	NewVotes      int              `json:"new_votes"`
+	Votes         int              `json:"votes"`
+	PossibleVotes int              `json:"possible_votes"`
+	HeadCorrect   bool             `json:"head_correct"`
+	HeadTimely    bool             `json:"head_timely"`
+	SourceTimely  bool             `json:"source_timely"`
+	TargetCorrect bool             `json:"target_correct"`
+	TargetTimely  bool             `json:"target_timely"`
+	Score         float64          `json:"score"`
+	Value         float64          `json:"value"`
+}
+
+type syncCommitteeAnalysis struct {
+	Contributions         int     `json:"contributions"`
+	PossibleContributions int     `json:"possible_contributions"`
+	Score                 float64 `json:"score"`
+	Value                 float64 `json:"value"`
+}
+
+type attestationData struct {
+	Block phase0.Slot `json:"block"`
+	Index int         `json:"index"`
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		priorAttestations: make(map[string]*attestationData),
+		headRoots:         make(map[phase0.Slot]phase0.Root),
+		targetRoots:       make(map[phase0.Slot]phase0.Root),
+		votes:             make(map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	if viper.GetString("connection") == "" {
+		return nil, errors.New("connection is required")
+	}
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	c.blockID = viper.GetString("blockid")
+	c.stream = viper.GetBool("stream")
+	c.jsonOutput = viper.GetBool("json")
+
+	return c, nil
+}

cmd/block/analyze/command_internal_test.go

@@ -0,0 +1,82 @@
+// Copyright © 2022 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 blockanalyze
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+			},
+			err: "connection is required",
+		},
+		{
+			name: "ValidatorsZero",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"validators": "0",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "validators must be at least 1",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			_, err := newCommand(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/block/analyze/output.go

@@ -0,0 +1,157 @@
+// Copyright © 2022 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 blockanalyze
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	if c.jsonOutput {
+		return c.outputJSON(ctx)
+	}
+
+	return c.outputTxt(ctx)
+}
+
+type attestationAnalysisJSON struct {
+	Head          string           `json:"head"`
+	Target        string           `json:"target"`
+	Distance      int              `json:"distance"`
+	Duplicate     *attestationData `json:"duplicate,omitempty"`
+	NewVotes      int              `json:"new_votes"`
+	Votes         int              `json:"votes"`
+	PossibleVotes int              `json:"possible_votes"`
+	HeadCorrect   bool             `json:"head_correct"`
+	HeadTimely    bool             `json:"head_timely"`
+	SourceTimely  bool             `json:"source_timely"`
+	TargetCorrect bool             `json:"target_correct"`
+	TargetTimely  bool             `json:"target_timely"`
+	Score         float64          `json:"score"`
+	Value         float64          `json:"value"`
+}
+
+func (a *attestationAnalysis) MarshalJSON() ([]byte, error) {
+	return json.Marshal(attestationAnalysisJSON{
+		Head:          fmt.Sprintf("%#x", a.Head),
+		Target:        fmt.Sprintf("%#x", a.Target),
+		Distance:      a.Distance,
+		Duplicate:     a.Duplicate,
+		NewVotes:      a.NewVotes,
+		Votes:         a.Votes,
+		PossibleVotes: a.PossibleVotes,
+		HeadCorrect:   a.HeadCorrect,
+		HeadTimely:    a.HeadTimely,
+		SourceTimely:  a.SourceTimely,
+		TargetCorrect: a.TargetCorrect,
+		TargetTimely:  a.TargetTimely,
+		Score:         a.Score,
+		Value:         a.Value,
+	})
+}
+
+func (c *command) outputJSON(_ context.Context) (string, error) {
+	data, err := json.Marshal(c.analysis)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func (c *command) outputTxt(_ context.Context) (string, error) {
+	builder := strings.Builder{}
+
+	for i, attestation := range c.analysis.Attestations {
+		if c.verbose {
+			builder.WriteString("Attestation ")
+			builder.WriteString(fmt.Sprintf("%d", i))
+			builder.WriteString(": ")
+			builder.WriteString("distance ")
+			builder.WriteString(fmt.Sprintf("%d", attestation.Distance))
+			builder.WriteString(", ")
+
+			if attestation.Duplicate != nil {
+				builder.WriteString("duplicate of attestation ")
+				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Index))
+				builder.WriteString(" in block ")
+				builder.WriteString(fmt.Sprintf("%d", attestation.Duplicate.Block))
+				builder.WriteString("\n")
+				continue
+			}
+
+			builder.WriteString(fmt.Sprintf("%d", attestation.NewVotes))
+			builder.WriteString("/")
+			builder.WriteString(fmt.Sprintf("%d", attestation.Votes))
+			builder.WriteString("/")
+			builder.WriteString(fmt.Sprintf("%d", attestation.PossibleVotes))
+			builder.WriteString(" new/total/possible votes")
+			if attestation.NewVotes == 0 {
+				builder.WriteString("\n")
+				continue
+			} else {
+				builder.WriteString(", ")
+			}
+			switch {
+			case !attestation.HeadCorrect:
+				builder.WriteString("head vote incorrect, ")
+			case !attestation.HeadTimely:
+				builder.WriteString("head vote correct but late, ")
+			}
+
+			if !attestation.SourceTimely {
+				builder.WriteString("source vote late, ")
+			}
+
+			switch {
+			case !attestation.TargetCorrect:
+				builder.WriteString("target vote incorrect, ")
+			case !attestation.TargetTimely:
+				builder.WriteString("target vote correct but late, ")
+			}
+
+			builder.WriteString("score ")
+			builder.WriteString(fmt.Sprintf("%0.3f", attestation.Score))
+			builder.WriteString(", value ")
+			builder.WriteString(fmt.Sprintf("%0.3f", attestation.Value))
+			builder.WriteString("\n")
+		}
+	}
+
+	if c.analysis.SyncCommitee.Contributions > 0 {
+		if c.verbose {
+			builder.WriteString("Sync committee contributions: ")
+			builder.WriteString(fmt.Sprintf("%d", c.analysis.SyncCommitee.Contributions))
+			builder.WriteString(" contributions, score ")
+			builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.SyncCommitee.Score))
+			builder.WriteString(", value ")
+			builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.SyncCommitee.Value))
+			builder.WriteString("\n")
+		}
+	}
+
+	builder.WriteString("Value for block ")
+	builder.WriteString(fmt.Sprintf("%d", c.analysis.Slot))
+	builder.WriteString(": ")
+	builder.WriteString(fmt.Sprintf("%0.3f", c.analysis.Value))
+	builder.WriteString("\n")
+
+	return builder.String(), nil
+}

cmd/block/analyze/process.go

@@ -0,0 +1,431 @@
+// Copyright © 2022 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 blockanalyze
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	block, err := c.blocksProvider.SignedBeaconBlock(ctx, c.blockID)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain beacon block")
+	}
+	if block == nil {
+		return errors.New("empty beacon block")
+	}
+
+	slot, err := block.Slot()
+	if err != nil {
+		return err
+	}
+	attestations, err := block.Attestations()
+	if err != nil {
+		return err
+	}
+
+	c.analysis = &blockAnalysis{
+		Slot: slot,
+	}
+
+	// Calculate how many parents we need to fetch.
+	minSlot := slot
+	for _, attestation := range attestations {
+		if attestation.Data.Slot < minSlot {
+			minSlot = attestation.Data.Slot
+		}
+	}
+	if c.debug {
+		fmt.Printf("Need to fetch blocks to slot %d\n", minSlot)
+	}
+
+	if err := c.fetchParents(ctx, block, minSlot); err != nil {
+		return err
+	}
+
+	return c.analyze(ctx, block)
+}
+
+func (c *command) analyze(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	if err := c.analyzeAttestations(ctx, block); err != nil {
+		return err
+	}
+
+	if err := c.analyzeSyncCommittees(ctx, block); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *command) analyzeAttestations(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	attestations, err := block.Attestations()
+	if err != nil {
+		return err
+	}
+	slot, err := block.Slot()
+	if err != nil {
+		return err
+	}
+
+	c.analysis.Attestations = make([]*attestationAnalysis, len(attestations))
+
+	blockVotes := make(map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist)
+	for i, attestation := range attestations {
+		if c.debug {
+			fmt.Printf("Processing attestation %d\n", i)
+		}
+		analysis := &attestationAnalysis{
+			Head:     attestation.Data.BeaconBlockRoot,
+			Target:   attestation.Data.Target.Root,
+			Distance: int(slot - attestation.Data.Slot),
+		}
+
+		root, err := attestation.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		if info, exists := c.priorAttestations[fmt.Sprintf("%#x", root)]; exists {
+			analysis.Duplicate = info
+		} else {
+			data := attestation.Data
+			_, exists := blockVotes[data.Slot]
+			if !exists {
+				blockVotes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+			}
+			_, exists = blockVotes[data.Slot][data.Index]
+			if !exists {
+				blockVotes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
+			}
+
+			// Count new votes.
+			analysis.PossibleVotes = int(attestation.AggregationBits.Len())
+			for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
+				if attestation.AggregationBits.BitAt(j) {
+					analysis.Votes++
+					if blockVotes[data.Slot][data.Index].BitAt(j) {
+						// Already attested to in this block; skip.
+						continue
+					}
+					if c.votes[data.Slot][data.Index].BitAt(j) {
+						// Already attested to in a previous block; skip.
+						continue
+					}
+					analysis.NewVotes++
+					blockVotes[data.Slot][data.Index].SetBitAt(j, true)
+				}
+			}
+			// Calculate head correct.
+			var err error
+			analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
+			if err != nil {
+				return err
+			}
+
+			// Calculate head timely.
+			analysis.HeadTimely = attestation.Data.Slot == slot-1
+
+			// Calculate source timely.
+			analysis.SourceTimely = attestation.Data.Slot >= slot-5
+
+			// Calculate target correct.
+			analysis.TargetCorrect, err = c.calcTargetCorrect(ctx, attestation)
+			if err != nil {
+				return err
+			}
+
+			// Calculate target timely.
+			analysis.TargetTimely = attestation.Data.Slot >= slot-32
+		}
+
+		// Calculate score and value.
+		if analysis.TargetCorrect && analysis.TargetTimely {
+			analysis.Score += float64(c.timelyTargetWeight) / float64(c.weightDenominator)
+		}
+		if analysis.SourceTimely {
+			analysis.Score += float64(c.timelySourceWeight) / float64(c.weightDenominator)
+		}
+		if analysis.HeadCorrect && analysis.HeadTimely {
+			analysis.Score += float64(c.timelyHeadWeight) / float64(c.weightDenominator)
+		}
+		analysis.Value = analysis.Score * float64(analysis.NewVotes)
+		c.analysis.Value += analysis.Value
+
+		c.analysis.Attestations[i] = analysis
+	}
+
+	return nil
+}
+
+func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedBeaconBlock, minSlot phase0.Slot) error {
+	parentRoot, err := block.ParentRoot()
+	if err != nil {
+		return err
+	}
+
+	// Obtain the parent block.
+	parentBlock, err := c.blocksProvider.SignedBeaconBlock(ctx, fmt.Sprintf("%#x", parentRoot))
+	if err != nil {
+		return err
+	}
+	if parentBlock == nil {
+		return fmt.Errorf("unable to obtain parent block %s", parentBlock)
+	}
+
+	parentSlot, err := parentBlock.Slot()
+	if err != nil {
+		return err
+	}
+	if parentSlot < minSlot {
+		return nil
+	}
+
+	if err := c.processParentBlock(ctx, parentBlock); err != nil {
+		return err
+	}
+
+	return c.fetchParents(ctx, parentBlock, minSlot)
+}
+
+func (c *command) processParentBlock(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	attestations, err := block.Attestations()
+	if err != nil {
+		return err
+	}
+	slot, err := block.Slot()
+	if err != nil {
+		return err
+	}
+	if c.debug {
+		fmt.Printf("Processing block %d\n", slot)
+	}
+
+	for i, attestation := range attestations {
+		root, err := attestation.HashTreeRoot()
+		if err != nil {
+			return err
+		}
+		c.priorAttestations[fmt.Sprintf("%#x", root)] = &attestationData{
+			Block: slot,
+			Index: i,
+		}
+
+		data := attestation.Data
+		_, exists := c.votes[data.Slot]
+		if !exists {
+			c.votes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+		}
+		_, exists = c.votes[data.Slot][data.Index]
+		if !exists {
+			c.votes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
+		}
+		for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
+			if attestation.AggregationBits.BitAt(j) {
+				c.votes[data.Slot][data.Index].SetBitAt(j, true)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to beacon node")
+	}
+
+	c.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	// Obtain the number of active validators.
+	var isProvider bool
+	c.blocksProvider, isProvider = c.eth2Client.(eth2client.SignedBeaconBlockProvider)
+	if !isProvider {
+		return errors.New("connection does not provide signed beacon block information")
+	}
+	c.blockHeadersProvider, isProvider = c.eth2Client.(eth2client.BeaconBlockHeadersProvider)
+	if !isProvider {
+		return errors.New("connection does not provide beacon block header information")
+	}
+
+	specProvider, isProvider := c.eth2Client.(eth2client.SpecProvider)
+	if !isProvider {
+		return errors.New("connection does not provide spec information")
+	}
+
+	spec, err := specProvider.Spec(ctx)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain spec")
+	}
+
+	tmp, exists := spec["TIMELY_SOURCE_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(14)
+	}
+	var ok bool
+	c.timelySourceWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("TIMELY_SOURCE_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["TIMELY_TARGET_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(26)
+	}
+	c.timelyTargetWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("TIMELY_TARGET_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["TIMELY_HEAD_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(14)
+	}
+	c.timelyHeadWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("TIMELY_HEAD_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["SYNC_REWARD_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(2)
+	}
+	c.syncRewardWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("SYNC_REWARD_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["PROPOSER_WEIGHT"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(8)
+	}
+	c.proposerWeight, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("PROPOSER_WEIGHT of unexpected type")
+	}
+
+	tmp, exists = spec["WEIGHT_DENOMINATOR"]
+	if !exists {
+		// Set a default value based on the Altair spec.
+		tmp = uint64(64)
+	}
+	c.weightDenominator, ok = tmp.(uint64)
+	if !ok {
+		return errors.New("WEIGHT_DENOMINATOR of unexpected type")
+	}
+	return nil
+}
+
+func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
+	root, exists := c.headRoots[slot]
+	if !exists {
+		for {
+			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			if err != nil {
+				return false, nil
+			}
+			if header == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !header.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.headRoots[attestation.Data.Slot] = header.Root
+			root = header.Root
+			break
+		}
+	}
+
+	return bytes.Equal(root[:], attestation.Data.BeaconBlockRoot[:]), nil
+}
+
+func (c *command) calcTargetCorrect(ctx context.Context, attestation *phase0.Attestation) (bool, error) {
+	root, exists := c.targetRoots[attestation.Data.Slot]
+	if !exists {
+		// Start with first slot of the target epoch.
+		slot := c.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+		for {
+			header, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, fmt.Sprintf("%d", slot))
+			if err != nil {
+				return false, nil
+			}
+			if header == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !header.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.targetRoots[attestation.Data.Slot] = header.Root
+			root = header.Root
+			break
+		}
+	}
+	return bytes.Equal(root[:], attestation.Data.Target.Root[:]), nil
+}
+
+func (c *command) analyzeSyncCommittees(ctx context.Context, block *spec.VersionedSignedBeaconBlock) error {
+	c.analysis.SyncCommitee = &syncCommitteeAnalysis{}
+	switch block.Version {
+	case spec.DataVersionPhase0:
+		return nil
+	case spec.DataVersionAltair:
+		c.analysis.SyncCommitee.Contributions = int(block.Altair.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
+		c.analysis.SyncCommitee.PossibleContributions = int(block.Altair.Message.Body.SyncAggregate.SyncCommitteeBits.Len())
+		c.analysis.SyncCommitee.Score = float64(c.syncRewardWeight) / float64(c.weightDenominator)
+		c.analysis.SyncCommitee.Value = c.analysis.SyncCommitee.Score * float64(c.analysis.SyncCommitee.Contributions)
+		c.analysis.Value += c.analysis.SyncCommitee.Value
+		return nil
+	default:
+		return fmt.Errorf("unsupported block version %d", block.Version)
+	}
+}

cmd/block/analyze/process_internal_test.go

@@ -0,0 +1,63 @@
+// Copyright © 2022 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 blockanalyze
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "InvalidData",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"validators": "1",
+				"data":       "[[",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/block/analyze/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2022 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 blockanalyze
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/block/info/input.go

@@ -32,6 +32,7 @@ type dataIn struct {
 	// Operation.
 	eth2Client eth2client.Service
 	jsonOutput bool
+	sszOutput  bool
 	// Chain information.
 	blockID string
 	stream  bool
@@ -48,13 +49,14 @@ func input(ctx context.Context) (*dataIn, error) {
 	data.verbose = viper.GetBool("verbose")
 	data.debug = viper.GetBool("debug")
 	data.jsonOutput = viper.GetBool("json")
+	data.sszOutput = viper.GetBool("ssz")
 
 	data.stream = viper.GetBool("stream")
 
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
 	if viper.GetString("blockid") == "" {

cmd/block/info/input_internal_test.go

@@ -66,7 +66,7 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 		{
 			name: "ConnectionBad",
@@ -79,7 +79,7 @@ func TestInput(t *testing.T) {
 				timeout: 5 * time.Second,
 				blockID: "justified",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 		{
 			name: "BlockIDNil",

cmd/block/info/output.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019, 2020, 2021 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
@@ -18,13 +18,16 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"math/big"
 	"sort"
 	"strings"
 	"time"
 	"unicode/utf8"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/wealdtech/go-string2eth"
@@ -47,34 +50,44 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 	return "", nil
 }
 
-func outputBlockGeneral(ctx context.Context, verbose bool, block *spec.BeaconBlock, genesisTime time.Time, slotDuration time.Duration, slotsPerEpoch uint64) (string, error) {
-	bodyRoot, err := block.Body.HashTreeRoot()
-	if err != nil {
-		return "", errors.Wrap(err, "failed to generate block root")
-	}
-
+func outputBlockGeneral(ctx context.Context,
+	verbose bool,
+	slot phase0.Slot,
+	blockRoot phase0.Root,
+	bodyRoot phase0.Root,
+	parentRoot phase0.Root,
+	stateRoot phase0.Root,
+	graffiti []byte,
+	genesisTime time.Time,
+	slotDuration time.Duration,
+	slotsPerEpoch uint64,
+) (
+	string,
+	error,
+) {
 	res := strings.Builder{}
 
-	res.WriteString(fmt.Sprintf("Slot: %d\n", block.Slot))
-	res.WriteString(fmt.Sprintf("Epoch: %d\n", spec.Epoch(uint64(block.Slot)/slotsPerEpoch)))
-	res.WriteString(fmt.Sprintf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(block.Slot)*int64(slotDuration.Seconds()), 0)))
-	res.WriteString(fmt.Sprintf("Block root: %#x\n", bodyRoot))
+	res.WriteString(fmt.Sprintf("Slot: %d\n", slot))
+	res.WriteString(fmt.Sprintf("Epoch: %d\n", phase0.Epoch(uint64(slot)/slotsPerEpoch)))
+	res.WriteString(fmt.Sprintf("Timestamp: %v\n", time.Unix(genesisTime.Unix()+int64(slot)*int64(slotDuration.Seconds()), 0)))
+	res.WriteString(fmt.Sprintf("Block root: %#x\n", blockRoot))
 	if verbose {
-		res.WriteString(fmt.Sprintf("Parent root: %#x\n", block.ParentRoot))
-		res.WriteString(fmt.Sprintf("State root: %#x\n", block.StateRoot))
+		res.WriteString(fmt.Sprintf("Body root: %#x\n", bodyRoot))
+		res.WriteString(fmt.Sprintf("Parent root: %#x\n", parentRoot))
+		res.WriteString(fmt.Sprintf("State root: %#x\n", stateRoot))
 	}
-	if len(block.Body.Graffiti) > 0 && hex.EncodeToString(block.Body.Graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
-		if utf8.Valid(block.Body.Graffiti) {
-			res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(block.Body.Graffiti)))
+	if len(graffiti) > 0 && hex.EncodeToString(graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
+		if utf8.Valid(graffiti) {
+			res.WriteString(fmt.Sprintf("Graffiti: %s\n", strings.TrimRight(string(graffiti), "\u0000")))
 		} else {
-			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", block.Body.Graffiti))
+			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", graffiti))
 		}
 	}
 
 	return res.String(), nil
 }
 
-func outputBlockETH1Data(ctx context.Context, eth1Data *spec.ETH1Data) (string, error) {
+func outputBlockETH1Data(ctx context.Context, eth1Data *phase0.ETH1Data) (string, error) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Ethereum 1 deposit count: %d\n", eth1Data.DepositCount))
@@ -84,10 +97,10 @@ func outputBlockETH1Data(ctx context.Context, eth1Data *spec.ETH1Data) (string,
 	return res.String(), nil
 }
 
-func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service, verbose bool, attestations []*spec.Attestation) (string, error) {
+func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service, verbose bool, attestations []*phase0.Attestation) (string, error) {
 	res := strings.Builder{}
 
-	validatorCommittees := make(map[spec.Slot]map[spec.CommitteeIndex][]spec.ValidatorIndex)
+	validatorCommittees := make(map[phase0.Slot]map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 	res.WriteString(fmt.Sprintf("Attestations: %d\n", len(attestations)))
 	if verbose {
 		beaconCommitteesProvider, isProvider := eth2Client.(eth2client.BeaconCommitteesProvider)
@@ -100,21 +113,25 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 				if !exists {
 					beaconCommittees, err := beaconCommitteesProvider.BeaconCommittees(ctx, fmt.Sprintf("%d", att.Data.Slot))
 					if err != nil {
-						return "", errors.Wrap(err, "failed to obtain beacon committees")
-					}
-					for _, beaconCommittee := range beaconCommittees {
-						if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
-							validatorCommittees[beaconCommittee.Slot] = make(map[spec.CommitteeIndex][]spec.ValidatorIndex)
+						// Failed to get it; create an empty committee to stop us continually attempting to re-fetch.
+						validatorCommittees[att.Data.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+					} else {
+						for _, beaconCommittee := range beaconCommittees {
+							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
+								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+							}
+							validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
 						}
-						validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
 					}
 					committees = validatorCommittees[att.Data.Slot]
 				}
 
 				res.WriteString(fmt.Sprintf("    Committee index: %d\n", att.Data.Index))
 				res.WriteString(fmt.Sprintf("    Attesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len()))
-				res.WriteString(fmt.Sprintf("    Aggregation bits: %s\n", bitsToString(att.AggregationBits)))
-				res.WriteString(fmt.Sprintf("    Attesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.Index])))
+				res.WriteString(fmt.Sprintf("    Aggregation bits: %s\n", bitlistToString(att.AggregationBits)))
+				if _, exists := committees[att.Data.Index]; exists {
+					res.WriteString(fmt.Sprintf("    Attesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.Index])))
+				}
 				res.WriteString(fmt.Sprintf("    Slot: %d\n", att.Data.Slot))
 				res.WriteString(fmt.Sprintf("    Beacon block root: %#x\n", att.Data.BeaconBlockRoot))
 				res.WriteString(fmt.Sprintf("    Source epoch: %d\n", att.Data.Source.Epoch))
@@ -128,7 +145,7 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 	return res.String(), nil
 }
 
-func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Service, verbose bool, attesterSlashings []*spec.AttesterSlashing) (string, error) {
+func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Service, verbose bool, attesterSlashings []*phase0.AttesterSlashing) (string, error) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Attester slashings: %d\n", len(attesterSlashings)))
@@ -175,7 +192,7 @@ func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Ser
 	return res.String(), nil
 }
 
-func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*spec.Deposit) (string, error) {
+func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*phase0.Deposit) (string, error) {
 	res := strings.Builder{}
 
 	// Deposits.
@@ -194,14 +211,14 @@ func outputBlockDeposits(ctx context.Context, verbose bool, deposits []*spec.Dep
 	return res.String(), nil
 }
 
-func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Service, verbose bool, voluntaryExits []*spec.SignedVoluntaryExit) (string, error) {
+func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Service, verbose bool, voluntaryExits []*phase0.SignedVoluntaryExit) (string, error) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Voluntary exits: %d\n", len(voluntaryExits)))
 	if verbose {
 		for i, voluntaryExit := range voluntaryExits {
 			res.WriteString(fmt.Sprintf("  %d:\n", i))
-			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []spec.ValidatorIndex{voluntaryExit.Message.ValidatorIndex})
+			validators, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, "head", []phase0.ValidatorIndex{voluntaryExit.Message.ValidatorIndex})
 			if err != nil {
 				res.WriteString(fmt.Sprintf("  Error: failed to obtain validators: %v\n", err))
 			} else {
@@ -214,7 +231,45 @@ func outputBlockVoluntaryExits(ctx context.Context, eth2Client eth2client.Servic
 	return res.String(), nil
 }
 
-func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.SignedBeaconBlock) (string, error) {
+func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service, verbose bool, syncAggregate *altair.SyncAggregate, epoch phase0.Epoch) (string, error) {
+	res := strings.Builder{}
+
+	res.WriteString("Sync aggregate: ")
+	res.WriteString(fmt.Sprintf("%d/%d\n", syncAggregate.SyncCommitteeBits.Count(), syncAggregate.SyncCommitteeBits.Len()))
+	if verbose {
+		specProvider, isProvider := eth2Client.(eth2client.SpecProvider)
+		if isProvider {
+			config, err := specProvider.Spec(ctx)
+			if err == nil {
+				slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
+
+				res.WriteString("  Contributions: ")
+				res.WriteString(bitvectorToString(syncAggregate.SyncCommitteeBits))
+				res.WriteString("\n")
+
+				syncCommitteesProvider, isProvider := eth2Client.(eth2client.SyncCommitteesProvider)
+				if isProvider {
+					syncCommittee, err := syncCommitteesProvider.SyncCommittee(ctx, fmt.Sprintf("%d", uint64(epoch)*slotsPerEpoch))
+					if err != nil {
+						res.WriteString(fmt.Sprintf("  Error: failed to obtain sync committee: %v\n", err))
+					} else {
+						res.WriteString("  Contributing validators:")
+						for i := uint64(0); i < syncAggregate.SyncCommitteeBits.Len(); i++ {
+							if syncAggregate.SyncCommitteeBits.BitAt(i) {
+								res.WriteString(fmt.Sprintf(" %d", syncCommittee.Validators[i]))
+							}
+						}
+						res.WriteString("\n")
+					}
+				}
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBellatrixBlockText(ctx context.Context, data *dataOut, signedBlock *bellatrix.SignedBeaconBlock) (string, error) {
 	if signedBlock == nil {
 		return "", errors.New("no block supplied")
 	}
@@ -224,7 +279,199 @@ func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.Signe
 	res := strings.Builder{}
 
 	// General info.
-	tmp, err := outputBlockGeneral(ctx, data.verbose, signedBlock.Message, data.genesisTime, data.slotDuration, data.slotsPerEpoch)
+	blockRoot, err := signedBlock.Message.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain block root")
+	}
+	bodyRoot, err := signedBlock.Message.Body.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate body root")
+	}
+
+	tmp, err := outputBlockGeneral(ctx,
+		data.verbose,
+		signedBlock.Message.Slot,
+		blockRoot,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti,
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Eth1 data.
+	if data.verbose {
+		tmp, err := outputBlockETH1Data(ctx, body.ETH1Data)
+		if err != nil {
+			return "", err
+		}
+		res.WriteString(tmp)
+	}
+
+	// Sync aggregate.
+	tmp, err = outputBlockSyncAggregate(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.SyncAggregate, phase0.Epoch(uint64(signedBlock.Message.Slot)/data.slotsPerEpoch))
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attestations.
+	tmp, err = outputBlockAttestations(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.Attestations)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attester slashings.
+	tmp, err = outputBlockAttesterSlashings(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.AttesterSlashings)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	res.WriteString(fmt.Sprintf("Proposer slashings: %d\n", len(body.ProposerSlashings)))
+	// Add verbose proposer slashings.
+
+	tmp, err = outputBlockDeposits(ctx, data.verbose, signedBlock.Message.Body.Deposits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Voluntary exits.
+	tmp, err = outputBlockVoluntaryExits(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.VoluntaryExits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	return res.String(), nil
+}
+
+func outputAltairBlockText(ctx context.Context, data *dataOut, signedBlock *altair.SignedBeaconBlock) (string, error) {
+	if signedBlock == nil {
+		return "", errors.New("no block supplied")
+	}
+
+	body := signedBlock.Message.Body
+
+	res := strings.Builder{}
+
+	// General info.
+	blockRoot, err := signedBlock.Message.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain block root")
+	}
+	bodyRoot, err := signedBlock.Message.Body.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate body root")
+	}
+
+	tmp, err := outputBlockGeneral(ctx,
+		data.verbose,
+		signedBlock.Message.Slot,
+		blockRoot,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti,
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Eth1 data.
+	if data.verbose {
+		tmp, err := outputBlockETH1Data(ctx, body.ETH1Data)
+		if err != nil {
+			return "", err
+		}
+		res.WriteString(tmp)
+	}
+
+	// Sync aggregate.
+	tmp, err = outputBlockSyncAggregate(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.SyncAggregate, phase0.Epoch(uint64(signedBlock.Message.Slot)/data.slotsPerEpoch))
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attestations.
+	tmp, err = outputBlockAttestations(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.Attestations)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attester slashings.
+	tmp, err = outputBlockAttesterSlashings(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.AttesterSlashings)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	res.WriteString(fmt.Sprintf("Proposer slashings: %d\n", len(body.ProposerSlashings)))
+	// Add verbose proposer slashings.
+
+	tmp, err = outputBlockDeposits(ctx, data.verbose, signedBlock.Message.Body.Deposits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Voluntary exits.
+	tmp, err = outputBlockVoluntaryExits(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.VoluntaryExits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	return res.String(), nil
+}
+
+func outputPhase0BlockText(ctx context.Context, data *dataOut, signedBlock *phase0.SignedBeaconBlock) (string, error) {
+	if signedBlock == nil {
+		return "", errors.New("no block supplied")
+	}
+
+	body := signedBlock.Message.Body
+
+	res := strings.Builder{}
+
+	// General info.
+	blockRoot, err := signedBlock.Message.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain block root")
+	}
+	bodyRoot, err := signedBlock.Message.Body.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate block root")
+	}
+	tmp, err := outputBlockGeneral(ctx,
+		data.verbose,
+		signedBlock.Message.Slot,
+		blockRoot,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti,
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
 	if err != nil {
 		return "", err
 	}
@@ -272,11 +519,61 @@ func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.Signe
 	return res.String(), nil
 }
 
+func outputBlockExecutionPayload(ctx context.Context,
+	verbose bool,
+	payload *bellatrix.ExecutionPayload,
+) (
+	string,
+	error,
+) {
+	if payload == nil {
+		return "", nil
+	}
+
+	res := strings.Builder{}
+	res.WriteString("Execution payload:\n")
+	res.WriteString("  Execution block number: ")
+	res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
+	if verbose {
+		baseFeePerGasBEBytes := make([]byte, len(payload.BaseFeePerGas))
+		for i := 0; i < 32; i++ {
+			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
+		}
+		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
+		res.WriteString("  Base fee per gas: ")
+		res.WriteString(string2eth.WeiToString(baseFeePerGas, true))
+		res.WriteString("\n  Block hash: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.BlockHash))
+		res.WriteString("  Parent hash: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.ParentHash))
+		res.WriteString("  Fee recipient: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.FeeRecipient))
+		res.WriteString("  Gas limit: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.GasLimit))
+		res.WriteString("  Gas used: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.GasUsed))
+		res.WriteString("  Timestamp: ")
+		res.WriteString(fmt.Sprintf("%s (%d)\n", time.Unix(int64(payload.Timestamp), 0).String(), payload.Timestamp))
+		res.WriteString("  Prev RANDAO: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.PrevRandao))
+		res.WriteString("  Receipts root: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.ReceiptsRoot))
+		res.WriteString("  State root: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.StateRoot))
+		res.WriteString("  Extra data: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.ExtraData))
+		res.WriteString("  Logs bloom: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.LogsBloom))
+	}
+
+	return res.String(), nil
+}
+
 // intersection returns a list of items common between the two sets.
-func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
+func intersection(set1 []uint64, set2 []uint64) []phase0.ValidatorIndex {
 	sort.Slice(set1, func(i, j int) bool { return set1[i] < set1[j] })
 	sort.Slice(set2, func(i, j int) bool { return set2[i] < set2[j] })
-	res := make([]spec.ValidatorIndex, 0)
+	res := make([]phase0.ValidatorIndex, 0)
 
 	set1Pos := 0
 	set2Pos := 0
@@ -287,7 +584,7 @@ func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
 		case set2[set2Pos] < set1[set1Pos]:
 			set2Pos++
 		default:
-			res = append(res, spec.ValidatorIndex(set1[set1Pos]))
+			res = append(res, phase0.ValidatorIndex(set1[set1Pos]))
 			set1Pos++
 			set2Pos++
 		}
@@ -296,7 +593,7 @@ func intersection(set1 []uint64, set2 []uint64) []spec.ValidatorIndex {
 	return res
 }
 
-func bitsToString(input bitfield.Bitlist) string {
+func bitlistToString(input bitfield.Bitlist) string {
 	bits := int(input.Len())
 
 	res := ""
@@ -313,7 +610,24 @@ func bitsToString(input bitfield.Bitlist) string {
 	return strings.TrimSpace(res)
 }
 
-func attestingIndices(input bitfield.Bitlist, indices []spec.ValidatorIndex) string {
+func bitvectorToString(input bitfield.Bitvector512) string {
+	bits := int(input.Len())
+
+	res := strings.Builder{}
+	for i := 0; i < bits; i++ {
+		if input.BitAt(uint64(i)) {
+			res.WriteString("✓")
+		} else {
+			res.WriteString("✕")
+		}
+		if i%8 == 7 && i != bits-1 {
+			res.WriteString(" ")
+		}
+	}
+	return res.String()
+}
+
+func attestingIndices(input bitfield.Bitlist, indices []phase0.ValidatorIndex) string {
 	bits := int(input.Len())
 	res := ""
 	for i := 0; i < bits; i++ {

cmd/block/info/process.go

@@ -21,11 +21,15 @@ import (
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	api "github.com/attestantio/go-eth2-client/api/v1"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/bellatrix"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 )
 
 var jsonOutput bool
+var sszOutput bool
 var results *dataOut
 
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
@@ -55,13 +59,29 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain beacon block")
 	}
-
-	if err := outputBlock(ctx, data.jsonOutput, signedBlock); err != nil {
-		return nil, errors.Wrap(err, "failed to output block")
+	if signedBlock == nil {
+		return nil, errors.New("empty beacon block")
+	}
+	switch signedBlock.Version {
+	case spec.DataVersionPhase0:
+		if err := outputPhase0Block(ctx, data.jsonOutput, signedBlock.Phase0); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	case spec.DataVersionAltair:
+		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Altair); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	case spec.DataVersionBellatrix:
+		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, signedBlock.Bellatrix); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	default:
+		return nil, errors.New("unknown block version")
 	}
 
 	if data.stream {
 		jsonOutput = data.jsonOutput
+		sszOutput = data.sszOutput
 		err := data.eth2Client.(eth2client.EventsProvider).Events(ctx, []string{"head"}, headEventHandler)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to start block stream")
@@ -81,14 +101,48 @@ func headEventHandler(event *api.Event) {
 	blockID := fmt.Sprintf("%#x", event.Data.(*api.HeadEvent).Block[:])
 	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(context.Background(), blockID)
 	if err != nil {
-		fmt.Printf("Failed to obtain block: %v\n", err)
+		if !jsonOutput {
+			fmt.Printf("Failed to obtain block: %v\n", err)
+		}
+		return
 	}
-	if err := outputBlock(context.Background(), jsonOutput, signedBlock); err != nil {
-		fmt.Printf("Failed to display block: %v\n", err)
+	if signedBlock == nil {
+		if !jsonOutput {
+			fmt.Println("Empty beacon block")
+		}
+		return
+	}
+	switch signedBlock.Version {
+	case spec.DataVersionPhase0:
+		if err := outputPhase0Block(context.Background(), jsonOutput, signedBlock.Phase0); err != nil {
+			if !jsonOutput {
+				fmt.Printf("Failed to output block: %v\n", err)
+			}
+			return
+		}
+	case spec.DataVersionAltair:
+		if err := outputAltairBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Altair); err != nil {
+			if !jsonOutput {
+				fmt.Printf("Failed to output block: %v\n", err)
+			}
+			return
+		}
+	case spec.DataVersionBellatrix:
+		if err := outputBellatrixBlock(context.Background(), jsonOutput, sszOutput, signedBlock.Bellatrix); err != nil {
+			if !jsonOutput {
+				fmt.Printf("Failed to output block: %v\n", err)
+			}
+			return
+		}
+	default:
+		if !jsonOutput {
+			fmt.Printf("Unknown block version: %v\n", signedBlock.Version)
+		}
+		return
 	}
 }
 
-func outputBlock(ctx context.Context, jsonOutput bool, signedBlock *spec.SignedBeaconBlock) error {
+func outputPhase0Block(ctx context.Context, jsonOutput bool, signedBlock *phase0.SignedBeaconBlock) error {
 	switch {
 	case jsonOutput:
 		data, err := json.Marshal(signedBlock)
@@ -97,7 +151,55 @@ func outputBlock(ctx context.Context, jsonOutput bool, signedBlock *spec.SignedB
 		}
 		fmt.Printf("%s\n", string(data))
 	default:
-		data, err := outputBlockText(ctx, results, signedBlock)
+		data, err := outputPhase0BlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Printf("%s\n", data)
+	}
+	return nil
+}
+
+func outputAltairBlock(ctx context.Context, jsonOutput bool, sszOutput bool, signedBlock *altair.SignedBeaconBlock) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputAltairBlockText(ctx, results, signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Printf("%s\n", data)
+	}
+	return nil
+}
+
+func outputBellatrixBlock(ctx context.Context, jsonOutput bool, sszOutput bool, signedBlock *bellatrix.SignedBeaconBlock) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputBellatrixBlockText(ctx, results, signedBlock)
 		if err != nil {
 			return errors.Wrap(err, "failed to generate text")
 		}

cmd/block/info/process_internal_test.go

@@ -47,7 +47,7 @@ func TestProcess(t *testing.T) {
 			dataIn: &dataIn{
 				eth2Client: eth2Client,
 			},
-			err: "failed to output block: failed to generate text: no block supplied",
+			err: "empty beacon block",
 		},
 	}
 

cmd/blockanalyze.go

@@ -0,0 +1,65 @@
+// Copyright © 2022 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	blockanalyze "github.com/wealdtech/ethdo/cmd/block/analyze"
+)
+
+var blockAnalyzeCmd = &cobra.Command{
+	Use:   "analyze",
+	Short: "Analyze a block",
+	Long: `Analyze the contents of a block.  For example:
+
+    ethdo block analyze --blockid=12345
+
+In quiet mode this will return 0 if the block information is present and not skipped, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := blockanalyze.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Print(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	blockCmd.AddCommand(blockAnalyzeCmd)
+	blockFlags(blockAnalyzeCmd)
+	blockAnalyzeCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
+	blockAnalyzeCmd.Flags().Bool("stream", false, "continually stream blocks as they arrive")
+	blockAnalyzeCmd.Flags().Bool("json", false, "output data in JSON format")
+}
+
+func blockAnalyzeBindings() {
+	if err := viper.BindPFlag("blockid", blockAnalyzeCmd.Flags().Lookup("blockid")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("stream", blockAnalyzeCmd.Flags().Lookup("stream")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("json", blockAnalyzeCmd.Flags().Lookup("json")); err != nil {
+		panic(err)
+	}
+}

cmd/blockinfo.go

@@ -26,7 +26,7 @@ var blockInfoCmd = &cobra.Command{
 	Short: "Obtain information about a block",
 	Long: `Obtain information about a block.  For example:
 
-    ethdo block info --slot=12345
+    ethdo block info --blockid=12345
 
 In quiet mode this will return 0 if the block information is present and not skipped, otherwise 1.`,
 	RunE: func(cmd *cobra.Command, args []string) error {
@@ -50,6 +50,7 @@ func init() {
 	blockInfoCmd.Flags().String("blockid", "head", "the ID of the block to fetch")
 	blockInfoCmd.Flags().Bool("stream", false, "continually stream blocks as they arrive")
 	blockInfoCmd.Flags().Bool("json", false, "output data in JSON format")
+	blockInfoCmd.Flags().Bool("ssz", false, "output data in SSZ format")
 }
 
 func blockInfoBindings() {
@@ -62,4 +63,7 @@ func blockInfoBindings() {
 	if err := viper.BindPFlag("json", blockInfoCmd.Flags().Lookup("json")); err != nil {
 		panic(err)
 	}
+	if err := viper.BindPFlag("ssz", blockInfoCmd.Flags().Lookup("ssz")); err != nil {
+		panic(err)
+	}
 }

cmd/chain/time/output.go

@@ -28,12 +28,17 @@ type dataOut struct {
 	quiet   bool
 	verbose bool
 
-	epoch      spec.Epoch
-	epochStart time.Time
-	epochEnd   time.Time
-	slot       spec.Slot
-	slotStart  time.Time
-	slotEnd    time.Time
+	epoch                         spec.Epoch
+	epochStart                    time.Time
+	epochEnd                      time.Time
+	slot                          spec.Slot
+	slotStart                     time.Time
+	slotEnd                       time.Time
+	syncCommitteePeriod           uint64
+	syncCommitteePeriodStart      time.Time
+	syncCommitteePeriodEpochStart spec.Epoch
+	syncCommitteePeriodEnd        time.Time
+	syncCommitteePeriodEpochEnd   spec.Epoch
 }
 
 func output(ctx context.Context, data *dataOut) (string, error) {
@@ -60,7 +65,18 @@ func output(ctx context.Context, data *dataOut) (string, error) {
 	builder.WriteString(data.slotStart.Format("2006-01-02 15:04:05"))
 	builder.WriteString("\n  Slot end ")
 	builder.WriteString(data.slotEnd.Format("2006-01-02 15:04:05"))
-	builder.WriteString("\n")
+
+	builder.WriteString("\nSync committee period ")
+	builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriod))
+	builder.WriteString("\n  Sync committee period start ")
+	builder.WriteString(data.syncCommitteePeriodStart.Format("2006-01-02 15:04:05"))
+	builder.WriteString(" (epoch ")
+	builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochStart))
+	builder.WriteString(")\n  Sync committee period end ")
+	builder.WriteString(data.syncCommitteePeriodEnd.Format("2006-01-02 15:04:05"))
+	builder.WriteString(" (epoch ")
+	builder.WriteString(fmt.Sprintf("%d", data.syncCommitteePeriodEpochEnd))
+	builder.WriteString(")\n")
 
 	return builder.String(), nil
 }

cmd/chain/time/process.go

@@ -19,7 +19,7 @@ import (
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
 )
@@ -41,6 +41,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
 	slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
+	epochsPerSyncCommitteePeriod := config["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"].(uint64)
 	genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain genesis data")
@@ -59,15 +60,15 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse slot")
 		}
-		results.slot = spec.Slot(slot)
+		results.slot = phase0.Slot(slot)
 	case data.epoch != "":
 		epoch, err := strconv.ParseUint(data.epoch, 10, 64)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse epoch")
 		}
-		results.slot = spec.Slot(epoch * slotsPerEpoch)
+		results.slot = phase0.Slot(epoch * slotsPerEpoch)
 	case data.timestamp != "":
-		timestamp, err := time.Parse("2006-01-02T15:04:05", data.timestamp)
+		timestamp, err := time.Parse("2006-01-02T15:04:05-0700", data.timestamp)
 		if err != nil {
 			return nil, errors.Wrap(err, "failed to parse timestamp")
 		}
@@ -75,15 +76,20 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		if secs < 0 {
 			return nil, errors.New("timestamp prior to genesis")
 		}
-		results.slot = spec.Slot(secs / slotDuration)
+		results.slot = phase0.Slot(secs / slotDuration)
 	}
 
 	// Fill in the info given the slot.
 	results.slotStart = genesis.GenesisTime.Add(time.Duration(results.slot) * slotDuration)
 	results.slotEnd = genesis.GenesisTime.Add(time.Duration(results.slot+1) * slotDuration)
-	results.epoch = spec.Epoch(uint64(results.slot) / slotsPerEpoch)
+	results.epoch = phase0.Epoch(uint64(results.slot) / slotsPerEpoch)
 	results.epochStart = genesis.GenesisTime.Add(time.Duration(uint64(results.epoch)*slotsPerEpoch) * slotDuration)
 	results.epochEnd = genesis.GenesisTime.Add(time.Duration(uint64(results.epoch+1)*slotsPerEpoch) * slotDuration)
+	results.syncCommitteePeriod = uint64(results.epoch) / epochsPerSyncCommitteePeriod
+	results.syncCommitteePeriodEpochStart = phase0.Epoch(results.syncCommitteePeriod * epochsPerSyncCommitteePeriod)
+	results.syncCommitteePeriodEpochEnd = phase0.Epoch((results.syncCommitteePeriod+1)*epochsPerSyncCommitteePeriod) - 1
+	results.syncCommitteePeriodStart = genesis.GenesisTime.Add(time.Duration(uint64(results.syncCommitteePeriodEpochStart)*slotsPerEpoch) * slotDuration)
+	results.syncCommitteePeriodEnd = genesis.GenesisTime.Add(time.Duration(uint64(results.syncCommitteePeriodEpochEnd)*slotsPerEpoch) * slotDuration)
 
 	return results, nil
 }

cmd/chain/time/process_internal_test.go

@@ -15,6 +15,7 @@ package chaintime
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"testing"
 	"time"
@@ -46,11 +47,16 @@ func TestProcess(t *testing.T) {
 				slot:                     "1",
 			},
 			expected: &dataOut{
-				epochStart: time.Unix(1606824023, 0),
-				epochEnd:   time.Unix(1606824407, 0),
-				slot:       1,
-				slotStart:  time.Unix(1606824035, 0),
-				slotEnd:    time.Unix(1606824047, 0),
+				epochStart:                    time.Unix(1606824023, 0),
+				epochEnd:                      time.Unix(1606824407, 0),
+				slot:                          1,
+				slotStart:                     time.Unix(1606824035, 0),
+				slotEnd:                       time.Unix(1606824047, 0),
+				syncCommitteePeriod:           0,
+				syncCommitteePeriodStart:      time.Unix(1606824023, 0),
+				syncCommitteePeriodEnd:        time.Unix(1606921943, 0),
+				syncCommitteePeriodEpochStart: 0,
+				syncCommitteePeriodEpochEnd:   255,
 			},
 		},
 		{
@@ -62,12 +68,17 @@ func TestProcess(t *testing.T) {
 				epoch:                    "2",
 			},
 			expected: &dataOut{
-				epoch:      2,
-				epochStart: time.Unix(1606824791, 0),
-				epochEnd:   time.Unix(1606825175, 0),
-				slot:       64,
-				slotStart:  time.Unix(1606824791, 0),
-				slotEnd:    time.Unix(1606824803, 0),
+				epoch:                         2,
+				epochStart:                    time.Unix(1606824791, 0),
+				epochEnd:                      time.Unix(1606825175, 0),
+				slot:                          64,
+				slotStart:                     time.Unix(1606824791, 0),
+				slotEnd:                       time.Unix(1606824803, 0),
+				syncCommitteePeriod:           0,
+				syncCommitteePeriodStart:      time.Unix(1606824023, 0),
+				syncCommitteePeriodEnd:        time.Unix(1606921943, 0),
+				syncCommitteePeriodEpochStart: 0,
+				syncCommitteePeriodEpochEnd:   255,
 			},
 		},
 		{
@@ -76,15 +87,20 @@ func TestProcess(t *testing.T) {
 				connection:               os.Getenv("ETHDO_TEST_CONNECTION"),
 				timeout:                  10 * time.Second,
 				allowInsecureConnections: true,
-				timestamp:                "2021-01-01T00:00:00",
+				timestamp:                "2021-01-01T00:00:00+0000",
 			},
 			expected: &dataOut{
-				epoch:      6862,
-				epochStart: time.Unix(1609459031, 0),
-				epochEnd:   time.Unix(1609459415, 0),
-				slot:       219598,
-				slotStart:  time.Unix(1609459199, 0),
-				slotEnd:    time.Unix(1609459211, 0),
+				epoch:                         6862,
+				epochStart:                    time.Unix(1609459031, 0),
+				epochEnd:                      time.Unix(1609459415, 0),
+				slot:                          219598,
+				slotStart:                     time.Unix(1609459199, 0),
+				slotEnd:                       time.Unix(1609459211, 0),
+				syncCommitteePeriod:           26,
+				syncCommitteePeriodStart:      time.Unix(1609379927, 0),
+				syncCommitteePeriodEnd:        time.Unix(1609477847, 0),
+				syncCommitteePeriodEpochStart: 6656,
+				syncCommitteePeriodEpochEnd:   6911,
 			},
 		},
 	}
@@ -96,6 +112,7 @@ func TestProcess(t *testing.T) {
 				require.EqualError(t, err, test.err)
 			} else {
 				require.NoError(t, err)
+				fmt.Printf("****** %d %d\n", res.syncCommitteePeriodStart.Unix(), res.syncCommitteePeriodEnd.Unix())
 				require.Equal(t, test.expected, res)
 			}
 		})

cmd/chain/verify/signedcontributionandproof/command.go

@@ -0,0 +1,86 @@
+// Copyright © 2021 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 chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	api "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Input.
+	data string
+	item *altair.SignedContributionAndProof
+
+	// Data access.
+	eth2Client         eth2client.Service
+	validatorsProvider eth2client.ValidatorsProvider
+
+	// Data.
+	spec          map[string]interface{}
+	validator     *api.Validator
+	syncCommittee *api.SyncCommittee
+
+	// Output.
+	itemStructureValid                       bool
+	validatorKnown                           bool
+	validatorInSyncCommittee                 bool
+	validatorIsAggregator                    bool
+	contributionSignatureValidFormat         bool
+	contributionAndProofSignatureValidFormat bool
+	contributionAndProofSignatureValid       bool
+	additionalInfo                           string
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	if viper.GetString("data") == "" {
+		return nil, errors.New("data is required")
+	}
+	c.data = viper.GetString("data")
+
+	if viper.GetString("connection") == "" {
+		return nil, errors.New("connection is required")
+	}
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	return c, nil
+}

cmd/chain/verify/signedcontributionandproof/command_internal_test.go

@@ -0,0 +1,80 @@
+// Copyright © 2021 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 chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "DataMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "data is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"data":    "{}",
+			},
+			err: "connection is required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"data":       "{}",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			_, err := newCommand(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/chain/verify/signedcontributionandproof/output.go

@@ -0,0 +1,127 @@
+// Copyright © 2021 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 chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"strings"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	builder := strings.Builder{}
+
+	builder.WriteString("Valid data structure: ")
+	if c.itemStructureValid {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Validator known: ")
+	if c.validatorKnown {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Validator in sync committee: ")
+	if c.validatorInSyncCommittee {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Validator is aggregator: ")
+	if c.validatorIsAggregator {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Contribution signature has valid format: ")
+	if c.contributionSignatureValidFormat {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Contribution and proof signature has valid format: ")
+	if c.contributionAndProofSignatureValidFormat {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	builder.WriteString("Contribution and proof signature is valid: ")
+	if c.contributionAndProofSignatureValid {
+		builder.WriteString("✓\n")
+	} else {
+		builder.WriteString("✕")
+		if c.additionalInfo != "" {
+			builder.WriteString(" (")
+			builder.WriteString(c.additionalInfo)
+			builder.WriteString(")")
+		}
+		builder.WriteString("\n")
+		return builder.String(), nil
+	}
+
+	return builder.String(), nil
+}

cmd/chain/verify/signedcontributionandproof/process.go

@@ -0,0 +1,303 @@
+// Copyright © 2021 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 chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"os"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/util"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Parse the data.
+	if c.data == "" {
+		return errors.New("no data supplied")
+	}
+	c.item = &altair.SignedContributionAndProof{}
+	err := json.Unmarshal([]byte(c.data), c.item)
+	if err != nil {
+		c.additionalInfo = err.Error()
+		return nil
+	}
+	c.itemStructureValid = true
+
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	for _, validatorIndex := range c.syncCommittee.Validators {
+		if validatorIndex == c.item.Message.AggregatorIndex {
+			c.validatorInSyncCommittee = true
+			break
+		}
+	}
+	if !c.validatorInSyncCommittee {
+		return nil
+	}
+
+	// Ensure the validator is an aggregator.
+	isAggregator, err := c.isAggregator(ctx)
+	if err != nil {
+		return errors.Wrap(err, "failed to ascertain if sync committee member is aggregator")
+	}
+	if !isAggregator {
+		return nil
+	}
+	c.validatorIsAggregator = true
+
+	// Confirm the contribution signature.
+	if err := c.confirmContributionSignature(ctx); err != nil {
+		return errors.Wrap(err, "failed to confirm the contribution signature")
+	}
+
+	// Confirm the contribution and proof signature.
+	if err := c.confirmContributionAndProofSignature(ctx); err != nil {
+		return errors.Wrap(err, "failed to confirm the contribution and proof signature")
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to beacon node")
+	}
+
+	// Obtain the validator.
+	var isProvider bool
+	c.validatorsProvider, isProvider = c.eth2Client.(eth2client.ValidatorsProvider)
+	if !isProvider {
+		return errors.New("connection does not provide validator information")
+	}
+
+	stateID := fmt.Sprintf("%d", c.item.Message.Contribution.Slot)
+	validators, err := c.validatorsProvider.Validators(ctx,
+		stateID,
+		[]phase0.ValidatorIndex{c.item.Message.AggregatorIndex},
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validator information")
+	}
+
+	if len(validators) == 0 || validators[c.item.Message.AggregatorIndex] == nil {
+		return nil
+	}
+	c.validatorKnown = true
+	c.validator = validators[c.item.Message.AggregatorIndex]
+
+	// Obtain the sync committee
+	syncCommitteesProvider, isProvider := c.eth2Client.(eth2client.SyncCommitteesProvider)
+	if !isProvider {
+		return errors.New("connection does not provide sync committee information")
+	}
+	c.syncCommittee, err = syncCommitteesProvider.SyncCommittee(ctx, stateID)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain sync committee information")
+	}
+
+	return nil
+}
+
+// isAggregator returns true if the given
+func (c *command) isAggregator(ctx context.Context) (bool, error) {
+	// Calculate the modulo.
+	specProvider, isProvider := c.eth2Client.(eth2client.SpecProvider)
+	if !isProvider {
+		return false, errors.New("connection does not provide spec information")
+	}
+	var err error
+	c.spec, err = specProvider.Spec(ctx)
+	if err != nil {
+		return false, errors.Wrap(err, "failed to obtain spec information")
+	}
+
+	tmp, exists := c.spec["SYNC_COMMITTEE_SIZE"]
+	if !exists {
+		return false, errors.New("spec does not contain SYNC_COMMITTEE_SIZE")
+	}
+	if _, isUint64 := tmp.(uint64); !isUint64 {
+		return false, errors.New("spec returned non-integer value for SYNC_COMMITTEE_SIZE")
+	}
+	syncCommitteeSize := tmp.(uint64)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "sync committee size is %d\n", syncCommitteeSize)
+	}
+
+	tmp, exists = c.spec["SYNC_COMMITTEE_SUBNET_COUNT"]
+	if !exists {
+		return false, errors.New("spec does not contain SYNC_COMMITTEE_SUBNET_COUNT")
+	}
+	if _, isUint64 := tmp.(uint64); !isUint64 {
+		return false, errors.New("spec returned non-integer value for SYNC_COMMITTEE_SUBNET_COUNT")
+	}
+	syncCommitteeSubnetCount := tmp.(uint64)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "sync committee subnet count is %d\n", syncCommitteeSubnetCount)
+	}
+
+	tmp, exists = c.spec["TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE"]
+	if !exists {
+		return false, errors.New("spec does not contain TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE")
+	}
+	if _, isUint64 := tmp.(uint64); !isUint64 {
+		return false, errors.New("spec returned non-integer value for TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE")
+	}
+	targetAggregatorsPerSyncSubcommittee := tmp.(uint64)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "target aggregators per sync subcommittee is %d\n", targetAggregatorsPerSyncSubcommittee)
+	}
+
+	modulo := syncCommitteeSize / syncCommitteeSubnetCount / targetAggregatorsPerSyncSubcommittee
+	if modulo < 1 {
+		modulo = 1
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "modulo is %d\n", modulo)
+	}
+
+	// Hash the selection proof.
+	sigHash := sha256.New()
+	n, err := sigHash.Write(c.item.Message.SelectionProof[:])
+	if err != nil {
+		return false, errors.Wrap(err, "failed to hash the selection proof")
+	}
+	if n != len(c.item.Signature[:]) {
+		return false, errors.New("failed to write all bytes of the selection proof to the hash")
+	}
+	hash := sigHash.Sum(nil)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "hash of selection proof is %#x\n", hash)
+	}
+
+	return binary.LittleEndian.Uint64(hash[:8])%modulo == 0, nil
+}
+
+func (c *command) confirmContributionSignature(ctx context.Context) error {
+	sigBytes := make([]byte, 96)
+	copy(sigBytes, c.item.Message.Contribution.Signature[:])
+	_, err := e2types.BLSSignatureFromBytes(sigBytes)
+	if err != nil {
+		c.additionalInfo = err.Error()
+		return nil
+	}
+	c.contributionSignatureValidFormat = true
+
+	subCommittee := c.syncCommittee.ValidatorAggregates[c.item.Message.Contribution.SubcommitteeIndex]
+	includedIndices := make([]phase0.ValidatorIndex, 0, len(subCommittee))
+	for i := uint64(0); i < c.item.Message.Contribution.AggregationBits.Len(); i++ {
+		if c.item.Message.Contribution.AggregationBits.BitAt(i) {
+			includedIndices = append(includedIndices, subCommittee[int(i)])
+		}
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Contribution validator indices: %v (%d)\n", includedIndices, len(includedIndices))
+	}
+
+	includedValidators, err := c.validatorsProvider.Validators(ctx, "head", includedIndices)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain subcommittee validators")
+	}
+	if len(includedValidators) == 0 {
+		return errors.New("obtained empty subcommittee validator list")
+	}
+
+	var aggregatePubKey *e2types.BLSPublicKey
+	for _, v := range includedValidators {
+		pubKeyBytes := make([]byte, 48)
+		copy(pubKeyBytes, v.Validator.PublicKey[:])
+		pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)
+		if err != nil {
+			return errors.Wrap(err, "failed to aggregate public key")
+		}
+		if aggregatePubKey == nil {
+			aggregatePubKey = pubKey
+		} else {
+			aggregatePubKey.Aggregate(pubKey)
+		}
+	}
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "Aggregate public key is %#x\n", aggregatePubKey.Marshal())
+	}
+
+	// Don't have the ability to carry out the batch verification at current.
+
+	return nil
+}
+
+func (c *command) confirmContributionAndProofSignature(ctx context.Context) error {
+	sigBytes := make([]byte, 96)
+	copy(sigBytes, c.item.Signature[:])
+	sig, err := e2types.BLSSignatureFromBytes(sigBytes)
+	if err != nil {
+		c.additionalInfo = err.Error()
+		return nil
+	}
+	c.contributionAndProofSignatureValidFormat = true
+
+	pubKeyBytes := make([]byte, 48)
+	copy(pubKeyBytes, c.validator.Validator.PublicKey[:])
+	pubKey, err := e2types.BLSPublicKeyFromBytes(pubKeyBytes)
+	if err != nil {
+		return errors.Wrap(err, "failed to configure public key")
+	}
+
+	objectRoot, err := c.item.Message.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain signging root")
+	}
+
+	tmp, exists := c.spec["DOMAIN_CONTRIBUTION_AND_PROOF"]
+	if !exists {
+		return errors.New("spec does not contain DOMAIN_CONTRIBUTION_AND_PROOF")
+	}
+	if _, isUint64 := tmp.(phase0.DomainType); !isUint64 {
+		return errors.New("spec returned non-domain type value for DOMAIN_CONTRIBUTION_AND_PROOF")
+	}
+	contributionAndProofDomainType := tmp.(phase0.DomainType)
+	if c.debug {
+		fmt.Fprintf(os.Stderr, "contribution and proof domain type is %#x\n", contributionAndProofDomainType)
+	}
+	domain, err := c.eth2Client.(eth2client.DomainProvider).Domain(ctx, contributionAndProofDomainType, phase0.Epoch(c.item.Message.Contribution.Slot/32))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain domain")
+	}
+
+	container := &phase0.SigningData{
+		ObjectRoot: objectRoot,
+		Domain:     domain,
+	}
+	signingRoot, err := container.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain signging root")
+	}
+
+	c.contributionAndProofSignatureValid = sig.Verify(signingRoot[:], pubKey)
+
+	return nil
+}

cmd/chain/verify/signedcontributionandproof/process_internal_test.go

@@ -0,0 +1,62 @@
+// Copyright © 2021 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 chainverifysignedcontributionandproof
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "InvalidData",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"data":       "[[",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/chain/verify/signedcontributionandproof/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 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 chainverifysignedcontributionandproof
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/chaininfo.go

@@ -46,6 +46,9 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 		genesis, err := eth2Client.(eth2client.GenesisProvider).Genesis(ctx)
 		errCheck(err, "Failed to obtain beacon chain genesis")
 
+		fork, err := eth2Client.(eth2client.ForkProvider).Fork(ctx, "head")
+		errCheck(err, "Failed to obtain current fork")
+
 		if quiet {
 			os.Exit(_exitSuccess)
 		}
@@ -57,7 +60,20 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 			outputIf(verbose, fmt.Sprintf("Genesis timestamp: %v", genesis.GenesisTime.Unix()))
 		}
 		fmt.Printf("Genesis validators root: %#x\n", genesis.GenesisValidatorsRoot)
-		fmt.Printf("Genesis fork version: %x\n", config["GENESIS_FORK_VERSION"].(spec.Version))
+		fmt.Printf("Genesis fork version: %#x\n", config["GENESIS_FORK_VERSION"].(spec.Version))
+		fmt.Printf("Current fork version: %#x\n", fork.CurrentVersion)
+		if verbose {
+			forkData := &spec.ForkData{
+				CurrentVersion:        fork.CurrentVersion,
+				GenesisValidatorsRoot: genesis.GenesisValidatorsRoot,
+			}
+			forkDataRoot, err := forkData.HashTreeRoot()
+			if err == nil {
+				var forkDigest spec.ForkDigest
+				copy(forkDigest[:], forkDataRoot[:])
+				fmt.Printf("Fork digest: %#x\n", forkDigest)
+			}
+		}
 		fmt.Printf("Seconds per slot: %d\n", int(config["SECONDS_PER_SLOT"].(time.Duration).Seconds()))
 		fmt.Printf("Slots per epoch: %d\n", config["SLOTS_PER_EPOCH"].(uint64))
 
@@ -69,18 +85,3 @@ func init() {
 	chainCmd.AddCommand(chainInfoCmd)
 	chainFlags(chainInfoCmd)
 }
-
-func timestampToSlot(genesis time.Time, timestamp time.Time, secondsPerSlot time.Duration) spec.Slot {
-	if timestamp.Unix() < genesis.Unix() {
-		return 0
-	}
-	return spec.Slot(uint64(timestamp.Unix()-genesis.Unix()) / uint64(secondsPerSlot.Seconds()))
-}
-
-func slotToTimestamp(genesis time.Time, slot spec.Slot, slotDuration time.Duration) int64 {
-	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())
-}
-
-func epochToTimestamp(genesis time.Time, slot spec.Slot, slotDuration time.Duration, slotsPerEpoch uint64) int64 {
-	return genesis.Unix() + int64(slot)*int64(slotDuration.Seconds())*int64(slotsPerEpoch)
-}

cmd/chainstatus.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2021 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
@@ -17,12 +17,13 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
-	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
 	"github.com/wealdtech/ethdo/util"
 )
 
@@ -40,52 +41,116 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		eth2Client, err := util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
-		specProvider, isProvider := eth2Client.(eth2client.SpecProvider)
-		assert(isProvider, "beacon node does not provide spec; cannot report on chain status")
-		config, err := specProvider.Spec(ctx)
-		errCheck(err, "Failed to obtain beacon chain specification")
+		chainTime, err := standardchaintime.New(ctx,
+			standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+			standardchaintime.WithForkScheduleProvider(eth2Client.(eth2client.ForkScheduleProvider)),
+			standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+		)
+		errCheck(err, "Failed to configure chaintime service")
 
 		finalityProvider, isProvider := eth2Client.(eth2client.FinalityProvider)
 		assert(isProvider, "beacon node does not provide finality; cannot report on chain status")
 		finality, err := finalityProvider.Finality(ctx, "head")
 		errCheck(err, "Failed to obtain finality information")
 
-		genesisProvider, isProvider := eth2Client.(eth2client.GenesisProvider)
-		assert(isProvider, "beacon node does not provide genesis; cannot report on chain status")
-		genesis, err := genesisProvider.Genesis(ctx)
-		errCheck(err, "Failed to obtain genesis information")
+		slot := chainTime.CurrentSlot()
 
-		slotDuration := config["SECONDS_PER_SLOT"].(time.Duration)
-		curSlot := timestampToSlot(genesis.GenesisTime, time.Now(), slotDuration)
-		slotsPerEpoch := config["SLOTS_PER_EPOCH"].(uint64)
-		curEpoch := spec.Epoch(uint64(curSlot) / slotsPerEpoch)
-		fmt.Printf("Current epoch: %d\n", curEpoch)
-		fmt.Printf("Justified epoch: %d\n", finality.Justified.Epoch)
-		if verbose {
-			distance := curEpoch - finality.Justified.Epoch
-			fmt.Printf("Justified epoch distance: %d\n", distance)
-		}
-		fmt.Printf("Finalized epoch: %d\n", finality.Finalized.Epoch)
-		if verbose {
-			distance := curEpoch - finality.Finalized.Epoch
-			fmt.Printf("Finalized epoch distance: %d\n", distance)
-		}
-		if verbose {
-			fmt.Printf("Prior justified epoch: %d\n", finality.PreviousJustified.Epoch)
-			distance := curEpoch - finality.PreviousJustified.Epoch
-			fmt.Printf("Prior justified epoch distance: %d\n", distance)
-		}
+		nextSlot := slot + 1
+		nextSlotTimestamp := chainTime.StartOfSlot(nextSlot)
+
+		epoch := chainTime.CurrentEpoch()
+		epochStartSlot := chainTime.FirstSlotOfEpoch(epoch)
+		epochEndSlot := chainTime.FirstSlotOfEpoch(epoch+1) - 1
+
+		nextEpoch := epoch + 1
+		nextEpochStartSlot := chainTime.FirstSlotOfEpoch(nextEpoch)
+		nextEpochTimestamp := chainTime.StartOfEpoch(nextEpoch)
+
+		res := strings.Builder{}
+
+		res.WriteString("Current slot: ")
+		res.WriteString(fmt.Sprintf("%d", slot))
+		res.WriteString("\n")
+
+		res.WriteString("Current epoch: ")
+		res.WriteString(fmt.Sprintf("%d", epoch))
+		res.WriteString("\n")
 
 		if verbose {
-			epochStartSlot := (uint64(curSlot) / slotsPerEpoch) * slotsPerEpoch
-			fmt.Printf("Epoch slots: %d-%d\n", epochStartSlot, epochStartSlot+slotsPerEpoch-1)
-			nextSlotTimestamp := slotToTimestamp(genesis.GenesisTime, curSlot+1, slotDuration)
-			fmt.Printf("Time until next slot: %2.1fs\n", float64(time.Until(time.Unix(nextSlotTimestamp, 0)).Milliseconds())/1000)
-			nextEpoch := epochToTimestamp(genesis.GenesisTime, spec.Slot(uint64(curSlot)/slotsPerEpoch+1), slotDuration, slotsPerEpoch)
-			fmt.Printf("Slots until next epoch: %d\n", (uint64(curSlot)/slotsPerEpoch+1)*slotsPerEpoch-uint64(curSlot))
-			fmt.Printf("Time until next epoch: %2.1fs\n", float64(time.Until(time.Unix(nextEpoch, 0)).Milliseconds())/1000)
+			res.WriteString("Epoch slots: ")
+			res.WriteString(fmt.Sprintf("%d", epochStartSlot))
+			res.WriteString("-")
+			res.WriteString(fmt.Sprintf("%d", epochEndSlot))
+			res.WriteString("\n")
 		}
 
+		res.WriteString("Time until next slot: ")
+		res.WriteString(time.Until(nextSlotTimestamp).Round(time.Second).String())
+		res.WriteString("\n")
+
+		res.WriteString("Time until next epoch: ")
+		res.WriteString(time.Until(nextEpochTimestamp).Round(time.Second).String())
+		res.WriteString("\n")
+
+		res.WriteString("Slots until next epoch: ")
+		res.WriteString(fmt.Sprintf("%d", nextEpochStartSlot-slot))
+		res.WriteString("\n")
+
+		res.WriteString("Justified epoch: ")
+		res.WriteString(fmt.Sprintf("%d", finality.Justified.Epoch))
+		res.WriteString("\n")
+		if verbose {
+			distance := epoch - finality.Justified.Epoch
+			res.WriteString("Justified epoch distance: ")
+			res.WriteString(fmt.Sprintf("%d", distance))
+			res.WriteString("\n")
+		}
+
+		res.WriteString("Finalized epoch: ")
+		res.WriteString(fmt.Sprintf("%d", finality.Finalized.Epoch))
+		res.WriteString("\n")
+		if verbose {
+			distance := epoch - finality.Finalized.Epoch
+			res.WriteString("Finalized epoch distance: ")
+			res.WriteString(fmt.Sprintf("%d", distance))
+			res.WriteString("\n")
+		}
+
+		if epoch >= chainTime.AltairInitialEpoch() {
+			period := chainTime.SlotToSyncCommitteePeriod(slot)
+			periodStartEpoch := chainTime.FirstEpochOfSyncPeriod(period)
+			periodStartSlot := chainTime.FirstSlotOfEpoch(periodStartEpoch)
+			nextPeriod := period + 1
+			nextPeriodStartEpoch := chainTime.FirstEpochOfSyncPeriod(nextPeriod)
+			periodEndEpoch := nextPeriodStartEpoch - 1
+			periodEndSlot := chainTime.FirstSlotOfEpoch(periodEndEpoch+1) - 1
+			nextPeriodTimestamp := chainTime.StartOfEpoch(nextPeriodStartEpoch)
+
+			res.WriteString("Sync committee period: ")
+			res.WriteString(fmt.Sprintf("%d", period))
+			res.WriteString("\n")
+
+			if verbose {
+				res.WriteString("Sync committee epochs: ")
+				res.WriteString(fmt.Sprintf("%d", periodStartEpoch))
+				res.WriteString("-")
+				res.WriteString(fmt.Sprintf("%d", periodEndEpoch))
+				res.WriteString("\n")
+
+				res.WriteString("Sync committee slots: ")
+				res.WriteString(fmt.Sprintf("%d", periodStartSlot))
+				res.WriteString("-")
+				res.WriteString(fmt.Sprintf("%d", periodEndSlot))
+				res.WriteString("\n")
+
+				res.WriteString("Time until next sync committee period: ")
+				res.WriteString(time.Until(nextPeriodTimestamp).Round(time.Second).String())
+				res.WriteString("\n")
+			}
+		}
+
+		fmt.Print(res.String())
+
 		os.Exit(_exitSuccess)
 	},
 }

cmd/chaintime.go

@@ -44,7 +44,7 @@ func init() {
 	chainFlags(chainTimeCmd)
 	chainTimeCmd.Flags().String("slot", "", "The slot for which to obtain information")
 	chainTimeCmd.Flags().String("epoch", "", "The epoch for which to obtain information")
-	chainTimeCmd.Flags().String("timestamp", "", "The timestamp for which to obtain information (format YYYY-MM-DDTHH:MM:SS)")
+	chainTimeCmd.Flags().String("timestamp", "", "The timestamp for which to obtain information (format YYYY-MM-DDTHH:MM:SS+ZZZZ)")
 }
 
 func chainTimeBindings() {

cmd/chainverify.go

@@ -0,0 +1,45 @@
+// Copyright © 2021 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"
+	"github.com/spf13/viper"
+)
+
+// chainVerifyCmd represents the chain verify command
+var chainVerifyCmd = &cobra.Command{
+	Use:   "verify",
+	Short: "Verify a beacon chain signature",
+	Long:  "Verify the signature for a given beacon chain structure is correct",
+}
+
+func init() {
+	chainCmd.AddCommand(chainVerifyCmd)
+}
+
+func chainVerifyFlags(cmd *cobra.Command) {
+	chainFlags(cmd)
+	cmd.Flags().String("validator", "", "The account, public key or index of the validator")
+	cmd.Flags().String("data", "", "The data to verify, as a JSON structure")
+}
+
+func chainVerifyBindings(cmd *cobra.Command) {
+	if err := viper.BindPFlag("validator", cmd.Flags().Lookup("validator")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("data", cmd.Flags().Lookup("data")); err != nil {
+		panic(err)
+	}
+}

cmd/chainverifysignedcontributionandproof.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	chainverifysignedcontributionandproof "github.com/wealdtech/ethdo/cmd/chain/verify/signedcontributionandproof"
+)
+
+var chainVerifySignedContributionAndProofCmd = &cobra.Command{
+	Use:   "signedcontributionandproof",
+	Short: "Verify a signed contribution and proof",
+	Long: `Verify a signed contribution and proof.  For example:
+
+    ethdo chain verify signedcontributionandproof --data=... --validator=...
+
+validator can be an account, a public key or an index.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := chainverifysignedcontributionandproof.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Print(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	chainVerifyCmd.AddCommand(chainVerifySignedContributionAndProofCmd)
+	chainVerifyFlags(chainVerifySignedContributionAndProofCmd)
+}
+
+func chainVerifySignedContributionAndProofBindings(cmd *cobra.Command) {
+	chainVerifyBindings(cmd)
+}

cmd/node/events/input.go

@@ -52,7 +52,7 @@ func input(ctx context.Context) (*dataIn, error) {
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
 	return data, nil

cmd/node/events/input_internal_test.go

@@ -66,7 +66,7 @@ func TestInput(t *testing.T) {
 			vars: map[string]interface{}{
 				"timeout": "5s",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 		{
 			name: "ConnectionBad",
@@ -75,7 +75,7 @@ func TestInput(t *testing.T) {
 				"connection": "localhost:1",
 				"topics":     []string{"one", "two"},
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 		{
 			name: "TopicsNil",

cmd/root.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 Weald Technology Trading
+// Copyright © 2019 - 2021 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
@@ -23,6 +23,7 @@ import (
 
 	homedir "github.com/mitchellh/go-homedir"
 	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
@@ -56,12 +57,28 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 		return nil
 	}
 
+	// Disable service logging.
+	zerolog.SetGlobalLevel(zerolog.Disabled)
+
 	// We bind viper here so that we bind to the correct command.
 	quiet = viper.GetBool("quiet")
 	verbose = viper.GetBool("verbose")
 	debug = viper.GetBool("debug")
-	// Command-specific bindings.
-	switch fmt.Sprintf("%s/%s", cmd.Parent().Name(), cmd.Name()) {
+
+	includeCommandBindings(cmd)
+
+	if quiet && verbose {
+		fmt.Println("Cannot supply both quiet and verbose flags")
+	}
+	if quiet && debug {
+		fmt.Println("Cannot supply both quiet and debug flags")
+	}
+
+	return util.SetupStore()
+}
+
+func includeCommandBindings(cmd *cobra.Command) {
+	switch commandPath(cmd) {
 	case "account/create":
 		accountCreateBindings()
 	case "account/derive":
@@ -72,16 +89,24 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 		attesterDutiesBindings()
 	case "attester/inclusion":
 		attesterInclusionBindings()
+	case "block/analyze":
+		blockAnalyzeBindings()
 	case "block/info":
 		blockInfoBindings()
 	case "chain/time":
 		chainTimeBindings()
+	case "chain/verify/signedcontributionandproof":
+		chainVerifySignedContributionAndProofBindings(cmd)
 	case "exit/verify":
 		exitVerifyBindings()
 	case "node/events":
 		nodeEventsBindings()
 	case "slot/time":
 		slotTimeBindings()
+	case "synccommittee/inclusion":
+		synccommitteeInclusionBindings()
+	case "synccommittee/members":
+		synccommitteeMembersBindings()
 	case "validator/depositdata":
 		validatorDepositdataBindings()
 	case "validator/duties":
@@ -92,24 +117,17 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 		validatorInfoBindings()
 	case "validator/keycheck":
 		validatorKeycheckBindings()
+	case "validator/expectation":
+		validatorExpectationBindings()
 	case "wallet/create":
 		walletCreateBindings()
 	case "wallet/import":
 		walletImportBindings()
+	case "wallet/sharedexport":
+		walletSharedExportBindings()
+	case "wallet/sharedimport":
+		walletSharedImportBindings()
 	}
-
-	if quiet && verbose {
-		fmt.Println("Cannot supply both quiet and verbose flags")
-	}
-	if quiet && debug {
-		fmt.Println("Cannot supply both quiet and debug flags")
-	}
-
-	if err := util.SetupStore(); err != nil {
-		return err
-	}
-
-	return nil
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.
@@ -191,7 +209,7 @@ func init() {
 	if err := viper.BindPFlag("debug", RootCmd.PersistentFlags().Lookup("debug")); err != nil {
 		panic(err)
 	}
-	RootCmd.PersistentFlags().String("connection", "localhost:4000", "connection to an Ethereum 2 node")
+	RootCmd.PersistentFlags().String("connection", "http://localhost:3500", "URL to an Ethereum 2 node's RET API endpoint")
 	if err := viper.BindPFlag("connection", RootCmd.PersistentFlags().Lookup("connection")); err != nil {
 		panic(err)
 	}
@@ -383,3 +401,14 @@ func remotesToEndpoints(remotes []string) ([]*dirk.Endpoint, error) {
 func relockAccount(locker e2wtypes.AccountLocker) {
 	errCheck(locker.Lock(context.Background()), "failed to re-lock account")
 }
+
+func commandPath(cmd *cobra.Command) string {
+	path := ""
+	for {
+		path = fmt.Sprintf("%s/%s", cmd.Name(), path)
+		if cmd.Parent().Name() == "ethdo" {
+			return strings.TrimRight(path, "/")
+		}
+		cmd = cmd.Parent()
+	}
+}

cmd/slot/time/input.go

@@ -54,7 +54,7 @@ func input(ctx context.Context) (*dataIn, error) {
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+		return nil, err
 	}
 
 	return data, nil

cmd/slot/time/input_internal_test.go

@@ -73,7 +73,7 @@ func TestInput(t *testing.T) {
 				"timeout": "5s",
 				"slot":    "1",
 			},
-			err: "failed to connect to Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
 		},
 	}
 

cmd/synccommittee.go

@@ -0,0 +1,32 @@
+// Copyright © 2021 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"
+)
+
+// synccommitteeCmd represents the synccommittee command
+var synccommitteeCmd = &cobra.Command{
+	Use:   "synccommittee",
+	Short: "Obtain information about Ethereum 2 sync committees",
+	Long:  "Obtain information about Ethereum 2 sync committees",
+}
+
+func init() {
+	RootCmd.AddCommand(synccommitteeCmd)
+}
+
+func synccommitteeFlags(cmd *cobra.Command) {
+}

cmd/synccommittee/inclusion/command.go

@@ -0,0 +1,83 @@
+// Copyright © 2022 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 inclusion
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Input.
+	account string
+	pubKey  string
+	index   string
+	epoch   int64
+
+	// Data access.
+	eth2Client eth2client.Service
+	chainTime  chaintime.Service
+
+	// Output.
+	inCommittee    bool
+	committeeIndex uint64
+	inclusions     []int
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	if viper.GetString("connection") == "" {
+		return nil, errors.New("connection is required")
+	}
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	// Validator.
+	c.account = viper.GetString("account")
+	c.pubKey = viper.GetString("pubkey")
+	c.index = viper.GetString("index")
+	if c.account == "" && c.pubKey == "" && c.index == "" {
+		return nil, errors.New("account, pubkey or index required")
+	}
+
+	// Epoch.
+	c.epoch = viper.GetInt64("epoch")
+
+	return c, nil
+}

cmd/synccommittee/inclusion/command_internal_test.go

@@ -0,0 +1,82 @@
+// Copyright © 2022 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 inclusion
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+			},
+			err: "connection is required",
+		},
+		{
+			name: "NoValidator",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "account, pubkey or index required",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+				"index":      "1",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			_, err := newCommand(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/synccommittee/inclusion/output.go

@@ -0,0 +1,81 @@
+// Copyright © 2022 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 inclusion
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	builder := strings.Builder{}
+
+	if c.verbose {
+		builder.WriteString("Epoch: ")
+		builder.WriteString(fmt.Sprintf("%d\n", c.epoch))
+	}
+
+	if !c.inCommittee {
+		builder.WriteString("Validator not in sync committee")
+	} else {
+		if c.verbose {
+			builder.WriteString("Validator sync committee index ")
+			builder.WriteString(fmt.Sprintf("%d\n", c.committeeIndex))
+		}
+
+		noBlock := 0
+		included := 0
+		missed := 0
+		for _, inclusion := range c.inclusions {
+			switch inclusion {
+			case 0:
+				noBlock++
+			case 1:
+				included++
+			case 2:
+				missed++
+			}
+		}
+		builder.WriteString("Expected: ")
+		builder.WriteString(fmt.Sprintf("%d", len(c.inclusions)))
+		builder.WriteString("\nIncluded: ")
+		builder.WriteString(fmt.Sprintf("%d", included))
+		builder.WriteString("\nMissed: ")
+		builder.WriteString(fmt.Sprintf("%d", missed))
+		builder.WriteString("\nNo block: ")
+		builder.WriteString(fmt.Sprintf("%d", noBlock))
+
+		builder.WriteString("\nPer-slot result: ")
+		for i, inclusion := range c.inclusions {
+			switch inclusion {
+			case 0:
+				builder.WriteString("-")
+			case 1:
+				builder.WriteString("✓")
+			case 2:
+				builder.WriteString("✕")
+			}
+			if i%8 == 7 && i != len(c.inclusions)-1 {
+				builder.WriteString(" ")
+			}
+		}
+	}
+
+	return builder.String(), nil
+}

cmd/synccommittee/inclusion/process.go

@@ -0,0 +1,130 @@
+// Copyright © 2022 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 inclusion
+
+import (
+	"context"
+	"fmt"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/altair"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	firstSlot, lastSlot := c.calculateSlots(ctx)
+
+	validatorIndex, err := util.ValidatorIndex(ctx, c.eth2Client, c.account, c.pubKey, c.index)
+	if err != nil {
+		return err
+	}
+
+	syncCommittee, err := c.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommitteeAtEpoch(ctx, "head", phase0.Epoch(c.epoch))
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain sync committee information")
+	}
+
+	if syncCommittee == nil {
+		return errors.New("no sync committee returned")
+	}
+
+	for i := range syncCommittee.Validators {
+		if syncCommittee.Validators[i] == validatorIndex {
+			c.inCommittee = true
+			c.committeeIndex = uint64(i)
+			break
+		}
+	}
+
+	if c.inCommittee {
+		// This validator is in the sync committee.  Check blocks to see where it has been included.
+		c.inclusions = make([]int, 0)
+		if lastSlot > c.chainTime.CurrentSlot() {
+			lastSlot = c.chainTime.CurrentSlot()
+		}
+		for slot := firstSlot; slot < lastSlot; slot++ {
+			block, err := c.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, fmt.Sprintf("%d", slot))
+			if err != nil {
+				return err
+			}
+			if block == nil {
+				c.inclusions = append(c.inclusions, 0)
+				continue
+			}
+			var aggregate *altair.SyncAggregate
+			switch block.Version {
+			case spec.DataVersionAltair:
+				aggregate = block.Altair.Message.Body.SyncAggregate
+				if aggregate.SyncCommitteeBits.BitAt(c.committeeIndex) {
+					c.inclusions = append(c.inclusions, 1)
+				} else {
+					c.inclusions = append(c.inclusions, 2)
+				}
+			case spec.DataVersionBellatrix:
+				aggregate = block.Bellatrix.Message.Body.SyncAggregate
+				if aggregate.SyncCommitteeBits.BitAt(c.committeeIndex) {
+					c.inclusions = append(c.inclusions, 1)
+				} else {
+					c.inclusions = append(c.inclusions, 2)
+				}
+			default:
+				return fmt.Errorf("unhandled block version %v", block.Version)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return err
+	}
+
+	c.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	return nil
+}
+
+func (c *command) calculateSlots(ctx context.Context) (phase0.Slot, phase0.Slot) {
+	var firstSlot phase0.Slot
+	var lastSlot phase0.Slot
+	if c.epoch == -1 {
+		c.epoch = int64(c.chainTime.CurrentEpoch()) - 1
+	}
+	firstSlot = c.chainTime.FirstSlotOfEpoch(phase0.Epoch(c.epoch))
+	lastSlot = c.chainTime.FirstSlotOfEpoch(phase0.Epoch(c.epoch) + 1)
+
+	return firstSlot, lastSlot
+}

cmd/synccommittee/inclusion/process_internal_test.go

@@ -0,0 +1,72 @@
+// Copyright © 2022 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 inclusion
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "InvalidConnection",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"index":      "1",
+				"connection": "invalid",
+			},
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"index":      "1",
+				"epoch":      "-1",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/synccommittee/inclusion/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2022 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 inclusion
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/synccommittee/members/input.go

@@ -0,0 +1,74 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/services/chaintime"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	// Operation.
+	eth2Client eth2client.Service
+	chainTime  chaintime.Service
+	epoch      int64
+	period     string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	data := &dataIn{}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	// Ethereum 2 client.
+	var err error
+	data.eth2Client, err = util.ConnectToBeaconNode(ctx, viper.GetString("connection"), viper.GetDuration("timeout"), viper.GetBool("allow-insecure-connections"))
+	if err != nil {
+		return nil, err
+	}
+
+	// Chain time.
+	data.chainTime, err = standardchaintime.New(ctx,
+		standardchaintime.WithGenesisTimeProvider(data.eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithForkScheduleProvider(data.eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithSpecProvider(data.eth2Client.(eth2client.SpecProvider)),
+	)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to configure chaintime service")
+	}
+
+	// Epoch
+	data.epoch = viper.GetInt64("epoch")
+	data.period = viper.GetString("period")
+
+	return data, nil
+}

cmd/synccommittee/members/input_internal_test.go

@@ -0,0 +1,88 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/testutil"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	testWallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	require.NoError(t, testWallet.(e2wtypes.WalletLocker).Unlock(context.Background(), nil))
+	viper.Set("passphrase", "pass")
+	_, err = testWallet.(e2wtypes.WalletAccountImporter).ImportAccount(context.Background(),
+		"Interop 0",
+		testutil.HexToBytes("0x25295f0d1d592a90b333e26e85149708208e9f8e8bc18f6c77bd62f8ad7a6866"),
+		[]byte("pass"),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "failed to connect to beacon node: failed to connect to Ethereum 2 client with any known method",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+			}
+		})
+	}
+}

cmd/synccommittee/members/output.go

@@ -0,0 +1,61 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	debug      bool
+	quiet      bool
+	verbose    bool
+	json       bool
+	validators []phase0.ValidatorIndex
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	if data.quiet {
+		return "", nil
+	}
+
+	if data.validators == nil {
+		return "No sync committee validators found", nil
+	}
+
+	if data.json {
+		bytes, err := json.Marshal(data.validators)
+		if err != nil {
+			return "", errors.Wrap(err, "failed to marshal JSON")
+		}
+		return string(bytes), nil
+	}
+
+	validators := make([]string, len(data.validators))
+	for i := range data.validators {
+		validators[i] = fmt.Sprintf("%d", data.validators[i])
+	}
+
+	return strings.Join(validators, ","), nil
+}

cmd/synccommittee/members/output_internal_test.go

@@ -0,0 +1,68 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+	"testing"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name:    "Empty",
+			dataOut: &dataOut{},
+			res:     "No sync committee validators found",
+		},
+		{
+			name: "Present",
+			dataOut: &dataOut{
+				validators: []phase0.ValidatorIndex{1, 2, 3},
+			},
+			res: "1,2,3",
+		},
+		{
+			name: "JSON",
+			dataOut: &dataOut{
+				json:       true,
+				validators: []phase0.ValidatorIndex{1, 2, 3},
+			},
+			res: "[1,2,3]",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/synccommittee/members/process.go

@@ -0,0 +1,77 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	epoch, err := calculateEpoch(ctx, data)
+	if err != nil {
+		return nil, err
+	}
+
+	syncCommittee, err := data.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommitteeAtEpoch(ctx, "head", epoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain sync committee information")
+	}
+
+	if syncCommittee == nil {
+		return nil, errors.New("no sync committee returned")
+	}
+
+	results := &dataOut{
+		debug:      data.debug,
+		quiet:      data.quiet,
+		verbose:    data.verbose,
+		validators: syncCommittee.Validators,
+	}
+
+	return results, nil
+}
+
+func calculateEpoch(ctx context.Context, data *dataIn) (phase0.Epoch, error) {
+	var epoch phase0.Epoch
+	if data.epoch != -1 {
+		epoch = phase0.Epoch(data.epoch)
+	} else {
+		switch strings.ToLower(data.period) {
+		case "", "current":
+			epoch = data.chainTime.CurrentEpoch()
+		case "next":
+			period := data.chainTime.SlotToSyncCommitteePeriod(data.chainTime.CurrentSlot())
+			nextPeriod := period + 1
+			epoch = data.chainTime.FirstEpochOfSyncPeriod(nextPeriod)
+		default:
+			return 0, fmt.Errorf("period %s not known", data.period)
+		}
+	}
+
+	if data.debug {
+		fmt.Printf("epoch is %d\n", epoch)
+	}
+
+	return epoch, nil
+}

cmd/synccommittee/members/process_internal_test.go

@@ -0,0 +1,74 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/auto"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+	eth2Client, err := auto.New(context.Background(),
+		auto.WithLogLevel(zerolog.Disabled),
+		auto.WithAddress(os.Getenv("ETHDO_TEST_CONNECTION")),
+	)
+	require.NoError(t, err)
+
+	chainTime, err := standardchaintime.New(context.Background(),
+		standardchaintime.WithGenesisTimeProvider(eth2Client.(eth2client.GenesisTimeProvider)),
+		standardchaintime.WithForkScheduleProvider(eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithSpecProvider(eth2Client.(eth2client.SpecProvider)),
+	)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				eth2Client: eth2Client,
+				chainTime:  chainTime,
+				epoch:      -1,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/synccommittee/members/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 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 members
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the wallet create data command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/synccommitteeinclusion.go

@@ -0,0 +1,67 @@
+// Copyright © 2022 Weald Technology Trading.
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	synccommitteeinclusion "github.com/wealdtech/ethdo/cmd/synccommittee/inclusion"
+)
+
+var synccommitteeInclusionCmd = &cobra.Command{
+	Use:   "inclusion",
+	Short: "Obtain sync committee inclusion data for a validator",
+	Long: `Obtain sync committee inclusion data for a validator.  For example:
+
+    ethdo synccommittee inclusion --epoch=12345 --index=11111
+
+In quiet mode this will return 0 if the validator was in the sync committee, otherwise 1.
+
+epoch can be a specific epoch; If not supplied all slots for the current sync committee period will be provided`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := synccommitteeinclusion.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	synccommitteeCmd.AddCommand(synccommitteeInclusionCmd)
+	synccommitteeFlags(synccommitteeInclusionCmd)
+	synccommitteeInclusionCmd.Flags().Int64("epoch", -1, "the epoch for which to fetch sync committee inclusion")
+	synccommitteeInclusionCmd.Flags().String("pubkey", "", "validator public key for sync committee")
+	synccommitteeInclusionCmd.Flags().String("index", "", "validator index for sync committee")
+}
+
+func synccommitteeInclusionBindings() {
+	if err := viper.BindPFlag("epoch", synccommitteeInclusionCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("pubkey", synccommitteeInclusionCmd.Flags().Lookup("pubkey")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("index", synccommitteeInclusionCmd.Flags().Lookup("index")); err != nil {
+		panic(err)
+	}
+}

cmd/synccommitteemembers.go

@@ -0,0 +1,63 @@
+// Copyright © 2021 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	synccommitteemembers "github.com/wealdtech/ethdo/cmd/synccommittee/members"
+)
+
+var synccommitteeMembersCmd = &cobra.Command{
+	Use:   "members",
+	Short: "Obtain information about members of a synccommittee",
+	Long: `Obtain information about members of a synccommittee.  For example:
+
+    ethdo synccommittee members --epoch=12345
+
+In quiet mode this will return 0 if the synccommittee members are found, otherwise 1.
+
+epoch can be a specific epoch.  period can be 'current' for the current sync period or 'next' for the next sync period`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := synccommitteemembers.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	synccommitteeCmd.AddCommand(synccommitteeMembersCmd)
+	synccommitteeFlags(synccommitteeMembersCmd)
+	synccommitteeMembersCmd.Flags().Int64("epoch", -1, "the epoch for which to fetch sync committees")
+	synccommitteeMembersCmd.Flags().String("period", "", "the sync committee period for which to fetch sync committees ('current', 'next')")
+}
+
+func synccommitteeMembersBindings() {
+	if err := viper.BindPFlag("epoch", synccommitteeMembersCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("period", synccommitteeMembersCmd.Flags().Lookup("period")); err != nil {
+		panic(err)
+	}
+}

cmd/validator/depositdata/output.go

@@ -109,6 +109,7 @@ func validatorDepositDataOutputLaunchpad(datum *dataOut) (string, error) {
 	forkVersionMap := map[spec.Version]string{
 		[4]byte{0x00, 0x00, 0x00, 0x00}: "mainnet",
 		[4]byte{0x00, 0x00, 0x20, 0x09}: "pyrmont",
+		[4]byte{0x00, 0x00, 0x10, 0x20}: "prater",
 	}
 
 	if datum.validatorPubKey == nil {

cmd/validator/depositdata/output_internal_test.go

@@ -253,10 +253,15 @@ func TestOutputLaunchpad(t *testing.T) {
 		tmp := testutil.HexToSignature("0xb7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2")
 		signature = &tmp
 	}
-	var forkVersion *spec.Version
+	var forkVersionPyrmont *spec.Version
 	{
 		tmp := testutil.HexToVersion("0x00002009")
-		forkVersion = &tmp
+		forkVersionPyrmont = &tmp
+	}
+	var forkVersionPrater *spec.Version
+	{
+		tmp := testutil.HexToVersion("0x00001020")
+		forkVersionPrater = &tmp
 	}
 	var depositDataRoot *spec.Root
 	{
@@ -316,7 +321,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					amount:                32000000000,
 					signature:             signature,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot,
 					depositMessageRoot:    depositMessageRoot,
 				},
@@ -332,7 +337,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					validatorPubKey:    validatorPubKey,
 					amount:             32000000000,
 					signature:          signature,
-					forkVersion:        forkVersion,
+					forkVersion:        forkVersionPyrmont,
 					depositDataRoot:    depositDataRoot,
 					depositMessageRoot: depositMessageRoot,
 				},
@@ -348,7 +353,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					validatorPubKey:       validatorPubKey,
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					amount:                32000000000,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot,
 					depositMessageRoot:    depositMessageRoot,
 				},
@@ -364,7 +369,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					validatorPubKey:       validatorPubKey,
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					signature:             signature,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot,
 					depositMessageRoot:    depositMessageRoot,
 				},
@@ -381,7 +386,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					amount:                32000000000,
 					signature:             signature,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositMessageRoot:    depositMessageRoot,
 				},
 			},
@@ -397,14 +402,14 @@ func TestOutputLaunchpad(t *testing.T) {
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					amount:                32000000000,
 					signature:             signature,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot,
 				},
 			},
 			err: "deposit message root required",
 		},
 		{
-			name: "Single",
+			name: "SinglePyrmont",
 			dataOut: []*dataOut{
 				{
 					format:                "launchpad",
@@ -413,13 +418,30 @@ func TestOutputLaunchpad(t *testing.T) {
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					amount:                32000000000,
 					signature:             signature,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot,
 					depositMessageRoot:    depositMessageRoot,
 				},
 			},
 			res: `[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"00002009","eth2_network_name":"pyrmont","deposit_cli_version":"1.1.0"}]`,
 		},
+		{
+			name: "SinglePrater",
+			dataOut: []*dataOut{
+				{
+					format:                "launchpad",
+					account:               "interop/00000",
+					validatorPubKey:       validatorPubKey,
+					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
+					amount:                32000000000,
+					signature:             signature,
+					forkVersion:           forkVersionPrater,
+					depositDataRoot:       depositDataRoot,
+					depositMessageRoot:    depositMessageRoot,
+				},
+			},
+			res: `[{"pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","withdrawal_credentials":"00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b","amount":32000000000,"signature":"b7a757a4c506ac6ac5f2d23e065de7d00dc9f5a6a3f9610a8b60b65f166379139ae382c91ecbbf5c9fabc34b1cd2cf8f0211488d50d8754716d8e72e17c1a00b5d9b37cc73767946790ebe66cf9669abfc5c25c67e1e2d1c2e11429d149c25a2","deposit_message_root":"139b510ea7f2788ab82da1f427d6cbe1db147c15a053db738ad5500cd83754a6","deposit_data_root":"9e51b386f4271c18149dd0f73297a26a4a8c15c3622c44af79c92446f44a3554","fork_version":"00001020","eth2_network_name":"prater","deposit_cli_version":"1.1.0"}]`,
+		},
 		{
 			name: "Double",
 			dataOut: []*dataOut{
@@ -430,7 +452,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					withdrawalCredentials: testutil.HexToBytes("0x00fad2a6bfb0e7f1f0f45460944fbd8dfa7f37da06a4d13b3983cc90bb46963b"),
 					amount:                32000000000,
 					signature:             signature,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot,
 					depositMessageRoot:    depositMessageRoot,
 				},
@@ -441,7 +463,7 @@ func TestOutputLaunchpad(t *testing.T) {
 					withdrawalCredentials: testutil.HexToBytes("0x00ec7ef7780c9d151597924036262dd28dc60e1228f4da6fecf9d402cb3f3594"),
 					amount:                32000000000,
 					signature:             signature2,
-					forkVersion:           forkVersion,
+					forkVersion:           forkVersionPyrmont,
 					depositDataRoot:       depositDataRoot2,
 					depositMessageRoot:    depositMessageRoot2,
 				},

cmd/validator/duties/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 Weald Technology Trading
+// Copyright © 2019 - 2022 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -15,10 +15,6 @@ package validatorduties
 
 import (
 	"context"
-	"encoding/hex"
-	"fmt"
-	"strconv"
-	"strings"
 	"time"
 
 	eth2client "github.com/attestantio/go-eth2-client"
@@ -26,7 +22,6 @@ import (
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
-	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
 )
 
 func process(ctx context.Context, data *dataIn) (*dataOut, error) {
@@ -46,7 +41,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		verbose: data.verbose,
 	}
 
-	validatorIndex, err := validatorIndex(ctx, eth2Client, data)
+	validatorIndex, err := util.ValidatorIndex(ctx, eth2Client, data.account, data.pubKey, data.index)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain validator index")
 	}
@@ -132,54 +127,3 @@ func currentEpoch(ctx context.Context, eth2Client eth2client.Service) (spec.Epoc
 	}
 	return spec.Epoch(uint64(time.Since(genesis.GenesisTime).Seconds()) / (uint64(slotDuration.Seconds()) * slotsPerEpoch)), nil
 }
-
-// validatorIndex obtains the index of a validator
-func validatorIndex(ctx context.Context, eth2Client eth2client.Service, data *dataIn) (spec.ValidatorIndex, error) {
-	switch {
-	case data.account != "":
-		ctx, cancel := context.WithTimeout(context.Background(), data.timeout)
-		defer cancel()
-		_, account, err := util.WalletAndAccountFromPath(ctx, data.account)
-		if err != nil {
-			return 0, errors.Wrap(err, "failed to obtain account")
-		}
-		return accountToIndex(ctx, account, eth2Client)
-	case data.pubKey != "":
-		pubKeyBytes, err := hex.DecodeString(strings.TrimPrefix(data.pubKey, "0x"))
-		if err != nil {
-			return 0, errors.Wrap(err, fmt.Sprintf("failed to decode public key %s", data.pubKey))
-		}
-		account, err := util.NewScratchAccount(nil, pubKeyBytes)
-		if err != nil {
-			return 0, errors.Wrap(err, fmt.Sprintf("invalid public key %s", data.pubKey))
-		}
-		return accountToIndex(ctx, account, eth2Client)
-	case data.index != "":
-		val, err := strconv.ParseUint(data.index, 10, 64)
-		if err != nil {
-			return 0, err
-		}
-		return spec.ValidatorIndex(val), nil
-	default:
-		return 0, errors.New("no validator")
-	}
-}
-
-func accountToIndex(ctx context.Context, account e2wtypes.Account, eth2Client eth2client.Service) (spec.ValidatorIndex, error) {
-	pubKey, err := util.BestPublicKey(account)
-	if err != nil {
-		return 0, err
-	}
-
-	pubKeys := make([]spec.BLSPubKey, 1)
-	copy(pubKeys[0][:], pubKey.Marshal())
-	validators, err := eth2Client.(eth2client.ValidatorsProvider).ValidatorsByPubKey(ctx, "head", pubKeys)
-	if err != nil {
-		return 0, err
-	}
-
-	for index := range validators {
-		return index, nil
-	}
-	return 0, errors.New("validator not found")
-}

cmd/validator/expectation/command.go

@@ -0,0 +1,73 @@
+// Copyright © 2021 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 validatorexpectation
+
+import (
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type command struct {
+	quiet   bool
+	verbose bool
+	debug   bool
+
+	// Beacon node connection.
+	timeout                  time.Duration
+	connection               string
+	allowInsecureConnections bool
+
+	// Input.
+	validators int64
+
+	// Data access.
+	eth2Client         eth2client.Service
+	validatorsProvider eth2client.ValidatorsProvider
+	activeValidators   int
+
+	// Output.
+	timeBetweenProposals      time.Duration
+	timeBetweenSyncCommittees time.Duration
+}
+
+func newCommand(ctx context.Context) (*command, error) {
+	c := &command{
+		quiet:   viper.GetBool("quiet"),
+		verbose: viper.GetBool("verbose"),
+		debug:   viper.GetBool("debug"),
+	}
+
+	// Timeout.
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	c.timeout = viper.GetDuration("timeout")
+
+	if viper.GetString("connection") == "" {
+		return nil, errors.New("connection is required")
+	}
+	c.connection = viper.GetString("connection")
+	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+
+	c.validators = viper.GetInt64("validators")
+	if c.validators < 1 {
+		return nil, errors.New("validators must be at least 1")
+	}
+
+	return c, nil
+}

cmd/validator/expectation/command_internal_test.go

@@ -0,0 +1,82 @@
+// Copyright © 2021 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 validatorexpectation
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestInput(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{},
+			err:  "timeout is required",
+		},
+		{
+			name: "ConnectionMissing",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+			},
+			err: "connection is required",
+		},
+		{
+			name: "ValidatorsZero",
+			vars: map[string]interface{}{
+				"timeout":    "5s",
+				"validators": "0",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+			err: "validators must be at least 1",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"validators": "1",
+				"timeout":    "5s",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			_, err := newCommand(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/validator/expectation/output.go

@@ -0,0 +1,39 @@
+// Copyright © 2021 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 validatorexpectation
+
+import (
+	"context"
+	"strings"
+
+	"github.com/hako/durafmt"
+)
+
+func (c *command) output(ctx context.Context) (string, error) {
+	if c.quiet {
+		return "", nil
+	}
+
+	builder := strings.Builder{}
+
+	builder.WriteString("Expected time between block proposals: ")
+	builder.WriteString(durafmt.Parse(c.timeBetweenProposals).LimitFirstN(2).String())
+	builder.WriteString("\n")
+
+	builder.WriteString("Expected time between sync committees: ")
+	builder.WriteString(durafmt.Parse(c.timeBetweenSyncCommittees).LimitFirstN(2).String())
+	builder.WriteString("\n")
+
+	return builder.String(), nil
+}

cmd/validator/expectation/process.go

@@ -0,0 +1,161 @@
+// Copyright © 2021 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 validatorexpectation
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/util"
+)
+
+func (c *command) process(ctx context.Context) error {
+	// Obtain information we need to process.
+	if err := c.setup(ctx); err != nil {
+		return err
+	}
+
+	if c.debug {
+		fmt.Printf("Active validators: %d\n", c.activeValidators)
+	}
+
+	if err := c.calculateProposalChance(ctx); err != nil {
+		return err
+	}
+
+	return c.calculateSyncCommitteeChance(ctx)
+}
+
+func (c *command) calculateProposalChance(ctx context.Context) error {
+	// Chance of proposing a block is 1/activeValidators.
+	// Expectation of number of slots before proposing a block is 1/p, == activeValidators slots.
+
+	spec, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return err
+	}
+
+	tmp, exists := spec["SECONDS_PER_SLOT"]
+	if !exists {
+		return errors.New("spec missing SECONDS_PER_SLOT")
+	}
+	slotDuration, isType := tmp.(time.Duration)
+	if !isType {
+		return errors.New("SECONDS_PER_SLOT of incorrect type")
+	}
+
+	c.timeBetweenProposals = slotDuration * time.Duration(c.activeValidators) / time.Duration(c.validators)
+
+	return nil
+}
+
+func (c *command) calculateSyncCommitteeChance(ctx context.Context) error {
+	// Chance of being in a sync committee is SYNC_COMMITTEE_SIZE/activeValidators.
+	// Expectation of number of periods before being in a sync committee is 1/p, activeValidators/SYNC_COMMITTEE_SIZE periods.
+
+	spec, err := c.eth2Client.(eth2client.SpecProvider).Spec(ctx)
+	if err != nil {
+		return err
+	}
+
+	tmp, exists := spec["SECONDS_PER_SLOT"]
+	if !exists {
+		return errors.New("spec missing SECONDS_PER_SLOT")
+	}
+	slotDuration, isType := tmp.(time.Duration)
+	if !isType {
+		return errors.New("SECONDS_PER_SLOT of incorrect type")
+	}
+
+	tmp, exists = spec["SYNC_COMMITTEE_SIZE"]
+	if !exists {
+		return errors.New("spec missing SYNC_COMMITTEE_SIZE")
+	}
+	syncCommitteeSize, isType := tmp.(uint64)
+	if !isType {
+		return errors.New("SYNC_COMMITTEE_SIZE of incorrect type")
+	}
+
+	tmp, exists = spec["SLOTS_PER_EPOCH"]
+	if !exists {
+		return errors.New("spec missing SLOTS_PER_EPOCH")
+	}
+	slotsPerEpoch, isType := tmp.(uint64)
+	if !isType {
+		return errors.New("SLOTS_PER_EPOCH of incorrect type")
+	}
+
+	tmp, exists = spec["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]
+	if !exists {
+		return errors.New("spec missing EPOCHS_PER_SYNC_COMMITTEE_PERIOD")
+	}
+	epochsPerPeriod, isType := tmp.(uint64)
+	if !isType {
+		return errors.New("EPOCHS_PER_SYNC_COMMITTEE_PERIOD of incorrect type")
+	}
+
+	periodsBetweenSyncCommittees := uint64(c.activeValidators) / syncCommitteeSize
+	if c.debug {
+		fmt.Printf("Sync committee periods between inclusion: %d\n", periodsBetweenSyncCommittees)
+	}
+
+	c.timeBetweenSyncCommittees = slotDuration * time.Duration(slotsPerEpoch*epochsPerPeriod) * time.Duration(periodsBetweenSyncCommittees) / time.Duration(c.validators)
+
+	return nil
+}
+
+func (c *command) setup(ctx context.Context) error {
+	var err error
+
+	// Connect to the client.
+	c.eth2Client, err = util.ConnectToBeaconNode(ctx, c.connection, c.timeout, c.allowInsecureConnections)
+	if err != nil {
+		return errors.Wrap(err, "failed to connect to beacon node")
+	}
+
+	chainTime, err := standardchaintime.New(ctx,
+		standardchaintime.WithSpecProvider(c.eth2Client.(eth2client.SpecProvider)),
+		standardchaintime.WithForkScheduleProvider(c.eth2Client.(eth2client.ForkScheduleProvider)),
+		standardchaintime.WithGenesisTimeProvider(c.eth2Client.(eth2client.GenesisTimeProvider)),
+	)
+	if err != nil {
+		return errors.Wrap(err, "failed to set up chaintime service")
+	}
+
+	// Obtain the number of active validators.
+	var isProvider bool
+	c.validatorsProvider, isProvider = c.eth2Client.(eth2client.ValidatorsProvider)
+	if !isProvider {
+		return errors.New("connection does not provide validator information")
+	}
+
+	validators, err := c.validatorsProvider.Validators(ctx, "head", nil)
+	if err != nil {
+		return errors.Wrap(err, "failed to obtain validators")
+	}
+
+	currentEpoch := chainTime.CurrentEpoch()
+	for _, validator := range validators {
+		if validator.Validator.ActivationEpoch <= currentEpoch &&
+			validator.Validator.ExitEpoch > currentEpoch {
+			c.activeValidators++
+		}
+	}
+
+	return nil
+}

cmd/validator/expectation/process_internal_test.go

@@ -0,0 +1,63 @@
+// Copyright © 2021 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 validatorexpectation
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProcess(t *testing.T) {
+	if os.Getenv("ETHDO_TEST_CONNECTION") == "" {
+		t.Skip("ETHDO_TEST_CONNECTION not configured; cannot run tests")
+	}
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		err  string
+	}{
+		{
+			name: "InvalidData",
+			vars: map[string]interface{}{
+				"timeout":    "60s",
+				"validators": "1",
+				"data":       "[[",
+				"connection": os.Getenv("ETHDO_TEST_CONNECTION"),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			cmd, err := newCommand(context.Background())
+			require.NoError(t, err)
+			err = cmd.process(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/validator/expectation/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 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 validatorexpectation
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+
+	c, err := newCommand(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to set up command")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	if err := c.process(ctx); err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := c.output(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/validatorexpectation.go

@@ -0,0 +1,55 @@
+// Copyright © 2021 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"
+	"strings"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	validatorexpectation "github.com/wealdtech/ethdo/cmd/validator/expectation"
+)
+
+var validatorExpectationCmd = &cobra.Command{
+	Use:   "expectation",
+	Short: "Calculate expectation for individual validators",
+	Long: `Calculate expectation for individual validators.  For example:
+
+    ethdo validator expectation`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := validatorexpectation.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if viper.GetBool("quiet") {
+			return nil
+		}
+		res = strings.TrimRight(res, "\n")
+		fmt.Println(res)
+		return nil
+	},
+}
+
+func init() {
+	validatorCmd.AddCommand(validatorExpectationCmd)
+	validatorFlags(validatorExpectationCmd)
+	validatorExpectationCmd.Flags().Int64("validators", 1, "Number of validators")
+}
+
+func validatorExpectationBindings() {
+	if err := viper.BindPFlag("validators", validatorExpectationCmd.Flags().Lookup("validators")); err != nil {
+		panic(err)
+	}
+}

cmd/validatorinfo.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 Weald Technology Trading
+// Copyright © 2020, 2021 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
@@ -54,7 +54,7 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 		)
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
-		account, err := validatorInfoAccount()
+		account, err := validatorInfoAccount(ctx, eth2Client)
 		errCheck(err, "Failed to obtain validator account")
 
 		pubKeys := make([]spec.BLSPubKey, 1)
@@ -99,6 +99,12 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 			fmt.Printf("Public key: %#x\n", validator.Validator.PublicKey)
 		}
 		fmt.Printf("Status: %v\n", validator.Status)
+		switch validator.Status {
+		case api.ValidatorStateActiveExiting, api.ValidatorStateActiveSlashed:
+			fmt.Printf("Exit epoch: %d\n", validator.Validator.ExitEpoch)
+		case api.ValidatorStateExitedUnslashed, api.ValidatorStateExitedSlashed:
+			fmt.Printf("Withdrawable epoch: %d\n", validator.Validator.WithdrawableEpoch)
+		}
 		fmt.Printf("Balance: %s\n", string2eth.GWeiToString(uint64(validator.Balance), true))
 		if validator.Status.IsActive() {
 			fmt.Printf("Effective balance: %s\n", string2eth.GWeiToString(uint64(validator.Validator.EffectiveBalance), true))
@@ -107,31 +113,12 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 			fmt.Printf("Withdrawal credentials: %#x\n", validator.Validator.WithdrawalCredentials)
 		}
 
-		//		transition := time.Unix(int64(validatorInfo.TransitionTimestamp), 0)
-		//		transitionPassed := int64(validatorInfo.TransitionTimestamp) <= time.Now().Unix()
-		//		switch validatorInfo.Status {
-		//		case ethpb.ValidatorStatus_DEPOSITED:
-		//			if validatorInfo.TransitionTimestamp != 0 {
-		//				fmt.Printf("Inclusion in chain: %s\n", transition)
-		//			}
-		//		case ethpb.ValidatorStatus_PENDING:
-		//			fmt.Printf("Activation: %s\n", transition)
-		//		case ethpb.ValidatorStatus_EXITING, ethpb.ValidatorStatus_SLASHING:
-		//			fmt.Printf("Attesting finishes: %s\n", transition)
-		//		case ethpb.ValidatorStatus_EXITED:
-		//			if transitionPassed {
-		//				fmt.Printf("Funds withdrawable: Now\n")
-		//			} else {
-		//				fmt.Printf("Funds withdrawable: %s\n", transition)
-		//			}
-		//		}
-
 		os.Exit(_exitSuccess)
 	},
 }
 
 // validatorInfoAccount obtains the account for the validator info command.
-func validatorInfoAccount() (e2wtypes.Account, error) {
+func validatorInfoAccount(ctx context.Context, eth2Client eth2client.Service) (e2wtypes.Account, error) {
 	var account e2wtypes.Account
 	var err error
 	switch {
@@ -151,6 +138,27 @@ func validatorInfoAccount() (e2wtypes.Account, error) {
 		if err != nil {
 			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", viper.GetString("pubkey")))
 		}
+	case viper.GetInt64("index") != -1:
+		validatorsProvider, isValidatorsProvider := eth2Client.(eth2client.ValidatorsProvider)
+		if !isValidatorsProvider {
+			return nil, errors.New("client does not provide validator information")
+		}
+		index := spec.ValidatorIndex(viper.GetInt64("index"))
+		validators, err := validatorsProvider.Validators(ctx, "head", []spec.ValidatorIndex{
+			index,
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain validator information.")
+		}
+		if len(validators) == 0 {
+			return nil, errors.New("unknown validator index")
+		}
+		pubKeyBytes := make([]byte, 48)
+		copy(pubKeyBytes, validators[index].Validator.PublicKey[:])
+		account, err = util.NewScratchAccount(nil, pubKeyBytes)
+		if err != nil {
+			return nil, errors.Wrap(err, fmt.Sprintf("invalid public key %s", viper.GetString("pubkey")))
+		}
 	default:
 		return nil, errors.New("neither account nor public key supplied")
 	}
@@ -212,6 +220,7 @@ func graphData(network string, validatorPubKey []byte) (uint64, spec.Gwei, error
 func init() {
 	validatorCmd.AddCommand(validatorInfoCmd)
 	validatorInfoCmd.Flags().String("pubkey", "", "Public key for which to obtain status")
+	validatorInfoCmd.Flags().Int64("index", -1, "Index for which to obtain status")
 	validatorFlags(validatorInfoCmd)
 }
 
@@ -219,4 +228,7 @@ func validatorInfoBindings() {
 	if err := viper.BindPFlag("pubkey", validatorInfoCmd.Flags().Lookup("pubkey")); err != nil {
 		panic(err)
 	}
+	if err := viper.BindPFlag("index", validatorInfoCmd.Flags().Lookup("index")); err != nil {
+		panic(err)
+	}
 }

cmd/version.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 - 2021 Weald Technology Trading
+// Copyright © 2019 - 2022 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
@@ -24,7 +24,7 @@ import (
 
 // ReleaseVersion is the release version of the codebase.
 // Usually overridden by tag names when building binaries.
-var ReleaseVersion = "local build (latest release 1.9.1)"
+var ReleaseVersion = "local build (latest release 1.18.0)"
 
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{

cmd/wallet/sharedexport/input.go

@@ -0,0 +1,83 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+	"github.com/wealdtech/ethdo/util"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type dataIn struct {
+	// System.
+	timeout      time.Duration
+	verbose      bool
+	debug        bool
+	wallet       e2wtypes.Wallet
+	file         string
+	participants uint32
+	threshold    uint32
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetString("remote") != "" {
+		return nil, errors.New("wallet export not available for remote wallets")
+	}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	// Quiet is not allowed.
+	if viper.GetBool("quiet") {
+		return nil, errors.New("quiet not allowed")
+	}
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	// Wallet.
+	wallet, err := util.WalletFromInput(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to access wallet")
+	}
+	data.wallet = wallet
+
+	// File.
+	data.file = viper.GetString("file")
+	if data.file == "" {
+		return nil, errors.New("file is required")
+	}
+
+	// Participants
+	data.participants = viper.GetUint32("participants")
+	if data.participants == 0 {
+		return nil, errors.New("participants is required")
+	}
+	data.threshold = viper.GetUint32("threshold")
+	if data.threshold == 0 {
+		return nil, errors.New("threshold is required")
+	}
+	if data.threshold > data.participants {
+		return nil, errors.New("threshold cannot be more than participants")
+	}
+
+	return data, nil
+}

cmd/wallet/sharedexport/input_internal_test.go

@@ -0,0 +1,153 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"wallet": "Test wallet",
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "Quiet",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "Test wallet",
+				"quiet":   "true",
+			},
+			err: "quiet not allowed",
+		},
+		{
+			name: "WalletMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "failed to access wallet: cannot determine wallet",
+		},
+		{
+			name: "WalletUnknown",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "unknown",
+			},
+			err: "failed to access wallet: wallet not found",
+		},
+		{
+			name: "Remote",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"remote":  "remoteaddress",
+			},
+			err: "wallet export not available for remote wallets",
+		},
+		{
+			name: "FileMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "Test wallet",
+			},
+			err: "file is required",
+		},
+		{
+			name: "ParticipantsMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"wallet":  "Test wallet",
+				"file":    "test.dat",
+			},
+			err: "participants is required",
+		},
+		{
+			name: "ThresholdMissing",
+			vars: map[string]interface{}{
+				"timeout":      "5s",
+				"wallet":       "Test wallet",
+				"file":         "test.dat",
+				"participants": "5",
+			},
+			err: "threshold is required",
+		},
+		{
+			name: "ThresholdTooHigh",
+			vars: map[string]interface{}{
+				"timeout":      "5s",
+				"wallet":       "Test wallet",
+				"file":         "test.dat",
+				"participants": "5",
+				"threshold":    "6",
+			},
+			err: "threshold cannot be more than participants",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout":      "5s",
+				"wallet":       "Test wallet",
+				"file":         "test.dat",
+				"participants": "5",
+				"threshold":    "3",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+				wallet:  wallet,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+				require.Equal(t, test.vars["wallet"], res.wallet.Name())
+			}
+		})
+	}
+}

cmd/wallet/sharedexport/output.go

@@ -0,0 +1,42 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/pkg/errors"
+)
+
+type dataOut struct {
+	shares [][]byte
+}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	if data == nil {
+		return "", errors.New("no data")
+	}
+
+	builder := strings.Builder{}
+	for i := range data.shares {
+		builder.WriteString(fmt.Sprintf("%x", data.shares[i]))
+		if i != len(data.shares)-1 {
+			builder.WriteString("\n")
+		}
+	}
+
+	return builder.String(), nil
+}

cmd/wallet/sharedexport/output_internal_test.go

@@ -0,0 +1,58 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name     string
+		dataOut  *dataOut
+		expected string
+		err      string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "Good",
+			dataOut: &dataOut{
+				shares: [][]byte{
+					{0x01, 0x02},
+					{0x02, 0x03},
+					{0x03, 0x04},
+				},
+			},
+			expected: "0102\n0203\n0304",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.expected, res)
+			}
+		})
+	}
+}

cmd/wallet/sharedexport/process.go

@@ -0,0 +1,86 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+	"crypto/rand"
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/shamir"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+type sharedExport struct {
+	Version      uint32 `json:"version"`
+	Participants uint32 `json:"participants"`
+	Threshold    uint32 `json:"threshold"`
+	Data         string `json:"data"`
+}
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if data.wallet == nil {
+		return nil, errors.New("wallet is required")
+	}
+
+	passphrase := make([]byte, 64)
+	n, err := rand.Read(passphrase)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to generate passphrase")
+	}
+	if n != 64 {
+		return nil, errors.New("failed to obtain passphrase")
+	}
+	exporter, isExporter := data.wallet.(e2wtypes.WalletExporter)
+	if !isExporter {
+		return nil, errors.New("wallet does not provide export")
+	}
+
+	export, err := exporter.Export(ctx, passphrase)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to export wallet")
+	}
+
+	shares, err := shamir.Split(passphrase, int(data.participants), int(data.threshold))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create shamir shares")
+	}
+
+	sharedExport := &sharedExport{
+		Version:      1,
+		Participants: data.participants,
+		Threshold:    data.threshold,
+		Data:         fmt.Sprintf("%#x", export),
+	}
+	sharedFile, err := json.Marshal(sharedExport)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to marshal shamir export")
+	}
+
+	if err := os.WriteFile(data.file, sharedFile, 0600); err != nil {
+		return nil, errors.Wrap(err, "failed to write export file")
+	}
+
+	results := &dataOut{
+		shares: shares,
+	}
+
+	return results, nil
+}

cmd/wallet/sharedexport/process_internal_test.go

@@ -0,0 +1,93 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+	"io/ioutil"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	filesystem "github.com/wealdtech/go-eth2-wallet-store-filesystem"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	base, err := ioutil.TempDir("", "")
+	require.NoError(t, err)
+	defer os.RemoveAll(base)
+	store := filesystem.New(filesystem.WithLocation(base))
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "WalletMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+			},
+			err: "wallet is required",
+		},
+		{
+			name: "FileInvalid",
+			dataIn: &dataIn{
+				timeout:      5 * time.Second,
+				wallet:       wallet,
+				file:         "/bad/bad/bad/backup.dat",
+				participants: 5,
+				threshold:    3,
+			},
+			err: "failed to write export file: open /bad/bad/bad/backup.dat: no such file or directory",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout:      5 * time.Second,
+				wallet:       wallet,
+				file:         "test.dat",
+				participants: 5,
+				threshold:    3,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				os.Remove(test.dataIn.file)
+				require.Len(t, res.shares, int(test.dataIn.participants))
+			}
+		})
+	}
+}

cmd/wallet/sharedexport/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 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 walletsharedexport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/wallet/sharedimport/input.go

@@ -0,0 +1,67 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+	"io/ioutil"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/viper"
+)
+
+type dataIn struct {
+	// System.
+	timeout time.Duration
+	quiet   bool
+	verbose bool
+	debug   bool
+	file    []byte
+	shares  []string
+}
+
+func input(ctx context.Context) (*dataIn, error) {
+	var err error
+	data := &dataIn{}
+
+	if viper.GetString("remote") != "" {
+		return nil, errors.New("wallet import not available for remote wallets")
+	}
+
+	if viper.GetDuration("timeout") == 0 {
+		return nil, errors.New("timeout is required")
+	}
+	data.timeout = viper.GetDuration("timeout")
+	data.quiet = viper.GetBool("quiet")
+	data.verbose = viper.GetBool("verbose")
+	data.debug = viper.GetBool("debug")
+
+	// Data.
+	if viper.GetString("file") == "" {
+		return nil, errors.New("file is required")
+	}
+	data.file, err = ioutil.ReadFile(viper.GetString("file"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to read wallet import file")
+	}
+
+	// Shares.
+	data.shares = viper.GetStringSlice("shares")
+	if len(data.shares) == 0 {
+		return nil, errors.New("failed to obtain shares")
+	}
+
+	return data, nil
+}

cmd/wallet/sharedimport/input_internal_test.go

@@ -0,0 +1,132 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/spf13/viper"
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
+	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
+	scratch "github.com/wealdtech/go-eth2-wallet-store-scratch"
+	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
+)
+
+func TestInput(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	dir := os.TempDir()
+	datFile := filepath.Join(dir, "backup.dat")
+	err := ioutil.WriteFile(datFile, []byte("dummy"), 0600)
+	require.NoError(t, err)
+	// defer os.RemoveAll(dir)
+
+	store := scratch.New()
+	require.NoError(t, e2wallet.UseStore(store))
+	wallet, err := nd.CreateWallet(context.Background(), "Test wallet", store, keystorev4.New())
+	require.NoError(t, err)
+	data, err := wallet.(e2wtypes.WalletExporter).Export(context.Background(), []byte("ce%NohGhah4ye5ra"))
+	require.NoError(t, err)
+	require.NoError(t, e2wallet.UseStore(scratch.New()))
+
+	tests := []struct {
+		name string
+		vars map[string]interface{}
+		res  *dataIn
+		err  string
+	}{
+		{
+			name: "TimeoutMissing",
+			vars: map[string]interface{}{
+				"data": fmt.Sprintf("%#x", data),
+			},
+			err: "timeout is required",
+		},
+		{
+			name: "FileMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "file is required",
+		},
+		{
+			name: "Remote",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"file":    "test.dat",
+				"remote":  "remoteaddress",
+			},
+			err: "wallet import not available for remote wallets",
+		},
+		{
+			name: "FilMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+			},
+			err: "file is required",
+		},
+		{
+			name: "FileBad",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"file":    "bad.dat",
+			},
+			err: "failed to read wallet import file: open bad.dat: no such file or directory",
+		},
+		{
+			name: "SharesMissing",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"file":    datFile,
+			},
+			err: "failed to obtain shares",
+		},
+		{
+			name: "Good",
+			vars: map[string]interface{}{
+				"timeout": "5s",
+				"file":    datFile,
+				"shares":  "01 02 03",
+			},
+			res: &dataIn{
+				timeout: 5 * time.Second,
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.NotNil(t, res)
+			}
+		})
+	}
+}

cmd/wallet/sharedimport/output.go

@@ -0,0 +1,24 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+)
+
+type dataOut struct{}
+
+func output(ctx context.Context, data *dataOut) (string, error) {
+	return "Wallet imported", nil
+}

cmd/wallet/sharedimport/output_internal_test.go

@@ -0,0 +1,47 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestOutput(t *testing.T) {
+	tests := []struct {
+		name    string
+		dataOut *dataOut
+		res     string
+		err     string
+	}{
+		{
+			name: "Good",
+			res:  "Wallet imported",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			res, err := output(context.Background(), test.dataOut)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res, res)
+			}
+		})
+	}
+}

cmd/wallet/sharedimport/process.go

@@ -0,0 +1,73 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/pkg/errors"
+	"github.com/wealdtech/ethdo/shamir"
+	e2wallet "github.com/wealdtech/go-eth2-wallet"
+)
+
+type sharedExport struct {
+	Version      uint32 `json:"version"`
+	Participants uint32 `json:"participants"`
+	Threshold    uint32 `json:"threshold"`
+	Data         string `json:"data"`
+}
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+	if len(data.file) == 0 {
+		return nil, errors.New("import file is required")
+	}
+
+	sharedExport := &sharedExport{}
+	err := json.Unmarshal(data.file, sharedExport)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to unmarshal export")
+	}
+
+	if len(data.shares) != int(sharedExport.Threshold) {
+		return nil, fmt.Errorf("import requires %d shares, %d were provided", sharedExport.Threshold, len(data.shares))
+	}
+
+	shares := make([][]byte, len(data.shares))
+	for i := range data.shares {
+		shares[i], err = hex.DecodeString(data.shares[i])
+		if err != nil {
+			return nil, errors.Wrap(err, "invalid share")
+		}
+	}
+	passphrase, err := shamir.Combine(shares)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to recreate passphrase from shares")
+	}
+	wallet, err := hex.DecodeString(strings.TrimPrefix(sharedExport.Data, "0x"))
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain data from export")
+	}
+	if _, err := e2wallet.ImportWallet(wallet, passphrase); err != nil {
+		return nil, errors.Wrap(err, "failed to import wallet")
+	}
+
+	return nil, nil
+}

cmd/wallet/sharedimport/process_internal_test.go

@@ -0,0 +1,138 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	e2types "github.com/wealdtech/go-eth2-types/v2"
+)
+
+func TestProcess(t *testing.T) {
+	require.NoError(t, e2types.InitBLS())
+
+	export := []byte(`{"version":1,"participants":5,"threshold":3,"data":"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"}`)
+	shares := []string{
+		"d04a162f3f648647acbfc5af0475041c3f64c3d72752ddc52ab53786802ed7dfea3929488dbefb3af582e713fe967a6ff24c86757186abe7d93afdcd81cdff4f8a",
+		"f06533d9efae8b015a5b9c73d2b3652b5e0c80fa9a948fdcfbda3d4bd54ae31573c8649ffb0a8900dfe1cecb740b0c3a477938f3e01244cac39a068612beb72bbe",
+		"682b8e6256ce6a4fde515060a326214f7a3789b79c11e2cb53e5b185d522d196ca0b76dea7a03d739ec87605ede429a9f214dfb06703dbb143d8d5b56413d7a0a7",
+		"53ccad137def6fcbaac0ccfff0fdbb02ab3fa4ce075b221f15a80203a318f29f09cfc7a40b29c910675791f847e3e72dc6f80e74b80f517512c1fd6be14ff5b2ff",
+		"ed2166659f7b5412a169ec83627386bc6ff1a31e67735d405b2bf7cb122ad7ced35c87e42c8e8f7ba90b5899a94be506687a9c5b353af2a216018d9f1bf61745a5",
+	}
+
+	dir := os.TempDir()
+	datFile := filepath.Join(dir, "backup.dat")
+	err := ioutil.WriteFile(datFile, export, 0600)
+	require.NoError(t, err)
+	defer os.RemoveAll(dir)
+
+	tests := []struct {
+		name   string
+		dataIn *dataIn
+		err    string
+	}{
+		{
+			name: "Nil",
+			err:  "no data",
+		},
+		{
+			name: "FileMissing",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+			},
+			err: "import file is required",
+		},
+		{
+			name: "FileBad",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				file:    []byte("\001\002"),
+				shares: []string{
+					shares[0],
+					shares[1],
+					shares[2],
+				},
+			},
+			err: "failed to unmarshal export: invalid character '\\x01' looking for beginning of value",
+		},
+		{
+			name: "SharesTooLow",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				file:    export,
+				shares: []string{
+					shares[0],
+					shares[1],
+				},
+			},
+			err: "import requires 3 shares, 2 were provided",
+		},
+		{
+			name: "SharesTooHigh",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				file:    export,
+				shares: []string{
+					shares[0],
+					shares[1],
+					shares[2],
+					shares[3],
+				},
+			},
+			err: "import requires 3 shares, 4 were provided",
+		},
+		{
+			name: "ShareBad",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				file:    export,
+				shares: []string{
+					"xxx",
+					shares[1],
+					shares[2],
+				},
+			},
+			err: "invalid share: encoding/hex: invalid byte: U+0078 'x'",
+		},
+		{
+			name: "Good",
+			dataIn: &dataIn{
+				timeout: 5 * time.Second,
+				file:    export,
+				shares: []string{
+					shares[0],
+					shares[1],
+					shares[2],
+				},
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := process(context.Background(), test.dataIn)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

cmd/wallet/sharedimport/run.go

@@ -0,0 +1,50 @@
+// Copyright © 2021 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 walletsharedimport
+
+import (
+	"context"
+
+	"github.com/pkg/errors"
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+)
+
+// Run runs the command.
+func Run(cmd *cobra.Command) (string, error) {
+	ctx := context.Background()
+	dataIn, err := input(ctx)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain input")
+	}
+
+	// Further errors do not need a usage report.
+	cmd.SilenceUsage = true
+
+	dataOut, err := process(ctx, dataIn)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to process")
+	}
+
+	if viper.GetBool("quiet") {
+		return "", nil
+	}
+
+	results, err := output(ctx, dataOut)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain output")
+	}
+
+	return results, nil
+}

cmd/walletimport.go

@@ -26,7 +26,7 @@ var walletImportCmd = &cobra.Command{
 	Short: "Import a wallet",
 	Long: `Import a wallet.  For example:
 
-    ethdo wallet import --importdata=primary --importpassphrase="my export secret"
+    ethdo wallet import --data=primary --passphrase="my export secret"
 
 In quiet mode this will return 0 if the wallet is imported successfully, otherwise 1.`,
 	RunE: func(cmd *cobra.Command, args []string) error {

cmd/walletsharedexport.go

@@ -0,0 +1,60 @@
+// Copyright © 2021 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	walletsharedexport "github.com/wealdtech/ethdo/cmd/wallet/sharedexport"
+)
+
+var walletSharedExportCmd = &cobra.Command{
+	Use:   "sharedexport",
+	Short: "Export a wallet using Shamir secret sharing",
+	Long: `Export a wallet for backup of transfer using Shamir secret sharing.  For example:
+
+    ethdo wallet sharedexport --wallet=primary --participants=5 --threshold=3 --file=backup.dat`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletsharedexport.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	walletCmd.AddCommand(walletSharedExportCmd)
+	walletFlags(walletSharedExportCmd)
+	walletSharedExportCmd.Flags().Uint32("participants", 0, "Number of participants in sharing scheme")
+	walletSharedExportCmd.Flags().Uint32("threshold", 0, "Number of participants required to recover the export")
+	walletSharedExportCmd.Flags().String("file", "", "Name of the file that stores the export")
+}
+
+func walletSharedExportBindings() {
+	if err := viper.BindPFlag("participants", walletSharedExportCmd.Flags().Lookup("participants")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("threshold", walletSharedExportCmd.Flags().Lookup("threshold")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("file", walletSharedExportCmd.Flags().Lookup("file")); err != nil {
+		panic(err)
+	}
+}

cmd/walletsharedimport.go

@@ -0,0 +1,58 @@
+// Copyright © 2021 Weald Technology Trading
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+	"github.com/spf13/viper"
+	walletsharedimport "github.com/wealdtech/ethdo/cmd/wallet/sharedimport"
+)
+
+var walletSharedImportCmd = &cobra.Command{
+	Use:   "sharedimport",
+	Short: "Import a wallet using Shamir secret sharing",
+	Long: `Import a wallet for backup of transfer using Shamir secret sharing.  For example:
+
+	ethdo wallet sharedimport --file=backup.dat --shares="1234 2345 3456"
+
+In quiet mode this will return 0 if the wallet is imported successfully, otherwise 1.`,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		res, err := walletsharedimport.Run(cmd)
+		if err != nil {
+			return err
+		}
+		if res != "" {
+			fmt.Println(res)
+		}
+		return nil
+	},
+}
+
+func init() {
+	walletCmd.AddCommand(walletSharedImportCmd)
+	walletFlags(walletSharedImportCmd)
+	walletSharedImportCmd.Flags().String("file", "", "Name of the file that stores the export")
+	walletSharedImportCmd.Flags().String("shares", "", "Shares required to decrypt the export, separated with spaces")
+}
+
+func walletSharedImportBindings() {
+	if err := viper.BindPFlag("file", walletSharedImportCmd.Flags().Lookup("file")); err != nil {
+		panic(err)
+	}
+	if err := viper.BindPFlag("shares", walletSharedImportCmd.Flags().Lookup("shares")); err != nil {
+		panic(err)
+	}
+}

docs/howto.md

@@ -37,7 +37,7 @@ ethdo wallet create --wallet="Recreated wallet" --type=hd --wallet-passphrase="s
 A wallet can be backed up with the `ethdo wallet export` command.  This creates an encrypted backup of the wallet, for example:
 
 ```sh
-ethdo wallet export --wallet="My wallet" --exportpassphrase="export secret" >export.dat
+ethdo wallet export --wallet="My wallet" --passphrase="export secret" >export.dat
 ```
 
 Note that by default the wallet backup is printed to the console, hence the `>export.dat` to redirect it to a file.
@@ -47,7 +47,7 @@ Note that by default the wallet backup is printed to the console, hence the `>ex
 A backed up wallet can be restored with the `ethdo wallet import` command, for example:
 
 ```sh
-ethdo wallet import --importdata=export.dat --importpassphrase="export secret"
+ethdo wallet import --data=export.dat --passphrase="export secret"
 ```
 
 In this example the wallet to be imported is being read from the `export.dat` file.

docs/usage.md

@@ -103,6 +103,33 @@ Personal wallet
 
 **N.B.** encrypted wallets will not show up in this list unless the correct passphrase for the store is supplied.
 
+#### `sharedexport`
+
+`ethdo wallet sharedexport` exports the wallet and all of its accounts with shared keys.  Options for exporting a wallet include:
+  - `wallet`: the name of the wallet to export (defaults to "primary")
+  - `participants`: the total number of participants that each hold a share
+  - `threshold`: the number of participants necessary to provide their share to restore the wallet
+  - `file`: the name of the file that stores the backup
+
+```sh
+$ ethdo wallet sharedexport --wallet="Personal wallet" --participants=3 --threshold=2 --file=backup.dat
+298a4efce34c7f46114b7c4ea4be3d3bef925dccb153dd00227b53c3be7dad668b326f2659b2375e708bb824b33f0e7364e0f21dd18e5f5f2d7d04de7c122a9189
+10eabc645fd1633e2e874ffc486fcbe313b33c34fbcb30511a74517296e01f332c6e3c40757c39b4dc47f3a417d321c4c81c2115e53fca57797c975913b8bf5063
+559c77b56d36cbd84f23669a376d389f8c6644933a1a4112512e4d063d0779489c6b6312e6c46def0ee33ce5b5aca0941a833f65e64b5d270c7224323f4e28b238
+```
+
+Each line of the output is a share and should be provided to one of the participants, along with the backup file.
+
+#### `sharedimport`
+
+`ethdo wallet sharedimport` imports a wallet and all of its accounts exported by `ethdo wallet sharedexport`.  Options for importing a wallet include:
+  - `file`: the name of the file that stores the backup
+  - `shares`: a number of shares, defined by _threshold_ during the export, separated by spaces
+
+```sh
+$ ethdo wallet sharedimport --file=backup.dat --shares="298a…9189 10ea…5063"
+```
+
 ### `account` commands
 
 Account commands focus on information about local accounts, generally those used by Geth and Parity but also those from hardware devices.
@@ -239,13 +266,35 @@ $ ethdo version
 ### `block` commands
 
 Block commands focus on providing information about Ethereum 2 blocks.
+#### `analyze`
+`ethdo block info` obtains information about a block in Ethereum 2.  Options include:
+  - `blockid`: the ID (slot, root, 'head') of the block to obtain
+
+```sh
+$ ethdo block analyze --blockid=80
+Value for block 80: 488.531
+```
+
+Additional information is supplied when using `--verbose`
+
+```
+$ ethdo block analyze --blockid=80 --verbose
+Attestation 0: distance 1, 119/119/132 new/total/possible votes, score 0.844, value 100.406
+Attestation 1: distance 1, 116/116/131 new/total/possible votes, score 0.844, value 97.875
+Attestation 2: distance 1, 115/115/131 new/total/possible votes, score 0.844, value 97.031
+Attestation 3: distance 1, 114/114/132 new/total/possible votes, score 0.844, value 96.188
+Attestation 4: distance 1, 113/113/132 new/total/possible votes, score 0.844, value 95.344
+Attestation 5: distance 1, 2/22/132 new/total/possible votes, score 0.844, value 1.688
+Value for block 80: 488.531
+```
+
 #### `info`
 
 `ethdo block info` obtains information about a block in Ethereum 2.  Options include:
-  - `slot`: the slot at which to attempt to fetch the block
+  - `blockid`: the ID (slot, root, 'head') of the block to obtain
 
 ```sh
-$ ethdo block info --slot=80 
+$ ethdo block info --blockid=80
 Attestations: 1
 Attester slashings: 0
 Deposits: 0
@@ -424,6 +473,40 @@ $ ethdo slot time --slot=5
 2020-12-01 12:01:23 +0000 GMT
 ```
 
+### `synccommittee` commands
+
+Sync committee commands focus on information about sync committees.
+
+#### `inclusion`
+
+`ethdo synccommittee inclusion` provides information about the inclusion, or not, of a validator's sync committee messages.  Options include:
+  - `account` the account of the validator for which to print sync committee contributions
+  - `index` the index of the validator for which to print sync committee contributions
+  - `pubkey` the public key of the validator for which to print sync committee contributions
+  - `epoch` the specific epoch for which to print sync committee contributions.  Defaults to the last complete epoch
+
+
+```sh
+$ ethdo synccommittee inclusion --index=274946 --epoch=91592
+Epoch: 91593
+Expected: 32
+Included: 30
+Missed: 1
+No block: 1
+Per-slot result: ✓✓✓✓✓✓✓✓ ✓✓✕✓✓✓✓✓ ✓✓✓✓-✓✓✓ ✓✓✓✓✓✓✓✓
+```
+
+#### `members`
+
+`ethdo synccommittee members` provides information about the members of a sync committee.  Options include:
+  - `epoch` the specific epoch for which to provide sync committee members.
+  - `period` the period for which to provide sync committee members.  Can be 'current' or 'next'; dfeaults to 'current'
+
+```sh
+$ ethdo synccommittee members
+138334,116317,231736,65706,60046,148162,274946,34724,18051,122841,269578,121110,89733,154887,202118,243459,267543,82793,59504,238929,55360,272874,93917,83116,264342,244312,264907,79193,15443,27997,127175,140965,64416,66399,173906,268885,67779,48139,215005,191435,107954,225228,148630,169357,61091,223319,40668,184307,95903,81179,237461,41723,119710,243333,248243,42757,228686,252749,17546,231625,132030,15934,108465,104302,93026,191946,63738,80996,90679,227542,75463,64581,242030,5429,61623,157314,145363,224733,232492,45357,80674,198583,221422,48665,154803,128608,172512,261074,102835,129935,255726,40846,218932,139874,194575,17346,171565,76413,237859,103170,95661,83018,73902,246680,35795,257792,23836,136624,45745,190990,124229,37281,23818,233435,253903,37502,8669,31151,267179,27954,181019,145719,112270,1899,184844,175014,121769,41717,218760,44813,255860,64865,31985,231664,134296,88114,185542,27557,1698,62470,79182,184325,80380,8865,218456,178979,243886,9466,221389,131476,160857,62916,195389,160182,99293,100263,242371,144594,227527,275978,65714,74350,60121,46642,219334,157142,99379,203508,84367,251808,276456,92563,199831,215312,193875,129690,104234,44290,227725,194780,163061,162328,176517,278620,137355,212826,131615,125734,151873,18977,147927,272759,160537,210675,180411,24203,37266,247527,128678,270287,90352,23043,169645,5304,183412,237387,79751,37635,275139,95857,185990,235565,49425,255836,254314,77582,104172,168556,143653,64173,64504,130363,216602,218107,181130,191845,56454,2040,270365,161952,222409,45097,51611,219190,154903,162311,257460,106337,110775,42928,275709,202352,54724,272295,274470,35220,19694,10347,169585,104938,35121,212982,190582,77999,110201,141519,239881,81263,84314,148883,254649,256309,270013,254179,134009,149660,177127,201926,30533,164789,154343,57437,28958,135169,186415,218514,171355,165247,213526,100044,184264,93278,269329,159634,4092,224671,217236,123946,80703,85444,247742,17959,146473,128231,167559,133899,181532,33378,79060,119785,249443,180469,43692,169679,154421,114047,87877,28337,59072,19807,204598,220293,99461,55272,227923,4503,12580,27044,68955,157373,61321,265034,106833,31534,69137,264783,129588,70433,88338,113528,226211,123003,118982,131549,60350,78896,165715,119736,52639,93274,164295,278837,186453,69910,36768,249533,106205,184057,253232,88155,121377,242589,148236,250065,191526,277249,157463,226527,93000,64784,176880,176380,144301,52061,169803,134291,96648,211716,223000,157911,256737,100938,50434,41075,114894,259888,116872,218201,83617,76348,256832,17113,50270,96468,128448,36987,127511,42397,10154,49234,193346,126352,57719,17029,213127,157942,187829,2353,62462,73637,29053,120324,108515,254684,35982,188131,217092,256206,85802,105907,21204,147562,188961,154541,131147,16000,225112,58362,170375,42239,188309,60280,125472,220119,268946,65736,274053,223569,60454,239552,4401,139357,279634,162711,112016,90295,170641,239770,212067,213770,78311,49057,256295,28666,167207,166783,213148,30689,72118,55912,197733,205116,106169,40570,225057,122079,126423,217781,212897,147499,201774,10616,157826,155954,258431,212151,255318,97138,151907,181491,40236,272993,104430,178068,56089,10067,185066,93669,124108,12785,230215,67995,196282,248285,215370,167715,186183,238147,164161,15068,127990,166146,244578,195912,199812,248435,135597,143024,225304,27045,238140,87008,272550,165234,218128,160038,17697,25332,23446,265921,201045,241106
+```
+
 ### `validator` commands
 
 Validator commands focus on interaction with Ethereum 2 validators.
@@ -500,6 +583,16 @@ $ ethdo validator keycheck --withdrawal-credentials=0x007e28dcf9029e8d92ca4b5d01
 Withdrawal credentials confirmed at path m/12381/3600/10/0
 ```
 
+#### `expectation`
+
+`ethdo validator expectation` calculates the times between expected actions.
+
+```sh
+$ ethdo validator expectation
+Expected time between block proposals: 4 weeks 6 days
+Expected time between sync committees: 1 year 27 weeks
+```
+
 ### `attester` commands
 
 Attester commands focus on Ethereum 2 validators' actions as attesters.

go.mod

@@ -1,64 +1,51 @@
 module github.com/wealdtech/ethdo
 
-go 1.13
+go 1.16
 
 require (
 	github.com/OneOfOne/xxhash v1.2.5 // indirect
-	github.com/attestantio/dirk v1.0.2
-	github.com/attestantio/go-eth2-client v0.6.21
-	github.com/aws/aws-sdk-go v1.37.1 // indirect
-	github.com/ferranbt/fastssz v0.0.0-20210120143747-11b9eff30ea9
-	github.com/fsnotify/fsnotify v1.4.9 // indirect
-	github.com/goccy/go-yaml v1.8.6 // indirect
-	github.com/gofrs/uuid v4.0.0+incompatible
-	github.com/gogo/protobuf v1.3.2
-	github.com/google/uuid v1.2.0
-	github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
-	github.com/herumi/bls-eth-go-binary v0.0.0-20210130185500-57372fb27371
-	github.com/jackc/puddle v1.1.3 // indirect
-	github.com/magiconair/properties v1.8.4 // indirect
-	github.com/minio/highwayhash v1.0.1 // indirect
+	github.com/attestantio/dirk v1.1.0
+	github.com/attestantio/go-eth2-client v0.11.0
+	github.com/aws/aws-sdk-go v1.42.44 // indirect
+	github.com/ferranbt/fastssz v0.0.0-20220103083642-bc5fefefa28b
+	github.com/gofrs/uuid v4.2.0+incompatible
+	github.com/google/uuid v1.3.0
+	github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b
+	github.com/hashicorp/hcl v1.0.1-vault-3 // indirect
+	github.com/herumi/bls-eth-go-binary v0.0.0-20220103074059-01b0ca9e9ef7
+	github.com/jackc/puddle v1.2.1 // indirect
+	github.com/minio/highwayhash v1.0.2 // indirect
 	github.com/mitchellh/go-homedir v1.1.0
-	github.com/nbutton23/zxcvbn-go v0.0.0-20201221231540-e56b841a3c88
-	github.com/pelletier/go-toml v1.8.1 // indirect
+	github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354
 	github.com/pkg/errors v0.9.1
 	github.com/protolambda/zssz v0.1.5 // indirect
-	github.com/prysmaticlabs/ethereumapis v0.0.0-20210201130911-92b2a467c108
-	github.com/prysmaticlabs/go-bitfield v0.0.0-20210129193852-0db57134419f
+	github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7
 	github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388
-	github.com/rs/zerolog v1.20.0
-	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/spf13/afero v1.5.1 // indirect
-	github.com/spf13/cast v1.3.1 // indirect
-	github.com/spf13/cobra v1.1.1
-	github.com/spf13/jwalterweatherman v1.1.0 // indirect
+	github.com/rs/zerolog v1.26.1
+	github.com/spf13/afero v1.8.0 // indirect
+	github.com/spf13/cobra v1.3.0
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.7.1
-	github.com/stretchr/testify v1.6.1
-	github.com/tj/assert v0.0.3 // indirect
+	github.com/spf13/viper v1.10.1
+	github.com/stretchr/testify v1.7.0
 	github.com/tyler-smith/go-bip39 v1.1.0
-	github.com/ugorji/go v1.1.4 // indirect
-	github.com/wealdtech/eth2-signer-api v1.6.0
 	github.com/wealdtech/go-bytesutil v1.1.1
-	github.com/wealdtech/go-ecodec v1.1.1
-	github.com/wealdtech/go-eth2-types/v2 v2.5.2
-	github.com/wealdtech/go-eth2-util v1.6.3
-	github.com/wealdtech/go-eth2-wallet v1.14.4
-	github.com/wealdtech/go-eth2-wallet-dirk v1.1.5
-	github.com/wealdtech/go-eth2-wallet-distributed v1.1.3
-	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.3
-	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.4
-	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.3
-	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.14
-	github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.4
-	github.com/wealdtech/go-eth2-wallet-store-scratch v1.6.2
-	github.com/wealdtech/go-eth2-wallet-types/v2 v2.8.2
+	github.com/wealdtech/go-ecodec v1.1.2
+	github.com/wealdtech/go-eth2-types/v2 v2.6.0
+	github.com/wealdtech/go-eth2-util v1.7.0
+	github.com/wealdtech/go-eth2-wallet v1.15.0
+	github.com/wealdtech/go-eth2-wallet-dirk v1.2.0
+	github.com/wealdtech/go-eth2-wallet-distributed v1.1.4
+	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.2.0
+	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.6.0
+	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.4.0
+	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.17.0
+	github.com/wealdtech/go-eth2-wallet-store-s3 v1.10.0
+	github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.0
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.9.0
 	github.com/wealdtech/go-string2eth v1.1.0
-	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad
-	golang.org/x/net v0.0.0-20210119194325-5f4716e94777 // indirect
-	golang.org/x/text v0.3.5
-	google.golang.org/genproto v0.0.0-20210201184850-646a494a81ea // indirect
-	google.golang.org/grpc v1.35.0
-	gopkg.in/ini.v1 v1.62.0 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
+	golang.org/x/crypto v0.0.0-20220128200615-198e4374d7ed // indirect
+	golang.org/x/text v0.3.7
+	google.golang.org/genproto v0.0.0-20220126215142-9970aeb2e350 // indirect
+	google.golang.org/grpc v1.44.0
+	gopkg.in/ini.v1 v1.66.3 // indirect
 )

services/chaintime/service.go

@@ -0,0 +1,57 @@
+// Copyright © 2021 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 chaintime
+
+import (
+	"time"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+)
+
+// Service provides a number of functions for calculating chain-related times.
+type Service interface {
+	// GenesisTime provides the time of the chain's genesis.
+	GenesisTime() time.Time
+	// SlotsPerEpoch provides the number of slots in the chain's epoch.
+	SlotsPerEpoch() uint64
+	// SlotDuration provides the duration of the chain's slot.
+	SlotDuration() time.Duration
+
+	// StartOfSlot provides the time at which a given slot starts.
+	StartOfSlot(slot phase0.Slot) time.Time
+	// StartOfEpoch provides the time at which a given epoch starts.
+	StartOfEpoch(epoch phase0.Epoch) time.Time
+	// CurrentSlot provides the current slot.
+	CurrentSlot() phase0.Slot
+	// CurrentEpoch provides the current epoch.
+	CurrentEpoch() phase0.Epoch
+	// CurrentSyncCommitteePeriod provides the current sync committee period.
+	CurrentSyncCommitteePeriod() uint64
+	// SlotToEpoch provides the epoch of the given slot.
+	SlotToEpoch(slot phase0.Slot) phase0.Epoch
+	// SlotToSyncCommitteePeriod provides the sync committee period of the given slot.
+	SlotToSyncCommitteePeriod(slot phase0.Slot) uint64
+	// FirstSlotOfEpoch provides the first slot of the given epoch.
+	FirstSlotOfEpoch(epoch phase0.Epoch) phase0.Slot
+	// TimestampToSlot provides the slot of the given timestamp.
+	TimestampToSlot(timestamp time.Time) phase0.Slot
+	// TimestampToEpoch provides the epoch of the given timestamp.
+	TimestampToEpoch(timestamp time.Time) phase0.Epoch
+	// FirstEpochOfSyncPeriod provides the first epoch of the given sync period.
+	FirstEpochOfSyncPeriod(period uint64) phase0.Epoch
+	// AltairInitialEpoch provides the epoch at which the Altair hard fork takes place.
+	AltairInitialEpoch() phase0.Epoch
+	// AltairInitialSyncCommitteePeriod provides the sync committee period in which the Altair hard fork takes place.
+	AltairInitialSyncCommitteePeriod() uint64
+}

services/chaintime/standard/parameters.go

@@ -0,0 +1,90 @@
+// Copyright © 2021 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 standard
+
+import (
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
+)
+
+type parameters struct {
+	logLevel             zerolog.Level
+	genesisTimeProvider  eth2client.GenesisTimeProvider
+	specProvider         eth2client.SpecProvider
+	forkScheduleProvider eth2client.ForkScheduleProvider
+}
+
+// Parameter is the interface for service parameters.
+type Parameter interface {
+	apply(*parameters)
+}
+
+type parameterFunc func(*parameters)
+
+func (f parameterFunc) apply(p *parameters) {
+	f(p)
+}
+
+// WithLogLevel sets the log level for the module.
+func WithLogLevel(logLevel zerolog.Level) Parameter {
+	return parameterFunc(func(p *parameters) {
+		p.logLevel = logLevel
+	})
+}
+
+// WithGenesisTimeProvider sets the genesis time provider.
+func WithGenesisTimeProvider(provider eth2client.GenesisTimeProvider) Parameter {
+	return parameterFunc(func(p *parameters) {
+		p.genesisTimeProvider = provider
+	})
+}
+
+// WithSpecProvider sets the spec provider.
+func WithSpecProvider(provider eth2client.SpecProvider) Parameter {
+	return parameterFunc(func(p *parameters) {
+		p.specProvider = provider
+	})
+}
+
+// WithForkScheduleProvider sets the fork schedule provider.
+func WithForkScheduleProvider(provider eth2client.ForkScheduleProvider) Parameter {
+	return parameterFunc(func(p *parameters) {
+		p.forkScheduleProvider = provider
+	})
+}
+
+// parseAndCheckParameters parses and checks parameters to ensure that mandatory parameters are present and correct.
+func parseAndCheckParameters(params ...Parameter) (*parameters, error) {
+	parameters := parameters{
+		logLevel: zerolog.GlobalLevel(),
+	}
+	for _, p := range params {
+		if params != nil {
+			p.apply(&parameters)
+		}
+	}
+
+	if parameters.specProvider == nil {
+		return nil, errors.New("no spec provider specified")
+	}
+	if parameters.genesisTimeProvider == nil {
+		return nil, errors.New("no genesis time provider specified")
+	}
+	if parameters.forkScheduleProvider == nil {
+		return nil, errors.New("no fork schedule provider specified")
+	}
+
+	return &parameters, nil
+}

services/chaintime/standard/service.go

@@ -0,0 +1,249 @@
+// Copyright © 2021 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 standard
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/pkg/errors"
+	"github.com/rs/zerolog"
+	zerologger "github.com/rs/zerolog/log"
+)
+
+// Service provides chain time services.
+type Service struct {
+	genesisTime                  time.Time
+	slotDuration                 time.Duration
+	slotsPerEpoch                uint64
+	epochsPerSyncCommitteePeriod uint64
+	altairForkEpoch              phase0.Epoch
+	bellatrixForkEpoch           phase0.Epoch
+}
+
+// module-wide log.
+var log zerolog.Logger
+
+// New creates a new controller.
+func New(ctx context.Context, params ...Parameter) (*Service, error) {
+	parameters, err := parseAndCheckParameters(params...)
+	if err != nil {
+		return nil, errors.Wrap(err, "problem with parameters")
+	}
+
+	// Set logging.
+	log = zerologger.With().Str("service", "chaintime").Str("impl", "standard").Logger().Level(parameters.logLevel)
+
+	genesisTime, err := parameters.genesisTimeProvider.GenesisTime(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain genesis time")
+	}
+	log.Trace().Time("genesis_time", genesisTime).Msg("Obtained genesis time")
+
+	spec, err := parameters.specProvider.Spec(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to obtain spec")
+	}
+
+	tmp, exists := spec["SECONDS_PER_SLOT"]
+	if !exists {
+		return nil, errors.New("SECONDS_PER_SLOT not found in spec")
+	}
+	slotDuration, ok := tmp.(time.Duration)
+	if !ok {
+		return nil, errors.New("SECONDS_PER_SLOT of unexpected type")
+	}
+
+	tmp, exists = spec["SLOTS_PER_EPOCH"]
+	if !exists {
+		return nil, errors.New("SLOTS_PER_EPOCH not found in spec")
+	}
+	slotsPerEpoch, ok := tmp.(uint64)
+	if !ok {
+		return nil, errors.New("SLOTS_PER_EPOCH of unexpected type")
+	}
+
+	var epochsPerSyncCommitteePeriod uint64
+	if tmp, exists := spec["EPOCHS_PER_SYNC_COMMITTEE_PERIOD"]; exists {
+		tmp2, ok := tmp.(uint64)
+		if !ok {
+			return nil, errors.New("EPOCHS_PER_SYNC_COMMITTEE_PERIOD of unexpected type")
+		}
+		epochsPerSyncCommitteePeriod = tmp2
+	}
+
+	altairForkEpoch, err := fetchAltairForkEpoch(ctx, parameters.forkScheduleProvider)
+	if err != nil {
+		// Set to far future epoch.
+		altairForkEpoch = 0xffffffffffffffff
+	}
+	log.Trace().Uint64("epoch", uint64(altairForkEpoch)).Msg("Obtained Altair fork epoch")
+
+	bellatrixForkEpoch, err := fetchBellatrixForkEpoch(ctx, parameters.forkScheduleProvider)
+	if err != nil {
+		// Set to far future epoch.
+		bellatrixForkEpoch = 0xffffffffffffffff
+	}
+	log.Trace().Uint64("epoch", uint64(bellatrixForkEpoch)).Msg("Obtained Bellatrix fork epoch")
+
+	s := &Service{
+		genesisTime:                  genesisTime,
+		slotDuration:                 slotDuration,
+		slotsPerEpoch:                slotsPerEpoch,
+		epochsPerSyncCommitteePeriod: epochsPerSyncCommitteePeriod,
+		altairForkEpoch:              altairForkEpoch,
+		bellatrixForkEpoch:           bellatrixForkEpoch,
+	}
+
+	return s, nil
+}
+
+// GenesisTime provides the time of the chain's genesis.
+func (s *Service) GenesisTime() time.Time {
+	return s.genesisTime
+}
+
+// SlotsPerEpoch provides the number of slots in the chain's epoch.
+func (s *Service) SlotsPerEpoch() uint64 {
+	return s.slotsPerEpoch
+}
+
+// SlotDuration provides the duration of the chain's slot.
+func (s *Service) SlotDuration() time.Duration {
+	return s.slotDuration
+}
+
+// StartOfSlot provides the time at which a given slot starts.
+func (s *Service) StartOfSlot(slot phase0.Slot) time.Time {
+	return s.genesisTime.Add(time.Duration(slot) * s.slotDuration)
+}
+
+// StartOfEpoch provides the time at which a given epoch starts.
+func (s *Service) StartOfEpoch(epoch phase0.Epoch) time.Time {
+	return s.genesisTime.Add(time.Duration(uint64(epoch)*s.slotsPerEpoch) * s.slotDuration)
+}
+
+// CurrentSlot provides the current slot.
+func (s *Service) CurrentSlot() phase0.Slot {
+	if s.genesisTime.After(time.Now()) {
+		return 0
+	}
+	return phase0.Slot(uint64(time.Since(s.genesisTime).Seconds()) / uint64(s.slotDuration.Seconds()))
+}
+
+// CurrentEpoch provides the current epoch.
+func (s *Service) CurrentEpoch() phase0.Epoch {
+	return phase0.Epoch(uint64(s.CurrentSlot()) / s.slotsPerEpoch)
+}
+
+// CurrentSyncCommitteePeriod provides the current sync committee period.
+func (s *Service) CurrentSyncCommitteePeriod() uint64 {
+	return uint64(s.CurrentEpoch()) / s.epochsPerSyncCommitteePeriod
+}
+
+// SlotToEpoch provides the epoch of a given slot.
+func (s *Service) SlotToEpoch(slot phase0.Slot) phase0.Epoch {
+	return phase0.Epoch(uint64(slot) / s.slotsPerEpoch)
+}
+
+// SlotToSyncCommitteePeriod provides the sync committee period of the given slot.
+func (s *Service) SlotToSyncCommitteePeriod(slot phase0.Slot) uint64 {
+	return uint64(s.SlotToEpoch(slot)) / s.epochsPerSyncCommitteePeriod
+}
+
+// FirstSlotOfEpoch provides the first slot of the given epoch.
+func (s *Service) FirstSlotOfEpoch(epoch phase0.Epoch) phase0.Slot {
+	return phase0.Slot(uint64(epoch) * s.slotsPerEpoch)
+}
+
+// TimestampToSlot provides the slot of the given timestamp.
+func (s *Service) TimestampToSlot(timestamp time.Time) phase0.Slot {
+	if timestamp.Before(s.genesisTime) {
+		return 0
+	}
+	secondsSinceGenesis := uint64(timestamp.Sub(s.genesisTime).Seconds())
+	return phase0.Slot(secondsSinceGenesis / uint64(s.slotDuration.Seconds()))
+}
+
+// TimestampToEpoch provides the epoch of the given timestamp.
+func (s *Service) TimestampToEpoch(timestamp time.Time) phase0.Epoch {
+	if timestamp.Before(s.genesisTime) {
+		return 0
+	}
+	secondsSinceGenesis := uint64(timestamp.Sub(s.genesisTime).Seconds())
+	return phase0.Epoch(secondsSinceGenesis / uint64(s.slotDuration.Seconds()) / s.slotsPerEpoch)
+}
+
+// FirstEpochOfSyncPeriod provides the first epoch of the given sync period.
+// Note that epochs before the sync committee period will provide the Altair hard fork epoch.
+func (s *Service) FirstEpochOfSyncPeriod(period uint64) phase0.Epoch {
+	epoch := phase0.Epoch(period * s.epochsPerSyncCommitteePeriod)
+	if epoch < s.altairForkEpoch {
+		epoch = s.altairForkEpoch
+	}
+	return epoch
+}
+
+// AltairInitialEpoch provides the epoch at which the Altair hard fork takes place.
+func (s *Service) AltairInitialEpoch() phase0.Epoch {
+	return s.altairForkEpoch
+}
+
+// AltairInitialSyncCommitteePeriod provides the sync committee period in which the Altair hard fork takes place.
+func (s *Service) AltairInitialSyncCommitteePeriod() uint64 {
+	return uint64(s.altairForkEpoch) / s.epochsPerSyncCommitteePeriod
+}
+
+func fetchAltairForkEpoch(ctx context.Context, provider eth2client.ForkScheduleProvider) (phase0.Epoch, error) {
+	forkSchedule, err := provider.ForkSchedule(ctx)
+	if err != nil {
+		return 0, err
+	}
+	for i := range forkSchedule {
+		if bytes.Equal(forkSchedule[i].CurrentVersion[:], forkSchedule[i].PreviousVersion[:]) {
+			// This is the genesis fork; ignore it.
+			continue
+		}
+		return forkSchedule[i].Epoch, nil
+	}
+	return 0, errors.New("no altair fork obtained")
+}
+
+// BellatrixInitialEpoch provides the epoch at which the Bellatrix hard fork takes place.
+func (s *Service) BellatrixInitialEpoch() phase0.Epoch {
+	return s.bellatrixForkEpoch
+}
+
+func fetchBellatrixForkEpoch(ctx context.Context, provider eth2client.ForkScheduleProvider) (phase0.Epoch, error) {
+	forkSchedule, err := provider.ForkSchedule(ctx)
+	if err != nil {
+		return 0, err
+	}
+	count := 0
+	for i := range forkSchedule {
+		count++
+		if bytes.Equal(forkSchedule[i].CurrentVersion[:], forkSchedule[i].PreviousVersion[:]) {
+			// This is the genesis fork; ignore it.
+			continue
+		}
+		if count == 1 {
+			return forkSchedule[i].Epoch, nil
+		}
+		count++
+	}
+	return 0, errors.New("no bellatrix fork obtained")
+}

services/chaintime/standard/service_test.go

@@ -0,0 +1,258 @@
+// Copyright © 2021 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 standard_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/require"
+	"github.com/wealdtech/ethdo/services/chaintime"
+	"github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/testing/mock"
+)
+
+func TestService(t *testing.T) {
+	genesisTime := time.Now()
+	slotDuration := 12 * time.Second
+	slotsPerEpoch := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
+	forkSchedule := []*phase0.Fork{
+		{
+			PreviousVersion: phase0.Version{0x01, 0x02, 0x03, 0x04},
+			CurrentVersion:  phase0.Version{0x01, 0x02, 0x03, 0x04},
+			Epoch:           0,
+		},
+		{
+			PreviousVersion: phase0.Version{0x01, 0x02, 0x03, 0x04},
+			CurrentVersion:  phase0.Version{0x05, 0x06, 0x07, 0x08},
+			Epoch:           10,
+		},
+	}
+
+	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
+	mockForkScheduleProvider := mock.NewForkScheduleProvider(forkSchedule)
+
+	tests := []struct {
+		name   string
+		params []standard.Parameter
+		err    string
+	}{
+		{
+			name: "GenesisTimeProviderMissing",
+			params: []standard.Parameter{
+				standard.WithLogLevel(zerolog.Disabled),
+				standard.WithSpecProvider(mockSpecProvider),
+				standard.WithForkScheduleProvider(mockForkScheduleProvider),
+			},
+			err: "problem with parameters: no genesis time provider specified",
+		},
+		{
+			name: "SpecProviderMissing",
+			params: []standard.Parameter{
+				standard.WithLogLevel(zerolog.Disabled),
+				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+				standard.WithForkScheduleProvider(mockForkScheduleProvider),
+			},
+			err: "problem with parameters: no spec provider specified",
+		},
+		{
+			name: "ForkScheduleProviderMissing",
+			params: []standard.Parameter{
+				standard.WithLogLevel(zerolog.Disabled),
+				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+				standard.WithSpecProvider(mockSpecProvider),
+			},
+			err: "problem with parameters: no fork schedule provider specified",
+		},
+		{
+			name: "Good",
+			params: []standard.Parameter{
+				standard.WithLogLevel(zerolog.Disabled),
+				standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+				standard.WithSpecProvider(mockSpecProvider),
+				standard.WithForkScheduleProvider(mockForkScheduleProvider),
+			},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			_, err := standard.New(context.Background(), test.params...)
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
+// createService is a helper that creates a mock chaintime service.
+func createService(genesisTime time.Time) (chaintime.Service, time.Duration, uint64, uint64, []*phase0.Fork, error) {
+	slotDuration := 12 * time.Second
+	slotsPerEpoch := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
+	forkSchedule := []*phase0.Fork{
+		{
+			PreviousVersion: phase0.Version{0x01, 0x02, 0x03, 0x04},
+			CurrentVersion:  phase0.Version{0x01, 0x02, 0x03, 0x04},
+			Epoch:           0,
+		},
+		{
+			PreviousVersion: phase0.Version{0x01, 0x02, 0x03, 0x04},
+			CurrentVersion:  phase0.Version{0x05, 0x06, 0x07, 0x08},
+			Epoch:           10,
+		},
+	}
+
+	mockGenesisTimeProvider := mock.NewGenesisTimeProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
+	mockForkScheduleProvider := mock.NewForkScheduleProvider(forkSchedule)
+	s, err := standard.New(context.Background(),
+		standard.WithGenesisTimeProvider(mockGenesisTimeProvider),
+		standard.WithSpecProvider(mockSpecProvider),
+		standard.WithForkScheduleProvider(mockForkScheduleProvider),
+	)
+	return s, slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod, forkSchedule, err
+}
+
+func TestGenesisTime(t *testing.T) {
+	genesisTime := time.Now()
+	s, _, _, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	require.Equal(t, genesisTime, s.GenesisTime())
+}
+
+func TestStartOfSlot(t *testing.T) {
+	genesisTime := time.Now()
+	s, slotDuration, _, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	require.Equal(t, genesisTime, s.StartOfSlot(0))
+	require.Equal(t, genesisTime.Add(1000*slotDuration), s.StartOfSlot(1000))
+}
+
+func TestStartOfEpoch(t *testing.T) {
+	genesisTime := time.Now()
+	s, slotDuration, slotsPerEpoch, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	require.Equal(t, genesisTime, s.StartOfEpoch(0))
+	require.Equal(t, genesisTime.Add(time.Duration(1000*slotsPerEpoch)*slotDuration), s.StartOfEpoch(1000))
+}
+
+func TestCurrentSlot(t *testing.T) {
+	genesisTime := time.Now().Add(-60 * time.Second)
+	s, _, _, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	require.Equal(t, phase0.Slot(5), s.CurrentSlot())
+}
+
+func TestCurrentEpoch(t *testing.T) {
+	genesisTime := time.Now().Add(-1000 * time.Second)
+	s, _, _, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	require.Equal(t, phase0.Epoch(2), s.CurrentEpoch())
+}
+
+func TestTimestampToSlot(t *testing.T) {
+	genesisTime := time.Now()
+	s, _, _, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name      string
+		timestamp time.Time
+		slot      phase0.Slot
+	}{
+		{
+			name:      "PreGenesis",
+			timestamp: genesisTime.AddDate(0, 0, -1),
+			slot:      0,
+		},
+		{
+			name:      "Genesis",
+			timestamp: genesisTime,
+			slot:      0,
+		},
+		{
+			name:      "Slot1",
+			timestamp: genesisTime.Add(12 * time.Second),
+			slot:      1,
+		},
+		{
+			name:      "Slot999",
+			timestamp: genesisTime.Add(999 * 12 * time.Second),
+			slot:      999,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			require.Equal(t, test.slot, s.TimestampToSlot(test.timestamp))
+		})
+	}
+}
+
+func TestTimestampToEpoch(t *testing.T) {
+	genesisTime := time.Now()
+	s, _, _, _, _, err := createService(genesisTime)
+	require.NoError(t, err)
+
+	tests := []struct {
+		name      string
+		timestamp time.Time
+		epoch     phase0.Epoch
+	}{
+		{
+			name:      "PreGenesis",
+			timestamp: genesisTime.AddDate(0, 0, -1),
+			epoch:     0,
+		},
+		{
+			name:      "Genesis",
+			timestamp: genesisTime,
+			epoch:     0,
+		},
+		{
+			name:      "Epoch1",
+			timestamp: genesisTime.Add(32 * 12 * time.Second),
+			epoch:     1,
+		},
+		{
+			name:      "Epoch1Boundary",
+			timestamp: genesisTime.Add(64 * 12 * time.Second).Add(-1 * time.Millisecond),
+			epoch:     1,
+		},
+		{
+			name:      "Epoch999",
+			timestamp: genesisTime.Add(999 * 32 * 12 * time.Second),
+			epoch:     999,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			require.Equal(t, test.epoch, s.TimestampToEpoch(test.timestamp))
+		})
+	}
+}

shamir/shamir.go

@@ -0,0 +1,234 @@
+package shamir
+
+import (
+	"crypto/rand"
+	"crypto/subtle"
+	"fmt"
+	mathrand "math/rand"
+	"time"
+)
+
+const (
+	// ShareOverhead is the byte size overhead of each share
+	// when using Split on a secret. This is caused by appending
+	// a one byte tag to the share.
+	ShareOverhead = 1
+)
+
+// polynomial represents a polynomial of arbitrary degree
+type polynomial struct {
+	coefficients []uint8
+}
+
+// makePolynomial constructs a random polynomial of the given
+// degree but with the provided intercept value.
+func makePolynomial(intercept, degree uint8) (polynomial, error) {
+	// Create a wrapper
+	p := polynomial{
+		coefficients: make([]byte, degree+1),
+	}
+
+	// Ensure the intercept is set
+	p.coefficients[0] = intercept
+
+	// Assign random co-efficients to the polynomial
+	if _, err := rand.Read(p.coefficients[1:]); err != nil {
+		return p, err
+	}
+
+	return p, nil
+}
+
+// evaluate returns the value of the polynomial for the given x
+func (p *polynomial) evaluate(x uint8) uint8 {
+	// Special case the origin
+	if x == 0 {
+		return p.coefficients[0]
+	}
+
+	// Compute the polynomial value using Horner's method.
+	degree := len(p.coefficients) - 1
+	out := p.coefficients[degree]
+	for i := degree - 1; i >= 0; i-- {
+		coeff := p.coefficients[i]
+		out = add(mult(out, x), coeff)
+	}
+	return out
+}
+
+// interpolatePolynomial takes N sample points and returns
+// the value at a given x using a lagrange interpolation.
+func interpolatePolynomial(xSamples, ySamples []uint8, x uint8) uint8 {
+	limit := len(xSamples)
+	var result, basis uint8
+	for i := 0; i < limit; i++ {
+		basis = 1
+		for j := 0; j < limit; j++ {
+			if i == j {
+				continue
+			}
+			num := add(x, xSamples[j])
+			denom := add(xSamples[i], xSamples[j])
+			term := div(num, denom)
+			basis = mult(basis, term)
+		}
+		group := mult(ySamples[i], basis)
+		result = add(result, group)
+	}
+	return result
+}
+
+// div divides two numbers in GF(2^8)
+func div(a, b uint8) uint8 {
+	if b == 0 {
+		// leaks some timing information but we don't care anyways as this
+		// should never happen, hence the panic
+		panic("divide by zero")
+	}
+
+	logA := logTable[a]
+	logB := logTable[b]
+	diff := ((int(logA) - int(logB)) + 255) % 255
+
+	ret := int(expTable[diff])
+
+	// Ensure we return zero if a is zero but aren't subject to timing attacks
+	ret = subtle.ConstantTimeSelect(subtle.ConstantTimeByteEq(a, 0), 0, ret)
+	return uint8(ret)
+}
+
+// mult multiplies two numbers in GF(2^8)
+func mult(a, b uint8) (out uint8) {
+	logA := logTable[a]
+	logB := logTable[b]
+	sum := (int(logA) + int(logB)) % 255
+
+	ret := int(expTable[sum])
+
+	// Ensure we return zero if either a or b are zero but aren't subject to
+	// timing attacks
+	ret = subtle.ConstantTimeSelect(subtle.ConstantTimeByteEq(a, 0), 0, ret)
+	ret = subtle.ConstantTimeSelect(subtle.ConstantTimeByteEq(b, 0), 0, ret)
+
+	return uint8(ret)
+}
+
+// add combines two numbers in GF(2^8)
+// This can also be used for subtraction since it is symmetric.
+func add(a, b uint8) uint8 {
+	return a ^ b
+}
+
+// Split takes an arbitrarily long secret and generates a `parts`
+// number of shares, `threshold` of which are required to reconstruct
+// the secret. The parts and threshold must be at least 2, and less
+// than 256. The returned shares are each one byte longer than the secret
+// as they attach a tag used to reconstruct the secret.
+func Split(secret []byte, parts, threshold int) ([][]byte, error) {
+	// Sanity check the input
+	if parts < threshold {
+		return nil, fmt.Errorf("parts cannot be less than threshold")
+	}
+	if parts > 255 {
+		return nil, fmt.Errorf("parts cannot exceed 255")
+	}
+	if threshold < 2 {
+		return nil, fmt.Errorf("threshold must be at least 2")
+	}
+	if threshold > 255 {
+		return nil, fmt.Errorf("threshold cannot exceed 255")
+	}
+	if len(secret) == 0 {
+		return nil, fmt.Errorf("cannot split an empty secret")
+	}
+
+	// Generate random list of x coordinates
+	mathrand.Seed(time.Now().UnixNano())
+	xCoordinates := mathrand.Perm(255)
+
+	// Allocate the output array, initialize the final byte
+	// of the output with the offset. The representation of each
+	// output is {y1, y2, .., yN, x}.
+	out := make([][]byte, parts)
+	for idx := range out {
+		out[idx] = make([]byte, len(secret)+1)
+		out[idx][len(secret)] = uint8(xCoordinates[idx]) + 1
+	}
+
+	// Construct a random polynomial for each byte of the secret.
+	// Because we are using a field of size 256, we can only represent
+	// a single byte as the intercept of the polynomial, so we must
+	// use a new polynomial for each byte.
+	for idx, val := range secret {
+		p, err := makePolynomial(val, uint8(threshold-1))
+		if err != nil {
+			return nil, fmt.Errorf("failed to generate polynomial: %w", err)
+		}
+
+		// Generate a `parts` number of (x,y) pairs
+		// We cheat by encoding the x value once as the final index,
+		// so that it only needs to be stored once.
+		for i := 0; i < parts; i++ {
+			x := uint8(xCoordinates[i]) + 1
+			y := p.evaluate(x)
+			out[i][idx] = y
+		}
+	}
+
+	// Return the encoded secrets
+	return out, nil
+}
+
+// Combine is used to reverse a Split and reconstruct a secret
+// once a `threshold` number of parts are available.
+func Combine(parts [][]byte) ([]byte, error) {
+	// Verify enough parts provided
+	if len(parts) < 2 {
+		return nil, fmt.Errorf("less than two parts cannot be used to reconstruct the secret")
+	}
+
+	// Verify the parts are all the same length
+	firstPartLen := len(parts[0])
+	if firstPartLen < 2 {
+		return nil, fmt.Errorf("parts must be at least two bytes")
+	}
+	for i := 1; i < len(parts); i++ {
+		if len(parts[i]) != firstPartLen {
+			return nil, fmt.Errorf("all parts must be the same length")
+		}
+	}
+
+	// Create a buffer to store the reconstructed secret
+	secret := make([]byte, firstPartLen-1)
+
+	// Buffer to store the samples
+	xSamples := make([]uint8, len(parts))
+	ySamples := make([]uint8, len(parts))
+
+	// Set the x value for each sample and ensure no x_sample values are the same,
+	// otherwise div() can be unhappy
+	checkMap := map[byte]bool{}
+	for i, part := range parts {
+		samp := part[firstPartLen-1]
+		if exists := checkMap[samp]; exists {
+			return nil, fmt.Errorf("duplicate part detected")
+		}
+		checkMap[samp] = true
+		xSamples[i] = samp
+	}
+
+	// Reconstruct each byte
+	for idx := range secret {
+		// Set the y value for each sample
+		for i, part := range parts {
+			ySamples[i] = part[idx]
+		}
+
+		// Interpolate the polynomial and compute the value at 0
+		val := interpolatePolynomial(xSamples, ySamples, 0)
+
+		// Evaluate the 0th value to get the intercept
+		secret[idx] = val
+	}
+	return secret, nil
+}

shamir/shamir_test.go

@@ -0,0 +1,198 @@
+package shamir
+
+import (
+	"bytes"
+	"testing"
+)
+
+func TestSplit_invalid(t *testing.T) {
+	secret := []byte("test")
+
+	if _, err := Split(secret, 0, 0); err == nil {
+		t.Fatalf("expect error")
+	}
+
+	if _, err := Split(secret, 2, 3); err == nil {
+		t.Fatalf("expect error")
+	}
+
+	if _, err := Split(secret, 1000, 3); err == nil {
+		t.Fatalf("expect error")
+	}
+
+	if _, err := Split(secret, 10, 1); err == nil {
+		t.Fatalf("expect error")
+	}
+
+	if _, err := Split(nil, 3, 2); err == nil {
+		t.Fatalf("expect error")
+	}
+}
+
+func TestSplit(t *testing.T) {
+	secret := []byte("test")
+
+	out, err := Split(secret, 5, 3)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	if len(out) != 5 {
+		t.Fatalf("bad: %v", out)
+	}
+
+	for _, share := range out {
+		if len(share) != len(secret)+1 {
+			t.Fatalf("bad: %v", out)
+		}
+	}
+}
+
+func TestCombine_invalid(t *testing.T) {
+	// Not enough parts
+	if _, err := Combine(nil); err == nil {
+		t.Fatalf("should err")
+	}
+
+	// Mis-match in length
+	parts := [][]byte{
+		[]byte("foo"),
+		[]byte("ba"),
+	}
+	if _, err := Combine(parts); err == nil {
+		t.Fatalf("should err")
+	}
+
+	// Too short
+	parts = [][]byte{
+		[]byte("f"),
+		[]byte("b"),
+	}
+	if _, err := Combine(parts); err == nil {
+		t.Fatalf("should err")
+	}
+
+	parts = [][]byte{
+		[]byte("foo"),
+		[]byte("foo"),
+	}
+	if _, err := Combine(parts); err == nil {
+		t.Fatalf("should err")
+	}
+}
+
+func TestCombine(t *testing.T) {
+	secret := []byte("test")
+
+	out, err := Split(secret, 5, 3)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	// There is 5*4*3 possible choices,
+	// we will just brute force try them all
+	for i := 0; i < 5; i++ {
+		for j := 0; j < 5; j++ {
+			if j == i {
+				continue
+			}
+			for k := 0; k < 5; k++ {
+				if k == i || k == j {
+					continue
+				}
+				parts := [][]byte{out[i], out[j], out[k]}
+				recomb, err := Combine(parts)
+				if err != nil {
+					t.Fatalf("err: %v", err)
+				}
+
+				if !bytes.Equal(recomb, secret) {
+					t.Errorf("parts: (i:%d, j:%d, k:%d) %v", i, j, k, parts)
+					t.Fatalf("bad: %v %v", recomb, secret)
+				}
+			}
+		}
+	}
+}
+
+func TestField_Add(t *testing.T) {
+	if out := add(16, 16); out != 0 {
+		t.Fatalf("Bad: %v 16", out)
+	}
+
+	if out := add(3, 4); out != 7 {
+		t.Fatalf("Bad: %v 7", out)
+	}
+}
+
+func TestField_Mult(t *testing.T) {
+	if out := mult(3, 7); out != 9 {
+		t.Fatalf("Bad: %v 9", out)
+	}
+
+	if out := mult(3, 0); out != 0 {
+		t.Fatalf("Bad: %v 0", out)
+	}
+
+	if out := mult(0, 3); out != 0 {
+		t.Fatalf("Bad: %v 0", out)
+	}
+}
+
+func TestField_Divide(t *testing.T) {
+	if out := div(0, 7); out != 0 {
+		t.Fatalf("Bad: %v 0", out)
+	}
+
+	if out := div(3, 3); out != 1 {
+		t.Fatalf("Bad: %v 1", out)
+	}
+
+	if out := div(6, 3); out != 2 {
+		t.Fatalf("Bad: %v 2", out)
+	}
+}
+
+func TestPolynomial_Random(t *testing.T) {
+	p, err := makePolynomial(42, 2)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	if p.coefficients[0] != 42 {
+		t.Fatalf("bad: %v", p.coefficients)
+	}
+}
+
+func TestPolynomial_Eval(t *testing.T) {
+	p, err := makePolynomial(42, 1)
+	if err != nil {
+		t.Fatalf("err: %v", err)
+	}
+
+	if out := p.evaluate(0); out != 42 {
+		t.Fatalf("bad: %v", out)
+	}
+
+	out := p.evaluate(1)
+	exp := add(42, mult(1, p.coefficients[1]))
+	if out != exp {
+		t.Fatalf("bad: %v %v %v", out, exp, p.coefficients)
+	}
+}
+
+func TestInterpolate_Rand(t *testing.T) {
+	for i := 0; i < 256; i++ {
+		p, err := makePolynomial(uint8(i), 2)
+		if err != nil {
+			t.Fatalf("err: %v", err)
+		}
+
+		xVals := []uint8{1, 2, 3}
+		yVals := []uint8{p.evaluate(1), p.evaluate(2), p.evaluate(3)}
+		out := interpolatePolynomial(xVals, yVals, 0)
+		if out != uint8(i) {
+			t.Fatalf("Bad: %v %d", out, i)
+		}
+	}
+}

shamir/tables.go

@@ -0,0 +1,79 @@
+package shamir
+
+// Tables taken from http://www.samiam.org/galois.html
+// They use 0xe5 (229) as the generator
+
+var (
+	// logTable provides the log(X)/log(g) at each index X
+	logTable = [256]uint8{
+		0x00, 0xff, 0xc8, 0x08, 0x91, 0x10, 0xd0, 0x36,
+		0x5a, 0x3e, 0xd8, 0x43, 0x99, 0x77, 0xfe, 0x18,
+		0x23, 0x20, 0x07, 0x70, 0xa1, 0x6c, 0x0c, 0x7f,
+		0x62, 0x8b, 0x40, 0x46, 0xc7, 0x4b, 0xe0, 0x0e,
+		0xeb, 0x16, 0xe8, 0xad, 0xcf, 0xcd, 0x39, 0x53,
+		0x6a, 0x27, 0x35, 0x93, 0xd4, 0x4e, 0x48, 0xc3,
+		0x2b, 0x79, 0x54, 0x28, 0x09, 0x78, 0x0f, 0x21,
+		0x90, 0x87, 0x14, 0x2a, 0xa9, 0x9c, 0xd6, 0x74,
+		0xb4, 0x7c, 0xde, 0xed, 0xb1, 0x86, 0x76, 0xa4,
+		0x98, 0xe2, 0x96, 0x8f, 0x02, 0x32, 0x1c, 0xc1,
+		0x33, 0xee, 0xef, 0x81, 0xfd, 0x30, 0x5c, 0x13,
+		0x9d, 0x29, 0x17, 0xc4, 0x11, 0x44, 0x8c, 0x80,
+		0xf3, 0x73, 0x42, 0x1e, 0x1d, 0xb5, 0xf0, 0x12,
+		0xd1, 0x5b, 0x41, 0xa2, 0xd7, 0x2c, 0xe9, 0xd5,
+		0x59, 0xcb, 0x50, 0xa8, 0xdc, 0xfc, 0xf2, 0x56,
+		0x72, 0xa6, 0x65, 0x2f, 0x9f, 0x9b, 0x3d, 0xba,
+		0x7d, 0xc2, 0x45, 0x82, 0xa7, 0x57, 0xb6, 0xa3,
+		0x7a, 0x75, 0x4f, 0xae, 0x3f, 0x37, 0x6d, 0x47,
+		0x61, 0xbe, 0xab, 0xd3, 0x5f, 0xb0, 0x58, 0xaf,
+		0xca, 0x5e, 0xfa, 0x85, 0xe4, 0x4d, 0x8a, 0x05,
+		0xfb, 0x60, 0xb7, 0x7b, 0xb8, 0x26, 0x4a, 0x67,
+		0xc6, 0x1a, 0xf8, 0x69, 0x25, 0xb3, 0xdb, 0xbd,
+		0x66, 0xdd, 0xf1, 0xd2, 0xdf, 0x03, 0x8d, 0x34,
+		0xd9, 0x92, 0x0d, 0x63, 0x55, 0xaa, 0x49, 0xec,
+		0xbc, 0x95, 0x3c, 0x84, 0x0b, 0xf5, 0xe6, 0xe7,
+		0xe5, 0xac, 0x7e, 0x6e, 0xb9, 0xf9, 0xda, 0x8e,
+		0x9a, 0xc9, 0x24, 0xe1, 0x0a, 0x15, 0x6b, 0x3a,
+		0xa0, 0x51, 0xf4, 0xea, 0xb2, 0x97, 0x9e, 0x5d,
+		0x22, 0x88, 0x94, 0xce, 0x19, 0x01, 0x71, 0x4c,
+		0xa5, 0xe3, 0xc5, 0x31, 0xbb, 0xcc, 0x1f, 0x2d,
+		0x3b, 0x52, 0x6f, 0xf6, 0x2e, 0x89, 0xf7, 0xc0,
+		0x68, 0x1b, 0x64, 0x04, 0x06, 0xbf, 0x83, 0x38,
+	}
+
+	// expTable provides the anti-log or exponentiation value
+	// for the equivalent index
+	expTable = [256]uint8{
+		0x01, 0xe5, 0x4c, 0xb5, 0xfb, 0x9f, 0xfc, 0x12,
+		0x03, 0x34, 0xd4, 0xc4, 0x16, 0xba, 0x1f, 0x36,
+		0x05, 0x5c, 0x67, 0x57, 0x3a, 0xd5, 0x21, 0x5a,
+		0x0f, 0xe4, 0xa9, 0xf9, 0x4e, 0x64, 0x63, 0xee,
+		0x11, 0x37, 0xe0, 0x10, 0xd2, 0xac, 0xa5, 0x29,
+		0x33, 0x59, 0x3b, 0x30, 0x6d, 0xef, 0xf4, 0x7b,
+		0x55, 0xeb, 0x4d, 0x50, 0xb7, 0x2a, 0x07, 0x8d,
+		0xff, 0x26, 0xd7, 0xf0, 0xc2, 0x7e, 0x09, 0x8c,
+		0x1a, 0x6a, 0x62, 0x0b, 0x5d, 0x82, 0x1b, 0x8f,
+		0x2e, 0xbe, 0xa6, 0x1d, 0xe7, 0x9d, 0x2d, 0x8a,
+		0x72, 0xd9, 0xf1, 0x27, 0x32, 0xbc, 0x77, 0x85,
+		0x96, 0x70, 0x08, 0x69, 0x56, 0xdf, 0x99, 0x94,
+		0xa1, 0x90, 0x18, 0xbb, 0xfa, 0x7a, 0xb0, 0xa7,
+		0xf8, 0xab, 0x28, 0xd6, 0x15, 0x8e, 0xcb, 0xf2,
+		0x13, 0xe6, 0x78, 0x61, 0x3f, 0x89, 0x46, 0x0d,
+		0x35, 0x31, 0x88, 0xa3, 0x41, 0x80, 0xca, 0x17,
+		0x5f, 0x53, 0x83, 0xfe, 0xc3, 0x9b, 0x45, 0x39,
+		0xe1, 0xf5, 0x9e, 0x19, 0x5e, 0xb6, 0xcf, 0x4b,
+		0x38, 0x04, 0xb9, 0x2b, 0xe2, 0xc1, 0x4a, 0xdd,
+		0x48, 0x0c, 0xd0, 0x7d, 0x3d, 0x58, 0xde, 0x7c,
+		0xd8, 0x14, 0x6b, 0x87, 0x47, 0xe8, 0x79, 0x84,
+		0x73, 0x3c, 0xbd, 0x92, 0xc9, 0x23, 0x8b, 0x97,
+		0x95, 0x44, 0xdc, 0xad, 0x40, 0x65, 0x86, 0xa2,
+		0xa4, 0xcc, 0x7f, 0xec, 0xc0, 0xaf, 0x91, 0xfd,
+		0xf7, 0x4f, 0x81, 0x2f, 0x5b, 0xea, 0xa8, 0x1c,
+		0x02, 0xd1, 0x98, 0x71, 0xed, 0x25, 0xe3, 0x24,
+		0x06, 0x68, 0xb3, 0x93, 0x2c, 0x6f, 0x3e, 0x6c,
+		0x0a, 0xb8, 0xce, 0xae, 0x74, 0xb1, 0x42, 0xb4,
+		0x1e, 0xd3, 0x49, 0xe9, 0x9c, 0xc8, 0xc6, 0xc7,
+		0x22, 0x6e, 0xdb, 0x20, 0xbf, 0x43, 0x51, 0x52,
+		0x66, 0xb2, 0x76, 0x60, 0xda, 0xc5, 0xf3, 0xf6,
+		0xaa, 0xcd, 0x9a, 0xa0, 0x75, 0x54, 0x0e, 0x01,
+	}
+)

shamir/tables_test.go

@@ -0,0 +1,13 @@
+package shamir
+
+import "testing"
+
+func TestTables(t *testing.T) {
+	for i := 1; i < 256; i++ {
+		logV := logTable[i]
+		expV := expTable[logV]
+		if expV != uint8(i) {
+			t.Fatalf("bad: %d log: %d exp: %d", i, logV, expV)
+		}
+	}
+}