Return on error.

.github/workflows/golangci-lint.yml

@@ -1,24 +1,23 @@
-name: 'golangci-lint'
+name: golangci-lint
 on:
-  pull_request:
   push:
+    tags:
+      - v*
     branches:
-      - 'master'
-  workflow_dispatch:
-
+    - master
+  pull_request:
 permissions:
-  contents: 'read'
-
+  contents: read
 jobs:
   golangci:
-    name: 'lint'
-    runs-on: 'ubuntu-24.04'
+    name: lint
+    runs-on: ubuntu-latest
     steps:
-      - uses: 'actions/setup-go@v5'
+      - uses: actions/setup-go@v4
         with:
-          cache: false
-          go-version: '^1.22'
-      - uses: 'actions/checkout@v4'
-      - uses: 'golangci/golangci-lint-action@v6'
+          go-version: '^1.21'
+      - uses: actions/checkout@v4
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v4
         with:
           only-new-issues: true

.github/workflows/release.yml

@@ -3,9 +3,8 @@ name: Release
 on:
   push:
     tags:
-      - 'v*'
-      - 't*'
-  workflow_dispatch:
+    - 'v*'
+    - 't*'
 
 jobs:
   # Set variables that will be available to all builds.
@@ -45,10 +44,9 @@ jobs:
     needs: [create_release, env_vars]
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
-          cache: false
-          go-version: '^1.22'
+          go-version: '^1.21'
 
       - name: Check out repository into the Go module directory
         uses: actions/checkout@v4
@@ -121,10 +119,9 @@ jobs:
     needs: [create_release, env_vars]
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
-          cache: false
-          go-version: '^1.22'
+          go-version: '^1.21'
 
       - name: Check out repository into the Go module directory
         uses: actions/checkout@v4
@@ -167,10 +164,9 @@ jobs:
     needs: [create_release, env_vars]
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v4
         with:
-          cache: false
-          go-version: '^1.22'
+          go-version: '^1.21'
 
       - name: Check out repository into the Go module directory
         uses: actions/checkout@v4

.github/workflows/test.yml

@@ -1,18 +1,15 @@
 name: test
 on:
-  pull_request:
   push:
     branches:
-      - master
-  workflow_dispatch:
-
+    - master
+  pull_request:
 jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/setup-go@v5
+      - uses: actions/setup-go@v4
         with:
-          cache: false
-          go-version: '^1.22'
+          go-version: '^1.21'
       - uses: actions/checkout@v4
-      - uses: n8maninger/action-golang-test@v2
+      - uses: n8maninger/action-golang-test@v1

.gitignore

@@ -15,12 +15,6 @@ coverage.html
 # Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
 .glide/
 
-# Intellij
-.idea/
-
-# Makefile
-Makefile
-
 # Vim
 *.sw?
 

.golangci.yml

@@ -106,11 +106,6 @@ output:
 
 # All available settings of specific linters.
 linters-settings:
-  gosec:
-    excludes:
-      # Flags for potentially-unsafe casting of ints, but generates a lot of false positives.
-      - 'G115'
-
   lll:
     line-length: 132
 
@@ -133,13 +128,15 @@ linters:
   disable:
     - contextcheck
     - cyclop
+    - deadcode
     - depguard
     - dupl
     - err113
     - errorlint
+    - execinquery
     - exhaustive
+    - exhaustivestruct
     - exhaustruct
-    - exportloopref
     - forbidigo
     - forcetypeassert
     - funlen
@@ -149,20 +146,29 @@ linters:
     - gocognit
     - goconst
     - goheader
+    - golint
+    - gomnd
+    - ifshort
+    - interfacer
     - ireturn
     - lll
     - maintidx
+    - maligned
     - mnd
     - musttag
     - nestif
     - nilnil
     - nlreturn
     - nolintlint
+    - nosnakecase
     - perfsprint
     - promlinter
     - rowserrcheck
+    - scopelint
     - sqlclosecheck
+    - structcheck
     - unparam
+    - varcheck
     - varnamelen
     - wastedassign
     - wrapcheck

CHANGELOG.md

@@ -1,34 +1,4 @@
-1.37.0:
- - support Electra
- - add `--compounding` flag when creating validator deposit data
-
-1.36.6:
-  - allow specification of blockid for validator info
-  - validator depositdata orders deposits from an HD wallet by path
-
-1.36.5:
-  - avoid corner case mnemonic derivation with 25th word
-
-1.36.2:
-  - avoid crash when signing and verifing signatures using keys rather than accounts
-
-1.36.1:
-  - more JSON data for epoch summary
-  - fix crash when block ifno had no blobs
-
-1.36.0:
-  - support keystore wallets
-
-1.35.6:
-  - provide more JSON data in "epoch summary"
-
-1.35.5:
-  - allow keystore to be output to the console
-
-1.35.4:
-  - provide consensus and execution client info in block info output 
-
-1.35.3:
+dev:
   - provide better error message on context deadlline exceeded
   - update launchpad output to match latest version
   - add deposit contract address to "chain info"

Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.23-bookworm AS builder
+FROM golang:1.21-bookworm as builder
 
 WORKDIR /app
 

README.md

@@ -151,13 +151,9 @@ Amazon S3-compatible stores have additional options available, which can be conf
 {
   "stores": {
     "s3": {
-      "region": "us-west-1",
-      "bucket": "my-s3-store",
-      "path": "/wallets",
-      "credentials": {
-        "id": "ABCDEF123",
-        "secret": "XXXXXXXXX"
-      }
+      "bucket":"mybucketname",
+      "path":"path/in/bucket",
+      "passphrase":"secret"
     }
   }
 }

cmd/account/derive/input.go

@@ -22,7 +22,6 @@ import (
 
 type dataIn struct {
 	quiet bool
-	json  bool
 	// Derivation information.
 	mnemonic string
 	path     string
@@ -38,9 +37,6 @@ func input(_ context.Context) (*dataIn, error) {
 	// Quiet.
 	data.quiet = viper.GetBool("quiet")
 
-	// JSON.
-	data.json = viper.GetBool("json")
-
 	// Mnemonic.
 	if viper.GetString("mnemonic") == "" {
 		return nil, errors.New("mnemonic is required")

cmd/account/derive/output.go

@@ -31,7 +31,6 @@ import (
 )
 
 type dataOut struct {
-	json                      bool
 	showPrivateKey            bool
 	showWithdrawalCredentials bool
 	generateKeystore          bool
@@ -95,14 +94,10 @@ func outputKeystore(_ context.Context, data *dataOut) (string, error) {
 		return "", errors.Wrap(err, "failed to marshal keystore JSON")
 	}
 
-	if data.json {
-		fmt.Fprintf(os.Stdout, "%s\n", string(out))
-	} else {
-		keystoreFilename := fmt.Sprintf("keystore-%s-%d.json", strings.ReplaceAll(data.path, "/", "_"), time.Now().Unix())
+	keystoreFilename := fmt.Sprintf("keystore-%s-%d.json", strings.ReplaceAll(data.path, "/", "_"), time.Now().Unix())
 
-		if err := os.WriteFile(keystoreFilename, out, 0o600); err != nil {
-			return "", errors.Wrap(err, fmt.Sprintf("failed to write %s", keystoreFilename))
-		}
+	if err := os.WriteFile(keystoreFilename, out, 0o600); err != nil {
+		return "", errors.Wrap(err, fmt.Sprintf("failed to write %s", keystoreFilename))
 	}
 	return "", nil
 }

cmd/account/derive/process.go

@@ -38,7 +38,6 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	}
 
 	results := &dataOut{
-		json:                      data.json,
 		showPrivateKey:            data.showPrivateKey,
 		showWithdrawalCredentials: data.showWithdrawalCredentials,
 		generateKeystore:          data.generateKeystore,

cmd/accountderive.go

@@ -50,7 +50,6 @@ func init() {
 	accountDeriveCmd.Flags().Bool("show-private-key", false, "show private key for derived account")
 	accountDeriveCmd.Flags().Bool("show-withdrawal-credentials", false, "show withdrawal credentials for derived account")
 	accountDeriveCmd.Flags().Bool("generate-keystore", false, "generate a keystore for the derived account")
-	accountDeriveCmd.Flags().Bool("json", false, "display the JSON keystore for the derived account on stdout")
 }
 
 func accountDeriveBindings(cmd *cobra.Command) {
@@ -63,7 +62,4 @@ func accountDeriveBindings(cmd *cobra.Command) {
 	if err := viper.BindPFlag("generate-keystore", cmd.Flags().Lookup("generate-keystore")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("json", cmd.Flags().Lookup("json")); err != nil {
-		panic(err)
-	}
 }

cmd/accountimport.go

@@ -24,7 +24,7 @@ import (
 var accountImportCmd = &cobra.Command{
 	Use:   "import",
 	Short: "Import an account",
-	Long: `Import an account from its private key.  For example:
+	Long: `Import an account from its private key or keystore.  For example:
 
     ethdo account import --account="primary/testing" --key="0x..." --passphrase="my secret"
 

cmd/attester/duties/input.go

@@ -61,10 +61,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/attester/inclusion/input.go

@@ -58,10 +58,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/attester/inclusion/output.go

@@ -19,7 +19,6 @@ import (
 	"strconv"
 	"strings"
 
-	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 )
@@ -28,7 +27,7 @@ type dataOut struct {
 	debug            bool
 	quiet            bool
 	verbose          bool
-	attestation      *spec.VersionedAttestation
+	attestation      *phase0.Attestation
 	slot             phase0.Slot
 	attestationIndex uint64
 	inclusionDelay   phase0.Slot

cmd/attester/inclusion/process.go

@@ -22,7 +22,6 @@ import (
 	eth2client "github.com/attestantio/go-eth2-client"
 	"github.com/attestantio/go-eth2-client/api"
 	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
-	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -109,17 +108,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 				headCorrect := false
 				targetCorrect := false
 				if data.verbose {
-					headCorrect, err = calcHeadCorrect(ctx, data, attestation)
+					headCorrect, err = calcHeadCorrect(ctx, data, attestationData)
 					if err != nil {
 						return nil, errors.Wrap(err, "failed to obtain head correct result")
 					}
-					targetCorrect, err = calcTargetCorrect(ctx, data, attestation)
+					targetCorrect, err = calcTargetCorrect(ctx, data, attestationData)
 					if err != nil {
 						return nil, errors.Wrap(err, "failed to obtain target correct result")
 					}
 				}
 				results.found = true
-				results.attestation = attestation
+				// TODO fix.
+				// results.attestation = attestation
 				results.slot = slot
 				results.attestationIndex = uint64(i)
 				results.inclusionDelay = slot - duty.Slot
@@ -138,12 +138,7 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return results, nil
 }
 
-func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *spec.VersionedAttestation) (bool, error) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return false, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
+func calcHeadCorrect(ctx context.Context, data *dataIn, attestationData *phase0.AttestationData) (bool, error) {
 	slot := attestationData.Slot
 	for {
 		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
@@ -164,17 +159,11 @@ func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *spec.Versio
 			slot--
 			continue
 		}
-
 		return bytes.Equal(response.Data.Root[:], attestationData.BeaconBlockRoot[:]), nil
 	}
 }
 
-func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *spec.VersionedAttestation) (bool, error) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return false, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
+func calcTargetCorrect(ctx context.Context, data *dataIn, attestationData *phase0.AttestationData) (bool, error) {
 	// Start with first slot of the target epoch.
 	slot := data.chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
 	for {
@@ -196,7 +185,6 @@ func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *spec.Vers
 			slot--
 			continue
 		}
-
 		return bytes.Equal(response.Data.Root[:], attestationData.Target.Root[:]), nil
 	}
 }

cmd/block/analyze/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	blockID    string
@@ -55,7 +56,7 @@ type command struct {
 	weightDenominator  uint64
 
 	// Processing.
-	priorAttestations map[string]*attestationDataInfo
+	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.
@@ -77,20 +78,20 @@ type blockAnalysis struct {
 }
 
 type attestationAnalysis struct {
-	Head          phase0.Root          `json:"head"`
-	Target        phase0.Root          `json:"target"`
-	Distance      int                  `json:"distance"`
-	Duplicate     *attestationDataInfo `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"`
+	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 {
@@ -100,7 +101,7 @@ type syncCommitteeAnalysis struct {
 	Value                 float64 `json:"value"`
 }
 
-type attestationDataInfo struct {
+type attestationData struct {
 	Block phase0.Slot `json:"block"`
 	Index int         `json:"index"`
 }
@@ -110,7 +111,7 @@ func newCommand(_ context.Context) (*command, error) {
 		quiet:             viper.GetBool("quiet"),
 		verbose:           viper.GetBool("verbose"),
 		debug:             viper.GetBool("debug"),
-		priorAttestations: make(map[string]*attestationDataInfo),
+		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),
@@ -124,6 +125,7 @@ func newCommand(_ context.Context) (*command, error) {
 
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	c.customSpecSupport = viper.GetBool("custom-spec")
 
 	c.blockID = viper.GetString("blockid")
 	c.stream = viper.GetBool("stream")

cmd/block/analyze/output.go

@@ -34,20 +34,20 @@ func (c *command) output(ctx context.Context) (string, error) {
 }
 
 type attestationAnalysisJSON struct {
-	Head          string               `json:"head"`
-	Target        string               `json:"target"`
-	Distance      int                  `json:"distance"`
-	Duplicate     *attestationDataInfo `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"`
+	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) {

cmd/block/analyze/process.go

@@ -17,11 +17,11 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"net/http"
 
 	eth2client "github.com/attestantio/go-eth2-client"
 	"github.com/attestantio/go-eth2-client/api"
 	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/electra"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
@@ -40,7 +40,7 @@ func (c *command) process(ctx context.Context) error {
 	})
 	if err != nil {
 		var apiError *api.Error
-		if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+		if errors.As(err, &apiError) && apiError.StatusCode == 404 {
 			return errors.New("empty beacon block")
 		}
 		return errors.Wrap(err, "failed to obtain beacon block")
@@ -65,7 +65,7 @@ func (c *command) process(ctx context.Context) error {
 	for _, attestation := range attestations {
 		attestationData, err := attestation.Data()
 		if err != nil {
-			return errors.Wrap(err, "failed to obtain attestation data")
+			continue
 		}
 		if attestationData.Slot < minSlot {
 			minSlot = attestationData.Slot
@@ -108,79 +108,26 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 			fmt.Printf("Processing attestation %d\n", i)
 		}
 
-		attestationData, err := attestation.Data()
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain attestation data")
+		var analysis *attestationAnalysis
+		switch attestation.Version {
+		case spec.DataVersionPhase0:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Phase0, blockVotes, spec.DataVersionPhase0)
+		case spec.DataVersionAltair:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Altair, blockVotes, spec.DataVersionAltair)
+		case spec.DataVersionBellatrix:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Bellatrix, blockVotes, spec.DataVersionBellatrix)
+		case spec.DataVersionCapella:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Capella, blockVotes, spec.DataVersionCapella)
+		case spec.DataVersionDeneb:
+			analysis, err = c.phase0Analysis(ctx, slot, attestation.Deneb, blockVotes, spec.DataVersionDeneb)
+		case spec.DataVersionElectra:
+			analysis, err = c.electraAnalysis(ctx, slot, attestation.Electra, blockVotes, spec.DataVersionElectra)
+		default:
+			return fmt.Errorf("unknown version %s", attestation.Version)
 		}
-
-		analysis := &attestationAnalysis{
-			Head:     attestationData.BeaconBlockRoot,
-			Target:   attestationData.Target.Root,
-			Distance: int(slot - attestationData.Slot),
-		}
-
-		root, err := attestation.HashTreeRoot()
 		if err != nil {
 			return err
 		}
-		if info, exists := c.priorAttestations[fmt.Sprintf("%#x", root)]; exists {
-			analysis.Duplicate = info
-		} else {
-			aggregationBits, err := attestation.AggregationBits()
-			if err != nil {
-				return err
-			}
-			_, exists := blockVotes[attestationData.Slot]
-			if !exists {
-				blockVotes[attestationData.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
-			}
-			_, exists = blockVotes[attestationData.Slot][attestationData.Index]
-			if !exists {
-				blockVotes[attestationData.Slot][attestationData.Index] = bitfield.NewBitlist(aggregationBits.Len())
-			}
-
-			// Count new votes.
-			analysis.PossibleVotes = int(aggregationBits.Len())
-			for j := range aggregationBits.Len() {
-				if aggregationBits.BitAt(j) {
-					analysis.Votes++
-					if blockVotes[attestationData.Slot][attestationData.Index].BitAt(j) {
-						// Already attested to in this block; skip.
-						continue
-					}
-					if c.votes[attestationData.Slot][attestationData.Index].BitAt(j) {
-						// Already attested to in a previous block; skip.
-						continue
-					}
-					analysis.NewVotes++
-					blockVotes[attestationData.Slot][attestationData.Index].SetBitAt(j, true)
-				}
-			}
-			// Calculate head correct.
-			analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
-			if err != nil {
-				return err
-			}
-
-			// Calculate head timely.
-			analysis.HeadTimely = analysis.HeadCorrect && attestationData.Slot == slot-1
-
-			// Calculate source timely.
-			analysis.SourceTimely = attestationData.Slot >= slot-5
-
-			// Calculate target correct.
-			analysis.TargetCorrect, err = c.calcTargetCorrect(ctx, attestation)
-			if err != nil {
-				return err
-			}
-
-			// Calculate target timely.
-			if block.Version < spec.DataVersionDeneb {
-				analysis.TargetTimely = attestationData.Slot >= slot-32
-			} else {
-				analysis.TargetTimely = true
-			}
-		}
 
 		// Calculate score and value.
 		if analysis.TargetCorrect && analysis.TargetTimely {
@@ -201,12 +148,171 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 	return nil
 }
 
+func (c *command) phase0Analysis(ctx context.Context,
+	slot phase0.Slot,
+	attestation *phase0.Attestation,
+	blockVotes map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist,
+	version spec.DataVersion,
+) (
+	*attestationAnalysis,
+	error,
+) {
+	analysis := &attestationAnalysis{
+		Head:     attestation.Data.BeaconBlockRoot,
+		Target:   attestation.Data.Target.Root,
+		Distance: int(slot - attestation.Data.Slot),
+	}
+
+	// TODO.
+	root, err := attestation.HashTreeRoot()
+	if err != nil {
+		return nil, 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.
+		analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate head timely.
+		analysis.HeadTimely = analysis.HeadCorrect && 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 nil, err
+		}
+
+		// Calculate target timely.
+		if version < spec.DataVersionDeneb {
+			analysis.TargetTimely = attestation.Data.Slot >= slot-32
+		} else {
+			analysis.TargetTimely = true
+		}
+	}
+
+	return analysis, nil
+}
+
+func (c *command) electraAnalysis(ctx context.Context,
+	slot phase0.Slot,
+	attestation *electra.Attestation,
+	blockVotes map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist,
+	version spec.DataVersion,
+) (
+	*attestationAnalysis,
+	error,
+) {
+	analysis := &attestationAnalysis{
+		Head:     attestation.Data.BeaconBlockRoot,
+		Target:   attestation.Data.Target.Root,
+		Distance: int(slot - attestation.Data.Slot),
+	}
+
+	// TODO.
+	root, err := attestation.HashTreeRoot()
+	if err != nil {
+		return nil, 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.calcElectraHeadCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate head timely.
+		analysis.HeadTimely = analysis.HeadCorrect && attestation.Data.Slot == slot-1
+
+		// Calculate source timely.
+		analysis.SourceTimely = attestation.Data.Slot >= slot-5
+
+		// Calculate target correct.
+		analysis.TargetCorrect, err = c.calcElectraTargetCorrect(ctx, attestation)
+		if err != nil {
+			return nil, err
+		}
+
+		// Calculate target timely.
+		if version < spec.DataVersionDeneb {
+			analysis.TargetTimely = attestation.Data.Slot >= slot-32
+		} else {
+			analysis.TargetTimely = true
+		}
+	}
+
+	return analysis, nil
+}
+
 func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedBeaconBlock, minSlot phase0.Slot) error {
 	parentRoot, err := block.ParentRoot()
 	if err != nil {
 		return err
 	}
-	root, err := block.Root()
+	root, err := block.Deneb.HashTreeRoot()
 	if err != nil {
 		panic(err)
 	}
@@ -224,7 +330,7 @@ func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedB
 	})
 	if err != nil {
 		var apiError *api.Error
-		if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+		if errors.As(err, &apiError) && apiError.StatusCode == 404 {
 			return errors.New("empty beacon block")
 		}
 		return err
@@ -250,10 +356,10 @@ func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedB
 }
 
 func (c *command) processParentBlock(_ context.Context, block *spec.VersionedSignedBeaconBlock) error {
-	attestations, err := block.Attestations()
-	if err != nil {
-		return err
-	}
+	//	attestations, err := block.Attestations()
+	//	if err != nil {
+	//		return err
+	//	}
 	slot, err := block.Slot()
 	if err != nil {
 		return err
@@ -262,39 +368,40 @@ func (c *command) processParentBlock(_ context.Context, block *spec.VersionedSig
 		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)] = &attestationDataInfo{
-			Block: slot,
-			Index: i,
-		}
+	// TODO reinstate.
+	// 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,
+	//	}
 
-		attestationData, err := attestation.Data()
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain attestation data")
-		}
-		aggregationBits, err := attestation.AggregationBits()
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain attestation aggregation bits")
-		}
+	//	data, err := attestation.Data()
+	//	if err != nil {
+	//		return err
+	//	}
+	//	aggregationBits, err := attestation.AggregationBits()
+	//	if err != nil {
+	//		return err
+	//	}
 
-		_, exists := c.votes[attestationData.Slot]
-		if !exists {
-			c.votes[attestationData.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
-		}
-		_, exists = c.votes[attestationData.Slot][attestationData.Index]
-		if !exists {
-			c.votes[attestationData.Slot][attestationData.Index] = bitfield.NewBitlist(aggregationBits.Len())
-		}
-		for j := range aggregationBits.Len() {
-			if aggregationBits.BitAt(j) {
-				c.votes[attestationData.Slot][attestationData.Index].SetBitAt(j, true)
-			}
-		}
-	}
+	//	_, 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(aggregationBits.Len())
+	//	}
+	//	for j := uint64(0); j < aggregationBits.Len(); j++ {
+	//		if aggregationBits.BitAt(j) {
+	//			c.votes[data.Slot][data.Index].SetBitAt(j, true)
+	//		}
+	//	}
+	//}
 
 	return nil
 }
@@ -304,10 +411,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -405,13 +513,8 @@ func (c *command) setup(ctx context.Context) error {
 	return nil
 }
 
-func (c *command) calcHeadCorrect(ctx context.Context, attestation *spec.VersionedAttestation) (bool, error) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return false, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
-	slot := attestationData.Slot
+func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
 	root, exists := c.headRoots[slot]
 	if !exists {
 		for {
@@ -420,7 +523,7 @@ func (c *command) calcHeadCorrect(ctx context.Context, attestation *spec.Version
 			})
 			if err != nil {
 				var apiError *api.Error
-				if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
 					if c.debug {
 						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
 					}
@@ -438,32 +541,27 @@ func (c *command) calcHeadCorrect(ctx context.Context, attestation *spec.Version
 				slot--
 				continue
 			}
-			c.headRoots[slot] = response.Data.Root
+			c.headRoots[attestation.Data.Slot] = response.Data.Root
 			root = response.Data.Root
 			break
 		}
 	}
 
-	return bytes.Equal(root[:], attestationData.BeaconBlockRoot[:]), nil
+	return bytes.Equal(root[:], attestation.Data.BeaconBlockRoot[:]), nil
 }
 
-func (c *command) calcTargetCorrect(ctx context.Context, attestation *spec.VersionedAttestation) (bool, error) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return false, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
-	root, exists := c.targetRoots[attestationData.Slot]
+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(attestationData.Target.Epoch)
+		slot := c.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
 		for {
 			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
 				Block: fmt.Sprintf("%d", slot),
 			})
 			if err != nil {
 				var apiError *api.Error
-				if errors.As(err, &apiError) && apiError.StatusCode == http.StatusNotFound {
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
 					if c.debug {
 						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
 					}
@@ -480,12 +578,85 @@ func (c *command) calcTargetCorrect(ctx context.Context, attestation *spec.Versi
 				slot--
 				continue
 			}
-			c.targetRoots[attestationData.Slot] = response.Data.Root
+			c.targetRoots[attestation.Data.Slot] = response.Data.Root
 			root = response.Data.Root
 			break
 		}
 	}
-	return bytes.Equal(root[:], attestationData.Target.Root[:]), nil
+	return bytes.Equal(root[:], attestation.Data.Target.Root[:]), nil
+}
+
+func (c *command) calcElectraHeadCorrect(ctx context.Context, attestation *electra.Attestation) (bool, error) {
+	slot := attestation.Data.Slot
+	root, exists := c.headRoots[slot]
+	if !exists {
+		for {
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
+			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
+				return false, err
+			}
+			if response.Data == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !response.Data.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.headRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
+			break
+		}
+	}
+
+	return bytes.Equal(root[:], attestation.Data.BeaconBlockRoot[:]), nil
+}
+
+func (c *command) calcElectraTargetCorrect(ctx context.Context, attestation *electra.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 {
+			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
+				Block: fmt.Sprintf("%d", slot),
+			})
+			if err != nil {
+				var apiError *api.Error
+				if errors.As(err, &apiError) && apiError.StatusCode == 404 {
+					if c.debug {
+						fmt.Printf("No block available for slot %d, assuming not in canonical chain", slot)
+					}
+					return false, nil
+				}
+			}
+			if response.Data == nil {
+				// No block.
+				slot--
+				continue
+			}
+			if !response.Data.Canonical {
+				// Not canonical.
+				slot--
+				continue
+			}
+			c.targetRoots[attestation.Data.Slot] = response.Data.Root
+			root = response.Data.Root
+			break
+		}
+	}
+	return bytes.Equal(root[:], attestation.Data.Target.Root[:]), nil
 }
 
 func (c *command) analyzeSyncCommittees(_ context.Context, block *spec.VersionedSignedBeaconBlock) error {
@@ -521,13 +692,6 @@ func (c *command) analyzeSyncCommittees(_ context.Context, block *spec.Versioned
 		c.analysis.SyncCommitee.Value = c.analysis.SyncCommitee.Score * float64(c.analysis.SyncCommitee.Contributions)
 		c.analysis.Value += c.analysis.SyncCommitee.Value
 		return nil
-	case spec.DataVersionElectra:
-		c.analysis.SyncCommitee.Contributions = int(block.Electra.Message.Body.SyncAggregate.SyncCommitteeBits.Count())
-		c.analysis.SyncCommitee.PossibleContributions = int(block.Electra.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/info/input.go

@@ -57,10 +57,11 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/block/info/output.go

@@ -19,7 +19,6 @@ import (
 	"encoding/hex"
 	"fmt"
 	"math/big"
-	"regexp"
 	"sort"
 	"strconv"
 	"strings"
@@ -56,7 +55,7 @@ func output(_ context.Context, data *dataOut) (string, error) {
 	return "", nil
 }
 
-func outputBlockGeneral(ctx context.Context,
+func outputBlockGeneral(_ context.Context,
 	verbose bool,
 	slot phase0.Slot,
 	proposerIndex phase0.ValidatorIndex,
@@ -84,7 +83,14 @@ func outputBlockGeneral(ctx context.Context,
 		res.WriteString(fmt.Sprintf("Parent root: %#x\n", parentRoot))
 		res.WriteString(fmt.Sprintf("State root: %#x\n", stateRoot))
 	}
-	res.WriteString(blockGraffiti(ctx, graffiti))
+	if len(graffiti) > 0 && hex.EncodeToString(graffiti) != "0000000000000000000000000000000000000000000000000000000000000000" {
+		graffiti = bytes.TrimRight(graffiti, "\u0000")
+		if utf8.Valid(graffiti) {
+			res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(graffiti)))
+		} else {
+			res.WriteString(fmt.Sprintf("Graffiti: %#x\n", graffiti))
+		}
+	}
 
 	return res.String(), nil
 }
@@ -134,61 +140,7 @@ func outputBlockAttestations(ctx context.Context, eth2Client eth2client.Service,
 				res.WriteString(fmt.Sprintf("    Attesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len()))
 				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, []int{int(att.Data.Index)})))
-				}
-				res.WriteString(fmt.Sprintf("    Slot: %d\n", att.Data.Slot))
-				res.WriteString(fmt.Sprintf("    Beacon block root: %#x\n", att.Data.BeaconBlockRoot))
-				res.WriteString(fmt.Sprintf("    Source epoch: %d\n", att.Data.Source.Epoch))
-				res.WriteString(fmt.Sprintf("    Source root: %#x\n", att.Data.Source.Root))
-				res.WriteString(fmt.Sprintf("    Target epoch: %d\n", att.Data.Target.Epoch))
-				res.WriteString(fmt.Sprintf("    Target root: %#x\n", att.Data.Target.Root))
-			}
-		}
-	}
-
-	return res.String(), nil
-}
-
-func outputElectraBlockAttestations(ctx context.Context, eth2Client eth2client.Service, verbose bool, attestations []*electra.Attestation) (string, error) {
-	res := strings.Builder{}
-
-	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)
-		if isProvider {
-			for i, att := range attestations {
-				res.WriteString(fmt.Sprintf("  %d:\n", i))
-
-				// Fetch committees for this epoch if not already obtained.
-				committees, exists := validatorCommittees[att.Data.Slot]
-				if !exists {
-					response, err := beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
-						State: fmt.Sprintf("%d", att.Data.Slot),
-					})
-					if err != nil {
-						// 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 response.Data {
-							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
-								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
-							}
-							validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
-						}
-					}
-					committees = validatorCommittees[att.Data.Slot]
-				}
-
-				committeeIndices := make([]phase0.CommitteeIndex, 0)
-				for _, committeeIndex := range att.CommitteeBits.BitIndices() {
-					committeeIndices = append(committeeIndices, phase0.CommitteeIndex(committeeIndex))
-				}
-				res.WriteString(fmt.Sprintf("    Committee indices: %d\n", committeeIndices))
-				res.WriteString(fmt.Sprintf("    Attesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len()))
-				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.CommitteeBits.BitIndices())))
+					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))
@@ -253,7 +205,71 @@ func outputBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Ser
 	return res.String(), nil
 }
 
