capella state version detection bug fix

In the event we receive a BLS_TO_EXECUTION_CHANGE and our head state is
before Capella, verify it's signature with the Capella fork version.

DEPENDENCIES.md

@@ -1,4 +1,4 @@
-# Dependency Management in Prysm
+# Dependency Managagement in Prysm
 
 Prysm is go project with many complicated dependencies, including some c++ based libraries. There
 are two parts to Prysm's dependency management. Go modules and bazel managed dependencies. Be sure 
@@ -28,7 +28,7 @@ including complicated c++ dependencies.
 One key advantage of Bazel over vanilla `go build` is that Bazel automatically (re)builds generated
 pb.go files at build time when file changes are present in any protobuf definition file or after
 any updates to the protobuf compiler or other relevant dependencies. Vanilla go users should run
-the following scripts often to ensure their generated files are up to date. Furthermore, Prysm
+the following scripts often to ensure their generated files are up to date. Further more, Prysm
 generates SSZ marshal related code based on defined data structures. These generated files must
 also be updated and checked in as frequently.
 

WORKSPACE

@@ -188,7 +188,7 @@ filegroup(
     url = "https://github.com/eth-clients/slashing-protection-interchange-tests/archive/b8413ca42dc92308019d0d4db52c87e9e125c4e9.tar.gz",
 )
 
-consensus_spec_version = "v1.3.0-rc.1"
+consensus_spec_version = "v1.3.0-rc.0"
 
 bls_test_version = "v0.1.1"
 
@@ -204,7 +204,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "3d6fadb64674eb64a84fae6c2efa9949231ea91e7cb74ada9214097323e86569",
+    #sha256 = "a92c41058dc17ced811cc85570cd6f8af761aedfcbd2dd7dd4fb64ac961d76f9",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -220,7 +220,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "54ffbcab1e77316a280e6f5a64c6ed62351e8f5678e6fa49340e49b9b5575e8e",
+    #sha256 = "49a7944da92429ac8f41347f19837762247cdbf00e628c285d1b826e58e4096d",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -236,7 +236,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "bb06d30ca533dc97d45f2367916ba9ff1b5af52f08a9d8c33bb7b1a61254094e",
+    #sha256 = "d19673e9cd55e0c8d45eefc33b60978e14c166d0e891976fcaa114085312adcb",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -251,7 +251,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    sha256 = "9d22246c00ec3907ef8dc3ddccdfe6f7153ce46df73deee0a0176fe7e4aa1126",
+    #sha256 = "a72b7457c403f6b76567d4d7bec19d01bedf7d5ef1d6f2c3a9e09ee86d401a14",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/beacon/client.go

@@ -28,14 +28,13 @@ import (
 )
 
 const (
-	getSignedBlockPath       = "/eth/v2/beacon/blocks"
-	getBlockRootPath         = "/eth/v1/beacon/blocks/{{.Id}}/root"
-	getForkForStatePath      = "/eth/v1/beacon/states/{{.Id}}/fork"
-	getWeakSubjectivityPath  = "/eth/v1/beacon/weak_subjectivity"
-	getForkSchedulePath      = "/eth/v1/config/fork_schedule"
-	getStatePath             = "/eth/v2/debug/beacon/states"
-	getNodeVersionPath       = "/eth/v1/node/version"
-	changeBLStoExecutionPath = "/eth/v1/beacon/pool/bls_to_execution_changes"
+	getSignedBlockPath      = "/eth/v2/beacon/blocks"
+	getBlockRootPath        = "/eth/v1/beacon/blocks/{{.Id}}/root"
+	getForkForStatePath     = "/eth/v1/beacon/states/{{.Id}}/fork"
+	getWeakSubjectivityPath = "/eth/v1/beacon/weak_subjectivity"
+	getForkSchedulePath     = "/eth/v1/config/fork_schedule"
+	getStatePath            = "/eth/v2/debug/beacon/states"
+	getNodeVersionPath      = "/eth/v1/node/version"
 )
 
 // StateOrBlockId represents the block_id / state_id parameters that several of the Eth Beacon API methods accept.
@@ -147,6 +146,7 @@ func withSSZEncoding() reqOption {
 // get is a generic, opinionated GET function to reduce boilerplate amongst the getters in this package.
 func (c *Client) get(ctx context.Context, path string, opts ...reqOption) ([]byte, error) {
 	u := c.baseURL.ResolveReference(&url.URL{Path: path})
+	log.Printf("requesting %s", u.String())
 	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
 	if err != nil {
 		return nil, err
@@ -343,60 +343,6 @@ func (c *Client) GetWeakSubjectivity(ctx context.Context) (*WeakSubjectivityData
 	}, nil
 }
 
-// SubmitChangeBLStoExecution calls a beacon API endpoint to set the withdrawal addresses based on the given signed messages.
-// If the API responds with something other than OK there will be failure messages associated to the corresponding request message.
-func (c *Client) SubmitChangeBLStoExecution(ctx context.Context, request []*apimiddleware.SignedBLSToExecutionChangeJson) error {
-	u := c.baseURL.ResolveReference(&url.URL{Path: changeBLStoExecutionPath})
-	body, err := json.Marshal(request)
-	if err != nil {
-		return errors.Wrap(err, "failed to marshal JSON")
-	}
-	req, err := http.NewRequestWithContext(ctx, http.MethodPost, u.String(), bytes.NewBuffer(body))
-	if err != nil {
-		return errors.Wrap(err, "invalid format, failed to create new POST request object")
-	}
-	req.Header.Set("Content-Type", "application/json")
-	resp, err := c.hc.Do(req)
-	if err != nil {
-		return err
-	}
-	defer func() {
-		err = resp.Body.Close()
-	}()
-	if resp.StatusCode != http.StatusOK {
-		decoder := json.NewDecoder(resp.Body)
-		decoder.DisallowUnknownFields()
-		errorJson := &apimiddleware.IndexedVerificationFailureErrorJson{}
-		if err := decoder.Decode(errorJson); err != nil {
-			return errors.Wrapf(err, "failed to decode error JSON for %s", resp.Request.URL)
-		}
-		for _, failure := range errorJson.Failures {
-			w := request[failure.Index].Message
-			log.WithFields(log.Fields{
-				"validator_index":    w.ValidatorIndex,
-				"withdrawal_address": w.ToExecutionAddress,
-			}).Error(failure.Message)
-		}
-		return errors.Errorf("POST error %d: %s", errorJson.Code, errorJson.Message)
-	}
-	return nil
-}
-
-// GetBLStoExecutionChanges gets all the set withdrawal messages in the node's operation pool.
-// Returns a struct representation of json response.
-func (c *Client) GetBLStoExecutionChanges(ctx context.Context) (*apimiddleware.BLSToExecutionChangesPoolResponseJson, error) {
-	body, err := c.get(ctx, changeBLStoExecutionPath)
-	if err != nil {
-		return nil, err
-	}
-	poolResponse := &apimiddleware.BLSToExecutionChangesPoolResponseJson{}
-	err = json.Unmarshal(body, poolResponse)
-	if err != nil {
-		return nil, err
-	}
-	return poolResponse, nil
-}
-
 func non200Err(response *http.Response) error {
 	bodyBytes, err := io.ReadAll(response.Body)
 	var body string

beacon-chain/blockchain/pow_block.go

@@ -49,13 +49,9 @@ func (s *Service) validateMergeBlock(ctx context.Context, b interfaces.SignedBea
 	if payload.IsNil() {
 		return errors.New("nil execution payload")
 	}
-	ok, err := canUseValidatedTerminalBlockHash(b.Block().Slot(), payload)
-	if err != nil {
+	if err := validateTerminalBlockHash(b.Block().Slot(), payload); err != nil {
 		return errors.Wrap(err, "could not validate terminal block hash")
 	}
-	if ok {
-		return nil
-	}
 	mergeBlockParentHash, mergeBlockTD, err := s.getBlkParentHashAndTD(ctx, payload.ParentHash())
 	if err != nil {
 		return errors.Wrap(err, "could not get merge block parent hash and total difficulty")
@@ -109,7 +105,7 @@ func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]
 	return blk.ParentHash[:], blkTDUint256, nil
 }
 
-// canUseValidatedTerminalBlockHash validates if the merge block is a valid terminal PoW block.
+// validateTerminalBlockHash validates if the merge block is a valid terminal PoW block.
 // spec code:
 // if TERMINAL_BLOCK_HASH != Hash32():
 //
@@ -117,17 +113,17 @@ func (s *Service) getBlkParentHashAndTD(ctx context.Context, blkHash []byte) ([]
 //	assert compute_epoch_at_slot(block.slot) >= TERMINAL_BLOCK_HASH_ACTIVATION_EPOCH
 //	assert block.body.execution_payload.parent_hash == TERMINAL_BLOCK_HASH
 //	return
-func canUseValidatedTerminalBlockHash(blkSlot types.Slot, payload interfaces.ExecutionData) (bool, error) {
+func validateTerminalBlockHash(blkSlot types.Slot, payload interfaces.ExecutionData) error {
 	if bytesutil.ToBytes32(params.BeaconConfig().TerminalBlockHash.Bytes()) == [32]byte{} {
-		return false, nil
+		return nil
 	}
 	if params.BeaconConfig().TerminalBlockHashActivationEpoch > slots.ToEpoch(blkSlot) {
-		return false, errors.New("terminal block hash activation epoch not reached")
+		return errors.New("terminal block hash activation epoch not reached")
 	}
 	if !bytes.Equal(payload.ParentHash(), params.BeaconConfig().TerminalBlockHash.Bytes()) {
-		return false, errors.New("parent hash does not match terminal block hash")
+		return errors.New("parent hash does not match terminal block hash")
 	}
-	return true, nil
+	return nil
 }
 
 // validateTerminalBlockDifficulties validates terminal pow block by comparing own total difficulty with parent's total difficulty.

beacon-chain/blockchain/pow_block_test.go

@@ -18,7 +18,6 @@ import (
 	enginev1 "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
-	"github.com/prysmaticlabs/prysm/v3/testing/util"
 )
 
 func Test_validTerminalPowBlock(t *testing.T) {
@@ -214,42 +213,20 @@ func Test_getBlkParentHashAndTD(t *testing.T) {
 func Test_validateTerminalBlockHash(t *testing.T) {
 	wrapped, err := blocks.WrappedExecutionPayload(&enginev1.ExecutionPayload{})
 	require.NoError(t, err)
-	ok, err := canUseValidatedTerminalBlockHash(1, wrapped)
-	require.NoError(t, err)
-	require.Equal(t, false, ok)
+	require.NoError(t, validateTerminalBlockHash(1, wrapped))
 
 	cfg := params.BeaconConfig()
 	cfg.TerminalBlockHash = [32]byte{0x01}
 	params.OverrideBeaconConfig(cfg)
-	ok, err = canUseValidatedTerminalBlockHash(1, wrapped)
-	require.ErrorContains(t, "terminal block hash activation epoch not reached", err)
-	require.Equal(t, false, ok)
+	require.ErrorContains(t, "terminal block hash activation epoch not reached", validateTerminalBlockHash(1, wrapped))
 
 	cfg.TerminalBlockHashActivationEpoch = 0
 	params.OverrideBeaconConfig(cfg)
-	ok, err = canUseValidatedTerminalBlockHash(1, wrapped)
-	require.ErrorContains(t, "parent hash does not match terminal block hash", err)
-	require.Equal(t, false, ok)
+	require.ErrorContains(t, "parent hash does not match terminal block hash", validateTerminalBlockHash(1, wrapped))
 
 	wrapped, err = blocks.WrappedExecutionPayload(&enginev1.ExecutionPayload{
 		ParentHash: cfg.TerminalBlockHash.Bytes(),
 	})
 	require.NoError(t, err)
-	ok, err = canUseValidatedTerminalBlockHash(1, wrapped)
-	require.NoError(t, err)
-	require.Equal(t, true, ok)
-
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB, doublylinkedtree.New())),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-	blk, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&ethpb.SignedBeaconBlockBellatrix{}))
-	require.NoError(t, err)
-	blk.Block().SetSlot(1)
-	require.NoError(t, blk.Block().Body().SetExecution(wrapped))
-	require.NoError(t, service.validateMergeBlock(ctx, blk))
+	require.NoError(t, validateTerminalBlockHash(1, wrapped))
 }

beacon-chain/blockchain/process_block.go

@@ -557,6 +557,22 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Be
 	return nil
 }
 
+func (s *Service) handleBlockBLSToExecChanges(blk interfaces.BeaconBlock) error {
+	if blk.Version() < version.Capella {
+		return nil
+	}
+	changes, err := blk.Body().BLSToExecutionChanges()
+	if err != nil {
+		return errors.Wrap(err, "could not get BLSToExecutionChanges")
+	}
+	for _, change := range changes {
+		if err := s.cfg.BLSToExecPool.MarkIncluded(change); err != nil {
+			return errors.Wrap(err, "could not mark BLSToExecutionChange as included")
+		}
+	}
+	return nil
+}
+
 // InsertSlashingsToForkChoiceStore inserts attester slashing indices to fork choice store.
 // To call this function, it's caller's responsibility to ensure the slashing object is valid.
 func (s *Service) InsertSlashingsToForkChoiceStore(ctx context.Context, slashings []*ethpb.AttesterSlashing) {

beacon-chain/blockchain/process_block_helpers.go

@@ -68,6 +68,7 @@ func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.BeaconBloc
 	// during initial syncing. There's no risk given a state summary object is just a
 	// a subset of the block object.
 	if !s.cfg.BeaconDB.HasStateSummary(ctx, parentRoot) && !s.cfg.BeaconDB.HasBlock(ctx, parentRoot) {
+		log.Errorf("requesting blockroot %#x", bytesutil.Trunc(parentRoot[:]))
 		return errors.New("could not reconstruct parent state")
 	}
 

beacon-chain/blockchain/process_block_test.go

@@ -26,6 +26,7 @@ import (
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state/stategen"
 	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
@@ -2304,6 +2305,65 @@ func TestFillMissingBlockPayloadId_DiffSlotExitEarly(t *testing.T) {
 	require.NoError(t, service.fillMissingBlockPayloadId(ctx, time.Unix(int64(params.BeaconConfig().SecondsPerSlot/2), 0)))
 }
 
+func TestHandleBBlockBLSToExecutionChanges(t *testing.T) {
+	ctx := context.Background()
+	beaconDB := testDB.SetupDB(t)
+	fc := doublylinkedtree.New()
+	pool := blstoexec.NewPool()
+	opts := []Option{
+		WithDatabase(beaconDB),
+		WithStateGen(stategen.New(beaconDB, fc)),
+		WithForkChoiceStore(fc),
+		WithStateNotifier(&mock.MockStateNotifier{}),
+		WithBLSToExecPool(pool),
+	}
+	service, err := NewService(ctx, opts...)
+	require.NoError(t, err)
+
+	t.Run("pre Capella block", func(t *testing.T) {
+		body := &ethpb.BeaconBlockBodyBellatrix{}
+		pbb := &ethpb.BeaconBlockBellatrix{
+			Body: body,
+		}
+		blk, err := consensusblocks.NewBeaconBlock(pbb)
+		require.NoError(t, err)
+		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
+	})
+
+	t.Run("Post Capella no changes", func(t *testing.T) {
+		body := &ethpb.BeaconBlockBodyCapella{}
+		pbb := &ethpb.BeaconBlockCapella{
+			Body: body,
+		}
+		blk, err := consensusblocks.NewBeaconBlock(pbb)
+		require.NoError(t, err)
+		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
+	})
+
+	t.Run("Post Capella some changes", func(t *testing.T) {
+		idx := types.ValidatorIndex(123)
+		change := &ethpb.BLSToExecutionChange{
+			ValidatorIndex: idx,
+		}
+		signedChange := &ethpb.SignedBLSToExecutionChange{
+			Message: change,
+		}
+		body := &ethpb.BeaconBlockBodyCapella{
+			BlsToExecutionChanges: []*ethpb.SignedBLSToExecutionChange{signedChange},
+		}
+		pbb := &ethpb.BeaconBlockCapella{
+			Body: body,
+		}
+		blk, err := consensusblocks.NewBeaconBlock(pbb)
+		require.NoError(t, err)
+
+		pool.InsertBLSToExecChange(signedChange)
+		require.Equal(t, true, pool.ValidatorExists(idx))
+		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
+		require.Equal(t, false, pool.ValidatorExists(idx))
+	})
+}
+
 // Helper function to simulate the block being on time or delayed for proposer
 // boost. It alters the genesisTime tracked by the store.
 func driftGenesisTime(s *Service, slot int64, delay int64) {

beacon-chain/blockchain/receive_block.go

@@ -10,7 +10,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 	"github.com/prysmaticlabs/prysm/v3/time"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
 	"go.opencensus.io/trace"
@@ -151,11 +150,6 @@ func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
 		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 {
-		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() {
 		s.cfg.SlashingPool.MarkIncludedAttesterSlashing(as)
@@ -163,20 +157,6 @@ func (s *Service) handlePostBlockOperations(b interfaces.BeaconBlock) error {
 	return nil
 }
 
-func (s *Service) handleBlockBLSToExecChanges(blk interfaces.BeaconBlock) error {
-	if blk.Version() < version.Capella {
-		return nil
-	}
-	changes, err := blk.Body().BLSToExecutionChanges()
-	if err != nil {
-		return errors.Wrap(err, "could not get BLSToExecutionChanges")
-	}
-	for _, change := range changes {
-		s.cfg.BLSToExecPool.MarkIncluded(change)
-	}
-	return nil
-}
-
 // This checks whether it's time to start saving hot state to DB.
 // It's time when there's `epochsSinceFinalitySaveHotStateDB` epochs of non-finality.
 func (s *Service) checkSaveHotStateDB(ctx context.Context) error {

beacon-chain/blockchain/receive_block_test.go

@@ -10,7 +10,6 @@ import (
 	testDB "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/attestations"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/voluntaryexits"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
@@ -333,62 +332,3 @@ func TestCheckSaveHotStateDB_Overflow(t *testing.T) {
 	require.NoError(t, s.checkSaveHotStateDB(context.Background()))
 	assert.LogsDoNotContain(t, hook, "Entering mode to save hot states in DB")
 }
-
-func TestHandleBlockBLSToExecutionChanges(t *testing.T) {
-	ctx := context.Background()
-	beaconDB := testDB.SetupDB(t)
-	fc := doublylinkedtree.New()
-	pool := blstoexec.NewPool()
-	opts := []Option{
-		WithDatabase(beaconDB),
-		WithStateGen(stategen.New(beaconDB, fc)),
-		WithForkChoiceStore(fc),
-		WithStateNotifier(&blockchainTesting.MockStateNotifier{}),
-		WithBLSToExecPool(pool),
-	}
-	service, err := NewService(ctx, opts...)
-	require.NoError(t, err)
-
-	t.Run("pre Capella block", func(t *testing.T) {
-		body := &ethpb.BeaconBlockBodyBellatrix{}
-		pbb := &ethpb.BeaconBlockBellatrix{
-			Body: body,
-		}
-		blk, err := blocks.NewBeaconBlock(pbb)
-		require.NoError(t, err)
-		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
-	})
-
-	t.Run("Post Capella no changes", func(t *testing.T) {
-		body := &ethpb.BeaconBlockBodyCapella{}
-		pbb := &ethpb.BeaconBlockCapella{
-			Body: body,
-		}
-		blk, err := blocks.NewBeaconBlock(pbb)
-		require.NoError(t, err)
-		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
-	})
-
-	t.Run("Post Capella some changes", func(t *testing.T) {
-		idx := types.ValidatorIndex(123)
-		change := &ethpb.BLSToExecutionChange{
-			ValidatorIndex: idx,
-		}
-		signedChange := &ethpb.SignedBLSToExecutionChange{
-			Message: change,
-		}
-		body := &ethpb.BeaconBlockBodyCapella{
-			BlsToExecutionChanges: []*ethpb.SignedBLSToExecutionChange{signedChange},
-		}
-		pbb := &ethpb.BeaconBlockCapella{
-			Body: body,
-		}
-		blk, err := blocks.NewBeaconBlock(pbb)
-		require.NoError(t, err)
-
-		pool.InsertBLSToExecChange(signedChange)
-		require.Equal(t, true, pool.ValidatorExists(idx))
-		require.NoError(t, service.handleBlockBLSToExecChanges(blk))
-		require.Equal(t, false, pool.ValidatorExists(idx))
-	})
-}

beacon-chain/core/altair/upgrade.go

@@ -67,10 +67,6 @@ func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.Beacon
 	epoch := time.CurrentEpoch(state)
 
 	numValidators := state.NumValidators()
-	hrs, err := state.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
 	s := &ethpb.BeaconStateAltair{
 		GenesisTime:           state.GenesisTime(),
 		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
@@ -83,7 +79,7 @@ func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.Beacon
 		LatestBlockHeader:           state.LatestBlockHeader(),
 		BlockRoots:                  state.BlockRoots(),
 		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             hrs,
+		HistoricalRoots:             state.HistoricalRoots(),
 		Eth1Data:                    state.Eth1Data(),
 		Eth1DataVotes:               state.Eth1DataVotes(),
 		Eth1DepositIndex:            state.Eth1DepositIndex(),

beacon-chain/core/altair/upgrade_test.go

@@ -82,11 +82,7 @@ func TestUpgradeToAltair(t *testing.T) {
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), aState.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), aState.BlockRoots())
 	require.DeepSSZEqual(t, preForkState.StateRoots(), aState.StateRoots())
-	r1, err := preForkState.HistoricalRoots()
-	require.NoError(t, err)
-	r2, err := aState.HistoricalRoots()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, r1, r2)
+	require.DeepSSZEqual(t, preForkState.HistoricalRoots(), aState.HistoricalRoots())
 	require.DeepSSZEqual(t, preForkState.Eth1Data(), aState.Eth1Data())
 	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), aState.Eth1DataVotes())
 	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), aState.Eth1DepositIndex())

beacon-chain/core/blocks/exit_test.go

@@ -131,118 +131,3 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 			helpers.ActivationExitEpoch(types.Epoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch)), newRegistry[0].ExitEpoch)
 	}
 }
-
-func TestVerifyExitAndSignature(t *testing.T) {
-	type args struct {
-		currentSlot types.Slot
-	}
-
-	tests := []struct {
-		name    string
-		args    args
-		setup   func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error)
-		wantErr string
-	}{
-		{
-			name: "Empty Exit",
-			args: args{
-				currentSlot: 0,
-			},
-			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error) {
-				fork := &ethpb.Fork{
-					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-					CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-					Epoch:           0,
-				}
-				genesisRoot := [32]byte{'a'}
-				return &ethpb.Validator{}, &ethpb.SignedVoluntaryExit{}, fork, genesisRoot[:], nil
-			},
-			wantErr: "nil exit",
-		},
-		{
-			name: "Happy Path",
-			args: args{
-				currentSlot: (params.BeaconConfig().SlotsPerEpoch * 2) + 1,
-			},
-			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error) {
-				fork := &ethpb.Fork{
-					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-					CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-					Epoch:           0,
-				}
-				signedExit := &ethpb.SignedVoluntaryExit{
-					Exit: &ethpb.VoluntaryExit{
-						Epoch:          2,
-						ValidatorIndex: 0,
-					},
-				}
-				bs, keys := util.DeterministicGenesisState(t, 1)
-				validator := bs.Validators()[0]
-				validator.ActivationEpoch = 1
-				err := bs.UpdateValidatorAtIndex(0, validator)
-				require.NoError(t, err)
-				sb, err := signing.ComputeDomainAndSign(bs, signedExit.Exit.Epoch, signedExit.Exit, params.BeaconConfig().DomainVoluntaryExit, keys[0])
-				require.NoError(t, err)
-				sig, err := bls.SignatureFromBytes(sb)
-				require.NoError(t, err)
-				signedExit.Signature = sig.Marshal()
-				return validator, signedExit, fork, bs.GenesisValidatorsRoot(), nil
-			},
-		},
-		{
-			name: "bad signature",
-			args: args{
-				currentSlot: (params.BeaconConfig().SlotsPerEpoch * 2) + 1,
-			},
-			setup: func() (*ethpb.Validator, *ethpb.SignedVoluntaryExit, *ethpb.Fork, []byte, error) {
-				fork := &ethpb.Fork{
-					PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-					CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-					Epoch:           0,
-				}
-				signedExit := &ethpb.SignedVoluntaryExit{
-					Exit: &ethpb.VoluntaryExit{
-						Epoch:          2,
-						ValidatorIndex: 0,
-					},
-				}
-				bs, keys := util.DeterministicGenesisState(t, 1)
-				validator := bs.Validators()[0]
-				validator.ActivationEpoch = 1
-
-				sb, err := signing.ComputeDomainAndSign(bs, signedExit.Exit.Epoch, signedExit.Exit, params.BeaconConfig().DomainVoluntaryExit, keys[0])
-				require.NoError(t, err)
-				sig, err := bls.SignatureFromBytes(sb)
-				require.NoError(t, err)
-				signedExit.Signature = sig.Marshal()
-				genesisRoot := [32]byte{'a'}
-				// use wrong genesis root and don't update validator
-				return validator, signedExit, fork, genesisRoot[:], nil
-			},
-			wantErr: "signature did not verify",
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			c := params.BeaconConfig().ShardCommitteePeriod
-			params.BeaconConfig().ShardCommitteePeriod = 0
-			validator, signedExit, fork, genesisRoot, err := tt.setup()
-			require.NoError(t, err)
-			rvalidator, err := state_native.NewValidator(validator)
-			require.NoError(t, err)
-			err = blocks.VerifyExitAndSignature(
-				rvalidator,
-				tt.args.currentSlot,
-				fork,
-				signedExit,
-				genesisRoot,
-			)
-			if tt.wantErr == "" {
-				require.NoError(t, err)
-			} else {
-				require.ErrorContains(t, tt.wantErr, err)
-			}
-			params.BeaconConfig().ShardCommitteePeriod = c // prevent contamination
-		})
-	}
-}

beacon-chain/core/blocks/exports_test.go

@@ -1,3 +1,4 @@
 package blocks
 
 var ProcessBLSToExecutionChange = processBLSToExecutionChange
+var BLSChangesSigningDomain = blsChangesSigningDomain

beacon-chain/core/blocks/genesis.go

@@ -37,7 +37,7 @@ func NewGenesisBlock(stateRoot []byte) *ethpb.SignedBeaconBlock {
 	return block
 }
 
-var ErrUnrecognizedState = errors.New("unknown underlying type for state.BeaconState value")
+var ErrUnrecognizedState = errors.New("uknonwn underlying type for state.BeaconState value")
 
 func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfaces.SignedBeaconBlock, error) {
 	root, err := st.HashTreeRoot(ctx)
@@ -113,38 +113,6 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
-	case *ethpb.BeaconStateCapella:
-		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockCapella{
-			Block: &ethpb.BeaconBlockCapella{
-				ParentRoot: params.BeaconConfig().ZeroHash[:],
-				StateRoot:  root[:],
-				Body: &ethpb.BeaconBlockBodyCapella{
-					RandaoReveal: make([]byte, 96),
-					Eth1Data: &ethpb.Eth1Data{
-						DepositRoot: make([]byte, 32),
-						BlockHash:   make([]byte, 32),
-					},
-					Graffiti: make([]byte, 32),
-					SyncAggregate: &ethpb.SyncAggregate{
-						SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
-						SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
-					},
-					ExecutionPayload: &enginev1.ExecutionPayloadCapella{
-						ParentHash:    make([]byte, 32),
-						FeeRecipient:  make([]byte, 20),
-						StateRoot:     make([]byte, 32),
-						ReceiptsRoot:  make([]byte, 32),
-						LogsBloom:     make([]byte, 256),
-						PrevRandao:    make([]byte, 32),
-						BaseFeePerGas: make([]byte, 32),
-						BlockHash:     make([]byte, 32),
-						Transactions:  make([][]byte, 0),
-						Withdrawals:   make([]*enginev1.Withdrawal, 0),
-					},
-				},
-			},
-			Signature: params.BeaconConfig().EmptySignature[:],
-		})
 	default:
 		return nil, ErrUnrecognizedState
 	}

beacon-chain/core/blocks/payload.go

@@ -133,6 +133,7 @@ func ValidatePayloadWhenMergeCompletes(st state.BeaconState, payload interfaces.
 		return err
 	}
 	if !bytes.Equal(payload.ParentHash(), header.BlockHash()) {
+		log.Errorf("parent Hash %#x,  header Hash: %#x", bytesutil.Trunc(payload.ParentHash()), bytesutil.Trunc(header.BlockHash()))
 		return ErrInvalidPayloadBlockHash
 	}
 	return nil

beacon-chain/core/blocks/withdrawals.go

@@ -17,6 +17,7 @@ import (
 	ethpbv2 "github.com/prysmaticlabs/prysm/v3/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/runtime/version"
+	"github.com/prysmaticlabs/prysm/v3/time/slots"
 )
 
 const executionToBLSPadding = 12
@@ -161,6 +162,25 @@ func ProcessWithdrawals(st state.BeaconState, withdrawals []*enginev1.Withdrawal
 	return st, nil
 }
 
