Use standard mock from go-eth2-client.

Electra

.github/workflows/golangci-lint.yml

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

.github/workflows/release.yml

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

.github/workflows/test.yml

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

.gitignore

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

.golangci.yml

@@ -69,7 +69,7 @@ run:
   # Define the Go version limit.
   # Mainly related to generics support since go1.18.
   # Default: use Go version from the go.mod file, fallback on the env var `GOVERSION`, fallback on 1.18
-  go: '1.19'
+  # go: '1.19'
 
 
 # output configuration options
@@ -106,6 +106,11 @@ 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
 
@@ -132,9 +137,9 @@ linters:
     - dupl
     - err113
     - errorlint
-    - execinquery
     - exhaustive
     - exhaustruct
+    - exportloopref
     - forbidigo
     - forcetypeassert
     - funlen
@@ -144,7 +149,6 @@ linters:
     - gocognit
     - goconst
     - goheader
-    - gomnd
     - ireturn
     - lll
     - maintidx

CHANGELOG.md

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

Dockerfile

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

cmd/attester/inclusion/output.go

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

cmd/attester/inclusion/process.go

@@ -22,6 +22,7 @@ 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"
@@ -93,9 +94,18 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 			return nil, errors.Wrap(err, "failed to obtain block attestations")
 		}
 		for i, attestation := range attestations {
-			if attestation.Data.Slot == duty.Slot &&
-				attestation.Data.Index == duty.CommitteeIndex &&
-				attestation.AggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
+			attestationData, err := attestation.Data()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to obtain attestation data")
+			}
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return nil, errors.Wrap(err, "failed to obtain attestation aggregation bits")
+			}
+
+			if attestationData.Slot == duty.Slot &&
+				attestationData.Index == duty.CommitteeIndex &&
+				aggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
 				headCorrect := false
 				targetCorrect := false
 				if data.verbose {
@@ -128,8 +138,13 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 	return results, nil
 }
 
-func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
-	slot := attestation.Data.Slot
+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")
+	}
+
+	slot := attestationData.Slot
 	for {
 		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
 			Block: fmt.Sprintf("%d", slot),
@@ -149,13 +164,19 @@ func calcHeadCorrect(ctx context.Context, data *dataIn, attestation *phase0.Atte
 			slot--
 			continue
 		}
-		return bytes.Equal(response.Data.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+
+		return bytes.Equal(response.Data.Root[:], attestationData.BeaconBlockRoot[:]), nil
 	}
 }
 
-func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.Attestation) (bool, error) {
+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")
+	}
+
 	// Start with first slot of the target epoch.
-	slot := data.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+	slot := data.chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
 	for {
 		response, err := data.eth2Client.(eth2client.BeaconBlockHeadersProvider).BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
 			Block: fmt.Sprintf("%d", slot),
@@ -175,7 +196,8 @@ func calcTargetCorrect(ctx context.Context, data *dataIn, attestation *phase0.At
 			slot--
 			continue
 		}
-		return bytes.Equal(response.Data.Root[:], attestation.Data.Target.Root[:]), nil
+
+		return bytes.Equal(response.Data.Root[:], attestationData.Target.Root[:]), nil
 	}
 }
 

cmd/block/analyze/command.go