-func outputElectraBlockAttesterSlashings(ctx context.Context, eth2Client eth2client.Service, verbose bool, attesterSlashings []*electra.AttesterSlashing) (string, error) {
+func outputElectraBlockAttestations(ctx context.Context,
+	eth2Client eth2client.Service,
+	verbose bool,
+	attestations []*electra.Attestation,
+) (
+	string,
+	error,
+) {
+	res := strings.Builder{}
+
+	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)
+		if isProvider {
+			for i, att := range attestations {
+				res.WriteString(fmt.Sprintf("  %d:\n", i))
+
+				// Fetch committees for this epoch if not already obtained.
+				committees, exists := validatorCommittees[att.Data.Slot]
+				if !exists {
+					response, err := beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
+						State: fmt.Sprintf("%d", att.Data.Slot),
+					})
+					if err != nil {
+						// 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 response.Data {
+							if _, exists := validatorCommittees[beaconCommittee.Slot]; !exists {
+								validatorCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
+							}
+							validatorCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
+						}
+					}
+					committees = validatorCommittees[att.Data.Slot]
+				}
+
+				res.WriteString(fmt.Sprintf("    Committee index: %d\n", att.Data.Index))
+				res.WriteString(fmt.Sprintf("    Attesters: %d/%d\n", att.AggregationBits.Count(), att.AggregationBits.Len()))
+				res.WriteString(fmt.Sprintf("    Aggregation bits: %s\n", 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))
+				res.WriteString(fmt.Sprintf("    Source root: %#x\n", att.Data.Source.Root))
+				res.WriteString(fmt.Sprintf("    Target epoch: %d\n", att.Data.Target.Epoch))
+				res.WriteString(fmt.Sprintf("    Target root: %#x\n", att.Data.Target.Root))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputElectraBlockAttesterSlashings(ctx context.Context,
+	eth2Client eth2client.Service,
+	verbose bool,
+	attesterSlashings []*electra.AttesterSlashing,
+) (
+	string,
+	error,
+) {
 	res := strings.Builder{}
 
 	res.WriteString(fmt.Sprintf("Attester slashings: %d\n", len(attesterSlashings)))
@@ -394,7 +410,7 @@ func outputBlockSyncAggregate(ctx context.Context, eth2Client eth2client.Service
 						res.WriteString(fmt.Sprintf("  Error: failed to obtain sync committee: %v\n", err))
 					} else {
 						res.WriteString("  Contributing validators:")
-						for i := range syncAggregate.SyncCommitteeBits.Len() {
+						for i := uint64(0); i < syncAggregate.SyncCommitteeBits.Len(); i++ {
 							if syncAggregate.SyncCommitteeBits.BitAt(i) {
 								res.WriteString(fmt.Sprintf(" %d", syncCommitteeResponse.Data.Validators[i]))
 							}
@@ -607,7 +623,7 @@ func outputDenebBlockText(ctx context.Context,
 	}
 	res.WriteString(tmp)
 
-	tmp, err = outputBlobInfo(ctx, data.verbose, blobs)
+	tmp, err = outputDenebBlobInfo(ctx, data.verbose, signedBlock.Message.Body, blobs)
 	if err != nil {
 		return "", err
 	}
@@ -692,6 +708,12 @@ func outputElectraBlockText(ctx context.Context,
 	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 {
@@ -705,19 +727,13 @@ func outputElectraBlockText(ctx context.Context,
 	}
 	res.WriteString(tmp)
 
-	tmp, err = outputDenebBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
+	tmp, err = outputElectraBlockExecutionPayload(ctx, data.verbose, signedBlock.Message.Body.ExecutionPayload)
 	if err != nil {
 		return "", err
 	}
 	res.WriteString(tmp)
 
-	tmp, err = outputElectraBlockExecutionRequests(ctx, data.verbose, signedBlock.Message.Body.ExecutionRequests)
-	if err != nil {
-		return "", err
-	}
-	res.WriteString(tmp)
-
-	tmp, err = outputBlobInfo(ctx, data.verbose, blobs)
+	tmp, err = outputElectraBlobInfo(ctx, data.verbose, signedBlock.Message.Body, blobs)
 	if err != nil {
 		return "", err
 	}
@@ -1006,7 +1022,7 @@ func outputCapellaBlockExecutionPayload(_ context.Context,
 		res.WriteString("  Execution block number: ")
 		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
 		baseFeePerGasBEBytes := make([]byte, len(payload.BaseFeePerGas))
-		for i := range 32 {
+		for i := 0; i < 32; i++ {
 			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
 		}
 		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
@@ -1112,69 +1128,124 @@ func outputDenebBlockExecutionPayload(_ context.Context,
 	return res.String(), nil
 }
 
-func outputElectraBlockExecutionRequests(_ context.Context,
+func outputElectraBlockExecutionPayload(_ context.Context,
 	verbose bool,
-	executionRequests *electra.ExecutionRequests,
+	payload *electra.ExecutionPayload,
 ) (
 	string,
 	error,
 ) {
-	if executionRequests == nil {
+	if payload == nil {
+		return "", nil
+	}
+
+	// If the block number is 0 then we're before the merge.
+	if payload.BlockNumber == 0 {
 		return "", nil
 	}
 
 	res := strings.Builder{}
-	res.WriteString("Deposit requests: ")
-	res.WriteString(fmt.Sprintf("%d\n", len(executionRequests.Deposits)))
-	if verbose {
-		for i, deposit := range executionRequests.Deposits {
-			res.WriteString(fmt.Sprintf("%3d:\n", i))
-			res.WriteString(fmt.Sprintf("    Public key: %#x\n", deposit.Pubkey))
-			res.WriteString(fmt.Sprintf("    Withdrawal credentials: %#x\n", deposit.WithdrawalCredentials))
-			res.WriteString(fmt.Sprintf("    Amount: %s\n", string2eth.GWeiToString(uint64(deposit.Amount), true)))
-		}
-	}
-	res.WriteString("Withdrawal requests: ")
-	res.WriteString(fmt.Sprintf("%d\n", len(executionRequests.Withdrawals)))
-	if verbose {
-		for i, withdrawal := range executionRequests.Withdrawals {
-			res.WriteString(fmt.Sprintf("%3d:\n", i))
-			res.WriteString(fmt.Sprintf("    Source address: %#x\n", withdrawal.SourceAddress))
-			res.WriteString(fmt.Sprintf("    Validator public key: %#x\n", withdrawal.ValidatorPubkey))
-			res.WriteString(fmt.Sprintf("    Amount: %s\n", string2eth.GWeiToString(uint64(withdrawal.Amount), true)))
-		}
-	}
-	res.WriteString("Consolidation requests: ")
-	res.WriteString(fmt.Sprintf("%d\n", len(executionRequests.Consolidations)))
-	if verbose {
-		for i, consolidation := range executionRequests.Consolidations {
-			res.WriteString(fmt.Sprintf("%3d:\n", i))
-			res.WriteString(fmt.Sprintf("    Source address: %#x\n", consolidation.SourceAddress))
-			res.WriteString(fmt.Sprintf("    Source public key: %#x\n", consolidation.SourcePubkey))
-			res.WriteString(fmt.Sprintf("    Target public key: %#x\n", consolidation.TargetPubkey))
+	if !verbose {
+		res.WriteString("Execution block number: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
+		res.WriteString("Transactions: ")
+		res.WriteString(fmt.Sprintf("%d\n", len(payload.Transactions)))
+	} else {
+		res.WriteString("Execution payload:\n")
+		res.WriteString("  Execution block number: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
+		res.WriteString("  Base fee per gas: ")
+		res.WriteString(string2eth.WeiToString(payload.BaseFeePerGas.ToBig(), 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(payload.FeeRecipient.String())
+		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: ")
+		if utf8.Valid(payload.ExtraData) {
+			res.WriteString(fmt.Sprintf("%s\n", string(payload.ExtraData)))
+		} else {
+			res.WriteString(fmt.Sprintf("%#x\n", payload.ExtraData))
 		}
+		res.WriteString("  Logs bloom: ")
+		res.WriteString(fmt.Sprintf("%#x\n", payload.LogsBloom))
+		res.WriteString("  Transactions: ")
+		res.WriteString(fmt.Sprintf("%d\n", len(payload.Transactions)))
+		res.WriteString("  Withdrawals: ")
+		res.WriteString(fmt.Sprintf("%d\n", len(payload.Withdrawals)))
+		res.WriteString("  Excess blob gas: ")
+		res.WriteString(fmt.Sprintf("%d\n", payload.ExcessBlobGas))
 	}
 
 	return res.String(), nil
 }
 
-func outputBlobInfo(_ context.Context,
+func outputDenebBlobInfo(_ context.Context,
 	verbose bool,
+	body *deneb.BeaconBlockBody,
 	blobs []*deneb.BlobSidecar,
 ) (
 	string,
 	error,
 ) {
+	if body == nil {
+		return "", nil
+	}
+
+	if !verbose {
+		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKZGCommitments)), nil
+	}
+
 	res := strings.Builder{}
 
-	res.WriteString(fmt.Sprintf("Blobs: %d\n", len(blobs)))
-
-	if verbose {
-		for i, blob := range blobs {
-			res.WriteString(fmt.Sprintf("%3d:\n", i))
-			res.WriteString(fmt.Sprintf("    KZG proof: %s\n", blob.KZGProof.String()))
-			res.WriteString(fmt.Sprintf("    KZG commitment: %s\n", blob.KZGCommitment.String()))
+	for i, blob := range blobs {
+		if i == 0 {
+			res.WriteString("Blobs\n")
 		}
+		res.WriteString(fmt.Sprintf("  Index: %d\n", blob.Index))
+		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", body.BlobKZGCommitments[i].String()))
+	}
+
+	return res.String(), nil
+}
+
+func outputElectraBlobInfo(_ context.Context,
+	verbose bool,
+	body *electra.BeaconBlockBody,
+	blobs []*deneb.BlobSidecar,
+) (
+	string,
+	error,
+) {
+	if body == nil {
+		return "", nil
+	}
+
+	if !verbose {
+		return fmt.Sprintf("Blobs: %d\n", len(body.BlobKZGCommitments)), nil
+	}
+
+	res := strings.Builder{}
+
+	for i, blob := range blobs {
+		if i == 0 {
+			res.WriteString("Blobs\n")
+		}
+		res.WriteString(fmt.Sprintf("  Index: %d\n", blob.Index))
+		res.WriteString(fmt.Sprintf("  KZG commitment: %s\n", body.BlobKZGCommitments[i].String()))
 	}
 
 	return res.String(), nil
@@ -1207,7 +1278,7 @@ func outputBellatrixBlockExecutionPayload(_ context.Context,
 		res.WriteString("  Execution block number: ")
 		res.WriteString(fmt.Sprintf("%d\n", payload.BlockNumber))
 		baseFeePerGasBEBytes := make([]byte, len(payload.BaseFeePerGas))
-		for i := range 32 {
+		for i := 0; i < 32; i++ {
 			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
 		}
 		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
@@ -1270,7 +1341,7 @@ func bitlistToString(input bitfield.Bitlist) string {
 	bits := int(input.Len())
 
 	res := ""
-	for i := range bits {
+	for i := 0; i < bits; i++ {
 		if input.BitAt(uint64(i)) {
 			res = fmt.Sprintf("%s✓", res)
 		} else {
@@ -1287,7 +1358,7 @@ func bitvectorToString(input bitfield.Bitvector512) string {
 	bits := int(input.Len())
 
 	res := strings.Builder{}
-	for i := range bits {
+	for i := 0; i < bits; i++ {
 		if input.BitAt(uint64(i)) {
 			res.WriteString("✓")
 		} else {
@@ -1300,118 +1371,13 @@ func bitvectorToString(input bitfield.Bitvector512) string {
 	return res.String()
 }
 
-func attestingIndices(input bitfield.Bitlist,
-	committees map[phase0.CommitteeIndex][]phase0.ValidatorIndex,
-	includedCommittees []int,
-) string {
+func attestingIndices(input bitfield.Bitlist, indices []phase0.ValidatorIndex) string {
 	bits := int(input.Len())
-
-	// Build up the validator list from the included committees.
-	validatorIndices := make([]phase0.ValidatorIndex, 0)
-	for _, committeeIndex := range includedCommittees {
-		validatorIndices = append(validatorIndices, committees[phase0.CommitteeIndex(committeeIndex)]...)
-	}
-
-	res := strings.Builder{}
-
-	for i := range bits {
+	res := ""
+	for i := 0; i < bits; i++ {
 		if input.BitAt(uint64(i)) {
-			// Work out the committee and offset given the index.
-			res.WriteString(fmt.Sprintf("%d ", validatorIndices[i]))
+			res = fmt.Sprintf("%s%d ", res, indices[i])
 		}
 	}
-
-	return strings.TrimSpace(res.String())
-}
-
-func blockGraffiti(_ context.Context, graffiti []byte) string {
-	if len(graffiti) == 0 || hex.EncodeToString(graffiti) == "0000000000000000000000000000000000000000000000000000000000000000" {
-		// No graffiti.
-		return ""
-	}
-
-	// Remove any trailing null characters.
-	graffiti = bytes.TrimRight(graffiti, "\u0000")
-
-	if !utf8.Valid(graffiti) {
-		// Graffiti is not valid UTF-8, return hex.
-		return fmt.Sprintf("Graffiti: %#x\n", graffiti)
-	}
-
-	// See if there is client identification information present in the graffiti.
-	// The client identification will always be the last entry in the graffiti, with a space beforehand.
-	parts := bytes.Split(graffiti, []byte{' '})
-
-	// Consensus and execution client values come from
-	// https://github.com/ethereum/execution-apis/blob/main/src/engine/identification.md
-	consensusClients := map[string]string{
-		"GR": "grandine",
-		"LH": "lighthouse",
-		"LS": "lodestar",
-		"NB": "nimbus",
-		"PM": "prysm",
-		"TK": "teku",
-	}
-	consensusRegex := regexp.MustCompile(`(GR|LH|LS|NB|PM|TK)([0-9a-f]*)`)
-	consensusData := consensusRegex.Find(parts[len(parts)-1])
-
-	executionClients := map[string]string{
-		"BU": "besu",
-		"EG": "erigon",
-		"EJ": "ethereumJS",
-		"GE": "go-ethereum",
-		"NM": "nethermind",
-		"RH": "reth",
-		"TR": "trin-execution",
-	}
-	executionRegex := regexp.MustCompile(`(BU|EG|EJ|GE|NM|RH|TR)([0-9a-f]*)`)
-	executionData := executionRegex.Find(parts[len(parts)-1])
-
-	if len(consensusData) == 0 && len(executionData) == 0 {
-		// There is no identifier; return the graffiti as-is.
-		return fmt.Sprintf("Graffiti: %s\n", string(graffiti))
-	}
-
-	res := strings.Builder{}
-
-	truncatedGraffiti := bytes.Join(parts[0:len(parts)-1], []byte(" "))
-	if len(truncatedGraffiti) > 0 {
-		res.WriteString(fmt.Sprintf("Graffiti: %s\n", string(truncatedGraffiti)))
-	}
-
-	if len(consensusData) > 0 {
-		consensusClient := consensusData[0:2]
-		consensusHash := ""
-		if len(consensusData) > 2 {
-			consensusHash = string(consensusData[2:])
-		}
-
-		res.WriteString("Consensus client: ")
-		res.WriteString(consensusClients[string(consensusClient)])
-		if consensusHash != "" {
-			res.WriteString(" (version hash ")
-			res.WriteString(consensusHash)
-			res.WriteString(")")
-		}
-		res.WriteString("\n")
-	}
-
-	if len(executionData) > 0 {
-		executionClient := executionData[0:2]
-		executionHash := ""
-		if len(executionData) > 2 {
-			executionHash = string(executionData[2:])
-		}
-
-		res.WriteString("Execution client: ")
-		res.WriteString(executionClients[string(executionClient)])
-		if executionHash != "" {
-			res.WriteString(" (version hash ")
-			res.WriteString(executionHash)
-			res.WriteString(")")
-		}
-		res.WriteString("\n")
-	}
-
-	return res.String()
+	return strings.TrimSpace(res)
 }

cmd/block/info/output_internal_test.go

@@ -175,58 +175,3 @@ func TestOutputBlockETH1Data(t *testing.T) {
 		})
 	}
 }
-
-func TestBlockGraffiti(t *testing.T) {
-	tests := []struct {
-		name     string
-		graffiti []byte
-		res      string
-	}{
-		{
-			name:     "Empty",
-			graffiti: []byte(""),
-		},
-		{
-			name:     "NoID",
-			graffiti: []byte("No identifier"),
-			res:      "Graffiti: No identifier\n",
-		},
-		{
-			name:     "SingleClient",
-			graffiti: []byte("Graffiti TK"),
-			res:      "Graffiti: Graffiti\nConsensus client: teku\n",
-		},
-		{
-			name:     "SingleClientImmediate",
-			graffiti: []byte("TK"),
-			res:      "Consensus client: teku\n",
-		},
-		{
-			name:     "SingleClientAndHashImmediate",
-			graffiti: []byte("TKa9f98260"),
-			res:      "Consensus client: teku (version hash a9f98260)\n",
-		},
-		{
-			name:     "DualClients",
-			graffiti: []byte("LHGE"),
-			res:      "Consensus client: lighthouse\nExecution client: go-ethereum\n",
-		},
-		{
-			name:     "DualClientsReverseOrder",
-			graffiti: []byte("GELH"),
-			res:      "Consensus client: lighthouse\nExecution client: go-ethereum\n",
-		},
-		{
-			name:     "DualClientsTruncatedHash",
-			graffiti: []byte("Freedom To Transact TKa9f9NM220b"),
-			res:      "Graffiti: Freedom To Transact\nConsensus client: teku (version hash a9f9)\nExecution client: nethermind (version hash 220b)\n",
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			res := blockGraffiti(context.Background(), test.graffiti)
-			require.Equal(t, test.res, res)
-		})
-	}
-}

cmd/block/info/process.go

@@ -57,10 +57,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		eth2Client: data.eth2Client,
 	}
 
-	err := populateResults(ctx, results)
+	specResponse, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
 	}
+	genesisResponse, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to connect to obtain genesis information")
+	}
+	genesis := genesisResponse.Data
+	results.genesisTime = genesis.GenesisTime
+	results.slotDuration = specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
+	results.slotsPerEpoch = specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
 
 	if data.blockTime != "" {
 		data.blockID, err = timeToBlockID(ctx, data.eth2Client, data.blockTime)
@@ -69,33 +77,68 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		}
 	}
 
-	block, err := obtainBlock(ctx, data, results)
+	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
+		Block: data.blockID,
+	})
 	if err != nil {
-		return nil, err
+		var apiErr *api.Error
+		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
+			if data.quiet {
+				os.Exit(1)
+			}
+
+			return nil, errors.New("empty beacon block")
+		}
+
+		return nil, errors.Wrap(err, "failed to obtain beacon block")
 	}
+	block := blockResponse.Data
 	if data.quiet {
 		os.Exit(0)
 	}
 
 	switch block.Version {
 	case spec.DataVersionPhase0:
-		err = outputPhase0Block(ctx, data.jsonOutput, block.Phase0)
+		if err := outputPhase0Block(ctx, data.jsonOutput, block.Phase0); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
 	case spec.DataVersionAltair:
-		err = outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair)
+		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
 	case spec.DataVersionBellatrix:
-		err = outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix)
+		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
 	case spec.DataVersionCapella:
-		err = outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella)
+		if err := outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
 	case spec.DataVersionDeneb:
-		err = processDenebBlock(ctx, data, block)
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain blob sidecars")
+		}
+		blobSidecars := blobSidecarsResponse.Data
+		if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, block.Deneb, blobSidecars); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
 	case spec.DataVersionElectra:
-		err = processElectraBlock(ctx, data, block)
+		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: data.blockID,
+		})
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to obtain blob sidecars")
+		}
+		blobSidecars := blobSidecarsResponse.Data
+		if err := outputElectraBlock(ctx, data.jsonOutput, data.sszOutput, block.Electra, blobSidecars); err != nil {
+			return nil, errors.Wrap(err, "failed to output block")
+		}
 	default:
 		return nil, errors.New("unknown block version")
 	}
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to process block")
-	}
 
 	if data.stream {
 		jsonOutput = data.jsonOutput
@@ -113,97 +156,6 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return &dataOut{}, nil
 }
 
-func populateResults(ctx context.Context, results *dataOut) error {
-	specResponse, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
-	if err != nil {
-		return errors.Wrap(err, "failed to connect to obtain configuration information")
-	}
-	genesisResponse, err := results.eth2Client.(eth2client.GenesisProvider).Genesis(ctx, &api.GenesisOpts{})
-	if err != nil {
-		return errors.Wrap(err, "failed to connect to obtain genesis information")
-	}
-	genesis := genesisResponse.Data
-	results.genesisTime = genesis.GenesisTime
-	results.slotDuration = specResponse.Data["SECONDS_PER_SLOT"].(time.Duration)
-	results.slotsPerEpoch = specResponse.Data["SLOTS_PER_EPOCH"].(uint64)
-
-	return nil
-}
-
-func obtainBlock(ctx context.Context, data *dataIn, results *dataOut,
-) (
-	*spec.VersionedSignedBeaconBlock,
-	error,
-) {
-	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
-		Block: data.blockID,
-	})
-	if err != nil {
-		var apiErr *api.Error
-		if errors.As(err, &apiErr) && apiErr.StatusCode == http.StatusNotFound {
-			if data.quiet {
-				os.Exit(1)
-			}
-
-			return nil, errors.New("empty beacon block")
-		}
-
-		return nil, errors.Wrap(err, "failed to obtain beacon block")
-	}
-
-	return blockResponse.Data, nil
-}
-
-func processDenebBlock(ctx context.Context,
-	data *dataIn,
-	block *spec.VersionedSignedBeaconBlock,
-) error {
-	var blobSidecars []*deneb.BlobSidecar
-	kzgCommitments, err := block.BlobKZGCommitments()
-	if err != nil {
-		return err
-	}
-	if len(kzgCommitments) > 0 {
-		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
-			Block: data.blockID,
-		})
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain blob sidecars")
-		}
-		blobSidecars = blobSidecarsResponse.Data
-	}
-	if err := outputDenebBlock(ctx, data.jsonOutput, data.sszOutput, block.Deneb, blobSidecars); err != nil {
-		return errors.Wrap(err, "failed to output block")
-	}
-
-	return nil
-}
-
-func processElectraBlock(ctx context.Context,
-	data *dataIn,
-	block *spec.VersionedSignedBeaconBlock,
-) error {
-	var blobSidecars []*deneb.BlobSidecar
-	kzgCommitments, err := block.BlobKZGCommitments()
-	if err != nil {
-		return err
-	}
-	if len(kzgCommitments) > 0 {
-		blobSidecarsResponse, err := results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
-			Block: data.blockID,
-		})
-		if err != nil {
-			return errors.Wrap(err, "failed to obtain blob sidecars")
-		}
-		blobSidecars = blobSidecarsResponse.Data
-	}
-	if err := outputElectraBlock(ctx, data.jsonOutput, data.sszOutput, block.Electra, blobSidecars); err != nil {
-		return errors.Wrap(err, "failed to output block")
-	}
-
-	return nil
-}
-
 func headEventHandler(event *apiv1.Event) {
 	ctx := context.Background()
 
@@ -240,25 +192,21 @@ func headEventHandler(event *apiv1.Event) {
 	case spec.DataVersionCapella:
 		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, block.Capella)
 	case spec.DataVersionDeneb:
-		var blobSidecars []*deneb.BlobSidecar
-		var kzgCommitments []deneb.KZGCommitment
-		kzgCommitments, err = block.BlobKZGCommitments()
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "Failed to obtain KZG commitments: %v\n", err)
-			return
+		var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+		blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: blockID,
+		})
+		if err == nil {
+			err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, block.Deneb, blobSidecarsResponse.Data)
 		}