+// blsChangesSigningDomain returns the signing domain to check  BLSToExecutionChange messages against.
+func blsChangesSigningDomain(st state.ReadOnlyBeaconState) ([]byte, error) {
+	var epoch types.Epoch
+	var fork *ethpb.Fork
+	if st.Version() < version.Capella {
+		epoch = params.BeaconConfig().CapellaForkEpoch
+		fork = &ethpb.Fork{
+			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
+			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
+			Epoch:           epoch,
+		}
+
+	} else {
+		epoch = slots.ToEpoch(st.Slot())
+		fork = st.Fork()
+	}
+	return signing.Domain(fork, epoch, params.BeaconConfig().DomainBLSToExecutionChange, st.GenesisValidatorsRoot())
+}
+
 func BLSChangesSignatureBatch(
 	st state.ReadOnlyBeaconState,
 	changes []*ethpb.SignedBLSToExecutionChange,
@@ -175,10 +195,9 @@ func BLSChangesSignatureBatch(
 		Messages:     make([][32]byte, len(changes)),
 		Descriptions: make([]string, len(changes)),
 	}
-	c := params.BeaconConfig()
-	domain, err := signing.ComputeDomain(c.DomainBLSToExecutionChange, c.GenesisForkVersion, st.GenesisValidatorsRoot())
+	domain, err := blsChangesSigningDomain(st)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not compute signing domain")
+		return nil, err
 	}
 	for i, change := range changes {
 		batch.Signatures[i] = change.Signature
@@ -204,8 +223,7 @@ func VerifyBLSChangeSignature(
 	st state.BeaconState,
 	change *ethpbv2.SignedBLSToExecutionChange,
 ) error {
-	c := params.BeaconConfig()
-	domain, err := signing.ComputeDomain(c.DomainBLSToExecutionChange, c.GenesisForkVersion, st.GenesisValidatorsRoot())
+	domain, err := blsChangesSigningDomain(st)
 	if err != nil {
 		return errors.Wrap(err, "could not compute signing domain")
 	}

beacon-chain/core/blocks/withdrawals_test.go

@@ -791,71 +791,6 @@ func TestBLSChangesSignatureBatch(t *testing.T) {
 	require.NoError(t, blocks.VerifyBLSChangeSignature(st, change))
 }
 
-func TestBLSChangesSignatureBatchWrongFork(t *testing.T) {
-	spb := &ethpb.BeaconStateCapella{
-		Fork: &ethpb.Fork{
-			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
-			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
-			Epoch:           params.BeaconConfig().CapellaForkEpoch,
-		},
-	}
-	numValidators := 10
-	validators := make([]*ethpb.Validator, numValidators)
-	blsChanges := make([]*ethpb.BLSToExecutionChange, numValidators)
-	spb.Balances = make([]uint64, numValidators)
-	privKeys := make([]common.SecretKey, numValidators)
-	maxEffectiveBalance := params.BeaconConfig().MaxEffectiveBalance
-	executionAddress := []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13}
-
-	for i := range validators {
-		v := &ethpb.Validator{}
-		v.EffectiveBalance = maxEffectiveBalance
-		v.WithdrawableEpoch = params.BeaconConfig().FarFutureEpoch
-		v.WithdrawalCredentials = make([]byte, 32)
-		priv, err := bls.RandKey()
-		require.NoError(t, err)
-		privKeys[i] = priv
-		pubkey := priv.PublicKey().Marshal()
-
-		message := &ethpb.BLSToExecutionChange{
-			ToExecutionAddress: executionAddress,
-			ValidatorIndex:     types.ValidatorIndex(i),
-			FromBlsPubkey:      pubkey,
-		}
-
-		hashFn := ssz.NewHasherFunc(hash.CustomSHA256Hasher())
-		digest := hashFn.Hash(pubkey)
-		digest[0] = params.BeaconConfig().BLSWithdrawalPrefixByte
-		copy(v.WithdrawalCredentials, digest[:])
-		validators[i] = v
-		blsChanges[i] = message
-	}
-	spb.Validators = validators
-	st, err := state_native.InitializeFromProtoCapella(spb)
-	require.NoError(t, err)
-
-	signedChanges := make([]*ethpb.SignedBLSToExecutionChange, numValidators)
-	for i, message := range blsChanges {
-		signature, err := signing.ComputeDomainAndSign(st, time.CurrentEpoch(st), message, params.BeaconConfig().DomainBLSToExecutionChange, privKeys[i])
-		require.NoError(t, err)
-
-		signed := &ethpb.SignedBLSToExecutionChange{
-			Message:   message,
-			Signature: signature,
-		}
-		signedChanges[i] = signed
-	}
-	batch, err := blocks.BLSChangesSignatureBatch(st, signedChanges)
-	require.NoError(t, err)
-	verify, err := batch.Verify()
-	require.NoError(t, err)
-	require.Equal(t, false, verify)
-
-	// Verify a single change
-	change := migration.V1Alpha1SignedBLSToExecChangeToV2(signedChanges[0])
-	require.ErrorIs(t, signing.ErrSigFailedToVerify, blocks.VerifyBLSChangeSignature(st, change))
-}
-
 func TestBLSChangesSignatureBatchFromBellatrix(t *testing.T) {
 	cfg := params.BeaconConfig()
 	savedConfig := cfg.Copy()
@@ -912,7 +847,7 @@ func TestBLSChangesSignatureBatchFromBellatrix(t *testing.T) {
 	spc := &ethpb.BeaconStateCapella{
 		Fork: &ethpb.Fork{
 			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
 			Epoch:           params.BeaconConfig().CapellaForkEpoch,
 		},
 	}
@@ -924,7 +859,7 @@ func TestBLSChangesSignatureBatchFromBellatrix(t *testing.T) {
 	require.NoError(t, err)
 
 	for i, message := range blsChanges {
-		signature, err := signing.ComputeDomainAndSign(stc, 0, message, params.BeaconConfig().DomainBLSToExecutionChange, privKeys[i])
+		signature, err := signing.ComputeDomainAndSign(stc, time.CurrentEpoch(stc), message, params.BeaconConfig().DomainBLSToExecutionChange, privKeys[i])
 		require.NoError(t, err)
 
 		signed := &ethpb.SignedBLSToExecutionChange{
@@ -944,3 +879,51 @@ func TestBLSChangesSignatureBatchFromBellatrix(t *testing.T) {
 	require.NoError(t, blocks.VerifyBLSChangeSignature(st, change))
 	params.OverrideBeaconConfig(savedConfig)
 }
+
+func TestBLSChangesSigningDomain(t *testing.T) {
+	cfg := params.BeaconConfig()
+	savedConfig := cfg.Copy()
+	cfg.CapellaForkEpoch = cfg.BellatrixForkEpoch.AddEpoch(2)
+	params.OverrideBeaconConfig(cfg)
+	capellaDomain := []byte{0xa, 0x0, 0x0, 0x0, 0xe7, 0xb4, 0xbb, 0x67, 0x55, 0x1d, 0xde, 0x95, 0x89, 0xc1, 0x55, 0x3d, 0xfd, 0xa3, 0x7a, 0x94, 0x2a, 0x18, 0xca, 0xf1, 0x84, 0xf9, 0xcc, 0x16, 0x29, 0xd2, 0x5c, 0xf5}
+
+	t.Run("pre-Capella fork", func(t *testing.T) {
+		spb := &ethpb.BeaconStateBellatrix{
+			Fork: &ethpb.Fork{
+				CurrentVersion:  params.BeaconConfig().BellatrixForkVersion,
+				PreviousVersion: params.BeaconConfig().AltairForkVersion,
+				Epoch:           params.BeaconConfig().BellatrixForkEpoch,
+			},
+		}
+		slot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+		require.NoError(t, err)
+		spb.Slot = slot
+
+		st, err := state_native.InitializeFromProtoBellatrix(spb)
+		require.NoError(t, err)
+
+		domain, err := blocks.BLSChangesSigningDomain(st)
+		require.NoError(t, err)
+		require.DeepEqual(t, capellaDomain, domain)
+	})
+	t.Run("post-Capella fork", func(t *testing.T) {
+		spb := &ethpb.BeaconStateCapella{
+			Fork: &ethpb.Fork{
+				CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
+				PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
+				Epoch:           params.BeaconConfig().CapellaForkEpoch,
+			},
+		}
+		slot, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
+		require.NoError(t, err)
+		spb.Slot = slot
+
+		st, err := state_native.InitializeFromProtoCapella(spb)
+		require.NoError(t, err)
+
+		domain, err := blocks.BLSChangesSigningDomain(st)
+		require.NoError(t, err)
+		require.DeepEqual(t, capellaDomain, domain)
+	})
+	params.OverrideBeaconConfig(savedConfig)
+}

beacon-chain/core/capella/upgrade.go

@@ -42,10 +42,6 @@ func UpgradeToCapella(state state.BeaconState) (state.BeaconState, error) {
 		return nil, err
 	}
 
-	hrs, err := state.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
 	s := &ethpb.BeaconStateCapella{
 		GenesisTime:           state.GenesisTime(),
 		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
@@ -58,7 +54,7 @@ func UpgradeToCapella(state state.BeaconState) (state.BeaconState, error) {
 		LatestBlockHeader:           state.LatestBlockHeader(),
 		BlockRoots:                  state.BlockRoots(),
 		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             hrs,
+		HistoricalRoots:             state.HistoricalRoots(),
 		Eth1Data:                    state.Eth1Data(),
 		Eth1DataVotes:               state.Eth1DataVotes(),
 		Eth1DepositIndex:            state.Eth1DepositIndex(),
@@ -94,7 +90,6 @@ func UpgradeToCapella(state state.BeaconState) (state.BeaconState, error) {
 		},
 		NextWithdrawalIndex:          0,
 		NextWithdrawalValidatorIndex: 0,
-		HistoricalSummaries:          make([]*ethpb.HistoricalSummary, 0),
 	}
 
 	return state_native.InitializeFromProtoUnsafeCapella(s)

beacon-chain/core/capella/upgrade_test.go

@@ -25,6 +25,7 @@ func TestUpgradeToCapella(t *testing.T) {
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
 	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
+	require.DeepSSZEqual(t, preForkState.HistoricalRoots(), mSt.HistoricalRoots())
 	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
 	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
 	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())
@@ -97,8 +98,4 @@ func TestUpgradeToCapella(t *testing.T) {
 	lwvi, err := mSt.NextWithdrawalValidatorIndex()
 	require.NoError(t, err)
 	require.Equal(t, types.ValidatorIndex(0), lwvi)
-
-	summaries, err := mSt.HistoricalSummaries()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(summaries))
 }

beacon-chain/core/epoch/epoch_processing.go

@@ -353,7 +353,7 @@ func ProcessRandaoMixesReset(state state.BeaconState) (state.BeaconState, error)
 }
 
 // ProcessHistoricalDataUpdate processes the updates to historical data during epoch processing.
-// From Capella onward, per spec,state's historical summaries are updated instead of historical roots.
+// For Capella state, per spec, historical summaries is updated instead of historical roots.
 func ProcessHistoricalDataUpdate(state state.BeaconState) (state.BeaconState, error) {
 	currentEpoch := time.CurrentEpoch(state)
 	nextEpoch := currentEpoch + 1
@@ -370,7 +370,7 @@ func ProcessHistoricalDataUpdate(state state.BeaconState) (state.BeaconState, er
 			if err != nil {
 				return nil, err
 			}
-			if err := state.AppendHistoricalSummaries(&ethpb.HistoricalSummary{BlockSummaryRoot: br[:], StateSummaryRoot: sr[:]}); err != nil {
+			if err := state.AppendHistoricalSummariesUpdate(&ethpb.HistoricalSummary{BlockSummaryRoot: br[:], StateSummaryRoot: sr[:]}); err != nil {
 				return nil, err
 			}
 		} else {

beacon-chain/core/epoch/epoch_processing_test.go

@@ -276,9 +276,7 @@ func TestProcessFinalUpdates_CanProcess(t *testing.T) {
 	assert.DeepNotEqual(t, params.BeaconConfig().ZeroHash[:], mix, "latest RANDAO still zero hashes")
 
 	// Verify historical root accumulator was appended.
-	roots, err := newS.HistoricalRoots()
-	require.NoError(t, err)
-	assert.Equal(t, 1, len(roots), "Unexpected slashed balance")
+	assert.Equal(t, 1, len(newS.HistoricalRoots()), "Unexpected slashed balance")
 	currAtt, err := newS.CurrentEpochAttestations()
 	require.NoError(t, err)
 	assert.NotNil(t, currAtt, "Nil value stored in current epoch attestations instead of empty slice")
@@ -460,7 +458,7 @@ func TestProcessSlashings_BadValue(t *testing.T) {
 	require.ErrorContains(t, "addition overflows", err)
 }
 
-func TestProcessHistoricalDataUpdate(t *testing.T) {
+func TestProcessHistoricalRootsUpdate(t *testing.T) {
 	tests := []struct {
 		name     string
 		st       func() state.BeaconState
@@ -473,9 +471,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 				return st
 			},
 			verifier: func(st state.BeaconState) {
-				roots, err := st.HistoricalRoots()
-				require.NoError(t, err)
-				require.Equal(t, 0, len(roots))
+				require.Equal(t, 0, len(st.HistoricalRoots()))
 			},
 		},
 		{
@@ -487,9 +483,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 				return st
 			},
 			verifier: func(st state.BeaconState) {
-				roots, err := st.HistoricalRoots()
-				require.NoError(t, err)
-				require.Equal(t, 1, len(roots))
+				require.Equal(t, 1, len(st.HistoricalRoots()))
 
 				b := &ethpb.HistoricalBatch{
 					BlockRoots: st.BlockRoots(),
@@ -497,10 +491,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 				}
 				r, err := b.HashTreeRoot()
 				require.NoError(t, err)
-				require.DeepEqual(t, r[:], roots[0])
-
-				_, err = st.HistoricalSummaries()
-				require.ErrorContains(t, "HistoricalSummaries is not supported for phase0", err)
+				require.DeepEqual(t, r[:], st.HistoricalRoots()[0])
 			},
 		},
 		{
@@ -512,9 +503,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 				return st
 			},
 			verifier: func(st state.BeaconState) {
-				summaries, err := st.HistoricalSummaries()
-				require.NoError(t, err)
-				require.Equal(t, 1, len(summaries))
+				require.Equal(t, 1, len(st.HistoricalSummaries()))
 
 				br, err := stateutil.ArraysRoot(st.BlockRoots(), fieldparams.BlockRootsLength)
 				require.NoError(t, err)
@@ -524,10 +513,7 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 					BlockSummaryRoot: br[:],
 					StateSummaryRoot: sr[:],
 				}
-				require.DeepEqual(t, b, summaries[0])
-				hrs, err := st.HistoricalRoots()
-				require.NoError(t, err)
-				require.DeepEqual(t, hrs, [][]byte{})
+				require.DeepEqual(t, b, st.HistoricalSummaries()[0])
 			},
 		},
 	}

beacon-chain/core/execution/upgrade.go

@@ -35,10 +35,6 @@ func UpgradeToBellatrix(state state.BeaconState) (state.BeaconState, error) {
 		return nil, err
 	}
 
-	hrs, err := state.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
 	s := &ethpb.BeaconStateBellatrix{
 		GenesisTime:           state.GenesisTime(),
 		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
@@ -51,7 +47,7 @@ func UpgradeToBellatrix(state state.BeaconState) (state.BeaconState, error) {
 		LatestBlockHeader:           state.LatestBlockHeader(),
 		BlockRoots:                  state.BlockRoots(),
 		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             hrs,
+		HistoricalRoots:             state.HistoricalRoots(),
 		Eth1Data:                    state.Eth1Data(),
 		Eth1DataVotes:               state.Eth1DataVotes(),
 		Eth1DepositIndex:            state.Eth1DepositIndex(),

beacon-chain/core/execution/upgrade_test.go

@@ -24,11 +24,7 @@ func TestUpgradeToBellatrix(t *testing.T) {
 	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
 	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
 	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
-	r1, err := preForkState.HistoricalRoots()
-	require.NoError(t, err)
-	r2, err := mSt.HistoricalRoots()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, r1, r2)
+	require.DeepSSZEqual(t, preForkState.HistoricalRoots(), mSt.HistoricalRoots())
 	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
 	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
 	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())

beacon-chain/core/feed/operation/events.go

@@ -19,9 +19,6 @@ const (
 
 	// SyncCommitteeContributionReceived is sent after a sync committee contribution object has been received.
 	SyncCommitteeContributionReceived
-
-	// BLSToExecutionChangeReceived is sent after a BLS to execution change object has been received from gossip or rpc.
-	BLSToExecutionChangeReceived
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -47,8 +44,3 @@ type SyncCommitteeContributionReceivedData struct {
 	// Contribution is the sync committee contribution object.
 	Contribution *ethpb.SignedContributionAndProof
 }
-
-// BLSToExecutionChangeReceivedData is the data sent with BLSToExecutionChangeReceived events.
-type BLSToExecutionChangeReceivedData struct {
-	Change *ethpb.SignedBLSToExecutionChange
-}

beacon-chain/db/kv/genesis_test.go

@@ -2,14 +2,12 @@ package kv
 
 import (
 	"context"
-	"encoding/hex"
 	"os"
 	"testing"
 
 	"github.com/bazelbuild/rules_go/go/tools/bazel"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db/iface"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
-	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/testing/util"
@@ -50,37 +48,6 @@ func testGenesisDataSaved(t *testing.T, db iface.Database) {
 	require.Equal(t, gbHTR, headHTR, "head block does not match genesis block")
 }
 
-func TestLoadCapellaFromFile(t *testing.T) {
-	cfg, err := params.ByName(params.MainnetName)
-	require.NoError(t, err)
-	// This state fixture is from a hive testnet, `0a` is the suffix they are using in their fork versions.
-	suffix, err := hex.DecodeString("0a")
-	require.NoError(t, err)
-	require.Equal(t, 1, len(suffix))
-	reversioned := cfg.Copy()
-	params.FillTestVersions(reversioned, suffix[0])
-	reversioned.CapellaForkEpoch = 0
-	require.Equal(t, [4]byte{3, 0, 0, 10}, bytesutil.ToBytes4(reversioned.CapellaForkVersion))
-	reversioned.ConfigName = "capella-genesis-test"
-	undo, err := params.SetActiveWithUndo(reversioned)
-	require.NoError(t, err)
-	defer func() {
-		require.NoError(t, undo())
-	}()
-
-	fp := "testdata/capella_genesis.ssz"
-	rfp, err := bazel.Runfile(fp)
-	if err == nil {
-		fp = rfp
-	}
-	sb, err := os.ReadFile(fp)
-	require.NoError(t, err)
-
-	db := setupDB(t)
-	require.NoError(t, db.LoadGenesis(context.Background(), sb))
-	testGenesisDataSaved(t, db)
-}
-
 func TestLoadGenesisFromFile(t *testing.T) {
 	// for this test to work, we need the active config to have these properties:
 	// - fork version schedule that matches mainnnet.genesis.ssz
@@ -90,7 +57,7 @@ func TestLoadGenesisFromFile(t *testing.T) {
 	// uses the mainnet fork schedule. construct the differently named mainnet config and set it active.
 	// finally, revert all this at the end of the test.
 
-	// first get the real mainnet out of the way by overwriting its schedule.
+	// first get the real mainnet out of the way by overwriting it schedule.
 	cfg, err := params.ByName(params.MainnetName)
 	require.NoError(t, err)
 	cfg = cfg.Copy()

beacon-chain/execution/engine_client.go

@@ -86,8 +86,6 @@ type EngineCaller interface {
 	GetTerminalBlockHash(ctx context.Context, transitionTime uint64) ([]byte, bool, error)
 }
 
-var EmptyBlockHash = errors.New("Block hash is empty 0x0000...")
-
 // NewPayload calls the engine_newPayloadVX method via JSON-RPC.
 func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionData) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.NewPayload")
@@ -473,10 +471,6 @@ func (s *Service) ReconstructFullBlock(
 	if executionBlock == nil {
 		return nil, fmt.Errorf("received nil execution block for request by hash %#x", executionBlockHash)
 	}
-	if bytes.Equal(executionBlock.Hash.Bytes(), []byte{}) {
-		return nil, EmptyBlockHash
-	}
-
 	executionBlock.Version = blindedBlock.Version()
 	payload, err := fullPayloadFromExecutionBlock(header, executionBlock)
 	if err != nil {

beacon-chain/execution/engine_client_test.go

@@ -54,7 +54,6 @@ func (RPCClientBad) CallContext(context.Context, interface{}, string, ...interfa
 }
 
 func TestClient_IPC(t *testing.T) {
-	t.Skip("Skipping IPC test to support Capella devnet-3")
 	server := newTestIPCServer(t)
 	defer server.Stop()
 	rpcClient := rpc.DialInProc(server)
@@ -148,15 +147,13 @@ func TestClient_IPC(t *testing.T) {
 		want, ok := fix["ExecutionBlock"].(*pb.ExecutionBlock)
 		require.Equal(t, true, ok)
 		arg := common.BytesToHash([]byte("foo"))
-		resp, err := srv.ExecutionBlockByHash(ctx, arg, true /* with txs */)
+		resp, err := srv.ExecutionBlockByHash(ctx, version.Bellatrix, arg, true /* with txs */)
 		require.NoError(t, err)
 		require.DeepEqual(t, want, resp)
 	})
 }
 
 func TestClient_HTTP(t *testing.T) {
-	t.Skip("Skipping HTTP test to support Capella devnet-3")
-
 	ctx := context.Background()
 	fix := fixtures()
 
@@ -621,7 +618,7 @@ func TestClient_HTTP(t *testing.T) {
 		service.rpcClient = rpcClient
 
 		// We call the RPC method via HTTP and expect a proper result.
-		resp, err := service.ExecutionBlockByHash(ctx, arg, true /* with txs */)
+		resp, err := service.ExecutionBlockByHash(ctx, version.Bellatrix, arg, true /* with txs */)
 		require.NoError(t, err)
 		require.DeepEqual(t, want, resp)
 	})

beacon-chain/execution/testing/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -15,7 +15,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	pb "github.com/prysmaticlabs/prysm/v3/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/v3/time/slots"
 )
 
 // EngineClient --
@@ -24,7 +23,6 @@ type EngineClient struct {
 	PayloadIDBytes              *pb.PayloadIDBytes
 	ForkChoiceUpdatedResp       []byte
 	ExecutionPayload            *pb.ExecutionPayload
-	ExecutionPayloadCapella     *pb.ExecutionPayloadCapella
 	ExecutionBlock              *pb.ExecutionBlock
 	Err                         error
 	ErrLatestExecBlock          error
@@ -56,10 +54,7 @@ func (e *EngineClient) ForkchoiceUpdated(
 }
 
 // GetPayload --
-func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, s types.Slot) (interfaces.ExecutionData, error) {
-	if slots.ToEpoch(s) >= params.BeaconConfig().CapellaForkEpoch {
-		return blocks.WrappedExecutionPayloadCapella(e.ExecutionPayloadCapella)
-	}
+func (e *EngineClient) GetPayload(_ context.Context, _ [8]byte, _ types.Slot) (interfaces.ExecutionData, error) {
 	p, err := blocks.WrappedExecutionPayload(e.ExecutionPayload)
 	if err != nil {
 		return nil, err

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

@@ -120,16 +120,16 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             |
 	//             3
 	//             |
-	//             4
+	//             4 <- head
 	//            /
-	//           5 <- head, justified epoch = 2
+	//           5 <- justified epoch = 2
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 2)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	r, err = f.Head(context.Background(), balances)
 	require.NoError(t, err)
-	assert.Equal(t, indexToHash(5), r, "Incorrect head for with justified epoch at 2")
+	assert.Equal(t, indexToHash(5), r, "Incorrect head for with justified epoch at 1")
 
 	// Insert block 6 with justified epoch 3: verify it's head
 	//            0
@@ -138,15 +138,15 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//             |
 	//             3
 	//             |
-	//             4
+	//             4 <- head
 	//            / \
-	//           5  6 <- head, justified epoch = 3
+	//           5  6 <- justified epoch = 3
 	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(6), indexToHash(4), params.BeaconConfig().ZeroHash, 3, 2)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background(), balances)
 	require.NoError(t, err)
-	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 3")
+	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 1")
 
 	// Moved 2 votes to block 5:
 	f.ProcessAttestation(context.Background(), []uint64{0, 1}, indexToHash(5), 4)
@@ -174,10 +174,10 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background(), balances)
 	require.NoError(t, err)
-	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 3")
+	assert.Equal(t, indexToHash(6), r, "Incorrect head for with justified epoch at 1")
 
-	// Insert block 10 with justified epoch 3, it becomes head
-	// Verify 10 is the head:
+	// Insert block 9 with justified epoch 3, it becomes head
+	// Verify 9 is the head:
 	//            0
 	//           / \
 	//          2  1
@@ -289,7 +289,7 @@ func TestVotes_CanFindHead(t *testing.T) {
 
 	r, err = f.Head(context.Background(), balances)
 	require.NoError(t, err)
-	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 3")
+	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 2")
 
 	// Insert new block 11 and verify head is at 11.
 	//          5   6

beacon-chain/node/node.go

@@ -448,11 +448,6 @@ func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context) error {
 		return nil
 	}
 	baseDir := cliCtx.String(cmd.DataDirFlag.Name)
-
-	if cliCtx.IsSet(flags.SlasherDirFlag.Name) {
-		baseDir = cliCtx.String(flags.SlasherDirFlag.Name)
-	}
-
 	dbPath := filepath.Join(baseDir, kv.BeaconNodeDbDirName)
 	clearDB := cliCtx.Bool(cmd.ClearDB.Name)
 	forceClearDB := cliCtx.Bool(cmd.ForceClearDB.Name)

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

@@ -52,8 +52,8 @@ func (c *AttCaches) SaveUnaggregatedAttestations(atts []*ethpb.Attestation) erro
 
 // UnaggregatedAttestations returns all the unaggregated attestations in cache.
 func (c *AttCaches) UnaggregatedAttestations() ([]*ethpb.Attestation, error) {
-	c.unAggregateAttLock.RLock()
-	defer c.unAggregateAttLock.RUnlock()
+	c.unAggregateAttLock.Lock()
+	defer c.unAggregateAttLock.Unlock()
 	unAggregatedAtts := c.unAggregatedAtt
 	atts := make([]*ethpb.Attestation, 0, len(unAggregatedAtts))
 	for _, att := range unAggregatedAtts {

beacon-chain/operations/attestations/prune_expired.go

@@ -59,8 +59,8 @@ func (s *Service) pruneExpiredAtts() {
 			if err := s.cfg.Pool.DeleteBlockAttestation(att); err != nil {
 				log.WithError(err).Error("Could not delete expired block attestation")
 			}
-			expiredBlockAtts.Inc()
 		}
+		expiredBlockAtts.Inc()
 	}
 }
 

beacon-chain/operations/blstoexec/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "//container/doubly-linked-list:go_default_library",
         "//crypto/bls/blst: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/operations/blstoexec/mock/mock.go

@@ -17,7 +17,7 @@ func (m *PoolMock) PendingBLSToExecChanges() ([]*eth.SignedBLSToExecutionChange,
 }
 
 // BLSToExecChangesForInclusion --
-func (m *PoolMock) BLSToExecChangesForInclusion(_ state.ReadOnlyBeaconState) ([]*eth.SignedBLSToExecutionChange, error) {
+func (m *PoolMock) BLSToExecChangesForInclusion(_ state.BeaconState) ([]*eth.SignedBLSToExecutionChange, error) {
 	return m.Changes, nil
 }
 
@@ -27,7 +27,7 @@ func (m *PoolMock) InsertBLSToExecChange(change *eth.SignedBLSToExecutionChange)
 }
 
 // MarkIncluded --
-func (*PoolMock) MarkIncluded(_ *eth.SignedBLSToExecutionChange) {
+func (*PoolMock) MarkIncluded(_ *eth.SignedBLSToExecutionChange) error {
 	panic("implement me")
 }
 

beacon-chain/operations/blstoexec/pool.go

@@ -4,6 +4,7 @@ import (
 	"math"
 	"sync"
 
+	"github.com/pkg/errors"
 	"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,9 +19,9 @@ import (
 // This pool is used by proposers to insert BLS-to-execution-change objects into new blocks.
 type PoolManager interface {
 	PendingBLSToExecChanges() ([]*ethpb.SignedBLSToExecutionChange, error)
-	BLSToExecChangesForInclusion(beaconState state.ReadOnlyBeaconState) ([]*ethpb.SignedBLSToExecutionChange, error)
+	BLSToExecChangesForInclusion(state.BeaconState) ([]*ethpb.SignedBLSToExecutionChange, error)
 	InsertBLSToExecChange(change *ethpb.SignedBLSToExecutionChange)
-	MarkIncluded(change *ethpb.SignedBLSToExecutionChange)
+	MarkIncluded(change *ethpb.SignedBLSToExecutionChange) error
 	ValidatorExists(idx types.ValidatorIndex) bool
 }
 
@@ -60,13 +61,13 @@ func (p *Pool) PendingBLSToExecChanges() ([]*ethpb.SignedBLSToExecutionChange, e
 	return result, nil
 }
 
-// BLSToExecChangesForInclusion returns objects that are ready for inclusion.
+// BLSToExecChangesForInclusion returns objects that are ready for inclusion at the given slot.
 // This method will not return more than the block enforced MaxBlsToExecutionChanges.
-func (p *Pool) BLSToExecChangesForInclusion(st state.ReadOnlyBeaconState) ([]*ethpb.SignedBLSToExecutionChange, error) {
+func (p *Pool) BLSToExecChangesForInclusion(st state.BeaconState) ([]*ethpb.SignedBLSToExecutionChange, error) {
 	p.lock.RLock()
 	length := int(math.Min(float64(params.BeaconConfig().MaxBlsToExecutionChanges), float64(p.pending.Len())))
 	result := make([]*ethpb.SignedBLSToExecutionChange, 0, length)
-	node := p.pending.Last()
+	node := p.pending.First()
 	for node != nil && len(result) < length {
 		change, err := node.Value()
 		if err != nil {
@@ -78,12 +79,14 @@ func (p *Pool) BLSToExecChangesForInclusion(st state.ReadOnlyBeaconState) ([]*et
 			logrus.WithError(err).Warning("removing invalid BLSToExecutionChange from pool")
 			// MarkIncluded removes the invalid change from the pool
 			p.lock.RUnlock()
-			p.MarkIncluded(change)
+			if err := p.MarkIncluded(change); err != nil {
+				return nil, errors.Wrap(err, "could not mark BLSToExecutionChange as included")
+			}
 			p.lock.RLock()
 		} else {
 			result = append(result, change)
 		}
-		node, err = node.Prev()
+		node, err = node.Next()
 		if err != nil {
 			p.lock.RUnlock()
 			return nil, err
@@ -115,7 +118,9 @@ func (p *Pool) BLSToExecChangesForInclusion(st state.ReadOnlyBeaconState) ([]*et
 		}
 		if !signature.Verify(cSet.PublicKeys[i], cSet.Messages[i][:]) {
 			logrus.Warning("removing BLSToExecutionChange with invalid signature from pool")
-			p.MarkIncluded(result[i])
+			if err := p.MarkIncluded(result[i]); err != nil {
+				return nil, errors.Wrap(err, "could not mark BLSToExecutionChange as included")
+			}
 		} else {
 			verified = append(verified, result[i])
 		}
@@ -138,18 +143,19 @@ func (p *Pool) InsertBLSToExecChange(change *ethpb.SignedBLSToExecutionChange) {
 }
 
 // MarkIncluded is used when an object has been included in a beacon block. Every block seen by this
-// node should call this method to include the object. This will remove the object from the pool.
-func (p *Pool) MarkIncluded(change *ethpb.SignedBLSToExecutionChange) {
+// listNode should call this method to include the object. This will remove the object from the pool.
+func (p *Pool) MarkIncluded(change *ethpb.SignedBLSToExecutionChange) error {
 	p.lock.Lock()
 	defer p.lock.Unlock()
 
 	node := p.m[change.Message.ValidatorIndex]
 	if node == nil {
-		return
+		return nil
 	}
 
 	delete(p.m, change.Message.ValidatorIndex)
 	p.pending.Remove(node)
+	return nil
 }
 
 // ValidatorExists checks if the bls to execution change object exists

beacon-chain/operations/blstoexec/pool_test.go

@@ -130,7 +130,7 @@ func TestBLSToExecChangesForInclusion(t *testing.T) {
 		// We want FIFO semantics, which means validator with index 16 shouldn't be returned
 		assert.Equal(t, int(params.BeaconConfig().MaxBlsToExecutionChanges), len(changes))
 		for _, ch := range changes {
-			assert.NotEqual(t, types.ValidatorIndex(15), ch.Message.ValidatorIndex)
+			assert.NotEqual(t, types.ValidatorIndex(16), ch.Message.ValidatorIndex)
 		}
 	})
 	t.Run("One Bad change", func(t *testing.T) {
@@ -143,19 +143,19 @@ func TestBLSToExecChangesForInclusion(t *testing.T) {
 		changes, err := pool.BLSToExecChangesForInclusion(st)
 		require.NoError(t, err)
 		assert.Equal(t, int(params.BeaconConfig().MaxBlsToExecutionChanges), len(changes))
-		assert.Equal(t, types.ValidatorIndex(30), changes[1].Message.ValidatorIndex)
+		assert.Equal(t, types.ValidatorIndex(2), changes[1].Message.ValidatorIndex)
 		signedChanges[1].Message.FromBlsPubkey[5] = saveByte
 	})
 	t.Run("One Bad Signature", func(t *testing.T) {
 		pool := NewPool()
-		copy(signedChanges[30].Signature, signedChanges[31].Signature)
+		copy(signedChanges[1].Signature, signedChanges[2].Signature)
 		for i := uint64(0); i < numValidators; i++ {
 			pool.InsertBLSToExecChange(signedChanges[i])
 		}
 		changes, err := pool.BLSToExecChangesForInclusion(st)
 		require.NoError(t, err)
 		assert.Equal(t, int(params.BeaconConfig().MaxBlsToExecutionChanges)-1, len(changes))
-		assert.Equal(t, types.ValidatorIndex(29), changes[1].Message.ValidatorIndex)
+		assert.Equal(t, types.ValidatorIndex(2), changes[1].Message.ValidatorIndex)
 	})
 }
 
@@ -237,7 +237,7 @@ func TestMarkIncluded(t *testing.T) {
 				ValidatorIndex: types.ValidatorIndex(0),
 			}}
 		pool.InsertBLSToExecChange(change)
-		pool.MarkIncluded(change)
+		require.NoError(t, pool.MarkIncluded(change))
 		assert.Equal(t, 0, pool.pending.Len())
 		_, ok := pool.m[0]
 		assert.Equal(t, false, ok)
@@ -259,7 +259,7 @@ func TestMarkIncluded(t *testing.T) {
 		pool.InsertBLSToExecChange(first)
 		pool.InsertBLSToExecChange(second)
 		pool.InsertBLSToExecChange(third)
-		pool.MarkIncluded(first)
+		require.NoError(t, pool.MarkIncluded(first))
 		require.Equal(t, 2, pool.pending.Len())
 		_, ok := pool.m[0]
 		assert.Equal(t, false, ok)
@@ -281,7 +281,7 @@ func TestMarkIncluded(t *testing.T) {
 		pool.InsertBLSToExecChange(first)
 		pool.InsertBLSToExecChange(second)
 		pool.InsertBLSToExecChange(third)
-		pool.MarkIncluded(third)
+		require.NoError(t, pool.MarkIncluded(third))
 		require.Equal(t, 2, pool.pending.Len())
 		_, ok := pool.m[2]
 		assert.Equal(t, false, ok)
@@ -303,7 +303,7 @@ func TestMarkIncluded(t *testing.T) {
 		pool.InsertBLSToExecChange(first)
 		pool.InsertBLSToExecChange(second)
 		pool.InsertBLSToExecChange(third)
-		pool.MarkIncluded(second)
+		require.NoError(t, pool.MarkIncluded(second))
 		require.Equal(t, 2, pool.pending.Len())
 		_, ok := pool.m[1]
 		assert.Equal(t, false, ok)
@@ -324,7 +324,7 @@ func TestMarkIncluded(t *testing.T) {
 			}}
 		pool.InsertBLSToExecChange(first)
 		pool.InsertBLSToExecChange(second)
-		pool.MarkIncluded(change)
+		require.NoError(t, pool.MarkIncluded(change))
 		require.Equal(t, 2, pool.pending.Len())
 		_, ok := pool.m[0]
 		require.Equal(t, true, ok)
@@ -378,7 +378,7 @@ func TestValidatorExists(t *testing.T) {
 				ValidatorIndex: types.ValidatorIndex(0),
 			}}
 		pool.InsertBLSToExecChange(change)
-		pool.MarkIncluded(change)
+		require.NoError(t, pool.MarkIncluded(change))
 		assert.Equal(t, false, pool.ValidatorExists(0))
 	})
 	t.Run("multiple validators added to pool and removed", func(t *testing.T) {
@@ -399,8 +399,8 @@ func TestValidatorExists(t *testing.T) {
 			}}
 		pool.InsertBLSToExecChange(thirdChange)
 
-		pool.MarkIncluded(firstChange)
-		pool.MarkIncluded(thirdChange)
+		assert.NoError(t, pool.MarkIncluded(firstChange))
+		assert.NoError(t, pool.MarkIncluded(thirdChange))
 
 		assert.Equal(t, false, pool.ValidatorExists(0))
 		assert.Equal(t, true, pool.ValidatorExists(10))

beacon-chain/rpc/apimiddleware/custom_handlers.go

@@ -416,8 +416,6 @@ func receiveEvents(eventChan <-chan *sse.Event, w http.ResponseWriter, req *http
 				data = &EventChainReorgJson{}
 			case events.SyncCommitteeContributionTopic:
 				data = &SignedContributionAndProofJson{}
-			case events.BLSToExecutionChangeTopic:
-				data = &SignedBLSToExecutionChangeJson{}
 			case "error":
 				data = &EventErrorJson{}
 			default:

beacon-chain/rpc/apimiddleware/endpoint_factory.go

@@ -166,7 +166,6 @@ func (_ *BeaconEndpointFactory) Create(path string) (*apimiddleware.Endpoint, er
 	case "/eth/v1/beacon/pool/bls_to_execution_changes":
 		endpoint.PostRequest = &SubmitBLSToExecutionChangesRequest{}
 		endpoint.GetResponse = &BLSToExecutionChangesPoolResponseJson{}
-		endpoint.Err = &IndexedVerificationFailureErrorJson{}
 		endpoint.Hooks = apimiddleware.HookCollection{
 			OnPreDeserializeRequestBodyIntoContainer: wrapBLSChangesArray,
 		}

beacon-chain/rpc/apimiddleware/structs.go

@@ -864,7 +864,6 @@ type BeaconStateCapellaJson struct {
 	LatestExecutionPayloadHeader *ExecutionPayloadHeaderCapellaJson `json:"latest_execution_payload_header"`
 	NextWithdrawalIndex          string                             `json:"next_withdrawal_index"`
 	NextWithdrawalValidatorIndex string                             `json:"next_withdrawal_validator_index"`
-	HistoricalSummaries          []*HistoricalSummaryJson           `json:"historical_summaries"`
 }
 
 type BeaconStateContainerV2Json struct {
@@ -1038,11 +1037,6 @@ type ForkChoiceDumpJson struct {
 	ForkChoiceNodes               []*ForkChoiceNodeJson `json:"fork_choice_nodes"`
 }
 
-type HistoricalSummaryJson struct {
-	BlockSummaryRoot string `json:"block_summary_root" hex:"true"`
-	StateSummaryRoot string `json:"state_summary_root" hex:"true"`
-}
-
 //----------------
 // SSZ
 // ---------------

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

@@ -115,7 +115,6 @@ go_test(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
-        "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/service:go_default_library",
         "//proto/eth/v1:go_default_library",

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

@@ -142,25 +142,32 @@ func (bs *Server) SubmitBlindedBlock(ctx context.Context, req *ethpbv2.SignedBli
 	ctx, span := trace.StartSpan(ctx, "beacon.SubmitBlindedBlock")
 	defer span.End()
 
-	switch blkContainer := req.Message.(type) {
-	case *ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock:
-		if err := bs.submitBlindedCapellaBlock(ctx, blkContainer.CapellaBlock, req.Signature); err != nil {
+	capellaBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock)
+	if ok {
+		if err := bs.submitBlindedCapellaBlock(ctx, capellaBlkContainer.CapellaBlock, req.Signature); err != nil {
 			return nil, err
 		}
-	case *ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock:
-		if err := bs.submitBlindedBellatrixBlock(ctx, blkContainer.BellatrixBlock, req.Signature); err != nil {
+	}
+
+	bellatrixBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock)
+	if ok {
+		if err := bs.submitBlindedBellatrixBlock(ctx, bellatrixBlkContainer.BellatrixBlock, req.Signature); err != nil {
 			return nil, err
 		}
-	case *ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block:
-		if err := bs.submitPhase0Block(ctx, blkContainer.Phase0Block, req.Signature); err != nil {
+	}
+
+	// At the end we check forks that don't have blinded blocks.
+	phase0BlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block)
+	if ok {
+		if err := bs.submitPhase0Block(ctx, phase0BlkContainer.Phase0Block, req.Signature); err != nil {
 			return nil, err
 		}
-	case *ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock:
-		if err := bs.submitAltairBlock(ctx, blkContainer.AltairBlock, req.Signature); err != nil {
+	}
+	altairBlkContainer, ok := req.Message.(*ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock)
+	if ok {
+		if err := bs.submitAltairBlock(ctx, altairBlkContainer.AltairBlock, req.Signature); err != nil {
 			return nil, err
 		}
-	default:
-		return nil, status.Errorf(codes.InvalidArgument, "Unsupported block container type %T", blkContainer)
 	}
 
 	return &emptypb.Empty{}, nil

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

@@ -1195,3 +1195,555 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		assert.NoError(t, err)
 	})
 }
+
+func TestServer_GetBlindedBlockSSZ(t *testing.T) {
+	t.Run("Phase 0", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		_, blkContainers := fillDBTestBlocks(ctx, t, beaconDB)
+		headBlock := blkContainers[len(blkContainers)-1]
+
+		b2 := util.NewBeaconBlock()
+		b2.Block.Slot = 30
+		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
+		util.SaveBlock(t, ctx, beaconDB, b2)
+
+		wsb, err := blocks.NewSignedBeaconBlock(headBlock.Block.(*ethpbalpha.BeaconBlockContainer_Phase0Block).Phase0Block)
+		require.NoError(t, err)
+
+		bs := &Server{
+			BeaconDB: beaconDB,
+			ChainInfoFetcher: &mock.ChainService{
+				DB:                  beaconDB,
+				Block:               wsb,
+				Root:                headBlock.BlockRoot,
+				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			},
+		}
+
+		blks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blks) > 0)
+		require.NoError(t, err)
+		sszBlock, err := blks[0].MarshalSSZ()
+		require.NoError(t, err)
+
+		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{BlockId: []byte("30")})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, sszBlock, resp.Data)
+		assert.Equal(t, ethpbv2.Version_PHASE0, resp.Version)
+	})
+
+	t.Run("Altair", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		_, blkContainers := fillDBTestBlocksAltair(ctx, t, beaconDB)
+		headBlock := blkContainers[len(blkContainers)-1]
+
+		b2 := util.NewBeaconBlockAltair()
+		b2.Block.Slot = 30
+		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
+		util.SaveBlock(t, ctx, beaconDB, b2)
+
+		chainBlk, err := blocks.NewSignedBeaconBlock(headBlock.GetAltairBlock())
+		require.NoError(t, err)
+		bs := &Server{
+			BeaconDB: beaconDB,
+			ChainInfoFetcher: &mock.ChainService{
+				DB:                  beaconDB,
+				Block:               chainBlk,
+				Root:                headBlock.BlockRoot,
+				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			},
+		}
+
+		blks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blks) > 0)
+		require.NoError(t, err)
+		sszBlock, err := blks[0].MarshalSSZ()
+		require.NoError(t, err)
+
+		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{BlockId: []byte("30")})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, sszBlock, resp.Data)
+		assert.Equal(t, ethpbv2.Version_ALTAIR, resp.Version)
+	})
+
+	t.Run("Bellatrix", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		_, blkContainers := fillDBTestBlocksBellatrixBlinded(ctx, t, beaconDB)
+		headBlock := blkContainers[len(blkContainers)-1]
+
+		b2 := util.NewBlindedBeaconBlockBellatrix()
+		b2.Block.Slot = 30
+		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
+		util.SaveBlock(t, ctx, beaconDB, b2)
+
+		chainBlk, err := blocks.NewSignedBeaconBlock(headBlock.GetBlindedBellatrixBlock())
+		require.NoError(t, err)
+		bs := &Server{
+			BeaconDB: beaconDB,
+			ChainInfoFetcher: &mock.ChainService{
+				DB:                  beaconDB,
+				Block:               chainBlk,
+				Root:                headBlock.BlockRoot,
+				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			},
+			OptimisticModeFetcher: &mock.ChainService{},
+		}
+
+		blks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blks) > 0)
+		require.NoError(t, err)
+		sszBlock, err := blks[0].MarshalSSZ()
+		require.NoError(t, err)
+
+		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{BlockId: []byte("30")})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, sszBlock, resp.Data)
+		assert.Equal(t, ethpbv2.Version_BELLATRIX, resp.Version)
+	})
+
+	t.Run("Capella", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		_, blkContainers := fillDBTestBlocksCapellaBlinded(ctx, t, beaconDB)
+		headBlock := blkContainers[len(blkContainers)-1]
+
+		b2 := util.NewBlindedBeaconBlockCapella()
+		b2.Block.Slot = 30
+		b2.Block.ParentRoot = bytesutil.PadTo([]byte{1}, 32)
+		util.SaveBlock(t, ctx, beaconDB, b2)
+
+		chainBlk, err := blocks.NewSignedBeaconBlock(headBlock.GetBlindedCapellaBlock())
+		require.NoError(t, err)
+		bs := &Server{
+			BeaconDB: beaconDB,
+			ChainInfoFetcher: &mock.ChainService{
+				DB:                  beaconDB,
+				Block:               chainBlk,
+				Root:                headBlock.BlockRoot,
+				FinalizedCheckPoint: &ethpbalpha.Checkpoint{Root: blkContainers[64].BlockRoot},
+			},
+			OptimisticModeFetcher: &mock.ChainService{},
+		}
+
+		blks, err := beaconDB.BlocksBySlot(ctx, 30)
+		require.Equal(t, true, len(blks) > 0)
+		require.NoError(t, err)
+		sszBlock, err := blks[0].MarshalSSZ()
+		require.NoError(t, err)
+
+		resp, err := bs.GetBlindedBlockSSZ(ctx, &ethpbv1.BlockRequest{BlockId: []byte("30")})
+		require.NoError(t, err)
+		assert.NotNil(t, resp)
+		assert.DeepEqual(t, sszBlock, resp.Data)
+		assert.Equal(t, ethpbv2.Version_CAPELLA, resp.Version)
+	})
+}
+
+func TestServer_SubmitBlindedBlockSSZ_OK(t *testing.T) {
+	t.Run("Phase 0", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlock()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
+		}
+		req := util.NewBeaconBlock()
+		req.Block.Slot = 5
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "phase0")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Altair", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockAltair()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+			HeadFetcher:      c,
+		}
+		req := util.NewBeaconBlockAltair()
+		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().AltairForkEpoch))
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "altair")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Bellatrix", func(t *testing.T) {
+		// INFO: This code block can be removed once Bellatrix
+		// fork epoch is set to a value other than math.MaxUint64
+		params.SetupTestConfigCleanup(t)
+		cfg := params.BeaconConfig()
+		cfg.BellatrixForkEpoch = cfg.AltairForkEpoch + 1000
+		cfg.ForkVersionSchedule[bytesutil.ToBytes4(cfg.BellatrixForkVersion)] = cfg.AltairForkEpoch + 1000
+		params.OverrideBeaconConfig(cfg)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockBellatrix()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			HeadFetcher:             c,
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+		req := util.NewBlindedBeaconBlockBellatrix()
+		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().BellatrixForkEpoch))
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "bellatrix")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Capella", func(t *testing.T) {
+		t.Skip("This test needs Capella fork version configured properly")
+
+		// INFO: This code block can be removed once Capella
+		// fork epoch is set to a value other than math.MaxUint64
+		params.SetupTestConfigCleanup(t)
+		cfg := params.BeaconConfig()
+		cfg.CapellaForkEpoch = cfg.BellatrixForkEpoch + 1000
+		cfg.ForkVersionSchedule[bytesutil.ToBytes4(cfg.CapellaForkVersion)] = cfg.BellatrixForkEpoch + 1000
+		params.OverrideBeaconConfig(cfg)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockCapella()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			HeadFetcher:             c,
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+		req := util.NewBlindedBeaconBlockCapella()
+		req.Block.Slot = params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().CapellaForkEpoch))
+		req.Block.ParentRoot = bsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockSsz, err := req.MarshalSSZ()
+		require.NoError(t, err)
+		blockReq := &ethpbv2.SSZContainer{
+			Data: blockSsz,
+		}
+		md := metadata.MD{}
+		md.Set(versionHeader, "capella")
+		sszCtx := metadata.NewIncomingContext(ctx, md)
+		_, err = beaconChainServer.SubmitBlindedBlockSSZ(sszCtx, blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+}
+
+func TestSubmitBlindedBlock(t *testing.T) {
+	t.Run("Phase 0", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlock()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+		}
+		req := util.NewBeaconBlock()
+		req.Block.Slot = 5
+		req.Block.ParentRoot = bsRoot[:]
+		v1Block, err := migration.V1Alpha1ToV1SignedBlock(req)
+		require.NoError(t, err)
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_Phase0Block{Phase0Block: v1Block.Block},
+			Signature: v1Block.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Altair", func(t *testing.T) {
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockAltair()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		beaconChainServer := &Server{
+			BeaconDB:         beaconDB,
+			BlockReceiver:    c,
+			ChainInfoFetcher: c,
+			BlockNotifier:    c.BlockNotifier(),
+			Broadcaster:      mockp2p.NewTestP2P(t),
+		}
+		req := util.NewBeaconBlockAltair()
+		req.Block.Slot = 5
+		req.Block.ParentRoot = bsRoot[:]
+		v2Block, err := migration.V1Alpha1BeaconBlockAltairToV2(req.Block)
+		require.NoError(t, err)
+		util.SaveBlock(t, ctx, beaconDB, req)
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_AltairBlock{AltairBlock: v2Block},
+			Signature: req.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err, "Could not propose block correctly")
+	})
+
+	t.Run("Bellatrix", func(t *testing.T) {
+		transactions := [][]byte{[]byte("transaction1"), []byte("transaction2")}
+		transactionsRoot, err := ssz.TransactionsRoot(transactions)
+		require.NoError(t, err)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockBellatrix()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+
+		blk := util.NewBeaconBlockBellatrix()
+		blk.Block.Slot = 5
+		blk.Block.ParentRoot = bsRoot[:]
+		blk.Block.Body.ExecutionPayload.Transactions = transactions
+		blindedBlk := util.NewBlindedBeaconBlockBellatrixV2()
+		blindedBlk.Message.Slot = 5
+		blindedBlk.Message.ParentRoot = bsRoot[:]
+		blindedBlk.Message.Body.ExecutionPayloadHeader.TransactionsRoot = transactionsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, blk)
+
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_BellatrixBlock{BellatrixBlock: blindedBlk.Message},
+			Signature: blindedBlk.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err)
+	})
+
+	t.Run("Capella", func(t *testing.T) {
+		transactions := [][]byte{[]byte("transaction1"), []byte("transaction2")}
+		transactionsRoot, err := ssz.TransactionsRoot(transactions)
+		require.NoError(t, err)
+
+		withdrawals := []*enginev1.Withdrawal{
+			{
+				Index:          1,
+				ValidatorIndex: 1,
+				Address:        bytesutil.PadTo([]byte("address1"), 20),
+				Amount:         1,
+			},
+			{
+				Index:          2,
+				ValidatorIndex: 2,
+				Address:        bytesutil.PadTo([]byte("address2"), 20),
+				Amount:         2,
+			},
+		}
+		withdrawalsRoot, err := ssz.WithdrawalSliceRoot(hash.CustomSHA256Hasher(), withdrawals, 16)
+		require.NoError(t, err)
+
+		beaconDB := dbTest.SetupDB(t)
+		ctx := context.Background()
+
+		genesis := util.NewBeaconBlockCapella()
+		util.SaveBlock(t, context.Background(), beaconDB, genesis)
+
+		numDeposits := uint64(64)
+		beaconState, _ := util.DeterministicGenesisState(t, numDeposits)
+		bsRoot, err := beaconState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		genesisRoot, err := genesis.Block.HashTreeRoot()
+		require.NoError(t, err)
+		require.NoError(t, beaconDB.SaveState(ctx, beaconState, genesisRoot), "Could not save genesis state")
+
+		c := &mock.ChainService{Root: bsRoot[:], State: beaconState}
+		alphaServer := &validator.Server{
+			SyncCommitteePool: synccommittee.NewStore(),
+			P2P:               &mockp2p.MockBroadcaster{},
+			BlockBuilder:      &builderTest.MockBuilderService{},
+			BlockReceiver:     c,
+			BlockNotifier:     &mock.MockBlockNotifier{},
+		}
+		beaconChainServer := &Server{
+			BeaconDB:                beaconDB,
+			BlockReceiver:           c,
+			ChainInfoFetcher:        c,
+			BlockNotifier:           c.BlockNotifier(),
+			Broadcaster:             mockp2p.NewTestP2P(t),
+			V1Alpha1ValidatorServer: alphaServer,
+		}
+
+		blk := util.NewBeaconBlockCapella()
+		blk.Block.Slot = 5
+		blk.Block.ParentRoot = bsRoot[:]
+		blk.Block.Body.ExecutionPayload.Transactions = transactions
+		blk.Block.Body.ExecutionPayload.Withdrawals = withdrawals
+		blindedBlk := util.NewBlindedBeaconBlockCapellaV2()
+		blindedBlk.Message.Slot = 5
+		blindedBlk.Message.ParentRoot = bsRoot[:]
+		blindedBlk.Message.Body.ExecutionPayloadHeader.TransactionsRoot = transactionsRoot[:]
+		blindedBlk.Message.Body.ExecutionPayloadHeader.WithdrawalsRoot = withdrawalsRoot[:]
+		util.SaveBlock(t, ctx, beaconDB, blk)
+
+		blockReq := &ethpbv2.SignedBlindedBeaconBlockContainer{
+			Message:   &ethpbv2.SignedBlindedBeaconBlockContainer_CapellaBlock{CapellaBlock: blindedBlk.Message},
+			Signature: blindedBlk.Signature,
+		}
+		_, err = beaconChainServer.SubmitBlindedBlock(context.Background(), blockReq)
+		assert.NoError(t, err)
+	})
+}

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

