potuz's suggestion

.bazelrc

@@ -3,7 +3,6 @@ import %workspace%/build/bazelrc/convenience.bazelrc
 import %workspace%/build/bazelrc/correctness.bazelrc
 import %workspace%/build/bazelrc/cross.bazelrc
 import %workspace%/build/bazelrc/debug.bazelrc
-import %workspace%/build/bazelrc/hermetic-cc.bazelrc
 import %workspace%/build/bazelrc/performance.bazelrc
 
 # E2E run with debug gotag
@@ -15,7 +14,7 @@ coverage --define=coverage_enabled=1
 # Stamp binaries with git information
 build --workspace_status_command=./hack/workspace_status.sh
 
-build --define blst_disabled=false --define blst_modern=true
+build --define blst_disabled=false
 run --define blst_disabled=false
 
 build:blst_disabled --define blst_disabled=true
@@ -28,7 +27,30 @@ build:minimal --@io_bazel_rules_go//go/config:tags=minimal
 build:release --compilation_mode=opt
 build:release --stamp
 
+# LLVM compiler for building C/C++ dependencies.
+build:llvm --define compiler=llvm
+build:llvm --copt -fno-sanitize=vptr,function
+build:llvm --linkopt -fno-sanitize=vptr,function
+# --incompatible_enable_cc_toolchain_resolution not needed after this issue is closed https://github.com/bazelbuild/bazel/issues/7260
+build:llvm --incompatible_enable_cc_toolchain_resolution
+
+build:asan --copt -fsanitize=address,undefined
+build:asan --copt -fno-omit-frame-pointer
+build:asan --linkopt -fsanitize=address,undefined
+build:asan --copt -fno-sanitize=vptr,function
+build:asan --linkopt -fno-sanitize=vptr,function
+build:asan --copt -DADDRESS_SANITIZER=1
+build:asan --copt -D__SANITIZE_ADDRESS__
+build:asan --linkopt -ldl
+
+build:llvm-asan --config=llvm
+build:llvm-asan --config=asan
+build:llvm-asan --linkopt -fuse-ld=ld.lld
+
+build:fuzz --@io_bazel_rules_go//go/config:tags=fuzz
+
 # Build binary with cgo symbolizer for debugging / profiling.
+build:cgo_symbolizer --config=llvm
 build:cgo_symbolizer --copt=-g
 build:cgo_symbolizer --define=USE_CGO_SYMBOLIZER=true
 build:cgo_symbolizer -c dbg
@@ -37,13 +59,9 @@ build:cgo_symbolizer --define=gotags=cgosymbolizer_enabled
 # toolchain build debug configs
 #------------------------------
 build:debug --sandbox_debug
-build:debug --toolchain_resolution_debug=".*"
+build:debug --toolchain_resolution_debug
 build:debug --verbose_failures
 build:debug -s
 
 # Set bazel gotag
 build --define gotags=bazel
-
-# Abseil requires c++14 or greater.
-build --cxxopt=-std=c++20
-build --host_cxxopt=-std=c++20

.bazelversion

@@ -1 +1 @@
-6.2.1
+6.1.0

BUILD.bazel

@@ -3,6 +3,7 @@ load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
 load("@io_kubernetes_build//defs:run_in_workspace.bzl", "workspace_binary")
 load("@io_bazel_rules_go//go:def.bzl", "nogo")
+load("@vaticle_bazel_distribution//common:rules.bzl", "assemble_targz", "assemble_versioned")
 load("@bazel_skylib//rules:common_settings.bzl", "string_setting")
 
 prefix = "github.com/prysmaticlabs/prysm"

WORKSPACE

@@ -16,37 +16,27 @@ load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies")
 
 rules_pkg_dependencies()
 
-HERMETIC_CC_TOOLCHAIN_VERSION = "v2.0.0"
-
 http_archive(
-    name = "hermetic_cc_toolchain",
-    sha256 = "57f03a6c29793e8add7bd64186fc8066d23b5ffd06fe9cc6b0b8c499914d3a65",
-    urls = [
-        "https://mirror.bazel.build/github.com/uber/hermetic_cc_toolchain/releases/download/{0}/hermetic_cc_toolchain-{0}.tar.gz".format(HERMETIC_CC_TOOLCHAIN_VERSION),
-        "https://github.com/uber/hermetic_cc_toolchain/releases/download/{0}/hermetic_cc_toolchain-{0}.tar.gz".format(HERMETIC_CC_TOOLCHAIN_VERSION),
-    ],
+    name = "com_grail_bazel_toolchain",
+    sha256 = "b210fc8e58782ef171f428bfc850ed7179bdd805543ebd1aa144b9c93489134f",
+    strip_prefix = "bazel-toolchain-83e69ba9e4b4fdad0d1d057fcb87addf77c281c9",
+    urls = ["https://github.com/grailbio/bazel-toolchain/archive/83e69ba9e4b4fdad0d1d057fcb87addf77c281c9.tar.gz"],
 )
 
-load("@hermetic_cc_toolchain//toolchain:defs.bzl", zig_toolchains = "toolchains")
+load("@com_grail_bazel_toolchain//toolchain:deps.bzl", "bazel_toolchain_dependencies")
 
-zig_toolchains()
+bazel_toolchain_dependencies()
 
-# Register zig sdk toolchains with support for Ubuntu 20.04 (Focal Fossa) which has an EOL date of April, 2025.
-# For ubuntu glibc support, see https://launchpad.net/ubuntu/+source/glibc
-register_toolchains(
-    "@zig_sdk//toolchain:linux_amd64_gnu.2.31",
-    "@zig_sdk//toolchain:linux_arm64_gnu.2.31",
-    # Hermetic cc toolchain is not yet supported on darwin. Sysroot needs to be provided.
-    # See https://github.com/uber/hermetic_cc_toolchain#osx-sysroot
-    #    "@zig_sdk//toolchain:darwin_amd64",
-    #    "@zig_sdk//toolchain:darwin_arm64",
-    # Windows builds are not supported yet.
-    #    "@zig_sdk//toolchain:windows_amd64",
+load("@com_grail_bazel_toolchain//toolchain:rules.bzl", "llvm_toolchain")
+
+llvm_toolchain(
+    name = "llvm_toolchain",
+    llvm_version = "13.0.1",
 )
 
-load("@prysm//tools/cross-toolchain:darwin_cc_hack.bzl", "configure_nonhermetic_darwin")
+load("@llvm_toolchain//:toolchains.bzl", "llvm_register_toolchains")
 
-configure_nonhermetic_darwin()
+llvm_register_toolchains()
 
 load("@prysm//tools/cross-toolchain:prysm_toolchains.bzl", "configure_prysm_toolchains")
 
@@ -321,13 +311,11 @@ http_archive(
     url = "https://github.com/bazelbuild/buildtools/archive/f2aed9ee205d62d45c55cfabbfd26342f8526862.zip",
 )
 
-http_archive(
+git_repository(
     name = "com_google_protobuf",
-    sha256 = "4e176116949be52b0408dfd24f8925d1eb674a781ae242a75296b17a1c721395",
-    strip_prefix = "protobuf-23.3",
-    urls = [
-        "https://github.com/protocolbuffers/protobuf/archive/v23.3.tar.gz",
-    ],
+    commit = "436bd7880e458532901c58f4d9d1ea23fa7edd52",
+    remote = "https://github.com/protocolbuffers/protobuf",
+    shallow_since = "1617835118 -0700",
 )
 
 # Group the sources of the library so that CMake rule have access to it

api/client/beacon/checkpoint_test.go

@@ -128,7 +128,6 @@ func TestDownloadWeakSubjectivityCheckpoint(t *testing.T) {
 	wst, err := util.NewBeaconState()
 	require.NoError(t, err)
 	fork, err := forkForEpoch(cfg, epoch)
-	require.NoError(t, err)
 	require.NoError(t, wst.SetFork(fork))
 
 	// set up checkpoint block
@@ -227,7 +226,6 @@ func TestDownloadBackwardsCompatibleCombined(t *testing.T) {
 	wst, err := util.NewBeaconState()
 	require.NoError(t, err)
 	fork, err := forkForEpoch(cfg, cfg.GenesisEpoch)
-	require.NoError(t, err)
 	require.NoError(t, wst.SetFork(fork))
 
 	// set up checkpoint block
@@ -401,7 +399,6 @@ func TestDownloadFinalizedData(t *testing.T) {
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	fork, err := forkForEpoch(cfg, epoch)
-	require.NoError(t, err)
 	require.NoError(t, st.SetFork(fork))
 	require.NoError(t, st.SetSlot(slot))
 

beacon-chain/blockchain/chain_info.go

@@ -340,13 +340,7 @@ func (s *Service) IsOptimistic(_ context.Context) (bool, error) {
 	}
 	s.headLock.RLock()
 	headRoot := s.head.root
-	headSlot := s.head.slot
-	headOptimistic := s.head.optimistic
 	s.headLock.RUnlock()
-	// we trust the head package for recent head slots, otherwise fallback to forkchoice
-	if headSlot+2 >= s.CurrentSlot() {
-		return headOptimistic, nil
-	}
 
 	s.cfg.ForkChoiceStore.RLock()
 	defer s.cfg.ForkChoiceStore.RUnlock()

beacon-chain/blockchain/chain_info_test.go

@@ -422,12 +422,6 @@ func TestService_IsOptimistic(t *testing.T) {
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
-	require.Equal(t, primitives.Slot(0), c.CurrentSlot())
-	require.Equal(t, false, opt)
-
-	c.SetGenesisTime(time.Now().Add(-time.Second * time.Duration(4*params.BeaconConfig().SecondsPerSlot)))
-	opt, err = c.IsOptimistic(ctx)
-	require.NoError(t, err)
 	require.Equal(t, true, opt)
 }
 

beacon-chain/blockchain/error.go

@@ -41,15 +41,13 @@ var (
 type invalidBlock struct {
 	invalidAncestorRoots [][32]byte
 	error
-	root          [32]byte
-	lastValidHash [32]byte
+	root [32]byte
 }
 
 type invalidBlockError interface {
 	Error() string
 	InvalidAncestorRoots() [][32]byte
 	BlockRoot() [32]byte
-	LastValidHash() [32]byte
 }
 
 // BlockRoot returns the invalid block root.
@@ -57,11 +55,6 @@ func (e invalidBlock) BlockRoot() [32]byte {
 	return e.root
 }
 
-// LastValidHash returns the last valid hash root.
-func (e invalidBlock) LastValidHash() [32]byte {
-	return e.lastValidHash
-}
-
 // InvalidAncestorRoots returns an optional list of invalid roots of the invalid block which leads up last valid root.
 func (e invalidBlock) InvalidAncestorRoots() [][32]byte {
 	return e.invalidAncestorRoots
@@ -79,19 +72,6 @@ func IsInvalidBlock(e error) bool {
 	return true
 }
 
-// InvalidBlockLVH returns the invalid block last valid hash root. If the error
-// doesn't have a last valid hash, [32]byte{} is returned.
-func InvalidBlockLVH(e error) [32]byte {
-	if e == nil {
-		return [32]byte{}
-	}
-	d, ok := e.(invalidBlockError)
-	if !ok {
-		return [32]byte{}
-	}
-	return d.LastValidHash()
-}
-
 // InvalidBlockRoot returns the invalid block root. If the error
 // doesn't have an invalid blockroot. [32]byte{} is returned.
 func InvalidBlockRoot(e error) [32]byte {

beacon-chain/blockchain/execution_engine.go

@@ -71,6 +71,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 
 	nextSlot := s.CurrentSlot() + 1 // Cache payload ID for next slot proposer.
 	hasAttr, attr, proposerId := s.getPayloadAttribute(ctx, arg.headState, nextSlot, arg.headRoot[:])
+
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, attr)
 	if err != nil {
 		switch err {
@@ -219,37 +220,35 @@ func (s *Service) notifyNewPayload(ctx context.Context, postStateVersion int,
 		}).Info("Called new payload with optimistic block")
 		return false, nil
 	case execution.ErrInvalidPayloadStatus:
-		lvh := bytesutil.ToBytes32(lastValidHash)
-		return false, invalidBlock{
-			error:         ErrInvalidPayload,
-			lastValidHash: lvh,
+		newPayloadInvalidNodeCount.Inc()
+		root, err := blk.Block().HashTreeRoot()
+		if err != nil {
+			return false, err
 		}
+		invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, blk.Block().ParentRoot(), bytesutil.ToBytes32(lastValidHash))
+		if err != nil {
+			return false, err
+		}
+		if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
+			return false, err
+		}
+		log.WithFields(logrus.Fields{
+			"slot":                 blk.Block().Slot(),
+			"blockRoot":            fmt.Sprintf("%#x", root),
+			"invalidChildrenCount": len(invalidRoots),
+		}).Warn("Pruned invalid blocks")
+		return false, invalidBlock{
+			invalidAncestorRoots: invalidRoots,
+			error:                ErrInvalidPayload,
+		}
+	case execution.ErrInvalidBlockHashPayloadStatus:
+		newPayloadInvalidNodeCount.Inc()
+		return false, ErrInvalidBlockHashPayloadStatus
 	default:
 		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 	}
 }
 
-// reportInvalidBlock deals with the event that an invalid block was detected by the execution layer
-func (s *Service) reportInvalidBlock(ctx context.Context, root, parentRoot, lvh [32]byte) error {
-	newPayloadInvalidNodeCount.Inc()
-	invalidRoots, err := s.cfg.ForkChoiceStore.SetOptimisticToInvalid(ctx, root, parentRoot, lvh)
-	if err != nil {
-		return err
-	}
-	if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
-		return err
-	}
-	log.WithFields(logrus.Fields{
-		"blockRoot":            fmt.Sprintf("%#x", root),
-		"invalidChildrenCount": len(invalidRoots),
-	}).Warn("Pruned invalid blocks")
-	return invalidBlock{
-		invalidAncestorRoots: invalidRoots,
-		error:                ErrInvalidPayload,
-		lastValidHash:        lvh,
-	}
-}
-
 // getPayloadAttributes returns the payload attributes for the given state and slot.
 // The attribute is required to initiate a payload build process in the context of an `engine_forkchoiceUpdated` call.
 func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState, slot primitives.Slot, headRoot []byte) (bool, payloadattribute.Attributer, primitives.ValidatorIndex) {

beacon-chain/blockchain/execution_engine_test.go

@@ -743,37 +743,6 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	require.Equal(t, true, validated)
 }
 
-func Test_reportInvalidBlock(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.MainnetConfig())
-	service, tr := minimalTestService(t)
-	ctx, _, fcs := tr.ctx, tr.db, tr.fcs
-	jcp := &ethpb.Checkpoint{}
-	st, root, err := prepareForkchoiceState(ctx, 0, [32]byte{'A'}, [32]byte{}, [32]byte{'a'}, jcp, jcp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 1, [32]byte{'B'}, [32]byte{'A'}, [32]byte{'b'}, jcp, jcp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'C'}, [32]byte{'B'}, [32]byte{'c'}, jcp, jcp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'d'}, jcp, jcp)
-	require.NoError(t, err)
-	require.NoError(t, fcs.InsertNode(ctx, st, root))
-
-	require.NoError(t, fcs.SetOptimisticToValid(ctx, [32]byte{'A'}))
-	err = service.reportInvalidBlock(ctx, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'a'})
-	require.Equal(t, IsInvalidBlock(err), true)
-	require.Equal(t, InvalidBlockLVH(err), [32]byte{'a'})
-	invalidRoots := InvalidAncestorRoots(err)
-	require.Equal(t, 3, len(invalidRoots))
-	require.Equal(t, [32]byte{'D'}, invalidRoots[0])
-	require.Equal(t, [32]byte{'C'}, invalidRoots[1])
-	require.Equal(t, [32]byte{'B'}, invalidRoots[2])
-}
-
 func Test_GetPayloadAttribute(t *testing.T) {
 	service, tr := minimalTestService(t, WithProposerIdsCache(cache.NewProposerPayloadIDsCache()))
 	ctx := tr.ctx

beacon-chain/blockchain/head.go

@@ -47,11 +47,9 @@ func (s *Service) UpdateAndSaveHeadWithBalances(ctx context.Context) error {
 
 // This defines the current chain service's view of head.
 type head struct {
-	root       [32]byte                             // current head root.
-	block      interfaces.ReadOnlySignedBeaconBlock // current head block.
-	state      state.BeaconState                    // current head state.
-	slot       primitives.Slot                      // the head block slot number
-	optimistic bool                                 // optimistic status when saved head
+	root  [32]byte                             // current head root.
+	block interfaces.ReadOnlySignedBeaconBlock // current head block.
+	state state.BeaconState                    // current head state.
 }
 
 // This saves head info to the local service cache, it also saves the
@@ -96,10 +94,6 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 		return errors.Wrap(err, "could not get old head root")
 	}
 	oldHeadRoot := bytesutil.ToBytes32(r)
-	isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(newHeadRoot)
-	if err != nil {
-		log.WithError(err).Error("could not check if node is optimistically synced")
-	}
 	if headBlock.Block().ParentRoot() != oldHeadRoot {
 		// A chain re-org occurred, so we fire an event notifying the rest of the services.
 		commonRoot, forkSlot, err := s.cfg.ForkChoiceStore.CommonAncestor(ctx, oldHeadRoot, newHeadRoot)
@@ -131,6 +125,10 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 		reorgDistance.Observe(float64(dis))
 		reorgDepth.Observe(float64(dep))
 
+		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(newHeadRoot)
+		if err != nil {
+			return errors.Wrap(err, "could not check if node is optimistically synced")
+		}
 		s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
@@ -152,14 +150,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 	}
 
 	// Cache the new head info.
-	newHead := &head{
-		root:       newHeadRoot,
-		block:      headBlock,
-		state:      headState,
-		optimistic: isOptimistic,
-		slot:       headBlock.Block().Slot(),
-	}
-	if err := s.setHead(newHead); err != nil {
+	if err := s.setHead(newHeadRoot, headBlock, headState); err != nil {
 		return errors.Wrap(err, "could not set head")
 	}
 
@@ -204,22 +195,20 @@ func (s *Service) saveHeadNoDB(ctx context.Context, b interfaces.ReadOnlySignedB
 	return nil
 }
 
-// This sets head view object which is used to track the head slot, root, block, state and optimistic status
-func (s *Service) setHead(newHead *head) error {
+// This sets head view object which is used to track the head slot, root, block and state.
+func (s *Service) setHead(root [32]byte, block interfaces.ReadOnlySignedBeaconBlock, state state.BeaconState) error {
 	s.headLock.Lock()
 	defer s.headLock.Unlock()
 
 	// This does a full copy of the block and state.
-	bCp, err := newHead.block.Copy()
+	bCp, err := block.Copy()
 	if err != nil {
 		return err
 	}
 	s.head = &head{
-		root:       newHead.root,
-		block:      bCp,
-		state:      newHead.state.Copy(),
-		optimistic: newHead.optimistic,
-		slot:       newHead.slot,
+		root:  root,
+		block: bCp,
+		state: state.Copy(),
 	}
 	return nil
 }

beacon-chain/blockchain/process_block.go

@@ -107,8 +107,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	}
 
 	// Verify that the parent block is in forkchoice
-	parentRoot := b.ParentRoot()
-	if !s.cfg.ForkChoiceStore.HasNode(parentRoot) {
+	if !s.cfg.ForkChoiceStore.HasNode(b.ParentRoot()) {
 		return ErrNotDescendantOfFinalized
 	}
 
@@ -135,9 +134,6 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	}
 	isValidPayload, err := s.notifyNewPayload(ctx, postStateVersion, postStateHeader, signed)
 	if err != nil {
-		if IsInvalidBlock(err) && InvalidBlockLVH(err) != [32]byte{} {
-			return s.reportInvalidBlock(ctx, blockRoot, parentRoot, InvalidBlockLVH(err))
-		}
 		return errors.Wrap(err, "could not validate new payload")
 	}
 	if signed.Version() < version.Capella && isValidPayload {
@@ -149,7 +145,8 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	if err := s.savePostStateInfo(ctx, blockRoot, signed, postState); err != nil {
 		return err
 	}
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, postState, blockRoot); err != nil {
+
+	if err := s.insertBlockToForkchoiceStore(ctx, signed.Block(), blockRoot, postState); err != nil {
 		return errors.Wrapf(err, "could not insert block %d to fork choice store", signed.Block().Slot())
 	}
 	if err := s.handleBlockAttestations(ctx, signed.Block(), postState); err != nil {
@@ -189,6 +186,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 			}
 		}()
 	}
+
 	justified := s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	start := time.Now()
 	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx)
@@ -259,6 +257,10 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 		if err := s.updateFinalized(ctx, &ethpb.Checkpoint{Epoch: finalized.Epoch, Root: finalized.Root[:]}); err != nil {
 			return err
 		}
+		isOptimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(finalized.Root)
+		if err != nil {
+			return errors.Wrap(err, "could not check if node is optimistically synced")
+		}
 		go func() {
 			// Send an event regarding the new finalized checkpoint over a common event feed.
 			stateRoot := signed.Block().StateRoot()
@@ -268,7 +270,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 					Epoch:               postState.FinalizedCheckpoint().Epoch,
 					Block:               postState.FinalizedCheckpoint().Root,
 					State:               stateRoot[:],
-					ExecutionOptimistic: isValidPayload,
+					ExecutionOptimistic: isOptimistic,
 				},
 			})
 
@@ -496,32 +498,10 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 		if err := helpers.UpdateCommitteeCache(ctx, copied, coreTime.CurrentEpoch(copied)); err != nil {
 			return err
 		}
-		e := coreTime.CurrentEpoch(copied)
-		if err := helpers.UpdateProposerIndicesInCache(ctx, copied, e); err != nil {
+		if err := helpers.UpdateProposerIndicesInCache(ctx, copied); err != nil {
 			return err
 		}
-		go func() {
-			// Use a custom deadline here, since this method runs asynchronously.
-			// We ignore the parent method's context and instead create a new one
-			// with a custom deadline, therefore using the background context instead.
-			slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
-			defer cancel()
-			if err := helpers.UpdateProposerIndicesInCache(slotCtx, copied, e+1); err != nil {
-				log.WithError(err).Warn("Failed to cache next epoch proposers")
-			}
-		}()
 	} else if postState.Slot() >= s.nextEpochBoundarySlot {
-		postState = postState.Copy()
-		if s.nextEpochBoundarySlot != 0 {
-			ep := slots.ToEpoch(s.nextEpochBoundarySlot)
-			_, nextProposerIndexToSlots, err := helpers.CommitteeAssignments(ctx, postState, ep)
-			if err != nil {
-				return err
-			}
-			for k, v := range nextProposerIndexToSlots {
-				s.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(v[0], k, [8]byte{}, [32]byte{})
-			}
-		}
 		s.nextEpochBoundarySlot, err = slots.EpochStart(coreTime.NextEpoch(postState))
 		if err != nil {
 			return err
@@ -532,7 +512,7 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 		if err := helpers.UpdateCommitteeCache(ctx, postState, coreTime.CurrentEpoch(postState)); err != nil {
 			return err
 		}
-		if err := helpers.UpdateProposerIndicesInCache(ctx, postState, coreTime.CurrentEpoch(postState)); err != nil {
+		if err := helpers.UpdateProposerIndicesInCache(ctx, postState); err != nil {
 			return err
 		}
 
@@ -544,9 +524,27 @@ func (s *Service) handleEpochBoundary(ctx context.Context, postState state.Beaco
 			return err
 		}
 	}
+
 	return nil
 }
 
+// This feeds in the block to fork choice store. It's allows fork choice store
+// to gain information on the most current chain.
+func (s *Service) insertBlockToForkchoiceStore(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock, root [32]byte, st state.BeaconState) error {
+	ctx, span := trace.StartSpan(ctx, "blockChain.insertBlockToForkchoiceStore")
+	defer span.End()
+
+	if !s.cfg.ForkChoiceStore.HasNode(blk.ParentRoot()) {
+		fCheckpoint := st.FinalizedCheckpoint()
+		jCheckpoint := st.CurrentJustifiedCheckpoint()
+		if err := s.fillInForkChoiceMissingBlocks(ctx, blk, fCheckpoint, jCheckpoint); err != nil {
+			return err
+		}
+	}
+
+	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
+}
+
 // This feeds in the attestations included in the block to fork choice store. It's allows fork choice store
 // to gain information on the most current chain.
 func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock, st state.BeaconState) error {

beacon-chain/blockchain/receive_attestation.go

@@ -94,10 +94,8 @@ func (s *Service) spawnProcessAttestationsRoutine() {
 			case <-s.ctx.Done():
 				return
 			case <-pat.C():
-				log.Infof("proposer_mocker: calling updated head via offset ticker")
 				s.UpdateHead(s.ctx, s.CurrentSlot()+1)
 			case <-st.C():
-				log.Infof("proposer_mocker: calling updated head via normal slot ticker in spawn atts")
 				s.cfg.ForkChoiceStore.Lock()
 				if err := s.cfg.ForkChoiceStore.NewSlot(s.ctx, s.CurrentSlot()); err != nil {
 					log.WithError(err).Error("could not process new slot")
@@ -126,8 +124,6 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 	}
 	s.processAttestations(ctx, disparity)
 
-	log.Infof("proposer_mocker: process attestations in fc took %s", time.Since(start).String())
-
 	processAttsElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
 
 	start = time.Now()
@@ -140,14 +136,11 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 		s.headLock.RUnlock()
 	}
 	newAttHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
-	log.Infof("proposer_mocker: head root in fc took %s", time.Since(start).String())
 
 	changed, err := s.forkchoiceUpdateWithExecution(s.ctx, newHeadRoot, proposingSlot)
 	if err != nil {
 		log.WithError(err).Error("could not update forkchoice")
 	}
-	log.Infof("proposer_mocker: fcu call in fc took %s", time.Since(start).String())
-
 	if changed {
 		s.headLock.RLock()
 		log.WithFields(logrus.Fields{

beacon-chain/blockchain/service.go

@@ -17,7 +17,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
-	coreTime "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/execution"
@@ -309,13 +308,7 @@ func (s *Service) initializeHeadFromDB(ctx context.Context) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized block")
 	}
-	if err := s.setHead(&head{
-		finalizedRoot,
-		finalizedBlock,
-		finalizedState,
-		finalizedBlock.Block().Slot(),
-		false,
-	}); err != nil {
+	if err := s.setHead(finalizedRoot, finalizedBlock, finalizedState); err != nil {
 		return errors.Wrap(err, "could not set head")
 	}
 
@@ -409,7 +402,7 @@ func (s *Service) initializeBeaconChain(
 	if err := helpers.UpdateCommitteeCache(ctx, genesisState, 0); err != nil {
 		return nil, err
 	}
-	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState, coreTime.CurrentEpoch(genesisState)); err != nil {
+	if err := helpers.UpdateProposerIndicesInCache(ctx, genesisState); err != nil {
 		return nil, err
 	}
 
@@ -447,13 +440,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 	}
 	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
 
-	if err := s.setHead(&head{
-		genesisBlkRoot,
-		genesisBlk,
-		genesisState,
-		genesisBlk.Block().Slot(),
-		false,
-	}); err != nil {
+	if err := s.setHead(genesisBlkRoot, genesisBlk, genesisState); err != nil {
 		log.WithError(err).Fatal("Could not set head")
 	}
 	return nil

beacon-chain/blockchain/service_test.go

@@ -377,7 +377,9 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
+	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, s.insertBlockToForkchoiceStore(ctx, wsb.Block(), r, beaconState))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -451,7 +453,9 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	bs := &ethpb.BeaconState{FinalizedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}, CurrentJustifiedCheckpoint: &ethpb.Checkpoint{Root: make([]byte, 32)}}
 	beaconState, err := state_native.InitializeFromProtoPhase0(bs)
 	require.NoError(b, err)
-	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
+	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	require.NoError(b, err)
+	require.NoError(b, s.insertBlockToForkchoiceStore(ctx, wsb.Block(), r, beaconState))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {

beacon-chain/core/altair/epoch_precompute.go

@@ -13,15 +13,6 @@ import (
 	"go.opencensus.io/trace"
 )
 
-// AttDelta contains rewards and penalties for a single attestation.
-type AttDelta struct {
-	HeadReward    uint64
-	SourceReward  uint64
-	SourcePenalty uint64
-	TargetReward  uint64
-	TargetPenalty uint64
-}
-
 // InitializePrecomputeValidators precomputes individual validator for its attested balances and the total sum of validators attested balances of the epoch.
 func InitializePrecomputeValidators(ctx context.Context, beaconState state.BeaconState) ([]*precompute.Validator, *precompute.Balance, error) {
 	ctx, span := trace.StartSpan(ctx, "altair.InitializePrecomputeValidators")
@@ -235,7 +226,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 		return beaconState, errors.New("validator registries not the same length as state's validator registries")
 	}
 
-	attDeltas, err := AttestationsDelta(beaconState, bal, vals)
+	attsRewards, attsPenalties, err := AttestationsDelta(beaconState, bal, vals)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attestation delta")
 	}
@@ -246,12 +237,11 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 		// Compute the post balance of the validator after accounting for the
 		// attester and proposer rewards and penalties.
-		delta := attDeltas[i]
-		balances[i], err = helpers.IncreaseBalanceWithVal(balances[i], delta.HeadReward+delta.SourceReward+delta.TargetReward)
+		balances[i], err = helpers.IncreaseBalanceWithVal(balances[i], attsRewards[i])
 		if err != nil {
 			return nil, err
 		}
-		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], delta.SourcePenalty+delta.TargetPenalty)
+		balances[i] = helpers.DecreaseBalanceWithVal(balances[i], attsPenalties[i])
 
 		vals[i].AfterEpochTransitionBalance = balances[i]
 	}
