Fix bad dependency.

Altair block info

.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: |
@@ -72,11 +72,11 @@ jobs:
        sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-amd64.sha256
        tar zcf ethdo-${RELEASE_VERSION}-linux-amd64.tar.gz ethdo
 
-    - name: Create linux ARM64 tgz file
-      run: |
-       mv ethdo-linux-arm64 ethdo
-       sha256sum ethdo >ethdo-${RELEASE_VERSION}-linux-arm64.sha256
-       tar zcf ethdo-${RELEASE_VERSION}-linux-arm64.tar.gz ethdo
+       # - name: Create 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 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,3 +1,10 @@
+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)
 

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.14-buster as builder
+FROM golang:1.16-buster as builder
 
 WORKDIR /app
 
@@ -16,4 +16,4 @@ WORKDIR /app
 
 COPY --from=builder /app/ethdo /app
 
-ENTRYPOINT ["/app/ethdo"]
+ENTRYPOINT ["/app/ethdo"]

cmd/attester/inclusion/process.go

@@ -21,7 +21,7 @@ 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/phase0"
 	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/util"
 	e2wtypes "github.com/wealdtech/go-eth2-wallet-types/v2"
@@ -53,7 +53,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	}
 
 	// Fetch validator
-	pubKeys := make([]spec.BLSPubKey, 1)
+	pubKeys := make([]phase0.BLSPubKey, 1)
 	pubKey, err := util.BestPublicKey(account)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain public key for account")
@@ -92,13 +92,21 @@ 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) {
@@ -113,9 +121,9 @@ 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 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/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
@@ -24,7 +24,8 @@ import (
 	"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/phase0"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/wealdtech/go-string2eth"
@@ -47,34 +48,42 @@ 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,
+	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("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", bodyRoot))
 	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("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", string(graffiti)))
 		} 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 +93,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)
@@ -104,7 +113,7 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 					}
 					for _, beaconCommittee := range beaconCommittees {
 						if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
-							validatorCommittees[beaconCommittee.Slot] = make(map[spec.CommitteeIndex][]spec.ValidatorIndex)
+							validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 						}
 						validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
 					}
@@ -113,7 +122,7 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 
 				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("    Aggregation bits: %s\n", bitlistToString(att.AggregationBits)))
 				res.WriteString(fmt.Sprintf("    Attesting indices: %s\n", attestingIndices(att.AggregationBits, committees[att.Data.Index])))
 				res.WriteString(fmt.Sprintf("    Slot: %d\n", att.Data.Slot))
 				res.WriteString(fmt.Sprintf("    Beacon block root: %#x\n", att.Data.BeaconBlockRoot))
@@ -128,7 +137,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 +184,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 +203,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 +223,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 outputAltairBlockText(ctx context.Context, data *dataOut, signedBlock *altair.SignedBeaconBlock) (string, error) {
 	if signedBlock == nil {
 		return "", errors.New("no block supplied")
 	}
@@ -224,7 +271,98 @@ 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)
+	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,
+		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.
+	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,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti,
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
 	if err != nil {
 		return "", err
 	}
@@ -273,10 +411,10 @@ func outputBlockText(ctx context.Context, data *dataOut, signedBlock *spec.Signe
 }
 
 // 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 +425,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 +434,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 +451,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,7 +21,9 @@ 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/phase0"
 	"github.com/pkg/errors"
 )
 
@@ -55,9 +57,20 @@ 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, signedBlock.Altair); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
+	default:
+		return nil, errors.New("unknown block version")
 	}
 
 	if data.stream {
@@ -82,13 +95,30 @@ func headEventHandler(event *api.Event) {
 	signedBlock, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(context.Background(), blockID)
 	if err != nil {
 		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 {
+		fmt.Println("Empty beacon block")
+		return
+	}
+	switch signedBlock.Version {
+	case spec.DataVersionPhase0:
+		if err := outputPhase0Block(context.Background(), jsonOutput, signedBlock.Phase0); err != nil {
+			fmt.Printf("Failed to output block: %v\n", err)
+			return
+		}
+	case spec.DataVersionAltair:
+		if err := outputAltairBlock(context.Background(), jsonOutput, signedBlock.Altair); err != nil {
+			fmt.Printf("Failed to output block: %v\n", err)
+			return
+		}
+	default:
+		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 +127,25 @@ 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, 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))
+	default:
+		data, err := outputAltairBlockText(ctx, results, signedBlock)
 		if err != nil {
 			return errors.Wrap(err, "failed to generate text")
 		}

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))
 