@@ -220,25 +220,29 @@ func (bs *Server) SubmitBlock(ctx context.Context, req *ethpbv2.SignedBeaconBloc
 	ctx, span := trace.StartSpan(ctx, "beacon.SubmitBlock")
 	defer span.End()
 
-	switch blkContainer := req.Message.(type) {
-	case *ethpbv2.SignedBeaconBlockContainer_Phase0Block:
-		if err := bs.submitPhase0Block(ctx, blkContainer.Phase0Block, req.Signature); err != nil {
+	phase0BlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainer_Phase0Block)
+	if ok {
+		if err := bs.submitPhase0Block(ctx, phase0BlkContainer.Phase0Block, req.Signature); err != nil {
 			return nil, err
 		}
-	case *ethpbv2.SignedBeaconBlockContainer_AltairBlock:
-		if err := bs.submitAltairBlock(ctx, blkContainer.AltairBlock, req.Signature); err != nil {
+	}
+	altairBlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainer_AltairBlock)
+	if ok {
+		if err := bs.submitAltairBlock(ctx, altairBlkContainer.AltairBlock, req.Signature); err != nil {
 			return nil, err
 		}
-	case *ethpbv2.SignedBeaconBlockContainer_BellatrixBlock:
-		if err := bs.submitBellatrixBlock(ctx, blkContainer.BellatrixBlock, req.Signature); err != nil {
+	}
+	bellatrixBlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainer_BellatrixBlock)
+	if ok {
+		if err := bs.submitBellatrixBlock(ctx, bellatrixBlkContainer.BellatrixBlock, req.Signature); err != nil {
 			return nil, err
 		}
-	case *ethpbv2.SignedBeaconBlockContainer_CapellaBlock:
-		if err := bs.submitCapellaBlock(ctx, blkContainer.CapellaBlock, req.Signature); err != nil {
+	}
+	capellaBlkContainer, ok := req.Message.(*ethpbv2.SignedBeaconBlockContainer_CapellaBlock)
+	if ok {
+		if err := bs.submitCapellaBlock(ctx, capellaBlkContainer.CapellaBlock, req.Signature); err != nil {
 			return nil, err
 		}
-	default:
-		return nil, status.Errorf(codes.InvalidArgument, "Unsupported block container type %T", blkContainer)
 	}
 
 	return &emptypb.Empty{}, nil
@@ -379,6 +383,7 @@ func (bs *Server) GetBlockV2(ctx context.Context, req *ethpbv2.BlockRequestV2) (
 	if !errors.Is(err, blocks.ErrUnsupportedGetter) {
 		return nil, status.Errorf(codes.Internal, "Could not get signed beacon block: %v", err)
 	}
+
 	return nil, status.Errorf(codes.Internal, "Unknown block type %T", blk)
 }
 

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

@@ -6,7 +6,6 @@ import (
 	"reflect"
 	"testing"
 
-	"github.com/prysmaticlabs/go-bitfield"
 	mock "github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db"
 	dbTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
@@ -44,6 +43,13 @@ func fillDBTestBlocks(ctx context.Context, t *testing.T, beaconDB db.Database) (
 		b := util.NewBeaconBlock()
 		b.Block.Slot = i
 		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
+		att1 := util.NewAttestation()
+		att1.Data.Slot = i
+		att1.Data.CommitteeIndex = types.CommitteeIndex(i)
+		att2 := util.NewAttestation()
+		att2.Data.Slot = i
+		att2.Data.CommitteeIndex = types.CommitteeIndex(i + 1)
+		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
 		blks[i], err = blocks.NewSignedBeaconBlock(b)
@@ -80,12 +86,13 @@ func fillDBTestBlocksAltair(ctx context.Context, t *testing.T, beaconDB db.Datab
 		b := util.NewBeaconBlockAltair()
 		b.Block.Slot = i
 		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
-		syncCommitteeBits := bitfield.NewBitvector512()
-		syncCommitteeBits.SetBitAt(100, true)
-		b.Block.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: bytesutil.PadTo([]byte("signature"), 96),
-		}
+		att1 := util.NewAttestation()
+		att1.Data.Slot = i
+		att1.Data.CommitteeIndex = types.CommitteeIndex(i)
+		att2 := util.NewAttestation()
+		att2.Data.Slot = i
+		att2.Data.CommitteeIndex = types.CommitteeIndex(i + 1)
+		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
 		signedB, err := blocks.NewSignedBeaconBlock(b)
@@ -121,28 +128,13 @@ func fillDBTestBlocksBellatrix(ctx context.Context, t *testing.T, beaconDB db.Da
 		b := util.NewBeaconBlockBellatrix()
 		b.Block.Slot = i
 		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
-		syncCommitteeBits := bitfield.NewBitvector512()
-		syncCommitteeBits.SetBitAt(100, true)
-		b.Block.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: bytesutil.PadTo([]byte("signature"), 96),
-		}
-		b.Block.Body.ExecutionPayload = &enginev1.ExecutionPayload{
-			ParentHash:    bytesutil.PadTo([]byte("parent_hash"), 32),
-			FeeRecipient:  bytesutil.PadTo([]byte("fee_recipient"), 20),
-			StateRoot:     bytesutil.PadTo([]byte("state_root"), 32),
-			ReceiptsRoot:  bytesutil.PadTo([]byte("receipts_root"), 32),
-			LogsBloom:     bytesutil.PadTo([]byte("logs_bloom"), 256),
-			PrevRandao:    bytesutil.PadTo([]byte("prev_randao"), 32),
-			BlockNumber:   123,
-			GasLimit:      123,
-			GasUsed:       123,
-			Timestamp:     123,
-			ExtraData:     bytesutil.PadTo([]byte("extra_data"), 32),
-			BaseFeePerGas: bytesutil.PadTo([]byte("base_fee_per_gas"), 32),
-			BlockHash:     bytesutil.PadTo([]byte("block_hash"), 32),
-			Transactions:  [][]byte{[]byte("transaction1"), []byte("transaction2")},
-		}
+		att1 := util.NewAttestation()
+		att1.Data.Slot = i
+		att1.Data.CommitteeIndex = types.CommitteeIndex(i)
+		att2 := util.NewAttestation()
+		att2.Data.Slot = i
+		att2.Data.CommitteeIndex = types.CommitteeIndex(i + 1)
+		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
 		signedB, err := blocks.NewSignedBeaconBlock(b)
@@ -178,42 +170,13 @@ func fillDBTestBlocksCapella(ctx context.Context, t *testing.T, beaconDB db.Data
 		b := util.NewBeaconBlockCapella()
 		b.Block.Slot = i
 		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
-		syncCommitteeBits := bitfield.NewBitvector512()
-		syncCommitteeBits.SetBitAt(100, true)
-		b.Block.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: bytesutil.PadTo([]byte("signature"), 96),
-		}
-		b.Block.Body.ExecutionPayload = &enginev1.ExecutionPayloadCapella{
-			ParentHash:    bytesutil.PadTo([]byte("parent_hash"), 32),
-			FeeRecipient:  bytesutil.PadTo([]byte("fee_recipient"), 20),
-			StateRoot:     bytesutil.PadTo([]byte("state_root"), 32),
-			ReceiptsRoot:  bytesutil.PadTo([]byte("receipts_root"), 32),
-			LogsBloom:     bytesutil.PadTo([]byte("logs_bloom"), 256),
-			PrevRandao:    bytesutil.PadTo([]byte("prev_randao"), 32),
-			BlockNumber:   123,
-			GasLimit:      123,
-			GasUsed:       123,
-			Timestamp:     123,
-			ExtraData:     bytesutil.PadTo([]byte("extra_data"), 32),
-			BaseFeePerGas: bytesutil.PadTo([]byte("base_fee_per_gas"), 32),
-			BlockHash:     bytesutil.PadTo([]byte("block_hash"), 32),
-			Transactions:  [][]byte{[]byte("transaction1"), []byte("transaction2")},
-			Withdrawals: []*enginev1.Withdrawal{
-				{
-					Index:          1,
-					ValidatorIndex: 1,
-					Address:        bytesutil.PadTo([]byte("address1"), 20),
-					Amount:         1,
-				},
-				{
-					Index:          2,
-					ValidatorIndex: 2,
-					Address:        bytesutil.PadTo([]byte("address2"), 20),
-					Amount:         2,
-				},
-			},
-		}
+		att1 := util.NewAttestation()
+		att1.Data.Slot = i
+		att1.Data.CommitteeIndex = types.CommitteeIndex(i)
+		att2 := util.NewAttestation()
+		att2.Data.Slot = i
+		att2.Data.CommitteeIndex = types.CommitteeIndex(i + 1)
+		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
 		signedB, err := blocks.NewSignedBeaconBlock(b)
@@ -249,28 +212,13 @@ func fillDBTestBlocksBellatrixBlinded(ctx context.Context, t *testing.T, beaconD
 		b := util.NewBlindedBeaconBlockBellatrix()
 		b.Block.Slot = i
 		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
-		syncCommitteeBits := bitfield.NewBitvector512()
-		syncCommitteeBits.SetBitAt(100, true)
-		b.Block.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: bytesutil.PadTo([]byte("signature"), 96),
-		}
-		b.Block.Body.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeader{
-			ParentHash:       bytesutil.PadTo([]byte("parent_hash"), 32),
-			FeeRecipient:     bytesutil.PadTo([]byte("fee_recipient"), 20),
-			StateRoot:        bytesutil.PadTo([]byte("state_root"), 32),
-			ReceiptsRoot:     bytesutil.PadTo([]byte("receipts_root"), 32),
-			LogsBloom:        bytesutil.PadTo([]byte("logs_bloom"), 256),
-			PrevRandao:       bytesutil.PadTo([]byte("prev_randao"), 32),
-			BlockNumber:      123,
-			GasLimit:         123,
-			GasUsed:          123,
-			Timestamp:        123,
-			ExtraData:        bytesutil.PadTo([]byte("extra_data"), 32),
-			BaseFeePerGas:    bytesutil.PadTo([]byte("base_fee_per_gas"), 32),
-			BlockHash:        bytesutil.PadTo([]byte("block_hash"), 32),
-			TransactionsRoot: bytesutil.PadTo([]byte("transactions_root"), 32),
-		}
+		att1 := util.NewAttestation()
+		att1.Data.Slot = i
+		att1.Data.CommitteeIndex = types.CommitteeIndex(i)
+		att2 := util.NewAttestation()
+		att2.Data.Slot = i
+		att2.Data.CommitteeIndex = types.CommitteeIndex(i + 1)
+		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
 		signedB, err := blocks.NewSignedBeaconBlock(b)
@@ -306,29 +254,13 @@ func fillDBTestBlocksCapellaBlinded(ctx context.Context, t *testing.T, beaconDB
 		b := util.NewBlindedBeaconBlockCapella()
 		b.Block.Slot = i
 		b.Block.ParentRoot = bytesutil.PadTo([]byte{uint8(i)}, 32)
-		syncCommitteeBits := bitfield.NewBitvector512()
-		syncCommitteeBits.SetBitAt(100, true)
-		b.Block.Body.SyncAggregate = &ethpbalpha.SyncAggregate{
-			SyncCommitteeBits:      syncCommitteeBits,
-			SyncCommitteeSignature: bytesutil.PadTo([]byte("signature"), 96),
-		}
-		b.Block.Body.ExecutionPayloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
-			ParentHash:       bytesutil.PadTo([]byte("parent_hash"), 32),
-			FeeRecipient:     bytesutil.PadTo([]byte("fee_recipient"), 20),
-			StateRoot:        bytesutil.PadTo([]byte("state_root"), 32),
-			ReceiptsRoot:     bytesutil.PadTo([]byte("receipts_root"), 32),
-			LogsBloom:        bytesutil.PadTo([]byte("logs_bloom"), 256),
-			PrevRandao:       bytesutil.PadTo([]byte("prev_randao"), 32),
-			BlockNumber:      123,
-			GasLimit:         123,
-			GasUsed:          123,
-			Timestamp:        123,
-			ExtraData:        bytesutil.PadTo([]byte("extra_data"), 32),
-			BaseFeePerGas:    bytesutil.PadTo([]byte("base_fee_per_gas"), 32),
-			BlockHash:        bytesutil.PadTo([]byte("block_hash"), 32),
-			TransactionsRoot: bytesutil.PadTo([]byte("transactions_root"), 32),
-			WithdrawalsRoot:  bytesutil.PadTo([]byte("withdrawals_root"), 32),
-		}
+		att1 := util.NewAttestation()
+		att1.Data.Slot = i
+		att1.Data.CommitteeIndex = types.CommitteeIndex(i)
+		att2 := util.NewAttestation()
+		att2.Data.Slot = i
+		att2.Data.CommitteeIndex = types.CommitteeIndex(i + 1)
+		b.Block.Body.Attestations = []*ethpbalpha.Attestation{att1, att2}
 		root, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
 		signedB, err := blocks.NewSignedBeaconBlock(b)

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

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v3/network/forks"
 	"github.com/prysmaticlabs/prysm/v3/testing/assert"
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -50,6 +49,8 @@ func TestGetSpec(t *testing.T) {
 	config.AltairForkEpoch = 100
 	config.BellatrixForkVersion = []byte("BellatrixForkVersion")
 	config.BellatrixForkEpoch = 101
+	config.ShardingForkVersion = []byte("ShardingForkVersion")
+	config.ShardingForkEpoch = 102
 	config.CapellaForkVersion = []byte("CapellaForkVersion")
 	config.CapellaForkEpoch = 103
 	config.BLSWithdrawalPrefixByte = byte('b')
@@ -137,7 +138,7 @@ func TestGetSpec(t *testing.T) {
 	resp, err := server.GetSpec(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
 
-	assert.Equal(t, 103, len(resp.Data))
+	assert.Equal(t, 105, len(resp.Data))
 	for k, v := range resp.Data {
 		switch k {
 		case "CONFIG_NAME":
@@ -202,6 +203,10 @@ func TestGetSpec(t *testing.T) {
 			assert.Equal(t, "0x"+hex.EncodeToString([]byte("BellatrixForkVersion")), v)
 		case "BELLATRIX_FORK_EPOCH":
 			assert.Equal(t, "101", v)
+		case "SHARDING_FORK_VERSION":
+			assert.Equal(t, "0x"+hex.EncodeToString([]byte("ShardingForkVersion")), v)
+		case "SHARDING_FORK_EPOCH":
+			assert.Equal(t, "102", v)
 		case "CAPELLA_FORK_VERSION":
 			assert.Equal(t, "0x"+hex.EncodeToString([]byte("CapellaForkVersion")), v)
 		case "CAPELLA_FORK_EPOCH":
@@ -420,6 +425,6 @@ func TestForkSchedule_CorrectNumberOfForks(t *testing.T) {
 	s := &Server{}
 	resp, err := s.GetForkSchedule(context.Background(), &emptypb.Empty{})
 	require.NoError(t, err)
-	os := forks.NewOrderedSchedule(params.BeaconConfig())
-	assert.Equal(t, os.Len(), len(resp.Data))
+	// Genesis and Altair.
+	assert.Equal(t, 3, len(resp.Data))
 }

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

@@ -334,12 +334,6 @@ func (bs *Server) SubmitSignedBLSToExecutionChanges(ctx context.Context, req *et
 			})
 			continue
 		}
-		bs.OperationNotifier.OperationFeed().Send(&feed.Event{
-			Type: operation.BLSToExecutionChangeReceived,
-			Data: &operation.BLSToExecutionChangeReceivedData{
-				Change: alphaChange,
-			},
-		})
 		bs.BLSChangesPool.InsertBLSToExecChange(alphaChange)
 		if st.Version() >= version.Capella {
 			if err := bs.Broadcaster.Broadcast(ctx, alphaChange); err != nil {

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

@@ -1205,8 +1205,8 @@ func TestSubmitSignedBLSToExecutionChanges_Ok(t *testing.T) {
 
 	spb := &ethpbv1alpha1.BeaconStateCapella{
 		Fork: &ethpbv1alpha1.Fork{
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
+			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
 			Epoch:           params.BeaconConfig().CapellaForkEpoch,
 		},
 	}
@@ -1342,8 +1342,8 @@ func TestSubmitSignedBLSToExecutionChanges_Bellatrix(t *testing.T) {
 
 	spc := &ethpbv1alpha1.BeaconStateCapella{
 		Fork: &ethpbv1alpha1.Fork{
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
+			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
 			Epoch:           params.BeaconConfig().CapellaForkEpoch,
 		},
 	}
@@ -1405,8 +1405,8 @@ func TestSubmitSignedBLSToExecutionChanges_Failures(t *testing.T) {
 
 	spb := &ethpbv1alpha1.BeaconStateCapella{
 		Fork: &ethpbv1alpha1.Fork{
-			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+			CurrentVersion:  params.BeaconConfig().CapellaForkVersion,
+			PreviousVersion: params.BeaconConfig().BellatrixForkVersion,
 			Epoch:           params.BeaconConfig().CapellaForkEpoch,
 		},
 	}

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

@@ -33,8 +33,6 @@ const (
 	ChainReorgTopic = "chain_reorg"
 	// SyncCommitteeContributionTopic represents a new sync committee contribution event topic.
 	SyncCommitteeContributionTopic = "contribution_and_proof"
-	// BLSToExecutionChangeTopic represents a new received BLS to execution change event topic.
-	BLSToExecutionChangeTopic = "bls_to_execution_change"
 )
 
 var casesHandled = map[string]bool{
@@ -45,7 +43,6 @@ var casesHandled = map[string]bool{
 	FinalizedCheckpointTopic:       true,
 	ChainReorgTopic:                true,
 	SyncCommitteeContributionTopic: true,
-	BLSToExecutionChangeTopic:      true,
 }
 
 // StreamEvents allows requesting all events from a set of topics defined in the Ethereum consensus API standard.
@@ -181,16 +178,6 @@ func handleBlockOperationEvents(
 		}
 		v2Data := migration.V1Alpha1SignedContributionAndProofToV2(contributionData.Contribution)
 		return streamData(stream, SyncCommitteeContributionTopic, v2Data)
-	case operation.BLSToExecutionChangeReceived:
-		if _, ok := requestedTopics[BLSToExecutionChangeTopic]; !ok {
-			return nil
-		}
-		changeData, ok := event.Data.(*operation.BLSToExecutionChangeReceivedData)
-		if !ok {
-			return nil
-		}
-		v2Change := migration.V1Alpha1SignedBLSToExecChangeToV2(changeData.Change)
-		return streamData(stream, BLSToExecutionChangeTopic, v2Change)
 	default:
 		return nil
 	}

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

@@ -238,43 +238,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 			feed: srv.OperationNotifier.OperationFeed(),
 		})
 	})
-	t.Run(BLSToExecutionChangeTopic, func(t *testing.T) {
-		ctx := context.Background()
-		srv, ctrl, mockStream := setupServer(ctx, t)
-		defer ctrl.Finish()
-
-		wantedChangeV1alpha1 := &eth.SignedBLSToExecutionChange{
-			Message: &eth.BLSToExecutionChange{
-				ValidatorIndex:     1,
-				FromBlsPubkey:      []byte("from"),
-				ToExecutionAddress: []byte("to"),
-			},
-			Signature: make([]byte, 96),
-		}
-		wantedChange := migration.V1Alpha1SignedBLSToExecChangeToV2(wantedChangeV1alpha1)
-		genericResponse, err := anypb.New(wantedChange)
-		require.NoError(t, err)
-
-		wantedMessage := &gateway.EventSource{
-			Event: BLSToExecutionChangeTopic,
-			Data:  genericResponse,
-		}
-
-		assertFeedSendAndReceive(ctx, &assertFeedArgs{
-			t:             t,
-			srv:           srv,
-			topics:        []string{BLSToExecutionChangeTopic},
-			stream:        mockStream,
-			shouldReceive: wantedMessage,
-			itemToSend: &feed.Event{
-				Type: operation.BLSToExecutionChangeReceived,
-				Data: &operation.BLSToExecutionChangeReceivedData{
-					Change: wantedChangeV1alpha1,
-				},
-			},
-			feed: srv.OperationNotifier.OperationFeed(),
-		})
-	})
 }
 
 func TestStreamEvents_StateEvents(t *testing.T) {

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

@@ -15,6 +15,7 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
+        "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/rpc/eth/helpers:go_default_library",

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

@@ -4,6 +4,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/synccommittee"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p"
 	v1alpha1validator "github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/prysm/v1alpha1/validator"
@@ -24,6 +25,7 @@ type Server struct {
 	StateFetcher           statefetcher.Fetcher
 	OptimisticModeFetcher  blockchain.OptimisticModeFetcher
 	SyncCommitteePool      synccommittee.Pool
+	BLSChangesPool         blstoexec.PoolManager
 	V1Alpha1Server         *v1alpha1validator.Server
 	ProposerSlotIndexCache *cache.ProposerPayloadIDsCache
 }

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

@@ -502,7 +502,7 @@ func (vs *Server) ProduceBlindedBlock(ctx context.Context, req *ethpbv1.ProduceB
 	}
 	b, err := vs.V1Alpha1Server.GetBeaconBlock(ctx, v1alpha1req)
 	if err != nil {
-		return nil, status.Error(codes.Unavailable, "Could not get block from prysm API")
+		return nil, err
 	}
 	blk, err := migration.V1Alpha1BeaconBlockBlindedBellatrixToV2Blinded(b.GetBlindedBellatrix())
 	if err != nil {

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

@@ -689,20 +689,18 @@ func TestProduceBlockV2(t *testing.T) {
 		mockChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:           mockChainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:         mockChainService,
-			HeadUpdater:           mockChainService,
-			ChainStartFetcher:     mockExecutionChain,
-			Eth1InfoFetcher:       mockExecutionChain,
-			Eth1BlockFetcher:      mockExecutionChain,
-			MockEth1Votes:         true,
-			AttPool:               attestations.NewPool(),
-			SlashingsPool:         slashings.NewPool(),
-			ExitPool:              voluntaryexits.NewPool(),
-			StateGen:              stategen.New(db, doublylinkedtree.New()),
-			TimeFetcher:           mockChainService,
-			OptimisticModeFetcher: mockChainService,
+			HeadFetcher:       mockChainService,
+			SyncChecker:       &mockSync.Sync{IsSyncing: false},
+			BlockReceiver:     mockChainService,
+			HeadUpdater:       mockChainService,
+			ChainStartFetcher: mockExecutionChain,
+			Eth1InfoFetcher:   mockExecutionChain,
+			Eth1BlockFetcher:  mockExecutionChain,
+			MockEth1Votes:     true,
+			AttPool:           attestations.NewPool(),
+			SlashingsPool:     slashings.NewPool(),
+			ExitPool:          voluntaryexits.NewPool(),
+			StateGen:          stategen.New(db, doublylinkedtree.New()),
 		}
 
 		proposerSlashings := make([]*ethpbalpha.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
@@ -799,21 +797,19 @@ func TestProduceBlockV2(t *testing.T) {
 		mochChainService := &mockChain.ChainService{State: beaconState, Root: parentRoot[:]}
 		mockExecutionChain := &mockExecution.Chain{}
 		v1Alpha1Server := &v1alpha1validator.Server{
-			HeadFetcher:           mochChainService,
-			SyncChecker:           &mockSync.Sync{IsSyncing: false},
-			BlockReceiver:         mochChainService,
-			HeadUpdater:           mochChainService,
-			ChainStartFetcher:     mockExecutionChain,
-			Eth1InfoFetcher:       mockExecutionChain,
-			Eth1BlockFetcher:      mockExecutionChain,
-			MockEth1Votes:         true,
-			AttPool:               attestations.NewPool(),
-			SlashingsPool:         slashings.NewPool(),
-			ExitPool:              voluntaryexits.NewPool(),
-			StateGen:              stategen.New(db, doublylinkedtree.New()),
-			SyncCommitteePool:     synccommittee.NewStore(),
-			TimeFetcher:           mochChainService,
-			OptimisticModeFetcher: mochChainService,
+			HeadFetcher:       mochChainService,
+			SyncChecker:       &mockSync.Sync{IsSyncing: false},
+			BlockReceiver:     mochChainService,
+			HeadUpdater:       mochChainService,
+			ChainStartFetcher: mockExecutionChain,
+			Eth1InfoFetcher:   mockExecutionChain,
+			Eth1BlockFetcher:  mockExecutionChain,
+			MockEth1Votes:     true,
+			AttPool:           attestations.NewPool(),
+			SlashingsPool:     slashings.NewPool(),
+			ExitPool:          voluntaryexits.NewPool(),
+			StateGen:          stategen.New(db, doublylinkedtree.New()),
+			SyncCommitteePool: synccommittee.NewStore(),
 		}
 
 		proposerSlashings := make([]*ethpbalpha.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
@@ -2109,14 +2105,6 @@ func TestProduceBlindedBlock(t *testing.T) {
 		require.NoError(t, err)
 		graffiti := bytesutil.ToBytes32([]byte("eth2"))
 
-		copied := beaconState.Copy()
-		require.NoError(t, copied.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))
-		idx, err := helpers.BeaconProposerIndex(ctx, copied)
-		require.NoError(t, err)
-		require.NoError(t,
-			db.SaveRegistrationsByValidatorIDs(ctx, []types.ValidatorIndex{idx},
-				[]*ethpbalpha.ValidatorRegistrationV1{{FeeRecipient: make([]byte, 20), Pubkey: make([]byte, 48)}}))
-
 		req := &ethpbv1.ProduceBlockRequest{
 			Slot:         params.BeaconConfig().SlotsPerEpoch + 1,
 			RandaoReveal: randaoReveal,

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

@@ -6,6 +6,7 @@ go_library(
         "assignments.go",
         "attestations.go",
         "blocks.go",
+        "blstoexec.go",
         "committees.go",
         "config.go",
         "log.go",
@@ -36,6 +37,7 @@ go_library(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
+        "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/state:go_default_library",

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

@@ -0,0 +1,24 @@
+package beacon
+
+import (
+	"context"
+
+	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// SubmitBLSToExecutionChange receives a withdrawal credential change object via
+// RPC and injects it into the beacon node's operations pool.
+// Submission into this pool does not guarantee inclusion into a beacon block. If the object passes validation
+// the node MUST broadcast it
+func (bs *Server) SubmitBLSToExecutionChange(
+	ctx context.Context,
+	req *ethpb.SignedBLSToExecutionChange,
+) (*ethpb.BLSToExecutionChangeResponse, error) {
+	bs.BLSChangesPool.InsertBLSToExecChange(req)
+	if err := bs.Broadcaster.Broadcast(ctx, req); err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not broadcast SigledBLSToExecutionChange object: %v", err)
+	}
+	return nil, nil
+}

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

@@ -15,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/execution"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state/stategen"
@@ -40,6 +41,7 @@ type Server struct {
 	Broadcaster                 p2p.Broadcaster
 	AttestationsPool            attestations.Pool
 	SlashingsPool               slashings.PoolManager
+	BLSChangesPool              blstoexec.PoolManager
 	ChainStartChan              chan time.Time
 	ReceivedAttestationsBuffer  chan *ethpb.Attestation
 	CollectedAttestationsBuffer chan []*ethpb.Attestation

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

@@ -14,7 +14,6 @@ go_library(
         "proposer_attestations.go",
         "proposer_bellatrix.go",
         "proposer_builder.go",
-        "proposer_capella.go",
         "proposer_deposits.go",
         "proposer_empty_block.go",
         "proposer_eth1data.go",
@@ -44,13 +43,14 @@ go_library(
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
+        "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/core/validators:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
-        "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
+        "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/synccommittee:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
@@ -125,7 +125,6 @@ common_deps = [
     "//beacon-chain/operations/synccommittee:go_default_library",
     "//beacon-chain/operations/voluntaryexits:go_default_library",
     "//beacon-chain/p2p/testing:go_default_library",
-    "//beacon-chain/rpc/testutil:go_default_library",
     "//beacon-chain/state:go_default_library",
     "//beacon-chain/state/state-native:go_default_library",
     "//beacon-chain/state/stategen:go_default_library",
@@ -175,7 +174,6 @@ go_test(
         "attester_test.go",
         "blocks_test.go",
         "exit_test.go",
-        "proposer_altair_test.go",
         "proposer_attestations_test.go",
         "proposer_bellatrix_test.go",
         "proposer_builder_test.go",

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

@@ -112,48 +112,6 @@ func TestServer_StreamAltairBlocks_OnHeadUpdated(t *testing.T) {
 	<-exitRoutine
 }
 
-func TestServer_StreamCapellaBlocks_OnHeadUpdated(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.OverrideBeaconConfig(params.BeaconConfig())
-	ctx := context.Background()
-	beaconState, privs := util.DeterministicGenesisStateCapella(t, 64)
-	c, err := altair.NextSyncCommittee(ctx, beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(c))
-
-	b, err := util.GenerateFullBlockCapella(beaconState, privs, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	chainService := &chainMock.ChainService{State: beaconState}
-	server := &Server{
-		Ctx:           ctx,
-		BlockNotifier: chainService.BlockNotifier(),
-		HeadFetcher:   chainService,
-	}
-	exitRoutine := make(chan bool)
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	mockStream := mock.NewMockBeaconNodeValidatorAltair_StreamBlocksServer(ctrl)
-
-	mockStream.EXPECT().Send(&ethpb.StreamBlocksResponse{Block: &ethpb.StreamBlocksResponse_CapellaBlock{CapellaBlock: b}}).Do(func(arg0 interface{}) {
-		exitRoutine <- true
-	})
-	mockStream.EXPECT().Context().Return(ctx).AnyTimes()
-
-	go func(tt *testing.T) {
-		assert.NoError(tt, server.StreamBlocksAltair(&ethpb.StreamBlocksRequest{}, mockStream), "Could not call RPC method")
-	}(t)
-	wrappedBlk, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
-	for sent := 0; sent == 0; {
-		sent = server.BlockNotifier.BlockFeed().Send(&feed.Event{
-			Type: blockfeed.ReceivedBlock,
-			Data: &blockfeed.ReceivedBlockData{SignedBlock: wrappedBlk},
-		})
-	}
-	<-exitRoutine
-}
-
 func TestServer_StreamAltairBlocksVerified_OnHeadUpdated(t *testing.T) {
 	db := dbTest.SetupDB(t)
 	ctx := context.Background()
@@ -196,46 +154,3 @@ func TestServer_StreamAltairBlocksVerified_OnHeadUpdated(t *testing.T) {
 	}
 	<-exitRoutine
 }
-
-func TestServer_StreamCapellaBlocksVerified_OnHeadUpdated(t *testing.T) {
-	db := dbTest.SetupDB(t)
-	ctx := context.Background()
-	beaconState, privs := util.DeterministicGenesisStateCapella(t, 32)
-	c, err := altair.NextSyncCommittee(ctx, beaconState)
-	require.NoError(t, err)
-	require.NoError(t, beaconState.SetCurrentSyncCommittee(c))
-
-	b, err := util.GenerateFullBlockCapella(beaconState, privs, util.DefaultBlockGenConfig(), 1)
-	require.NoError(t, err)
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	wrappedBlk := util.SaveBlock(t, ctx, db, b)
-	chainService := &chainMock.ChainService{State: beaconState}
-	server := &Server{
-		Ctx:           ctx,
-		StateNotifier: chainService.StateNotifier(),
-		HeadFetcher:   chainService,
-	}
-	exitRoutine := make(chan bool)
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	mockStream := mock.NewMockBeaconNodeValidatorAltair_StreamBlocksServer(ctrl)
-	mockStream.EXPECT().Send(&ethpb.StreamBlocksResponse{Block: &ethpb.StreamBlocksResponse_CapellaBlock{CapellaBlock: b}}).Do(func(arg0 interface{}) {
-		exitRoutine <- true
-	})
-	mockStream.EXPECT().Context().Return(ctx).AnyTimes()
-
-	go func(tt *testing.T) {
-		assert.NoError(tt, server.StreamBlocksAltair(&ethpb.StreamBlocksRequest{
-			VerifiedOnly: true,
-		}, mockStream), "Could not call RPC method")
-	}(t)
-	// Send in a loop to ensure it is delivered (busy wait for the service to subscribe to the state feed).
-	for sent := 0; sent == 0; {
-		sent = server.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.BlockProcessed,
-			Data: &statefeed.BlockProcessedData{Slot: b.Block.Slot, BlockRoot: r, SignedBlock: wrappedBlk},
-		})
-	}
-	<-exitRoutine
-}

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

@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db/kv"
+	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
@@ -36,8 +37,8 @@ var eth1DataNotification bool
 const eth1dataTimeout = 2 * time.Second
 
 // GetBeaconBlock is called by a proposer during its assigned slot to request a block to sign
-// by passing in the slot and the signed randao reveal of the slot. Returns phase0 beacon blocks
-// before the Altair fork epoch and Altair blocks post-fork epoch.
+// by passing in the slot and the signed randao reveal of the slot. Returns a full block
+// corresponding to the fork epoch
 func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (*ethpb.GenericBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.GetBeaconBlock")
 	defer span.End()
@@ -49,16 +50,15 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	}
 
 	// 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 {
-		if err := vs.optimisticStatus(ctx); err != nil {
-			return nil, status.Errorf(codes.Unavailable, "Validator is not ready to propose: %v", err)
-		}
+	if err := vs.optimisticStatus(ctx); err != nil {
+		return nil, status.Errorf(codes.Unavailable, "Validator is not ready to propose: %v", err)
 	}
 
-	sBlk, err := getEmptyBlock(req.Slot)
+	sBlk, err := emptyBlockToSign(req.Slot)
 	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)
@@ -82,46 +82,94 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	// Set eth1 data.
 	eth1Data, err := vs.eth1DataMajorityVote(ctx, head)
 	if err != nil {
-		eth1Data = &ethpb.Eth1Data{DepositRoot: params.BeaconConfig().ZeroHash[:], BlockHash: params.BeaconConfig().ZeroHash[:]}
 		log.WithError(err).Error("Could not get eth1data")
-	}
-	blk.Body().SetEth1Data(eth1Data)
+	} else {
+		blk.Body().SetEth1Data(eth1Data)
 
-	// Set deposit and attestation.
-	deposits, atts, err := vs.packDepositsAndAttestations(ctx, head, eth1Data) // TODO: split attestations and deposits
-	if err != nil {
-		blk.Body().SetDeposits([]*ethpb.Deposit{})
-		blk.Body().SetAttestations([]*ethpb.Attestation{})
-		log.WithError(err).Error("Could not pack deposits and attestations")
+		// Set deposit and attestation.
+		deposits, atts, err := vs.packDepositsAndAttestations(ctx, head, eth1Data) // TODO: split attestations and deposits
+		if err != nil {
+			log.WithError(err).Error("Could not pack deposits and attestations")
+		} else {
+			blk.Body().SetDeposits(deposits)
+			blk.Body().SetAttestations(atts)
+		}
 	}
-	blk.Body().SetDeposits(deposits)
-	blk.Body().SetAttestations(atts)
 
-	// Set proposer index.
+	// Set proposer index
 	idx, err := helpers.BeaconProposerIndex(ctx, head)
 	if err != nil {
 		return nil, fmt.Errorf("could not calculate proposer index %v", err)
 	}
 	blk.SetProposerIndex(idx)
 
-	// Set slashings.
+	// Set slashings
 	validProposerSlashings, validAttSlashings := vs.getSlashings(ctx, head)
 	blk.Body().SetProposerSlashings(validProposerSlashings)
 	blk.Body().SetAttesterSlashings(validAttSlashings)
 
-	// Set exits.
+	// Set exits
 	blk.Body().SetVoluntaryExits(vs.getExits(head, req.Slot))
 
 	// Set sync aggregate. New in Altair.
-	vs.setSyncAggregate(ctx, blk)
-
-	// Set execution data. New in Bellatrix.
-	if err := vs.setExecutionData(ctx, blk, head); err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not set execution data: %v", err)
+	if req.Slot > 0 && slots.ToEpoch(req.Slot) >= params.BeaconConfig().AltairForkEpoch {
+		syncAggregate, err := vs.getSyncAggregate(ctx, req.Slot-1, bytesutil.ToBytes32(parentRoot))
+		if err != nil {
+			log.WithError(err).Error("Could not get sync aggregate")
+		} else {
+			if err := blk.Body().SetSyncAggregate(syncAggregate); err != nil {
+				log.WithError(err).Error("Could not set sync aggregate")
+				if err := blk.Body().SetSyncAggregate(&ethpb.SyncAggregate{
+					SyncCommitteeBits:      make([]byte, params.BeaconConfig().SyncCommitteeSize),
+					SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+				}); err != nil {
+					return nil, status.Errorf(codes.Internal, "Could not set default sync aggregate: %v", err)
+				}
+			}
+		}
 	}
 
-	// Set bls to execution change. New in Capella.
-	vs.setBlsToExecData(blk, head)
+	// Set execution data. New in Bellatrix
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch {
+		fallBackToLocal := true
+		canUseBuilder, err := vs.canUseBuilder(ctx, req.Slot, idx)
+		if err != nil {
+			log.WithError(err).Warn("Proposer: failed to check if builder can be used")
+		} else if canUseBuilder {
+			h, err := vs.getPayloadHeaderFromBuilder(ctx, req.Slot, idx)
+			if err != nil {
+				log.WithError(err).Warn("Proposer: failed to get payload header from builder")
+			} else {
+				blk.SetBlinded(true)
+				if err := blk.Body().SetExecution(h); err != nil {
+					log.WithError(err).Warn("Proposer: failed to set execution payload")
+				} else {
+					fallBackToLocal = false
+				}
+			}
+		}
+		if fallBackToLocal {
+			executionData, err := vs.getExecutionPayload(ctx, req.Slot, idx, bytesutil.ToBytes32(parentRoot), head)
+			if err != nil {
+				return nil, status.Errorf(codes.Internal, "Could not get execution payload: %v", err)
+			}
+			if err := blk.Body().SetExecution(executionData); err != nil {
+				return nil, status.Errorf(codes.Internal, "Could not set execution payload: %v", err)
+			}
+		}
+	}
+
+	// Set bls to execution change. New in Capella
+	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().CapellaForkEpoch {
+		changes, err := vs.BLSChangesPool.BLSToExecChangesForInclusion(head)
+		if err != nil {
+			log.WithError(err).Error("Could not get bls to execution changes")
+		} else {
+			if err := blk.Body().SetBLSToExecutionChanges(changes); err != nil {
+				log.WithError(err).Error("Could not set bls to execution changes")
+			}
+		}
+	}
 
 	sr, err := vs.computeStateRoot(ctx, sBlk)
 	if err != nil {
@@ -135,19 +183,42 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	}
 	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().CapellaForkEpoch {
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: pb.(*ethpb.BeaconBlockCapella)}}, nil
-	}
-	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch && !blk.IsBlinded() {
+	} else if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch {
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: pb.(*ethpb.BeaconBlockBellatrix)}}, nil
-	}
-	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch && blk.IsBlinded() {
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*ethpb.BlindedBeaconBlockBellatrix)}}, nil
-	}
-	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().AltairForkEpoch {
+	} else if slots.ToEpoch(req.Slot) >= params.BeaconConfig().AltairForkEpoch {
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: pb.(*ethpb.BeaconBlockAltair)}}, nil
 	}
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: pb.(*ethpb.BeaconBlock)}}, nil
 }
 
+func emptyBlockToSign(slot types.Slot) (interfaces.SignedBeaconBlock, error) {
+	var sBlk interfaces.SignedBeaconBlock
+	var err error
+	switch {
+	case slots.ToEpoch(slot) < params.BeaconConfig().AltairForkEpoch:
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
+		}
+	case slots.ToEpoch(slot) < params.BeaconConfig().BellatrixForkEpoch:
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{Body: &ethpb.BeaconBlockBodyAltair{}}})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
+		}
+	case slots.ToEpoch(slot) < params.BeaconConfig().CapellaForkEpoch:
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{Body: &ethpb.BeaconBlockBodyBellatrix{}}})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
+		}
+	default:
+		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockCapella{Block: &ethpb.BeaconBlockCapella{Body: &ethpb.BeaconBlockBodyCapella{}}})
+		if err != nil {
+			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
+		}
+	}
+	return sBlk, err
+}
+
 // ProposeBeaconBlock is called by a proposer during its assigned slot to create a block in an attempt
 // to get it processed by the beacon node as the canonical head.
 func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {

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

@@ -3,52 +3,21 @@ package validator
 import (
 	"context"
 
-	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
-	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	synccontribution "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1/attestation/aggregation/sync_contribution"
-	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 	"go.opencensus.io/trace"
 )
 
-func (vs *Server) setSyncAggregate(ctx context.Context, blk interfaces.BeaconBlock) {
-	if blk.Version() < version.Altair {
-		return
-	}
-
-	syncAggregate, err := vs.getSyncAggregate(ctx, blk.Slot()-1, blk.ParentRoot())
-	if err != nil {
-		log.WithError(err).Error("Could not get sync aggregate")
-		emptySig := [96]byte{0xC0}
-		emptyAggregate := &ethpb.SyncAggregate{
-			SyncCommitteeBits:      make([]byte, params.BeaconConfig().SyncCommitteeSize),
-			SyncCommitteeSignature: emptySig[:],
-		}
-		if err := blk.Body().SetSyncAggregate(emptyAggregate); err != nil {
-			log.WithError(err).Error("Could not set sync aggregate")
-		}
-		return
-	}
-
-	// Can not error. We already filter block versioning at the top. Phase 0 is impossible.
-	if err := blk.Body().SetSyncAggregate(syncAggregate); err != nil {
-		log.WithError(err).Error("Could not set sync aggregate")
-	}
-}
-
 // getSyncAggregate retrieves the sync contributions from the pool to construct the sync aggregate object.
 // The contributions are filtered based on matching of the input root and slot then profitability.
 func (vs *Server) getSyncAggregate(ctx context.Context, slot types.Slot, root [32]byte) (*ethpb.SyncAggregate, error) {
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.getSyncAggregate")
 	defer span.End()
 
-	if vs.SyncCommitteePool == nil {
-		return nil, errors.New("sync committee pool is nil")
-	}
 	// Contributions have to match the input root
 	contributions, err := vs.SyncCommitteePool.SyncCommitteeContributions(slot)
 	if err != nil {

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

@@ -1,28 +0,0 @@
-package validator
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v3/config/params"
-	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
-	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v3/testing/require"
-	"github.com/prysmaticlabs/prysm/v3/testing/util"
-)
-
-func TestServer_SetSyncAggregate_EmptyCase(t *testing.T) {
-	b, err := blocks.NewBeaconBlock(util.NewBeaconBlockAltair().Block)
-	require.NoError(t, err)
-	s := &Server{} // Sever is not initialized with sync committee pool.
-	s.setSyncAggregate(context.Background(), b)
-	agg, err := b.Body().SyncAggregate()
-	require.NoError(t, err)
-
-	emptySig := [96]byte{0xC0}
-	want := &ethpb.SyncAggregate{
-		SyncCommitteeBits:      make([]byte, params.BeaconConfig().SyncCommitteeSize),
-		SyncCommitteeSignature: emptySig[:],
-	}
-	require.DeepEqual(t, want, agg)
-}

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

@@ -80,7 +80,7 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 // filter separates attestation list into two groups: valid and invalid attestations.
 // The first group passes the all the required checks for attestation to be considered for proposing.
 // And attestations from the second group should be deleted.
-func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (proposerAtts, proposerAtts) {
+func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (proposerAtts, proposerAtts, error) {
 	validAtts := make([]*ethpb.Attestation, 0, len(a))
 	invalidAtts := make([]*ethpb.Attestation, 0, len(a))
 	var attestationProcessor func(context.Context, state.BeaconState, *ethpb.Attestation) (state.BeaconState, error)
@@ -98,7 +98,7 @@ func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (propose
 		}
 	} else {
 		// Exit early if there is an unknown state type.
-		return validAtts, invalidAtts
+		return validAtts, invalidAtts, errors.Errorf("unknown state type: %v", st.Version())
 	}
 
 	for _, att := range a {
@@ -108,7 +108,7 @@ func (a proposerAtts) filter(ctx context.Context, st state.BeaconState) (propose
 		}
 		invalidAtts = append(invalidAtts, att)
 	}
-	return validAtts, invalidAtts
+	return validAtts, invalidAtts, nil
 }
 
 // sortByProfitability orders attestations by highest slot and by highest aggregation bit count.
@@ -247,7 +247,10 @@ func (vs *Server) validateAndDeleteAttsInPool(ctx context.Context, st state.Beac
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.validateAndDeleteAttsInPool")
 	defer span.End()
 
-	validAtts, invalidAtts := proposerAtts(atts).filter(ctx, st)
+	validAtts, invalidAtts, err := proposerAtts(atts).filter(ctx, st)
+	if err != nil {
+		return nil, err
+	}
 	if err := vs.deleteAttsInPool(ctx, invalidAtts); err != nil {
 		return nil, err
 	}

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

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"math/big"
 	"time"
 
 	"github.com/pkg/errors"
@@ -11,9 +12,9 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/signing"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
+	coreBlock "github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
@@ -35,38 +36,6 @@ var builderGetPayloadMissCount = promauto.NewCounter(prometheus.CounterOpts{
 // block request. This value is known as `BUILDER_PROPOSAL_DELAY_TOLERANCE` in builder spec.
 const blockBuilderTimeout = 1 * time.Second
 
-// Sets the execution data for the block. Execution data can come from local EL client or remote builder depends on validator registration and circuit breaker conditions.
-func (vs *Server) setExecutionData(ctx context.Context, blk interfaces.BeaconBlock, headState state.BeaconState) error {
-	idx := blk.ProposerIndex()
-	slot := blk.Slot()
-	if slots.ToEpoch(slot) < params.BeaconConfig().BellatrixForkEpoch {
-		return nil
-	}
-
-	canUseBuilder, err := vs.canUseBuilder(ctx, slot, idx)
-	if err != nil {
-		log.WithError(err).Warn("Proposer: failed to check if builder can be used")
-	} else if canUseBuilder {
-		h, err := vs.getPayloadHeaderFromBuilder(ctx, slot, idx)
-		if err != nil {
-			builderGetPayloadMissCount.Inc()
-			log.WithError(err).Warn("Proposer: failed to get payload header from builder")
-		} else {
-			blk.SetBlinded(true)
-			if err := blk.Body().SetExecution(h); err != nil {
-				log.WithError(err).Warn("Proposer: failed to set execution payload")
-			} else {
-				return nil
-			}
-		}
-	}
-	executionData, err := vs.getExecutionPayload(ctx, slot, idx, blk.ParentRoot(), headState)
-	if err != nil {
-		return errors.Wrap(err, "failed to get execution payload")
-	}
-	return blk.Body().SetExecution(executionData)
-}
-
 // This function retrieves the payload header given the slot number and the validator index.
 // It's a no-op if the latest head block is not versioned bellatrix.
 func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Slot, idx types.ValidatorIndex) (interfaces.ExecutionData, error) {
@@ -86,10 +55,6 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Sl
 	if err != nil {
 		return nil, err
 	}
-
-	ctx, cancel := context.WithTimeout(ctx, blockBuilderTimeout)
-	defer cancel()
-
 	bid, err := vs.BlockBuilder.GetHeader(ctx, slot, bytesutil.ToBytes32(h.BlockHash()), pk)
 	if err != nil {
 		return nil, err
@@ -98,7 +63,7 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Sl
 		return nil, errors.New("builder returned nil bid")
 	}
 
-	v := bytesutil.LittleEndianBytesToBigInt(bid.Message.Value)
+	v := new(big.Int).SetBytes(bytesutil.ReverseByteOrder(bid.Message.Value))
 	if v.String() == "0" {
 		return nil, errors.New("builder returned header with 0 bid amount")
 	}
@@ -124,7 +89,7 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Sl
 		return nil, fmt.Errorf("incorrect timestamp %d != %d", bid.Message.Header.Timestamp, uint64(t.Unix()))
 	}
 
-	if err := validateBuilderSignature(bid); err != nil {
+	if err := vs.validateBuilderSignature(bid); err != nil {
 		return nil, errors.Wrap(err, "could not validate builder signature")
 	}
 
@@ -133,14 +98,15 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Sl
 		"builderPubKey": fmt.Sprintf("%#x", bid.Message.Pubkey),
 		"blockHash":     fmt.Sprintf("%#x", bid.Message.Header.BlockHash),
 	}).Info("Received header with bid")
-	return consensusblocks.WrappedExecutionPayloadHeader(bid.Message.Header)
+
+	return coreBlock.WrappedExecutionPayloadHeader(bid.Message.Header)
 }
 
 // This function retrieves the full payload block using the input blind block. This input must be versioned as
 // bellatrix blind block. The output block will contain the full payload. The original header block
 // will be returned the block builder is not configured.
 func (vs *Server) unblindBuilderBlock(ctx context.Context, b interfaces.SignedBeaconBlock) (interfaces.SignedBeaconBlock, error) {
-	if err := consensusblocks.BeaconBlockIsNil(b); err != nil {
+	if err := coreBlock.BeaconBlockIsNil(b); err != nil {
 		return nil, err
 	}
 
@@ -247,8 +213,26 @@ func (vs *Server) unblindBuilderBlock(ctx context.Context, b interfaces.SignedBe
 	return wb, nil
 }
 
+// readyForBuilder returns true if builder is allowed to be used. Builder is only allowed to be use after the
+// first finalized checkpt has been execution-enabled.
+func (vs *Server) readyForBuilder(ctx context.Context) (bool, error) {
+	cp := vs.FinalizationFetcher.FinalizedCheckpt()
+	// Checkpoint root is zero means we are still at genesis epoch.
+	if bytesutil.ToBytes32(cp.Root) == params.BeaconConfig().ZeroHash {
+		return false, nil
+	}
+	b, err := vs.BeaconDB.Block(ctx, bytesutil.ToBytes32(cp.Root))
+	if err != nil {
+		return false, err
+	}
+	if err = consensusblocks.BeaconBlockIsNil(b); err != nil {
+		return false, err
+	}
+	return blocks.IsExecutionBlock(b.Block().Body())
+}
+
 // Validates builder signature and returns an error if the signature is invalid.
-func validateBuilderSignature(bid *ethpb.SignedBuilderBid) error {
+func (vs *Server) validateBuilderSignature(bid *ethpb.SignedBuilderBid) error {
 	d, err := signing.ComputeDomain(params.BeaconConfig().DomainApplicationBuilder,
 		nil, /* fork version */
 		nil /* genesis val root */)

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

@@ -5,14 +5,29 @@ import (
 	"testing"
 	"time"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	blockchainTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain/testing"
 	builderTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/builder/testing"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/cache"
+	consensusblocks "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/signing"
+	prysmtime "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/time"
+	dbTest "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
+	mockExecution "github.com/prysmaticlabs/prysm/v3/beacon-chain/execution/testing"
+	doublylinkedtree "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/doubly-linked-tree"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/attestations"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/slashings"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/synccommittee"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/voluntaryexits"
+	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state/stategen"
+	mockSync "github.com/prysmaticlabs/prysm/v3/beacon-chain/sync/initial-sync/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
+	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v3/encoding/ssz"
@@ -21,6 +36,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 	"github.com/prysmaticlabs/prysm/v3/testing/util"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 func TestServer_getPayloadHeader(t *testing.T) {
@@ -158,11 +174,7 @@ func TestServer_getPayloadHeader(t *testing.T) {
 				require.ErrorContains(t, tc.err, err)
 			} else {
 				require.NoError(t, err)
-				if tc.returnedHeader != nil {
-					want, err := blocks.WrappedExecutionPayloadHeader(tc.returnedHeader)
-					require.NoError(t, err)
-					require.DeepEqual(t, want, h)
-				}
+				require.DeepEqual(t, tc.returnedHeader, h)
 			}
 		})
 	}
@@ -307,6 +319,406 @@ func TestServer_getBuilderBlock(t *testing.T) {
 	}
 }
 
+func TestServer_readyForBuilder(t *testing.T) {
+	ctx := context.Background()
+	vs := &Server{BeaconDB: dbTest.SetupDB(t)}
+	cs := &blockchainTest.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{}} // Checkpoint root is zeros.
+	vs.FinalizationFetcher = cs
+	ready, err := vs.readyForBuilder(ctx)
+	require.NoError(t, err)
+	require.Equal(t, false, ready)
+
+	b := util.NewBeaconBlockBellatrix()
+	wb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	wbr, err := wb.Block().HashTreeRoot()
+	require.NoError(t, err)
+
+	b1 := util.NewBeaconBlockBellatrix()
+	b1.Block.Body.ExecutionPayload.BlockNumber = 1 // Execution enabled.
+	wb1, err := blocks.NewSignedBeaconBlock(b1)
+	require.NoError(t, err)
+	wbr1, err := wb1.Block().HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, vs.BeaconDB.SaveBlock(ctx, wb))
+	require.NoError(t, vs.BeaconDB.SaveBlock(ctx, wb1))
+
+	// Ready is false given finalized block does not have execution.
+	cs = &blockchainTest.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: wbr[:]}}
+	vs.FinalizationFetcher = cs
+	ready, err = vs.readyForBuilder(ctx)
+	require.NoError(t, err)
+	require.Equal(t, false, ready)
+
+	// Ready is true given finalized block has execution.
+	cs = &blockchainTest.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: wbr1[:]}}
+	vs.FinalizationFetcher = cs
+	ready, err = vs.readyForBuilder(ctx)
+	require.NoError(t, err)
+	require.Equal(t, true, ready)
+}
+
+func TestServer_GetBellatrixBeaconBlock_HappyCase(t *testing.T) {
+	db := dbTest.SetupDB(t)
+	ctx := context.Background()
+	hook := logTest.NewGlobal()
+
+	terminalBlockHash := bytesutil.PadTo([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 32)
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.BellatrixForkEpoch = 2
+	cfg.AltairForkEpoch = 1
+	cfg.TerminalBlockHash = common.BytesToHash(terminalBlockHash)
+	cfg.TerminalBlockHashActivationEpoch = 2
+	params.OverrideBeaconConfig(cfg)
+
+	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
+	stateRoot, err := beaconState.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	genesis := consensusblocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := blocks.NewSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
+
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+	require.NoError(t, err)
+
+	emptyPayload := &v1.ExecutionPayload{
+		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),
+	}
+	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Slot:       bellatrixSlot + 1,
+			ParentRoot: parentRoot[:],
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				RandaoReveal:     genesis.Block.Body.RandaoReveal,
+				Graffiti:         genesis.Block.Body.Graffiti,
+				Eth1Data:         genesis.Block.Body.Eth1Data,
+				SyncAggregate:    &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+				ExecutionPayload: emptyPayload,
+			},
+		},
+		Signature: genesis.Signature,
+	}
+
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
+
+	proposerServer := &Server{
+		HeadFetcher:       &blockchainTest.ChainService{State: beaconState, Root: parentRoot[:], Optimistic: false},
+		TimeFetcher:       &blockchainTest.ChainService{Genesis: time.Now()},
+		SyncChecker:       &mockSync.Sync{IsSyncing: false},
+		BlockReceiver:     &blockchainTest.ChainService{},
+		HeadUpdater:       &blockchainTest.ChainService{},
+		ChainStartFetcher: &mockExecution.Chain{},
+		Eth1InfoFetcher:   &mockExecution.Chain{},
+		MockEth1Votes:     true,
+		AttPool:           attestations.NewPool(),
+		SlashingsPool:     slashings.NewPool(),
+		ExitPool:          voluntaryexits.NewPool(),
+		StateGen:          stategen.New(db, doublylinkedtree.New()),
+		SyncCommitteePool: synccommittee.NewStore(),
+		ExecutionEngineCaller: &mockExecution.EngineClient{
+			PayloadIDBytes:   &v1.PayloadIDBytes{1},
+			ExecutionPayload: emptyPayload,
+		},
+		BeaconDB:               db,
+		ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
+		BlockBuilder:           &builderTest.MockBuilderService{},
+	}
+	proposerServer.ProposerSlotIndexCache.SetProposerAndPayloadIDs(17, 11, [8]byte{'a'}, parentRoot)
+
+	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
+	require.NoError(t, err)
+
+	block, err := proposerServer.getBellatrixBeaconBlock(ctx, &ethpb.BlockRequest{
+		Slot:         bellatrixSlot + 1,
+		RandaoReveal: randaoReveal,
+	})
+	require.NoError(t, err)
+	bellatrixBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Bellatrix)
+	require.Equal(t, true, ok)
+	require.LogsContain(t, hook, "Computed state root")
+	require.DeepEqual(t, emptyPayload, bellatrixBlk.Bellatrix.Body.ExecutionPayload) // Payload should equal.
+}
+
+func TestServer_GetBellatrixBeaconBlock_LocalProgressingWithBuilderSkipped(t *testing.T) {
+	db := dbTest.SetupDB(t)
+	ctx := context.Background()
+	hook := logTest.NewGlobal()
+
+	terminalBlockHash := bytesutil.PadTo([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 32)
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.BellatrixForkEpoch = 2
+	cfg.AltairForkEpoch = 1
+	cfg.TerminalBlockHash = common.BytesToHash(terminalBlockHash)
+	cfg.TerminalBlockHashActivationEpoch = 2
+	params.OverrideBeaconConfig(cfg)
+
+	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
+	stateRoot, err := beaconState.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	genesis := consensusblocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := blocks.NewSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
+
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+	require.NoError(t, err)
+
+	emptyPayload := &v1.ExecutionPayload{
+		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),
+	}
+	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Slot:       bellatrixSlot + 1,
+			ParentRoot: parentRoot[:],
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				RandaoReveal:     genesis.Block.Body.RandaoReveal,
+				Graffiti:         genesis.Block.Body.Graffiti,
+				Eth1Data:         genesis.Block.Body.Eth1Data,
+				SyncAggregate:    &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+				ExecutionPayload: emptyPayload,
+			},
+		},
+		Signature: genesis.Signature,
+	}
+
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
+
+	proposerServer := &Server{
+		HeadFetcher:       &blockchainTest.ChainService{State: beaconState, Root: parentRoot[:], Optimistic: false},
+		TimeFetcher:       &blockchainTest.ChainService{Genesis: time.Now()},
+		SyncChecker:       &mockSync.Sync{IsSyncing: false},
+		BlockReceiver:     &blockchainTest.ChainService{},
+		HeadUpdater:       &blockchainTest.ChainService{},
+		ChainStartFetcher: &mockExecution.Chain{},
+		Eth1InfoFetcher:   &mockExecution.Chain{},
+		MockEth1Votes:     true,
+		AttPool:           attestations.NewPool(),
+		SlashingsPool:     slashings.NewPool(),
+		ExitPool:          voluntaryexits.NewPool(),
+		StateGen:          stategen.New(db, doublylinkedtree.New()),
+		SyncCommitteePool: synccommittee.NewStore(),
+		ExecutionEngineCaller: &mockExecution.EngineClient{
+			PayloadIDBytes:   &v1.PayloadIDBytes{1},
+			ExecutionPayload: emptyPayload,
+		},
+		BeaconDB:               db,
+		ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
+		BlockBuilder:           &builderTest.MockBuilderService{},
+	}
+	proposerServer.ProposerSlotIndexCache.SetProposerAndPayloadIDs(17, 11, [8]byte{'a'}, parentRoot)
+
+	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
+	require.NoError(t, err)
+
+	// Configure builder, this should fail if it's not local engine processing
+	proposerServer.BlockBuilder = &builderTest.MockBuilderService{HasConfigured: true, ErrGetHeader: errors.New("bad)")}
+	block, err := proposerServer.getBellatrixBeaconBlock(ctx, &ethpb.BlockRequest{
+		Slot:         bellatrixSlot + 1,
+		RandaoReveal: randaoReveal,
+		SkipMevBoost: true,
+	})
+	require.NoError(t, err)
+	bellatrixBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Bellatrix)
+	require.Equal(t, true, ok)
+	require.LogsContain(t, hook, "Computed state root")
+	require.DeepEqual(t, emptyPayload, bellatrixBlk.Bellatrix.Body.ExecutionPayload) // Payload should equal.
+}
+
+func TestServer_GetBellatrixBeaconBlock_BuilderCase(t *testing.T) {
+	db := dbTest.SetupDB(t)
+	ctx := context.Background()
+	hook := logTest.NewGlobal()
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.BellatrixForkEpoch = 2
+	cfg.AltairForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
+
+	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
+	stateRoot, err := beaconState.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	genesis := consensusblocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := blocks.NewSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wsb), "Could not save genesis block")
+
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+	require.NoError(t, err)
+
+	emptyPayload := &v1.ExecutionPayload{
+		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),
+	}
+	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Slot:       bellatrixSlot + 1,
+			ParentRoot: parentRoot[:],
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				RandaoReveal:     genesis.Block.Body.RandaoReveal,
+				Graffiti:         genesis.Block.Body.Graffiti,
+				Eth1Data:         genesis.Block.Body.Eth1Data,
+				SyncAggregate:    &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+				ExecutionPayload: emptyPayload,
+			},
+		},
+		Signature: genesis.Signature,
+	}
+
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
+
+	b1 := util.NewBeaconBlockBellatrix()
+	b1.Block.Body.ExecutionPayload.BlockNumber = 1 // Execution enabled.
+	wb1, err := blocks.NewSignedBeaconBlock(b1)
+	require.NoError(t, err)
+	wbr1, err := wb1.Block().HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wb1))
+
+	random, err := helpers.RandaoMix(beaconState, prysmtime.CurrentEpoch(beaconState))
+	require.NoError(t, err)
+
+	tstamp, err := slots.ToTime(beaconState.GenesisTime(), bellatrixSlot+1)
+	require.NoError(t, err)
+	h := &v1.ExecutionPayloadHeader{
+		BlockNumber:      123,
+		GasLimit:         456,
+		GasUsed:          789,
+		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:       random,
+		BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+		BlockHash:        make([]byte, fieldparams.RootLength),
+		TransactionsRoot: make([]byte, fieldparams.RootLength),
+		ExtraData:        make([]byte, 0),
+		Timestamp:        uint64(tstamp.Unix()),
+	}
+
+	proposerServer := &Server{
+		FinalizationFetcher: &blockchainTest.ChainService{FinalizedCheckPoint: &ethpb.Checkpoint{Root: wbr1[:]}},
+		HeadFetcher:         &blockchainTest.ChainService{State: beaconState, Root: parentRoot[:], Optimistic: false, Block: wb1},
+		TimeFetcher:         &blockchainTest.ChainService{Genesis: time.Unix(int64(beaconState.GenesisTime()), 0)},
+		SyncChecker:         &mockSync.Sync{IsSyncing: false},
+		BlockReceiver:       &blockchainTest.ChainService{},
+		HeadUpdater:         &blockchainTest.ChainService{},
+		ForkFetcher:         &blockchainTest.ChainService{Fork: &ethpb.Fork{}},
+		GenesisFetcher:      &blockchainTest.ChainService{},
+		ChainStartFetcher:   &mockExecution.Chain{},
+		Eth1InfoFetcher:     &mockExecution.Chain{},
+		MockEth1Votes:       true,
+		AttPool:             attestations.NewPool(),
+		SlashingsPool:       slashings.NewPool(),
+		ExitPool:            voluntaryexits.NewPool(),
+		StateGen:            stategen.New(db, doublylinkedtree.New()),
+		SyncCommitteePool:   synccommittee.NewStore(),
+		ExecutionEngineCaller: &mockExecution.EngineClient{
+			PayloadIDBytes:   &v1.PayloadIDBytes{1},
+			ExecutionPayload: emptyPayload,
+		},
+		BeaconDB: db,
+	}
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	bid := &ethpb.BuilderBid{
+		Header: h,
+		Pubkey: sk.PublicKey().Marshal(),
+		Value:  bytesutil.PadTo([]byte{1, 2, 3}, 32),
+	}
+	d := params.BeaconConfig().DomainApplicationBuilder
+	domain, err := signing.ComputeDomain(d, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(bid, domain)
+	require.NoError(t, err)
+	sBid := &ethpb.SignedBuilderBid{
+		Message:   bid,
+		Signature: sk.Sign(sr[:]).Marshal(),
+	}
+	proposerServer.BlockBuilder = &builderTest.MockBuilderService{HasConfigured: true, Bid: sBid}
+	proposerServer.ForkFetcher = &blockchainTest.ChainService{ForkChoiceStore: doublylinkedtree.New()}
+	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
+	require.NoError(t, err)
+
+	require.NoError(t, proposerServer.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []types.ValidatorIndex{11},
+		[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: bytesutil.PadTo([]byte{}, fieldparams.FeeRecipientLength), Pubkey: bytesutil.PadTo([]byte{}, fieldparams.BLSPubkeyLength)}}))
+
+	params.SetupTestConfigCleanup(t)
+	cfg.MaxBuilderConsecutiveMissedSlots = bellatrixSlot + 1
+	cfg.MaxBuilderEpochMissedSlots = 32
+	params.OverrideBeaconConfig(cfg)
+
+	block, err := proposerServer.getBellatrixBeaconBlock(ctx, &ethpb.BlockRequest{
+		Slot:         bellatrixSlot + 1,
+		RandaoReveal: randaoReveal,
+	})
+	require.NoError(t, err)
+	bellatrixBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_BlindedBellatrix)
+	require.Equal(t, true, ok)
+	require.LogsContain(t, hook, "Computed state root")
+	require.DeepEqual(t, h, bellatrixBlk.BlindedBellatrix.Body.ExecutionPayloadHeader) // Payload header should equal.
+}
+
 func TestServer_validateBuilderSignature(t *testing.T) {
 	sk, err := bls.RandKey()
 	require.NoError(t, err)

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

@@ -58,7 +58,7 @@ func (vs *Server) circuitBreakBuilder(s types.Slot) (bool, error) {
 			"currentSlot":                    s,
 			"highestReceivedSlot":            highestReceivedSlot,
 			"maxConsecutiveSkipSlotsAllowed": maxConsecutiveSkipSlotsAllowed,
-		}).Warn("Circuit breaker activated due to missing consecutive slot. Ignore if mev-boost is not used")
+		}).Warn("Builder circuit breaker activated due to missing consecutive slot")
 		return true, nil
 	}
 