-		if len(kzgCommitments) > 0 {
-			var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
-			blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
-				Block: blockID,
-			})
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "Failed to obtain blob sidecars: %v\n", err)
-				return
-			}
-			blobSidecars = blobSidecarsResponse.Data
+	case spec.DataVersionElectra:
+		var blobSidecarsResponse *api.Response[[]*deneb.BlobSidecar]
+		blobSidecarsResponse, err = results.eth2Client.(eth2client.BlobSidecarsProvider).BlobSidecars(ctx, &api.BlobSidecarsOpts{
+			Block: blockID,
+		})
+		if err == nil {
+			err = outputElectraBlock(context.Background(), jsonOutput, sszOutput, block.Electra, blobSidecarsResponse.Data)
 		}
-		err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, block.Deneb, blobSidecars)
 	default:
 		err = errors.New("unknown block version")
 	}

cmd/chain/eth1votes/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	xepoch  string
@@ -64,10 +65,11 @@ type vote struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
-		json:    viper.GetBool("json"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		json:              viper.GetBool("json"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/chain/eth1votes/process.go

@@ -127,10 +127,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")

cmd/chain/queues/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	epoch string
@@ -49,10 +50,11 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
-		json:    viper.GetBool("json"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		json:              viper.GetBool("json"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/chain/queues/process.go

@@ -62,10 +62,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")

cmd/chain/time/input.go

@@ -31,6 +31,7 @@ type dataIn struct {
 	// Input
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 	timestamp                string
 	slot                     string
 	epoch                    string
@@ -73,6 +74,7 @@ func input(_ context.Context) (*dataIn, error) {
 
 	data.connection = viper.GetString("connection")
 	data.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	data.customSpecSupport = viper.GetBool("custom-spec")
 
 	return data, nil
 }

cmd/chain/time/process.go

@@ -31,10 +31,11 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	}
 
 	eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       data.connection,
-		Timeout:       data.timeout,
-		AllowInsecure: data.allowInsecureConnections,
-		LogFallback:   !data.quiet,
+		Address:           data.connection,
+		Timeout:           data.timeout,
+		AllowInsecure:     data.allowInsecureConnections,
+		CustomSpecSupport: data.customSpecSupport,
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to Ethereum 2 beacon node")

cmd/chain/verify/signedcontributionandproof/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	data string
@@ -60,9 +61,10 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/chain/verify/signedcontributionandproof/process.go

@@ -87,10 +87,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -221,7 +222,7 @@ func (c *command) confirmContributionSignature(ctx context.Context) error {
 
 	subCommittee := c.syncCommittee.ValidatorAggregates[c.item.Message.Contribution.SubcommitteeIndex]
 	includedIndices := make([]phase0.ValidatorIndex, 0, len(subCommittee))
-	for i := range c.item.Message.Contribution.AggregationBits.Len() {
+	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)])
 		}

cmd/chaininfo.go

@@ -40,10 +40,11 @@ In quiet mode this will return 0 if the chain information can be obtained, other
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 

cmd/chainspec.go

@@ -41,10 +41,11 @@ In quiet mode this will return 0 if the chain specification can be obtained, oth
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum consensus node")
 

cmd/chainstatus.go

@@ -44,10 +44,11 @@ In quiet mode this will return 0 if the chain status can be obtained, otherwise
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 

cmd/epoch.go

@@ -29,12 +29,12 @@ func init() {
 	RootCmd.AddCommand(epochCmd)
 }
 
-func epochFlags(cmd *cobra.Command) {
-	cmd.Flags().String("epoch", "", "the epoch for which to obtain information (default current, can be 'current', 'last' or a number)")
+func epochFlags(_ *cobra.Command) {
+	epochSummaryCmd.Flags().String("epoch", "", "the epoch for which to obtain information (default current, can be 'current', 'last' or a number)")
 }
 
 func epochBindings(cmd *cobra.Command) {
-	if err := viper.BindPFlag("validators", cmd.Flags().Lookup("validators")); err != nil {
+	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
 		panic(err)
 	}
 }

cmd/epoch/summary/command.go

@@ -34,13 +34,12 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
-	epoch         string
-	validatorsStr []string
-	validators    map[phase0.ValidatorIndex]struct{}
-	stream        bool
-	jsonOutput    bool
+	epoch      string
+	stream     bool
+	jsonOutput bool
 
 	// Data access.
 	eth2Client                 eth2client.Service
@@ -60,61 +59,45 @@ type command struct {
 }
 
 type epochSummary struct {
-	Epoch                      phase0.Epoch          `json:"epoch"`
-	FirstSlot                  phase0.Slot           `json:"first_slot"`
-	LastSlot                   phase0.Slot           `json:"last_slot"`
-	Blocks                     int                   `json:"blocks"`
-	Proposals                  []*epochProposal      `json:"proposals"`
-	SyncCommitteeValidators    int                   `json:"sync_committee_validators"`
-	SyncCommittee              []*epochSyncCommittee `json:"sync_committees"`
-	ActiveValidators           int                   `json:"active_validators"`
-	ParticipatingValidators    int                   `json:"participating_validators"`
-	HeadCorrectValidators      int                   `json:"head_correct_validators"`
-	HeadTimelyValidators       int                   `json:"head_timely_validators"`
-	SourceTimelyValidators     int                   `json:"source_timely_validators"`
-	TargetCorrectValidators    int                   `json:"target_correct_validators"`
-	TargetTimelyValidators     int                   `json:"target_timely_validators"`
-	NonParticipatingValidators []*attestingValidator `json:"nonparticipating_validators"`
-	NonHeadCorrectValidators   []*attestingValidator `json:"nonheadcorrect_validators"`
-	NonHeadTimelyValidators    []*attestingValidator `json:"nonheadtimely_validators"`
-	NonTargetCorrectValidators []*attestingValidator `json:"nontargetcorrect_validators"`
-	NonSourceTimelyValidators  []*attestingValidator `json:"nonsourcetimely_validators"`
-	Blobs                      int                   `json:"blobs"`
+	Epoch                      phase0.Epoch                 `json:"epoch"`
+	FirstSlot                  phase0.Slot                  `json:"first_slot"`
+	LastSlot                   phase0.Slot                  `json:"last_slot"`
+	Proposals                  []*epochProposal             `json:"proposals"`
+	SyncCommittee              []*epochSyncCommittee        `json:"sync_committees"`
+	ActiveValidators           int                          `json:"active_validators"`
+	ParticipatingValidators    int                          `json:"participating_validators"`
+	HeadCorrectValidators      int                          `json:"head_correct_validators"`
+	HeadTimelyValidators       int                          `json:"head_timely_validators"`
+	SourceTimelyValidators     int                          `json:"source_timely_validators"`
+	TargetCorrectValidators    int                          `json:"target_correct_validators"`
+	TargetTimelyValidators     int                          `json:"target_timely_validators"`
+	NonParticipatingValidators []*nonParticipatingValidator `json:"nonparticipating_validators"`
+	Blobs                      int                          `json:"blobs"`
 }
 
 type epochProposal struct {
-	ValidatorIndex phase0.ValidatorIndex `json:"validator_index"`
-	Slot           phase0.Slot           `json:"slot"`
-	Block          bool                  `json:"block"`
+	Slot     phase0.Slot           `json:"slot"`
+	Proposer phase0.ValidatorIndex `json:"proposer"`
+	Block    bool                  `json:"block"`
 }
 
 type epochSyncCommittee struct {
-	ValidatorIndex phase0.ValidatorIndex `json:"validator_index"`
-	Missed         int                   `json:"missed"`
-	MissedSlots    []phase0.Slot         `json:"missed_slots"`
+	Index  phase0.ValidatorIndex `json:"index"`
+	Missed int                   `json:"missed"`
 }
 
-type attestingValidator struct {
-	Validator     phase0.ValidatorIndex `json:"validator_index"`
-	Slot          phase0.Slot           `json:"slot"`
-	Committee     phase0.CommitteeIndex `json:"committee_index"`
-	HeadVote      *phase0.Root          `json:"head_vote,omitempty"`
-	Head          *phase0.Root          `json:"head,omitempty"`
-	TargetVote    *phase0.Root          `json:"target_vote,omitempty"`
-	Target        *phase0.Root          `json:"target,omitempty"`
-	InclusionSlot phase0.Slot           `json:"inclusion_slot,omitempty"`
+type nonParticipatingValidator struct {
+	Validator phase0.ValidatorIndex `json:"validator_index"`
+	Slot      phase0.Slot           `json:"slot"`
+	Committee phase0.CommitteeIndex `json:"committee_index"`
 }
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:         viper.GetBool("quiet"),
-		verbose:       viper.GetBool("verbose"),
-		debug:         viper.GetBool("debug"),
-		validatorsStr: viper.GetStringSlice("validators"),
-		summary: &epochSummary{
-			Proposals: make([]*epochProposal, 0),
-		},
-		validators:  make(map[phase0.ValidatorIndex]struct{}),
+		quiet:       viper.GetBool("quiet"),
+		verbose:     viper.GetBool("verbose"),
+		debug:       viper.GetBool("debug"),
+		summary:     &epochSummary{},
 		blocksCache: make(map[string]*spec.VersionedSignedBeaconBlock),
 	}
 
@@ -126,6 +109,7 @@ func newCommand(_ context.Context) (*command, error) {
 
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	c.customSpecSupport = viper.GetBool("custom-spec")
 
 	c.epoch = viper.GetString("epoch")
 	c.stream = viper.GetBool("stream")

cmd/epoch/summary/output.go

@@ -50,7 +50,7 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 	missedProposals := make([]string, 0, len(c.summary.Proposals))
 	for _, proposal := range c.summary.Proposals {
 		if !proposal.Block {
-			missedProposals = append(missedProposals, fmt.Sprintf("\n    Slot %d (validator %d)", proposal.Slot, proposal.ValidatorIndex))
+			missedProposals = append(missedProposals, fmt.Sprintf("\n    Slot %d (validator %d)", proposal.Slot, proposal.Proposer))
 		} else {
 			proposedBlocks++
 		}
@@ -64,7 +64,7 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 			builder.WriteString("\n    Slot ")
 			builder.WriteString(fmt.Sprintf("%d (%d/%d)", proposal.Slot, uint64(proposal.Slot)%uint64(len(c.summary.Proposals)), len(c.summary.Proposals)))
 			builder.WriteString(" validator ")
-			builder.WriteString(fmt.Sprintf("%d", proposal.ValidatorIndex))
+			builder.WriteString(fmt.Sprintf("%d", proposal.Proposer))
 			builder.WriteString(" not proposed or not included")
 		}
 	}
@@ -98,7 +98,7 @@ func (c *command) outputTxt(_ context.Context) (string, error) {
 		if c.verbose {
 			for _, syncCommittee := range c.summary.SyncCommittee {
 				builder.WriteString("\n    Validator ")
-				builder.WriteString(fmt.Sprintf("%d", syncCommittee.ValidatorIndex))
+				builder.WriteString(fmt.Sprintf("%d", syncCommittee.Index))
 				builder.WriteString(" included ")
 				builder.WriteString(fmt.Sprintf("%d/%d", proposedBlocks-syncCommittee.Missed, proposedBlocks))
 				builder.WriteString(fmt.Sprintf(" (%0.2f%%)", 100.0*float64(proposedBlocks-syncCommittee.Missed)/float64(proposedBlocks)))

cmd/epoch/summary/process.go

@@ -43,14 +43,6 @@ func (c *command) process(ctx context.Context) error {
 	c.summary.FirstSlot = c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)
 	c.summary.LastSlot = c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) - 1
 
-	validators, err := util.ParseValidators(ctx, c.validatorsProvider, c.validatorsStr, "head")
-	if err != nil {
-		return errors.Wrap(err, "failed to parse validators")
-	}
-	for _, validator := range validators {
-		c.validators[validator.Index] = struct{}{}
-	}
-
 	if err := c.processProposerDuties(ctx); err != nil {
 		return err
 	}
@@ -60,7 +52,6 @@ func (c *command) process(ctx context.Context) error {
 	if err := c.processSyncCommitteeDuties(ctx); err != nil {
 		return err
 	}
-
 	return c.processBlobs(ctx)
 }
 
@@ -78,20 +69,10 @@ func (c *command) processProposerDuties(ctx context.Context) error {
 			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", duty.Slot))
 		}
 		present := block != nil
-		if present {
-			c.summary.Blocks++
-		}
-
-		_, exists := c.validators[duty.ValidatorIndex]
-		if len(c.validators) > 0 && !exists {
-			// Not one of ours.
-			continue
-		}
-
 		c.summary.Proposals = append(c.summary.Proposals, &epochProposal{
-			Slot:           duty.Slot,
-			ValidatorIndex: duty.ValidatorIndex,
-			Block:          present,
+			Slot:     duty.Slot,
+			Proposer: duty.ValidatorIndex,
+			Block:    present,
 		})
 	}
 
@@ -99,25 +80,14 @@ func (c *command) processProposerDuties(ctx context.Context) error {
 }
 
 func (c *command) activeValidators(ctx context.Context) (map[phase0.ValidatorIndex]*apiv1.Validator, error) {
-	validatorIndices := make([]phase0.ValidatorIndex, 0, len(c.validators))
-	for validator := range c.validators {
-		validatorIndices = append(validatorIndices, validator)
-	}
-
 	response, err := c.validatorsProvider.Validators(ctx, &api.ValidatorsOpts{
-		State:   "head",
-		Indices: validatorIndices,
+		State: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)),
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to obtain validators for epoch")
 	}
 	activeValidators := make(map[phase0.ValidatorIndex]*apiv1.Validator)
 	for _, validator := range response.Data {
-		_, exists := c.validators[validator.Index]
-		if len(c.validators) > 0 && !exists {
-			continue
-		}
-
 		if validator.Validator.ActivationEpoch <= c.summary.Epoch && validator.Validator.ExitEpoch > c.summary.Epoch {
 			activeValidators[validator.Index] = validator
 		}
@@ -142,45 +112,20 @@ func (c *command) processAttesterDuties(ctx context.Context) error {
 		lastSlot = c.chainTime.CurrentSlot()
 	}
 
-	participatingValidators, headCorrectValidators, headTimelyValidators, sourceTimelyValidators, targetCorrectValidators, targetTimelyValidators, participations, err := c.processSlots(ctx, firstSlot, lastSlot)
+	var votes map[phase0.ValidatorIndex]struct{}
+	var participations map[phase0.ValidatorIndex]*nonParticipatingValidator
+	c.summary.ParticipatingValidators, c.summary.HeadCorrectValidators, c.summary.HeadTimelyValidators, c.summary.SourceTimelyValidators, c.summary.TargetCorrectValidators, c.summary.TargetTimelyValidators, votes, participations, err = c.processSlots(ctx, firstSlot, lastSlot)
 	if err != nil {
 		return err
 	}
 
-	c.summary.ParticipatingValidators = len(participatingValidators)
-	c.summary.HeadCorrectValidators = len(headCorrectValidators)
-	c.summary.HeadTimelyValidators = len(headTimelyValidators)
-	c.summary.SourceTimelyValidators = len(sourceTimelyValidators)
-	c.summary.TargetCorrectValidators = len(targetCorrectValidators)
-	c.summary.TargetTimelyValidators = len(targetTimelyValidators)
-
-	c.summary.NonParticipatingValidators = make([]*attestingValidator, 0, len(activeValidators)-len(participatingValidators))
+	c.summary.NonParticipatingValidators = make([]*nonParticipatingValidator, 0, len(activeValidators)-len(votes))
 	for activeValidatorIndex := range activeValidators {
-		if _, exists := participatingValidators[activeValidatorIndex]; !exists {
+		if _, exists := votes[activeValidatorIndex]; !exists {
 			if _, exists := participations[activeValidatorIndex]; exists {
 				c.summary.NonParticipatingValidators = append(c.summary.NonParticipatingValidators, participations[activeValidatorIndex])
 			}
 		}
-		if _, exists := headCorrectValidators[activeValidatorIndex]; !exists {
-			if _, exists := participations[activeValidatorIndex]; exists {
-				c.summary.NonHeadCorrectValidators = append(c.summary.NonHeadCorrectValidators, participations[activeValidatorIndex])
-			}
-		}
-		if _, exists := headTimelyValidators[activeValidatorIndex]; !exists {
-			if _, exists := participations[activeValidatorIndex]; exists {
-				c.summary.NonHeadTimelyValidators = append(c.summary.NonHeadTimelyValidators, participations[activeValidatorIndex])
-			}
-		}
-		if _, exists := targetCorrectValidators[activeValidatorIndex]; !exists {
-			if _, exists := participations[activeValidatorIndex]; exists {
-				c.summary.NonTargetCorrectValidators = append(c.summary.NonTargetCorrectValidators, participations[activeValidatorIndex])
-			}
-		}
-		if _, exists := sourceTimelyValidators[activeValidatorIndex]; !exists {
-			if _, exists := participations[activeValidatorIndex]; exists {
-				c.summary.NonSourceTimelyValidators = append(c.summary.NonSourceTimelyValidators, participations[activeValidatorIndex])
-			}
-		}
 	}
 	sort.Slice(c.summary.NonParticipatingValidators, func(i int, j int) bool {
 		if c.summary.NonParticipatingValidators[i].Slot != c.summary.NonParticipatingValidators[j].Slot {
@@ -195,18 +140,18 @@ func (c *command) processAttesterDuties(ctx context.Context) error {
 	return nil
 }
 
-//nolint:gocyclo
 func (c *command) processSlots(ctx context.Context,
 	firstSlot phase0.Slot,
 	lastSlot phase0.Slot,
 ) (
+	int,
+	int,
+	int,
+	int,
+	int,
+	int,
 	map[phase0.ValidatorIndex]struct{},
-	map[phase0.ValidatorIndex]struct{},
-	map[phase0.ValidatorIndex]struct{},
-	map[phase0.ValidatorIndex]struct{},
-	map[phase0.ValidatorIndex]struct{},
-	map[phase0.ValidatorIndex]struct{},
-	map[phase0.ValidatorIndex]*attestingValidator,
+	map[phase0.ValidatorIndex]*nonParticipatingValidator,
 	error,
 ) {
 	votes := make(map[phase0.ValidatorIndex]struct{})
@@ -216,7 +161,7 @@ func (c *command) processSlots(ctx context.Context,
 	targetCorrects := make(map[phase0.ValidatorIndex]struct{})
 	targetTimelys := make(map[phase0.ValidatorIndex]struct{})
 	allCommittees := make(map[phase0.Slot]map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
-	participations := make(map[phase0.ValidatorIndex]*attestingValidator)
+	participations := make(map[phase0.ValidatorIndex]*nonParticipatingValidator)
 
 	// Need a cache of beacon block headers to reduce lookup times.
 	headersCache := util.NewBeaconBlockHeaderCache(c.beaconBlockHeadersProvider)
@@ -224,7 +169,7 @@ func (c *command) processSlots(ctx context.Context,
 	for slot := firstSlot; slot <= lastSlot; slot++ {
 		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", slot))
 		if err != nil {
-			return nil, nil, nil, nil, nil, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
+			return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
 		}
 		if block == nil {
 			// No block at this slot; that's fine.
@@ -232,16 +177,16 @@ func (c *command) processSlots(ctx context.Context,
 		}
 		slot, err := block.Slot()
 		if err != nil {
-			return nil, nil, nil, nil, nil, nil, nil, err
+			return 0, 0, 0, 0, 0, 0, nil, nil, err
 		}
 		attestations, err := block.Attestations()
 		if err != nil {
-			return nil, nil, nil, nil, nil, nil, nil, err
+			return 0, 0, 0, 0, 0, 0, nil, nil, err
 		}
 		for _, attestation := range attestations {
 			attestationData, err := attestation.Data()
 			if err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, errors.Wrap(err, "failed to obtain attestation data")
+				return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain attestation data for slot %d", slot))
 			}
 			if attestationData.Slot < c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) || attestationData.Slot >= c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) {
 				// Outside of this epoch's range.
@@ -253,29 +198,18 @@ func (c *command) processSlots(ctx context.Context,
 					State: fmt.Sprintf("%d", attestationData.Slot),
 				})
 				if err != nil {
-					return nil, nil, nil, nil, nil, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestationData.Slot))
+					return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestationData.Slot))
 				}
 				for _, beaconCommittee := range response.Data {
 					if _, exists := allCommittees[beaconCommittee.Slot]; !exists {
 						allCommittees[beaconCommittee.Slot] = make(map[phase0.CommitteeIndex][]phase0.ValidatorIndex)
 					}
-
 					allCommittees[beaconCommittee.Slot][beaconCommittee.Index] = beaconCommittee.Validators
-
 					for _, index := range beaconCommittee.Validators {
-						if len(c.validators) > 0 {
-							if _, exists := c.validators[index]; !exists {
-								// Not one of our validators.
-								continue
-							}
-						}
-
-						if _, exists := participations[index]; !exists {
-							participations[index] = &attestingValidator{
-								Validator: index,
-								Slot:      beaconCommittee.Slot,
-								Committee: beaconCommittee.Index,
-							}
+						participations[index] = &nonParticipatingValidator{
+							Validator: index,
+							Slot:      beaconCommittee.Slot,
+							Committee: beaconCommittee.Index,
 						}
 					}
 				}
@@ -284,74 +218,49 @@ func (c *command) processSlots(ctx context.Context,
 			committee := slotCommittees[attestationData.Index]
 
 			inclusionDistance := slot - attestationData.Slot
-
-			head, err := util.AttestationHead(ctx, headersCache, attestation)
+			headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestationData)
 			if err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, err
+				return 0, 0, 0, 0, 0, 0, nil, nil, err
 			}
-			headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestation)
+			targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestationData)
 			if err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, err
-			}
-			target, err := util.AttestationTarget(ctx, headersCache, c.chainTime, attestation)
-			if err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, err
-			}
-			targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestation)
-			if err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, err
+				return 0, 0, 0, 0, 0, 0, nil, nil, err
 			}
 
 			aggregationBits, err := attestation.AggregationBits()
 			if err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, errors.Wrap(err, "failed to obtain aggregation bits")
+				return 0, 0, 0, 0, 0, 0, nil, nil, err
 			}
-			for i := range aggregationBits.Len() {
+			for i := uint64(0); i < aggregationBits.Len(); i++ {
 				if aggregationBits.BitAt(i) {
-					validatorIndex := committee[int(i)]
-					if len(c.validators) > 0 {
-						if _, exists := c.validators[validatorIndex]; !exists {
-							// Not one of our validators.
-							continue
-						}
+					votes[committee[int(i)]] = struct{}{}
+					if _, exists := headCorrects[committee[int(i)]]; !exists && headCorrect {
+						headCorrects[committee[int(i)]] = struct{}{}
 					}
-
-					// Only set the information from the first attestation we find for this validator.
-					if participations[validatorIndex].InclusionSlot == 0 {
-						participations[validatorIndex].HeadVote = &attestationData.BeaconBlockRoot
-						participations[validatorIndex].Head = &head
-						participations[validatorIndex].TargetVote = &attestationData.Target.Root
-						participations[validatorIndex].Target = &target
-						participations[validatorIndex].InclusionSlot = slot
+					if _, exists := headTimelys[committee[int(i)]]; !exists && headCorrect && inclusionDistance == 1 {
+						headTimelys[committee[int(i)]] = struct{}{}
 					}
-
-					votes[validatorIndex] = struct{}{}
-					if _, exists := headCorrects[validatorIndex]; !exists && headCorrect {
-						headCorrects[validatorIndex] = struct{}{}
+					if _, exists := sourceTimelys[committee[int(i)]]; !exists && inclusionDistance <= 5 {
+						sourceTimelys[committee[int(i)]] = struct{}{}
 					}
-					if _, exists := headTimelys[validatorIndex]; !exists && headCorrect && inclusionDistance == 1 {
-						headTimelys[validatorIndex] = struct{}{}
+					if _, exists := targetCorrects[committee[int(i)]]; !exists && targetCorrect {
+						targetCorrects[committee[int(i)]] = struct{}{}
 					}
-					if _, exists := sourceTimelys[validatorIndex]; !exists && inclusionDistance <= 5 {
-						sourceTimelys[validatorIndex] = struct{}{}
-					}
-					if _, exists := targetCorrects[validatorIndex]; !exists && targetCorrect {
-						targetCorrects[validatorIndex] = struct{}{}
-					}
-					if _, exists := targetTimelys[validatorIndex]; !exists && targetCorrect && inclusionDistance <= 32 {
-						targetTimelys[validatorIndex] = struct{}{}
+					if _, exists := targetTimelys[committee[int(i)]]; !exists && targetCorrect && inclusionDistance <= 32 {
+						targetTimelys[committee[int(i)]] = struct{}{}
 					}
 				}
 			}
 		}
 	}
 
-	return votes,
-		headCorrects,
-		headTimelys,
-		sourceTimelys,
-		targetCorrects,
-		targetTimelys,
+	return len(votes),
+		len(headCorrects),
+		len(headTimelys),
+		len(sourceTimelys),
+		len(targetCorrects),
+		len(targetTimelys),
+		votes,
 		participations,
 		nil
 }
@@ -373,18 +282,7 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 		return errors.Wrap(err, "empty sync committee")
 	}
 
-	for _, validatorIndex := range committee.Validators {
-		if len(c.validators) == 0 {
-			c.summary.SyncCommitteeValidators++
-		} else {
-			if _, exists := c.validators[validatorIndex]; exists {
-				c.summary.SyncCommitteeValidators++
-			}
-		}
-	}
-
 	missed := make(map[phase0.ValidatorIndex]int)
-	missedSlots := make(map[phase0.ValidatorIndex][]phase0.Slot)
 	for _, index := range committee.Validators {
 		missed[index] = 0
 	}
@@ -407,15 +305,9 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 		if err != nil {
 			return errors.Wrapf(err, "failed to obtain sync aggregate for slot %d", slot)
 		}
-		for i := range aggregate.SyncCommitteeBits.Len() {
-			validatorIndex := committee.Validators[int(i)]
-			if _, exists := c.validators[validatorIndex]; !exists {
-				// Not one of ours.
-				continue
-			}
+		for i := uint64(0); i < aggregate.SyncCommitteeBits.Len(); i++ {
 			if !aggregate.SyncCommitteeBits.BitAt(i) {
-				missed[validatorIndex]++
-				missedSlots[validatorIndex] = append(missedSlots[validatorIndex], slot)
+				missed[committee.Validators[int(i)]]++
 			}
 		}
 	}
@@ -424,9 +316,8 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 	for index, count := range missed {
 		if count > 0 {
 			c.summary.SyncCommittee = append(c.summary.SyncCommittee, &epochSyncCommittee{
-				ValidatorIndex: index,
-				Missed:         count,
-				MissedSlots:    missedSlots[index],
+				Index:  index,
+				Missed: count,
 			})
 		}
 	}
@@ -438,7 +329,7 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 			return missedDiff > 0
 		}
 		// Then order by validator index.
-		return c.summary.SyncCommittee[i].ValidatorIndex < c.summary.SyncCommittee[j].ValidatorIndex
+		return c.summary.SyncCommittee[i].Index < c.summary.SyncCommittee[j].Index
 	})
 
 	return nil
@@ -449,10 +340,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")
@@ -496,10 +388,10 @@ func (c *command) setup(ctx context.Context) error {
 }
 
 func (c *command) processBlobs(ctx context.Context) error {
-	for _, proposal := range c.summary.Proposals {
-		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", proposal.Slot))
+	for slot := c.summary.FirstSlot; slot <= c.summary.LastSlot; slot++ {
+		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", slot))
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", proposal.Slot))
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
 		}
 		if block == nil {
 			continue

cmd/epochsummary.go

@@ -46,17 +46,9 @@ In quiet mode this will return 0 if information for the epoch is found, otherwis
 
 func init() {
 	epochCmd.AddCommand(epochSummaryCmd)
-	epochSummaryFlags(epochSummaryCmd)
-}
-
-func epochSummaryFlags(cmd *cobra.Command) {
-	epochFlags(cmd)
-	cmd.Flags().StringSlice("validators", nil, "the validators for which to obtain a summary")
+	epochFlags(epochSummaryCmd)
 }
 
 func epochSummaryBindings(cmd *cobra.Command) {
 	epochBindings(cmd)
-	if err := viper.BindPFlag("validators", cmd.Flags().Lookup("validators")); err != nil {
-		panic(err)
-	}
 }

cmd/exitverify.go

@@ -47,10 +47,11 @@ In quiet mode this will return 0 if the exit is verified correctly, otherwise 1.
 		errCheck(err, "Failed to obtain signed operation")
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 

cmd/node/events/input.go

@@ -51,10 +51,11 @@ func input(ctx context.Context) (*dataIn, error) {
 
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/nodeinfo.go

@@ -37,10 +37,11 @@ In quiet mode this will return 0 if the node information can be obtained, otherw
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 

cmd/proposer/duties/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	epoch      string
@@ -62,6 +63,7 @@ func newCommand(_ context.Context) (*command, error) {
 		timeout:                  viper.GetDuration("timeout"),
 		connection:               viper.GetString("connection"),
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		customSpecSupport:        viper.GetBool("custom-spec"),
 		epoch:                    viper.GetString("epoch"),
 		slot:                     viper.GetString("slot"),
 		jsonOutput:               viper.GetBool("json"),

cmd/proposer/duties/process.go

@@ -88,10 +88,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")

cmd/root.go

@@ -136,6 +136,7 @@ func init() {
 	addPersistentFlags()
 }
 
+//nolint:gocyclo
 func addPersistentFlags() {
 	RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.ethdo.yaml)")
 
@@ -252,6 +253,10 @@ func addPersistentFlags() {
 	if err := viper.BindPFlag("allow-insecure-connections", RootCmd.PersistentFlags().Lookup("allow-insecure-connections")); err != nil {
 		panic(err)
 	}
+	RootCmd.PersistentFlags().Bool("custom-spec", false, "allow custom (non-mainnet) beacon node specifications")
+	if err := viper.BindPFlag("custom-spec", RootCmd.PersistentFlags().Lookup("custom-spec")); err != nil {
+		panic(err)
+	}
 }
 
 // initConfig reads in config file and ENV variables if set.

cmd/signaturesign.go

@@ -19,7 +19,6 @@ import (
 	"os"
 
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
@@ -60,8 +59,6 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 			account, err = util.ParseAccount(ctx, viper.GetString("account"), util.GetPassphrases(), true)
 		case viper.GetString("private-key") != "":
 			account, err = util.ParseAccount(ctx, viper.GetString("private-key"), nil, true)
-		default:
-			err = errors.New("account or private key must be supplied")
 		}
 		errCheck(err, "Failed to obtain account")
 

cmd/signatureverify.go

@@ -19,7 +19,6 @@ import (
 	"os"
 
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/wealdtech/ethdo/util"
@@ -72,10 +71,6 @@ In quiet mode this will return 0 if the data can be signed, otherwise 1.`,
 			account, err = util.ParseAccount(ctx, viper.GetString("private-key"), nil, false)
 		case viper.GetString("public-key") != "":
 			account, err = util.ParseAccount(ctx, viper.GetString("public-key"), nil, false)
-		case signatureVerifySigner != "":
-			account, err = util.ParseAccount(ctx, signatureVerifySigner, nil, false)
-		default:
-			err = errors.New("one of account, private-key, public-key, or signer must be supplied")
 		}
 		errCheck(err, "Failed to obtain account")
 		outputIf(viper.GetBool("debug"), fmt.Sprintf("Public key is %#x", account.PublicKey().Marshal()))

cmd/slot/time/input.go

@@ -53,10 +53,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/synccommittee/inclusion/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	validator string
@@ -51,9 +52,10 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/synccommittee/inclusion/process.go

@@ -141,10 +141,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return err

cmd/synccommittee/members/input.go

@@ -52,10 +52,11 @@ func input(ctx context.Context) (*dataIn, error) {
 	// Ethereum 2 client.
 	var err error
 	data.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       viper.GetString("connection"),
-		Timeout:       viper.GetDuration("timeout"),
-		AllowInsecure: viper.GetBool("allow-insecure-connections"),
-		LogFallback:   !data.quiet,
+		Address:           viper.GetString("connection"),
+		Timeout:           viper.GetDuration("timeout"),
+		AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+		CustomSpecSupport: viper.GetBool("custom-spec"),
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/validator/credentials/get/command.go

@@ -35,6 +35,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Data access.
 	consensusClient    eth2client.Service
@@ -46,9 +47,10 @@ type command struct {
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:   viper.GetBool("quiet"),
-		verbose: viper.GetBool("verbose"),
-		debug:   viper.GetBool("debug"),
+		quiet:             viper.GetBool("quiet"),
+		verbose:           viper.GetBool("verbose"),
+		debug:             viper.GetBool("debug"),
+		customSpecSupport: viper.GetBool("custom-spec"),
 	}
 
 	// Timeout.

cmd/validator/credentials/get/process.go

@@ -49,10 +49,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the consensus node.
 	c.consensusClient, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to consensus node")

cmd/validator/credentials/set/command.go

@@ -54,6 +54,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Information required to generate the operations.
 	withdrawalAddress bellatrix.ExecutionAddress
@@ -78,6 +79,7 @@ func newCommand(_ context.Context) (*command, error) {
 		timeout:                  viper.GetDuration("timeout"),
 		connection:               viper.GetString("connection"),
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		customSpecSupport:        viper.GetBool("custom-spec"),
 		prepareOffline:           viper.GetBool("prepare-offline"),
 		account:                  viper.GetString("account"),
 		withdrawalAccount:        viper.GetString("withdrawal-account"),

cmd/validator/credentials/set/process.go

@@ -482,17 +482,17 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 	validator, exists := validators[validatorPubkey]
 	if !exists {
 		if c.debug {
-			fmt.Fprintf(os.Stderr, "no validator found with public key %s at path %s\n", validatorPubkey, path)
+			fmt.Fprintf(os.Stderr, "No validator found with public key %s at path %s\n", validatorPubkey, path)
 		}
 		return false, nil
 	}
 
-	if c.verbose {
+	if c.verbose || c.debug {
 		fmt.Fprintf(os.Stderr, "Validator %d found with public key %s at path %s\n", validator.Index, validatorPubkey, path)
 	}
 
 	if validator.WithdrawalCredentials[0] != byte(0) {
-		if c.debug {
+		if c.verbose || c.debug {
 			fmt.Fprintf(os.Stderr, "Validator %s has non-BLS withdrawal credentials %#x\n", validatorPubkey, validator.WithdrawalCredentials)
 		}
 		return false, nil
@@ -523,7 +523,7 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 	withdrawalCredentials := ethutil.SHA256(withdrawalPubkey)
 	withdrawalCredentials[0] = byte(0) // BLS_WITHDRAWAL_PREFIX
 	if !bytes.Equal(withdrawalCredentials, validator.WithdrawalCredentials) {
-		if c.verbose && c.privateKey == "" {
+		if (c.verbose || c.debug) && c.privateKey == "" {
 			fmt.Fprintf(os.Stderr, "Validator %s withdrawal credentials %#x do not match expected credentials, cannot update\n", validatorPubkey, validator.WithdrawalCredentials)
 		}
 		return false, nil
@@ -538,6 +538,10 @@ func (c *command) generateOperationFromSeedAndPath(ctx context.Context,
 		return false, err
 	}
 
+	if c.verbose || c.debug {
+		fmt.Fprintf(os.Stderr, "Withdrawal credentials change operation generated for validator with public key %s at path %s\n", validatorPubkey, path)
+	}
+
 	return true, nil
 }
 
@@ -727,10 +731,11 @@ func (c *command) setup(ctx context.Context) error {
 	// Connect to the consensus node.
 	var err error
 	c.consensusClient, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return err

cmd/validator/depositdata/input.go

@@ -16,8 +16,6 @@ package depositdata
 import (
 	"context"
 	"encoding/hex"
-	"fmt"
-	"os"
 	"strings"
 	"time"
 
@@ -31,7 +29,6 @@ import (
 )
 
 type dataIn struct {
-	debug             bool
 	format            string
 	timeout           time.Duration
 	withdrawalAccount string
@@ -42,16 +39,13 @@ type dataIn struct {
 	forkVersion       *spec.Version
 	domain            *spec.Domain
 	passphrases       []string
-	compounding       bool
 }
 
 func input() (*dataIn, error) {
 	var err error
 	data := &dataIn{
-		debug:       viper.GetBool("debug"),
 		forkVersion: &spec.Version{},
 		domain:      &spec.Domain{},
-		compounding: viper.GetBool("compounding"),
 	}
 
 	if viper.GetString("validatoraccount") == "" {
@@ -103,9 +97,6 @@ func input() (*dataIn, error) {
 	if withdrawalDetailsPresent > 1 {
 		return nil, errors.New("only one of withdrawal account, public key or address is allowed")
 	}
-	if data.compounding && data.withdrawalAddress == "" {
-		return nil, errors.New("a compounding validator must be created with a withdrawal address")
-	}
 
 	if viper.GetString("depositvalue") == "" {
 		return nil, errors.New("deposit value is required")
@@ -115,6 +106,10 @@ func input() (*dataIn, error) {
 		return nil, errors.Wrap(err, "deposit value is invalid")
 	}
 	data.amount = spec.Gwei(amount)
+	// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
+	if data.amount < 1000000000 { // MIN_DEPOSIT_AMOUNT
+		return nil, errors.New("deposit value must be at least 1 Ether")
+	}
 
 	data.forkVersion, err = inputForkVersion(ctx)
 	if err != nil {
@@ -122,12 +117,6 @@ func input() (*dataIn, error) {
 	}
 
 	copy(data.domain[:], e2types.Domain(e2types.DomainDeposit, data.forkVersion[:], e2types.ZeroGenesisValidatorsRoot))
-	if data.debug {
-		fmt.Fprintf(os.Stderr, "Deposit domain is %#x\n", e2types.DomainDeposit)
-		fmt.Fprintf(os.Stderr, "Fork version is %#x\n", *data.forkVersion)
-		fmt.Fprintf(os.Stderr, "Genesis validators root is %#x\n", e2types.ZeroGenesisValidatorsRoot)
-		fmt.Fprintf(os.Stderr, "Signature domain is %#x\n", *data.domain)
-	}
 
 	return data, nil
 }

cmd/validator/depositdata/input_internal_test.go

@@ -190,6 +190,17 @@ func TestInput(t *testing.T) {
 			},
 			err: "deposit value is required",
 		},
+		{
+			name: "DepositValueTooSmall",
+			vars: map[string]interface{}{
+				"timeout":           "10s",
+				"validatoraccount":  "Test/Interop 0",
+				"withdrawalaccount": "Test/Interop 0",
+				"depositvalue":      "1000 Wei",
+				"forkversion":       "0x01020304",
+			},
+			err: "deposit value must be at least 1 Ether",
+		},
 		{
 			name: "DepositValueInvalid",
 			vars: map[string]interface{}{

cmd/validator/depositdata/output.go

@@ -24,7 +24,6 @@ import (
 type dataOut struct {
 	format                string
 	account               string
-	path                  string
 	validatorPubKey       *spec.BLSPubKey
 	withdrawalCredentials []byte
 	amount                spec.Gwei
@@ -171,7 +170,7 @@ func validatorDepositDataOutputJSON(datum *dataOut) (string, error) {
 	if datum.depositDataRoot == nil {
 		return "", errors.New("deposit data root required")
 	}
-	if datum.depositMessageRoot == nil {
+	if datum.depositDataRoot == nil {
 		return "", errors.New("deposit message root required")
 	}
 	if datum.forkVersion == nil {

cmd/validator/depositdata/process.go

@@ -17,8 +17,6 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
-	"sort"
-	"strconv"
 	"strings"
 
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
@@ -42,21 +40,6 @@ func process(data *dataIn) ([]*dataOut, error) {
 		return nil, err
 	}
 
-	// These values are hard-coded, to allow deposit data to be generated without a connection to the beacon node.
-	if data.amount < 1000000000 { // MIN_DEPOSIT_AMOUNT
-		return nil, errors.New("deposit value must be at least 1 Ether")
-	}
-	switch data.compounding {
-	case false:
-		if data.amount > 32000000000 {
-			return nil, errors.New("deposit value exceeds maximum for a non-compounding validator")
-		}
-	case true:
-		if data.amount > 2048000000000 {
-			return nil, errors.New("deposit value exceeds maximum for a compounding validator")
-		}
-	}
-
 	for _, validatorAccount := range data.validatorAccounts {
 		validatorPubKey, err := ethdoutil.BestPublicKey(validatorAccount)
 		if err != nil {
@@ -97,7 +80,7 @@ func process(data *dataIn) ([]*dataOut, error) {
 		copy(depositDataRoot[:], root[:])
 
 		validatorWallet := validatorAccount.(e2wtypes.AccountWalletProvider).Wallet()
-		result := &dataOut{
+		results = append(results, &dataOut{
 			format:                data.format,
 			account:               fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()),
 			validatorPubKey:       &pubKey,
@@ -107,53 +90,8 @@ func process(data *dataIn) ([]*dataOut, error) {
 			forkVersion:           data.forkVersion,
 			depositMessageRoot:    &depositMessageRoot,
 			depositDataRoot:       &depositDataRoot,
-		}
-		if pathProvider, isPathProvider := validatorAccount.(e2wtypes.AccountPathProvider); isPathProvider {
-			result.path = pathProvider.Path()
-		}
-		results = append(results, result)
-	}
-	if len(results) == 0 {
-		return results, nil
-	}
-
-	// Order the results
-	if results[0].path != "" {
-		// Order accounts by their path components.
-		sort.Slice(results, func(i int, j int) bool {
-			iBits := strings.Split(results[i].path, "/")
-			jBits := strings.Split(results[j].path, "/")
-			for index := range iBits {
-				if iBits[index] == "m" && jBits[index] == "m" {
-					continue
-				}
-				if len(jBits) <= index {
-					return false
-				}
-				iBit, err := strconv.ParseUint(iBits[index], 10, 64)
-				if err != nil {
-					return true
-				}
-				jBit, err := strconv.ParseUint(jBits[index], 10, 64)
-				if err != nil {
-					return false
-				}
-				if iBit < jBit {
-					return true
-				}
-				if iBit > jBit {
-					return false
-				}
-			}
-			return len(jBits) > len(iBits)
-		})
-	} else {
-		// Order accounts by their name.
-		sort.Slice(results, func(i int, j int) bool {
-			return strings.Compare(results[i].account, results[j].account) < 0
 		})
 	}
-
 	return results, nil
 }
 
@@ -207,11 +145,7 @@ func createWithdrawalCredentials(data *dataIn) ([]byte, error) {
 		withdrawalCredentials = make([]byte, 32)
 		copy(withdrawalCredentials[12:32], withdrawalAddressBytes)
 		// This is hard-coded, to allow deposit data to be generated without a connection to the beacon node.
-		if data.compounding {
-			withdrawalCredentials[0] = byte(2) // COMPOUNDING_WITHDRAWAL_PREFIX
-		} else {
-			withdrawalCredentials[0] = byte(1) // ETH1_ADDRESS_WITHDRAWAL_PREFIX
-		}
+		withdrawalCredentials[0] = byte(1) // ETH1_ADDRESS_WITHDRAWAL_PREFIX
 	default:
 		return nil, errors.New("withdrawal account, public key or address is required")
 	}

cmd/validator/depositdata/run.go

@@ -37,7 +37,7 @@ func Run(cmd *cobra.Command) (string, error) {
 		case errors.Is(err, context.DeadlineExceeded):
 			return "", errors.New("operation timed out; try increasing with --timeout option")
 		default:
-			return "", err
+			return "", errors.Join(errors.New("failed to process"), err)
 		}
 	}
 

cmd/validator/duties/input.go

@@ -28,8 +28,9 @@ type dataIn struct {
 	verbose bool
 	debug   bool
 	// Ethereum 2 connection.
-	eth2Client    string
-	allowInsecure bool
+	eth2Client        string
+	allowInsecure     bool
+	customSpecSupport bool
 	// Operation.
 	account string
 	pubKey  string
@@ -50,6 +51,7 @@ func input(_ context.Context) (*dataIn, error) {
 	// Ethereum 2 connection.
 	data.eth2Client = viper.GetString("connection")
 	data.allowInsecure = viper.GetBool("allow-insecure-connections")
+	data.customSpecSupport = viper.GetBool("custom-spec")
 
 	// Account.
 	data.account = viper.GetString("account")

cmd/validator/duties/process.go

@@ -32,10 +32,11 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	// Ethereum 2 client.
 	eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       data.eth2Client,
-		Timeout:       data.timeout,
-		AllowInsecure: data.allowInsecure,
-		LogFallback:   !data.quiet,
+		Address:           data.eth2Client,
+		Timeout:           data.timeout,
+		AllowInsecure:     data.allowInsecure,
+		CustomSpecSupport: data.customSpecSupport,
+		LogFallback:       !data.quiet,
 	})
 	if err != nil {
 		return nil, err

cmd/validator/exit/command.go

@@ -50,6 +50,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Information required to generate the operations.
 	chainInfo *beacon.ChainInfo
@@ -73,6 +74,7 @@ func newCommand(_ context.Context) (*command, error) {
 		timeout:                  viper.GetDuration("timeout"),
 		connection:               viper.GetString("connection"),
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		customSpecSupport:        viper.GetBool("custom-spec"),
 		prepareOffline:           viper.GetBool("prepare-offline"),
 		passphrases:              util.GetPassphrases(),
 		mnemonic:                 viper.GetString("mnemonic"),

cmd/validator/exit/process.go

@@ -595,10 +595,11 @@ func (c *command) setup(ctx context.Context) error {
 	// Connect to the consensus node.
 	var err error
 	c.consensusClient, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return err

cmd/validator/expectation/command.go

@@ -35,6 +35,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	validators int64

cmd/validator/expectation/process.go

@@ -125,10 +125,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")

cmd/validator/keycheck/process.go

@@ -101,7 +101,7 @@ func checkMnemonic(ctx context.Context, debug bool, validatorWithdrawalCredentia
 	// Create seed from mnemonic and passphrase.
 	seed := bip39.NewSeed(mnemonic, mnemonicPassphrase)
 	// Check first 1024 indices.
-	for i := range 1024 {
+	for i := 0; i < 1024; i++ {
 		path := fmt.Sprintf("m/12381/3600/%d/0", i)
 		if debug {
 			fmt.Printf("Checking path %s\n", path)

cmd/validator/summary/command.go

@@ -34,6 +34,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Operation.
 	epoch      string
@@ -131,6 +132,7 @@ func newCommand(_ context.Context) (*command, error) {
 
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	c.customSpecSupport = viper.GetBool("custom-spec")
 
 	c.epoch = viper.GetString("epoch")
 	c.validators = viper.GetStringSlice("validators")

cmd/validator/summary/process.go

@@ -245,7 +245,11 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 	for _, attestation := range attestations {
 		attestationData, err := attestation.Data()
 		if err != nil {
-			return errors.Wrap(err, "failed to obtain attestation data")
+			continue
+		}
+		aggregationBits, err := attestation.AggregationBits()
+		if err != nil {
+			continue
 		}
 		if _, exists := dutiesBySlot[attestationData.Slot]; !exists {
 			// We do not have any attestations for this slot.
@@ -256,10 +260,6 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 			continue
 		}
 		for _, duty := range dutiesBySlot[attestationData.Slot][attestationData.Index] {
-			aggregationBits, err := attestation.AggregationBits()
-			if err != nil {
-				return errors.Wrap(err, "failed to obtain aggregation bits")
-			}
 			if aggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
 				// Found it.
 				if _, exists := votes[duty.ValidatorIndex]; exists {
@@ -279,7 +279,7 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 					InclusionDistance: int(inclusionDelay),
 				}
 
-				headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestation)
+				headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestationData)
 				if err != nil {
 					return errors.Wrap(err, "failed to calculate if attestation had correct head vote")
 				}
@@ -303,7 +303,7 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 					c.summary.UntimelySourceValidators = append(c.summary.UntimelySourceValidators, fault)
 				}
 
-				targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestation)
+				targetCorrect, err := util.AttestationTargetCorrect(ctx, headersCache, c.chainTime, attestationData)
 				if err != nil {
 					return errors.Wrap(err, "failed to calculate if attestation had correct target vote")
 				}
@@ -407,10 +407,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")

cmd/validator/withdrawal/command.go

@@ -39,6 +39,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Processing.
 	consensusClient          consensusclient.Service
@@ -60,6 +61,7 @@ func newCommand(_ context.Context) (*command, error) {
 		timeout:                  viper.GetDuration("timeout"),
 		connection:               viper.GetString("connection"),
 		allowInsecureConnections: viper.GetBool("allow-insecure-connections"),
+		customSpecSupport:        viper.GetBool("custom-spec"),
 		validator:                viper.GetString("validator"),
 		res:                      &res{},
 	}

cmd/validator/withdrawal/process.go

@@ -129,10 +129,11 @@ func (c *command) setup(ctx context.Context) error {
 	// Connect to the consensus node.
 	var err error
 	c.consensusClient, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return err

cmd/validator/yield/command.go

@@ -33,6 +33,7 @@ type command struct {
 	timeout                  time.Duration
 	connection               string
 	allowInsecureConnections bool
+	customSpecSupport        bool
 
 	// Input.
 	validators string
@@ -76,6 +77,7 @@ func newCommand(_ context.Context) (*command, error) {
 
 	c.connection = viper.GetString("connection")
 	c.allowInsecureConnections = viper.GetBool("allow-insecure-connections")
+	c.customSpecSupport = viper.GetBool("custom-spec")
 
 	c.validators = viper.GetString("validators")
 

cmd/validator/yield/process.go

@@ -114,10 +114,11 @@ func (c *command) setup(ctx context.Context) error {
 
 	// Connect to the client.
 	c.eth2Client, err = util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-		Address:       c.connection,
-		Timeout:       c.timeout,
-		AllowInsecure: c.allowInsecureConnections,
-		LogFallback:   !c.quiet,
+		Address:           c.connection,
+		Timeout:           c.timeout,
+		AllowInsecure:     c.allowInsecureConnections,
+		CustomSpecSupport: c.customSpecSupport,
+		LogFallback:       !c.quiet,
 	})
 	if err != nil {
 		return errors.Wrap(err, "failed to connect to beacon node")

cmd/validatordepositdata.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 - 2025 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
@@ -57,7 +57,6 @@ func init() {
 	validatorDepositDataCmd.Flags().Bool("raw", false, "Print raw deposit data transaction data")
 	validatorDepositDataCmd.Flags().String("forkversion", "", "Use a hard-coded fork version (default is to use mainnet value)")
 	validatorDepositDataCmd.Flags().Bool("launchpad", false, "Print launchpad-compatible JSON")
-	validatorDepositDataCmd.Flags().Bool("compounding", false, "Create a compounding (max 2048 ETH) validator")
 }
 
 func validatorDepositdataBindings(cmd *cobra.Command) {
@@ -85,7 +84,4 @@ func validatorDepositdataBindings(cmd *cobra.Command) {
 	if err := viper.BindPFlag("launchpad", cmd.Flags().Lookup("launchpad")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("compounding", cmd.Flags().Lookup("compounding")); err != nil {
-		panic(err)
-	}
 }

cmd/validatorinfo.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 - 2025 Weald Technology Trading
+// Copyright © 2020 - 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
@@ -47,10 +47,11 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 		ctx := context.Background()
 
 		eth2Client, err := util.ConnectToBeaconNode(ctx, &util.ConnectOpts{
-			Address:       viper.GetString("connection"),
-			Timeout:       viper.GetDuration("timeout"),
-			AllowInsecure: viper.GetBool("allow-insecure-connections"),
-			LogFallback:   !viper.GetBool("quiet"),
+			Address:           viper.GetString("connection"),
+			Timeout:           viper.GetDuration("timeout"),
+			AllowInsecure:     viper.GetBool("allow-insecure-connections"),
+			CustomSpecSupport: viper.GetBool("custom-spec"),
+			LogFallback:       !viper.GetBool("quiet"),
 		})
 		errCheck(err, "Failed to connect to Ethereum 2 beacon node")
 
@@ -67,17 +68,9 @@ In quiet mode this will return 0 if the validator information can be obtained, o
 			os.Exit(_exitFailure)
 		}
 
-		validator, err := util.ParseValidator(ctx, eth2Client.(eth2client.ValidatorsProvider), viper.GetString("validator"), viper.GetString("blockid"))
+		validator, err := util.ParseValidator(ctx, eth2Client.(eth2client.ValidatorsProvider), viper.GetString("validator"), "head")
 		errCheck(err, "Failed to obtain validator")
 
-		if viper.GetBool("json") {
-			data, err := json.Marshal(validator)
-			errCheck(err, "failed to marshal JSON")
-			fmt.Fprintf(os.Stdout, "%s", string(data))
-
-			return
-		}
-
 		if viper.GetBool("verbose") {
 			network, err := util.Network(ctx, eth2Client)
 			errCheck(err, "Failed to obtain network")
@@ -193,8 +186,7 @@ func graphData(network string, validatorPubKey []byte) (uint64, spec.Gwei, error
 
 func init() {
 	validatorCmd.AddCommand(validatorInfoCmd)
-	validatorInfoCmd.Flags().String("validator", "", "ID of the validator")
-	validatorInfoCmd.Flags().String("blockid", "head", "the block at which to fetch the information")
+	validatorInfoCmd.Flags().String("validator", "", "Public key for which to obtain status")
 	validatorFlags(validatorInfoCmd)
 }
 
@@ -202,7 +194,4 @@ func validatorInfoBindings(cmd *cobra.Command) {
 	if err := viper.BindPFlag("validator", cmd.Flags().Lookup("validator")); err != nil {
 		panic(err)
 	}
-	if err := viper.BindPFlag("blockid", cmd.Flags().Lookup("blockid")); err != nil {
-		panic(err)
-	}
 }

cmd/version.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 - 2025 Weald Technology Trading.
+// Copyright © 2019 - 2024 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.37.0)"
+var ReleaseVersion = "local build (latest release 1.35.3)"
 
 // versionCmd represents the version command.
 var versionCmd = &cobra.Command{

cmd/wallet/create/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 - 2024 Weald Technology Trading
+// Copyright © 2019, 2020 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -24,7 +24,6 @@ import (
 	distributed "github.com/wealdtech/go-eth2-wallet-distributed"
 	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
 	hd "github.com/wealdtech/go-eth2-wallet-hd/v2"
-	keystore "github.com/wealdtech/go-eth2-wallet-keystore"
 	nd "github.com/wealdtech/go-eth2-wallet-nd/v2"
 	"golang.org/x/text/unicode/norm"
 )
@@ -41,8 +40,6 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		return processHD(ctx, data)
 	case "distributed":
 		return processDistributed(ctx, data)
-	case "keystore":
-		return processKeystore(ctx, data)
 	default:
 		return nil, errors.New("wallet type not supported")
 	}
@@ -135,16 +132,3 @@ func processDistributed(ctx context.Context, data *dataIn) (*dataOut, error) {
 
 	return results, nil
 }
-
-func processKeystore(ctx context.Context, data *dataIn) (*dataOut, error) {
-	if data == nil {
-		return nil, errors.New("no data")
-	}
-
-	results := &dataOut{}
-
-	if _, err := keystore.CreateWallet(ctx, data.walletName, data.store, keystorev4.New()); err != nil {
-		return nil, err
-	}
-	return results, nil
-}

docs/usage.md

@@ -47,7 +47,7 @@ $ ethdo wallet batch --wallet="Validators" ---passphrase="my account secret" --b
 `ethdo wallet create` creates a new wallet with the given parameters.  Options for creating a wallet include:
 
 - `wallet`: the name of the wallet to create
-- `type`: the type of wallet to create.  This can be either "nd" for a non-deterministic wallet, where private keys are generated randomly, "hd" for a hierarchical deterministic wallet, where private keys are generated from a seed and path as per [EIP-2333](https://eips.ethereum.org/EIPS/eip-2333), "keystore" for a wallet where data is written in the [EIP=2335](https://eips.ethereum.org/EIPS/eip-2335) format, or "distributed" for a wallet used by [Dirk](https://github.com/wealdtech/dirk) (defaults to "nd")
+- `type`: the type of wallet to create.  This can be either "nd" for a non-deterministic wallet, where private keys are generated randomly, or "hd" for a hierarchical deterministic wallet, where private keys are generated from a seed and path as per [EIP-2333](https://eips.ethereum.org/EIPS/eip-2333) (defaults to "nd")
 - `wallet-passphrase`: the passphrase for of the wallet.  This is required for hierarchical deterministic wallets, to protect the seed
 - `mnemonic`: for hierarchical deterministic wallets only, use a pre-defined 24-word [BIP-39 seed phrase](https://en.bitcoin.it/wiki/Seed_phrase) to create the wallet, along with an additional "seed extension" phrase if required.  **Warning** The same mnemonic can be used to create multiple wallets, in which case they will generate the same keys.
 
@@ -183,7 +183,6 @@ $ ethdo account create --account="Personal wallet/Operations" --wallet-passphras
 - `show-private-key`: show the private of the derived account.  **Warning** displaying private keys, especially those derived from seeds held on hardware wallets, can expose your Ether to risk of being stolen.  Only use this option if you are sure you understand the risks involved
 - `show-withdrawal-credentials`: show the withdrawal credentials of the derived account
 - `generate-keystore`: generate a keystore for the account
-- `json`: output the generated keystore to stdout
 
 ```sh
 $ ethdo account derive --mnemonic="abandon ... abandon art" --path="m/12381/3600/0/0"
@@ -659,7 +658,6 @@ $ ethdo validator credentials set --validator=Validators/1 --withdrawal-address=
 - `withdrawaladdress` specify the Ethereum execution address to be used for the withdrawal credentials (if withdrawalpubkey is not supplied)
 - `withdrawalpubkey` specify the public key to be used for the withdrawal credentials (if withdrawalaccount is not supplied)
 - `validatoraccount` specify the account to be used for the validator
-- `compounding` specify if this validator should be compounding, retaining Ether above 32 ETH by default to compound rewards
 - `depositvalue` specify the amount of the deposit
 - `forkversion` specify the fork version for the deposit signature; this defaults to mainnet.  Note that supplying an incorrect value could result in the loss of your deposit, so only supply this value if you are sure you know what you are doing.  You can find the value for other chains by fetching the value supplied in "Genesis fork version" of the `ethdo chain info` command
 - `raw` generate raw hex output that can be supplied as the data to an Ethereum 1 deposit transaction
@@ -683,7 +681,6 @@ $ ethdo validator exit --private-key=0x01e748d098d3bcb477d636f19d510399ae18205fa
 `ethdo validator info` provides information for a given validator.  Options include:
 
 - `validator`: the validator for which to obtain information, as a [validator specifier](https://github.com/wealdtech/ethdo#validator-specifier)
-- `blockid`: the ID (slot, root, 'head') of the block at which to obtain information
 
 ```sh
 $ ethdo validator info --validator=Validators/1

go.mod

@@ -1,106 +1,106 @@
 module github.com/wealdtech/ethdo
 
-go 1.22.7
+go 1.21
 
-toolchain go1.23.2
+toolchain go1.21.6
 
 require (
-	github.com/attestantio/go-eth2-client v0.24.0
-	github.com/ferranbt/fastssz v0.1.4
+	github.com/attestantio/go-eth2-client v0.21.4-0.20240514220516-2646ce28c3e4
+	github.com/ferranbt/fastssz v0.1.3
 	github.com/gofrs/uuid v4.4.0+incompatible
 	github.com/google/uuid v1.6.0
 	github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b
-	github.com/herumi/bls-eth-go-binary v1.36.1
+	github.com/herumi/bls-eth-go-binary v1.33.0
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354
 	github.com/pkg/errors v0.9.1
-	github.com/prysmaticlabs/go-bitfield v0.0.0-20240618144021-706c95b2dd15
+	github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e
 	github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388
-	github.com/rs/zerolog v1.33.0
-	github.com/shopspring/decimal v1.4.0
-	github.com/spf13/cobra v1.8.1
+	github.com/rs/zerolog v1.32.0
+	github.com/shopspring/decimal v1.3.1
+	github.com/spf13/cobra v1.8.0
 	github.com/spf13/pflag v1.0.5
-	github.com/spf13/viper v1.19.0
-	github.com/stretchr/testify v1.10.0
+	github.com/spf13/viper v1.18.2
+	github.com/stretchr/testify v1.8.4
 	github.com/tyler-smith/go-bip39 v1.1.0
 	github.com/wealdtech/go-bytesutil v1.2.1
 	github.com/wealdtech/go-ecodec v1.1.4
 	github.com/wealdtech/go-eth2-types/v2 v2.8.2
 	github.com/wealdtech/go-eth2-util v1.8.2
-	github.com/wealdtech/go-eth2-wallet v1.17.0
-	github.com/wealdtech/go-eth2-wallet-dirk v1.5.1
+	github.com/wealdtech/go-eth2-wallet v1.16.0
+	github.com/wealdtech/go-eth2-wallet-dirk v1.4.7
 	github.com/wealdtech/go-eth2-wallet-distributed v1.2.1
 	github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.4.1
 	github.com/wealdtech/go-eth2-wallet-hd/v2 v2.7.0
-	github.com/wealdtech/go-eth2-wallet-keystore v1.0.0
 	github.com/wealdtech/go-eth2-wallet-nd/v2 v2.5.0
 	github.com/wealdtech/go-eth2-wallet-store-filesystem v1.18.1
 	github.com/wealdtech/go-eth2-wallet-store-s3 v1.12.0
 	github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.2
-	github.com/wealdtech/go-eth2-wallet-types/v2 v2.12.0
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.11.0
 	github.com/wealdtech/go-string2eth v1.2.1
-	golang.org/x/text v0.21.0
+	golang.org/x/text v0.15.0
 )
 
 require (
-	github.com/aws/aws-sdk-go v1.55.5 // indirect
+	github.com/aws/aws-sdk-go v1.51.1 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/cespare/xxhash/v2 v2.2.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/dgraph-io/ristretto v0.2.0 // indirect
+	github.com/dgraph-io/ristretto v0.1.1 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/emicklei/dot v1.6.4 // indirect
-	github.com/fsnotify/fsnotify v1.8.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
+	github.com/fatih/color v1.16.0 // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/go-logr/logr v1.4.1 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/goccy/go-yaml v1.15.12 // indirect
+	github.com/goccy/go-yaml v1.9.2 // indirect
+	github.com/golang/glog v1.2.0 // indirect
+	github.com/golang/protobuf v1.5.4 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/holiman/uint256 v1.3.2 // indirect
+	github.com/holiman/uint256 v1.2.4 // indirect
 	github.com/huandu/go-clone v1.7.2 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/jackc/puddle/v2 v2.2.1 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.9 // indirect
-	github.com/magiconair/properties v1.8.9 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/magiconair/properties v1.8.7 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/minio/highwayhash v1.0.3 // indirect
+	github.com/minio/highwayhash v1.0.2 // indirect
 	github.com/minio/sha256-simd v1.0.1 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
-	github.com/pk910/dynamic-ssz v0.0.5 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.1 // indirect
+	github.com/pk910/dynamic-ssz v0.0.4 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/prometheus/client_golang v1.20.5 // indirect
-	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.61.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/prometheus/client_golang v1.19.0 // indirect
+	github.com/prometheus/client_model v0.6.0 // indirect
+	github.com/prometheus/common v0.50.0 // indirect
+	github.com/prometheus/procfs v0.13.0 // indirect
 	github.com/protolambda/zssz v0.1.5 // indirect
 	github.com/r3labs/sse/v2 v2.10.0 // indirect
-	github.com/sagikazarmark/locafero v0.6.0 // indirect
+	github.com/sagikazarmark/locafero v0.4.0 // indirect
 	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
 	github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 // indirect
 	github.com/sourcegraph/conc v0.3.0 // indirect
 	github.com/spf13/afero v1.11.0 // indirect
-	github.com/spf13/cast v1.7.1 // indirect
+	github.com/spf13/cast v1.6.0 // indirect
 	github.com/subosito/gotenv v1.6.0 // indirect
 	github.com/wealdtech/eth2-signer-api v1.7.2 // indirect
 	github.com/wealdtech/go-indexer v1.1.0 // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.58.0 // indirect
-	go.opentelemetry.io/otel v1.33.0 // indirect
-	go.opentelemetry.io/otel/metric v1.33.0 // indirect
-	go.opentelemetry.io/otel/trace v1.33.0 // indirect
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 // indirect
+	go.opentelemetry.io/otel v1.24.0 // indirect
+	go.opentelemetry.io/otel/metric v1.24.0 // indirect
+	go.opentelemetry.io/otel/trace v1.24.0 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.32.0 // indirect
-	golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67 // indirect
-	golang.org/x/net v0.33.0 // indirect
-	golang.org/x/sync v0.10.0 // indirect
-	golang.org/x/sys v0.29.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20241219192143-6b3ec007d9bb // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20241219192143-6b3ec007d9bb // indirect
-	google.golang.org/grpc v1.69.2 // indirect
-	google.golang.org/protobuf v1.36.0 // indirect
+	golang.org/x/crypto v0.23.0 // indirect
+	golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f // indirect
+	golang.org/x/net v0.23.0 // indirect
+	golang.org/x/sync v0.6.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20240314234333-6e1732d8331c // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20240314234333-6e1732d8331c // indirect
+	google.golang.org/grpc v1.62.1 // indirect
+	google.golang.org/protobuf v1.33.0 // indirect
 	gopkg.in/Knetic/govaluate.v3 v3.0.0 // indirect
 	gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect
 	gopkg.in/ini.v1 v1.67.0 // indirect

go.sum

@@ -1,41 +1,56 @@
-github.com/attestantio/go-eth2-client v0.24.0 h1:lGVbcnhlBwRglt1Zs56JOCgXVyLWKFZOmZN8jKhE7Ws=
-github.com/attestantio/go-eth2-client v0.24.0/go.mod h1:/KTLN3WuH1xrJL7ZZrpBoWM1xCCihnFbzequD5L+83o=
-github.com/aws/aws-sdk-go v1.55.5 h1:KKUZBfBoyqy5d3swXyiC7Q76ic40rYcbqH7qjh59kzU=
-github.com/aws/aws-sdk-go v1.55.5/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+github.com/attestantio/go-eth2-client v0.21.4-0.20240514220516-2646ce28c3e4 h1:tvLDLWLMMdo/UzMPCX+a9wh+zdAZzS2NEOqAaq9m5BY=
+github.com/attestantio/go-eth2-client v0.21.4-0.20240514220516-2646ce28c3e4/go.mod h1:RssbJ8txdfZ+O7cIjOKCvizcTWHzgPuJNByrwtQ6tBQ=
+github.com/attestantio/go-eth2-client v0.21.4 h1:1QW4f3NXCcbUsxmRBElotTjSIhRwLsmdowUvxJnyaJU=
+github.com/attestantio/go-eth2-client v0.21.4/go.mod h1:d7ZPNrMX8jLfIgML5u7QZxFo2AukLM+5m08iMaLdqb8=
+github.com/aws/aws-sdk-go v1.51.1 h1:AFvTihcDPanvptoKS09a4yYmNtPm3+pXlk6uYHmZiFk=
+github.com/aws/aws-sdk-go v1.51.1/go.mod h1:LF8svs817+Nz+DmiMQKTO3ubZ/6IaTpq3TjupRn3Eqk=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
+github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
+github.com/cpuguy83/go-md2man/v2 v2.0.3/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
 github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgraph-io/ristretto v0.2.0 h1:XAfl+7cmoUDWW/2Lx8TGZQjjxIQ2Ley9DSf52dru4WE=
-github.com/dgraph-io/ristretto v0.2.0/go.mod h1:8uBHCU/PBV4Ag0CJrP47b9Ofby5dqWNh4FicAdoqFNU=
-github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13 h1:fAjc9m62+UWV/WAFKLNi6ZS0675eEUC9y3AlwSbQu1Y=
-github.com/dgryski/go-farm v0.0.0-20200201041132-a6ae2369ad13/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/dgraph-io/ristretto v0.1.1 h1:6CWw5tJNgpegArSHpNHJKldNeq03FQCwYvfMVWajOK8=
+github.com/dgraph-io/ristretto v0.1.1/go.mod h1:S1GPSBCYCIhmVNfcth17y2zZtQT6wzkzgwUve0VDWWA=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
+github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
+github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/emicklei/dot v1.6.4 h1:cG9ycT67d9Yw22G+mAb4XiuUz6E6H1S0zePp/5Cwe/c=
-github.com/emicklei/dot v1.6.4/go.mod h1:DeV7GvQtIw4h2u73RKBkkFdvVAz0D9fzeJrgPW6gy/s=
-github.com/ferranbt/fastssz v0.1.4 h1:OCDB+dYDEQDvAgtAGnTSidK1Pe2tW3nFV40XyMkTeDY=
-github.com/ferranbt/fastssz v0.1.4/go.mod h1:Ea3+oeoRGGLGm5shYAeDgu6PGUlcvQhE2fILyD9+tGg=
+github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
+github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM=
+github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE=
+github.com/ferranbt/fastssz v0.1.3 h1:ZI+z3JH05h4kgmFXdHuR1aWYsgrg7o+Fw7/NCzM16Mo=
+github.com/ferranbt/fastssz v0.1.3/go.mod h1:0Y9TEd/9XuFlh7mskMPfXiI2Dkw4Ddg9EyXt1W7MRvE=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
-github.com/fsnotify/fsnotify v1.8.0 h1:dAwr6QBTBZIkG8roQaJjGof0pp0EeF+tNV7YBP3F/8M=
-github.com/fsnotify/fsnotify v1.8.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
-github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.1 h1:pKouT5E8xu9zeFC39JXRDukb6JFQPXM5p5I91188VAQ=
+github.com/go-logr/logr v1.4.1/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/goccy/go-yaml v1.15.12 h1:KLUSwfrUcTU6F8sAkf23OIPYC6aFVMNFSu4btROEm6w=
-github.com/goccy/go-yaml v1.15.12/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
+github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q=
+github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8=
+github.com/go-playground/universal-translator v0.17.0 h1:icxd5fm+REJzpZx7ZfpaD876Lmtgy7VtROAbHHXk8no=
+github.com/go-playground/universal-translator v0.17.0/go.mod h1:UkSxE5sNxxRwHyU+Scu5vgOQjsIJAF8j9muTVoKLVtA=
+github.com/go-playground/validator/v10 v10.4.1 h1:pH2c5ADXtd66mxoE0Zm9SUhxE20r7aM3F26W0hOn+GE=
+github.com/go-playground/validator/v10 v10.4.1/go.mod h1:nlOn6nFhuKACm19sB/8EGNn9GlaMV7XkbRSipzJ0Ii4=
+github.com/goccy/go-yaml v1.9.2 h1:2Njwzw+0+pjU2gb805ZC1B/uBuAs2VcZ3K+ZgHwDs7w=
+github.com/goccy/go-yaml v1.9.2/go.mod h1:U/jl18uSupI5rdI2jmuCswEA2htH9eXfferR3KfscvA=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
 github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/glog v1.2.0 h1:uCdmnmatrKCgMBlM4rMuJZWOkPDqdbZPnrMXDY4gI68=
+github.com/golang/glog v1.2.0/go.mod h1:6AhwSGph0fcJtXVM/PEHPqZlFeoLxhs7/t5UDAwmO+w=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
 github.com/golang/snappy v0.0.4 h1:yAGX7huGHXlcLOEtBnF4w7FQwA26wojNCwOYAEhLjQM=
@@ -48,10 +63,10 @@ github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b h1:wDUNC2eKiL35DbLvsD
 github.com/hako/durafmt v0.0.0-20210608085754-5c1018a4e16b/go.mod h1:VzxiSdG6j1pi7rwGm/xYI5RbtpBgM8sARDXlvEvxlu0=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
-github.com/herumi/bls-eth-go-binary v1.36.1 h1:SfLjxbO1fWkKtKS7J3Ezd1/5QXrcaTZgWynxdSe10hQ=
-github.com/herumi/bls-eth-go-binary v1.36.1/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
-github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA=
-github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
+github.com/herumi/bls-eth-go-binary v1.33.0 h1:fHoysK+WbL/FQIJoVGECGd2lBLa2De7YjAGZljI2vzQ=
+github.com/herumi/bls-eth-go-binary v1.33.0/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
+github.com/holiman/uint256 v1.2.4 h1:jUc4Nk8fm9jZabQuqr2JzednajVmBpC+oiTiXZJEApU=
+github.com/holiman/uint256 v1.2.4/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
 github.com/huandu/go-assert v1.1.5 h1:fjemmA7sSfYHJD7CUqs9qTwwfdNAx7/j2/ZlHXzNB3c=
 github.com/huandu/go-assert v1.1.5/go.mod h1:yOLvuqZwmcHIC5rIzrBhT7D3Q9c3GFnd0JrPVhn/06U=
 github.com/huandu/go-clone v1.7.2 h1:3+Aq0Ed8XK+zKkLjE2dfHg0XrpIfcohBE1K+c8Usxoo=
@@ -60,104 +75,109 @@ github.com/huandu/go-clone/generic v1.6.0 h1:Wgmt/fUZ28r16F2Y3APotFD59sHk1p78K0X
 github.com/huandu/go-clone/generic v1.6.0/go.mod h1:xgd9ZebcMsBWWcBx5mVMCoqMX24gLWr5lQicr+nVXNs=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
-github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
+github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
 github.com/jmespath/go-jmespath v0.4.0 h1:BEgLn5cpjn8UN1mAw4NjwDrS35OdebyEtFe+9YPoQUg=
 github.com/jmespath/go-jmespath v0.4.0/go.mod h1:T8mJZnbsbmF+m6zOOFylbeCJqk5+pHWvzYPziyZiYoo=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGwWFoC7ycTf1rcQZHOlsJ6N8=
 github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
-github.com/klauspost/cpuid/v2 v2.2.9 h1:66ze0taIn2H33fBvCkXuv9BmCwDfafmiIVpKV9kKGuY=
-github.com/klauspost/cpuid/v2 v2.2.9/go.mod h1:rqkxqrZ1EhYM9G+hXH7YdowN5R5RGN6NK4QwQ3WMXF8=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/magiconair/properties v1.8.9 h1:nWcCbLq1N2v/cpNsy5WvQ37Fb+YElfq20WJ/a8RkpQM=
-github.com/magiconair/properties v1.8.9/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y=
+github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII=
+github.com/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
+github.com/magiconair/properties v1.8.7/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/minio/highwayhash v1.0.3 h1:kbnuUMoHYyVl7szWjSxJnxw11k2U709jqFPPmIUyD6Q=
-github.com/minio/highwayhash v1.0.3/go.mod h1:GGYsuwP/fPD6Y9hMiXuapVvlIUEhFhMTh0rxU3ik1LQ=
+github.com/minio/highwayhash v1.0.2 h1:Aak5U0nElisjDCfPSG79Tgzkn2gl66NxOMspRrKnA/g=
+github.com/minio/highwayhash v1.0.2/go.mod h1:BQskDq+xkJ12lmlUUi7U0M5Swg3EWR+dLTk+kldvVxY=
 github.com/minio/sha256-simd v1.0.1 h1:6kaan5IFmwTNynnKKpDHe6FWHohJOHhCPchzK49dzMM=
 github.com/minio/sha256-simd v1.0.1/go.mod h1:Pz6AKMiUdngCLpeTL/RJY1M9rUuPMYujV5xJjtbRSN8=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
-github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354 h1:4kuARK6Y6FxaNu/BnU2OAaLF86eTVhP2hjTB6iMvItA=
 github.com/nbutton23/zxcvbn-go v0.0.0-20210217022336-fa2cb2858354/go.mod h1:KSVJerMDfblTH7p5MZaTt+8zaT2iEk3AkVb9PQdZuE8=
-github.com/pelletier/go-toml/v2 v2.2.3 h1:YmeHyLY8mFWbdkNWwpr+qIL2bEqT0o95WSdkNHvL12M=
-github.com/pelletier/go-toml/v2 v2.2.3/go.mod h1:MfCQTFTvCcUyyvvwm1+G6H/jORL20Xlb6rzQu9GuUkc=
-github.com/pk910/dynamic-ssz v0.0.5 h1:VP9heGYUwzlpyhk28P2nCAzhvGsePJOOOO5vQMDh2qQ=
-github.com/pk910/dynamic-ssz v0.0.5/go.mod h1:b6CrLaB2X7pYA+OSEEbkgXDEcRnjLOZIxZTsMuO/Y9c=
+github.com/pelletier/go-toml/v2 v2.1.1 h1:LWAJwfNvjQZCFIDKWYQaM62NcYeYViCmWIwmOStowAI=
+github.com/pelletier/go-toml/v2 v2.1.1/go.mod h1:tJU2Z3ZkXwnxa4DPO899bsyIoywizdUvyaeZurnPPDc=
+github.com/pk910/dynamic-ssz v0.0.3 h1:fCWzFowq9P6SYCc7NtJMkZcIHk+r5hSVD+32zVi6Aio=
+github.com/pk910/dynamic-ssz v0.0.3/go.mod h1:b6CrLaB2X7pYA+OSEEbkgXDEcRnjLOZIxZTsMuO/Y9c=
+github.com/pk910/dynamic-ssz v0.0.4 h1:DT29+1055tCEPCaR4V/ez+MOKW7BzBsmjyFvBRqx0ME=
+github.com/pk910/dynamic-ssz v0.0.4/go.mod h1:b6CrLaB2X7pYA+OSEEbkgXDEcRnjLOZIxZTsMuO/Y9c=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
-github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
-github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
-github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
-github.com/prometheus/common v0.61.0 h1:3gv/GThfX0cV2lpO7gkTUwZru38mxevy90Bj8YFSRQQ=
-github.com/prometheus/common v0.61.0/go.mod h1:zr29OCN/2BsJRaFwG8QOBr41D6kkchKbpeNH7pAjb/s=
-github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
-github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
+github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU=
+github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k=
+github.com/prometheus/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos=
+github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8=
+github.com/prometheus/common v0.50.0 h1:YSZE6aa9+luNa2da6/Tik0q0A5AbR+U003TItK57CPQ=
+github.com/prometheus/common v0.50.0/go.mod h1:wHFBCEVWVmHMUpg7pYcOm2QUR/ocQdYSJVQJKnHc3xQ=
+github.com/prometheus/procfs v0.13.0 h1:GqzLlQyfsPbaEHaQkO7tbDlriv/4o5Hudv6OXHGKX7o=
+github.com/prometheus/procfs v0.13.0/go.mod h1:cd4PFCR54QLnGKPaKGA6l+cfuNXtht43ZKY6tow0Y1g=
 github.com/protolambda/zssz v0.1.5 h1:7fjJjissZIIaa2QcvmhS/pZISMX21zVITt49sW1ouek=
 github.com/protolambda/zssz v0.1.5/go.mod h1:a4iwOX5FE7/JkKA+J/PH0Mjo9oXftN6P8NZyL28gpag=
-github.com/prysmaticlabs/go-bitfield v0.0.0-20240618144021-706c95b2dd15 h1:lC8kiphgdOBTcbTvo8MwkvpKjO0SlAgjv4xIK5FGJ94=
-github.com/prysmaticlabs/go-bitfield v0.0.0-20240618144021-706c95b2dd15/go.mod h1:8svFBIKKu31YriBG/pNizo9N0Jr9i5PQ+dFkxWg3x5k=
+github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e h1:ATgOe+abbzfx9kCPeXIW4fiWyDdxlwHw07j8UGhdTd4=
+github.com/prysmaticlabs/go-bitfield v0.0.0-20240328144219-a1caa50c3a1e/go.mod h1:wmuf/mdK4VMD+jA9ThwcUKjg3a2XWM9cVfFYjDyY4j4=
 github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388 h1:4bD+ujqGfY4zoDUF3q9MhdmpPXzdp03DYUIlXeQ72kk=
 github.com/prysmaticlabs/go-ssz v0.0.0-20210121151755-f6208871c388/go.mod h1:VecIJZrewdAuhVckySLFt2wAAHRME934bSDurP8ftkc=
-github.com/prysmaticlabs/gohashtree v0.0.4-beta h1:H/EbCuXPeTV3lpKeXGPpEV9gsUpkqOOVnWapUyeWro4=
-github.com/prysmaticlabs/gohashtree v0.0.4-beta/go.mod h1:BFdtALS+Ffhg3lGQIHv9HDWuHS8cTvHZzrHWxwOtGOs=
 github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0=
 github.com/r3labs/sse/v2 v2.10.0/go.mod h1:Igau6Whc+F17QUgML1fYe1VPZzTV6EMCnYktEmkNJ7I=
-github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
+github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
+github.com/rs/zerolog v1.32.0 h1:keLypqrlIjaFsbmJOBdB/qvyF8KEtCWHwobLp5l/mQ0=
+github.com/rs/zerolog v1.32.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sagikazarmark/locafero v0.6.0 h1:ON7AQg37yzcRPU69mt7gwhFEBwxI6P9T4Qu3N51bwOk=
-github.com/sagikazarmark/locafero v0.6.0/go.mod h1:77OmuIc6VTraTXKXIs/uvUxKGUXjE1GbemJYHqdNjX0=
+github.com/sagikazarmark/locafero v0.4.0 h1:HApY1R9zGo4DBgr7dqsTH/JJxLTTsOt7u6keLGt6kNQ=
+github.com/sagikazarmark/locafero v0.4.0/go.mod h1:Pe1W6UlPYUk/+wc/6KFhbORCfqzgYEpgQ3O5fPuL3H4=
 github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
 github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
-github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
-github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
+github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8=
+github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o=
 github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
 github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
 github.com/spf13/afero v1.11.0 h1:WJQKhtpdm3v2IzqG8VMqrr6Rf3UYpEF239Jy9wNepM8=
 github.com/spf13/afero v1.11.0/go.mod h1:GH9Y3pIexgf1MTIWtNGyogA5MwRIDXGUr+hbWNoBjkY=
-github.com/spf13/cast v1.7.1 h1:cuNEagBQEHWN1FnbGEjCXL2szYEXqfJPbP2HNUaca9Y=
-github.com/spf13/cast v1.7.1/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
-github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM=
-github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y=
+github.com/spf13/cast v1.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
+github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+github.com/spf13/cobra v1.8.0 h1:7aJaZx1B85qltLMc546zn58BxxfZdR/W22ej9CFoEf0=
+github.com/spf13/cobra v1.8.0/go.mod h1:WXLWApfZ71AjXPya3WOlMsY9yMs7YeiHhFVlvLyhcho=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.19.0 h1:RWq5SEjt8o25SROyN3z2OrDB9l7RPd3lwTWU8EcEdcI=
-github.com/spf13/viper v1.19.0/go.mod h1:GQUN9bilAbhU/jgc1bKs99f/suXKeUMct8Adx5+Ntkg=
+github.com/spf13/viper v1.18.2 h1:LUXCnvUvSM6FXAsj6nnfc8Q2tp1dIgUfY9Kc8GsSOiQ=
+github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMVB+yk=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
 github.com/stretchr/testify v1.1.4/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
 github.com/tyler-smith/go-bip39 v1.1.0 h1:5eUemwrMargf3BSLRRCalXT93Ns6pQJIjYQN2nyfOP8=
 github.com/tyler-smith/go-bip39 v1.1.0/go.mod h1:gUYDtqQw1JS3ZJ8UWVcGTGqqr6YIN3CWg+kkNaLt55U=
+github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10 h1:CQh33pStIp/E30b7TxDlXfM0145bn2e8boI30IxAhTg=
+github.com/umbracle/gohashtree v0.0.2-alpha.0.20230207094856-5b775a815c10/go.mod h1:x/Pa0FF5Te9kdrlZKJK82YmAkvL8+f989USgz6Jiw7M=
 github.com/wealdtech/eth2-signer-api v1.7.2 h1:9wmwWEstUwukyZmh0OhQfSHm9KrqFHF7oLSlrk0l2Uk=
 github.com/wealdtech/eth2-signer-api v1.7.2/go.mod h1:HOdnGSKi9z6OkV/UgpKpbsF3HcOAJkIjjjSWTXisnWI=
 github.com/wealdtech/go-bytesutil v1.2.1 h1:TjuRzcG5KaPwaR5JB7L/OgJqMQWvlrblA1n0GfcXFSY=
@@ -168,10 +188,10 @@ github.com/wealdtech/go-eth2-types/v2 v2.8.2 h1:b5aXlNBLKgjAg/Fft9VvGlqAUCQMP5Lz
 github.com/wealdtech/go-eth2-types/v2 v2.8.2/go.mod h1:IAz9Lz1NVTaHabQa+4zjk2QDKMv8LVYo0n46M9o/TXw=
 github.com/wealdtech/go-eth2-util v1.8.2 h1:gq+JMrnadifyKadUr75wmfP7+usiqMu9t3VVoob5Dvo=
 github.com/wealdtech/go-eth2-util v1.8.2/go.mod h1:/80GAK0K/3+PqUBZHvaOPd3b1sjHeimxQh1nrJzgaPk=
-github.com/wealdtech/go-eth2-wallet v1.17.0 h1:hMjGRjvpk95gguW6UXFDkRHWjYqE0cdrO7cOClF9Ubo=
-github.com/wealdtech/go-eth2-wallet v1.17.0/go.mod h1:qMmDrx//GrdZ3q+0Jf9SNwCaLsFOxOmXgr1yptpSMIE=
-github.com/wealdtech/go-eth2-wallet-dirk v1.5.1 h1:h1wZK31yonLkwddajg+Prhhd2rrvIIxQ3HxwZ3udnaY=
-github.com/wealdtech/go-eth2-wallet-dirk v1.5.1/go.mod h1:Yz1Mc+HfbG1CODeBpAQ++/Us76OdXzI5kVs1qGvUiBM=
+github.com/wealdtech/go-eth2-wallet v1.16.0 h1:syD1xDYB7emk4x+6bTYm5VZp9nx5FLab5Fgm09Eq1Kg=
+github.com/wealdtech/go-eth2-wallet v1.16.0/go.mod h1:JFA2P7PpPR8quQ/T6Gsr/4VLj5sQVnyzKgfPA+eqmYE=
+github.com/wealdtech/go-eth2-wallet-dirk v1.4.7 h1:P9xgaoBB9h1r0OUEE6LHffZ+IbiGE4uniMaNjvP1+D8=
+github.com/wealdtech/go-eth2-wallet-dirk v1.4.7/go.mod h1:fP/g7OQQTYCFRg+ZIv6eoTvDdjkZlHnLcf41UgCvrM8=
 github.com/wealdtech/go-eth2-wallet-distributed v1.2.1 h1:+pbG9i9b5TrWd7GDRX8yq4FKA+D7k7aI6uySEvAZ+Kk=
 github.com/wealdtech/go-eth2-wallet-distributed v1.2.1/go.mod h1:jYkDax2VhUNKIct6TVlgxAagvR56/eg7y7J+JFq+gDo=
 github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4 v1.4.1 h1:9j7bpwjT9wmwBb54ZkBhTm1uNIlFFcCJXefd/YskZPw=
@@ -180,8 +200,6 @@ github.com/wealdtech/go-eth2-wallet-encryptor-unencrypted v1.0.2 h1:IMIyl70hbJlx
 github.com/wealdtech/go-eth2-wallet-encryptor-unencrypted v1.0.2/go.mod h1:T8nyAscWIWNcNa6EG/19PwH/OCt2Ly7Orn5okmiuSP4=
 github.com/wealdtech/go-eth2-wallet-hd/v2 v2.7.0 h1:5g4emFacTf+sX6zx6SbZIZGR7Jx5Xr/Xdb7sXnEXlWk=
 github.com/wealdtech/go-eth2-wallet-hd/v2 v2.7.0/go.mod h1:aWgnEi07w1L9wMBRB69sYvoEONppAUly6FDQRWQGqH8=
-github.com/wealdtech/go-eth2-wallet-keystore v1.0.0 h1:DYR6TAyi7RxXoAanLSPdiufGxCX617BQwWOdCxHqHX4=
-github.com/wealdtech/go-eth2-wallet-keystore v1.0.0/go.mod h1:6DGINunnasS9y9F7KH3ya2h74fHWgSCfP3dAJWe4A6U=
 github.com/wealdtech/go-eth2-wallet-nd/v2 v2.5.0 h1:vphAFklkYMRJVo9f5rVWly7PECHrLS4yarjemBa7fRM=
 github.com/wealdtech/go-eth2-wallet-nd/v2 v2.5.0/go.mod h1:kBZUZogqwvvxulEvXi5l6OjZyd7EBmCKxce5Q+lW7fs=
 github.com/wealdtech/go-eth2-wallet-store-filesystem v1.18.1 h1:Ceq74WL57jdBQnrZJFJyGRBKOOFI5wwq9VoxeAbjoEk=
@@ -190,59 +208,62 @@ github.com/wealdtech/go-eth2-wallet-store-s3 v1.12.0 h1:noknYCbHw2soPhwke1LvC99K
 github.com/wealdtech/go-eth2-wallet-store-s3 v1.12.0/go.mod h1:1lSVxfQynUAd5u46rCeAI8wCl8S44lZsNYYXlxVAvwU=
 github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.2 h1:TwOt7bEHsVe6dKJb7XuUG7m06gaBGPCQlBk24Ql8Mws=
 github.com/wealdtech/go-eth2-wallet-store-scratch v1.7.2/go.mod h1:rtIoB34tqL3kUOK+LsLTAHfynxLR8pGScy0lmQmpbKc=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.12.0 h1:w0OrVImtQfjN7XCqALfgVtcmH8FChaUZjwNGKGzqp0E=
-github.com/wealdtech/go-eth2-wallet-types/v2 v2.12.0/go.mod h1:m8xsnPZLq1vt7bnMveTc4xxVJUv8mBL21iPU4kALYGE=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.11.0 h1:yX9+FfUXvPDvZ8Q5bhF+64AWrQwh4a3/HpfTx99DnZc=
+github.com/wealdtech/go-eth2-wallet-types/v2 v2.11.0/go.mod h1:UVP9YFcnPiIzHqbmCMW3qrQ3TK5FOqr1fmKqNT9JGr8=
 github.com/wealdtech/go-indexer v1.1.0 h1:vn4gY7nSYSLe0sXVauJgyHvK4NXiDrLKBYYYKWypahk=
 github.com/wealdtech/go-indexer v1.1.0/go.mod h1:lEFTda1rul1EwWIX3QqXq/KW0tnEEhC41Lup06V7Tlo=
 github.com/wealdtech/go-string2eth v1.2.1 h1:u9sofvGFkp+uvTg4Nvsvy5xBaiw8AibGLLngfC4F76g=
 github.com/wealdtech/go-string2eth v1.2.1/go.mod h1:9uwxm18zKZfrReXrGIbdiRYJtbE91iGcj6TezKKEx80=
-go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
-go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.58.0 h1:PS8wXpbyaDJQ2VDHHncMe9Vct0Zn1fEjpsjrLxGJoSc=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.58.0/go.mod h1:HDBUsEjOuRC0EzKZ1bSaRGZWUBAzo+MhAcUUORSr4D0=
-go.opentelemetry.io/otel v1.33.0 h1:/FerN9bax5LoK51X/sI0SVYrjSE0/yUL7DpxW4K3FWw=
-go.opentelemetry.io/otel v1.33.0/go.mod h1:SUUkR6csvUQl+yjReHu5uM3EtVV7MBm5FHKRlNx4I8I=
-go.opentelemetry.io/otel/metric v1.33.0 h1:r+JOocAyeRVXD8lZpjdQjzMadVZp2M4WmQ+5WtEnklQ=
-go.opentelemetry.io/otel/metric v1.33.0/go.mod h1:L9+Fyctbp6HFTddIxClbQkjtubW6O9QS3Ann/M82u6M=
-go.opentelemetry.io/otel/sdk v1.31.0 h1:xLY3abVHYZ5HSfOg3l2E5LUj2Cwva5Y7yGxnSW9H5Gk=
-go.opentelemetry.io/otel/sdk v1.31.0/go.mod h1:TfRbMdhvxIIr/B2N2LQW2S5v9m3gOQ/08KsbbO5BPT0=
-go.opentelemetry.io/otel/sdk/metric v1.31.0 h1:i9hxxLJF/9kkvfHppyLL55aW7iIJz4JjxTeYusH7zMc=
-go.opentelemetry.io/otel/sdk/metric v1.31.0/go.mod h1:CRInTMVvNhUKgSAMbKyTMxqOBC0zgyxzW55lZzX43Y8=
-go.opentelemetry.io/otel/trace v1.33.0 h1:cCJuF7LRjUFso9LPnEAHJDB2pqzp+hbO8eu1qqW2d/s=
-go.opentelemetry.io/otel/trace v1.33.0/go.mod h1:uIcdVUZMpTAmz0tI1z04GoVSezK37CbGV4fr1f2nBck=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0 h1:4Pp6oUg3+e/6M4C0A/3kJ2VYa++dsWVTtGgLVj5xtHg=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.49.0/go.mod h1:Mjt1i1INqiaoZOMGR1RIUJN+i3ChKoFRqzrRQhlkbs0=
+go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
+go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
+go.opentelemetry.io/otel/metric v1.24.0/go.mod h1:VYhLe1rFfxuTXLgj4CBiyz+9WYBA8pNGJgDcSFRKBco=
+go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
+go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
 go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
 go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
-golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
-golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67 h1:1UoZQm6f0P/ZO0w1Ri+f+ifG/gXhegadRdwBIXEFWDo=
-golang.org/x/exp v0.0.0-20241217172543-b2144cdd0a67/go.mod h1:qj5a5QZpwLU2NLQudwIN5koi3beDhSAlJwa67PuM98c=
+golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f h1:3CW0unweImhOzd5FmYuRsD4Y4oQFKZIjAnKbjV4WIrw=
+golang.org/x/exp v0.0.0-20240314144324-c7f7c6466f7f/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
-golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
-golang.org/x/sync v0.10.0 h1:3NQrjDixjgGwUOCaF8w2+VYHv0Ve/vGYSbdkTa98gmQ=
-golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs=
+golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20221010170243-090e33056c14/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo=
-golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
-google.golang.org/genproto/googleapis/api v0.0.0-20241219192143-6b3ec007d9bb h1:B7GIB7sr443wZ/EAEl7VZjmh1V6qzkt5V+RYcUYtS1U=
-google.golang.org/genproto/googleapis/api v0.0.0-20241219192143-6b3ec007d9bb/go.mod h1:E5//3O5ZIG2l71Xnt+P/CYUY8Bxs8E7WMoZ9tlcMbAY=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241219192143-6b3ec007d9bb h1:3oy2tynMOP1QbTC0MsNNAV+Se8M2Bd0A5+x1QHyw+pI=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20241219192143-6b3ec007d9bb/go.mod h1:lcTa1sDdWEIHMWlITnIczmw5w60CF9ffkb8Z+DVmmjA=
-google.golang.org/grpc v1.69.2 h1:U3S9QEtbXC0bYNvRtcoklF3xGtLViumSYxWykJS+7AU=
-google.golang.org/grpc v1.69.2/go.mod h1:vyjdE6jLBI76dgpDojsFGNaHlxdjXN9ghpnd2o7JGZ4=
-google.golang.org/protobuf v1.36.0 h1:mjIs9gYtt56AzC4ZaffQuh88TZurBGhIJMBZGSxNerQ=
-google.golang.org/protobuf v1.36.0/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028 h1:+cNy6SZtPcJQH3LJVLOSmiC7MMxXNOb3PU/VUEz+EhU=
+golang.org/x/xerrors v0.0.0-20231012003039-104605ab7028/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
+google.golang.org/genproto/googleapis/api v0.0.0-20240314234333-6e1732d8331c h1:kaI7oewGK5YnVwj+Y+EJBO/YN1ht8iTL9XkFHtVZLsc=
+google.golang.org/genproto/googleapis/api v0.0.0-20240314234333-6e1732d8331c/go.mod h1:VQW3tUculP/D4B+xVCo+VgSq8As6wA9ZjHl//pmk+6s=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240314234333-6e1732d8331c h1:lfpJ/2rWPa/kJgxyyXM8PrNnfCzcmxJ265mADgwmvLI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20240314234333-6e1732d8331c/go.mod h1:WtryC6hu0hhx87FDGxWCDptyssuo68sk10vYjF+T9fY=
+google.golang.org/grpc v1.62.1 h1:B4n+nfKzOICUXMgyrNd19h/I9oH0L1pizfk1d4zSgTk=
+google.golang.org/grpc v1.62.1/go.mod h1:IWTG0VlJLCh1SkC58F7np9ka9mx/WNkjl4PGJaiq+QE=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/Knetic/govaluate.v3 v3.0.0 h1:18mUyIt4ZlRlFZAAfVetz4/rzlJs9yhN+U02F4u1AOc=
 gopkg.in/Knetic/govaluate.v3 v3.0.0/go.mod h1:csKLBORsPbafmSCGTEh3U7Ozmsuq8ZSIlKk1bcqph0E=
 gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y=

services/chaintime/service.go

@@ -62,6 +62,4 @@ type Service interface {
 	CapellaInitialEpoch() phase0.Epoch
 	// DenebInitialEpoch provides the epoch at which the Deneb hard fork takes place.
 	DenebInitialEpoch() phase0.Epoch
-	// ElectraInitialEpoch provides the epoch at which the Electra hard fork takes place.
-	ElectraInitialEpoch() phase0.Epoch
 }

services/chaintime/standard/service.go

@@ -35,7 +35,6 @@ type Service struct {
 	bellatrixForkEpoch           phase0.Epoch
 	capellaForkEpoch             phase0.Epoch
 	denebForkEpoch               phase0.Epoch
-	electraForkEpoch             phase0.Epoch
 }
 
 // module-wide log.
@@ -117,13 +116,6 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 	}
 	log.Trace().Uint64("epoch", uint64(denebForkEpoch)).Msg("Obtained Deneb fork epoch")
 
-	electraForkEpoch, err := fetchElectraForkEpoch(ctx, parameters.specProvider)
-	if err != nil {
-		// Set to far future epoch.
-		electraForkEpoch = 0xffffffffffffffff
-	}
-	log.Trace().Uint64("epoch", uint64(electraForkEpoch)).Msg("Obtained Electra fork epoch")
-
 	s := &Service{
 		genesisTime:                  genesisResponse.Data.GenesisTime,
 		slotDuration:                 slotDuration,
@@ -133,7 +125,6 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 		bellatrixForkEpoch:           bellatrixForkEpoch,
 		capellaForkEpoch:             capellaForkEpoch,
 		denebForkEpoch:               denebForkEpoch,
-		electraForkEpoch:             electraForkEpoch,
 	}
 
 	return s, nil
@@ -350,32 +341,3 @@ func fetchDenebForkEpoch(ctx context.Context,
 
 	return phase0.Epoch(epoch), nil
 }
-
-// ElectraInitialEpoch provides the epoch at which the Electra hard fork takes place.
-func (s *Service) ElectraInitialEpoch() phase0.Epoch {
-	return s.electraForkEpoch
-}
-
-func fetchElectraForkEpoch(ctx context.Context,
-	specProvider eth2client.SpecProvider,
-) (
-	phase0.Epoch,
-	error,
-) {
-	// Fetch the fork version.
-	specResponse, err := specProvider.Spec(ctx, &api.SpecOpts{})
-	if err != nil {
-		return 0, errors.Wrap(err, "failed to obtain spec")
-	}
-	tmp, exists := specResponse.Data["ELECTRA_FORK_EPOCH"]
-	if !exists {
-		return 0, errors.New("deneb fork version not known by chain")
-	}
-	epoch, isEpoch := tmp.(uint64)
-	if !isEpoch {
-		//nolint:revive
-		return 0, errors.New("ELECTRA_FORK_EPOCH is not a uint64!")
-	}
-
-	return phase0.Epoch(epoch), nil
-}

services/chaintime/standard/service_test.go

@@ -18,41 +18,22 @@ import (
 	"testing"
 	"time"
 
-	"github.com/attestantio/go-eth2-client/api"
-	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
-	"github.com/attestantio/go-eth2-client/mock"
 	"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) {
-	ctx := context.Background()
+	genesisTime := time.Now()
+	slotDuration := 12 * time.Second
+	slotsPerEpoch := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
 
-	mockClient, err := mock.New(ctx)
-	require.NoError(t, err)
-	// genesis is 1 day ago.
-	genesisTime := time.Now().AddDate(0, 0, -1)
-	mockClient.GenesisFunc = func(context.Context, *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error) {
-		return &api.Response[*apiv1.Genesis]{
-			Data: &apiv1.Genesis{
-				GenesisTime: genesisTime,
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
-	mockClient.SpecFunc = func(context.Context, *api.SpecOpts) (*api.Response[map[string]any], error) {
-		return &api.Response[map[string]any]{
-			Data: map[string]any{
-				"SECONDS_PER_SLOT":                 time.Second * 12,
-				"SLOTS_PER_EPOCH":                  uint64(32),
-				"EPOCHS_PER_SYNC_COMMITTEE_PERIOD": uint64(256),
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
 
 	tests := []struct {
 		name   string
@@ -63,7 +44,7 @@ func TestService(t *testing.T) {
 			name: "GenesisProviderMissing",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithSpecProvider(mockClient),
+				standard.WithSpecProvider(mockSpecProvider),
 			},
 			err: "problem with parameters: no genesis provider specified",
 		},
@@ -71,7 +52,7 @@ func TestService(t *testing.T) {
 			name: "SpecProviderMissing",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisProvider(mockClient),
+				standard.WithGenesisProvider(mockGenesisProvider),
 			},
 			err: "problem with parameters: no spec provider specified",
 		},
@@ -79,8 +60,8 @@ func TestService(t *testing.T) {
 			name: "Good",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisProvider(mockClient),
-				standard.WithSpecProvider(mockClient),
+				standard.WithGenesisProvider(mockGenesisProvider),
+				standard.WithSpecProvider(mockSpecProvider),
 			},
 		},
 	}
@@ -99,14 +80,7 @@ func TestService(t *testing.T) {
 
 // createService is a helper that creates a mock chaintime service.
 func createService(genesisTime time.Time) (chaintime.Service, time.Duration, uint64, uint64, []*phase0.Fork, error) {
-	ctx := context.Background()
-
-	mockClient, err := mock.New(ctx)
-	if err != nil {
-		return nil, 0, 0, 0, nil, err
-	}
-
-	secondsPerSlot := time.Second * 12
+	slotDuration := 12 * time.Second
 	slotsPerEpoch := uint64(32)
 	epochsPerSyncCommitteePeriod := uint64(256)
 	forkSchedule := []*phase0.Fork{
@@ -122,36 +96,13 @@ func createService(genesisTime time.Time) (chaintime.Service, time.Duration, uin
 		},
 	}
 
-	mockClient.GenesisFunc = func(context.Context, *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error) {
-		return &api.Response[*apiv1.Genesis]{
-			Data: &apiv1.Genesis{
-				GenesisTime: genesisTime,
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
-	mockClient.SpecFunc = func(context.Context, *api.SpecOpts) (*api.Response[map[string]any], error) {
-		return &api.Response[map[string]any]{
-			Data: map[string]any{
-				"SECONDS_PER_SLOT":                 secondsPerSlot,
-				"SLOTS_PER_EPOCH":                  slotsPerEpoch,
-				"EPOCHS_PER_SYNC_COMMITTEE_PERIOD": epochsPerSyncCommitteePeriod,
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
-	mockClient.ForkScheduleFunc = func(context.Context, *api.ForkScheduleOpts) (*api.Response[[]*phase0.Fork], error) {
-		return &api.Response[[]*phase0.Fork]{
-			Data:     forkSchedule,
-			Metadata: make(map[string]any),
-		}, nil
-	}
-
-	s, err := standard.New(ctx,
-		standard.WithGenesisProvider(mockClient),
-		standard.WithSpecProvider(mockClient),
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
+	s, err := standard.New(context.Background(),
+		standard.WithGenesisProvider(mockGenesisProvider),
+		standard.WithSpecProvider(mockSpecProvider),
 	)
-	return s, secondsPerSlot, slotsPerEpoch, epochsPerSyncCommitteePeriod, forkSchedule, err
+	return s, slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod, forkSchedule, err
 }
 
 func TestGenesisTime(t *testing.T) {

shamir/shamir.go

@@ -75,9 +75,9 @@ func (p *polynomial) evaluate(x uint8) uint8 {
 func interpolatePolynomial(xSamples, ySamples []uint8, x uint8) uint8 {
 	limit := len(xSamples)
 	var result, basis uint8
-	for i := range limit {
+	for i := 0; i < limit; i++ {
 		basis = 1
-		for j := range limit {
+		for j := 0; j < limit; j++ {
 			if i == j {
 				continue
 			}
@@ -183,7 +183,7 @@ func Split(secret []byte, parts, threshold int) ([][]byte, error) {
 		// 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 := range parts {
+		for i := 0; i < parts; i++ {
 			x := uint8(xCoordinates[i]) + 1
 			y := p.evaluate(x)
 			out[i][idx] = y

testing/mock/eth2client.go

@@ -0,0 +1,163 @@
+// 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"
+	"github.com/attestantio/go-eth2-client/api"
+	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
+	"github.com/attestantio/go-eth2-client/spec"
+	"github.com/attestantio/go-eth2-client/spec/phase0"
+)
+
+// GenesisProvider is a mock for eth2client.GenesisProvider.
+type GenesisProvider struct {
+	genesisTime time.Time
+}
+
+// NewGenesisProvider returns a mock genesis provider with the provided value.
+func NewGenesisProvider(genesisTime time.Time) eth2client.GenesisProvider {
+	return &GenesisProvider{
+		genesisTime: genesisTime,
+	}
+}
+
+// Genesisis a mock.
+func (m *GenesisProvider) Genesis(_ context.Context, _ *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error) {
+	return &api.Response[*apiv1.Genesis]{
+		Data: &apiv1.Genesis{
+			GenesisTime: m.genesisTime,
+		},
+		Metadata: make(map[string]any),
+	}, nil
+}
+
+// SpecProvider is a mock for eth2client.SpecProvider.
+type SpecProvider struct {
+	spec map[string]any
+}
+
+// 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]any{
+			"SECONDS_PER_SLOT":                 slotDuration,
+			"SLOTS_PER_EPOCH":                  slotsPerEpoch,
+			"EPOCHS_PER_SYNC_COMMITTEE_PERIOD": epochsPerSyncCommitteePeriod,
+		},
+	}
+}
+
+// Spec is a mock.
+func (m *SpecProvider) Spec(_ context.Context, _ *api.SpecOpts) (*api.Response[map[string]any], error) {
+	return &api.Response[map[string]any]{
+		Data:     m.spec,
+		Metadata: make(map[string]any),
+	}, 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(_ context.Context, _ *api.ForkScheduleOpts) (*api.Response[[]*phase0.Fork], error) {
+	return &api.Response[[]*phase0.Fork]{
+		Data:     m.schedule,
+		Metadata: make(map[string]any),
+	}, 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(_ 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(_ context.Context, _ []*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(_ context.Context, _ *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(_ context.Context, _ []*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(_ context.Context, _ []*apiv1.BeaconCommitteeSubscription) error {
+	return nil
+}

util/account.go

@@ -1,4 +1,3 @@
-// Copyright © 2020 - 2025 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
@@ -57,12 +56,6 @@ func ParseAccount(ctx context.Context,
 				account, err = parseAccountFromKeystorePath(ctx, accountStr, supplementary, unlock)
 			}
 		}
-		if err != nil {
-			if strings.Count(accountStr, " ") > 7 {
-				// It is also possible that this is a mnemonic with "/" in the additional word, so try that as well.
-				account, err = parseAccountFromMnemonic(ctx, accountStr, supplementary, unlock)
-			}
-		}
 		if err != nil {
 			return nil, err
 		}

util/account_test.go

@@ -1,4 +1,4 @@
-// Copyright © 2020 - 2025 Weald Technology Trading
+// Copyright © 2020 Weald Technology Trading
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
@@ -75,18 +75,6 @@ func TestParseAccount(t *testing.T) {
 			supplementary:  []string{"m/12381/3600/0/0"},
 			expectedPubkey: "0x99b1f1d84d76185466d86c34bde1101316afddae76217aa86cd066979b19858c2c9d9e56eebc1e067ac54277a61790db",
 		},
-		{
-			name:           "ShortMnemonic",
-			accountStr:     "aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban art",
-			supplementary:  []string{"m/12381/3600/0/0"},
-			expectedPubkey: "0x99b1f1d84d76185466d86c34bde1101316afddae76217aa86cd066979b19858c2c9d9e56eebc1e067ac54277a61790db",
-		},
-		{
-			name:           "ShortMnemonicWith25th",
-			accountStr:     `aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban aban art !"£$%^&*()<>,./?;:'@#~]}[{-_=+`,
-			supplementary:  []string{"m/12381/3600/0/0"},
-			expectedPubkey: "0xa9264986cbde1f05d4c37ed57b03c476f360f0c64cf4a41752c3d352f60caebb6555c5522f0f962962a619336e1539f2",
-		},
 		{
 			name:             "MnemonicUnlocked",
 			accountStr:       "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",

util/attestations.go

@@ -17,59 +17,18 @@ import (
 	"bytes"
 	"context"
 
-	"github.com/attestantio/go-eth2-client/spec"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
-	"github.com/pkg/errors"
 	"github.com/wealdtech/ethdo/services/chaintime"
 )
 
-// AttestationHead returns the head for which the attestation should have voted.
-func AttestationHead(ctx context.Context,
-	headersCache *BeaconBlockHeaderCache,
-	attestation *spec.VersionedAttestation,
-) (
-	phase0.Root,
-	error,
-) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return phase0.Root{}, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
-	slot := attestationData.Slot
-	for {
-		header, err := headersCache.Fetch(ctx, slot)
-		if err != nil {
-			return phase0.Root{}, err
-		}
-		if header == nil {
-			// No block.
-			slot--
-			continue
-		}
-		if !header.Canonical {
-			// Not canonical.
-			slot--
-			continue
-		}
-
-		return header.Root, nil
-	}
-}
-
 // AttestationHeadCorrect returns true if the given attestation had the correct head.
 func AttestationHeadCorrect(ctx context.Context,
 	headersCache *BeaconBlockHeaderCache,
-	attestation *spec.VersionedAttestation,
+	attestationData *phase0.AttestationData,
 ) (
 	bool,
 	error,
 ) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return false, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
 	slot := attestationData.Slot
 	for {
 		header, err := headersCache.Fetch(ctx, slot)
@@ -86,61 +45,19 @@ func AttestationHeadCorrect(ctx context.Context,
 			slot--
 			continue
 		}
-
 		return bytes.Equal(header.Root[:], attestationData.BeaconBlockRoot[:]), nil
 	}
 }
 
-// AttestationTarget returns the target for which the attestation should have voted.
-func AttestationTarget(ctx context.Context,
-	headersCache *BeaconBlockHeaderCache,
-	chainTime chaintime.Service,
-	attestation *spec.VersionedAttestation,
-) (
-	phase0.Root,
-	error,
-) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return phase0.Root{}, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
-	// Start with first slot of the target epoch.
-	slot := chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
-	for {
-		header, err := headersCache.Fetch(ctx, slot)
-		if err != nil {
-			return phase0.Root{}, err
-		}
-		if header == nil {
-			// No block.
-			slot--
-			continue
-		}
-		if !header.Canonical {
-			// Not canonical.
-			slot--
-			continue
-		}
-
-		return header.Root, nil
-	}
-}
-
 // AttestationTargetCorrect returns true if the given attestation had the correct target.
 func AttestationTargetCorrect(ctx context.Context,
 	headersCache *BeaconBlockHeaderCache,
 	chainTime chaintime.Service,
-	attestation *spec.VersionedAttestation,
+	attestationData *phase0.AttestationData,
 ) (
 	bool,
 	error,
 ) {
-	attestationData, err := attestation.Data()
-	if err != nil {
-		return false, errors.Wrap(err, "failed to obtain attestation data")
-	}
-
 	// Start with first slot of the target epoch.
 	slot := chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
 	for {
@@ -158,7 +75,6 @@ func AttestationTargetCorrect(ctx context.Context,
 			slot--
 			continue
 		}
-
 		return bytes.Equal(header.Root[:], attestationData.Target.Root[:]), nil
 	}
 }

util/beaconnode.go

@@ -38,10 +38,11 @@ var defaultBeaconNodeAddresses = []string{
 var fallbackBeaconNode = "http://mainnet-consensus.attestant.io/"
 
 type ConnectOpts struct {
-	Address       string
-	Timeout       time.Duration
-	AllowInsecure bool
-	LogFallback   bool
+	Address           string
+	Timeout           time.Duration
+	AllowInsecure     bool
+	LogFallback       bool
+	CustomSpecSupport bool
 }
 
 // ConnectToBeaconNode connects to a beacon node at the given address.
@@ -56,12 +57,12 @@ func ConnectToBeaconNode(ctx context.Context, opts *ConnectOpts) (eth2client.Ser
 
 	if opts.Address != "" {
 		// We have an explicit address; use it.
-		return connectToBeaconNode(ctx, opts.Address, opts.Timeout, opts.AllowInsecure)
+		return connectToBeaconNode(ctx, opts.Address, opts.Timeout, opts.AllowInsecure, opts.CustomSpecSupport)
 	}
 
 	// Try the defaults.
 	for _, address := range defaultBeaconNodeAddresses {
-		client, err := connectToBeaconNode(ctx, address, opts.Timeout, opts.AllowInsecure)
+		client, err := connectToBeaconNode(ctx, address, opts.Timeout, opts.AllowInsecure, opts.CustomSpecSupport)
 		if err == nil {
 			return client, nil
 		}
@@ -71,7 +72,7 @@ func ConnectToBeaconNode(ctx context.Context, opts *ConnectOpts) (eth2client.Ser
 	if opts.LogFallback {
 		fmt.Fprintf(os.Stderr, "No connection supplied with --connection parameter and no local beacon node found, attempting to use mainnet fallback\n")
 	}
-	client, err := connectToBeaconNode(ctx, fallbackBeaconNode, opts.Timeout, true)
+	client, err := connectToBeaconNode(ctx, fallbackBeaconNode, opts.Timeout, true, opts.CustomSpecSupport)
 	if err == nil {
 		return client, nil
 	}
@@ -79,7 +80,7 @@ func ConnectToBeaconNode(ctx context.Context, opts *ConnectOpts) (eth2client.Ser
 	return nil, errors.New("failed to connect to any beacon node")
 }
 
-func connectToBeaconNode(ctx context.Context, address string, timeout time.Duration, allowInsecure bool) (eth2client.Service, error) {
+func connectToBeaconNode(ctx context.Context, address string, timeout time.Duration, allowInsecure bool, withCustomSpecSupport bool) (eth2client.Service, error) {
 	if !strings.HasPrefix(address, "http") {
 		address = fmt.Sprintf("http://%s", address)
 	}
@@ -101,6 +102,7 @@ func connectToBeaconNode(ctx context.Context, address string, timeout time.Durat
 		http.WithLogLevel(zerolog.Disabled),
 		http.WithAddress(address),
 		http.WithTimeout(timeout),
+		http.WithCustomSpecSupport(withCustomSpecSupport),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to connect to beacon node")

util/epoch_test.go

@@ -18,44 +18,28 @@ import (
 	"testing"
 	"time"
 
-	"github.com/attestantio/go-eth2-client/api"
-	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
-	"github.com/attestantio/go-eth2-client/mock"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/testing/mock"
 	"github.com/wealdtech/ethdo/util"
 )
 
 func TestParseEpoch(t *testing.T) {
 	ctx := context.Background()
 
-	mockClient, err := mock.New(ctx)
-	require.NoError(t, err)
 	// genesis is 1 day ago.
 	genesisTime := time.Now().AddDate(0, 0, -1)
-	mockClient.GenesisFunc = func(context.Context, *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error) {
-		return &api.Response[*apiv1.Genesis]{
-			Data: &apiv1.Genesis{
-				GenesisTime: genesisTime,
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
-	mockClient.SpecFunc = func(context.Context, *api.SpecOpts) (*api.Response[map[string]any], error) {
-		return &api.Response[map[string]any]{
-			Data: map[string]any{
-				"SECONDS_PER_SLOT": time.Second * 12,
-				"SLOTS_PER_EPOCH":  uint64(32),
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
+	slotDuration := 12 * time.Second
+	slotsPerEpoch := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithLogLevel(zerolog.Disabled),
-		standardchaintime.WithGenesisProvider(mockClient),
-		standardchaintime.WithSpecProvider(mockClient),
+		standardchaintime.WithGenesisProvider(mockGenesisProvider),
+		standardchaintime.WithSpecProvider(mockSpecProvider),
 	)
 	require.NoError(t, err)
 

util/slot_test.go

@@ -18,44 +18,28 @@ import (
 	"testing"
 	"time"
 
-	"github.com/attestantio/go-eth2-client/api"
-	apiv1 "github.com/attestantio/go-eth2-client/api/v1"
-	"github.com/attestantio/go-eth2-client/mock"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/rs/zerolog"
 	"github.com/stretchr/testify/require"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
+	"github.com/wealdtech/ethdo/testing/mock"
 	"github.com/wealdtech/ethdo/util"
 )
 
 func TestParseSlot(t *testing.T) {
 	ctx := context.Background()
 
-	mockClient, err := mock.New(ctx)
-	require.NoError(t, err)
 	// genesis is 1 day ago.
 	genesisTime := time.Now().AddDate(0, 0, -1)
-	mockClient.GenesisFunc = func(context.Context, *api.GenesisOpts) (*api.Response[*apiv1.Genesis], error) {
-		return &api.Response[*apiv1.Genesis]{
-			Data: &apiv1.Genesis{
-				GenesisTime: genesisTime,
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
-	mockClient.SpecFunc = func(context.Context, *api.SpecOpts) (*api.Response[map[string]any], error) {
-		return &api.Response[map[string]any]{
-			Data: map[string]any{
-				"SECONDS_PER_SLOT": time.Second * 12,
-				"SLOTS_PER_EPOCH":  uint64(32),
-			},
-			Metadata: make(map[string]any),
-		}, nil
-	}
+	slotDuration := 12 * time.Second
+	slotsPerSlot := uint64(32)
+	epochsPerSyncCommitteePeriod := uint64(256)
+	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
+	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerSlot, epochsPerSyncCommitteePeriod)
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithLogLevel(zerolog.Disabled),
-		standardchaintime.WithGenesisProvider(mockClient),
-		standardchaintime.WithSpecProvider(mockClient),
+		standardchaintime.WithGenesisProvider(mockGenesisProvider),
+		standardchaintime.WithSpecProvider(mockSpecProvider),
 	)
 	require.NoError(t, err)