cmd/root.go

@@ -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,6 +57,9 @@ 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")
@@ -82,6 +86,8 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 		nodeEventsBindings()
 	case "slot/time":
 		slotTimeBindings()
+	case "synccommittee/members":
+		synccommitteeMembersBindings()
 	case "validator/depositdata":
 		validatorDepositdataBindings()
 	case "validator/duties":
@@ -109,11 +115,7 @@ func persistentPreRunE(cmd *cobra.Command, args []string) error {
 		fmt.Println("Cannot supply both quiet and debug flags")
 	}
 
-	if err := util.SetupStore(); err != nil {
-		return err
-	}
-
-	return nil
+	return util.SetupStore()
 }
 
 // Execute adds all child commands to the root command and sets flags appropriately.

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/members/input.go

@@ -0,0 +1,78 @@
+// 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"
+	spec "github.com/attestantio/go-eth2-client/spec/phase0"
+	"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      spec.Epoch
+}
+
+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, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")
+	}
+
+	// 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
+	epoch := viper.GetInt64("epoch")
+	if epoch == -1 {
+		data.epoch = data.chainTime.CurrentEpoch()
+	} else {
+		data.epoch = spec.Epoch(epoch)
+	}
+
+	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 Ethereum 2 beacon node: failed to connect to beacon node: problem with parameters: no address specified",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			viper.Reset()
+
+			for k, v := range test.vars {
+				viper.Set(k, v)
+			}
+			res, err := input(context.Background())
+			if test.err != "" {
+				require.EqualError(t, err, test.err)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, test.res.timeout, res.timeout)
+			}
+		})
+	}
+}