@@ -55,7 +55,7 @@ type command struct {
 	weightDenominator  uint64
 
 	// Processing.
-	priorAttestations map[string]*attestationData
+	priorAttestations map[string]*attestationDataInfo
 	// 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 +77,20 @@ type blockAnalysis struct {
 }
 
 type attestationAnalysis struct {
-	Head          phase0.Root      `json:"head"`
-	Target        phase0.Root      `json:"target"`
-	Distance      int              `json:"distance"`
-	Duplicate     *attestationData `json:"duplicate,omitempty"`
-	NewVotes      int              `json:"new_votes"`
-	Votes         int              `json:"votes"`
-	PossibleVotes int              `json:"possible_votes"`
-	HeadCorrect   bool             `json:"head_correct"`
-	HeadTimely    bool             `json:"head_timely"`
-	SourceTimely  bool             `json:"source_timely"`
-	TargetCorrect bool             `json:"target_correct"`
-	TargetTimely  bool             `json:"target_timely"`
-	Score         float64          `json:"score"`
-	Value         float64          `json:"value"`
+	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"`
 }
 
 type syncCommitteeAnalysis struct {
@@ -100,7 +100,7 @@ type syncCommitteeAnalysis struct {
 	Value                 float64 `json:"value"`
 }
 
-type attestationData struct {
+type attestationDataInfo struct {
 	Block phase0.Slot `json:"block"`
 	Index int         `json:"index"`
 }
@@ -110,7 +110,7 @@ func newCommand(_ context.Context) (*command, error) {
 		quiet:             viper.GetBool("quiet"),
 		verbose:           viper.GetBool("verbose"),
 		debug:             viper.GetBool("debug"),
-		priorAttestations: make(map[string]*attestationData),
+		priorAttestations: make(map[string]*attestationDataInfo),
 		headRoots:         make(map[phase0.Slot]phase0.Root),
 		targetRoots:       make(map[phase0.Slot]phase0.Root),
 		votes:             make(map[phase0.Slot]map[phase0.CommitteeIndex]bitfield.Bitlist),

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     *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"`
+	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"`
 }
 
 func (a *attestationAnalysis) MarshalJSON() ([]byte, error) {

cmd/block/analyze/process.go

@@ -63,8 +63,12 @@ func (c *command) process(ctx context.Context) error {
 	// Calculate how many parents we need to fetch.
 	minSlot := slot
 	for _, attestation := range attestations {
-		if attestation.Data.Slot < minSlot {
-			minSlot = attestation.Data.Slot
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
+		}
+		if attestationData.Slot < minSlot {
+			minSlot = attestationData.Slot
 		}
 	}
 	if c.debug {
@@ -103,10 +107,16 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 		if c.debug {
 			fmt.Printf("Processing attestation %d\n", i)
 		}
+
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
+		}
+
 		analysis := &attestationAnalysis{
-			Head:     attestation.Data.BeaconBlockRoot,
-			Target:   attestation.Data.Target.Root,
-			Distance: int(slot - attestation.Data.Slot),
+			Head:     attestationData.BeaconBlockRoot,
+			Target:   attestationData.Target.Root,
+			Distance: int(slot - attestationData.Slot),
 		}
 
 		root, err := attestation.HashTreeRoot()
@@ -116,45 +126,47 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 		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)
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return err
 			}
-			_, exists = blockVotes[data.Slot][data.Index]
+			_, exists := blockVotes[attestationData.Slot]
 			if !exists {
-				blockVotes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
+				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(attestation.AggregationBits.Len())
-			for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
-				if attestation.AggregationBits.BitAt(j) {
+			analysis.PossibleVotes = int(aggregationBits.Len())
+			for j := range aggregationBits.Len() {
+				if aggregationBits.BitAt(j) {
 					analysis.Votes++
-					if blockVotes[data.Slot][data.Index].BitAt(j) {
+					if blockVotes[attestationData.Slot][attestationData.Index].BitAt(j) {
 						// Already attested to in this block; skip.
 						continue
 					}
-					if c.votes[data.Slot][data.Index].BitAt(j) {
+					if c.votes[attestationData.Slot][attestationData.Index].BitAt(j) {
 						// Already attested to in a previous block; skip.
 						continue
 					}
 					analysis.NewVotes++
-					blockVotes[data.Slot][data.Index].SetBitAt(j, true)
+					blockVotes[attestationData.Slot][attestationData.Index].SetBitAt(j, true)
 				}
 			}
 			// Calculate head correct.
-			var err error
 			analysis.HeadCorrect, err = c.calcHeadCorrect(ctx, attestation)
 			if err != nil {
 				return err
 			}
 
 			// Calculate head timely.
-			analysis.HeadTimely = analysis.HeadCorrect && attestation.Data.Slot == slot-1
+			analysis.HeadTimely = analysis.HeadCorrect && attestationData.Slot == slot-1
 
 			// Calculate source timely.
-			analysis.SourceTimely = attestation.Data.Slot >= slot-5
+			analysis.SourceTimely = attestationData.Slot >= slot-5
 
 			// Calculate target correct.
 			analysis.TargetCorrect, err = c.calcTargetCorrect(ctx, attestation)
@@ -164,7 +176,7 @@ func (c *command) analyzeAttestations(ctx context.Context, block *spec.Versioned
 
 			// Calculate target timely.
 			if block.Version < spec.DataVersionDeneb {
-				analysis.TargetTimely = attestation.Data.Slot >= slot-32
+				analysis.TargetTimely = attestationData.Slot >= slot-32
 			} else {
 				analysis.TargetTimely = true
 			}
@@ -194,7 +206,7 @@ func (c *command) fetchParents(ctx context.Context, block *spec.VersionedSignedB
 	if err != nil {
 		return err
 	}
-	root, err := block.Deneb.HashTreeRoot()
+	root, err := block.Root()
 	if err != nil {
 		panic(err)
 	}
@@ -255,23 +267,31 @@ func (c *command) processParentBlock(_ context.Context, block *spec.VersionedSig
 		if err != nil {
 			return err
 		}
-		c.priorAttestations[fmt.Sprintf("%#x", root)] = &attestationData{
+		c.priorAttestations[fmt.Sprintf("%#x", root)] = &attestationDataInfo{
 			Block: slot,
 			Index: i,
 		}
 
-		data := attestation.Data
-		_, exists := c.votes[data.Slot]
-		if !exists {
-			c.votes[data.Slot] = make(map[phase0.CommitteeIndex]bitfield.Bitlist)
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
 		}
-		_, exists = c.votes[data.Slot][data.Index]
-		if !exists {
-			c.votes[data.Slot][data.Index] = bitfield.NewBitlist(attestation.AggregationBits.Len())
+		aggregationBits, err := attestation.AggregationBits()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation aggregation bits")
 		}
-		for j := uint64(0); j < attestation.AggregationBits.Len(); j++ {
-			if attestation.AggregationBits.BitAt(j) {
-				c.votes[data.Slot][data.Index].SetBitAt(j, true)
+
+		_, 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)
 			}
 		}
 	}
@@ -385,8 +405,13 @@ func (c *command) setup(ctx context.Context) error {
 	return nil
 }
 
-func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attestation) (bool, error) {
-	slot := attestation.Data.Slot
+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
 	root, exists := c.headRoots[slot]
 	if !exists {
 		for {
@@ -413,20 +438,25 @@ func (c *command) calcHeadCorrect(ctx context.Context, attestation *phase0.Attes
 				slot--
 				continue
 			}
-			c.headRoots[attestation.Data.Slot] = response.Data.Root
+			c.headRoots[slot] = response.Data.Root
 			root = response.Data.Root
 			break
 		}
 	}
 
-	return bytes.Equal(root[:], attestation.Data.BeaconBlockRoot[:]), nil
+	return bytes.Equal(root[:], attestationData.BeaconBlockRoot[:]), nil
 }
 
-func (c *command) calcTargetCorrect(ctx context.Context, attestation *phase0.Attestation) (bool, error) {
-	root, exists := c.targetRoots[attestation.Data.Slot]
+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]
 	if !exists {
 		// Start with first slot of the target epoch.
-		slot := c.chainTime.FirstSlotOfEpoch(attestation.Data.Target.Epoch)
+		slot := c.chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
 		for {
 			response, err := c.blockHeadersProvider.BeaconBlockHeader(ctx, &api.BeaconBlockHeaderOpts{
 				Block: fmt.Sprintf("%d", slot),
@@ -450,12 +480,12 @@ func (c *command) calcTargetCorrect(ctx context.Context, attestation *phase0.Att
 				slot--
 				continue
 			}
-			c.targetRoots[attestation.Data.Slot] = response.Data.Root
+			c.targetRoots[attestationData.Slot] = response.Data.Root
 			root = response.Data.Root
 			break
 		}
 	}
-	return bytes.Equal(root[:], attestation.Data.Target.Root[:]), nil
+	return bytes.Equal(root[:], attestationData.Target.Root[:]), nil
 }
 
 func (c *command) analyzeSyncCommittees(_ context.Context, block *spec.VersionedSignedBeaconBlock) error {
@@ -491,6 +521,13 @@ 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/output.go

@@ -32,6 +32,7 @@ import (
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/attestantio/go-eth2-client/spec/deneb"
+	"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"
@@ -133,7 +134,61 @@ 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[att.Data.Index])))
+					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("    Slot: %d\n", att.Data.Slot))
 				res.WriteString(fmt.Sprintf("    Beacon block root: %#x\n", att.Data.BeaconBlockRoot))
@@ -198,6 +253,56 @@ 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) {
+	res := strings.Builder{}
+
+	res.WriteString(fmt.Sprintf("Attester slashings: %d\n", len(attesterSlashings)))
+	if verbose {
+		for i, slashing := range attesterSlashings {
+			// Say what was slashed.
+			att1 := slashing.Attestation1
+			att2 := slashing.Attestation2
+			slashedIndices := intersection(att1.AttestingIndices, att2.AttestingIndices)
+			if len(slashedIndices) == 0 {
+				continue
+			}
+
+			res.WriteString(fmt.Sprintf("  %d:\n", i))
+			res.WriteString(fmt.Sprintln("    Slashed validators:"))
+			response, err := eth2Client.(eth2client.ValidatorsProvider).Validators(ctx, &api.ValidatorsOpts{
+				State:   "head",
+				Indices: slashedIndices,
+			})
+			if err != nil {
+				return "", errors.Wrap(err, "failed to obtain beacon committees")
+			}
+			for k, v := range response.Data {
+				res.WriteString(fmt.Sprintf("      %#x (%d)\n", v.Validator.PublicKey[:], k))
+			}
+
+			// Say what caused the slashing.
+			if att1.Data.Target.Epoch == att2.Data.Target.Epoch {
+				res.WriteString(fmt.Sprintf("    Double voted for same target epoch (%d):\n", att1.Data.Target.Epoch))
+				if !bytes.Equal(att1.Data.Target.Root[:], att2.Data.Target.Root[:]) {
+					res.WriteString(fmt.Sprintf("      Attestation 1 target epoch root: %#x\n", att1.Data.Target.Root))
+					res.WriteString(fmt.Sprintf("      Attestation 2target epoch root: %#x\n", att2.Data.Target.Root))
+				}
+				if !bytes.Equal(att1.Data.BeaconBlockRoot[:], att2.Data.BeaconBlockRoot[:]) {
+					res.WriteString(fmt.Sprintf("      Attestation 1 beacon block root: %#x\n", att1.Data.BeaconBlockRoot))
+					res.WriteString(fmt.Sprintf("      Attestation 2 beacon block root: %#x\n", att2.Data.BeaconBlockRoot))
+				}
+			} else if att1.Data.Source.Epoch < att2.Data.Source.Epoch &&
+				att1.Data.Target.Epoch > att2.Data.Target.Epoch {
+				res.WriteString("    Surround voted:\n")
+				res.WriteString(fmt.Sprintf("      Attestation 1 vote: %d->%d\n", att1.Data.Source.Epoch, att1.Data.Target.Epoch))
+				res.WriteString(fmt.Sprintf("      Attestation 2 vote: %d->%d\n", att2.Data.Source.Epoch, att2.Data.Target.Epoch))
+			}
+		}
+	}
+
+	return res.String(), nil
+}
+
 func outputBlockDeposits(_ context.Context, verbose bool, deposits []*phase0.Deposit) (string, error) {
 	res := strings.Builder{}
 
@@ -289,7 +394,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 := uint64(0); i < syncAggregate.SyncCommitteeBits.Len(); i++ {
+						for i := range syncAggregate.SyncCommitteeBits.Len() {
 							if syncAggregate.SyncCommitteeBits.BitAt(i) {
 								res.WriteString(fmt.Sprintf(" %d", syncCommitteeResponse.Data.Validators[i]))
 							}
@@ -502,7 +607,117 @@ func outputDenebBlockText(ctx context.Context,
 	}
 	res.WriteString(tmp)
 
-	tmp, err = outputDenebBlobInfo(ctx, data.verbose, signedBlock.Message.Body, blobs)
+	tmp, err = outputBlobInfo(ctx, data.verbose, blobs)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	return res.String(), nil
+}
+
+func outputElectraBlockText(ctx context.Context,
+	data *dataOut,
+	signedBlock *electra.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) (
+	string,
+	error,
+) {
+	if signedBlock == nil {
+		return "", errors.New("no block supplied")
+	}
+
+	body := signedBlock.Message.Body
+
+	res := strings.Builder{}
+
+	// General info.
+	blockRoot, err := signedBlock.Message.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to obtain block root")
+	}
+	bodyRoot, err := signedBlock.Message.Body.HashTreeRoot()
+	if err != nil {
+		return "", errors.Wrap(err, "failed to generate body root")
+	}
+
+	tmp, err := outputBlockGeneral(ctx,
+		data.verbose,
+		signedBlock.Message.Slot,
+		signedBlock.Message.ProposerIndex,
+		blockRoot,
+		bodyRoot,
+		signedBlock.Message.ParentRoot,
+		signedBlock.Message.StateRoot,
+		signedBlock.Message.Body.Graffiti[:],
+		data.genesisTime,
+		data.slotDuration,
+		data.slotsPerEpoch)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Eth1 data.
+	if data.verbose {
+		tmp, err := outputBlockETH1Data(ctx, body.ETH1Data)
+		if err != nil {
+			return "", err
+		}
+		res.WriteString(tmp)
+	}
+
+	// Sync aggregate.
+	tmp, err = outputBlockSyncAggregate(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.SyncAggregate, phase0.Epoch(uint64(signedBlock.Message.Slot)/data.slotsPerEpoch))
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attestations.
+	tmp, err = outputElectraBlockAttestations(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.Attestations)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	// Attester slashings.
+	tmp, err = outputElectraBlockAttesterSlashings(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.AttesterSlashings)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	res.WriteString(fmt.Sprintf("Proposer slashings: %d\n", len(body.ProposerSlashings)))
+	// Add verbose proposer slashings.
+
+	// Voluntary exits.
+	tmp, err = outputBlockVoluntaryExits(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.VoluntaryExits)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputBlockBLSToExecutionChanges(ctx, data.eth2Client, data.verbose, signedBlock.Message.Body.BLSToExecutionChanges)
+	if err != nil {
+		return "", err
+	}
+	res.WriteString(tmp)
+
+	tmp, err = outputDenebBlockExecutionPayload(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)
 	if err != nil {
 		return "", err
 	}
@@ -791,7 +1006,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 := 0; i < 32; i++ {
+		for i := range 32 {
 			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
 		}
 		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
@@ -897,30 +1112,69 @@ func outputDenebBlockExecutionPayload(_ context.Context,
 	return res.String(), nil
 }
 
-func outputDenebBlobInfo(_ context.Context,
+func outputElectraBlockExecutionRequests(_ context.Context,
+	verbose bool,
+	executionRequests *electra.ExecutionRequests,
+) (
+	string,
+	error,
+) {
+	if executionRequests == nil {
+		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))
+		}
+	}
+
+	return res.String(), nil
+}
+
+func outputBlobInfo(_ 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{}
 
-	for i, blob := range blobs {
-		if i == 0 {
-			res.WriteString("Blobs\n")
+	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()))
 		}
-		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
@@ -953,7 +1207,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 := 0; i < 32; i++ {
+		for i := range 32 {
 			baseFeePerGasBEBytes[i] = payload.BaseFeePerGas[32-1-i]
 		}
 		baseFeePerGas := new(big.Int).SetBytes(baseFeePerGasBEBytes)
@@ -1016,7 +1270,7 @@ func bitlistToString(input bitfield.Bitlist) string {
 	bits := int(input.Len())
 
 	res := ""
-	for i := 0; i < bits; i++ {
+	for i := range bits {
 		if input.BitAt(uint64(i)) {
 			res = fmt.Sprintf("%s✓", res)
 		} else {
@@ -1033,7 +1287,7 @@ func bitvectorToString(input bitfield.Bitvector512) string {
 	bits := int(input.Len())
 
 	res := strings.Builder{}
-	for i := 0; i < bits; i++ {
+	for i := range bits {
 		if input.BitAt(uint64(i)) {
 			res.WriteString("✓")
 		} else {
@@ -1046,15 +1300,28 @@ func bitvectorToString(input bitfield.Bitvector512) string {
 	return res.String()
 }
 
-func attestingIndices(input bitfield.Bitlist, indices []phase0.ValidatorIndex) string {
+func attestingIndices(input bitfield.Bitlist,
+	committees map[phase0.CommitteeIndex][]phase0.ValidatorIndex,
+	includedCommittees []int,
+) string {
 	bits := int(input.Len())
-	res := ""
-	for i := 0; i < bits; i++ {
+
+	// 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 {
 		if input.BitAt(uint64(i)) {
-			res = fmt.Sprintf("%s%d ", res, indices[i])
+			// Work out the committee and offset given the index.
+			res.WriteString(fmt.Sprintf("%d ", validatorIndices[i]))
 		}
 	}
-	return strings.TrimSpace(res)
+
+	return strings.TrimSpace(res.String())
 }
 
 func blockGraffiti(_ context.Context, graffiti []byte) string {
@@ -1095,8 +1362,9 @@ func blockGraffiti(_ context.Context, graffiti []byte) string {
 		"GE": "go-ethereum",
 		"NM": "nethermind",
 		"RH": "reth",
+		"TR": "trin-execution",
 	}
-	executionRegex := regexp.MustCompile(`(BU|EG|EJ|GE|NM|RH)([0-9a-f]*)`)
+	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 {

cmd/block/info/process.go

@@ -31,6 +31,7 @@ import (
 	"github.com/attestantio/go-eth2-client/spec/bellatrix"
 	"github.com/attestantio/go-eth2-client/spec/capella"
 	"github.com/attestantio/go-eth2-client/spec/deneb"
+	"github.com/attestantio/go-eth2-client/spec/electra"
 	"github.com/attestantio/go-eth2-client/spec/phase0"
 	"github.com/pkg/errors"
 	standardchaintime "github.com/wealdtech/ethdo/services/chaintime/standard"
@@ -56,18 +57,10 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		eth2Client: data.eth2Client,
 	}
 
-	specResponse, err := results.eth2Client.(eth2client.SpecProvider).Spec(ctx, &api.SpecOpts{})
+	err := populateResults(ctx, results)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to connect to obtain configuration information")
+		return nil, err
 	}
-	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)
@@ -76,57 +69,33 @@ func process(ctx context.Context, data *dataIn) (*dataOut, error) {
 		}
 	}
 
-	blockResponse, err := results.eth2Client.(eth2client.SignedBeaconBlockProvider).SignedBeaconBlock(ctx, &api.SignedBeaconBlockOpts{
-		Block: data.blockID,
-	})
+	block, err := obtainBlock(ctx, data, results)
 	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 nil, err
 	}
-	block := blockResponse.Data
 	if data.quiet {
 		os.Exit(0)
 	}
 
 	switch block.Version {
 	case spec.DataVersionPhase0:
-		if err := outputPhase0Block(ctx, data.jsonOutput, block.Phase0); err != nil {
-			return nil, errors.Wrap(err, "failed to output block")
-		}
+		err = outputPhase0Block(ctx, data.jsonOutput, block.Phase0)
 	case spec.DataVersionAltair:
-		if err := outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair); err != nil {
-			return nil, errors.Wrap(err, "failed to output block")
-		}
+		err = outputAltairBlock(ctx, data.jsonOutput, data.sszOutput, block.Altair)
 	case spec.DataVersionBellatrix:
-		if err := outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix); err != nil {
-			return nil, errors.Wrap(err, "failed to output block")
-		}
+		err = outputBellatrixBlock(ctx, data.jsonOutput, data.sszOutput, block.Bellatrix)
 	case spec.DataVersionCapella:
-		if err := outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella); err != nil {
-			return nil, errors.Wrap(err, "failed to output block")
-		}
+		err = outputCapellaBlock(ctx, data.jsonOutput, data.sszOutput, block.Capella)
 	case spec.DataVersionDeneb:
-		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")
-		}
+		err = processDenebBlock(ctx, data, block)
+	case spec.DataVersionElectra:
+		err = processElectraBlock(ctx, data, 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
@@ -144,6 +113,97 @@ 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()
 
@@ -180,13 +240,25 @@ func headEventHandler(event *apiv1.Event) {
 	case spec.DataVersionCapella:
 		err = outputCapellaBlock(ctx, jsonOutput, sszOutput, block.Capella)
 	case spec.DataVersionDeneb:
-		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)
+		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
 		}
+		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
+		}
+		err = outputDenebBlock(context.Background(), jsonOutput, sszOutput, block.Deneb, blobSidecars)
 	default:
 		err = errors.New("unknown block version")
 	}
@@ -319,6 +391,35 @@ func outputDenebBlock(ctx context.Context,
 	return nil
 }
 
+func outputElectraBlock(ctx context.Context,
+	jsonOutput bool,
+	sszOutput bool,
+	signedBlock *electra.SignedBeaconBlock,
+	blobs []*deneb.BlobSidecar,
+) error {
+	switch {
+	case jsonOutput:
+		data, err := json.Marshal(signedBlock)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate JSON")
+		}
+		fmt.Printf("%s\n", string(data))
+	case sszOutput:
+		data, err := signedBlock.MarshalSSZ()
+		if err != nil {
+			return errors.Wrap(err, "failed to generate SSZ")
+		}
+		fmt.Printf("%x\n", data)
+	default:
+		data, err := outputElectraBlockText(ctx, results, signedBlock, blobs)
+		if err != nil {
+			return errors.Wrap(err, "failed to generate text")
+		}
+		fmt.Print(data)
+	}
+	return nil
+}
+
 func timeToBlockID(ctx context.Context, eth2Client eth2client.Service, input string) (string, error) {
 	var timestamp time.Time
 

cmd/chain/eth1votes/process.go

@@ -97,6 +97,9 @@ func (c *command) process(ctx context.Context) error {
 	case spec.DataVersionDeneb:
 		c.incumbent = state.Deneb.ETH1Data
 		c.eth1DataVotes = state.Deneb.ETH1DataVotes
+	case spec.DataVersionElectra:
+		c.incumbent = state.Electra.ETH1Data
+		c.eth1DataVotes = state.Electra.ETH1DataVotes
 	default:
 		return fmt.Errorf("unhandled beacon state version %v", state.Version)
 	}

cmd/chain/verify/signedcontributionandproof/process.go

@@ -221,7 +221,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 := uint64(0); i < c.item.Message.Contribution.AggregationBits.Len(); i++ {
+	for i := range c.item.Message.Contribution.AggregationBits.Len() {
 		if c.item.Message.Contribution.AggregationBits.BitAt(i) {
 			includedIndices = append(includedIndices, subCommittee[int(i)])
 		}

cmd/epoch.go

@@ -29,12 +29,12 @@ func init() {
 	RootCmd.AddCommand(epochCmd)
 }
 
-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 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 epochBindings(cmd *cobra.Command) {
-	if err := viper.BindPFlag("epoch", cmd.Flags().Lookup("epoch")); err != nil {
+	if err := viper.BindPFlag("validators", cmd.Flags().Lookup("validators")); err != nil {
 		panic(err)
 	}
 }

cmd/epoch/summary/command.go

@@ -36,9 +36,11 @@ type command struct {
 	allowInsecureConnections bool
 
 	// Operation.
-	epoch      string
-	stream     bool
-	jsonOutput bool
+	epoch         string
+	validatorsStr []string
+	validators    map[phase0.ValidatorIndex]struct{}
+	stream        bool
+	jsonOutput    bool
 
 	// Data access.
 	eth2Client                 eth2client.Service
@@ -58,45 +60,61 @@ type command struct {
 }
 
 type epochSummary struct {
-	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"`
+	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"`
 }
 
 type epochProposal struct {
-	Slot     phase0.Slot           `json:"slot"`
-	Proposer phase0.ValidatorIndex `json:"proposer"`
-	Block    bool                  `json:"block"`
+	ValidatorIndex phase0.ValidatorIndex `json:"validator_index"`
+	Slot           phase0.Slot           `json:"slot"`
+	Block          bool                  `json:"block"`
 }
 
 type epochSyncCommittee struct {
-	Index  phase0.ValidatorIndex `json:"index"`
-	Missed int                   `json:"missed"`
+	ValidatorIndex phase0.ValidatorIndex `json:"validator_index"`
+	Missed         int                   `json:"missed"`
+	MissedSlots    []phase0.Slot         `json:"missed_slots"`
 }
 
-type nonParticipatingValidator struct {
-	Validator phase0.ValidatorIndex `json:"validator_index"`
-	Slot      phase0.Slot           `json:"slot"`
-	Committee phase0.CommitteeIndex `json:"committee_index"`
+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"`
 }
 
 func newCommand(_ context.Context) (*command, error) {
 	c := &command{
-		quiet:       viper.GetBool("quiet"),
-		verbose:     viper.GetBool("verbose"),
-		debug:       viper.GetBool("debug"),
-		summary:     &epochSummary{},
+		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{}),
 		blocksCache: make(map[string]*spec.VersionedSignedBeaconBlock),
 	}
 

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.Proposer))
+			missedProposals = append(missedProposals, fmt.Sprintf("\n    Slot %d (validator %d)", proposal.Slot, proposal.ValidatorIndex))
 		} 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.Proposer))
+			builder.WriteString(fmt.Sprintf("%d", proposal.ValidatorIndex))
 			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.Index))
+				builder.WriteString(fmt.Sprintf("%d", syncCommittee.ValidatorIndex))
 				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,6 +43,14 @@ 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
 	}
@@ -52,6 +60,7 @@ func (c *command) process(ctx context.Context) error {
 	if err := c.processSyncCommitteeDuties(ctx); err != nil {
 		return err
 	}
+
 	return c.processBlobs(ctx)
 }
 
@@ -69,10 +78,20 @@ 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,
-			Proposer: duty.ValidatorIndex,
-			Block:    present,
+			Slot:           duty.Slot,
+			ValidatorIndex: duty.ValidatorIndex,
+			Block:          present,
 		})
 	}
 
@@ -80,14 +99,25 @@ 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: fmt.Sprintf("%d", c.chainTime.FirstSlotOfEpoch(c.summary.Epoch)),
+		State:   "head",
+		Indices: validatorIndices,
 	})
 	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
 		}
