Preston's Review

* Remove EnableEIP4881 flag

* Gaz

* Fix missing error handler

* Remove old tree and fix tests

* Gaz

* Fix build import

* Replace depositcache

* Add pendingDeposit tests

* Nishant's fix

* Fix unsafe uint64 to int

* Fix other unsafe uint64 to int

* Remove: RemovePendingDeposit

* Deprecate and remove DisableEIP4881 flag

* Check: index not greater than deposit count

* Move index check

.buildkite-bazelrc

@@ -12,7 +12,8 @@
 build:remote-cache --remote_download_minimal
 build:remote-cache --remote_build_event_upload=minimal
 build:remote-cache --remote_cache=grpc://bazel-remote-cache:9092
-build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
+# Does not work with rules_oci. See https://github.com/bazel-contrib/rules_oci/issues/292
+#build:remote-cache --experimental_remote_downloader=grpc://bazel-remote-cache:9092
 build:remote-cache --remote_local_fallback
 build:remote-cache --experimental_remote_cache_async
 build:remote-cache --experimental_remote_merkle_tree_cache

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.4.0"
+consensus_spec_version = "v1.5.0-alpha.0"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "c282c0f86f23f3d2e0f71f5975769a4077e62a7e3c7382a16bd26a7e589811a0",
+    sha256 = "33c5547772b6d8d6f041dff7e7d26b0358c2392daed34394a3aa81147812a81c",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "4649c35aa3b8eb0cfdc81bee7c05649f90ef36bede5b0513e1f2e8baf37d6033",
+    sha256 = "06f286199cf2fedd4700487fb8feb0904e0ae18daaa4b3f70ea430ca9c388167",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "c5a03f724f757456ffaabd2a899992a71d2baf45ee4db65ca3518f2b7ee928c8",
+    sha256 = "5f2a4452b323075eba6bf950003f7d91fd04ebcbde5bd087beafb5d6f6325ad4",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "cd1c9d97baccbdde1d2454a7dceb8c6c61192a3b581eee12ffc94969f2db8453",
+    sha256 = "fd7e83e8cbeb3e297f2aeb93776305f7d606272c97834d8d9be673984501ed36",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/beacon/health.go

@@ -36,19 +36,19 @@ func (n *NodeHealthTracker) IsHealthy() bool {
 }
 
 func (n *NodeHealthTracker) CheckHealth(ctx context.Context) bool {
-	n.Lock()
-	defer n.Unlock()
-
+	n.RLock()
 	newStatus := n.node.IsHealthy(ctx)
 	if n.isHealthy == nil {
 		n.isHealthy = &newStatus
 	}
-
 	isStatusChanged := newStatus != *n.isHealthy
+	n.RUnlock()
+
 	if isStatusChanged {
-		// Update the health status
+		n.Lock()
+		// Double-check the condition to ensure it hasn't changed since the first check.
 		n.isHealthy = &newStatus
-		// Send the new status to the health channel
+		n.Unlock() // It's better to unlock as soon as the protected section is over.
 		n.healthChan <- newStatus
 	}
 	return newStatus

api/client/beacon/health_test.go

@@ -99,9 +99,9 @@ func TestNodeHealth_Concurrency(t *testing.T) {
 	for i := 0; i < numGoroutines; i++ {
 		go func() {
 			defer wg.Done()
-			client.EXPECT().IsHealthy(gomock.Any()).Return(false).Times(1)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(false)
 			n.CheckHealth(context.Background())
-			client.EXPECT().IsHealthy(gomock.Any()).Return(true).Times(1)
+			client.EXPECT().IsHealthy(gomock.Any()).Return(true)
 			n.CheckHealth(context.Background())
 		}()
 	}

api/constants.go

@@ -4,6 +4,6 @@ const (
 	WebUrlPrefix        = "/v2/validator/"
 	WebApiUrlPrefix     = "/api/v2/validator/"
 	KeymanagerApiPrefix = "/eth/v1"
-	SystemLogsPrefix    = "health/logs"
-	AuthTokenFileName   = "auth-token"
+
+	AuthTokenFileName = "auth-token"
 )

beacon-chain/cache/BUILD.bazel

@@ -6,7 +6,6 @@ go_library(
         "active_balance.go",
         "active_balance_disabled.go",  # keep
         "attestation_data.go",
-        "balance_cache_key.go",
         "checkpoint_state.go",
         "committee.go",
         "committee_disabled.go",  # keep
@@ -71,7 +70,6 @@ go_test(
         "committee_fuzz_test.go",
         "committee_test.go",
         "payload_id_test.go",
-        "private_access_test.go",
         "proposer_indices_test.go",
         "registration_test.go",
         "skip_slot_cache_test.go",
@@ -95,7 +93,6 @@ go_test(
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
-        "@com_github_hashicorp_golang_lru//:go_default_library",
         "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],

beacon-chain/cache/active_balance.go

@@ -3,13 +3,17 @@
 package cache
 
 import (
+	"encoding/binary"
 	"sync"
 
 	lru "github.com/hashicorp/golang-lru"
+	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 const (
@@ -82,3 +86,36 @@ func (c *BalanceCache) Get(st state.ReadOnlyBeaconState) (uint64, error) {
 	balanceCacheHit.Inc()
 	return value.(uint64), nil
 }
+
+// Given input state `st`, balance key is constructed as:
+// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
+func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
+	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
+	if err != nil {
+		// impossible condition due to early division
+		return "", errors.Errorf("start slot calculation overflows: %v", err)
+	}
+	prevSlot := primitives.Slot(0)
+	if epochStartSlot > 1 {
+		prevSlot = epochStartSlot - 1
+	}
+	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
+	if err != nil {
+		// impossible condition because index is always constrained within state
+		return "", err
+	}
+
+	// Mix in current epoch
+	b := make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
+	key := append(r, b...)
+
+	// Mix in validator count
+	b = make([]byte, 8)
+	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
+	key = append(key, b...)
+
+	return string(key), nil
+}

beacon-chain/cache/active_balance_test.go

@@ -1,13 +1,12 @@
 //go:build !fuzz
 
-package cache_test
+package cache
 
 import (
 	"encoding/binary"
 	"math"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -28,33 +27,33 @@ func TestBalanceCache_AddGetBalance(t *testing.T) {
 	st, err := state_native.InitializeFromProtoPhase0(raw)
 	require.NoError(t, err)
 
-	cc := cache.NewEffectiveBalanceCache()
-	_, err = cc.Get(st)
-	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
+	cache := NewEffectiveBalanceCache()
+	_, err = cache.Get(st)
+	require.ErrorContains(t, ErrNotFound.Error(), err)
 
 	b := uint64(100)
-	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
-	cachedB, err := cc.Get(st)
+	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
+	cachedB, err := cache.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 
 	require.NoError(t, st.SetSlot(1000))
-	_, err = cc.Get(st)
-	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
+	_, err = cache.Get(st)
+	require.ErrorContains(t, ErrNotFound.Error(), err)
 
 	b = uint64(200)
-	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cc.Get(st)
+	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
+	cachedB, err = cache.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 
 	require.NoError(t, st.SetSlot(1000+params.BeaconConfig().SlotsPerHistoricalRoot))
-	_, err = cc.Get(st)
-	require.ErrorContains(t, cache.ErrNotFound.Error(), err)
+	_, err = cache.Get(st)
+	require.ErrorContains(t, ErrNotFound.Error(), err)
 
 	b = uint64(300)
-	require.NoError(t, cc.AddTotalEffectiveBalance(st, b))
-	cachedB, err = cc.Get(st)
+	require.NoError(t, cache.AddTotalEffectiveBalance(st, b))
+	cachedB, err = cache.Get(st)
 	require.NoError(t, err)
 	require.Equal(t, b, cachedB)
 }
@@ -73,6 +72,6 @@ func TestBalanceCache_BalanceKey(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(primitives.Slot(math.MaxUint64)))
 
-	_, err = cache.BalanceCacheKey(st)
+	_, err = balanceCacheKey(st)
 	require.NoError(t, err)
 }

beacon-chain/cache/balance_cache_key.go

@@ -1,43 +0,0 @@
-package cache
-
-import (
-	"encoding/binary"
-	"fmt"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-)
-
-// Given input state `st`, balance key is constructed as:
-// (block_root in `st` at epoch_start_slot - 1) + current_epoch + validator_count
-func balanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	currentEpoch := st.Slot().DivSlot(slotsPerEpoch)
-	epochStartSlot, err := slotsPerEpoch.SafeMul(uint64(currentEpoch))
-	if err != nil {
-		// impossible condition due to early division
-		return "", fmt.Errorf("start slot calculation overflows: %w", err)
-	}
-	prevSlot := primitives.Slot(0)
-	if epochStartSlot > 1 {
-		prevSlot = epochStartSlot - 1
-	}
-	r, err := st.BlockRootAtIndex(uint64(prevSlot % params.BeaconConfig().SlotsPerHistoricalRoot))
-	if err != nil {
-		// impossible condition because index is always constrained within state
-		return "", err
-	}
-
-	// Mix in current epoch
-	b := make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(currentEpoch))
-	key := append(r, b...)
-
-	// Mix in validator count
-	b = make([]byte, 8)
-	binary.LittleEndian.PutUint64(b, uint64(st.NumValidators()))
-	key = append(key, b...)
-
-	return string(key), nil
-}

beacon-chain/cache/checkpoint_state_test.go

@@ -1,9 +1,8 @@
-package cache_test
+package cache
 
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -16,7 +15,7 @@ import (
 )
 
 func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
-	cache := cache.NewCheckpointStateCache()
+	cache := NewCheckpointStateCache()
 
 	cp1 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'A'}, 32)}
 	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
@@ -59,16 +58,16 @@ func TestCheckpointStateCache_StateByCheckpoint(t *testing.T) {
 }
 
 func TestCheckpointStateCache_MaxSize(t *testing.T) {
-	c := cache.NewCheckpointStateCache()
+	c := NewCheckpointStateCache()
 	st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
 		Slot: 0,
 	})
 	require.NoError(t, err)
 
-	for i := uint64(0); i < uint64(cache.MaxCheckpointStateSize()+100); i++ {
+	for i := uint64(0); i < uint64(maxCheckpointStateSize+100); i++ {
 		require.NoError(t, st.SetSlot(primitives.Slot(i)))
 		require.NoError(t, c.AddCheckpointState(&ethpb.Checkpoint{Epoch: primitives.Epoch(i), Root: make([]byte, 32)}, st))
 	}
 
-	assert.Equal(t, cache.MaxCheckpointStateSize(), len(c.Cache().Keys()))
+	assert.Equal(t, maxCheckpointStateSize, len(c.cache.Keys()))
 }

beacon-chain/cache/private_access_test.go

@@ -1,18 +0,0 @@
-package cache
-
-import (
-	lru "github.com/hashicorp/golang-lru"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-)
-
-func BalanceCacheKey(st state.ReadOnlyBeaconState) (string, error) {
-	return balanceCacheKey(st)
-}
-
-func MaxCheckpointStateSize() int {
-	return maxCheckpointStateSize
-}
-
-func (c *CheckpointStateCache) Cache() *lru.Cache {
-	return c.cache
-}

beacon-chain/cache/sync_committee_head_state_test.go

@@ -1,9 +1,8 @@
-package cache_test
+package cache
 
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -126,7 +125,7 @@ func TestSyncCommitteeHeadState(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			c := cache.NewSyncCommitteeHeadState()
+			c := NewSyncCommitteeHeadState()
 			if tt.put != nil {
 				err := c.Put(tt.put.slot, tt.put.state)
 				if (err != nil) != tt.wantPutErr {

beacon-chain/core/helpers/beacon_committee.go

@@ -143,137 +143,105 @@ func BeaconCommittee(
 	return ComputeCommittee(validatorIndices, seed, indexOffset, count)
 }
 
-// CommitteeAssignment represents committee list, committee index, and to be attested slot for a given epoch.
-type CommitteeAssignment struct {
+// CommitteeAssignmentContainer represents a committee list, committee index, and to be attested slot for a given epoch.
+type CommitteeAssignmentContainer struct {
 	Committee      []primitives.ValidatorIndex
 	AttesterSlot   primitives.Slot
 	CommitteeIndex primitives.CommitteeIndex
 }
 
-// verifyAssignmentEpoch verifies if the given epoch is valid for assignment based on the provided state.
-// It checks if the epoch is not greater than the next epoch, and if the start slot of the epoch is greater
-// than or equal to the minimum valid start slot calculated based on the state's current slot and historical roots.
-func verifyAssignmentEpoch(epoch primitives.Epoch, state state.BeaconState) error {
+// CommitteeAssignments is a map of validator indices pointing to the appropriate committee
+// assignment for the given epoch.
+//
+// 1. Determine the proposer validator index for each slot.
+// 2. Compute all committees.
+// 3. Determine the attesting slot for each committee.
+// 4. Construct a map of validator indices pointing to the respective committees.
+func CommitteeAssignments(
+	ctx context.Context,
+	state state.BeaconState,
+	epoch primitives.Epoch,
+) (map[primitives.ValidatorIndex]*CommitteeAssignmentContainer, map[primitives.ValidatorIndex][]primitives.Slot, error) {
 	nextEpoch := time.NextEpoch(state)
 	if epoch > nextEpoch {
-		return fmt.Errorf("epoch %d can't be greater than next epoch %d", epoch, nextEpoch)
+		return nil, nil, fmt.Errorf(
+			"epoch %d can't be greater than next epoch %d",
+			epoch,
+			nextEpoch,
+		)
 	}
 
+	// We determine the slots in which proposers are supposed to act.
+	// Some validators may need to propose multiple times per epoch, so
+	// we use a map of proposer idx -> []slot to keep track of this possibility.
 	startSlot, err := slots.EpochStart(epoch)
 	if err != nil {
-		return err
+		return nil, nil, err
 	}
 	minValidStartSlot := primitives.Slot(0)
-	if stateSlot := state.Slot(); stateSlot >= params.BeaconConfig().SlotsPerHistoricalRoot {
-		minValidStartSlot = stateSlot - params.BeaconConfig().SlotsPerHistoricalRoot
+	if state.Slot() >= params.BeaconConfig().SlotsPerHistoricalRoot {
+		minValidStartSlot = state.Slot() - params.BeaconConfig().SlotsPerHistoricalRoot
 	}
 	if startSlot < minValidStartSlot {
-		return fmt.Errorf("start slot %d is smaller than the minimum valid start slot %d", startSlot, minValidStartSlot)
-	}
-	return nil
-}
-
-// ProposerAssignments calculates proposer assignments for each validator during the specified epoch.
-// It verifies the validity of the epoch, then iterates through each slot in the epoch to determine the
-// proposer for that slot and assigns them accordingly.
-func ProposerAssignments(ctx context.Context, state state.BeaconState, epoch primitives.Epoch) (map[primitives.ValidatorIndex][]primitives.Slot, error) {
-	// Verify if the epoch is valid for assignment based on the provided state.
-	if err := verifyAssignmentEpoch(epoch, state); err != nil {
-		return nil, err
-	}
-	startSlot, err := slots.EpochStart(epoch)
-	if err != nil {
-		return nil, err
+		return nil, nil, fmt.Errorf("start slot %d is smaller than the minimum valid start slot %d", startSlot, minValidStartSlot)
 	}
 
-	proposerAssignments := make(map[primitives.ValidatorIndex][]primitives.Slot)
-
-	originalStateSlot := state.Slot()
-
+	proposerIndexToSlots := make(map[primitives.ValidatorIndex][]primitives.Slot, params.BeaconConfig().SlotsPerEpoch)
 	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
 		// Skip proposer assignment for genesis slot.
 		if slot == 0 {
 			continue
 		}
-		// Set the state's current slot.
 		if err := state.SetSlot(slot); err != nil {
-			return nil, err
+			return nil, nil, err
 		}
-
-		// Determine the proposer index for the current slot.
 		i, err := BeaconProposerIndex(ctx, state)
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not check proposer at slot %d", state.Slot())
+			return nil, nil, errors.Wrapf(err, "could not check proposer at slot %d", state.Slot())
 		}
+		proposerIndexToSlots[i] = append(proposerIndexToSlots[i], slot)
+	}
 
-		// Append the slot to the proposer's assignments.
-		if _, ok := proposerAssignments[i]; !ok {
-			proposerAssignments[i] = make([]primitives.Slot, 0)
+	// If previous proposer indices computation is outside if current proposal epoch range,
+	// we need to reset state slot back to start slot so that we can compute the correct committees.
+	currentProposalEpoch := epoch < nextEpoch
+	if !currentProposalEpoch {
+		if err := state.SetSlot(state.Slot() - params.BeaconConfig().SlotsPerEpoch); err != nil {
+			return nil, nil, err
 		}
-		proposerAssignments[i] = append(proposerAssignments[i], slot)
 	}
 
-	// Reset state back to its original slot.
-	if err := state.SetSlot(originalStateSlot); err != nil {
-		return nil, err
-	}
-
-	return proposerAssignments, nil
-}
-
-// CommitteeAssignments calculates committee assignments for each validator during the specified epoch.
-// It retrieves active validator indices, determines the number of committees per slot, and computes
-// assignments for each validator based on their presence in the provided validators slice.
-func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch primitives.Epoch, validators []primitives.ValidatorIndex) (map[primitives.ValidatorIndex]*CommitteeAssignment, error) {
-	// Verify if the epoch is valid for assignment based on the provided state.
-	if err := verifyAssignmentEpoch(epoch, state); err != nil {
-		return nil, err
-	}
-
-	// Retrieve active validator count for the specified epoch.
-	activeValidatorCount, err := ActiveValidatorCount(ctx, state, epoch)
+	activeValidatorIndices, err := ActiveValidatorIndices(ctx, state, epoch)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
+	// Each slot in an epoch has a different set of committees. This value is derived from the
+	// active validator set, which does not change.
+	numCommitteesPerSlot := SlotCommitteeCount(uint64(len(activeValidatorIndices)))
+	validatorIndexToCommittee := make(map[primitives.ValidatorIndex]*CommitteeAssignmentContainer, len(activeValidatorIndices))
 
-	// Determine the number of committees per slot based on the number of active validator indices.
-	numCommitteesPerSlot := SlotCommitteeCount(activeValidatorCount)
-
-	startSlot, err := slots.EpochStart(epoch)
-	if err != nil {
-		return nil, err
-	}
-
-	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
-	vals := make(map[primitives.ValidatorIndex]struct{})
-	for _, v := range validators {
-		vals[v] = struct{}{}
-	}
-
-	// Compute committee assignments for each slot in the epoch.
-	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
-		// Compute committees for the current slot.
+	// Compute all committees for all slots.
+	for i := primitives.Slot(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
+		// Compute committees.
 		for j := uint64(0); j < numCommitteesPerSlot; j++ {
-			committee, err := BeaconCommitteeFromState(ctx, state, slot, primitives.CommitteeIndex(j))
+			slot := startSlot + i
+			committee, err := BeaconCommitteeFromState(ctx, state, slot, primitives.CommitteeIndex(j) /*committee index*/)
 			if err != nil {
-				return nil, err
+				return nil, nil, err
 			}
 
+			cac := &CommitteeAssignmentContainer{
+				Committee:      committee,
+				CommitteeIndex: primitives.CommitteeIndex(j),
+				AttesterSlot:   slot,
+			}
 			for _, vIndex := range committee {
-				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
-					continue
-				}
-				if _, ok := assignments[vIndex]; !ok {
-					assignments[vIndex] = &CommitteeAssignment{}
-				}
-				assignments[vIndex].Committee = committee
-				assignments[vIndex].AttesterSlot = slot
-				assignments[vIndex].CommitteeIndex = primitives.CommitteeIndex(j)
+				validatorIndexToCommittee[vIndex] = cac
 			}
 		}
 	}
 
-	return assignments, nil
+	return validatorIndexToCommittee, proposerIndexToSlots, nil
 }
 
 // VerifyBitfieldLength verifies that a bitfield length matches the given committee size.

beacon-chain/core/helpers/beacon_committee_test.go

@@ -104,10 +104,7 @@ func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) {
 		Slot: 0, // Epoch 0.
 	})
 	require.NoError(t, err)
-	_, err = helpers.CommitteeAssignments(context.Background(), state, epoch+1, nil)
-	assert.ErrorContains(t, "can't be greater than next epoch", err)
-
-	_, err = helpers.ProposerAssignments(context.Background(), state, epoch+1)
+	_, _, err = helpers.CommitteeAssignments(context.Background(), state, epoch+1)
 	assert.ErrorContains(t, "can't be greater than next epoch", err)
 }
 
@@ -131,10 +128,10 @@ func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	assignments, err := helpers.ProposerAssignments(context.Background(), state, 0)
-	require.NoError(t, err, "Failed to determine Assignments")
-	for _, slots := range assignments {
-		for _, s := range slots {
+	_, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), state, 0)
+	require.NoError(t, err, "Failed to determine CommitteeAssignments")
+	for _, ss := range proposerIndexToSlots {
+		for _, s := range ss {
 			assert.NotEqual(t, uint64(0), s, "No proposer should be assigned to slot 0")
 		}
 	}
@@ -143,7 +140,6 @@ func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) {
 func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 	// Initialize test with 256 validators, each slot and each index gets 4 validators.
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
-	validatorIndices := make([]primitives.ValidatorIndex, len(validators))
 	for i := 0; i < len(validators); i++ {
 		// First 2 epochs only half validators are activated.
 		var activationEpoch primitives.Epoch
@@ -154,7 +150,6 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 			ActivationEpoch: activationEpoch,
 			ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
 		}
-		validatorIndices[i] = primitives.ValidatorIndex(i)
 	}
 
 	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
@@ -206,16 +201,14 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 		t.Run(fmt.Sprintf("%d", i), func(t *testing.T) {
 			helpers.ClearCache()
 
-			assignments, err := helpers.CommitteeAssignments(context.Background(), state, slots.ToEpoch(tt.slot), validatorIndices)
-			require.NoError(t, err, "Failed to determine Assignments")
-			cac := assignments[tt.index]
+			validatorIndexToCommittee, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), state, slots.ToEpoch(tt.slot))
+			require.NoError(t, err, "Failed to determine CommitteeAssignments")
+			cac := validatorIndexToCommittee[tt.index]
 			assert.Equal(t, tt.committeeIndex, cac.CommitteeIndex, "Unexpected committeeIndex for validator index %d", tt.index)
 			assert.Equal(t, tt.slot, cac.AttesterSlot, "Unexpected slot for validator index %d", tt.index)
-			proposerAssignments, err := helpers.ProposerAssignments(context.Background(), state, slots.ToEpoch(tt.slot))
-			require.NoError(t, err)
-			if len(proposerAssignments[tt.index]) > 0 && proposerAssignments[tt.index][0] != tt.proposerSlot {
+			if len(proposerIndexToSlots[tt.index]) > 0 && proposerIndexToSlots[tt.index][0] != tt.proposerSlot {
 				t.Errorf("wanted proposer slot %d, got proposer slot %d for validator index %d",
-					tt.proposerSlot, proposerAssignments[tt.index][0], tt.index)
+					tt.proposerSlot, proposerIndexToSlots[tt.index][0], tt.index)
 			}
 			assert.DeepEqual(t, tt.committee, cac.Committee, "Unexpected committee for validator index %d", tt.index)
 		})
@@ -245,13 +238,13 @@ func TestCommitteeAssignments_CannotRetrieveFuture(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	assignments, err := helpers.ProposerAssignments(context.Background(), state, time.CurrentEpoch(state))
+	_, proposerIndxs, err := helpers.CommitteeAssignments(context.Background(), state, time.CurrentEpoch(state))
 	require.NoError(t, err)
-	require.NotEqual(t, 0, len(assignments), "wanted non-zero proposer index set")
+	require.NotEqual(t, 0, len(proposerIndxs), "wanted non-zero proposer index set")
 
-	assignments, err = helpers.ProposerAssignments(context.Background(), state, time.CurrentEpoch(state)+1)
+	_, proposerIndxs, err = helpers.CommitteeAssignments(context.Background(), state, time.CurrentEpoch(state)+1)
 	require.NoError(t, err)
-	require.NotEqual(t, 0, len(assignments), "wanted non-zero proposer index set")
+	require.NotEqual(t, 0, len(proposerIndxs), "wanted non-zero proposer index set")
 }
 
 func TestCommitteeAssignments_CannotRetrieveOlderThanSlotsPerHistoricalRoot(t *testing.T) {
@@ -271,7 +264,7 @@ func TestCommitteeAssignments_CannotRetrieveOlderThanSlotsPerHistoricalRoot(t *t
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	_, err = helpers.CommitteeAssignments(context.Background(), state, 0, nil)
+	_, _, err = helpers.CommitteeAssignments(context.Background(), state, 0)
 	require.ErrorContains(t, "start slot 0 is smaller than the minimum valid start slot 1", err)
 }
 
@@ -293,12 +286,12 @@ func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) {
 	})
 	require.NoError(t, err)
 	epoch := primitives.Epoch(1)
-	assignments, err := helpers.ProposerAssignments(context.Background(), state, epoch)
-	require.NoError(t, err, "Failed to determine Assignments")
+	_, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), state, epoch)
+	require.NoError(t, err, "Failed to determine CommitteeAssignments")
 
 	slotsWithProposers := make(map[primitives.Slot]bool)