cmd/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,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"
+	"fmt"
+
+	eth2client "github.com/attestantio/go-eth2-client"
+	"github.com/pkg/errors"
+)
+
+func process(ctx context.Context, data *dataIn) (*dataOut, error) {
+	if data == nil {
+		return nil, errors.New("no data")
+	}
+
+	if data.epoch < data.chainTime.AltairInitialEpoch() {
+		return nil, errors.New("not an Altair epoch")
+	}
+
+	syncCommittee, err := data.eth2Client.(eth2client.SyncCommitteesProvider).SyncCommittee(ctx, fmt.Sprintf("%d", data.chainTime.FirstSlotOfEpoch(data.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
+}

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:      61650,
+			},
+		},
+	}
+
+	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/synccommitteemembers.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 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.`,
+	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")
+}
+
+func synccommitteeMembersBindings() {
+	if err := viper.BindPFlag("epoch", synccommitteeMembersCmd.Flags().Lookup("epoch")); err != nil {
+		panic(err)
+	}
+}

cmd/version.go

@@ -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.10.2)"
+var ReleaseVersion = "local build (latest release 1.12.2)"
 
 // versionCmd represents the version command
 var versionCmd = &cobra.Command{

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 {

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.

go.mod

@@ -1,67 +1,48 @@
 module github.com/wealdtech/ethdo
 
-go 1.13
+go 1.16
 
 require (
-	github.com/DataDog/zstd v1.4.8 // indirect
 	github.com/OneOfOne/xxhash v1.2.5 // indirect
-	github.com/attestantio/dirk v1.0.2
-	github.com/attestantio/go-eth2-client v0.6.30
-	github.com/aws/aws-sdk-go v1.40.14 // indirect
-	github.com/dgraph-io/badger/v2 v2.2007.3 // indirect
-	github.com/dgraph-io/ristretto v0.1.0 // indirect
-	github.com/fatih/color v1.12.0 // indirect
-	github.com/ferranbt/fastssz v0.0.0-20210719200358-90640294cb9c
-	github.com/goccy/go-yaml v1.9.2 // indirect
+	github.com/attestantio/dirk v1.0.3
+	github.com/attestantio/go-eth2-client v0.7.2
+	github.com/ferranbt/fastssz v0.0.0-20210905181407-59cf6761a7d5
 	github.com/gofrs/uuid v4.0.0+incompatible
-	github.com/golang/glog v0.0.0-20210429001901-424d2337a529 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
-	github.com/google/go-cmp v0.5.6 // indirect
 	github.com/google/uuid v1.3.0
-	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0 // indirect
 	github.com/hashicorp/hcl v1.0.1-vault-3 // indirect
-	github.com/herumi/bls-eth-go-binary v0.0.0-20210520070601-31246bfa8ac4
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
-	github.com/kr/text v0.2.0 // indirect
-	github.com/mattn/go-isatty v0.0.13 // indirect
+	github.com/herumi/bls-eth-go-binary v0.0.0-20210902234237-7763804ee078
 	github.com/minio/highwayhash v1.0.2 // indirect
 	github.com/mitchellh/go-homedir v1.1.0
+	github.com/mitchellh/mapstructure v1.4.2 // indirect
 	github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
 	github.com/pkg/errors v0.9.1
-	github.com/prometheus/common v0.30.0 // indirect
-	github.com/prometheus/procfs v0.7.1 // indirect
 	github.com/protolambda/zssz v0.1.5 // indirect
 	github.com/prysmaticlabs/ethereumapis v0.0.0-20210201130911-92b2a467c108 // indirect
-	github.com/prysmaticlabs/go-bitfield v0.0.0-20210706153858-5cb5ce8bdbfe
+	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.23.0
-	github.com/spf13/cast v1.4.0 // indirect
 	github.com/spf13/cobra v1.2.1
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.8.1
 	github.com/stretchr/testify v1.7.0
 	github.com/tyler-smith/go-bip39 v1.1.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.5
-	github.com/wealdtech/go-eth2-util v1.6.4
-	github.com/wealdtech/go-eth2-wallet v1.14.4
-	github.com/wealdtech/go-eth2-wallet-dirk v1.1.6
-	github.com/wealdtech/go-eth2-wallet-distributed v1.1.3
-	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.5
-	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.4
+	github.com/wealdtech/go-ecodec v1.1.2
+	github.com/wealdtech/go-eth2-types/v2 v2.5.6
+	github.com/wealdtech/go-eth2-util v1.6.5
+	github.com/wealdtech/go-eth2-wallet v1.14.6
+	github.com/wealdtech/go-eth2-wallet-dirk v1.1.7
+	github.com/wealdtech/go-eth2-wallet-distributed v1.1.4
+	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.1.6
+	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.5.5
+	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.3.4
+	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.16.15
+	github.com/wealdtech/go-eth2-wallet-store-s3 v1.9.5
+	github.com/wealdtech/go-eth2-wallet-store-scratch v1.6.3
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.8.5
 	github.com/wealdtech/go-string2eth v1.1.0
-	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97 // indirect
-	golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985 // indirect
-	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c // indirect
-	golang.org/x/text v0.3.6
-	google.golang.org/genproto v0.0.0-20210803142424-70bd63adacf2 // indirect
-	google.golang.org/grpc v1.39.0
-	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	golang.org/x/text v0.3.7
+	google.golang.org/grpc v1.40.0
 )
+
+replace github.com/fsnotify/fsnotify v1.5.0 => github.com/fsnotify/fsnotify v1.5.1

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,215 @@
+// 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
+}
+
+// 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")
+
+	s := &Service{
+		genesisTime:                  genesisTime,
+		slotDuration:                 slotDuration,
+		slotsPerEpoch:                slotsPerEpoch,
+		epochsPerSyncCommitteePeriod: epochsPerSyncCommitteePeriod,
+		altairForkEpoch:              altairForkEpoch,
+	}
+
+	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")
+}

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

testing/mock/eth2client.go

@@ -0,0 +1,151 @@
+// 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 mock
+
+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"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+)
+
+// GenesisTimeProvider is a mock for eth2client.GenesisTimeProvider.
+type GenesisTimeProvider struct {
+	genesisTime time.Time
+}
+
+// NewGenesisTimeProvider returns a mock genesis time provider with the provided value.
+func NewGenesisTimeProvider(genesisTime time.Time) eth2client.GenesisTimeProvider {
+	return &GenesisTimeProvider{
+		genesisTime: genesisTime,
+	}
+}
+
+// GenesisTime is a mock.
+func (m *GenesisTimeProvider) GenesisTime(ctx context.Context) (time.Time, error) {
+	return m.genesisTime, nil
+}
+
+// SpecProvider is a mock for eth2client.SpecProvider.
+type SpecProvider struct {
+	spec map[string]interface{}
+}
+
+// NewSpecProvider returns a mock spec provider with the provided values.
+func NewSpecProvider(slotDuration time.Duration,
+	slotsPerEpoch uint64,
+	epochsPerSyncCommitteePeriod uint64,
+) eth2client.SpecProvider {
+	return &SpecProvider{
+		spec: map[string]interface{}{
+			"SECONDS_PER_SLOT":                 slotDuration,
+			"SLOTS_PER_EPOCH":                  slotsPerEpoch,
+			"EPOCHS_PER_SYNC_COMMITTEE_PERIOD": epochsPerSyncCommitteePeriod,
+		},
+	}
+}
+
+// Spec is a mock.
+func (m *SpecProvider) Spec(ctx context.Context) (map[string]interface{}, error) {
+	return m.spec, nil
+}
+
+// ForkScheduleProvider is a mock for eth2client.ForkScheduleProvider.
+type ForkScheduleProvider struct {
+	schedule []*phase0.Fork
+}
+
+// NewForkScheduleProvider returns a mock spec provider with the provided values.
+func NewForkScheduleProvider(schedule []*phase0.Fork) eth2client.ForkScheduleProvider {
+	return &ForkScheduleProvider{
+		schedule: schedule,
+	}
+}
+
+// ForkSchedule is a mock.
+func (m *ForkScheduleProvider) ForkSchedule(ctx context.Context) ([]*phase0.Fork, error) {
+	return m.schedule, nil
+}
+
+// SlotsPerEpochProvider is a mock for eth2client.SlotsPerEpochProvider.
+type SlotsPerEpochProvider struct {
+	slotsPerEpoch uint64
+}
+
+// NewSlotsPerEpochProvider returns a mock slots per epoch provider with the provided value.
+func NewSlotsPerEpochProvider(slotsPerEpoch uint64) eth2client.SlotsPerEpochProvider {
+	return &SlotsPerEpochProvider{
+		slotsPerEpoch: slotsPerEpoch,
+	}
+}
+
+// SlotsPerEpoch is a mock.
+func (m *SlotsPerEpochProvider) SlotsPerEpoch(ctx context.Context) (uint64, error) {
+	return m.slotsPerEpoch, nil
+}
+
+// AttestationsSubmitter is a mock for eth2client.AttestationsSubmitter.
+type AttestationsSubmitter struct{}
+
+// NewAttestationSubmitter returns a mock attestations submitter with the provided value.
+func NewAttestationSubmitter() eth2client.AttestationsSubmitter {
+	return &AttestationsSubmitter{}
+}
+
+// SubmitAttestations is a mock.
+func (m *AttestationsSubmitter) SubmitAttestations(ctx context.Context, attestations []*phase0.Attestation) error {
+	return nil
+}
+
+// BeaconBlockSubmitter is a mock for eth2client.BeaconBlockSubmitter.
+type BeaconBlockSubmitter struct{}
+
+// NewBeaconBlockSubmitter returns a mock beacon block submitter with the provided value.
+func NewBeaconBlockSubmitter() eth2client.BeaconBlockSubmitter {
+	return &BeaconBlockSubmitter{}
+}
+
+// SubmitBeaconBlock is a mock.
+func (m *BeaconBlockSubmitter) SubmitBeaconBlock(ctx context.Context, bloc *spec.VersionedSignedBeaconBlock) error {
+	return nil
+}
+
+// AggregateAttestationsSubmitter is a mock for eth2client.AggregateAttestationsSubmitter.
+type AggregateAttestationsSubmitter struct{}
+
+// NewAggregateAttestationsSubmitter returns a mock aggregate attestation submitter with the provided value.
+func NewAggregateAttestationsSubmitter() eth2client.AggregateAttestationsSubmitter {
+	return &AggregateAttestationsSubmitter{}
+}
+
+// SubmitAggregateAttestations is a mock.
+func (m *AggregateAttestationsSubmitter) SubmitAggregateAttestations(ctx context.Context, aggregates []*phase0.SignedAggregateAndProof) error {
+	return nil
+}
+
+// BeaconCommitteeSubscriptionsSubmitter is a mock for eth2client.BeaconCommitteeSubscriptionsSubmitter.
+type BeaconCommitteeSubscriptionsSubmitter struct{}
+
+// NewBeaconCommitteeSubscriptionsSubmitter returns a mock beacon committee subscription submitter with the provided value.
+func NewBeaconCommitteeSubscriptionsSubmitter() eth2client.BeaconCommitteeSubscriptionsSubmitter {
+	return &BeaconCommitteeSubscriptionsSubmitter{}
+}
+
+// SubmitBeaconCommitteeSubscriptions is a mock.
+func (m *BeaconCommitteeSubscriptionsSubmitter) SubmitBeaconCommitteeSubscriptions(ctx context.Context, subscriptions []*api.BeaconCommitteeSubscription) error {
+	return nil
+}