@@ -265,8 +255,10 @@ func ProcessRewardsAndPenaltiesPrecompute(
 
 // AttestationsDelta computes and returns the rewards and penalties differences for individual validators based on the
 // voting records.
-func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, vals []*precompute.Validator) ([]*AttDelta, error) {
-	attDeltas := make([]*AttDelta, len(vals))
+func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, vals []*precompute.Validator) (rewards, penalties []uint64, err error) {
+	numOfVals := beaconState.NumValidators()
+	rewards = make([]uint64, numOfVals)
+	penalties = make([]uint64, numOfVals)
 
 	cfg := params.BeaconConfig()
 	prevEpoch := time.PrevEpoch(beaconState)
@@ -280,29 +272,29 @@ func AttestationsDelta(beaconState state.BeaconState, bal *precompute.Balance, v
 	bias := cfg.InactivityScoreBias
 	inactivityPenaltyQuotient, err := beaconState.InactivityPenaltyQuotient()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	inactivityDenominator := bias * inactivityPenaltyQuotient
 
 	for i, v := range vals {
-		attDeltas[i], err = attestationDelta(bal, v, baseRewardMultiplier, inactivityDenominator, leak)
+		rewards[i], penalties[i], err = attestationDelta(bal, v, baseRewardMultiplier, inactivityDenominator, leak)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 	}
 
-	return attDeltas, nil
+	return rewards, penalties, nil
 }
 
 func attestationDelta(
 	bal *precompute.Balance,
 	val *precompute.Validator,
 	baseRewardMultiplier, inactivityDenominator uint64,
-	inactivityLeak bool) (*AttDelta, error) {
+	inactivityLeak bool) (reward, penalty uint64, err error) {
 	eligible := val.IsActivePrevEpoch || (val.IsSlashed && !val.IsWithdrawableCurrentEpoch)
 	// Per spec `ActiveCurrentEpoch` can't be 0 to process attestation delta.
 	if !eligible || bal.ActiveCurrentEpoch == 0 {
-		return &AttDelta{}, nil
+		return 0, 0, nil
 	}
 
 	cfg := params.BeaconConfig()
@@ -315,32 +307,32 @@ func attestationDelta(
 	srcWeight := cfg.TimelySourceWeight
 	tgtWeight := cfg.TimelyTargetWeight
 	headWeight := cfg.TimelyHeadWeight
-	attDelta := &AttDelta{}
+	reward, penalty = uint64(0), uint64(0)
 	// Process source reward / penalty
 	if val.IsPrevEpochSourceAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * srcWeight * (bal.PrevEpochAttested / increment)
-			attDelta.SourceReward += n / (activeIncrement * weightDenominator)
+			reward += n / (activeIncrement * weightDenominator)
 		}
 	} else {
-		attDelta.SourcePenalty += baseReward * srcWeight / weightDenominator
+		penalty += baseReward * srcWeight / weightDenominator
 	}
 
 	// Process target reward / penalty
 	if val.IsPrevEpochTargetAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * tgtWeight * (bal.PrevEpochTargetAttested / increment)
-			attDelta.TargetReward += n / (activeIncrement * weightDenominator)
+			reward += n / (activeIncrement * weightDenominator)
 		}
 	} else {
-		attDelta.TargetPenalty += baseReward * tgtWeight / weightDenominator
+		penalty += baseReward * tgtWeight / weightDenominator
 	}
 
 	// Process head reward / penalty
 	if val.IsPrevEpochHeadAttester && !val.IsSlashed {
 		if !inactivityLeak {
 			n := baseReward * headWeight * (bal.PrevEpochHeadAttested / increment)
-			attDelta.HeadReward += n / (activeIncrement * weightDenominator)
+			reward += n / (activeIncrement * weightDenominator)
 		}
 	}
 
@@ -349,10 +341,10 @@ func attestationDelta(
 	if !val.IsPrevEpochTargetAttester || val.IsSlashed {
 		n, err := math.Mul64(effectiveBalance, val.InactivityScore)
 		if err != nil {
-			return &AttDelta{}, err
+			return 0, 0, err
 		}
-		attDelta.TargetPenalty += n / inactivityDenominator
+		penalty += n / inactivityDenominator
 	}
 
-	return attDelta, nil
+	return reward, penalty, nil
 }

beacon-chain/core/altair/epoch_precompute_test.go