@@ -112,20 +142,45 @@ func (c *command) processAttesterDuties(ctx context.Context) error {
 		lastSlot = c.chainTime.CurrentSlot()
 	}
 
-	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)
+	participatingValidators, headCorrectValidators, headTimelyValidators, sourceTimelyValidators, targetCorrectValidators, targetTimelyValidators, participations, err := c.processSlots(ctx, firstSlot, lastSlot)
 	if err != nil {
 		return err
 	}
 
-	c.summary.NonParticipatingValidators = make([]*nonParticipatingValidator, 0, len(activeValidators)-len(votes))
+	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))
 	for activeValidatorIndex := range activeValidators {
-		if _, exists := votes[activeValidatorIndex]; !exists {
+		if _, exists := participatingValidators[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 {
@@ -140,18 +195,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]*nonParticipatingValidator,
+	map[phase0.ValidatorIndex]struct{},
+	map[phase0.ValidatorIndex]struct{},
+	map[phase0.ValidatorIndex]struct{},
+	map[phase0.ValidatorIndex]struct{},
+	map[phase0.ValidatorIndex]struct{},
+	map[phase0.ValidatorIndex]*attestingValidator,
 	error,
 ) {
 	votes := make(map[phase0.ValidatorIndex]struct{})
@@ -161,7 +216,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]*nonParticipatingValidator)
+	participations := make(map[phase0.ValidatorIndex]*attestingValidator)
 
 	// Need a cache of beacon block headers to reduce lookup times.
 	headersCache := util.NewBeaconBlockHeaderCache(c.beaconBlockHeadersProvider)
@@ -169,7 +224,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 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
+			return nil, nil, nil, nil, nil, 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.
@@ -177,81 +232,126 @@ func (c *command) processSlots(ctx context.Context,
 		}
 		slot, err := block.Slot()
 		if err != nil {
-			return 0, 0, 0, 0, 0, 0, nil, nil, err
+			return nil, nil, nil, nil, nil, nil, nil, err
 		}
 		attestations, err := block.Attestations()
 		if err != nil {
-			return 0, 0, 0, 0, 0, 0, nil, nil, err
+			return nil, nil, nil, nil, nil, nil, nil, err
 		}
 		for _, attestation := range attestations {
-			if attestation.Data.Slot < c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) || attestation.Data.Slot >= c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) {
+			attestationData, err := attestation.Data()
+			if err != nil {
+				return nil, nil, nil, nil, nil, nil, nil, errors.Wrap(err, "failed to obtain attestation data")
+			}
+			if attestationData.Slot < c.chainTime.FirstSlotOfEpoch(c.summary.Epoch) || attestationData.Slot >= c.chainTime.FirstSlotOfEpoch(c.summary.Epoch+1) {
 				// Outside of this epoch's range.
 				continue
 			}
-			slotCommittees, exists := allCommittees[attestation.Data.Slot]
+			slotCommittees, exists := allCommittees[attestationData.Slot]
 			if !exists {
 				response, err := c.beaconCommitteesProvider.BeaconCommittees(ctx, &api.BeaconCommitteesOpts{
-					State: fmt.Sprintf("%d", attestation.Data.Slot),
+					State: fmt.Sprintf("%d", attestationData.Slot),
 				})
 				if err != nil {
-					return 0, 0, 0, 0, 0, 0, nil, nil, errors.Wrap(err, fmt.Sprintf("failed to obtain committees for slot %d", attestation.Data.Slot))
+					return nil, nil, nil, nil, nil, 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 {
-						participations[index] = &nonParticipatingValidator{
-							Validator: index,
-							Slot:      beaconCommittee.Slot,
-							Committee: beaconCommittee.Index,
+						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,
+							}
 						}
 					}
 				}
-				slotCommittees = allCommittees[attestation.Data.Slot]
+				slotCommittees = allCommittees[attestationData.Slot]
 			}