@@ -81,7 +81,7 @@ func (vs *Server) circuitBreakBuilder(s types.Slot) (bool, error) {
 		log.WithFields(logrus.Fields{
 			"totalMissed":              diff,
 			"maxEpochSkipSlotsAllowed": maxEpochSkipSlotsAllowed,
-		}).Warn("Circuit breaker activated due to missing enough slots last epoch. Ignore if mev-boost is not used")
+		}).Warn("Builder circuit breaker activated due to missing enough slots last epoch")
 		return true, nil
 	}
 

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

@@ -34,7 +34,7 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 		err,
 	)
 	require.Equal(t, true, b)
-	require.LogsContain(t, hook, "Circuit breaker activated due to missing consecutive slot. Ignore if mev-boost is not used")
+	require.LogsContain(t, hook, "Builder circuit breaker activated due to missing consecutive slot")
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
@@ -56,7 +56,7 @@ func TestServer_circuitBreakBuilder(t *testing.T) {
 	b, err = s.circuitBreakBuilder(params.BeaconConfig().SlotsPerEpoch + 1)
 	require.NoError(t, err)
 	require.Equal(t, true, b)
-	require.LogsContain(t, hook, "Circuit breaker activated due to missing enough slots last epoch. Ignore if mev-boost is not used")
+	require.LogsContain(t, hook, "Builder circuit breaker activated due to missing enough slots last epoch")
 
 	want := params.BeaconConfig().SlotsPerEpoch - params.BeaconConfig().MaxBuilderEpochMissedSlots
 	for i := types.Slot(2); i <= want+2; i++ {

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

@@ -1,29 +0,0 @@
-package validator
-
-import (
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
-	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v3/runtime/version"
-)
-
-// Sets the bls to exec data for a block.
-func (vs *Server) setBlsToExecData(blk interfaces.BeaconBlock, headState state.BeaconState) {
-	if blk.Version() < version.Capella {
-		return
-	}
-	if err := blk.Body().SetBLSToExecutionChanges([]*ethpb.SignedBLSToExecutionChange{}); err != nil {
-		log.WithError(err).Error("Could not set bls to execution data in block")
-		return
-	}
-	changes, err := vs.BLSChangesPool.BLSToExecChangesForInclusion(headState)
-	if err != nil {
-		log.WithError(err).Error("Could not get bls to execution changes")
-		return
-	} else {
-		if err := blk.Body().SetBLSToExecutionChanges(changes); err != nil {
-			log.WithError(err).Error("Could not set bls to execution changes")
-			return
-		}
-	}
-}

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

@@ -40,9 +40,14 @@ var (
 	})
 )
 