-	for _, slots := range assignments {
-		for _, slot := range slots {
+	for _, proposerSlots := range proposerIndexToSlots {
+		for _, slot := range proposerSlots {
 			slotsWithProposers[slot] = true
 		}
 	}

beacon-chain/db/filesystem/BUILD.bazel

@@ -18,12 +18,10 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/logging:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/db/filesystem/blob.go

@@ -10,13 +10,11 @@ import (
 	"strings"
 	"time"
 
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/logging"
@@ -29,7 +27,6 @@ var (
 	errEmptyBlobWritten    = errors.New("zero bytes written to disk when saving blob sidecar")
 	errSidecarEmptySSZData = errors.New("sidecar marshalled to an empty ssz byte slice")
 	errNoBasePath          = errors.New("BlobStorage base path not specified in init")
-	errInvalidRootString   = errors.New("Could not parse hex string as a [32]byte")
 )
 
 const (
@@ -336,11 +333,3 @@ func (p blobNamer) path() string {
 func rootString(root [32]byte) string {
 	return fmt.Sprintf("%#x", root)
 }
-
-func stringToRoot(str string) ([32]byte, error) {
-	slice, err := hexutil.Decode(str)
-	if err != nil {
-		return [32]byte{}, errors.Wrapf(errInvalidRootString, "input=%s", str)
-	}
-	return bytesutil.ToBytes32(slice), nil
-}

beacon-chain/db/filesystem/cache.go

@@ -48,26 +48,27 @@ type BlobStorageSummarizer interface {
 type blobStorageCache struct {
 	mu     sync.RWMutex
 	nBlobs float64
-	cache  map[[32]byte]BlobStorageSummary
+	cache  map[string]BlobStorageSummary
 }
 
 var _ BlobStorageSummarizer = &blobStorageCache{}
 
 func newBlobStorageCache() *blobStorageCache {
 	return &blobStorageCache{
-		cache: make(map[[32]byte]BlobStorageSummary, params.BeaconConfig().MinEpochsForBlobsSidecarsRequest*fieldparams.SlotsPerEpoch),
+		cache: make(map[string]BlobStorageSummary, params.BeaconConfig().MinEpochsForBlobsSidecarsRequest*fieldparams.SlotsPerEpoch),
 	}
 }
 
 // Summary returns the BlobStorageSummary for `root`. The BlobStorageSummary can be used to check for the presence of
 // BlobSidecars based on Index.
 func (s *blobStorageCache) Summary(root [32]byte) BlobStorageSummary {
+	k := rootString(root)
 	s.mu.RLock()
 	defer s.mu.RUnlock()
-	return s.cache[root]
+	return s.cache[k]
 }
 
-func (s *blobStorageCache) ensure(key [32]byte, slot primitives.Slot, idx uint64) error {
+func (s *blobStorageCache) ensure(key string, slot primitives.Slot, idx uint64) error {
 	if idx >= fieldparams.MaxBlobsPerBlock {
 		return errIndexOutOfBounds
 	}
@@ -83,7 +84,7 @@ func (s *blobStorageCache) ensure(key [32]byte, slot primitives.Slot, idx uint64
 	return nil
 }
 
-func (s *blobStorageCache) slot(key [32]byte) (primitives.Slot, bool) {
+func (s *blobStorageCache) slot(key string) (primitives.Slot, bool) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	v, ok := s.cache[key]
@@ -93,7 +94,7 @@ func (s *blobStorageCache) slot(key [32]byte) (primitives.Slot, bool) {
 	return v.slot, ok
 }
 
-func (s *blobStorageCache) evict(key [32]byte) {
+func (s *blobStorageCache) evict(key string) {
 	var deleted float64
 	s.mu.Lock()
 	v, ok := s.cache[key]

beacon-chain/db/filesystem/cache_test.go

@@ -48,7 +48,7 @@ func TestSlotByRoot_Summary(t *testing.T) {
 	sc := newBlobStorageCache()
 	for _, c := range cases {
 		if c.expected != nil {
-			key := bytesutil.ToBytes32([]byte(c.name))
+			key := rootString(bytesutil.ToBytes32([]byte(c.name)))
 			sc.cache[key] = BlobStorageSummary{slot: 0, mask: *c.expected}
 		}
 	}

beacon-chain/db/filesystem/mock.go

@@ -66,7 +66,7 @@ func NewMockBlobStorageSummarizer(t *testing.T, set map[[32]byte][]int) BlobStor
 	c := newBlobStorageCache()
 	for k, v := range set {
 		for i := range v {
-			if err := c.ensure(k, 0, uint64(v[i])); err != nil {
+			if err := c.ensure(rootString(k), 0, uint64(v[i])); err != nil {
 				t.Fatal(err)
 			}
 		}

beacon-chain/db/filesystem/pruner.go

@@ -64,7 +64,7 @@ func newBlobPruner(fs afero.Fs, retain primitives.Epoch, opts ...prunerOpt) (*bl
 // notify updates the pruner's view of root->blob mappings. This allows the pruner to build a cache
 // of root->slot mappings and decide when to evict old blobs based on the age of present blobs.
 func (p *blobPruner) notify(root [32]byte, latest primitives.Slot, idx uint64) error {
-	if err := p.cache.ensure(root, latest, idx); err != nil {
+	if err := p.cache.ensure(rootString(root), latest, idx); err != nil {
 		return err
 	}
 	pruned := uint64(windowMin(latest, p.windowSize))
@@ -160,10 +160,7 @@ func shouldRetain(slot, pruneBefore primitives.Slot) bool {
 }
 
 func (p *blobPruner) tryPruneDir(dir string, pruneBefore primitives.Slot) (int, error) {
-	root, err := rootFromDir(dir)
-	if err != nil {
-		return 0, errors.Wrapf(err, "invalid directory, could not parse subdir as root %s", dir)
-	}
+	root := rootFromDir(dir)
 	slot, slotCached := p.cache.slot(root)
 	// Return early if the slot is cached and doesn't need pruning.
 	if slotCached && shouldRetain(slot, pruneBefore) {
@@ -221,7 +218,7 @@ func (p *blobPruner) tryPruneDir(dir string, pruneBefore primitives.Slot) (int,
 		return removed, errors.Wrapf(err, "unable to remove blob directory %s", dir)
 	}
 
-	p.cache.evict(root)
+	p.cache.evict(rootFromDir(dir))
 	return len(scFiles), nil
 }
 
@@ -238,13 +235,8 @@ func idxFromPath(fname string) (uint64, error) {
 	return strconv.ParseUint(parts[0], 10, 64)
 }
 
-func rootFromDir(dir string) ([32]byte, error) {
-	subdir := filepath.Base(dir) // end of the path should be the blob directory, named by hex encoding of root
-	root, err := stringToRoot(subdir)
-	if err != nil {
-		return root, errors.Wrapf(err, "invalid directory, could not parse subdir as root %s", dir)
-	}
-	return root, nil
+func rootFromDir(dir string) string {
+	return filepath.Base(dir) // end of the path should be the blob directory, named by hex encoding of root
 }
 
 // Read slot from marshaled BlobSidecar data in the given file. See slotFromBlob for details.

beacon-chain/db/filesystem/pruner_test.go

@@ -25,11 +25,11 @@ func TestTryPruneDir_CachedNotExpired(t *testing.T) {
 	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, fieldparams.MaxBlobsPerBlock)
 	sc, err := verification.BlobSidecarNoop(sidecars[0])
 	require.NoError(t, err)
-	rootStr := rootString(sc.BlockRoot())
+	root := fmt.Sprintf("%#x", sc.BlockRoot())
 	// This slot is right on the edge of what would need to be pruned, so by adding it to the cache and
 	// skipping any other test setup, we can be certain the hot cache path never touches the filesystem.
-	require.NoError(t, pr.cache.ensure(sc.BlockRoot(), sc.Slot(), 0))
-	pruned, err := pr.tryPruneDir(rootStr, pr.windowSize)
+	require.NoError(t, pr.cache.ensure(root, sc.Slot(), 0))
+	pruned, err := pr.tryPruneDir(root, pr.windowSize)
 	require.NoError(t, err)
 	require.Equal(t, 0, pruned)
 }
@@ -43,10 +43,10 @@ func TestTryPruneDir_CachedExpired(t *testing.T) {
 		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, 1)
 		sc, err := verification.BlobSidecarNoop(sidecars[0])
 		require.NoError(t, err)
-		rootStr := rootString(sc.BlockRoot())
-		require.NoError(t, fs.Mkdir(rootStr, directoryPermissions)) // make empty directory
-		require.NoError(t, pr.cache.ensure(sc.BlockRoot(), sc.Slot(), 0))
-		pruned, err := pr.tryPruneDir(rootStr, slot+1)
+		root := fmt.Sprintf("%#x", sc.BlockRoot())
+		require.NoError(t, fs.Mkdir(root, directoryPermissions)) // make empty directory
+		require.NoError(t, pr.cache.ensure(root, sc.Slot(), 0))
+		pruned, err := pr.tryPruneDir(root, slot+1)
 		require.NoError(t, err)
 		require.Equal(t, 0, pruned)
 	})
@@ -61,21 +61,20 @@ func TestTryPruneDir_CachedExpired(t *testing.T) {
 		require.NoError(t, bs.Save(scs[1]))
 
 		// check that the root->slot is cached
-		root := scs[0].BlockRoot()
-		rootStr := rootString(root)
-		cs, cok := bs.pruner.cache.slot(scs[0].BlockRoot())
+		root := fmt.Sprintf("%#x", scs[0].BlockRoot())
+		cs, cok := bs.pruner.cache.slot(root)
 		require.Equal(t, true, cok)
 		require.Equal(t, slot, cs)
 
 		// ensure that we see the saved files in the filesystem
-		files, err := listDir(fs, rootStr)
+		files, err := listDir(fs, root)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 
-		pruned, err := bs.pruner.tryPruneDir(rootStr, slot+1)
+		pruned, err := bs.pruner.tryPruneDir(root, slot+1)
 		require.NoError(t, err)
 		require.Equal(t, 2, pruned)
-		files, err = listDir(fs, rootStr)
+		files, err = listDir(fs, root)
 		require.ErrorIs(t, err, os.ErrNotExist)
 		require.Equal(t, 0, len(files))
 	})
@@ -93,8 +92,7 @@ func TestTryPruneDir_SlotFromFile(t *testing.T) {
 		require.NoError(t, bs.Save(scs[1]))
 
 		// check that the root->slot is cached
-		root := scs[0].BlockRoot()
-		rootStr := rootString(root)
+		root := fmt.Sprintf("%#x", scs[0].BlockRoot())
 		cs, ok := bs.pruner.cache.slot(root)
 		require.Equal(t, true, ok)
 		require.Equal(t, slot, cs)
@@ -104,14 +102,14 @@ func TestTryPruneDir_SlotFromFile(t *testing.T) {
 		require.Equal(t, false, ok)
 
 		// ensure that we see the saved files in the filesystem
-		files, err := listDir(fs, rootStr)
+		files, err := listDir(fs, root)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 
-		pruned, err := bs.pruner.tryPruneDir(rootStr, slot+1)
+		pruned, err := bs.pruner.tryPruneDir(root, slot+1)
 		require.NoError(t, err)
 		require.Equal(t, 2, pruned)
-		files, err = listDir(fs, rootStr)
+		files, err = listDir(fs, root)
 		require.ErrorIs(t, err, os.ErrNotExist)
 		require.Equal(t, 0, len(files))
 	})
@@ -127,25 +125,24 @@ func TestTryPruneDir_SlotFromFile(t *testing.T) {
 		require.NoError(t, bs.Save(scs[1]))
 
 		// Evict slot mapping from the cache so that we trigger the file read path.
-		root := scs[0].BlockRoot()
-		rootStr := rootString(root)
+		root := fmt.Sprintf("%#x", scs[0].BlockRoot())
 		bs.pruner.cache.evict(root)
 		_, ok := bs.pruner.cache.slot(root)
 		require.Equal(t, false, ok)
 
 		// Ensure that we see the saved files in the filesystem.
-		files, err := listDir(fs, rootStr)
+		files, err := listDir(fs, root)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 
 		// This should use the slotFromFile code (simulating restart).
 		// Setting pruneBefore == slot, so that the slot will be outside the window (at the boundary).
-		pruned, err := bs.pruner.tryPruneDir(rootStr, slot)
+		pruned, err := bs.pruner.tryPruneDir(root, slot)
 		require.NoError(t, err)
 		require.Equal(t, 0, pruned)
 
 		// Ensure files are still present.
-		files, err = listDir(fs, rootStr)
+		files, err = listDir(fs, root)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(files))
 	})
@@ -319,45 +316,3 @@ func TestListDir(t *testing.T) {
 		})
 	}
 }
-
-func TestRootFromDir(t *testing.T) {
-	cases := []struct {
-		name string
-		dir  string
-		err  error
-		root [32]byte
-	}{
-		{
-			name: "happy path",
-			dir:  "0xffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5cb",
-			root: [32]byte{255, 255, 135, 94, 29, 152, 92, 92, 203, 33, 72, 148, 152, 63, 36, 40,
-				237, 178, 113, 240, 248, 123, 104, 186, 112, 16, 228, 169, 157, 243, 181, 203},
-		},
-		{
-			name: "too short",
-			dir:  "0xffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5c",
-			err:  errInvalidRootString,
-		},
-		{
-			name: "too log",
-			dir:  "0xffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5cbb",
-			err:  errInvalidRootString,
-		},
-		{
-			name: "missing prefix",
-			dir:  "ffff875e1d985c5ccb214894983f2428edb271f0f87b68ba7010e4a99df3b5cb",
-			err:  errInvalidRootString,
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			root, err := stringToRoot(c.dir)
-			if c.err != nil {
-				require.ErrorIs(t, err, c.err)
-				return
-			}
-			require.NoError(t, err)
-			require.Equal(t, c.root, root)
-		})
-	}
-}

beacon-chain/p2p/discovery.go

@@ -20,6 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	ecdsaprysm "github.com/prysmaticlabs/prysm/v5/crypto/ecdsa"
+	"github.com/prysmaticlabs/prysm/v5/math"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
@@ -132,7 +133,13 @@ func (s *Service) listenForNewNodes() {
 		}
 		// Restrict dials if limit is applied.
 		if flags.MaxDialIsActive() {
-			wantedCount = min(wantedCount, flags.Get().MaxConcurrentDials)
+			var err error
+			wantedICount := math.Min(uint64(wantedCount), uint64(flags.Get().MaxConcurrentDials))
+			wantedCount, err = math.Int(wantedICount)
+			if err != nil {
+				log.WithError(err).Error("Could not get wanted count")
+				continue
+			}
 		}
 		wantedNodes := enode.ReadNodes(iterator, wantedCount)
 		wg := new(sync.WaitGroup)

beacon-chain/p2p/iterator.go

@@ -34,7 +34,7 @@ func (f *filterIter) Next() bool {
 		if lookupCounter > backOffCounter {
 			lookupCounter = 0
 			runtime.Gosched()
-			time.Sleep(pollingPeriod)
+			time.Sleep(30 * time.Second)
 		}
 		if f.Context.Err() != nil {
 			return false

beacon-chain/p2p/subnets.go

@@ -90,7 +90,13 @@ func (s *Service) FindPeersWithSubnet(ctx context.Context, topic string,
 		nodeCount := int(params.BeaconNetworkConfig().MinimumPeersInSubnetSearch)
 		// Restrict dials if limit is applied.
 		if flags.MaxDialIsActive() {
-			nodeCount = min(nodeCount, flags.Get().MaxConcurrentDials)
+			var err error
+			wantedICount := mathutil.Min(uint64(nodeCount), uint64(flags.Get().MaxConcurrentDials))
+			nodeCount, err = mathutil.Int(wantedICount)
+			if err != nil {
+				log.WithError(err).Error("Could not get wanted count")
+				continue
+			}
 		}
 		nodes := enode.ReadNodes(iterator, nodeCount)
 		for _, node := range nodes {

beacon-chain/rpc/eth/config/handlers_test.go

@@ -78,6 +78,8 @@ func TestGetSpec(t *testing.T) {
 	config.CapellaForkEpoch = 103
 	config.DenebForkVersion = []byte("DenebForkVersion")
 	config.DenebForkEpoch = 105
+	config.ElectraForkVersion = []byte("ElectraForkVersion")
+	config.ElectraForkEpoch = 107
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
 	config.GenesisDelay = 24
@@ -170,293 +172,309 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 129, len(data))
+	assert.Equal(t, 136, len(data))
 	for k, v := range data {
-		switch k {
-		case "CONFIG_NAME":
-			assert.Equal(t, "ConfigName", v)
-		case "PRESET_BASE":
-			assert.Equal(t, "PresetBase", v)
-		case "MAX_COMMITTEES_PER_SLOT":
-			assert.Equal(t, "1", v)
-		case "TARGET_COMMITTEE_SIZE":
-			assert.Equal(t, "2", v)
-		case "MAX_VALIDATORS_PER_COMMITTEE":
-			assert.Equal(t, "3", v)
-		case "MIN_PER_EPOCH_CHURN_LIMIT":
-			assert.Equal(t, "4", v)
-		case "CHURN_LIMIT_QUOTIENT":
-			assert.Equal(t, "5", v)
-		case "SHUFFLE_ROUND_COUNT":
-			assert.Equal(t, "6", v)
-		case "MIN_GENESIS_ACTIVE_VALIDATOR_COUNT":
-			assert.Equal(t, "7", v)
-		case "MIN_GENESIS_TIME":
-			assert.Equal(t, "8", v)
-		case "HYSTERESIS_QUOTIENT":
-			assert.Equal(t, "9", v)
-		case "HYSTERESIS_DOWNWARD_MULTIPLIER":
-			assert.Equal(t, "10", v)
-		case "HYSTERESIS_UPWARD_MULTIPLIER":
-			assert.Equal(t, "11", v)
-		case "SAFE_SLOTS_TO_UPDATE_JUSTIFIED":
-			assert.Equal(t, "0", v)
-		case "ETH1_FOLLOW_DISTANCE":
-			assert.Equal(t, "13", v)
-		case "TARGET_AGGREGATORS_PER_COMMITTEE":
-			assert.Equal(t, "14", v)
-		case "RANDOM_SUBNETS_PER_VALIDATOR":
-			assert.Equal(t, "15", v)
-		case "EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION":
-			assert.Equal(t, "16", v)
-		case "SECONDS_PER_ETH1_BLOCK":
-			assert.Equal(t, "17", v)
-		case "DEPOSIT_CHAIN_ID":
-			assert.Equal(t, "18", v)
-		case "DEPOSIT_NETWORK_ID":
-			assert.Equal(t, "19", v)
-		case "DEPOSIT_CONTRACT_ADDRESS":
-			assert.Equal(t, "DepositContractAddress", v)
-		case "MIN_DEPOSIT_AMOUNT":
-			assert.Equal(t, "20", v)
-		case "MAX_EFFECTIVE_BALANCE":
-			assert.Equal(t, "21", v)
-		case "EJECTION_BALANCE":
-			assert.Equal(t, "22", v)
-		case "EFFECTIVE_BALANCE_INCREMENT":
-			assert.Equal(t, "23", v)
-		case "GENESIS_FORK_VERSION":
-			assert.Equal(t, "0x"+hex.EncodeToString([]byte("GenesisForkVersion")), v)
-		case "ALTAIR_FORK_VERSION":
-			assert.Equal(t, "0x"+hex.EncodeToString([]byte("AltairForkVersion")), v)
-		case "ALTAIR_FORK_EPOCH":
-			assert.Equal(t, "100", v)
-		case "BELLATRIX_FORK_VERSION":
-			assert.Equal(t, "0x"+hex.EncodeToString([]byte("BellatrixForkVersion")), v)
-		case "BELLATRIX_FORK_EPOCH":
-			assert.Equal(t, "101", v)
-		case "CAPELLA_FORK_VERSION":
-			assert.Equal(t, "0x"+hex.EncodeToString([]byte("CapellaForkVersion")), v)
-		case "CAPELLA_FORK_EPOCH":
-			assert.Equal(t, "103", v)
-		case "DENEB_FORK_VERSION":
-			assert.Equal(t, "0x"+hex.EncodeToString([]byte("DenebForkVersion")), v)
-		case "DENEB_FORK_EPOCH":
-			assert.Equal(t, "105", v)
-		case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
-			assert.Equal(t, "1000", v)
-		case "BLS_WITHDRAWAL_PREFIX":
-			assert.Equal(t, "0x62", v)
-		case "ETH1_ADDRESS_WITHDRAWAL_PREFIX":
-			assert.Equal(t, "0x63", v)
-		case "GENESIS_DELAY":
-			assert.Equal(t, "24", v)
-		case "SECONDS_PER_SLOT":
-			assert.Equal(t, "25", v)
-		case "MIN_ATTESTATION_INCLUSION_DELAY":
-			assert.Equal(t, "26", v)
-		case "SLOTS_PER_EPOCH":
-			assert.Equal(t, "27", v)
-		case "MIN_SEED_LOOKAHEAD":
-			assert.Equal(t, "28", v)
-		case "MAX_SEED_LOOKAHEAD":
-			assert.Equal(t, "29", v)
-		case "EPOCHS_PER_ETH1_VOTING_PERIOD":
-			assert.Equal(t, "30", v)
-		case "SLOTS_PER_HISTORICAL_ROOT":
-			assert.Equal(t, "31", v)
-		case "MIN_VALIDATOR_WITHDRAWABILITY_DELAY":
-			assert.Equal(t, "32", v)
-		case "SHARD_COMMITTEE_PERIOD":
-			assert.Equal(t, "33", v)
-		case "MIN_EPOCHS_TO_INACTIVITY_PENALTY":
-			assert.Equal(t, "34", v)
-		case "EPOCHS_PER_HISTORICAL_VECTOR":
-			assert.Equal(t, "35", v)
-		case "EPOCHS_PER_SLASHINGS_VECTOR":
-			assert.Equal(t, "36", v)
-		case "HISTORICAL_ROOTS_LIMIT":
-			assert.Equal(t, "37", v)
-		case "VALIDATOR_REGISTRY_LIMIT":
-			assert.Equal(t, "38", v)
-		case "BASE_REWARD_FACTOR":
-			assert.Equal(t, "39", v)
-		case "WHISTLEBLOWER_REWARD_QUOTIENT":
-			assert.Equal(t, "40", v)
-		case "PROPOSER_REWARD_QUOTIENT":
-			assert.Equal(t, "41", v)
-		case "INACTIVITY_PENALTY_QUOTIENT":
-			assert.Equal(t, "42", v)
-		case "HF1_INACTIVITY_PENALTY_QUOTIENT":
-			assert.Equal(t, "43", v)
-		case "MIN_SLASHING_PENALTY_QUOTIENT":
-			assert.Equal(t, "44", v)
-		case "HF1_MIN_SLASHING_PENALTY_QUOTIENT":
-			assert.Equal(t, "45", v)
-		case "PROPORTIONAL_SLASHING_MULTIPLIER":
-			assert.Equal(t, "46", v)
-		case "HF1_PROPORTIONAL_SLASHING_MULTIPLIER":
-			assert.Equal(t, "47", v)
-		case "MAX_PROPOSER_SLASHINGS":
-			assert.Equal(t, "48", v)
-		case "MAX_ATTESTER_SLASHINGS":
-			assert.Equal(t, "49", v)
-		case "MAX_ATTESTATIONS":
-			assert.Equal(t, "50", v)
-		case "MAX_DEPOSITS":
-			assert.Equal(t, "51", v)
-		case "MAX_VOLUNTARY_EXITS":
-			assert.Equal(t, "52", v)
-		case "MAX_BLOBS_PER_BLOCK":
-			assert.Equal(t, "4", v)
-		case "TIMELY_HEAD_FLAG_INDEX":
-			assert.Equal(t, "0x35", v)
-		case "TIMELY_SOURCE_FLAG_INDEX":
-			assert.Equal(t, "0x36", v)
-		case "TIMELY_TARGET_FLAG_INDEX":
-			assert.Equal(t, "0x37", v)
-		case "TIMELY_HEAD_WEIGHT":
-			assert.Equal(t, "56", v)
-		case "TIMELY_SOURCE_WEIGHT":
-			assert.Equal(t, "57", v)
-		case "TIMELY_TARGET_WEIGHT":
-			assert.Equal(t, "58", v)
-		case "SYNC_REWARD_WEIGHT":
-			assert.Equal(t, "59", v)
-		case "WEIGHT_DENOMINATOR":
-			assert.Equal(t, "60", v)
-		case "TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE":
-			assert.Equal(t, "61", v)
-		case "SYNC_COMMITTEE_SUBNET_COUNT":
-			assert.Equal(t, "62", v)
-		case "SYNC_COMMITTEE_SIZE":
-			assert.Equal(t, "63", v)
-		case "SYNC_PUBKEYS_PER_AGGREGATE":
-			assert.Equal(t, "64", v)
-		case "INACTIVITY_SCORE_BIAS":
-			assert.Equal(t, "65", v)
-		case "EPOCHS_PER_SYNC_COMMITTEE_PERIOD":
-			assert.Equal(t, "66", v)
-		case "INACTIVITY_PENALTY_QUOTIENT_ALTAIR":
-			assert.Equal(t, "67", v)
-		case "MIN_SLASHING_PENALTY_QUOTIENT_ALTAIR":
-			assert.Equal(t, "68", v)
-		case "PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR":
-			assert.Equal(t, "69", v)
-		case "INACTIVITY_SCORE_RECOVERY_RATE":
-			assert.Equal(t, "70", v)
-		case "MIN_SYNC_COMMITTEE_PARTICIPANTS":
-			assert.Equal(t, "71", v)
-		case "PROPOSER_WEIGHT":
-			assert.Equal(t, "8", v)
-		case "DOMAIN_BEACON_PROPOSER":
-			assert.Equal(t, "0x30303031", v)
-		case "DOMAIN_BEACON_ATTESTER":
-			assert.Equal(t, "0x30303032", v)
-		case "DOMAIN_RANDAO":
-			assert.Equal(t, "0x30303033", v)
-		case "DOMAIN_DEPOSIT":
-			assert.Equal(t, "0x30303034", v)
-		case "DOMAIN_VOLUNTARY_EXIT":
-			assert.Equal(t, "0x30303035", v)
-		case "DOMAIN_SELECTION_PROOF":
-			assert.Equal(t, "0x30303036", v)
-		case "DOMAIN_AGGREGATE_AND_PROOF":
-			assert.Equal(t, "0x30303037", v)
-		case "DOMAIN_APPLICATION_MASK":
-			assert.Equal(t, "0x31303030", v)
-		case "DOMAIN_SYNC_COMMITTEE":
-			assert.Equal(t, "0x07000000", v)
-		case "DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF":
-			assert.Equal(t, "0x08000000", v)
-		case "DOMAIN_CONTRIBUTION_AND_PROOF":
-			assert.Equal(t, "0x09000000", v)
-		case "DOMAIN_BLS_TO_EXECUTION_CHANGE":
-			assert.Equal(t, "0x0a000000", v)
-		case "DOMAIN_APPLICATION_BUILDER":
-			assert.Equal(t, "0x00000001", v)
-		case "DOMAIN_BLOB_SIDECAR":
-			assert.Equal(t, "0x00000000", v)
-		case "TRANSITION_TOTAL_DIFFICULTY":
-			assert.Equal(t, "0", v)
-		case "TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH":
-			assert.Equal(t, "72", v)
-		case "TERMINAL_BLOCK_HASH":
-			s, ok := v.(string)
-			require.Equal(t, true, ok)
-			assert.Equal(t, common.HexToHash("TerminalBlockHash"), common.HexToHash(s))
-		case "TERMINAL_TOTAL_DIFFICULTY":
-			assert.Equal(t, "73", v)
-		case "DefaultFeeRecipient":
-			assert.Equal(t, common.HexToAddress("DefaultFeeRecipient"), v)
-		case "PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX":
-			assert.Equal(t, "3", v)
-		case "MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX":
-			assert.Equal(t, "32", v)
-		case "INACTIVITY_PENALTY_QUOTIENT_BELLATRIX":
-			assert.Equal(t, "16777216", v)
-		case "PROPOSER_SCORE_BOOST":
-			assert.Equal(t, "40", v)
-		case "INTERVALS_PER_SLOT":
-			assert.Equal(t, "3", v)
-		case "MAX_WITHDRAWALS_PER_PAYLOAD":
-			assert.Equal(t, "74", v)
-		case "MAX_BLS_TO_EXECUTION_CHANGES":
-			assert.Equal(t, "75", v)
-		case "MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP":
-			assert.Equal(t, "76", v)
-		case "REORG_MAX_EPOCHS_SINCE_FINALIZATION":
-			assert.Equal(t, "2", v)
-		case "REORG_WEIGHT_THRESHOLD":
-			assert.Equal(t, "20", v)
-		case "REORG_PARENT_WEIGHT_THRESHOLD":
-			assert.Equal(t, "160", v)
-		case "MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT":
-			assert.Equal(t, "8", v)
-		case "MAX_REQUEST_LIGHT_CLIENT_UPDATES":
-			assert.Equal(t, "128", v)
-		case "SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY":
-		case "NODE_ID_BITS":
-			assert.Equal(t, "256", v)
-		case "ATTESTATION_SUBNET_EXTRA_BITS":
-			assert.Equal(t, "0", v)
-		case "ATTESTATION_SUBNET_PREFIX_BITS":
-			assert.Equal(t, "6", v)
-		case "SUBNETS_PER_NODE":
-			assert.Equal(t, "2", v)
-		case "EPOCHS_PER_SUBNET_SUBSCRIPTION":
-			assert.Equal(t, "256", v)
-		case "MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS":
-			assert.Equal(t, "4096", v)
-		case "MAX_REQUEST_BLOB_SIDECARS":
-			assert.Equal(t, "768", v)
-		case "MESSAGE_DOMAIN_INVALID_SNAPPY":
-			assert.Equal(t, "0x00000000", v)
-		case "MESSAGE_DOMAIN_VALID_SNAPPY":
-			assert.Equal(t, "0x01000000", v)
-		case "ATTESTATION_PROPAGATION_SLOT_RANGE":
-			assert.Equal(t, "32", v)
-		case "RESP_TIMEOUT":
-			assert.Equal(t, "10", v)
-		case "TTFB_TIMEOUT":
-			assert.Equal(t, "5", v)
-		case "MIN_EPOCHS_FOR_BLOCK_REQUESTS":
-			assert.Equal(t, "33024", v)
-		case "GOSSIP_MAX_SIZE":
-			assert.Equal(t, "10485760", v)
-		case "MAX_CHUNK_SIZE":
-			assert.Equal(t, "10485760", v)
-		case "ATTESTATION_SUBNET_COUNT":
-			assert.Equal(t, "64", v)
-		case "MAXIMUM_GOSSIP_CLOCK_DISPARITY":
-			assert.Equal(t, "500", v)
-		case "MAX_REQUEST_BLOCKS":
-			assert.Equal(t, "1024", v)
-		case "MAX_REQUEST_BLOCKS_DENEB":
-			assert.Equal(t, "128", v)
-		default:
-			t.Errorf("Incorrect key: %s", k)
-		}
+		t.Run(k, func(t *testing.T) {
+			switch k {
+			case "CONFIG_NAME":
+				assert.Equal(t, "ConfigName", v)
+			case "PRESET_BASE":
+				assert.Equal(t, "PresetBase", v)
+			case "MAX_COMMITTEES_PER_SLOT":
+				assert.Equal(t, "1", v)
+			case "TARGET_COMMITTEE_SIZE":
+				assert.Equal(t, "2", v)
+			case "MAX_VALIDATORS_PER_COMMITTEE":
+				assert.Equal(t, "3", v)
+			case "MIN_PER_EPOCH_CHURN_LIMIT":
+				assert.Equal(t, "4", v)
+			case "CHURN_LIMIT_QUOTIENT":
+				assert.Equal(t, "5", v)
+			case "SHUFFLE_ROUND_COUNT":
+				assert.Equal(t, "6", v)
+			case "MIN_GENESIS_ACTIVE_VALIDATOR_COUNT":
+				assert.Equal(t, "7", v)
+			case "MIN_GENESIS_TIME":
+				assert.Equal(t, "8", v)
+			case "HYSTERESIS_QUOTIENT":
+				assert.Equal(t, "9", v)
+			case "HYSTERESIS_DOWNWARD_MULTIPLIER":
+				assert.Equal(t, "10", v)
+			case "HYSTERESIS_UPWARD_MULTIPLIER":
+				assert.Equal(t, "11", v)
+			case "SAFE_SLOTS_TO_UPDATE_JUSTIFIED":
+				assert.Equal(t, "0", v)
+			case "ETH1_FOLLOW_DISTANCE":
+				assert.Equal(t, "13", v)
+			case "TARGET_AGGREGATORS_PER_COMMITTEE":
+				assert.Equal(t, "14", v)
+			case "RANDOM_SUBNETS_PER_VALIDATOR":
+				assert.Equal(t, "15", v)
+			case "EPOCHS_PER_RANDOM_SUBNET_SUBSCRIPTION":
+				assert.Equal(t, "16", v)
+			case "SECONDS_PER_ETH1_BLOCK":
+				assert.Equal(t, "17", v)
+			case "DEPOSIT_CHAIN_ID":
+				assert.Equal(t, "18", v)
+			case "DEPOSIT_NETWORK_ID":
+				assert.Equal(t, "19", v)
+			case "DEPOSIT_CONTRACT_ADDRESS":
+				assert.Equal(t, "DepositContractAddress", v)
+			case "MIN_DEPOSIT_AMOUNT":
+				assert.Equal(t, "20", v)
+			case "MAX_EFFECTIVE_BALANCE":
+				assert.Equal(t, "21", v)
+			case "EJECTION_BALANCE":
+				assert.Equal(t, "22", v)
+			case "EFFECTIVE_BALANCE_INCREMENT":
+				assert.Equal(t, "23", v)
+			case "GENESIS_FORK_VERSION":
+				assert.Equal(t, "0x"+hex.EncodeToString([]byte("GenesisForkVersion")), v)
+			case "ALTAIR_FORK_VERSION":
+				assert.Equal(t, "0x"+hex.EncodeToString([]byte("AltairForkVersion")), v)
+			case "ALTAIR_FORK_EPOCH":
+				assert.Equal(t, "100", v)
+			case "BELLATRIX_FORK_VERSION":
+				assert.Equal(t, "0x"+hex.EncodeToString([]byte("BellatrixForkVersion")), v)
+			case "BELLATRIX_FORK_EPOCH":
+				assert.Equal(t, "101", v)
+			case "CAPELLA_FORK_VERSION":
+				assert.Equal(t, "0x"+hex.EncodeToString([]byte("CapellaForkVersion")), v)
+			case "CAPELLA_FORK_EPOCH":
+				assert.Equal(t, "103", v)
+			case "DENEB_FORK_VERSION":
+				assert.Equal(t, "0x"+hex.EncodeToString([]byte("DenebForkVersion")), v)
+			case "DENEB_FORK_EPOCH":
+				assert.Equal(t, "105", v)
+			case "ELECTRA_FORK_VERSION":
+				assert.Equal(t, "0x"+hex.EncodeToString([]byte("ElectraForkVersion")), v)
+			case "ELECTRA_FORK_EPOCH":
+				assert.Equal(t, "107", v)
+			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
+				assert.Equal(t, "1000", v)
+			case "BLS_WITHDRAWAL_PREFIX":
+				assert.Equal(t, "0x62", v)
+			case "ETH1_ADDRESS_WITHDRAWAL_PREFIX":
+				assert.Equal(t, "0x63", v)
+			case "GENESIS_DELAY":
+				assert.Equal(t, "24", v)
+			case "SECONDS_PER_SLOT":
+				assert.Equal(t, "25", v)
+			case "MIN_ATTESTATION_INCLUSION_DELAY":
+				assert.Equal(t, "26", v)
+			case "SLOTS_PER_EPOCH":
+				assert.Equal(t, "27", v)
+			case "MIN_SEED_LOOKAHEAD":
+				assert.Equal(t, "28", v)
+			case "MAX_SEED_LOOKAHEAD":
+				assert.Equal(t, "29", v)
+			case "EPOCHS_PER_ETH1_VOTING_PERIOD":
+				assert.Equal(t, "30", v)
+			case "SLOTS_PER_HISTORICAL_ROOT":
+				assert.Equal(t, "31", v)
+			case "MIN_VALIDATOR_WITHDRAWABILITY_DELAY":
+				assert.Equal(t, "32", v)
+			case "SHARD_COMMITTEE_PERIOD":
+				assert.Equal(t, "33", v)
+			case "MIN_EPOCHS_TO_INACTIVITY_PENALTY":
+				assert.Equal(t, "34", v)
+			case "EPOCHS_PER_HISTORICAL_VECTOR":
+				assert.Equal(t, "35", v)
+			case "EPOCHS_PER_SLASHINGS_VECTOR":
+				assert.Equal(t, "36", v)
+			case "HISTORICAL_ROOTS_LIMIT":
+				assert.Equal(t, "37", v)
+			case "VALIDATOR_REGISTRY_LIMIT":
+				assert.Equal(t, "38", v)
+			case "BASE_REWARD_FACTOR":
+				assert.Equal(t, "39", v)
+			case "WHISTLEBLOWER_REWARD_QUOTIENT":
+				assert.Equal(t, "40", v)
+			case "PROPOSER_REWARD_QUOTIENT":
+				assert.Equal(t, "41", v)
+			case "INACTIVITY_PENALTY_QUOTIENT":
+				assert.Equal(t, "42", v)
+			case "HF1_INACTIVITY_PENALTY_QUOTIENT":
+				assert.Equal(t, "43", v)
+			case "MIN_SLASHING_PENALTY_QUOTIENT":
+				assert.Equal(t, "44", v)
+			case "HF1_MIN_SLASHING_PENALTY_QUOTIENT":
+				assert.Equal(t, "45", v)
+			case "PROPORTIONAL_SLASHING_MULTIPLIER":
+				assert.Equal(t, "46", v)
+			case "HF1_PROPORTIONAL_SLASHING_MULTIPLIER":
+				assert.Equal(t, "47", v)
+			case "MAX_PROPOSER_SLASHINGS":
+				assert.Equal(t, "48", v)
+			case "MAX_ATTESTER_SLASHINGS":
+				assert.Equal(t, "49", v)
+			case "MAX_ATTESTATIONS":
+				assert.Equal(t, "50", v)
+			case "MAX_DEPOSITS":
+				assert.Equal(t, "51", v)
+			case "MAX_VOLUNTARY_EXITS":
+				assert.Equal(t, "52", v)
+			case "MAX_BLOBS_PER_BLOCK":
+				assert.Equal(t, "4", v)
+			case "TIMELY_HEAD_FLAG_INDEX":
+				assert.Equal(t, "0x35", v)
+			case "TIMELY_SOURCE_FLAG_INDEX":
+				assert.Equal(t, "0x36", v)
+			case "TIMELY_TARGET_FLAG_INDEX":
+				assert.Equal(t, "0x37", v)
+			case "TIMELY_HEAD_WEIGHT":
+				assert.Equal(t, "56", v)
+			case "TIMELY_SOURCE_WEIGHT":
+				assert.Equal(t, "57", v)
+			case "TIMELY_TARGET_WEIGHT":
+				assert.Equal(t, "58", v)
+			case "SYNC_REWARD_WEIGHT":
+				assert.Equal(t, "59", v)
+			case "WEIGHT_DENOMINATOR":
+				assert.Equal(t, "60", v)
+			case "TARGET_AGGREGATORS_PER_SYNC_SUBCOMMITTEE":
+				assert.Equal(t, "61", v)
+			case "SYNC_COMMITTEE_SUBNET_COUNT":
+				assert.Equal(t, "62", v)
+			case "SYNC_COMMITTEE_SIZE":
+				assert.Equal(t, "63", v)
+			case "SYNC_PUBKEYS_PER_AGGREGATE":
+				assert.Equal(t, "64", v)
+			case "INACTIVITY_SCORE_BIAS":
+				assert.Equal(t, "65", v)
+			case "EPOCHS_PER_SYNC_COMMITTEE_PERIOD":
+				assert.Equal(t, "66", v)
+			case "INACTIVITY_PENALTY_QUOTIENT_ALTAIR":
+				assert.Equal(t, "67", v)
+			case "MIN_SLASHING_PENALTY_QUOTIENT_ALTAIR":
+				assert.Equal(t, "68", v)
+			case "PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR":
+				assert.Equal(t, "69", v)
+			case "INACTIVITY_SCORE_RECOVERY_RATE":
+				assert.Equal(t, "70", v)
+			case "MIN_SYNC_COMMITTEE_PARTICIPANTS":
+				assert.Equal(t, "71", v)
+			case "PROPOSER_WEIGHT":
+				assert.Equal(t, "8", v)
+			case "DOMAIN_BEACON_PROPOSER":
+				assert.Equal(t, "0x30303031", v)
+			case "DOMAIN_BEACON_ATTESTER":
+				assert.Equal(t, "0x30303032", v)
+			case "DOMAIN_RANDAO":
+				assert.Equal(t, "0x30303033", v)
+			case "DOMAIN_DEPOSIT":
+				assert.Equal(t, "0x30303034", v)
+			case "DOMAIN_VOLUNTARY_EXIT":
+				assert.Equal(t, "0x30303035", v)
+			case "DOMAIN_SELECTION_PROOF":
+				assert.Equal(t, "0x30303036", v)
+			case "DOMAIN_AGGREGATE_AND_PROOF":
+				assert.Equal(t, "0x30303037", v)
+			case "DOMAIN_APPLICATION_MASK":
+				assert.Equal(t, "0x31303030", v)
+			case "DOMAIN_SYNC_COMMITTEE":
+				assert.Equal(t, "0x07000000", v)
+			case "DOMAIN_SYNC_COMMITTEE_SELECTION_PROOF":
+				assert.Equal(t, "0x08000000", v)
+			case "DOMAIN_CONTRIBUTION_AND_PROOF":
+				assert.Equal(t, "0x09000000", v)
+			case "DOMAIN_BLS_TO_EXECUTION_CHANGE":
+				assert.Equal(t, "0x0a000000", v)
+			case "DOMAIN_APPLICATION_BUILDER":
+				assert.Equal(t, "0x00000001", v)
+			case "DOMAIN_BLOB_SIDECAR":
+				assert.Equal(t, "0x00000000", v)
+			case "TRANSITION_TOTAL_DIFFICULTY":
+				assert.Equal(t, "0", v)
+			case "TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH":
+				assert.Equal(t, "72", v)
+			case "TERMINAL_BLOCK_HASH":
+				s, ok := v.(string)
+				require.Equal(t, true, ok)
+				assert.Equal(t, common.HexToHash("TerminalBlockHash"), common.HexToHash(s))
+			case "TERMINAL_TOTAL_DIFFICULTY":
+				assert.Equal(t, "73", v)
+			case "DefaultFeeRecipient":
+				assert.Equal(t, common.HexToAddress("DefaultFeeRecipient"), v)
+			case "PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX":
+				assert.Equal(t, "3", v)
+			case "MIN_SLASHING_PENALTY_QUOTIENT_BELLATRIX":
+				assert.Equal(t, "32", v)
+			case "INACTIVITY_PENALTY_QUOTIENT_BELLATRIX":
+				assert.Equal(t, "16777216", v)
+			case "PROPOSER_SCORE_BOOST":
+				assert.Equal(t, "40", v)
+			case "INTERVALS_PER_SLOT":
+				assert.Equal(t, "3", v)
+			case "MAX_WITHDRAWALS_PER_PAYLOAD":
+				assert.Equal(t, "74", v)
+			case "MAX_BLS_TO_EXECUTION_CHANGES":
+				assert.Equal(t, "75", v)
+			case "MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP":
+				assert.Equal(t, "76", v)
+			case "REORG_MAX_EPOCHS_SINCE_FINALIZATION":
+				assert.Equal(t, "2", v)
+			case "REORG_WEIGHT_THRESHOLD":
+				assert.Equal(t, "20", v)
+			case "REORG_PARENT_WEIGHT_THRESHOLD":
+				assert.Equal(t, "160", v)
+			case "MAX_PER_EPOCH_ACTIVATION_CHURN_LIMIT":
+				assert.Equal(t, "8", v)
+			case "MAX_REQUEST_LIGHT_CLIENT_UPDATES":
+				assert.Equal(t, "128", v)
+			case "SAFE_SLOTS_TO_IMPORT_OPTIMISTICALLY":
+			case "NODE_ID_BITS":
+				assert.Equal(t, "256", v)
+			case "ATTESTATION_SUBNET_EXTRA_BITS":
+				assert.Equal(t, "0", v)
+			case "ATTESTATION_SUBNET_PREFIX_BITS":
+				assert.Equal(t, "6", v)
+			case "SUBNETS_PER_NODE":
+				assert.Equal(t, "2", v)
+			case "EPOCHS_PER_SUBNET_SUBSCRIPTION":
+				assert.Equal(t, "256", v)
+			case "MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS":
+				assert.Equal(t, "4096", v)
+			case "MAX_REQUEST_BLOB_SIDECARS":
+				assert.Equal(t, "768", v)
+			case "MESSAGE_DOMAIN_INVALID_SNAPPY":
+				assert.Equal(t, "0x00000000", v)
+			case "MESSAGE_DOMAIN_VALID_SNAPPY":
+				assert.Equal(t, "0x01000000", v)
+			case "ATTESTATION_PROPAGATION_SLOT_RANGE":
+				assert.Equal(t, "32", v)
+			case "RESP_TIMEOUT":
+				assert.Equal(t, "10", v)
+			case "TTFB_TIMEOUT":
+				assert.Equal(t, "5", v)
+			case "MIN_EPOCHS_FOR_BLOCK_REQUESTS":
+				assert.Equal(t, "33024", v)
+			case "GOSSIP_MAX_SIZE":
+				assert.Equal(t, "10485760", v)
+			case "MAX_CHUNK_SIZE":
+				assert.Equal(t, "10485760", v)
+			case "ATTESTATION_SUBNET_COUNT":
+				assert.Equal(t, "64", v)
+			case "MAXIMUM_GOSSIP_CLOCK_DISPARITY":
+				assert.Equal(t, "500", v)
+			case "MAX_REQUEST_BLOCKS":
+				assert.Equal(t, "1024", v)
+			case "MAX_REQUEST_BLOCKS_DENEB":
+				assert.Equal(t, "128", v)
+			case "NUMBER_OF_COLUMNS":
+				assert.Equal(t, "128", v)
+			case "MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA":
+				assert.Equal(t, "128000000000", v)
+			case "MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT":
+				assert.Equal(t, "256000000000", v)
+			case "DATA_COLUMN_SIDECAR_SUBNET_COUNT":
+				assert.Equal(t, "32", v)
+			case "MAX_REQUEST_DATA_COLUMN_SIDECARS":
+				assert.Equal(t, "16384", v)
+			default:
+				t.Errorf("Incorrect key: %s", k)
+			}
+		})
 	}
 }
 

beacon-chain/rpc/eth/validator/handlers.go

@@ -664,7 +664,7 @@ func (s *Server) GetAttesterDuties(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	assignments, err := helpers.CommitteeAssignments(ctx, st, requestedEpoch, requestedValIndices)
+	committeeAssignments, _, err := helpers.CommitteeAssignments(ctx, st, requestedEpoch)
 	if err != nil {
 		httputil.HandleError(w, "Could not compute committee assignments: "+err.Error(), http.StatusInternalServerError)
 		return
@@ -684,7 +684,7 @@ func (s *Server) GetAttesterDuties(w http.ResponseWriter, r *http.Request) {
 			httputil.HandleError(w, fmt.Sprintf("Invalid validator index %d", index), http.StatusBadRequest)
 			return
 		}
-		committee := assignments[index]
+		committee := committeeAssignments[index]
 		if committee == nil {
 			continue
 		}
@@ -708,20 +708,10 @@ func (s *Server) GetAttesterDuties(w http.ResponseWriter, r *http.Request) {
 		})
 	}
 
-	var dependentRoot []byte
-	if requestedEpoch == 0 {
-		r, err := s.BeaconDB.GenesisBlockRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not get genesis block root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		dependentRoot = r[:]
-	} else {
-		dependentRoot, err = attestationDependentRoot(st, requestedEpoch)
-		if err != nil {
-			httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
+	dependentRoot, err := attestationDependentRoot(st, requestedEpoch)
+	if err != nil {
+		httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
+		return
 	}
 	isOptimistic, err := s.OptimisticModeFetcher.IsOptimistic(ctx)
 	if err != nil {
@@ -803,11 +793,11 @@ func (s *Server) GetProposerDuties(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	var assignments map[primitives.ValidatorIndex][]primitives.Slot
+	var proposals map[primitives.ValidatorIndex][]primitives.Slot
 	if nextEpochLookahead {
-		assignments, err = helpers.ProposerAssignments(ctx, st, nextEpoch)
+		_, proposals, err = helpers.CommitteeAssignments(ctx, st, nextEpoch)
 	} else {
-		assignments, err = helpers.ProposerAssignments(ctx, st, requestedEpoch)
+		_, proposals, err = helpers.CommitteeAssignments(ctx, st, requestedEpoch)
 	}
 	if err != nil {
 		httputil.HandleError(w, "Could not compute committee assignments: "+err.Error(), http.StatusInternalServerError)
@@ -815,7 +805,7 @@ func (s *Server) GetProposerDuties(w http.ResponseWriter, r *http.Request) {
 	}
 
 	duties := make([]*structs.ProposerDuty, 0)
-	for index, proposalSlots := range assignments {
+	for index, proposalSlots := range proposals {
 		val, err := st.ValidatorAtIndexReadOnly(index)
 		if err != nil {
 			httputil.HandleError(w, fmt.Sprintf("Could not get validator at index %d: %v", index, err), http.StatusInternalServerError)
@@ -832,20 +822,10 @@ func (s *Server) GetProposerDuties(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	var dependentRoot []byte
-	if requestedEpoch == 0 {
-		r, err := s.BeaconDB.GenesisBlockRoot(ctx)
-		if err != nil {
-			httputil.HandleError(w, "Could not get genesis block root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-		dependentRoot = r[:]
-	} else {
-		dependentRoot, err = proposalDependentRoot(st, requestedEpoch)
-		if err != nil {
-			httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
-			return
-		}
+	dependentRoot, err := proposalDependentRoot(st, requestedEpoch)
+	if err != nil {
+		httputil.HandleError(w, "Could not get dependent root: "+err.Error(), http.StatusInternalServerError)
+		return
 	}
 	isOptimistic, err := s.OptimisticModeFetcher.IsOptimistic(ctx)
 	if err != nil {

beacon-chain/rpc/eth/validator/handlers_test.go

@@ -1443,9 +1443,6 @@ func TestGetAttesterDuties(t *testing.T) {
 	chain := &mockChain.ChainService{
 		State: bs, Root: genesisRoot[:], Slot: &chainSlot,
 	}
-	db := dbutil.SetupDB(t)
-	require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), genesisRoot))
-
 	s := &Server{
 		Stater: &testutil.MockStater{
 			StatesBySlot: map[primitives.Slot]state.BeaconState{
@@ -1456,7 +1453,6 @@ func TestGetAttesterDuties(t *testing.T) {
 		TimeFetcher:           chain,
 		SyncChecker:           &mockSync.Sync{IsSyncing: false},
 		OptimisticModeFetcher: chain,
-		BeaconDB:              db,
 	}
 
 	t.Run("single validator", func(t *testing.T) {
@@ -1623,6 +1619,7 @@ func TestGetAttesterDuties(t *testing.T) {
 		blk.Block.Slot = 31
 		root, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
+		db := dbutil.SetupDB(t)
 		util.SaveBlock(t, ctx, db, blk)
 		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
@@ -1635,7 +1632,6 @@ func TestGetAttesterDuties(t *testing.T) {
 			TimeFetcher:           chain,
 			OptimisticModeFetcher: chain,
 			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-			BeaconDB:              db,
 		}
 
 		var body bytes.Buffer
@@ -1697,9 +1693,6 @@ func TestGetProposerDuties(t *testing.T) {
 		pubKeys[i] = deposits[i].Data.PublicKey
 	}
 
-	db := dbutil.SetupDB(t)
-	require.NoError(t, db.SaveGenesisBlockRoot(context.Background(), genesisRoot))
-
 	t.Run("ok", func(t *testing.T) {
 		bs, err := transition.GenesisBeaconState(context.Background(), deposits, 0, eth1Data)
 		require.NoError(t, err, "Could not set up genesis state")
@@ -1717,7 +1710,6 @@ func TestGetProposerDuties(t *testing.T) {
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			PayloadIDCache:         cache.NewPayloadIDCache(),
 			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v1/validator/duties/proposer/{epoch}", nil)
@@ -1745,7 +1737,6 @@ func TestGetProposerDuties(t *testing.T) {
 	t.Run("next epoch", func(t *testing.T) {
 		bs, err := transition.GenesisBeaconState(context.Background(), deposits, 0, eth1Data)
 		require.NoError(t, err, "Could not set up genesis state")
-		require.NoError(t, bs.SetSlot(params.BeaconConfig().SlotsPerEpoch))
 		require.NoError(t, bs.SetBlockRoots(roots))
 		chainSlot := primitives.Slot(0)
 		chain := &mockChain.ChainService{
@@ -1759,7 +1750,6 @@ func TestGetProposerDuties(t *testing.T) {
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			PayloadIDCache:         cache.NewPayloadIDCache(),
 			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v1/validator/duties/proposer/{epoch}", nil)
@@ -1802,7 +1792,6 @@ func TestGetProposerDuties(t *testing.T) {
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			PayloadIDCache:         cache.NewPayloadIDCache(),
 			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
 		}
 
 		currentEpoch := slots.ToEpoch(bs.Slot())
@@ -1819,6 +1808,7 @@ func TestGetProposerDuties(t *testing.T) {
 		assert.StringContains(t, fmt.Sprintf("Request epoch %d can not be greater than next epoch %d", currentEpoch+2, currentEpoch+1), e.Message)
 	})
 	t.Run("execution optimistic", func(t *testing.T) {
+		ctx := context.Background()
 		bs, err := transition.GenesisBeaconState(context.Background(), deposits, 0, eth1Data)
 		require.NoError(t, err, "Could not set up genesis state")
 		// Set state to non-epoch start slot.
@@ -1828,6 +1818,11 @@ func TestGetProposerDuties(t *testing.T) {
 		blk := util.NewBeaconBlock()
 		blk.Block.ParentRoot = parentRoot[:]
 		blk.Block.Slot = 31
+		root, err := blk.Block.HashTreeRoot()
+		require.NoError(t, err)
+		db := dbutil.SetupDB(t)
+		util.SaveBlock(t, ctx, db, blk)
+		require.NoError(t, db.SaveGenesisBlockRoot(ctx, root))
 
 		chainSlot := primitives.Slot(0)
 		chain := &mockChain.ChainService{
@@ -1841,7 +1836,6 @@ func TestGetProposerDuties(t *testing.T) {
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			PayloadIDCache:         cache.NewPayloadIDCache(),
 			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			BeaconDB:               db,
 		}
 
 		request := httptest.NewRequest(http.MethodGet, "http://www.example.com/eth/v1/validator/duties/proposer/{epoch}", nil)

beacon-chain/rpc/prysm/v1alpha1/beacon/assignments.go

@@ -105,28 +105,23 @@ func (bs *Server) ListValidatorAssignments(
 	}
 
 	// Initialize all committee related data.
-	assignments, err := helpers.CommitteeAssignments(ctx, requestedState, requestedEpoch, filteredIndices[start:end])
+	committeeAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(ctx, requestedState, requestedEpoch)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not compute committee assignments: %v", err)
 	}
 
-	proposalSlots, err := helpers.ProposerAssignments(ctx, requestedState, requestedEpoch)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not compute proposer slots: %v", err)
-	}
-
 	for _, index := range filteredIndices[start:end] {
 		if uint64(index) >= uint64(requestedState.NumValidators()) {
 			return nil, status.Errorf(codes.OutOfRange, "Validator index %d >= validator count %d",
 				index, requestedState.NumValidators())
 		}
-		a := assignments[index]
+		comAssignment := committeeAssignments[index]
 		pubkey := requestedState.PubkeyAtIndex(index)
 		assign := &ethpb.ValidatorAssignments_CommitteeAssignment{
-			BeaconCommittees: a.Committee,
-			CommitteeIndex:   a.CommitteeIndex,
-			AttesterSlot:     a.AttesterSlot,
-			ProposerSlots:    proposalSlots[index],
+			BeaconCommittees: comAssignment.Committee,
+			CommitteeIndex:   comAssignment.CommitteeIndex,
+			AttesterSlot:     comAssignment.AttesterSlot,
+			ProposerSlots:    proposerIndexToSlots[index],
 			PublicKey:        pubkey[:],
 			ValidatorIndex:   index,
 		}

beacon-chain/rpc/prysm/v1alpha1/beacon/assignments_test.go

@@ -174,18 +174,16 @@ func TestServer_ListAssignments_Pagination_DefaultPageSize_NoArchive(t *testing.
 
 	activeIndices, err := helpers.ActiveValidatorIndices(ctx, s, 0)
 	require.NoError(t, err)
-	assignments, err := helpers.CommitteeAssignments(context.Background(), s, 0, activeIndices[0:params.BeaconConfig().DefaultPageSize])
-	require.NoError(t, err)
-	proposerSlots, err := helpers.ProposerAssignments(ctx, s, 0)
+	committeeAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), s, 0)
 	require.NoError(t, err)
 	for _, index := range activeIndices[0:params.BeaconConfig().DefaultPageSize] {
 		val, err := s.ValidatorAtIndex(index)
 		require.NoError(t, err)
 		wanted = append(wanted, &ethpb.ValidatorAssignments_CommitteeAssignment{
-			BeaconCommittees: assignments[index].Committee,
-			CommitteeIndex:   assignments[index].CommitteeIndex,
-			AttesterSlot:     assignments[index].AttesterSlot,
-			ProposerSlots:    proposerSlots[index],
+			BeaconCommittees: committeeAssignments[index].Committee,
+			CommitteeIndex:   committeeAssignments[index].CommitteeIndex,
+			AttesterSlot:     committeeAssignments[index].AttesterSlot,
+			ProposerSlots:    proposerIndexToSlots[index],
 			PublicKey:        val.PublicKey,
 			ValidatorIndex:   index,
 		})
@@ -246,18 +244,16 @@ func TestServer_ListAssignments_FilterPubkeysIndices_NoPagination(t *testing.T)
 
 	activeIndices, err := helpers.ActiveValidatorIndices(ctx, s, 0)
 	require.NoError(t, err)
-	assignments, err := helpers.CommitteeAssignments(context.Background(), s, 0, activeIndices[1:4])
-	require.NoError(t, err)
-	proposerSlots, err := helpers.ProposerAssignments(ctx, s, 0)
+	committeeAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), s, 0)
 	require.NoError(t, err)
 	for _, index := range activeIndices[1:4] {
 		val, err := s.ValidatorAtIndex(index)
 		require.NoError(t, err)
 		wanted = append(wanted, &ethpb.ValidatorAssignments_CommitteeAssignment{
-			BeaconCommittees: assignments[index].Committee,
-			CommitteeIndex:   assignments[index].CommitteeIndex,
-			AttesterSlot:     assignments[index].AttesterSlot,
-			ProposerSlots:    proposerSlots[index],
+			BeaconCommittees: committeeAssignments[index].Committee,
+			CommitteeIndex:   committeeAssignments[index].CommitteeIndex,
+			AttesterSlot:     committeeAssignments[index].AttesterSlot,
+			ProposerSlots:    proposerIndexToSlots[index],
 			PublicKey:        val.PublicKey,
 			ValidatorIndex:   index,
 		})
@@ -316,18 +312,16 @@ func TestServer_ListAssignments_CanFilterPubkeysIndices_WithPagination(t *testin
 
 	activeIndices, err := helpers.ActiveValidatorIndices(ctx, s, 0)
 	require.NoError(t, err)
-	as, err := helpers.CommitteeAssignments(context.Background(), s, 0, activeIndices[3:5])
-	require.NoError(t, err)
-	proposalSlots, err := helpers.ProposerAssignments(ctx, s, 0)
+	committeeAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), s, 0)
 	require.NoError(t, err)
 	for _, index := range activeIndices[3:5] {
 		val, err := s.ValidatorAtIndex(index)
 		require.NoError(t, err)
 		assignments = append(assignments, &ethpb.ValidatorAssignments_CommitteeAssignment{
-			BeaconCommittees: as[index].Committee,
-			CommitteeIndex:   as[index].CommitteeIndex,
-			AttesterSlot:     as[index].AttesterSlot,
-			ProposerSlots:    proposalSlots[index],
+			BeaconCommittees: committeeAssignments[index].Committee,
+			CommitteeIndex:   committeeAssignments[index].CommitteeIndex,
+			AttesterSlot:     committeeAssignments[index].AttesterSlot,
+			ProposerSlots:    proposerIndexToSlots[index],
 			PublicKey:        val.PublicKey,
 			ValidatorIndex:   index,
 		})
@@ -346,18 +340,16 @@ func TestServer_ListAssignments_CanFilterPubkeysIndices_WithPagination(t *testin
 	req = &ethpb.ListValidatorAssignmentsRequest{Indices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6}, PageSize: 5, PageToken: "1"}
 	res, err = bs.ListValidatorAssignments(context.Background(), req)
 	require.NoError(t, err)
-	as, err = helpers.CommitteeAssignments(context.Background(), s, 0, activeIndices[6:7])
-	require.NoError(t, err)
-	proposalSlots, err = helpers.ProposerAssignments(ctx, s, 0)
+	cAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(context.Background(), s, 0)
 	require.NoError(t, err)
 	for _, index := range activeIndices[6:7] {
 		val, err := s.ValidatorAtIndex(index)
 		require.NoError(t, err)
 		assignments = append(assignments, &ethpb.ValidatorAssignments_CommitteeAssignment{
-			BeaconCommittees: as[index].Committee,
-			CommitteeIndex:   as[index].CommitteeIndex,
-			AttesterSlot:     as[index].AttesterSlot,
-			ProposerSlots:    proposalSlots[index],
+			BeaconCommittees: cAssignments[index].Committee,
+			CommitteeIndex:   cAssignments[index].CommitteeIndex,
+			AttesterSlot:     cAssignments[index].AttesterSlot,
+			ProposerSlots:    proposerIndexToSlots[index],
 			PublicKey:        val.PublicKey,
 			ValidatorIndex:   index,
 		})

beacon-chain/rpc/prysm/v1alpha1/validator/duties.go

@@ -7,7 +7,6 @@ import (
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -53,31 +52,16 @@ func (vs *Server) duties(ctx context.Context, req *ethpb.DutiesRequest) (*ethpb.
 			return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", epochStartSlot, err)
 		}
 	}
-
-	requestIndices := make([]primitives.ValidatorIndex, 0, len(req.PublicKeys))
-	for _, pubKey := range req.PublicKeys {
-		idx, ok := s.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
-		if !ok {
-			continue
-		}
-		requestIndices = append(requestIndices, idx)
-	}
-
-	assignments, err := helpers.CommitteeAssignments(ctx, s, req.Epoch, requestIndices)
+	committeeAssignments, proposerIndexToSlots, err := helpers.CommitteeAssignments(ctx, s, req.Epoch)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not compute committee assignments: %v", err)
 	}
 	// Query the next epoch assignments for committee subnet subscriptions.
-	nextEpochAssignments, err := helpers.CommitteeAssignments(ctx, s, req.Epoch+1, requestIndices)
+	nextCommitteeAssignments, _, err := helpers.CommitteeAssignments(ctx, s, req.Epoch+1)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not compute next committee assignments: %v", err)
 	}
 
-	proposalSlots, err := helpers.ProposerAssignments(ctx, s, req.Epoch)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not compute proposer slots: %v", err)
-	}
-
 	validatorAssignments := make([]*ethpb.DutiesResponse_Duty, 0, len(req.PublicKeys))
 	nextValidatorAssignments := make([]*ethpb.DutiesResponse_Duty, 0, len(req.PublicKeys))
 
@@ -97,20 +81,20 @@ func (vs *Server) duties(ctx context.Context, req *ethpb.DutiesRequest) (*ethpb.
 
 			assignment.ValidatorIndex = idx
 			assignment.Status = s
-			assignment.ProposerSlots = proposalSlots[idx]
+			assignment.ProposerSlots = proposerIndexToSlots[idx]
 
 			// The next epoch has no lookup for proposer indexes.
 			nextAssignment.ValidatorIndex = idx
 			nextAssignment.Status = s
 
-			ca, ok := assignments[idx]
+			ca, ok := committeeAssignments[idx]
 			if ok {
 				assignment.Committee = ca.Committee
 				assignment.AttesterSlot = ca.AttesterSlot
 				assignment.CommitteeIndex = ca.CommitteeIndex
 			}
 			// Save the next epoch assignments.
-			ca, ok = nextEpochAssignments[idx]
+			ca, ok = nextCommitteeAssignments[idx]
 			if ok {
 				nextAssignment.Committee = ca.Committee
 				nextAssignment.AttesterSlot = ca.AttesterSlot
@@ -139,9 +123,9 @@ func (vs *Server) duties(ctx context.Context, req *ethpb.DutiesRequest) (*ethpb.
 			// Next epoch sync committee duty is assigned with next period sync committee only during
 			// sync period epoch boundary (ie. EPOCHS_PER_SYNC_COMMITTEE_PERIOD - 1). Else wise
 			// next epoch sync committee duty is the same as current epoch.
-			nextEpoch := req.Epoch + 1
+			nextSlotToEpoch := slots.ToEpoch(s.Slot() + 1)
 			currentEpoch := coreTime.CurrentEpoch(s)
-			if slots.SyncCommitteePeriod(nextEpoch) > slots.SyncCommitteePeriod(currentEpoch) {
+			if slots.SyncCommitteePeriod(nextSlotToEpoch) == slots.SyncCommitteePeriod(currentEpoch)+1 {
 				nextAssignment.IsSyncCommittee, err = helpers.IsNextPeriodSyncCommittee(s, idx)
 				if err != nil {
 					return nil, status.Errorf(codes.Internal, "Could not determine next epoch sync committee: %v", err)

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -30,7 +30,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
-	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -363,32 +362,25 @@ func (vs *Server) broadcastReceiveBlock(ctx context.Context, block interfaces.Si
 
 // broadcastAndReceiveBlobs handles the broadcasting and reception of blob sidecars.
 func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethpb.BlobSidecar, root [32]byte) error {
-	eg, eCtx := errgroup.WithContext(ctx)
 	for i, sc := range sidecars {
-		// Copy the iteration instance to a local variable to give each go-routine its own copy to play with.
-		// See https://golang.org/doc/faq#closures_and_goroutines for more details.
-		subIdx := i
-		sCar := sc
-		eg.Go(func() error {
-			if err := vs.P2P.BroadcastBlob(eCtx, uint64(subIdx), sCar); err != nil {
-				return errors.Wrap(err, "broadcast blob failed")
-			}
-			readOnlySc, err := blocks.NewROBlobWithRoot(sCar, root)
-			if err != nil {
-				return errors.Wrap(err, "ROBlob creation failed")
-			}
-			verifiedBlob := blocks.NewVerifiedROBlob(readOnlySc)
-			if err := vs.BlobReceiver.ReceiveBlob(ctx, verifiedBlob); err != nil {
-				return errors.Wrap(err, "receive blob failed")
-			}
-			vs.OperationNotifier.OperationFeed().Send(&feed.Event{
-				Type: operation.BlobSidecarReceived,
-				Data: &operation.BlobSidecarReceivedData{Blob: &verifiedBlob},
-			})
-			return nil
+		if err := vs.P2P.BroadcastBlob(ctx, uint64(i), sc); err != nil {
+			return errors.Wrap(err, "broadcast blob failed")
+		}
+
+		readOnlySc, err := blocks.NewROBlobWithRoot(sc, root)
+		if err != nil {
+			return errors.Wrap(err, "ROBlob creation failed")
+		}
+		verifiedBlob := blocks.NewVerifiedROBlob(readOnlySc)
+		if err := vs.BlobReceiver.ReceiveBlob(ctx, verifiedBlob); err != nil {
+			return errors.Wrap(err, "receive blob failed")
+		}
+		vs.OperationNotifier.OperationFeed().Send(&feed.Event{
+			Type: operation.BlobSidecarReceived,
+			Data: &operation.BlobSidecarReceivedData{Blob: &verifiedBlob},
 		})
 	}
-	return eg.Wait()
+	return nil
 }
 
 // PrepareBeaconProposer caches and updates the fee recipient for the given proposer.

beacon-chain/rpc/prysm/v1alpha1/validator/server.go

@@ -99,15 +99,10 @@ func (vs *Server) WaitForActivation(req *ethpb.ValidatorActivationRequest, strea
 		return status.Errorf(codes.Internal, "Could not send response over stream: %v", err)
 	}
 
-	waitTime := time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
-	timer := time.NewTimer(waitTime)
-	defer timer.Stop()
-
 	for {
-		timer.Reset(waitTime)
 		select {
 		// Pinging every slot for activation.
-		case <-timer.C:
+		case <-time.After(time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second):
 			activeValidatorExists, validatorStatuses, err := vs.activationStatus(stream.Context(), req.PublicKeys)
 			if err != nil {
 				return status.Errorf(codes.Internal, "Could not fetch validator status: %v", err)

beacon-chain/state/state-native/README.md

@@ -1,24 +0,0 @@
-## Adding a new field to the state
-
-Note: Whenever only the name of a file is provided, it's assumed to be in the `/beacon-chain/state/state-native` package.
-
-- Add a `BeaconState[Version]FieldCount` configuration item to `/config/params/config.go` and set it in `/config/params/mainnet_config.go`.
-- Add the field to the `BeaconState` struct in `beacon_state_mainnet.go` and `beacon_state_minimal.go`. Update the marshaling code too.
-- Add the field's metadata to `/beacon-chain/state/state-native/types/types.go`.
-- Add a getter and a setter for the field, either to existing `getter_XXX.go`/`setter_XXX.go` files or create new ones if the field doesn't fit anywhere.
-Add the new getter and setter to `/beacon-chain/state/interfaces.go`.
-- Update state hashing in `hasher.go`.
-- Update `ToProtoUnsafe()` and `ToProto()` functions and add a new `ProtobufBeaconState[Version]` function, all in `getters_state.go`.
-- If the field is a multi-value slice, update `multi_value_slices.go`.
-- Update `spec_parameters.go`.
-- Update `state_trie.go`:
-  - Add a `[version]Fields` variable that contains all fields of the new state version.
-  - Add a `[version]SharedFieldRefCount` constant that represents the number of fields whose references are shared between states.
-  - Add an `experimentalState[Version]SharedFieldCountRef` constant that represents the number of **non multi-value slice** fields whose references are shared
-between states.
-  - Add the following functions: `InitializeFromProto[Version]()`, `InitializeFromProtoUnsafe[Version]()`.
-  - Update the following functions: `Copy()`, `initializeMerkleLayers()`, `RecordStateMetrics()` (applies only to multi-value slice fields), `rootSelector()`,
-`finalizerCleanup()` (applies only to multi-value slice fields).
-- If the field is a slice, add it to the field map in `types.go`.
-- If the field is a slice, update the `fieldConverters()` function in `/beacon-chain/state/fieldtrie/field_trie_helpers.go`. The exact implementation will vary
-depending on a few factors (is the field similar to an existing one, is it a multi-value slice etc.)

beacon-chain/state/state-native/state_test.go

@@ -20,6 +20,34 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
+func TestValidatorMap_DistinctCopy(t *testing.T) {
+	count := uint64(100)
+	vals := make([]*ethpb.Validator, 0, count)
+	for i := uint64(1); i < count; i++ {
+		var someRoot [32]byte
+		var someKey [fieldparams.BLSPubkeyLength]byte
+		copy(someRoot[:], strconv.Itoa(int(i)))
+		copy(someKey[:], strconv.Itoa(int(i)))
+		vals = append(vals, &ethpb.Validator{
+			PublicKey:                  someKey[:],
+			WithdrawalCredentials:      someRoot[:],
+			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
+			Slashed:                    false,
+			ActivationEligibilityEpoch: 1,
+			ActivationEpoch:            1,
+			ExitEpoch:                  1,
+			WithdrawableEpoch:          1,
+		})
+	}
+	handler := stateutil.NewValMapHandler(vals)
+	newHandler := handler.Copy()
+	wantedPubkey := strconv.Itoa(22)
+	handler.Set(bytesutil.ToBytes48([]byte(wantedPubkey)), 27)
+	val1, _ := handler.Get(bytesutil.ToBytes48([]byte(wantedPubkey)))
+	val2, _ := newHandler.Get(bytesutil.ToBytes48([]byte(wantedPubkey)))
+	assert.NotEqual(t, val1, val2, "Values are supposed to be unequal due to copy")
+}
+
 func TestBeaconState_NoDeadlock_Phase0(t *testing.T) {
 	count := uint64(100)
 	vals := make([]*ethpb.Validator, 0, count)

beacon-chain/state/stateutil/validator_map_handler.go

@@ -36,6 +36,24 @@ func (v *ValidatorMapHandler) IsNil() bool {
 	return v.mapRef == nil || v.valIdxMap == nil
 }
 
+// Copy the whole map and returns a map handler with the copied map.
+func (v *ValidatorMapHandler) Copy() *ValidatorMapHandler {
+	if v == nil || v.valIdxMap == nil {
+		return &ValidatorMapHandler{valIdxMap: map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex{}, mapRef: new(Reference), RWMutex: new(sync.RWMutex)}
+	}
+	v.RLock()
+	defer v.RUnlock()
+	m := make(map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex, len(v.valIdxMap))
+	for k, v := range v.valIdxMap {
+		m[k] = v
+	}
+	return &ValidatorMapHandler{
+		valIdxMap: m,
+		mapRef:    &Reference{refs: 1},
+		RWMutex:   new(sync.RWMutex),
+	}
+}
+
 // Get the validator index using the corresponding public key.
 func (v *ValidatorMapHandler) Get(key [fieldparams.BLSPubkeyLength]byte) (primitives.ValidatorIndex, bool) {
 	v.RLock()

beacon-chain/sync/initial-sync/blocks_fetcher.go

@@ -461,7 +461,7 @@ func (r *blobRange) Request() *p2ppb.BlobSidecarsByRangeRequest {
 	}
 	return &p2ppb.BlobSidecarsByRangeRequest{
 		StartSlot: r.low,
-		Count:     uint64(r.high.FlooredSubSlot(r.low)) + 1,
+		Count:     uint64(r.high.SubSlot(r.low)) + 1,
 	}
 }
 

cmd/beacon-chain/flags/base.go

@@ -230,7 +230,7 @@ var (
 	// MaxConcurrentDials defines a flag to set the maximum number of peers that a node will attempt to dial with from discovery.
 	MaxConcurrentDials = &cli.Uint64Flag{
 		Name: "max-concurrent-dials",
-		Usage: "Sets the maximum number of peers that a node will attempt to dial with from discovery. By default we will dials as " +
+		Usage: "Sets the maximum number of peers that a node will attempt to dial with from discovery. By default we will dials as" +
 			"many peers as possible.",
 	}
 	// SuggestedFeeRecipient specifies the fee recipient for the transaction fees.

config/params/config.go

@@ -157,6 +157,8 @@ type BeaconChainConfig struct {
 	CapellaForkEpoch     primitives.Epoch `yaml:"CAPELLA_FORK_EPOCH" spec:"true"`     // CapellaForkEpoch is used to represent the assigned fork epoch for capella.
 	DenebForkVersion     []byte           `yaml:"DENEB_FORK_VERSION" spec:"true"`     // DenebForkVersion is used to represent the fork version for deneb.
 	DenebForkEpoch       primitives.Epoch `yaml:"DENEB_FORK_EPOCH" spec:"true"`       // DenebForkEpoch is used to represent the assigned fork epoch for deneb.
+	ElectraForkVersion   []byte           `yaml:"ELECTRA_FORK_VERSION" spec:"true"`   // ElectraForkVersion is used to represent the fork version for deneb.
+	ElectraForkEpoch     primitives.Epoch `yaml:"ELECTRA_FORK_EPOCH" spec:"true"`     // ElectraForkEpoch is used to represent the assigned fork epoch for deneb.
 
 	ForkVersionSchedule map[[fieldparams.VersionLength]byte]primitives.Epoch // Schedule of fork epochs by version.
 	ForkVersionNames    map[[fieldparams.VersionLength]byte]string           // Human-readable names of fork versions.
@@ -226,6 +228,13 @@ type BeaconChainConfig struct {
 	MaxRequestBlobSidecars           uint64           `yaml:"MAX_REQUEST_BLOB_SIDECARS" spec:"true"`             // MaxRequestBlobSidecars is the maximum number of blobs to request in a single request.
 	MaxRequestBlocksDeneb            uint64           `yaml:"MAX_REQUEST_BLOCKS_DENEB" spec:"true"`              // MaxRequestBlocksDeneb is the maximum number of blocks in a single request after the deneb epoch.
 
+	// Values introduce in Electra upgrade
+	NumberOfColumns                     uint64 `yaml:"NUMBER_OF_COLUMNS" spec:"true"`                         // NumberOfColumns in the extended data matrix.
+	DataColumnSidecarSubnetCount        uint64 `yaml:"DATA_COLUMN_SIDECAR_SUBNET_COUNT" spec:"true"`          // DataColumnSidecarSubnetCount is the number of data column sidecar subnets used in the gossipsub protocol
+	MaxPerEpochActivationExitChurnLimit uint64 `yaml:"MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT" spec:"true"` // MaxPerEpochActivationExitChurnLimit represents the maximum combined activation and exit churn.
+	MinPerEpochChurnLimitElectra        uint64 `yaml:"MIN_PER_EPOCH_CHURN_LIMIT_ELECTRA" spec:"true"`         // MinPerEpochChurnLimitElectra is the minimum amount of churn allotted for validator rotations for electra.
+	MaxRequestDataColumnSidecars        uint64 `yaml:"MAX_REQUEST_DATA_COLUMN_SIDECARS" spec:"true"`          // MaxRequestDataColumnSidecars is the maximum number of data column sidecars in a single request
+
 	// Networking Specific Parameters
 	GossipMaxSize                   uint64          `yaml:"GOSSIP_MAX_SIZE" spec:"true"`                    // GossipMaxSize is the maximum allowed size of uncompressed gossip messages.
 	MaxChunkSize                    uint64          `yaml:"MAX_CHUNK_SIZE" spec:"true"`                     // MaxChunkSize is the maximum allowed size of uncompressed req/resp chunked responses.

config/params/mainnet_config.go

@@ -27,6 +27,8 @@ const (
 	mainnetCapellaForkEpoch = 194048 // April 12, 2023, 22:27:35 UTC
 	// Deneb Fork Epoch for mainnet config.
 	mainnetDenebForkEpoch = 269568 // March 13, 2024, 13:55:35 UTC
+	// Electra Fork Epoch for mainnet config
+	mainnetElectraForkEpoch = math.MaxUint64 // Far future / to be defined
 )
 
 var mainnetNetworkConfig = &NetworkConfig{
@@ -207,6 +209,8 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	CapellaForkEpoch:     mainnetCapellaForkEpoch,
 	DenebForkVersion:     []byte{4, 0, 0, 0},
 	DenebForkEpoch:       mainnetDenebForkEpoch,
+	ElectraForkVersion:   []byte{5, 0, 0, 0},
+	ElectraForkEpoch:     mainnetElectraForkEpoch,
 
 	// New values introduced in Altair hard fork 1.
 	// Participation flag indices.
@@ -265,6 +269,13 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxRequestBlobSidecars:           768,
 	MaxRequestBlocksDeneb:            128,
 
+	// Values related to electra
+	NumberOfColumns:                     128,
+	MaxRequestDataColumnSidecars:        16384,
+	DataColumnSidecarSubnetCount:        32,
+	MinPerEpochChurnLimitElectra:        128000000000,
+	MaxPerEpochActivationExitChurnLimit: 256000000000,
+
 	// Values related to networking parameters.
 	GossipMaxSize:                   10 * 1 << 20, // 10 MiB
 	MaxChunkSize:                    10 * 1 << 20, // 10 MiB

config/params/minimal_config.go

@@ -91,12 +91,18 @@ func MinimalSpecConfig() *BeaconChainConfig {
 	minimalConfig.CapellaForkEpoch = math.MaxUint64
 	minimalConfig.DenebForkVersion = []byte{4, 0, 0, 1}
 	minimalConfig.DenebForkEpoch = math.MaxUint64
+	minimalConfig.ElectraForkVersion = []byte{5, 0, 0, 1}
+	minimalConfig.AltairForkEpoch = math.MaxUint64
 
 	minimalConfig.SyncCommitteeSize = 32
 	minimalConfig.InactivityScoreBias = 4
 	minimalConfig.EpochsPerSyncCommitteePeriod = 8
 	minimalConfig.MinEpochsForBlockRequests = 272
 
+	// New Electra params
+	minimalConfig.MinPerEpochChurnLimitElectra = 64000000000
+	minimalConfig.MaxPerEpochActivationExitChurnLimit = 128000000000
+
 	// Ethereum PoW parameters.
 	minimalConfig.DepositChainID = 5   // Chain ID of eth1 goerli.
 	minimalConfig.DepositNetworkID = 5 // Network ID of eth1 goerli.

consensus-types/primitives/slot.go

@@ -124,14 +124,6 @@ func (s Slot) SubSlot(x Slot) Slot {
 	return s.Sub(uint64(x))
 }
 
-// FlooredSubSlot safely subtracts x from the slot, returning 0 if the result would underflow.
-func (s Slot) FlooredSubSlot(x Slot) Slot {
-	if s < x {
-		return 0
-	}
-	return s - x
-}
-
 // SafeSubSlot finds difference between two slot values.
 // In case of arithmetic issues (overflow/underflow/div by zero) error is returned.
 func (s Slot) SafeSubSlot(x Slot) (Slot, error) {

deps.bzl

@@ -705,8 +705,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_decred_dcrd_dcrec_secp256k1_v4",
         importpath = "github.com/decred/dcrd/dcrec/secp256k1/v4",
-        sum = "h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=",
-        version = "v4.3.0",
+        sum = "h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=",
+        version = "v4.2.0",
     )
     go_repository(
         name = "com_github_deepmap_oapi_codegen",
@@ -1295,8 +1295,8 @@ def prysm_deps():
         importpath = "github.com/golang/protobuf",
         patch_args = ["-p1"],
         patches = ["@io_bazel_rules_go//third_party:com_github_golang_protobuf-extras.patch"],
-        sum = "h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=",
-        version = "v1.5.4",
+        sum = "h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=",
+        version = "v1.5.3",
     )
     go_repository(
         name = "com_github_golang_snappy",
@@ -1607,14 +1607,14 @@ def prysm_deps():
     go_repository(
         name = "com_github_hashicorp_golang_lru_arc_v2",
         importpath = "github.com/hashicorp/golang-lru/arc/v2",
-        sum = "h1:QxkVTxwColcduO+LP7eJO56r2hFiG8zEbfAAzRv52KQ=",
-        version = "v2.0.7",
+        sum = "h1:l2zaLDubNhW4XO3LnliVj0GXO3+/CGNJAg1dcN2Fpfw=",
+        version = "v2.0.5",
     )
     go_repository(
         name = "com_github_hashicorp_golang_lru_v2",
         importpath = "github.com/hashicorp/golang-lru/v2",
-        sum = "h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=",
-        version = "v2.0.7",
+        sum = "h1:wW7h1TG88eUIJ2i69gaE3uNVtEPIagzhGvHgwfx2Vm4=",
+        version = "v2.0.5",
     )
     go_repository(
         name = "com_github_hashicorp_hcl",
@@ -1975,8 +1975,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_klauspost_compress",
         importpath = "github.com/klauspost/compress",
-        sum = "h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=",
-        version = "v1.17.8",
+        sum = "h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=",
+        version = "v1.17.6",
     )
     go_repository(
         name = "com_github_klauspost_cpuid",
@@ -2105,8 +2105,8 @@ def prysm_deps():
         ],
         build_file_proto_mode = "disable_global",
         importpath = "github.com/libp2p/go-libp2p",
-        sum = "h1:1xS1Bkr9X7GtdvV6ntLnDV9xB1kNjHK1lZ0eaO6gnhc=",
-        version = "v0.35.0",
+        sum = "h1:tvJl9b9M6nSLBtZSXSguq+/lRhRj2oLRkyhBmQNMFLA=",
+        version = "v0.33.1",
     )
     go_repository(
         name = "com_github_libp2p_go_libp2p_asn_util",
@@ -2124,8 +2124,8 @@ def prysm_deps():
         name = "com_github_libp2p_go_libp2p_pubsub",
         build_file_proto_mode = "disable_global",
         importpath = "github.com/libp2p/go-libp2p-pubsub",
-        sum = "h1:+JvS8Kty0OiyUiN0i8H5JbaCgjnJTRnTHe4rU88dLFc=",
-        version = "v0.11.0",
+        sum = "h1:wS0S5FlISavMaAbxyQn3dxMOe2eegMfswM471RuHJwA=",
+        version = "v0.10.0",
     )
     go_repository(
         name = "com_github_libp2p_go_libp2p_testing",
@@ -2448,8 +2448,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_multiformats_go_multiaddr",
         importpath = "github.com/multiformats/go-multiaddr",
-        sum = "h1:rrKqpY9h+n80EwhhC/kkcunCZZ7URIF8yN1WEUt2Hvc=",
-        version = "v0.12.4",
+        sum = "h1:9G9sTY/wCYajKa9lyfWPmpZAwe6oV+Wb1zcmMS1HG24=",
+        version = "v0.12.2",
     )
     go_repository(
         name = "com_github_multiformats_go_multiaddr_dns",
@@ -2577,8 +2577,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_nxadm_tail",
         importpath = "github.com/nxadm/tail",
-        sum = "h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=",
-        version = "v1.4.11",
+        sum = "h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=",
+        version = "v1.4.8",
     )
     go_repository(
         name = "com_github_nytimes_gziphandler",
@@ -2787,26 +2787,26 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_datachannel",
         importpath = "github.com/pion/datachannel",
-        sum = "h1:1IxKJntfSlYkpUj8LlYRSWpYiTTC02nUrOE8T3DqGeg=",
-        version = "v1.5.6",
+        sum = "h1:10ef4kwdjije+M9d7Xm9im2Y3O6A6ccQb0zcqZcJew8=",
+        version = "v1.5.5",
     )
     go_repository(
         name = "com_github_pion_dtls_v2",
         importpath = "github.com/pion/dtls/v2",
-        sum = "h1:9U/dpCYl1ySttROPWJgqWKEylUdT0fXp/xst6JwY5Ks=",
-        version = "v2.2.11",
+        sum = "h1:BUroldfiIbV9jSnC6cKOMnyiORRWrWWpV11JUyEu5OA=",
+        version = "v2.2.8",
     )
     go_repository(
         name = "com_github_pion_ice_v2",
         importpath = "github.com/pion/ice/v2",
-        sum = "h1:RYgzhH/u5lH0XO+ABatVKCtRd+4U1GEaCXSMjNr13tI=",
-        version = "v2.3.24",
+        sum = "h1:rZjVmUwyT55cmN8ySMpL7rsS8KYsJERsrxJLLxpKhdw=",
+        version = "v2.3.11",
     )
     go_repository(
         name = "com_github_pion_interceptor",
         importpath = "github.com/pion/interceptor",
-        sum = "h1:39fsnlP1U8gw2JzOFWdfCU82vHvhW9o0rZnZF56wF+M=",
-        version = "v0.1.29",
+        sum = "h1:pwY9r7P6ToQ3+IF0bajN0xmk/fNw/suTgaTdlwTDmhc=",
+        version = "v0.1.25",
     )
     go_repository(
         name = "com_github_pion_logging",
@@ -2817,8 +2817,8 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_mdns",
         importpath = "github.com/pion/mdns",
-        sum = "h1:CiMYlY+O0azojWDmxdNr7ADGrnZ+V6Ilfner+6mSVK8=",
-        version = "v0.0.12",
+        sum = "h1:7Ue5KZsqq8EuqStnpPWV33vYYEH0+skdDN5L7EiEsI4=",
+        version = "v0.0.9",
     )
     go_repository(
         name = "com_github_pion_randutil",
@@ -2829,26 +2829,26 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_rtcp",
         importpath = "github.com/pion/rtcp",
-        sum = "h1:KCkGV3vJ+4DAJmvP0vaQShsb0xkRfWkO540Gy102KyE=",
-        version = "v1.2.14",
+        sum = "h1:+EQijuisKwm/8VBs8nWllr0bIndR7Lf7cZG200mpbNo=",
+        version = "v1.2.13",
     )
     go_repository(
         name = "com_github_pion_rtp",
         importpath = "github.com/pion/rtp",
-        sum = "h1:MTmn/b0aWWsAzux2AmP8WGllusBVw4NPYPVFFd7jUPw=",
-        version = "v1.8.6",
+        sum = "h1:VEHxqzSVQxCkKDSHro5/4IUUG1ea+MFdqR2R3xSpNU8=",
+        version = "v1.8.3",
     )
     go_repository(
         name = "com_github_pion_sctp",
         importpath = "github.com/pion/sctp",
-        sum = "h1:PKrMs+o9EMLRvFfXq59WFsC+V8mN1wnKzqrv+3D/gYY=",
-        version = "v1.8.16",
+        sum = "h1:TP5ZVxV5J7rz7uZmbyvnUvsn7EJ2x/5q9uhsTtXbI3g=",
+        version = "v1.8.9",
     )
     go_repository(
         name = "com_github_pion_sdp_v3",
         importpath = "github.com/pion/sdp/v3",
-        sum = "h1:pX++dCHoHUwq43kuwf3PyJfHlwIj4hXA7Vrifiq0IJY=",
-        version = "v3.0.9",
+        sum = "h1:WuDLhtuFUUVpTfus9ILC4HRyHsW6TdugjEX/QY9OiUw=",
+        version = "v3.0.6",
     )
     go_repository(
         name = "com_github_pion_srtp_v2",
@@ -2865,26 +2865,20 @@ def prysm_deps():
     go_repository(
         name = "com_github_pion_transport_v2",
         importpath = "github.com/pion/transport/v2",
-        sum = "h1:iyi25i/21gQck4hfRhomF6SktmUQjRsRW4WJdhfc3Kc=",
-        version = "v2.2.5",
-    )
-    go_repository(
-        name = "com_github_pion_transport_v3",
-        importpath = "github.com/pion/transport/v3",
-        sum = "h1:r+40RJR25S9w3jbA6/5uEPTzcdn7ncyU44RWCbHkLg4=",
-        version = "v3.0.2",
+        sum = "h1:41JJK6DZQYSeVLxILA2+F4ZkKb4Xd/tFJZRFZQ9QAlo=",
+        version = "v2.2.4",
     )
     go_repository(
         name = "com_github_pion_turn_v2",
         importpath = "github.com/pion/turn/v2",
-        sum = "h1:Xr2niVsiPTB0FPtt+yAWKFUkU1eotQbGgpTIld4x1Gc=",
-        version = "v2.1.6",
+        sum = "h1:2xn8rduI5W6sCZQkEnIUDAkrBQNl2eYIBCHMZ3QMmP8=",
+        version = "v2.1.4",
     )
     go_repository(
         name = "com_github_pion_webrtc_v3",
         importpath = "github.com/pion/webrtc/v3",
-        sum = "h1:Wtfi6AZMQg+624cvCXUuSmrKWepSB7zfgYDOYqsSOVU=",
-        version = "v3.2.40",
+        sum = "h1:GbqEuxBbVLFhXk0GwxKAoaIJYiEa9TyoZPEZC+2HZxM=",
+        version = "v3.2.23",
     )
     go_repository(
         name = "com_github_pkg_diff",
@@ -2931,20 +2925,20 @@ def prysm_deps():
     go_repository(
         name = "com_github_prometheus_client_golang",
         importpath = "github.com/prometheus/client_golang",
-        sum = "h1:wZWJDwK+NameRJuPGDhlnFgx8e8HN3XHQeLaYJFJBOE=",
-        version = "v1.19.1",
+        sum = "h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk=",
+        version = "v1.18.0",
     )
     go_repository(
         name = "com_github_prometheus_client_model",
         importpath = "github.com/prometheus/client_model",
-        sum = "h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=",
-        version = "v0.6.1",
+        sum = "h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos=",
+        version = "v0.6.0",
     )
     go_repository(
         name = "com_github_prometheus_common",
         importpath = "github.com/prometheus/common",
-        sum = "h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=",
-        version = "v0.48.0",
+        sum = "h1:p5Cz0FNHo7SnWOmWmoRozVcjEp0bIVU8cV7OShpjL1k=",
+        version = "v0.47.0",
     )
     go_repository(
         name = "com_github_prometheus_procfs",
@@ -3021,6 +3015,15 @@ def prysm_deps():
         sum = "h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=",
         version = "v0.4.0",
     )
+    go_repository(
+        name = "com_github_quic_go_qtls_go1_20",
+        build_directives = [
+            "gazelle:exclude generate_cert.go",
+        ],
+        importpath = "github.com/quic-go/qtls-go1-20",
+        sum = "h1:MfFAPULvst4yoMgY9QmtpYmfij/em7O8UUi+bNVm7Cg=",
+        version = "v0.3.4",
+    )
     go_repository(
         name = "com_github_quic_go_quic_go",
         build_directives = [
@@ -3028,14 +3031,14 @@ def prysm_deps():
             "gazelle:exclude tools.go",
         ],
         importpath = "github.com/quic-go/quic-go",
-        sum = "h1:So5wOr7jyO4vzL2sd8/pD9Kesciv91zSk8BoFngItQ0=",
-        version = "v0.44.0",
+        sum = "h1:uSfdap0eveIl8KXnipv9K7nlwZ5IqLlYOpJ58u5utpM=",
+        version = "v0.42.0",
     )
     go_repository(
         name = "com_github_quic_go_webtransport_go",
         importpath = "github.com/quic-go/webtransport-go",
-        sum = "h1:HxSrwun11U+LlmwpgM1kEqIqH90IT4N8auv/cD7QFJg=",
-        version = "v0.8.0",
+        sum = "h1:CvNsKqc4W2HljHJnoT+rMmbRJybShZ0YPFDD3NxaZLY=",
+        version = "v0.6.0",
     )
     go_repository(
         name = "com_github_raulk_go_watchdog",
@@ -3125,12 +3128,6 @@ def prysm_deps():
         sum = "h1:nMinx+JaEm/zJz4cEyClQeAw5rsYSB5th3xv+5lV6Vg=",
         version = "v3.3.4",
     )
-    go_repository(
-        name = "com_github_sclevine_agouti",
-        importpath = "github.com/sclevine/agouti",
-        sum = "h1:8IBJS6PWz3uTlMP3YBIR5f+KAldcGuOeFkFbUWfBgK4=",
-        version = "v3.0.0+incompatible",
-    )
     go_repository(
         name = "com_github_sean_seed",
         importpath = "github.com/sean-/seed",
@@ -3410,14 +3407,14 @@ def prysm_deps():
     go_repository(
         name = "com_github_stretchr_objx",
         importpath = "github.com/stretchr/objx",
-        sum = "h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=",
-        version = "v0.5.2",
+        sum = "h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=",
+        version = "v0.5.0",
     )
     go_repository(
         name = "com_github_stretchr_testify",
         importpath = "github.com/stretchr/testify",
-        sum = "h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=",
-        version = "v1.9.0",
+        sum = "h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=",
+        version = "v1.8.4",
     )
     go_repository(
         name = "com_github_subosito_gotenv",
@@ -4786,8 +4783,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_google_protobuf",
         importpath = "google.golang.org/protobuf",
-        sum = "h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=",
-        version = "v1.34.1",
+        sum = "h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=",
+        version = "v1.32.0",
     )
     go_repository(
         name = "org_golang_x_build",
@@ -4798,14 +4795,14 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_crypto",
         importpath = "golang.org/x/crypto",
-        sum = "h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=",
-        version = "v0.23.0",
+        sum = "h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=",
+        version = "v0.19.0",
     )
     go_repository(
         name = "org_golang_x_exp",
         importpath = "golang.org/x/exp",
-        sum = "h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=",
-        version = "v0.0.0-20240506185415-9bf2ced13842",
+        sum = "h1:HinSgX1tJRX3KsL//Gxynpw5CTOAIPhgL4W8PNiIpVE=",
+        version = "v0.0.0-20240213143201-ec583247a57a",
     )
     go_repository(
         name = "org_golang_x_exp_typeparams",
@@ -4834,14 +4831,14 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_mod",
         importpath = "golang.org/x/mod",
-        sum = "h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=",
-        version = "v0.17.0",
+        sum = "h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8=",
+        version = "v0.15.0",
     )
     go_repository(
         name = "org_golang_x_net",
         importpath = "golang.org/x/net",
-        sum = "h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=",
-        version = "v0.25.0",
+        sum = "h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=",
+        version = "v0.21.0",
     )
     go_repository(
         name = "org_golang_x_oauth2",
@@ -4858,32 +4855,32 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_sync",
         importpath = "golang.org/x/sync",
-        sum = "h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=",
-        version = "v0.7.0",
+        sum = "h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=",
+        version = "v0.6.0",
     )
     go_repository(
         name = "org_golang_x_sys",
         importpath = "golang.org/x/sys",
-        sum = "h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=",
-        version = "v0.20.0",
+        sum = "h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=",
+        version = "v0.17.0",
     )
     go_repository(
         name = "org_golang_x_telemetry",
         importpath = "golang.org/x/telemetry",
-        sum = "h1:IRJeR9r1pYWsHKTRe/IInb7lYvbBVIqOgsX/u0mbOWY=",
-        version = "v0.0.0-20240228155512-f48c80bd79b2",
+        sum = "h1:+Kc94D8UVEVxJnLXp/+FMfqQARZtWHfVrcRtcG8aT3g=",
+        version = "v0.0.0-20240208230135-b75ee8823808",
     )
     go_repository(
         name = "org_golang_x_term",
         importpath = "golang.org/x/term",
-        sum = "h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=",
-        version = "v0.20.0",
+        sum = "h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=",
+        version = "v0.17.0",
     )
     go_repository(
         name = "org_golang_x_text",
         importpath = "golang.org/x/text",
-        sum = "h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=",
-        version = "v0.15.0",
+        sum = "h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=",
+        version = "v0.14.0",
     )
     go_repository(
         name = "org_golang_x_time",
@@ -4894,8 +4891,8 @@ def prysm_deps():
     go_repository(
         name = "org_golang_x_tools",
         importpath = "golang.org/x/tools",
-        sum = "h1:qc0xYgIbsSDt9EyWz05J5wfa7LOVW0YTLOXrqdLAWIw=",
-        version = "v0.21.0",
+        sum = "h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ=",
+        version = "v0.18.0",
     )
     go_repository(
         name = "org_golang_x_xerrors",
@@ -4906,8 +4903,8 @@ def prysm_deps():
     go_repository(
         name = "org_uber_go_atomic",
         importpath = "go.uber.org/atomic",
-        sum = "h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=",
-        version = "v1.7.0",
+        sum = "h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=",
+        version = "v1.11.0",
     )
     go_repository(
         name = "org_uber_go_automaxprocs",
@@ -4929,8 +4926,8 @@ def prysm_deps():
     go_repository(
         name = "org_uber_go_fx",
         importpath = "go.uber.org/fx",
-        sum = "h1:RqBh3cYdzZS0uqwVeEjOX2p73dddLpym315myy/Bpb0=",
-        version = "v1.21.1",
+        sum = "h1:zVwVQGS8zYvhh9Xxcu4w1M6ESyeMzebzj2NbSayZ4Mk=",
+        version = "v1.20.1",
     )
     go_repository(
         name = "org_uber_go_goleak",

go.mod

@@ -25,7 +25,7 @@ require (
 	github.com/gogo/protobuf v1.3.2
 	github.com/golang-jwt/jwt/v4 v4.5.0
 	github.com/golang/gddo v0.0.0-20200528160355-8d077c1d8f4c
-	github.com/golang/protobuf v1.5.4
+	github.com/golang/protobuf v1.5.3
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb
 	github.com/google/gofuzz v1.2.0
 	github.com/google/uuid v1.4.0
@@ -44,9 +44,9 @@ require (
 	github.com/json-iterator/go v1.1.12
 	github.com/k0kubun/go-ansi v0.0.0-20180517002512-3bf9e2903213
 	github.com/kr/pretty v0.3.1
-	github.com/libp2p/go-libp2p v0.35.0
+	github.com/libp2p/go-libp2p v0.33.1
 	github.com/libp2p/go-libp2p-mplex v0.9.0
-	github.com/libp2p/go-libp2p-pubsub v0.11.0
+	github.com/libp2p/go-libp2p-pubsub v0.10.0
 	github.com/libp2p/go-mplex v0.7.0
 	github.com/logrusorgru/aurora v2.0.3+incompatible
 	github.com/manifoldco/promptui v0.7.0
@@ -54,15 +54,15 @@ require (
 	github.com/minio/highwayhash v1.0.2
 	github.com/minio/sha256-simd v1.0.1
 	github.com/mohae/deepcopy v0.0.0-20170929034955-c48cc78d4826
-	github.com/multiformats/go-multiaddr v0.12.4
+	github.com/multiformats/go-multiaddr v0.12.2
 	github.com/onsi/ginkgo v1.16.5
 	github.com/onsi/gomega v1.30.0
 	github.com/patrickmn/go-cache v2.1.0+incompatible
 	github.com/paulbellamy/ratecounter v0.2.0
 	github.com/pborman/uuid v1.2.1
 	github.com/pkg/errors v0.9.1
-	github.com/prometheus/client_golang v1.19.1
-	github.com/prometheus/client_model v0.6.1
+	github.com/prometheus/client_golang v1.18.0
+	github.com/prometheus/client_model v0.6.0
 	github.com/prometheus/prom2json v1.3.0
 	github.com/prysmaticlabs/fastssz v0.0.0-20221107182844-78142813af44
 	github.com/prysmaticlabs/go-bitfield v0.0.0-20210809151128-385d8c5e3fb7
@@ -73,7 +73,7 @@ require (
 	github.com/sirupsen/logrus v1.9.0
 	github.com/spf13/afero v1.10.0
 	github.com/status-im/keycard-go v0.2.0
-	github.com/stretchr/testify v1.9.0
+	github.com/stretchr/testify v1.8.4
 	github.com/supranational/blst v0.3.11
 	github.com/thomaso-mirodin/intmath v0.0.0-20160323211736-5dc6d854e46e
 	github.com/trailofbits/go-mutexasserts v0.0.0-20230328101604-8cdbc5f3d279
@@ -87,14 +87,14 @@ require (
 	go.opencensus.io v0.24.0
 	go.uber.org/automaxprocs v1.5.2
 	go.uber.org/mock v0.4.0
-	golang.org/x/crypto v0.23.0
-	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842
-	golang.org/x/mod v0.17.0
-	golang.org/x/sync v0.7.0
-	golang.org/x/tools v0.21.0
+	golang.org/x/crypto v0.19.0
+	golang.org/x/exp v0.0.0-20240213143201-ec583247a57a
+	golang.org/x/mod v0.15.0
+	golang.org/x/sync v0.6.0
+	golang.org/x/tools v0.18.0
 	google.golang.org/genproto v0.0.0-20230410155749-daa745c078e1
 	google.golang.org/grpc v1.56.3
-	google.golang.org/protobuf v1.34.1
+	google.golang.org/protobuf v1.32.0
 	gopkg.in/d4l3k/messagediff.v1 v1.2.1
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
@@ -127,7 +127,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/davidlazar/go-crypto v0.0.0-20200604182044-b73af7476f6c // indirect
 	github.com/deckarep/golang-set/v2 v2.5.0 // indirect
-	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 // indirect
+	github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 // indirect
 	github.com/deepmap/oapi-codegen v1.8.2 // indirect
 	github.com/dlclark/regexp2 v1.7.0 // indirect
 	github.com/docker/go-units v0.5.0 // indirect
@@ -152,7 +152,7 @@ require (
 	github.com/gorilla/websocket v1.5.1 // indirect
 	github.com/graph-gophers/graphql-go v1.3.0 // indirect
 	github.com/hashicorp/go-bexpr v0.1.10 // indirect
-	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
+	github.com/hashicorp/golang-lru/v2 v2.0.5 // indirect
 	github.com/holiman/billy v0.0.0-20230718173358-1c7e68d277a7 // indirect
 	github.com/holiman/bloomfilter/v2 v2.0.3 // indirect
 	github.com/holiman/goevmlab v0.0.0-20231201084119-c73b3c97929c // indirect
@@ -165,7 +165,7 @@ require (
 	github.com/jbenet/go-temp-err-catcher v0.1.0 // indirect
 	github.com/juju/ansiterm v0.0.0-20180109212912-720a0952cc2a // indirect
 	github.com/karalabe/usb v0.0.3-0.20230711191512-61db3e06439c // indirect
-	github.com/klauspost/compress v1.17.8 // indirect
+	github.com/klauspost/compress v1.17.6 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
 	github.com/koron/go-ssdp v0.0.4 // indirect
 	github.com/kr/text v0.2.0 // indirect
@@ -203,41 +203,25 @@ require (
 	github.com/multiformats/go-multihash v0.2.3 // indirect
 	github.com/multiformats/go-multistream v0.5.0 // indirect
 	github.com/multiformats/go-varint v0.0.7 // indirect
-	github.com/nxadm/tail v1.4.11 // indirect
+	github.com/nxadm/tail v1.4.8 // indirect
 	github.com/olekukonko/tablewriter v0.0.5 // indirect
 	github.com/onsi/ginkgo/v2 v2.15.0 // indirect
 	github.com/opencontainers/runtime-spec v1.2.0 // indirect
 	github.com/opentracing/opentracing-go v1.2.0 // indirect
 	github.com/pbnjay/memory v0.0.0-20210728143218-7b4eea64cf58 // indirect
-	github.com/pion/datachannel v1.5.6 // indirect
-	github.com/pion/dtls/v2 v2.2.11 // indirect
-	github.com/pion/ice/v2 v2.3.24 // indirect
-	github.com/pion/interceptor v0.1.29 // indirect
-	github.com/pion/logging v0.2.2 // indirect
-	github.com/pion/mdns v0.0.12 // indirect
-	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/rtcp v1.2.14 // indirect
-	github.com/pion/rtp v1.8.6 // indirect
-	github.com/pion/sctp v1.8.16 // indirect
-	github.com/pion/sdp/v3 v3.0.9 // indirect
-	github.com/pion/srtp/v2 v2.0.18 // indirect
-	github.com/pion/stun v0.6.1 // indirect
-	github.com/pion/transport/v2 v2.2.5 // indirect
-	github.com/pion/turn/v2 v2.1.6 // indirect
-	github.com/pion/webrtc/v3 v3.2.40 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/prometheus/common v0.48.0 // indirect
+	github.com/prometheus/common v0.47.0 // indirect
 	github.com/prometheus/procfs v0.12.0 // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
-	github.com/quic-go/quic-go v0.44.0 // indirect
-	github.com/quic-go/webtransport-go v0.8.0 // indirect
+	github.com/quic-go/quic-go v0.42.0 // indirect
+	github.com/quic-go/webtransport-go v0.6.0 // indirect
 	github.com/raulk/go-watchdog v1.3.0 // indirect
 	github.com/rivo/uniseg v0.4.4 // indirect
 	github.com/rogpeppe/go-internal v1.11.0 // indirect
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/shirou/gopsutil v3.21.11+incompatible // indirect
 	github.com/spaolacci/murmur3 v1.1.0 // indirect
-	github.com/stretchr/objx v0.5.2 // indirect
+	github.com/stretchr/objx v0.5.0 // indirect
 	github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 // indirect
 	github.com/tklauser/go-sysconf v0.3.13 // indirect
 	github.com/tklauser/numcpus v0.7.0 // indirect
@@ -246,14 +230,14 @@ require (
 	github.com/xrash/smetrics v0.0.0-20201216005158-039620a65673 // indirect
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
 	go.uber.org/dig v1.17.1 // indirect
-	go.uber.org/fx v1.21.1 // indirect
+	go.uber.org/fx v1.20.1 // indirect
 	go.uber.org/multierr v1.11.0 // indirect
 	go.uber.org/zap v1.27.0 // indirect
 	golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 // indirect
-	golang.org/x/net v0.25.0 // indirect
+	golang.org/x/net v0.21.0 // indirect
 	golang.org/x/oauth2 v0.16.0 // indirect
-	golang.org/x/term v0.20.0 // indirect
-	golang.org/x/text v0.15.0 // indirect
+	golang.org/x/term v0.17.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 	golang.org/x/time v0.5.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect
 	gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
@@ -273,7 +257,7 @@ require (
 	github.com/go-playground/validator/v10 v10.13.0
 	github.com/peterh/liner v1.2.0 // indirect
 	github.com/prysmaticlabs/gohashtree v0.0.4-beta
-	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/sys v0.17.0 // indirect
 	google.golang.org/api v0.44.0 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
 	k8s.io/klog/v2 v2.80.0 // indirect

go.sum

@@ -215,8 +215,8 @@ github.com/deckarep/golang-set/v2 v2.5.0 h1:hn6cEZtQ0h3J8kFrHR/NrzyOoTnjgW1+FmNJ
 github.com/deckarep/golang-set/v2 v2.5.0/go.mod h1:VAky9rY/yGXJOLEDv3OMci+7wtDpOF4IN+y82NBOac4=
 github.com/decred/dcrd/crypto/blake256 v1.0.1 h1:7PltbUIQB7u/FfZ39+DGa/ShuMyJ5ilcvdfma9wOH6Y=
 github.com/decred/dcrd/crypto/blake256 v1.0.1/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0 h1:rpfIENRNNilwHwZeG5+P150SMrnNEcHYvcCuK6dPZSg=
-github.com/decred/dcrd/dcrec/secp256k1/v4 v4.3.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0 h1:8UrgZ3GkP4i/CLijOJx79Yu+etlyjdBU4sfcs2WYQMs=
+github.com/decred/dcrd/dcrec/secp256k1/v4 v4.2.0/go.mod h1:v57UDF4pDQJcEfFUCRop3lJL149eHGSe9Jvczhzjo/0=
 github.com/deepmap/oapi-codegen v1.6.0/go.mod h1:ryDa9AgbELGeB+YEXE1dR53yAjHwFvE9iAUlWl9Al3M=
 github.com/deepmap/oapi-codegen v1.8.2 h1:SegyeYGcdi0jLLrpbCMoJxnUUn8GBXHsvr4rbzjuhfU=
 github.com/deepmap/oapi-codegen v1.8.2/go.mod h1:YLgSKSDv/bZQB7N4ws6luhozi3cEdRktEqrX88CvjIw=
@@ -405,8 +405,8 @@ github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw
 github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
 github.com/golang/protobuf v1.5.1/go.mod h1:DopwsBzvsk0Fs44TXzsVbJyPhcCPeIwnvohx4u74HPM=
 github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
-github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
+github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
+github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/golang/snappy v0.0.0-20170215233205-553a64147049/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
 github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
@@ -462,7 +462,6 @@ github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+
 github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4=
 github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/googleapis/gax-go v2.0.0+incompatible/go.mod h1:SFVmujtThgffbyetf+mdk2eWhX2bMyUtNHzFKcPA9HY=
@@ -522,8 +521,8 @@ github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ
 github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d h1:dg1dEPuWpEqDnvIw251EVy4zlP8gWbsGj4BsUKCRpYs=
 github.com/hashicorp/golang-lru v0.5.5-0.20210104140557-80c98217689d/go.mod h1:iADmTwqILo4mZ8BN3D2Q6+9jd8WM5uGBxy+E8yxSoD4=
-github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k=
-github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
+github.com/hashicorp/golang-lru/v2 v2.0.5 h1:wW7h1TG88eUIJ2i69gaE3uNVtEPIagzhGvHgwfx2Vm4=
+github.com/hashicorp/golang-lru/v2 v2.0.5/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM=
 github.com/hashicorp/hcl v0.0.0-20170914154624-68e816d1c783/go.mod h1:oZtUIOe8dh44I2q6ScRibXws4Ajl+d+nod3AaR9vL5w=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hashicorp/logutils v1.0.0/go.mod h1:QIAnNjmIWmVIIkWDTG1z5v++HQmx9WQRO+LraFDTW64=
@@ -598,8 +597,8 @@ github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+o
 github.com/klauspost/compress v1.9.8/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
 github.com/klauspost/compress v1.10.1/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
 github.com/klauspost/compress v1.11.7/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=
-github.com/klauspost/compress v1.17.8 h1:YcnTYrq7MikUT7k0Yb5eceMmALQPYBW/Xltxn0NAMnU=
-github.com/klauspost/compress v1.17.8/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/klauspost/compress v1.17.6 h1:60eq2E/jlfwQXtvZEeBUYADs+BwKBWURIY+Gj2eRGjI=
+github.com/klauspost/compress v1.17.6/go.mod h1:/dCuZOvVtNoHsyb+cuJD3itjs3NbnF6KH9zAO4BDxPM=
 github.com/klauspost/cpuid v1.2.3/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
 github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
 github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
@@ -636,14 +635,14 @@ github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6
 github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg=
 github.com/libp2p/go-flow-metrics v0.1.0 h1:0iPhMI8PskQwzh57jB9WxIuIOQ0r+15PChFGkx3Q3WM=
 github.com/libp2p/go-flow-metrics v0.1.0/go.mod h1:4Xi8MX8wj5aWNDAZttg6UPmc0ZrnFNsMtpsYUClFtro=
-github.com/libp2p/go-libp2p v0.35.0 h1:1xS1Bkr9X7GtdvV6ntLnDV9xB1kNjHK1lZ0eaO6gnhc=
-github.com/libp2p/go-libp2p v0.35.0/go.mod h1:snyJQix4ET6Tj+LeI0VPjjxTtdWpeOhYt5lEY0KirkQ=
+github.com/libp2p/go-libp2p v0.33.1 h1:tvJl9b9M6nSLBtZSXSguq+/lRhRj2oLRkyhBmQNMFLA=
+github.com/libp2p/go-libp2p v0.33.1/go.mod h1:zOUTMjG4I7TXwMndNyOBn/CNtVBLlvBlnxfi+8xzx+E=
 github.com/libp2p/go-libp2p-asn-util v0.4.1 h1:xqL7++IKD9TBFMgnLPZR6/6iYhawHKHl950SO9L6n94=
 github.com/libp2p/go-libp2p-asn-util v0.4.1/go.mod h1:d/NI6XZ9qxw67b4e+NgpQexCIiFYJjErASrYW4PFDN8=
 github.com/libp2p/go-libp2p-mplex v0.9.0 h1:R58pDRAmuBXkYugbSSXR9wrTX3+1pFM1xP2bLuodIq8=
 github.com/libp2p/go-libp2p-mplex v0.9.0/go.mod h1:ro1i4kuwiFT+uMPbIDIFkcLs1KRbNp0QwnUXM+P64Og=
-github.com/libp2p/go-libp2p-pubsub v0.11.0 h1:+JvS8Kty0OiyUiN0i8H5JbaCgjnJTRnTHe4rU88dLFc=
-github.com/libp2p/go-libp2p-pubsub v0.11.0/go.mod h1:QEb+hEV9WL9wCiUAnpY29FZR6W3zK8qYlaml8R4q6gQ=
+github.com/libp2p/go-libp2p-pubsub v0.10.0 h1:wS0S5FlISavMaAbxyQn3dxMOe2eegMfswM471RuHJwA=
+github.com/libp2p/go-libp2p-pubsub v0.10.0/go.mod h1:1OxbaT/pFRO5h+Dpze8hdHQ63R0ke55XTs6b6NwLLkw=
 github.com/libp2p/go-libp2p-testing v0.12.0 h1:EPvBb4kKMWO29qP4mZGyhVzUyR25dvfUIK5WDu6iPUA=
 github.com/libp2p/go-libp2p-testing v0.12.0/go.mod h1:KcGDRXyN7sQCllucn1cOOS+Dmm7ujhfEyXQL5lvkcPg=
 github.com/libp2p/go-mplex v0.7.0 h1:BDhFZdlk5tbr0oyFq/xv/NPGfjbnrsDam1EvutpBDbY=
@@ -759,8 +758,8 @@ github.com/multiformats/go-base36 v0.2.0 h1:lFsAbNOGeKtuKozrtBsAkSVhv1p9D0/qedU9
 github.com/multiformats/go-base36 v0.2.0/go.mod h1:qvnKE++v+2MWCfePClUEjE78Z7P2a1UV0xHgWc0hkp4=
 github.com/multiformats/go-multiaddr v0.1.1/go.mod h1:aMKBKNEYmzmDmxfX88/vz+J5IU55txyt0p4aiWVohjo=
 github.com/multiformats/go-multiaddr v0.2.0/go.mod h1:0nO36NvPpyV4QzvTLi/lafl2y95ncPj0vFwVF6k6wJ4=
-github.com/multiformats/go-multiaddr v0.12.4 h1:rrKqpY9h+n80EwhhC/kkcunCZZ7URIF8yN1WEUt2Hvc=
-github.com/multiformats/go-multiaddr v0.12.4/go.mod h1:sBXrNzucqkFJhvKOiwwLyqamGa/P5EIXNPLovyhQCII=
+github.com/multiformats/go-multiaddr v0.12.2 h1:9G9sTY/wCYajKa9lyfWPmpZAwe6oV+Wb1zcmMS1HG24=
+github.com/multiformats/go-multiaddr v0.12.2/go.mod h1:GKyaTYjZRdcUhyOetrxTk9z0cW+jA/YrnqTOvKgi44M=
 github.com/multiformats/go-multiaddr-dns v0.3.1 h1:QgQgR+LQVt3NPTjbrLLpsaT2ufAA2y0Mkk+QRVJbW3A=
 github.com/multiformats/go-multiaddr-dns v0.3.1/go.mod h1:G/245BRQ6FJGmryJCrOuTdB37AMA5AMOVuO6NY3JwTk=
 github.com/multiformats/go-multiaddr-fmt v0.1.0 h1:WLEFClPycPkp4fnIzoFoV9FVd49/eQsuaL3/CWe167E=
@@ -792,9 +791,8 @@ github.com/neelance/astrewrite v0.0.0-20160511093645-99348263ae86/go.mod h1:kHJE
 github.com/neelance/sourcemap v0.0.0-20151028013722-8c68805598ab/go.mod h1:Qr6/a/Q4r9LP1IltGz7tA7iOK1WonHEYhu1HRBA7ZiM=
 github.com/nishanths/predeclared v0.0.0-20200524104333-86fad755b4d3/go.mod h1:nt3d53pc1VYcphSCIaYAJtnPYnr3Zyn8fMq2wvPGPso=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
+github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE=
 github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU=
-github.com/nxadm/tail v1.4.11 h1:8feyoE3OzPrcshW5/MJ4sGESc5cqmGkGCWlco4l0bqY=
-github.com/nxadm/tail v1.4.11/go.mod h1:OTaG3NK980DZzxbRq6lEuzgU+mug70nY11sMd4JXXHc=
 github.com/oklog/oklog v0.3.2/go.mod h1:FCV+B7mhrz4o+ueLpx+KqkyXRGMWOYEvfiXtdGtbWGs=
 github.com/oklog/run v1.0.0/go.mod h1:dlhp/R75TPv97u0XWUtDeV/lRKWPKSdTuV0TZvrmrQA=
 github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
@@ -863,50 +861,6 @@ github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi
 github.com/pierrec/lz4 v2.4.1+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi+IEE17M5jbnwPHcY=
 github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
 github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
-github.com/pion/datachannel v1.5.6 h1:1IxKJntfSlYkpUj8LlYRSWpYiTTC02nUrOE8T3DqGeg=
-github.com/pion/datachannel v1.5.6/go.mod h1:1eKT6Q85pRnr2mHiWHxJwO50SfZRtWHTsNIVb/NfGW4=
-github.com/pion/dtls/v2 v2.2.7/go.mod h1:8WiMkebSHFD0T+dIU+UeBaoV7kDhOW5oDCzZ7WZ/F9s=
-github.com/pion/dtls/v2 v2.2.11 h1:9U/dpCYl1ySttROPWJgqWKEylUdT0fXp/xst6JwY5Ks=
-github.com/pion/dtls/v2 v2.2.11/go.mod h1:d9SYc9fch0CqK90mRk1dC7AkzzpwJj6u2GU3u+9pqFE=
-github.com/pion/ice/v2 v2.3.24 h1:RYgzhH/u5lH0XO+ABatVKCtRd+4U1GEaCXSMjNr13tI=
-github.com/pion/ice/v2 v2.3.24/go.mod h1:KXJJcZK7E8WzrBEYnV4UtqEZsGeWfHxsNqhVcVvgjxw=
-github.com/pion/interceptor v0.1.29 h1:39fsnlP1U8gw2JzOFWdfCU82vHvhW9o0rZnZF56wF+M=
-github.com/pion/interceptor v0.1.29/go.mod h1:ri+LGNjRUc5xUNtDEPzfdkmSqISixVTBF/z/Zms/6T4=
-github.com/pion/logging v0.2.2 h1:M9+AIj/+pxNsDfAT64+MAVgJO0rsyLnoJKCqf//DoeY=
-github.com/pion/logging v0.2.2/go.mod h1:k0/tDVsRCX2Mb2ZEmTqNa7CWsQPc+YYCB7Q+5pahoms=
-github.com/pion/mdns v0.0.12 h1:CiMYlY+O0azojWDmxdNr7ADGrnZ+V6Ilfner+6mSVK8=
-github.com/pion/mdns v0.0.12/go.mod h1:VExJjv8to/6Wqm1FXK+Ii/Z9tsVk/F5sD/N70cnYFbk=
-github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
-github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
-github.com/pion/rtcp v1.2.12/go.mod h1:sn6qjxvnwyAkkPzPULIbVqSKI5Dv54Rv7VG0kNxh9L4=
-github.com/pion/rtcp v1.2.14 h1:KCkGV3vJ+4DAJmvP0vaQShsb0xkRfWkO540Gy102KyE=
-github.com/pion/rtcp v1.2.14/go.mod h1:sn6qjxvnwyAkkPzPULIbVqSKI5Dv54Rv7VG0kNxh9L4=
-github.com/pion/rtp v1.8.3/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
-github.com/pion/rtp v1.8.6 h1:MTmn/b0aWWsAzux2AmP8WGllusBVw4NPYPVFFd7jUPw=
-github.com/pion/rtp v1.8.6/go.mod h1:pBGHaFt/yW7bf1jjWAoUjpSNoDnw98KTMg+jWWvziqU=
-github.com/pion/sctp v1.8.13/go.mod h1:YKSgO/bO/6aOMP9LCie1DuD7m+GamiK2yIiPM6vH+GA=
-github.com/pion/sctp v1.8.16 h1:PKrMs+o9EMLRvFfXq59WFsC+V8mN1wnKzqrv+3D/gYY=
-github.com/pion/sctp v1.8.16/go.mod h1:P6PbDVA++OJMrVNg2AL3XtYHV4uD6dvfyOovCgMs0PE=
-github.com/pion/sdp/v3 v3.0.9 h1:pX++dCHoHUwq43kuwf3PyJfHlwIj4hXA7Vrifiq0IJY=
-github.com/pion/sdp/v3 v3.0.9/go.mod h1:B5xmvENq5IXJimIO4zfp6LAe1fD9N+kFv+V/1lOdz8M=
-github.com/pion/srtp/v2 v2.0.18 h1:vKpAXfawO9RtTRKZJbG4y0v1b11NZxQnxRl85kGuUlo=
-github.com/pion/srtp/v2 v2.0.18/go.mod h1:0KJQjA99A6/a0DOVTu1PhDSw0CXF2jTkqOoMg3ODqdA=
-github.com/pion/stun v0.6.1 h1:8lp6YejULeHBF8NmV8e2787BogQhduZugh5PdhDyyN4=
-github.com/pion/stun v0.6.1/go.mod h1:/hO7APkX4hZKu/D0f2lHzNyvdkTGtIy3NDmLR7kSz/8=
-github.com/pion/transport/v2 v2.2.1/go.mod h1:cXXWavvCnFF6McHTft3DWS9iic2Mftcz1Aq29pGcU5g=
-github.com/pion/transport/v2 v2.2.2/go.mod h1:OJg3ojoBJopjEeECq2yJdXH9YVrUJ1uQ++NjXLOUorc=
-github.com/pion/transport/v2 v2.2.3/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
-github.com/pion/transport/v2 v2.2.4/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
-github.com/pion/transport/v2 v2.2.5 h1:iyi25i/21gQck4hfRhomF6SktmUQjRsRW4WJdhfc3Kc=
-github.com/pion/transport/v2 v2.2.5/go.mod h1:q2U/tf9FEfnSBGSW6w5Qp5PFWRLRj3NjLhCCgpRK4p0=
-github.com/pion/transport/v3 v3.0.1/go.mod h1:UY7kiITrlMv7/IKgd5eTUcaahZx5oUN3l9SzK5f5xE0=
-github.com/pion/transport/v3 v3.0.2 h1:r+40RJR25S9w3jbA6/5uEPTzcdn7ncyU44RWCbHkLg4=
-github.com/pion/transport/v3 v3.0.2/go.mod h1:nIToODoOlb5If2jF9y2Igfx3PFYWfuXi37m0IlWa/D0=
-github.com/pion/turn/v2 v2.1.3/go.mod h1:huEpByKKHix2/b9kmTAM3YoX6MKP+/D//0ClgUYR2fY=
-github.com/pion/turn/v2 v2.1.6 h1:Xr2niVsiPTB0FPtt+yAWKFUkU1eotQbGgpTIld4x1Gc=
-github.com/pion/turn/v2 v2.1.6/go.mod h1:huEpByKKHix2/b9kmTAM3YoX6MKP+/D//0ClgUYR2fY=
-github.com/pion/webrtc/v3 v3.2.40 h1:Wtfi6AZMQg+624cvCXUuSmrKWepSB7zfgYDOYqsSOVU=
-github.com/pion/webrtc/v3 v3.2.40/go.mod h1:M1RAe3TNTD1tzyvqHrbVODfwdPGSXOUo/OgpoGGJqFY=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
@@ -931,16 +885,16 @@ github.com/prometheus/client_golang v1.3.0/go.mod h1:hJaj2vgQTGQmVCsAACORcieXFeD
 github.com/prometheus/client_golang v1.4.1/go.mod h1:e9GMxYsXl05ICDXkRhurwBS4Q3OK1iX/F2sw+iXX5zU=
 github.com/prometheus/client_golang v1.7.1/go.mod h1:PY5Wy2awLA44sXw4AOSfFBetzPP4j5+D6mVACh+pe2M=
 github.com/prometheus/client_golang v1.9.0/go.mod h1:FqZLKOZnGdFAhOK4nqGHa7D66IdsO+O441Eve7ptJDU=
-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.18.0 h1:HzFfmkOzH5Q8L8G+kSJKUx5dtG87sewO+FoDDqP5Tbk=
+github.com/prometheus/client_golang v1.18.0/go.mod h1:T+GXkCk5wSJyOqMIzVgvvjFDlkOQntgjkJWKrN5txjA=
 github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190115171406-56726106282f/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
 github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.1.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
 github.com/prometheus/client_model v0.2.0/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
-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/client_model v0.6.0 h1:k1v3CzpSRUTrKMppY35TLwPvxHqBu0bYgxZzqGIgaos=
+github.com/prometheus/client_model v0.6.0/go.mod h1:NTQHnmxFpouOD0DpvP4XujX3CdOAGQPoaGhyTchlyt8=
 github.com/prometheus/common v0.0.0-20180801064454-c7de2306084e/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
 github.com/prometheus/common v0.2.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
@@ -950,8 +904,8 @@ github.com/prometheus/common v0.7.0/go.mod h1:DjGbpBbp5NYNiECxcL/VnbXCCaQpKd3tt2
 github.com/prometheus/common v0.9.1/go.mod h1:yhUN8i9wzaXS3w1O07YhxHEBxD+W35wd8bs7vj7HSQ4=
 github.com/prometheus/common v0.10.0/go.mod h1:Tlit/dnDKsSWFlCLTWaA1cyBgKHSMdTB80sz/V91rCo=
 github.com/prometheus/common v0.15.0/go.mod h1:U+gB1OBLb1lF3O42bTCL+FK18tX9Oar16Clt/msog/s=
-github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
-github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
+github.com/prometheus/common v0.47.0 h1:p5Cz0FNHo7SnWOmWmoRozVcjEp0bIVU8cV7OShpjL1k=
+github.com/prometheus/common v0.47.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
 github.com/prometheus/procfs v0.0.0-20180725123919-05ee40e3a273/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
 github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
@@ -981,10 +935,10 @@ github.com/prysmaticlabs/protoc-gen-go-cast v0.0.0-20230228205207-28762a7b9294 h
 github.com/prysmaticlabs/protoc-gen-go-cast v0.0.0-20230228205207-28762a7b9294/go.mod h1:ZVEbRdnMkGhp/pu35zq4SXxtvUwWK0J1MATtekZpH2Y=
 github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
-github.com/quic-go/quic-go v0.44.0 h1:So5wOr7jyO4vzL2sd8/pD9Kesciv91zSk8BoFngItQ0=
-github.com/quic-go/quic-go v0.44.0/go.mod h1:z4cx/9Ny9UtGITIPzmPTXh1ULfOyWh4qGQlpnPcWmek=
-github.com/quic-go/webtransport-go v0.8.0 h1:HxSrwun11U+LlmwpgM1kEqIqH90IT4N8auv/cD7QFJg=
-github.com/quic-go/webtransport-go v0.8.0/go.mod h1:N99tjprW432Ut5ONql/aUhSLT0YVSlwHohQsuac9WaM=
+github.com/quic-go/quic-go v0.42.0 h1:uSfdap0eveIl8KXnipv9K7nlwZ5IqLlYOpJ58u5utpM=
+github.com/quic-go/quic-go v0.42.0/go.mod h1:132kz4kL3F9vxhW3CtQJLDVwcFe5wdWeJXXijhsO57M=
+github.com/quic-go/webtransport-go v0.6.0 h1:CvNsKqc4W2HljHJnoT+rMmbRJybShZ0YPFDD3NxaZLY=
+github.com/quic-go/webtransport-go v0.6.0/go.mod h1:9KjU4AEBqEQidGHNDkZrb8CAa1abRaosM2yGOyiikEc=
 github.com/raulk/go-watchdog v1.3.0 h1:oUmdlHxdkXRJlwfG0O9omj8ukerm8MEQavSiDTEtBsk=
 github.com/raulk/go-watchdog v1.3.0/go.mod h1:fIvOnLbF0b0ZwkB9YU4mOW9Did//4vPZtDqv66NfsMU=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
@@ -1080,9 +1034,8 @@ github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.2.0/go.mod h1:qt09Ya8vawLte6SNmTgCsAVtYtaKzEcn8ATUoHMkEqE=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
-github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
-github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
@@ -1093,10 +1046,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
-github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-github.com/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/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/supranational/blst v0.3.11 h1:LyU6FolezeWAhvQk0k6O/d49jqgO52MSDDfYgbeoEm4=
 github.com/supranational/blst v0.3.11/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
@@ -1184,12 +1135,14 @@ go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 go.uber.org/automaxprocs v1.5.2 h1:2LxUOGiR3O6tw8ui5sZa2LAaHnsviZdVOUZw4fvbnME=
 go.uber.org/automaxprocs v1.5.2/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 go.uber.org/dig v1.17.1 h1:Tga8Lz8PcYNsWsyHMZ1Vm0OQOUaJNDyvPImgbAu9YSc=
 go.uber.org/dig v1.17.1/go.mod h1:Us0rSJiThwCv2GteUN0Q7OKvU7n5J4dxZ9JKUXozFdE=
-go.uber.org/fx v1.21.1 h1:RqBh3cYdzZS0uqwVeEjOX2p73dddLpym315myy/Bpb0=
-go.uber.org/fx v1.21.1/go.mod h1:HT2M7d7RHo+ebKGh9NRcrsrHHfpZ60nW3QRubMRfv48=
+go.uber.org/fx v1.20.1 h1:zVwVQGS8zYvhh9Xxcu4w1M6ESyeMzebzj2NbSayZ4Mk=
+go.uber.org/fx v1.20.1/go.mod h1:iSYNbHf2y55acNCwCXKx7LbWb5WG1Bnue5RDXz1OREg=
 go.uber.org/goleak v1.1.11-0.20210813005559-691160354723/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
@@ -1232,14 +1185,8 @@ golang.org/x/crypto v0.0.0-20210322153248-0c34fe9e7dc2/go.mod h1:T9bdIzuCu7OtxOm
 golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
 golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
-golang.org/x/crypto v0.8.0/go.mod h1:mRqEX+O9/h5TFCrQhkgjo2yKi0yYA+9ecGkdQoHrywE=
-golang.org/x/crypto v0.11.0/go.mod h1:xgJhtzW8F9jGdVFWZESrid1U1bjeNy4zgy5cRr/CIio=
-golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
-golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg=
+golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
 golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
-golang.org/x/crypto v0.23.0 h1:dIJU/v2J8Mdglj/8rJ6UUOM3Zc9zLZxVZwwxMooUSAI=
-golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
@@ -1251,8 +1198,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0
 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
 golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
 golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
+golang.org/x/exp v0.0.0-20240213143201-ec583247a57a h1:HinSgX1tJRX3KsL//Gxynpw5CTOAIPhgL4W8PNiIpVE=
+golang.org/x/exp v0.0.0-20240213143201-ec583247a57a/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc=
 golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678 h1:1P7xPZEwZMoBoz0Yze5Nx2/4pxj6nw9ZqHWXqP0iRgQ=
 golang.org/x/exp/typeparams v0.0.0-20231108232855-2478ac86f678/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk=
 golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
@@ -1281,9 +1228,8 @@ golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
-golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
-golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
-golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.15.0 h1:SernR4v+D55NyBH2QiEQrlBAnj1ECL6AGrA5+dPaMY8=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
 golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
@@ -1336,16 +1282,8 @@ golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLd
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
 golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
-golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
-golang.org/x/net v0.13.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
-golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
-golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
+golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
 golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
-golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
-golang.org/x/net v0.25.0 h1:d/OCCoBEUq33pjydKrGQhw7IlUPI2Oylr+8qLx49kac=
-golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
 golang.org/x/oauth2 v0.0.0-20170912212905-13449ad91cb2/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
@@ -1378,9 +1316,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ
 golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20180810173357-98c5dad5d1a0/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
@@ -1472,30 +1409,14 @@ golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBc
 golang.org/x/sys v0.1.0/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.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.17.0 h1:25cE3gD+tdBA7lp7QfhuV+rJiE9YXTcS3VG1SqssI/Y=
 golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
-golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
-golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
-golang.org/x/term v0.10.0/go.mod h1:lpqdcUyK/oCiQxvxVrppt5ggO2KCZ5QblwqPnfZ6d5o=
-golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU=
-golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY=
+golang.org/x/term v0.17.0 h1:mkTF7LCd6WGJNL3K1Ad7kwxNfYAW6a8a8QqtMblp/4U=
 golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
-golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
-golang.org/x/term v0.20.0 h1:VnkxpohqXaOBYJtBmEppKUG6mXpi+4O6purfc2+sMhw=
-golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
 golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
@@ -1506,13 +1427,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
-golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.11.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 golang.org/x/time v0.0.0-20170424234030-8be79e1e0910/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
@@ -1590,9 +1506,8 @@ golang.org/x/tools v0.1.1-0.20210205202024-ef80cdb6ec6d/go.mod h1:9bzcO0MWcOuT0t
 golang.org/x/tools v0.1.4/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
-golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
-golang.org/x/tools v0.21.0 h1:qc0xYgIbsSDt9EyWz05J5wfa7LOVW0YTLOXrqdLAWIw=
-golang.org/x/tools v0.21.0/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/tools v0.18.0 h1:k8NLag8AGHnn+PHbl7g43CtqZAwG60vZkLqgyZgIHgQ=
+golang.org/x/tools v0.18.0/go.mod h1:GL7B4CwcLLeo59yx/9UWWuNOW1n3VZ4f5axWfML7Lcg=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
@@ -1734,8 +1649,8 @@ google.golang.org/protobuf v1.25.1-0.20200805231151-a709e31e5d12/go.mod h1:9JNX7
 google.golang.org/protobuf v1.25.1-0.20201208041424-160c7477e0e8/go.mod h1:hFxJC2f0epmp1elRCiEGJTKAWbwxZ2nvqZdHl3FQXCY=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.34.1 h1:9ddQBjfCyZPOHPUiPxpYESBLc+T8P3E+Vo4IbKZgFWg=
-google.golang.org/protobuf v1.34.1/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.32.0 h1:pPC6BG5ex8PDFnkbrGU3EixyhKcQ2aDuBS36lqK/C7I=
+google.golang.org/protobuf v1.32.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/bsm/ratelimit.v1 v1.0.0-20160220154919-db14e161995a/go.mod h1:KF9sEfUPAXdG8Oev9e99iLGnl2uJMjc5B+4y3O7x610=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

hack/beacon-node-api/README.md

@@ -0,0 +1,17 @@
+# Beacon Node API
+
+https://ethereum.github.io/beacon-APIs/
+
+## Postman
+
+You can use Postman to test the API. https://www.postman.com/
+
+### Postman collection
+
+In this package you will find the Postman collection for the Beacon Node API. 
+You can import this collection in your own Postman instance to test the API.
+
+#### Updating the collection
+
+The collection will need to be exported and overwritten to update the collection. A PR should be created once the file
+is updated.

testing/spectest/minimal/altair/operations/sync_committee_test.go

@@ -7,5 +7,5 @@ import (
 )
 
 func TestMinimal_Altair_Operations_SyncCommittee(t *testing.T) {
-	operations.RunSyncCommitteeTest(t, "minimal")
+	operations.RunProposerSlashingTest(t, "minimal")
 }

testing/spectest/minimal/bellatrix/operations/sync_committee_test.go

@@ -7,5 +7,5 @@ import (
 )
 
 func TestMinimal_Bellatrix_Operations_SyncCommittee(t *testing.T) {
-	operations.RunSyncCommitteeTest(t, "minimal")
+	operations.RunProposerSlashingTest(t, "minimal")
 }

testing/spectest/minimal/capella/operations/sync_committee_test.go

@@ -7,5 +7,5 @@ import (
 )
 
 func TestMinimal_Capella_Operations_SyncCommittee(t *testing.T) {
-	operations.RunSyncCommitteeTest(t, "minimal")
+	operations.RunProposerSlashingTest(t, "minimal")
 }

testing/spectest/minimal/deneb/operations/sync_committee_test.go

@@ -7,5 +7,5 @@ import (
 )
 
 func TestMinimal_Deneb_Operations_SyncCommittee(t *testing.T) {
-	operations.RunSyncCommitteeTest(t, "minimal")
+	operations.RunProposerSlashingTest(t, "minimal")
 }

testing/validator-mock/BUILD.bazel

@@ -5,9 +5,9 @@ package(default_testonly = True)
 go_library(
     name = "go_default_library",
     srcs = [
-        "chain_client_mock.go",
+        "beacon_chain_client_mock.go",
         "node_client_mock.go",
-        "prysm_chain_client_mock.go",
+        "prysm_beacon_chain_client_mock.go",
         "validator_client_mock.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/testing/validator-mock",

testing/validator-mock/beacon_chain_client_mock.go

@@ -18,31 +18,31 @@ import (
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
 )
 
-// MockChainClient is a mock of ChainClient interface.
-type MockChainClient struct {
+// MockBeaconChainClient is a mock of BeaconChainClient interface.
+type MockBeaconChainClient struct {
 	ctrl     *gomock.Controller
-	recorder *MockChainClientMockRecorder
+	recorder *MockBeaconChainClientMockRecorder
 }
 
-// MockChainClientMockRecorder is the mock recorder for MockChainClient.
-type MockChainClientMockRecorder struct {
-	mock *MockChainClient
+// MockBeaconChainClientMockRecorder is the mock recorder for MockBeaconChainClient.
+type MockBeaconChainClientMockRecorder struct {
+	mock *MockBeaconChainClient
 }
 
-// NewMockChainClient creates a new mock instance.
-func NewMockChainClient(ctrl *gomock.Controller) *MockChainClient {
-	mock := &MockChainClient{ctrl: ctrl}
-	mock.recorder = &MockChainClientMockRecorder{mock}
+// NewMockBeaconChainClient creates a new mock instance.
+func NewMockBeaconChainClient(ctrl *gomock.Controller) *MockBeaconChainClient {
+	mock := &MockBeaconChainClient{ctrl: ctrl}
+	mock.recorder = &MockBeaconChainClientMockRecorder{mock}
 	return mock
 }
 
 // EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockChainClient) EXPECT() *MockChainClientMockRecorder {
+func (m *MockBeaconChainClient) EXPECT() *MockBeaconChainClientMockRecorder {
 	return m.recorder
 }
 
 // GetChainHead mocks base method.
-func (m *MockChainClient) GetChainHead(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ChainHead, error) {
+func (m *MockBeaconChainClient) GetChainHead(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ChainHead, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetChainHead", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ChainHead)
@@ -51,13 +51,13 @@ func (m *MockChainClient) GetChainHead(arg0 context.Context, arg1 *emptypb.Empty
 }
 
 // GetChainHead indicates an expected call of GetChainHead.
-func (mr *MockChainClientMockRecorder) GetChainHead(arg0, arg1 any) *gomock.Call {
+func (mr *MockBeaconChainClientMockRecorder) GetChainHead(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainHead", reflect.TypeOf((*MockChainClient)(nil).GetChainHead), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetChainHead", reflect.TypeOf((*MockBeaconChainClient)(nil).GetChainHead), arg0, arg1)
 }
 
 // GetValidatorParticipation mocks base method.
-func (m *MockChainClient) GetValidatorParticipation(arg0 context.Context, arg1 *eth.GetValidatorParticipationRequest) (*eth.ValidatorParticipationResponse, error) {
+func (m *MockBeaconChainClient) GetValidatorParticipation(arg0 context.Context, arg1 *eth.GetValidatorParticipationRequest) (*eth.ValidatorParticipationResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetValidatorParticipation", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ValidatorParticipationResponse)
@@ -66,13 +66,13 @@ func (m *MockChainClient) GetValidatorParticipation(arg0 context.Context, arg1 *
 }
 
 // GetValidatorParticipation indicates an expected call of GetValidatorParticipation.
-func (mr *MockChainClientMockRecorder) GetValidatorParticipation(arg0, arg1 any) *gomock.Call {
+func (mr *MockBeaconChainClientMockRecorder) GetValidatorParticipation(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorParticipation", reflect.TypeOf((*MockChainClient)(nil).GetValidatorParticipation), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorParticipation", reflect.TypeOf((*MockBeaconChainClient)(nil).GetValidatorParticipation), arg0, arg1)
 }
 
 // GetValidatorPerformance mocks base method.
-func (m *MockChainClient) GetValidatorPerformance(arg0 context.Context, arg1 *eth.ValidatorPerformanceRequest) (*eth.ValidatorPerformanceResponse, error) {
+func (m *MockBeaconChainClient) GetValidatorPerformance(arg0 context.Context, arg1 *eth.ValidatorPerformanceRequest) (*eth.ValidatorPerformanceResponse, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetValidatorPerformance", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ValidatorPerformanceResponse)
@@ -81,13 +81,13 @@ func (m *MockChainClient) GetValidatorPerformance(arg0 context.Context, arg1 *et
 }
 
 // GetValidatorPerformance indicates an expected call of GetValidatorPerformance.
-func (mr *MockChainClientMockRecorder) GetValidatorPerformance(arg0, arg1 any) *gomock.Call {
+func (mr *MockBeaconChainClientMockRecorder) GetValidatorPerformance(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorPerformance", reflect.TypeOf((*MockChainClient)(nil).GetValidatorPerformance), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorPerformance", reflect.TypeOf((*MockBeaconChainClient)(nil).GetValidatorPerformance), arg0, arg1)
 }
 
 // GetValidatorQueue mocks base method.
-func (m *MockChainClient) GetValidatorQueue(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ValidatorQueue, error) {
+func (m *MockBeaconChainClient) GetValidatorQueue(arg0 context.Context, arg1 *emptypb.Empty) (*eth.ValidatorQueue, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "GetValidatorQueue", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ValidatorQueue)
@@ -96,13 +96,13 @@ func (m *MockChainClient) GetValidatorQueue(arg0 context.Context, arg1 *emptypb.
 }
 
 // GetValidatorQueue indicates an expected call of GetValidatorQueue.
-func (mr *MockChainClientMockRecorder) GetValidatorQueue(arg0, arg1 any) *gomock.Call {
+func (mr *MockBeaconChainClientMockRecorder) GetValidatorQueue(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorQueue", reflect.TypeOf((*MockChainClient)(nil).GetValidatorQueue), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorQueue", reflect.TypeOf((*MockBeaconChainClient)(nil).GetValidatorQueue), arg0, arg1)
 }
 
 // ListValidatorBalances mocks base method.
-func (m *MockChainClient) ListValidatorBalances(arg0 context.Context, arg1 *eth.ListValidatorBalancesRequest) (*eth.ValidatorBalances, error) {
+func (m *MockBeaconChainClient) ListValidatorBalances(arg0 context.Context, arg1 *eth.ListValidatorBalancesRequest) (*eth.ValidatorBalances, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListValidatorBalances", arg0, arg1)
 	ret0, _ := ret[0].(*eth.ValidatorBalances)
@@ -111,13 +111,13 @@ func (m *MockChainClient) ListValidatorBalances(arg0 context.Context, arg1 *eth.
 }
 
 // ListValidatorBalances indicates an expected call of ListValidatorBalances.
-func (mr *MockChainClientMockRecorder) ListValidatorBalances(arg0, arg1 any) *gomock.Call {
+func (mr *MockBeaconChainClientMockRecorder) ListValidatorBalances(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidatorBalances", reflect.TypeOf((*MockChainClient)(nil).ListValidatorBalances), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidatorBalances", reflect.TypeOf((*MockBeaconChainClient)(nil).ListValidatorBalances), arg0, arg1)
 }
 
 // ListValidators mocks base method.
-func (m *MockChainClient) ListValidators(arg0 context.Context, arg1 *eth.ListValidatorsRequest) (*eth.Validators, error) {
+func (m *MockBeaconChainClient) ListValidators(arg0 context.Context, arg1 *eth.ListValidatorsRequest) (*eth.Validators, error) {
 	m.ctrl.T.Helper()
 	ret := m.ctrl.Call(m, "ListValidators", arg0, arg1)
 	ret0, _ := ret[0].(*eth.Validators)
@@ -126,7 +126,7 @@ func (m *MockChainClient) ListValidators(arg0 context.Context, arg1 *eth.ListVal
 }
 
 // ListValidators indicates an expected call of ListValidators.
-func (mr *MockChainClientMockRecorder) ListValidators(arg0, arg1 any) *gomock.Call {
+func (mr *MockBeaconChainClientMockRecorder) ListValidators(arg0, arg1 any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidators", reflect.TypeOf((*MockChainClient)(nil).ListValidators), arg0, arg1)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListValidators", reflect.TypeOf((*MockBeaconChainClient)(nil).ListValidators), arg0, arg1)
 }

testing/validator-mock/node_client_mock.go

@@ -21,8 +21,8 @@ import (
 
 // MockNodeClient is a mock of NodeClient interface.
 type MockNodeClient struct {
-	ctrl     *gomock.Controller
-	recorder *MockNodeClientMockRecorder
+	ctrl          *gomock.Controller
+	recorder      *MockNodeClientMockRecorder
 	healthTracker *beacon.NodeHealthTracker
 }
 

testing/validator-mock/prysm_beacon_chain_client_mock.go

@@ -0,0 +1,57 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/prysmaticlabs/prysm/v5/validator/client/iface (interfaces: PrysmBeaconChainClient)
+//
+// Generated by this command:
+//
+//	mockgen -package=validator_mock -destination=testing/validator-mock/prysm_beacon_chain_client_mock.go github.com/prysmaticlabs/prysm/v5/validator/client/iface PrysmBeaconChainClient
+//
+
+// Package validator_mock is a generated GoMock package.
+package validator_mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	validator "github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
+	iface "github.com/prysmaticlabs/prysm/v5/validator/client/iface"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockPrysmBeaconChainClient is a mock of PrysmBeaconChainClient interface.
+type MockPrysmBeaconChainClient struct {
+	ctrl     *gomock.Controller
+	recorder *MockPrysmBeaconChainClientMockRecorder
+}
+
+// MockPrysmBeaconChainClientMockRecorder is the mock recorder for MockPrysmBeaconChainClient.
+type MockPrysmBeaconChainClientMockRecorder struct {
+	mock *MockPrysmBeaconChainClient
+}
+
+// NewMockPrysmBeaconChainClient creates a new mock instance.
+func NewMockPrysmBeaconChainClient(ctrl *gomock.Controller) *MockPrysmBeaconChainClient {
+	mock := &MockPrysmBeaconChainClient{ctrl: ctrl}
+	mock.recorder = &MockPrysmBeaconChainClientMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPrysmBeaconChainClient) EXPECT() *MockPrysmBeaconChainClientMockRecorder {
+	return m.recorder
+}
+
+// GetValidatorCount mocks base method.
+func (m *MockPrysmBeaconChainClient) GetValidatorCount(arg0 context.Context, arg1 string, arg2 []validator.Status) ([]iface.ValidatorCount, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetValidatorCount", arg0, arg1, arg2)
+	ret0, _ := ret[0].([]iface.ValidatorCount)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetValidatorCount indicates an expected call of GetValidatorCount.
+func (mr *MockPrysmBeaconChainClientMockRecorder) GetValidatorCount(arg0, arg1, arg2 any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorCount", reflect.TypeOf((*MockPrysmBeaconChainClient)(nil).GetValidatorCount), arg0, arg1, arg2)
+}

testing/validator-mock/prysm_chain_client_mock.go

@@ -1,52 +0,0 @@
-// Code generated by MockGen. DO NOT EDIT.
-// Source: github.com/prysmaticlabs/prysm/v4/validator/client/iface (interfaces: PrysmChainClient)
-
-// Package validator_mock is a generated GoMock package.
-package validator_mock
-
-import (
-	context "context"
-	reflect "reflect"
-
-	validator "github.com/prysmaticlabs/prysm/v5/consensus-types/validator"
-	iface "github.com/prysmaticlabs/prysm/v5/validator/client/iface"
-	gomock "go.uber.org/mock/gomock"
-)
-
-// MockPrysmChainClient is a mock of PrysmChainClient interface.
-type MockPrysmChainClient struct {
-	ctrl     *gomock.Controller
-	recorder *MockPrysmChainClientMockRecorder
-}
-
-// MockPrysmChainClientMockRecorder is the mock recorder for MockPrysmChainClient.
-type MockPrysmChainClientMockRecorder struct {
-	mock *MockPrysmChainClient
-}
-
-// NewMockPrysmChainClient creates a new mock instance.
-func NewMockPrysmChainClient(ctrl *gomock.Controller) *MockPrysmChainClient {
-	mock := &MockPrysmChainClient{ctrl: ctrl}
-	mock.recorder = &MockPrysmChainClientMockRecorder{mock}
-	return mock
-}
-
-// EXPECT returns an object that allows the caller to indicate expected use.
-func (m *MockPrysmChainClient) EXPECT() *MockPrysmChainClientMockRecorder {
-	return m.recorder
-}
-
-// GetValidatorCount mocks base method.
-func (m *MockPrysmChainClient) GetValidatorCount(arg0 context.Context, arg1 string, arg2 []validator.Status) ([]iface.ValidatorCount, error) {
-	m.ctrl.T.Helper()
-	ret := m.ctrl.Call(m, "GetValidatorCount", arg0, arg1, arg2)
-	ret0, _ := ret[0].([]iface.ValidatorCount)
-	ret1, _ := ret[1].(error)
-	return ret0, ret1
-}
-
-// GetValidatorCount indicates an expected call of GetValidatorCount.
-func (mr *MockPrysmChainClientMockRecorder) GetValidatorCount(arg0, arg1, arg2 interface{}) *gomock.Call {
-	mr.mock.ctrl.T.Helper()
-	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorCount", reflect.TypeOf((*MockPrysmChainClient)(nil).GetValidatorCount), arg0, arg1, arg2)
-}

validator/client/aggregate.go

@@ -44,7 +44,7 @@ func (v *validator) SubmitAggregateAndProof(ctx context.Context, slot primitives
 	}
 
 	// Avoid sending beacon node duplicated aggregation requests.
-	k := validatorSubnetSubscriptionKey(slot, duty.CommitteeIndex)
+	k := validatorSubscribeKey(slot, duty.CommitteeIndex)
 	v.aggregatedSlotCommitteeIDCacheLock.Lock()
 	if v.aggregatedSlotCommitteeIDCache.Contains(k) {
 		v.aggregatedSlotCommitteeIDCacheLock.Unlock()
@@ -149,7 +149,7 @@ func (v *validator) signSlotWithSelectionProof(ctx context.Context, pubKey [fiel
 	if err != nil {
 		return nil, err
 	}
-	sig, err = v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err = v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     root[:],
 		SignatureDomain: domain.SignatureDomain,
@@ -203,7 +203,7 @@ func (v *validator) aggregateAndProofSig(ctx context.Context, pubKey [fieldparam
 	if err != nil {
 		return nil, err
 	}
-	sig, err = v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err = v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     root[:],
 		SignatureDomain: d.SignatureDomain,

validator/client/attest.go

@@ -203,7 +203,7 @@ func (v *validator) signAtt(ctx context.Context, pubKey [fieldparams.BLSPubkeyLe
 	if err != nil {
 		return nil, [32]byte{}, err
 	}
-	sig, err := v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err := v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     root[:],
 		SignatureDomain: domain.SignatureDomain,

validator/client/attest_test.go

@@ -167,7 +167,7 @@ func TestAttestToBlockHead_AttestsCorrectly(t *testing.T) {
 			root, err := signing.ComputeSigningRoot(expectedAttestation.Data, make([]byte, 32))
 			require.NoError(t, err)
 
-			sig, err := validator.km.Sign(context.Background(), &validatorpb.SignRequest{
+			sig, err := validator.keyManager.Sign(context.Background(), &validatorpb.SignRequest{
 				PublicKey:   validatorKey.PublicKey().Marshal(),
 				SigningRoot: root[:],
 			})
@@ -504,7 +504,7 @@ func TestSignAttestation(t *testing.T) {
 			att.Data.BeaconBlockRoot = bytesutil.PadTo([]byte("blockRoot"), 32)
 
 			pk := testKeyFromBytes(t, []byte{1})
-			validator.km = newMockKeymanager(t, pk)
+			validator.keyManager = newMockKeymanager(t, pk)
 			sig, sr, err := validator.signAtt(ctx, pk.pub, att.Data, att.Data.Slot)
 			require.NoError(t, err, "%x,%x,%v", sig, sr, err)
 			require.Equal(t, "b6a60f8497bd328908be83634d045"+

validator/client/beacon-api/beacon_api_beacon_chain_client.go

@@ -17,15 +17,15 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
 )
 
-type beaconApiChainClient struct {
-	fallbackClient          iface.ChainClient
+type beaconApiBeaconChainClient struct {
+	fallbackClient          iface.BeaconChainClient
 	jsonRestHandler         JsonRestHandler
 	stateValidatorsProvider StateValidatorsProvider
 }
 
 const getValidatorPerformanceEndpoint = "/prysm/validators/performance"
 
-func (c beaconApiChainClient) getHeadBlockHeaders(ctx context.Context) (*structs.GetBlockHeaderResponse, error) {
+func (c beaconApiBeaconChainClient) getHeadBlockHeaders(ctx context.Context) (*structs.GetBlockHeaderResponse, error) {
 	blockHeader := structs.GetBlockHeaderResponse{}
 	err := c.jsonRestHandler.Get(ctx, "/eth/v1/beacon/headers/head", &blockHeader)
 	if err != nil {
@@ -43,7 +43,7 @@ func (c beaconApiChainClient) getHeadBlockHeaders(ctx context.Context) (*structs
 	return &blockHeader, nil
 }
 
-func (c beaconApiChainClient) GetChainHead(ctx context.Context, _ *empty.Empty) (*ethpb.ChainHead, error) {
+func (c beaconApiBeaconChainClient) GetChainHead(ctx context.Context, _ *empty.Empty) (*ethpb.ChainHead, error) {
 	const endpoint = "/eth/v1/beacon/states/head/finality_checkpoints"
 
 	finalityCheckpoints := structs.GetFinalityCheckpointsResponse{}
@@ -146,16 +146,16 @@ func (c beaconApiChainClient) GetChainHead(ctx context.Context, _ *empty.Empty)
 	}, nil
 }
 
-func (c beaconApiChainClient) ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
+func (c beaconApiBeaconChainClient) ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.ListValidatorBalances(ctx, in)
 	}
 
 	// TODO: Implement me
-	panic("beaconApiChainClient.ListValidatorBalances is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiChainClientWithFallback.")
+	panic("beaconApiBeaconChainClient.ListValidatorBalances is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func (c beaconApiChainClient) ListValidators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error) {
+func (c beaconApiBeaconChainClient) ListValidators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error) {
 	pageSize := in.PageSize
 
 	// We follow the gRPC behavior here, which returns a maximum of 250 results when pageSize == 0
@@ -310,16 +310,16 @@ func (c beaconApiChainClient) ListValidators(ctx context.Context, in *ethpb.List
 	}, nil
 }
 
-func (c beaconApiChainClient) GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
+func (c beaconApiBeaconChainClient) GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.GetValidatorQueue(ctx, in)
 	}
 
 	// TODO: Implement me
-	panic("beaconApiChainClient.GetValidatorQueue is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiChainClientWithFallback.")
+	panic("beaconApiBeaconChainClient.GetValidatorQueue is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func (c beaconApiChainClient) GetValidatorPerformance(ctx context.Context, in *ethpb.ValidatorPerformanceRequest) (*ethpb.ValidatorPerformanceResponse, error) {
+func (c beaconApiBeaconChainClient) GetValidatorPerformance(ctx context.Context, in *ethpb.ValidatorPerformanceRequest) (*ethpb.ValidatorPerformanceResponse, error) {
 	request, err := json.Marshal(structs.GetValidatorPerformanceRequest{
 		PublicKeys: in.PublicKeys,
 		Indices:    in.Indices,
@@ -345,17 +345,17 @@ func (c beaconApiChainClient) GetValidatorPerformance(ctx context.Context, in *e
 	}, nil
 }
 
-func (c beaconApiChainClient) GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
+func (c beaconApiBeaconChainClient) GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
 	if c.fallbackClient != nil {
 		return c.fallbackClient.GetValidatorParticipation(ctx, in)
 	}
 
 	// TODO: Implement me
-	panic("beaconApiChainClient.GetValidatorParticipation is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiChainClientWithFallback.")
+	panic("beaconApiBeaconChainClient.GetValidatorParticipation is not implemented. To use a fallback client, pass a fallback client as the last argument of NewBeaconApiBeaconChainClientWithFallback.")
 }
 
-func NewBeaconApiChainClientWithFallback(jsonRestHandler JsonRestHandler, fallbackClient iface.ChainClient) iface.ChainClient {
-	return &beaconApiChainClient{
+func NewBeaconApiBeaconChainClientWithFallback(jsonRestHandler JsonRestHandler, fallbackClient iface.BeaconChainClient) iface.BeaconChainClient {
+	return &beaconApiBeaconChainClient{
 		jsonRestHandler:         jsonRestHandler,
 		fallbackClient:          fallbackClient,
 		stateValidatorsProvider: beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler},

validator/client/beacon-api/beacon_api_beacon_chain_client_test.go

@@ -31,7 +31,7 @@ func TestListValidators(t *testing.T) {
 		defer ctrl.Finish()
 		ctx := context.Background()
 
-		beaconChainClient := beaconApiChainClient{}
+		beaconChainClient := beaconApiBeaconChainClient{}
 		_, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 			PageToken: "foo",
 		})
@@ -43,7 +43,7 @@ func TestListValidators(t *testing.T) {
 		defer ctrl.Finish()
 		ctx := context.Background()
 
-		beaconChainClient := beaconApiChainClient{}
+		beaconChainClient := beaconApiBeaconChainClient{}
 		_, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 			QueryFilter: &ethpb.ListValidatorsRequest_Epoch{
 				Epoch: math.MaxUint64,
@@ -63,7 +63,7 @@ func TestListValidators(t *testing.T) {
 			errors.New("foo error"),
 		)
 
-		beaconChainClient := beaconApiChainClient{stateValidatorsProvider: stateValidatorsProvider}
+		beaconChainClient := beaconApiBeaconChainClient{stateValidatorsProvider: stateValidatorsProvider}
 		_, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 			QueryFilter: &ethpb.ListValidatorsRequest_Epoch{
 				Epoch: 0,
@@ -83,7 +83,7 @@ func TestListValidators(t *testing.T) {
 			errors.New("bar error"),
 		)
 
-		beaconChainClient := beaconApiChainClient{stateValidatorsProvider: stateValidatorsProvider}
+		beaconChainClient := beaconApiBeaconChainClient{stateValidatorsProvider: stateValidatorsProvider}
 		_, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 			QueryFilter: &ethpb.ListValidatorsRequest_Genesis{},
 		})
@@ -101,7 +101,7 @@ func TestListValidators(t *testing.T) {
 			errors.New("foo error"),
 		)
 
-		beaconChainClient := beaconApiChainClient{stateValidatorsProvider: stateValidatorsProvider}
+		beaconChainClient := beaconApiBeaconChainClient{stateValidatorsProvider: stateValidatorsProvider}
 		_, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 			QueryFilter: nil,
 		})
@@ -122,7 +122,7 @@ func TestListValidators(t *testing.T) {
 		jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 		jsonRestHandler.EXPECT().Get(ctx, blockHeaderEndpoint, gomock.Any()).Return(errors.New("bar error"))
 
-		beaconChainClient := beaconApiChainClient{
+		beaconChainClient := beaconApiBeaconChainClient{
 			stateValidatorsProvider: stateValidatorsProvider,
 			jsonRestHandler:         jsonRestHandler,
 		}
@@ -200,7 +200,7 @@ func TestListValidators(t *testing.T) {
 					testCase.blockHeaderResponse,
 				)
 
-				beaconChainClient := beaconApiChainClient{
+				beaconChainClient := beaconApiBeaconChainClient{
 					stateValidatorsProvider: stateValidatorsProvider,
 					jsonRestHandler:         jsonRestHandler,
 				}
@@ -333,7 +333,7 @@ func TestListValidators(t *testing.T) {
 					nil,
 				)
 
-				beaconChainClient := beaconApiChainClient{stateValidatorsProvider: stateValidatorsProvider}
+				beaconChainClient := beaconApiBeaconChainClient{stateValidatorsProvider: stateValidatorsProvider}
 				_, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 					QueryFilter: &ethpb.ListValidatorsRequest_Genesis{},
 				})
@@ -561,7 +561,7 @@ func TestListValidators(t *testing.T) {
 					nil,
 				)
 
-				beaconChainClient := beaconApiChainClient{stateValidatorsProvider: stateValidatorsProvider}
+				beaconChainClient := beaconApiBeaconChainClient{stateValidatorsProvider: stateValidatorsProvider}
 				validators, err := beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{
 					QueryFilter: &ethpb.ListValidatorsRequest_Genesis{},
 					PublicKeys:  [][]byte{},
@@ -752,7 +752,7 @@ func TestGetChainHead(t *testing.T) {
 					testCase.generateFinalityCheckpointsResponse(),
 				)
 
-				beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
+				beaconChainClient := beaconApiBeaconChainClient{jsonRestHandler: jsonRestHandler}
 				_, err := beaconChainClient.GetChainHead(ctx, &emptypb.Empty{})
 				assert.ErrorContains(t, testCase.expectedError, err)
 			})
@@ -859,7 +859,7 @@ func TestGetChainHead(t *testing.T) {
 					testCase.generateHeadBlockHeadersResponse(),
 				)
 
-				beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
+				beaconChainClient := beaconApiBeaconChainClient{jsonRestHandler: jsonRestHandler}
 				_, err := beaconChainClient.GetChainHead(ctx, &emptypb.Empty{})
 				assert.ErrorContains(t, testCase.expectedError, err)
 			})
@@ -913,7 +913,7 @@ func TestGetChainHead(t *testing.T) {
 			HeadEpoch:                  slots.ToEpoch(8),
 		}
 
-		beaconChainClient := beaconApiChainClient{jsonRestHandler: jsonRestHandler}
+		beaconChainClient := beaconApiBeaconChainClient{jsonRestHandler: jsonRestHandler}
 		chainHead, err := beaconChainClient.GetChainHead(ctx, &emptypb.Empty{})
 		require.NoError(t, err)
 		assert.DeepEqual(t, expectedChainHead, chainHead)
@@ -949,7 +949,7 @@ func Test_beaconApiBeaconChainClient_GetValidatorPerformance(t *testing.T) {
 		nil,
 	)
 
-	c := beaconApiChainClient{
+	c := beaconApiBeaconChainClient{
 		jsonRestHandler: jsonRestHandler,
 	}
 

validator/client/beacon-api/beacon_api_validator_client.go

@@ -23,7 +23,7 @@ type beaconApiValidatorClient struct {
 	stateValidatorsProvider StateValidatorsProvider
 	jsonRestHandler         JsonRestHandler
 	beaconBlockConverter    BeaconBlockConverter
-	prysmChainClient        iface.PrysmChainClient
+	prysmBeaconChainCLient  iface.PrysmBeaconChainClient
 	isEventStreamRunning    bool
 }
 
@@ -34,7 +34,7 @@ func NewBeaconApiValidatorClient(jsonRestHandler JsonRestHandler, opts ...Valida
 		stateValidatorsProvider: beaconApiStateValidatorsProvider{jsonRestHandler: jsonRestHandler},
 		jsonRestHandler:         jsonRestHandler,
 		beaconBlockConverter:    beaconApiBeaconBlockConverter{},
-		prysmChainClient: prysmChainClient{
+		prysmBeaconChainCLient: prysmBeaconChainClient{
 			nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
 			jsonRestHandler: jsonRestHandler,
 		},

validator/client/beacon-api/mock/json_rest_handler_mock.go

@@ -76,4 +76,3 @@ func (mr *MockJsonRestHandlerMockRecorder) Post(ctx, endpoint, headers, data, re
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockJsonRestHandler)(nil).Post), ctx, endpoint, headers, data, resp)
 }
-

validator/client/beacon-api/prysm_beacon_chain_client.go

@@ -13,20 +13,20 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
 )
 
-// NewPrysmChainClient returns implementation of iface.PrysmChainClient.
-func NewPrysmChainClient(jsonRestHandler JsonRestHandler, nodeClient iface.NodeClient) iface.PrysmChainClient {
-	return prysmChainClient{
+// NewPrysmBeaconChainClient returns implementation of iface.PrysmBeaconChainClient.
+func NewPrysmBeaconChainClient(jsonRestHandler JsonRestHandler, nodeClient iface.NodeClient) iface.PrysmBeaconChainClient {
+	return prysmBeaconChainClient{
 		jsonRestHandler: jsonRestHandler,
 		nodeClient:      nodeClient,
 	}
 }
 
-type prysmChainClient struct {
+type prysmBeaconChainClient struct {
 	jsonRestHandler JsonRestHandler
 	nodeClient      iface.NodeClient
 }
 
-func (c prysmChainClient) GetValidatorCount(ctx context.Context, stateID string, statuses []validator2.Status) ([]iface.ValidatorCount, error) {
+func (c prysmBeaconChainClient) GetValidatorCount(ctx context.Context, stateID string, statuses []validator2.Status) ([]iface.ValidatorCount, error) {
 	// Check node version for prysm beacon node as it is a custom endpoint for prysm beacon node.
 	nodeVersion, err := c.nodeClient.GetVersion(ctx, nil)
 	if err != nil {

validator/client/beacon-api/status.go

@@ -79,7 +79,7 @@ func (c *beaconApiValidatorClient) getValidatorsStatusResponse(ctx context.Conte
 		return nil, nil, nil, errors.Wrap(err, "failed to get state validators")
 	}
 
-	validatorsCountResponse, err := c.prysmChainClient.GetValidatorCount(ctx, "head", nil)
+	validatorsCountResponse, err := c.prysmBeaconChainCLient.GetValidatorCount(ctx, "head", nil)
 	if err != nil && !errors.Is(err, iface.ErrNotSupported) {
 		return nil, nil, nil, errors.Wrap(err, "failed to get total validator count")
 	}

validator/client/beacon-api/status_test.go

@@ -55,7 +55,7 @@ func TestValidatorStatus_Nominal(t *testing.T) {
 	jsonRestHandler := mock.NewMockJsonRestHandler(ctrl)
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: stateValidatorsProvider,
-		prysmChainClient: prysmChainClient{
+		prysmBeaconChainCLient: prysmBeaconChainClient{
 			nodeClient: &beaconApiNodeClient{
 				jsonRestHandler: jsonRestHandler,
 			},
@@ -181,7 +181,7 @@ func TestMultipleValidatorStatus_Nominal(t *testing.T) {
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: stateValidatorsProvider,
-		prysmChainClient: prysmChainClient{
+		prysmBeaconChainCLient: prysmBeaconChainClient{
 			nodeClient: &beaconApiNodeClient{
 				jsonRestHandler: jsonRestHandler,
 			},
@@ -429,7 +429,7 @@ func TestGetValidatorsStatusResponse_Nominal_SomeActiveValidators(t *testing.T)
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: stateValidatorsProvider,
-		prysmChainClient: prysmChainClient{
+		prysmBeaconChainCLient: prysmBeaconChainClient{
 			nodeClient: &beaconApiNodeClient{
 				jsonRestHandler: jsonRestHandler,
 			},
@@ -499,7 +499,7 @@ func TestGetValidatorsStatusResponse_Nominal_NoActiveValidators(t *testing.T) {
 
 	validatorClient := beaconApiValidatorClient{
 		stateValidatorsProvider: stateValidatorsProvider,
-		prysmChainClient: prysmChainClient{
+		prysmBeaconChainCLient: prysmBeaconChainClient{
 			nodeClient: &beaconApiNodeClient{
 				jsonRestHandler: jsonRestHandler,
 			},
@@ -729,7 +729,7 @@ func TestValidatorStatusResponse_InvalidData(t *testing.T) {
 
 				validatorClient := beaconApiValidatorClient{
 					stateValidatorsProvider: stateValidatorsProvider,
-					prysmChainClient: prysmChainClient{
+					prysmBeaconChainCLient: prysmBeaconChainClient{
 						nodeClient: &beaconApiNodeClient{
 							jsonRestHandler: jsonRestHandler,
 						},

validator/client/beacon-api/validator_count_test.go

@@ -141,7 +141,7 @@ func TestGetValidatorCount(t *testing.T) {
 			).Times(test.validatorCountCalled)
 
 			// Type assertion.
-			var client iface.PrysmChainClient = &prysmChainClient{
+			var client iface.PrysmBeaconChainClient = &prysmBeaconChainClient{
 				nodeClient:      &beaconApiNodeClient{jsonRestHandler: jsonRestHandler},
 				jsonRestHandler: jsonRestHandler,
 			}

validator/client/beacon-chain-client-factory/beacon_chain_client_factory.go

@@ -9,19 +9,19 @@ import (
 	validatorHelpers "github.com/prysmaticlabs/prysm/v5/validator/helpers"
 )
 
-func NewChainClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.JsonRestHandler) iface.ChainClient {
-	grpcClient := grpcApi.NewGrpcChainClient(validatorConn.GetGrpcClientConn())
+func NewBeaconChainClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.JsonRestHandler) iface.BeaconChainClient {
+	grpcClient := grpcApi.NewGrpcBeaconChainClient(validatorConn.GetGrpcClientConn())
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewBeaconApiChainClientWithFallback(jsonRestHandler, grpcClient)
+		return beaconApi.NewBeaconApiBeaconChainClientWithFallback(jsonRestHandler, grpcClient)
 	} else {
 		return grpcClient
 	}
 }
 
-func NewPrysmChainClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.JsonRestHandler) iface.PrysmChainClient {
+func NewPrysmBeaconClient(validatorConn validatorHelpers.NodeConnection, jsonRestHandler beaconApi.JsonRestHandler) iface.PrysmBeaconChainClient {
 	if features.Get().EnableBeaconRESTApi {
-		return beaconApi.NewPrysmChainClient(jsonRestHandler, nodeClientFactory.NewNodeClient(validatorConn, jsonRestHandler))
+		return beaconApi.NewPrysmBeaconChainClient(jsonRestHandler, nodeClientFactory.NewNodeClient(validatorConn, jsonRestHandler))
 	} else {
-		return grpcApi.NewGrpcPrysmChainClient(validatorConn.GetGrpcClientConn())
+		return grpcApi.NewGrpcPrysmBeaconChainClient(validatorConn.GetGrpcClientConn())
 	}
 }

validator/client/grpc-api/grpc_beacon_chain_client.go

@@ -9,34 +9,34 @@ import (
 	"google.golang.org/grpc"
 )
 
-type grpcChainClient struct {
+type grpcBeaconChainClient struct {
 	beaconChainClient ethpb.BeaconChainClient
 }
 
-func (c *grpcChainClient) GetChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error) {
+func (c *grpcBeaconChainClient) GetChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error) {
 	return c.beaconChainClient.GetChainHead(ctx, in)
 }
 
-func (c *grpcChainClient) ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
+func (c *grpcBeaconChainClient) ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error) {
 	return c.beaconChainClient.ListValidatorBalances(ctx, in)
 }
 
-func (c *grpcChainClient) ListValidators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error) {
+func (c *grpcBeaconChainClient) ListValidators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error) {
 	return c.beaconChainClient.ListValidators(ctx, in)
 }
 
-func (c *grpcChainClient) GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
+func (c *grpcBeaconChainClient) GetValidatorQueue(ctx context.Context, in *empty.Empty) (*ethpb.ValidatorQueue, error) {
 	return c.beaconChainClient.GetValidatorQueue(ctx, in)
 }
 
-func (c *grpcChainClient) GetValidatorPerformance(ctx context.Context, in *ethpb.ValidatorPerformanceRequest) (*ethpb.ValidatorPerformanceResponse, error) {
+func (c *grpcBeaconChainClient) GetValidatorPerformance(ctx context.Context, in *ethpb.ValidatorPerformanceRequest) (*ethpb.ValidatorPerformanceResponse, error) {
 	return c.beaconChainClient.GetValidatorPerformance(ctx, in)
 }
 
-func (c *grpcChainClient) GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
+func (c *grpcBeaconChainClient) GetValidatorParticipation(ctx context.Context, in *ethpb.GetValidatorParticipationRequest) (*ethpb.ValidatorParticipationResponse, error) {
 	return c.beaconChainClient.GetValidatorParticipation(ctx, in)
 }
 
-func NewGrpcChainClient(cc grpc.ClientConnInterface) iface.ChainClient {
-	return &grpcChainClient{ethpb.NewBeaconChainClient(cc)}
+func NewGrpcBeaconChainClient(cc grpc.ClientConnInterface) iface.BeaconChainClient {
+	return &grpcBeaconChainClient{ethpb.NewBeaconChainClient(cc)}
 }

validator/client/grpc-api/grpc_prysm_beacon_chain_client.go

@@ -18,12 +18,12 @@ import (
 	"google.golang.org/grpc"
 )
 
-type grpcPrysmChainClient struct {
-	chainClient iface.ChainClient
+type grpcPrysmBeaconChainClient struct {
+	beaconChainClient iface.BeaconChainClient
 }
 
-func (g grpcPrysmChainClient) GetValidatorCount(ctx context.Context, _ string, statuses []validator.Status) ([]iface.ValidatorCount, error) {
-	resp, err := g.chainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{PageSize: 0})
+func (g grpcPrysmBeaconChainClient) GetValidatorCount(ctx context.Context, _ string, statuses []validator.Status) ([]iface.ValidatorCount, error) {
+	resp, err := g.beaconChainClient.ListValidators(ctx, &ethpb.ListValidatorsRequest{PageSize: 0})
 	if err != nil {
 		return nil, errors.Wrap(err, "list validators failed")
 	}
@@ -33,7 +33,7 @@ func (g grpcPrysmChainClient) GetValidatorCount(ctx context.Context, _ string, s
 		vals = append(vals, val.Validator)
 	}
 
-	head, err := g.chainClient.GetChainHead(ctx, &empty.Empty{})
+	head, err := g.beaconChainClient.GetChainHead(ctx, &empty.Empty{})
 	if err != nil {
 		return nil, errors.Wrap(err, "get chain head")
 	}
@@ -92,6 +92,6 @@ func validatorCountByStatus(validators []*ethpb.Validator, statuses []validator.
 	return resp, nil
 }
 
-func NewGrpcPrysmChainClient(cc grpc.ClientConnInterface) iface.PrysmChainClient {
-	return &grpcPrysmChainClient{chainClient: &grpcChainClient{ethpb.NewBeaconChainClient(cc)}}
+func NewGrpcPrysmBeaconChainClient(cc grpc.ClientConnInterface) iface.PrysmBeaconChainClient {
+	return &grpcPrysmBeaconChainClient{beaconChainClient: &grpcBeaconChainClient{ethpb.NewBeaconChainClient(cc)}}
 }

validator/client/grpc-api/grpc_prysm_beacon_chain_client_test.go

@@ -291,8 +291,8 @@ func TestGetValidatorCount(t *testing.T) {
 				})
 			}
 
-			chainClient := mock.NewMockChainClient(ctrl)
-			chainClient.EXPECT().ListValidators(
+			beaconChainClient := mock.NewMockBeaconChainClient(ctrl)
+			beaconChainClient.EXPECT().ListValidators(
 				gomock.Any(),
 				gomock.Any(),
 			).Return(
@@ -300,7 +300,7 @@ func TestGetValidatorCount(t *testing.T) {
 				nil,
 			)
 
-			chainClient.EXPECT().GetChainHead(
+			beaconChainClient.EXPECT().GetChainHead(
 				gomock.Any(),
 				gomock.Any(),
 			).Return(
@@ -308,8 +308,8 @@ func TestGetValidatorCount(t *testing.T) {
 				nil,
 			)
 
-			prysmBeaconChainClient := &grpcPrysmChainClient{
-				chainClient: chainClient,
+			prysmBeaconChainClient := &grpcPrysmBeaconChainClient{
+				beaconChainClient: beaconChainClient,
 			}
 
 			var statuses []validator.Status

validator/client/iface/beacon_chain_client.go

@@ -7,7 +7,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
-type ChainClient interface {
+type BeaconChainClient interface {
 	GetChainHead(ctx context.Context, in *empty.Empty) (*ethpb.ChainHead, error)
 	ListValidatorBalances(ctx context.Context, in *ethpb.ListValidatorBalancesRequest) (*ethpb.ValidatorBalances, error)
 	ListValidators(ctx context.Context, in *ethpb.ListValidatorsRequest) (*ethpb.Validators, error)

validator/client/iface/prysm_beacon_chain_client.go

@@ -14,7 +14,7 @@ type ValidatorCount struct {
 	Count  uint64
 }
 
-// PrysmChainClient defines an interface required to implement all the prysm specific custom endpoints.
-type PrysmChainClient interface {
+// PrysmBeaconChainClient defines an interface required to implement all the prysm specific custom endpoints.
+type PrysmBeaconChainClient interface {
 	GetValidatorCount(context.Context, string, []validator.Status) ([]ValidatorCount, error)
 }

validator/client/key_reload.go

@@ -39,7 +39,7 @@ func (v *validator) HandleKeyReload(ctx context.Context, currentKeys [][fieldpar
 
 	// "-1" indicates that validator count endpoint is not supported by the beacon node.
 	var valCount int64 = -1
-	valCounts, err := v.prysmChainClient.GetValidatorCount(ctx, "head", []validator2.Status{validator2.Active})
+	valCounts, err := v.prysmBeaconClient.GetValidatorCount(ctx, "head", []validator2.Status{validator2.Active})
 	if err != nil && !errors.Is(err, iface.ErrNotSupported) {
 		return false, errors.Wrap(err, "could not get active validator count")
 	}

validator/client/key_reload_test.go

@@ -29,14 +29,14 @@ func TestValidator_HandleKeyReload(t *testing.T) {
 		active := randKeypair(t)
 
 		client := validatormock.NewMockValidatorClient(ctrl)
-		chainClient := validatormock.NewMockChainClient(ctrl)
-		prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+		beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+		prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 		v := validator{
-			validatorClient:  client,
-			km:               newMockKeymanager(t, inactive),
-			genesisTime:      1,
-			chainClient:      chainClient,
-			prysmChainClient: prysmChainClient,
+			validatorClient:   client,
+			keyManager:        newMockKeymanager(t, inactive),
+			genesisTime:       1,
+			beaconClient:      beaconClient,
+			prysmBeaconClient: prysmBeaconClient,
 		}
 
 		resp := testutil.GenerateMultipleValidatorStatusResponse([][]byte{inactive.pub[:], active.pub[:]})
@@ -48,7 +48,7 @@ func TestValidator_HandleKeyReload(t *testing.T) {
 				PublicKeys: [][]byte{inactive.pub[:], active.pub[:]},
 			},
 		).Return(resp, nil)
-		prysmChainClient.EXPECT().GetValidatorCount(
+		prysmBeaconClient.EXPECT().GetValidatorCount(
 			gomock.Any(),
 			"head",
 			[]validator2.Status{validator2.Active},
@@ -65,15 +65,15 @@ func TestValidator_HandleKeyReload(t *testing.T) {
 		hook := logTest.NewGlobal()
 
 		client := validatormock.NewMockValidatorClient(ctrl)
-		chainClient := validatormock.NewMockChainClient(ctrl)
-		prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+		beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+		prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 		kp := randKeypair(t)
 		v := validator{
-			validatorClient:  client,
-			km:               newMockKeymanager(t, kp),
-			genesisTime:      1,
-			chainClient:      chainClient,
-			prysmChainClient: prysmChainClient,
+			validatorClient:   client,
+			keyManager:        newMockKeymanager(t, kp),
+			genesisTime:       1,
+			beaconClient:      beaconClient,
+			prysmBeaconClient: prysmBeaconClient,
 		}
 
 		resp := testutil.GenerateMultipleValidatorStatusResponse([][]byte{kp.pub[:]})
@@ -84,7 +84,7 @@ func TestValidator_HandleKeyReload(t *testing.T) {
 				PublicKeys: [][]byte{kp.pub[:]},
 			},
 		).Return(resp, nil)
-		prysmChainClient.EXPECT().GetValidatorCount(
+		prysmBeaconClient.EXPECT().GetValidatorCount(
 			gomock.Any(),
 			"head",
 			[]validator2.Status{validator2.Active},
@@ -102,7 +102,7 @@ func TestValidator_HandleKeyReload(t *testing.T) {
 		client := validatormock.NewMockValidatorClient(ctrl)
 		v := validator{
 			validatorClient: client,
-			km:              newMockKeymanager(t, kp),
+			keyManager:      newMockKeymanager(t, kp),
 			genesisTime:     1,
 		}
 

validator/client/metrics.go

@@ -234,13 +234,13 @@ func (v *validator) LogValidatorGainsAndLosses(ctx context.Context, slot primiti
 		// Do nothing unless we are at the end of the epoch, and not in the first epoch.
 		return nil
 	}
-	if !v.logValidatorPerformance {
+	if !v.logValidatorBalances {
 		return nil
 	}
 
 	var pks [][fieldparams.BLSPubkeyLength]byte
 	var err error
-	pks, err = v.km.FetchValidatingPublicKeys(ctx)
+	pks, err = v.keyManager.FetchValidatingPublicKeys(ctx)
 	if err != nil {
 		return err
 	}
@@ -249,7 +249,7 @@ func (v *validator) LogValidatorGainsAndLosses(ctx context.Context, slot primiti
 	req := &ethpb.ValidatorPerformanceRequest{
 		PublicKeys: pubKeys,
 	}
-	resp, err := v.chainClient.GetValidatorPerformance(ctx, req)
+	resp, err := v.beaconClient.GetValidatorPerformance(ctx, req)
 	if err != nil {
 		return err
 	}
@@ -270,11 +270,11 @@ func (v *validator) LogValidatorGainsAndLosses(ctx context.Context, slot primiti
 			v.voteStats.startEpoch = prevEpoch
 		}
 	}
-	v.prevEpochBalancesLock.Lock()
+	v.prevBalanceLock.Lock()
 	for i, pubKey := range resp.PublicKeys {
 		v.logForEachValidator(i, pubKey, resp, slot, prevEpoch)
 	}
-	v.prevEpochBalancesLock.Unlock()
+	v.prevBalanceLock.Unlock()
 
 	v.UpdateLogAggregateStats(resp, slot)
 	return nil
@@ -284,7 +284,7 @@ func (v *validator) logForEachValidator(index int, pubKey []byte, resp *ethpb.Va
 	truncatedKey := fmt.Sprintf("%#x", bytesutil.Trunc(pubKey))
 	pubKeyBytes := bytesutil.ToBytes48(pubKey)
 	if slot < params.BeaconConfig().SlotsPerEpoch {
-		v.prevEpochBalances[pubKeyBytes] = params.BeaconConfig().MaxEffectiveBalance
+		v.prevBalance[pubKeyBytes] = params.BeaconConfig().MaxEffectiveBalance
 	}
 
 	// Safely load data from response with slice out of bounds checks. The server should return
@@ -325,7 +325,7 @@ func (v *validator) logForEachValidator(index int, pubKey []byte, resp *ethpb.Va
 
 	fmtKey := fmt.Sprintf("%#x", pubKey)
 	gweiPerEth := float64(params.BeaconConfig().GweiPerEth)
-	if v.prevEpochBalances[pubKeyBytes] > 0 {
+	if v.prevBalance[pubKeyBytes] > 0 {
 		newBalance := float64(balAfterEpoch) / gweiPerEth
 		prevBalance := float64(balBeforeEpoch) / gweiPerEth
 		startBalance := float64(v.startBalances[pubKeyBytes]) / gweiPerEth
@@ -380,7 +380,7 @@ func (v *validator) logForEachValidator(index int, pubKey []byte, resp *ethpb.Va
 			}
 		}
 	}
-	v.prevEpochBalances[pubKeyBytes] = balBeforeEpoch
+	v.prevBalance[pubKeyBytes] = balBeforeEpoch
 }
 
 // UpdateLogAggregateStats updates and logs the voteStats struct of a validator using the RPC response obtained from LogValidatorGainsAndLosses.
@@ -438,12 +438,12 @@ func (v *validator) UpdateLogAggregateStats(resp *ethpb.ValidatorPerformanceResp
 	log.WithFields(epochSummaryFields).Info("Previous epoch aggregated voting summary")
 
 	var totalStartBal, totalPrevBal uint64
-	v.prevEpochBalancesLock.RLock()
+	v.prevBalanceLock.RLock()
 	for i, val := range v.startBalances {
 		totalStartBal += val
-		totalPrevBal += v.prevEpochBalances[i]
+		totalPrevBal += v.prevBalance[i]
 	}
-	v.prevEpochBalancesLock.RUnlock()
+	v.prevBalanceLock.RUnlock()
 
 	if totalStartBal == 0 || summary.totalAttestedCount == 0 {
 		log.Error("Failed to print launch summary: one or more divisors is 0")

validator/client/metrics_test.go

@@ -15,9 +15,9 @@ import (
 
 func TestUpdateLogAggregateStats(t *testing.T) {
 	v := &validator{
-		logValidatorPerformance: true,
-		startBalances:           make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
-		prevEpochBalances:       make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
+		logValidatorBalances: true,
+		startBalances:        make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
+		prevBalance:          make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
 		voteStats: voteStats{
 			startEpoch: 0, // this would otherwise have been previously set in LogValidatorGainsAndLosses()
 		},
@@ -66,9 +66,9 @@ func TestUpdateLogAggregateStats(t *testing.T) {
 		},
 	}
 
-	v.prevEpochBalances[pubKeyBytes[0]] = uint64(33200000000)
-	v.prevEpochBalances[pubKeyBytes[1]] = uint64(33300000000)
-	v.prevEpochBalances[pubKeyBytes[2]] = uint64(31000000000)
+	v.prevBalance[pubKeyBytes[0]] = uint64(33200000000)
+	v.prevBalance[pubKeyBytes[1]] = uint64(33300000000)
+	v.prevBalance[pubKeyBytes[2]] = uint64(31000000000)
 
 	var hook *logTest.Hook
 
@@ -89,9 +89,9 @@ func TestUpdateLogAggregateStats(t *testing.T) {
 
 func TestUpdateLogAltairAggregateStats(t *testing.T) {
 	v := &validator{
-		logValidatorPerformance: true,
-		startBalances:           make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
-		prevEpochBalances:       make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
+		logValidatorBalances: true,
+		startBalances:        make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
+		prevBalance:          make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
 		voteStats: voteStats{
 			startEpoch: params.BeaconConfig().AltairForkEpoch, // this would otherwise have been previously set in LogValidatorGainsAndLosses()
 		},
@@ -141,9 +141,9 @@ func TestUpdateLogAltairAggregateStats(t *testing.T) {
 		},
 	}
 
-	v.prevEpochBalances[pubKeyBytes[0]] = uint64(33200000000)
-	v.prevEpochBalances[pubKeyBytes[1]] = uint64(33300000000)
-	v.prevEpochBalances[pubKeyBytes[2]] = uint64(31000000000)
+	v.prevBalance[pubKeyBytes[0]] = uint64(33200000000)
+	v.prevBalance[pubKeyBytes[1]] = uint64(33300000000)
+	v.prevBalance[pubKeyBytes[2]] = uint64(31000000000)
 
 	var hook *logTest.Hook
 

validator/client/propose.go

@@ -302,7 +302,7 @@ func (v *validator) signRandaoReveal(ctx context.Context, pubKey [fieldparams.BL
 	if err != nil {
 		return nil, err
 	}
-	randaoReveal, err = v.km.Sign(ctx, &validatorpb.SignRequest{
+	randaoReveal, err = v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     root[:],
 		SignatureDomain: domain.SignatureDomain,
@@ -334,7 +334,7 @@ func (v *validator) signBlock(ctx context.Context, pubKey [fieldparams.BLSPubkey
 	if err != nil {
 		return nil, [32]byte{}, err
 	}
-	sig, err := v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err := v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     blockRoot[:],
 		SignatureDomain: domain.SignatureDomain,

validator/client/propose_test.go

@@ -94,7 +94,7 @@ func setupWithKey(t *testing.T, validatorKey bls.SecretKey, isSlashingProtection
 
 	validator := &validator{
 		db:                             valDB,
-		km:                             newMockKeymanager(t, keypair{pub: pubKey, pri: validatorKey}),
+		keyManager:                     newMockKeymanager(t, keypair{pub: pubKey, pri: validatorKey}),
 		validatorClient:                m.validatorClient,
 		graffiti:                       []byte{},
 		submittedAtts:                  make(map[submittedAttKey]*submittedAtt),
@@ -866,7 +866,7 @@ func TestSignBlock(t *testing.T) {
 
 			kp := testKeyFromBytes(t, []byte{1})
 
-			validator.km = newMockKeymanager(t, kp)
+			validator.keyManager = newMockKeymanager(t, kp)
 			b, err := blocks.NewBeaconBlock(blk.Block)
 			require.NoError(t, err)
 			sig, blockRoot, err := validator.signBlock(ctx, kp.pub, 0, 0, b)
@@ -902,7 +902,7 @@ func TestSignAltairBlock(t *testing.T) {
 			blk := util.NewBeaconBlockAltair()
 			blk.Block.Slot = 1
 			blk.Block.ProposerIndex = 100
-			validator.km = newMockKeymanager(t, kp)
+			validator.keyManager = newMockKeymanager(t, kp)
 			wb, err := blocks.NewBeaconBlock(blk.Block)
 			require.NoError(t, err)
 			sig, blockRoot, err := validator.signBlock(ctx, kp.pub, 0, 0, wb)
@@ -935,7 +935,7 @@ func TestSignBellatrixBlock(t *testing.T) {
 			blk.Block.ProposerIndex = 100
 
 			kp := randKeypair(t)
-			validator.km = newMockKeymanager(t, kp)
+			validator.keyManager = newMockKeymanager(t, kp)
 			wb, err := blocks.NewBeaconBlock(blk.Block)
 			require.NoError(t, err)
 			sig, blockRoot, err := validator.signBlock(ctx, kp.pub, 0, 0, wb)

validator/client/runner_test.go

@@ -181,8 +181,7 @@ func TestAttests_NextSlot(t *testing.T) {
 	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
 	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
 	_ = tracker.CheckHealth(context.Background())
-	attSubmitted := make(chan interface{})
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker, AttSubmitted: attSubmitted}
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -194,8 +193,9 @@ func TestAttests_NextSlot(t *testing.T) {
 
 		cancel()
 	}()
+	timer := time.NewTimer(200 * time.Millisecond)
 	run(ctx, v)
-	<-attSubmitted
+	<-timer.C
 	require.Equal(t, true, v.AttestToBlockHeadCalled, "SubmitAttestation(%d) was not called", slot)
 	assert.Equal(t, uint64(slot), v.AttestToBlockHeadArg1, "SubmitAttestation was called with wrong arg")
 }
@@ -208,8 +208,7 @@ func TestProposes_NextSlot(t *testing.T) {
 	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
 	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
 	_ = tracker.CheckHealth(context.Background())
-	blockProposed := make(chan interface{})
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker, BlockProposed: blockProposed}
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -221,9 +220,9 @@ func TestProposes_NextSlot(t *testing.T) {
 
 		cancel()
 	}()
+	timer := time.NewTimer(200 * time.Millisecond)
 	run(ctx, v)
-	<-blockProposed
-
+	<-timer.C
 	require.Equal(t, true, v.ProposeBlockCalled, "ProposeBlock(%d) was not called", slot)
 	assert.Equal(t, uint64(slot), v.ProposeBlockArg1, "ProposeBlock was called with wrong arg")
 }
@@ -236,9 +235,7 @@ func TestBothProposesAndAttests_NextSlot(t *testing.T) {
 	node.EXPECT().IsHealthy(gomock.Any()).Return(true).AnyTimes()
 	// avoid race condition between the cancellation of the context in the go stream from slot and the setting of IsHealthy
 	_ = tracker.CheckHealth(context.Background())
-	blockProposed := make(chan interface{})
-	attSubmitted := make(chan interface{})
-	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker, BlockProposed: blockProposed, AttSubmitted: attSubmitted}
+	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, Tracker: tracker}
 	ctx, cancel := context.WithCancel(context.Background())
 
 	slot := primitives.Slot(55)
@@ -250,9 +247,9 @@ func TestBothProposesAndAttests_NextSlot(t *testing.T) {
 
 		cancel()
 	}()
+	timer := time.NewTimer(200 * time.Millisecond)
 	run(ctx, v)
-	<-blockProposed
-	<-attSubmitted
+	<-timer.C
 	require.Equal(t, true, v.AttestToBlockHeadCalled, "SubmitAttestation(%d) was not called", slot)
 	assert.Equal(t, uint64(slot), v.AttestToBlockHeadArg1, "SubmitAttestation was called with wrong arg")
 	require.Equal(t, true, v.ProposeBlockCalled, "ProposeBlock(%d) was not called", slot)

validator/client/service.go

@@ -3,6 +3,7 @@ package client
 import (
 	"context"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/dgraph-io/ristretto"
@@ -34,54 +35,75 @@ import (
 	"go.opencensus.io/plugin/ocgrpc"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
+	"google.golang.org/protobuf/types/known/emptypb"
 )
 
+// SyncChecker is able to determine if a beacon node is currently
+// going through chain synchronization.
+type SyncChecker interface {
+	Syncing(ctx context.Context) (bool, error)
+}
+
+// GenesisFetcher can retrieve genesis information such as
+// the genesis time and the validator deposit contract address.
+type GenesisFetcher interface {
+	GenesisInfo(ctx context.Context) (*ethpb.Genesis, error)
+}
+
 // ValidatorService represents a service to manage the validator client
 // routine.
 type ValidatorService struct {
-	ctx                     context.Context
-	cancel                  context.CancelFunc
-	validator               iface.Validator
-	db                      db.Database
-	conn                    validatorHelpers.NodeConnection
-	wallet                  *wallet.Wallet
-	walletInitializedFeed   *event.Feed
-	graffiti                []byte
-	graffitiStruct          *graffiti.Graffiti
-	interopKeysConfig       *local.InteropKeymanagerConfig
-	web3SignerConfig        *remoteweb3signer.SetupConfig
-	proposerSettings        *proposer.Settings
-	validatorsRegBatchSize  int
-	useWeb                  bool
-	emitAccountMetrics      bool
-	logValidatorPerformance bool
-	distributed             bool
+	useWeb                 bool
+	emitAccountMetrics     bool
+	logValidatorBalances   bool
+	distributed            bool
+	interopKeysConfig      *local.InteropKeymanagerConfig
+	conn                   validatorHelpers.NodeConnection
+	grpcRetryDelay         time.Duration
+	grpcRetries            uint
+	maxCallRecvMsgSize     int
+	cancel                 context.CancelFunc
+	walletInitializedFeed  *event.Feed
+	wallet                 *wallet.Wallet
+	graffitiStruct         *graffiti.Graffiti
+	dataDir                string
+	withCert               string
+	endpoint               string
+	ctx                    context.Context
+	validator              iface.Validator
+	db                     db.Database
+	grpcHeaders            []string
+	graffiti               []byte
+	Web3SignerConfig       *remoteweb3signer.SetupConfig
+	proposerSettings       *proposer.Settings
+	validatorsRegBatchSize int
 }
 
 // Config for the validator service.
 type Config struct {
-	Validator               iface.Validator
-	DB                      db.Database
-	Wallet                  *wallet.Wallet
-	WalletInitializedFeed   *event.Feed
-	GRPCMaxCallRecvMsgSize  int
-	GRPCRetries             uint
-	GRPCRetryDelay          time.Duration
-	GRPCHeaders             []string
-	BeaconNodeGRPCEndpoint  string
-	BeaconNodeCert          string
-	BeaconApiEndpoint       string
-	BeaconApiTimeout        time.Duration
-	Graffiti                string
-	GraffitiStruct          *graffiti.Graffiti
-	InteropKmConfig         *local.InteropKeymanagerConfig
-	Web3SignerConfig        *remoteweb3signer.SetupConfig
-	ProposerSettings        *proposer.Settings
-	ValidatorsRegBatchSize  int
-	UseWeb                  bool
-	LogValidatorPerformance bool
-	EmitAccountMetrics      bool
-	Distributed             bool
+	UseWeb                     bool
+	LogValidatorBalances       bool
+	EmitAccountMetrics         bool
+	Distributed                bool
+	InteropKeysConfig          *local.InteropKeymanagerConfig
+	Wallet                     *wallet.Wallet
+	WalletInitializedFeed      *event.Feed
+	GrpcRetriesFlag            uint
+	GrpcMaxCallRecvMsgSizeFlag int
+	GrpcRetryDelay             time.Duration
+	GraffitiStruct             *graffiti.Graffiti
+	Validator                  iface.Validator
+	ValDB                      db.Database
+	CertFlag                   string
+	DataDir                    string
+	GrpcHeadersFlag            string
+	GraffitiFlag               string
+	Endpoint                   string
+	Web3SignerConfig           *remoteweb3signer.SetupConfig
+	ProposerSettings           *proposer.Settings
+	BeaconApiEndpoint          string
+	BeaconApiTimeout           time.Duration
+	ValidatorsRegBatchSize     int
 }
 
 // NewValidatorService creates a new validator service for the service
@@ -89,41 +111,48 @@ type Config struct {
 func NewValidatorService(ctx context.Context, cfg *Config) (*ValidatorService, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	s := &ValidatorService{
-		ctx:                     ctx,
-		cancel:                  cancel,
-		validator:               cfg.Validator,
-		db:                      cfg.DB,
-		wallet:                  cfg.Wallet,
-		walletInitializedFeed:   cfg.WalletInitializedFeed,
-		graffiti:                []byte(cfg.Graffiti),
-		graffitiStruct:          cfg.GraffitiStruct,
-		interopKeysConfig:       cfg.InteropKmConfig,
-		web3SignerConfig:        cfg.Web3SignerConfig,
-		proposerSettings:        cfg.ProposerSettings,
-		validatorsRegBatchSize:  cfg.ValidatorsRegBatchSize,
-		useWeb:                  cfg.UseWeb,
-		emitAccountMetrics:      cfg.EmitAccountMetrics,
-		logValidatorPerformance: cfg.LogValidatorPerformance,
-		distributed:             cfg.Distributed,
+		ctx:                    ctx,
+		cancel:                 cancel,
+		endpoint:               cfg.Endpoint,
+		withCert:               cfg.CertFlag,
+		dataDir:                cfg.DataDir,
+		graffiti:               []byte(cfg.GraffitiFlag),
+		logValidatorBalances:   cfg.LogValidatorBalances,
+		emitAccountMetrics:     cfg.EmitAccountMetrics,
+		maxCallRecvMsgSize:     cfg.GrpcMaxCallRecvMsgSizeFlag,
+		grpcRetries:            cfg.GrpcRetriesFlag,
+		grpcRetryDelay:         cfg.GrpcRetryDelay,
+		grpcHeaders:            strings.Split(cfg.GrpcHeadersFlag, ","),
+		validator:              cfg.Validator,
+		db:                     cfg.ValDB,
+		wallet:                 cfg.Wallet,
+		walletInitializedFeed:  cfg.WalletInitializedFeed,
+		useWeb:                 cfg.UseWeb,
+		interopKeysConfig:      cfg.InteropKeysConfig,
+		graffitiStruct:         cfg.GraffitiStruct,
+		Web3SignerConfig:       cfg.Web3SignerConfig,
+		proposerSettings:       cfg.ProposerSettings,
+		validatorsRegBatchSize: cfg.ValidatorsRegBatchSize,
+		distributed:            cfg.Distributed,
 	}
 
 	dialOpts := ConstructDialOptions(
-		cfg.GRPCMaxCallRecvMsgSize,
-		cfg.BeaconNodeCert,
-		cfg.GRPCRetries,
-		cfg.GRPCRetryDelay,
+		s.maxCallRecvMsgSize,
+		s.withCert,
+		s.grpcRetries,
+		s.grpcRetryDelay,
 	)
 	if dialOpts == nil {
 		return s, nil
 	}
 
-	s.ctx = grpcutil.AppendHeaders(ctx, cfg.GRPCHeaders)
+	s.ctx = grpcutil.AppendHeaders(ctx, s.grpcHeaders)
 
-	grpcConn, err := grpc.DialContext(ctx, cfg.BeaconNodeGRPCEndpoint, dialOpts...)
+	grpcConn, err := grpc.DialContext(ctx, s.endpoint, dialOpts...)
 	if err != nil {
 		return s, err
 	}
-	if cfg.BeaconNodeCert != "" {
+	if s.withCert != "" {
 		log.Info("Established secure gRPC connection")
 	}
 	s.conn = validatorHelpers.NewNodeConnection(
@@ -173,39 +202,38 @@ func (v *ValidatorService) Start() {
 	validatorClient := validatorClientFactory.NewValidatorClient(v.conn, restHandler)
 
 	valStruct := &validator{
-		slotFeed:                       new(event.Feed),
-		startBalances:                  make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
-		prevEpochBalances:              make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
-		blacklistedPubkeys:             slashablePublicKeys,
-		pubkeyToValidatorIndex:         make(map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex),
-		wallet:                         v.wallet,
-		walletInitializedChan:          make(chan *wallet.Wallet, 1),
-		walletInitializedFeed:          v.walletInitializedFeed,
-		graffiti:                       v.graffiti,
-		graffitiStruct:                 v.graffitiStruct,
-		graffitiOrderedIndex:           graffitiOrderedIndex,
 		validatorClient:                validatorClient,
-		chainClient:                    beaconChainClientFactory.NewChainClient(v.conn, restHandler),
+		beaconClient:                   beaconChainClientFactory.NewBeaconChainClient(v.conn, restHandler),
 		nodeClient:                     nodeClientFactory.NewNodeClient(v.conn, restHandler),
-		prysmChainClient:               beaconChainClientFactory.NewPrysmChainClient(v.conn, restHandler),
+		prysmBeaconClient:              beaconChainClientFactory.NewPrysmBeaconClient(v.conn, restHandler),
 		db:                             v.db,
-		km:                             nil,
-		web3SignerConfig:               v.web3SignerConfig,
-		proposerSettings:               v.proposerSettings,
+		graffiti:                       v.graffiti,
+		logValidatorBalances:           v.logValidatorBalances,
+		emitAccountMetrics:             v.emitAccountMetrics,
+		startBalances:                  make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
+		prevBalance:                    make(map[[fieldparams.BLSPubkeyLength]byte]uint64),
+		pubkeyToValidatorIndex:         make(map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex),
 		signedValidatorRegistrations:   make(map[[fieldparams.BLSPubkeyLength]byte]*ethpb.SignedValidatorRegistrationV1),
-		validatorsRegBatchSize:         v.validatorsRegBatchSize,
-		interopKeysConfig:              v.interopKeysConfig,
-		attSelections:                  make(map[attSelectionKey]iface.BeaconCommitteeSelection),
-		aggregatedSlotCommitteeIDCache: aggregatedSlotCommitteeIDCache,
-		domainDataCache:                cache,
-		voteStats:                      voteStats{startEpoch: primitives.Epoch(^uint64(0))},
-		syncCommitteeStats:             syncCommitteeStats{},
 		submittedAtts:                  make(map[submittedAttKey]*submittedAtt),
 		submittedAggregates:            make(map[submittedAttKey]*submittedAtt),
-		logValidatorPerformance:        v.logValidatorPerformance,
-		emitAccountMetrics:             v.emitAccountMetrics,
+		domainDataCache:                cache,
+		aggregatedSlotCommitteeIDCache: aggregatedSlotCommitteeIDCache,
+		voteStats:                      voteStats{startEpoch: primitives.Epoch(^uint64(0))},
+		syncCommitteeStats:             syncCommitteeStats{},
 		useWeb:                         v.useWeb,
+		interopKeysConfig:              v.interopKeysConfig,
+		wallet:                         v.wallet,
+		walletInitializedFeed:          v.walletInitializedFeed,
+		slotFeed:                       new(event.Feed),
+		graffitiStruct:                 v.graffitiStruct,
+		graffitiOrderedIndex:           graffitiOrderedIndex,
+		eipImportBlacklistedPublicKeys: slashablePublicKeys,
+		Web3SignerConfig:               v.Web3SignerConfig,
+		proposerSettings:               v.proposerSettings,
+		walletInitializedChannel:       make(chan *wallet.Wallet, 1),
+		validatorsRegBatchSize:         v.validatorsRegBatchSize,
 		distributed:                    v.distributed,
+		attSelections:                  make(map[attSelectionKey]iface.BeaconCommitteeSelection),
 	}
 
 	v.validator = valStruct
@@ -240,11 +268,6 @@ func (v *ValidatorService) Keymanager() (keymanager.IKeymanager, error) {
 	return v.validator.Keymanager()
 }
 
-// RemoteSignerConfig returns the web3signer configuration
-func (v *ValidatorService) RemoteSignerConfig() *remoteweb3signer.SetupConfig {
-	return v.web3SignerConfig
-}
-
 // ProposerSettings returns a deep copy of the underlying proposer settings in the validator
 func (v *ValidatorService) ProposerSettings() *proposer.Settings {
 	settings := v.validator.ProposerSettings()
@@ -319,6 +342,23 @@ func ConstructDialOptions(
 	return dialOpts
 }
 
+// Syncing returns whether or not the beacon node is currently synchronizing the chain.
+func (v *ValidatorService) Syncing(ctx context.Context) (bool, error) {
+	nc := ethpb.NewNodeClient(v.conn.GetGrpcClientConn())
+	resp, err := nc.GetSyncStatus(ctx, &emptypb.Empty{})
+	if err != nil {
+		return false, err
+	}
+	return resp.Syncing, nil
+}
+
+// GenesisInfo queries the beacon node for the chain genesis info containing
+// the genesis time along with the validator deposit contract address.
+func (v *ValidatorService) GenesisInfo(ctx context.Context) (*ethpb.Genesis, error) {
+	nc := ethpb.NewNodeClient(v.conn.GetGrpcClientConn())
+	return nc.GetGenesis(ctx, &emptypb.Empty{})
+}
+
 func (v *ValidatorService) GetGraffiti(ctx context.Context, pubKey [fieldparams.BLSPubkeyLength]byte) ([]byte, error) {
 	if v.validator == nil {
 		return nil, errors.New("validator is unavailable")

validator/client/service_test.go

@@ -2,7 +2,6 @@ package client
 
 import (
 	"context"
-	"strings"
 	"testing"
 	"time"
 
@@ -14,6 +13,8 @@ import (
 )
 
 var _ runtime.Service = (*ValidatorService)(nil)
+var _ GenesisFetcher = (*ValidatorService)(nil)
+var _ SyncChecker = (*ValidatorService)(nil)
 
 func TestStop_CancelsContext(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
@@ -58,7 +59,7 @@ func TestStart_GrpcHeaders(t *testing.T) {
 			"Authorization", "this is a valid value",
 		},
 	} {
-		cfg := &Config{GRPCHeaders: strings.Split(input, ",")}
+		cfg := &Config{GrpcHeadersFlag: input}
 		validatorService, err := NewValidatorService(ctx, cfg)
 		require.NoError(t, err)
 		md, _ := metadata.FromOutgoingContext(validatorService.ctx)

validator/client/sync_committee.go

@@ -58,7 +58,7 @@ func (v *validator) SubmitSyncCommitteeMessage(ctx context.Context, slot primiti
 		return
 	}
 
-	sig, err := v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err := v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     r[:],
 		SignatureDomain: d.SignatureDomain,
@@ -243,7 +243,7 @@ func (v *validator) signSyncSelectionData(ctx context.Context, pubKey [fieldpara
 	if err != nil {
 		return nil, err
 	}
-	sig, err := v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err := v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     root[:],
 		SignatureDomain: domain.SignatureDomain,
@@ -266,7 +266,7 @@ func (v *validator) signContributionAndProof(ctx context.Context, pubKey [fieldp
 	if err != nil {
 		return nil, err
 	}
-	sig, err := v.km.Sign(ctx, &validatorpb.SignRequest{
+	sig, err := v.keyManager.Sign(ctx, &validatorpb.SignRequest{
 		PublicKey:       pubKey[:],
 		SigningRoot:     root[:],
 		SignatureDomain: d.SignatureDomain,

validator/client/testutil/mock_validator.go

@@ -3,7 +3,6 @@ package testutil
 import (
 	"bytes"
 	"context"
-	"errors"
 	"time"
 
 	api "github.com/prysmaticlabs/prysm/v5/api/client"
@@ -61,8 +60,6 @@ type FakeValidator struct {
 	Km                                keymanager.IKeymanager
 	graffiti                          string
 	Tracker                           *beacon.NodeHealthTracker
-	AttSubmitted                      chan interface{}
-	BlockProposed                     chan interface{}
 }
 
 // Done for mocking.
@@ -76,7 +73,7 @@ func (fv *FakeValidator) WaitForKeymanagerInitialization(_ context.Context) erro
 	return nil
 }
 
-// LogSubmittedSyncCommitteeMessages --
+// LogSyncCommitteeMessagesSubmitted --
 func (fv *FakeValidator) LogSubmittedSyncCommitteeMessages() {}
 
 // WaitForChainStart for mocking.
@@ -173,20 +170,12 @@ func (fv *FakeValidator) RolesAt(_ context.Context, slot primitives.Slot) (map[[
 func (fv *FakeValidator) SubmitAttestation(_ context.Context, slot primitives.Slot, _ [fieldparams.BLSPubkeyLength]byte) {
 	fv.AttestToBlockHeadCalled = true
 	fv.AttestToBlockHeadArg1 = uint64(slot)
-	if fv.AttSubmitted != nil {
-		close(fv.AttSubmitted)
-		fv.AttSubmitted = nil
-	}
 }
 
 // ProposeBlock for mocking.
 func (fv *FakeValidator) ProposeBlock(_ context.Context, slot primitives.Slot, _ [fieldparams.BLSPubkeyLength]byte) {
 	fv.ProposeBlockCalled = true
 	fv.ProposeBlockArg1 = uint64(slot)
-	if fv.BlockProposed != nil {
-		close(fv.BlockProposed)
-		fv.BlockProposed = nil
-	}
 }
 
 // SubmitAggregateAndProof for mocking.
@@ -259,9 +248,9 @@ func (fv *FakeValidator) PushProposerSettings(ctx context.Context, km keymanager
 	ctx = nctx
 	defer cancel()
 	time.Sleep(fv.ProposerSettingWait)
-	if errors.Is(ctx.Err(), context.DeadlineExceeded) {
+	if ctx.Err() == context.DeadlineExceeded {
 		log.Error("deadline exceeded")
-		// can't return error as it will trigger a log.fatal
+		// can't return error or it will trigger a log.fatal
 		return nil
 	}
 
@@ -295,19 +284,19 @@ func (fv *FakeValidator) SetProposerSettings(_ context.Context, settings *propos
 }
 
 // GetGraffiti for mocking
-func (fv *FakeValidator) GetGraffiti(_ context.Context, _ [fieldparams.BLSPubkeyLength]byte) ([]byte, error) {
-	return []byte(fv.graffiti), nil
+func (f *FakeValidator) GetGraffiti(_ context.Context, _ [fieldparams.BLSPubkeyLength]byte) ([]byte, error) {
+	return []byte(f.graffiti), nil
 }
 
 // SetGraffiti for mocking
-func (fv *FakeValidator) SetGraffiti(_ context.Context, _ [fieldparams.BLSPubkeyLength]byte, graffiti []byte) error {
-	fv.graffiti = string(graffiti)
+func (f *FakeValidator) SetGraffiti(_ context.Context, _ [fieldparams.BLSPubkeyLength]byte, graffiti []byte) error {
+	f.graffiti = string(graffiti)
 	return nil
 }
 
 // DeleteGraffiti for mocking
-func (fv *FakeValidator) DeleteGraffiti(_ context.Context, _ [fieldparams.BLSPubkeyLength]byte) error {
-	fv.graffiti = ""
+func (f *FakeValidator) DeleteGraffiti(_ context.Context, _ [fieldparams.BLSPubkeyLength]byte) error {
+	f.graffiti = ""
 	return nil
 }
 

validator/client/validator.go

@@ -41,7 +41,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/validator/accounts/wallet"
 	beacon_api "github.com/prysmaticlabs/prysm/v5/validator/client/beacon-api"
 	"github.com/prysmaticlabs/prysm/v5/validator/client/iface"
-	"github.com/prysmaticlabs/prysm/v5/validator/db"
+	vdb "github.com/prysmaticlabs/prysm/v5/validator/db"
 	dbCommon "github.com/prysmaticlabs/prysm/v5/validator/db/common"
 	"github.com/prysmaticlabs/prysm/v5/validator/graffiti"
 	"github.com/prysmaticlabs/prysm/v5/validator/keymanager"
@@ -69,51 +69,51 @@ var (
 )
 
 type validator struct {
-	duties                             *ethpb.DutiesResponse
-	ticker                             slots.Ticker
-	genesisTime                        uint64
-	highestValidSlot                   primitives.Slot
-	slotFeed                           *event.Feed
-	startBalances                      map[[fieldparams.BLSPubkeyLength]byte]uint64
-	prevEpochBalances                  map[[fieldparams.BLSPubkeyLength]byte]uint64
-	blacklistedPubkeys                 map[[fieldparams.BLSPubkeyLength]byte]bool
-	pubkeyToValidatorIndex             map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex
-	wallet                             *wallet.Wallet
-	walletInitializedChan              chan *wallet.Wallet
-	walletInitializedFeed              *event.Feed
-	graffiti                           []byte
-	graffitiStruct                     *graffiti.Graffiti
-	graffitiOrderedIndex               uint64
-	validatorClient                    iface.ValidatorClient
-	chainClient                        iface.ChainClient
-	nodeClient                         iface.NodeClient
-	prysmChainClient                   iface.PrysmChainClient
-	db                                 db.Database
-	km                                 keymanager.IKeymanager
-	web3SignerConfig                   *remoteweb3signer.SetupConfig
-	proposerSettings                   *proposer.Settings
-	signedValidatorRegistrations       map[[fieldparams.BLSPubkeyLength]byte]*ethpb.SignedValidatorRegistrationV1
-	validatorsRegBatchSize             int
-	interopKeysConfig                  *local.InteropKeymanagerConfig
-	attSelections                      map[attSelectionKey]iface.BeaconCommitteeSelection
-	aggregatedSlotCommitteeIDCache     *lru.Cache
-	domainDataCache                    *ristretto.Cache
-	voteStats                          voteStats
-	syncCommitteeStats                 syncCommitteeStats
-	submittedAtts                      map[submittedAttKey]*submittedAtt
-	submittedAggregates                map[submittedAttKey]*submittedAtt
-	logValidatorPerformance            bool
-	emitAccountMetrics                 bool
+	logValidatorBalances               bool
 	useWeb                             bool
+	emitAccountMetrics                 bool
 	distributed                        bool
 	domainDataLock                     sync.RWMutex
 	attLogsLock                        sync.Mutex
 	aggregatedSlotCommitteeIDCacheLock sync.Mutex
 	highestValidSlotLock               sync.Mutex
-	prevEpochBalancesLock              sync.RWMutex
-	blacklistedPubkeysLock             sync.RWMutex
+	prevBalanceLock                    sync.RWMutex
+	slashableKeysLock                  sync.RWMutex
 	attSelectionLock                   sync.Mutex
+	eipImportBlacklistedPublicKeys     map[[fieldparams.BLSPubkeyLength]byte]bool
+	walletInitializedFeed              *event.Feed
+	submittedAtts                      map[submittedAttKey]*submittedAtt
+	submittedAggregates                map[submittedAttKey]*submittedAtt
+	startBalances                      map[[fieldparams.BLSPubkeyLength]byte]uint64
 	dutiesLock                         sync.RWMutex
+	duties                             *ethpb.DutiesResponse
+	prevBalance                        map[[fieldparams.BLSPubkeyLength]byte]uint64
+	pubkeyToValidatorIndex             map[[fieldparams.BLSPubkeyLength]byte]primitives.ValidatorIndex
+	signedValidatorRegistrations       map[[fieldparams.BLSPubkeyLength]byte]*ethpb.SignedValidatorRegistrationV1
+	attSelections                      map[attSelectionKey]iface.BeaconCommitteeSelection
+	graffitiOrderedIndex               uint64
+	aggregatedSlotCommitteeIDCache     *lru.Cache
+	domainDataCache                    *ristretto.Cache
+	highestValidSlot                   primitives.Slot
+	genesisTime                        uint64
+	slotFeed                           *event.Feed
+	interopKeysConfig                  *local.InteropKeymanagerConfig
+	wallet                             *wallet.Wallet
+	graffitiStruct                     *graffiti.Graffiti
+	beaconClient                       iface.BeaconChainClient
+	nodeClient                         iface.NodeClient
+	validatorClient                    iface.ValidatorClient
+	prysmBeaconClient                  iface.PrysmBeaconChainClient
+	db                                 vdb.Database
+	keyManager                         keymanager.IKeymanager
+	ticker                             slots.Ticker
+	graffiti                           []byte
+	voteStats                          voteStats
+	syncCommitteeStats                 syncCommitteeStats
+	Web3SignerConfig                   *remoteweb3signer.SetupConfig
+	proposerSettings                   *proposer.Settings
+	walletInitializedChannel           chan *wallet.Wallet
+	validatorsRegBatchSize             int
 }
 
 type validatorStatus struct {
@@ -132,7 +132,7 @@ func (v *validator) Done() {
 	v.ticker.Done()
 }
 
-// WaitForKmInitialization checks if the validator needs to wait for keymanager initialization.
+// WaitForKeymanagerInitialization checks if the validator needs to wait for
 func (v *validator) WaitForKeymanagerInitialization(ctx context.Context) error {
 	genesisRoot, err := v.db.GenesisValidatorsRoot(ctx)
 	if err != nil {
@@ -142,32 +142,32 @@ func (v *validator) WaitForKeymanagerInitialization(ctx context.Context) error {
 	if v.useWeb && v.wallet == nil {
 		log.Info("Waiting for keymanager to initialize validator client with web UI")
 		// if wallet is not set, wait for it to be set through the UI
-		km, err := waitForWebWalletInitialization(ctx, v.walletInitializedFeed, v.walletInitializedChan)
+		km, err := waitForWebWalletInitialization(ctx, v.walletInitializedFeed, v.walletInitializedChannel)
 		if err != nil {
 			return err
 		}
-		v.km = km
+		v.keyManager = km
 	} else {
 		if v.interopKeysConfig != nil {
 			keyManager, err := local.NewInteropKeymanager(ctx, v.interopKeysConfig.Offset, v.interopKeysConfig.NumValidatorKeys)
 			if err != nil {
 				return errors.Wrap(err, "could not generate interop keys for key manager")
 			}
-			v.km = keyManager
+			v.keyManager = keyManager
 		} else if v.wallet == nil {
 			return errors.New("wallet not set")
 		} else {
-			if v.web3SignerConfig != nil {
-				v.web3SignerConfig.GenesisValidatorsRoot = genesisRoot
+			if v.Web3SignerConfig != nil {
+				v.Web3SignerConfig.GenesisValidatorsRoot = genesisRoot
 			}
-			keyManager, err := v.wallet.InitializeKeymanager(ctx, accountsiface.InitKeymanagerConfig{ListenForChanges: true, Web3SignerConfig: v.web3SignerConfig})
+			keyManager, err := v.wallet.InitializeKeymanager(ctx, accountsiface.InitKeymanagerConfig{ListenForChanges: true, Web3SignerConfig: v.Web3SignerConfig})
 			if err != nil {
 				return errors.Wrap(err, "could not initialize key manager")
 			}
-			v.km = keyManager
+			v.keyManager = keyManager
 		}
 	}
-	recheckKeys(ctx, v.db, v.km)
+	recheckKeys(ctx, v.db, v.keyManager)
 	return nil
 }
 
@@ -197,22 +197,23 @@ func waitForWebWalletInitialization(
 }
 
 // recheckKeys checks if the validator has any keys that need to be rechecked.
-// The keymanager implements a subscription to push these updates to the validator.
-func recheckKeys(ctx context.Context, valDB db.Database, km keymanager.IKeymanager) {
+// the keymanager implements a subscription to push these updates to the validator.
+func recheckKeys(ctx context.Context, valDB vdb.Database, keyManager keymanager.IKeymanager) {
 	var validatingKeys [][fieldparams.BLSPubkeyLength]byte
 	var err error
-	validatingKeys, err = km.FetchValidatingPublicKeys(ctx)
+	validatingKeys, err = keyManager.FetchValidatingPublicKeys(ctx)
 	if err != nil {
 		log.WithError(err).Debug("Could not fetch validating keys")
 	}
 	if err := valDB.UpdatePublicKeysBuckets(validatingKeys); err != nil {
-		go recheckValidatingKeysBucket(ctx, valDB, km)
+		log.WithError(err).Debug("Could not update public keys buckets")
 	}
+	go recheckValidatingKeysBucket(ctx, valDB, keyManager)
 }
 
 // to accounts changes in the keymanager, then updates those keys'
 // buckets in bolt DB if a bucket for a key does not exist.
-func recheckValidatingKeysBucket(ctx context.Context, valDB db.Database, km keymanager.IKeymanager) {
+func recheckValidatingKeysBucket(ctx context.Context, valDB vdb.Database, km keymanager.IKeymanager) {
 	importedKeymanager, ok := km.(*local.Keymanager)
 	if !ok {
 		return
@@ -402,7 +403,7 @@ func (v *validator) checkAndLogValidatorStatus(statuses []*validatorStatus, acti
 func (v *validator) CanonicalHeadSlot(ctx context.Context) (primitives.Slot, error) {
 	ctx, span := trace.StartSpan(ctx, "validator.CanonicalHeadSlot")
 	defer span.End()
-	head, err := v.chainClient.GetChainHead(ctx, &emptypb.Empty{})
+	head, err := v.beaconClient.GetChainHead(ctx, &emptypb.Empty{})
 	if err != nil {
 		return 0, errors.Wrap(client.ErrConnectionIssue, err.Error())
 	}
@@ -426,7 +427,7 @@ func (v *validator) CheckDoppelGanger(ctx context.Context) error {
 	if !features.Get().EnableDoppelGanger {
 		return nil
 	}
-	pubkeys, err := v.km.FetchValidatingPublicKeys(ctx)
+	pubkeys, err := v.keyManager.FetchValidatingPublicKeys(ctx)
 	if err != nil {
 		return err
 	}
@@ -532,16 +533,16 @@ func (v *validator) UpdateDuties(ctx context.Context, slot primitives.Slot) erro
 	ctx, span := trace.StartSpan(ctx, "validator.UpdateAssignments")
 	defer span.End()
 
-	validatingKeys, err := v.km.FetchValidatingPublicKeys(ctx)
+	validatingKeys, err := v.keyManager.FetchValidatingPublicKeys(ctx)
 	if err != nil {
 		return err
 	}
 
 	// Filter out the slashable public keys from the duties request.
 	filteredKeys := make([][fieldparams.BLSPubkeyLength]byte, 0, len(validatingKeys))
-	v.blacklistedPubkeysLock.RLock()
+	v.slashableKeysLock.RLock()
 	for _, pubKey := range validatingKeys {
-		if ok := v.blacklistedPubkeys[pubKey]; !ok {
+		if ok := v.eipImportBlacklistedPublicKeys[pubKey]; !ok {
 			filteredKeys = append(filteredKeys, pubKey)
 		} else {
 			log.WithField(
@@ -550,7 +551,7 @@ func (v *validator) UpdateDuties(ctx context.Context, slot primitives.Slot) erro
 				"in request to update validator duties")
 		}
 	}
-	v.blacklistedPubkeysLock.RUnlock()
+	v.slashableKeysLock.RUnlock()
 
 	req := &ethpb.DutiesRequest{
 		Epoch:      primitives.Epoch(slot / params.BeaconConfig().SlotsPerEpoch),
@@ -600,28 +601,28 @@ func (v *validator) UpdateDuties(ctx context.Context, slot primitives.Slot) erro
 
 // subscribeToSubnets iterates through each validator duty, signs each slot, and asks beacon node
 // to eagerly subscribe to subnets so that the aggregator has attestations to aggregate.
-func (v *validator) subscribeToSubnets(ctx context.Context, duties *ethpb.DutiesResponse) error {
-	subscribeSlots := make([]primitives.Slot, 0, len(duties.CurrentEpochDuties)+len(duties.NextEpochDuties))
-	subscribeCommitteeIndices := make([]primitives.CommitteeIndex, 0, len(duties.CurrentEpochDuties)+len(duties.NextEpochDuties))
-	subscribeIsAggregator := make([]bool, 0, len(duties.CurrentEpochDuties)+len(duties.NextEpochDuties))
-	activeDuties := make([]*ethpb.DutiesResponse_Duty, 0, len(duties.CurrentEpochDuties)+len(duties.NextEpochDuties))
+func (v *validator) subscribeToSubnets(ctx context.Context, res *ethpb.DutiesResponse) error {
+	subscribeSlots := make([]primitives.Slot, 0, len(res.CurrentEpochDuties)+len(res.NextEpochDuties))
+	subscribeCommitteeIndices := make([]primitives.CommitteeIndex, 0, len(res.CurrentEpochDuties)+len(res.NextEpochDuties))
+	subscribeIsAggregator := make([]bool, 0, len(res.CurrentEpochDuties)+len(res.NextEpochDuties))
+	activeDuties := make([]*ethpb.DutiesResponse_Duty, 0, len(res.CurrentEpochDuties)+len(res.NextEpochDuties))
 	alreadySubscribed := make(map[[64]byte]bool)
 
 	if v.distributed {
 		// Get aggregated selection proofs to calculate isAggregator.
-		if err := v.getAggregatedSelectionProofs(ctx, duties); err != nil {
+		if err := v.getAggregatedSelectionProofs(ctx, res); err != nil {
 			return errors.Wrap(err, "could not get aggregated selection proofs")
 		}
 	}
 
-	for _, duty := range duties.CurrentEpochDuties {
+	for _, duty := range res.CurrentEpochDuties {
 		pk := bytesutil.ToBytes48(duty.PublicKey)
 		if duty.Status == ethpb.ValidatorStatus_ACTIVE || duty.Status == ethpb.ValidatorStatus_EXITING {
 			attesterSlot := duty.AttesterSlot
 			committeeIndex := duty.CommitteeIndex
 			validatorIndex := duty.ValidatorIndex
 
-			alreadySubscribedKey := validatorSubnetSubscriptionKey(attesterSlot, committeeIndex)
+			alreadySubscribedKey := validatorSubscribeKey(attesterSlot, committeeIndex)
 			if _, ok := alreadySubscribed[alreadySubscribedKey]; ok {
 				continue
 			}
@@ -641,13 +642,13 @@ func (v *validator) subscribeToSubnets(ctx context.Context, duties *ethpb.Duties
 		}
 	}
 
-	for _, duty := range duties.NextEpochDuties {
+	for _, duty := range res.NextEpochDuties {
 		if duty.Status == ethpb.ValidatorStatus_ACTIVE || duty.Status == ethpb.ValidatorStatus_EXITING {
 			attesterSlot := duty.AttesterSlot
 			committeeIndex := duty.CommitteeIndex
 			validatorIndex := duty.ValidatorIndex
 
-			alreadySubscribedKey := validatorSubnetSubscriptionKey(attesterSlot, committeeIndex)
+			alreadySubscribedKey := validatorSubscribeKey(attesterSlot, committeeIndex)
 			if _, ok := alreadySubscribed[alreadySubscribedKey]; ok {
 				continue
 			}
@@ -705,8 +706,7 @@ func (v *validator) RolesAt(ctx context.Context, slot primitives.Slot) (map[[fie
 
 			aggregator, err := v.isAggregator(ctx, duty.Committee, slot, bytesutil.ToBytes48(duty.PublicKey), duty.ValidatorIndex)
 			if err != nil {
-				aggregator = false
-				log.WithError(err).Errorf("Could not check if validator %#x is an aggregator", bytesutil.Trunc(duty.PublicKey))
+				return nil, errors.Wrap(err, "could not check if a validator is an aggregator")
 			}
 			if aggregator {
 				roles = append(roles, iface.RoleAggregator)
@@ -731,8 +731,7 @@ func (v *validator) RolesAt(ctx context.Context, slot primitives.Slot) (map[[fie
 		if inSyncCommittee {
 			aggregator, err := v.isSyncCommitteeAggregator(ctx, slot, bytesutil.ToBytes48(duty.PublicKey), duty.ValidatorIndex)
 			if err != nil {
-				aggregator = false
-				log.WithError(err).Errorf("Could not check if validator %#x is an aggregator", bytesutil.Trunc(duty.PublicKey))
+				return nil, errors.Wrap(err, "could not check if a validator is a sync committee aggregator")
 			}
 			if aggregator {
 				roles = append(roles, iface.RoleSyncCommitteeAggregator)
@@ -752,24 +751,18 @@ func (v *validator) RolesAt(ctx context.Context, slot primitives.Slot) (map[[fie
 
 // Keymanager returns the underlying validator's keymanager.
 func (v *validator) Keymanager() (keymanager.IKeymanager, error) {
-	if v.km == nil {
+	if v.keyManager == nil {
 		return nil, errors.New("keymanager is not initialized")
 	}
-	return v.km, nil
+	return v.keyManager, nil
 }
 
 // isAggregator checks if a validator is an aggregator of a given slot and committee,
 // it uses a modulo calculated by validator count in committee and samples randomness around it.
-func (v *validator) isAggregator(
-	ctx context.Context,
-	committeeIndex []primitives.ValidatorIndex,
-	slot primitives.Slot,
-	pubKey [fieldparams.BLSPubkeyLength]byte,
-	validatorIndex primitives.ValidatorIndex,
-) (bool, error) {
+func (v *validator) isAggregator(ctx context.Context, committee []primitives.ValidatorIndex, slot primitives.Slot, pubKey [fieldparams.BLSPubkeyLength]byte, validatorIndex primitives.ValidatorIndex) (bool, error) {
 	modulo := uint64(1)
-	if len(committeeIndex)/int(params.BeaconConfig().TargetAggregatorsPerCommittee) > 1 {
-		modulo = uint64(len(committeeIndex)) / params.BeaconConfig().TargetAggregatorsPerCommittee
+	if len(committee)/int(params.BeaconConfig().TargetAggregatorsPerCommittee) > 1 {
+		modulo = uint64(len(committee)) / params.BeaconConfig().TargetAggregatorsPerCommittee
 	}
 
 	var (
@@ -1048,7 +1041,7 @@ func (v *validator) PushProposerSettings(ctx context.Context, km keymanager.IKey
 	if err != nil {
 		return err
 	}
-	proposerReqs, err := v.buildPrepProposerReqs(filteredKeys)
+	proposerReqs, err := v.buildPrepProposerReqs(ctx, filteredKeys)
 	if err != nil {
 		return err
 	}
@@ -1159,9 +1152,9 @@ func (v *validator) filterAndCacheActiveKeys(ctx context.Context, pubkeys [][fie
 	return filteredKeys, nil
 }
 
-func (v *validator) buildPrepProposerReqs(activePubkeys [][fieldparams.BLSPubkeyLength]byte) ([]*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer, error) {
+func (v *validator) buildPrepProposerReqs(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte /* only active pubkeys */) ([]*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer, error) {
 	var prepareProposerReqs []*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer
-	for _, k := range activePubkeys {
+	for _, k := range pubkeys {
 		// Default case: Define fee recipient to burn address
 		var feeRecipient common.Address
 
@@ -1192,11 +1185,7 @@ func (v *validator) buildPrepProposerReqs(activePubkeys [][fieldparams.BLSPubkey
 	return prepareProposerReqs, nil
 }
 
-func (v *validator) buildSignedRegReqs(
-	ctx context.Context,
-	activePubkeys [][fieldparams.BLSPubkeyLength]byte,
-	signer iface.SigningFunc,
-) []*ethpb.SignedValidatorRegistrationV1 {
+func (v *validator) buildSignedRegReqs(ctx context.Context, pubkeys [][fieldparams.BLSPubkeyLength]byte /* only active pubkeys */, signer iface.SigningFunc) []*ethpb.SignedValidatorRegistrationV1 {
 	var signedValRegRegs []*ethpb.SignedValidatorRegistrationV1
 	if v.ProposerSettings() == nil {
 		return signedValRegRegs
@@ -1205,7 +1194,7 @@ func (v *validator) buildSignedRegReqs(
 	if v.genesisTime > uint64(time.Now().UTC().Unix()) {
 		return signedValRegRegs
 	}
-	for i, k := range activePubkeys {
+	for i, k := range pubkeys {
 		feeRecipient := common.HexToAddress(params.BeaconConfig().EthBurnAddressHex)
 		gasLimit := params.BeaconConfig().DefaultBuilderGasLimit
 		enabled := false
@@ -1255,7 +1244,7 @@ func (v *validator) buildSignedRegReqs(
 			FeeRecipient: feeRecipient[:],
 			GasLimit:     gasLimit,
 			Timestamp:    uint64(time.Now().UTC().Unix()),
-			Pubkey:       activePubkeys[i][:],
+			Pubkey:       pubkeys[i][:],
 		}
 
 		signedReq, err := v.SignValidatorRegistrationRequest(ctx, signer, req)
@@ -1383,8 +1372,8 @@ func (v *validator) getAttSelection(key attSelectionKey) ([]byte, error) {
 
 // This constructs a validator subscribed key, it's used to track
 // which subnet has already been pending requested.
-func validatorSubnetSubscriptionKey(slot primitives.Slot, committeeIndex primitives.CommitteeIndex) [64]byte {
-	return bytesutil.ToBytes64(append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeIndex))...))
+func validatorSubscribeKey(slot primitives.Slot, committeeID primitives.CommitteeIndex) [64]byte {
+	return bytesutil.ToBytes64(append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeID))...))
 }
 
 // This tracks all validators' voting status.

validator/client/validator_test.go

@@ -305,10 +305,10 @@ func TestWaitForChainStart_ReceiveErrorFromStream(t *testing.T) {
 func TestCanonicalHeadSlot_FailedRPC(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
-	client := validatormock.NewMockChainClient(ctrl)
+	client := validatormock.NewMockBeaconChainClient(ctrl)
 	v := validator{
-		chainClient: client,
-		genesisTime: 1,
+		beaconClient: client,
+		genesisTime:  1,
 	}
 	client.EXPECT().GetChainHead(
 		gomock.Any(),
@@ -321,9 +321,9 @@ func TestCanonicalHeadSlot_FailedRPC(t *testing.T) {
 func TestCanonicalHeadSlot_OK(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
-	client := validatormock.NewMockChainClient(ctrl)
+	client := validatormock.NewMockBeaconChainClient(ctrl)
 	v := validator{
-		chainClient: client,
+		beaconClient: client,
 	}
 	client.EXPECT().GetChainHead(
 		gomock.Any(),
@@ -339,22 +339,22 @@ func TestWaitMultipleActivation_LogsActivationEpochOK(t *testing.T) {
 	hook := logTest.NewGlobal()
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
-	client := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	validatorClient := validatormock.NewMockValidatorClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 
 	kp := randKeypair(t)
 	v := validator{
-		validatorClient:  client,
-		km:               newMockKeymanager(t, kp),
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        newMockKeymanager(t, kp),
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 
 	resp := generateMockStatusResponse([][]byte{kp.pub[:]})
 	resp.Statuses[0].Status.Status = ethpb.ValidatorStatus_ACTIVE
 	clientStream := mock2.NewMockBeaconNodeValidator_WaitForActivationClient(ctrl)
-	client.EXPECT().WaitForActivation(
+	validatorClient.EXPECT().WaitForActivation(
 		gomock.Any(),
 		&ethpb.ValidatorActivationRequest{
 			PublicKeys: [][]byte{kp.pub[:]},
@@ -364,7 +364,7 @@ func TestWaitMultipleActivation_LogsActivationEpochOK(t *testing.T) {
 		resp,
 		nil,
 	)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},
@@ -465,7 +465,7 @@ func TestUpdateDuties_ReturnsError(t *testing.T) {
 
 	v := validator{
 		validatorClient: client,
-		km:              newMockKeymanager(t, randKeypair(t)),
+		keyManager:      newMockKeymanager(t, randKeypair(t)),
 		duties: &ethpb.DutiesResponse{
 			CurrentEpochDuties: []*ethpb.DutiesResponse_Duty{
 				{
@@ -505,7 +505,7 @@ func TestUpdateDuties_OK(t *testing.T) {
 		},
 	}
 	v := validator{
-		km:              newMockKeymanager(t, randKeypair(t)),
+		keyManager:      newMockKeymanager(t, randKeypair(t)),
 		validatorClient: client,
 	}
 	client.EXPECT().GetDuties(
@@ -549,9 +549,9 @@ func TestUpdateDuties_OK_FilterBlacklistedPublicKeys(t *testing.T) {
 		blacklistedPublicKeys[k] = true
 	}
 	v := validator{
-		km:                 km,
-		validatorClient:    client,
-		blacklistedPubkeys: blacklistedPublicKeys,
+		keyManager:                     km,
+		validatorClient:                client,
+		eipImportBlacklistedPublicKeys: blacklistedPublicKeys,
 	}
 
 	resp := &ethpb.DutiesResponse{
@@ -611,7 +611,7 @@ func TestUpdateDuties_AllValidatorsExited(t *testing.T) {
 		},
 	}
 	v := validator{
-		km:              newMockKeymanager(t, randKeypair(t)),
+		keyManager:      newMockKeymanager(t, randKeypair(t)),
 		validatorClient: client,
 	}
 	client.EXPECT().GetDuties(
@@ -654,7 +654,7 @@ func TestUpdateDuties_Distributed(t *testing.T) {
 	}
 
 	v := validator{
-		km:              newMockKeymanager(t, keys),
+		keyManager:      newMockKeymanager(t, keys),
 		validatorClient: client,
 		distributed:     true,
 	}
@@ -997,7 +997,7 @@ func TestValidator_CheckDoppelGanger(t *testing.T) {
 					}
 					v := &validator{
 						validatorClient: client,
-						km:              km,
+						keyManager:      km,
 						db:              db,
 					}
 					client.EXPECT().CheckDoppelGanger(
@@ -1038,7 +1038,7 @@ func TestValidator_CheckDoppelGanger(t *testing.T) {
 					}
 					v := &validator{
 						validatorClient: client,
-						km:              km,
+						keyManager:      km,
 						db:              db,
 					}
 					client.EXPECT().CheckDoppelGanger(
@@ -1077,7 +1077,7 @@ func TestValidator_CheckDoppelGanger(t *testing.T) {
 					}
 					v := &validator{
 						validatorClient: client,
-						km:              km,
+						keyManager:      km,
 						db:              db,
 					}
 					client.EXPECT().CheckDoppelGanger(
@@ -1122,7 +1122,7 @@ func TestValidator_CheckDoppelGanger(t *testing.T) {
 					}
 					v := &validator{
 						validatorClient: client,
-						km:              km,
+						keyManager:      km,
 						db:              db,
 					}
 					client.EXPECT().CheckDoppelGanger(
@@ -1150,7 +1150,7 @@ func TestValidator_CheckDoppelGanger(t *testing.T) {
 					}
 					v := &validator{
 						validatorClient: client,
-						km:              km,
+						keyManager:      km,
 						db:              db,
 					}
 					client.EXPECT().CheckDoppelGanger(
@@ -1366,7 +1366,7 @@ func TestValidator_WaitForKeymanagerInitialization_web3Signer(t *testing.T) {
 				db:     db,
 				useWeb: false,
 				wallet: w,
-				web3SignerConfig: &remoteweb3signer.SetupConfig{
+				Web3SignerConfig: &remoteweb3signer.SetupConfig{
 					BaseEndpoint:       "http://localhost:8545",
 					ProvidedPublicKeys: keys,
 				},
@@ -1391,10 +1391,10 @@ func TestValidator_WaitForKeymanagerInitialization_Web(t *testing.T) {
 			require.NoError(t, err)
 			walletChan := make(chan *wallet.Wallet, 1)
 			v := validator{
-				db:                    db,
-				useWeb:                true,
-				walletInitializedFeed: &event.Feed{},
-				walletInitializedChan: walletChan,
+				db:                       db,
+				useWeb:                   true,
+				walletInitializedFeed:    &event.Feed{},
+				walletInitializedChannel: walletChan,
 			}
 			wait := make(chan struct{})
 			go func() {
@@ -1992,7 +1992,7 @@ func TestValidator_PushSettings(t *testing.T) {
 				pubkeys, err := km.FetchValidatingPublicKeys(ctx)
 				require.NoError(t, err)
 				if tt.feeRecipientMap != nil {
-					feeRecipients, err := v.buildPrepProposerReqs(pubkeys)
+					feeRecipients, err := v.buildPrepProposerReqs(ctx, pubkeys)
 					require.NoError(t, err)
 					signedRegisterValidatorRequests := v.buildSignedRegReqs(ctx, pubkeys, km.Sign)
 					for _, recipient := range feeRecipients {
@@ -2148,7 +2148,7 @@ func TestValidator_buildPrepProposerReqs_WithoutDefaultConfig(t *testing.T) {
 	}
 	filteredKeys, err := v.filterAndCacheActiveKeys(ctx, pubkeys, 0)
 	require.NoError(t, err)
-	actual, err := v.buildPrepProposerReqs(filteredKeys)
+	actual, err := v.buildPrepProposerReqs(ctx, filteredKeys)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expected, actual)
 }
@@ -2316,7 +2316,7 @@ func TestValidator_buildPrepProposerReqs_WithDefaultConfig(t *testing.T) {
 	}
 	filteredKeys, err := v.filterAndCacheActiveKeys(ctx, pubkeys, 641)
 	require.NoError(t, err)
-	actual, err := v.buildPrepProposerReqs(filteredKeys)
+	actual, err := v.buildPrepProposerReqs(ctx, filteredKeys)
 	require.NoError(t, err)
 	assert.DeepEqual(t, expected, actual)
 }

validator/client/wait_for_activation.go

@@ -50,7 +50,7 @@ func (v *validator) WaitForActivation(ctx context.Context, accountsChangedChan c
 func (v *validator) internalWaitForActivation(ctx context.Context, accountsChangedChan <-chan [][fieldparams.BLSPubkeyLength]byte) error {
 	ctx, span := trace.StartSpan(ctx, "validator.WaitForActivation")
 	defer span.End()
-	validatingKeys, err := v.km.FetchValidatingPublicKeys(ctx)
+	validatingKeys, err := v.keyManager.FetchValidatingPublicKeys(ctx)
 	if err != nil {
 		return errors.Wrap(err, msgCouldNotFetchKeys)
 	}
@@ -120,7 +120,7 @@ func (v *validator) internalWaitForActivation(ctx context.Context, accountsChang
 
 			// "-1" indicates that validator count endpoint is not supported by the beacon node.
 			var valCount int64 = -1
-			valCounts, err := v.prysmChainClient.GetValidatorCount(ctx, "head", []validator2.Status{validator2.Active})
+			valCounts, err := v.prysmBeaconClient.GetValidatorCount(ctx, "head", []validator2.Status{validator2.Active})
 			if err != nil && !errors.Is(err, iface.ErrNotSupported) {
 				return errors.Wrap(err, "could not get active validator count")
 			}

validator/client/wait_for_activation_test.go

@@ -32,12 +32,12 @@ func TestWaitActivation_ContextCanceled(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
 	kp := randKeypair(t)
 	v := validator{
 		validatorClient: validatorClient,
-		km:              newMockKeymanager(t, kp),
-		chainClient:     chainClient,
+		keyManager:      newMockKeymanager(t, kp),
+		beaconClient:    beaconClient,
 	}
 	clientStream := mock.NewMockBeaconNodeValidator_WaitForActivationClient(ctrl)
 	ctx, cancel := context.WithCancel(context.Background())
@@ -58,14 +58,14 @@ func TestWaitActivation_StreamSetupFails_AttemptsToReconnect(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 	kp := randKeypair(t)
 	v := validator{
-		validatorClient:  validatorClient,
-		km:               newMockKeymanager(t, kp),
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        newMockKeymanager(t, kp),
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 	clientStream := mock.NewMockBeaconNodeValidator_WaitForActivationClient(ctrl)
 	validatorClient.EXPECT().WaitForActivation(
@@ -74,7 +74,7 @@ func TestWaitActivation_StreamSetupFails_AttemptsToReconnect(t *testing.T) {
 			PublicKeys: [][]byte{kp.pub[:]},
 		},
 	).Return(clientStream, errors.New("failed stream")).Return(clientStream, nil)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},
@@ -89,14 +89,14 @@ func TestWaitForActivation_ReceiveErrorFromStream_AttemptsReconnection(t *testin
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 	kp := randKeypair(t)
 	v := validator{
-		validatorClient:  validatorClient,
-		km:               newMockKeymanager(t, kp),
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        newMockKeymanager(t, kp),
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 	clientStream := mock.NewMockBeaconNodeValidator_WaitForActivationClient(ctrl)
 	validatorClient.EXPECT().WaitForActivation(
@@ -105,7 +105,7 @@ func TestWaitForActivation_ReceiveErrorFromStream_AttemptsReconnection(t *testin
 			PublicKeys: [][]byte{kp.pub[:]},
 		},
 	).Return(clientStream, nil)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},
@@ -125,15 +125,15 @@ func TestWaitActivation_LogsActivationEpochOK(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 	kp := randKeypair(t)
 	v := validator{
-		validatorClient:  validatorClient,
-		km:               newMockKeymanager(t, kp),
-		genesisTime:      1,
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        newMockKeymanager(t, kp),
+		genesisTime:       1,
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 	resp := generateMockStatusResponse([][]byte{kp.pub[:]})
 	resp.Statuses[0].Status.Status = ethpb.ValidatorStatus_ACTIVE
@@ -144,7 +144,7 @@ func TestWaitActivation_LogsActivationEpochOK(t *testing.T) {
 			PublicKeys: [][]byte{kp.pub[:]},
 		},
 	).Return(clientStream, nil)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},
@@ -161,14 +161,14 @@ func TestWaitForActivation_Exiting(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 	kp := randKeypair(t)
 	v := validator{
-		validatorClient:  validatorClient,
-		km:               newMockKeymanager(t, kp),
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        newMockKeymanager(t, kp),
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 	resp := generateMockStatusResponse([][]byte{kp.pub[:]})
 	resp.Statuses[0].Status.Status = ethpb.ValidatorStatus_EXITING
@@ -179,7 +179,7 @@ func TestWaitForActivation_Exiting(t *testing.T) {
 			PublicKeys: [][]byte{kp.pub[:]},
 		},
 	).Return(clientStream, nil)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},
@@ -201,17 +201,17 @@ func TestWaitForActivation_RefetchKeys(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 
 	kp := randKeypair(t)
 	km := newMockKeymanager(t)
 
 	v := validator{
-		validatorClient:  validatorClient,
-		km:               km,
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        km,
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 	resp := generateMockStatusResponse([][]byte{kp.pub[:]})
 	resp.Statuses[0].Status.Status = ethpb.ValidatorStatus_ACTIVE
@@ -222,7 +222,7 @@ func TestWaitForActivation_RefetchKeys(t *testing.T) {
 			PublicKeys: [][]byte{kp.pub[:]},
 		},
 	).Return(clientStream, nil)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},
@@ -258,13 +258,13 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) {
 		active := randKeypair(t)
 		km := newMockKeymanager(t, inactive)
 		validatorClient := validatormock.NewMockValidatorClient(ctrl)
-		chainClient := validatormock.NewMockChainClient(ctrl)
-		prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+		beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+		prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 		v := validator{
-			validatorClient:  validatorClient,
-			km:               km,
-			chainClient:      chainClient,
-			prysmChainClient: prysmChainClient,
+			validatorClient:   validatorClient,
+			keyManager:        km,
+			beaconClient:      beaconClient,
+			prysmBeaconClient: prysmBeaconClient,
 		}
 		inactiveResp := generateMockStatusResponse([][]byte{inactive.pub[:]})
 		inactiveResp.Statuses[0].Status.Status = ethpb.ValidatorStatus_UNKNOWN_STATUS
@@ -279,7 +279,7 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) {
 			time.Sleep(time.Second * 2)
 			return inactiveClientStream, nil
 		})
-		prysmChainClient.EXPECT().GetValidatorCount(
+		prysmBeaconClient.EXPECT().GetValidatorCount(
 			gomock.Any(),
 			"head",
 			[]validatorType.Status{validatorType.Active},
@@ -348,14 +348,14 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) {
 		err = km.RecoverAccountsFromMnemonic(ctx, constant.TestMnemonic, derived.DefaultMnemonicLanguage, "", 1)
 		require.NoError(t, err)
 		validatorClient := validatormock.NewMockValidatorClient(ctrl)
-		chainClient := validatormock.NewMockChainClient(ctrl)
-		prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+		beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+		prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 		v := validator{
-			validatorClient:  validatorClient,
-			km:               km,
-			genesisTime:      1,
-			chainClient:      chainClient,
-			prysmChainClient: prysmChainClient,
+			validatorClient:   validatorClient,
+			keyManager:        km,
+			genesisTime:       1,
+			beaconClient:      beaconClient,
+			prysmBeaconClient: prysmBeaconClient,
 		}
 
 		inactiveResp := generateMockStatusResponse([][]byte{inactivePubKey[:]})
@@ -371,7 +371,7 @@ func TestWaitForActivation_AccountsChanged(t *testing.T) {
 			time.Sleep(time.Second * 2)
 			return inactiveClientStream, nil
 		})
-		prysmChainClient.EXPECT().GetValidatorCount(
+		prysmBeaconClient.EXPECT().GetValidatorCount(
 			gomock.Any(),
 			"head",
 			[]validatorType.Status{validatorType.Active},
@@ -415,15 +415,15 @@ func TestWaitActivation_NotAllValidatorsActivatedOK(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 	validatorClient := validatormock.NewMockValidatorClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
-	prysmChainClient := validatormock.NewMockPrysmChainClient(ctrl)
+	beaconClient := validatormock.NewMockBeaconChainClient(ctrl)
+	prysmBeaconClient := validatormock.NewMockPrysmBeaconChainClient(ctrl)
 
 	kp := randKeypair(t)
 	v := validator{
-		validatorClient:  validatorClient,
-		km:               newMockKeymanager(t, kp),
-		chainClient:      chainClient,
-		prysmChainClient: prysmChainClient,
+		validatorClient:   validatorClient,
+		keyManager:        newMockKeymanager(t, kp),
+		beaconClient:      beaconClient,
+		prysmBeaconClient: prysmBeaconClient,
 	}
 	resp := generateMockStatusResponse([][]byte{kp.pub[:]})
 	resp.Statuses[0].Status.Status = ethpb.ValidatorStatus_ACTIVE
@@ -432,7 +432,7 @@ func TestWaitActivation_NotAllValidatorsActivatedOK(t *testing.T) {
 		gomock.Any(),
 		gomock.Any(),
 	).Return(clientStream, nil)
-	prysmChainClient.EXPECT().GetValidatorCount(
+	prysmBeaconClient.EXPECT().GetValidatorCount(
 		gomock.Any(),
 		"head",
 		[]validatorType.Status{validatorType.Active},

validator/node/node.go

@@ -63,15 +63,15 @@ import (
 // ValidatorClient defines an instance of an Ethereum validator that manages
 // the entire lifecycle of services attached to it participating in proof of stake.
 type ValidatorClient struct {
-	cliCtx                *cli.Context
-	ctx                   context.Context
-	cancel                context.CancelFunc
-	db                    iface.ValidatorDB
-	services              *runtime.ServiceRegistry // Lifecycle and service store.
-	lock                  sync.RWMutex
-	wallet                *wallet.Wallet
-	walletInitializedFeed *event.Feed
-	stop                  chan struct{} // Channel to wait for termination notifications.
+	cliCtx            *cli.Context
+	ctx               context.Context
+	cancel            context.CancelFunc
+	db                iface.ValidatorDB
+	services          *runtime.ServiceRegistry // Lifecycle and service store.
+	lock              sync.RWMutex
+	wallet            *wallet.Wallet
+	walletInitialized *event.Feed
+	stop              chan struct{} // Channel to wait for termination notifications.
 }
 
 // NewValidatorClient creates a new instance of the Prysm validator client.
@@ -100,12 +100,12 @@ func NewValidatorClient(cliCtx *cli.Context) (*ValidatorClient, error) {
 	registry := runtime.NewServiceRegistry()
 	ctx, cancel := context.WithCancel(cliCtx.Context)
 	validatorClient := &ValidatorClient{
-		cliCtx:                cliCtx,
-		ctx:                   ctx,
-		cancel:                cancel,
-		services:              registry,
-		walletInitializedFeed: new(event.Feed),
-		stop:                  make(chan struct{}),
+		cliCtx:            cliCtx,
+		ctx:               ctx,
+		cancel:            cancel,
+		services:          registry,
+		walletInitialized: new(event.Feed),
+		stop:              make(chan struct{}),
 	}
 
 	if err := features.ConfigureValidator(cliCtx); err != nil {
@@ -485,13 +485,23 @@ func (c *ValidatorClient) registerPrometheusService(cliCtx *cli.Context) error {
 
 func (c *ValidatorClient) registerValidatorService(cliCtx *cli.Context) error {
 	var (
-		interopKmConfig *local.InteropKeymanagerConfig
-		err             error
+		endpoint             string        = c.cliCtx.String(flags.BeaconRPCProviderFlag.Name)
+		dataDir              string        = c.cliCtx.String(cmd.DataDirFlag.Name)
+		logValidatorBalances bool          = !c.cliCtx.Bool(flags.DisablePenaltyRewardLogFlag.Name)
+		emitAccountMetrics   bool          = !c.cliCtx.Bool(flags.DisableAccountMetricsFlag.Name)
+		cert                 string        = c.cliCtx.String(flags.CertFlag.Name)
+		graffiti             string        = c.cliCtx.String(flags.GraffitiFlag.Name)
+		maxCallRecvMsgSize   int           = c.cliCtx.Int(cmd.GrpcMaxCallRecvMsgSizeFlag.Name)
+		grpcRetries          uint          = c.cliCtx.Uint(flags.GrpcRetriesFlag.Name)
+		grpcRetryDelay       time.Duration = c.cliCtx.Duration(flags.GrpcRetryDelayFlag.Name)
+
+		interopKeysConfig *local.InteropKeymanagerConfig
+		err               error
 	)
 
 	// Configure interop.
 	if c.cliCtx.IsSet(flags.InteropNumValidators.Name) {
-		interopKmConfig = &local.InteropKeymanagerConfig{
+		interopKeysConfig = &local.InteropKeymanagerConfig{
 			Offset:           cliCtx.Uint64(flags.InteropStartIndex.Name),
 			NumValidatorKeys: cliCtx.Uint64(flags.InteropNumValidators.Name),
 		}
@@ -519,27 +529,28 @@ func (c *ValidatorClient) registerValidatorService(cliCtx *cli.Context) error {
 	}
 
 	validatorService, err := client.NewValidatorService(c.cliCtx.Context, &client.Config{
-		DB:                      c.db,
-		Wallet:                  c.wallet,
-		WalletInitializedFeed:   c.walletInitializedFeed,
-		GRPCMaxCallRecvMsgSize:  c.cliCtx.Int(cmd.GrpcMaxCallRecvMsgSizeFlag.Name),
-		GRPCRetries:             c.cliCtx.Uint(flags.GrpcRetriesFlag.Name),
-		GRPCRetryDelay:          c.cliCtx.Duration(flags.GrpcRetryDelayFlag.Name),
-		GRPCHeaders:             strings.Split(c.cliCtx.String(flags.GrpcHeadersFlag.Name), ","),
-		BeaconNodeGRPCEndpoint:  c.cliCtx.String(flags.BeaconRPCProviderFlag.Name),
-		BeaconNodeCert:          c.cliCtx.String(flags.CertFlag.Name),
-		BeaconApiEndpoint:       c.cliCtx.String(flags.BeaconRESTApiProviderFlag.Name),
-		BeaconApiTimeout:        time.Second * 30,
-		Graffiti:                g.ParseHexGraffiti(c.cliCtx.String(flags.GraffitiFlag.Name)),
-		GraffitiStruct:          graffitiStruct,
-		InteropKmConfig:         interopKmConfig,
-		Web3SignerConfig:        web3signerConfig,
-		ProposerSettings:        ps,
-		ValidatorsRegBatchSize:  c.cliCtx.Int(flags.ValidatorsRegistrationBatchSizeFlag.Name),
-		UseWeb:                  c.cliCtx.Bool(flags.EnableWebFlag.Name),
-		LogValidatorPerformance: !c.cliCtx.Bool(flags.DisablePenaltyRewardLogFlag.Name),
-		EmitAccountMetrics:      !c.cliCtx.Bool(flags.DisableAccountMetricsFlag.Name),
-		Distributed:             c.cliCtx.Bool(flags.EnableDistributed.Name),
+		Endpoint:                   endpoint,
+		DataDir:                    dataDir,
+		LogValidatorBalances:       logValidatorBalances,
+		EmitAccountMetrics:         emitAccountMetrics,
+		CertFlag:                   cert,
+		GraffitiFlag:               g.ParseHexGraffiti(graffiti),
+		GrpcMaxCallRecvMsgSizeFlag: maxCallRecvMsgSize,
+		GrpcRetriesFlag:            grpcRetries,
+		GrpcRetryDelay:             grpcRetryDelay,
+		GrpcHeadersFlag:            c.cliCtx.String(flags.GrpcHeadersFlag.Name),
+		ValDB:                      c.db,
+		UseWeb:                     c.cliCtx.Bool(flags.EnableWebFlag.Name),
+		InteropKeysConfig:          interopKeysConfig,
+		Wallet:                     c.wallet,
+		WalletInitializedFeed:      c.walletInitialized,
+		GraffitiStruct:             graffitiStruct,
+		Web3SignerConfig:           web3signerConfig,
+		ProposerSettings:           ps,
+		BeaconApiTimeout:           time.Second * 30,
+		BeaconApiEndpoint:          c.cliCtx.String(flags.BeaconRESTApiProviderFlag.Name),
+		ValidatorsRegBatchSize:     c.cliCtx.Int(flags.ValidatorsRegistrationBatchSizeFlag.Name),
+		Distributed:                c.cliCtx.Bool(flags.EnableDistributed.Name),
 	})
 	if err != nil {
 		return errors.Wrap(err, "could not initialize validator service")
@@ -614,8 +625,22 @@ func (c *ValidatorClient) registerRPCService(router *mux.Router) error {
 	if err := c.services.FetchService(&vs); err != nil {
 		return err
 	}
-	authTokenPath := c.cliCtx.String(flags.AuthTokenPathFlag.Name)
+	validatorGatewayHost := c.cliCtx.String(flags.GRPCGatewayHost.Name)
+	validatorGatewayPort := c.cliCtx.Int(flags.GRPCGatewayPort.Name)
+	validatorMonitoringHost := c.cliCtx.String(cmd.MonitoringHostFlag.Name)
+	validatorMonitoringPort := c.cliCtx.Int(flags.MonitoringPortFlag.Name)
+	rpcHost := c.cliCtx.String(flags.RPCHost.Name)
+	rpcPort := c.cliCtx.Int(flags.RPCPort.Name)
+	nodeGatewayEndpoint := c.cliCtx.String(flags.BeaconRPCGatewayProviderFlag.Name)
+	beaconClientEndpoint := c.cliCtx.String(flags.BeaconRPCProviderFlag.Name)
+	maxCallRecvMsgSize := c.cliCtx.Int(cmd.GrpcMaxCallRecvMsgSizeFlag.Name)
+	grpcRetries := c.cliCtx.Uint(flags.GrpcRetriesFlag.Name)
+	grpcRetryDelay := c.cliCtx.Duration(flags.GrpcRetryDelayFlag.Name)
 	walletDir := c.cliCtx.String(flags.WalletDirFlag.Name)
+	grpcHeaders := c.cliCtx.String(flags.GrpcHeadersFlag.Name)
+	clientCert := c.cliCtx.String(flags.CertFlag.Name)
+
+	authTokenPath := c.cliCtx.String(flags.AuthTokenPathFlag.Name)
 	// if no auth token path flag was passed try to set a default value
 	if authTokenPath == "" {
 		authTokenPath = flags.AuthTokenPathFlag.Value
@@ -624,28 +649,34 @@ func (c *ValidatorClient) registerRPCService(router *mux.Router) error {
 			authTokenPath = filepath.Join(walletDir, api.AuthTokenFileName)
 		}
 	}
-	s := rpc.NewServer(c.cliCtx.Context, &rpc.Config{
-		Host:                   c.cliCtx.String(flags.RPCHost.Name),
-		Port:                   fmt.Sprintf("%d", c.cliCtx.Int(flags.RPCPort.Name)),
-		GRPCGatewayHost:        c.cliCtx.String(flags.GRPCGatewayHost.Name),
-		GRPCGatewayPort:        c.cliCtx.Int(flags.GRPCGatewayPort.Name),
-		GRPCMaxCallRecvMsgSize: c.cliCtx.Int(cmd.GrpcMaxCallRecvMsgSizeFlag.Name),
-		GRPCRetries:            c.cliCtx.Uint(flags.GrpcRetriesFlag.Name),
-		GRPCRetryDelay:         c.cliCtx.Duration(flags.GrpcRetryDelayFlag.Name),
-		GRPCHeaders:            strings.Split(c.cliCtx.String(flags.GrpcHeadersFlag.Name), ","),
-		BeaconNodeGRPCEndpoint: c.cliCtx.String(flags.BeaconRPCProviderFlag.Name),
-		BeaconApiEndpoint:      c.cliCtx.String(flags.BeaconRESTApiProviderFlag.Name),
-		BeaconApiTimeout:       time.Second * 30,
-		BeaconNodeCert:         c.cliCtx.String(flags.CertFlag.Name),
-		DB:                     c.db,
-		Wallet:                 c.wallet,
-		WalletDir:              walletDir,
-		WalletInitializedFeed:  c.walletInitializedFeed,
-		ValidatorService:       vs,
-		AuthTokenPath:          authTokenPath,
-		Router:                 router,
+
+	server := rpc.NewServer(c.cliCtx.Context, &rpc.Config{
+		ValDB:                    c.db,
+		Host:                     rpcHost,
+		Port:                     fmt.Sprintf("%d", rpcPort),
+		WalletInitializedFeed:    c.walletInitialized,
+		ValidatorService:         vs,
+		SyncChecker:              vs,
+		GenesisFetcher:           vs,
+		NodeGatewayEndpoint:      nodeGatewayEndpoint,
+		AuthTokenPath:            authTokenPath,
+		WalletDir:                walletDir,
+		Wallet:                   c.wallet,
+		ValidatorGatewayHost:     validatorGatewayHost,
+		ValidatorGatewayPort:     validatorGatewayPort,
+		ValidatorMonitoringHost:  validatorMonitoringHost,
+		ValidatorMonitoringPort:  validatorMonitoringPort,
+		BeaconClientEndpoint:     beaconClientEndpoint,
+		ClientMaxCallRecvMsgSize: maxCallRecvMsgSize,
+		ClientGrpcRetries:        grpcRetries,
+		ClientGrpcRetryDelay:     grpcRetryDelay,
+		ClientGrpcHeaders:        strings.Split(grpcHeaders, ","),
+		ClientWithCert:           clientCert,
+		BeaconApiTimeout:         time.Second * 30,
+		BeaconApiEndpoint:        c.cliCtx.String(flags.BeaconRESTApiProviderFlag.Name),
+		Router:                   router,
 	})
-	return c.services.RegisterService(s)
+	return c.services.RegisterService(server)
 }
 
 func (c *ValidatorClient) registerRPCGatewayService(router *mux.Router) error {

validator/rpc/BUILD.bazel

@@ -81,6 +81,7 @@ go_library(
         "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
+        "@org_golang_google_grpc//credentials:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//reflection:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",

validator/rpc/auth_token.go

@@ -104,7 +104,7 @@ func (s *Server) refreshAuthTokenFromFileChanges(ctx context.Context, authTokenP
 				log.WithError(err).Errorf("Could not watch for file changes for: %s", authTokenPath)
 				continue
 			}
-			validatorWebAddr := fmt.Sprintf("%s:%d", s.grpcGatewayHost, s.grpcGatewayPort)
+			validatorWebAddr := fmt.Sprintf("%s:%d", s.validatorGatewayHost, s.validatorGatewayPort)
 			logValidatorWebAuth(validatorWebAddr, s.authToken, authTokenPath)
 		case err := <-watcher.Errors:
 			log.WithError(err).Errorf("Could not watch for file changes for: %s", authTokenPath)

validator/rpc/beacon.go

@@ -27,26 +27,26 @@ func (s *Server) registerBeaconClient() error {
 		grpcretry.StreamClientInterceptor(),
 	))
 	dialOpts := client.ConstructDialOptions(
-		s.grpcMaxCallRecvMsgSize,
-		s.beaconNodeCert,
-		s.grpcRetries,
-		s.grpcRetryDelay,
+		s.clientMaxCallRecvMsgSize,
+		s.clientWithCert,
+		s.clientGrpcRetries,
+		s.clientGrpcRetryDelay,
 		streamInterceptor,
 	)
 	if dialOpts == nil {
 		return errors.New("no dial options for beacon chain gRPC client")
 	}
 
-	s.ctx = grpcutil.AppendHeaders(s.ctx, s.grpcHeaders)
+	s.ctx = grpcutil.AppendHeaders(s.ctx, s.clientGrpcHeaders)
 
-	grpcConn, err := grpc.DialContext(s.ctx, s.beaconNodeEndpoint, dialOpts...)
+	grpcConn, err := grpc.DialContext(s.ctx, s.beaconClientEndpoint, dialOpts...)
 	if err != nil {
-		return errors.Wrapf(err, "could not dial endpoint: %s", s.beaconNodeEndpoint)
+		return errors.Wrapf(err, "could not dial endpoint: %s", s.beaconClientEndpoint)
 	}
-	if s.beaconNodeCert != "" {
+	if s.clientWithCert != "" {
 		log.Info("Established secure gRPC connection")
 	}
-	s.healthClient = ethpb.NewHealthClient(grpcConn)
+	s.beaconNodeHealthClient = ethpb.NewHealthClient(grpcConn)
 
 	conn := validatorHelpers.NewNodeConnection(
 		grpcConn,
@@ -56,8 +56,8 @@ func (s *Server) registerBeaconClient() error {
 
 	restHandler := beaconApi.NewBeaconApiJsonRestHandler(http.Client{Timeout: s.beaconApiTimeout}, s.beaconApiEndpoint)
 
-	s.chainClient = beaconChainClientFactory.NewChainClient(conn, restHandler)
-	s.nodeClient = nodeClientFactory.NewNodeClient(conn, restHandler)
+	s.beaconChainClient = beaconChainClientFactory.NewBeaconChainClient(conn, restHandler)
+	s.beaconNodeClient = nodeClientFactory.NewNodeClient(conn, restHandler)
 	s.beaconNodeValidatorClient = validatorClientFactory.NewValidatorClient(conn, restHandler)
 
 	return nil

validator/rpc/beacon_test.go

@@ -11,8 +11,8 @@ import (
 
 func TestGrpcHeaders(t *testing.T) {
 	s := &Server{
-		ctx:         context.Background(),
-		grpcHeaders: []string{"first=value1", "second=value2"},
+		ctx:               context.Background(),
+		clientGrpcHeaders: []string{"first=value1", "second=value2"},
 	}
 	err := s.registerBeaconClient()
 	require.NoError(t, err)

validator/rpc/handlers_accounts.go

@@ -258,7 +258,7 @@ func (s *Server) VoluntaryExit(w http.ResponseWriter, r *http.Request) {
 	}
 	cfg := accounts.PerformExitCfg{
 		ValidatorClient:  s.beaconNodeValidatorClient,
-		NodeClient:       s.nodeClient,
+		NodeClient:       s.beaconNodeClient,
 		Keymanager:       km,
 		RawPubKeys:       pubKeys,
 		FormattedPubKeys: req.PublicKeys,

validator/rpc/handlers_accounts_test.go

@@ -292,7 +292,7 @@ func TestServer_VoluntaryExit(t *testing.T) {
 	s := &Server{
 		walletInitialized:         true,
 		wallet:                    w,
-		nodeClient:                mockNodeClient,
+		beaconNodeClient:          mockNodeClient,
 		beaconNodeValidatorClient: mockValidatorClient,
 		validatorService:          vs,
 	}

validator/rpc/handlers_beacon.go

@@ -25,30 +25,30 @@ import (
 func (s *Server) GetBeaconStatus(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "validator.web.beacon.GetBeaconStatus")
 	defer span.End()
-	syncStatus, err := s.nodeClient.GetSyncStatus(ctx, &emptypb.Empty{})
+	syncStatus, err := s.beaconNodeClient.GetSyncStatus(ctx, &emptypb.Empty{})
 	if err != nil {
 		log.WithError(err).Error("beacon node call to get sync status failed")
 		httputil.WriteJson(w, &BeaconStatusResponse{
-			BeaconNodeEndpoint: s.beaconNodeEndpoint,
+			BeaconNodeEndpoint: s.nodeGatewayEndpoint,
 			Connected:          false,
 			Syncing:            false,
 		})
 		return
 	}
-	genesis, err := s.nodeClient.GetGenesis(ctx, &emptypb.Empty{})
+	genesis, err := s.beaconNodeClient.GetGenesis(ctx, &emptypb.Empty{})
 	if err != nil {
 		httputil.HandleError(w, errors.Wrap(err, "GetGenesis call failed").Error(), http.StatusInternalServerError)
 		return
 	}
 	genesisTime := uint64(time.Unix(genesis.GenesisTime.Seconds, 0).Unix())
 	address := genesis.DepositContractAddress
-	chainHead, err := s.chainClient.GetChainHead(ctx, &emptypb.Empty{})
+	chainHead, err := s.beaconChainClient.GetChainHead(ctx, &emptypb.Empty{})
 	if err != nil {
 		httputil.HandleError(w, errors.Wrap(err, "GetChainHead").Error(), http.StatusInternalServerError)
 		return
 	}
 	httputil.WriteJson(w, &BeaconStatusResponse{
-		BeaconNodeEndpoint:     s.beaconNodeEndpoint,
+		BeaconNodeEndpoint:     s.beaconClientEndpoint,
 		Connected:              true,
 		Syncing:                syncStatus.Syncing,
 		GenesisTime:            fmt.Sprintf("%d", genesisTime),
@@ -85,7 +85,7 @@ func (s *Server) GetValidatorPerformance(w http.ResponseWriter, r *http.Request)
 	req := &ethpb.ValidatorPerformanceRequest{
 		PublicKeys: pubkeys,
 	}
-	validatorPerformance, err := s.chainClient.GetValidatorPerformance(ctx, req)
+	validatorPerformance, err := s.beaconChainClient.GetValidatorPerformance(ctx, req)
 	if err != nil {
 		httputil.HandleError(w, errors.Wrap(err, "GetValidatorPerformance call failed").Error(), http.StatusInternalServerError)
 		return
@@ -133,7 +133,7 @@ func (s *Server) GetValidatorBalances(w http.ResponseWriter, r *http.Request) {
 		PageSize:   int32(ps),
 		PageToken:  pageToken,
 	}
-	listValidatorBalances, err := s.chainClient.ListValidatorBalances(ctx, req)
+	listValidatorBalances, err := s.beaconChainClient.ListValidatorBalances(ctx, req)
 	if err != nil {
 		httputil.HandleError(w, errors.Wrap(err, "ListValidatorBalances call failed").Error(), http.StatusInternalServerError)
 		return
@@ -187,7 +187,7 @@ func (s *Server) GetValidators(w http.ResponseWriter, r *http.Request) {
 		PageSize:   int32(ps),
 		PageToken:  pageToken,
 	}
-	validators, err := s.chainClient.ListValidators(ctx, req)
+	validators, err := s.beaconChainClient.ListValidators(ctx, req)
 	if err != nil {
 		httputil.HandleError(w, errors.Wrap(err, "ListValidators call failed").Error(), http.StatusInternalServerError)
 		return
@@ -204,7 +204,7 @@ func (s *Server) GetValidators(w http.ResponseWriter, r *http.Request) {
 func (s *Server) GetPeers(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "validator.web.beacon.GetPeers")
 	defer span.End()
-	peers, err := s.nodeClient.ListPeers(ctx, &emptypb.Empty{})
+	peers, err := s.beaconNodeClient.ListPeers(ctx, &emptypb.Empty{})
 	if err != nil {
 		httputil.HandleError(w, errors.Wrap(err, "ListPeers call failed").Error(), http.StatusInternalServerError)
 		return

validator/rpc/handlers_beacon_test.go

@@ -27,7 +27,7 @@ func TestGetBeaconStatus_NotConnected(t *testing.T) {
 		gomock.Any(),
 	).Return(nil /*response*/, errors.New("uh oh"))
 	srv := &Server{
-		nodeClient: nodeClient,
+		beaconNodeClient: nodeClient,
 	}
 	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/v2/validator/beacon/status"), nil)
 	wr := httptest.NewRecorder()
@@ -47,7 +47,7 @@ func TestGetBeaconStatus_NotConnected(t *testing.T) {
 func TestGetBeaconStatus_OK(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	nodeClient := validatormock.NewMockNodeClient(ctrl)
-	chainClient := validatormock.NewMockChainClient(ctrl)
+	beaconChainClient := validatormock.NewMockBeaconChainClient(ctrl)
 	nodeClient.EXPECT().GetSyncStatus(
 		gomock.Any(), // ctx
 		gomock.Any(),
@@ -60,15 +60,15 @@ func TestGetBeaconStatus_OK(t *testing.T) {
 		GenesisTime:            timeStamp,
 		DepositContractAddress: []byte("hello"),
 	}, nil)
-	chainClient.EXPECT().GetChainHead(
+	beaconChainClient.EXPECT().GetChainHead(
 		gomock.Any(), // ctx
 		gomock.Any(),
 	).Return(&ethpb.ChainHead{
 		HeadEpoch: 1,
 	}, nil)
 	srv := &Server{
-		nodeClient:  nodeClient,
-		chainClient: chainClient,
+		beaconNodeClient:  nodeClient,
+		beaconChainClient: beaconChainClient,
 	}
 
 	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/v2/validator/beacon/status"), nil)
@@ -228,7 +228,7 @@ func TestServer_GetValidators(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			ctrl := gomock.NewController(t)
-			beaconChainClient := validatormock.NewMockChainClient(ctrl)
+			beaconChainClient := validatormock.NewMockBeaconChainClient(ctrl)
 			if tt.wantErr == "" {
 				beaconChainClient.EXPECT().ListValidators(
 					gomock.Any(), // ctx
@@ -236,7 +236,7 @@ func TestServer_GetValidators(t *testing.T) {
 				).Return(tt.chainResp, nil)
 			}
 			s := &Server{
-				chainClient: beaconChainClient,
+				beaconChainClient: beaconChainClient,
 			}
 			req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/v2/validator/beacon/validators?%s", tt.query), http.NoBody)
 			wr := httptest.NewRecorder()

validator/rpc/handlers_health.go

@@ -18,7 +18,7 @@ func (s *Server) GetVersion(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "validator.web.health.GetVersion")
 	defer span.End()
 
-	beacon, err := s.nodeClient.GetVersion(ctx, &emptypb.Empty{})
+	beacon, err := s.beaconNodeClient.GetVersion(ctx, &emptypb.Empty{})
 	if err != nil {
 		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -51,7 +51,7 @@ func (s *Server) StreamBeaconLogs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	// TODO: StreamBeaconLogs grpc will need to be replaced in the future
-	client, err := s.healthClient.StreamBeaconLogs(ctx, &emptypb.Empty{})
+	client, err := s.beaconNodeHealthClient.StreamBeaconLogs(ctx, &emptypb.Empty{})
 	if err != nil {
 		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -102,8 +102,8 @@ func (s *Server) StreamValidatorLogs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	ch := make(chan []byte, s.logStreamerBufferSize)
-	sub := s.logStreamer.LogsFeed().Subscribe(ch)
+	ch := make(chan []byte, s.streamLogsBufferSize)
+	sub := s.logsStreamer.LogsFeed().Subscribe(ch)
 	defer func() {
 		sub.Unsubscribe()
 		close(ch)
@@ -113,7 +113,7 @@ func (s *Server) StreamValidatorLogs(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Cache-Control", "no-cache")
 	w.Header().Set("Connection", api.KeepAlive)
 
-	recentLogs := s.logStreamer.GetLastFewLogs()
+	recentLogs := s.logsStreamer.GetLastFewLogs()
 	logStrings := make([]string, len(recentLogs))
 	for i, l := range recentLogs {
 		logStrings[i] = string(l)

validator/rpc/handlers_health_test.go

@@ -73,8 +73,8 @@ func TestStreamBeaconLogs(t *testing.T) {
 
 	// Setting up the mock in the server struct
 	s := Server{
-		ctx:          context.Background(),
-		healthClient: mockClient,
+		ctx:                    context.Background(),
+		beaconNodeHealthClient: mockClient,
 	}
 
 	// Create a mock ResponseWriter and Request
@@ -119,9 +119,9 @@ func TestStreamValidatorLogs(t *testing.T) {
 	logStreamer := mock.NewMockStreamer(mockLogs)
 	// Setting up the mock in the server struct
 	s := Server{
-		ctx:                   ctx,
-		logStreamer:           logStreamer,
-		logStreamerBufferSize: 100,
+		ctx:                  ctx,
+		logsStreamer:         logStreamer,
+		streamLogsBufferSize: 100,
 	}
 
 	w := &flushableResponseRecorder{
@@ -170,8 +170,8 @@ func TestServer_GetVersion(t *testing.T) {
 	ctx := context.Background()
 	mockNodeClient := validatormock.NewMockNodeClient(ctrl)
 	s := Server{
-		ctx:        ctx,
-		nodeClient: mockNodeClient,
+		ctx:              ctx,
+		beaconNodeClient: mockNodeClient,
 	}
 	mockNodeClient.EXPECT().GetVersion(gomock.Any(), gomock.Any()).Return(&eth.Version{
 		Version:  "4.10.1",

validator/rpc/handlers_keymanager.go

@@ -133,7 +133,7 @@ func (s *Server) ImportKeystores(w http.ResponseWriter, r *http.Request) {
 		keystores[i] = k
 	}
 	if req.SlashingProtection != "" {
-		if s.db == nil || s.db.ImportStandardProtectionJSON(ctx, bytes.NewBufferString(req.SlashingProtection)) != nil {
+		if s.valDB == nil || s.valDB.ImportStandardProtectionJSON(ctx, bytes.NewBufferString(req.SlashingProtection)) != nil {
 			statuses := make([]*keymanager.KeyStatus, len(req.Keystores))
 			for i := 0; i < len(req.Keystores); i++ {
 				statuses[i] = &keymanager.KeyStatus{
@@ -285,11 +285,11 @@ func (s *Server) transformDeletedKeysStatuses(
 // Gets a map of all public keys in the database, useful for O(1) lookups.
 func (s *Server) publicKeysInDB(ctx context.Context) (map[[fieldparams.BLSPubkeyLength]byte]bool, error) {
 	pubKeysInDB := make(map[[fieldparams.BLSPubkeyLength]byte]bool)
-	attestedPublicKeys, err := s.db.AttestedPublicKeys(ctx)
+	attestedPublicKeys, err := s.valDB.AttestedPublicKeys(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not get attested public keys from DB: %v", err)
 	}
-	proposedPublicKeys, err := s.db.ProposedPublicKeys(ctx)
+	proposedPublicKeys, err := s.valDB.ProposedPublicKeys(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not get proposed public keys from DB: %v", err)
 	}
@@ -313,7 +313,7 @@ func (s *Server) slashingProtectionHistoryForDeletedKeys(
 			filteredKeys = append(filteredKeys, pk)
 		}
 	}
-	return slashingprotection.ExportStandardProtectionJSON(ctx, s.db, filteredKeys...)
+	return slashingprotection.ExportStandardProtectionJSON(ctx, s.valDB, filteredKeys...)
 }
 
 // SetVoluntaryExit creates a signed voluntary exit message and returns a VoluntaryExit object.
@@ -347,7 +347,7 @@ func (s *Server) SetVoluntaryExit(w http.ResponseWriter, r *http.Request) {
 	epoch := primitives.Epoch(e)
 
 	if rawEpoch == "" {
-		genesisResponse, err := s.nodeClient.GetGenesis(ctx, &emptypb.Empty{})
+		genesisResponse, err := s.beaconNodeClient.GetGenesis(ctx, &emptypb.Empty{})
 		if err != nil {
 			httputil.HandleError(w, errors.Wrap(err, "Failed to get genesis time").Error(), http.StatusInternalServerError)
 			return
@@ -414,7 +414,7 @@ func (s *Server) ListRemoteKeys(w http.ResponseWriter, r *http.Request) {
 	for i := 0; i < len(pubKeys); i++ {
 		keystoreResponse[i] = &RemoteKey{
 			Pubkey:   hexutil.Encode(pubKeys[i][:]),
-			Url:      s.validatorService.RemoteSignerConfig().BaseEndpoint,
+			Url:      s.validatorService.Web3SignerConfig.BaseEndpoint,
 			Readonly: true,
 		}
 	}

validator/rpc/handlers_keymanager_test.go

@@ -289,7 +289,7 @@ func TestServer_ImportKeystores(t *testing.T) {
 				})
 			}
 			require.NoError(t, err)
-			s.db = validatorDB
+			s.valDB = validatorDB
 
 			// Have to close it after import is done otherwise it complains db is not open.
 			defer func() {
@@ -413,7 +413,7 @@ func TestServer_DeleteKeystores(t *testing.T) {
 			})
 		}
 		require.NoError(t, err)
-		srv.db = validatorDB
+		srv.valDB = validatorDB
 
 		// Have to close it after import is done otherwise it complains db is not open.
 		defer func() {
@@ -589,7 +589,7 @@ func TestServer_DeleteKeystores_FailedSlashingProtectionExport(t *testing.T) {
 			require.NoError(t, err)
 			err = validatorDB.SaveGenesisValidatorsRoot(ctx, make([]byte, fieldparams.RootLength))
 			require.NoError(t, err)
-			srv.db = validatorDB
+			srv.valDB = validatorDB
 
 			// Have to close it after import is done otherwise it complains db is not open.
 			defer func() {
@@ -746,7 +746,7 @@ func TestServer_SetVoluntaryExit(t *testing.T) {
 		validatorService:          vs,
 		beaconNodeValidatorClient: beaconClient,
 		wallet:                    w,
-		nodeClient:                mockNodeClient,
+		beaconNodeClient:          mockNodeClient,
 		walletInitialized:         w != nil,
 	}
 
@@ -841,7 +841,7 @@ func TestServer_SetVoluntaryExit(t *testing.T) {
 			resp := &SetVoluntaryExitResponse{}
 			require.NoError(t, json.Unmarshal(w.Body.Bytes(), resp))
 			if tt.w.epoch == 0 {
-				genesisResponse, err := s.nodeClient.GetGenesis(ctx, &emptypb.Empty{})
+				genesisResponse, err := s.beaconNodeClient.GetGenesis(ctx, &emptypb.Empty{})
 				require.NoError(t, err)
 				tt.w.epoch, err = client.CurrentEpoch(genesisResponse.GenesisTime)
 				require.NoError(t, err)
@@ -1091,14 +1091,14 @@ func TestServer_SetGasLimit(t *testing.T) {
 				validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{}, isSlashingProtectionMinimal)
 				vs, err := client.NewValidatorService(ctx, &client.Config{
 					Validator: m,
-					DB:        validatorDB,
+					ValDB:     validatorDB,
 				})
 				require.NoError(t, err)
 
 				s := &Server{
 					validatorService:          vs,
 					beaconNodeValidatorClient: beaconClient,
-					db:                        validatorDB,
+					valDB:                     validatorDB,
 				}
 
 				if tt.beaconReturn != nil {
@@ -1280,12 +1280,12 @@ func TestServer_DeleteGasLimit(t *testing.T) {
 				validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{}, isSlashingProtectionMinimal)
 				vs, err := client.NewValidatorService(ctx, &client.Config{
 					Validator: m,
-					DB:        validatorDB,
+					ValDB:     validatorDB,
 				})
 				require.NoError(t, err)
 				s := &Server{
 					validatorService: vs,
-					db:               validatorDB,
+					valDB:            validatorDB,
 				}
 				// Set up global default value for builder gas limit.
 				params.BeaconConfig().DefaultBuilderGasLimit = uint64(globalDefaultGasLimit)
@@ -1744,13 +1744,13 @@ func TestServer_FeeRecipientByPubkey(t *testing.T) {
 				// save a default here
 				vs, err := client.NewValidatorService(ctx, &client.Config{
 					Validator: m,
-					DB:        validatorDB,
+					ValDB:     validatorDB,
 				})
 				require.NoError(t, err)
 				s := &Server{
 					validatorService:          vs,
 					beaconNodeValidatorClient: beaconClient,
-					db:                        validatorDB,
+					valDB:                     validatorDB,
 				}
 				request := &SetFeeRecipientByPubkeyRequest{
 					Ethaddress: tt.args,
@@ -1854,12 +1854,12 @@ func TestServer_DeleteFeeRecipientByPubkey(t *testing.T) {
 				validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{}, isSlashingProtectionMinimal)
 				vs, err := client.NewValidatorService(ctx, &client.Config{
 					Validator: m,
-					DB:        validatorDB,
+					ValDB:     validatorDB,
 				})
 				require.NoError(t, err)
 				s := &Server{
 					validatorService: vs,
-					db:               validatorDB,
+					valDB:            validatorDB,
 				}
 				req := httptest.NewRequest(http.MethodDelete, fmt.Sprintf("/eth/v1/validator/{pubkey}/feerecipient"), nil)
 				req = mux.SetURLVars(req, map[string]string{"pubkey": pubkey})