-			committee := slotCommittees[attestation.Data.Index]
+			committee := slotCommittees[attestationData.Index]
 
-			inclusionDistance := slot - attestation.Data.Slot
+			inclusionDistance := slot - attestationData.Slot
+
+			head, err := util.AttestationHead(ctx, headersCache, attestation)
+			if err != nil {
+				return nil, nil, nil, nil, nil, nil, nil, err
+			}
 			headCorrect, err := util.AttestationHeadCorrect(ctx, headersCache, attestation)
 			if err != nil {
-				return 0, 0, 0, 0, 0, 0, nil, nil, err
+				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 0, 0, 0, 0, 0, 0, nil, nil, err
+				return nil, nil, nil, nil, nil, nil, nil, err
 			}
 
-			for i := uint64(0); i < attestation.AggregationBits.Len(); i++ {
-				if attestation.AggregationBits.BitAt(i) {
-					votes[committee[int(i)]] = struct{}{}
-					if _, exists := headCorrects[committee[int(i)]]; !exists && headCorrect {
-						headCorrects[committee[int(i)]] = struct{}{}
+			aggregationBits, err := attestation.AggregationBits()
+			if err != nil {
+				return nil, nil, nil, nil, nil, nil, nil, errors.Wrap(err, "failed to obtain aggregation bits")
+			}
+			for i := range aggregationBits.Len() {
+				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
+						}
 					}
-					if _, exists := headTimelys[committee[int(i)]]; !exists && headCorrect && inclusionDistance == 1 {
-						headTimelys[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 := sourceTimelys[committee[int(i)]]; !exists && inclusionDistance <= 5 {
-						sourceTimelys[committee[int(i)]] = struct{}{}
+
+					votes[validatorIndex] = struct{}{}
+					if _, exists := headCorrects[validatorIndex]; !exists && headCorrect {
+						headCorrects[validatorIndex] = struct{}{}
 					}
-					if _, exists := targetCorrects[committee[int(i)]]; !exists && targetCorrect {
-						targetCorrects[committee[int(i)]] = struct{}{}
+					if _, exists := headTimelys[validatorIndex]; !exists && headCorrect && inclusionDistance == 1 {
+						headTimelys[validatorIndex] = struct{}{}
 					}
-					if _, exists := targetTimelys[committee[int(i)]]; !exists && targetCorrect && inclusionDistance <= 32 {
-						targetTimelys[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{}{}
 					}
 				}
 			}
 		}
 	}
-	return len(votes),
-		len(headCorrects),
-		len(headTimelys),
-		len(sourceTimelys),
-		len(targetCorrects),
-		len(targetTimelys),
-		votes,
+
+	return votes,
+		headCorrects,
+		headTimelys,
+		sourceTimelys,
+		targetCorrects,
+		targetTimelys,
 		participations,
 		nil
 }
@@ -273,7 +373,18 @@ 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
 	}
@@ -296,9 +407,15 @@ 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 := uint64(0); i < aggregate.SyncCommitteeBits.Len(); i++ {
+		for i := range aggregate.SyncCommitteeBits.Len() {
+			validatorIndex := committee.Validators[int(i)]
+			if _, exists := c.validators[validatorIndex]; !exists {
+				// Not one of ours.
+				continue
+			}
 			if !aggregate.SyncCommitteeBits.BitAt(i) {
-				missed[committee.Validators[int(i)]]++
+				missed[validatorIndex]++
+				missedSlots[validatorIndex] = append(missedSlots[validatorIndex], slot)
 			}
 		}
 	}
@@ -307,8 +424,9 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 	for index, count := range missed {
 		if count > 0 {
 			c.summary.SyncCommittee = append(c.summary.SyncCommittee, &epochSyncCommittee{
-				Index:  index,
-				Missed: count,
+				ValidatorIndex: index,
+				Missed:         count,
+				MissedSlots:    missedSlots[index],
 			})
 		}
 	}
@@ -320,7 +438,7 @@ func (c *command) processSyncCommitteeDuties(ctx context.Context) error {
 			return missedDiff > 0
 		}
 		// Then order by validator index.
-		return c.summary.SyncCommittee[i].Index < c.summary.SyncCommittee[j].Index
+		return c.summary.SyncCommittee[i].ValidatorIndex < c.summary.SyncCommittee[j].ValidatorIndex
 	})
 
 	return nil