-// This returns the execution payload of a given slot. The function has full awareness of pre and post merge.
+// This returns the execution payload of a given slot.
+// The function has full awareness of pre and post merge.
 // The payload is computed given the respected time of merge.
-func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx types.ValidatorIndex, headRoot [32]byte, st state.BeaconState) (interfaces.ExecutionData, error) {
+func (vs *Server) getExecutionPayload(ctx context.Context,
+	slot types.Slot,
+	vIdx types.ValidatorIndex,
+	headRoot [32]byte,
+	st state.BeaconState) (interfaces.ExecutionData, error) {
 	proposerID, payloadId, ok := vs.ProposerSlotIndexCache.GetProposerPayloadIDs(slot, headRoot)
 	feeRecipient := params.BeaconConfig().DefaultFeeRecipient
 	recipient, err := vs.BeaconDB.FeeRecipientByValidatorID(ctx, vIdx)
@@ -72,7 +77,7 @@ func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx
 		payload, err := vs.ExecutionEngineCaller.GetPayload(ctx, pid, slot)
 		switch {
 		case err == nil:
-			warnIfFeeRecipientDiffers(payload, feeRecipient)
+			warnIfFeeRecipientDiffers(payload.FeeRecipient(), feeRecipient)
 			return payload, nil
 		case errors.Is(err, context.DeadlineExceeded):
 		default:
@@ -99,14 +104,14 @@ func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx
 		parentHash = header.BlockHash()
 	} else {
 		if activationEpochNotReached(slot) {
-			return consensusblocks.WrappedExecutionPayload(emptyPayload())
+			return emptyPayload()
 		}
 		parentHash, hasTerminalBlock, err = vs.getTerminalBlockHashIfExists(ctx, uint64(t.Unix()))
 		if err != nil {
 			return nil, err
 		}
 		if !hasTerminalBlock {
-			return consensusblocks.WrappedExecutionPayload(emptyPayload())
+			return emptyPayload()
 		}
 	}
 	payloadIDCacheMiss.Inc()
@@ -142,18 +147,15 @@ func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx
 		FinalizedBlockHash: finalizedBlockHash,
 	}
 
-	p := &enginev1.PayloadAttributes{
+	p, err := payloadattribute.New(&enginev1.PayloadAttributes{
 		Timestamp:             uint64(t.Unix()),
 		PrevRandao:            random,
 		SuggestedFeeRecipient: feeRecipient.Bytes(),
-	}
-
-	// This will change in subsequent hardforks like Capella.
-	pa, err := payloadattribute.New(p)
+	})
 	if err != nil {
 		return nil, err
 	}
-	payloadID, _, err := vs.ExecutionEngineCaller.ForkchoiceUpdated(ctx, f, pa)
+	payloadID, _, err := vs.ExecutionEngineCaller.ForkchoiceUpdated(ctx, f, p)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not prepare payload")
 	}
