Merge branch 'develop' of github.com:prysmaticlabs/prysm into ensure-e2e-evals

* remove deprecated http provider flag

* test

---------

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

.bazelversion

@@ -1 +1 @@
-5.3.0
+6.1.0

WORKSPACE

@@ -4,15 +4,18 @@ load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 load("@bazel_tools//tools/build_defs/repo:git.bzl", "git_repository")
 
 http_archive(
-    name = "bazel_toolchains",
-    sha256 = "8e0633dfb59f704594f19ae996a35650747adc621ada5e8b9fb588f808c89cb0",
-    strip_prefix = "bazel-toolchains-3.7.0",
+    name = "rules_pkg",
+    sha256 = "8c20f74bca25d2d442b327ae26768c02cf3c99e93fad0381f32be9aab1967675",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/releases/download/3.7.0/bazel-toolchains-3.7.0.tar.gz",
-        "https://github.com/bazelbuild/bazel-toolchains/releases/download/3.7.0/bazel-toolchains-3.7.0.tar.gz",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_pkg/releases/download/0.8.1/rules_pkg-0.8.1.tar.gz",
+        "https://github.com/bazelbuild/rules_pkg/releases/download/0.8.1/rules_pkg-0.8.1.tar.gz",
     ],
 )
 
+load("@rules_pkg//:deps.bzl", "rules_pkg_dependencies")
+
+rules_pkg_dependencies()
+
 http_archive(
     name = "com_grail_bazel_toolchain",
     sha256 = "b210fc8e58782ef171f428bfc850ed7179bdd805543ebd1aa144b9c93489134f",
@@ -39,10 +42,6 @@ load("@prysm//tools/cross-toolchain:prysm_toolchains.bzl", "configure_prysm_tool
 
 configure_prysm_toolchains()
 
-load("@prysm//tools/cross-toolchain:rbe_toolchains_config.bzl", "rbe_toolchains_config")
-
-rbe_toolchains_config()
-
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
 http_archive(
@@ -87,10 +86,10 @@ http_archive(
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "ae013bf35bd23234d1dea46b079f1e05ba74ac0321423830119d3e787ec73483",
+    sha256 = "dd926a88a564a9246713a9c00b35315f54cbd46b31a26d5d8fb264c07045f05d",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.36.0/rules_go-v0.36.0.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.36.0/rules_go-v0.36.0.zip",
+        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.38.1/rules_go-v0.38.1.zip",
+        "https://github.com/bazelbuild/rules_go/releases/download/v0.38.1/rules_go-v0.38.1.zip",
     ],
 )
 
@@ -165,7 +164,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.19.4",
+    go_version = "1.19.7",
     nogo = "@//:nogo",
 )
 
@@ -191,6 +190,21 @@ filegroup(
     url = "https://github.com/eth-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
+http_archive(
+    name = "eip4881_spec_tests",
+    build_file_content = """
+filegroup(
+    name = "test_data",
+    srcs = glob([
+        "**/*.yaml",
+    ]),
+    visibility = ["//visibility:public"],
+)
+    """,
+    sha256 = "89cb659498c0d196fc9f957f8b849b2e1a5c041c3b2b3ae5432ac5c26944297e",
+    url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
+)
+
 consensus_spec_version = "v1.3.0-rc.3"
 
 bls_test_version = "v0.1.1"

api/client/beacon/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//encoding/ssz/detect:go_default_library",
         "//io/file:go_default_library",
         "//network/forks:go_default_library",
+        "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",

api/client/beacon/checkpoint.go

@@ -103,8 +103,8 @@ func DownloadFinalizedData(ctx context.Context, client *Client) (*OriginData, er
 	}
 
 	log.Printf("BeaconState slot=%d, Block slot=%d", s.Slot(), b.Block().Slot())
-	log.Printf("BeaconState htr=%#xd, Block state_root=%#x", sr, b.Block().StateRoot())
-	log.Printf("BeaconState latest_block_header htr=%#xd, block htr=%#x", br, realBlockRoot)
+	log.Printf("BeaconState htr=%#x, Block state_root=%#x", sr, b.Block().StateRoot())
+	log.Printf("BeaconState latest_block_header htr=%#x, block htr=%#x", br, realBlockRoot)
 	return &OriginData{
 		st: s,
 		b:  b,

api/client/beacon/checkpoint_test.go

@@ -398,11 +398,7 @@ func populateValidators(cfg *params.BeaconChainConfig, st state.BeaconState, val
 	if err := st.SetValidators(validators); err != nil {
 		return err
 	}
-	if err := st.SetBalances(balances); err != nil {
-		return err
-	}
-
-	return nil
+	return st.SetBalances(balances)
 }
 
 func TestDownloadFinalizedData(t *testing.T) {

api/client/beacon/client.go

@@ -17,6 +17,7 @@ import (
 	"time"
 
 	"github.com/prysmaticlabs/prysm/v3/network/forks"
+	v1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
@@ -33,6 +34,7 @@ const (
 	getForkForStatePath      = "/eth/v1/beacon/states/{{.Id}}/fork"
 	getWeakSubjectivityPath  = "/eth/v1/beacon/weak_subjectivity"
 	getForkSchedulePath      = "/eth/v1/config/fork_schedule"
+	getConfigSpecPath        = "/eth/v1/config/spec"
 	getStatePath             = "/eth/v2/debug/beacon/states"
 	getNodeVersionPath       = "/eth/v1/node/version"
 	changeBLStoExecutionPath = "/eth/v1/beacon/pool/bls_to_execution_changes"
@@ -252,6 +254,20 @@ func (c *Client) GetForkSchedule(ctx context.Context) (forks.OrderedSchedule, er
 	return ofs, nil
 }
 
+// GetConfigSpec retrieve the current configs of the network used by the beacon node.
+func (c *Client) GetConfigSpec(ctx context.Context) (*v1.SpecResponse, error) {
+	body, err := c.get(ctx, getConfigSpecPath)
+	if err != nil {
+		return nil, errors.Wrap(err, "error requesting configSpecPath")
+	}
+	fsr := &v1.SpecResponse{}
+	err = json.Unmarshal(body, fsr)
+	if err != nil {
+		return nil, err
+	}
+	return fsr, nil
+}
+
 type NodeVersion struct {
 	implementation string
 	semver         string

beacon-chain/blockchain/chain_info.go

@@ -33,7 +33,7 @@ type ChainInfoFetcher interface {
 // HeadUpdater defines a common interface for methods in blockchain service
 // which allow to update the head info
 type HeadUpdater interface {
-	UpdateHead(context.Context) error
+	UpdateHead(context.Context, primitives.Slot)
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -2,14 +2,22 @@ package blockchain
 
 import (
 	"context"
+	"fmt"
+	"time"
 
 	"github.com/pkg/errors"
+	doublylinkedtree "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v3/config/features"
+	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v3/time/slots"
+	"github.com/sirupsen/logrus"
 )
 
-func (s *Service) isNewProposer() bool {
-	_, _, ok := s.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(s.CurrentSlot()+1, [32]byte{} /* root */)
+func (s *Service) isNewProposer(slot primitives.Slot) bool {
+	_, _, ok := s.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(slot, [32]byte{} /* root */)
 	return ok
 }
 
@@ -40,12 +48,18 @@ func (s *Service) getStateAndBlock(ctx context.Context, r [32]byte) (state.Beaco
 	return headState, newHeadBlock, nil
 }
 
-func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, newHeadRoot [32]byte) error {
+// fockchoiceUpdateWithExecution is a wrapper around notifyForkchoiceUpdate. It decides whether a new call to FCU should be made.
+func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, newHeadRoot [32]byte, proposingSlot primitives.Slot) error {
 	isNewHead := s.isNewHead(newHeadRoot)
-	if !isNewHead && !s.isNewProposer() {
+	if !isNewHead {
 		return nil
 	}
-
+	isNewProposer := s.isNewProposer(proposingSlot)
+	if isNewProposer && !features.Get().DisableReorgLateBlocks {
+		if s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
+			return nil
+		}
+	}
 	headState, headBlock, err := s.getStateAndBlock(ctx, newHeadRoot)
 	if err != nil {
 		log.WithError(err).Error("Could not get forkchoice update argument")
@@ -58,19 +72,56 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, newHeadRoot
 		headBlock: headBlock.Block(),
 	})
 	if err != nil {
-		return err
+		return errors.Wrap(err, "could not notify forkchoice update")
 	}
 
-	if isNewHead {
-		if err := s.saveHead(ctx, newHeadRoot, headBlock, headState); err != nil {
-			log.WithError(err).Error("could not save head")
-		}
-
-		// Only need to prune attestations from pool if the head has changed.
-		if err := s.pruneAttsFromPool(headBlock); err != nil {
-			return err
-		}
+	if err := s.saveHead(ctx, newHeadRoot, headBlock, headState); err != nil {
+		log.WithError(err).Error("could not save head")
 	}
 
+	// Only need to prune attestations from pool if the head has changed.
+	if err := s.pruneAttsFromPool(headBlock); err != nil {
+		log.WithError(err).Error("could not prune attestations from pool")
+	}
 	return nil
 }
+
+// shouldOverrideFCU checks whether the incoming block is still subject to being
+// reorged or not by the next proposer.
+func (s *Service) shouldOverrideFCU(newHeadRoot [32]byte, proposingSlot primitives.Slot) bool {
+	headWeight, err := s.ForkChoicer().Weight(newHeadRoot)
+	if err != nil {
+		log.WithError(err).WithField("root", fmt.Sprintf("%#x", newHeadRoot)).Warn("could not determine node weight")
+	}
+	currentSlot := s.CurrentSlot()
+	if proposingSlot == currentSlot {
+		proposerHead := s.ForkChoicer().GetProposerHead()
+		if proposerHead != newHeadRoot {
+			return true
+		}
+		log.WithFields(logrus.Fields{
+			"root":   fmt.Sprintf("%#x", newHeadRoot),
+			"weight": headWeight,
+		}).Infof("Attempted late block reorg aborted due to attestations at %d seconds",
+			params.BeaconConfig().SecondsPerSlot)
+		lateBlockFailedAttemptSecondThreshold.Inc()
+	} else {
+		if s.ForkChoicer().ShouldOverrideFCU() {
+			return true
+		}
+		secs, err := slots.SecondsSinceSlotStart(currentSlot,
+			uint64(s.genesisTime.Unix()), uint64(time.Now().Unix()))
+		if err != nil {
+			log.WithError(err).Error("could not compute seconds since slot start")
+		}
+		if secs >= doublylinkedtree.ProcessAttestationsThreshold {
+			log.WithFields(logrus.Fields{
+				"root":   fmt.Sprintf("%#x", newHeadRoot),
+				"weight": headWeight,
+			}).Infof("Attempted late block reorg aborted due to attestations at %d seconds",
+				doublylinkedtree.ProcessAttestationsThreshold)
+			lateBlockFailedAttemptFirstThreshold.Inc()
+		}
+	}
+	return false
+}

beacon-chain/blockchain/forkchoice_update_execution_test.go

@@ -3,6 +3,7 @@ package blockchain
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/cache"
 	testDB "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
@@ -21,10 +22,10 @@ import (
 func TestService_isNewProposer(t *testing.T) {
 	beaconDB := testDB.SetupDB(t)
 	service := setupBeaconChain(t, beaconDB)
-	require.Equal(t, false, service.isNewProposer())
+	require.Equal(t, false, service.isNewProposer(service.CurrentSlot()+1))
 
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(service.CurrentSlot()+1, 0, [8]byte{}, [32]byte{} /* root */)
-	require.Equal(t, true, service.isNewProposer())
+	require.Equal(t, true, service.isNewProposer(service.CurrentSlot()+1))
 }
 
 func TestService_isNewHead(t *testing.T) {
@@ -75,7 +76,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
 	service.cfg.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
-	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, service.headRoot()))
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, service.headRoot(), service.CurrentSlot()+1))
 	hookErr := "could not notify forkchoice update"
 	invalidStateErr := "could not get state summary: could not find block in DB"
 	require.LogsDoNotContain(t, hook, invalidStateErr)
@@ -83,7 +84,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 	gb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlock())
 	require.NoError(t, err)
 	require.NoError(t, service.saveInitSyncBlock(ctx, [32]byte{'a'}, gb))
-	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, [32]byte{'a'}))
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, [32]byte{'a'}, service.CurrentSlot()+1))
 	require.LogsContain(t, hook, invalidStateErr)
 
 	hook.Reset()
@@ -107,7 +108,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 		state: st,
 	}
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1}, [32]byte{2})
-	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, r1))
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, r1, service.CurrentSlot()))
 	require.LogsDoNotContain(t, hook, invalidStateErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 
@@ -124,7 +125,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 		state: st,
 	}
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(2, 1, [8]byte{1}, [32]byte{2})
-	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, r1))
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, r1, service.CurrentSlot()+1))
 	require.LogsDoNotContain(t, hook, invalidStateErr)
 	require.LogsDoNotContain(t, hook, hookErr)
 	vId, payloadID, has := service.cfg.ProposerSlotIndexCache.GetProposerPayloadIDs(2, [32]byte{2})
@@ -134,7 +135,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 
 	// Test zero headRoot returns immediately.
 	headRoot := service.headRoot()
-	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, [32]byte{}))
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, [32]byte{}, service.CurrentSlot()+1))
 	require.Equal(t, service.headRoot(), headRoot)
 }
 
@@ -184,7 +185,52 @@ func TestService_forkchoiceUpdateWithExecution_SameHeadRootNewProposer(t *testin
 
 	// Set head to be the same but proposing next slot
 	service.head.root = r
+	service.head.block = sb
+	service.head.state = st
 	service.cfg.ProposerSlotIndexCache.SetProposerAndPayloadIDs(service.CurrentSlot()+1, 0, [8]byte{}, [32]byte{} /* root */)
-	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, r))
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, r, service.CurrentSlot()+1))
 
 }
+
+func TestShouldOverrideFCU(t *testing.T) {
+	hook := logTest.NewGlobal()
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	fcs := doublylinkedtree.New()
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB, fcs)),
+		WithForkChoiceStore(fcs),
+		WithProposerIdsCache(cache.NewProposerPayloadIDsCache()),
+	}
+	service, err := NewService(ctx, opts...)
+	service.SetGenesisTime(time.Now().Add(-time.Duration(2*params.BeaconConfig().SecondsPerSlot) * time.Second))
+	require.NoError(t, err)
+	headRoot := [32]byte{'b'}
+	parentRoot := [32]byte{'a'}
+	ojc := &ethpb.Checkpoint{}
+	st, root, err := prepareForkchoiceState(ctx, 1, parentRoot, [32]byte{}, [32]byte{}, ojc, ojc)
+	require.NoError(t, err)
+	require.NoError(t, fcs.InsertNode(ctx, st, root))
+	st, root, err = prepareForkchoiceState(ctx, 2, headRoot, parentRoot, [32]byte{}, ojc, ojc)
+	require.NoError(t, err)
+	require.NoError(t, fcs.InsertNode(ctx, st, root))
+
+	require.Equal(t, primitives.Slot(2), service.CurrentSlot())
+	require.Equal(t, true, service.shouldOverrideFCU(headRoot, 2))
+	require.LogsDoNotContain(t, hook, "12 seconds")
+	require.Equal(t, false, service.shouldOverrideFCU(parentRoot, 2))
+	require.LogsContain(t, hook, "12 seconds")
+
+	head, err := fcs.Head(ctx)
+	require.NoError(t, err)
+	require.Equal(t, headRoot, head)
+
+	fcs.SetGenesisTime(uint64(time.Now().Unix()) - 29)
+	require.Equal(t, true, service.shouldOverrideFCU(parentRoot, 3))
+	require.LogsDoNotContain(t, hook, "10 seconds")
+	fcs.SetGenesisTime(uint64(time.Now().Unix()) - 24)
+	service.SetGenesisTime(time.Now().Add(-time.Duration(2*params.BeaconConfig().SecondsPerSlot+10) * time.Second))
+	require.Equal(t, false, service.shouldOverrideFCU(parentRoot, 3))
+	require.LogsContain(t, hook, "10 seconds")
+}

beacon-chain/blockchain/metrics.go

@@ -111,6 +111,18 @@ var (
 		Name: "beacon_reorgs_total",
 		Help: "Count the number of times beacon chain has a reorg",
 	})
+	LateBlockAttemptedReorgCount = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "beacon_late_block_attempted_reorgs",
+		Help: "Count the number of times a proposer served by this beacon has attempted a late block reorg",
+	})
+	lateBlockFailedAttemptFirstThreshold = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "beacon_failed_reorg_attempts_first_threshold",
+		Help: "Count the number of times a proposer served by this beacon attempted a late block reorg but desisted in the first threshold",
+	})
+	lateBlockFailedAttemptSecondThreshold = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "beacon_failed_reorg_attempts_second_threshold",
+		Help: "Count the number of times a proposer served by this beacon attempted a late block reorg but desisted in the second threshold",
+	})
 	saveOrphanedAttCount = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "saved_orphaned_att_total",
 		Help: "Count the number of times an orphaned attestation is saved",
@@ -158,10 +170,6 @@ var (
 		Name: "txs_per_slot_count",
 		Help: "Count the number of txs per slot",
 	})
-	missedPayloadIDFilledCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "missed_payload_id_filled_count",
-		Help: "",
-	})
 	onBlockProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
 		Name: "on_block_processing_milliseconds",
 		Help: "Total time in milliseconds to complete a call to onBlock()",

beacon-chain/blockchain/process_attestation.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1/attestation"
@@ -37,7 +36,7 @@ import (
 //
 //	 # Update latest messages for attesting indices
 //	 update_latest_messages(store, indexed_attestation.attesting_indices, attestation)
-func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation) error {
+func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onAttestation")
 	defer span.End()
 
@@ -63,7 +62,7 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation) error
 	genesisTime := uint64(s.genesisTime.Unix())
 
 	// Verify attestation target is from current epoch or previous epoch.
-	if err := verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Unix()), tgt); err != nil {
+	if err := verifyAttTargetEpoch(ctx, genesisTime, uint64(time.Now().Add(disparity).Unix()), tgt); err != nil {
 		return err
 	}
 
@@ -72,11 +71,11 @@ func (s *Service) OnAttestation(ctx context.Context, a *ethpb.Attestation) error
 		return errors.Wrap(err, "could not verify attestation beacon block")
 	}
 
-	// Note that LMG GHOST and FFG consistency check is ignored because it was performed in sync's validation pipeline:
+	// Note that LMD GHOST and FFG consistency check is ignored because it was performed in sync's validation pipeline:
 	// validate_aggregate_proof.go and validate_beacon_attestation.go
 
 	// Verify attestations can only affect the fork choice of subsequent slots.
-	if err := slots.VerifyTime(genesisTime, a.Data.Slot+1, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+	if err := slots.VerifyTime(genesisTime, a.Data.Slot+1, disparity); err != nil {
 		return err
 	}
 

beacon-chain/blockchain/process_attestation_test.go

@@ -117,7 +117,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := service.OnAttestation(ctx, tt.a)
+			err := service.OnAttestation(ctx, tt.a, 0)
 			if tt.wantedErr != "" {
 				assert.ErrorContains(t, tt.wantedErr, err)
 			} else {
@@ -154,7 +154,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-	require.NoError(t, service.OnAttestation(ctx, att[0]))
+	require.NoError(t, service.OnAttestation(ctx, att[0], 0))
 }
 
 func TestStore_SaveCheckpointState(t *testing.T) {

beacon-chain/blockchain/process_block.go

@@ -152,9 +152,6 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	if err := s.handleBlockAttestations(ctx, signed.Block(), postState); err != nil {
 		return errors.Wrap(err, "could not handle block's attestations")
 	}
-	if err := s.handleBlockBLSToExecChanges(signed.Block()); err != nil {
-		return errors.Wrap(err, "could not handle block's BLSToExecutionChanges")
-	}
 
 	s.InsertSlashingsToForkChoiceStore(ctx, signed.Block().Body().AttesterSlashings())
 	if isValidPayload {
@@ -214,7 +211,9 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 	}
 	newBlockHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
 
-	if err := s.forkchoiceUpdateWithExecution(ctx, headRoot); err != nil {
+	// verify conditions for FCU, notifies FCU, and saves the new head.
+	// This function also prunes attestations, other similar operations happen in prunePostBlockOperationPools.
+	if err := s.forkchoiceUpdateWithExecution(ctx, headRoot, s.CurrentSlot()+1); err != nil {
 		return err
 	}
 
@@ -447,12 +446,22 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 			}
 		}
 	}
+	// Save boundary states that will be useful for forkchoice
+	for r, st := range boundaries {
+		if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
+			return err
+		}
+	}
+	// Also saves the last post state which to be used as pre state for the next batch.
+	lastBR := blockRoots[len(blks)-1]
+	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
+		return err
+	}
 	// Insert all nodes but the last one to forkchoice
 	if err := s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes); err != nil {
 		return errors.Wrap(err, "could not insert batch to forkchoice")
 	}
 	// Insert the last block to forkchoice
-	lastBR := blockRoots[len(blks)-1]
 	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastBR); err != nil {
 		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
 	}
@@ -462,17 +471,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.ReadOnlySi
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
-
-	for r, st := range boundaries {
-		if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-			return err
-		}
-	}
-	// Also saves the last post state which to be used as pre state for the next batch.
 	lastB := blks[len(blks)-1]
-	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
-		return err
-	}
 	arg := &notifyForkchoiceUpdateArg{
 		headState: preState,
 		headRoot:  lastBR,
@@ -597,8 +596,8 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 }
 
 // This removes the attestations in block `b` from the attestation mem pool.