@@ -378,10 +496,10 @@ func (c *command) setup(ctx context.Context) error {
 }
 
 func (c *command) processBlobs(ctx context.Context) error {
-	for slot := c.summary.FirstSlot; slot <= c.summary.LastSlot; slot++ {
-		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", slot))
+	for _, proposal := range c.summary.Proposals {
+		block, err := c.fetchBlock(ctx, fmt.Sprintf("%d", proposal.Slot))
 		if err != nil {
-			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", slot))
+			return errors.Wrap(err, fmt.Sprintf("failed to obtain block for slot %d", proposal.Slot))
 		}
 		if block == nil {
 			continue
@@ -391,6 +509,8 @@ func (c *command) processBlobs(ctx context.Context) error {
 			// No blobs in these forks.
 		case spec.DataVersionDeneb:
 			c.summary.Blobs += len(block.Deneb.Message.Body.BlobKZGCommitments)
+		case spec.DataVersionElectra:
+			c.summary.Blobs += len(block.Electra.Message.Body.BlobKZGCommitments)
 		default:
 			return fmt.Errorf("unhandled block version %v", block.Version)
 		}

cmd/epochsummary.go

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

cmd/signaturesign.go

@@ -19,6 +19,7 @@ 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"
@@ -59,6 +60,8 @@ 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,6 +19,7 @@ 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"
@@ -71,6 +72,10 @@ 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/synccommittee/inclusion/process.go

@@ -120,6 +120,13 @@ func (c *command) process(ctx context.Context) error {
 				} else {
 					c.inclusions = append(c.inclusions, 2)
 				}
+			case spec.DataVersionElectra:
+				aggregate = block.Electra.Message.Body.SyncAggregate
+				if aggregate.SyncCommitteeBits.BitAt(c.committeeIndex) {
+					c.inclusions = append(c.inclusions, 1)
+				} else {
+					c.inclusions = append(c.inclusions, 2)
+				}
 			default:
 				return fmt.Errorf("unhandled block version %v", block.Version)
 			}

cmd/validator/depositdata/input.go

@@ -16,6 +16,8 @@ package depositdata
 import (
 	"context"
 	"encoding/hex"
+	"fmt"
+	"os"
 	"strings"
 	"time"
 
@@ -29,6 +31,7 @@ import (
 )
 
 type dataIn struct {
+	debug             bool
 	format            string
 	timeout           time.Duration
 	withdrawalAccount string
@@ -39,13 +42,16 @@ 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") == "" {
@@ -97,6 +103,9 @@ 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")
@@ -106,10 +115,6 @@ 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 {
@@ -117,6 +122,12 @@ 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,17 +190,6 @@ 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,6 +24,7 @@ import (
 type dataOut struct {
 	format                string
 	account               string
+	path                  string
 	validatorPubKey       *spec.BLSPubKey
 	withdrawalCredentials []byte
 	amount                spec.Gwei
@@ -170,7 +171,7 @@ func validatorDepositDataOutputJSON(datum *dataOut) (string, error) {
 	if datum.depositDataRoot == nil {
 		return "", errors.New("deposit data root required")
 	}
-	if datum.depositDataRoot == nil {
+	if datum.depositMessageRoot == nil {
 		return "", errors.New("deposit message root required")
 	}
 	if datum.forkVersion == nil {

cmd/validator/depositdata/process.go

@@ -17,6 +17,8 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"sort"
+	"strconv"
 	"strings"
 
 	spec "github.com/attestantio/go-eth2-client/spec/phase0"
@@ -40,6 +42,21 @@ 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 {
@@ -80,7 +97,7 @@ func process(data *dataIn) ([]*dataOut, error) {
 		copy(depositDataRoot[:], root[:])
 
 		validatorWallet := validatorAccount.(e2wtypes.AccountWalletProvider).Wallet()
-		results = append(results, &dataOut{
+		result := &dataOut{
 			format:                data.format,
 			account:               fmt.Sprintf("%s/%s", validatorWallet.Name(), validatorAccount.Name()),
 			validatorPubKey:       &pubKey,
@@ -90,8 +107,53 @@ 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
 }
 
@@ -145,7 +207,11 @@ 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.
-		withdrawalCredentials[0] = byte(1) // ETH1_ADDRESS_WITHDRAWAL_PREFIX
+		if data.compounding {
+			withdrawalCredentials[0] = byte(2) // COMPOUNDING_WITHDRAWAL_PREFIX
+		} else {
+			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 "", errors.Join(errors.New("failed to process"), err)
+			return "", err
 		}
 	}
 

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 := 0; i < 1024; i++ {
+	for i := range 1024 {
 		path := fmt.Sprintf("m/12381/3600/%d/0", i)
 		if debug {
 			fmt.Printf("Checking path %s\n", path)

cmd/validator/summary/process.go

@@ -243,16 +243,24 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 		return err
 	}
 	for _, attestation := range attestations {
-		if _, exists := dutiesBySlot[attestation.Data.Slot]; !exists {
+		attestationData, err := attestation.Data()
+		if err != nil {
+			return errors.Wrap(err, "failed to obtain attestation data")
+		}
+		if _, exists := dutiesBySlot[attestationData.Slot]; !exists {
 			// We do not have any attestations for this slot.
 			continue
 		}
-		if _, exists := dutiesBySlot[attestation.Data.Slot][attestation.Data.Index]; !exists {
+		if _, exists := dutiesBySlot[attestationData.Slot][attestationData.Index]; !exists {
 			// We do not have any attestations for this committee.
 			continue
 		}
-		for _, duty := range dutiesBySlot[attestation.Data.Slot][attestation.Data.Index] {
-			if attestation.AggregationBits.BitAt(duty.ValidatorCommitteeIndex) {
+		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 {
 					// Duplicate; ignore.
@@ -261,13 +269,13 @@ func (c *command) processAttesterDutiesSlot(ctx context.Context,
 				votes[duty.ValidatorIndex] = struct{}{}
 
 				// Update the metrics for the attestation.
-				index := int(attestation.Data.Slot - c.chainTime.FirstSlotOfEpoch(c.summary.Epoch))
+				index := int(attestationData.Slot - c.chainTime.FirstSlotOfEpoch(c.summary.Epoch))
 				c.summary.Slots[index].Attestations.Included++
 				inclusionDelay := slot - duty.Slot
 
 				fault := &validatorFault{
 					Validator:         duty.ValidatorIndex,
-					AttestationData:   attestation.Data,
+					AttestationData:   attestationData,
 					InclusionDistance: int(inclusionDelay),
 				}
 

cmd/validatordepositdata.go

@@ -1,4 +1,4 @@
-// Copyright © 2019 - 2022 Weald Technology Trading
+// Copyright © 2019 - 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,6 +57,7 @@ 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) {
@@ -84,4 +85,7 @@ 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 - 2022 Weald Technology Trading
+// 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
@@ -67,9 +67,17 @@ 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"), "head")
+		validator, err := util.ParseValidator(ctx, eth2Client.(eth2client.ValidatorsProvider), viper.GetString("validator"), viper.GetString("blockid"))
 		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")
@@ -185,7 +193,8 @@ func graphData(network string, validatorPubKey []byte) (uint64, spec.Gwei, error
 
 func init() {
 	validatorCmd.AddCommand(validatorInfoCmd)
-	validatorInfoCmd.Flags().String("validator", "", "Public key for which to obtain status")
+	validatorInfoCmd.Flags().String("validator", "", "ID of the validator")
+	validatorInfoCmd.Flags().String("blockid", "head", "the block at which to fetch the information")
 	validatorFlags(validatorInfoCmd)
 }
 
@@ -193,4 +202,7 @@ 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 - 2024 Weald Technology Trading.
+// Copyright © 2019 - 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
@@ -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.35.5)"
+var ReleaseVersion = "local build (latest release 1.37.0)"
 
 // versionCmd represents the version command.
 var versionCmd = &cobra.Command{

cmd/wallet/create/process.go

@@ -1,4 +1,4 @@
-// Copyright © 2019, 2020 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,6 +24,7 @@ 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"
 )
@@ -40,6 +41,8 @@ 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")
 	}
@@ -132,3 +135,16 @@ 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, 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")
+- `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")
 - `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.
 
@@ -659,6 +659,7 @@ $ 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
@@ -682,6 +683,7 @@ $ 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,16 +1,16 @@
 module github.com/wealdtech/ethdo
 
-go 1.21
+go 1.22.7
 
-toolchain go1.21.6
+toolchain go1.23.2
 
 require (
-	github.com/attestantio/go-eth2-client v0.21.9
-	github.com/ferranbt/fastssz v0.1.3
+	github.com/attestantio/go-eth2-client v0.24.0
+	github.com/ferranbt/fastssz v0.1.4
 	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.35.0
+	github.com/herumi/bls-eth-go-binary v1.36.1
 	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
@@ -21,59 +21,59 @@ require (
 	github.com/spf13/cobra v1.8.1
 	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.19.0
-	github.com/stretchr/testify v1.9.0
+	github.com/stretchr/testify v1.10.0
 	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.16.0
-	github.com/wealdtech/go-eth2-wallet-dirk v1.4.9
+	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-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.11.0
+	github.com/wealdtech/go-eth2-wallet-types/v2 v2.12.0
 	github.com/wealdtech/go-string2eth v1.2.1
-	golang.org/x/text v0.16.0
+	golang.org/x/text v0.21.0
 )
 
 require (
-	github.com/aws/aws-sdk-go v1.55.3 // indirect
+	github.com/aws/aws-sdk-go v1.55.5 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
-	github.com/dgraph-io/ristretto v0.1.1 // indirect
+	github.com/dgraph-io/ristretto v0.2.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/fatih/color v1.17.0 // indirect
-	github.com/fsnotify/fsnotify v1.7.0 // 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/go-logr/stdr v1.2.2 // indirect
-	github.com/goccy/go-yaml v1.12.0 // indirect
-	github.com/golang/glog v1.2.2 // indirect
+	github.com/goccy/go-yaml v1.15.12 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
-	github.com/holiman/uint256 v1.3.1 // indirect
+	github.com/holiman/uint256 v1.3.2 // 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.1 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.8 // indirect
-	github.com/magiconair/properties v1.8.7 // indirect
-	github.com/mattn/go-colorable v0.1.13 // 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/mattn/go-isatty v0.0.20 // indirect
 	github.com/minio/highwayhash v1.0.3 // 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.2 // indirect
-	github.com/pk910/dynamic-ssz v0.0.4 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
+	github.com/pk910/dynamic-ssz v0.0.5 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
-	github.com/prometheus/client_golang v1.19.1 // indirect
+	github.com/prometheus/client_golang v1.20.5 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
-	github.com/prometheus/common v0.55.0 // indirect
+	github.com/prometheus/common v0.61.0 // indirect
 	github.com/prometheus/procfs v0.15.1 // indirect
 	github.com/protolambda/zssz v0.1.5 // indirect
 	github.com/r3labs/sse/v2 v2.10.0 // indirect
@@ -82,25 +82,25 @@ require (
 	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.6.0 // indirect
+	github.com/spf13/cast v1.7.1 // 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/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 // indirect
-	go.opentelemetry.io/otel v1.28.0 // indirect
-	go.opentelemetry.io/otel/metric v1.28.0 // indirect
-	go.opentelemetry.io/otel/trace v1.28.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.uber.org/multierr v1.11.0 // indirect
-	golang.org/x/crypto v0.25.0 // indirect
-	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect
-	golang.org/x/net v0.27.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/sys v0.22.0 // indirect
-	golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20240725223205-93522f1f2a9f // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20240725223205-93522f1f2a9f // indirect
-	google.golang.org/grpc v1.65.0 // indirect
-	google.golang.org/protobuf v1.34.2 // 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
 	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,10 +1,9 @@
-github.com/attestantio/go-eth2-client v0.21.9 h1:NX5GmbAyx2ZtKEsKk6JsxPcaGR1E0vugMEb4kVsY0XU=
-github.com/attestantio/go-eth2-client v0.21.9/go.mod h1:d7ZPNrMX8jLfIgML5u7QZxFo2AukLM+5m08iMaLdqb8=
-github.com/aws/aws-sdk-go v1.55.3 h1:0B5hOX+mIx7I5XPOrjrHlKSDQV/+ypFZpIHOx5LOk3E=
-github.com/aws/aws-sdk-go v1.55.3/go.mod h1:eRwEWoyTWFMVYVQzKMNHWP5/RV4xIUGMQfXQHfHkpNU=
+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/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.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 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/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
@@ -13,40 +12,32 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSs
 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.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/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/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/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
-github.com/fatih/color v1.17.0/go.mod h1:YZ7TlrGPkiz6ku9fK3TLD/pl3CpsiFyu8N92HLgmosI=
-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/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/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.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
-github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+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/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/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-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.12.0 h1:/1WHjnMsI1dlIBQutrvSMGZRQufVO3asrHfTwfACoPM=
-github.com/goccy/go-yaml v1.12.0/go.mod h1:wKnAMd44+9JAAnGQpWVEgBzGt3YuTaQ4uXoHvE4m7WU=
+github.com/goccy/go-yaml v1.15.12 h1:KLUSwfrUcTU6F8sAkf23OIPYC6aFVMNFSu4btROEm6w=
+github.com/goccy/go-yaml v1.15.12/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
 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.2 h1:1+mZ9upx1Dh6FmUTFR1naJ77miKiXgALjWOZ3NVFPmY=
-github.com/golang/glog v1.2.2/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=
 github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
@@ -57,10 +48,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.35.0 h1:4CgrKurBK4g0ZMKBdHq5CwK9slYe7Ei+HF+/n6RSkOI=
-github.com/herumi/bls-eth-go-binary v1.35.0/go.mod h1:luAnRm3OsMQeokhGzpYmc0ZKwawY7o87PUEP11Z7r7U=
-github.com/holiman/uint256 v1.3.1 h1:JfTzmih28bittyHM8z360dCjIA9dbPIBlcTI6lmctQs=
-github.com/holiman/uint256 v1.3.1/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E=
+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/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=
@@ -69,24 +60,25 @@ 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.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
-github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+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/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/cpuid/v2 v2.2.8 h1:+StwCXwm9PdpiEkPyzBXIy+M9KUb4ODm0Zarf1kS5BM=
-github.com/klauspost/cpuid/v2 v2.2.8/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+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/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/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.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+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/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.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=
@@ -103,21 +95,21 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq
 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.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
-github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
-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/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/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.19.1 h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=
-github.com/prometheus/client_golang v1.19.1/go.mod h1:mP78NwGzrVks5S2H6ab8+ZZGJLZUq1hoULYBAYBw1Ho=
+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.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
-github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
+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/protolambda/zssz v0.1.5 h1:7fjJjissZIIaa2QcvmhS/pZISMX21zVITt49sW1ouek=
@@ -126,10 +118,12 @@ github.com/prysmaticlabs/go-bitfield v0.0.0-20240618144021-706c95b2dd15 h1:lC8ki
 github.com/prysmaticlabs/go-bitfield v0.0.0-20240618144021-706c95b2dd15/go.mod h1:8svFBIKKu31YriBG/pNizo9N0Jr9i5PQ+dFkxWg3x5k=
 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.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
-github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
+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/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=
@@ -146,8 +140,8 @@ github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9yS
 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.6.0 h1:GEiTHELF+vaR5dhz3VqZfFSzZjYbgeKDpBxQVS4GYJ0=
-github.com/spf13/cast v1.6.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
+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/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
@@ -155,23 +149,15 @@ github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An
 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/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/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 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.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/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+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/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=
@@ -182,10 +168,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.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.9 h1:lwIGIRaYuMqa8F/qdNvLyUx8aO8AunECoeyp6MoCT3M=
-github.com/wealdtech/go-eth2-wallet-dirk v1.4.9/go.mod h1:AAMtGzKPvLYZn6YBcDRHKHL6dO2ZHAFeVAW1wAnQI1U=
+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-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=
@@ -194,6 +180,8 @@ 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=
@@ -202,57 +190,59 @@ 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.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-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-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/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0 h1:9G6E0TXzGFVfTnawRzrPl83iHOAV7L8NJiR8RSGYV1g=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.53.0/go.mod h1:azvtTADFQJA8mX80jIH/akaE7h+dbm/sVuaHqN13w74=
-go.opentelemetry.io/otel v1.28.0 h1:/SqNcYk+idO0CxKEUOtKQClMK/MimZihKYMruSMViUo=
-go.opentelemetry.io/otel v1.28.0/go.mod h1:q68ijF8Fc8CnMHKyzqL6akLO46ePnjkgfIMIjUIX9z4=
-go.opentelemetry.io/otel/metric v1.28.0 h1:f0HGvSl1KRAU1DLgLGFjrwVyismPlnuU6JD6bOeuA5Q=
-go.opentelemetry.io/otel/metric v1.28.0/go.mod h1:Fb1eVBFZmLVTMb6PPohq3TO9IIhUisDsbJoL/+uQW4s=
-go.opentelemetry.io/otel/trace v1.28.0 h1:GhQ9cUuQGmNDd5BTCP2dAvv75RdMxEfTmYejp+lkx9g=
-go.opentelemetry.io/otel/trace v1.28.0/go.mod h1:jPyXzNPg6da9+38HEwElrQiHlVMTnVfM3/yv2OlIHaI=
+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.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.25.0 h1:ypSNr+bnYL2YhwoMt2zPxHFmbAN1KZs/njMG3hxUp30=
-golang.org/x/crypto v0.25.0/go.mod h1:T+wALwcMOSE0kXgUAnPAHqTLW+XHgcELELW8VaDgm/M=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8=
-golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY=
+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/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.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+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/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-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.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.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/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9 h1:LLhsEBxRTBLuKlQxFBYUOU8xyFgXv6cOTp2HASDlsDk=
-golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90=
-google.golang.org/genproto/googleapis/api v0.0.0-20240725223205-93522f1f2a9f h1:b1Ln/PG8orm0SsBbHZWke8dDp2lrCD4jSmfglFpTZbk=
-google.golang.org/genproto/googleapis/api v0.0.0-20240725223205-93522f1f2a9f/go.mod h1:AHT0dDg3SoMOgZGnZk29b5xTbPHMoEC8qthmBLJCpys=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240725223205-93522f1f2a9f h1:RARaIm8pxYuxyNPbBQf5igT7XdOyCNtat1qAT2ZxjU4=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20240725223205-93522f1f2a9f/go.mod h1:Ue6ibwXGpU+dqIcODieyLOcgj7z8+IcskoNIgZxtrFY=
-google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc=
-google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ=
-google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
-google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
+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=
 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,4 +62,6 @@ 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,6 +35,7 @@ type Service struct {
 	bellatrixForkEpoch           phase0.Epoch
 	capellaForkEpoch             phase0.Epoch
 	denebForkEpoch               phase0.Epoch
+	electraForkEpoch             phase0.Epoch
 }
 
 // module-wide log.
@@ -116,6 +117,13 @@ 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,
@@ -125,6 +133,7 @@ func New(ctx context.Context, params ...Parameter) (*Service, error) {
 		bellatrixForkEpoch:           bellatrixForkEpoch,
 		capellaForkEpoch:             capellaForkEpoch,
 		denebForkEpoch:               denebForkEpoch,
+		electraForkEpoch:             electraForkEpoch,
 	}
 
 	return s, nil
@@ -341,3 +350,32 @@ 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,22 +18,41 @@ 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) {
-	genesisTime := time.Now()
-	slotDuration := 12 * time.Second
-	slotsPerEpoch := uint64(32)
-	epochsPerSyncCommitteePeriod := uint64(256)
+	ctx := context.Background()
 
-	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
-	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
+	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
+	}
 
 	tests := []struct {
 		name   string
@@ -44,7 +63,7 @@ func TestService(t *testing.T) {
 			name: "GenesisProviderMissing",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithSpecProvider(mockSpecProvider),
+				standard.WithSpecProvider(mockClient),
 			},
 			err: "problem with parameters: no genesis provider specified",
 		},
@@ -52,7 +71,7 @@ func TestService(t *testing.T) {
 			name: "SpecProviderMissing",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisProvider(mockGenesisProvider),
+				standard.WithGenesisProvider(mockClient),
 			},
 			err: "problem with parameters: no spec provider specified",
 		},
@@ -60,8 +79,8 @@ func TestService(t *testing.T) {
 			name: "Good",
 			params: []standard.Parameter{
 				standard.WithLogLevel(zerolog.Disabled),
-				standard.WithGenesisProvider(mockGenesisProvider),
-				standard.WithSpecProvider(mockSpecProvider),
+				standard.WithGenesisProvider(mockClient),
+				standard.WithSpecProvider(mockClient),
 			},
 		},
 	}
@@ -80,7 +99,14 @@ 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) {
-	slotDuration := 12 * time.Second
+	ctx := context.Background()
+
+	mockClient, err := mock.New(ctx)
+	if err != nil {
+		return nil, 0, 0, 0, nil, err
+	}
+
+	secondsPerSlot := time.Second * 12
 	slotsPerEpoch := uint64(32)
 	epochsPerSyncCommitteePeriod := uint64(256)
 	forkSchedule := []*phase0.Fork{
@@ -96,13 +122,36 @@ func createService(genesisTime time.Time) (chaintime.Service, time.Duration, uin
 		},
 	}
 
-	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
-	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
-	s, err := standard.New(context.Background(),
-		standard.WithGenesisProvider(mockGenesisProvider),
-		standard.WithSpecProvider(mockSpecProvider),
+	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),
 	)
-	return s, slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod, forkSchedule, err
+	return s, secondsPerSlot, 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 := 0; i < limit; i++ {
+	for i := range limit {
 		basis = 1
-		for j := 0; j < limit; j++ {
+		for j := range limit {
 			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 := 0; i < parts; i++ {
+		for i := range parts {
 			x := uint8(xCoordinates[i]) + 1
 			y := p.evaluate(x)
 			out[i][idx] = y

testing/mock/eth2client.go

@@ -1,163 +0,0 @@
-// 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,3 +1,4 @@
+// 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
@@ -56,6 +57,12 @@ 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 Weald Technology Trading
+// 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
@@ -75,6 +75,18 @@ 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,19 +17,60 @@ 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 *phase0.Attestation,
+	attestation *spec.VersionedAttestation,
 ) (
 	bool,
 	error,
 ) {
-	slot := attestation.Data.Slot
+	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)
 		if err != nil {
@@ -45,7 +86,44 @@ func AttestationHeadCorrect(ctx context.Context,
 			slot--
 			continue
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.BeaconBlockRoot[:]), nil
+
+		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
 	}
 }
 
@@ -53,13 +131,18 @@ func AttestationHeadCorrect(ctx context.Context,
 func AttestationTargetCorrect(ctx context.Context,
 	headersCache *BeaconBlockHeaderCache,
 	chainTime chaintime.Service,
-	attestation *phase0.Attestation,
+	attestation *spec.VersionedAttestation,
 ) (
 	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(attestation.Data.Target.Epoch)
+	slot := chainTime.FirstSlotOfEpoch(attestationData.Target.Epoch)
 	for {
 		header, err := headersCache.Fetch(ctx, slot)
 		if err != nil {
@@ -75,6 +158,7 @@ func AttestationTargetCorrect(ctx context.Context,
 			slot--
 			continue
 		}
-		return bytes.Equal(header.Root[:], attestation.Data.Target.Root[:]), nil
+
+		return bytes.Equal(header.Root[:], attestationData.Target.Root[:]), nil
 	}
 }

util/epoch_test.go

@@ -18,28 +18,44 @@ 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)
-	slotDuration := 12 * time.Second
-	slotsPerEpoch := uint64(32)
-	epochsPerSyncCommitteePeriod := uint64(256)
-	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
-	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerEpoch, epochsPerSyncCommitteePeriod)
+	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
+	}
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithLogLevel(zerolog.Disabled),
-		standardchaintime.WithGenesisProvider(mockGenesisProvider),
-		standardchaintime.WithSpecProvider(mockSpecProvider),
+		standardchaintime.WithGenesisProvider(mockClient),
+		standardchaintime.WithSpecProvider(mockClient),
 	)
 	require.NoError(t, err)
 

util/slot_test.go

@@ -18,28 +18,44 @@ 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)
-	slotDuration := 12 * time.Second
-	slotsPerSlot := uint64(32)
-	epochsPerSyncCommitteePeriod := uint64(256)
-	mockGenesisProvider := mock.NewGenesisProvider(genesisTime)
-	mockSpecProvider := mock.NewSpecProvider(slotDuration, slotsPerSlot, epochsPerSyncCommitteePeriod)
+	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
+	}
 	chainTime, err := standardchaintime.New(context.Background(),
 		standardchaintime.WithLogLevel(zerolog.Disabled),
-		standardchaintime.WithGenesisProvider(mockGenesisProvider),
-		standardchaintime.WithSpecProvider(mockSpecProvider),
+		standardchaintime.WithGenesisProvider(mockClient),
+		standardchaintime.WithSpecProvider(mockClient),
 	)
 	require.NoError(t, err)