@@ -164,18 +166,18 @@ func (vs *Server) getExecutionPayload(ctx context.Context, slot types.Slot, vIdx
 	if err != nil {
 		return nil, err
 	}
-	warnIfFeeRecipientDiffers(payload, feeRecipient)
+	warnIfFeeRecipientDiffers(payload.FeeRecipient(), feeRecipient)
 	return payload, nil
 }
 
 // warnIfFeeRecipientDiffers logs a warning if the fee recipient in the included payload does not
 // match the requested one.
-func warnIfFeeRecipientDiffers(payload interfaces.ExecutionData, feeRecipient common.Address) {
+func warnIfFeeRecipientDiffers(payloadRecipient []byte, feeRecipient common.Address) {
 	// Warn if the fee recipient is not the value we expect.
-	if payload != nil && !bytes.Equal(payload.FeeRecipient(), feeRecipient[:]) {
+	if !bytes.Equal(payloadRecipient, feeRecipient[:]) {
 		logrus.WithFields(logrus.Fields{
 			"wantedFeeRecipient": fmt.Sprintf("%#x", feeRecipient),
-			"received":           fmt.Sprintf("%#x", payload.FeeRecipient()),
+			"received":           fmt.Sprintf("%#x", payloadRecipient),
 		}).Warn("Fee recipient address from execution client is not what was expected. " +
 			"It is possible someone has compromised your client to try and take your transaction fees")
 	}
@@ -227,8 +229,8 @@ func activationEpochNotReached(slot types.Slot) bool {
 	return false
 }
 
-func emptyPayload() *enginev1.ExecutionPayload {
-	return &enginev1.ExecutionPayload{
+func emptyPayload() (interfaces.ExecutionData, error) {
+	return consensusblocks.WrappedExecutionPayload(&enginev1.ExecutionPayload{
 		ParentHash:    make([]byte, fieldparams.RootLength),
 		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
 		StateRoot:     make([]byte, fieldparams.RootLength),
@@ -237,5 +239,5 @@ func emptyPayload() *enginev1.ExecutionPayload {
 		PrevRandao:    make([]byte, fieldparams.RootLength),
 		BaseFeePerGas: make([]byte, fieldparams.RootLength),
 		BlockHash:     make([]byte, fieldparams.RootLength),
-	}
+	})
 }

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

@@ -124,7 +124,7 @@ func TestServer_getExecutionPayload(t *testing.T) {
 				ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
 			}
 			vs.ProposerSlotIndexCache.SetProposerAndPayloadIDs(tt.st.Slot(), 100, [8]byte{100}, [32]byte{'a'})
-			_, err := vs.getExecutionPayload(context.Background(), tt.st.Slot(), tt.validatorIndx, [32]byte{'a'}, tt.st)
+			_, err := vs.getExecutionPayload(context.Background(), tt.st.Slot(), tt.validatorIndx, [32]byte{'a'})
 			if tt.errString != "" {
 				require.ErrorContains(t, tt.errString, err)
 			} else {
@@ -160,7 +160,7 @@ func TestServer_getExecutionPayloadContextTimeout(t *testing.T) {
 	}
 	vs.ProposerSlotIndexCache.SetProposerAndPayloadIDs(nonTransitionSt.Slot(), 100, [8]byte{100}, [32]byte{'a'})
 
-	_, err = vs.getExecutionPayload(context.Background(), nonTransitionSt.Slot(), 100, [32]byte{'a'}, nonTransitionSt)
+	_, err = vs.getExecutionPayload(context.Background(), nonTransitionSt.Slot(), 100, [32]byte{'a'})
 	require.NoError(t, err)
 }
 
@@ -205,7 +205,7 @@ func TestServer_getExecutionPayload_UnexpectedFeeRecipient(t *testing.T) {
 		BeaconDB:               beaconDB,
 		ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
 	}
-	gotPayload, err := vs.getExecutionPayload(context.Background(), transitionSt.Slot(), 0, [32]byte{}, transitionSt)
+	gotPayload, err := vs.getExecutionPayload(context.Background(), transitionSt.Slot(), 0, [32]byte{})
 	require.NoError(t, err)
 	require.NotNil(t, gotPayload)
 
@@ -217,7 +217,7 @@ func TestServer_getExecutionPayload_UnexpectedFeeRecipient(t *testing.T) {
 	payload.FeeRecipient = evilRecipientAddress[:]
 	vs.ProposerSlotIndexCache = cache.NewProposerPayloadIDsCache()
 
-	gotPayload, err = vs.getExecutionPayload(context.Background(), transitionSt.Slot(), 0, [32]byte{}, transitionSt)
+	gotPayload, err = vs.getExecutionPayload(context.Background(), transitionSt.Slot(), 0, [32]byte{})
 	require.NoError(t, err)
 	require.NotNil(t, gotPayload)
 

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

@@ -19,19 +19,14 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/signing"
 	coretime "github.com/prysmaticlabs/prysm/v3/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/db"
 	dbutil "github.com/prysmaticlabs/prysm/v3/beacon-chain/db/testing"
 	mockExecution "github.com/prysmaticlabs/prysm/v3/beacon-chain/execution/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/attestations"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/slashings"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/synccommittee"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/voluntaryexits"
 	mockp2p "github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/testing"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/rpc/testutil"
-	"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/beacon-chain/state/stategen"
 	mockSync "github.com/prysmaticlabs/prysm/v3/beacon-chain/sync/initial-sync/testing"
@@ -56,449 +51,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-func TestServer_GetBeaconBlock_Phase0(t *testing.T) {
-	db := dbutil.SetupDB(t)
-	ctx := context.Background()
-
-	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
-	stateRoot, err := beaconState.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	genesis := b.NewGenesisBlock(stateRoot[:])
-	genBlk := &ethpb.SignedBeaconBlock{
-		Block: &ethpb.BeaconBlock{
-			Slot:       genesis.Block.Slot,
-			ParentRoot: genesis.Block.ParentRoot,
-			StateRoot:  genesis.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBody{
-				RandaoReveal: genesis.Block.Body.RandaoReveal,
-				Graffiti:     genesis.Block.Body.Graffiti,
-				Eth1Data:     genesis.Block.Body.Eth1Data,
-			},
-		},
-		Signature: genesis.Signature,
-	}
-	util.SaveBlock(t, ctx, db, genBlk)
-
-	parentRoot, err := genBlk.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	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")
-
-	require.NoError(t, err, "Could not get signing root")
-	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")
-
-	proposerServer := getProposerServer(db, beaconState, parentRoot[:])
-
-	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
-	require.NoError(t, err)
-
-	graffiti := bytesutil.ToBytes32([]byte("eth2"))
-	req := &ethpb.BlockRequest{
-		Slot:         1,
-		RandaoReveal: randaoReveal,
-		Graffiti:     graffiti[:],
-	}
-	proposerSlashings, attSlashings := injectSlashings(t, beaconState, privKeys, proposerServer)
-
-	block, err := proposerServer.GetBeaconBlock(ctx, req)
-	require.NoError(t, err)
-	phase0Blk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Phase0)
-	require.Equal(t, true, ok)
-	assert.Equal(t, req.Slot, phase0Blk.Phase0.Slot)
-	assert.DeepEqual(t, parentRoot[:], phase0Blk.Phase0.ParentRoot, "Expected block to have correct parent root")
-	assert.DeepEqual(t, randaoReveal, phase0Blk.Phase0.Body.RandaoReveal, "Expected block to have correct randao reveal")
-	assert.DeepEqual(t, req.Graffiti, phase0Blk.Phase0.Body.Graffiti, "Expected block to have correct Graffiti")
-	assert.Equal(t, params.BeaconConfig().MaxProposerSlashings, uint64(len(phase0Blk.Phase0.Body.ProposerSlashings)))
-	assert.DeepEqual(t, proposerSlashings, phase0Blk.Phase0.Body.ProposerSlashings)
-	assert.Equal(t, params.BeaconConfig().MaxAttesterSlashings, uint64(len(phase0Blk.Phase0.Body.AttesterSlashings)))
-	assert.DeepEqual(t, attSlashings, phase0Blk.Phase0.Body.AttesterSlashings)
-}
-
-func TestServer_GetBeaconBlock_Altair(t *testing.T) {
-	db := dbutil.SetupDB(t)
-	ctx := context.Background()
-
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.AltairForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
-	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
-
-	stateRoot, err := beaconState.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	genesis := b.NewGenesisBlock(stateRoot[:])
-	util.SaveBlock(t, ctx, db, genesis)
-
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	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")
-
-	altairSlot, err := slots.EpochStart(params.BeaconConfig().AltairForkEpoch)
-	require.NoError(t, err)
-
-	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
-	genAltair := &ethpb.SignedBeaconBlockAltair{
-		Block: &ethpb.BeaconBlockAltair{
-			Slot:       altairSlot + 1,
-			ParentRoot: parentRoot[:],
-			StateRoot:  genesis.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBodyAltair{
-				RandaoReveal:  genesis.Block.Body.RandaoReveal,
-				Graffiti:      genesis.Block.Body.Graffiti,
-				Eth1Data:      genesis.Block.Body.Eth1Data,
-				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
-			},
-		},
-		Signature: genesis.Signature,
-	}
-
-	blkRoot, err := genAltair.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
-	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
-
-	proposerServer := getProposerServer(db, beaconState, parentRoot[:])
-
-	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
-	require.NoError(t, err)
-
-	graffiti := bytesutil.ToBytes32([]byte("eth2"))
-	require.NoError(t, err)
-	req := &ethpb.BlockRequest{
-		Slot:         altairSlot + 1,
-		RandaoReveal: randaoReveal,
-		Graffiti:     graffiti[:],
-	}
-	proposerSlashings, attSlashings := injectSlashings(t, beaconState, privKeys, proposerServer)
-
-	block, err := proposerServer.GetBeaconBlock(ctx, req)
-	require.NoError(t, err)
-	altairBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Altair)
-	require.Equal(t, true, ok)
-
-	assert.Equal(t, req.Slot, altairBlk.Altair.Slot)
-	assert.DeepEqual(t, parentRoot[:], altairBlk.Altair.ParentRoot, "Expected block to have correct parent root")
-	assert.DeepEqual(t, randaoReveal, altairBlk.Altair.Body.RandaoReveal, "Expected block to have correct randao reveal")
-	assert.DeepEqual(t, req.Graffiti, altairBlk.Altair.Body.Graffiti, "Expected block to have correct Graffiti")
-	assert.Equal(t, params.BeaconConfig().MaxProposerSlashings, uint64(len(altairBlk.Altair.Body.ProposerSlashings)))
-	assert.DeepEqual(t, proposerSlashings, altairBlk.Altair.Body.ProposerSlashings)
-	assert.Equal(t, params.BeaconConfig().MaxAttesterSlashings, uint64(len(altairBlk.Altair.Body.AttesterSlashings)))
-	assert.DeepEqual(t, attSlashings, altairBlk.Altair.Body.AttesterSlashings)
-}
-
-func TestServer_GetBeaconBlock_Bellatrix(t *testing.T) {
-	db := dbutil.SetupDB(t)
-	ctx := context.Background()
-	hook := logTest.NewGlobal()
-
-	terminalBlockHash := bytesutil.PadTo([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 32)
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.BellatrixForkEpoch = 2
-	cfg.AltairForkEpoch = 1
-	cfg.TerminalBlockHash = common.BytesToHash(terminalBlockHash)
-	cfg.TerminalBlockHashActivationEpoch = 2
-	params.OverrideBeaconConfig(cfg)
-	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
-
-	stateRoot, err := beaconState.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	genesis := b.NewGenesisBlock(stateRoot[:])
-	util.SaveBlock(t, ctx, db, genesis)
-
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	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")
-
-	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
-	require.NoError(t, err)
-
-	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot:       bellatrixSlot + 1,
-			ParentRoot: parentRoot[:],
-			StateRoot:  genesis.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				RandaoReveal:  genesis.Block.Body.RandaoReveal,
-				Graffiti:      genesis.Block.Body.Graffiti,
-				Eth1Data:      genesis.Block.Body.Eth1Data,
-				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
-				ExecutionPayload: &enginev1.ExecutionPayload{
-					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,
-	}
-
-	blkRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
-	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
-
-	c := mockExecution.New()
-	c.HashesByHeight[0] = terminalBlockHash
-	random, err := helpers.RandaoMix(beaconState, slots.ToEpoch(beaconState.Slot()))
-	require.NoError(t, err)
-	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), bellatrixSlot+1)
-	require.NoError(t, err)
-
-	payload := &enginev1.ExecutionPayload{
-		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:    random,
-		BaseFeePerGas: make([]byte, fieldparams.RootLength),
-		BlockHash:     make([]byte, fieldparams.RootLength),
-		Transactions:  make([][]byte, 0),
-		ExtraData:     make([]byte, 0),
-		BlockNumber:   1,
-		GasLimit:      2,
-		GasUsed:       3,
-		Timestamp:     uint64(timeStamp.Unix()),
-	}
-
-	proposerServer := getProposerServer(db, beaconState, parentRoot[:])
-	proposerServer.Eth1BlockFetcher = c
-	proposerServer.ExecutionEngineCaller = &mockExecution.EngineClient{
-		PayloadIDBytes:   &enginev1.PayloadIDBytes{1},
-		ExecutionPayload: payload,
-	}
-
-	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
-	require.NoError(t, err)
-
-	graffiti := bytesutil.ToBytes32([]byte("eth2"))
-	require.NoError(t, err)
-	req := &ethpb.BlockRequest{
-		Slot:         bellatrixSlot + 1,
-		RandaoReveal: randaoReveal,
-		Graffiti:     graffiti[:],
-	}
-
-	block, err := proposerServer.GetBeaconBlock(ctx, req)
-	require.NoError(t, err)
-	bellatrixBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Bellatrix)
-	require.Equal(t, true, ok)
-
-	assert.Equal(t, req.Slot, bellatrixBlk.Bellatrix.Slot)
-	assert.DeepEqual(t, parentRoot[:], bellatrixBlk.Bellatrix.ParentRoot, "Expected block to have correct parent root")
-	assert.DeepEqual(t, randaoReveal, bellatrixBlk.Bellatrix.Body.RandaoReveal, "Expected block to have correct randao reveal")
-	assert.DeepEqual(t, req.Graffiti, bellatrixBlk.Bellatrix.Body.Graffiti, "Expected block to have correct Graffiti")
-
-	require.LogsContain(t, hook, "Fee recipient is currently using the burn address")
-	require.DeepEqual(t, payload, bellatrixBlk.Bellatrix.Body.ExecutionPayload) // Payload should equal.
-
-	// Operator sets default fee recipient to not be burned through beacon node cli.
-	newHook := logTest.NewGlobal()
-	params.SetupTestConfigCleanup(t)
-	cfg = params.MinimalSpecConfig().Copy()
-	cfg.DefaultFeeRecipient = common.Address{'b'}
-	params.OverrideBeaconConfig(cfg)
-	_, err = proposerServer.GetBeaconBlock(ctx, req)
-	require.NoError(t, err)
-	require.LogsDoNotContain(t, newHook, "Fee recipient is currently using the burn address")
-}
-
-func TestServer_GetBeaconBlock_Capella(t *testing.T) {
-	db := dbutil.SetupDB(t)
-	ctx := context.Background()
-	transition.SkipSlotCache.Disable()
-
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.CapellaForkEpoch = 3
-	cfg.BellatrixForkEpoch = 2
-	cfg.AltairForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
-	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
-
-	stateRoot, err := beaconState.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	genesis := b.NewGenesisBlock(stateRoot[:])
-	util.SaveBlock(t, ctx, db, genesis)
-
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	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")
-
-	capellaSlot, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
-	require.NoError(t, err)
-
-	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
-	blk := &ethpb.SignedBeaconBlockCapella{
-		Block: &ethpb.BeaconBlockCapella{
-			Slot:       capellaSlot + 1,
-			ParentRoot: parentRoot[:],
-			StateRoot:  genesis.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBodyCapella{
-				RandaoReveal:  genesis.Block.Body.RandaoReveal,
-				Graffiti:      genesis.Block.Body.Graffiti,
-				Eth1Data:      genesis.Block.Body.Eth1Data,
-				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
-				ExecutionPayload: &enginev1.ExecutionPayloadCapella{
-					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,
-	}
-
-	blkRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
-	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
-
-	random, err := helpers.RandaoMix(beaconState, slots.ToEpoch(beaconState.Slot()))
-	require.NoError(t, err)
-	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), capellaSlot+1)
-	require.NoError(t, err)
-	payload := &enginev1.ExecutionPayloadCapella{
-		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:    random,
-		BaseFeePerGas: make([]byte, fieldparams.RootLength),
-		BlockHash:     make([]byte, fieldparams.RootLength),
-		Transactions:  make([][]byte, 0),
-		ExtraData:     make([]byte, 0),
-		BlockNumber:   1,
-		GasLimit:      2,
-		GasUsed:       3,
-		Timestamp:     uint64(timeStamp.Unix()),
-	}
-
-	proposerServer := getProposerServer(db, beaconState, parentRoot[:])
-	proposerServer.ExecutionEngineCaller = &mockExecution.EngineClient{
-		PayloadIDBytes:          &enginev1.PayloadIDBytes{1},
-		ExecutionPayloadCapella: payload,
-	}
-
-	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
-	require.NoError(t, err)
-
-	graffiti := bytesutil.ToBytes32([]byte("eth2"))
-	require.NoError(t, err)
-	req := &ethpb.BlockRequest{
-		Slot:         capellaSlot + 1,
-		RandaoReveal: randaoReveal,
-		Graffiti:     graffiti[:],
-	}
-
-	copiedState := beaconState.Copy()
-	copiedState, err = transition.ProcessSlots(ctx, copiedState, capellaSlot+1)
-	require.NoError(t, err)
-	change, err := util.GenerateBLSToExecutionChange(copiedState, privKeys[1], 0)
-	require.NoError(t, err)
-	proposerServer.BLSChangesPool.InsertBLSToExecChange(change)
-
-	got, err := proposerServer.GetBeaconBlock(ctx, req)
-	require.NoError(t, err)
-	require.Equal(t, 1, len(got.GetCapella().Body.BlsToExecutionChanges))
-	require.DeepEqual(t, change, got.GetCapella().Body.BlsToExecutionChanges[0])
-}
-
-func TestServer_GetBeaconBlock_Optimistic(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.BellatrixForkEpoch = 2
-	cfg.AltairForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
-
-	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
-	require.NoError(t, err)
-
-	proposerServer := &Server{
-		OptimisticModeFetcher: &mock.ChainService{Optimistic: true},
-		SyncChecker:           &mockSync.Sync{},
-		TimeFetcher:           &mock.ChainService{}}
-	req := &ethpb.BlockRequest{
-		Slot: bellatrixSlot + 1,
-	}
-	_, err = proposerServer.GetBeaconBlock(context.Background(), req)
-	s, ok := status.FromError(err)
-	require.Equal(t, true, ok)
-	require.DeepEqual(t, codes.Unavailable, s.Code())
-	require.ErrorContains(t, errOptimisticMode.Error(), err)
-}
-
-func getProposerServer(db db.HeadAccessDatabase, headState state.BeaconState, headRoot []byte) *Server {
-	return &Server{
-		HeadFetcher:           &mock.ChainService{State: headState, Root: headRoot},
-		SyncChecker:           &mockSync.Sync{IsSyncing: false},
-		BlockReceiver:         &mock.ChainService{},
-		HeadUpdater:           &mock.ChainService{},
-		ChainStartFetcher:     &mockExecution.Chain{},
-		Eth1InfoFetcher:       &mockExecution.Chain{},
-		Eth1BlockFetcher:      &mockExecution.Chain{},
-		MockEth1Votes:         true,
-		AttPool:               attestations.NewPool(),
-		SlashingsPool:         slashings.NewPool(),
-		ExitPool:              voluntaryexits.NewPool(),
-		StateGen:              stategen.New(db, doublylinkedtree.New()),
-		SyncCommitteePool:     synccommittee.NewStore(),
-		OptimisticModeFetcher: &mock.ChainService{},
-		TimeFetcher: &testutil.MockGenesisTimeFetcher{
-			Genesis: time.Now(),
-		},
-		ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
-		BeaconDB:               db,
-		BLSChangesPool:         blstoexec.NewPool(),
-	}
-}
-
-func injectSlashings(t *testing.T, st state.BeaconState, keys []bls.SecretKey, server *Server) ([]*ethpb.ProposerSlashing, []*ethpb.AttesterSlashing) {
-	proposerSlashings := make([]*ethpb.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
-	for i := types.ValidatorIndex(0); uint64(i) < params.BeaconConfig().MaxProposerSlashings; i++ {
-		proposerSlashing, err := util.GenerateProposerSlashingForValidator(st, keys[i], i /* validator index */)
-		require.NoError(t, err)
-		proposerSlashings[i] = proposerSlashing
-		err = server.SlashingsPool.InsertProposerSlashing(context.Background(), st, proposerSlashing)
-		require.NoError(t, err)
-	}
-
-	attSlashings := make([]*ethpb.AttesterSlashing, params.BeaconConfig().MaxAttesterSlashings)
-	for i := uint64(0); i < params.BeaconConfig().MaxAttesterSlashings; i++ {
-		attesterSlashing, err := util.GenerateAttesterSlashingForValidator(st, keys[i+params.BeaconConfig().MaxProposerSlashings], types.ValidatorIndex(i+params.BeaconConfig().MaxProposerSlashings) /* validator index */)
-		require.NoError(t, err)
-		attSlashings[i] = attesterSlashing
-		err = server.SlashingsPool.InsertAttesterSlashing(context.Background(), st, attesterSlashing)
-		require.NoError(t, err)
-	}
-	return proposerSlashings, attSlashings
-}
-
 func TestProposer_ProposeBlock_OK(t *testing.T) {
 	tests := []struct {
 		name  string
@@ -2362,6 +1914,382 @@ func TestProposer_DeleteAttsInPool_Aggregated(t *testing.T) {
 	assert.Equal(t, 0, len(atts), "Did not delete unaggregated attestation")
 }
 
+func TestProposer_GetBeaconBlock_PreForkEpoch(t *testing.T) {
+	db := dbutil.SetupDB(t)
+	ctx := context.Background()
+
+	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
+	stateRoot, err := beaconState.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	genesis := b.NewGenesisBlock(stateRoot[:])
+	genBlk := &ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{
+			Slot:       genesis.Block.Slot,
+			ParentRoot: genesis.Block.ParentRoot,
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBody{
+				RandaoReveal: genesis.Block.Body.RandaoReveal,
+				Graffiti:     genesis.Block.Body.Graffiti,
+				Eth1Data:     genesis.Block.Body.Eth1Data,
+			},
+		},
+		Signature: genesis.Signature,
+	}
+	util.SaveBlock(t, ctx, db, genBlk)
+
+	parentRoot, err := genBlk.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	proposerServer := &Server{
+		HeadFetcher:       &mock.ChainService{State: beaconState, Root: parentRoot[:]},
+		SyncChecker:       &mockSync.Sync{IsSyncing: false},
+		BlockReceiver:     &mock.ChainService{},
+		HeadUpdater:       &mock.ChainService{},
+		ChainStartFetcher: &mockExecution.Chain{},
+		Eth1InfoFetcher:   &mockExecution.Chain{},
+		Eth1BlockFetcher:  &mockExecution.Chain{},
+		MockEth1Votes:     true,
+		AttPool:           attestations.NewPool(),
+		SlashingsPool:     slashings.NewPool(),
+		ExitPool:          voluntaryexits.NewPool(),
+		StateGen:          stategen.New(db, doublylinkedtree.New()),
+		SyncCommitteePool: synccommittee.NewStore(),
+	}
+
+	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
+	require.NoError(t, err)
+
+	graffiti := bytesutil.ToBytes32([]byte("eth2"))
+	req := &ethpb.BlockRequest{
+		Slot:         1,
+		RandaoReveal: randaoReveal,
+		Graffiti:     graffiti[:],
+	}
+
+	proposerSlashings := make([]*ethpb.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
+	for i := types.ValidatorIndex(0); uint64(i) < params.BeaconConfig().MaxProposerSlashings; i++ {
+		proposerSlashing, err := util.GenerateProposerSlashingForValidator(
+			beaconState,
+			privKeys[i],
+			i, /* validator index */
+		)
+		require.NoError(t, err)
+		proposerSlashings[i] = proposerSlashing
+		err = proposerServer.SlashingsPool.InsertProposerSlashing(context.Background(), beaconState, proposerSlashing)
+		require.NoError(t, err)
+	}
+
+	attSlashings := make([]*ethpb.AttesterSlashing, params.BeaconConfig().MaxAttesterSlashings)
+	for i := uint64(0); i < params.BeaconConfig().MaxAttesterSlashings; i++ {
+		attesterSlashing, err := util.GenerateAttesterSlashingForValidator(
+			beaconState,
+			privKeys[i+params.BeaconConfig().MaxProposerSlashings],
+			types.ValidatorIndex(i+params.BeaconConfig().MaxProposerSlashings), /* validator index */
+		)
+		require.NoError(t, err)
+		attSlashings[i] = attesterSlashing
+		err = proposerServer.SlashingsPool.InsertAttesterSlashing(context.Background(), beaconState, attesterSlashing)
+		require.NoError(t, err)
+	}
+	block, err := proposerServer.GetBeaconBlock(ctx, req)
+	require.NoError(t, err)
+	phase0Blk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Phase0)
+	require.Equal(t, true, ok)
+
+	assert.Equal(t, req.Slot, phase0Blk.Phase0.Slot)
+	assert.DeepEqual(t, parentRoot[:], phase0Blk.Phase0.ParentRoot, "Expected block to have correct parent root")
+	assert.DeepEqual(t, randaoReveal, phase0Blk.Phase0.Body.RandaoReveal, "Expected block to have correct randao reveal")
+	assert.DeepEqual(t, req.Graffiti, phase0Blk.Phase0.Body.Graffiti, "Expected block to have correct Graffiti")
+	assert.Equal(t, params.BeaconConfig().MaxProposerSlashings, uint64(len(phase0Blk.Phase0.Body.ProposerSlashings)))
+	assert.DeepEqual(t, proposerSlashings, phase0Blk.Phase0.Body.ProposerSlashings)
+	assert.Equal(t, params.BeaconConfig().MaxAttesterSlashings, uint64(len(phase0Blk.Phase0.Body.AttesterSlashings)))
+	assert.DeepEqual(t, attSlashings, phase0Blk.Phase0.Body.AttesterSlashings)
+}
+
+func TestProposer_GetBeaconBlock_PostForkEpoch(t *testing.T) {
+	db := dbutil.SetupDB(t)
+	ctx := context.Background()
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.AltairForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
+	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
+
+	stateRoot, err := beaconState.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	genesis := b.NewGenesisBlock(stateRoot[:])
+	util.SaveBlock(t, ctx, db, genesis)
+
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	altairSlot, err := slots.EpochStart(params.BeaconConfig().AltairForkEpoch)
+	require.NoError(t, err)
+
+	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+	genAltair := &ethpb.SignedBeaconBlockAltair{
+		Block: &ethpb.BeaconBlockAltair{
+			Slot:       altairSlot + 1,
+			ParentRoot: parentRoot[:],
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBodyAltair{
+				RandaoReveal:  genesis.Block.Body.RandaoReveal,
+				Graffiti:      genesis.Block.Body.Graffiti,
+				Eth1Data:      genesis.Block.Body.Eth1Data,
+				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+			},
+		},
+		Signature: genesis.Signature,
+	}
+
+	blkRoot, err := genAltair.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
+
+	proposerServer := &Server{
+		HeadFetcher:       &mock.ChainService{State: beaconState, Root: parentRoot[:]},
+		SyncChecker:       &mockSync.Sync{IsSyncing: false},
+		BlockReceiver:     &mock.ChainService{},
+		HeadUpdater:       &mock.ChainService{},
+		ChainStartFetcher: &mockExecution.Chain{},
+		Eth1InfoFetcher:   &mockExecution.Chain{},
+		Eth1BlockFetcher:  &mockExecution.Chain{},
+		MockEth1Votes:     true,
+		AttPool:           attestations.NewPool(),
+		SlashingsPool:     slashings.NewPool(),
+		ExitPool:          voluntaryexits.NewPool(),
+		StateGen:          stategen.New(db, doublylinkedtree.New()),
+		SyncCommitteePool: synccommittee.NewStore(),
+	}
+
+	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
+	require.NoError(t, err)
+
+	graffiti := bytesutil.ToBytes32([]byte("eth2"))
+	require.NoError(t, err)
+	req := &ethpb.BlockRequest{
+		Slot:         altairSlot + 1,
+		RandaoReveal: randaoReveal,
+		Graffiti:     graffiti[:],
+	}
+
+	proposerSlashings := make([]*ethpb.ProposerSlashing, params.BeaconConfig().MaxProposerSlashings)
+	for i := types.ValidatorIndex(0); uint64(i) < params.BeaconConfig().MaxProposerSlashings; i++ {
+		proposerSlashing, err := util.GenerateProposerSlashingForValidator(
+			beaconState,
+			privKeys[i],
+			i, /* validator index */
+		)
+		require.NoError(t, err)
+		proposerSlashings[i] = proposerSlashing
+		err = proposerServer.SlashingsPool.InsertProposerSlashing(context.Background(), beaconState, proposerSlashing)
+		require.NoError(t, err)
+	}
+
+	attSlashings := make([]*ethpb.AttesterSlashing, params.BeaconConfig().MaxAttesterSlashings)
+	for i := uint64(0); i < params.BeaconConfig().MaxAttesterSlashings; i++ {
+		attesterSlashing, err := util.GenerateAttesterSlashingForValidator(
+			beaconState,
+			privKeys[i+params.BeaconConfig().MaxProposerSlashings],
+			types.ValidatorIndex(i+params.BeaconConfig().MaxProposerSlashings), /* validator index */
+		)
+		require.NoError(t, err)
+		attSlashings[i] = attesterSlashing
+		err = proposerServer.SlashingsPool.InsertAttesterSlashing(context.Background(), beaconState, attesterSlashing)
+		require.NoError(t, err)
+	}
+	block, err := proposerServer.GetBeaconBlock(ctx, req)
+	require.NoError(t, err)
+	altairBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Altair)
+	require.Equal(t, true, ok)
+
+	assert.Equal(t, req.Slot, altairBlk.Altair.Slot)
+	assert.DeepEqual(t, parentRoot[:], altairBlk.Altair.ParentRoot, "Expected block to have correct parent root")
+	assert.DeepEqual(t, randaoReveal, altairBlk.Altair.Body.RandaoReveal, "Expected block to have correct randao reveal")
+	assert.DeepEqual(t, req.Graffiti, altairBlk.Altair.Body.Graffiti, "Expected block to have correct Graffiti")
+	assert.Equal(t, params.BeaconConfig().MaxProposerSlashings, uint64(len(altairBlk.Altair.Body.ProposerSlashings)))
+	assert.DeepEqual(t, proposerSlashings, altairBlk.Altair.Body.ProposerSlashings)
+	assert.Equal(t, params.BeaconConfig().MaxAttesterSlashings, uint64(len(altairBlk.Altair.Body.AttesterSlashings)))
+	assert.DeepEqual(t, attSlashings, altairBlk.Altair.Body.AttesterSlashings)
+}
+
+func TestProposer_GetBeaconBlock_BellatrixEpoch(t *testing.T) {
+	db := dbutil.SetupDB(t)
+	ctx := context.Background()
+	hook := logTest.NewGlobal()
+
+	terminalBlockHash := bytesutil.PadTo([]byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 32)
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.BellatrixForkEpoch = 2
+	cfg.AltairForkEpoch = 1
+	cfg.TerminalBlockHash = common.BytesToHash(terminalBlockHash)
+	cfg.TerminalBlockHashActivationEpoch = 2
+	params.OverrideBeaconConfig(cfg)
+	beaconState, privKeys := util.DeterministicGenesisState(t, 64)
+
+	stateRoot, err := beaconState.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	genesis := b.NewGenesisBlock(stateRoot[:])
+	util.SaveBlock(t, ctx, db, genesis)
+
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	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")
+
+	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+	require.NoError(t, err)
+
+	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Slot:       bellatrixSlot + 1,
+			ParentRoot: parentRoot[:],
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				RandaoReveal:  genesis.Block.Body.RandaoReveal,
+				Graffiti:      genesis.Block.Body.Graffiti,
+				Eth1Data:      genesis.Block.Body.Eth1Data,
+				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+				ExecutionPayload: &enginev1.ExecutionPayload{
+					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,
+	}
+
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
+
+	c := mockExecution.New()
+	c.HashesByHeight[0] = terminalBlockHash
+	random, err := helpers.RandaoMix(beaconState, slots.ToEpoch(beaconState.Slot()))
+	require.NoError(t, err)
+	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), bellatrixSlot+1)
+	require.NoError(t, err)
+
+	payload := &enginev1.ExecutionPayload{
+		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:    random,
+		BaseFeePerGas: make([]byte, fieldparams.RootLength),
+		BlockHash:     make([]byte, fieldparams.RootLength),
+		Transactions:  make([][]byte, 0),
+		ExtraData:     make([]byte, 0),
+		BlockNumber:   1,
+		GasLimit:      2,
+		GasUsed:       3,
+		Timestamp:     uint64(timeStamp.Unix()),
+	}
+	proposerServer := &Server{
+		HeadFetcher:       &mock.ChainService{State: beaconState, Root: parentRoot[:], Optimistic: false},
+		TimeFetcher:       &mock.ChainService{Genesis: time.Now()},
+		SyncChecker:       &mockSync.Sync{IsSyncing: false},
+		BlockReceiver:     &mock.ChainService{},
+		HeadUpdater:       &mock.ChainService{},
+		ChainStartFetcher: &mockExecution.Chain{},
+		Eth1InfoFetcher:   &mockExecution.Chain{},
+		Eth1BlockFetcher:  c,
+		MockEth1Votes:     true,
+		AttPool:           attestations.NewPool(),
+		SlashingsPool:     slashings.NewPool(),
+		ExitPool:          voluntaryexits.NewPool(),
+		StateGen:          stategen.New(db, doublylinkedtree.New()),
+		SyncCommitteePool: synccommittee.NewStore(),
+		ExecutionEngineCaller: &mockExecution.EngineClient{
+			PayloadIDBytes:   &enginev1.PayloadIDBytes{1},
+			ExecutionPayload: payload,
+		},
+		BeaconDB:               db,
+		ProposerSlotIndexCache: cache.NewProposerPayloadIDsCache(),
+	}
+
+	randaoReveal, err := util.RandaoReveal(beaconState, 0, privKeys)
+	require.NoError(t, err)
+
+	graffiti := bytesutil.ToBytes32([]byte("eth2"))
+	require.NoError(t, err)
+	req := &ethpb.BlockRequest{
+		Slot:         bellatrixSlot + 1,
+		RandaoReveal: randaoReveal,
+		Graffiti:     graffiti[:],
+	}
+
+	block, err := proposerServer.GetBeaconBlock(ctx, req)
+	require.NoError(t, err)
+	bellatrixBlk, ok := block.GetBlock().(*ethpb.GenericBeaconBlock_Bellatrix)
+	require.Equal(t, true, ok)
+
+	assert.Equal(t, req.Slot, bellatrixBlk.Bellatrix.Slot)
+	assert.DeepEqual(t, parentRoot[:], bellatrixBlk.Bellatrix.ParentRoot, "Expected block to have correct parent root")
+	assert.DeepEqual(t, randaoReveal, bellatrixBlk.Bellatrix.Body.RandaoReveal, "Expected block to have correct randao reveal")
+	assert.DeepEqual(t, req.Graffiti, bellatrixBlk.Bellatrix.Body.Graffiti, "Expected block to have correct Graffiti")
+
+	require.LogsContain(t, hook, "Fee recipient is currently using the burn address")
+	require.DeepEqual(t, payload, bellatrixBlk.Bellatrix.Body.ExecutionPayload) // Payload should equal.
+
+	// Operator sets default fee recipient to not be burned through beacon node cli.
+	newHook := logTest.NewGlobal()
+	params.SetupTestConfigCleanup(t)
+	cfg = params.MinimalSpecConfig().Copy()
+	cfg.DefaultFeeRecipient = common.Address{'b'}
+	params.OverrideBeaconConfig(cfg)
+	_, err = proposerServer.GetBeaconBlock(ctx, req)
+	require.NoError(t, err)
+	require.LogsDoNotContain(t, newHook, "Fee recipient is currently using the burn address")
+}
+
+func TestProposer_GetBeaconBlock_Optimistic(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.BellatrixForkEpoch = 2
+	cfg.AltairForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
+
+	bellatrixSlot, err := slots.EpochStart(params.BeaconConfig().BellatrixForkEpoch)
+	require.NoError(t, err)
+
+	proposerServer := &Server{OptimisticModeFetcher: &mock.ChainService{Optimistic: true}, TimeFetcher: &mock.ChainService{}}
+	req := &ethpb.BlockRequest{
+		Slot: bellatrixSlot + 1,
+	}
+	_, err = proposerServer.GetBeaconBlock(context.Background(), req)
+	s, ok := status.FromError(err)
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, codes.Unavailable, s.Code())
+	require.ErrorContains(t, errOptimisticMode.Error(), err)
+}
+
 func TestProposer_GetSyncAggregate_OK(t *testing.T) {
 	proposerServer := &Server{
 		SyncChecker:       &mockSync.Sync{IsSyncing: false},

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

@@ -63,6 +63,7 @@ type Server struct {
 	SlashingsPool          slashings.PoolManager
 	ExitPool               voluntaryexits.PoolManager
 	SyncCommitteePool      synccommittee.Pool
+	BLSChangesPool         blstoexec.PoolManager
 	BlockReceiver          blockchain.BlockReceiver
 	MockEth1Votes          bool
 	Eth1BlockFetcher       execution.POWBlockFetcher
@@ -73,7 +74,6 @@ type Server struct {
 	BeaconDB               db.HeadAccessDatabase
 	ExecutionEngineCaller  execution.EngineCaller
 	BlockBuilder           builder.BlockBuilder
-	BLSChangesPool         blstoexec.PoolManager
 }
 
 // WaitForActivation checks if a validator public key exists in the active validator registry of the current

beacon-chain/rpc/service.go

@@ -98,6 +98,7 @@ type Config struct {
 	AttestationsPool              attestations.Pool
 	ExitPool                      voluntaryexits.PoolManager
 	SlashingsPool                 slashings.PoolManager
+	BLSToExecPool                 blstoexec.PoolManager
 	SlashingChecker               slasherservice.SlashingChecker
 	SyncCommitteeObjectPool       synccommittee.Pool
 	BLSChangesPool                blstoexec.PoolManager
@@ -218,12 +219,12 @@ func (s *Service) Start() {
 		SlashingsPool:          s.cfg.SlashingsPool,
 		StateGen:               s.cfg.StateGen,
 		SyncCommitteePool:      s.cfg.SyncCommitteeObjectPool,
+		BLSChangesPool:         s.cfg.BLSChangesPool,
 		ReplayerBuilder:        ch,
 		ExecutionEngineCaller:  s.cfg.ExecutionEngineCaller,
 		BeaconDB:               s.cfg.BeaconDB,
 		ProposerSlotIndexCache: s.cfg.ProposerIdsCache,
 		BlockBuilder:           s.cfg.BlockBuilder,
-		BLSChangesPool:         s.cfg.BLSChangesPool,
 	}
 	validatorServerV1 := &validator.Server{
 		HeadFetcher:           s.cfg.HeadFetcher,
@@ -243,6 +244,7 @@ func (s *Service) Start() {
 			ReplayerBuilder:    ch,
 		},
 		SyncCommitteePool:      s.cfg.SyncCommitteeObjectPool,
+		BLSChangesPool:         s.cfg.BLSChangesPool,
 		ProposerSlotIndexCache: s.cfg.ProposerIdsCache,
 	}
 
@@ -295,6 +297,7 @@ func (s *Service) Start() {
 		ReceivedAttestationsBuffer:  make(chan *ethpbv1alpha1.Attestation, attestationBufferSize),
 		CollectedAttestationsBuffer: make(chan []*ethpbv1alpha1.Attestation, attestationBufferSize),
 		ReplayerBuilder:             ch,
+		BLSChangesPool:              s.cfg.BLSChangesPool,
 	}
 	beaconChainServerV1 := &beacon.Server{
 		CanonicalHistory:   ch,

beacon-chain/rpc/statefetcher/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@io_opencensus_go//trace:go_default_library",
     ],

beacon-chain/rpc/statefetcher/fetcher.go

@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v3/time/slots"
 	"go.opencensus.io/trace"
 )
 
@@ -114,29 +113,13 @@ func (p *StateProvider) State(ctx context.Context, stateId []byte) (state.Beacon
 		}
 	case "finalized":
 		checkpoint := p.ChainInfoFetcher.FinalizedCheckpt()
-		targetSlot, err := slots.EpochStart(checkpoint.Epoch)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get start slot")
-		}
-		// We use the stategen replayer to fetch the finalized state and then
-		// replay it to the start slot of our checkpoint's epoch. The replayer
-		// only ever accesses our canonical history, so the state retrieved will
-		// always be the finalized state at that epoch.
-		s, err = p.ReplayerBuilder.ReplayerForSlot(targetSlot).ReplayToSlot(ctx, targetSlot)
+		s, err = p.StateGenService.StateByRoot(ctx, bytesutil.ToBytes32(checkpoint.Root))
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get finalized state")
 		}
 	case "justified":
 		checkpoint := p.ChainInfoFetcher.CurrentJustifiedCheckpt()
-		targetSlot, err := slots.EpochStart(checkpoint.Epoch)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get start slot")
-		}
-		// We use the stategen replayer to fetch the justified state and then
-		// replay it to the start slot of our checkpoint's epoch. The replayer
-		// only ever accesses our canonical history, so the state retrieved will
-		// always be the justified state at that epoch.
-		s, err = p.ReplayerBuilder.ReplayerForSlot(targetSlot).ReplayToSlot(ctx, targetSlot)
+		s, err = p.StateGenService.StateByRoot(ctx, bytesutil.ToBytes32(checkpoint.Root))
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get justified state")
 		}
@@ -220,6 +203,9 @@ func (p *StateProvider) StateBySlot(ctx context.Context, target types.Slot) (sta
 	if target > p.GenesisTimeFetcher.CurrentSlot() {
 		return nil, errors.New("requested slot is in the future")
 	}
+	if target > p.ChainInfoFetcher.HeadSlot() {
+		return nil, errors.New("requested slot number is higher than head slot number")
+	}
 
 	st, err := p.ReplayerBuilder.ReplayerForSlot(target).ReplayBlocks(ctx)
 	if err != nil {

beacon-chain/rpc/statefetcher/fetcher_test.go

@@ -94,19 +94,15 @@ func TestGetState(t *testing.T) {
 
 	t.Run("finalized", func(t *testing.T) {
 		stateGen := mockstategen.NewMockService()
-		replayer := mockstategen.NewMockReplayerBuilder()
-		replayer.SetMockStateForSlot(newBeaconState, params.BeaconConfig().SlotsPerEpoch*10)
 		stateGen.StatesByRoot[stateRoot] = newBeaconState
 
 		p := StateProvider{
 			ChainInfoFetcher: &chainMock.ChainService{
 				FinalizedCheckPoint: &ethpb.Checkpoint{
-					Root:  stateRoot[:],
-					Epoch: 10,
+					Root: stateRoot[:],
 				},
 			},
 			StateGenService: stateGen,
-			ReplayerBuilder: replayer,
 		}
 
 		s, err := p.State(ctx, []byte("finalized"))
@@ -118,19 +114,15 @@ func TestGetState(t *testing.T) {
 
 	t.Run("justified", func(t *testing.T) {
 		stateGen := mockstategen.NewMockService()
-		replayer := mockstategen.NewMockReplayerBuilder()
-		replayer.SetMockStateForSlot(newBeaconState, params.BeaconConfig().SlotsPerEpoch*10)
 		stateGen.StatesByRoot[stateRoot] = newBeaconState
 
 		p := StateProvider{
 			ChainInfoFetcher: &chainMock.ChainService{
 				CurrentJustifiedCheckPoint: &ethpb.Checkpoint{
-					Root:  stateRoot[:],
-					Epoch: 10,
+					Root: stateRoot[:],
 				},
 			},
 			StateGenService: stateGen,
-			ReplayerBuilder: replayer,
 		}
 
 		s, err := p.State(ctx, []byte("justified"))
@@ -395,16 +387,11 @@ func TestStateBySlot_FutureSlot(t *testing.T) {
 }
 
 func TestStateBySlot_AfterHeadSlot(t *testing.T) {
-	headSt, err := statenative.InitializeFromProtoPhase0(&ethpb.BeaconState{Slot: 100})
-	require.NoError(t, err)
-	slotSt, err := statenative.InitializeFromProtoPhase0(&ethpb.BeaconState{Slot: 101})
+	st, err := statenative.InitializeFromProtoPhase0(&ethpb.BeaconState{Slot: 100})
 	require.NoError(t, err)
 	currentSlot := types.Slot(102)
-	mock := &chainMock.ChainService{State: headSt, Slot: &currentSlot}
-	mockReplayer := mockstategen.NewMockReplayerBuilder()
-	mockReplayer.SetMockStateForSlot(slotSt, 101)
-	p := StateProvider{ChainInfoFetcher: mock, GenesisTimeFetcher: mock, ReplayerBuilder: mockReplayer}
-	st, err := p.StateBySlot(context.Background(), 101)
-	require.NoError(t, err)
-	assert.Equal(t, types.Slot(101), st.Slot())
+	mock := &chainMock.ChainService{State: st, Slot: &currentSlot}
+	p := StateProvider{ChainInfoFetcher: mock, GenesisTimeFetcher: mock}
+	_, err = p.StateBySlot(context.Background(), 101)
+	assert.ErrorContains(t, "requested slot number is higher than head slot number", err)
 }

beacon-chain/state/interfaces.go

@@ -18,9 +18,11 @@ import (
 type BeaconState interface {
 	SpecParametersProvider
 	ReadOnlyBeaconState
+	ReadOnlyWithdrawals
 	WriteOnlyBeaconState
 	Copy() BeaconState
 	HashTreeRoot(ctx context.Context) ([32]byte, error)
+	FutureForkStub
 	StateProver
 }
 
@@ -48,10 +50,6 @@ type ReadOnlyBeaconState interface {
 	ReadOnlyBalances
 	ReadOnlyCheckpoint
 	ReadOnlyAttestations
-	ReadOnlyWithdrawals
-	ReadOnlyParticipation
-	ReadOnlyInactivity
-	ReadOnlySyncCommittee
 	ToProtoUnsafe() interface{}
 	ToProto() interface{}
 	GenesisTime() uint64
@@ -59,8 +57,8 @@ type ReadOnlyBeaconState interface {
 	Slot() types.Slot
 	Fork() *ethpb.Fork
 	LatestBlockHeader() *ethpb.BeaconBlockHeader
-	HistoricalRoots() ([][]byte, error)
-	HistoricalSummaries() ([]*ethpb.HistoricalSummary, error)
+	HistoricalRoots() [][]byte
+	HistoricalSummaries() []*ethpb.HistoricalSummary
 	Slashings() []uint64
 	FieldReferencesCount() map[string]uint64
 	MarshalSSZ() ([]byte, error)
@@ -79,9 +77,6 @@ type WriteOnlyBeaconState interface {
 	WriteOnlyBalances
 	WriteOnlyCheckpoint
 	WriteOnlyAttestations
-	WriteOnlyParticipation
-	WriteOnlyInactivity
-	WriteOnlySyncCommittee
 	SetGenesisTime(val uint64) error
 	SetGenesisValidatorsRoot(val []byte) error
 	SetSlot(val types.Slot) error
@@ -91,7 +86,7 @@ type WriteOnlyBeaconState interface {
 	SetSlashings(val []uint64) error
 	UpdateSlashingsAtIndex(idx, val uint64) error
 	AppendHistoricalRoots(root [32]byte) error
-	AppendHistoricalSummaries(*ethpb.HistoricalSummary) error
+	AppendHistoricalSummariesUpdate(*ethpb.HistoricalSummary) error
 	SetLatestExecutionPayloadHeader(payload interfaces.ExecutionData) error
 	SetNextWithdrawalIndex(i uint64) error
 	SetNextWithdrawalValidatorIndex(i types.ValidatorIndex) error
@@ -140,7 +135,6 @@ type ReadOnlyCheckpoint interface {
 	FinalizedCheckpoint() *ethpb.Checkpoint
 	FinalizedCheckpointEpoch() types.Epoch
 	JustificationBits() bitfield.Bitvector4
-	UnrealizedCheckpointBalances() (uint64, uint64, uint64, error)
 }
 
 // ReadOnlyBlockRoots defines a struct which only has read access to block roots methods.
@@ -182,23 +176,6 @@ type ReadOnlyWithdrawals interface {
 	NextWithdrawalIndex() (uint64, error)
 }
 
-// ReadOnlyParticipation defines a struct which only has read access to participation methods.
-type ReadOnlyParticipation interface {
-	CurrentEpochParticipation() ([]byte, error)
-	PreviousEpochParticipation() ([]byte, error)
-}
-
-// ReadOnlyInactivity defines a struct which only has read access to inactivity methods.
-type ReadOnlyInactivity interface {
-	InactivityScores() ([]uint64, error)
-}
-
-// ReadOnlySyncCommittee defines a struct which only has read access to sync committee methods.
-type ReadOnlySyncCommittee interface {
-	CurrentSyncCommittee() (*ethpb.SyncCommittee, error)
-	NextSyncCommittee() (*ethpb.SyncCommittee, error)
-}
-
 // WriteOnlyBlockRoots defines a struct which only has write access to block roots methods.
 type WriteOnlyBlockRoots interface {
 	SetBlockRoots(val [][]byte) error
@@ -257,24 +234,23 @@ type WriteOnlyAttestations interface {
 	RotateAttestations() error
 }
 
-// WriteOnlyParticipation defines a struct which only has write access to participation methods.
-type WriteOnlyParticipation interface {
+// FutureForkStub defines methods that are used for future forks. This is a low cost solution to enable
+// various state casting of interface to work.
+type FutureForkStub interface {
 	AppendCurrentParticipationBits(val byte) error
 	AppendPreviousParticipationBits(val byte) error
+	AppendInactivityScore(s uint64) error
+	CurrentEpochParticipation() ([]byte, error)
+	PreviousEpochParticipation() ([]byte, error)
+	UnrealizedCheckpointBalances() (uint64, uint64, uint64, error)
+	InactivityScores() ([]uint64, error)
+	SetInactivityScores(val []uint64) error
+	CurrentSyncCommittee() (*ethpb.SyncCommittee, error)
+	SetCurrentSyncCommittee(val *ethpb.SyncCommittee) error
 	SetPreviousParticipationBits(val []byte) error
 	SetCurrentParticipationBits(val []byte) error
 	ModifyCurrentParticipationBits(func(val []byte) ([]byte, error)) error
 	ModifyPreviousParticipationBits(func(val []byte) ([]byte, error)) error
-}
-
-// WriteOnlyInactivity defines a struct which only has write access to inactivity methods.
-type WriteOnlyInactivity interface {
-	AppendInactivityScore(s uint64) error
-	SetInactivityScores(val []uint64) error
-}
-
-// WriteOnlySyncCommittee defines a struct which only has write access to sync committee methods.
-type WriteOnlySyncCommittee interface {
-	SetCurrentSyncCommittee(val *ethpb.SyncCommittee) error
+	NextSyncCommittee() (*ethpb.SyncCommittee, error)
 	SetNextSyncCommittee(val *ethpb.SyncCommittee) error
 }

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

@@ -3,7 +3,6 @@ package state_native
 import (
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 )
 
 // GenesisTime of the beacon state as a uint64.
@@ -68,15 +67,15 @@ func (b *BeaconState) forkVal() *ethpb.Fork {
 }
 
 // HistoricalRoots based on epochs stored in the beacon state.
-func (b *BeaconState) HistoricalRoots() ([][]byte, error) {
+func (b *BeaconState) HistoricalRoots() [][]byte {
 	if b.historicalRoots == nil {
-		return nil, nil
+		return nil
 	}
 
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.historicalRoots.Slice(), nil
+	return b.historicalRoots.Slice()
 }
 
 // balancesLength returns the length of the balances slice.
@@ -90,19 +89,15 @@ func (b *BeaconState) balancesLength() int {
 }
 
 // HistoricalSummaries of the beacon state.
-func (b *BeaconState) HistoricalSummaries() ([]*ethpb.HistoricalSummary, error) {
-	if b.version < version.Capella {
-		return nil, errNotSupported("HistoricalSummaries", b.version)
-	}
-
+func (b *BeaconState) HistoricalSummaries() []*ethpb.HistoricalSummary {
 	if b.historicalSummaries == nil {
-		return nil, nil
+		return nil
 	}
 
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	return b.historicalSummariesVal(), nil
+	return b.historicalSummariesVal()
 }
 
 // historicalSummariesVal of the beacon state.

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

@@ -1,6 +1,7 @@
 package state_native
 
 import (
+	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
@@ -49,7 +50,7 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
 	b.lock.RLock()
 	defer b.lock.RUnlock()
 
-	withdrawals := make([]*enginev1.Withdrawal, 0, params.BeaconConfig().MaxWithdrawalsPerPayload)
+	withdrawals := make([]*enginev1.Withdrawal, 0, fieldparams.MaxWithdrawalsPerPayload)
 	validatorIndex := b.nextWithdrawalValidatorIndex
 	withdrawalIndex := b.nextWithdrawalIndex
 	epoch := slots.ToEpoch(b.slot)
@@ -75,7 +76,7 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, error) {
 			})
 			withdrawalIndex++
 		}
-		if uint64(len(withdrawals)) == params.BeaconConfig().MaxWithdrawalsPerPayload {
+		if uint64(len(withdrawals)) == fieldparams.MaxWithdrawalsPerPayload {
 			break
 		}
 		validatorIndex += 1

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

@@ -26,7 +26,7 @@ func TestNextWithdrawalIndex(t *testing.T) {
 	})
 }
 
-func TestLastWithdrawalValidatorIndex(t *testing.T) {
+func TestNextWithdrawalValidatorIndex(t *testing.T) {
 	t.Run("ok", func(t *testing.T) {
 		s := BeaconState{version: version.Capella, nextWithdrawalValidatorIndex: 123}
 		i, err := s.NextWithdrawalValidatorIndex()

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

@@ -1,8 +1,10 @@
 package state_native
 
 import (
+	"bytes"
 	"context"
 	"encoding/binary"
+	"fmt"
 
 	"github.com/pkg/errors"
 	nativetypes "github.com/prysmaticlabs/prysm/v3/beacon-chain/state/state-native/types"
@@ -12,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v3/encoding/ssz"
+	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v3/runtime/version"
 	"go.opencensus.io/trace"
 )
@@ -257,7 +260,7 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		fieldRoots[nativetypes.NextWithdrawalValidatorIndex.RealPosition()] = nextWithdrawalValidatorIndexRoot
 
 		// Historical summary root.
-		historicalSummaryRoot, err := stateutil.HistoricalSummariesRoot(state.historicalSummaries)
+		historicalSummaryRoot, err := historicalSummaryRoot(state.historicalSummaries)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not compute historical summary merkleization")
 		}
@@ -266,3 +269,39 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 
 	return fieldRoots, nil
 }
+
+func historicalSummaryRoot(summaries []*ethpb.HistoricalSummary) ([32]byte, error) {
+	max := uint64(fieldparams.HistoricalRootsLength)
+	if uint64(len(summaries)) > max {
+		return [32]byte{}, fmt.Errorf("historical summary exceeds max length %d", max)
+	}
+
+	hasher := hash.CustomSHA256Hasher()
+	roots := make([][32]byte, len(summaries))
+	for i := 0; i < len(summaries); i++ {
+		r, err := summaries[i].HashTreeRoot()
+		if err != nil {
+			return [32]byte{}, errors.Wrap(err, "could not merkleize historical summary")
+		}
+		roots[i] = r
+	}
+
+	summariesRoot, err := ssz.BitwiseMerkleize(
+		hasher,
+		roots,
+		uint64(len(roots)),
+		fieldparams.HistoricalRootsLength,
+	)
+	if err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not compute epoch attestations merkleization")
+	}
+	summariesLenBuf := new(bytes.Buffer)
+	if err := binary.Write(summariesLenBuf, binary.LittleEndian, uint64(len(summaries))); err != nil {
+		return [32]byte{}, errors.Wrap(err, "could not marshal historical summary length")
+	}
+	// We need to mix in the length of the slice.
+	summariesLenRoot := make([]byte, 32)
+	copy(summariesLenRoot, summariesLenBuf.Bytes())
+	res := ssz.MixInLength(summariesRoot, summariesLenRoot)
+	return res, nil
+}

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

@@ -258,10 +258,6 @@ func TestComputeFieldRootsWithHasher_Capella(t *testing.T) {
 	require.NoError(t, beaconState.SetLatestExecutionPayloadHeader(wrappedHeader))
 	require.NoError(t, beaconState.SetNextWithdrawalIndex(123))
 	require.NoError(t, beaconState.SetNextWithdrawalValidatorIndex(123))
-	require.NoError(t, beaconState.AppendHistoricalSummaries(&ethpb.HistoricalSummary{
-		BlockSummaryRoot: bytesutil.PadTo([]byte("block summary root"), 32),
-		StateSummaryRoot: bytesutil.PadTo([]byte("state summary root"), 32),
-	}))
 
 	nativeState, ok := beaconState.(*statenative.BeaconState)
 	require.Equal(t, true, ok)
@@ -302,7 +298,6 @@ func TestComputeFieldRootsWithHasher_Capella(t *testing.T) {
 		{0x39, 0x29, 0x16, 0xe8, 0x5a, 0xd2, 0xb, 0xbb, 0x1f, 0xef, 0x6a, 0xe0, 0x2d, 0xa6, 0x6a, 0x46, 0x81, 0xba, 0xcf, 0x86, 0xfc, 0x16, 0x22, 0x2a, 0x9b, 0x72, 0x96, 0x71, 0x2b, 0xc7, 0x5b, 0x9d},
 		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
 		{0x7b, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
-		{0xa1, 0x4, 0x64, 0x31, 0x2a, 0xa, 0x49, 0x31, 0x1c, 0x1, 0x41, 0x17, 0xc0, 0x52, 0x52, 0xfa, 0x4c, 0xf4, 0x95, 0x4f, 0x5c, 0xb0, 0x5a, 0x40, 0xc1, 0x32, 0x39, 0xc3, 0x7c, 0xb7, 0x2c, 0x27},
 	}
 	assert.DeepEqual(t, expected, root)
 }

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

@@ -1,6 +1,8 @@
 package state_native
 
 import (
+	"fmt"
+
 	"github.com/pkg/errors"
 	nativetypes "github.com/prysmaticlabs/prysm/v3/beacon-chain/state/state-native/types"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state/stateutil"
@@ -113,7 +115,7 @@ func (b *BeaconState) AppendHistoricalRoots(root [32]byte) error {
 	defer b.lock.Unlock()
 
 	if b.version > version.Bellatrix {
-		return errNotSupported("AppendHistoricalRoots", b.version)
+		return fmt.Errorf("AppendHistoricalRoots is not supported for version %d", b.version)
 	}
 
 	roots := b.historicalRoots
@@ -129,14 +131,14 @@ func (b *BeaconState) AppendHistoricalRoots(root [32]byte) error {
 	return nil
 }
 
-// AppendHistoricalSummaries for the beacon state. Appends the new value
+// AppendHistoricalSummariesUpdate AppendHistoricalSummary for the beacon state. Appends the new value
 // to the end of list.
-func (b *BeaconState) AppendHistoricalSummaries(summary *ethpb.HistoricalSummary) error {
+func (b *BeaconState) AppendHistoricalSummariesUpdate(summary *ethpb.HistoricalSummary) error {
 	b.lock.Lock()
 	defer b.lock.Unlock()
 
 	if b.version < version.Capella {
-		return errNotSupported("AppendHistoricalSummaries", b.version)
+		return fmt.Errorf("AppendHistoricalSummariesUpdate is not supported for version %d", b.version)
 	}
 
 	summaries := b.historicalSummaries

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

@@ -20,7 +20,7 @@ func (b *BeaconState) SetNextWithdrawalIndex(i uint64) error {
 	return nil
 }
 
-// SetLastWithdrawalValidatorIndex sets the index of the validator which is
+// SetNexWithdrawalValidatorIndex sets the index of the validator which is
 // next in line for a partial withdrawal.
 func (b *BeaconState) SetNextWithdrawalValidatorIndex(i types.ValidatorIndex) error {
 	if b.version < version.Capella {

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

@@ -20,7 +20,7 @@ func TestSetNextWithdrawalIndex(t *testing.T) {
 	require.Equal(t, true, s.dirtyFields[nativetypes.NextWithdrawalIndex])
 }
 
-func TestSetLastWithdrawalValidatorIndex(t *testing.T) {
+func TestSetNextWithdrawalValidatorIndex(t *testing.T) {
 	s := BeaconState{
 		version:                      version.Capella,
 		nextWithdrawalValidatorIndex: 3,

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

@@ -515,7 +515,6 @@ func (b *BeaconState) Copy() state.BeaconState {
 		// Large arrays, increases over time.
 		balances:                   b.balances,
 		historicalRoots:            b.historicalRoots,
-		historicalSummaries:        b.historicalSummaries,
 		validators:                 b.validators,
 		previousEpochParticipation: b.previousEpochParticipation,
 		currentEpochParticipation:  b.currentEpochParticipation,
@@ -534,6 +533,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 		nextSyncCommittee:                   b.nextSyncCommitteeVal(),
 		latestExecutionPayloadHeader:        b.latestExecutionPayloadHeaderVal(),
 		latestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapellaVal(),
+		historicalSummaries:                 b.historicalSummariesVal(),
 
 		dirtyFields:      make(map[nativetypes.FieldIndex]bool, fieldCount),
 		dirtyIndices:     make(map[nativetypes.FieldIndex][]uint64, fieldCount),
@@ -838,7 +838,7 @@ func (b *BeaconState) rootSelector(ctx context.Context, field nativetypes.FieldI
 	case nativetypes.NextWithdrawalValidatorIndex:
 		return ssz.Uint64Root(uint64(b.nextWithdrawalValidatorIndex)), nil
 	case nativetypes.HistoricalSummaries:
-		return stateutil.HistoricalSummariesRoot(b.historicalSummaries)
+		return historicalSummaryRoot(b.historicalSummaries)
 	}
 	return [32]byte{}, errors.New("invalid field index provided")
 }

beacon-chain/state/stategen/replay.go

@@ -3,7 +3,6 @@ package stategen
 import (
 	"context"
 	"fmt"
-	"runtime/debug"
 	"time"
 
 	"github.com/pkg/errors"
@@ -42,8 +41,7 @@ func (_ *State) replayBlocks(
 		"endSlot":   targetSlot,
 		"diff":      targetSlot - state.Slot(),
 	})
-	log.Debugf("Replaying state at %s", debug.Stack())
-
+	log.Debug("Replaying state")
 	// The input block list is sorted in decreasing slots order.
 	if len(signed) > 0 {
 		for i := len(signed) - 1; i >= 0; i-- {

beacon-chain/state/stateutil/BUILD.bazel

@@ -9,7 +9,6 @@ go_library(
         "field_root_eth1.go",
         "field_root_validator.go",
         "field_root_vector.go",
-        "historical_summaries_root.go",
         "participation_bit_root.go",
         "pending_attestation_root.go",
         "reference.go",

beacon-chain/state/stateutil/historical_summaries_root.go

@@ -1,49 +0,0 @@
-package stateutil
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-
-	"github.com/pkg/errors"
-	fieldparams "github.com/prysmaticlabs/prysm/v3/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v3/crypto/hash"
-	"github.com/prysmaticlabs/prysm/v3/encoding/ssz"
-	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-)
-
-func HistoricalSummariesRoot(summaries []*ethpb.HistoricalSummary) ([32]byte, error) {
-	max := uint64(fieldparams.HistoricalRootsLength)
-	if uint64(len(summaries)) > max {
-		return [32]byte{}, fmt.Errorf("historical summary exceeds max length %d", max)
-	}
-
-	hasher := hash.CustomSHA256Hasher()
-	roots := make([][32]byte, len(summaries))
-	for i := 0; i < len(summaries); i++ {
-		r, err := summaries[i].HashTreeRoot()
-		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not merkleize historical summary")
-		}
-		roots[i] = r
-	}
-
-	summariesRoot, err := ssz.BitwiseMerkleize(
-		hasher,
-		roots,
-		uint64(len(roots)),
-		fieldparams.HistoricalRootsLength,
-	)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not compute historical summaries merkleization")
-	}
-	summariesLenBuf := new(bytes.Buffer)
-	if err := binary.Write(summariesLenBuf, binary.LittleEndian, uint64(len(summaries))); err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not marshal historical summary length")
-	}
-	// We need to mix in the length of the slice.
-	summariesLenRoot := make([]byte, 32)
-	copy(summariesLenRoot, summariesLenBuf.Bytes())
-	res := ssz.MixInLength(summariesRoot, summariesLenRoot)
-	return res, nil
-}

beacon-chain/sync/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "batch_verifier.go",
-        "broadcast_bls_changes.go",
         "context.go",
         "deadlines.go",
         "decode_pubsub.go",
@@ -134,7 +133,6 @@ go_test(
     size = "small",
     srcs = [
         "batch_verifier_test.go",
-        "broadcast_bls_changes_test.go",
         "context_test.go",
         "decode_pubsub_test.go",
         "error_test.go",

beacon-chain/sync/broadcast_bls_changes.go

@@ -1,29 +0,0 @@
-package sync
-
-import (
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v3/config/params"
-	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v3/time/slots"
-)
-
-// This routine broadcasts all known BLS changes at the Capella fork.
-func (s *Service) broadcastBLSChanges(currSlot types.Slot) error {
-	capellaSlotStart, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
-	if err != nil {
-		// only possible error is an overflow, so we exit early from the method
-		return nil
-	}
-	if currSlot == capellaSlotStart {
-		changes, err := s.cfg.blsToExecPool.PendingBLSToExecChanges()
-		if err != nil {
-			return errors.Wrap(err, "could not get BLS to execution changes")
-		}
-		for _, ch := range changes {
-			if err := s.cfg.p2p.Broadcast(s.ctx, ch); err != nil {
-				return errors.Wrap(err, "could not broadcast BLS to execution changes.")
-			}
-		}
-	}
-	return nil
-}

beacon-chain/sync/broadcast_bls_changes_test.go

@@ -1,50 +0,0 @@
-package sync
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	mockChain "github.com/prysmaticlabs/prysm/v3/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/v3/beacon-chain/operations/blstoexec"
-	mockp2p "github.com/prysmaticlabs/prysm/v3/beacon-chain/p2p/testing"
-	mockSync "github.com/prysmaticlabs/prysm/v3/beacon-chain/sync/initial-sync/testing"
-	"github.com/prysmaticlabs/prysm/v3/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v3/testing/require"
-	"github.com/prysmaticlabs/prysm/v3/time/slots"
-)
-
-func TestBroadcastBLSChanges(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	c := params.BeaconConfig()
-	c.CapellaForkEpoch = c.BellatrixForkEpoch.Add(2)
-	params.OverrideBeaconConfig(c)
-	chainService := &mockChain.ChainService{
-		Genesis:        time.Now(),
-		ValidatorsRoot: [32]byte{'A'},
-	}
-	s := NewService(context.Background(),
-		WithP2P(mockp2p.NewTestP2P(t)),
-		WithInitialSync(&mockSync.Sync{IsSyncing: false}),
-		WithChainService(chainService),
-		WithStateNotifier(chainService.StateNotifier()),
-		WithOperationNotifier(chainService.OperationNotifier()),
-		WithBlsToExecPool(blstoexec.NewPool()),
-	)
-	var emptySig [96]byte
-	s.cfg.blsToExecPool.InsertBLSToExecChange(&ethpb.SignedBLSToExecutionChange{
-		Message: &ethpb.BLSToExecutionChange{
-			ValidatorIndex:     10,
-			FromBlsPubkey:      make([]byte, 48),
-			ToExecutionAddress: make([]byte, 20),
-		},
-		Signature: emptySig[:],
-	})
-
-	capellaStart, err := slots.EpochStart(params.BeaconConfig().CapellaForkEpoch)
-	require.NoError(t, err)
-	require.NoError(t, s.broadcastBLSChanges(capellaStart))
-	require.NoError(t, s.broadcastBLSChanges(capellaStart+1))
-
-}

beacon-chain/sync/fork_watcher.go

@@ -28,12 +28,6 @@ func (s *Service) forkWatcher() {
 				log.WithError(err).Error("Unable to check for fork in the previous epoch")
 				continue
 			}
-			// Broadcast BLS changes at the Capella fork boundary
-			if err := s.broadcastBLSChanges(currSlot); err != nil {
-				log.WithError(err).Error("Unable to broadcast BLS to execution changes")
-				continue
-			}
-
 		case <-s.ctx.Done():
 			log.Debug("Context closed, exiting goroutine")
 			slotTicker.Done()

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

@@ -18,7 +18,6 @@ import (
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	leakybucket "github.com/prysmaticlabs/prysm/v3/container/leaky-bucket"
 	"github.com/prysmaticlabs/prysm/v3/crypto/rand"
-	"github.com/prysmaticlabs/prysm/v3/math"
 	p2ppb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
@@ -78,7 +77,7 @@ type blocksFetcher struct {
 	chain           blockchainService
 	p2p             p2p.P2P
 	db              db.ReadOnlyDatabase
-	blocksPerPeriod uint64
+	blocksPerSecond uint64
 	rateLimiter     *leakybucket.Collector
 	peerLocks       map[peer.ID]*peerLock
 	fetchRequests   chan *fetchRequestParams
@@ -113,11 +112,11 @@ type fetchRequestResponse struct {
 
 // newBlocksFetcher creates ready to use fetcher.
 func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetcher {
-	blocksPerPeriod := flags.Get().BlockBatchLimit
+	blocksPerSecond := flags.Get().BlockBatchLimit
 	allowedBlocksBurst := flags.Get().BlockBatchLimitBurstFactor * flags.Get().BlockBatchLimit
 	// Allow fetcher to go almost to the full burst capacity (less a single batch).
 	rateLimiter := leakybucket.NewCollector(
-		float64(blocksPerPeriod), int64(allowedBlocksBurst-blocksPerPeriod),
+		float64(blocksPerSecond), int64(allowedBlocksBurst-blocksPerSecond),
 		blockLimiterPeriod, false /* deleteEmptyBuckets */)
 
 	capacityWeight := cfg.peerFilterCapacityWeight
@@ -133,7 +132,7 @@ func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetc
 		chain:           cfg.chain,
 		p2p:             cfg.p2p,
 		db:              cfg.db,
-		blocksPerPeriod: uint64(blocksPerPeriod),
+		blocksPerSecond: uint64(blocksPerSecond),
 		rateLimiter:     rateLimiter,
 		peerLocks:       make(map[peer.ID]*peerLock),
 		fetchRequests:   make(chan *fetchRequestParams, maxPendingRequests),
@@ -324,7 +323,7 @@ func (f *blocksFetcher) requestBlocks(
 		"score":    f.p2p.Peers().Scorers().BlockProviderScorer().FormatScorePretty(pid),
 	}).Debug("Requesting blocks")
 	if f.rateLimiter.Remaining(pid.String()) < int64(req.Count) {
-		if err := f.waitForBandwidth(pid, req.Count); err != nil {
+		if err := f.waitForBandwidth(pid); err != nil {
 			l.Unlock()
 			return nil, err
 		}
@@ -352,7 +351,7 @@ func (f *blocksFetcher) requestBlocksByRoot(
 		"score":    f.p2p.Peers().Scorers().BlockProviderScorer().FormatScorePretty(pid),
 	}).Debug("Requesting blocks (by roots)")
 	if f.rateLimiter.Remaining(pid.String()) < int64(len(*req)) {
-		if err := f.waitForBandwidth(pid, uint64(len(*req))); err != nil {
+		if err := f.waitForBandwidth(pid); err != nil {
 			l.Unlock()
 			return nil, err
 		}
@@ -364,19 +363,9 @@ func (f *blocksFetcher) requestBlocksByRoot(
 }
 
 // waitForBandwidth blocks up until peer's bandwidth is restored.
-func (f *blocksFetcher) waitForBandwidth(pid peer.ID, count uint64) error {
+func (f *blocksFetcher) waitForBandwidth(pid peer.ID) error {
 	log.WithField("peer", pid).Debug("Slowing down for rate limit")
-	rem := f.rateLimiter.Remaining(pid.String())
-	if uint64(rem) >= count {
-		// Exit early if we have sufficient capacity
-		return nil
-	}
-	intCount, err := math.Int(count)
-	if err != nil {
-		return err
-	}
-	toWait := timeToWait(int64(intCount), rem, f.rateLimiter.Capacity(), f.rateLimiter.TillEmpty(pid.String()))
-	timer := time.NewTimer(toWait)
+	timer := time.NewTimer(f.rateLimiter.TillEmpty(pid.String()))
 	defer timer.Stop()
 	select {
 	case <-f.ctx.Done():
@@ -386,18 +375,3 @@ func (f *blocksFetcher) waitForBandwidth(pid peer.ID, count uint64) error {
 	}
 	return nil
 }
-
-// Determine how long it will take for us to have the required number of blocks allowed by our rate limiter.
-// We do this by calculating the duration till the rate limiter can request these blocks without exceeding
-// the provided bandwidth limits per peer.
-func timeToWait(wanted, rem, capacity int64, timeTillEmpty time.Duration) time.Duration {
-	// Defensive check if we have more than enough blocks
-	// to request from the peer.
-	if rem >= wanted {
-		return 0
-	}
-	blocksNeeded := wanted - rem
-	currentNumBlks := capacity - rem
-	expectedTime := int64(timeTillEmpty) * blocksNeeded / currentNumBlks
-	return time.Duration(expectedTime)
-}

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

@@ -110,7 +110,7 @@ func (f *blocksFetcher) filterPeers(ctx context.Context, peers []peer.ID, peersP
 		remaining, capacity := float64(f.rateLimiter.Remaining(peerID.String())), float64(f.rateLimiter.Capacity())
 		// When capacity is close to exhaustion, allow less performant peer to take a chance.
 		// Otherwise, there's a good chance system will be forced to wait for rate limiter.
-		if remaining < float64(f.blocksPerPeriod) {
+		if remaining < float64(f.blocksPerSecond) {
 			return 0.0
 		}
 		capScore := remaining / capacity

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

@@ -590,42 +590,6 @@ func TestBlocksFetcher_RequestBlocksRateLimitingLocks(t *testing.T) {
 	require.LogsContain(t, hook, fmt.Sprintf("msg=\"Slowing down for rate limit\" peer=%s", p2.PeerID()))
 }
 
-func TestBlocksFetcher_WaitForBandwidth(t *testing.T) {
-	p1 := p2pt.NewTestP2P(t)
-	p2 := p2pt.NewTestP2P(t)
-	p1.Connect(p2)
-	require.Equal(t, 1, len(p1.BHost.Network().Peers()), "Expected peers to be connected")
-	req := &ethpb.BeaconBlocksByRangeRequest{
-		StartSlot: 100,
-		Step:      1,
-		Count:     64,
-	}
-
-	topic := p2pm.RPCBlocksByRangeTopicV1
-	protocol := libp2pcore.ProtocolID(topic + p2.Encoding().ProtocolSuffix())
-	streamHandlerFn := func(stream network.Stream) {
-		assert.NoError(t, stream.Close())
-	}
-	p2.BHost.SetStreamHandler(protocol, streamHandlerFn)
-
-	burstFactor := uint64(flags.Get().BlockBatchLimitBurstFactor)
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	fetcher := newBlocksFetcher(ctx, &blocksFetcherConfig{p2p: p1})
-	fetcher.rateLimiter = leakybucket.NewCollector(float64(req.Count), int64(req.Count*burstFactor), 5*time.Second, false)
-	fetcher.chain = &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
-	start := time.Now()
-	assert.NoError(t, fetcher.waitForBandwidth(p2.PeerID(), 10))
-	dur := time.Since(start)
-	assert.Equal(t, true, dur < time.Millisecond, "waited excessively for bandwidth")
-	fetcher.rateLimiter.Add(p2.PeerID().String(), int64(req.Count*burstFactor))
-	start = time.Now()
-	assert.NoError(t, fetcher.waitForBandwidth(p2.PeerID(), req.Count))
-	dur = time.Since(start)
-	assert.Equal(t, float64(5), dur.Truncate(1*time.Second).Seconds(), "waited excessively for bandwidth")
-}
-
 func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T) {
 	p1 := p2pt.NewTestP2P(t)
 	tests := []struct {
@@ -896,46 +860,3 @@ func TestBlocksFetcher_requestBlocksFromPeerReturningInvalidBlocks(t *testing.T)
 		})
 	}
 }
-
-func TestTimeToWait(t *testing.T) {
-	tests := []struct {
-		name          string
-		wanted        int64
-		rem           int64
-		capacity      int64
-		timeTillEmpty time.Duration
-		want          time.Duration
-	}{
-		{
-			name:          "Limiter has sufficient blocks",
-			wanted:        64,
-			rem:           64,
-			capacity:      320,
-			timeTillEmpty: 200 * time.Second,
-			want:          0 * time.Second,
-		},
-		{
-			name:          "Limiter has reached full capacity",
-			wanted:        64,
-			rem:           0,
-			capacity:      640,
-			timeTillEmpty: 60 * time.Second,
-			want:          6 * time.Second,
-		},
-		{
-			name:          "Requesting full capacity from peer",
-			wanted:        640,
-			rem:           0,
-			capacity:      640,
-			timeTillEmpty: 60 * time.Second,
-			want:          60 * time.Second,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := timeToWait(tt.wanted, tt.rem, tt.capacity, tt.timeTillEmpty); got != tt.want {
-				t.Errorf("timeToWait() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}

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

@@ -374,7 +374,6 @@ func TestBlocksFetcher_findForkWithPeer(t *testing.T) {
 
 	t.Run("no diverging blocks", func(t *testing.T) {
 		p2 := connectPeerHavingBlocks(t, p1, knownBlocks, 64, p1.Peers())
-		time.Sleep(100 * time.Millisecond)
 		defer func() {
 			assert.NoError(t, p1.Disconnect(p2))
 		}()
@@ -386,7 +385,6 @@ func TestBlocksFetcher_findForkWithPeer(t *testing.T) {
 		forkedSlot := types.Slot(24)
 		altBlocks := extendBlockSequence(t, knownBlocks[:forkedSlot], 128)
 		p2 := connectPeerHavingBlocks(t, p1, altBlocks, 128, p1.Peers())
-		time.Sleep(100 * time.Millisecond)
 		defer func() {
 			assert.NoError(t, p1.Disconnect(p2))
 		}()
@@ -399,7 +397,6 @@ func TestBlocksFetcher_findForkWithPeer(t *testing.T) {
 	t.Run("first block is diverging - no common ancestor", func(t *testing.T) {
 		altBlocks := extendBlockSequence(t, []*ethpb.SignedBeaconBlock{}, 128)
 		p2 := connectPeerHavingBlocks(t, p1, altBlocks, 128, p1.Peers())
-		time.Sleep(100 * time.Millisecond)
 		defer func() {
 			assert.NoError(t, p1.Disconnect(p2))
 		}()
@@ -411,7 +408,6 @@ func TestBlocksFetcher_findForkWithPeer(t *testing.T) {
 		forkedSlot := types.Slot(60)
 		altBlocks := extendBlockSequence(t, knownBlocks[:forkedSlot], 128)
 		p2 := connectPeerHavingBlocks(t, p1, altBlocks, 128, p1.Peers())
-		time.Sleep(100 * time.Millisecond)
 		defer func() {
 			assert.NoError(t, p1.Disconnect(p2))
 		}()

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

@@ -179,7 +179,7 @@ func (q *blocksQueue) loop() {
 	if startSlot > startBackSlots {
 		startSlot -= startBackSlots
 	}
-	blocksPerRequest := q.blocksFetcher.blocksPerPeriod
+	blocksPerRequest := q.blocksFetcher.blocksPerSecond
 	for i := startSlot; i < startSlot.Add(blocksPerRequest*lookaheadSteps); i += types.Slot(blocksPerRequest) {
 		q.smm.addStateMachine(i)
 	}
@@ -294,7 +294,7 @@ func (q *blocksQueue) onScheduleEvent(ctx context.Context) eventHandlerFn {
 			m.setState(stateSkipped)
 			return m.state, errSlotIsTooHigh
 		}
-		blocksPerRequest := q.blocksFetcher.blocksPerPeriod
+		blocksPerRequest := q.blocksFetcher.blocksPerSecond
 		if err := q.blocksFetcher.scheduleRequest(ctx, m.start, blocksPerRequest); err != nil {
 			return m.state, err
 		}