@@ -213,16 +213,9 @@ func TestAttestationsDelta(t *testing.T) {
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	deltas, err := AttestationsDelta(s, balance, validators)
+	rewards, penalties, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
 
-	rewards := make([]uint64, len(deltas))
-	penalties := make([]uint64, len(deltas))
-	for i, d := range deltas {
-		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty
-	}
-
 	// Reward amount should increase as validator index increases due to setup.
 	for i := 1; i < len(rewards); i++ {
 		require.Equal(t, true, rewards[i] > rewards[i-1])
@@ -251,16 +244,9 @@ func TestAttestationsDeltaBellatrix(t *testing.T) {
 	require.NoError(t, err)
 	validators, balance, err = ProcessEpochParticipation(context.Background(), s, balance, validators)
 	require.NoError(t, err)
-	deltas, err := AttestationsDelta(s, balance, validators)
+	rewards, penalties, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
 
-	rewards := make([]uint64, len(deltas))
-	penalties := make([]uint64, len(deltas))
-	for i, d := range deltas {
-		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty
-	}
-
 	// Reward amount should increase as validator index increases due to setup.
 	for i := 1; i < len(rewards); i++ {
 		require.Equal(t, true, rewards[i] > rewards[i-1])
@@ -299,15 +285,8 @@ func TestProcessRewardsAndPenaltiesPrecompute_Ok(t *testing.T) {
 	}
 
 	wanted := make([]uint64, s.NumValidators())
-	deltas, err := AttestationsDelta(s, balance, validators)
+	rewards, penalties, err := AttestationsDelta(s, balance, validators)
 	require.NoError(t, err)
-
-	rewards := make([]uint64, len(deltas))
-	penalties := make([]uint64, len(deltas))
-	for i, d := range deltas {
-		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty
-	}
 	for i := range rewards {
 		wanted[i] += rewards[i]
 	}

beacon-chain/core/helpers/beacon_committee.go

@@ -336,21 +336,20 @@ func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState,
 }
 
 // UpdateProposerIndicesInCache updates proposer indices entry of the committee cache.
-// Input state is used to retrieve active validator indices.
-// Input epoch is the epoch to retrieve proposer indices for.
-func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState, epoch primitives.Epoch) error {
+func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaconState) error {
 	// The cache uses the state root at the (current epoch - 1)'s slot as key. (e.g. for epoch 2, the key is root at slot 63)
 	// Which is the reason why we skip genesis epoch.
-	if epoch <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
+	if time.CurrentEpoch(state) <= params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
 		return nil
 	}
 
 	// Use state root from (current_epoch - 1))
-	s, err := slots.EpochEnd(epoch - 1)
+	wantedEpoch := time.PrevEpoch(state)
+	s, err := slots.EpochEnd(wantedEpoch)
 	if err != nil {
 		return err
 	}
-	r, err := state.StateRootAtIndex(uint64(s % params.BeaconConfig().SlotsPerHistoricalRoot))
+	r, err := StateRootAtSlot(state, s)
 	if err != nil {
 		return err
 	}
@@ -367,11 +366,11 @@ func UpdateProposerIndicesInCache(ctx context.Context, state state.ReadOnlyBeaco
 		return nil
 	}
 
-	indices, err := ActiveValidatorIndices(ctx, state, epoch)
+	indices, err := ActiveValidatorIndices(ctx, state, time.CurrentEpoch(state))
 	if err != nil {
 		return err
 	}
-	proposerIndices, err := precomputeProposerIndices(state, indices, epoch)
+	proposerIndices, err := precomputeProposerIndices(state, indices)
 	if err != nil {
 		return err
 	}
@@ -433,10 +432,11 @@ func computeCommittee(
 
 // This computes proposer indices of the current epoch and returns a list of proposer indices,
 // the index of the list represents the slot number.
-func precomputeProposerIndices(state state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, e primitives.Epoch) ([]primitives.ValidatorIndex, error) {
+func precomputeProposerIndices(state state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex) ([]primitives.ValidatorIndex, error) {
 	hashFunc := hash.CustomSHA256Hasher()
 	proposerIndices := make([]primitives.ValidatorIndex, params.BeaconConfig().SlotsPerEpoch)
 
+	e := time.CurrentEpoch(state)
 	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconProposer)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not generate seed")

beacon-chain/core/helpers/beacon_committee_test.go

@@ -639,7 +639,7 @@ func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	indices, err := ActiveValidatorIndices(context.Background(), state, 0)
 	require.NoError(t, err)
 
-	proposerIndices, err := precomputeProposerIndices(state, indices, time.CurrentEpoch(state))
+	proposerIndices, err := precomputeProposerIndices(state, indices)
 	require.NoError(t, err)
 
 	var wantedProposerIndices []primitives.ValidatorIndex

beacon-chain/core/helpers/validators.go

@@ -262,7 +262,7 @@ func BeaconProposerIndex(ctx context.Context, state state.ReadOnlyBeaconState) (
 				}
 				return proposerIndices[state.Slot()%params.BeaconConfig().SlotsPerEpoch], nil
 			}
-			if err := UpdateProposerIndicesInCache(ctx, state, time.CurrentEpoch(state)); err != nil {
+			if err := UpdateProposerIndicesInCache(ctx, state); err != nil {
 				return 0, errors.Wrap(err, "could not update committee cache")
 			}
 		}

beacon-chain/forkchoice/doubly-linked-tree/forkchoice.go

@@ -39,7 +39,7 @@ func New() *ForkChoice {
 
 	b := make([]uint64, 0)
 	v := make([]Vote, 0)
-	return &ForkChoice{store: s, balances: b, votes: v}
+	return &ForkChoice{store: s, balances: b, votes: v, fcLock: new(fcLock)}
 }
 
 // NodeCount returns the current number of nodes in the Store.

beacon-chain/forkchoice/doubly-linked-tree/types.go

@@ -1,7 +1,11 @@
 package doublylinkedtree
 
 import (
+	"bytes"
+	"runtime/debug"
+	"runtime/pprof"
 	"sync"
+	"time"
 
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v4/beacon-chain/forkchoice/types"
@@ -11,7 +15,7 @@ import (
 
 // ForkChoice defines the overall fork choice store which includes all block nodes, validator's latest votes and balances.
 type ForkChoice struct {
-	sync.RWMutex
+	*fcLock
 	store               *Store
 	votes               []Vote                      // tracks individual validator's last vote.
 	balances            []uint64                    // tracks individual validator's balances last accounted in votes.
@@ -68,3 +72,52 @@ type Vote struct {
 	nextRoot    [fieldparams.RootLength]byte // next voting root.
 	nextEpoch   primitives.Epoch             // epoch of next voting period.
 }
+
+type fcLock struct {
+	lk       sync.RWMutex
+	t        time.Time
+	currChan chan int
+}
+
+func (f *fcLock) Lock() {
+	f.lk.Lock()
+	f.t = time.Now()
+	f.currChan = make(chan int)
+	go func(t time.Time, c chan int) {
+		tim := time.NewTimer(3 * time.Second)
+		select {
+		case <-c:
+			tim.Stop()
+		case <-tim.C:
+			tim.Stop()
+			pfile := pprof.Lookup("goroutine")
+			bf := bytes.NewBuffer([]byte{})
+			err := pfile.WriteTo(bf, 1)
+			_ = err
+			log.Warnf("FC lock is taking longer than 3 seconds with the complete stack of %s", bf.String())
+		}
+	}(time.Now(), f.currChan)
+}
+
+func (f *fcLock) Unlock() {
+	t := time.Since(f.t)
+	f.t = time.Time{}
+	close(f.currChan)
+	f.lk.Unlock()
+	if t > time.Second {
+		log.Warnf("FC lock is taking longer than 1 second: %s with the complete stack of %s", t.String(), string(debug.Stack()))
+	}
+}
+
+func (f *fcLock) RLock() {
+	t := time.Now()
+	f.lk.RLock()
+	dt := time.Since(t)
+	if dt > time.Second {
+		log.Warnf("FC Rlock is taking longer than 1 second: %s with stack %s", dt.String(), string(debug.Stack()))
+	}
+}
+
+func (f *fcLock) RUnlock() {
+	f.lk.RUnlock()
+}

beacon-chain/node/node.go

@@ -230,8 +230,8 @@ func New(cliCtx *cli.Context, opts ...Option) (*BeaconNode, error) {
 		return nil, err
 	}
 
-	log.Debugln("Registering Deterministic Genesis Service")
-	if err := beacon.registerDeterministicGenesisService(); err != nil {
+	log.Debugln("Registering Determinstic Genesis Service")
+	if err := beacon.registerDeterminsticGenesisService(); err != nil {
 		return nil, err
 	}
 
@@ -924,7 +924,7 @@ func (b *BeaconNode) registerGRPCGateway(router *mux.Router) error {
 	return b.services.RegisterService(g)
 }
 
-func (b *BeaconNode) registerDeterministicGenesisService() error {
+func (b *BeaconNode) registerDeterminsticGenesisService() error {
 	genesisTime := b.cliCtx.Uint64(flags.InteropGenesisTimeFlag.Name)
 	genesisValidators := b.cliCtx.Uint64(flags.InteropNumValidatorsFlag.Name)
 
@@ -987,8 +987,7 @@ func (b *BeaconNode) registerBuilderService(cliCtx *cli.Context) error {
 	opts := append(b.serviceFlagOpts.builderOpts,
 		builder.WithHeadFetcher(chainService),
 		builder.WithDatabase(b.db))
-	// make cache the default.
-	if !cliCtx.Bool(features.DisableRegistrationCache.Name) {
+	if cliCtx.Bool(flags.EnableRegistrationCache.Name) {
 		opts = append(opts, builder.WithRegistrationCache())
 	}
 	svc, err := builder.NewService(b.ctx, opts...)

beacon-chain/operations/attestations/BUILD.bazel

@@ -47,7 +47,6 @@ go_test(
     deps = [
         "//async:go_default_library",
         "//beacon-chain/operations/attestations/kv:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//crypto/bls:go_default_library",

beacon-chain/operations/attestations/kv/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
         "//beacon-chain/core/helpers:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/hash:go_default_library",
@@ -40,8 +39,8 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//crypto/bls:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/operations/attestations/kv/aggregated.go

@@ -2,12 +2,9 @@ package kv
 
 import (
 	"context"
-	"runtime"
-	"sync"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v4/config/features"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	attaggregation "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation/aggregation/attestations"
@@ -26,11 +23,21 @@ func (c *AttCaches) AggregateUnaggregatedAttestations(ctx context.Context) error
 	if err != nil {
 		return err
 	}
-	return c.aggregateUnaggregatedAtts(ctx, unaggregatedAtts)
+	return c.aggregateUnaggregatedAttestations(ctx, unaggregatedAtts)
 }
 
-func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedAtts []*ethpb.Attestation) error {
-	_, span := trace.StartSpan(ctx, "operations.attestations.kv.aggregateUnaggregatedAtts")
+// AggregateUnaggregatedAttestationsBySlotIndex aggregates the unaggregated attestations and saves
+// newly aggregated attestations in the pool. Unaggregated attestations are filtered by slot and
+// committee index.
+func (c *AttCaches) AggregateUnaggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) error {
+	ctx, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregateUnaggregatedAttestationsBySlotIndex")
+	defer span.End()
+	unaggregatedAtts := c.UnaggregatedAttestationsBySlotIndex(ctx, slot, committeeIndex)
+	return c.aggregateUnaggregatedAttestations(ctx, unaggregatedAtts)
+}
+
+func (c *AttCaches) aggregateUnaggregatedAttestations(ctx context.Context, unaggregatedAtts []*ethpb.Attestation) error {
+	ctx, span := trace.StartSpan(ctx, "operations.attestations.kv.aggregateUnaggregatedAttestations")
 	defer span.End()
 
 	attsByDataRoot := make(map[[32]byte][]*ethpb.Attestation, len(unaggregatedAtts))
@@ -45,32 +52,26 @@ func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedA
 	// Aggregate unaggregated attestations from the pool and save them in the pool.
 	// Track the unaggregated attestations that aren't able to aggregate.
 	leftOverUnaggregatedAtt := make(map[[32]byte]bool)
-
-	if features.Get().AggregateParallel {
-		leftOverUnaggregatedAtt = c.aggregateParallel(attsByDataRoot, leftOverUnaggregatedAtt)
-	} else {
-		for _, atts := range attsByDataRoot {
-			aggregated, err := attaggregation.AggregateDisjointOneBitAtts(atts)
+	for _, atts := range attsByDataRoot {
+		aggregated, err := attaggregation.AggregateDisjointOneBitAtts(atts)
+		if err != nil {
+			return errors.Wrap(err, "could not aggregate unaggregated attestations")
+		}
+		if aggregated == nil {
+			return errors.New("could not aggregate unaggregated attestations")
+		}
+		if helpers.IsAggregated(aggregated) {
+			if err := c.SaveAggregatedAttestations([]*ethpb.Attestation{aggregated}); err != nil {
+				return err
+			}
+		} else {
+			h, err := hashFn(aggregated)
 			if err != nil {
-				return errors.Wrap(err, "could not aggregate unaggregated attestations")
-			}
-			if aggregated == nil {
-				return errors.New("could not aggregate unaggregated attestations")
-			}
-			if helpers.IsAggregated(aggregated) {
-				if err := c.SaveAggregatedAttestations([]*ethpb.Attestation{aggregated}); err != nil {
-					return err
-				}
-			} else {
-				h, err := hashFn(aggregated)
-				if err != nil {
-					return err
-				}
-				leftOverUnaggregatedAtt[h] = true
+				return err
 			}
+			leftOverUnaggregatedAtt[h] = true
 		}
 	}
-
 	// Remove the unaggregated attestations from the pool that were successfully aggregated.
 	for _, att := range unaggregatedAtts {
 		h, err := hashFn(att)
@@ -87,58 +88,6 @@ func (c *AttCaches) aggregateUnaggregatedAtts(ctx context.Context, unaggregatedA
 	return nil
 }
 
-// aggregateParallel aggregates attestations in parallel for `atts` and saves them in the pool,
-// returns the unaggregated attestations that weren't able to aggregate.
-// Given `n` CPU cores, it creates a channel of size `n` and spawns `n` goroutines to aggregate attestations
-func (c *AttCaches) aggregateParallel(atts map[[32]byte][]*ethpb.Attestation, leftOver map[[32]byte]bool) map[[32]byte]bool {
-	var leftoverLock sync.Mutex
-	wg := sync.WaitGroup{}
-
-	n := runtime.GOMAXPROCS(0) // defaults to the value of runtime.NumCPU
-	ch := make(chan []*ethpb.Attestation, n)
-	wg.Add(n)
-	for i := 0; i < n; i++ {
-		go func() {
-			defer wg.Done()
-			for as := range ch {
-				aggregated, err := attaggregation.AggregateDisjointOneBitAtts(as)
-				if err != nil {
-					log.WithError(err).Error("could not aggregate unaggregated attestations")
-					continue
-				}
-				if aggregated == nil {
-					log.Error("nil aggregated attestation")
-					continue
-				}
-				if helpers.IsAggregated(aggregated) {
-					if err := c.SaveAggregatedAttestations([]*ethpb.Attestation{aggregated}); err != nil {
-						log.WithError(err).Error("could not save aggregated attestation")
-						continue
-					}
-				} else {
-					h, err := hashFn(aggregated)
-					if err != nil {
-						log.WithError(err).Error("could not hash attestation")
-						continue
-					}
-					leftoverLock.Lock()
-					leftOver[h] = true
-					leftoverLock.Unlock()
-				}
-			}
-		}()
-	}
-
-	for _, as := range atts {
-		ch <- as
-	}
-
-	close(ch)
-	wg.Wait()
-
-	return leftOver
-}
-
 // SaveAggregatedAttestation saves an aggregated attestation in cache.
 func (c *AttCaches) SaveAggregatedAttestation(att *ethpb.Attestation) error {
 	if err := helpers.ValidateNilAttestation(att); err != nil {
@@ -216,7 +165,7 @@ func (c *AttCaches) AggregatedAttestations() []*ethpb.Attestation {
 // AggregatedAttestationsBySlotIndex returns the aggregated attestations in cache,
 // filtered by committee index and slot.
 func (c *AttCaches) AggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.Attestation {
-	_, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregatedAttestationsBySlotIndex")
+	ctx, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregatedAttestationsBySlotIndex")
 	defer span.End()
 
 	atts := make([]*ethpb.Attestation, 0)

beacon-chain/operations/attestations/kv/aggregated_test.go

@@ -9,7 +9,7 @@ import (
 	"github.com/pkg/errors"
 	fssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v4/config/features"
+	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
@@ -18,11 +18,6 @@ import (
 )
 
 func TestKV_Aggregated_AggregateUnaggregatedAttestations(t *testing.T) {
-	resetFn := features.InitWithReset(&features.Flags{
-		AggregateParallel: true,
-	})
-	defer resetFn()
-
 	cache := NewAttCaches()
 	priv, err := bls.RandKey()
 	require.NoError(t, err)
@@ -44,6 +39,61 @@ func TestKV_Aggregated_AggregateUnaggregatedAttestations(t *testing.T) {
 	require.Equal(t, 1, len(cache.AggregatedAttestationsBySlotIndex(context.Background(), 2, 0)), "Did not aggregate correctly")
 }
 
+func TestKV_Aggregated_AggregateUnaggregatedAttestationsBySlotIndex(t *testing.T) {
+	cache := NewAttCaches()
+	genData := func(slot primitives.Slot, committeeIndex primitives.CommitteeIndex) *ethpb.AttestationData {
+		return util.HydrateAttestationData(&ethpb.AttestationData{
+			Slot:           slot,
+			CommitteeIndex: committeeIndex,
+		})
+	}
+	genSign := func() []byte {
+		priv, err := bls.RandKey()
+		require.NoError(t, err)
+		return priv.Sign([]byte{'a'}).Marshal()
+	}
+
+	atts := []*ethpb.Attestation{
+		// The first slot.
+		{AggregationBits: bitfield.Bitlist{0b1001}, Data: genData(1, 2), Signature: genSign()},
+		{AggregationBits: bitfield.Bitlist{0b1010}, Data: genData(1, 2), Signature: genSign()},
+		{AggregationBits: bitfield.Bitlist{0b1100}, Data: genData(1, 2), Signature: genSign()},
+		{AggregationBits: bitfield.Bitlist{0b1001}, Data: genData(1, 3), Signature: genSign()},
+		{AggregationBits: bitfield.Bitlist{0b1100}, Data: genData(1, 3), Signature: genSign()},
+		// The second slot.
+		{AggregationBits: bitfield.Bitlist{0b1001}, Data: genData(2, 3), Signature: genSign()},
+		{AggregationBits: bitfield.Bitlist{0b1010}, Data: genData(2, 3), Signature: genSign()},
+		{AggregationBits: bitfield.Bitlist{0b1100}, Data: genData(2, 4), Signature: genSign()},
+	}
+	ctx := context.Background()
+
+	// Make sure that no error is produced if aggregation is requested on empty unaggregated list.
+	require.NoError(t, cache.AggregateUnaggregatedAttestationsBySlotIndex(ctx, 1, 2))
+	require.NoError(t, cache.AggregateUnaggregatedAttestationsBySlotIndex(ctx, 2, 3))
+	require.Equal(t, 0, len(cache.UnaggregatedAttestationsBySlotIndex(ctx, 1, 2)))
+	require.Equal(t, 0, len(cache.AggregatedAttestationsBySlotIndex(ctx, 1, 2)), "Did not aggregate correctly")
+	require.Equal(t, 0, len(cache.UnaggregatedAttestationsBySlotIndex(ctx, 1, 3)))
+	require.Equal(t, 0, len(cache.AggregatedAttestationsBySlotIndex(ctx, 1, 3)), "Did not aggregate correctly")
+
+	// Persist unaggregated attestations, and aggregate on per slot/committee index base.
+	require.NoError(t, cache.SaveUnaggregatedAttestations(atts))
+	require.NoError(t, cache.AggregateUnaggregatedAttestationsBySlotIndex(ctx, 1, 2))
+	require.NoError(t, cache.AggregateUnaggregatedAttestationsBySlotIndex(ctx, 2, 3))
+
+	// Committee attestations at a slot should be aggregated.
+	require.Equal(t, 0, len(cache.UnaggregatedAttestationsBySlotIndex(ctx, 1, 2)))
+	require.Equal(t, 1, len(cache.AggregatedAttestationsBySlotIndex(ctx, 1, 2)), "Did not aggregate correctly")
+	// Committee attestations haven't been aggregated.
+	require.Equal(t, 2, len(cache.UnaggregatedAttestationsBySlotIndex(ctx, 1, 3)))
+	require.Equal(t, 0, len(cache.AggregatedAttestationsBySlotIndex(ctx, 1, 3)), "Did not aggregate correctly")
+	// Committee at a second slot is aggregated.
+	require.Equal(t, 0, len(cache.UnaggregatedAttestationsBySlotIndex(ctx, 2, 3)))
+	require.Equal(t, 1, len(cache.AggregatedAttestationsBySlotIndex(ctx, 2, 3)), "Did not aggregate correctly")
+	// The second committee at second slot is not aggregated.
+	require.Equal(t, 1, len(cache.UnaggregatedAttestationsBySlotIndex(ctx, 2, 4)))
+	require.Equal(t, 0, len(cache.AggregatedAttestationsBySlotIndex(ctx, 2, 4)), "Did not aggregate correctly")
+}
+
 func TestKV_Aggregated_SaveAggregatedAttestation(t *testing.T) {
 	tests := []struct {
 		name          string

beacon-chain/operations/attestations/pool.go

@@ -15,6 +15,7 @@ import (
 type Pool interface {
 	// For Aggregated attestations
 	AggregateUnaggregatedAttestations(ctx context.Context) error
+	AggregateUnaggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) error
 	SaveAggregatedAttestation(att *ethpb.Attestation) error
 	SaveAggregatedAttestations(atts []*ethpb.Attestation) error
 	AggregatedAttestations() []*ethpb.Attestation

beacon-chain/operations/attestations/prepare_forkchoice_test.go

@@ -7,7 +7,6 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v4/config/features"
 	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	attaggregation "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1/attestation/aggregation/attestations"
@@ -18,11 +17,6 @@ import (
 )
 
 func TestBatchAttestations_Multiple(t *testing.T) {
-	resetFn := features.InitWithReset(&features.Flags{
-		AggregateParallel: true,
-	})
-	defer resetFn()
-
 	s, err := NewService(context.Background(), &Config{Pool: NewPool()})
 	require.NoError(t, err)
 

beacon-chain/rpc/BUILD.bazel

@@ -25,7 +25,6 @@ go_library(
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/rpc/eth/beacon:go_default_library",
-        "//beacon-chain/rpc/eth/builder:go_default_library",
         "//beacon-chain/rpc/eth/debug:go_default_library",
         "//beacon-chain/rpc/eth/events:go_default_library",
         "//beacon-chain/rpc/eth/node:go_default_library",

beacon-chain/rpc/eth/builder/BUILD.bazel

@@ -1,48 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "handlers.go",
-        "server.go",
-        "structs.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/builder",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/rpc/lookup:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//network:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["handlers_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/blockchain/testing:go_default_library",
-        "//beacon-chain/rpc/testutil:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//network:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_gorilla_mux//:go_default_library",
-    ],
-)

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

@@ -1,131 +0,0 @@
-package builder
-
-import (
-	"fmt"
-	"net/http"
-	"strconv"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/v4/config/params"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v4/network"
-	enginev1 "github.com/prysmaticlabs/prysm/v4/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/v4/time/slots"
-)
-
-// ExpectedWithdrawals get the withdrawals computed from the specified state, that will be included in the block that gets built on the specified state.
-func (s *Server) ExpectedWithdrawals(w http.ResponseWriter, r *http.Request) {
-	// Retrieve beacon state
-	stateId := mux.Vars(r)["state_id"]
-	if stateId == "" {
-		network.WriteError(w, &network.DefaultErrorJson{
-			Message: "state_id is required in URL params",
-			Code:    http.StatusBadRequest,
-		})
-		return
-	}
-	st, err := s.Stater.State(r.Context(), []byte(stateId))
-	if err != nil {
-		network.WriteError(w, handleWrapError(err, "could not retrieve state", http.StatusNotFound))
-		return
-	}
-	queryParam := r.URL.Query().Get("proposal_slot")
-	var proposalSlot primitives.Slot
-	if queryParam != "" {
-		pSlot, err := strconv.ParseUint(queryParam, 10, 64)
-		if err != nil {
-			network.WriteError(w, handleWrapError(err, "invalid proposal slot value", http.StatusBadRequest))
-			return
-		}
-		proposalSlot = primitives.Slot(pSlot)
-	} else {
-		proposalSlot = st.Slot() + 1
-	}
-	// Perform sanity checks on proposal slot before computing state
-	capellaStart, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
-	if err != nil {
-		network.WriteError(w, handleWrapError(err, "could not calculate Capella start slot", http.StatusInternalServerError))
-		return
-	}
-	if proposalSlot < capellaStart {
-		network.WriteError(w, &network.DefaultErrorJson{
-			Message: "expected withdrawals are not supported before Capella fork",
-			Code:    http.StatusBadRequest,
-		})
-		return
-	}
-	if proposalSlot <= st.Slot() {
-		network.WriteError(w, &network.DefaultErrorJson{
-			Message: fmt.Sprintf("proposal slot must be bigger than state slot. proposal slot: %d, state slot: %d", proposalSlot, st.Slot()),
-			Code:    http.StatusBadRequest,
-		})
-		return
-	}
-	lookAheadLimit := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().MaxSeedLookahead)))
-	if st.Slot().Add(lookAheadLimit) <= proposalSlot {
-		network.WriteError(w, &network.DefaultErrorJson{
-			Message: fmt.Sprintf("proposal slot cannot be >= %d slots ahead of state slot", lookAheadLimit),
-			Code:    http.StatusBadRequest,
-		})
-		return
-	}
-	// Get metadata for response
-	isOptimistic, err := s.OptimisticModeFetcher.IsOptimistic(r.Context())
-	if err != nil {
-		network.WriteError(w, handleWrapError(err, "could not get optimistic mode info", http.StatusInternalServerError))
-		return
-	}
-	root, err := helpers.BlockRootAtSlot(st, st.Slot()-1)
-	if err != nil {
-		network.WriteError(w, handleWrapError(err, "could not get block root", http.StatusInternalServerError))
-		return
-	}
-	var blockRoot = [32]byte(root)
-	isFinalized := s.FinalizationFetcher.IsFinalized(r.Context(), blockRoot)
-	// Advance state forward to proposal slot
-	st, err = transition.ProcessSlots(r.Context(), st, proposalSlot)
-	if err != nil {
-		network.WriteError(w, &network.DefaultErrorJson{
-			Message: "could not process slots",
-			Code:    http.StatusInternalServerError,
-		})
-		return
-	}
-	withdrawals, err := st.ExpectedWithdrawals()
-	if err != nil {
-		network.WriteError(w, &network.DefaultErrorJson{
-			Message: "could not get expected withdrawals",
-			Code:    http.StatusInternalServerError,
-		})
-		return
-	}
-	network.WriteJson(w, &ExpectedWithdrawalsResponse{
-		ExecutionOptimistic: isOptimistic,
-		Finalized:           isFinalized,
-		Data:                buildExpectedWithdrawalsData(withdrawals),
-	})
-}
-
-func buildExpectedWithdrawalsData(withdrawals []*enginev1.Withdrawal) []*ExpectedWithdrawal {
-	data := make([]*ExpectedWithdrawal, len(withdrawals))
-	for i, withdrawal := range withdrawals {
-		data[i] = &ExpectedWithdrawal{
-			Address:        hexutil.Encode(withdrawal.Address),
-			Amount:         strconv.FormatUint(withdrawal.Amount, 10),
-			Index:          strconv.FormatUint(withdrawal.Index, 10),
-			ValidatorIndex: strconv.FormatUint(uint64(withdrawal.ValidatorIndex), 10),
-		}
-	}
-	return data
-}
-
-func handleWrapError(err error, message string, code int) *network.DefaultErrorJson {
-	return &network.DefaultErrorJson{
-		Message: errors.Wrapf(err, message).Error(),
-		Code:    code,
-	}
-}

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

@@ -1,210 +0,0 @@
-package builder
-
-import (
-	"bytes"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"strconv"
-	"testing"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/gorilla/mux"
-	mock "github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/testutil"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v4/config/params"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
-	"github.com/prysmaticlabs/prysm/v4/network"
-	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v4/testing/assert"
-	"github.com/prysmaticlabs/prysm/v4/testing/require"
-	"github.com/prysmaticlabs/prysm/v4/testing/util"
-	"github.com/prysmaticlabs/prysm/v4/time/slots"
-)
-
-func TestExpectedWithdrawals_BadRequest(t *testing.T) {
-	st, err := util.NewBeaconStateCapella()
-	slotsAhead := 5000
-	require.NoError(t, err)
-	capellaSlot, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
-	require.NoError(t, err)
-	currentSlot := capellaSlot + primitives.Slot(slotsAhead)
-	require.NoError(t, st.SetSlot(currentSlot))
-	mockChainService := &mock.ChainService{Optimistic: true}
-
-	testCases := []struct {
-		name         string
-		path         string
-		urlParams    map[string]string
-		state        state.BeaconState
-		errorMessage string
-	}{
-		{
-			name: "no state_id url params",
-			path: "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot" +
-				strconv.FormatUint(uint64(currentSlot), 10),
-			urlParams:    map[string]string{},
-			state:        nil,
-			errorMessage: "state_id is required in URL params",
-		},
-		{
-			name:         "invalid proposal slot value",
-			path:         "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot=aaa",
-			urlParams:    map[string]string{"state_id": "head"},
-			state:        st,
-			errorMessage: "invalid proposal slot value",
-		},
-		{
-			name: "proposal slot < Capella start slot",
-			path: "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot=" +
-				strconv.FormatUint(uint64(capellaSlot)-1, 10),
-			urlParams:    map[string]string{"state_id": "head"},
-			state:        st,
-			errorMessage: "expected withdrawals are not supported before Capella fork",
-		},
-		{
-			name: "proposal slot == Capella start slot",
-			path: "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot=" +
-				strconv.FormatUint(uint64(capellaSlot), 10),
-			urlParams:    map[string]string{"state_id": "head"},
-			state:        st,
-			errorMessage: "proposal slot must be bigger than state slot",
-		},
-		{
-			name: "Proposal slot >= 128 slots ahead of state slot",
-			path: "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot=" +
-				strconv.FormatUint(uint64(currentSlot+128), 10),
-			urlParams:    map[string]string{"state_id": "head"},
-			state:        st,
-			errorMessage: "proposal slot cannot be >= 128 slots ahead of state slot",
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			s := &Server{
-				FinalizationFetcher:   mockChainService,
-				OptimisticModeFetcher: mockChainService,
-				Stater:                &testutil.MockStater{BeaconState: testCase.state},
-			}
-			request := httptest.NewRequest("GET", testCase.path, nil)
-			request = mux.SetURLVars(request, testCase.urlParams)
-			writer := httptest.NewRecorder()
-			writer.Body = &bytes.Buffer{}
-
-			s.ExpectedWithdrawals(writer, request)
-			assert.Equal(t, http.StatusBadRequest, writer.Code)
-			e := &network.DefaultErrorJson{}
-			require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-			assert.Equal(t, http.StatusBadRequest, e.Code)
-			assert.StringContains(t, testCase.errorMessage, e.Message)
-		})
-	}
-}
-
-func TestExpectedWithdrawals(t *testing.T) {
-	st, err := util.NewBeaconStateCapella()
-	slotsAhead := 5000
-	require.NoError(t, err)
-	capellaSlot, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
-	require.NoError(t, err)
-	currentSlot := capellaSlot + primitives.Slot(slotsAhead)
-	require.NoError(t, st.SetSlot(currentSlot))
-	mockChainService := &mock.ChainService{Optimistic: true}
-
-	t.Run("get correct expected withdrawals", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig().Copy()
-		cfg.MaxValidatorsPerWithdrawalsSweep = 16
-		params.OverrideBeaconConfig(cfg)
-
-		// Update state with updated validator fields
-		valCount := 17
-		validators := make([]*eth.Validator, 0, valCount)
-		balances := make([]uint64, 0, valCount)
-		for i := 0; i < valCount; i++ {
-			blsKey, err := bls.RandKey()
-			require.NoError(t, err)
-			val := &eth.Validator{
-				PublicKey:             blsKey.PublicKey().Marshal(),
-				WithdrawalCredentials: make([]byte, 32),
-				ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-				WithdrawableEpoch:     params.BeaconConfig().FarFutureEpoch,
-				EffectiveBalance:      params.BeaconConfig().MaxEffectiveBalance,
-			}
-			val.WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-			validators = append(validators, val)
-			balances = append(balances, params.BeaconConfig().MaxEffectiveBalance)
-		}
-
-		epoch := slots.ToEpoch(st.Slot())
-		// Fully withdrawable now with more than 0 balance
-		validators[5].WithdrawableEpoch = epoch
-		// Fully withdrawable now but 0 balance
-		validators[10].WithdrawableEpoch = epoch
-		balances[10] = 0
-		// Partially withdrawable now but fully withdrawable after 1 epoch
-		validators[14].WithdrawableEpoch = epoch + 1
-		balances[14] += params.BeaconConfig().MinDepositAmount
-		// Partially withdrawable
-		validators[15].WithdrawableEpoch = epoch + 2
-		balances[15] += params.BeaconConfig().MinDepositAmount
-		// Above sweep bound
-		validators[16].WithdrawableEpoch = epoch + 1
-		balances[16] += params.BeaconConfig().MinDepositAmount
-
-		require.NoError(t, st.SetValidators(validators))
-		require.NoError(t, st.SetBalances(balances))
-		inactivityScores := make([]uint64, valCount)
-		for i := range inactivityScores {
-			inactivityScores[i] = 10
-		}
-		require.NoError(t, st.SetInactivityScores(inactivityScores))
-
-		s := &Server{
-			FinalizationFetcher:   mockChainService,
-			OptimisticModeFetcher: mockChainService,
-			Stater:                &testutil.MockStater{BeaconState: st},
-		}
-		request := httptest.NewRequest(
-			"GET", "/eth/v1/builder/states/{state_id}/expected_withdrawals?proposal_slot="+
-				strconv.FormatUint(uint64(currentSlot+params.BeaconConfig().SlotsPerEpoch), 10), nil)
-		request = mux.SetURLVars(request, map[string]string{"state_id": "head"})
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.ExpectedWithdrawals(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &ExpectedWithdrawalsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, true, resp.ExecutionOptimistic)
-		assert.Equal(t, false, resp.Finalized)
-		assert.Equal(t, 3, len(resp.Data))
-		expectedWithdrawal1 := &ExpectedWithdrawal{
-			Index:          strconv.FormatUint(0, 10),
-			ValidatorIndex: strconv.FormatUint(5, 10),
-			Address:        hexutil.Encode(validators[5].WithdrawalCredentials[12:]),
-			// Decreased due to epoch processing when state advanced forward
-			Amount: strconv.FormatUint(31998257885, 10),
-		}
-		expectedWithdrawal2 := &ExpectedWithdrawal{
-			Index:          strconv.FormatUint(1, 10),
-			ValidatorIndex: strconv.FormatUint(14, 10),
-			Address:        hexutil.Encode(validators[14].WithdrawalCredentials[12:]),
-			// MaxEffectiveBalance + MinDepositAmount + decrease after epoch processing
-			Amount: strconv.FormatUint(32998257885, 10),
-		}
-		expectedWithdrawal3 := &ExpectedWithdrawal{
-			Index:          strconv.FormatUint(2, 10),
-			ValidatorIndex: strconv.FormatUint(15, 10),
-			Address:        hexutil.Encode(validators[15].WithdrawalCredentials[12:]),
-			// MinDepositAmount + decrease after epoch processing
-			Amount: strconv.FormatUint(998257885, 10),
-		}
-		require.DeepEqual(t, expectedWithdrawal1, resp.Data[0])
-		require.DeepEqual(t, expectedWithdrawal2, resp.Data[1])
-		require.DeepEqual(t, expectedWithdrawal3, resp.Data[2])
-	})
-}

beacon-chain/rpc/eth/builder/server.go

@@ -1,12 +0,0 @@
-package builder
-
-import (
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/blockchain"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/lookup"
-)
-
-type Server struct {
-	FinalizationFetcher   blockchain.FinalizationFetcher
-	OptimisticModeFetcher blockchain.OptimisticModeFetcher
-	Stater                lookup.Stater
-}

beacon-chain/rpc/eth/builder/structs.go

@@ -1,14 +0,0 @@
-package builder
-
-type ExpectedWithdrawalsResponse struct {
-	Data                []*ExpectedWithdrawal `json:"data"`
-	ExecutionOptimistic bool                  `json:"execution_optimistic"`
-	Finalized           bool                  `json:"finalized"`
-}
-
-type ExpectedWithdrawal struct {
-	Address        string `json:"address" hex:"true"`
-	Amount         string `json:"amount"`
-	Index          string `json:"index"`
-	ValidatorIndex string `json:"validator_index"`
-}

beacon-chain/rpc/eth/rewards/BUILD.bazel

@@ -13,21 +13,14 @@ go_library(
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
-        "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
-        "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//network:go_default_library",
         "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_wealdtech_go_bytesutil//:go_default_library",
     ],
 )
 
@@ -40,7 +33,6 @@ go_test(
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
-        "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen/mock:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

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

@@ -1,8 +1,6 @@
 package rewards
 
 import (
-	"encoding/json"
-	"fmt"
 	"net/http"
 	"strconv"
 	"strings"
@@ -10,19 +8,12 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/altair"
 	coreblocks "github.com/prysmaticlabs/prysm/v4/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/lookup"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v4/config/params"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/network"
 	"github.com/prysmaticlabs/prysm/v4/runtime/version"
-	"github.com/prysmaticlabs/prysm/v4/time/slots"
-	"github.com/wealdtech/go-bytesutil"
 )
 
 // BlockRewards is an HTTP handler for Beacon API getBlockRewards.
@@ -37,7 +28,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	}
 	if blk.Version() == version.Phase0 {
 		errJson := &network.DefaultErrorJson{
-			Message: "Block rewards are not supported for Phase 0 blocks",
+			Message: "block rewards are not supported for Phase 0 blocks",
 			Code:    http.StatusBadRequest,
 		}
 		network.WriteError(w, errJson)
@@ -50,7 +41,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	st, err := s.ReplayerBuilder.ReplayerForSlot(blk.Block().Slot()-1).ReplayToSlot(r.Context(), blk.Block().Slot())
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get state: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get state").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -61,7 +52,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	initBalance, err := st.BalanceAtIndex(proposerIndex)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get proposer's balance: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get proposer's balance").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -70,7 +61,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	st, err = altair.ProcessAttestationsNoVerifySignature(r.Context(), st, blk)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get attestation rewards" + err.Error(),
+			Message: errors.Wrapf(err, "could not get attestation rewards").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -79,7 +70,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	attBalance, err := st.BalanceAtIndex(proposerIndex)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get proposer's balance: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get proposer's balance").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -88,7 +79,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	st, err = coreblocks.ProcessAttesterSlashings(r.Context(), st, blk.Block().Body().AttesterSlashings(), validators.SlashValidator)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get attester slashing rewards: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get attester slashing rewards").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -97,7 +88,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	attSlashingsBalance, err := st.BalanceAtIndex(proposerIndex)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get proposer's balance: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get proposer's balance").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -106,7 +97,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	st, err = coreblocks.ProcessProposerSlashings(r.Context(), st, blk.Block().Body().ProposerSlashings(), validators.SlashValidator)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get proposer slashing rewards" + err.Error(),
+			Message: errors.Wrapf(err, "could not get proposer slashing rewards").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -115,7 +106,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	proposerSlashingsBalance, err := st.BalanceAtIndex(proposerIndex)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get proposer's balance: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get proposer's balance").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -124,7 +115,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	sa, err := blk.Block().Body().SyncAggregate()
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get sync aggregate: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get sync aggregate").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -134,7 +125,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	_, syncCommitteeReward, err = altair.ProcessSyncAggregate(r.Context(), st, sa)
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get sync aggregate rewards: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get sync aggregate rewards").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -144,7 +135,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	optimistic, err := s.OptimisticModeFetcher.IsOptimistic(r.Context())
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get optimistic mode info: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get optimistic mode info").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -153,7 +144,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	blkRoot, err := blk.Block().HashTreeRoot()
 	if err != nil {
 		errJson := &network.DefaultErrorJson{
-			Message: "Could not get block root: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get block root").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 		network.WriteError(w, errJson)
@@ -161,7 +152,7 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	}
 
 	response := &BlockRewardsResponse{
-		Data: BlockRewards{
+		Data: &BlockRewards{
 			ProposerIndex:     strconv.FormatUint(uint64(proposerIndex), 10),
 			Total:             strconv.FormatUint(proposerSlashingsBalance-initBalance+syncCommitteeReward, 10),
 			Attestations:      strconv.FormatUint(attBalance-initBalance, 10),
@@ -175,300 +166,22 @@ func (s *Server) BlockRewards(w http.ResponseWriter, r *http.Request) {
 	network.WriteJson(w, response)
 }
 
-// AttestationRewards retrieves attestation reward info for validators specified by array of public keys or validator index.
-// If no array is provided, return reward info for every validator.
-// TODO: Inclusion delay
-func (s *Server) AttestationRewards(w http.ResponseWriter, r *http.Request) {
-	st, ok := s.attRewardsState(w, r)
-	if !ok {
-		return
-	}
-	bal, vals, valIndices, ok := attRewardsBalancesAndVals(w, r, st)
-	if !ok {
-		return
-	}
-	totalRewards, ok := totalAttRewards(w, st, bal, vals, valIndices)
-	if !ok {
-		return
-	}
-	idealRewards, ok := idealAttRewards(w, st, bal, vals)
-	if !ok {
-		return
-	}
-
-	optimistic, err := s.OptimisticModeFetcher.IsOptimistic(r.Context())
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not get optimistic mode info: " + err.Error(),
-			Code:    http.StatusInternalServerError,
-		}
-		network.WriteError(w, errJson)
-		return
-	}
-	blkRoot, err := st.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not get block root: " + err.Error(),
-			Code:    http.StatusInternalServerError,
-		}
-		network.WriteError(w, errJson)
-		return
-	}
-
-	resp := &AttestationRewardsResponse{
-		Data: AttestationRewards{
-			IdealRewards: idealRewards,
-			TotalRewards: totalRewards,
-		},
-		ExecutionOptimistic: optimistic,
-		Finalized:           s.FinalizationFetcher.IsFinalized(r.Context(), blkRoot),
-	}
-	network.WriteJson(w, resp)
-}
-
-func (s *Server) attRewardsState(w http.ResponseWriter, r *http.Request) (state.BeaconState, bool) {
-	segments := strings.Split(r.URL.Path, "/")
-	requestedEpoch, err := strconv.ParseUint(segments[len(segments)-1], 10, 64)
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not decode epoch: " + err.Error(),
-			Code:    http.StatusBadRequest,
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	if primitives.Epoch(requestedEpoch) < params.BeaconConfig().AltairForkEpoch {
-		errJson := &network.DefaultErrorJson{
-			Message: "Attestation rewards are not supported for Phase 0",
-			Code:    http.StatusNotFound,
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	currentEpoch := uint64(slots.ToEpoch(s.TimeFetcher.CurrentSlot()))
-	if requestedEpoch+1 >= currentEpoch {
-		errJson := &network.DefaultErrorJson{
-			Code:    http.StatusNotFound,
-			Message: "Attestation rewards are available after two epoch transitions to ensure all attestations have a chance of inclusion",
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	nextEpochEnd, err := slots.EpochEnd(primitives.Epoch(requestedEpoch + 1))
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not get next epoch's ending slot: " + err.Error(),
-			Code:    http.StatusInternalServerError,
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	st, err := s.Stater.StateBySlot(r.Context(), nextEpochEnd)
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not get state for epoch's starting slot: " + err.Error(),
-			Code:    http.StatusInternalServerError,
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	return st, true
-}
-
-func attRewardsBalancesAndVals(
-	w http.ResponseWriter,
-	r *http.Request,
-	st state.BeaconState,
-) (*precompute.Balance, []*precompute.Validator, []primitives.ValidatorIndex, bool) {
-	allVals, bal, err := altair.InitializePrecomputeValidators(r.Context(), st)
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not initialize precompute validators: " + err.Error(),
-			Code:    http.StatusBadRequest,
-		}
-		network.WriteError(w, errJson)
-		return nil, nil, nil, false
-	}
-	allVals, bal, err = altair.ProcessEpochParticipation(r.Context(), st, bal, allVals)
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not process epoch participation: " + err.Error(),
-			Code:    http.StatusBadRequest,
-		}
-		network.WriteError(w, errJson)
-		return nil, nil, nil, false
-	}
-	var rawValIds []string
-	if r.Body != http.NoBody {
-		if err = json.NewDecoder(r.Body).Decode(&rawValIds); err != nil {
-			errJson := &network.DefaultErrorJson{
-				Message: "Could not decode validators: " + err.Error(),
-				Code:    http.StatusBadRequest,
-			}
-			network.WriteError(w, errJson)
-			return nil, nil, nil, false
-		}
-	}
-	valIndices := make([]primitives.ValidatorIndex, len(rawValIds))
-	for i, v := range rawValIds {
-		index, err := strconv.ParseUint(v, 10, 64)
-		if err != nil {
-			pubkey, err := bytesutil.FromHexString(v)
-			if err != nil || len(pubkey) != fieldparams.BLSPubkeyLength {
-				errJson := &network.DefaultErrorJson{
-					Message: fmt.Sprintf("%s is not a validator index or pubkey", v),
-					Code:    http.StatusBadRequest,
-				}
-				network.WriteError(w, errJson)
-				return nil, nil, nil, false
-			}
-			var ok bool
-			valIndices[i], ok = st.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubkey))
-			if !ok {
-				errJson := &network.DefaultErrorJson{
-					Message: fmt.Sprintf("No validator index found for pubkey %#x", pubkey),
-					Code:    http.StatusBadRequest,
-				}
-				network.WriteError(w, errJson)
-				return nil, nil, nil, false
-			}
-		} else {
-			if index >= uint64(st.NumValidators()) {
-				errJson := &network.DefaultErrorJson{
-					Message: fmt.Sprintf("Validator index %d is too large. Maximum allowed index is %d", index, st.NumValidators()-1),
-					Code:    http.StatusBadRequest,
-				}
-				network.WriteError(w, errJson)
-				return nil, nil, nil, false
-			}
-			valIndices[i] = primitives.ValidatorIndex(index)
-		}
-	}
-	if len(valIndices) == 0 {
-		valIndices = make([]primitives.ValidatorIndex, len(allVals))
-		for i := 0; i < len(allVals); i++ {
-			valIndices[i] = primitives.ValidatorIndex(i)
-		}
-	}
-	if len(valIndices) == len(allVals) {
-		return bal, allVals, valIndices, true
-	} else {
-		filteredVals := make([]*precompute.Validator, len(valIndices))
-		for i, valIx := range valIndices {
-			filteredVals[i] = allVals[valIx]
-		}
-		return bal, filteredVals, valIndices, true
-	}
-}
-
-// idealAttRewards returns rewards for hypothetical, perfectly voting validators
-// whose effective balances are over EJECTION_BALANCE and match balances in passed in validators.
-func idealAttRewards(
-	w http.ResponseWriter,
-	st state.BeaconState,
-	bal *precompute.Balance,
-	vals []*precompute.Validator,
-) ([]IdealAttestationReward, bool) {
-	idealValsCount := uint64(16)
-	minIdealBalance := uint64(17)
-	maxIdealBalance := minIdealBalance + idealValsCount - 1
-	idealRewards := make([]IdealAttestationReward, 0, idealValsCount)
-	idealVals := make([]*precompute.Validator, 0, idealValsCount)
-	increment := params.BeaconConfig().EffectiveBalanceIncrement
-	for i := minIdealBalance; i <= maxIdealBalance; i++ {
-		for _, v := range vals {
-			if v.CurrentEpochEffectiveBalance/1e9 == i {
-				effectiveBalance := i * increment
-				idealVals = append(idealVals, &precompute.Validator{
-					IsActivePrevEpoch:            true,
-					IsSlashed:                    false,
-					CurrentEpochEffectiveBalance: effectiveBalance,
-					IsPrevEpochSourceAttester:    true,
-					IsPrevEpochTargetAttester:    true,
-					IsPrevEpochHeadAttester:      true,
-				})
-				idealRewards = append(idealRewards, IdealAttestationReward{EffectiveBalance: strconv.FormatUint(effectiveBalance, 10)})
-				break
-			}
-		}
-	}
-	deltas, err := altair.AttestationsDelta(st, bal, idealVals)
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not get attestations delta: " + err.Error(),
-			Code:    http.StatusInternalServerError,
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	for i, d := range deltas {
-		idealRewards[i].Head = strconv.FormatUint(d.HeadReward, 10)
-		if d.SourcePenalty > 0 {
-			idealRewards[i].Source = fmt.Sprintf("-%s", strconv.FormatUint(d.SourcePenalty, 10))
-		} else {
-			idealRewards[i].Source = strconv.FormatUint(d.SourceReward, 10)
-		}
-		if d.TargetPenalty > 0 {
-			idealRewards[i].Target = fmt.Sprintf("-%s", strconv.FormatUint(d.TargetPenalty, 10))
-		} else {
-			idealRewards[i].Target = strconv.FormatUint(d.TargetReward, 10)
-		}
-	}
-	return idealRewards, true
-}
-
-func totalAttRewards(
-	w http.ResponseWriter,
-	st state.BeaconState,
-	bal *precompute.Balance,
-	vals []*precompute.Validator,
-	valIndices []primitives.ValidatorIndex,
-) ([]TotalAttestationReward, bool) {
-	totalRewards := make([]TotalAttestationReward, len(valIndices))
-	for i, v := range valIndices {
-		totalRewards[i] = TotalAttestationReward{ValidatorIndex: strconv.FormatUint(uint64(v), 10)}
-	}
-	deltas, err := altair.AttestationsDelta(st, bal, vals)
-	if err != nil {
-		errJson := &network.DefaultErrorJson{
-			Message: "Could not get attestations delta: " + err.Error(),
-			Code:    http.StatusInternalServerError,
-		}
-		network.WriteError(w, errJson)
-		return nil, false
-	}
-	for i, d := range deltas {
-		totalRewards[i].Head = strconv.FormatUint(d.HeadReward, 10)
-		if d.SourcePenalty > 0 {
-			totalRewards[i].Source = fmt.Sprintf("-%s", strconv.FormatUint(d.SourcePenalty, 10))
-		} else {
-			totalRewards[i].Source = strconv.FormatUint(d.SourceReward, 10)
-		}
-		if d.TargetPenalty > 0 {
-			totalRewards[i].Target = fmt.Sprintf("-%s", strconv.FormatUint(d.TargetPenalty, 10))
-		} else {
-			totalRewards[i].Target = strconv.FormatUint(d.TargetReward, 10)
-		}
-	}
-	return totalRewards, true
-}
-
 func handleGetBlockError(blk interfaces.ReadOnlySignedBeaconBlock, err error) *network.DefaultErrorJson {
 	if errors.Is(err, lookup.BlockIdParseError{}) {
 		return &network.DefaultErrorJson{
-			Message: "Invalid block ID: " + err.Error(),
+			Message: errors.Wrapf(err, "invalid block ID").Error(),
 			Code:    http.StatusBadRequest,
 		}
 	}
 	if err != nil {
 		return &network.DefaultErrorJson{
-			Message: "Could not get block from block ID: " + err.Error(),
+			Message: errors.Wrapf(err, "could not get block from block ID").Error(),
 			Code:    http.StatusInternalServerError,
 		}
 	}
 	if err := blocks.BeaconBlockIsNil(blk); err != nil {
 		return &network.DefaultErrorJson{
-			Message: "Could not find requested block" + err.Error(),
+			Message: errors.Wrapf(err, "could not find requested block").Error(),
 			Code:    http.StatusNotFound,
 		}
 	}

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

@@ -4,11 +4,8 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
-	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"strconv"
-	"strings"
 	"testing"
 
 	"github.com/prysmaticlabs/go-bitfield"
@@ -16,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/testutil"
-	"github.com/prysmaticlabs/prysm/v4/beacon-chain/state"
 	mockstategen "github.com/prysmaticlabs/prysm/v4/beacon-chain/state/stategen/mock"
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
@@ -36,7 +32,7 @@ import (
 func TestBlockRewards(t *testing.T) {
 	valCount := 64
 
-	st, err := util.NewBeaconStateCapella()
+	st, err := util.NewBeaconStateAltair()
 	require.NoError(t, st.SetSlot(1))
 	require.NoError(t, err)
 	validators := make([]*eth.Validator, 0, valCount)
@@ -197,285 +193,6 @@ func TestBlockRewards(t *testing.T) {
 		e := &network.DefaultErrorJson{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
 		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, "Block rewards are not supported for Phase 0 blocks", e.Message)
-	})
-}
-
-func TestAttestationRewards(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
-
-	valCount := 64
-
-	st, err := util.NewBeaconStateCapella()
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*3-1))
-	validators := make([]*eth.Validator, 0, valCount)
-	balances := make([]uint64, 0, valCount)
-	secretKeys := make([]bls.SecretKey, 0, valCount)
-	for i := 0; i < valCount; i++ {
-		blsKey, err := bls.RandKey()
-		require.NoError(t, err)
-		secretKeys = append(secretKeys, blsKey)
-		validators = append(validators, &eth.Validator{
-			PublicKey:         blsKey.PublicKey().Marshal(),
-			ExitEpoch:         params.BeaconConfig().FarFutureEpoch,
-			WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
-			EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance / 64 * uint64(i+1),
-		})
-		balances = append(balances, params.BeaconConfig().MaxEffectiveBalance/64*uint64(i+1))
-	}
-	require.NoError(t, st.SetValidators(validators))
-	require.NoError(t, st.SetBalances(balances))
-	require.NoError(t, st.SetInactivityScores(make([]uint64, len(validators))))
-	participation := make([]byte, len(validators))
-	for i := range participation {
-		participation[i] = 0b111
-	}
-	require.NoError(t, st.SetCurrentParticipationBits(participation))
-	require.NoError(t, st.SetPreviousParticipationBits(participation))
-
-	currentSlot := params.BeaconConfig().SlotsPerEpoch * 3
-	mockChainService := &mock.ChainService{Optimistic: true, Slot: &currentSlot}
-	s := &Server{
-		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-			params.BeaconConfig().SlotsPerEpoch*3 - 1: st,
-		}},
-		TimeFetcher:           mockChainService,
-		OptimisticModeFetcher: mockChainService,
-		FinalizationFetcher:   mockChainService,
-	}
-
-	t.Run("ok - ideal rewards", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		request := httptest.NewRequest("POST", url, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &AttestationRewardsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, 16, len(resp.Data.IdealRewards))
-		sum := uint64(0)
-		for _, r := range resp.Data.IdealRewards {
-			hr, err := strconv.ParseUint(r.Head, 10, 64)
-			require.NoError(t, err)
-			sr, err := strconv.ParseUint(r.Source, 10, 64)
-			require.NoError(t, err)
-			tr, err := strconv.ParseUint(r.Target, 10, 64)
-			require.NoError(t, err)
-			sum += hr + sr + tr
-		}
-		assert.Equal(t, uint64(20756849), sum)
-	})
-	t.Run("ok - filtered vals", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		var body bytes.Buffer
-		pubkey := fmt.Sprintf("%#x", secretKeys[10].PublicKey().Marshal())
-		valIds, err := json.Marshal([]string{"20", pubkey})
-		require.NoError(t, err)
-		_, err = body.Write(valIds)
-		require.NoError(t, err)
-		request := httptest.NewRequest("POST", url, &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &AttestationRewardsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, 2, len(resp.Data.TotalRewards))
-		sum := uint64(0)
-		for _, r := range resp.Data.TotalRewards {
-			hr, err := strconv.ParseUint(r.Head, 10, 64)
-			require.NoError(t, err)
-			sr, err := strconv.ParseUint(r.Source, 10, 64)
-			require.NoError(t, err)
-			tr, err := strconv.ParseUint(r.Target, 10, 64)
-			require.NoError(t, err)
-			sum += hr + sr + tr
-		}
-		assert.Equal(t, uint64(794265), sum)
-	})
-	t.Run("ok - all vals", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		request := httptest.NewRequest("POST", url, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &AttestationRewardsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, 64, len(resp.Data.TotalRewards))
-		sum := uint64(0)
-		for _, r := range resp.Data.TotalRewards {
-			hr, err := strconv.ParseUint(r.Head, 10, 64)
-			require.NoError(t, err)
-			sr, err := strconv.ParseUint(r.Source, 10, 64)
-			require.NoError(t, err)
-			tr, err := strconv.ParseUint(r.Target, 10, 64)
-			require.NoError(t, err)
-			sum += hr + sr + tr
-		}
-		assert.Equal(t, uint64(54221955), sum)
-	})
-	t.Run("ok - penalty", func(t *testing.T) {
-		st, err := util.NewBeaconStateCapella()
-		require.NoError(t, err)
-		require.NoError(t, st.SetSlot(params.BeaconConfig().SlotsPerEpoch*3-1))
-		validators := make([]*eth.Validator, 0, valCount)
-		balances := make([]uint64, 0, valCount)
-		secretKeys := make([]bls.SecretKey, 0, valCount)
-		for i := 0; i < valCount; i++ {
-			blsKey, err := bls.RandKey()
-			require.NoError(t, err)
-			secretKeys = append(secretKeys, blsKey)
-			validators = append(validators, &eth.Validator{
-				PublicKey:         blsKey.PublicKey().Marshal(),
-				ExitEpoch:         params.BeaconConfig().FarFutureEpoch,
-				WithdrawableEpoch: params.BeaconConfig().FarFutureEpoch,
-				EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance / 64 * uint64(i),
-			})
-			balances = append(balances, params.BeaconConfig().MaxEffectiveBalance/64*uint64(i))
-		}
-		validators[63].Slashed = true
-		require.NoError(t, st.SetValidators(validators))
-		require.NoError(t, st.SetBalances(balances))
-		require.NoError(t, st.SetInactivityScores(make([]uint64, len(validators))))
-		participation := make([]byte, len(validators))
-		for i := range participation {
-			participation[i] = 0b111
-		}
-		require.NoError(t, st.SetCurrentParticipationBits(participation))
-		require.NoError(t, st.SetPreviousParticipationBits(participation))
-
-		currentSlot := params.BeaconConfig().SlotsPerEpoch * 3
-		mockChainService := &mock.ChainService{Optimistic: true, Slot: &currentSlot}
-		s := &Server{
-			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-				params.BeaconConfig().SlotsPerEpoch*3 - 1: st,
-			}},
-			TimeFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-		}
-
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		var body bytes.Buffer
-		valIds, err := json.Marshal([]string{"63"})
-		require.NoError(t, err)
-		_, err = body.Write(valIds)
-		require.NoError(t, err)
-		request := httptest.NewRequest("POST", url, &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &AttestationRewardsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, "0", resp.Data.TotalRewards[0].Head)
-		assert.Equal(t, "-432270", resp.Data.TotalRewards[0].Source)
-		assert.Equal(t, "-802788", resp.Data.TotalRewards[0].Target)
-	})
-	t.Run("invalid validator index/pubkey", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		var body bytes.Buffer
-		valIds, err := json.Marshal([]string{"10", "foo"})
-		require.NoError(t, err)
-		_, err = body.Write(valIds)
-		require.NoError(t, err)
-		request := httptest.NewRequest("POST", url, &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &network.DefaultErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, "foo is not a validator index or pubkey", e.Message)
-	})
-	t.Run("unknown validator pubkey", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		var body bytes.Buffer
-		privkey, err := bls.RandKey()
-		require.NoError(t, err)
-		pubkey := fmt.Sprintf("%#x", privkey.PublicKey().Marshal())
-		valIds, err := json.Marshal([]string{"10", pubkey})
-		require.NoError(t, err)
-		_, err = body.Write(valIds)
-		require.NoError(t, err)
-		request := httptest.NewRequest("POST", url, &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &network.DefaultErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, "No validator index found for pubkey "+pubkey, e.Message)
-	})
-	t.Run("validator index too large", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/1"
-		var body bytes.Buffer
-		valIds, err := json.Marshal([]string{"10", "999"})
-		require.NoError(t, err)
-		_, err = body.Write(valIds)
-		require.NoError(t, err)
-		request := httptest.NewRequest("POST", url, &body)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &network.DefaultErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, "Validator index 999 is too large. Maximum allowed index is 63", e.Message)
-	})
-	t.Run("phase 0", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/0"
-		request := httptest.NewRequest("POST", url, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusNotFound, writer.Code)
-		e := &network.DefaultErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusNotFound, e.Code)
-		assert.Equal(t, "Attestation rewards are not supported for Phase 0", e.Message)
-	})
-	t.Run("invalid epoch", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/foo"
-		request := httptest.NewRequest("POST", url, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusBadRequest, writer.Code)
-		e := &network.DefaultErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusBadRequest, e.Code)
-		assert.Equal(t, true, strings.Contains(e.Message, "Could not decode epoch"))
-	})
-	t.Run("previous epoch", func(t *testing.T) {
-		url := "http://only.the.epoch.number.at.the.end.is.important/2"
-		request := httptest.NewRequest("POST", url, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.AttestationRewards(writer, request)
-		assert.Equal(t, http.StatusNotFound, writer.Code)
-		e := &network.DefaultErrorJson{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
-		assert.Equal(t, http.StatusNotFound, e.Code)
-		assert.Equal(t, "Attestation rewards are available after two epoch transitions to ensure all attestations have a chance of inclusion", e.Message)
+		assert.Equal(t, "block rewards are not supported for Phase 0 blocks", e.Message)
 	})
 }

beacon-chain/rpc/eth/rewards/server.go

@@ -11,8 +11,4 @@ type Server struct {
 	OptimisticModeFetcher blockchain.OptimisticModeFetcher
 	FinalizationFetcher   blockchain.FinalizationFetcher
 	ReplayerBuilder       stategen.ReplayerBuilder
-	// TODO: Init
-	TimeFetcher blockchain.TimeFetcher
-	Stater      lookup.Stater
-	HeadFetcher blockchain.HeadFetcher
 }

beacon-chain/rpc/eth/rewards/structs.go

@@ -1,9 +1,9 @@
 package rewards
 
 type BlockRewardsResponse struct {
-	Data                BlockRewards `json:"data"`
-	ExecutionOptimistic bool         `json:"execution_optimistic"`
-	Finalized           bool         `json:"finalized"`
+	Data                *BlockRewards `json:"data"`
+	ExecutionOptimistic bool          `json:"execution_optimistic"`
+	Finalized           bool          `json:"finalized"`
 }
 
 type BlockRewards struct {
@@ -14,29 +14,3 @@ type BlockRewards struct {
 	ProposerSlashings string `json:"proposer_slashings"`
 	AttesterSlashings string `json:"attester_slashings"`
 }
-
-type AttestationRewardsResponse struct {
-	Data                AttestationRewards `json:"data"`
-	ExecutionOptimistic bool               `json:"execution_optimistic"`
-	Finalized           bool               `json:"finalized"`
-}
-
-type AttestationRewards struct {
-	IdealRewards []IdealAttestationReward `json:"ideal_rewards"`
-	TotalRewards []TotalAttestationReward `json:"total_rewards"`
-}
-
-type IdealAttestationReward struct {
-	EffectiveBalance string `json:"effective_balance"`
-	Head             string `json:"head"`
-	Target           string `json:"target"`
-	Source           string `json:"source"`
-}
-
-type TotalAttestationReward struct {
-	ValidatorIndex string `json:"validator_index"`
-	Head           string `json:"head"`
-	Target         string `json:"target"`
-	Source         string `json:"source"`
-	InclusionDelay string `json:"inclusion_delay"`
-}

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -75,7 +75,6 @@ go_library(
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
-        "//io/file:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",

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

@@ -66,7 +66,11 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 		return nil, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
 	}
 
+	if err := vs.AttPool.AggregateUnaggregatedAttestationsBySlotIndex(ctx, req.Slot, req.CommitteeIndex); err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not aggregate unaggregated attestations")
+	}
 	aggregatedAtts := vs.AttPool.AggregatedAttestationsBySlotIndex(ctx, req.Slot, req.CommitteeIndex)
+
 	// Filter out the best aggregated attestation (ie. the one with the most aggregated bits).
 	if len(aggregatedAtts) == 0 {
 		aggregatedAtts = vs.AttPool.UnaggregatedAttestationsBySlotIndex(ctx, req.Slot, req.CommitteeIndex)

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

@@ -238,18 +238,6 @@ func (vs *Server) duties(ctx context.Context, req *ethpb.DutiesRequest) (*ethpb.
 		assignValidatorToSubnet(pubKey, nextAssignment.Status)
 	}
 
-	// Cache proposer assignment for the current epoch.
-	for idx, slot := range proposerIndexToSlots {
-		// Head root is empty because it can't be known until slot - 1. Same with payload id.
-		vs.ProposerSlotIndexCache.SetProposerAndPayloadIDs(slot[0], idx, [8]byte{} /* payloadID */, [32]byte{} /* head root */)
-	}
-	// Cache proposer assignment for the next epoch.
-	for idx, slot := range nextProposerIndexToSlots {
-		vs.ProposerSlotIndexCache.SetProposerAndPayloadIDs(slot[0], idx, [8]byte{} /* payloadID */, [32]byte{} /* head root */)
-	}
-	// Prune payload ID cache for any slots before request slot.
-	vs.ProposerSlotIndexCache.PrunePayloadIDs(epochStartSlot)
-
 	return &ethpb.DutiesResponse{
 		Duties:             validatorAssignments,
 		CurrentEpochDuties: validatorAssignments,

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

@@ -1,12 +1,9 @@
 package validator
 
 import (
-	"bytes"
 	"context"
 	"encoding/hex"
 	"fmt"
-	"path"
-	"runtime/pprof"
 	"strings"
 	"sync"
 	"time"
@@ -28,7 +25,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v4/io/file"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"github.com/sirupsen/logrus"
@@ -57,10 +53,6 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	if err != nil {
 		log.WithError(err).Error("Could not convert slot to time")
 	}
-	bf := bytes.NewBuffer([]byte{})
-	if err := pprof.StartCPUProfile(bf); err != nil {
-		log.WithError(err)
-	}
 	log.WithFields(logrus.Fields{
 		"slot":               req.Slot,
 		"sinceSlotStartTime": time.Since(t),
@@ -71,16 +63,13 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 		return nil, status.Error(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 
-	curr := time.Now()
 	// process attestations and update head in forkchoice
 	vs.ForkchoiceFetcher.UpdateHead(ctx, vs.TimeFetcher.CurrentSlot())
-	log.Infof("proposer_mocker: update head in rpc took %s", time.Since(curr).String())
 	headRoot := vs.ForkchoiceFetcher.CachedHeadRoot()
 	parentRoot := vs.ForkchoiceFetcher.GetProposerHead()
 	if parentRoot != headRoot {
 		blockchain.LateBlockAttemptedReorgCount.Inc()
 	}
-	log.Infof("proposer_mocker: fetching head root in rpc took %s", time.Since(curr).String())
 
 	// An optimistic validator MUST NOT produce a block (i.e., sign across the DOMAIN_BEACON_PROPOSER domain).
 	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch {
@@ -101,7 +90,6 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", req.Slot, err)
 	}
-	log.Infof("proposer_mocker: fetching head state rpc took %s", time.Since(curr).String())
 
 	// Set slot, graffiti, randao reveal, and parent root.
 	sBlk.SetSlot(req.Slot)
@@ -115,10 +103,9 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 		return nil, fmt.Errorf("could not calculate proposer index %v", err)
 	}
 	sBlk.SetProposerIndex(idx)
-	log.Infof("proposer_mocker: setting proposer index took %s", time.Since(curr).String())
 
 	if features.Get().BuildBlockParallel {
-		if err := vs.BuildBlockParallel(ctx, sBlk, head, curr); err != nil {
+		if err := vs.BuildBlockParallel(ctx, sBlk, head); err != nil {
 			return nil, errors.Wrap(err, "could not build block in parallel")
 		}
 	} else {
@@ -181,20 +168,6 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 		"sinceSlotStartTime": time.Since(t),
 		"validator":          sBlk.Block().ProposerIndex(),
 	}).Info("Finished building block")
-	pprof.StopCPUProfile()
-	if time.Since(t) > 1*time.Second {
-		dbPath := vs.BeaconDB.DatabasePath()
-		dbPath = path.Join(dbPath, "profiles")
-		err = file.MkdirAll(dbPath)
-		if err != nil {
-			log.WithError(err)
-		} else {
-			dbPath = path.Join(dbPath, fmt.Sprintf("%d.profile", req.Slot))
-			if err = file.WriteFile(dbPath, bf.Bytes()); err != nil {
-				log.WithError(err)
-			}
-		}
-	}
 
 	pb, err := sBlk.Block().Proto()
 	if err != nil {
@@ -218,7 +191,7 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: pb.(*ethpb.BeaconBlock)}}, nil
 }
 
-func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.SignedBeaconBlock, head state.BeaconState, curr time.Time) error {
+func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.SignedBeaconBlock, head state.BeaconState) error {
 	// Build consensus fields in background
 	var wg sync.WaitGroup
 	wg.Add(1)
@@ -232,7 +205,6 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 			log.WithError(err).Error("Could not get eth1data")
 		}
 		sBlk.SetEth1Data(eth1Data)
-		log.Infof("proposer_mocker: setting eth1data took %s", time.Since(curr).String())
 
 		// Set deposit and attestation.
 		deposits, atts, err := vs.packDepositsAndAttestations(ctx, head, eth1Data) // TODO: split attestations and deposits
@@ -244,26 +216,20 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 			sBlk.SetDeposits(deposits)
 			sBlk.SetAttestations(atts)
 		}
-		log.Infof("proposer_mocker: setting deposits and atts took %s", time.Since(curr).String())
 
 		// Set slashings.
 		validProposerSlashings, validAttSlashings := vs.getSlashings(ctx, head)
 		sBlk.SetProposerSlashings(validProposerSlashings)
 		sBlk.SetAttesterSlashings(validAttSlashings)
-		log.Infof("proposer_mocker: setting slashings took %s", time.Since(curr).String())
 
 		// Set exits.
 		sBlk.SetVoluntaryExits(vs.getExits(head, sBlk.Block().Slot()))
-		log.Infof("proposer_mocker: setting exits took %s", time.Since(curr).String())
 
 		// Set sync aggregate. New in Altair.
 		vs.setSyncAggregate(ctx, sBlk)
-		log.Infof("proposer_mocker: setting sync aggs took %s", time.Since(curr).String())
 
 		// Set bls to execution change. New in Capella.
 		vs.setBlsToExecData(sBlk, head)
-		log.Infof("proposer_mocker: setting bls data took %s", time.Since(curr).String())
-
 	}()
 
 	localPayload, err := vs.getLocalPayload(ctx, sBlk.Block(), head)
@@ -280,7 +246,6 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 	if err := setExecutionData(ctx, sBlk, localPayload, builderPayload); err != nil {
 		return status.Errorf(codes.Internal, "Could not set execution data: %v", err)
 	}
-	log.Infof("proposer_mocker: setting execution data took %s", time.Since(curr).String())
 
 	wg.Wait() // Wait until block is built via consensus and execution fields.
 
@@ -427,12 +392,10 @@ func (vs *Server) proposeGenericBeaconBlock(ctx context.Context, blk interfaces.
 // computeStateRoot computes the state root after a block has been processed through a state transition and
 // returns it to the validator client.
 func (vs *Server) computeStateRoot(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
-	curr := time.Now()
 	beaconState, err := vs.StateGen.StateByRoot(ctx, block.Block().ParentRoot())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not retrieve beacon state")
 	}
-	log.Infof("proposer_mocker: fetching parent state took %s", time.Since(curr).String())
 	root, err := transition.CalculateStateRoot(
 		ctx,
 		beaconState,
@@ -441,7 +404,6 @@ func (vs *Server) computeStateRoot(ctx context.Context, block interfaces.ReadOnl
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not calculate state root at slot %d", beaconState.Slot())
 	}
-	log.Infof("proposer_mocker: calculating state root took %s", time.Since(curr).String())
 
 	log.WithField("beaconStateRoot", fmt.Sprintf("%#x", root)).Debugf("Computed state root")
 	return root[:], nil

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

@@ -30,7 +30,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v4/network/forks"
 	ethpb "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v4/time/slots"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -70,7 +69,7 @@ type Server struct {
 	OperationNotifier      opfeed.Notifier
 	StateGen               stategen.StateManager
 	ReplayerBuilder        stategen.ReplayerBuilder
-	BeaconDB               db.Database
+	BeaconDB               db.HeadAccessDatabase
 	ExecutionEngineCaller  execution.EngineCaller
 	BlockBuilder           builder.BlockBuilder
 	BLSChangesPool         blstoexec.PoolManager
@@ -185,33 +184,3 @@ func (vs *Server) WaitForChainStart(_ *emptypb.Empty, stream ethpb.BeaconNodeVal
 	}
 	return stream.Send(res)
 }
-
-func (vs *Server) RandomStuff() {
-	for vs.TimeFetcher.GenesisTime().IsZero() {
-		time.Sleep(5 * time.Second)
-	}
-	genTime := vs.TimeFetcher.GenesisTime()
-
-	ticker := slots.NewSlotTicker(genTime, params.BeaconConfig().SecondsPerSlot)
-	for {
-		select {
-		case <-vs.Ctx.Done():
-			ticker.Done()
-			return
-		case slot := <-ticker.C():
-			curr := time.Now()
-			time.Sleep(18 * time.Millisecond)
-			_, err := vs.GetBeaconBlock(context.Background(), &ethpb.BlockRequest{
-				Slot:         slot,
-				Graffiti:     make([]byte, 32),
-				RandaoReveal: make([]byte, 96),
-			})
-			if err != nil {
-				log.Error(err)
-				continue
-			}
-			log.Infof("proposer_mocker: successfully produced block %d in %s", slot, time.Since(curr).String())
-		}
-	}
-
-}

beacon-chain/rpc/service.go

@@ -30,7 +30,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/beacon"
-	rpcBuilder "github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/builder"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/debug"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/events"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/rpc/eth/node"
@@ -83,7 +82,7 @@ type Config struct {
 	KeyFlag                       string
 	BeaconMonitoringHost          string
 	BeaconMonitoringPort          int
-	BeaconDB                      db.Database
+	BeaconDB                      db.HeadAccessDatabase
 	ChainInfoFetcher              blockchain.ChainInfoFetcher
 	HeadFetcher                   blockchain.HeadFetcher
 	CanonicalFetcher              blockchain.CanonicalFetcher
@@ -212,19 +211,8 @@ func (s *Service) Start() {
 		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
 		FinalizationFetcher:   s.cfg.FinalizationFetcher,
 		ReplayerBuilder:       ch,
-		TimeFetcher:           s.cfg.GenesisTimeFetcher,
-		Stater:                stater,
-		HeadFetcher:           s.cfg.HeadFetcher,
 	}
 	s.cfg.Router.HandleFunc("/eth/v1/beacon/rewards/blocks/{block_id}", rewardsServer.BlockRewards)
-	s.cfg.Router.HandleFunc("/eth/v1/beacon/rewards/attestations/{epoch}", rewardsServer.AttestationRewards)
-
-	builderServer := &rpcBuilder.Server{
-		FinalizationFetcher:   s.cfg.FinalizationFetcher,
-		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
-		Stater:                stater,
-	}
-	s.cfg.Router.HandleFunc("/eth/v1/builder/states/{state_id}/expected_withdrawals", builderServer.ExpectedWithdrawals)
 
 	validatorServer := &validatorv1alpha1.Server{
 		Ctx:                    s.ctx,
@@ -262,7 +250,6 @@ func (s *Service) Start() {
 		BLSChangesPool:         s.cfg.BLSChangesPool,
 		ClockWaiter:            s.cfg.ClockWaiter,
 	}
-	go validatorServer.RandomStuff()
 	validatorServerV1 := &validator.Server{
 		HeadFetcher:            s.cfg.HeadFetcher,
 		TimeFetcher:            s.cfg.GenesisTimeFetcher,

beacon-chain/state/fieldtrie/helpers_test.go

@@ -251,10 +251,6 @@ func TestFieldTrie_NativeState_fieldConvertersNative(t *testing.T) {
 				field:   types.FieldIndex(9),
 				indices: []uint64{1},
 				elements: []*ethpb.Eth1Data{
-					{
-						DepositRoot:  make([]byte, fieldparams.RootLength),
-						DepositCount: 2,
-					},
 					{
 						DepositRoot:  make([]byte, fieldparams.RootLength),
 						DepositCount: 1,
@@ -325,14 +321,11 @@ func TestFieldTrie_NativeState_fieldConvertersNative(t *testing.T) {
 			wantHex: []string{"0x7d7696e7f12593934afcd87a0d38e1a981bee63cb4cf0568ba36a6e0596eeccb"},
 		},
 		{
-			name: "Attestations convertAll false",
+			name: "Attestations",
 			args: &args{
 				field:   types.FieldIndex(15),
 				indices: []uint64{1},
 				elements: []*ethpb.PendingAttestation{
-					{
-						ProposerIndex: 0,
-					},
 					{
 						ProposerIndex: 1,
 					},
@@ -359,12 +352,8 @@ func TestFieldTrie_NativeState_fieldConvertersNative(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			roots, err := fieldConverters(tt.args.field, tt.args.indices, tt.args.elements, tt.args.convertAll)
-			if err != nil {
-				if tt.errMsg != "" {
-					require.ErrorContains(t, tt.errMsg, err)
-				} else {
-					t.Error("Unexpected error: " + err.Error())
-				}
+			if err != nil && tt.errMsg != "" {
+				require.ErrorContains(t, tt.errMsg, err)
 			} else {
 				for i, root := range roots {
 					hex := hexutil.Encode(root[:])

build/bazelrc/hermetic-cc.bazelrc

@@ -1,19 +0,0 @@
-# From Bazel's perspective, this is almost equivalent to always specifying
-# --extra_toolchains on every bazel <...> command-line invocation. It also
-# means there is no way to disable the toolchain with the command line. This is
-# useful if you find bazel-hermetic-cc useful enough to compile for all of your
-# targets and tools.
-#
-# With BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1 Bazel stops detecting the default
-# host toolchain. Configuring toolchains is complicated enough, and the
-# auto-detection (read: fallback to non-hermetic toolchain) is a footgun best
-# avoided. This option is not documented in bazel, so may break. If you intend
-# to use the hermetic toolchain exclusively, it won't hurt.
-build --action_env BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN=1
-
-# This snippet instructs Bazel to use the registered "new kinds of toolchains".
-# This flag not needed after this issue is closed https://github.com/bazelbuild/bazel/issues/7260
-build --incompatible_enable_cc_toolchain_resolution
-
-# Add a no-op warning for users still using --config=llvm
-build:llvm --unconditional_warning="llvm config is no longer used as clang is now the default compiler"

cmd/beacon-chain/BUILD.bazel

@@ -65,10 +65,7 @@ container_image(
 container_bundle(
     name = "image_bundle",
     images = {
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:latest": ":image_with_creation_time",
-        "gcr.io/prysmaticlabs/prysm/beacon-chain:{DOCKER_TAG}": ":image_with_creation_time",
-        "index.docker.io/prysmaticlabs/prysm-beacon-chain:latest": ":image_with_creation_time",
-        "index.docker.io/prysmaticlabs/prysm-beacon-chain:{DOCKER_TAG}": ":image_with_creation_time",
+        "gcr.io/prysmaticlabs/prysm/beacon-chain:fcTesting": ":image_with_creation_time",
     },
     tags = ["manual"],
     visibility = ["//beacon-chain:__pkg__"],
@@ -119,20 +116,6 @@ docker_push(
     visibility = ["//beacon-chain:__pkg__"],
 )
 
-docker_push(
-    name = "push_images_debug",
-    bundle = ":image_bundle_debug",
-    tags = ["manual"],
-    visibility = ["//beacon-chain:__pkg__"],
-)
-
-docker_push(
-    name = "push_images_alpine",
-    bundle = ":image_bundle_alpine",
-    tags = ["manual"],
-    visibility = ["//beacon-chain:__pkg__"],
-)
-
 go_binary(
     name = "beacon-chain",
     embed = [":go_default_library"],

cmd/beacon-chain/flags/base.go

@@ -202,7 +202,11 @@ var (
 		Usage: "Sets the maximum number of headers that a deposit log query can fetch.",
 		Value: uint64(1000),
 	}
-
+	// EnableRegistrationCache a temporary flag for enabling the validator registration cache instead of db.
+	EnableRegistrationCache = &cli.BoolFlag{
+		Name:  "enable-registration-cache",
+		Usage: "A temporary flag for enabling the validator registration cache instead of persisting in db. The cache will clear on restart.",
+	}
 	// WeakSubjectivityCheckpoint defines the weak subjectivity checkpoint the node must sync through to defend against long range attacks.
 	WeakSubjectivityCheckpoint = &cli.StringFlag{
 		Name: "weak-subjectivity-checkpoint",

cmd/beacon-chain/main.go

@@ -58,6 +58,7 @@ var appFlags = []cli.Flag{
 	flags.InteropGenesisTimeFlag,
 	flags.SlotsPerArchivedPoint,
 	flags.EnableDebugRPCEndpoints,
+	flags.EnableRegistrationCache,
 	flags.SubscribeToAllSubnets,
 	flags.HistoricalSlasherNode,
 	flags.ChainID,

cmd/beacon-chain/usage.go

@@ -113,6 +113,7 @@ var appHelpFlagGroups = []flagGroup{
 			flags.BlockBatchLimit,
 			flags.BlockBatchLimitBurstFactor,
 			flags.EnableDebugRPCEndpoints,
+			flags.EnableRegistrationCache,
 			flags.SubscribeToAllSubnets,
 			flags.HistoricalSlasherNode,
 			flags.ChainID,

cmd/validator/accounts/exit_test.go

@@ -134,6 +134,7 @@ func TestExitAccountsCli_OK_AllPublicKeys(t *testing.T) {
 
 	mockNodeClient.EXPECT().
 		GetGenesis(gomock.Any(), gomock.Any()).
+		Times(2).
 		Return(&ethpb.Genesis{GenesisTime: genesisTime}, nil)
 
 	mockValidatorClient.EXPECT().

config/features/config.go

@@ -70,7 +70,6 @@ type Flags struct {
 	PrepareAllPayloads bool // PrepareAllPayloads informs the engine to prepare a block on every slot.
 
 	BuildBlockParallel bool // BuildBlockParallel builds beacon block for proposer in parallel.
-	AggregateParallel  bool // AggregateParallel aggregates attestations in parallel.
 
 	// KeystoreImportDebounceInterval specifies the time duration the validator waits to reload new keys if they have
 	// changed on disk. This feature is for advanced use cases only.
@@ -230,10 +229,6 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		logEnabled(disableBuildBlockParallel)
 		cfg.BuildBlockParallel = false
 	}
-	if ctx.IsSet(aggregateParallel.Name) {
-		logEnabled(aggregateParallel)
-		cfg.AggregateParallel = true
-	}
 	if ctx.IsSet(disableResourceManager.Name) {
 		logEnabled(disableResourceManager)
 		cfg.DisableResourceManager = true

config/features/deprecated_flags.go

@@ -32,12 +32,6 @@ var (
 		Usage:  deprecatedUsage,
 		Hidden: true,
 	}
-
-	deprecatedEnableRegistrationCache = &cli.BoolFlag{
-		Name:   "enable-registration-cache",
-		Usage:  deprecatedUsage,
-		Hidden: true,
-	}
 )
 
 // Deprecated flags for both the beacon node and validator client.
@@ -47,7 +41,6 @@ var deprecatedFlags = []cli.Flag{
 	deprecatedEnableReorgLateBlocks,
 	deprecatedDisableGossipBatchAggregation,
 	deprecatedBuildBlockParallel,
-	deprecatedEnableRegistrationCache,
 }
 
 // deprecatedBeaconFlags contains flags that are still used by other components

config/features/flags.go

@@ -148,17 +148,6 @@ var (
 		Name:  "disable-resource-manager",
 		Usage: "Disables running the libp2p resource manager",
 	}
-
-	// DisableRegistrationCache a flag for disabling the validator registration cache and use db instead.
-	DisableRegistrationCache = &cli.BoolFlag{
-		Name:  "diable-registration-cache",
-		Usage: "A temporary flag for disabling the validator registration cache instead of using the db. note: registrations do not clear on restart while using the db",
-	}
-
-	aggregateParallel = &cli.BoolFlag{
-		Name:  "aggregate-parallel",
-		Usage: "Enables parallel aggregation of attestations",
-	}
 )
 
 // devModeFlags holds list of flags that are set when development mode is on.
@@ -211,8 +200,6 @@ var BeaconChainFlags = append(deprecatedBeaconFlags, append(deprecatedFlags, []c
 	aggregateSecondInterval,
 	aggregateThirdInterval,
 	disableResourceManager,
-	DisableRegistrationCache,
-	aggregateParallel,
 }...)...)
 
 // E2EBeaconChainFlags contains a list of the beacon chain feature flags to be tested in E2E.

config/validator/service/proposer_settings.go

@@ -84,15 +84,6 @@ type ProposerSettings struct {
 	DefaultConfig *ProposerOption
 }
 
-// ShouldBeSaved goes through checks to see if the value should be saveable
-// Pseudocode: conditions for being saved into the database
-// 1. settings are not nil
-// 2. proposeconfig is not nil (this defines specific settings for each validator key), default config can be nil in this case and fall back to beacon node settings
-// 3. defaultconfig is not nil, meaning it has at least fee recipient settings (this defines general settings for all validator keys but keys will use settings from propose config if available), propose config can be nil in this case
-func (settings *ProposerSettings) ShouldBeSaved() bool {
-	return settings != nil && (settings.ProposeConfig != nil || settings.DefaultConfig != nil && settings.DefaultConfig.FeeRecipientConfig != nil)
-}
-
 // ToPayload converts struct to ProposerSettingsPayload
 func (ps *ProposerSettings) ToPayload() *validatorpb.ProposerSettingsPayload {
 	if ps == nil {

config/validator/service/proposer_settings_test.go

@@ -98,117 +98,3 @@ func Test_Proposer_Setting_Cloning(t *testing.T) {
 
 	})
 }
-
-func TestProposerSettings_ShouldBeSaved(t *testing.T) {
-	key1hex := "0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a"
-	key1, err := hexutil.Decode(key1hex)
-	require.NoError(t, err)
-	type fields struct {
-		ProposeConfig map[[fieldparams.BLSPubkeyLength]byte]*ProposerOption
-		DefaultConfig *ProposerOption
-	}
-	tests := []struct {
-		name   string
-		fields fields
-		want   bool
-	}{
-		{
-			name: "Should be saved, proposeconfig populated and no default config",
-			fields: fields{
-				ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*ProposerOption{
-					bytesutil.ToBytes48(key1): {
-						FeeRecipientConfig: &FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-						},
-						BuilderConfig: &BuilderConfig{
-							Enabled:  true,
-							GasLimit: validator.Uint64(40000000),
-							Relays:   []string{"https://example-relay.com"},
-						},
-					},
-				},
-				DefaultConfig: nil,
-			},
-			want: true,
-		},
-		{
-			name: "Should be saved, default populated and no proposeconfig ",
-			fields: fields{
-				ProposeConfig: nil,
-				DefaultConfig: &ProposerOption{
-					FeeRecipientConfig: &FeeRecipientConfig{
-						FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-					},
-					BuilderConfig: &BuilderConfig{
-						Enabled:  true,
-						GasLimit: validator.Uint64(40000000),
-						Relays:   []string{"https://example-relay.com"},
-					},
-				},
-			},
-			want: true,
-		},
-		{
-			name: "Should be saved, all populated",
-			fields: fields{
-				ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*ProposerOption{
-					bytesutil.ToBytes48(key1): {
-						FeeRecipientConfig: &FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-						},
-						BuilderConfig: &BuilderConfig{
-							Enabled:  true,
-							GasLimit: validator.Uint64(40000000),
-							Relays:   []string{"https://example-relay.com"},
-						},
-					},
-				},
-				DefaultConfig: &ProposerOption{
-					FeeRecipientConfig: &FeeRecipientConfig{
-						FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-					},
-					BuilderConfig: &BuilderConfig{
-						Enabled:  true,
-						GasLimit: validator.Uint64(40000000),
-						Relays:   []string{"https://example-relay.com"},
-					},
-				},
-			},
-			want: true,
-		},
-
-		{
-			name: "Should not be saved, proposeconfig not populated and default not populated",
-			fields: fields{
-				ProposeConfig: nil,
-				DefaultConfig: nil,
-			},
-			want: false,
-		},
-		{
-			name: "Should not be saved, builder data only",
-			fields: fields{
-				ProposeConfig: nil,
-				DefaultConfig: &ProposerOption{
-					BuilderConfig: &BuilderConfig{
-						Enabled:  true,
-						GasLimit: validator.Uint64(40000000),
-						Relays:   []string{"https://example-relay.com"},
-					},
-				},
-			},
-			want: false,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			settings := &ProposerSettings{
-				ProposeConfig: tt.fields.ProposeConfig,
-				DefaultConfig: tt.fields.DefaultConfig,
-			}
-			if got := settings.ShouldBeSaved(); got != tt.want {
-				t.Errorf("ShouldBeSaved() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

deps.bzl

@@ -4867,3 +4867,12 @@ def prysm_deps():
         sum = "h1:FiJd5l1UOLj0wCgbSE0rwwXHzEdAZS6hiiSnxJN/D60=",
         version = "v1.24.0",
     )
+
+    # Note: go_repository is already wrapped with maybe!
+    maybe(
+        git_repository,
+        name = "vaticle_bazel_distribution",
+        commit = "96424c85195a97dad81f69fdbbef2e1574bf8801",
+        remote = "https://github.com/vaticle/bazel-distribution",
+        shallow_since = "1569509514 +0300",
+    )

encoding/ssz/detect/configfork_test.go

@@ -134,7 +134,6 @@ func TestUnmarshalState(t *testing.T) {
 	}()
 	bc := params.BeaconConfig()
 	altairSlot, err := slots.EpochStart(bc.AltairForkEpoch)
-	require.NoError(t, err)
 	bellaSlot, err := slots.EpochStart(bc.BellatrixForkEpoch)
 	require.NoError(t, err)
 	cases := []struct {
@@ -206,7 +205,6 @@ func TestUnmarshalBlock(t *testing.T) {
 	altairv := bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion)
 	bellav := bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion)
 	altairS, err := slots.EpochStart(params.BeaconConfig().AltairForkEpoch)
-	require.NoError(t, err)
 	bellaS, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
 	require.NoError(t, err)
 	cases := []struct {
@@ -298,7 +296,6 @@ func TestUnmarshalBlindedBlock(t *testing.T) {
 	altairv := bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion)
 	bellav := bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion)
 	altairS, err := slots.EpochStart(params.BeaconConfig().AltairForkEpoch)
-	require.NoError(t, err)
 	bellaS, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
 	require.NoError(t, err)
 	cases := []struct {

nogo_config.json

@@ -147,11 +147,11 @@
     }
   },
   "ineffassign": {
-    "exclude_files": {
-      "external/.*": "Third party code",
-      "rules_go_work-.*": "Third party code",
-      ".*\\.pb.*.go": "Generated code is ok",
-      ".*generated\\.ssz\\.go": "Generated code is ok"
+    "only_files": {
+      "beacon-chain/.*": "",
+      "shared/.*": "",
+      "slasher/.*": "",
+      "validator/.*": ""
     }
   },
   "properpermissions": {

proto/eth/service/key_management.pb.gw.go

@@ -597,76 +597,6 @@ func local_request_KeyManagement_DeleteGasLimit_0(ctx context.Context, marshaler
 
 }
 
-func request_KeyManagement_SetVoluntaryExit_0(ctx context.Context, marshaler runtime.Marshaler, client KeyManagementClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq SetVoluntaryExitRequest
-	var metadata runtime.ServerMetadata
-
-	newReader, berr := utilities.IOReaderFactory(req.Body)
-	if berr != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
-	}
-	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["pubkey"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pubkey")
-	}
-
-	pubkey, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pubkey", err)
-	}
-	protoReq.Pubkey = (pubkey)
-
-	msg, err := client.SetVoluntaryExit(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
-	return msg, metadata, err
-
-}
-
-func local_request_KeyManagement_SetVoluntaryExit_0(ctx context.Context, marshaler runtime.Marshaler, server KeyManagementServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
-	var protoReq SetVoluntaryExitRequest
-	var metadata runtime.ServerMetadata
-
-	newReader, berr := utilities.IOReaderFactory(req.Body)
-	if berr != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", berr)
-	}
-	if err := marshaler.NewDecoder(newReader()).Decode(&protoReq); err != nil && err != io.EOF {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
-	}
-
-	var (
-		val string
-		ok  bool
-		err error
-		_   = err
-	)
-
-	val, ok = pathParams["pubkey"]
-	if !ok {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pubkey")
-	}
-
-	pubkey, err := runtime.Bytes(val)
-	if err != nil {
-		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pubkey", err)
-	}
-	protoReq.Pubkey = (pubkey)
-
-	msg, err := server.SetVoluntaryExit(ctx, &protoReq)
-	return msg, metadata, err
-
-}
-
 // RegisterKeyManagementHandlerServer registers the http handlers for service KeyManagement to "mux".
 // UnaryRPC     :call KeyManagementServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -949,29 +879,6 @@ func RegisterKeyManagementHandlerServer(ctx context.Context, mux *runtime.ServeM
 
 	})
 
-	mux.Handle("POST", pattern_KeyManagement_SetVoluntaryExit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		var stream runtime.ServerTransportStream
-		ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/ethereum.eth.service.KeyManagement/SetVoluntaryExit")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := local_request_KeyManagement_SetVoluntaryExit_0(rctx, inboundMarshaler, server, req, pathParams)
-		md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_KeyManagement_SetVoluntaryExit_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	return nil
 }
 
@@ -1253,26 +1160,6 @@ func RegisterKeyManagementHandlerClient(ctx context.Context, mux *runtime.ServeM
 
 	})
 
-	mux.Handle("POST", pattern_KeyManagement_SetVoluntaryExit_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
-		ctx, cancel := context.WithCancel(req.Context())
-		defer cancel()
-		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
-		rctx, err := runtime.AnnotateContext(ctx, mux, req, "/ethereum.eth.service.KeyManagement/SetVoluntaryExit")
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-		resp, md, err := request_KeyManagement_SetVoluntaryExit_0(rctx, inboundMarshaler, client, req, pathParams)
-		ctx = runtime.NewServerMetadataContext(ctx, md)
-		if err != nil {
-			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
-			return
-		}
-
-		forward_KeyManagement_SetVoluntaryExit_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
-
-	})
-
 	return nil
 }
 
@@ -1300,8 +1187,6 @@ var (
 	pattern_KeyManagement_SetGasLimit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"internal", "eth", "v1", "validator", "pubkey", "gas_limit"}, ""))
 
 	pattern_KeyManagement_DeleteGasLimit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"internal", "eth", "v1", "validator", "pubkey", "gas_limit"}, ""))
-
-	pattern_KeyManagement_SetVoluntaryExit_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"internal", "eth", "v1", "validator", "pubkey", "voluntary_exit"}, ""))
 )
 
 var (
@@ -1328,6 +1213,4 @@ var (
 	forward_KeyManagement_SetGasLimit_0 = runtime.ForwardResponseMessage
 
 	forward_KeyManagement_DeleteGasLimit_0 = runtime.ForwardResponseMessage
-
-	forward_KeyManagement_SetVoluntaryExit_0 = runtime.ForwardResponseMessage
 )

proto/eth/service/key_management.proto

@@ -18,7 +18,6 @@ package ethereum.eth.service;
 import "google/api/annotations.proto";
 import "google/protobuf/descriptor.proto";
 import "google/protobuf/empty.proto";
-import "proto/eth/ext/options.proto";
 
 option csharp_namespace = "Ethereum.Eth.Service";
 option go_package = "github.com/prysmaticlabs/prysm/v4/proto/eth/service";
@@ -218,24 +217,6 @@ service KeyManagement {
     };
   }
 
-  // SetVoluntaryExit creates a signed voluntary exit message and returns a VoluntaryExit object.
-  //
-  //  Spec page: https://ethereum.github.io/keymanager-APIs/?urls.primaryName=dev#/Voluntary%20Exit/signVoluntaryExit
-  //
-  // HTTP response status codes:
-  //  - 200: Successfully created and signed voluntary exit
-  //  - 400: Bad request, malformed request
-  //  - 401: Unauthorized, no token is found.
-  //  - 403: Forbidden, a token is found but is invalid
-  //  - 404: Path not found
-  //  - 500: Validator internal error
-  rpc SetVoluntaryExit(SetVoluntaryExitRequest) returns (SetVoluntaryExitResponse) {
-    option (google.api.http) = {
-      post: "/internal/eth/v1/validator/{pubkey}/voluntary_exit",
-      body: "*"
-    };
-  }
-
 }
 
 message ListKeystoresResponse {
@@ -371,20 +352,3 @@ message SetGasLimitRequest {
 message DeleteGasLimitRequest {
   bytes pubkey = 1;
 }
-
-message SetVoluntaryExitRequest {
-  bytes pubkey = 1 [(ethereum.eth.ext.ssz_size) = "48"];
-  uint64 epoch = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Epoch"];
-}
-
-message SetVoluntaryExitResponse {
-  message SignedVoluntaryExit {
-    message VoluntaryExit {
-      uint64 epoch = 1 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.Epoch"];
-      uint64 validator_index = 2 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v4/consensus-types/primitives.ValidatorIndex"];
-    }
-    VoluntaryExit message = 1;
-    bytes signature = 2;
-  }
-  SignedVoluntaryExit data = 1;
-}

proto/prysm/v1alpha1/cloners_test.go

@@ -451,8 +451,14 @@ func TestCopyBlindedBeaconBlockBodyCapella(t *testing.T) {
 
 func bytes(length int) []byte {
 	b := make([]byte, length)
+	_, err := rand.Read(b)
+	if err != nil {
+		panic(err)
+	}
 	for i := 0; i < length; i++ {
-		b[i] = uint8(rand.Int31n(255) + 1)
+		if b[i] == 0x00 {
+			b[i] = uint8(rand.Int())
+		}
 	}
 	return b
 }

testing/endtoend/component_handler_test.go

@@ -256,7 +256,7 @@ func (c *componentHandler) required() []e2etypes.ComponentRunner {
 func (c *componentHandler) printPIDs(logger func(string, ...interface{})) {
 	msg := "\nPID of components. Attach a debugger... if you dare!\n\n"
 
-	msg += "This test PID: " + strconv.Itoa(os.Getpid()) + " (parent=" + strconv.Itoa(os.Getppid()) + ")\n"
+	msg = "This test PID: " + strconv.Itoa(os.Getpid()) + " (parent=" + strconv.Itoa(os.Getppid()) + ")\n"
 
 	// Beacon chain nodes
 	msg += fmt.Sprintf("Beacon chain nodes: %v\n", PIDsFromMultiComponentRunner(c.beaconNodes))

testing/endtoend/components/eth1/transactions.go

@@ -114,7 +114,7 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, f *filler.Filler
 	for i := uint64(0); i < N; i++ {
 		index := i
 		g.Go(func() error {
-			tx, err := txfuzz.RandomValidTx(client, f, sender, nonce+index, gasPrice, nil, al)
+			tx, err := txfuzz.RandomValidTx(client, f, sender, nonce+index, expectedPrice, nil, al)
 			if err != nil {
 				// In the event the transaction constructed is not valid, we continue with the routine
 				// rather than complete stop it.
@@ -129,12 +129,9 @@ func SendTransaction(client *rpc.Client, key *ecdsa.PrivateKey, f *filler.Filler
 				return nil
 			}
 			err = backend.SendTransaction(context.Background(), signedTx)
-			if err != nil {
-				// We continue on if the constructed transaction is invalid
-				// and can't be submitted on chain.
-				//nolint:nilerr
-				return nil
-			}
+			// We continue on if the constructed transaction is invalid
+			// and can't be submitted on chain.
+			//nolint:nilerr
 			return nil
 		})
 	}

testing/endtoend/components/lighthouse_validator.go

@@ -172,6 +172,11 @@ func (v *LighthouseValidatorNode) Start(ctx context.Context) error {
 	}
 
 	_, _, index, _ := v.config, v.validatorNum, v.index, v.offset
+	beaconRPCPort := e2e.TestParams.Ports.PrysmBeaconNodeRPCPort + index
+	if beaconRPCPort >= e2e.TestParams.Ports.PrysmBeaconNodeRPCPort+e2e.TestParams.BeaconNodeCount {
+		// Point any extra validator clients to a node we know is running.
+		beaconRPCPort = e2e.TestParams.Ports.PrysmBeaconNodeRPCPort
+	}
 	kPath := e2e.TestParams.TestPath + fmt.Sprintf("/lighthouse-validator-%d", index)
 	testNetDir := e2e.TestParams.TestPath + fmt.Sprintf("/lighthouse-testnet-%d", index)
 	httpPort := e2e.TestParams.Ports.LighthouseBeaconNodeHTTPPort

testing/endtoend/endtoend_test.go

@@ -516,6 +516,7 @@ func (r *testRunner) defaultEndToEndRun() error {
 		if err := r.testCheckpointSync(ctx, g, index, conns, httpEndpoints[0], benr, menr); err != nil {
 			return errors.Wrap(err, "checkpoint sync test failed")
 		}
+		index += 1
 	}
 
 	if config.ExtraEpochs > 0 {

testing/spectest/shared/altair/rewards/rewards_penalties.go

@@ -76,16 +76,9 @@ func runPrecomputeRewardsAndPenaltiesTest(t *testing.T, testFolderPath string) {
 	require.NoError(t, err)
 	vp, bp, err = altair.ProcessEpochParticipation(ctx, preBeaconState, bp, vp)
 	require.NoError(t, err)
-	deltas, err := altair.AttestationsDelta(preBeaconState, bp, vp)
+	rewards, penalties, err := altair.AttestationsDelta(preBeaconState, bp, vp)
 	require.NoError(t, err)
 
-	rewards := make([]uint64, len(deltas))
-	penalties := make([]uint64, len(deltas))
-	for i, d := range deltas {
-		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty
-	}
-
 	totalSpecTestRewards := make([]uint64, len(rewards))
 	totalSpecTestPenalties := make([]uint64, len(penalties))
 

testing/spectest/shared/bellatrix/rewards/rewards_penalties.go

@@ -80,16 +80,9 @@ func runPrecomputeRewardsAndPenaltiesTest(t *testing.T, testFolderPath string) {
 	require.NoError(t, err)
 	vp, bp, err = altair.ProcessEpochParticipation(ctx, preBeaconState, bp, vp)
 	require.NoError(t, err)
-	deltas, err := altair.AttestationsDelta(preBeaconState, bp, vp)
+	rewards, penalties, err := altair.AttestationsDelta(preBeaconState, bp, vp)
 	require.NoError(t, err)
 
-	rewards := make([]uint64, len(deltas))
-	penalties := make([]uint64, len(deltas))
-	for i, d := range deltas {
-		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty
-	}
-
 	totalSpecTestRewards := make([]uint64, len(rewards))
 	totalSpecTestPenalties := make([]uint64, len(penalties))
 

testing/spectest/shared/capella/rewards/rewards_penalties.go

@@ -80,16 +80,9 @@ func runPrecomputeRewardsAndPenaltiesTest(t *testing.T, testFolderPath string) {
 	require.NoError(t, err)
 	vp, bp, err = altair.ProcessEpochParticipation(ctx, preBeaconState, bp, vp)
 	require.NoError(t, err)
-	deltas, err := altair.AttestationsDelta(preBeaconState, bp, vp)
+	rewards, penalties, err := altair.AttestationsDelta(preBeaconState, bp, vp)
 	require.NoError(t, err)
 
-	rewards := make([]uint64, len(deltas))
-	penalties := make([]uint64, len(deltas))
-	for i, d := range deltas {
-		rewards[i] = d.HeadReward + d.SourceReward + d.TargetReward
-		penalties[i] = d.SourcePenalty + d.TargetPenalty
-	}
-
 	totalSpecTestRewards := make([]uint64, len(rewards))
 	totalSpecTestPenalties := make([]uint64, len(penalties))
 

tools/cross-toolchain/darwin_cc_hack.bzl

@@ -1,114 +0,0 @@
-load("@bazel_tools//tools/cpp:unix_cc_configure.bzl", "configure_unix_toolchain")
-load(
-    "@bazel_tools//tools/cpp:lib_cc_configure.bzl",
-    "get_cpu_value",
-    "resolve_labels",
-)
-
-"""
-This file is a copy of https://github.com/bazelbuild/bazel/blob/master/tools/cpp/cc_configure.bzl
-with some minor changes. The original file is licensed under Apache 2.0 license. The gist of this
-is that we want darwin to register the local toolchain and disregard the environment variable of
-BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN. We must support a local toolchain for darwin until
-hermetic_cc_toolchain supports darwin's sysroot in a hermetic way.
-"""
-
-def cc_autoconf_toolchains_impl(repository_ctx):
-    """Generate BUILD file with 'toolchain' targets for the local host C++ toolchain.
-
-    Args:
-      repository_ctx: repository context
-    """
-
-    cpu_value = get_cpu_value(repository_ctx)
-
-    if cpu_value.startswith("darwin"):
-        paths = resolve_labels(repository_ctx, [
-            "@bazel_tools//tools/cpp:BUILD.toolchains.tpl",
-        ])
-        repository_ctx.template(
-            "BUILD",
-            paths["@bazel_tools//tools/cpp:BUILD.toolchains.tpl"],
-            {"%{name}": get_cpu_value(repository_ctx)},
-        )
-    else:
-        repository_ctx.file("BUILD", "# C++ toolchain autoconfiguration was disabled by BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN env variable.")
-
-
-def cc_autoconf_impl(repository_ctx, overriden_tools = dict()):
-    """Generate BUILD file with 'cc_toolchain' targets for the local host C++ toolchain.
-
-    Args:
-       repository_ctx: repository context
-       overriden_tools: dict of tool paths to use instead of autoconfigured tools
-    """
-    cpu_value = get_cpu_value(repository_ctx)
-
-    if cpu_value.startswith("darwin"):
-        print("Configuring local C++ toolchain for Darwin. This is non-hermetic and builds may " + 
-        "not be reproducible. Consider building on linux for a hermetic build.")
-        configure_unix_toolchain(repository_ctx, cpu_value, overriden_tools)
-    else: 
-        paths = resolve_labels(repository_ctx, [
-            "@bazel_tools//tools/cpp:BUILD.empty.tpl",
-            "@bazel_tools//tools/cpp:empty_cc_toolchain_config.bzl",
-        ])
-        repository_ctx.symlink(paths["@bazel_tools//tools/cpp:empty_cc_toolchain_config.bzl"], "cc_toolchain_config.bzl")
-        repository_ctx.template("BUILD", paths["@bazel_tools//tools/cpp:BUILD.empty.tpl"], {
-            "%{cpu}": get_cpu_value(repository_ctx),
-        })
-
-cc_autoconf_toolchains = repository_rule(
-    environ = [
-        "BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN",
-    ],
-    implementation = cc_autoconf_toolchains_impl,
-    configure = True,
-)
-
-cc_autoconf = repository_rule(
-    environ = [
-        "ABI_LIBC_VERSION",
-        "ABI_VERSION",
-        "BAZEL_COMPILER",
-        "BAZEL_HOST_SYSTEM",
-        "BAZEL_CONLYOPTS",
-        "BAZEL_CXXOPTS",
-        "BAZEL_LINKOPTS",
-        "BAZEL_LINKLIBS",
-        "BAZEL_LLVM_COV",
-        "BAZEL_LLVM_PROFDATA",
-        "BAZEL_PYTHON",
-        "BAZEL_SH",
-        "BAZEL_TARGET_CPU",
-        "BAZEL_TARGET_LIBC",
-        "BAZEL_TARGET_SYSTEM",
-        "BAZEL_DO_NOT_DETECT_CPP_TOOLCHAIN",
-        "BAZEL_USE_LLVM_NATIVE_COVERAGE",
-        "BAZEL_LLVM",
-        "BAZEL_IGNORE_SYSTEM_HEADERS_VERSIONS",
-        "USE_CLANG_CL",
-        "CC",
-        "CC_CONFIGURE_DEBUG",
-        "CC_TOOLCHAIN_NAME",
-        "CPLUS_INCLUDE_PATH",
-        "DEVELOPER_DIR",
-        "GCOV",
-        "LIBTOOL",
-        "HOMEBREW_RUBY_PATH",
-        "SYSTEMROOT",
-        "USER",
-    ],
-    implementation = cc_autoconf_impl,
-    configure = True,
-)
-
-def configure_nonhermetic_darwin():
-    """A C++ configuration rules that generate the crosstool file."""
-    cc_autoconf_toolchains(name = "local_config_cc_toolchains")
-    cc_autoconf(name = "local_config_cc")
-    native.bind(name = "cc_toolchain", actual = "@local_config_cc//:toolchain")
-    native.register_toolchains(
-        # Use register_toolchain's target pattern expansion to register all toolchains in the package.
-        "@local_config_cc_toolchains//:all",
-    )

validator/accounts/accounts_exit.go

@@ -84,19 +84,11 @@ func PerformVoluntaryExit(
 	ctx context.Context, cfg PerformExitCfg,
 ) (rawExitedKeys [][]byte, formattedExitedKeys []string, err error) {
 	var rawNotExitedKeys [][]byte
-	genesisResponse, err := cfg.NodeClient.GetGenesis(ctx, &emptypb.Empty{})
-	if err != nil {
-		log.WithError(err).Errorf("voluntary exit failed: %v", err)
-	}
 	for i, key := range cfg.RawPubKeys {
 		// When output directory is present, only create the signed exit, but do not propose it.
 		// Otherwise, propose the exit immediately.
-		epoch, err := client.CurrentEpoch(genesisResponse.GenesisTime)
-		if err != nil {
-			log.WithError(err).Errorf("voluntary exit failed: %v", err)
-		}
 		if len(cfg.OutputDirectory) > 0 {
-			sve, err := client.CreateSignedVoluntaryExit(ctx, cfg.ValidatorClient, cfg.Keymanager.Sign, key, epoch)
+			sve, err := client.CreateSignedVoluntaryExit(ctx, cfg.ValidatorClient, cfg.NodeClient, cfg.Keymanager.Sign, key)
 			if err != nil {
 				rawNotExitedKeys = append(rawNotExitedKeys, key)
 				msg := err.Error()
@@ -109,7 +101,7 @@ func PerformVoluntaryExit(
 			} else if err := writeSignedVoluntaryExitJSON(ctx, sve, cfg.OutputDirectory); err != nil {
 				log.WithError(err).Error("failed to write voluntary exit")
 			}
-		} else if err := client.ProposeExit(ctx, cfg.ValidatorClient, cfg.Keymanager.Sign, key, epoch); err != nil {
+		} else if err := client.ProposeExit(ctx, cfg.ValidatorClient, cfg.NodeClient, cfg.Keymanager.Sign, key); err != nil {
 			rawNotExitedKeys = append(rawNotExitedKeys, key)
 
 			msg := err.Error()

validator/accounts/testing/mock.go

@@ -92,113 +92,113 @@ type MockValidator struct {
 	proposerSettings *validatorserviceconfig.ProposerSettings
 }
 
-func (_ *MockValidator) LogSyncCommitteeMessagesSubmitted() {}
+func (_ MockValidator) LogSyncCommitteeMessagesSubmitted() {}
 
-func (_ *MockValidator) Done() {
+func (_ MockValidator) Done() {
 	panic("implement me")
 }
 
-func (_ *MockValidator) WaitForChainStart(_ context.Context) error {
+func (_ MockValidator) WaitForChainStart(_ context.Context) error {
 	panic("implement me")
 }
 
-func (_ *MockValidator) WaitForSync(_ context.Context) error {
+func (_ MockValidator) WaitForSync(_ context.Context) error {
 	panic("implement me")
 }
 
-func (_ *MockValidator) WaitForActivation(_ context.Context, _ chan [][48]byte) error {
+func (_ MockValidator) WaitForActivation(_ context.Context, _ chan [][48]byte) error {
 	panic("implement me")
 }
 
-func (_ *MockValidator) CanonicalHeadSlot(_ context.Context) (primitives.Slot, error) {
+func (_ MockValidator) CanonicalHeadSlot(_ context.Context) (primitives.Slot, error) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) NextSlot() <-chan primitives.Slot {
+func (_ MockValidator) NextSlot() <-chan primitives.Slot {
 	panic("implement me")
 }
 
-func (_ *MockValidator) SlotDeadline(_ primitives.Slot) time.Time {
+func (_ MockValidator) SlotDeadline(_ primitives.Slot) time.Time {
 	panic("implement me")
 }
 
-func (_ *MockValidator) LogValidatorGainsAndLosses(_ context.Context, _ primitives.Slot) error {
+func (_ MockValidator) LogValidatorGainsAndLosses(_ context.Context, _ primitives.Slot) error {
 	panic("implement me")
 }
 
-func (_ *MockValidator) UpdateDuties(_ context.Context, _ primitives.Slot) error {
+func (_ MockValidator) UpdateDuties(_ context.Context, _ primitives.Slot) error {
 	panic("implement me")
 }
 
-func (_ *MockValidator) RolesAt(_ context.Context, _ primitives.Slot) (map[[48]byte][]iface2.ValidatorRole, error) {
+func (_ MockValidator) RolesAt(_ context.Context, _ primitives.Slot) (map[[48]byte][]iface2.ValidatorRole, error) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) SubmitAttestation(_ context.Context, _ primitives.Slot, _ [48]byte) {
+func (_ MockValidator) SubmitAttestation(_ context.Context, _ primitives.Slot, _ [48]byte) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) ProposeBlock(_ context.Context, _ primitives.Slot, _ [48]byte) {
+func (_ MockValidator) ProposeBlock(_ context.Context, _ primitives.Slot, _ [48]byte) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) SubmitAggregateAndProof(_ context.Context, _ primitives.Slot, _ [48]byte) {
+func (_ MockValidator) SubmitAggregateAndProof(_ context.Context, _ primitives.Slot, _ [48]byte) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) SubmitSyncCommitteeMessage(_ context.Context, _ primitives.Slot, _ [48]byte) {
+func (_ MockValidator) SubmitSyncCommitteeMessage(_ context.Context, _ primitives.Slot, _ [48]byte) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) SubmitSignedContributionAndProof(_ context.Context, _ primitives.Slot, _ [48]byte) {
+func (_ MockValidator) SubmitSignedContributionAndProof(_ context.Context, _ primitives.Slot, _ [48]byte) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) LogAttestationsSubmitted() {
+func (_ MockValidator) LogAttestationsSubmitted() {
 	panic("implement me")
 }
 
-func (_ *MockValidator) UpdateDomainDataCaches(_ context.Context, _ primitives.Slot) {
+func (_ MockValidator) UpdateDomainDataCaches(_ context.Context, _ primitives.Slot) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) WaitForKeymanagerInitialization(_ context.Context) error {
+func (_ MockValidator) WaitForKeymanagerInitialization(_ context.Context) error {
 	panic("implement me")
 }
 
-func (m *MockValidator) Keymanager() (keymanager.IKeymanager, error) {
+func (m MockValidator) Keymanager() (keymanager.IKeymanager, error) {
 	return m.Km, nil
 }
 
-func (_ *MockValidator) ReceiveBlocks(_ context.Context, _ chan<- error) {
+func (_ MockValidator) ReceiveBlocks(_ context.Context, _ chan<- error) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) HandleKeyReload(_ context.Context, _ [][48]byte) (bool, error) {
+func (_ MockValidator) HandleKeyReload(_ context.Context, _ [][48]byte) (bool, error) {
 	panic("implement me")
 }
 
-func (_ *MockValidator) CheckDoppelGanger(_ context.Context) error {
+func (_ MockValidator) CheckDoppelGanger(_ context.Context) error {
 	panic("implement me")
 }
 
 // HasProposerSettings for mocking
-func (*MockValidator) HasProposerSettings() bool {
+func (MockValidator) HasProposerSettings() bool {
 	panic("implement me")
 }
 
 // PushProposerSettings for mocking
-func (_ *MockValidator) PushProposerSettings(_ context.Context, _ keymanager.IKeymanager, _ primitives.Slot, _ time.Time) error {
+func (_ MockValidator) PushProposerSettings(_ context.Context, _ keymanager.IKeymanager, _ primitives.Slot, _ time.Time) error {
 	panic("implement me")
 }
 
 // SetPubKeyToValidatorIndexMap for mocking
-func (_ *MockValidator) SetPubKeyToValidatorIndexMap(_ context.Context, _ keymanager.IKeymanager) error {
+func (_ MockValidator) SetPubKeyToValidatorIndexMap(_ context.Context, _ keymanager.IKeymanager) error {
 	panic("implement me")
 }
 
 // SignValidatorRegistrationRequest for mocking
-func (_ *MockValidator) SignValidatorRegistrationRequest(_ context.Context, _ iface2.SigningFunc, _ *ethpb.ValidatorRegistrationV1) (*ethpb.SignedValidatorRegistrationV1, error) {
+func (_ MockValidator) SignValidatorRegistrationRequest(_ context.Context, _ iface2.SigningFunc, _ *ethpb.ValidatorRegistrationV1) (*ethpb.SignedValidatorRegistrationV1, error) {
 	panic("implement me")
 }
 
@@ -208,7 +208,6 @@ func (m *MockValidator) ProposerSettings() *validatorserviceconfig.ProposerSetti
 }
 
 // SetProposerSettings for mocking
-func (m *MockValidator) SetProposerSettings(_ context.Context, settings *validatorserviceconfig.ProposerSettings) error {
+func (m *MockValidator) SetProposerSettings(settings *validatorserviceconfig.ProposerSettings) {
 	m.proposerSettings = settings
-	return nil
 }

validator/client/BUILD.bazel

@@ -80,7 +80,6 @@ go_library(
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_bazel_rules_go//proto/wkt:empty_go_proto",
-        "@io_bazel_rules_go//proto/wkt:timestamp_go_proto",
         "@io_opencensus_go//plugin/ocgrpc:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_grpc//:go_default_library",
@@ -174,5 +173,6 @@ go_test(
         "@org_golang_google_grpc//metadata:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
+        "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",
     ],
 )

validator/client/iface/validator.go

@@ -63,7 +63,7 @@ type Validator interface {
 	PushProposerSettings(ctx context.Context, km keymanager.IKeymanager, slot primitives.Slot, deadline time.Time) error
 	SignValidatorRegistrationRequest(ctx context.Context, signer SigningFunc, newValidatorRegistration *ethpb.ValidatorRegistrationV1) (*ethpb.SignedValidatorRegistrationV1, error)
 	ProposerSettings() *validatorserviceconfig.ProposerSettings
-	SetProposerSettings(context.Context, *validatorserviceconfig.ProposerSettings) error
+	SetProposerSettings(*validatorserviceconfig.ProposerSettings)
 }
 
 // SigningFunc interface defines a type for the a function that signs a message

validator/client/propose.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/golang/protobuf/ptypes/timestamp"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v4/async"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing"
@@ -26,6 +25,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/validator/client/iface"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
+	"google.golang.org/protobuf/types/known/emptypb"
 )
 
 const domainDataErr = "could not get domain data"
@@ -198,14 +198,14 @@ func (v *validator) ProposeBlock(ctx context.Context, slot primitives.Slot, pubK
 func ProposeExit(
 	ctx context.Context,
 	validatorClient iface.ValidatorClient,
+	nodeClient iface.NodeClient,
 	signer iface.SigningFunc,
 	pubKey []byte,
-	epoch primitives.Epoch,
 ) error {
 	ctx, span := trace.StartSpan(ctx, "validator.ProposeExit")
 	defer span.End()
 
-	signedExit, err := CreateSignedVoluntaryExit(ctx, validatorClient, signer, pubKey, epoch)
+	signedExit, err := CreateSignedVoluntaryExit(ctx, validatorClient, nodeClient, signer, pubKey)
 	if err != nil {
 		return errors.Wrap(err, "failed to create signed voluntary exit")
 	}
@@ -217,22 +217,16 @@ func ProposeExit(
 	span.AddAttributes(
 		trace.StringAttribute("exitRoot", fmt.Sprintf("%#x", exitResp.ExitRoot)),
 	)
-	return nil
-}
 
-func CurrentEpoch(genesisTime *timestamp.Timestamp) (primitives.Epoch, error) {
-	totalSecondsPassed := prysmTime.Now().Unix() - genesisTime.Seconds
-	currentSlot := primitives.Slot((uint64(totalSecondsPassed)) / params.BeaconConfig().SecondsPerSlot)
-	currentEpoch := slots.ToEpoch(currentSlot)
-	return currentEpoch, nil
+	return nil
 }
 
 func CreateSignedVoluntaryExit(
 	ctx context.Context,
 	validatorClient iface.ValidatorClient,
+	nodeClient iface.NodeClient,
 	signer iface.SigningFunc,
 	pubKey []byte,
-	epoch primitives.Epoch,
 ) (*ethpb.SignedVoluntaryExit, error) {
 	ctx, span := trace.StartSpan(ctx, "validator.CreateSignedVoluntaryExit")
 	defer span.End()
@@ -241,12 +235,15 @@ func CreateSignedVoluntaryExit(
 	if err != nil {
 		return nil, errors.Wrap(err, "gRPC call to get validator index failed")
 	}
-	exit := &ethpb.VoluntaryExit{Epoch: epoch, ValidatorIndex: indexResponse.Index}
-	slot, err := slots.EpochStart(epoch)
+	genesisResponse, err := nodeClient.GetGenesis(ctx, &emptypb.Empty{})
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to retrieve slot")
+		return nil, errors.Wrap(err, "gRPC call to get genesis time failed")
 	}
-	sig, err := signVoluntaryExit(ctx, validatorClient, signer, pubKey, exit, slot)
+	totalSecondsPassed := prysmTime.Now().Unix() - genesisResponse.GenesisTime.Seconds
+	currentEpoch := primitives.Epoch(uint64(totalSecondsPassed) / uint64(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot)))
+	currentSlot := slots.CurrentSlot(uint64(genesisResponse.GenesisTime.AsTime().Unix()))
+	exit := &ethpb.VoluntaryExit{Epoch: currentEpoch, ValidatorIndex: indexResponse.Index}
+	sig, err := signVoluntaryExit(ctx, validatorClient, signer, pubKey, exit, currentSlot)
 	if err != nil {
 		return nil, errors.Wrap(err, "failed to sign voluntary exit")
 	}

validator/client/propose_test.go

@@ -6,6 +6,7 @@ import (
 	"errors"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/golang/mock/gomock"
 	"github.com/prysmaticlabs/prysm/v4/beacon-chain/core/signing"
@@ -27,6 +28,7 @@ import (
 	testing2 "github.com/prysmaticlabs/prysm/v4/validator/db/testing"
 	"github.com/prysmaticlabs/prysm/v4/validator/graffiti"
 	logTest "github.com/sirupsen/logrus/hooks/test"
+	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 type mocks struct {
@@ -646,15 +648,39 @@ func TestProposeExit_ValidatorIndexFailed(t *testing.T) {
 	err := ProposeExit(
 		context.Background(),
 		m.validatorClient,
+		m.nodeClient,
 		m.signfunc,
 		validatorKey.PublicKey().Marshal(),
-		params.BeaconConfig().GenesisEpoch,
 	)
 	assert.NotNil(t, err)
 	assert.ErrorContains(t, "uh oh", err)
 	assert.ErrorContains(t, "gRPC call to get validator index failed", err)
 }
 
+func TestProposeExit_GetGenesisFailed(t *testing.T) {
+	_, m, validatorKey, finish := setup(t)
+	defer finish()
+
+	m.validatorClient.EXPECT().
+		ValidatorIndex(gomock.Any(), gomock.Any()).
+		Return(nil, nil)
+
+	m.nodeClient.EXPECT().
+		GetGenesis(gomock.Any(), gomock.Any()).
+		Return(nil, errors.New("uh oh"))
+
+	err := ProposeExit(
+		context.Background(),
+		m.validatorClient,
+		m.nodeClient,
+		m.signfunc,
+		validatorKey.PublicKey().Marshal(),
+	)
+	assert.NotNil(t, err)
+	assert.ErrorContains(t, "uh oh", err)
+	assert.ErrorContains(t, "gRPC call to get genesis time failed", err)
+}
+
 func TestProposeExit_DomainDataFailed(t *testing.T) {
 	_, m, validatorKey, finish := setup(t)
 	defer finish()
@@ -663,6 +689,15 @@ func TestProposeExit_DomainDataFailed(t *testing.T) {
 		ValidatorIndex(gomock.Any(), gomock.Any()).
 		Return(&ethpb.ValidatorIndexResponse{Index: 1}, nil)
 
+	// Any time in the past will suffice
+	genesisTime := &timestamppb.Timestamp{
+		Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
+	}
+
+	m.nodeClient.EXPECT().
+		GetGenesis(gomock.Any(), gomock.Any()).
+		Return(&ethpb.Genesis{GenesisTime: genesisTime}, nil)
+
 	m.validatorClient.EXPECT().
 		DomainData(gomock.Any(), gomock.Any()).
 		Return(nil, errors.New("uh oh"))
@@ -670,9 +705,9 @@ func TestProposeExit_DomainDataFailed(t *testing.T) {
 	err := ProposeExit(
 		context.Background(),
 		m.validatorClient,
+		m.nodeClient,
 		m.signfunc,
 		validatorKey.PublicKey().Marshal(),
-		params.BeaconConfig().GenesisEpoch,
 	)
 	assert.NotNil(t, err)
 	assert.ErrorContains(t, domainDataErr, err)
@@ -688,6 +723,15 @@ func TestProposeExit_DomainDataIsNil(t *testing.T) {
 		ValidatorIndex(gomock.Any(), gomock.Any()).
 		Return(&ethpb.ValidatorIndexResponse{Index: 1}, nil)
 
+	// Any time in the past will suffice
+	genesisTime := &timestamppb.Timestamp{
+		Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
+	}
+
+	m.nodeClient.EXPECT().
+		GetGenesis(gomock.Any(), gomock.Any()).
+		Return(&ethpb.Genesis{GenesisTime: genesisTime}, nil)
+
 	m.validatorClient.EXPECT().
 		DomainData(gomock.Any(), gomock.Any()).
 		Return(nil, nil)
@@ -695,9 +739,9 @@ func TestProposeExit_DomainDataIsNil(t *testing.T) {
 	err := ProposeExit(
 		context.Background(),
 		m.validatorClient,
+		m.nodeClient,
 		m.signfunc,
 		validatorKey.PublicKey().Marshal(),
-		params.BeaconConfig().GenesisEpoch,
 	)
 	assert.NotNil(t, err)
 	assert.ErrorContains(t, domainDataErr, err)
@@ -712,6 +756,15 @@ func TestProposeBlock_ProposeExitFailed(t *testing.T) {
 		ValidatorIndex(gomock.Any(), gomock.Any()).
 		Return(&ethpb.ValidatorIndexResponse{Index: 1}, nil)
 
+	// Any time in the past will suffice
+	genesisTime := &timestamppb.Timestamp{
+		Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
+	}
+
+	m.nodeClient.EXPECT().
+		GetGenesis(gomock.Any(), gomock.Any()).
+		Return(&ethpb.Genesis{GenesisTime: genesisTime}, nil)
+
 	m.validatorClient.EXPECT().
 		DomainData(gomock.Any(), gomock.Any()).
 		Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil)
@@ -723,9 +776,9 @@ func TestProposeBlock_ProposeExitFailed(t *testing.T) {
 	err := ProposeExit(
 		context.Background(),
 		m.validatorClient,
+		m.nodeClient,
 		m.signfunc,
 		validatorKey.PublicKey().Marshal(),
-		params.BeaconConfig().GenesisEpoch,
 	)
 	assert.NotNil(t, err)
 	assert.ErrorContains(t, "uh oh", err)
@@ -740,6 +793,15 @@ func TestProposeExit_BroadcastsBlock(t *testing.T) {
 		ValidatorIndex(gomock.Any(), gomock.Any()).
 		Return(&ethpb.ValidatorIndexResponse{Index: 1}, nil)
 
+	// Any time in the past will suffice
+	genesisTime := &timestamppb.Timestamp{
+		Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
+	}
+
+	m.nodeClient.EXPECT().
+		GetGenesis(gomock.Any(), gomock.Any()).
+		Return(&ethpb.Genesis{GenesisTime: genesisTime}, nil)
+
 	m.validatorClient.EXPECT().
 		DomainData(gomock.Any(), gomock.Any()).
 		Return(&ethpb.DomainResponse{SignatureDomain: make([]byte, 32)}, nil)
@@ -751,9 +813,9 @@ func TestProposeExit_BroadcastsBlock(t *testing.T) {
 	assert.NoError(t, ProposeExit(
 		context.Background(),
 		m.validatorClient,
+		m.nodeClient,
 		m.signfunc,
 		validatorKey.PublicKey().Marshal(),
-		params.BeaconConfig().GenesisEpoch,
 	))
 }
 

validator/client/runner.go

@@ -67,7 +67,7 @@ func run(ctx context.Context, v iface.Validator) {
 			}
 		}
 	} else {
-		log.Warn("Validator client started without proposer settings such as fee recipient" +
+		log.Warnln("Validator client started without proposer settings such as fee recipient" +
 			" and will continue to use settings provided in the beacon node.")
 	}
 
@@ -108,10 +108,9 @@ func run(ctx context.Context, v iface.Validator) {
 				continue
 			}
 
-			// create call on a separate thread to push proposer settings from the middle of an epoch.
-			if slots.SinceEpochStarts(slot) == params.BeaconConfig().SlotsPerEpoch/2 && v.ProposerSettings() != nil {
+			if slots.IsEpochStart(slot) && v.ProposerSettings() != nil {
 				go func() {
-					// deadline set for 1 epoch from call to not overlap.
+					// deadline set for end of epoch
 					epochDeadline := v.SlotDeadline(slot + params.BeaconConfig().SlotsPerEpoch - 1)
 					if err := v.PushProposerSettings(ctx, km, slot, epochDeadline); err != nil {
 						log.WithError(err).Warn("Failed to update proposer settings")

validator/client/runner_test.go

@@ -225,14 +225,13 @@ func notActive(t *testing.T) [fieldparams.BLSPubkeyLength]byte {
 
 func TestUpdateProposerSettingsAt_EpochStart(t *testing.T) {
 	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}}
-	err := v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+	v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 		DefaultConfig: &validatorserviceconfig.ProposerOption{
 			FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
 				FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"),
 			},
 		},
 	})
-	require.NoError(t, err)
 	ctx, cancel := context.WithCancel(context.Background())
 	hook := logTest.NewGlobal()
 	slot := params.BeaconConfig().SlotsPerEpoch
@@ -250,14 +249,13 @@ func TestUpdateProposerSettingsAt_EpochStart(t *testing.T) {
 
 func TestUpdateProposerSettingsAt_EpochEndExceeded(t *testing.T) {
 	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, ProposerSettingWait: time.Duration(params.BeaconConfig().SecondsPerSlot+1) * time.Second}
-	err := v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+	v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 		DefaultConfig: &validatorserviceconfig.ProposerOption{
 			FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
 				FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"),
 			},
 		},
 	})
-	require.NoError(t, err)
 	ctx, cancel := context.WithCancel(context.Background())
 	hook := logTest.NewGlobal()
 	slot := params.BeaconConfig().SlotsPerEpoch - 1 //have it set close to the end of epoch
@@ -275,14 +273,13 @@ func TestUpdateProposerSettingsAt_EpochEndExceeded(t *testing.T) {
 
 func TestUpdateProposerSettingsAt_EpochEndOk(t *testing.T) {
 	v := &testutil.FakeValidator{Km: &mockKeymanager{accountsChangedFeed: &event.Feed{}}, ProposerSettingWait: time.Duration(params.BeaconConfig().SecondsPerSlot-1) * time.Second}
-	err := v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+	v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 		DefaultConfig: &validatorserviceconfig.ProposerOption{
 			FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
 				FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"),
 			},
 		},
 	})
-	require.NoError(t, err)
 	ctx, cancel := context.WithCancel(context.Background())
 	hook := logTest.NewGlobal()
 	slot := params.BeaconConfig().SlotsPerEpoch - 1 //have it set close to the end of epoch
@@ -304,14 +301,13 @@ func TestUpdateProposerSettings_ContinuesAfterValidatorRegistrationFails(t *test
 		ProposerSettingsErr: errors.Wrap(ErrBuilderValidatorRegistration, errSomeotherError.Error()),
 		Km:                  &mockKeymanager{accountsChangedFeed: &event.Feed{}},
 	}
-	err := v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+	v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 		DefaultConfig: &validatorserviceconfig.ProposerOption{
 			FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
 				FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455012BFEBf6177F1D2e9738D9"),
 			},
 		},
 	})
-	require.NoError(t, err)
 	ctx, cancel := context.WithCancel(context.Background())
 	hook := logTest.NewGlobal()
 	slot := params.BeaconConfig().SlotsPerEpoch

validator/client/service.go

@@ -188,6 +188,14 @@ func (v *ValidatorService) Start() {
 		return
 	}
 
+	// checks db if proposer settings exist if none is provided.
+	if v.proposerSettings == nil {
+		settings, err := v.db.ProposerSettings(v.ctx)
+		if err == nil {
+			v.proposerSettings = settings
+		}
+	}
+
 	validatorClient := validatorClientFactory.NewValidatorClient(v.conn)
 	beaconClient := beaconChainClientFactory.NewBeaconChainClient(v.conn)
 
@@ -275,13 +283,15 @@ func (v *ValidatorService) ProposerSettings() *validatorserviceconfig.ProposerSe
 
 // SetProposerSettings sets the proposer settings on the validator service as well as the underlying validator
 func (v *ValidatorService) SetProposerSettings(ctx context.Context, settings *validatorserviceconfig.ProposerSettings) error {
-	// validator service proposer settings is only used for pass through from node -> validator service -> validator.
-	// in memory use of proposer settings happens on validator.
+	if v.db == nil {
+		return errors.New("db is not set")
+	}
+	if err := v.db.SaveProposerSettings(ctx, settings); err != nil {
+		return err
+	}
 	v.proposerSettings = settings
-
-	// passes settings down to be updated in database and saved in memory.
-	// updates to validator porposer settings will be in the validator object and not validator service.
-	return v.validator.SetProposerSettings(ctx, settings)
+	v.validator.SetProposerSettings(settings)
+	return nil
 }
 
 // ConstructDialOptions constructs a list of grpc dial options

validator/client/testutil/mock_validator.go

@@ -281,7 +281,6 @@ func (f *FakeValidator) ProposerSettings() *validatorserviceconfig.ProposerSetti
 }
 
 // SetProposerSettings for mocking
-func (f *FakeValidator) SetProposerSettings(_ context.Context, settings *validatorserviceconfig.ProposerSettings) error {
+func (f *FakeValidator) SetProposerSettings(settings *validatorserviceconfig.ProposerSettings) {
 	f.proposerSettings = settings
-	return nil
 }

validator/client/validator.go

@@ -953,21 +953,12 @@ func (v *validator) logDuties(slot primitives.Slot, duties []*ethpb.DutiesRespon
 	}
 }
 
-// ProposerSettings gets the current proposer settings saved in memory validator
 func (v *validator) ProposerSettings() *validatorserviceconfig.ProposerSettings {
 	return v.proposerSettings
 }
 
-// SetProposerSettings sets and saves the passed in proposer settings overriding the in memory one
-func (v *validator) SetProposerSettings(ctx context.Context, settings *validatorserviceconfig.ProposerSettings) error {
-	if v.db == nil {
-		return errors.New("db is not set")
-	}
-	if err := v.db.SaveProposerSettings(ctx, settings); err != nil {
-		return err
-	}
+func (v *validator) SetProposerSettings(settings *validatorserviceconfig.ProposerSettings) {
 	v.proposerSettings = settings
-	return nil
 }
 
 // PushProposerSettings calls the prepareBeaconProposer RPC to set the fee recipient and also the register validator API if using a custom builder.

validator/client/validator_test.go

@@ -1403,7 +1403,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						GasLimit: 40000000,
 					},
 				}
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: config,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1415,7 +1415,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				client.EXPECT().SubmitValidatorRegistrations(
 					gomock.Any(),
 					gomock.Any(),
@@ -1485,7 +1484,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						GasLimit: 40000000,
 					},
 				}
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: config,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1497,7 +1496,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				client.EXPECT().SubmitValidatorRegistrations(
 					gomock.Any(),
 					gomock.Any(),
@@ -1559,7 +1557,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						FeeRecipient: common.HexToAddress("0x055Fb65722E7b2455043BFEBf6177F1D2e9738D9"),
 					},
 				}
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: config,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1567,7 +1565,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				return &v
 			},
 			feeRecipientMap: map[primitives.ValidatorIndex]string{
@@ -1602,7 +1599,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 				require.NoError(t, err)
 				keys, err := km.FetchValidatingPublicKeys(ctx)
 				require.NoError(t, err)
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: nil,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1614,7 +1611,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				v.pubkeyToValidatorIndex[keys[0]] = primitives.ValidatorIndex(1)
 				client.EXPECT().MultipleValidatorStatus(
 					gomock.Any(),
@@ -1663,7 +1659,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 				}
 				err := v.WaitForKeymanagerInitialization(ctx)
 				require.NoError(t, err)
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: nil,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1675,7 +1671,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				km, err := v.Keymanager()
 				require.NoError(t, err)
 				keys, err := km.FetchValidatingPublicKeys(ctx)
@@ -1750,7 +1745,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						FeeRecipient: common.Address{},
 					},
 				}
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: config,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1758,7 +1753,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				return &v
 			},
 		},
@@ -1793,7 +1787,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						FeeRecipient: common.HexToAddress("0x046Fb65722E7b2455043BFEBf6177F1D2e9738D9"),
 					},
 				}
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: config,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1801,7 +1795,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				return &v
 			},
 		},
@@ -1845,7 +1838,7 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						GasLimit: 40000000,
 					},
 				}
-				err = v.SetProposerSettings(context.Background(), &validatorserviceconfig.ProposerSettings{
+				v.SetProposerSettings(&validatorserviceconfig.ProposerSettings{
 					ProposeConfig: config,
 					DefaultConfig: &validatorserviceconfig.ProposerOption{
 						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
@@ -1857,7 +1850,6 @@ func TestValidator_PushProposerSettings(t *testing.T) {
 						},
 					},
 				})
-				require.NoError(t, err)
 				client.EXPECT().PrepareBeaconProposer(gomock.Any(), &ethpb.PrepareBeaconProposerRequest{
 					Recipients: []*ethpb.PrepareBeaconProposerRequest_FeeRecipientContainer{
 						{FeeRecipient: common.HexToAddress("0x0").Bytes(), ValidatorIndex: 1},

validator/db/kv/proposer_settings.go

@@ -121,11 +121,6 @@ func (s *Store) ProposerSettingsExists(ctx context.Context) (bool, error) {
 func (s *Store) SaveProposerSettings(ctx context.Context, settings *validatorServiceConfig.ProposerSettings) error {
 	_, span := trace.StartSpan(ctx, "validator.db.SaveProposerSettings")
 	defer span.End()
-	// nothing to save
-	if !settings.ShouldBeSaved() {
-		log.Warn("proposer settings are empty, nothing has been saved")
-		return nil
-	}
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(proposerSettingsBucket)
 		m, err := proto.Marshal(settings.ToPayload())

validator/node/BUILD.bazel

@@ -16,7 +16,6 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//validator/accounts:go_default_library",
-        "//validator/db/iface:go_default_library",
         "//validator/db/testing:go_default_library",
         "//validator/keymanager:go_default_library",
         "//validator/keymanager/remote-web3signer:go_default_library",

validator/node/node.go

@@ -227,7 +227,6 @@ func (c *ValidatorClient) initializeFromCLI(cliCtx *cli.Context) error {
 		if dataDir == "" && c.wallet != nil {
 			dataDir = c.wallet.AccountsDir()
 			if dataDir == "" {
-				// skipcq: RVV-A0003
 				log.Fatal(
 					"Could not determine your system'c HOME path, please specify a --datadir you wish " +
 						"to use for your validator data",
@@ -311,7 +310,6 @@ func (c *ValidatorClient) initializeForWeb(cliCtx *cli.Context) error {
 		if dataDir == "" {
 			dataDir = cmd.DefaultDataDir()
 			if dataDir == "" {
-				// skipcq: RVV-A0003
 				log.Fatal(
 					"Could not determine your system'c HOME path, please specify a --datadir you wish " +
 						"to use for your validator data",
@@ -498,20 +496,21 @@ func proposerSettings(cliCtx *cli.Context, db iface.ValidatorDB) (*validatorServ
 	if cliCtx.IsSet(flags.ProposerSettingsFlag.Name) && cliCtx.IsSet(flags.ProposerSettingsURLFlag.Name) {
 		return nil, errors.New("cannot specify both " + flags.ProposerSettingsFlag.Name + " and " + flags.ProposerSettingsURLFlag.Name)
 	}
-	builderConfigFromFlag, err := BuilderSettingsFromFlags(cliCtx)
-	if err != nil {
-		return nil, err
-	}
+
 	// is overridden by file and URL flags
 	if cliCtx.IsSet(flags.SuggestedFeeRecipientFlag.Name) &&
 		!cliCtx.IsSet(flags.ProposerSettingsFlag.Name) &&
 		!cliCtx.IsSet(flags.ProposerSettingsURLFlag.Name) {
 		suggestedFee := cliCtx.String(flags.SuggestedFeeRecipientFlag.Name)
+		builderConfig, err := BuilderSettingsFromFlags(cliCtx)
+		if err != nil {
+			return nil, err
+		}
 		fileConfig = &validatorpb.ProposerSettingsPayload{
 			ProposerConfig: nil,
 			DefaultConfig: &validatorpb.ProposerOptionPayload{
 				FeeRecipient: suggestedFee,
-				Builder:      builderConfigFromFlag.ToPayload(),
+				Builder:      builderConfig.ToPayload(),
 			},
 		}
 	}
@@ -527,13 +526,13 @@ func proposerSettings(cliCtx *cli.Context, db iface.ValidatorDB) (*validatorServ
 		}
 	}
 
-	// this condition triggers if SuggestedFeeRecipientFlag,ProposerSettingsFlag or ProposerSettingsURLFlag did not create any settings
+	// nothing is set, so just return nil
 	if fileConfig == nil {
-		// Checks the db or enable builder settings before starting the node without proposer settings
-		// starting the node without proposer settings, will skip API calls for push proposer settings and register validator
-		return handleNoProposerSettingsFlagsProvided(cliCtx, db, builderConfigFromFlag)
+		if cliCtx.Bool(flags.EnableBuilderFlag.Name) {
+			return nil, fmt.Errorf("%s flag can only be used when a default fee recipient is present on the validator client", flags.EnableBuilderFlag.Name)
+		}
+		return nil, nil
 	}
-
 	// convert file config to proposer config for internal use
 	vpSettings := &validatorServiceConfig.ProposerSettings{}
 
@@ -557,13 +556,16 @@ func proposerSettings(cliCtx *cli.Context, db iface.ValidatorDB) (*validatorServ
 		},
 		BuilderConfig: validatorServiceConfig.ToBuilderConfig(fileConfig.DefaultConfig.Builder),
 	}
-
-	if builderConfigFromFlag != nil {
-		config := builderConfigFromFlag
-		if config.GasLimit == validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit) && vpSettings.DefaultConfig.BuilderConfig != nil {
-			config.GasLimit = vpSettings.DefaultConfig.BuilderConfig.GasLimit
+	if vpSettings.DefaultConfig.BuilderConfig == nil {
+		builderConfig, err := BuilderSettingsFromFlags(cliCtx)
+		if err != nil {
+			return nil, err
 		}
-		vpSettings.DefaultConfig.BuilderConfig = config
+		vpSettings.DefaultConfig.BuilderConfig = builderConfig
+	}
+
+	if vpSettings.DefaultConfig.BuilderConfig != nil {
+		vpSettings.DefaultConfig.BuilderConfig.GasLimit = reviewGasLimit(vpSettings.DefaultConfig.BuilderConfig.GasLimit)
 	}
 
 	if psExists {
@@ -592,14 +594,14 @@ func proposerSettings(cliCtx *cli.Context, db iface.ValidatorDB) (*validatorServ
 			if err := warnNonChecksummedAddress(option.FeeRecipient); err != nil {
 				return nil, err
 			}
-			if builderConfigFromFlag != nil {
-				config := builderConfigFromFlag.ToPayload()
-				if config.GasLimit == validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit) && option.Builder != nil {
-					config.GasLimit = option.Builder.GasLimit
-				}
-				option.Builder = config
-			} else if option.Builder != nil {
+			if option.Builder != nil {
 				option.Builder.GasLimit = reviewGasLimit(option.Builder.GasLimit)
+			} else {
+				builderConfig, err := BuilderSettingsFromFlags(cliCtx)
+				if err != nil {
+					return nil, err
+				}
+				option.Builder = builderConfig.ToPayload()
 			}
 			o := &validatorServiceConfig.ProposerOption{
 				FeeRecipientConfig: &validatorServiceConfig.FeeRecipientConfig{
@@ -626,49 +628,6 @@ func proposerSettings(cliCtx *cli.Context, db iface.ValidatorDB) (*validatorServ
 	return vpSettings, nil
 }
 
-func handleNoProposerSettingsFlagsProvided(cliCtx *cli.Context,
-	db iface.ValidatorDB,
-	builderConfigFromFlag *validatorServiceConfig.BuilderConfig) (*validatorServiceConfig.ProposerSettings, error) {
-	log.Info("no proposer settings files have been provided, attempting to load from db.")
-	// checks db if proposer settings exist if none is provided.
-	settings, err := db.ProposerSettings(cliCtx.Context)
-	if err == nil {
-		// process any overrides to builder settings
-		overrideBuilderSettings(settings, builderConfigFromFlag)
-		// if settings are empty
-		log.Info("successfully loaded proposer settings from db.")
-		return settings, nil
-	} else {
-		log.WithError(err).Warn("no proposer settings will be loaded from the db")
-	}
-
-	if cliCtx.Bool(flags.EnableBuilderFlag.Name) {
-		// if there are no proposer settings provided, create a default where fee recipient is not populated, this will be skipped for validator registration on validators that don't have a fee recipient set.
-		// skip saving to DB if only builder settings are provided until a trigger like keymanager API updates with fee recipient values
-		return &validatorServiceConfig.ProposerSettings{
-			DefaultConfig: &validatorServiceConfig.ProposerOption{
-				BuilderConfig: builderConfigFromFlag,
-			},
-		}, nil
-	}
-	return nil, nil
-}
-
-func overrideBuilderSettings(settings *validatorServiceConfig.ProposerSettings, builderConfigFromFlag *validatorServiceConfig.BuilderConfig) {
-	// override the db settings with the results based on whether the --enable-builder flag is provided.
-	if builderConfigFromFlag == nil {
-		log.Infof("proposer settings loaded from db. validator registration to builder is not enabled, please use the --%s flag if you wish to use a builder.", flags.EnableBuilderFlag.Name)
-	}
-	if settings.ProposeConfig != nil {
-		for key := range settings.ProposeConfig {
-			settings.ProposeConfig[key].BuilderConfig = builderConfigFromFlag
-		}
-	}
-	if settings.DefaultConfig != nil {
-		settings.DefaultConfig.BuilderConfig = builderConfigFromFlag
-	}
-}
-
 func BuilderSettingsFromFlags(cliCtx *cli.Context) (*validatorServiceConfig.BuilderConfig, error) {
 	if cliCtx.Bool(flags.EnableBuilderFlag.Name) {
 		gasLimit := validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit)

validator/node/node_test.go

@@ -21,7 +21,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/testing/assert"
 	"github.com/prysmaticlabs/prysm/v4/testing/require"
 	"github.com/prysmaticlabs/prysm/v4/validator/accounts"
-	"github.com/prysmaticlabs/prysm/v4/validator/db/iface"
 	dbTest "github.com/prysmaticlabs/prysm/v4/validator/db/testing"
 	"github.com/prysmaticlabs/prysm/v4/validator/keymanager"
 	remoteweb3signer "github.com/prysmaticlabs/prysm/v4/validator/keymanager/remote-web3signer"
@@ -228,7 +227,6 @@ func TestProposerSettings(t *testing.T) {
 		urlResponse                  string
 		wantErr                      string
 		wantLog                      string
-		withdb                       func(db iface.ValidatorDB) error
 		validatorRegistrationEnabled bool
 	}{
 		{
@@ -554,7 +552,7 @@ func TestProposerSettings(t *testing.T) {
 			validatorRegistrationEnabled: true,
 		},
 		{
-			name: "Enable Builder flag does override completed builder config",
+			name: "Enable Builder flag does not override completed builder config",
 			args: args{
 				proposerSettingsFlagValues: &proposerSettingsFlag{
 					dir:        "./testdata/good-prepare-beacon-proposer-config.yaml",
@@ -582,7 +580,7 @@ func TestProposerSettings(t *testing.T) {
 							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
 						},
 						BuilderConfig: &validatorserviceconfig.BuilderConfig{
-							Enabled:  true,
+							Enabled:  false,
 							GasLimit: validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit),
 						},
 					},
@@ -590,185 +588,6 @@ func TestProposerSettings(t *testing.T) {
 			},
 			validatorRegistrationEnabled: true,
 		},
-		{
-			name: "Only Enable Builder flag",
-			args: args{
-				proposerSettingsFlagValues: &proposerSettingsFlag{
-					dir:        "",
-					url:        "",
-					defaultfee: "",
-				},
-			},
-			want: func() *validatorserviceconfig.ProposerSettings {
-				return &validatorserviceconfig.ProposerSettings{
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						BuilderConfig: &validatorserviceconfig.BuilderConfig{
-							Enabled:  true,
-							GasLimit: validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit),
-						},
-					},
-				}
-			},
-			validatorRegistrationEnabled: true,
-		},
-		{
-			name: "No Flags but saved to DB with builder and override removed builder data",
-			args: args{
-				proposerSettingsFlagValues: &proposerSettingsFlag{
-					dir:        "",
-					url:        "",
-					defaultfee: "",
-				},
-			},
-			want: func() *validatorserviceconfig.ProposerSettings {
-				key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a")
-				require.NoError(t, err)
-				return &validatorserviceconfig.ProposerSettings{
-					ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{
-						bytesutil.ToBytes48(key1): {
-							FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-								FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-							},
-						},
-					},
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
-						},
-					},
-				}
-			},
-			withdb: func(db iface.ValidatorDB) error {
-				key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a")
-				require.NoError(t, err)
-				settings := &validatorserviceconfig.ProposerSettings{
-					ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{
-						bytesutil.ToBytes48(key1): {
-							FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-								FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-							},
-							BuilderConfig: &validatorserviceconfig.BuilderConfig{
-								Enabled:  true,
-								GasLimit: validator.Uint64(40000000),
-							},
-						},
-					},
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
-						},
-						BuilderConfig: &validatorserviceconfig.BuilderConfig{
-							Enabled:  true,
-							GasLimit: validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit),
-						},
-					},
-				}
-				return db.SaveProposerSettings(context.Background(), settings)
-			},
-		},
-		{
-			name: "Enable builder flag but saved to DB without builder data now includes builder data",
-			args: args{
-				proposerSettingsFlagValues: &proposerSettingsFlag{
-					dir:        "",
-					url:        "",
-					defaultfee: "",
-				},
-			},
-			want: func() *validatorserviceconfig.ProposerSettings {
-				key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a")
-				require.NoError(t, err)
-				return &validatorserviceconfig.ProposerSettings{
-					ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{
-						bytesutil.ToBytes48(key1): {
-							FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-								FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-							},
-							BuilderConfig: &validatorserviceconfig.BuilderConfig{
-								Enabled:  true,
-								GasLimit: validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit),
-							},
-						},
-					},
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
-						},
-						BuilderConfig: &validatorserviceconfig.BuilderConfig{
-							Enabled:  true,
-							GasLimit: validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit),
-						},
-					},
-				}
-			},
-			withdb: func(db iface.ValidatorDB) error {
-				key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a")
-				require.NoError(t, err)
-				settings := &validatorserviceconfig.ProposerSettings{
-					ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{
-						bytesutil.ToBytes48(key1): {
-							FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-								FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-							},
-						},
-					},
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
-						},
-					},
-				}
-				return db.SaveProposerSettings(context.Background(), settings)
-			},
-			validatorRegistrationEnabled: true,
-		},
-		{
-			name: "No flags, but saved to database",
-			args: args{
-				proposerSettingsFlagValues: &proposerSettingsFlag{
-					dir:        "",
-					url:        "",
-					defaultfee: "",
-				},
-			},
-			want: func() *validatorserviceconfig.ProposerSettings {
-				key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a")
-				require.NoError(t, err)
-				return &validatorserviceconfig.ProposerSettings{
-					ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{
-						bytesutil.ToBytes48(key1): {
-							FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-								FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-							},
-						},
-					},
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
-						},
-					},
-				}
-			},
-			withdb: func(db iface.ValidatorDB) error {
-				key1, err := hexutil.Decode("0xa057816155ad77931185101128655c0191bd0214c201ca48ed887f6c4c6adf334070efcd75140eada5ac83a92506dd7a")
-				require.NoError(t, err)
-				settings := &validatorserviceconfig.ProposerSettings{
-					ProposeConfig: map[[fieldparams.BLSPubkeyLength]byte]*validatorserviceconfig.ProposerOption{
-						bytesutil.ToBytes48(key1): {
-							FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-								FeeRecipient: common.HexToAddress("0x50155530FCE8a85ec7055A5F8b2bE214B3DaeFd3"),
-							},
-						},
-					},
-					DefaultConfig: &validatorserviceconfig.ProposerOption{
-						FeeRecipientConfig: &validatorserviceconfig.FeeRecipientConfig{
-							FeeRecipient: common.HexToAddress("0x6e35733c5af9B61374A128e6F85f553aF09ff89A"),
-						},
-					},
-				}
-				return db.SaveProposerSettings(context.Background(), settings)
-			},
-		},
 		{
 			name: "No flags set means empty config",
 			args: args{
@@ -861,10 +680,6 @@ func TestProposerSettings(t *testing.T) {
 			}
 			cliCtx := cli.NewContext(&app, set, nil)
 			validatorDB := dbTest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
-			if tt.withdb != nil {
-				err := tt.withdb(validatorDB)
-				require.NoError(t, err)
-			}
 			got, err := proposerSettings(cliCtx, validatorDB)
 			if tt.wantErr != "" {
 				require.ErrorContains(t, tt.wantErr, err)
@@ -877,29 +692,17 @@ func TestProposerSettings(t *testing.T) {
 			}
 			w := tt.want()
 			require.DeepEqual(t, w, got)
-
 		})
 	}
 }
 
-func Test_ProposerSettingsWithOnlyBuilder_DoesNotSaveInDB(t *testing.T) {
+// return an error if the user is using builder settings without any default fee recipient
+func TestProposerSettings_EnableBuilder_noFeeRecipient(t *testing.T) {
+	validatorDB := dbTest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
 	app := cli.App{}
 	set := flag.NewFlagSet("test", 0)
 	set.Bool(flags.EnableBuilderFlag.Name, true, "")
 	cliCtx := cli.NewContext(&app, set, nil)
-	validatorDB := dbTest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
-	got, err := proposerSettings(cliCtx, validatorDB)
-	require.NoError(t, err)
-	_, err = validatorDB.ProposerSettings(cliCtx.Context)
-	require.ErrorContains(t, "no proposer settings found in bucket", err)
-	want := &validatorserviceconfig.ProposerSettings{
-		DefaultConfig: &validatorserviceconfig.ProposerOption{
-			BuilderConfig: &validatorserviceconfig.BuilderConfig{
-				Enabled:  true,
-				GasLimit: validator.Uint64(params.BeaconConfig().DefaultBuilderGasLimit),
-				Relays:   nil,
-			},
-		},
-	}
-	require.DeepEqual(t, want, got)
+	_, err := proposerSettings(cliCtx, validatorDB)
+	require.ErrorContains(t, "can only be used when a default fee recipient is present on the validator client", err)
 }

validator/rpc/BUILD.bazel

@@ -102,7 +102,6 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//config/validator/service:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/rand:go_default_library",
@@ -139,7 +138,6 @@ go_test(
         "@org_golang_google_grpc//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_google_grpc//metadata:go_default_library",
-        "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
         "@org_golang_google_protobuf//types/known/timestamppb:go_default_library",
     ],
 )

validator/rpc/accounts_test.go

@@ -205,6 +205,7 @@ func TestServer_VoluntaryExit(t *testing.T) {
 
 	mockNodeClient.EXPECT().
 		GetGenesis(gomock.Any(), gomock.Any()).
+		Times(2).
 		Return(&ethpb.Genesis{GenesisTime: genesisTime}, nil)
 
 	mockValidatorClient.EXPECT().

validator/rpc/apimiddleware/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "custom_hooks.go",
         "endpoint_factory.go",
         "structs.go",
     ],
@@ -17,17 +16,11 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "custom_hooks_test.go",
-        "structs_test.go",
-    ],
+    srcs = ["structs_test.go"],
     embed = [":go_default_library"],
     deps = [
-        "//api/gateway/apimiddleware:go_default_library",
         "//config/fieldparams:go_default_library",
         "//proto/eth/service:go_default_library",
-        "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
     ],
 )

validator/rpc/apimiddleware/custom_hooks.go

@@ -1,39 +0,0 @@
-package apimiddleware
-
-import (
-	"bytes"
-	"encoding/json"
-	"io"
-	"net/http"
-	"strconv"
-
-	"github.com/prysmaticlabs/prysm/v4/api/gateway/apimiddleware"
-)
-
-// "/eth/v1/validator/{pubkey}/voluntary_exit" POST expects epoch as a query param.
-// This hook adds the query param to the body so that it is a valid POST request as
-// grpc-gateway does not handle query params in POST requests.
-func setVoluntaryExitEpoch(
-	endpoint *apimiddleware.Endpoint,
-	_ http.ResponseWriter,
-	req *http.Request,
-) (apimiddleware.RunDefault, apimiddleware.ErrorJson) {
-	if _, ok := endpoint.PostRequest.(*SetVoluntaryExitRequestJson); ok {
-		var epoch = req.URL.Query().Get("epoch")
-		// To handle the request without the query param
-		if epoch == "" {
-			epoch = "0"
-		}
-		_, err := strconv.ParseUint(epoch, 10, 64)
-		if err != nil {
-			return false, apimiddleware.InternalServerErrorWithMessage(err, "invalid epoch")
-		}
-		j := &SetVoluntaryExitRequestJson{Epoch: epoch}
-		b, err := json.Marshal(j)
-		if err != nil {
-			return false, apimiddleware.InternalServerErrorWithMessage(err, "could not marshal epoch")
-		}
-		req.Body = io.NopCloser(bytes.NewReader(b))
-	}
-	return true, nil
-}

validator/rpc/apimiddleware/custom_hooks_test.go

@@ -1,49 +0,0 @@
-package apimiddleware
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v4/api/gateway/apimiddleware"
-	"github.com/prysmaticlabs/prysm/v4/testing/assert"
-	"github.com/prysmaticlabs/prysm/v4/testing/require"
-)
-
-func TestSetVoluntaryExitEpoch(t *testing.T) {
-	t.Run("ok", func(t *testing.T) {
-		endpoint := &apimiddleware.Endpoint{
-			PostRequest: &SetVoluntaryExitRequestJson{},
-		}
-		epoch := "300"
-
-		var body bytes.Buffer
-		request := httptest.NewRequest("POST", fmt.Sprintf("http://foo.example?epoch=%s", epoch), &body)
-
-		runDefault, errJson := setVoluntaryExitEpoch(endpoint, nil, request)
-		require.Equal(t, true, errJson == nil)
-		assert.Equal(t, apimiddleware.RunDefault(true), runDefault)
-
-		var b SetVoluntaryExitRequestJson
-		err := json.NewDecoder(request.Body).Decode(&b)
-		require.NoError(t, err)
-		require.Equal(t, epoch, b.Epoch)
-	})
-	t.Run("invalid query returns error", func(t *testing.T) {
-		endpoint := &apimiddleware.Endpoint{
-			PostRequest: &SetVoluntaryExitRequestJson{},
-		}
-		epoch := "/12"
-		var body bytes.Buffer
-		request := httptest.NewRequest("POST", fmt.Sprintf("http://foo.example?epoch=%s", epoch), &body)
-
-		runDefault, errJson := setVoluntaryExitEpoch(endpoint, nil, request)
-		assert.NotNil(t, errJson)
-		assert.Equal(t, apimiddleware.RunDefault(false), runDefault)
-		err := errors.New(errJson.Msg())
-		assert.ErrorContains(t, "invalid epoch", err)
-	})
-}

validator/rpc/apimiddleware/endpoint_factory.go

@@ -20,7 +20,6 @@ func (*ValidatorEndpointFactory) Paths() []string {
 		"/eth/v1/remotekeys",
 		"/eth/v1/validator/{pubkey}/feerecipient",
 		"/eth/v1/validator/{pubkey}/gas_limit",
-		"/eth/v1/validator/{pubkey}/voluntary_exit",
 	}
 }
 
@@ -48,12 +47,6 @@ func (*ValidatorEndpointFactory) Create(path string) (*apimiddleware.Endpoint, e
 		endpoint.GetResponse = &GetGasLimitResponseJson{}
 		endpoint.PostRequest = &SetGasLimitRequestJson{}
 		endpoint.DeleteRequest = &DeleteGasLimitRequestJson{}
-	case "/eth/v1/validator/{pubkey}/voluntary_exit":
-		endpoint.PostRequest = &SetVoluntaryExitRequestJson{}
-		endpoint.PostResponse = &SetVoluntaryExitResponseJson{}
-		endpoint.Hooks = apimiddleware.HookCollection{
-			OnPreDeserializeRequestBodyIntoContainer: setVoluntaryExitEpoch,
-		}
 	default:
 		return nil, errors.New("invalid path")
 	}

validator/rpc/apimiddleware/structs.go

@@ -100,22 +100,3 @@ type SetGasLimitRequestJson struct {
 type DeleteGasLimitRequestJson struct {
 	Pubkey string `json:"pubkey" hex:"true"`
 }
-
-type SetVoluntaryExitRequestJson struct {
-	Pubkey string `json:"pubkey" hex:"true"`
-	Epoch  string `json:"epoch"`
-}
-
-type SetVoluntaryExitResponseJson struct {
-	SignedVoluntaryExit *SignedVoluntaryExitJson `json:"data"`
-}
-
-type SignedVoluntaryExitJson struct {
-	VoluntaryExit *VoluntaryExitJson `json:"message"`
-	Signature     string             `json:"signature" hex:"true"`
-}
-
-type VoluntaryExitJson struct {
-	Epoch          string `json:"epoch"`
-	ValidatorIndex string `json:"validator_index"`
-}

validator/rpc/standard_api.go

@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
 	ethpbservice "github.com/prysmaticlabs/prysm/v4/proto/eth/service"
 	eth "github.com/prysmaticlabs/prysm/v4/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v4/validator/client"
 	"github.com/prysmaticlabs/prysm/v4/validator/keymanager"
 	"github.com/prysmaticlabs/prysm/v4/validator/keymanager/derived"
 	slashingprotection "github.com/prysmaticlabs/prysm/v4/validator/slashing-protection-history"
@@ -25,7 +24,6 @@ import (
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/metadata"
 	"google.golang.org/grpc/status"
-	"google.golang.org/protobuf/types/known/emptypb"
 )
 
 // ListKeystores implements the standard validator key management API.
@@ -600,7 +598,7 @@ func (s *Server) SetFeeRecipientByPubkey(ctx context.Context, req *ethpbservice.
 		}
 	case settings.ProposeConfig == nil:
 		var builderConfig *validatorServiceConfig.BuilderConfig
-		if settings.DefaultConfig != nil && settings.DefaultConfig.BuilderConfig != nil {
+		if settings.DefaultConfig != nil {
 			builderConfig = settings.DefaultConfig.BuilderConfig.Clone()
 		}
 		settings.ProposeConfig = map[[fieldparams.BLSPubkeyLength]byte]*validatorServiceConfig.ProposerOption{
@@ -619,7 +617,7 @@ func (s *Server) SetFeeRecipientByPubkey(ctx context.Context, req *ethpbservice.
 			}
 		} else {
 			var builderConfig = &validatorServiceConfig.BuilderConfig{}
-			if settings.DefaultConfig != nil && settings.DefaultConfig.BuilderConfig != nil {
+			if settings.DefaultConfig != nil {
 				builderConfig = settings.DefaultConfig.BuilderConfig.Clone()
 			}
 			settings.ProposeConfig[bytesutil.ToBytes48(validatorKey)] = &validatorServiceConfig.ProposerOption{
@@ -681,51 +679,3 @@ func validatePublicKey(pubkey []byte) error {
 	}
 	return nil
 }
-
-// SetVoluntaryExit creates a signed voluntary exit message and returns a VoluntaryExit object.
-func (s *Server) SetVoluntaryExit(ctx context.Context, req *ethpbservice.SetVoluntaryExitRequest) (*ethpbservice.SetVoluntaryExitResponse, error) {
-	if s.validatorService == nil {
-		return nil, status.Error(codes.FailedPrecondition, "Validator service not ready")
-	}
-	if err := validatePublicKey(req.Pubkey); err != nil {
-		return nil, status.Error(codes.FailedPrecondition, err.Error())
-	}
-	if s.wallet == nil {
-		return nil, status.Error(codes.FailedPrecondition, "No wallet found")
-	}
-	km, err := s.validatorService.Keymanager()
-	if err != nil {
-		return nil, err
-	}
-	if req.Epoch == 0 {
-		genesisResponse, err := s.beaconNodeClient.GetGenesis(ctx, &emptypb.Empty{})
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not create voluntary exit: %v", err)
-		}
-		epoch, err := client.CurrentEpoch(genesisResponse.GenesisTime)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "gRPC call to get genesis time failed: %v", err)
-		}
-		req.Epoch = epoch
-	}
-	sve, err := client.CreateSignedVoluntaryExit(
-		ctx,
-		s.beaconNodeValidatorClient,
-		km.Sign,
-		req.Pubkey,
-		req.Epoch,
-	)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not create voluntary exit: %v", err)
-	}
-
-	return &ethpbservice.SetVoluntaryExitResponse{
-		Data: &ethpbservice.SetVoluntaryExitResponse_SignedVoluntaryExit{
-			Message: &ethpbservice.SetVoluntaryExitResponse_SignedVoluntaryExit_VoluntaryExit{
-				Epoch:          uint64(sve.Exit.Epoch),
-				ValidatorIndex: uint64(sve.Exit.ValidatorIndex),
-			},
-			Signature: sve.Signature,
-		},
-	}, nil
-}

validator/rpc/standard_api_test.go

@@ -1,14 +1,12 @@
 package rpc
 
 import (
-	"bytes"
 	"context"
 	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"testing"
-	"time"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -19,7 +17,6 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v4/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v4/config/params"
 	validatorserviceconfig "github.com/prysmaticlabs/prysm/v4/config/validator/service"
-	"github.com/prysmaticlabs/prysm/v4/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v4/consensus-types/validator"
 	"github.com/prysmaticlabs/prysm/v4/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v4/encoding/bytesutil"
@@ -44,8 +41,6 @@ import (
 	keystorev4 "github.com/wealdtech/go-eth2-wallet-encryptor-keystorev4"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
-	"google.golang.org/protobuf/types/known/emptypb"
-	"google.golang.org/protobuf/types/known/timestamppb"
 )
 
 func TestServer_ListKeystores(t *testing.T) {
@@ -768,8 +763,7 @@ func TestServer_ListFeeRecipientByPubkey(t *testing.T) {
 			mockValidatorClient := validatormock.NewMockValidatorClient(ctrl)
 
 			m := &mock.MockValidator{}
-			err := m.SetProposerSettings(ctx, tt.args)
-			require.NoError(t, err)
+			m.SetProposerSettings(tt.args)
 
 			if tt.args == nil {
 				mockValidatorClient.EXPECT().GetFeeRecipientByPubKey(gomock.Any(), gomock.Any()).Return(tt.cached, nil)
@@ -1005,8 +999,7 @@ func TestServer_FeeRecipientByPubkey(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			m := &mock.MockValidator{}
-			err := m.SetProposerSettings(ctx, tt.proposerSettings)
-			require.NoError(t, err)
+			m.SetProposerSettings(tt.proposerSettings)
 			validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
 
 			// save a default here
@@ -1108,8 +1101,7 @@ func TestServer_DeleteFeeRecipientByPubkey(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			m := &mock.MockValidator{}
-			err := m.SetProposerSettings(ctx, tt.proposerSettings)
-			require.NoError(t, err)
+			m.SetProposerSettings(tt.proposerSettings)
 			validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
 			vs, err := client.NewValidatorService(ctx, &client.Config{
 				Validator: m,
@@ -1205,8 +1197,7 @@ func TestServer_GetGasLimit(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			m := &mock.MockValidator{}
-			err := m.SetProposerSettings(ctx, tt.args)
-			require.NoError(t, err)
+			m.SetProposerSettings(tt.args)
 			vs, err := client.NewValidatorService(ctx, &client.Config{
 				Validator: m,
 			})
@@ -1355,8 +1346,7 @@ func TestServer_SetGasLimit(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			m := &mock.MockValidator{}
-			err := m.SetProposerSettings(ctx, tt.proposerSettings)
-			require.NoError(t, err)
+			m.SetProposerSettings(tt.proposerSettings)
 			validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
 			vs, err := client.NewValidatorService(ctx, &client.Config{
 				Validator: m,
@@ -1525,8 +1515,7 @@ func TestServer_DeleteGasLimit(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			m := &mock.MockValidator{}
-			err := m.SetProposerSettings(ctx, tt.proposerSettings)
-			require.NoError(t, err)
+			m.SetProposerSettings(tt.proposerSettings)
 			validatorDB := dbtest.SetupDB(t, [][fieldparams.BLSPubkeyLength]byte{})
 			vs, err := client.NewValidatorService(ctx, &client.Config{
 				Validator: m,
@@ -1551,116 +1540,3 @@ func TestServer_DeleteGasLimit(t *testing.T) {
 		})
 	}
 }
-
-func TestServer_SetVoluntaryExit(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	ctx := grpc.NewContextWithServerTransportStream(context.Background(), &runtime.ServerTransportStream{})
-	defaultWalletPath = setupWalletDir(t)
-	opts := []accounts.Option{
-		accounts.WithWalletDir(defaultWalletPath),
-		accounts.WithKeymanagerType(keymanager.Derived),
-		accounts.WithWalletPassword(strongPass),
-		accounts.WithSkipMnemonicConfirm(true),
-	}
-	acc, err := accounts.NewCLIManager(opts...)
-	require.NoError(t, err)
-	w, err := acc.WalletCreate(ctx)
-	require.NoError(t, err)
-	km, err := w.InitializeKeymanager(ctx, iface.InitKeymanagerConfig{ListenForChanges: false})
-	require.NoError(t, err)
-
-	m := &mock.MockValidator{Km: km}
-	vs, err := client.NewValidatorService(ctx, &client.Config{
-		Validator: m,
-	})
-	require.NoError(t, err)
-
-	dr, ok := km.(*derived.Keymanager)
-	require.Equal(t, true, ok)
-	err = dr.RecoverAccountsFromMnemonic(ctx, mocks.TestMnemonic, derived.DefaultMnemonicLanguage, "", 1)
-	require.NoError(t, err)
-	pubKeys, err := dr.FetchValidatingPublicKeys(ctx)
-	require.NoError(t, err)
-
-	beaconClient := validatormock.NewMockValidatorClient(ctrl)
-	mockNodeClient := validatormock.NewMockNodeClient(ctrl)
-	// Any time in the past will suffice
-	genesisTime := &timestamppb.Timestamp{
-		Seconds: time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC).Unix(),
-	}
-
-	beaconClient.EXPECT().ValidatorIndex(gomock.Any(), &eth.ValidatorIndexRequest{PublicKey: pubKeys[0][:]}).
-		Times(3).
-		Return(&eth.ValidatorIndexResponse{Index: 2}, nil)
-
-	beaconClient.EXPECT().DomainData(
-		gomock.Any(), // ctx
-		gomock.Any(), // epoch
-	).Times(3).
-		Return(&eth.DomainResponse{SignatureDomain: make([]byte, 32)}, nil /*err*/)
-
-	mockNodeClient.EXPECT().
-		GetGenesis(gomock.Any(), gomock.Any()).
-		Times(3).
-		Return(&eth.Genesis{GenesisTime: genesisTime}, nil)
-
-	s := &Server{
-		validatorService:          vs,
-		beaconNodeValidatorClient: beaconClient,
-		wallet:                    w,
-		beaconNodeClient:          mockNodeClient,
-	}
-
-	type want struct {
-		epoch          primitives.Epoch
-		validatorIndex uint64
-		signature      []byte
-	}
-
-	tests := []struct {
-		name   string
-		pubkey []byte
-		epoch  primitives.Epoch
-		w      want
-	}{
-		{
-			name:  "Ok: with epoch",
-			epoch: 30000000,
-			w: want{
-				epoch:          30000000,
-				validatorIndex: 2,
-				signature:      []uint8{175, 157, 5, 134, 253, 2, 193, 35, 176, 43, 217, 36, 39, 240, 24, 79, 207, 133, 150, 7, 237, 16, 54, 244, 64, 27, 244, 17, 8, 225, 140, 1, 172, 24, 35, 95, 178, 116, 172, 213, 113, 182, 193, 61, 192, 65, 162, 253, 19, 202, 111, 164, 195, 215, 0, 205, 95, 7, 30, 251, 244, 157, 210, 155, 238, 30, 35, 219, 177, 232, 174, 62, 218, 69, 23, 249, 180, 140, 60, 29, 190, 249, 229, 95, 235, 236, 81, 33, 60, 4, 201, 227, 70, 239, 167, 2},
-			},
-		},
-		{
-			name: "Ok: epoch not set",
-			w: want{
-				epoch:          0,
-				validatorIndex: 2,
-				signature:      []uint8{},
-			},
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			resp, err := s.SetVoluntaryExit(ctx, &ethpbservice.SetVoluntaryExitRequest{Pubkey: pubKeys[0][:], Epoch: tt.epoch})
-			require.NoError(t, err)
-			if tt.w.epoch == 0 {
-				genesisResponse, err := s.beaconNodeClient.GetGenesis(ctx, &emptypb.Empty{})
-				require.NoError(t, err)
-				tt.w.epoch, err = client.CurrentEpoch(genesisResponse.GenesisTime)
-				require.NoError(t, err)
-				resp2, err := s.SetVoluntaryExit(ctx, &ethpbservice.SetVoluntaryExitRequest{Pubkey: pubKeys[0][:], Epoch: tt.epoch})
-				require.NoError(t, err)
-				tt.w.signature = resp2.Data.Signature
-			}
-			require.Equal(t, uint64(tt.w.epoch), resp.Data.Message.Epoch)
-			require.Equal(t, tt.w.validatorIndex, resp.Data.Message.ValidatorIndex)
-			require.NotEmpty(t, resp.Data.Signature)
-			ok = bytes.Equal(tt.w.signature, resp.Data.Signature)
-			require.Equal(t, true, ok)
-		})
-	}
-}