-func (s *Service) pruneAttsFromPool(b interfaces.ReadOnlySignedBeaconBlock) error {
-	atts := b.Block().Body().Attestations()
+func (s *Service) pruneAttsFromPool(headBlock interfaces.ReadOnlySignedBeaconBlock) error {
+	atts := headBlock.Block().Body().Attestations()
 	for _, att := range atts {
 		if helpers.IsAggregated(att) {
 			if err := s.cfg.AttPool.DeleteAggregatedAttestation(att); err != nil {
@@ -667,15 +666,15 @@ func (s *Service) fillMissingPayloadIDRoutine(ctx context.Context, stateFeed *ev
 			break
 		}
 
-		ticker := time.NewTicker(time.Second)
-		defer ticker.Stop()
+		attThreshold := params.BeaconConfig().SecondsPerSlot / 3
+		ticker := slots.NewSlotTickerWithOffset(s.genesisTime, time.Duration(attThreshold)*time.Second, params.BeaconConfig().SecondsPerSlot)
 		for {
 			select {
-			case ti := <-ticker.C:
-				if err := s.fillMissingBlockPayloadId(ctx, ti); err != nil {
+			case <-ticker.C():
+				if err := s.fillMissingBlockPayloadId(ctx); err != nil {
 					log.WithError(err).Error("Could not fill missing payload ID")
 				}
-			case <-s.ctx.Done():
+			case <-ctx.Done():
 				log.Debug("Context closed, exiting routine")
 				return
 			}
@@ -683,16 +682,9 @@ func (s *Service) fillMissingPayloadIDRoutine(ctx context.Context, stateFeed *ev
 	}()
 }
 
-// Returns true if time `t` is halfway through the slot in sec.
-func atHalfSlot(t time.Time) bool {
-	s := params.BeaconConfig().SecondsPerSlot
-	return uint64(t.Second())%s == s/2
-}
-
-func (s *Service) fillMissingBlockPayloadId(ctx context.Context, ti time.Time) error {
-	if !atHalfSlot(ti) {
-		return nil
-	}
+// fillMissingBlockPayloadId is called 4 seconds into the slot and calls FCU if we are proposing next slot
+// and the cache has been missed
+func (s *Service) fillMissingBlockPayloadId(ctx context.Context) error {
 	s.ForkChoicer().RLock()
 	highestReceivedSlot := s.cfg.ForkChoiceStore.HighestReceivedBlockSlot()
 	s.ForkChoicer().RUnlock()
@@ -705,10 +697,10 @@ func (s *Service) fillMissingBlockPayloadId(ctx context.Context, ti time.Time) e
 	if !has || id != [8]byte{} {
 		return nil
 	}
-	missedPayloadIDFilledCount.Inc()
 	s.headLock.RLock()
 	headBlock, err := s.headBlock()
 	if err != nil {
+		s.headLock.RUnlock()
 		return err
 	}
 	headState := s.headState(ctx)

beacon-chain/blockchain/process_block_test.go

@@ -2164,7 +2164,7 @@ func TestFillMissingBlockPayloadId_DiffSlotExitEarly(t *testing.T) {
 
 	service, err := NewService(ctx, opts...)
 	require.NoError(t, err)
-	require.NoError(t, service.fillMissingBlockPayloadId(ctx, time.Unix(int64(params.BeaconConfig().SecondsPerSlot/2), 0)))
+	require.NoError(t, service.fillMissingBlockPayloadId(ctx), 0)
 }
 
 // Helper function to simulate the block being on time or delayed for proposer

beacon-chain/blockchain/receive_attestation.go

@@ -11,7 +11,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
+	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
@@ -19,6 +21,10 @@ import (
 	"go.opencensus.io/trace"
 )
 
+// reorgLateBlockCountAttestations is the time until the end of the slot in which we count
+// attestations to see if we will reorg the incoming block
+const reorgLateBlockCountAttestations = 2 * time.Second
+
 // AttestationStateFetcher allows for retrieving a beacon state corresponding to the block
 // root of an attestation's target checkpoint.
 type AttestationStateFetcher interface {
@@ -88,30 +94,40 @@ func (s *Service) spawnProcessAttestationsRoutine(stateFeed *event.Feed) {
 		}
 
 		st := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+		pat := slots.NewSlotTickerWithOffset(s.genesisTime, -reorgLateBlockCountAttestations, params.BeaconConfig().SecondsPerSlot)
 		for {
 			select {
 			case <-s.ctx.Done():
 				return
+			case <-pat.C():
+				s.ForkChoicer().Lock()
+				s.UpdateHead(s.ctx, s.CurrentSlot()+1)
+				s.ForkChoicer().Unlock()
 			case <-st.C():
+				s.ForkChoicer().Lock()
 				if err := s.ForkChoicer().NewSlot(s.ctx, s.CurrentSlot()); err != nil {
-					log.WithError(err).Error("Could not process new slot")
+					log.WithError(err).Error("could not process new slot")
 				}
 
-				if err := s.UpdateHead(s.ctx); err != nil {
-					log.WithError(err).Error("Could not process attestations and update head")
-				}
+				s.UpdateHead(s.ctx, s.CurrentSlot())
+				s.ForkChoicer().Unlock()
 			}
 		}
 	}()
 }
 
 // UpdateHead updates the canonical head of the chain based on information from fork-choice attestations and votes.
-// It requires no external inputs.
-func (s *Service) UpdateHead(ctx context.Context) error {
+// The caller of this function MUST hold a lock in forkchoice
+func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot) {
 	start := time.Now()
-	s.ForkChoicer().Lock()
-	defer s.ForkChoicer().Unlock()
-	s.processAttestations(ctx)
+
+	// This function is only called at 10 seconds or 0 seconds into the slot
+	disparity := params.BeaconNetworkConfig().MaximumGossipClockDisparity
+	if !features.Get().DisableReorgLateBlocks {
+		disparity += reorgLateBlockCountAttestations
+	}
+	s.processAttestations(ctx, disparity)
+
 	processAttsElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
 
 	start = time.Now()
@@ -129,21 +145,20 @@ func (s *Service) UpdateHead(ctx context.Context) error {
 		}).Debug("Head changed due to attestations")
 	}
 	s.headLock.RUnlock()
-	if err := s.forkchoiceUpdateWithExecution(ctx, newHeadRoot); err != nil {
-		return err
+	if err := s.forkchoiceUpdateWithExecution(s.ctx, newHeadRoot, proposingSlot); err != nil {
+		log.WithError(err).Error("could not update forkchoice")
 	}
-	return nil
 }
 
 // This processes fork choice attestations from the pool to account for validator votes and fork choice.
-func (s *Service) processAttestations(ctx context.Context) {
+func (s *Service) processAttestations(ctx context.Context, disparity time.Duration) {
 	atts := s.cfg.AttPool.ForkchoiceAttestations()
 	for _, a := range atts {
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
 		// https://github.com/ethereum/consensus-specs/blob/dev/specs/phase0/fork-choice.md#validate_on_attestation
 		nextSlot := a.Data.Slot + 1
-		if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), nextSlot, params.BeaconNetworkConfig().MaximumGossipClockDisparity); err != nil {
+		if err := slots.VerifyTime(uint64(s.genesisTime.Unix()), nextSlot, disparity); err != nil {
 			continue
 		}
 
@@ -161,7 +176,7 @@ func (s *Service) processAttestations(ctx context.Context) {
 			continue
 		}
 
-		if err := s.receiveAttestationNoPubsub(ctx, a); err != nil {
+		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
 			log.WithFields(logrus.Fields{
 				"slot":             a.Data.Slot,
 				"committeeIndex":   a.Data.CommitteeIndex,
@@ -178,11 +193,11 @@ func (s *Service) processAttestations(ctx context.Context) {
 //  1. Validate attestation, update validator's latest vote
 //  2. Apply fork choice to the processed attestation
 //  3. Save latest head info
-func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation) error {
+func (s *Service) receiveAttestationNoPubsub(ctx context.Context, att *ethpb.Attestation, disparity time.Duration) error {
 	ctx, span := trace.StartSpan(ctx, "beacon-chain.blockchain.receiveAttestationNoPubsub")
 	defer span.End()
 
-	if err := s.OnAttestation(ctx, att); err != nil {
+	if err := s.OnAttestation(ctx, att, disparity); err != nil {
 		return errors.Wrap(err, "could not process attestation")
 	}
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -120,7 +120,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(atts))
-	service.processAttestations(ctx)
+	service.processAttestations(ctx, 0)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
 	require.LogsDoNotContain(t, hook, "Could not process attestation for fork choice")
 }
@@ -183,10 +183,9 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	service.head.root = r // Old head
 
 	require.Equal(t, 1, len(service.cfg.AttPool.ForkchoiceAttestations()))
-	require.NoError(t, err, service.UpdateHead(ctx))
-
+	service.UpdateHead(ctx, 0)
+	require.Equal(t, tRoot, service.headRoot())
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations())) // Validate att pool is empty
-	require.Equal(t, tRoot, service.head.root)                             // Validate head is the new one
 }
 
 func TestService_UpdateHead_NoAtts(t *testing.T) {
@@ -236,9 +235,8 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	require.Equal(t, 3, fcs.NodeCount())
 
 	require.Equal(t, 0, service.cfg.AttPool.ForkchoiceAttestationCount())
-	require.NoError(t, err, service.UpdateHead(ctx))
+	service.UpdateHead(ctx, 0)
+	require.Equal(t, r, service.headRoot())
 
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations())) // Validate att pool is empty
-	require.Equal(t, r, service.head.root)                                 // Validate head is the new one
-
 }

beacon-chain/blockchain/receive_block.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 
 	"github.com/pkg/errors"
@@ -48,7 +49,6 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-
 	// Apply state transition on the new block.
 	if err := s.onBlock(ctx, blockCopy, blockRoot); err != nil {
 		err := errors.Wrap(err, "could not process block")
@@ -56,9 +56,9 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		return err
 	}
 
-	// Handle post block operations such as attestations and exits.
-	if err := s.handlePostBlockOperations(blockCopy.Block()); err != nil {
-		return err
+	// Handle post block operations such as pruning exits and bls messages if incoming block is the head
+	if err := s.prunePostBlockOperationPools(ctx, blockCopy, blockRoot); err != nil {
+		log.WithError(err).Error("Could not prune canonical objects from pool ")
 	}
 
 	// Have we been finalizing? Should we start saving hot states to db?
@@ -157,29 +157,40 @@ func (s *Service) ReceiveAttesterSlashing(ctx context.Context, slashing *ethpb.A
 	s.InsertSlashingsToForkChoiceStore(ctx, []*ethpb.AttesterSlashing{slashing})
 }
 
-func (s *Service) handlePostBlockOperations(b interfaces.ReadOnlyBeaconBlock) error {
+// prunePostBlockOperationPools only runs on new head otherwise should return a nil.
+func (s *Service) prunePostBlockOperationPools(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock, root [32]byte) error {
+	headRoot, err := s.HeadRoot(ctx)
+	if err != nil {
+		return err
+	}
+	// By comparing the current headroot, that has already gone through forkchoice,
+	// we can assume that if equal the current block root is canonical.
+	if !bytes.Equal(headRoot, root[:]) {
+		return nil
+	}
+
 	// Mark block exits as seen so we don't include same ones in future blocks.
-	for _, e := range b.Body().VoluntaryExits() {
+	for _, e := range blk.Block().Body().VoluntaryExits() {
 		s.cfg.ExitPool.MarkIncluded(e)
 	}
 
 	// Mark block BLS changes as seen so we don't include same ones in future blocks.
-	if err := s.handleBlockBLSToExecChanges(b); err != nil {
+	if err := s.markIncludedBlockBLSToExecChanges(blk.Block()); err != nil {
 		return errors.Wrap(err, "could not process BLSToExecutionChanges")
 	}
 
 	//  Mark attester slashings as seen so we don't include same ones in future blocks.
-	for _, as := range b.Body().AttesterSlashings() {
+	for _, as := range blk.Block().Body().AttesterSlashings() {
 		s.cfg.SlashingPool.MarkIncludedAttesterSlashing(as)
 	}
 	return nil
 }
 
-func (s *Service) handleBlockBLSToExecChanges(blk interfaces.ReadOnlyBeaconBlock) error {
-	if blk.Version() < version.Capella {
+func (s *Service) markIncludedBlockBLSToExecChanges(headBlock interfaces.ReadOnlyBeaconBlock) error {
+	if headBlock.Version() < version.Capella {
 		return nil
 	}
-	changes, err := blk.Body().BLSToExecutionChanges()
+	changes, err := headBlock.Body().BLSToExecutionChanges()
 	if err != nil {
 		return errors.Wrap(err, "could not get BLSToExecutionChanges")
 	}

beacon-chain/blockchain/receive_block_test.go

@@ -357,7 +357,7 @@ func TestHandleBlockBLSToExecutionChanges(t *testing.T) {
 		}
 		blk, err := blocks.NewBeaconBlock(pbb)
 		require.NoError(t, err)
-		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
+		require.NoError(t, service.markIncludedBlockBLSToExecChanges(blk))
 	})
 
 	t.Run("Post Capella no changes", func(t *testing.T) {
@@ -367,7 +367,7 @@ func TestHandleBlockBLSToExecutionChanges(t *testing.T) {
 		}
 		blk, err := blocks.NewBeaconBlock(pbb)
 		require.NoError(t, err)
-		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
+		require.NoError(t, service.markIncludedBlockBLSToExecChanges(blk))
 	})
 
 	t.Run("Post Capella some changes", func(t *testing.T) {
@@ -389,7 +389,7 @@ func TestHandleBlockBLSToExecutionChanges(t *testing.T) {
 
 		pool.InsertBLSToExecChange(signedChange)
 		require.Equal(t, true, pool.ValidatorExists(idx))
-		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
+		require.NoError(t, service.markIncludedBlockBLSToExecChanges(blk))
 		require.Equal(t, false, pool.ValidatorExists(idx))
 	})
 }

beacon-chain/blockchain/testing/BUILD.bazel

@@ -20,11 +20,13 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

beacon-chain/blockchain/testing/mock.go

@@ -19,11 +19,13 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v3/beacon-chain/state/state-native"
 	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
+	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
 )
@@ -459,7 +461,17 @@ func (s *ChainService) IsOptimisticForRoot(_ context.Context, root [32]byte) (bo
 }
 
 // UpdateHead mocks the same method in the chain service.
-func (s *ChainService) UpdateHead(_ context.Context) error { return nil }
+func (s *ChainService) UpdateHead(ctx context.Context, slot primitives.Slot) {
+	ojc := &ethpb.Checkpoint{}
+	st, root, err := prepareForkchoiceState(ctx, slot, bytesutil.ToBytes32(s.Root), [32]byte{}, [32]byte{}, ojc, ojc)
+	if err != nil {
+		logrus.WithError(err).Error("could not update head")
+	}
+	err = s.ForkChoicer().InsertNode(ctx, st, root)
+	if err != nil {
+		logrus.WithError(err).Error("could not insert node to forkchoice")
+	}
+}
 
 // ReceiveAttesterSlashing mocks the same method in the chain service.
 func (s *ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterSlashing) {}
@@ -468,3 +480,37 @@ func (s *ChainService) ReceiveAttesterSlashing(context.Context, *ethpb.AttesterS
 func (s *ChainService) IsFinalized(_ context.Context, blockRoot [32]byte) bool {
 	return s.FinalizedRoots[blockRoot]
 }
+
+// prepareForkchoiceState prepares a beacon state with the given data to mock
+// insert into forkchoice
+func prepareForkchoiceState(
+	_ context.Context,
+	slot primitives.Slot,
+	blockRoot [32]byte,
+	parentRoot [32]byte,
+	payloadHash [32]byte,
+	justified *ethpb.Checkpoint,
+	finalized *ethpb.Checkpoint,
+) (state.BeaconState, [32]byte, error) {
+	blockHeader := &ethpb.BeaconBlockHeader{
+		ParentRoot: parentRoot[:],
+	}
+
+	executionHeader := &enginev1.ExecutionPayloadHeader{
+		BlockHash: payloadHash[:],
+	}
+
+	base := &ethpb.BeaconStateBellatrix{
+		Slot:                         slot,
+		RandaoMixes:                  make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+		BlockRoots:                   make([][]byte, 1),
+		CurrentJustifiedCheckpoint:   justified,
+		FinalizedCheckpoint:          finalized,
+		LatestExecutionPayloadHeader: executionHeader,
+		LatestBlockHeader:            blockHeader,
+	}
+
+	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
+	st, err := state_native.InitializeFromProtoBellatrix(base)
+	return st, blockRoot, err
+}

beacon-chain/cache/depositsnapshot/BUILD.bazel

@@ -1,4 +1,4 @@
-load("@prysm//tools/go:def.bzl", "go_library")
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
@@ -19,3 +19,25 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
     ],
 )
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "deposit_tree_snapshot_test.go",
+        "merkle_tree_test.go",
+        "spec_test.go",
+    ],
+    data = [
+        "@eip4881_spec_tests//:test_data",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//io/file:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//testing/assert:go_default_library",
+        "//testing/require:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+        "@in_gopkg_yaml_v3//:go_default_library",
+        "@io_bazel_rules_go//go/tools/bazel:go_default_library",
+    ],
+)

beacon-chain/cache/depositsnapshot/deposit_tree.go

@@ -23,8 +23,6 @@ var (
 	ErrInvalidIndex = errors.New("index should be greater than finalizedDeposits - 1")
 	// ErrNoDeposits occurs when the number of deposits is 0.
 	ErrNoDeposits = errors.New("number of deposits should be greater than 0")
-	// ErrNoFinalizedDeposits occurs when the number of finalized deposits is 0.
-	ErrNoFinalizedDeposits = errors.New("number of finalized deposits should be greater than 0")
 	// ErrTooManyDeposits occurs when the number of deposits exceeds the capacity of the tree.
 	ErrTooManyDeposits = errors.New("number of deposits should not be greater than the capacity of the tree")
 )
@@ -62,7 +60,7 @@ func (d *DepositTree) getSnapshot() (DepositTreeSnapshot, error) {
 		return DepositTreeSnapshot{}, ErrEmptyExecutionBlock
 	}
 	var finalized [][32]byte
-	depositCount, _ := d.tree.GetFinalized(finalized)
+	depositCount, finalized := d.tree.GetFinalized(finalized)
 	return fromTreeParts(finalized, depositCount, d.finalizedExecutionBlock)
 }
 
@@ -119,9 +117,6 @@ func (d *DepositTree) getProof(index uint64) ([32]byte, [][32]byte, error) {
 		return [32]byte{}, nil, ErrInvalidMixInLength
 	}
 	finalizedDeposits, _ := d.tree.GetFinalized([][32]byte{})
-	if finalizedDeposits == 0 {
-		return [32]byte{}, nil, ErrNoFinalizedDeposits
-	}
 	if finalizedDeposits != 0 {
 		finalizedDeposits = finalizedDeposits - 1
 	}

beacon-chain/cache/depositsnapshot/deposit_tree_snapshot.go

@@ -40,7 +40,7 @@ func (ds *DepositTreeSnapshot) CalculateRoot() ([32]byte, error) {
 		}
 		size >>= 1
 	}
-	return sha256.Sum256(append(root[:], bytesutil.Uint64ToBytesLittleEndian(ds.depositCount)...)), nil
+	return sha256.Sum256(append(root[:], bytesutil.Uint64ToBytesLittleEndian32(ds.depositCount)...)), nil
 }
 
 // fromTreeParts constructs the deposit tree from pre-existing data.

beacon-chain/cache/depositsnapshot/deposit_tree_snapshot_test.go

@@ -0,0 +1,54 @@
+package depositsnapshot
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v3/testing/require"
+)
+
+func TestDepositTreeSnapshot_CalculateRoot(t *testing.T) {
+	tests := []struct {
+		name         string
+		finalized    int
+		depositCount uint64
+		want         [32]byte
+	}{
+		{
+			name:         "empty",
+			finalized:    0,
+			depositCount: 0,
+			want:         [32]byte{215, 10, 35, 71, 49, 40, 92, 104, 4, 194, 164, 245, 103, 17, 221, 184, 200, 44, 153, 116, 15, 32, 120, 84, 137, 16, 40, 175, 52, 226, 126, 94},
+		},
+		{
+			name:         "1 Finalized",
+			finalized:    1,
+			depositCount: 2,
+			want:         [32]byte{36, 118, 154, 57, 217, 109, 145, 116, 238, 1, 207, 59, 187, 28, 69, 187, 70, 55, 153, 180, 15, 150, 37, 72, 140, 36, 109, 154, 212, 202, 47, 59},
+		},
+		{
+			name:         "many finalised",
+			finalized:    6,
+			depositCount: 20,
+			want:         [32]byte{210, 63, 57, 119, 12, 5, 3, 25, 139, 20, 244, 59, 114, 119, 35, 88, 222, 88, 122, 106, 239, 20, 45, 140, 99, 92, 222, 166, 133, 159, 128, 72},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var finalized [][32]byte
+			for i := 0; i < tt.finalized; i++ {
+				finalized = append(finalized, hexString(t, fmt.Sprintf("%064d", i)))
+			}
+			ds := &DepositTreeSnapshot{
+				finalized:    finalized,
+				depositCount: tt.depositCount,
+			}
+			root, err := ds.CalculateRoot()
+			require.NoError(t, err)
+			if got := root; !reflect.DeepEqual(got, tt.want) {
+				require.DeepEqual(t, tt.want, got)
+			}
+		})
+	}
+}

beacon-chain/cache/depositsnapshot/merkle_tree_test.go

@@ -0,0 +1,141 @@
+package depositsnapshot
+
+import (
+	"encoding/hex"
+	"fmt"
+	"reflect"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v3/testing/assert"
+	"github.com/prysmaticlabs/prysm/v3/testing/require"
+)
+
+func hexString(t *testing.T, hexStr string) [32]byte {
+	t.Helper()
+	b, err := hex.DecodeString(hexStr)
+	require.NoError(t, err)
+	if len(b) != 32 {
+		assert.Equal(t, 32, len(b), "bad hash length, expected 32")
+	}
+	x := (*[32]byte)(b)
+	return *x
+}
+
+func Test_create(t *testing.T) {
+	tests := []struct {
+		name   string
+		leaves [][32]byte
+		depth  uint64
+		want   MerkleTreeNode
+	}{
+		{
+			name:   "empty tree",
+			leaves: nil,
+			depth:  0,
+			want:   &ZeroNode{},
+		},
+		{
+			name:   "zero depth",
+			leaves: [][32]byte{hexString(t, fmt.Sprintf("%064d", 0))},
+			depth:  0,
+			want:   &LeafNode{},
+		},
+		{
+			name:   "depth of 1",
+			leaves: [][32]byte{hexString(t, fmt.Sprintf("%064d", 0))},
+			depth:  1,
+			want:   &InnerNode{&LeafNode{}, &ZeroNode{}},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := create(tt.leaves, tt.depth); !reflect.DeepEqual(got, tt.want) {
+				require.DeepEqual(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func Test_fromSnapshotParts(t *testing.T) {
+	tests := []struct {
+		name      string
+		finalized [][32]byte
+		deposits  uint64
+		level     uint64
+		want      MerkleTreeNode
+	}{
+		{
+			name:      "empty",
+			finalized: nil,
+			deposits:  0,
+			level:     0,
+			want:      &ZeroNode{},
+		},
+		{
+			name:      "single finalized node",
+			finalized: [][32]byte{hexString(t, fmt.Sprintf("%064d", 0))},
+			deposits:  1,
+			level:     0,
+			want: &FinalizedNode{
+				depositCount: 1,
+				hash:         [32]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+			},
+		},
+		{
+			name:      "multiple deposits and 1 Finalized",
+			finalized: [][32]byte{hexString(t, fmt.Sprintf("%064d", 0))},
+			deposits:  2,
+			level:     4,
+			want: &InnerNode{
+				left:  &InnerNode{&InnerNode{&FinalizedNode{depositCount: 2, hash: hexString(t, fmt.Sprintf("%064d", 0))}, &ZeroNode{1}}, &ZeroNode{2}},
+				right: &ZeroNode{3},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tree, err := fromSnapshotParts(tt.finalized, tt.deposits, tt.level)
+			require.NoError(t, err)
+			if got := tree; !reflect.DeepEqual(got, tt.want) {
+				require.DeepEqual(t, tt.want, got)
+			}
+		})
+	}
+}
+
+func Test_generateProof(t *testing.T) {
+	tests := []struct {
+		name   string
+		leaves uint64
+	}{
+		{
+			name:   "1 leaf",
+			leaves: 1,
+		},
+		{
+			name:   "4 leaves",
+			leaves: 4,
+		},
+		{
+			name:   "10 leaves",
+			leaves: 10,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			testCases, err := readTestCases()
+			require.NoError(t, err)
+			tree := New()
+			for _, c := range testCases[:tt.leaves] {
+				err = tree.pushLeaf(c.DepositDataRoot)
+				require.NoError(t, err)
+			}
+			for i := uint64(0); i < tt.leaves; i++ {
+				leaf, proof := generateProof(tree.tree, i, DepositContractDepth)
+				require.Equal(t, leaf, testCases[i].DepositDataRoot)
+				calcRoot := merkleRootFromBranch(leaf, proof, i)
+				require.Equal(t, tree.tree.GetRoot(), calcRoot)
+			}
+		})
+	}
+}

beacon-chain/cache/depositsnapshot/spec_test.go

@@ -0,0 +1,355 @@
+package depositsnapshot
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"strconv"
+	"strings"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v3/io/file"
+	eth "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
+	"github.com/prysmaticlabs/prysm/v3/testing/require"
+	"gopkg.in/yaml.v3"
+)
+
+type testCase struct {
+	DepositData     depositData `yaml:"deposit_data"`
+	DepositDataRoot [32]byte    `yaml:"deposit_data_root"`
+	Eth1Data        *eth1Data   `yaml:"eth1_data"`
+	BlockHeight     uint64      `yaml:"block_height"`
+	Snapshot        snapshot    `yaml:"snapshot"`
+}
+
+func (tc *testCase) UnmarshalYAML(value *yaml.Node) error {
+	raw := struct {
+		DepositData     depositData `yaml:"deposit_data"`
+		DepositDataRoot string      `yaml:"deposit_data_root"`
+		Eth1Data        *eth1Data   `yaml:"eth1_data"`
+		BlockHeight     string      `yaml:"block_height"`
+		Snapshot        snapshot    `yaml:"snapshot"`
+	}{}
+	err := value.Decode(&raw)
+	if err != nil {
+		return err
+	}
+	tc.DepositDataRoot, err = hexStringToByteArray(raw.DepositDataRoot)
+	if err != nil {
+		return err
+	}
+	tc.DepositData = raw.DepositData
+	tc.Eth1Data = raw.Eth1Data
+	tc.BlockHeight, err = stringToUint64(raw.BlockHeight)
+	if err != nil {
+		return err
+	}
+	tc.Snapshot = raw.Snapshot
+	return nil
+}
+
+type depositData struct {
+	Pubkey                []byte `yaml:"pubkey"`
+	WithdrawalCredentials []byte `yaml:"withdrawal_credentials"`
+	Amount                uint64 `yaml:"amount"`
+	Signature             []byte `yaml:"signature"`
+}
+
+func (dd *depositData) UnmarshalYAML(value *yaml.Node) error {
+	raw := struct {
+		Pubkey                string `yaml:"pubkey"`
+		WithdrawalCredentials string `yaml:"withdrawal_credentials"`
+		Amount                string `yaml:"amount"`
+		Signature             string `yaml:"signature"`
+	}{}
+	err := value.Decode(&raw)
+	if err != nil {
+		return err
+	}
+	dd.Pubkey, err = hexStringToBytes(raw.Pubkey)
+	if err != nil {
+		return err
+	}
+	dd.WithdrawalCredentials, err = hexStringToBytes(raw.WithdrawalCredentials)
+	if err != nil {
+		return err
+	}
+	dd.Amount, err = strconv.ParseUint(raw.Amount, 10, 64)
+	if err != nil {
+		return err
+	}
+	dd.Signature, err = hexStringToBytes(raw.Signature)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type eth1Data struct {
+	DepositRoot  [32]byte `yaml:"deposit_root"`
+	DepositCount uint64   `yaml:"deposit_count"`
+	BlockHash    [32]byte `yaml:"block_hash"`
+}
+
+func (ed *eth1Data) UnmarshalYAML(value *yaml.Node) error {
+	raw := struct {
+		DepositRoot  string `yaml:"deposit_root"`
+		DepositCount string `yaml:"deposit_count"`
+		BlockHash    string `yaml:"block_hash"`
+	}{}
+	err := value.Decode(&raw)
+	if err != nil {
+		return err
+	}
+	ed.DepositRoot, err = hexStringToByteArray(raw.DepositRoot)
+	if err != nil {
+		return err
+	}
+	ed.DepositCount, err = stringToUint64(raw.DepositCount)
+	if err != nil {
+		return err
+	}
+	ed.BlockHash, err = hexStringToByteArray(raw.BlockHash)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+type snapshot struct {
+	DepositTreeSnapshot
+}
+
+func (sd *snapshot) UnmarshalYAML(value *yaml.Node) error {
+	raw := struct {
+		Finalized            []string `yaml:"finalized"`
+		DepositRoot          string   `yaml:"deposit_root"`
+		DepositCount         string   `yaml:"deposit_count"`
+		ExecutionBlockHash   string   `yaml:"execution_block_hash"`
+		ExecutionBlockHeight string   `yaml:"execution_block_height"`
+	}{}
+	err := value.Decode(&raw)
+	if err != nil {
+		return err
+	}
+	sd.finalized = make([][32]byte, len(raw.Finalized))
+	for i, finalized := range raw.Finalized {
+		sd.finalized[i], err = hexStringToByteArray(finalized)
+		if err != nil {
+			return err
+		}
+	}
+	sd.depositRoot, err = hexStringToByteArray(raw.DepositRoot)
+	if err != nil {
+		return err
+	}
+	sd.depositCount, err = stringToUint64(raw.DepositCount)
+	if err != nil {
+		return err
+	}
+	sd.executionBlock.Hash, err = hexStringToByteArray(raw.ExecutionBlockHash)
+	if err != nil {
+		return err
+	}
+	sd.executionBlock.Depth, err = stringToUint64(raw.ExecutionBlockHeight)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func readTestCases() ([]testCase, error) {
+	testFolders, err := bazel.ListRunfiles()
+	if err != nil {
+		return nil, err
+	}
+	for _, ff := range testFolders {
+		if strings.Contains(ff.ShortPath, "eip4881_spec_tests") &&
+			strings.Contains(ff.ShortPath, "eip-4881/test_cases.yaml") {
+			enc, err := file.ReadFileAsBytes(ff.Path)
+			if err != nil {
+				return nil, err
+			}
+			var testCases []testCase
+			err = yaml.Unmarshal(enc, &testCases)
+			if err != nil {
+				return []testCase{}, err
+			}
+			return testCases, nil
+		}
+	}
+	return nil, errors.New("spec test file not found")
+}
+
+func TestRead(t *testing.T) {
+	tcs, err := readTestCases()
+	require.NoError(t, err)
+	for _, tc := range tcs {
+		t.Log(tc)
+	}
+}
+
+func hexStringToByteArray(s string) (b [32]byte, err error) {
+	var raw []byte
+	raw, err = hexStringToBytes(s)
+	if err != nil {
+		return
+	}
+	if len(raw) != 32 {
+		err = errors.New("invalid hex string length")
+		return
+	}
+	copy(b[:], raw[:32])
+	return
+}
+
+func hexStringToBytes(s string) (b []byte, err error) {
+	b, err = hex.DecodeString(strings.TrimPrefix(s, "0x"))
+	return
+}
+
+func stringToUint64(s string) (uint64, error) {
+	value, err := strconv.ParseUint(s, 10, 32)
+	if err != nil {
+		return 0, err
+	}
+	return value, nil
+}
+
+func merkleRootFromBranch(leaf [32]byte, branch [][32]byte, index uint64) [32]byte {
+	root := leaf
+	for i, l := range branch {
+		ithBit := (index >> i) & 0x1
+		if ithBit == 1 {
+			root = sha256.Sum256(append(l[:], root[:]...))
+		} else {
+			root = sha256.Sum256(append(root[:], l[:]...))
+		}
+	}
+	return root
+}
+
+func checkProof(t *testing.T, tree *DepositTree, index uint64) {
+	leaf, proof, err := tree.getProof(index)
+	require.NoError(t, err)
+	calcRoot := merkleRootFromBranch(leaf, proof, index)
+	require.Equal(t, tree.getRoot(), calcRoot)
+}
+
+func compareProof(t *testing.T, tree1, tree2 *DepositTree, index uint64) {
+	require.Equal(t, tree1.getRoot(), tree2.getRoot())
+	checkProof(t, tree1, index)
+	checkProof(t, tree2, index)
+}
+
+func cloneFromSnapshot(t *testing.T, snapshot DepositTreeSnapshot, testCases []testCase) *DepositTree {
+	cp, err := fromSnapshot(snapshot)
+	require.NoError(t, err)
+	for _, c := range testCases {
+		err = cp.pushLeaf(c.DepositDataRoot)
+		require.NoError(t, err)
+	}
+	return &cp
+}
+
+func TestDepositCases(t *testing.T) {
+	tree := New()
+	testCases, err := readTestCases()
+	require.NoError(t, err)
+	for _, c := range testCases {
+		err = tree.pushLeaf(c.DepositDataRoot)
+		require.NoError(t, err)
+	}
+}
+
+func TestFinalization(t *testing.T) {
+	tree := New()
+	testCases, err := readTestCases()
+	require.NoError(t, err)
+	for _, c := range testCases[:128] {
+		err = tree.pushLeaf(c.DepositDataRoot)
+		require.NoError(t, err)
+	}
+	originalRoot := tree.getRoot()
+	require.DeepEqual(t, testCases[127].Eth1Data.DepositRoot, originalRoot)
+	err = tree.finalize(&eth.Eth1Data{
+		DepositRoot:  testCases[100].Eth1Data.DepositRoot[:],
+		DepositCount: testCases[100].Eth1Data.DepositCount,
+		BlockHash:    testCases[100].Eth1Data.BlockHash[:],
+	}, testCases[100].BlockHeight)
+	require.NoError(t, err)
+	// ensure finalization doesn't change root
+	require.Equal(t, tree.getRoot(), originalRoot)
+	snapshotData, err := tree.getSnapshot()
+	require.NoError(t, err)
+	require.DeepEqual(t, testCases[100].Snapshot.DepositTreeSnapshot, snapshotData)
+	// create a copy of the tree from a snapshot by replaying
+	// the deposits after the finalized deposit
+	cp := cloneFromSnapshot(t, snapshotData, testCases[101:128])
+	// ensure original and copy have the same root
+	require.Equal(t, tree.getRoot(), cp.getRoot())
+	//	finalize original again to check double finalization
+	err = tree.finalize(&eth.Eth1Data{
+		DepositRoot:  testCases[105].Eth1Data.DepositRoot[:],
+		DepositCount: testCases[105].Eth1Data.DepositCount,
+		BlockHash:    testCases[105].Eth1Data.BlockHash[:],
+	}, testCases[105].BlockHeight)
+	require.NoError(t, err)
+	//	root should still be the same
+	require.Equal(t, originalRoot, tree.getRoot())
+	// create a copy of the tree by taking a snapshot again
+	snapshotData, err = tree.getSnapshot()
+	require.NoError(t, err)
+	cp = cloneFromSnapshot(t, snapshotData, testCases[106:128])
+	// create a copy of the tree by replaying ALL deposits from nothing
+	fullTreeCopy := New()
+	for _, c := range testCases[:128] {
+		err = fullTreeCopy.pushLeaf(c.DepositDataRoot)
+		require.NoError(t, err)
+	}
+	for i := 106; i < 128; i++ {
+		compareProof(t, tree, cp, uint64(i))
+		compareProof(t, tree, fullTreeCopy, uint64(i))
+	}
+}
+
+func TestSnapshotCases(t *testing.T) {
+	tree := New()
+	testCases, err := readTestCases()
+	require.NoError(t, err)
+	for _, c := range testCases {
+		err = tree.pushLeaf(c.DepositDataRoot)
+		require.NoError(t, err)
+	}
+	for _, c := range testCases {
+		err = tree.finalize(&eth.Eth1Data{
+			DepositRoot:  c.Eth1Data.DepositRoot[:],
+			DepositCount: c.Eth1Data.DepositCount,
+			BlockHash:    c.Eth1Data.BlockHash[:],
+		}, c.BlockHeight)
+		require.NoError(t, err)
+		s, err := tree.getSnapshot()
+		require.NoError(t, err)
+		require.DeepEqual(t, c.Snapshot.DepositTreeSnapshot, s)
+	}
+}
+
+func TestEmptyTreeSnapshot(t *testing.T) {
+	_, err := New().getSnapshot()
+	require.ErrorContains(t, "empty execution block", err)
+}
+
+func TestInvalidSnapshot(t *testing.T) {
+	invalidSnapshot := DepositTreeSnapshot{
+		finalized:    nil,
+		depositRoot:  Zerohashes[0],
+		depositCount: 0,
+		executionBlock: executionBlock{
+			Hash:  Zerohashes[0],
+			Depth: 0,
+		},
+	}
+	_, err := fromSnapshot(invalidSnapshot)
+	require.ErrorContains(t, "snapshot root is invalid", err)
+}

beacon-chain/db/kv/state_summary_test.go

@@ -74,5 +74,5 @@ func TestStateSummary_CanDelete(t *testing.T) {
 	require.Equal(t, true, db.HasStateSummary(ctx, r1), "State summary should be saved")
 
 	require.NoError(t, db.deleteStateSummary(r1))
-	require.Equal(t, false, db.HasStateSummary(ctx, r1), "State summary should not be saved")
+	require.Equal(t, false, db.HasStateSummary(ctx, r1), "State summary should be deleted")
 }

beacon-chain/execution/BUILD.bazel

@@ -37,6 +37,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
+        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -107,6 +108,7 @@ go_test(
         "//beacon-chain/execution/types:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
+        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/execution/engine_client.go

@@ -15,6 +15,7 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/execution/types"
+	"github.com/prysmaticlabs/prysm/v3/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
@@ -48,6 +49,10 @@ const (
 	ExecutionBlockByHashMethod = "eth_getBlockByHash"
 	// ExecutionBlockByNumberMethod request string for JSON-RPC.
 	ExecutionBlockByNumberMethod = "eth_getBlockByNumber"
+	// GetPayloadBodiesByHashV1 v1 request string for JSON-RPC.
+	GetPayloadBodiesByHashV1 = "engine_getPayloadBodiesByHashV1"
+	// GetPayloadBodiesByRangeV1 v1 request string for JSON-RPC.
+	GetPayloadBodiesByRangeV1 = "engine_getPayloadBodiesByRangeV1"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
 	defaultEngineTimeout = time.Second
 )
@@ -437,6 +442,50 @@ func (s *Service) HeaderByNumber(ctx context.Context, number *big.Int) (*types.H
 	return hdr, err
 }
 
+// GetPayloadBodiesByHash returns the relevant payload bodies for the provided block hash.
+func (s *Service) GetPayloadBodiesByHash(ctx context.Context, executionBlockHashes []common.Hash) ([]*pb.ExecutionPayloadBodyV1, error) {
+	if !features.Get().EnableOptionalEngineMethods {
+		return nil, errors.New("optional engine methods not enabled")
+	}
+	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetPayloadBodiesByHashV1")
+	defer span.End()
+
+	result := make([]*pb.ExecutionPayloadBodyV1, 0)
+	err := s.rpcClient.CallContext(ctx, &result, GetPayloadBodiesByHashV1, executionBlockHashes)
+
+	for i, item := range result {
+		if item == nil {
+			result[i] = &pb.ExecutionPayloadBodyV1{
+				Transactions: make([][]byte, 0),
+				Withdrawals:  make([]*pb.Withdrawal, 0),
+			}
+		}
+	}
+	return result, handleRPCError(err)
+}
+
+// GetPayloadBodiesByRange returns the relevant payload bodies for the provided range.
+func (s *Service) GetPayloadBodiesByRange(ctx context.Context, start, count uint64) ([]*pb.ExecutionPayloadBodyV1, error) {
+	if !features.Get().EnableOptionalEngineMethods {
+		return nil, errors.New("optional engine methods not enabled")
+	}
+	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetPayloadBodiesByRangeV1")
+	defer span.End()
+
+	result := make([]*pb.ExecutionPayloadBodyV1, 0)
+	err := s.rpcClient.CallContext(ctx, &result, GetPayloadBodiesByRangeV1, start, count)
+
+	for i, item := range result {
+		if item == nil {
+			result[i] = &pb.ExecutionPayloadBodyV1{
+				Transactions: make([][]byte, 0),
+				Withdrawals:  make([]*pb.Withdrawal, 0),
+			}
+		}
+	}
+	return result, handleRPCError(err)
+}
+
 // ReconstructFullBlock takes in a blinded beacon block and reconstructs
 // a beacon block with a full execution payload via the engine API.
 func (s *Service) ReconstructFullBlock(
@@ -669,6 +718,9 @@ func handleRPCError(err error) error {
 	case -38003:
 		errInvalidPayloadAttributesCount.Inc()
 		return ErrInvalidPayloadAttributes
+	case -38004:
+		errRequestTooLargeCount.Inc()
+		return ErrRequestTooLarge
 	case -32000:
 		errServerErrorCount.Inc()
 		// Only -32000 status codes are data errors in the RPC specification.

beacon-chain/execution/engine_client_test.go

@@ -20,6 +20,7 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	mocks "github.com/prysmaticlabs/prysm/v3/beacon-chain/execution/testing"
+	"github.com/prysmaticlabs/prysm/v3/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
@@ -1314,7 +1315,7 @@ func fixtures() map[string]interface{} {
 			ReceiptsRoot:  &common.Hash{'d'},
 			LogsBloom:     &hexutil.Bytes{'e'},
 			PrevRandao:    &common.Hash{'f'},
-			BaseFeePerGas: fmt.Sprintf("%s", "0x123"),
+			BaseFeePerGas: "0x123",
 			BlockHash:     &common.Hash{'g'},
 			Transactions:  []hexutil.Bytes{{'h'}},
 			Withdrawals:   []*pb.Withdrawal{},
@@ -1323,7 +1324,7 @@ func fixtures() map[string]interface{} {
 			GasUsed:       &hexUint,
 			Timestamp:     &hexUint,
 		},
-		BlockValue: fmt.Sprintf("%s", "0x11ff"),
+		BlockValue: "0x11ff",
 	}
 	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
 	sha3Uncles := bytesutil.PadTo([]byte("sha3Uncles"), fieldparams.RootLength)
@@ -1817,3 +1818,505 @@ func newPayloadV2Setup(t *testing.T, status *pb.PayloadStatus, payload *pb.Execu
 	service.rpcClient = rpcClient
 	return service
 }
+
+func TestCapella_PayloadBodiesByHash(t *testing.T) {
+	resetFn := features.InitWithReset(&features.Flags{
+		EnableOptionalEngineMethods: true,
+	})
+	defer resetFn()
+	t.Run("empty response works", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 0)
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByHash(ctx, []common.Hash{})
+		require.NoError(t, err)
+		require.Equal(t, 0, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("single element response null works", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 1)
+			executionPayloadBodies[0] = nil
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByHash(ctx, []common.Hash{})
+		require.NoError(t, err)
+		require.Equal(t, 1, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("empty, null, full works", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 3)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{},
+				Withdrawals:  []*pb.Withdrawal{},
+			}
+			executionPayloadBodies[1] = nil
+			executionPayloadBodies[2] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          1,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByHash(ctx, []common.Hash{})
+		require.NoError(t, err)
+		require.Equal(t, 3, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("full works, single item", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 1)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          1,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByHash(ctx, []common.Hash{})
+		require.NoError(t, err)
+		require.Equal(t, 1, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("full works, multiple items", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 2)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          1,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+			executionPayloadBodies[1] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          2,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByHash(ctx, []common.Hash{})
+		require.NoError(t, err)
+		require.Equal(t, 2, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("returning empty, null, empty should work properly", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			// [A, B, C] but no B in the server means
+			// we get [Abody, null, Cbody].
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 3)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{},
+				Withdrawals:  []*pb.Withdrawal{},
+			}
+			executionPayloadBodies[1] = nil
+			executionPayloadBodies[2] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{},
+				Withdrawals:  []*pb.Withdrawal{},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByHash(ctx, []common.Hash{})
+		require.NoError(t, err)
+		require.Equal(t, 3, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+}
+
+func TestCapella_PayloadBodiesByRange(t *testing.T) {
+	resetFn := features.InitWithReset(&features.Flags{
+		EnableOptionalEngineMethods: true,
+	})
+	defer resetFn()
+	t.Run("empty response works", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 0)
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByRange(ctx, uint64(1), uint64(2))
+		require.NoError(t, err)
+		require.Equal(t, 0, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("single element response null works", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 1)
+			executionPayloadBodies[0] = nil
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByRange(ctx, uint64(1), uint64(2))
+		require.NoError(t, err)
+		require.Equal(t, 1, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("empty, null, full works", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 3)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{},
+				Withdrawals:  []*pb.Withdrawal{},
+			}
+			executionPayloadBodies[1] = nil
+			executionPayloadBodies[2] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          1,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByRange(ctx, uint64(1), uint64(2))
+		require.NoError(t, err)
+		require.Equal(t, 3, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("full works, single item", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 1)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          1,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByRange(ctx, uint64(1), uint64(2))
+		require.NoError(t, err)
+		require.Equal(t, 1, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("full works, multiple items", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 2)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          1,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+			executionPayloadBodies[1] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{hexutil.MustDecode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")},
+				Withdrawals: []*pb.Withdrawal{{
+					Index:          2,
+					ValidatorIndex: 1,
+					Address:        hexutil.MustDecode("0xcf8e0d4e9587369b2301d0790347320302cc0943"),
+					Amount:         1,
+				}},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByRange(ctx, uint64(1), uint64(2))
+		require.NoError(t, err)
+		require.Equal(t, 2, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+	t.Run("returning empty, null, empty should work properly", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Header().Set("Content-Type", "application/json")
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			// [A, B, C] but no B in the server means
+			// we get [Abody, null, Cbody].
+			executionPayloadBodies := make([]*pb.ExecutionPayloadBodyV1, 3)
+			executionPayloadBodies[0] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{},
+				Withdrawals:  []*pb.Withdrawal{},
+			}
+			executionPayloadBodies[1] = nil
+			executionPayloadBodies[2] = &pb.ExecutionPayloadBodyV1{
+				Transactions: [][]byte{},
+				Withdrawals:  []*pb.Withdrawal{},
+			}
+
+			resp := map[string]interface{}{
+				"jsonrpc": "2.0",
+				"id":      1,
+				"result":  executionPayloadBodies,
+			}
+			err := json.NewEncoder(w).Encode(resp)
+			require.NoError(t, err)
+		}))
+		ctx := context.Background()
+
+		rpcClient, err := rpc.DialHTTP(srv.URL)
+		require.NoError(t, err)
+
+		service := &Service{}
+		service.rpcClient = rpcClient
+
+		results, err := service.GetPayloadBodiesByRange(ctx, uint64(1), uint64(2))
+		require.NoError(t, err)
+		require.Equal(t, 3, len(results))
+
+		for _, item := range results {
+			require.NotNil(t, item)
+		}
+	})
+}

beacon-chain/execution/errors.go

@@ -34,4 +34,6 @@ var (
 	ErrInvalidBlockHashPayloadStatus = errors.New("payload status is INVALID_BLOCK_HASH")
 	// ErrNilResponse when the response is nil.
 	ErrNilResponse = errors.New("nil response")
+	// ErrRequestTooLarge when the request is too large
+	ErrRequestTooLarge = errors.New("request too large")
 )

beacon-chain/execution/metrics.go

@@ -71,4 +71,8 @@ var (
 		Name: "reconstructed_execution_payload_count",
 		Help: "Count the number of execution payloads that are reconstructed using JSON-RPC from payload headers",
 	})
+	errRequestTooLargeCount = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "execution_payload_bodies_count",
+		Help: "The number of requested payload bodies is too large",
+	})
 )

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

@@ -495,7 +495,7 @@ func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byt
 	}
 }
 
-// InsertOptimisticChain inserts all nodes corresponding to blocks in the slice
+// InsertChain inserts all nodes corresponding to blocks in the slice
 // `blocks`. This slice must be ordered from child to parent. It includes all
 // blocks **except** the first one (that is the one with the highest slot
 // number). All blocks are assumed to be a strict chain

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

@@ -16,9 +16,9 @@ import (
 // consider a block to be late, and thus a candidate to being reorged.
 const orphanLateBlockFirstThreshold = 4
 
-// processAttestationsThreshold  is the number of seconds after which we
+// ProcessAttestationsThreshold  is the number of seconds after which we
 // process attestations for the current slot
-const processAttestationsThreshold = 10
+const ProcessAttestationsThreshold = 10
 
 // applyWeightChanges recomputes the weight of the node passed as an argument and all of its descendants,
 // using the current balance stored in each node.
@@ -148,7 +148,7 @@ func (n *Node) arrivedEarly(genesisTime uint64) (bool, error) {
 // slot will have secs = 10 below.
 func (n *Node) arrivedAfterOrphanCheck(genesisTime uint64) (bool, error) {
 	secs, err := slots.SecondsSinceSlotStart(n.slot, genesisTime, n.timestamp)
-	return secs >= processAttestationsThreshold, err
+	return secs >= ProcessAttestationsThreshold, err
 }
 
 // nodeTreeDump appends to the given list all the nodes descending from this one

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

@@ -294,7 +294,7 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	require.Equal(t, false, late)
 
 	// very late block
-	driftGenesisTime(f, 3, processAttestationsThreshold+1)
+	driftGenesisTime(f, 3, ProcessAttestationsThreshold+1)
 	root = [32]byte{'c'}
 	state, blkRoot, err = prepareForkchoiceState(ctx, 3, root, [32]byte{'b'}, [32]byte{'C'}, 0, 0)
 	require.NoError(t, err)

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

@@ -31,8 +31,6 @@ import (
 //	    if ancestor_at_finalized_slot == store.finalized_checkpoint.root:
 //	        store.justified_checkpoint = store.best_justified_checkpoint
 func (f *ForkChoice) NewSlot(ctx context.Context, slot primitives.Slot) error {
-	f.Lock()
-	defer f.Unlock()
 	// Reset proposer boost root
 	if err := f.resetBoostedProposerRoot(ctx); err != nil {
 		return errors.Wrap(err, "could not reset boosted proposer root in fork choice")

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

@@ -3,6 +3,7 @@ package doublylinkedtree
 import (
 	"time"
 
+	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
 )
@@ -41,9 +42,11 @@ func (f *ForkChoice) ShouldOverrideFCU() (override bool) {
 	if head == nil {
 		return
 	}
+
 	if head.slot != slots.CurrentSlot(f.store.genesisTime) {
 		return
 	}
+
 	// Do not reorg on epoch boundaries
 	if (head.slot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
 		return
@@ -90,6 +93,9 @@ func (f *ForkChoice) ShouldOverrideFCU() (override bool) {
 // This function needs to be called only when proposing a block and all
 // attestation processing has already happened.
 func (f *ForkChoice) GetProposerHead() [32]byte {
+	if features.Get().DisableReorgLateBlocks {
+		return f.CachedHeadRoot()
+	}
 	head := f.store.headNode
 	if head == nil {
 		return [32]byte{}

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

@@ -226,14 +226,6 @@ func (f *ForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	return f.store.highestReceivedNode.slot
 }
 
-// HighestReceivedBlockRoot returns the highest slot root received by the forkchoice
-func (f *ForkChoice) HighestReceivedBlockRoot() [32]byte {
-	if f.store.highestReceivedNode == nil {
-		return [32]byte{}
-	}
-	return f.store.highestReceivedNode.root
-}
-
 // ReceivedBlocksLastEpoch returns the number of blocks received in the last epoch
 func (f *ForkChoice) ReceivedBlocksLastEpoch() (uint64, error) {
 	count := uint64(0)

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

@@ -320,26 +320,6 @@ func TestStore_PruneMapsNodes(t *testing.T) {
 
 }
 
-func TestForkChoice_HighestReceivedBlockSlotRoot(t *testing.T) {
-	f := setup(1, 1)
-	s := f.store
-	_, err := s.insert(context.Background(), 100, [32]byte{'A'}, [32]byte{}, params.BeaconConfig().ZeroHash, 1, 1)
-	require.NoError(t, err)
-	require.Equal(t, primitives.Slot(100), s.highestReceivedNode.slot)
-	require.Equal(t, primitives.Slot(100), f.HighestReceivedBlockSlot())
-	require.Equal(t, [32]byte{'A'}, f.HighestReceivedBlockRoot())
-	_, err = s.insert(context.Background(), 1000, [32]byte{'B'}, [32]byte{}, params.BeaconConfig().ZeroHash, 1, 1)
-	require.NoError(t, err)
-	require.Equal(t, primitives.Slot(1000), s.highestReceivedNode.slot)
-	require.Equal(t, primitives.Slot(1000), f.HighestReceivedBlockSlot())
-	require.Equal(t, [32]byte{'B'}, f.HighestReceivedBlockRoot())
-	_, err = s.insert(context.Background(), 500, [32]byte{'C'}, [32]byte{}, params.BeaconConfig().ZeroHash, 1, 1)
-	require.NoError(t, err)
-	require.Equal(t, primitives.Slot(1000), s.highestReceivedNode.slot)
-	require.Equal(t, primitives.Slot(1000), f.HighestReceivedBlockSlot())
-	require.Equal(t, [32]byte{'B'}, f.HighestReceivedBlockRoot())
-}
-
 func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	f := setup(1, 1)
 	s := f.store

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

@@ -124,7 +124,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//            /
 	//           5 <- head, justified epoch = 2
 	//
-	// We set this node's slot to be 64 so that when prunning below we do not prune its child
+	// We set this node's slot to be 64 so that when pruning below we do not prune its child
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 2*params.BeaconConfig().SlotsPerEpoch, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 2)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))

beacon-chain/forkchoice/interfaces.go

@@ -30,9 +30,8 @@ type ForkChoicer interface {
 // HeadRetriever retrieves head root and optimistic info of the current chain.
 type HeadRetriever interface {
 	Head(context.Context) ([32]byte, error)
+	GetProposerHead() [32]byte
 	CachedHeadRoot() [32]byte
-	Tips() ([][32]byte, []primitives.Slot)
-	IsOptimistic(root [32]byte) (bool, error)
 }
 
 // BlockProcessor processes the block that's used for accounting fork choice.
@@ -44,7 +43,6 @@ type BlockProcessor interface {
 // AttestationProcessor processes the attestation that's used for accounting fork choice.
 type AttestationProcessor interface {
 	ProcessAttestation(context.Context, []uint64, [32]byte, primitives.Epoch)
-	InsertSlashedIndex(context.Context, primitives.ValidatorIndex)
 }
 
 // Getter returns fork choice related information.
@@ -62,10 +60,12 @@ type Getter interface {
 	BestJustifiedCheckpoint() *forkchoicetypes.Checkpoint
 	NodeCount() int
 	HighestReceivedBlockSlot() primitives.Slot
-	HighestReceivedBlockRoot() [32]byte
 	ReceivedBlocksLastEpoch() (uint64, error)
 	ForkChoiceDump(context.Context) (*v1.ForkChoiceDump, error)
 	Weight(root [32]byte) (uint64, error)
+	Tips() ([][32]byte, []primitives.Slot)
+	IsOptimistic(root [32]byte) (bool, error)
+	ShouldOverrideFCU() bool
 }
 
 // Setter allows to set forkchoice information
@@ -78,4 +78,5 @@ type Setter interface {
 	SetOriginRoot([32]byte)
 	NewSlot(context.Context, primitives.Slot) error
 	SetBalancesByRooter(BalancesByRooter)
+	InsertSlashedIndex(context.Context, primitives.ValidatorIndex)
 }

beacon-chain/forkchoice/types/types.go

@@ -7,16 +7,8 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 )
 
-// ProposerBoostRootArgs to call the BoostProposerRoot function.
-type ProposerBoostRootArgs struct {
-	BlockRoot       [32]byte
-	BlockSlot       primitives.Slot
-	CurrentSlot     primitives.Slot
-	SecondsIntoSlot uint64
-}
-
 // Checkpoint is an array version of ethpb.Checkpoint. It is used internally in
-// forkchoice, while the slice version is used in the interface to legagy code
+// forkchoice, while the slice version is used in the interface to legacy code
 // in other packages
 type Checkpoint struct {
 	Epoch primitives.Epoch

beacon-chain/node/config_test.go

@@ -143,18 +143,19 @@ func TestConfigureNetwork_ConfigFile(t *testing.T) {
 		"node2")), 0666))
 
 	require.NoError(t, set.Parse([]string{"test-command", "--" + cmd.ConfigFileFlag.Name, "flags_test.yaml"}))
+	comFlags := cmd.WrapFlags([]cli.Flag{
+		&cli.StringFlag{
+			Name: cmd.ConfigFileFlag.Name,
+		},
+		&cli.StringSliceFlag{
+			Name: cmd.BootstrapNode.Name,
+		},
+	})
 	command := &cli.Command{
-		Name: "test-command",
-		Flags: cmd.WrapFlags([]cli.Flag{
-			&cli.StringFlag{
-				Name: cmd.ConfigFileFlag.Name,
-			},
-			&cli.StringSliceFlag{
-				Name: cmd.BootstrapNode.Name,
-			},
-		}),
+		Name:  "test-command",
+		Flags: comFlags,
 		Before: func(cliCtx *cli.Context) error {
-			return cmd.LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags)
+			return cmd.LoadFlagsFromConfig(cliCtx, comFlags)
 		},
 		Action: func(cliCtx *cli.Context) error {
 			//TODO: https://github.com/urfave/cli/issues/1197 right now does not set flag
@@ -165,7 +166,7 @@ func TestConfigureNetwork_ConfigFile(t *testing.T) {
 			return nil
 		},
 	}
-	require.NoError(t, command.Run(context))
+	require.NoError(t, command.Run(context, context.Args().Slice()...))
 	require.NoError(t, os.Remove("flags_test.yaml"))
 }
 

beacon-chain/operations/blstoexec/BUILD.bazel

@@ -17,6 +17,8 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//container/doubly-linked-list:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/operations/blstoexec/pool.go

@@ -4,6 +4,8 @@ import (
 	"math"
 	"sync"
 
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
@@ -18,6 +20,13 @@ import (
 // we only do it when the map is smaller than this upper bound.
 const blsChangesPoolThreshold = 2000
 
+var (
+	blsToExecMessageInPoolTotal = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "bls_to_exec_message_pool_total",
+		Help: "The number of saved bls to exec message in the operation cool.",
+	})
+)
+
 // PoolManager maintains pending and seen BLS-to-execution-change objects.
 // This pool is used by proposers to insert BLS-to-execution-change objects into new blocks.
 type PoolManager interface {
@@ -116,6 +125,9 @@ func (p *Pool) InsertBLSToExecChange(change *ethpb.SignedBLSToExecutionChange) {
 
 	p.pending.Append(doublylinkedlist.NewNode(change))
 	p.m[change.Message.ValidatorIndex] = p.pending.Last()
+
+	blsToExecMessageInPoolTotal.Inc()
+
 }
 
 // MarkIncluded is used when an object has been included in a beacon block. Every block seen by this
@@ -134,6 +146,8 @@ func (p *Pool) MarkIncluded(change *ethpb.SignedBLSToExecutionChange) {
 	if p.numPending() == blsChangesPoolThreshold {
 		p.cycleMap()
 	}
+
+	blsToExecMessageInPoolTotal.Dec()
 }
 
 // ValidatorExists checks if the bls to execution change object exists

beacon-chain/p2p/BUILD.bazel

@@ -86,7 +86,6 @@ go_library(
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/muxer/mplex:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/protocol/identify:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/security/noise:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/transport/tcp:go_default_library",
         "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",

beacon-chain/p2p/peers/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
     deps = [
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/rand:go_default_library",
@@ -45,7 +44,6 @@ go_test(
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",

beacon-chain/p2p/peers/peers_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v3/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/sirupsen/logrus"
 )
 
@@ -13,11 +12,6 @@ func TestMain(m *testing.M) {
 	logrus.SetLevel(logrus.DebugLevel)
 	logrus.SetOutput(io.Discard)
 
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnablePeerScorer: true,
-	})
-	defer resetCfg()
-
 	resetFlags := flags.Get()
 	flags.Init(&flags.GlobalFlags{
 		BlockBatchLimit:            64,

beacon-chain/p2p/peers/scorers/BUILD.bazel

@@ -15,7 +15,6 @@ go_library(
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/types:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/rand:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -40,7 +39,6 @@ go_test(
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/types:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/rand:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/p2p/peers/scorers/block_providers.go

@@ -9,7 +9,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/peerdata"
 	"github.com/prysmaticlabs/prysm/v3/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/crypto/rand"
 	prysmTime "github.com/prysmaticlabs/prysm/v3/time"
 )
@@ -291,9 +290,6 @@ func (s *BlockProviderScorer) mapScoresAndPeers(
 func (s *BlockProviderScorer) FormatScorePretty(pid peer.ID) string {
 	s.store.RLock()
 	defer s.store.RUnlock()
-	if !features.Get().EnablePeerScorer {
-		return "disabled"
-	}
 	score := s.score(pid)
 	return fmt.Sprintf("[%0.1f%%, raw: %0.2f,  blocks: %d/%d]",
 		(score/s.MaxScore())*100, score, s.processedBlocks(pid), s.config.ProcessedBlocksCap)

beacon-chain/p2p/peers/scorers/block_providers_test.go

@@ -11,7 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/scorers"
 	"github.com/prysmaticlabs/prysm/v3/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/crypto/rand"
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/time"
@@ -460,16 +459,6 @@ func TestScorers_BlockProvider_FormatScorePretty(t *testing.T) {
 			tt.check(scorer)
 		})
 	}
-
-	t.Run("peer scorer disabled", func(t *testing.T) {
-		resetCfg := features.InitWithReset(&features.Flags{
-			EnablePeerScorer: false,
-		})
-		defer resetCfg()
-		peerStatuses := peerStatusGen()
-		scorer := peerStatuses.Scorers().BlockProviderScorer()
-		assert.Equal(t, "disabled", scorer.FormatScorePretty("peer1"))
-	})
 }
 
 func TestScorers_BlockProvider_BadPeerMarking(t *testing.T) {

beacon-chain/p2p/peers/scorers/scorers_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/scorers"
 	"github.com/prysmaticlabs/prysm/v3/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/sirupsen/logrus"
 )
 
@@ -15,11 +14,6 @@ func TestMain(m *testing.M) {
 	logrus.SetLevel(logrus.DebugLevel)
 	logrus.SetOutput(io.Discard)
 
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnablePeerScorer: true,
-	})
-	defer resetCfg()
-
 	resetFlags := flags.Get()
 	flags.Init(&flags.GlobalFlags{
 		BlockBatchLimit:            64,

beacon-chain/p2p/peers/scorers/service.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/peerdata"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 )
 
 var _ Scorer = (*Service)(nil)
@@ -138,10 +137,8 @@ func (s *Service) IsBadPeerNoLock(pid peer.ID) bool {
 	if s.scorers.peerStatusScorer.isBadPeer(pid) {
 		return true
 	}
-	if features.Get().EnablePeerScorer {
-		if s.scorers.gossipScorer.isBadPeer(pid) {
-			return true
-		}
+	if s.scorers.gossipScorer.isBadPeer(pid) {
+		return true
 	}
 	return false
 }

beacon-chain/p2p/peers/status.go

@@ -36,7 +36,6 @@ import (
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/peerdata"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/scorers"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/crypto/rand"
@@ -544,11 +543,6 @@ func (p *Status) Prune() {
 	p.store.Lock()
 	defer p.store.Unlock()
 
-	// Default to old method if flag isnt enabled.
-	if !features.Get().EnablePeerScorer {
-		p.deprecatedPrune()
-		return
-	}
 	// Exit early if there is nothing to prune.
 	if len(p.store.Peers()) <= p.store.Config().MaxPeers {
 		return
@@ -593,52 +587,6 @@ func (p *Status) Prune() {
 	p.tallyIPTracker()
 }
 
-// Deprecated: This is the old peer pruning method based on
-// bad response counts.
-func (p *Status) deprecatedPrune() {
-	// Exit early if there is nothing to prune.
-	if len(p.store.Peers()) <= p.store.Config().MaxPeers {
-		return
-	}
-
-	notBadPeer := func(peerData *peerdata.PeerData) bool {
-		return peerData.BadResponses < p.scorers.BadResponsesScorer().Params().Threshold
-	}
-	type peerResp struct {
-		pid     peer.ID
-		badResp int
-	}
-	peersToPrune := make([]*peerResp, 0)
-	// Select disconnected peers with a smaller bad response count.
-	for pid, peerData := range p.store.Peers() {
-		if peerData.ConnState == PeerDisconnected && notBadPeer(peerData) {
-			peersToPrune = append(peersToPrune, &peerResp{
-				pid:     pid,
-				badResp: peerData.BadResponses,
-			})
-		}
-	}
-
-	// Sort peers in ascending order, so the peers with the
-	// least amount of bad responses are pruned first. This
-	// is to protect the node from malicious/lousy peers so
-	// that their memory is still kept.
-	sort.Slice(peersToPrune, func(i, j int) bool {
-		return peersToPrune[i].badResp < peersToPrune[j].badResp
-	})
-
-	limitDiff := len(p.store.Peers()) - p.store.Config().MaxPeers
-	if limitDiff > len(peersToPrune) {
-		limitDiff = len(peersToPrune)
-	}
-	peersToPrune = peersToPrune[:limitDiff]
-	// Delete peers from map.
-	for _, peerData := range peersToPrune {
-		p.store.DeletePeerData(peerData.pid)
-	}
-	p.tallyIPTracker()
-}
-
 // BestFinalized returns the highest finalized epoch equal to or higher than ours that is agreed
 // upon by the majority of peers. This method may not return the absolute highest finalized, but
 // the finalized epoch in which most peers can serve blocks (plurality voting).
@@ -746,9 +694,6 @@ func (p *Status) BestNonFinalized(minPeers int, ourHeadEpoch primitives.Epoch) (
 // bad response count. In the future scoring will be used
 // to determine the most suitable peers to take out.
 func (p *Status) PeersToPrune() []peer.ID {
-	if !features.Get().EnablePeerScorer {
-		return p.deprecatedPeersToPrune()
-	}
 	connLimit := p.ConnectedPeerLimit()
 	inBoundLimit := uint64(p.InboundLimit())
 	activePeers := p.Active()
@@ -812,71 +757,6 @@ func (p *Status) PeersToPrune() []peer.ID {
 	return ids
 }
 
-// Deprecated: Is used to represent the older method
-// of pruning which utilized bad response counts.
-func (p *Status) deprecatedPeersToPrune() []peer.ID {
-	connLimit := p.ConnectedPeerLimit()
-	inBoundLimit := p.InboundLimit()
-	activePeers := p.Active()
-	numInboundPeers := len(p.InboundConnected())
-	// Exit early if we are still below our max
-	// limit.
-	if uint64(len(activePeers)) <= connLimit {
-		return []peer.ID{}
-	}
-	p.store.Lock()
-	defer p.store.Unlock()
-
-	type peerResp struct {
-		pid     peer.ID
-		badResp int
-	}
-	peersToPrune := make([]*peerResp, 0)
-	// Select connected and inbound peers to prune.
-	for pid, peerData := range p.store.Peers() {
-		if peerData.ConnState == PeerConnected &&
-			peerData.Direction == network.DirInbound {
-			peersToPrune = append(peersToPrune, &peerResp{
-				pid:     pid,
-				badResp: peerData.BadResponses,
-			})
-		}
-	}
-
-	// Sort in descending order to favour pruning peers with a
-	// higher bad response count.
-	sort.Slice(peersToPrune, func(i, j int) bool {
-		return peersToPrune[i].badResp > peersToPrune[j].badResp
-	})
-
-	// Determine amount of peers to prune using our
-	// max connection limit.
-	amountToPrune, err := pmath.Sub64(uint64(len(activePeers)), connLimit)
-	if err != nil {
-		// This should never happen
-		log.WithError(err).Error("Failed to determine amount of peers to prune")
-		return []peer.ID{}
-	}
-	// Also check for inbound peers above our limit.
-	excessInbound := uint64(0)
-	if numInboundPeers > inBoundLimit {
-		excessInbound = uint64(numInboundPeers - inBoundLimit)
-	}
-	// Prune the largest amount between excess peers and
-	// excess inbound peers.
-	if excessInbound > amountToPrune {
-		amountToPrune = excessInbound
-	}
-	if amountToPrune < uint64(len(peersToPrune)) {
-		peersToPrune = peersToPrune[:amountToPrune]
-	}
-	ids := make([]peer.ID, 0, len(peersToPrune))
-	for _, pr := range peersToPrune {
-		ids = append(ids, pr.pid)
-	}
-	return ids
-}
-
 // HighestEpoch returns the highest epoch reported epoch amongst peers.
 func (p *Status) HighestEpoch() primitives.Epoch {
 	p.store.RLock()

beacon-chain/p2p/peers/status_test.go

@@ -15,7 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/peerdata"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/peers/scorers"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/wrapper"
@@ -549,10 +548,6 @@ func TestPrune(t *testing.T) {
 }
 
 func TestPeerIPTracker(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnablePeerScorer: false,
-	})
-	defer resetCfg()
 	maxBadResponses := 2
 	p := peers.NewStatus(context.Background(), &peers.StatusConfig{
 		PeerLimit: 30,
@@ -587,7 +582,7 @@ func TestPeerIPTracker(t *testing.T) {
 	p.Prune()
 
 	for _, pr := range badPeers {
-		assert.Equal(t, false, p.IsBad(pr), "peer with good ip is regarded as bad")
+		assert.Equal(t, true, p.IsBad(pr), "peer with good ip is regarded as bad")
 	}
 }
 
@@ -691,10 +686,6 @@ func TestAtInboundPeerLimit(t *testing.T) {
 }
 
 func TestPrunePeers(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnablePeerScorer: false,
-	})
-	defer resetCfg()
 	p := peers.NewStatus(context.Background(), &peers.StatusConfig{
 		PeerLimit: 30,
 		ScorerParams: &scorers.Config{
@@ -745,13 +736,11 @@ func TestPrunePeers(t *testing.T) {
 	}
 
 	// Ensure it is in the descending order.
-	currCount, err := p.Scorers().BadResponsesScorer().Count(peersToPrune[0])
-	require.NoError(t, err)
+	currScore := p.Scorers().Score(peersToPrune[0])
 	for _, pid := range peersToPrune {
-		count, err := p.Scorers().BadResponsesScorer().Count(pid)
-		require.NoError(t, err)
-		assert.Equal(t, true, currCount >= count)
-		currCount = count
+		score := p.Scorers().BadResponsesScorer().Score(pid)
+		assert.Equal(t, true, currScore >= score)
+		currScore = score
 	}
 }
 

beacon-chain/p2p/service.go

@@ -17,7 +17,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/protocol"
-	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
 	"github.com/multiformats/go-multiaddr"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/async"
@@ -133,7 +132,6 @@ func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	}
 
 	s.host = h
-	s.host.RemoveStreamHandler(identify.IDDelta)
 	// Gossipsub registration is done before we add in any new peers
 	// due to libp2p's gossipsub implementation not taking into
 	// account previously added peers when creating the gossipsub

beacon-chain/p2p/testing/mock_host.go

@@ -51,7 +51,8 @@ func (_ *MockHost) Connect(_ context.Context, _ peer.AddrInfo) error {
 func (_ *MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {}
 
 // SetStreamHandlerMatch --
-func (_ *MockHost) SetStreamHandlerMatch(protocol.ID, func(string) bool, network.StreamHandler) {}
+func (_ *MockHost) SetStreamHandlerMatch(protocol.ID, func(id protocol.ID) bool, network.StreamHandler) {
+}
 
 // RemoveStreamHandler --
 func (_ *MockHost) RemoveStreamHandler(_ protocol.ID) {}

beacon-chain/package/BUILD.bazel

@@ -46,6 +46,7 @@ pkg_deb(
     package = "prysm-beacon-chain",
     postinst = "postinst.sh",
     preinst = "preinst.sh",
+    tags = ["no-remote"],
     version_file = "//runtime:version_file",
     visibility = ["//beacon-chain:__pkg__"],
 )

beacon-chain/rpc/apimiddleware/BUILD.bazel

@@ -19,6 +19,7 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//proto/eth/v2:go_default_library",
+        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_r3labs_sse//:go_default_library",

beacon-chain/rpc/apimiddleware/custom_handlers.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/http"
@@ -14,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/api/gateway/apimiddleware"
 	"github.com/prysmaticlabs/prysm/v3/api/grpc"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/eth/events"
+	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 	"github.com/r3labs/sse"
 )
 
@@ -364,6 +366,10 @@ func handleEvents(m *apimiddleware.ApiProxyMiddleware, _ apimiddleware.Endpoint,
 	return true
 }
 
+type dataSubset struct {
+	Version string `json:"version"`
+}
+
 func receiveEvents(eventChan <-chan *sse.Event, w http.ResponseWriter, req *http.Request) apimiddleware.ErrorJson {
 	for {
 		select {
@@ -418,6 +424,19 @@ func receiveEvents(eventChan <-chan *sse.Event, w http.ResponseWriter, req *http
 				data = &SignedContributionAndProofJson{}
 			case events.BLSToExecutionChangeTopic:
 				data = &SignedBLSToExecutionChangeJson{}
+			case events.PayloadAttributesTopic:
+				dataSubset := &dataSubset{}
+				if err := json.Unmarshal(msg.Data, dataSubset); err != nil {
+					return apimiddleware.InternalServerError(err)
+				}
+				switch dataSubset.Version {
+				case version.String(version.Capella):
+					data = &EventPayloadAttributeStreamV2Json{}
+				case version.String(version.Bellatrix):
+					data = &EventPayloadAttributeStreamV1Json{}
+				default:
+					return apimiddleware.InternalServerError(errors.New("payload version unsupported"))
+				}
 			case "error":
 				data = &EventErrorJson{}
 			default:

beacon-chain/rpc/apimiddleware/structs.go

@@ -1160,6 +1160,47 @@ type EventChainReorgJson struct {
 	ExecutionOptimistic bool   `json:"execution_optimistic"`
 }
 
+type EventPayloadAttributeStreamV1Json struct {
+	Version string `json:"version"`
+	Data    *EventPayloadAttributeV1Json
+}
+
+type EventPayloadAttributeStreamV2Json struct {
+	Version string `json:"version"`
+	Data    *EventPayloadAttributeV2Json
+}
+
+type EventPayloadAttributeV1Json struct {
+	ProposerIndex     string                   `json:"proposer_index"`
+	ProposalSlot      string                   `json:"proposal_slot"`
+	ParentBlockNumber string                   `json:"parent_block_number"`
+	ParentBlockRoot   string                   `json:"parent_block_root" hex:"true"`
+	ParentBlockHash   string                   `json:"parent_block_hash" hex:"true"`
+	PayloadAttributes *PayloadAttributesV1Json `json:"payload_attributes"`
+}
+
+type EventPayloadAttributeV2Json struct {
+	ProposerIndex     string                   `json:"proposer_index"`
+	ProposalSlot      string                   `json:"proposal_slot"`
+	ParentBlockNumber string                   `json:"parent_block_number"`
+	ParentBlockRoot   string                   `json:"parent_block_root" hex:"true"`
+	ParentBlockHash   string                   `json:"parent_block_hash" hex:"true"`
+	PayloadAttributes *PayloadAttributesV2Json `json:"payload_attributes_v2"`
+}
+
+type PayloadAttributesV1Json struct {
+	Timestamp             string `json:"timestamp"`
+	Random                string `json:"prev_randao" hex:"true"`
+	SuggestedFeeRecipient string `json:"suggested_fee_recipient" hex:"true"`
+}
+
+type PayloadAttributesV2Json struct {
+	Timestamp             string            `json:"timestamp"`
+	Random                string            `json:"prev_randao" hex:"true"`
+	SuggestedFeeRecipient string            `json:"suggested_fee_recipient" hex:"true"`
+	Withdrawals           []*WithdrawalJson `json:"withdrawals"`
+}
+
 // ---------------
 // Error handling.
 // ---------------

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

@@ -9,15 +9,22 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/eth/events",
     visibility = ["//beacon-chain:__subpackages__"],
     deps = [
+        "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/eth/service:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/migration:go_default_library",
+        "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//proto/gateway:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_google_grpc//codes:go_default_library",
         "@org_golang_google_grpc//status:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
@@ -32,18 +39,25 @@ go_test(
     deps = [
         "//async/event:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/block:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/mock:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_golang_mock//gomock:go_default_library",
         "@com_github_grpc_ecosystem_grpc_gateway_v2//proto/gateway:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/rpc/eth/events/events.go

@@ -9,9 +9,15 @@ import (
 	blockfeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/block"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/time"
+	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpbservice "github.com/prysmaticlabs/prysm/v3/proto/eth/service"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/v3/proto/migration"
+	"github.com/prysmaticlabs/prysm/v3/runtime/version"
+	"github.com/prysmaticlabs/prysm/v3/time/slots"
+	log "github.com/sirupsen/logrus"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 	"google.golang.org/protobuf/proto"
@@ -35,6 +41,8 @@ const (
 	SyncCommitteeContributionTopic = "contribution_and_proof"
 	// BLSToExecutionChangeTopic represents a new received BLS to execution change event topic.
 	BLSToExecutionChangeTopic = "bls_to_execution_change"
+	// PayloadAttributesTopic represents a new payload attributes for execution payload building event topic.
+	PayloadAttributesTopic = "payload_attributes"
 )
 
 var casesHandled = map[string]bool{
@@ -46,6 +54,7 @@ var casesHandled = map[string]bool{
 	ChainReorgTopic:                true,
 	SyncCommitteeContributionTopic: true,
 	BLSToExecutionChangeTopic:      true,
+	PayloadAttributesTopic:         true,
 }
 
 // StreamEvents allows requesting all events from a set of topics defined in the Ethereum consensus API standard.
@@ -95,7 +104,7 @@ func (s *Server) StreamEvents(
 				return status.Errorf(codes.Internal, "Could not handle block operations event: %v", err)
 			}
 		case event := <-stateChan:
-			if err := handleStateEvents(stream, requestedTopics, event); err != nil {
+			if err := s.handleStateEvents(stream, requestedTopics, event); err != nil {
 				return status.Errorf(codes.Internal, "Could not handle state event: %v", err)
 			}
 		case <-s.Ctx.Done():
@@ -191,24 +200,31 @@ func handleBlockOperationEvents(
 		}
 		v2Change := migration.V1Alpha1SignedBLSToExecChangeToV2(changeData.Change)
 		return streamData(stream, BLSToExecutionChangeTopic, v2Change)
+
 	default:
 		return nil
 	}
 }
 
-func handleStateEvents(
+func (s *Server) handleStateEvents(
 	stream ethpbservice.Events_StreamEventsServer, requestedTopics map[string]bool, event *feed.Event,
 ) error {
 	switch event.Type {
 	case statefeed.NewHead:
-		if _, ok := requestedTopics[HeadTopic]; !ok {
+		if _, ok := requestedTopics[HeadTopic]; ok {
+			head, ok := event.Data.(*ethpb.EventHead)
+			if !ok {
+				return nil
+			}
+			return streamData(stream, HeadTopic, head)
+		}
+		if _, ok := requestedTopics[PayloadAttributesTopic]; ok {
+			if err := s.streamPayloadAttributes(stream); err != nil {
+				log.WithError(err).Error("Unable to obtain stream payload attributes")
+			}
 			return nil
 		}
-		head, ok := event.Data.(*ethpb.EventHead)
-		if !ok {
-			return nil
-		}
-		return streamData(stream, HeadTopic, head)
+		return nil
 	case statefeed.FinalizedCheckpoint:
 		if _, ok := requestedTopics[FinalizedCheckpointTopic]; !ok {
 			return nil
@@ -232,6 +248,82 @@ func handleStateEvents(
 	}
 }
 
+// streamPayloadAttributes on new head event.
+// This event stream is intended to be used by builders and relays.
+func (s *Server) streamPayloadAttributes(stream ethpbservice.Events_StreamEventsServer) error {
+	headState, err := s.HeadFetcher.HeadStateReadOnly(s.Ctx)
+	if err != nil {
+		return err
+	}
+
+	headBlock, err := s.HeadFetcher.HeadBlock(s.Ctx)
+	if err != nil {
+		return err
+	}
+
+	headRoot, err := s.HeadFetcher.HeadRoot(s.Ctx)
+	if err != nil {
+		return err
+	}
+
+	headPayload, err := headBlock.Block().Body().Execution()
+	if err != nil {
+		return err
+	}
+
+	t, err := slots.ToTime(uint64(headState.GenesisTime()), headState.Slot())
+	if err != nil {
+		return err
+	}
+
+	prevRando, err := helpers.RandaoMix(headState, time.CurrentEpoch(headState))
+	if err != nil {
+		return err
+	}
+
+	switch headState.Version() {
+	case version.Bellatrix:
+		return streamData(stream, PayloadAttributesTopic, &ethpb.EventPayloadAttributeV1{
+			Version: version.String(headState.Version()),
+			Data: &ethpb.EventPayloadAttributeV1_BasePayloadAttribute{
+				ProposerIndex:     headBlock.Block().ProposerIndex(),
+				ProposalSlot:      headState.Slot(),
+				ParentBlockNumber: headPayload.BlockNumber(),
+				ParentBlockRoot:   headRoot,
+				ParentBlockHash:   headPayload.BlockHash(),
+				PayloadAttributes: &enginev1.PayloadAttributes{
+					Timestamp:             uint64(t.Unix()),
+					PrevRandao:            prevRando,
+					SuggestedFeeRecipient: headPayload.FeeRecipient(),
+				},
+			},
+		})
+	case version.Capella:
+		withdrawals, err := headState.ExpectedWithdrawals()
+		if err != nil {
+			return err
+		}
+		return streamData(stream, PayloadAttributesTopic, &ethpb.EventPayloadAttributeV2{
+			Version: version.String(headState.Version()),
+			Data: &ethpb.EventPayloadAttributeV2_BasePayloadAttribute{
+				ProposerIndex:     headBlock.Block().ProposerIndex(),
+				ProposalSlot:      headState.Slot(),
+				ParentBlockNumber: headPayload.BlockNumber(),
+				ParentBlockRoot:   headRoot,
+				ParentBlockHash:   headPayload.BlockHash(),
+				PayloadAttributesV2: &enginev1.PayloadAttributesV2{
+					Timestamp:             uint64(t.Unix()),
+					PrevRandao:            prevRando,
+					SuggestedFeeRecipient: headPayload.FeeRecipient(),
+					Withdrawals:           withdrawals,
+				},
+			},
+		})
+	default:
+		return errors.New("payload version is not supported")
+	}
+}
+
 func streamData(stream ethpbservice.Events_StreamEventsServer, name string, data proto.Message) error {
 	returnData, err := anypb.New(data)
 	if err != nil {

beacon-chain/rpc/eth/events/events_test.go

@@ -3,20 +3,28 @@ package events
 import (
 	"context"
 	"testing"
+	"time"
 
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/golang/mock/gomock"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/proto/gateway"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v3/async/event"
 	mockChain "github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain/testing"
+	b "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/block"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
+	prysmtime "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/time"
+	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
+	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/v3/proto/migration"
 	eth "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/testing/mock"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
@@ -312,6 +320,203 @@ func TestStreamEvents_StateEvents(t *testing.T) {
 			feed: srv.StateNotifier.StateFeed(),
 		})
 	})
+	t.Run(PayloadAttributesTopic+"_bellatrix", func(t *testing.T) {
+		ctx := context.Background()
+
+		beaconState, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+		err := beaconState.SetSlot(2)
+		require.NoError(t, err, "Count not set slot")
+		stateRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err, "Could not hash genesis state")
+
+		genesis := b.NewGenesisBlock(stateRoot[:])
+
+		parentRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err, "Could not get signing root")
+
+		var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+		blk := &eth.SignedBeaconBlockBellatrix{
+			Block: &eth.BeaconBlockBellatrix{
+				ProposerIndex: 1,
+				Slot:          1,
+				ParentRoot:    parentRoot[:],
+				StateRoot:     genesis.Block.StateRoot,
+				Body: &eth.BeaconBlockBodyBellatrix{
+					RandaoReveal:  genesis.Block.Body.RandaoReveal,
+					Graffiti:      genesis.Block.Body.Graffiti,
+					Eth1Data:      genesis.Block.Body.Eth1Data,
+					SyncAggregate: &eth.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+					ExecutionPayload: &enginev1.ExecutionPayload{
+						BlockNumber:   1,
+						ParentHash:    make([]byte, fieldparams.RootLength),
+						FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+						StateRoot:     make([]byte, fieldparams.RootLength),
+						ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+						LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+						PrevRandao:    make([]byte, fieldparams.RootLength),
+						BaseFeePerGas: make([]byte, fieldparams.RootLength),
+						BlockHash:     make([]byte, fieldparams.RootLength),
+					},
+				},
+			},
+			Signature: genesis.Signature,
+		}
+		signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+		require.NoError(t, err)
+		srv, ctrl, mockStream := setupServer(ctx, t)
+		defer ctrl.Finish()
+		srv.HeadFetcher = &mockChain.ChainService{
+			Genesis:        time.Now(),
+			State:          beaconState,
+			Block:          signedBlk,
+			Root:           make([]byte, 32),
+			ValidatorsRoot: [32]byte{},
+		}
+
+		prevRando, err := helpers.RandaoMix(beaconState, prysmtime.CurrentEpoch(beaconState))
+		require.NoError(t, err)
+
+		wantedPayload := &ethpb.EventPayloadAttributeV1{
+			Version: version.String(version.Bellatrix),
+			Data: &ethpb.EventPayloadAttributeV1_BasePayloadAttribute{
+				ProposerIndex:     1,
+				ProposalSlot:      2,
+				ParentBlockNumber: 1,
+				ParentBlockRoot:   make([]byte, 32),
+				ParentBlockHash:   make([]byte, 32),
+				PayloadAttributes: &enginev1.PayloadAttributes{
+					Timestamp:             24,
+					PrevRandao:            prevRando,
+					SuggestedFeeRecipient: make([]byte, 20),
+				},
+			},
+		}
+		genericResponse, err := anypb.New(wantedPayload)
+		require.NoError(t, err)
+		wantedMessage := &gateway.EventSource{
+			Event: PayloadAttributesTopic,
+			Data:  genericResponse,
+		}
+
+		assertFeedSendAndReceive(ctx, &assertFeedArgs{
+			t:             t,
+			srv:           srv,
+			topics:        []string{PayloadAttributesTopic},
+			stream:        mockStream,
+			shouldReceive: wantedMessage,
+			itemToSend: &feed.Event{
+				Type: statefeed.NewHead,
+				Data: wantedPayload,
+			},
+			feed: srv.StateNotifier.StateFeed(),
+		})
+	})
+	t.Run(PayloadAttributesTopic+"_capella", func(t *testing.T) {
+		ctx := context.Background()
+		beaconState, _ := util.DeterministicGenesisStateCapella(t, 1)
+		validator, err := beaconState.ValidatorAtIndex(0)
+		require.NoError(t, err, "Could not get validator")
+		by, err := hexutil.Decode("0x010000000000000000000000a94f5374fce5edbc8e2a8697c15331677e6ebf0b")
+		require.NoError(t, err)
+		validator.WithdrawalCredentials = by
+		err = beaconState.UpdateValidatorAtIndex(0, validator)
+		require.NoError(t, err)
+		err = beaconState.SetSlot(2)
+		require.NoError(t, err, "Count not set slot")
+		err = beaconState.SetNextWithdrawalValidatorIndex(0)
+		require.NoError(t, err, "Could not set withdrawal index")
+		err = beaconState.SetBalances([]uint64{33000000000})
+		require.NoError(t, err, "Could not set validator balance")
+		stateRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err, "Could not hash genesis state")
+
+		genesis := b.NewGenesisBlock(stateRoot[:])
+
+		parentRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err, "Could not get signing root")
+
+		withdrawals, err := beaconState.ExpectedWithdrawals()
+		require.NoError(t, err, "Could get expected withdrawals")
+		require.NotEqual(t, len(withdrawals), 0)
+		var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+		blk := &eth.SignedBeaconBlockCapella{
+			Block: &eth.BeaconBlockCapella{
+				ProposerIndex: 1,
+				Slot:          1,
+				ParentRoot:    parentRoot[:],
+				StateRoot:     genesis.Block.StateRoot,
+				Body: &eth.BeaconBlockBodyCapella{
+					RandaoReveal:  genesis.Block.Body.RandaoReveal,
+					Graffiti:      genesis.Block.Body.Graffiti,
+					Eth1Data:      genesis.Block.Body.Eth1Data,
+					SyncAggregate: &eth.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+					ExecutionPayload: &enginev1.ExecutionPayloadCapella{
+						BlockNumber:   1,
+						ParentHash:    make([]byte, fieldparams.RootLength),
+						FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+						StateRoot:     make([]byte, fieldparams.RootLength),
+						ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+						LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+						PrevRandao:    make([]byte, fieldparams.RootLength),
+						BaseFeePerGas: make([]byte, fieldparams.RootLength),
+						BlockHash:     make([]byte, fieldparams.RootLength),
+						Withdrawals:   withdrawals,
+					},
+				},
+			},
+			Signature: genesis.Signature,
+		}
+		signedBlk, err := blocks.NewSignedBeaconBlock(blk)
+		require.NoError(t, err)
+		srv, ctrl, mockStream := setupServer(ctx, t)
+		defer ctrl.Finish()
+		srv.HeadFetcher = &mockChain.ChainService{
+			Genesis:        time.Now(),
+			State:          beaconState,
+			Block:          signedBlk,
+			Root:           make([]byte, 32),
+			ValidatorsRoot: [32]byte{},
+		}
+
+		prevRando, err := helpers.RandaoMix(beaconState, prysmtime.CurrentEpoch(beaconState))
+		require.NoError(t, err)
+
+		wantedPayload := &ethpb.EventPayloadAttributeV2{
+			Version: version.String(version.Capella),
+			Data: &ethpb.EventPayloadAttributeV2_BasePayloadAttribute{
+				ProposerIndex:     1,
+				ProposalSlot:      2,
+				ParentBlockNumber: 1,
+				ParentBlockRoot:   make([]byte, 32),
+				ParentBlockHash:   make([]byte, 32),
+				PayloadAttributesV2: &enginev1.PayloadAttributesV2{
+					Timestamp:             24,
+					PrevRandao:            prevRando,
+					SuggestedFeeRecipient: make([]byte, 20),
+					Withdrawals:           withdrawals,
+				},
+			},
+		}
+		genericResponse, err := anypb.New(wantedPayload)
+		require.NoError(t, err)
+		wantedMessage := &gateway.EventSource{
+			Event: PayloadAttributesTopic,
+			Data:  genericResponse,
+		}
+
+		assertFeedSendAndReceive(ctx, &assertFeedArgs{
+			t:             t,
+			srv:           srv,
+			topics:        []string{PayloadAttributesTopic},
+			stream:        mockStream,
+			shouldReceive: wantedMessage,
+			itemToSend: &feed.Event{
+				Type: statefeed.NewHead,
+				Data: wantedPayload,
+			},
+			feed: srv.StateNotifier.StateFeed(),
+		})
+	})
 	t.Run(FinalizedCheckpointTopic, func(t *testing.T) {
 		ctx := context.Background()
 		srv, ctrl, mockStream := setupServer(ctx, t)

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

@@ -6,6 +6,7 @@ package events
 import (
 	"context"
 
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain"
 	blockfeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/block"
 	opfeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/state"
@@ -18,4 +19,5 @@ type Server struct {
 	StateNotifier     statefeed.Notifier
 	BlockNotifier     blockfeed.Notifier
 	OperationNotifier opfeed.Notifier
+	HeadFetcher       blockchain.HeadFetcher
 }

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

@@ -691,13 +691,14 @@ func TestProduceBlockV2(t *testing.T) {
 
 		beaconState, parentRoot, privKeys := util.DeterministicGenesisStateWithGenesisBlock(t, ctx, db, 64)
 
-		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
+		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			HeadFetcher:           mockChainService,
 			SyncChecker:           &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:         mockChainService,
 			HeadUpdater:           mockChainService,
+			ForkFetcher:           mockChainService,
 			ChainStartFetcher:     mockExecutionChain,
 			Eth1InfoFetcher:       mockExecutionChain,
 			Eth1BlockFetcher:      mockExecutionChain,
@@ -705,10 +706,11 @@ func TestProduceBlockV2(t *testing.T) {
 			AttPool:               attestations.NewPool(),
 			SlashingsPool:         slashings.NewPool(),
 			ExitPool:              voluntaryexits.NewPool(),
-			StateGen:              stategen.New(db, doublylinkedtree.New()),
+			StateGen:              stategen.New(db, mockChainService.ForkChoiceStore),
 			TimeFetcher:           mockChainService,
 			OptimisticModeFetcher: mockChainService,
 		}
+		require.NoError(t, db.SaveGenesisData(ctx, beaconState))
 
 		proposerSlashings := make([]*ethpbalpha.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
 		for i := primitives.ValidatorIndex(0); uint64(i) < params.BeaconConfig().MaxProposerSlashings; i++ {
@@ -801,13 +803,14 @@ func TestProduceBlockV2(t *testing.T) {
 		require.NoError(t, db.SaveState(ctx, beaconState, parentRoot), "Could not save genesis state")
 		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
-		mochChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
+		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:           mochChainService,
+			HeadFetcher:           mockChainService,
 			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:         mochChainService,
-			HeadUpdater:           mochChainService,
+			BlockReceiver:         mockChainService,
+			HeadUpdater:           mockChainService,
+			ForkFetcher:           mockChainService,
 			ChainStartFetcher:     mockExecutionChain,
 			Eth1InfoFetcher:       mockExecutionChain,
 			Eth1BlockFetcher:      mockExecutionChain,
@@ -817,8 +820,8 @@ func TestProduceBlockV2(t *testing.T) {
 			ExitPool:              voluntaryexits.NewPool(),
 			StateGen:              stategen.New(db, doublylinkedtree.New()),
 			SyncCommitteePool:     synccommittee.NewStore(),
-			TimeFetcher:           mochChainService,
-			OptimisticModeFetcher: mochChainService,
+			TimeFetcher:           mockChainService,
+			OptimisticModeFetcher: mockChainService,
 		}
 
 		proposerSlashings := make([]*ethpbalpha.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
@@ -993,7 +996,7 @@ func TestProduceBlockV2(t *testing.T) {
 
 		var payloadIdBytes enginev1.PayloadIDBytes
 		copy(payloadIdBytes[:], "payload_id")
-		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
+		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			ExecutionEngineCaller: &mockExecution.EngineClient{
@@ -1007,6 +1010,7 @@ func TestProduceBlockV2(t *testing.T) {
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
 			HeadUpdater:            mockChainService,
+			ForkFetcher:            mockChainService,
 			ChainStartFetcher:      mockExecutionChain,
 			Eth1InfoFetcher:        mockExecutionChain,
 			Eth1BlockFetcher:       mockExecutionChain,
@@ -1235,7 +1239,7 @@ func TestProduceBlockV2(t *testing.T) {
 
 		var payloadIdBytes enginev1.PayloadIDBytes
 		copy(payloadIdBytes[:], "payload_id")
-		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
+		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			ExecutionEngineCaller: &mockExecution.EngineClient{
@@ -1249,6 +1253,7 @@ func TestProduceBlockV2(t *testing.T) {
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:          mockChainService,
 			HeadUpdater:            mockChainService,
+			ForkFetcher:            mockChainService,
 			ChainStartFetcher:      mockExecutionChain,
 			Eth1InfoFetcher:        mockExecutionChain,
 			Eth1BlockFetcher:       mockExecutionChain,
@@ -1380,11 +1385,13 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 
 		bs, parentRoot, privKeys := util.DeterministicGenesisStateWithGenesisBlock(t, ctx, db, 2)
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       &mockChain.ChainService{State: bs, Root: parentRoot[:]},
+			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
+			BlockReceiver:     mockChainService,
+			HeadUpdater:       mockChainService,
+			ForkFetcher:       mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -1541,11 +1548,13 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 		require.NoError(t, db.SaveState(ctx, bs, parentRoot), "Could not save genesis state")
 		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       &mockChain.ChainService{State: bs, Root: parentRoot[:]},
+			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
+			BlockReceiver:     mockChainService,
+			HeadUpdater:       mockChainService,
+			ForkFetcher:       mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -1738,6 +1747,7 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 		require.NoError(t, db.SaveState(ctx, bs, parentRoot), "Could not save genesis state")
 		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			ExecutionEngineCaller: &mockExecution.EngineClient{
 				ExecutionBlock: &enginev1.ExecutionBlock{
@@ -1745,11 +1755,12 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 				},
 			},
 			TimeFetcher:            &mockChain.ChainService{},
-			HeadFetcher:            &mockChain.ChainService{State: bs, Root: parentRoot[:]},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
+			HeadFetcher:            mockChainService,
+			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
+			BlockReceiver:          mockChainService,
+			HeadUpdater:            mockChainService,
+			ForkFetcher:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -1966,6 +1977,7 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 		prevRandao, err := helpers.RandaoMix(bs, 2)
 		require.NoError(t, err)
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			ExecutionEngineCaller: &mockExecution.EngineClient{
 				ExecutionBlock: &enginev1.ExecutionBlock{
@@ -1987,11 +1999,12 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 				},
 			},
 			TimeFetcher:            &mockChain.ChainService{},
-			HeadFetcher:            &mockChain.ChainService{State: bs, Root: parentRoot[:]},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
+			HeadFetcher:            mockChainService,
+			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
+			BlockReceiver:          mockChainService,
+			HeadUpdater:            mockChainService,
+			ForkFetcher:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -2216,11 +2229,13 @@ func TestProduceBlindedBlock(t *testing.T) {
 
 		beaconState, parentRoot, privKeys := util.DeterministicGenesisStateWithGenesisBlock(t, ctx, db, 64)
 
+		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
+			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
+			BlockReceiver:     mockChainService,
+			HeadUpdater:       mockChainService,
+			ForkFetcher:       mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -2320,11 +2335,13 @@ func TestProduceBlindedBlock(t *testing.T) {
 		require.NoError(t, db.SaveState(ctx, beaconState, parentRoot), "Could not save genesis state")
 		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
+		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       &mockChain.ChainService{State: beaconState, Root: parentRoot[:]},
+			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
+			BlockReceiver:     mockChainService,
+			HeadUpdater:       mockChainService,
+			ForkFetcher:       mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -2453,6 +2470,11 @@ func TestProduceBlindedBlock(t *testing.T) {
 		require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee))
 		require.NoError(t, beaconState.SetNextSyncCommittee(syncCommittee))
 
+		ts := time.Now()
+		ti := ts.Add(-time.Duration(uint64(params.BeaconConfig().SlotsPerEpoch+1)*params.BeaconConfig().SecondsPerSlot) * time.Second)
+		require.NoError(t, beaconState.SetGenesisTime(uint64(ti.Unix())))
+		random, err := helpers.RandaoMix(beaconState, coreTime.CurrentEpoch(beaconState))
+		require.NoError(t, err)
 		stateRoot, err := beaconState.HashTreeRoot(ctx)
 		require.NoError(t, err, "Could not hash genesis state")
 		genesisBlock := util.NewBeaconBlockBellatrix()
@@ -2461,9 +2483,6 @@ func TestProduceBlindedBlock(t *testing.T) {
 		parentRoot, err := genesisBlock.Block.HashTreeRoot()
 		require.NoError(t, err)
 
-		require.NoError(t, db.SaveState(ctx, beaconState, parentRoot), "Could not save genesis state")
-		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
-
 		fb := util.HydrateSignedBeaconBlockBellatrix(&ethpbalpha.SignedBeaconBlockBellatrix{})
 		fb.Block.Body.ExecutionPayload.GasLimit = 123
 		wfb, err := blocks.NewSignedBeaconBlock(fb)
@@ -2474,12 +2493,10 @@ func TestProduceBlindedBlock(t *testing.T) {
 
 		sk, err := bls.RandKey()
 		require.NoError(t, err)
-		ti := time.Unix(0, 0)
-		ts, err := slots.ToTime(uint64(ti.Unix()), params.BeaconConfig().SlotsPerEpoch+1)
-		require.NoError(t, err)
-		require.NoError(t, beaconState.SetGenesisTime(uint64(ti.Unix())))
-		random, err := helpers.RandaoMix(beaconState, coreTime.CurrentEpoch(beaconState))
-		require.NoError(t, err)
+
+		require.NoError(t, db.SaveState(ctx, beaconState, parentRoot), "Could not save genesis state")
+		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
+
 		bid := &ethpbalpha.BuilderBid{
 			Header: &enginev1.ExecutionPayloadHeader{
 				ParentHash:       make([]byte, fieldparams.RootLength),
@@ -2507,18 +2524,20 @@ func TestProduceBlindedBlock(t *testing.T) {
 			Signature: sk.Sign(sr[:]).Marshal(),
 		}
 
+		fcs := doublylinkedtree.New()
+		fcs.SetGenesisTime(uint64(ti.Unix()))
+		chainSlot := primitives.Slot(params.BeaconConfig().SlotsPerEpoch + 1)
+		mockChainService := &mockChain.ChainService{Slot: &chainSlot, Genesis: ti, State: beaconState, Root: parentRoot[:], ForkChoiceStore: fcs, Block: wfb}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			BeaconDB:    db,
-			ForkFetcher: &mockChain.ChainService{ForkChoiceStore: doublylinkedtree.New()},
-			TimeFetcher: &mockChain.ChainService{
-				Genesis: ti,
-			},
-			HeadFetcher:            &mockChain.ChainService{State: beaconState, Root: parentRoot[:], Block: wfb},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
+			BeaconDB:               db,
+			ForkFetcher:            mockChainService,
+			TimeFetcher:            mockChainService,
+			HeadFetcher:            mockChainService,
+			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
-			ChainStartFetcher:      &mockExecution.Chain{},
+			BlockReceiver:          mockChainService,
+			HeadUpdater:            mockChainService,
+			ChainStartFetcher:      &mockExecution.Chain{GenesisState: beaconState},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
 			MockEth1Votes:          true,
@@ -2623,7 +2642,7 @@ func TestProduceBlindedBlock(t *testing.T) {
 		containerBlock, ok := resp.Data.Block.(*ethpbv2.BlindedBeaconBlockContainer_BellatrixBlock)
 		require.Equal(t, true, ok)
 		blk := containerBlock.BellatrixBlock
-		assert.Equal(t, req.Slot, blk.Slot, "Expected block to have slot of 1")
+		assert.Equal(t, req.Slot, blk.Slot, "Expected block to have slot of 33")
 		assert.DeepEqual(t, parentRoot[:], blk.ParentRoot, "Expected block to have correct parent root")
 		assert.DeepEqual(t, randaoReveal, blk.Body.RandaoReveal, "Expected block to have correct randao reveal")
 		assert.DeepEqual(t, req.Graffiti, blk.Body.Graffiti, "Expected block to have correct graffiti")
@@ -2667,6 +2686,10 @@ func TestProduceBlindedBlock(t *testing.T) {
 		require.NoError(t, beaconState.SetCurrentSyncCommittee(syncCommittee))
 		require.NoError(t, beaconState.SetNextSyncCommittee(syncCommittee))
 
+		ts := time.Now()
+		ti := ts.Add(-time.Duration(uint64(2*params.BeaconConfig().SlotsPerEpoch+1)*params.BeaconConfig().SecondsPerSlot) * time.Second)
+		require.NoError(t, beaconState.SetGenesisTime(uint64(ti.Unix())))
+
 		stateRoot, err := beaconState.HashTreeRoot(ctx)
 		require.NoError(t, err, "Could not hash genesis state")
 		genesisBlock := util.NewBeaconBlockCapella()
@@ -2688,10 +2711,6 @@ func TestProduceBlindedBlock(t *testing.T) {
 
 		sk, err := bls.RandKey()
 		require.NoError(t, err)
-		ti := time.Unix(0, 0)
-		ts, err := slots.ToTime(uint64(ti.Unix()), params.BeaconConfig().SlotsPerEpoch*2+1)
-		require.NoError(t, err)
-		require.NoError(t, beaconState.SetGenesisTime(uint64(ti.Unix())))
 		random, err := helpers.RandaoMix(beaconState, coreTime.CurrentEpoch(beaconState))
 		require.NoError(t, err)
 		wds, err := beaconState.ExpectedWithdrawals()
@@ -2726,18 +2745,21 @@ func TestProduceBlindedBlock(t *testing.T) {
 			Signature: sk.Sign(sr[:]).Marshal(),
 		}
 		id := &enginev1.PayloadIDBytes{0x1}
+
+		chainSlot := primitives.Slot(2*params.BeaconConfig().SlotsPerEpoch + 1)
+		fcs := doublylinkedtree.New()
+		fcs.SetGenesisTime(uint64(ti.Unix()))
+		mockChainService := &mockChain.ChainService{Slot: &chainSlot, Genesis: ti, State: beaconState, Root: parentRoot[:], ForkChoiceStore: fcs, Block: wfb}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			ExecutionEngineCaller: &mockExecution.EngineClient{PayloadIDBytes: id, ExecutionPayloadCapella: &enginev1.ExecutionPayloadCapella{BlockNumber: 1, Withdrawals: wds}, BlockValue: big.NewInt(0)},
-			BeaconDB:              db,
-			ForkFetcher:           &mockChain.ChainService{ForkChoiceStore: doublylinkedtree.New()},
-			TimeFetcher: &mockChain.ChainService{
-				Genesis: ti,
-			},
-			HeadFetcher:            &mockChain.ChainService{State: beaconState, Root: parentRoot[:], Block: wfb},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
+			ExecutionEngineCaller:  &mockExecution.EngineClient{PayloadIDBytes: id, ExecutionPayloadCapella: &enginev1.ExecutionPayloadCapella{BlockNumber: 1, Withdrawals: wds}, BlockValue: big.NewInt(0)},
+			BeaconDB:               db,
+			ForkFetcher:            mockChainService,
+			TimeFetcher:            mockChainService,
+			HeadFetcher:            mockChainService,
+			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
+			BlockReceiver:          mockChainService,
+			HeadUpdater:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -2746,7 +2768,7 @@ func TestProduceBlindedBlock(t *testing.T) {
 			SlashingsPool:          slashings.NewPool(),
 			ExitPool:               voluntaryexits.NewPool(),
 			BLSChangesPool:         blstoexec.NewPool(),
-			StateGen:               stategen.New(db, doublylinkedtree.New()),
+			StateGen:               stategen.New(db, fcs),
 			SyncCommitteePool:      synccommittee.NewStore(),
 			ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
 			BlockBuilder: &builderTest.MockBuilderService{
@@ -2877,11 +2899,13 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 
 		bs, parentRoot, privKeys := util.DeterministicGenesisStateWithGenesisBlock(t, ctx, db, 2)
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       &mockChain.ChainService{State: bs, Root: parentRoot[:]},
+			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
+			BlockReceiver:     mockChainService,
+			HeadUpdater:       mockChainService,
+			ForkFetcher:       mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -3038,11 +3062,13 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 		require.NoError(t, db.SaveState(ctx, bs, parentRoot), "Could not save genesis state")
 		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:       &mockChain.ChainService{State: bs, Root: parentRoot[:]},
+			HeadFetcher:       mockChainService,
 			SyncChecker:       &mockSync.Sync{IsSyncing: false},
 			BlockReceiver:     &mockChain.ChainService{},
-			HeadUpdater:       &mockChain.ChainService{},
+			HeadUpdater:       mockChainService,
+			ForkFetcher:       mockChainService,
 			ChainStartFetcher: &mockExecution.Chain{},
 			Eth1InfoFetcher:   &mockExecution.Chain{},
 			Eth1BlockFetcher:  &mockExecution.Chain{},
@@ -3235,18 +3261,20 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 		require.NoError(t, db.SaveState(ctx, bs, parentRoot), "Could not save genesis state")
 		require.NoError(t, db.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			ExecutionEngineCaller: &mockExecution.EngineClient{
 				ExecutionBlock: &enginev1.ExecutionBlock{
 					TotalDifficulty: "0x1",
 				},
 			},
-			TimeFetcher:            &mockChain.ChainService{},
-			HeadFetcher:            &mockChain.ChainService{State: bs, Root: parentRoot[:]},
-			OptimisticModeFetcher:  &mockChain.ChainService{},
+			TimeFetcher:            mockChainService,
+			HeadFetcher:            mockChainService,
+			OptimisticModeFetcher:  mockChainService,
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
+			BlockReceiver:          mockChainService,
+			HeadUpdater:            mockChainService,
+			ForkFetcher:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},
@@ -3457,6 +3485,7 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 		prevRandao, err := helpers.RandaoMix(bs, 2)
 		require.NoError(t, err)
 
+		mockChainService := &mockChain.ChainService{State: bs, Root: parentRoot[:], ForkChoiceStore: doublylinkedtree.New()}
 		v1Alpha1Server := &v1alpha1validator.Server{
 			ExecutionEngineCaller: &mockExecution.EngineClient{
 				ExecutionBlock: &enginev1.ExecutionBlock{
@@ -3478,11 +3507,12 @@ func TestProduceBlindedBlockSSZ(t *testing.T) {
 				},
 			},
 			TimeFetcher:            &mockChain.ChainService{},
-			HeadFetcher:            &mockChain.ChainService{State: bs, Root: parentRoot[:]},
+			HeadFetcher:            mockChainService,
 			OptimisticModeFetcher:  &mockChain.ChainService{},
 			SyncChecker:            &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:          &mockChain.ChainService{},
-			HeadUpdater:            &mockChain.ChainService{},
+			BlockReceiver:          mockChainService,
+			HeadUpdater:            mockChainService,
+			ForkFetcher:            mockChainService,
 			ChainStartFetcher:      &mockExecution.Chain{},
 			Eth1InfoFetcher:        &mockExecution.Chain{},
 			Eth1BlockFetcher:       &mockExecution.Chain{},

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

@@ -266,6 +266,7 @@ func (bs *Server) listBlocksForGenesis(ctx context.Context, _ *ethpb.ListBlocksR
 //
 // This includes the head block slot and root as well as information about
 // the most recent finalized and justified slots.
+// DEPRECATED: This endpoint is superseded by the /eth/v1/beacon API endpoint
 func (bs *Server) GetChainHead(ctx context.Context, _ *emptypb.Empty) (*ethpb.ChainHead, error) {
 	return bs.chainHeadRetrieval(ctx)
 }

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

@@ -27,6 +27,7 @@ go_library(
         "@com_github_ipfs_go_log_v2//:go_default_library",
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
+        "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_bazel_rules_go//proto/wkt:empty_go_proto",
         "@org_golang_google_grpc//codes:go_default_library",

beacon-chain/rpc/prysm/v1alpha1/debug/p2p.go

@@ -6,6 +6,7 @@ import (
 	"github.com/golang/protobuf/ptypes/empty"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/libp2p/go-libp2p/core/protocol"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"google.golang.org/grpc/codes"
@@ -92,7 +93,7 @@ func (ds *Server) getPeer(pid peer.ID) (*ethpb.DebugPeerResponse, error) {
 		aVersion = ""
 	}
 	peerInfo := &ethpb.DebugPeerResponse_PeerInfo{
-		Protocols:       protocols,
+		Protocols:       protocol.ConvertToStrings(protocols),
 		FaultCount:      uint64(resp),
 		ProtocolVersion: pVersion,
 		AgentVersion:    aVersion,

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

@@ -11,6 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	emptypb "github.com/golang/protobuf/ptypes/empty"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/feed/block"
@@ -47,9 +48,15 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 		return nil, status.Error(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 
-	if err := vs.HeadUpdater.UpdateHead(ctx); err != nil {
-		log.WithError(err).Error("Could not process attestations and update head")
+	// process attestations and update head in forkchoice
+	vs.ForkFetcher.ForkChoicer().Lock()
+	vs.HeadUpdater.UpdateHead(ctx, vs.ForkFetcher.CurrentSlot())
+	headRoot := vs.ForkFetcher.ForkChoicer().CachedHeadRoot()
+	parentRoot := vs.ForkFetcher.ForkChoicer().GetProposerHead()
+	if parentRoot != headRoot {
+		blockchain.LateBlockAttemptedReorgCount.Inc()
 	}
+	vs.ForkFetcher.ForkChoicer().Unlock()
 
 	// 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 {
@@ -62,15 +69,11 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not prepare block: %v", err)
 	}
-	parentRoot, err := vs.HeadFetcher.HeadRoot(ctx)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get head root: %v", err)
-	}
 	head, err := vs.HeadFetcher.HeadState(ctx)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not get head state: %v", err)
 	}
-	head, err = transition.ProcessSlotsUsingNextSlotCache(ctx, head, parentRoot, req.Slot)
+	head, err = transition.ProcessSlotsUsingNextSlotCache(ctx, head, parentRoot[:], req.Slot)
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not process slots up to %d: %v", req.Slot, err)
 	}
@@ -79,7 +82,7 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	sBlk.SetSlot(req.Slot)
 	sBlk.SetGraffiti(req.Graffiti)
 	sBlk.SetRandaoReveal(req.RandaoReveal)
-	sBlk.SetParentRoot(parentRoot)
+	sBlk.SetParentRoot(parentRoot[:])
 
 	// Set eth1 data.
 	eth1Data, err := vs.eth1DataMajorityVote(ctx, head)

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

@@ -56,7 +56,7 @@ func (vs *Server) circuitBreakBuilder(s primitives.Slot) (bool, error) {
 		return true, err
 	}
 
-	if diff > maxConsecutiveSkipSlotsAllowed {
+	if diff >= maxConsecutiveSkipSlotsAllowed {
 		log.WithFields(logrus.Fields{
 			"currentSlot":                    s,
 			"highestReceivedSlot":            highestReceivedSlot,
@@ -80,7 +80,7 @@ func (vs *Server) circuitBreakBuilder(s primitives.Slot) (bool, error) {
 	if err != nil {
 		return true, err
 	}
-	if diff > maxEpochSkipSlotsAllowed {
+	if diff >= maxEpochSkipSlotsAllowed {
 		log.WithFields(logrus.Fields{
 			"totalMissed":              diff,
 			"maxEpochSkipSlotsAllowed": maxEpochSkipSlotsAllowed,

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

@@ -42,7 +42,7 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 	st, blkRoot, err := createState(1, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, s.ForkFetcher.ForkChoicer().InsertNode(ctx, st, blkRoot))
-	b, err = s.circuitBreakBuilder(params.BeaconConfig().MaxBuilderConsecutiveMissedSlots + 1)
+	b, err = s.circuitBreakBuilder(params.BeaconConfig().MaxBuilderConsecutiveMissedSlots)
 	require.NoError(t, err)
 	require.Equal(t, false, b)
 
@@ -119,7 +119,7 @@ func TestServer_canUseBuilder(t *testing.T) {
 	require.NoError(t, proposerServer.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{0},
 		[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: f, Pubkey: p}}))
 
-	reg, err = proposerServer.canUseBuilder(ctx, params.BeaconConfig().MaxBuilderConsecutiveMissedSlots, 0)
+	reg, err = proposerServer.canUseBuilder(ctx, params.BeaconConfig().MaxBuilderConsecutiveMissedSlots-1, 0)
 	require.NoError(t, err)
 	require.Equal(t, true, reg)
 }

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

@@ -439,10 +439,12 @@ func TestServer_GetBeaconBlock_Optimistic(t *testing.T) {
 	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
 	require.NoError(t, err)
 
+	mockChainService := &mock.ChainService{ForkChoiceStore: doublylinkedtree.New()}
 	proposerServer := &Server{
 		OptimisticModeFetcher: &mock.ChainService{Optimistic: true},
 		SyncChecker:           &mockSync.Sync{},
-		HeadUpdater:           &mock.ChainService{},
+		HeadUpdater:           mockChainService,
+		ForkFetcher:           mockChainService,
 		TimeFetcher:           &mock.ChainService{}}
 	req := &ethpb.BlockRequest{
 		Slot: bellatrixSlot + 1,
@@ -455,14 +457,16 @@ func TestServer_GetBeaconBlock_Optimistic(t *testing.T) {
 }
 
 func getProposerServer(db db.HeadAccessDatabase, headState state.BeaconState, headRoot []byte) *Server {
+	mockChainService := &mock.ChainService{State: headState, Root: headRoot, ForkChoiceStore: doublylinkedtree.New()}
 	return &Server{
-		HeadFetcher:           &mock.ChainService{State: headState, Root: headRoot},
+		HeadFetcher:           mockChainService,
 		SyncChecker:           &mockSync.Sync{IsSyncing: false},
-		BlockReceiver:         &mock.ChainService{},
-		HeadUpdater:           &mock.ChainService{},
+		BlockReceiver:         mockChainService,
+		HeadUpdater:           mockChainService,
 		ChainStartFetcher:     &mockExecution.Chain{},
 		Eth1InfoFetcher:       &mockExecution.Chain{},
 		Eth1BlockFetcher:      &mockExecution.Chain{},
+		ForkFetcher:           mockChainService,
 		MockEth1Votes:         true,
 		AttPool:               attestations.NewPool(),
 		SlashingsPool:         slashings.NewPool(),

beacon-chain/rpc/service.go

@@ -335,6 +335,7 @@ func (s *Service) Start() {
 		StateNotifier:     s.cfg.StateNotifier,
 		BlockNotifier:     s.cfg.BlockNotifier,
 		OperationNotifier: s.cfg.OperationNotifier,
+		HeadFetcher:       s.cfg.HeadFetcher,
 	})
 	if s.cfg.EnableDebugRPCEndpoints {
 		log.Info("Enabled debug gRPC endpoints")

beacon-chain/sync/fork_watcher_test.go

@@ -90,7 +90,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) {
 				assert.Equal(t, true, s.subHandler.digestExists(digest))
 				rpcMap := make(map[string]bool)
 				for _, p := range s.cfg.p2p.Host().Mux().Protocols() {
-					rpcMap[p] = true
+					rpcMap[string(p)] = true
 				}
 				assert.Equal(t, true, rpcMap[p2p.RPCBlocksByRangeTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()], "topic doesn't exist")
 				assert.Equal(t, true, rpcMap[p2p.RPCBlocksByRootTopicV2+s.cfg.p2p.Encoding().ProtocolSuffix()], "topic doesn't exist")
@@ -134,7 +134,7 @@ func TestService_CheckForNextEpochFork(t *testing.T) {
 				assert.Equal(t, true, s.subHandler.digestExists(digest))
 				rpcMap := make(map[string]bool)
 				for _, p := range s.cfg.p2p.Host().Mux().Protocols() {
-					rpcMap[p] = true
+					rpcMap[string(p)] = true
 				}
 			},
 		},
@@ -189,7 +189,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 				ptcls := s.cfg.p2p.Host().Mux().Protocols()
 				pMap := make(map[string]bool)
 				for _, p := range ptcls {
-					pMap[p] = true
+					pMap[string(p)] = true
 				}
 				assert.Equal(t, true, pMap[p2p.RPCGoodByeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()])
 				assert.Equal(t, true, pMap[p2p.RPCStatusTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()])
@@ -259,7 +259,7 @@ func TestService_CheckForPreviousEpochFork(t *testing.T) {
 				ptcls := s.cfg.p2p.Host().Mux().Protocols()
 				pMap := make(map[string]bool)
 				for _, p := range ptcls {
-					pMap[p] = true
+					pMap[string(p)] = true
 				}
 				assert.Equal(t, true, pMap[p2p.RPCGoodByeTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()])
 				assert.Equal(t, true, pMap[p2p.RPCStatusTopicV1+s.cfg.p2p.Encoding().ProtocolSuffix()])

beacon-chain/sync/initial-sync/BUILD.bazel

@@ -120,7 +120,6 @@ go_test(
         "//beacon-chain/p2p/types:go_default_library",
         "//beacon-chain/sync:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

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

@@ -469,7 +469,7 @@ func TestBlocksFetcher_findAncestor(t *testing.T) {
 		wsb, err := blocks.NewSignedBeaconBlock(knownBlocks[4])
 		require.NoError(t, err)
 		_, err = fetcher.findAncestor(ctx, p2.PeerID(), wsb)
-		assert.ErrorContains(t, "protocol not supported", err)
+		assert.ErrorContains(t, "protocols not supported", err)
 	})
 
 	t.Run("no blocks", func(t *testing.T) {

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

@@ -19,7 +19,6 @@ import (
 	p2pTypes "github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/types"
 	beaconsync "github.com/prysmaticlabs/prysm/v3/beacon-chain/sync"
 	"github.com/prysmaticlabs/prysm/v3/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
@@ -55,11 +54,6 @@ func TestMain(m *testing.M) {
 	logrus.SetLevel(logrus.DebugLevel)
 	logrus.SetOutput(io.Discard)
 
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnablePeerScorer: true,
-	})
-	defer resetCfg()
-
 	resetFlags := flags.Get()
 	flags.Init(&flags.GlobalFlags{
 		BlockBatchLimit:            64,

beacon-chain/sync/rpc_send_request_test.go

@@ -37,7 +37,7 @@ func TestSendRequest_SendBeaconBlocksByRangeRequest(t *testing.T) {
 		req := &ethpb.BeaconBlocksByRangeRequest{}
 		chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
 		_, err := SendBeaconBlocksByRangeRequest(ctx, chain, p1, bogusPeer.PeerID(), req, nil)
-		assert.ErrorContains(t, "protocol not supported", err)
+		assert.ErrorContains(t, "protocols not supported", err)
 	})
 
 	knownBlocks := make([]*ethpb.SignedBeaconBlock, 0)
@@ -329,7 +329,7 @@ func TestSendRequest_SendBeaconBlocksByRootRequest(t *testing.T) {
 		req := &p2pTypes.BeaconBlockByRootsReq{}
 		chain := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
 		_, err := SendBeaconBlocksByRootRequest(ctx, chain, p1, bogusPeer.PeerID(), req, nil)
-		assert.ErrorContains(t, "protocol not supported", err)
+		assert.ErrorContains(t, "protocols not supported", err)
 	})
 
 	knownBlocksProvider := func(p2pProvider p2p.P2P, processor BeaconBlockProcessor) func(stream network.Stream) {

beacon-chain/sync/validate_sync_contribution_proof.go

@@ -251,7 +251,6 @@ func (s *Service) rejectInvalidSyncAggregateSignature(m *ethpb.SignedContributio
 		defer span.End()
 		// The aggregate signature is valid for the message `beacon_block_root` and aggregate pubkey
 		// derived from the participation info in `aggregation_bits` for the subcommittee specified by the `contribution.subcommittee_index`.
-		var activePubkeys []bls.PublicKey
 		var activeRawPubkeys [][]byte
 		syncPubkeys, err := s.cfg.chain.HeadSyncCommitteePubKeys(ctx, m.Message.Contribution.Slot, primitives.CommitteeIndex(m.Message.Contribution.SubcommitteeIndex))
 		if err != nil {
@@ -265,12 +264,6 @@ func (s *Service) rejectInvalidSyncAggregateSignature(m *ethpb.SignedContributio
 		}
 		for i, pk := range syncPubkeys {
 			if bVector.BitAt(uint64(i)) {
-				pubK, err := bls.PublicKeyFromBytes(pk)
-				if err != nil {
-					tracing.AnnotateError(span, err)
-					return pubsub.ValidationIgnore, err
-				}
-				activePubkeys = append(activePubkeys, pubK)
 				activeRawPubkeys = append(activeRawPubkeys, pk)
 			}
 		}

build/bazelrc/correctness.bazelrc

@@ -1,10 +1,3 @@
-# Do not upload locally executed action results to the remote cache.
-# This should be the default for local builds so local builds cannot poison the remote cache.
-# It should be flipped to `--remote_upload_local_results` on CI
-# by using `--bazelrc=.aspect/bazelrc/ci.bazelrc`.
-# Docs: https://bazel.build/reference/command-line-reference#flag--remote_upload_local_results
-build --noremote_upload_local_results
-
 # Don't allow network access for build actions in the sandbox.
 # Ensures that you don't accidentally make non-hermetic actions/tests which depend on remote
 # services.

build/bazelrc/cross.bazelrc

@@ -2,8 +2,10 @@
 -----------------------------------------------
 
 build:cross --crosstool_top=@prysm_toolchains//:multiarch_toolchain
-build:cross --host_platform=@io_bazel_rules_go//go/toolchain:linux_amd64
+build:cross --extra_execution_platforms=@//tools/cross-toolchain/configs/config:platform
+build:cross --extra_toolchains=@prysm_toolchains//:cc-toolchain-multiarch
 build:cross --host_crosstool_top=@prysm_toolchains//:hostonly_toolchain
+build:cross --platforms=@//tools/cross-toolchain/configs/config:platform
 
 # linux_amd64 config for cross compiler toolchain, not strictly necessary since host/exec env is amd64
 build:linux_amd64 --platforms=@io_bazel_rules_go//go/toolchain:linux_amd64_cgo
@@ -21,10 +23,10 @@ build:osx_arm64 --cpu=aarch64
 
 # windows
 build:windows_amd64 --config=cross
-build:windows_amd64  --platforms=@io_bazel_rules_go//go/toolchain:windows_amd64_cgo
+build:windows_amd64 --platforms=@io_bazel_rules_go//go/toolchain:windows_amd64_cgo
 build:windows_amd64 --compiler=mingw-w64
 
-# linux_arm64 conifg for cross compiler toolchain
+# linux_arm64 config for cross compiler toolchain
 build:linux_arm64 --config=cross
 build:linux_arm64 --platforms=@io_bazel_rules_go//go/toolchain:linux_arm64_cgo
 build:linux_arm64 --copt=-funsafe-math-optimizations
@@ -38,20 +40,17 @@ build:linux_arm64 --copt=-march=armv8-a
 # Docker Sandbox Configs
 #-----------------------
 # Note all docker sandbox configs must run from a linux x86_64 host
-# build:docker-sandbox --experimental_docker_image=gcr.io/prysmaticlabs/rbe-worker:latest
+build:docker-sandbox --unconditional_warning="⚠️  Docker sandbox is extremely slow! Consider a remote executor, if possible. See tools/cross-toolchain/README.md#Caveats ⚠️"
 build:docker-sandbox --spawn_strategy=docker --strategy=Javac=docker --genrule_strategy=docker
 build:docker-sandbox --define=EXECUTOR=remote
 build:docker-sandbox --experimental_docker_verbose
 build:docker-sandbox --experimental_enable_docker_sandbox
-build:docker-sandbox --crosstool_top=@rbe_ubuntu_clang//cc:toolchain 
-build:docker-sandbox --host_javabase=@rbe_ubuntu_clang//java:jdk 
-build:docker-sandbox --javabase=@rbe_ubuntu_clang//java:jdk 
-build:docker-sandbox --host_java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8 
-build:docker-sandbox --java_toolchain=@bazel_tools//tools/jdk:toolchain_hostjdk8 
-build:docker-sandbox --extra_execution_platforms=@rbe_ubuntu_clang//config:platform 
-build:docker-sandbox --host_platform=@rbe_ubuntu_clang//config:platform 
-build:docker-sandbox --platforms=@rbe_ubuntu_clang//config:platform
-build:docker-sandbox --extra_toolchains=@prysm_toolchains//:cc-toolchain-multiarch
+
+# Remote with docker sandbox fallback
+build:remote --spawn_strategy=remote,docker,linux-sandbox --strategy=Javac=remote,docker,linux-sandbox --genrule_strategy=remote,docker,linux-sandbox
+build:remote --define=EXECUTOR=remote
+build:remote --experimental_docker_verbose
+build:remote --experimental_enable_docker_sandbox
 
 # windows_amd64 docker sandbox build config
 build:windows_amd64_docker --config=docker-sandbox --config=windows_amd64

cmd/beacon-chain/execution/options.go

@@ -68,8 +68,7 @@ func parseJWTSecretFromFile(c *cli.Context) ([]byte, error) {
 }
 
 func parseExecutionChainEndpoint(c *cli.Context) (string, error) {
-	aliasUsed := c.IsSet(flags.HTTPWeb3ProviderFlag.Name)
-	if c.String(flags.ExecutionEngineEndpoint.Name) == "" && !aliasUsed {
+	if c.String(flags.ExecutionEngineEndpoint.Name) == "" {
 		return "", fmt.Errorf(
 			"you need to specify %s to provide a connection endpoint to an Ethereum execution client "+
 				"for your Prysm beacon node. This is a requirement for running a node. You can read more about "+
@@ -78,12 +77,5 @@ func parseExecutionChainEndpoint(c *cli.Context) (string, error) {
 			flags.ExecutionEngineEndpoint.Name,
 		)
 	}
-	// If users only declare the deprecated flag without setting the execution engine
-	// flag, we fallback to using the deprecated flag value.
-	if aliasUsed && !c.IsSet(flags.ExecutionEngineEndpoint.Name) {
-		log.Warnf("The %s flag has been deprecated and will be removed in a future release,"+
-			"please use the execution endpoint flag instead %s", flags.HTTPWeb3ProviderFlag.Name, flags.ExecutionEngineEndpoint.Name)
-		return c.String(flags.HTTPWeb3ProviderFlag.Name), nil
-	}
 	return c.String(flags.ExecutionEngineEndpoint.Name), nil
 }

cmd/beacon-chain/flags/base.go

@@ -39,13 +39,6 @@ var (
 		Usage: "A comma separated list of key value pairs to pass as HTTP headers for all execution " +
 			"client calls. Example: --execution-headers=key1=value1,key2=value2",
 	}
-	// Deprecated: HTTPWeb3ProviderFlag is a deprecated flag and is an alias for the ExecutionEngineEndpoint flag.
-	HTTPWeb3ProviderFlag = &cli.StringFlag{
-		Name:   "http-web3provider",
-		Usage:  "DEPRECATED: A mainchain web3 provider string http endpoint. Can contain auth header as well in the format --http-web3provider=\"https://goerli.infura.io/v3/xxxx,Basic xxx\" for project secret (base64 encoded) and --http-web3provider=\"https://goerli.infura.io/v3/xxxx,Bearer xxx\" for jwt use",
-		Value:  "http://localhost:8551",
-		Hidden: true,
-	}
 	// ExecutionJWTSecretFlag provides a path to a file containing a hex-encoded string representing a 32 byte secret
 	// used to authenticate with an execution node via HTTP. This is required if using an HTTP connection, otherwise all requests
 	// to execution nodes for consensus-related calls will fail. This is not required if using an IPC connection.

cmd/beacon-chain/main.go

@@ -39,7 +39,6 @@ var appFlags = []cli.Flag{
 	flags.DepositContractFlag,
 	flags.ExecutionEngineEndpoint,
 	flags.ExecutionEngineHeaders,
-	flags.HTTPWeb3ProviderFlag,
 	flags.ExecutionJWTSecretFlag,
 	flags.RPCHost,
 	flags.RPCPort,
@@ -195,9 +194,6 @@ func main() {
 		if err := cmd.ExpandSingleEndpointIfFile(ctx, flags.ExecutionEngineEndpoint); err != nil {
 			return err
 		}
-		if err := cmd.ExpandSingleEndpointIfFile(ctx, flags.HTTPWeb3ProviderFlag); err != nil {
-			return err
-		}
 		if ctx.IsSet(flags.SetGCPercent.Name) {
 			runtimeDebug.SetGCPercent(ctx.Int(flags.SetGCPercent.Name))
 		}

cmd/beacon-chain/usage.go

@@ -107,7 +107,6 @@ var appHelpFlagGroups = []flagGroup{
 			flags.GPRCGatewayCorsDomain,
 			flags.ExecutionEngineEndpoint,
 			flags.ExecutionEngineHeaders,
-			flags.HTTPWeb3ProviderFlag,
 			flags.ExecutionJWTSecretFlag,
 			flags.SetGCPercent,
 			flags.SlotsPerArchivedPoint,

cmd/flags_test.go

@@ -17,26 +17,27 @@ func TestLoadFlagsFromConfig(t *testing.T) {
 	require.NoError(t, os.WriteFile("flags_test.yaml", []byte("testflag: 100"), 0666))
 
 	require.NoError(t, set.Parse([]string{"test-command", "--" + ConfigFileFlag.Name, "flags_test.yaml"}))
+	comFlags := WrapFlags([]cli.Flag{
+		&cli.StringFlag{
+			Name: ConfigFileFlag.Name,
+		},
+		&cli.IntFlag{
+			Name:  "testflag",
+			Value: 0,
+		},
+	})
 	command := &cli.Command{
-		Name: "test-command",
-		Flags: WrapFlags([]cli.Flag{
-			&cli.StringFlag{
-				Name: ConfigFileFlag.Name,
-			},
-			&cli.IntFlag{
-				Name:  "testflag",
-				Value: 0,
-			},
-		}),
+		Name:  "test-command",
+		Flags: comFlags,
 		Before: func(cliCtx *cli.Context) error {
-			return LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags)
+			return LoadFlagsFromConfig(cliCtx, comFlags)
 		},
 		Action: func(cliCtx *cli.Context) error {
 			require.Equal(t, 100, cliCtx.Int("testflag"))
 			return nil
 		},
 	}
-	require.NoError(t, command.Run(context))
+	require.NoError(t, command.Run(context, context.Args().Slice()...))
 	require.NoError(t, os.Remove("flags_test.yaml"))
 }
 

cmd/helpers_test.go

@@ -84,30 +84,30 @@ func TestEnterPassword(t *testing.T) {
 func TestExpandSingleEndpointIfFile(t *testing.T) {
 	app := cli.App{}
 	set := flag.NewFlagSet("test", 0)
-	HTTPWeb3ProviderFlag := &cli.StringFlag{Name: "http-web3provider", Value: ""}
-	set.String(HTTPWeb3ProviderFlag.Name, "", "")
+	ExecutionEndpointFlag := &cli.StringFlag{Name: "execution-endpoint", Value: ""}
+	set.String(ExecutionEndpointFlag.Name, "", "")
 	context := cli.NewContext(&app, set, nil)
 
 	// with nothing set
-	require.NoError(t, ExpandSingleEndpointIfFile(context, HTTPWeb3ProviderFlag))
-	require.Equal(t, "", context.String(HTTPWeb3ProviderFlag.Name))
+	require.NoError(t, ExpandSingleEndpointIfFile(context, ExecutionEndpointFlag))
+	require.Equal(t, "", context.String(ExecutionEndpointFlag.Name))
 
 	// with url scheme
-	require.NoError(t, context.Set(HTTPWeb3ProviderFlag.Name, "http://localhost:8545"))
-	require.NoError(t, ExpandSingleEndpointIfFile(context, HTTPWeb3ProviderFlag))
-	require.Equal(t, "http://localhost:8545", context.String(HTTPWeb3ProviderFlag.Name))
+	require.NoError(t, context.Set(ExecutionEndpointFlag.Name, "http://localhost:8545"))
+	require.NoError(t, ExpandSingleEndpointIfFile(context, ExecutionEndpointFlag))
+	require.Equal(t, "http://localhost:8545", context.String(ExecutionEndpointFlag.Name))
 
 	// relative user home path
 	usr, err := user.Current()
 	require.NoError(t, err)
-	require.NoError(t, context.Set(HTTPWeb3ProviderFlag.Name, "~/relative/path.ipc"))
-	require.NoError(t, ExpandSingleEndpointIfFile(context, HTTPWeb3ProviderFlag))
-	require.Equal(t, usr.HomeDir+"/relative/path.ipc", context.String(HTTPWeb3ProviderFlag.Name))
+	require.NoError(t, context.Set(ExecutionEndpointFlag.Name, "~/relative/path.ipc"))
+	require.NoError(t, ExpandSingleEndpointIfFile(context, ExecutionEndpointFlag))
+	require.Equal(t, usr.HomeDir+"/relative/path.ipc", context.String(ExecutionEndpointFlag.Name))
 
 	// current dir path
 	curentdir, err := os.Getwd()
 	require.NoError(t, err)
-	require.NoError(t, context.Set(HTTPWeb3ProviderFlag.Name, "./path.ipc"))
-	require.NoError(t, ExpandSingleEndpointIfFile(context, HTTPWeb3ProviderFlag))
-	require.Equal(t, curentdir+"/path.ipc", context.String(HTTPWeb3ProviderFlag.Name))
+	require.NoError(t, context.Set(ExecutionEndpointFlag.Name, "./path.ipc"))
+	require.NoError(t, ExpandSingleEndpointIfFile(context, ExecutionEndpointFlag))
+	require.Equal(t, curentdir+"/path.ipc", context.String(ExecutionEndpointFlag.Name))
 }

cmd/prysmctl/p2p/BUILD.bazel

@@ -41,7 +41,6 @@ go_library(
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/protocol/identify:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/security/noise:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/transport/tcp:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

cmd/prysmctl/p2p/client.go

@@ -13,7 +13,6 @@ import (
 	corenet "github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/protocol"
-	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
 	"github.com/libp2p/go-libp2p/p2p/security/noise"
 	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
 	"github.com/pkg/errors"
@@ -70,7 +69,6 @@ func newClient(beaconEndpoints []string, clientPort uint) (*client, error) {
 	if err != nil {
 		return nil, errors.Wrap(err, "could not start libp2p")
 	}
-	h.RemoveStreamHandler(identify.IDDelta)
 	if len(beaconEndpoints) == 0 {
 		return nil, errors.New("no specified beacon API endpoints")
 	}

cmd/prysmctl/testnet/BUILD.bazel

@@ -16,10 +16,13 @@ go_library(
         "//beacon-chain/state/state-native:go_default_library",
         "//cmd/flags:go_default_library",
         "//config/params:go_default_library",
+        "//container/trie:go_default_library",
         "//io/file:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/interop:go_default_library",
         "//runtime/version:go_default_library",
+        "@com_github_ethereum_go_ethereum//ethclient:go_default_library",
+        "@com_github_ethereum_go_ethereum//rpc:go_default_library",
         "@com_github_ghodss_yaml//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",

cmd/prysmctl/testnet/generate_genesis.go

@@ -6,38 +6,43 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
+	"math/big"
 	"os"
 	"strings"
 
+	"github.com/ethereum/go-ethereum/ethclient"
+	"github.com/ethereum/go-ethereum/rpc"
+	"github.com/ghodss/yaml"
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/capella"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/execution"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
 	state_native "github.com/prysmaticlabs/prysm/v3/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v3/cmd/flags"
-	"github.com/prysmaticlabs/prysm/v3/runtime/version"
-
-	"github.com/ghodss/yaml"
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
+	"github.com/prysmaticlabs/prysm/v3/container/trie"
 	"github.com/prysmaticlabs/prysm/v3/io/file"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/runtime/interop"
+	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 	"github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
 
 var (
 	generateGenesisStateFlags = struct {
-		DepositJsonFile string
-		ChainConfigFile string
-		ConfigName      string
-		NumValidators   uint64
-		GenesisTime     uint64
-		OutputSSZ       string
-		OutputJSON      string
-		OutputYaml      string
-		ForkName        string
+		DepositJsonFile   string
+		ChainConfigFile   string
+		ConfigName        string
+		NumValidators     uint64
+		GenesisTime       uint64
+		OutputSSZ         string
+		OutputJSON        string
+		OutputYaml        string
+		ForkName          string
+		OverrideEth1Data  bool
+		ExecutionEndpoint string
 	}{}
 	log           = logrus.WithField("prefix", "genesis")
 	outputSSZFlag = &cli.StringFlag{
@@ -95,6 +100,18 @@ var (
 				Destination: &generateGenesisStateFlags.GenesisTime,
 				Usage:       "Unix timestamp seconds used as the genesis time in the genesis state. If unset, defaults to now()",
 			},
+			&cli.BoolFlag{
+				Name:        "override-eth1data",
+				Destination: &generateGenesisStateFlags.OverrideEth1Data,
+				Usage:       "Overrides Eth1Data with values from execution client. If unset, defaults to false",
+				Value:       false,
+			},
+			&cli.StringFlag{
+				Name:        "execution-endpoint",
+				Destination: &generateGenesisStateFlags.ExecutionEndpoint,
+				Usage:       "Endpoint to preferred execution client. If unset, defaults to Geth",
+				Value:       "http://localhost:8545",
+			},
 			flags.EnumValue{
 				Name:        "fork",
 				Usage:       fmt.Sprintf("Name of the BeaconState schema to use in output encoding [%s]", strings.Join(versionNames(), ",")),
@@ -238,6 +255,7 @@ func generateGenesis(ctx context.Context) (*ethpb.BeaconState, error) {
 	genesisTime := generateGenesisStateFlags.GenesisTime
 	numValidators := generateGenesisStateFlags.NumValidators
 	depositJsonFile := generateGenesisStateFlags.DepositJsonFile
+	overrideEth1Data := generateGenesisStateFlags.OverrideEth1Data
 	if depositJsonFile != "" {
 		expanded, err := file.ExpandPath(depositJsonFile)
 		if err != nil {
@@ -265,6 +283,35 @@ func generateGenesis(ctx context.Context) (*ethpb.BeaconState, error) {
 	if err != nil {
 		return nil, err
 	}
+	if overrideEth1Data {
+		log.Print("Overriding Eth1Data with data from execution client")
+		conn, err := rpc.Dial(generateGenesisStateFlags.ExecutionEndpoint)
+		if err != nil {
+			return nil, errors.Wrapf(
+				err,
+				"could not dial %s please make sure you are running your execution client",
+				generateGenesisStateFlags.ExecutionEndpoint)
+		}
+		client := ethclient.NewClient(conn)
+		header, err := client.HeaderByNumber(ctx, big.NewInt(0))
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get header by number")
+		}
+		t, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not create deposit tree")
+		}
+		depositRoot, err := t.HashTreeRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get hash tree root")
+		}
+		genesisState.Eth1Data = &ethpb.Eth1Data{
+			DepositRoot:  depositRoot[:],
+			DepositCount: 0,
+			BlockHash:    header.Hash().Bytes(),
+		}
+		genesisState.Eth1DepositIndex = 0
+	}
 	return genesisState, err
 }
 

cmd/prysmctl/validator/BUILD.bazel

@@ -16,8 +16,7 @@ go_library(
         "//cmd/validator/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//encoding/bytesutil:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//runtime/tos:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_logrusorgru_aurora//:go_default_library",

cmd/prysmctl/validator/withdraw.go

@@ -7,6 +7,7 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -15,8 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/api/client/beacon"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/apimiddleware"
 	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v3/config/params"
-	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 	"go.opencensus.io/trace"
@@ -53,7 +53,7 @@ func getWithdrawalMessagesFromPathFlag(c *cli.Context) ([]*apimiddleware.SignedB
 		}
 		var to []*apimiddleware.SignedBLSToExecutionChangeJson
 		if err := json.Unmarshal(b, &to); err != nil {
-			log.Warnf("provided file: %s, is not a list of signed withdrawal messages", foundFilePath)
+			log.Warnf("provided file: %s, is not a list of signed withdrawal messages. Error:%s", foundFilePath, err.Error())
 			continue
 		}
 		// verify 0x from file and add if needed
@@ -93,7 +93,19 @@ func callWithdrawalEndpoints(ctx context.Context, host string, request []*apimid
 	if err != nil {
 		return errors.Wrap(err, "could not retrieve current fork information")
 	}
-	if !(params.BeaconConfig().ForkVersionSchedule[bytesutil.ToBytes4(fork.CurrentVersion)] >= params.BeaconConfig().CapellaForkEpoch) {
+	spec, err := client.GetConfigSpec(ctx)
+	if err != nil {
+		return err
+	}
+	forkEpoch, ok := spec.Data["CAPELLA_FORK_EPOCH"]
+	if !ok {
+		return errors.New("Configs used on beacon node do not contain CAPELLA_FORK_EPOCH")
+	}
+	capellaForkEpoch, err := strconv.Atoi(forkEpoch)
+	if err != nil {
+		return errors.New("could not convert CAPELLA_FORK_EPOCH to a number")
+	}
+	if fork.Epoch < primitives.Epoch(capellaForkEpoch) {
 		return errors.New("setting withdrawals using the BLStoExecutionChange endpoint is only available after the Capella/Shanghai hard fork.")
 	}
 	err = client.SubmitChangeBLStoExecution(ctx, request)

cmd/prysmctl/validator/withdraw_test.go

@@ -41,12 +41,19 @@ func getHappyPathTestServer(file string, t *testing.T) *httptest.Server {
 					Data: &apimiddleware.ForkJson{
 						PreviousVersion: hexutil.Encode(params.BeaconConfig().CapellaForkVersion),
 						CurrentVersion:  hexutil.Encode(params.BeaconConfig().CapellaForkVersion),
-						Epoch:           fmt.Sprintf("%d", params.BeaconConfig().CapellaForkEpoch),
+						Epoch:           "1350",
 					},
 					ExecutionOptimistic: false,
 					Finalized:           true,
 				})
 				require.NoError(t, err)
+			} else if r.RequestURI == "/eth/v1/config/spec" {
+				m := make(map[string]string)
+				m["CAPELLA_FORK_EPOCH"] = "1350"
+				err := json.NewEncoder(w).Encode(&apimiddleware.SpecResponseJson{
+					Data: m,
+				})
+				require.NoError(t, err)
 			}
 
 		}
@@ -231,6 +238,15 @@ func TestCallWithdrawalEndpoint_Errors(t *testing.T) {
 					Finalized:           true,
 				})
 				require.NoError(t, err)
+			} else if r.RequestURI == "/eth/v1/config/spec" {
+				w.WriteHeader(200)
+				w.Header().Set("Content-Type", "application/json")
+				m := make(map[string]string)
+				m["CAPELLA_FORK_EPOCH"] = "1350"
+				err := json.NewEncoder(w).Encode(&apimiddleware.SpecResponseJson{
+					Data: m,
+				})
+				require.NoError(t, err)
 			} else {
 				w.WriteHeader(400)
 				w.Header().Set("Content-Type", "application/json")
@@ -268,16 +284,26 @@ func TestCallWithdrawalEndpoint_ForkBeforeCapella(t *testing.T) {
 	srv := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(200)
 		w.Header().Set("Content-Type", "application/json")
-		err := json.NewEncoder(w).Encode(&apimiddleware.StateForkResponseJson{
-			Data: &apimiddleware.ForkJson{
-				PreviousVersion: hexutil.Encode(params.BeaconConfig().BellatrixForkVersion),
-				CurrentVersion:  hexutil.Encode(params.BeaconConfig().BellatrixForkVersion),
-				Epoch:           fmt.Sprintf("%d", params.BeaconConfig().BellatrixForkEpoch),
-			},
-			ExecutionOptimistic: false,
-			Finalized:           true,
-		})
-		require.NoError(t, err)
+		if r.RequestURI == "/eth/v1/beacon/states/head/fork" {
+
+			err := json.NewEncoder(w).Encode(&apimiddleware.StateForkResponseJson{
+				Data: &apimiddleware.ForkJson{
+					PreviousVersion: hexutil.Encode(params.BeaconConfig().BellatrixForkVersion),
+					CurrentVersion:  hexutil.Encode(params.BeaconConfig().BellatrixForkVersion),
+					Epoch:           "1000",
+				},
+				ExecutionOptimistic: false,
+				Finalized:           true,
+			})
+			require.NoError(t, err)
+		} else if r.RequestURI == "/eth/v1/config/spec" {
+			m := make(map[string]string)
+			m["CAPELLA_FORK_EPOCH"] = "1350"
+			err := json.NewEncoder(w).Encode(&apimiddleware.SpecResponseJson{
+				Data: m,
+			})
+			require.NoError(t, err)
+		}
 	}))
 	err = srv.Listener.Close()
 	require.NoError(t, err)

cmd/validator/flags/flags.go

@@ -252,18 +252,7 @@ var (
 		Name:  "keys-dir",
 		Usage: "Path to a directory where keystores to be imported are stored",
 	}
-	// GrpcRemoteAddressFlag defines the host:port address for a remote keymanager to connect to.
-	GrpcRemoteAddressFlag = &cli.StringFlag{
-		Name:  "grpc-remote-address",
-		Usage: "Host:port of a gRPC server for a remote keymanager",
-		Value: "",
-	}
-	// DisableRemoteSignerTlsFlag disables TLS when connecting to a remote signer.
-	DisableRemoteSignerTlsFlag = &cli.BoolFlag{
-		Name:  "disable-remote-signer-tls",
-		Usage: "Disables TLS when connecting to a remote signer. (WARNING! This will result in insecure requests!)",
-		Value: false,
-	}
+
 	// RemoteSignerCertPathFlag defines the path to a client.crt file for a wallet to connect to
 	// a secure signer via TLS and gRPC.
 	RemoteSignerCertPathFlag = &cli.StringFlag{

cmd/validator/flags/flags_test.go

@@ -25,18 +25,19 @@ func TestLoadFlagsFromConfig_PreProcessing_Web3signer(t *testing.T) {
 		pubkey2)), 0666))
 
 	require.NoError(t, set.Parse([]string{"test-command", "--" + cmd.ConfigFileFlag.Name, "flags_test.yaml"}))
+	comFlags := cmd.WrapFlags([]cli.Flag{
+		&cli.StringFlag{
+			Name: cmd.ConfigFileFlag.Name,
+		},
+		&cli.StringSliceFlag{
+			Name: Web3SignerPublicValidatorKeysFlag.Name,
+		},
+	})
 	command := &cli.Command{
-		Name: "test-command",
-		Flags: cmd.WrapFlags([]cli.Flag{
-			&cli.StringFlag{
-				Name: cmd.ConfigFileFlag.Name,
-			},
-			&cli.StringSliceFlag{
-				Name: Web3SignerPublicValidatorKeysFlag.Name,
-			},
-		}),
+		Name:  "test-command",
+		Flags: comFlags,
 		Before: func(cliCtx *cli.Context) error {
-			return cmd.LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags)
+			return cmd.LoadFlagsFromConfig(cliCtx, comFlags)
 		},
 		Action: func(cliCtx *cli.Context) error {
 			//TODO: https://github.com/urfave/cli/issues/1197 right now does not set flag
@@ -47,7 +48,7 @@ func TestLoadFlagsFromConfig_PreProcessing_Web3signer(t *testing.T) {
 			return nil
 		},
 	}
-	require.NoError(t, command.Run(context))
+	require.NoError(t, command.Run(context, context.Args().Slice()...))
 	require.NoError(t, os.Remove("flags_test.yaml"))
 }
 
@@ -59,19 +60,20 @@ func TestLoadFlagsFromConfig_EnableBuilderHasDefaultValue(t *testing.T) {
 	require.NoError(t, os.WriteFile("flags_test.yaml", []byte("---\nenable-builder: true"), 0666))
 
 	require.NoError(t, set.Parse([]string{"test-command", "--" + cmd.ConfigFileFlag.Name, "flags_test.yaml"}))
+	comFlags := cmd.WrapFlags([]cli.Flag{
+		&cli.StringFlag{
+			Name: cmd.ConfigFileFlag.Name,
+		},
+		&cli.BoolFlag{
+			Name:  EnableBuilderFlag.Name,
+			Value: false,
+		},
+	})
 	command := &cli.Command{
-		Name: "test-command",
-		Flags: cmd.WrapFlags([]cli.Flag{
-			&cli.StringFlag{
-				Name: cmd.ConfigFileFlag.Name,
-			},
-			&cli.BoolFlag{
-				Name:  EnableBuilderFlag.Name,
-				Value: false,
-			},
-		}),
+		Name:  "test-command",
+		Flags: comFlags,
 		Before: func(cliCtx *cli.Context) error {
-			return cmd.LoadFlagsFromConfig(cliCtx, cliCtx.Command.Flags)
+			return cmd.LoadFlagsFromConfig(cliCtx, comFlags)
 		},
 		Action: func(cliCtx *cli.Context) error {
 
@@ -80,6 +82,6 @@ func TestLoadFlagsFromConfig_EnableBuilderHasDefaultValue(t *testing.T) {
 			return nil
 		},
 	}
-	require.NoError(t, command.Run(context))
+	require.NoError(t, command.Run(context, context.Args().Slice()...))
 	require.NoError(t, os.Remove("flags_test.yaml"))
 }

cmd/validator/wallet/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "create.go",
-        "edit.go",
         "recover.go",
         "wallet.go",
     ],
@@ -20,7 +19,6 @@ go_library(
         "//validator/accounts/userprompt:go_default_library",
         "//validator/accounts/wallet:go_default_library",
         "//validator/keymanager:go_default_library",
-        "//validator/keymanager/remote:go_default_library",
         "@com_github_manifoldco_promptui//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
@@ -32,9 +30,9 @@ go_library(
 
 go_test(
     name = "go_default_test",
+    testonly = True,
     srcs = [
         "create_test.go",
-        "edit_test.go",
         "recover_test.go",
     ],
     embed = [":go_default_library"],
@@ -50,7 +48,6 @@ go_test(
         "//validator/keymanager:go_default_library",
         "//validator/keymanager/derived:go_default_library",
         "//validator/keymanager/local:go_default_library",
-        "//validator/keymanager/remote:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",

cmd/validator/wallet/create.go

@@ -117,13 +117,6 @@ func ConstructCLIManagerOpts(cliCtx *cli.Context, keymanagerKind keymanager.Kind
 			cliOpts = append(cliOpts, accounts.WithMnemonic25thWord(mnemonicPassphrase))
 		}
 	}
-	if keymanagerKind == keymanager.Remote {
-		opts, err := userprompt.InputRemoteKeymanagerConfig(cliCtx)
-		if err != nil {
-			return []accounts.Option{}, errors.Wrap(err, "could not input remote keymanager config")
-		}
-		cliOpts = append(cliOpts, accounts.WithKeymanagerOpts(opts))
-	}
 	if keymanagerKind == keymanager.Web3Signer {
 		return []accounts.Option{}, errors.New("web3signer keymanager does not require persistent wallets.")
 	}
@@ -139,7 +132,6 @@ func inputKeymanagerKind(cliCtx *cli.Context) (keymanager.Kind, error) {
 		Items: []string{
 			wallet.KeymanagerKindSelections[keymanager.Local],
 			wallet.KeymanagerKindSelections[keymanager.Derived],
-			wallet.KeymanagerKindSelections[keymanager.Remote],
 			wallet.KeymanagerKindSelections[keymanager.Web3Signer],
 		},
 	}

cmd/validator/wallet/create_test.go

@@ -1,26 +1,108 @@
 package wallet
 
 import (
-	"context"
 	"flag"
 	"io"
+	"os"
+	"path/filepath"
+	"strconv"
 	"testing"
 
 	"github.com/pkg/errors"
 	cmdacc "github.com/prysmaticlabs/prysm/v3/cmd/validator/accounts"
 	"github.com/prysmaticlabs/prysm/v3/cmd/validator/flags"
+	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts"
 	"github.com/prysmaticlabs/prysm/v3/validator/accounts/wallet"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager"
 	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/local"
-	"github.com/prysmaticlabs/prysm/v3/validator/keymanager/remote"
 	"github.com/sirupsen/logrus"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"github.com/urfave/cli/v2"
 )
 
+const (
+	passwordFileName = "password.txt"
+	password         = "OhWOWthisisatest42!$"
+)
+
+// `cmd/validator/accounts/delete_test.go`. https://pastebin.com/2n2VB7Ez is
+// the error I couldn't get around.
+func setupWalletAndPasswordsDir(t testing.TB) (string, string, string) {
+	walletDir := filepath.Join(t.TempDir(), "wallet")
+	passwordsDir := filepath.Join(t.TempDir(), "passwords")
+	passwordFileDir := filepath.Join(t.TempDir(), "passwordFile")
+	require.NoError(t, os.MkdirAll(passwordFileDir, params.BeaconIoConfig().ReadWriteExecutePermissions))
+	passwordFilePath := filepath.Join(passwordFileDir, passwordFileName)
+	require.NoError(t, os.WriteFile(passwordFilePath, []byte(password), os.ModePerm))
+	return walletDir, passwordsDir, passwordFilePath
+}
+
+type testWalletConfig struct {
+	exitAll                 bool
+	skipDepositConfirm      bool
+	keymanagerKind          keymanager.Kind
+	numAccounts             int64
+	grpcHeaders             string
+	privateKeyFile          string
+	accountPasswordFile     string
+	walletPasswordFile      string
+	backupPasswordFile      string
+	backupPublicKeys        string
+	voluntaryExitPublicKeys string
+	deletePublicKeys        string
+	keysDir                 string
+	backupDir               string
+	walletDir               string
+	passwordsDir            string
+}
+
+func setupWalletCtx(
+	tb testing.TB,
+	cfg *testWalletConfig,
+) *cli.Context {
+	app := cli.App{}
+	set := flag.NewFlagSet("test", 0)
+	set.String(flags.WalletDirFlag.Name, cfg.walletDir, "")
+	set.String(flags.KeysDirFlag.Name, cfg.keysDir, "")
+	set.String(flags.KeymanagerKindFlag.Name, cfg.keymanagerKind.String(), "")
+	set.String(flags.DeletePublicKeysFlag.Name, cfg.deletePublicKeys, "")
+	set.String(flags.VoluntaryExitPublicKeysFlag.Name, cfg.voluntaryExitPublicKeys, "")
+	set.String(flags.BackupDirFlag.Name, cfg.backupDir, "")
+	set.String(flags.BackupPasswordFile.Name, cfg.backupPasswordFile, "")
+	set.String(flags.BackupPublicKeysFlag.Name, cfg.backupPublicKeys, "")
+	set.String(flags.WalletPasswordFileFlag.Name, cfg.walletPasswordFile, "")
+	set.String(flags.AccountPasswordFileFlag.Name, cfg.accountPasswordFile, "")
+	set.Int64(flags.NumAccountsFlag.Name, cfg.numAccounts, "")
+	set.Bool(flags.SkipDepositConfirmationFlag.Name, cfg.skipDepositConfirm, "")
+	set.Bool(flags.SkipMnemonic25thWordCheckFlag.Name, true, "")
+	set.Bool(flags.ExitAllFlag.Name, cfg.exitAll, "")
+	set.String(flags.GrpcHeadersFlag.Name, cfg.grpcHeaders, "")
+
+	if cfg.privateKeyFile != "" {
+		set.String(flags.ImportPrivateKeyFileFlag.Name, cfg.privateKeyFile, "")
+		assert.NoError(tb, set.Set(flags.ImportPrivateKeyFileFlag.Name, cfg.privateKeyFile))
+	}
+	assert.NoError(tb, set.Set(flags.WalletDirFlag.Name, cfg.walletDir))
+	assert.NoError(tb, set.Set(flags.SkipMnemonic25thWordCheckFlag.Name, "true"))
+	assert.NoError(tb, set.Set(flags.KeysDirFlag.Name, cfg.keysDir))
+	assert.NoError(tb, set.Set(flags.KeymanagerKindFlag.Name, cfg.keymanagerKind.String()))
+	assert.NoError(tb, set.Set(flags.DeletePublicKeysFlag.Name, cfg.deletePublicKeys))
+	assert.NoError(tb, set.Set(flags.VoluntaryExitPublicKeysFlag.Name, cfg.voluntaryExitPublicKeys))
+	assert.NoError(tb, set.Set(flags.BackupDirFlag.Name, cfg.backupDir))
+	assert.NoError(tb, set.Set(flags.BackupPublicKeysFlag.Name, cfg.backupPublicKeys))
+	assert.NoError(tb, set.Set(flags.BackupPasswordFile.Name, cfg.backupPasswordFile))
+	assert.NoError(tb, set.Set(flags.WalletPasswordFileFlag.Name, cfg.walletPasswordFile))
+	assert.NoError(tb, set.Set(flags.AccountPasswordFileFlag.Name, cfg.accountPasswordFile))
+	assert.NoError(tb, set.Set(flags.NumAccountsFlag.Name, strconv.Itoa(int(cfg.numAccounts))))
+	assert.NoError(tb, set.Set(flags.SkipDepositConfirmationFlag.Name, strconv.FormatBool(cfg.skipDepositConfirm)))
+	assert.NoError(tb, set.Set(flags.ExitAllFlag.Name, strconv.FormatBool(cfg.exitAll)))
+	assert.NoError(tb, set.Set(flags.GrpcHeadersFlag.Name, cfg.grpcHeaders))
+	return cli.NewContext(&app, set, nil)
+}
+
 func init() {
 	logrus.SetLevel(logrus.DebugLevel)
 	logrus.SetOutput(io.Discard)
@@ -137,57 +219,6 @@ func TestCreateWallet_WalletAlreadyExists(t *testing.T) {
 	require.ErrorContains(t, "already exists", err)
 }
 
-func TestCreateWallet_Remote(t *testing.T) {
-	walletDir, _, walletPasswordFile := setupWalletAndPasswordsDir(t)
-	wantCfg := &remote.KeymanagerOpts{
-		RemoteCertificate: &remote.CertificateConfig{
-			RequireTls:     true,
-			ClientCertPath: "/tmp/client.crt",
-			ClientKeyPath:  "/tmp/client.key",
-			CACertPath:     "/tmp/ca.crt",
-		},
-		RemoteAddr: "host.example.com:4000",
-	}
-	app := cli.App{}
-	set := flag.NewFlagSet("test", 0)
-	keymanagerKind := "remote"
-	set.String(flags.WalletDirFlag.Name, walletDir, "")
-	set.String(flags.WalletPasswordFileFlag.Name, walletDir, "")
-	set.String(flags.KeymanagerKindFlag.Name, keymanagerKind, "")
-	set.String(flags.GrpcRemoteAddressFlag.Name, wantCfg.RemoteAddr, "")
-	set.String(flags.RemoteSignerCertPathFlag.Name, wantCfg.RemoteCertificate.ClientCertPath, "")
-	set.String(flags.RemoteSignerKeyPathFlag.Name, wantCfg.RemoteCertificate.ClientKeyPath, "")
-	set.String(flags.RemoteSignerCACertPathFlag.Name, wantCfg.RemoteCertificate.CACertPath, "")
-	assert.NoError(t, set.Set(flags.WalletDirFlag.Name, walletDir))
-	assert.NoError(t, set.Set(flags.WalletPasswordFileFlag.Name, walletPasswordFile))
-	assert.NoError(t, set.Set(flags.KeymanagerKindFlag.Name, keymanagerKind))
-	assert.NoError(t, set.Set(flags.GrpcRemoteAddressFlag.Name, wantCfg.RemoteAddr))
-	assert.NoError(t, set.Set(flags.RemoteSignerCertPathFlag.Name, wantCfg.RemoteCertificate.ClientCertPath))
-	assert.NoError(t, set.Set(flags.RemoteSignerKeyPathFlag.Name, wantCfg.RemoteCertificate.ClientKeyPath))
-	assert.NoError(t, set.Set(flags.RemoteSignerCACertPathFlag.Name, wantCfg.RemoteCertificate.CACertPath))
-	cliCtx := cli.NewContext(&app, set, nil)
-
-	// We attempt to create the wallet.
-	_, err := CreateAndSaveWalletCli(cliCtx)
-	require.NoError(t, err)
-
-	// We attempt to open the newly created wallet.
-	ctx := context.Background()
-	w, err := wallet.OpenWallet(cliCtx.Context, &wallet.Config{
-		WalletDir: walletDir,
-	})
-	assert.NoError(t, err)
-
-	// We read the keymanager config for the newly created wallet.
-	encoded, err := w.ReadKeymanagerConfigFromDisk(ctx)
-	assert.NoError(t, err)
-	cfg, err := remote.UnmarshalOptionsFile(encoded)
-	assert.NoError(t, err)
-
-	// We assert the created configuration was as desired.
-	assert.DeepEqual(t, wantCfg, cfg)
-}
-
 func TestInputKeymanagerKind(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -219,18 +250,6 @@ func TestInputKeymanagerKind(t *testing.T) {
 			want:    keymanager.Derived,
 			wantErr: false,
 		},
-		{
-			name:    "remote returns remote kind",
-			args:    "remote",
-			want:    keymanager.Remote,
-			wantErr: false,
-		},
-		{
-			name:    "REMOTE (capitalized) returns remote kind",
-			args:    "REMOTE",
-			want:    keymanager.Remote,
-			wantErr: false,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {