Add set payload attestations

# Conflicts:
#	beacon-chain/core/transition/transition_no_verify_sig.go

.github/workflows/changelog.yml

@@ -1,33 +0,0 @@
-name: CI
-
-on:
-  pull_request:
-    branches:
-      - develop
-
-jobs:
-  changed_files:
-    runs-on: ubuntu-latest 
-    name: Check CHANGELOG.md
-    steps:
-      - uses: actions/checkout@v4
-      - name: changelog modified
-        id: changelog-modified
-        uses: tj-actions/changed-files@v45
-        with:
-          files: CHANGELOG.md
-
-      - name: List all changed files
-        env:
-          ALL_CHANGED_FILES: ${{ steps.changelog-modified.outputs.all_changed_files }}
-        run: |
-          if [[ ${ALL_CHANGED_FILES[*]} =~ (^|[[:space:]])"CHANGELOG.md"($|[[:space:]]) ]];
-          then
-            echo "CHANGELOG.md was modified.";
-            exit 0;
-          else
-            echo "CHANGELOG.md was not modified.";
-            echo "Please see CHANGELOG.md and follow the instructions to add your changes to that file."
-            echo "In some rare scenarios, a changelog entry is not required and this CI check can be ignored."
-            exit 1;
-          fi

beacon-chain/blockchain/BUILD.bazel

@@ -6,6 +6,7 @@ go_library(
         "chain_info.go",
         "chain_info_forkchoice.go",
         "currently_syncing_block.go",
+        "currently_syncing_execution_payload_envelope.go",
         "defragment.go",
         "error.go",
         "execution_engine.go",
@@ -25,6 +26,8 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
+        "receive_execution_payload_envelope.go",
+        "receive_payload_attestation_message.go",
         "service.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
@@ -43,6 +46,7 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
+        "//beacon-chain/core/epbs:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
@@ -97,6 +101,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )
@@ -109,6 +114,7 @@ go_test(
         "chain_info_norace_test.go",
         "chain_info_test.go",
         "checktags_test.go",
+        "epbs_test.go",
         "error_test.go",
         "execution_engine_test.go",
         "forkchoice_update_execution_test.go",
@@ -124,6 +130,7 @@ go_test(
         "process_block_test.go",
         "receive_attestation_test.go",
         "receive_block_test.go",
+        "receive_execution_payload_envelope_test.go",
         "service_norace_test.go",
         "service_test.go",
         "setup_test.go",
@@ -177,6 +184,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -43,7 +43,7 @@ type ForkchoiceFetcher interface {
 	GetProposerHead() [32]byte
 	SetForkChoiceGenesisTime(uint64)
 	UpdateHead(context.Context, primitives.Slot)
-	HighestReceivedBlockSlot() primitives.Slot
+	HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte)
 	ReceivedBlocksLastEpoch() (uint64, error)
 	InsertNode(context.Context, state.BeaconState, consensus_blocks.ROBlock) error
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
@@ -51,6 +51,7 @@ type ForkchoiceFetcher interface {
 	ProposerBoost() [32]byte
 	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
 	IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error)
+	GetPTCVote(root [32]byte) primitives.PTCStatus
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.
@@ -119,6 +120,12 @@ type OptimisticModeFetcher interface {
 	IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error)
 }
 
+// ExecutionPayloadFetcher defines a common interface that returns forkchoice
+// information about payload block hashes
+type ExecutionPayloadFetcher interface {
+	HashInForkchoice([32]byte) bool
+}
+
 // FinalizedCheckpt returns the latest finalized checkpoint from chain store.
 func (s *Service) FinalizedCheckpt() *ethpb.Checkpoint {
 	s.cfg.ForkChoiceStore.RLock()
@@ -400,6 +407,14 @@ func (s *Service) InForkchoice(root [32]byte) bool {
 	return s.cfg.ForkChoiceStore.HasNode(root)
 }
 
+// HashInForkchoice returns true if the given payload block hash is found in
+// forkchoice
+func (s *Service) HashInForkchoice(hash [32]byte) bool {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.HasHash(hash)
+}
+
 // IsOptimisticForRoot takes the root as argument instead of the current head
 // and returns true if it is optimistic.
 func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool, error) {

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -6,6 +6,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/forkchoice"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
@@ -30,11 +31,11 @@ func (s *Service) SetForkChoiceGenesisTime(timestamp uint64) {
 	s.cfg.ForkChoiceStore.SetGenesisTime(timestamp)
 }
 
-// HighestReceivedBlockSlot returns the corresponding value from forkchoice
-func (s *Service) HighestReceivedBlockSlot() primitives.Slot {
+// HighestReceivedBlockSlotRoot returns the corresponding value from forkchoice
+func (s *Service) HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte) {
 	s.cfg.ForkChoiceStore.RLock()
 	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.HighestReceivedBlockSlot()
+	return s.cfg.ForkChoiceStore.HighestReceivedBlockSlotRoot()
 }
 
 // ReceivedBlocksLastEpoch returns the corresponding value from forkchoice
@@ -100,3 +101,30 @@ func (s *Service) ParentRoot(root [32]byte) ([32]byte, error) {
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	return s.cfg.ForkChoiceStore.ParentRoot(root)
 }
+
+// GetPTCVote wraps a call to the corresponding method in forkchoice and checks
+// the currently syncing status
+// Warning: this method will return the current PTC status regardless of
+// timeliness. A client MUST call this method when about to submit a PTC
+// attestation, that is exactly at the threshold to submit the attestation.
+func (s *Service) GetPTCVote(root [32]byte) primitives.PTCStatus {
+	s.cfg.ForkChoiceStore.RLock()
+	f := s.cfg.ForkChoiceStore.GetPTCVote()
+	s.cfg.ForkChoiceStore.RUnlock()
+	if f != primitives.PAYLOAD_ABSENT {
+		return f
+	}
+	f, isSyncing := s.payloadBeingSynced.isSyncing(root)
+	if isSyncing {
+		return f
+	}
+	return primitives.PAYLOAD_ABSENT
+}
+
+// insertPayloadEnvelope wraps a locked call to the corresponding method in
+// forkchoice
+func (s *Service) insertPayloadEnvelope(envelope interfaces.ROExecutionPayloadEnvelope) error {
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	return s.cfg.ForkChoiceStore.InsertPayloadEnvelope(envelope)
+}

beacon-chain/blockchain/chain_info_test.go

@@ -37,6 +37,7 @@ func prepareForkchoiceState(
 	blockRoot [32]byte,
 	parentRoot [32]byte,
 	payloadHash [32]byte,
+	parentHash [32]byte,
 	justified *ethpb.Checkpoint,
 	finalized *ethpb.Checkpoint,
 ) (state.BeaconState, consensus_blocks.ROBlock, error) {
@@ -69,7 +70,8 @@ func prepareForkchoiceState(
 			ParentRoot: parentRoot[:],
 			Body: &ethpb.BeaconBlockBodyBellatrix{
 				ExecutionPayload: &enginev1.ExecutionPayload{
-					BlockHash: payloadHash[:],
+					BlockHash:  payloadHash[:],
+					ParentHash: parentHash[:],
 				},
 			},
 		},
@@ -142,7 +144,7 @@ func TestUnrealizedJustifiedBlockHash(t *testing.T) {
 	service := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: []byte{'j'}}
 	ofc := &ethpb.Checkpoint{Root: []byte{'f'}}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	service.cfg.ForkChoiceStore.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) { return []uint64{}, nil })
@@ -336,22 +338,22 @@ func TestService_ChainHeads(t *testing.T) {
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, [32]byte{'B'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'D'}, [32]byte{'C'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, [32]byte{'E'}, [32]byte{'D'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 
@@ -433,10 +435,10 @@ func TestService_IsOptimistic(t *testing.T) {
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 
@@ -469,10 +471,10 @@ func TestService_IsOptimisticForRoot(t *testing.T) {
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 

beacon-chain/blockchain/currently_syncing_execution_payload_envelope.go

@@ -0,0 +1,36 @@
+package blockchain
+
+import (
+	"sync"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+type currentlySyncingPayload struct {
+	sync.Mutex
+	roots map[[32]byte]primitives.PTCStatus
+}
+
+func (b *currentlySyncingPayload) set(envelope interfaces.ROExecutionPayloadEnvelope) {
+	b.Lock()
+	defer b.Unlock()
+	if envelope.PayloadWithheld() {
+		b.roots[envelope.BeaconBlockRoot()] = primitives.PAYLOAD_WITHHELD
+	} else {
+		b.roots[envelope.BeaconBlockRoot()] = primitives.PAYLOAD_PRESENT
+	}
+}
+
+func (b *currentlySyncingPayload) unset(root [32]byte) {
+	b.Lock()
+	defer b.Unlock()
+	delete(b.roots, root)
+}
+
+func (b *currentlySyncingPayload) isSyncing(root [32]byte) (status primitives.PTCStatus, isSyncing bool) {
+	b.Lock()
+	defer b.Unlock()
+	status, isSyncing = b.roots[root]
+	return
+}

beacon-chain/blockchain/epbs_test.go

@@ -0,0 +1,18 @@
+package blockchain
+
+import (
+	"testing"
+
+	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestServiceGetPTCVote(t *testing.T) {
+	c := &currentlySyncingPayload{roots: make(map[[32]byte]primitives.PTCStatus)}
+	s := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, payloadBeingSynced: c}
+	r := [32]byte{'r'}
+	require.Equal(t, primitives.PAYLOAD_ABSENT, s.GetPTCVote(r))
+	c.roots[r] = primitives.PAYLOAD_WITHHELD
+	require.Equal(t, primitives.PAYLOAD_WITHHELD, s.GetPTCVote(r))
+}

beacon-chain/blockchain/error.go

@@ -30,6 +30,9 @@ var (
 	ErrNotCheckpoint = errors.New("not a checkpoint in forkchoice")
 	// ErrNilHead is returned when no head is present in the blockchain service.
 	ErrNilHead = errors.New("nil head")
+	// errInvalidValidatorIndex is returned when a validator index is
+	// invalid or unexpected
+	errInvalidValidatorIndex = errors.New("invalid validator index")
 )
 
 var errMaxBlobsExceeded = errors.New("Expected commitments in block exceeds MAX_BLOBS_PER_BLOCK")

beacon-chain/blockchain/execution_engine.go

@@ -2,6 +2,7 @@ package blockchain
 
 import (
 	"context"
+	"crypto/sha256"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -27,6 +28,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const blobCommitmentVersionKZG uint8 = 0x01
+
 var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
 
 // notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
@@ -91,6 +94,14 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				log.WithError(err).Error("Could not set head root to invalid")
 				return nil, nil
 			}
+			if len(invalidRoots) == 0 {
+				log.WithFields(logrus.Fields{
+					"slot":      headBlk.Slot(),
+					"blockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(headRoot[:])),
+				}).Warn("invalid payload")
+				return nil, nil
+			}
+
 			if err := s.removeInvalidBlockAndState(ctx, invalidRoots); err != nil {
 				log.WithError(err).Error("Could not remove invalid block and state")
 				return nil, nil
@@ -105,6 +116,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 				}).Warn("Pruned invalid blocks, could not update head root")
 				return nil, invalidBlock{error: ErrInvalidPayload, root: arg.headRoot, invalidAncestorRoots: invalidRoots}
 			}
+
 			b, err := s.getBlock(ctx, r)
 			if err != nil {
 				log.WithError(err).Error("Could not get head block")
@@ -280,7 +292,8 @@ func (s *Service) pruneInvalidBlock(ctx context.Context, root, parentRoot, lvh [
 
 // getPayloadAttributes returns the payload attributes for the given state and slot.
 // The attribute is required to initiate a payload build process in the context of an `engine_forkchoiceUpdated` call.
-func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState, slot primitives.Slot, headRoot []byte) payloadattribute.Attributer {
+func (s *Service)
+(ctx context.Context, st state.BeaconState, slot primitives.Slot, headRoot []byte) payloadattribute.Attributer {
 	emptyAttri := payloadattribute.EmptyWithVersion(st.Version())
 
 	// If it is an epoch boundary then process slots to get the right
@@ -407,7 +420,13 @@ func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([
 
 	versionedHashes := make([]common.Hash, len(commitments))
 	for i, commitment := range commitments {
-		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes[i] = ConvertKzgCommitmentToVersionedHash(commitment)
 	}
 	return versionedHashes, nil
 }
+
+func ConvertKzgCommitmentToVersionedHash(commitment []byte) common.Hash {
+	versionedHash := sha256.Sum256(commitment)
+	versionedHash[0] = blobCommitmentVersionKZG
+	return versionedHash
+}

beacon-chain/blockchain/execution_engine_test.go

@@ -46,13 +46,13 @@ func Test_NotifyForkchoiceUpdate_GetPayloadAttrErrorCanContinue(t *testing.T) {
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -104,13 +104,13 @@ func Test_NotifyForkchoiceUpdate(t *testing.T) {
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -287,16 +287,16 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{}))
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, [32]byte{'B'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, [32]byte{'C'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -316,10 +316,8 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 		headRoot:  brd,
 	}
 	_, err = service.notifyForkchoiceUpdate(ctx, a)
-	require.Equal(t, true, IsInvalidBlock(err))
-	require.Equal(t, brd, InvalidBlockRoot(err))
-	require.Equal(t, brd, InvalidAncestorRoots(err)[0])
-	require.Equal(t, 1, len(InvalidAncestorRoots(err)))
+	// The incoming block is not invalid because the empty node is still valid on ePBS.
+	require.Equal(t, false, IsInvalidBlock(err))
 }
 
 //
@@ -398,28 +396,28 @@ func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{}))
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, bra, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 
 	bState, _ := util.DeterministicGenesisState(t, 10)
 	require.NoError(t, beaconDB.SaveState(ctx, bState, bra))
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, [32]byte{'A'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 3, brc, brb, [32]byte{'C'}, [32]byte{'B'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 4, brd, brc, [32]byte{'D'}, [32]byte{'C'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 5, bre, brb, [32]byte{'E'}, [32]byte{'D'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 6, brf, bre, [32]byte{'F'}, [32]byte{'E'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 7, brg, bre, [32]byte{'G'}, [32]byte{'F'}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -512,10 +510,10 @@ func Test_NotifyNewPayload(t *testing.T) {
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, r, [32]byte{}, [32]byte{'A'}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -692,7 +690,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			}
 			service.cfg.ExecutionEngineCaller = e
 			root := [32]byte{'a'}
-			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+			state, blkRoot, err := prepareForkchoiceState(ctx, 0, root, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 			require.NoError(t, err)
 			require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
@@ -759,17 +757,17 @@ func Test_reportInvalidBlock(t *testing.T) {
 	service, tr := minimalTestService(t)
 	ctx, _, fcs := tr.ctx, tr.db, tr.fcs
 	jcp := &ethpb.Checkpoint{}
-	st, root, err := prepareForkchoiceState(ctx, 0, [32]byte{'A'}, [32]byte{}, [32]byte{'a'}, jcp, jcp)
+	st, root, err := prepareForkchoiceState(ctx, 0, [32]byte{'A'}, [32]byte{}, [32]byte{'a'}, [32]byte{}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 1, [32]byte{'B'}, [32]byte{'A'}, [32]byte{'b'}, jcp, jcp)
+	st, root, err = prepareForkchoiceState(ctx, 1, [32]byte{'B'}, [32]byte{'A'}, [32]byte{'b'}, [32]byte{'a'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'C'}, [32]byte{'B'}, [32]byte{'c'}, jcp, jcp)
+	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'C'}, [32]byte{'B'}, [32]byte{'c'}, [32]byte{'b'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 
-	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'d'}, jcp, jcp)
+	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'D'}, [32]byte{'C'}, [32]byte{'d'}, [32]byte{'c'}, jcp, jcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 
@@ -931,7 +929,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	fjc := &forkchoicetypes.Checkpoint{Epoch: 0, Root: params.BeaconConfig().ZeroHash}
 	require.NoError(t, fcs.UpdateJustifiedCheckpoint(ctx, fjc))
 	require.NoError(t, fcs.UpdateFinalizedCheckpoint(fjc))
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, genesisRoot, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	fcs.SetOriginRoot(genesisRoot)
@@ -965,7 +963,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, opStateSummary))
 	tenjc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
 	tenfc := &ethpb.Checkpoint{Epoch: 10, Root: genesisRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, tenjc, tenfc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 320, opRoot, genesisRoot, params.BeaconConfig().ZeroHash, [32]byte{}, tenjc, tenfc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	assert.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, opRoot))
@@ -994,7 +992,7 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	require.NoError(t, beaconDB.SaveStateSummary(ctx, validSummary))
 	twentyjc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
 	twentyfc := &ethpb.Checkpoint{Epoch: 20, Root: validRoot[:]}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, genesisRoot, params.BeaconConfig().ZeroHash, twentyjc, twentyfc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 640, validRoot, genesisRoot, params.BeaconConfig().ZeroHash, [32]byte{}, twentyjc, twentyfc)
 	require.NoError(t, err)
 	fcs.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) { return []uint64{}, nil })
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
@@ -1056,8 +1054,8 @@ func TestService_removeInvalidBlockAndState(t *testing.T) {
 
 	require.NoError(t, service.removeInvalidBlockAndState(ctx, [][32]byte{r1, r2}))
 
-	require.Equal(t, false, service.hasBlock(ctx, r1))
-	require.Equal(t, false, service.hasBlock(ctx, r2))
+	require.Equal(t, false, service.chainHasBlock(ctx, r1))
+	require.Equal(t, false, service.chainHasBlock(ctx, r2))
 	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r1))
 	require.Equal(t, false, service.cfg.BeaconDB.HasStateSummary(ctx, r2))
 	has, err := service.cfg.StateGen.HasState(ctx, r1)

beacon-chain/blockchain/forkchoice_update_execution_test.go

@@ -122,13 +122,13 @@ func TestService_forkchoiceUpdateWithExecution_SameHeadRootNewProposer(t *testin
 
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 1, altairBlkRoot, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, bellatrixBlkRoot, altairBlkRoot, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 
@@ -164,10 +164,10 @@ func TestShouldOverrideFCU(t *testing.T) {
 	headRoot := [32]byte{'b'}
 	parentRoot := [32]byte{'a'}
 	ojc := &ethpb.Checkpoint{}
-	st, root, err := prepareForkchoiceState(ctx, 1, parentRoot, [32]byte{}, [32]byte{}, ojc, ojc)
+	st, root, err := prepareForkchoiceState(ctx, 1, parentRoot, [32]byte{}, [32]byte{}, [32]byte{}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 2, headRoot, parentRoot, [32]byte{}, ojc, ojc)
+	st, root, err = prepareForkchoiceState(ctx, 2, headRoot, parentRoot, [32]byte{}, [32]byte{}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, root))
 

beacon-chain/blockchain/head_test.go

@@ -48,7 +48,7 @@ func TestSaveHead_Different(t *testing.T) {
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
@@ -63,11 +63,11 @@ func TestSaveHead_Different(t *testing.T) {
 	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -101,7 +101,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	require.NoError(t, err)
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, oldBlock.Block().Slot(), oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	service.head = &head{
@@ -110,7 +110,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	}
 
 	reorgChainParent := [32]byte{'B'}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 0, reorgChainParent, oldRoot, oldBlock.Block().ParentRoot(), ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, 0, reorgChainParent, oldRoot, oldBlock.Block().ParentRoot(), [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
@@ -122,7 +122,7 @@ func TestSaveHead_Different_Reorg(t *testing.T) {
 	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -238,11 +238,11 @@ func TestRetrieveHead_ReadOnly(t *testing.T) {
 	wsb := util.SaveBlock(t, context.Background(), service.cfg.BeaconDB, newHeadSignedBlock)
 	newRoot, err := newHeadBlock.HashTreeRoot()
 	require.NoError(t, err)
-	state, blkRoot, err := prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, slots.PrevSlot(wsb.Block().Slot()), wsb.Block().ParentRoot(), service.cfg.ForkChoiceStore.CachedHeadRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 
-	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, ojc, ofc)
+	state, blkRoot, err = prepareForkchoiceState(ctx, wsb.Block().Slot(), newRoot, wsb.Block().ParentRoot(), [32]byte{}, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	headState, err := util.NewBeaconState()
@@ -304,7 +304,7 @@ func TestSaveOrphanedAtts(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -381,7 +381,7 @@ func TestSaveOrphanedOps(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -451,7 +451,7 @@ func TestSaveOrphanedAtts_CanFilter(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlockCapella{blkG, blk1, blk2, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -509,7 +509,7 @@ func TestSaveOrphanedAtts_DoublyLinkedTrie(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk3, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -568,7 +568,7 @@ func TestSaveOrphanedAtts_CanFilter_DoublyLinkedTrie(t *testing.T) {
 	for _, blk := range []*ethpb.SignedBeaconBlock{blkG, blk1, blk2, blk4} {
 		r, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r, bytesutil.ToBytes32(blk.Block.ParentRoot), [32]byte{}, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -583,7 +583,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	ctx, beaconDB, fcs := tr.ctx, tr.db, tr.fcs
 
 	ojp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, ojp, ojp)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, [32]byte{}, ojp, ojp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
 
@@ -603,7 +603,7 @@ func TestUpdateHead_noSavedChanges(t *testing.T) {
 	headRoot := service.headRoot()
 	require.Equal(t, [32]byte{}, headRoot)
 
-	st, blkRoot, err = prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, fcp, fcp)
+	st, blkRoot, err = prepareForkchoiceState(ctx, 0, bellatrixBlkRoot, [32]byte{}, [32]byte{}, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
 	require.NoError(t, fcs.InsertNode(ctx, st, blkRoot))
 	fcs.SetBalancesByRooter(func(context.Context, [32]byte) ([]uint64, error) { return []uint64{1, 2}, nil })

beacon-chain/blockchain/log.go

@@ -45,28 +45,44 @@ func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
 		}
 		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
 	}
-	if b.Version() >= version.Bellatrix {
-		p, err := b.Body().Execution()
+	if b.Version() >= version.EPBS {
+		sh, err := b.Body().SignedExecutionPayloadHeader()
 		if err != nil {
 			return err
 		}
-		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
-		txs, err := p.Transactions()
-		switch {
-		case errors.Is(err, consensus_types.ErrUnsupportedField):
-		case err != nil:
-			return err
-		default:
-			log = log.WithField("txCount", len(txs))
-			txsPerSlotCount.Set(float64(len(txs)))
-		}
-	}
-	if b.Version() >= version.Deneb {
-		kzgs, err := b.Body().BlobKzgCommitments()
+		header, err := sh.Header()
 		if err != nil {
-			log.WithError(err).Error("Failed to get blob KZG commitments")
-		} else if len(kzgs) > 0 {
-			log = log.WithField("kzgCommitmentCount", len(kzgs))
+			return err
+		}
+		log = log.WithFields(logrus.Fields{"payloadHash": header.BlockHash(),
+			"builderIndex":           header.BuilderIndex(),
+			"value":                  header.Value(),
+			"blobKzgCommitmentsRoot": header.BlobKzgCommitmentsRoot(),
+		})
+	} else {
+		if b.Version() >= version.Bellatrix {
+			p, err := b.Body().Execution()
+			if err != nil {
+				return err
+			}
+			log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
+			txs, err := p.Transactions()
+			switch {
+			case errors.Is(err, consensus_types.ErrUnsupportedField):
+			case err != nil:
+				return err
+			default:
+				log = log.WithField("txCount", len(txs))
+				txsPerSlotCount.Set(float64(len(txs)))
+			}
+		}
+		if b.Version() >= version.Deneb {
+			kzgs, err := b.Body().BlobKzgCommitments()
+			if err != nil {
+				log.WithError(err).Error("Failed to get blob KZG commitments")
+			} else if len(kzgs) > 0 {
+				log = log.WithField("kzgCommitmentCount", len(kzgs))
+			}
 		}
 	}
 	log.Info("Finished applying state transition")
@@ -112,6 +128,9 @@ func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte
 
 // logs payload related data every slot.
 func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
+	if block.Version() >= version.EPBS {
+		return nil
+	}
 	isExecutionBlk, err := blocks.IsExecutionBlock(block.Body())
 	if err != nil {
 		return errors.Wrap(err, "could not determine if block is execution block")

beacon-chain/blockchain/metrics.go

@@ -182,6 +182,10 @@ var (
 		Name: "chain_service_processing_milliseconds",
 		Help: "Total time to call a chain service in ReceiveBlock()",
 	})
+	executionEngineProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
+		Name: "execution_engine_processing_milliseconds",
+		Help: "Total time to process an execution payload envelope in ReceiveExecutionPayloadEnvelope()",
+	})
 	dataAvailWaitedTime = promauto.NewSummary(prometheus.SummaryOpts{
 		Name: "da_waited_time_milliseconds",
 		Help: "Total time spent waiting for a data availability check in ReceiveBlock()",

beacon-chain/blockchain/options.go

@@ -1,6 +1,8 @@
 package blockchain
 
 import (
+	"sync"
+
 	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
@@ -69,6 +71,22 @@ func WithDepositCache(c cache.DepositCache) Option {
 	}
 }
 
+// WithPayloadAttestationCache for payload attestation cache.
+func WithPayloadAttestationCache(c *cache.PayloadAttestationCache) Option {
+	return func(s *Service) error {
+		s.cfg.PayloadAttestationCache = c
+		return nil
+	}
+}
+
+// WithPayloadEnvelopeCache for payload envelope cache.
+func WithPayloadEnvelopeCache(c *sync.Map) Option {
+	return func(s *Service) error {
+		s.cfg.PayloadEnvelopeCache = c
+		return nil
+	}
+}
+
 // WithPayloadIDCache for payload ID cache.
 func WithPayloadIDCache(c *cache.PayloadIDCache) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation.go

@@ -97,7 +97,7 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	// We assume trusted attestation in this function has verified signature.
 
 	// Update forkchoice store with the new attestation for updating weight.
-	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Target.Epoch)
+	s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indexedAtt.GetAttestingIndices(), bytesutil.ToBytes32(a.GetData().BeaconBlockRoot), a.GetData().Slot)
 
 	return nil
 }

beacon-chain/blockchain/process_attestation_test.go

@@ -32,7 +32,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	util.SaveBlock(t, ctx, beaconDB, blkWithoutState)
 
 	cp := &ethpb.Checkpoint{}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
+	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, cp, cp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 
@@ -41,7 +41,7 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	r, err := blkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 	cp = &ethpb.Checkpoint{Root: r[:]}
-	st, roblock, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
+	st, roblock, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, cp, cp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	util.SaveBlock(t, ctx, beaconDB, blkWithStateBadAtt)
@@ -139,7 +139,7 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 		ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
 		ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-		state, roblock, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+		state, roblock, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, roblock))
 		require.NoError(t, service.OnAttestation(ctx, att[0], 0))
@@ -170,7 +170,7 @@ func TestService_GetRecentPreState(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)
 
-	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, [32]byte{}, cp0, cp0)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	service.head = &head{
@@ -202,7 +202,7 @@ func TestService_GetAttPreState_Concurrency(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: ckRoot}))
 
-	st, root, err := prepareForkchoiceState(ctx, 100, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, cp1, cp1)
+	st, root, err := prepareForkchoiceState(ctx, 100, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, [32]byte{}, cp1, cp1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 
@@ -259,7 +259,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'A'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)}))
 
-	st, root, err := prepareForkchoiceState(ctx, 1, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, cp1, cp1)
+	st, root, err := prepareForkchoiceState(ctx, 1, [32]byte(cp1.Root), [32]byte{}, [32]byte{'R'}, [32]byte{}, cp1, cp1)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	s1, err := service.getAttPreState(ctx, cp1)
@@ -273,7 +273,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	_, err = service.getAttPreState(ctx, cp2)
 	require.ErrorContains(t, "epoch 2 root 0x4200000000000000000000000000000000000000000000000000000000000000: not a checkpoint in forkchoice", err)
 
-	st, root, err = prepareForkchoiceState(ctx, 33, [32]byte(cp2.Root), [32]byte(cp1.Root), [32]byte{'R'}, cp2, cp2)
+	st, root, err = prepareForkchoiceState(ctx, 33, [32]byte(cp2.Root), [32]byte(cp1.Root), [32]byte{'R'}, [32]byte{}, cp2, cp2)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 
@@ -298,7 +298,7 @@ func TestStore_SaveCheckpointState(t *testing.T) {
 	cp3 := &ethpb.Checkpoint{Epoch: 1, Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, s, bytesutil.ToBytes32([]byte{'C'})))
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Root: bytesutil.PadTo([]byte{'C'}, fieldparams.RootLength)}))
-	st, root, err = prepareForkchoiceState(ctx, 31, [32]byte(cp3.Root), [32]byte(cp2.Root), [32]byte{'P'}, cp2, cp2)
+	st, root, err = prepareForkchoiceState(ctx, 31, [32]byte(cp3.Root), [32]byte(cp2.Root), [32]byte{'P'}, [32]byte{}, cp2, cp2)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 
@@ -318,7 +318,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r1[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
-	st, roblock, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, checkpoint, checkpoint)
+	st, roblock, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, [32]byte{}, checkpoint, checkpoint)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	returned, err := service.getAttPreState(ctx, checkpoint)
@@ -336,7 +336,7 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r2[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
-	st, roblock, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, newCheckpoint, newCheckpoint)
+	st, roblock, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, [32]byte{}, newCheckpoint, newCheckpoint)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)

beacon-chain/blockchain/process_block.go

@@ -67,7 +67,9 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	fcuArgs := &fcuConfig{}
 
 	if s.inRegularSync() {
-		defer s.handleSecondFCUCall(cfg, fcuArgs)
+		if cfg.roblock.Version() < version.EPBS {
+			defer s.handleSecondFCUCall(cfg, fcuArgs)
+		}
 	}
 	defer s.sendLightClientFeeds(cfg)
 	defer s.sendStateFeedOnBlock(cfg)
@@ -99,6 +101,9 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
 		return nil
 	}
+	if cfg.roblock.Version() >= version.EPBS {
+		return nil
+	}
 	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
 		log.WithError(err).Error("Could not get forkchoice update argument")
 		return nil
@@ -375,7 +380,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		}
 		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
-			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
+			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Slot)
 		} else if err := s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
 			return err
 		}

beacon-chain/blockchain/process_block_test.go

@@ -140,7 +140,7 @@ func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
 	// the parent of the last block inserted is the tree node.
 	fcp := &ethpb.Checkpoint{Epoch: 0, Root: service.originBlockRoot[:]}
 	r0 := bytesutil.ToBytes32(roots[0])
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, fcp, fcp)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
@@ -182,7 +182,7 @@ func TestFillForkChoiceMissingBlocks_RootsMatch(t *testing.T) {
 	// the parent of the last block inserted is the tree node.
 	fcp := &ethpb.Checkpoint{Epoch: 0, Root: service.originBlockRoot[:]}
 	r0 := bytesutil.ToBytes32(roots[0])
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, fcp, fcp)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, r0, service.originBlockRoot, [32]byte{}, [32]byte{}, fcp, fcp)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	fcp2 := &forkchoicetypes.Checkpoint{Epoch: 0, Root: r0}
@@ -462,7 +462,7 @@ func TestAncestor_CanUseForkchoice(t *testing.T) {
 		beaconBlock.Block.ParentRoot = bytesutil.PadTo(b.Block.ParentRoot, 32)
 		r, err := b.Block.HashTreeRoot()
 		require.NoError(t, err)
-		st, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, ojc, ofc)
+		st, blkRoot, err := prepareForkchoiceState(context.Background(), b.Block.Slot, r, bytesutil.ToBytes32(b.Block.ParentRoot), params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	}
@@ -502,7 +502,7 @@ func TestAncestor_CanUseDB(t *testing.T) {
 		util.SaveBlock(t, context.Background(), beaconDB, beaconBlock)
 	}
 
-	st, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(context.Background(), 200, r200, r200, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
@@ -1109,7 +1109,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 	logHook := logTest.NewGlobal()
 	for i := 0; i < 10; i++ {
 		fc := &ethpb.Checkpoint{}
-		st, blkRoot, err := prepareForkchoiceState(ctx, 0, wsb1.Block().ParentRoot(), [32]byte{}, [32]byte{}, fc, fc)
+		st, blkRoot, err := prepareForkchoiceState(ctx, 0, wsb1.Block().ParentRoot(), [32]byte{}, [32]byte{}, [32]byte{}, fc, fc)
 		require.NoError(t, err)
 		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 		var wg sync.WaitGroup

beacon-chain/blockchain/receive_attestation.go

@@ -177,7 +177,7 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		}
 
 		hasState := s.cfg.BeaconDB.HasStateSummary(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
-		hasBlock := s.hasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
+		hasBlock := s.chainHasBlock(ctx, bytesutil.ToBytes32(a.GetData().BeaconBlockRoot))
 		if !(hasState && hasBlock) {
 			continue
 		}

beacon-chain/blockchain/receive_attestation_test.go

@@ -43,11 +43,11 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 
 	f := service.cfg.ForkChoiceStore
 	fc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, r32, err := prepareForkchoiceState(ctx, 32, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, fc, fc)
+	state, r32, err := prepareForkchoiceState(ctx, 32, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, [32]byte{}, fc, fc)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r32))
 
-	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32.Root(), params.BeaconConfig().ZeroHash, fc, fc)
+	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32.Root(), params.BeaconConfig().ZeroHash, [32]byte{}, fc, fc)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r33))
 
@@ -83,7 +83,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, [32]byte{}, ojc, ofc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	attsToSave := make([]ethpb.Att, len(atts))
@@ -147,7 +147,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, ojc, ojc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, [32]byte{}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.Equal(t, 3, fcs.NodeCount())
@@ -196,7 +196,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	util.SaveBlock(t, ctx, service.cfg.BeaconDB, b)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, ojc, ojc)
+	state, blkRoot, err := prepareForkchoiceState(ctx, 2, r, service.originBlockRoot, [32]byte{'b'}, [32]byte{}, ojc, ojc)
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	require.Equal(t, 3, fcs.NodeCount())

beacon-chain/blockchain/receive_block.go

@@ -41,18 +41,30 @@ var epochsSinceFinalityExpandCache = primitives.Epoch(4)
 // BlockReceiver interface defines the methods of chain service for receiving and processing new blocks.
 type BlockReceiver interface {
 	ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityStore) error
+	ReceiveExecutionPayloadEnvelope(ctx context.Context, env interfaces.ROExecutionPayloadEnvelope, avs das.AvailabilityStore) error
 	ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityStore) error
 	HasBlock(ctx context.Context, root [32]byte) bool
 	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
 	BlockBeingSynced([32]byte) bool
 }
 
+// PayloadAttestationReceiver defines methods of the chain service for receiving
+// and processing new payload attestations and payload attestation messages
+type PayloadAttestationReceiver interface {
+	ReceivePayloadAttestationMessage(ctx context.Context, a *ethpb.PayloadAttestationMessage) error
+}
+
 // BlobReceiver interface defines the methods of chain service for receiving new
 // blobs
 type BlobReceiver interface {
 	ReceiveBlob(context.Context, blocks.VerifiedROBlob) error
 }
 
+// ExecutionPayloadReceiver interface defines the methods of chain service for receiving `ROExecutionPayloadEnvelope`.
+type ExecutionPayloadReceiver interface {
+	ReceiveExecutionPayloadEnvelope(ctx context.Context, envelope interfaces.ROExecutionPayloadEnvelope, _ das.AvailabilityStore) error
+}
+
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -89,14 +101,30 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
-
-	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, roblock)
-	if err != nil {
-		return err
-	}
-	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
-	if err != nil {
-		return err
+	var postState state.BeaconState
+	var isValidPayload bool
+	var daWaitedTime time.Duration
+	if blockCopy.Version() >= version.EPBS {
+		postState, err = s.validateStateTransition(ctx, preState, roblock)
+		if err != nil {
+			return errors.Wrap(err, "could not validate state transition")
+		}
+		optimistic, err := s.IsOptimisticForRoot(ctx, roblock.Block().ParentRoot())
+		if err != nil {
+			return errors.Wrap(err, "could not check if parent is optimistic")
+		}
+		// if the parent is not optimistic then we can set the block as
+		// not optimistic.
+		isValidPayload = !optimistic
+	} else {
+		postState, isValidPayload, err = s.validateExecutionAndConsensus(ctx, preState, roblock)
+		if err != nil {
+			return err
+		}
+		daWaitedTime, err = s.handleDA(ctx, blockCopy, blockRoot, avs)
+		if err != nil {
+			return err
+		}
 	}
 	// Defragment the state before continuing block processing.
 	s.defragmentState(postState)

beacon-chain/blockchain/receive_execution_payload_envelope.go

@@ -0,0 +1,153 @@
+package blockchain
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+	"golang.org/x/sync/errgroup"
+)
+
+// ReceiveExecutionPayloadEnvelope is a function that defines the operations (minus pubsub)
+// that are performed on a received execution payload envelope. The operations consist of:
+//  1. Validate the payload, apply state transition.
+//  2. Apply fork choice to the processed payload
+//  3. Save latest head info
+func (s *Service) ReceiveExecutionPayloadEnvelope(ctx context.Context, envelope interfaces.ROExecutionPayloadEnvelope, _ das.AvailabilityStore) error {
+	receivedTime := time.Now()
+	root := envelope.BeaconBlockRoot()
+	s.payloadBeingSynced.set(envelope)
+	defer s.payloadBeingSynced.unset(root)
+
+	preState, err := s.getPayloadEnvelopePrestate(ctx, envelope)
+	if err != nil {
+		return errors.Wrap(err, "could not get prestate")
+	}
+
+	eg, _ := errgroup.WithContext(ctx)
+	var postState state.BeaconState
+	eg.Go(func() error {
+		if err := epbs.ValidatePayloadStateTransition(ctx, preState, envelope); err != nil {
+			return errors.Wrap(err, "failed to validate consensus state transition function")
+		}
+		return nil
+	})
+	var isValidPayload bool
+	eg.Go(func() error {
+		var err error
+		isValidPayload, err = s.validateExecutionOnEnvelope(ctx, envelope)
+		if err != nil {
+			return errors.Wrap(err, "could not notify the engine of the new payload")
+		}
+		return nil
+	})
+
+	if err := eg.Wait(); err != nil {
+		return err
+	}
+	_ = isValidPayload
+	_ = postState
+	daStartTime := time.Now()
+	// TODO: Add DA check
+	daWaitedTime := time.Since(daStartTime)
+	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
+	// TODO: Add Head update, cache handling, postProcessing
+	if err := s.insertPayloadEnvelope(envelope); err != nil {
+		return errors.Wrap(err, "could not insert payload to forkchoice")
+	}
+	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
+	executionEngineProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
+	return nil
+}
+
+// notifyNewPayload signals execution engine on a new payload.
+// It returns true if the EL has returned VALID for the block
+func (s *Service) notifyNewEnvelope(ctx context.Context, envelope interfaces.ROExecutionPayloadEnvelope) (bool, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
+	defer span.End()
+
+	payload, err := envelope.Execution()
+	if err != nil {
+		return false, errors.Wrap(err, "could not get execution payload")
+	}
+
+	versionedHashes := envelope.VersionedHashes()
+	root := envelope.BeaconBlockRoot()
+	parentRoot, err := s.ParentRoot(root)
+	if err != nil {
+		return false, errors.Wrap(err, "could not get parent block root")
+	}
+	pr := common.Hash(parentRoot)
+	requests := envelope.ExecutionRequests()
+	lastValidHash, err := s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr, requests)
+	switch {
+	case err == nil:
+		newPayloadValidNodeCount.Inc()
+		return true, nil
+	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
+		newPayloadOptimisticNodeCount.Inc()
+		log.WithFields(logrus.Fields{
+			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
+		}).Info("Called new payload with optimistic block")
+		return false, nil
+	case errors.Is(err, execution.ErrInvalidPayloadStatus):
+		lvh := bytesutil.ToBytes32(lastValidHash)
+		return false, invalidBlock{
+			error:         ErrInvalidPayload,
+			lastValidHash: lvh,
+		}
+	default:
+		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
+	}
+}
+
+// validateExecutionOnEnvelope notifies the engine of the incoming execution payload and returns true if the payload is valid
+func (s *Service) validateExecutionOnEnvelope(ctx context.Context, e interfaces.ROExecutionPayloadEnvelope) (bool, error) {
+	isValidPayload, err := s.notifyNewEnvelope(ctx, e)
+	if err == nil {
+		return isValidPayload, nil
+	}
+	blockRoot := e.BeaconBlockRoot()
+	parentRoot, rootErr := s.ParentRoot(blockRoot)
+	if rootErr != nil {
+		return false, errors.Wrap(rootErr, "could not get parent block root")
+	}
+	s.cfg.ForkChoiceStore.Lock()
+	err = s.handleInvalidExecutionError(ctx, err, blockRoot, parentRoot)
+	s.cfg.ForkChoiceStore.Unlock()
+	return false, err
+}
+
+func (s *Service) getPayloadEnvelopePrestate(ctx context.Context, e interfaces.ROExecutionPayloadEnvelope) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "blockChain.getPayloadEnvelopePreState")
+	defer span.End()
+
+	// Verify incoming payload has a valid pre state.
+	root := e.BeaconBlockRoot()
+	// Verify the referred block is known to forkchoice
+	if !s.InForkchoice(root) {
+		return nil, errors.New("Cannot import execution payload envelope for unknown block")
+	}
+	if err := s.verifyBlkPreState(ctx, root); err != nil {
+		return nil, errors.Wrap(err, "could not verify payload prestate")
+	}
+
+	preState, err := s.cfg.StateGen.StateByRoot(ctx, root)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get pre state")
+	}
+	if preState == nil || preState.IsNil() {
+		return nil, errors.Wrap(err, "nil pre state")
+	}
+	return preState, nil
+}

beacon-chain/blockchain/receive_execution_payload_envelope_test.go

@@ -0,0 +1,100 @@
+package blockchain
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func Test_getPayloadEnvelopePrestate(t *testing.T) {
+	service, tr := minimalTestService(t)
+	ctx, fcs := tr.ctx, tr.fcs
+
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+
+	p := random.ExecutionPayloadEnvelope(t)
+	p.BeaconBlockRoot = service.originBlockRoot[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+
+	_, err = service.getPayloadEnvelopePrestate(ctx, e)
+	require.NoError(t, err)
+}
+
+func Test_notifyNewEnvelope(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx, fcs := tr.ctx, tr.fcs
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+	p := random.ExecutionPayloadEnvelope(t)
+	p.BeaconBlockRoot = service.originBlockRoot[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	engine := &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = engine
+	isValidPayload, err := service.notifyNewEnvelope(ctx, e)
+	require.NoError(t, err)
+	require.Equal(t, true, isValidPayload)
+}
+
+func Test_validateExecutionOnEnvelope(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx, fcs := tr.ctx, tr.fcs
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+	p := random.ExecutionPayloadEnvelope(t)
+	p.BeaconBlockRoot = service.originBlockRoot[:]
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	engine := &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = engine
+	isValidPayload, err := service.validateExecutionOnEnvelope(ctx, e)
+	require.NoError(t, err)
+	require.Equal(t, true, isValidPayload)
+}
+
+func Test_ReceiveExecutionPayloadEnvelope(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx, fcs := tr.ctx, tr.fcs
+	gs, _ := util.DeterministicGenesisStateEpbs(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
+	post := gs.Copy()
+	p := &enginev1.ExecutionPayloadEnvelope{
+		Payload: &enginev1.ExecutionPayloadElectra{
+			ParentHash: make([]byte, 32),
+			BlockHash:  make([]byte, 32),
+		},
+		BeaconBlockRoot:    service.originBlockRoot[:],
+		BlobKzgCommitments: make([][]byte, 0),
+		StateRoot:          make([]byte, 32),
+		ExecutionRequests:  &enginev1.ExecutionRequests{},
+	}
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	das := &das.MockAvailabilityStore{}
+
+	blockHeader := post.LatestBlockHeader()
+	prevStateRoot, err := post.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	blockHeader.StateRoot = prevStateRoot[:]
+	require.NoError(t, post.SetLatestBlockHeader(blockHeader))
+	stRoot, err := post.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	p.StateRoot = stRoot[:]
+	engine := &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = engine
+	require.NoError(t, service.ReceiveExecutionPayloadEnvelope(ctx, e, das))
+}

beacon-chain/blockchain/receive_payload_attestation_message.go

@@ -0,0 +1,33 @@
+package blockchain
+
+import (
+	"context"
+	"slices"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+func (s *Service) ReceivePayloadAttestationMessage(ctx context.Context, a *eth.PayloadAttestationMessage) error {
+	if err := helpers.ValidateNilPayloadAttestationMessage(a); err != nil {
+		return err
+	}
+	root := [32]byte(a.Data.BeaconBlockRoot)
+	st, err := s.HeadStateReadOnly(ctx)
+	if err != nil {
+		return err
+	}
+	ptc, err := helpers.GetPayloadTimelinessCommittee(ctx, st, a.Data.Slot)
+	if err != nil {
+		return err
+	}
+	idx := slices.Index(ptc, a.ValidatorIndex)
+	if idx == -1 {
+		return errInvalidValidatorIndex
+	}
+	if s.cfg.PayloadAttestationCache.Seen(root, uint64(primitives.ValidatorIndex(idx))) {
+		return nil
+	}
+	return s.cfg.PayloadAttestationCache.Add(a, uint64(idx))
+}

beacon-chain/blockchain/service.go

@@ -66,6 +66,7 @@ type Service struct {
 	syncComplete                  chan struct{}
 	blobNotifiers                 *blobNotifierMap
 	blockBeingSynced              *currentlySyncingBlock
+	payloadBeingSynced            *currentlySyncingPayload
 	blobStorage                   *filesystem.BlobStorage
 	lastPublishedLightClientEpoch primitives.Epoch
 }
@@ -76,6 +77,8 @@ type config struct {
 	ChainStartFetcher       execution.ChainStartFetcher
 	BeaconDB                db.HeadAccessDatabase
 	DepositCache            cache.DepositCache
+	PayloadAttestationCache *cache.PayloadAttestationCache
+	PayloadEnvelopeCache    *sync.Map
 	PayloadIDCache          *cache.PayloadIDCache
 	TrackedValidatorsCache  *cache.TrackedValidatorsCache
 	AttPool                 attestations.Pool
@@ -180,6 +183,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 		blobNotifiers:        bn,
 		cfg:                  &config{},
 		blockBeingSynced:     &currentlySyncingBlock{roots: make(map[[32]byte]struct{})},
+		payloadBeingSynced:   &currentlySyncingPayload{roots: make(map[[32]byte]primitives.PTCStatus)},
 	}
 	for _, opt := range opts {
 		if err := opt(srv); err != nil {
@@ -555,7 +559,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 // 2.) Check DB.
 // Checking 1.) is ten times faster than checking 2.)
 // this function requires a lock in forkchoice
-func (s *Service) hasBlock(ctx context.Context, root [32]byte) bool {
+func (s *Service) chainHasBlock(ctx context.Context, root [32]byte) bool {
 	if s.cfg.ForkChoiceStore.HasNode(root) {
 		return true
 	}

beacon-chain/blockchain/service_test.go

@@ -386,8 +386,8 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
 
-	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
-	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
+	assert.Equal(t, false, s.chainHasBlock(ctx, [32]byte{}), "Should not have block")
+	assert.Equal(t, true, s.chainHasBlock(ctx, r), "Should have block")
 }
 
 func TestServiceStop_SaveCachedBlocks(t *testing.T) {

beacon-chain/blockchain/testing/BUILD.bazel

@@ -3,7 +3,10 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     testonly = True,
-    srcs = ["mock.go"],
+    srcs = [
+        "mock.go",
+        "mock_epbs.go",
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing",
     visibility = [
         "//beacon-chain:__subpackages__",

beacon-chain/blockchain/testing/mock.go

@@ -37,44 +37,50 @@ var ErrNilState = errors.New("nil state")
 
 // ChainService defines the mock interface for testing
 type ChainService struct {
-	NotFinalized                bool
-	Optimistic                  bool
-	ValidAttestation            bool
-	ValidatorsRoot              [32]byte
-	PublicKey                   [fieldparams.BLSPubkeyLength]byte
-	FinalizedCheckPoint         *ethpb.Checkpoint
-	CurrentJustifiedCheckPoint  *ethpb.Checkpoint
-	PreviousJustifiedCheckPoint *ethpb.Checkpoint
-	Slot                        *primitives.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
-	Balance                     *precompute.Balance
-	CanonicalRoots              map[[32]byte]bool
-	Fork                        *ethpb.Fork
-	ETH1Data                    *ethpb.Eth1Data
-	InitSyncBlockRoots          map[[32]byte]bool
-	DB                          db.Database
-	State                       state.BeaconState
-	Block                       interfaces.ReadOnlySignedBeaconBlock
-	VerifyBlkDescendantErr      error
-	stateNotifier               statefeed.Notifier
-	BlocksReceived              []interfaces.ReadOnlySignedBeaconBlock
-	SyncCommitteeIndices        []primitives.CommitteeIndex
-	blockNotifier               blockfeed.Notifier
-	opNotifier                  opfeed.Notifier
-	Root                        []byte
-	SyncCommitteeDomain         []byte
-	SyncSelectionProofDomain    []byte
-	SyncContributionProofDomain []byte
-	SyncCommitteePubkeys        [][]byte
-	Genesis                     time.Time
-	ForkChoiceStore             forkchoice.ForkChoicer
-	ReceiveBlockMockErr         error
-	OptimisticCheckRootReceived [32]byte
-	FinalizedRoots              map[[32]byte]bool
-	OptimisticRoots             map[[32]byte]bool
-	BlockSlot                   primitives.Slot
-	SyncingRoot                 [32]byte
-	Blobs                       []blocks.VerifiedROBlob
-	TargetRoot                  [32]byte
+	NotFinalized                        bool
+	Optimistic                          bool
+	ValidAttestation                    bool
+	ValidatorsRoot                      [32]byte
+	PublicKey                           [fieldparams.BLSPubkeyLength]byte
+	FinalizedCheckPoint                 *ethpb.Checkpoint
+	CurrentJustifiedCheckPoint          *ethpb.Checkpoint
+	PreviousJustifiedCheckPoint         *ethpb.Checkpoint
+	Slot                                *primitives.Slot // Pointer because 0 is a useful value, so checking against it can be incorrect.
+	Balance                             *precompute.Balance
+	CanonicalRoots                      map[[32]byte]bool
+	Fork                                *ethpb.Fork
+	ETH1Data                            *ethpb.Eth1Data
+	InitSyncBlockRoots                  map[[32]byte]bool
+	DB                                  db.Database
+	State                               state.BeaconState
+	Block                               interfaces.ReadOnlySignedBeaconBlock
+	ExecutionPayloadEnvelope            interfaces.ROExecutionPayloadEnvelope
+	VerifyBlkDescendantErr              error
+	stateNotifier                       statefeed.Notifier
+	BlocksReceived                      []interfaces.ReadOnlySignedBeaconBlock
+	SyncCommitteeIndices                []primitives.CommitteeIndex
+	blockNotifier                       blockfeed.Notifier
+	opNotifier                          opfeed.Notifier
+	Root                                []byte
+	SyncCommitteeDomain                 []byte
+	SyncSelectionProofDomain            []byte
+	SyncContributionProofDomain         []byte
+	SyncCommitteePubkeys                [][]byte
+	Genesis                             time.Time
+	ForkChoiceStore                     forkchoice.ForkChoicer
+	ReceiveBlockMockErr                 error
+	ReceiveEnvelopeMockErr              error
+	OptimisticCheckRootReceived         [32]byte
+	FinalizedRoots                      map[[32]byte]bool
+	OptimisticRoots                     map[[32]byte]bool
+	BlockSlot                           primitives.Slot
+	SyncingRoot                         [32]byte
+	Blobs                               []blocks.VerifiedROBlob
+	TargetRoot                          [32]byte
+	HighestReceivedSlot                 primitives.Slot
+	HighestReceivedRoot                 [32]byte
+	PayloadStatus                       primitives.PTCStatus
+	ReceivePayloadAttestationMessageErr error
 }
 
 func (s *ChainService) Ancestor(ctx context.Context, root []byte, slot primitives.Slot) ([]byte, error) {
@@ -641,12 +647,12 @@ func (s *ChainService) ReceivedBlocksLastEpoch() (uint64, error) {
 	return 0, nil
 }
 
-// HighestReceivedBlockSlot mocks the same method in the chain service
-func (s *ChainService) HighestReceivedBlockSlot() primitives.Slot {
+// HighestReceivedBlockSlotRoot mocks the same method in the chain service
+func (s *ChainService) HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte) {
 	if s.ForkChoiceStore != nil {
-		return s.ForkChoiceStore.HighestReceivedBlockSlot()
+		return s.ForkChoiceStore.HighestReceivedBlockSlotRoot()
 	}
-	return 0
+	return s.HighestReceivedSlot, s.HighestReceivedRoot
 }
 
 // InsertNode mocks the same method in the chain service
@@ -706,3 +712,17 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil
 }
+
+// HashInForkchoice mocks the same method in the chain service
+func (c *ChainService) HashInForkchoice([32]byte) bool {
+	return false
+}
+
+// ReceivePayloadAttestationMessage mocks the same method in the chain service
+func (c *ChainService) ReceivePayloadAttestationMessage(_ context.Context, _ *ethpb.PayloadAttestationMessage) error {
+	return c.ReceivePayloadAttestationMessageErr
+}
+
+func (c *ChainService) GetPTCVote(root [32]byte) primitives.PTCStatus {
+	return c.PayloadStatus
+}

beacon-chain/blockchain/testing/mock_epbs.go

@@ -0,0 +1,25 @@
+package testing
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+// ReceiveExecutionPayloadEnvelope mocks the  method in chain service.
+func (s *ChainService) ReceiveExecutionPayloadEnvelope(ctx context.Context, env interfaces.ROExecutionPayloadEnvelope, _ das.AvailabilityStore) error {
+	if s.ReceiveBlockMockErr != nil {
+		return s.ReceiveBlockMockErr
+	}
+	if s.State == nil {
+		return ErrNilState
+	}
+	if s.State.Slot() == env.Slot() {
+		if err := s.State.SetLatestFullSlot(s.State.Slot()); err != nil {
+			return err
+		}
+	}
+	s.ExecutionPayloadEnvelope = env
+	return nil
+}

beacon-chain/cache/BUILD.bazel

@@ -15,11 +15,13 @@ go_library(
         "doc.go",
         "error.go",
         "interfaces.go",
+        "payload_attestation.go",
         "payload_id.go",
         "proposer_indices.go",
         "proposer_indices_disabled.go",  # keep
         "proposer_indices_type.go",
         "registration.go",
+        "signed_execution_header.go",
         "skip_slot_cache.go",
         "subnet_ids.go",
         "sync_committee.go",
@@ -42,11 +44,13 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
@@ -70,10 +74,12 @@ go_test(
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
         "committee_test.go",
+        "payload_attestation_test.go",
         "payload_id_test.go",
         "private_access_test.go",
         "proposer_indices_test.go",
         "registration_test.go",
+        "signed_execution_header_test.go",
         "skip_slot_cache_test.go",
         "subnet_ids_test.go",
         "sync_committee_head_state_test.go",
@@ -88,7 +94,9 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",

beacon-chain/cache/payload_attestation.go

@@ -0,0 +1,132 @@
+package cache
+
+import (
+	"errors"
+	"sync"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+var errNilPayloadAttestationMessage = errors.New("nil Payload Attestation Message")
+
+// PayloadAttestationCache keeps a map of all the PTC votes that were seen,
+// already aggregated. The key is the beacon block root.
+type PayloadAttestationCache struct {
+	root         [32]byte
+	attestations [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation
+	sync.Mutex
+}
+
+// Seen returns true if a vote for the given Beacon Block Root has already been processed
+// for this Payload Timeliness Committee index. This will return true even if
+// the Payload status differs.
+func (p *PayloadAttestationCache) Seen(root [32]byte, idx uint64) bool {
+	p.Lock()
+	defer p.Unlock()
+	if p.root != root {
+		return false
+	}
+	for _, agg := range p.attestations {
+		if agg == nil {
+			continue
+		}
+		if agg.AggregationBits.BitAt(idx) {
+			return true
+		}
+	}
+	return false
+}
+
+// messageToPayloadAttestation creates a PayloadAttestation with a single
+// aggregated bit from the passed PayloadAttestationMessage
+func messageToPayloadAttestation(att *eth.PayloadAttestationMessage, idx uint64) *eth.PayloadAttestation {
+	bits := primitives.NewPayloadAttestationAggregationBits()
+	bits.SetBitAt(idx, true)
+	data := &eth.PayloadAttestationData{
+		BeaconBlockRoot: bytesutil.SafeCopyBytes(att.Data.BeaconBlockRoot),
+		Slot:            att.Data.Slot,
+		PayloadStatus:   att.Data.PayloadStatus,
+	}
+	return &eth.PayloadAttestation{
+		AggregationBits: bits,
+		Data:            data,
+		Signature:       bytesutil.SafeCopyBytes(att.Signature),
+	}
+}
+
+// aggregateSigFromMessage returns the aggregated signature from a Payload
+// Attestation by adding the passed signature in the PayloadAttestationMessage,
+// no signature validation is performed.
+func aggregateSigFromMessage(aggregated *eth.PayloadAttestation, message *eth.PayloadAttestationMessage) ([]byte, error) {
+	aggSig, err := bls.SignatureFromBytesNoValidation(aggregated.Signature)
+	if err != nil {
+		return nil, err
+	}
+	sig, err := bls.SignatureFromBytesNoValidation(message.Signature)
+	if err != nil {
+		return nil, err
+	}
+	return bls.AggregateSignatures([]bls.Signature{aggSig, sig}).Marshal(), nil
+}
+
+// Add adds a PayloadAttestationMessage to the internal cache of aggregated
+// PayloadAttestations.
+// If the index has already been seen for this attestation status the function does nothing.
+// If the root is not the cached root, the function will clear the previous cache
+// This function assumes that the message has already been validated. In
+// particular that the signature is valid and that the block root corresponds to
+// the given slot in the attestation data.
+func (p *PayloadAttestationCache) Add(att *eth.PayloadAttestationMessage, idx uint64) error {
+	if att == nil || att.Data == nil || att.Data.BeaconBlockRoot == nil {
+		return errNilPayloadAttestationMessage
+	}
+	p.Lock()
+	defer p.Unlock()
+	root := [32]byte(att.Data.BeaconBlockRoot)
+	if p.root != root {
+		p.root = root
+		p.attestations = [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{}
+	}
+	agg := p.attestations[att.Data.PayloadStatus]
+	if agg == nil {
+		p.attestations[att.Data.PayloadStatus] = messageToPayloadAttestation(att, idx)
+		return nil
+	}
+	if agg.AggregationBits.BitAt(idx) {
+		return nil
+	}
+	sig, err := aggregateSigFromMessage(agg, att)
+	if err != nil {
+		return err
+	}
+	agg.Signature = sig
+	agg.AggregationBits.SetBitAt(idx, true)
+	return nil
+}
+
+// Get returns the aggregated PayloadAttestation for the given root and status
+// if the root doesn't exist or status is invalid, the function returns nil.
+func (p *PayloadAttestationCache) Get(root [32]byte, status primitives.PTCStatus) *eth.PayloadAttestation {
+	p.Lock()
+	defer p.Unlock()
+
+	if p.root != root {
+		return nil
+	}
+	if status >= primitives.PAYLOAD_INVALID_STATUS {
+		return nil
+	}
+
+	return eth.CopyPayloadAttestation(p.attestations[status])
+}
+
+// Clear clears the internal map
+func (p *PayloadAttestationCache) Clear() {
+	p.Lock()
+	defer p.Unlock()
+	p.root = [32]byte{}
+	p.attestations = [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{}
+}

beacon-chain/cache/payload_attestation_test.go

@@ -0,0 +1,143 @@
+package cache
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestPayloadAttestationCache(t *testing.T) {
+	p := &PayloadAttestationCache{}
+
+	//Test Has seen
+	root := [32]byte{'r'}
+	idx := uint64(5)
+	require.Equal(t, false, p.Seen(root, idx))
+
+	// Test Add
+	msg := &eth.PayloadAttestationMessage{
+		Signature: bls.NewAggregateSignature().Marshal(),
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: root[:],
+			Slot:            1,
+			PayloadStatus:   primitives.PAYLOAD_PRESENT,
+		},
+	}
+
+	// Add new root
+	require.NoError(t, p.Add(msg, idx))
+	require.Equal(t, true, p.Seen(root, idx))
+	require.Equal(t, root, p.root)
+	att := p.attestations[primitives.PAYLOAD_PRESENT]
+	indices := att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx)}, indices)
+	singleSig := bytesutil.SafeCopyBytes(msg.Signature)
+	require.DeepEqual(t, singleSig, att.Signature)
+
+	// Test Seen
+	require.Equal(t, true, p.Seen(root, idx))
+	require.Equal(t, false, p.Seen(root, idx+1))
+
+	// Add another attestation on the same data
+	msg2 := &eth.PayloadAttestationMessage{
+		Signature: bls.NewAggregateSignature().Marshal(),
+		Data:      att.Data,
+	}
+	idx2 := uint64(7)
+	require.NoError(t, p.Add(msg2, idx2))
+	att = p.attestations[primitives.PAYLOAD_PRESENT]
+	indices = att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx), int(idx2)}, indices)
+	require.DeepNotEqual(t, att.Signature, msg.Signature)
+
+	// Try again the same index
+	require.NoError(t, p.Add(msg2, idx2))
+	att2 := p.attestations[primitives.PAYLOAD_PRESENT]
+	indices = att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx), int(idx2)}, indices)
+	require.DeepEqual(t, att, att2)
+
+	// Test Seen
+	require.Equal(t, true, p.Seen(root, idx2))
+	require.Equal(t, false, p.Seen(root, idx2+1))
+
+	// Add another payload status for a different payload status
+	msg3 := &eth.PayloadAttestationMessage{
+		Signature: bls.NewAggregateSignature().Marshal(),
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: root[:],
+			Slot:            1,
+			PayloadStatus:   primitives.PAYLOAD_WITHHELD,
+		},
+	}
+	idx3 := uint64(17)
+
+	require.NoError(t, p.Add(msg3, idx3))
+	att3 := p.attestations[primitives.PAYLOAD_WITHHELD]
+	indices3 := att3.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx3)}, indices3)
+	require.DeepEqual(t, singleSig, att3.Signature)
+
+	// Add a different root
+	root2 := [32]byte{'s'}
+	msg.Data.BeaconBlockRoot = root2[:]
+	require.NoError(t, p.Add(msg, idx))
+	require.Equal(t, root2, p.root)
+	require.Equal(t, true, p.Seen(root2, idx))
+	require.Equal(t, false, p.Seen(root, idx))
+	att = p.attestations[primitives.PAYLOAD_PRESENT]
+	indices = att.AggregationBits.BitIndices()
+	require.DeepEqual(t, []int{int(idx)}, indices)
+}
+
+func TestPayloadAttestationCache_Get(t *testing.T) {
+	root := [32]byte{1, 2, 3}
+	wrongRoot := [32]byte{4, 5, 6}
+	status := primitives.PAYLOAD_PRESENT
+	invalidStatus := primitives.PAYLOAD_INVALID_STATUS
+
+	cache := &PayloadAttestationCache{
+		root: root,
+		attestations: [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{
+			{
+				Signature: []byte{1},
+			},
+			{
+				Signature: []byte{2},
+			},
+			{
+				Signature: []byte{3},
+			},
+		},
+	}
+
+	t.Run("valid root and status", func(t *testing.T) {
+		result := cache.Get(root, status)
+		require.NotNil(t, result, "Expected a non-nil result")
+		require.DeepEqual(t, cache.attestations[status], result)
+	})
+
+	t.Run("invalid root", func(t *testing.T) {
+		result := cache.Get(wrongRoot, status)
+		require.IsNil(t, result)
+	})
+
+	t.Run("status out of bound", func(t *testing.T) {
+		result := cache.Get(root, invalidStatus)
+		require.IsNil(t, result)
+	})
+
+	t.Run("no attestation", func(t *testing.T) {
+		emptyCache := &PayloadAttestationCache{
+			root:         root,
+			attestations: [primitives.PAYLOAD_INVALID_STATUS]*eth.PayloadAttestation{},
+		}
+
+		result := emptyCache.Get(root, status)
+		require.IsNil(t, result)
+	})
+}

beacon-chain/cache/signed_execution_header.go

@@ -0,0 +1,76 @@
+package cache
+
+import (
+	"bytes"
+	"sync"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+)
+
+// ExecutionPayloadHeaders is used  by the sync service to store signed execution payload headers after they pass validation,
+// and filter out subsequent headers with lower value.
+// The signed header from this cache could be used by the proposer when proposing the next slot.
+type ExecutionPayloadHeaders struct {
+	headers map[primitives.Slot][]*enginev1.SignedExecutionPayloadHeader
+	sync.RWMutex
+}
+
+func NewExecutionPayloadHeaders() *ExecutionPayloadHeaders {
+	return &ExecutionPayloadHeaders{
+		headers: make(map[primitives.Slot][]*enginev1.SignedExecutionPayloadHeader),
+	}
+}
+
+// SaveSignedExecutionPayloadHeader saves the signed execution payload header to the cache.
+// The cache stores headers for up to two slots. If the input slot is higher than the lowest slot
+// currently in the cache, the lowest slot is removed to make space for the new header.
+// Only the highest value header for a given parent block hash will be stored.
+// This function assumes caller already checks header's slot is current or next slot, it doesn't account for slot validation.
+func (c *ExecutionPayloadHeaders) SaveSignedExecutionPayloadHeader(header *enginev1.SignedExecutionPayloadHeader) {
+	c.Lock()
+	defer c.Unlock()
+
+	for s := range c.headers {
+		if s+1 < header.Message.Slot {
+			delete(c.headers, s)
+		}
+	}
+
+	// Add or update the header in the map
+	if _, ok := c.headers[header.Message.Slot]; !ok {
+		c.headers[header.Message.Slot] = []*enginev1.SignedExecutionPayloadHeader{header}
+	} else {
+		found := false
+		for i, h := range c.headers[header.Message.Slot] {
+			if bytes.Equal(h.Message.ParentBlockHash, header.Message.ParentBlockHash) && bytes.Equal(h.Message.ParentBlockRoot, header.Message.ParentBlockRoot) {
+				if header.Message.Value > h.Message.Value {
+					c.headers[header.Message.Slot][i] = header
+				}
+				found = true
+				break
+			}
+		}
+		if !found {
+			c.headers[header.Message.Slot] = append(c.headers[header.Message.Slot], header)
+		}
+	}
+}
+
+// SignedExecutionPayloadHeader returns the signed payload header for the given slot and parent block hash and block root.
+// Returns nil if the header is not found.
+// This should be used when the caller wants the header to match parent block hash and parent block root such as proposer choosing a header to propose.
+func (c *ExecutionPayloadHeaders) SignedExecutionPayloadHeader(slot primitives.Slot, parentBlockHash []byte, parentBlockRoot []byte) *enginev1.SignedExecutionPayloadHeader {
+	c.RLock()
+	defer c.RUnlock()
+
+	if headers, ok := c.headers[slot]; ok {
+		for _, header := range headers {
+			if bytes.Equal(header.Message.ParentBlockHash, parentBlockHash) && bytes.Equal(header.Message.ParentBlockRoot, parentBlockRoot) {
+				return header
+			}
+		}
+	}
+
+	return nil
+}

beacon-chain/cache/signed_execution_header_test.go

@@ -0,0 +1,243 @@
+package cache
+
+import (
+	"testing"
+
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func Test_SaveSignedExecutionPayloadHeader(t *testing.T) {
+	t.Run("First header should be added to cache", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				Value:           100,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header)
+		require.Equal(t, 1, len(c.headers))
+		require.Equal(t, header, c.headers[1][0])
+	})
+
+	t.Run("Second header with higher slot should be added, and both slots should be in cache", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header1 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				Value:           100,
+			},
+		}
+		header2 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           100,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header1)
+		c.SaveSignedExecutionPayloadHeader(header2)
+		require.Equal(t, 2, len(c.headers))
+		require.Equal(t, header1, c.headers[1][0])
+		require.Equal(t, header2, c.headers[2][0])
+	})
+
+	t.Run("Third header with higher slot should replace the oldest slot", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header1 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				Value:           100,
+			},
+		}
+		header2 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           100,
+			},
+		}
+		header3 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            3,
+				ParentBlockHash: []byte("parent3"),
+				Value:           100,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header1)
+		c.SaveSignedExecutionPayloadHeader(header2)
+		c.SaveSignedExecutionPayloadHeader(header3)
+		require.Equal(t, 2, len(c.headers))
+		require.Equal(t, header2, c.headers[2][0])
+		require.Equal(t, header3, c.headers[3][0])
+	})
+
+	t.Run("Header with same slot but higher value should replace the existing one", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header1 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           100,
+			},
+		}
+		header2 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           200,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header1)
+		c.SaveSignedExecutionPayloadHeader(header2)
+		require.Equal(t, 1, len(c.headers[2]))
+		require.Equal(t, header2, c.headers[2][0])
+	})
+
+	t.Run("Header with different parent block hash should be appended to the same slot", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header1 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent1"),
+				Value:           100,
+			},
+		}
+		header2 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           200,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header1)
+		c.SaveSignedExecutionPayloadHeader(header2)
+		require.Equal(t, 2, len(c.headers[2]))
+		require.Equal(t, header1, c.headers[2][0])
+		require.Equal(t, header2, c.headers[2][1])
+	})
+}
+
+func TestSignedExecutionPayloadHeader(t *testing.T) {
+	t.Run("Return header when slot and parentBlockHash match", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				ParentBlockRoot: []byte("root1"),
+				Value:           100,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header)
+		result := c.SignedExecutionPayloadHeader(1, []byte("parent1"), []byte("root1"))
+		require.NotNil(t, result)
+		require.Equal(t, header, result)
+	})
+
+	t.Run("Return nil when no matching slot and parentBlockHash", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				ParentBlockRoot: []byte("root1"),
+				Value:           100,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header)
+		result := c.SignedExecutionPayloadHeader(2, []byte("parent2"), []byte("root1"))
+		require.IsNil(t, result)
+	})
+
+	t.Run("Return nil when no matching slot and parentBlockRoot", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				ParentBlockRoot: []byte("root1"),
+				Value:           100,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header)
+		result := c.SignedExecutionPayloadHeader(2, []byte("parent1"), []byte("root2"))
+		require.IsNil(t, result)
+	})
+
+	t.Run("Return header when there are two slots in the cache and a match is found", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header1 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				Value:           100,
+			},
+		}
+		header2 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           200,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header1)
+		c.SaveSignedExecutionPayloadHeader(header2)
+
+		// Check for the first header
+		result1 := c.SignedExecutionPayloadHeader(1, []byte("parent1"), []byte{})
+		require.NotNil(t, result1)
+		require.Equal(t, header1, result1)
+
+		// Check for the second header
+		result2 := c.SignedExecutionPayloadHeader(2, []byte("parent2"), []byte{})
+		require.NotNil(t, result2)
+		require.Equal(t, header2, result2)
+	})
+
+	t.Run("Return nil when slot is evicted from cache", func(t *testing.T) {
+		c := NewExecutionPayloadHeaders()
+		header1 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            1,
+				ParentBlockHash: []byte("parent1"),
+				Value:           100,
+			},
+		}
+		header2 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            2,
+				ParentBlockHash: []byte("parent2"),
+				Value:           200,
+			},
+		}
+		header3 := &enginev1.SignedExecutionPayloadHeader{
+			Message: &enginev1.ExecutionPayloadHeaderEPBS{
+				Slot:            3,
+				ParentBlockHash: []byte("parent3"),
+				Value:           300,
+			},
+		}
+		c.SaveSignedExecutionPayloadHeader(header1)
+		c.SaveSignedExecutionPayloadHeader(header2)
+		c.SaveSignedExecutionPayloadHeader(header3)
+
+		// The first slot should be evicted, so result should be nil
+		result := c.SignedExecutionPayloadHeader(1, []byte("parent1"), []byte{})
+		require.IsNil(t, result)
+
+		// The second slot should still be present
+		result = c.SignedExecutionPayloadHeader(2, []byte("parent2"), []byte{})
+		require.NotNil(t, result)
+		require.Equal(t, header2, result)
+
+		// The third slot should be present
+		result = c.SignedExecutionPayloadHeader(3, []byte("parent3"), []byte{})
+		require.NotNil(t, result)
+		require.Equal(t, header3, result)
+	})
+}

beacon-chain/core/blocks/BUILD.bazel

@@ -90,6 +90,7 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/epbs:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/trie:go_default_library",
@@ -107,6 +108,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/core/blocks/genesis.go

@@ -12,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
@@ -222,6 +223,42 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
+	case *ethpb.BeaconStateEPBS:
+		kzgs := make([][]byte, 0)
+		kzgRoot, err := ssz.KzgCommitmentsRoot(kzgs)
+		if err != nil {
+			return nil, err
+		}
+		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockEpbs{
+			Block: &ethpb.BeaconBlockEpbs{
+				ParentRoot: params.BeaconConfig().ZeroHash[:],
+				StateRoot:  root[:],
+				Body: &ethpb.BeaconBlockBodyEpbs{
+					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),
+					},
+					SignedExecutionPayloadHeader: &enginev1.SignedExecutionPayloadHeader{
+						Message: &enginev1.ExecutionPayloadHeaderEPBS{
+							ParentBlockHash:        make([]byte, 32),
+							ParentBlockRoot:        make([]byte, 32),
+							BlockHash:              make([]byte, 32),
+							BlobKzgCommitmentsRoot: kzgRoot[:],
+						},
+						Signature: make([]byte, 96),
+					},
+					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
+					PayloadAttestations:   make([]*ethpb.PayloadAttestation, 0),
+				},
+			},
+			Signature: params.BeaconConfig().EmptySignature[:],
+		})
 	default:
 		return nil, ErrUnrecognizedState
 	}

beacon-chain/core/blocks/payload.go

@@ -239,12 +239,47 @@ func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
 // GetBlockPayloadHash returns the hash of the execution payload of the block
 func GetBlockPayloadHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
 	var payloadHash [32]byte
-	if IsPreBellatrixVersion(blk.Version()) {
-		return payloadHash, nil
+	if blk.Version() >= version.EPBS {
+		header, err := blk.Body().SignedExecutionPayloadHeader()
+		if err != nil {
+			return payloadHash, err
+		}
+		payload, err := header.Header()
+		if err != nil {
+			return payloadHash, err
+		}
+		return payload.BlockHash(), nil
 	}
-	payload, err := blk.Body().Execution()
-	if err != nil {
-		return payloadHash, err
+	if blk.Version() >= version.Bellatrix {
+		payload, err := blk.Body().Execution()
+		if err != nil {
+			return payloadHash, err
+		}
+		return bytesutil.ToBytes32(payload.BlockHash()), nil
 	}
-	return bytesutil.ToBytes32(payload.BlockHash()), nil
+	return payloadHash, nil
+}
+
+// GetBlockParentHash returns the hash of the parent execution payload
+func GetBlockParentHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
+	var parentHash [32]byte
+	if blk.Version() >= version.EPBS {
+		header, err := blk.Body().SignedExecutionPayloadHeader()
+		if err != nil {
+			return parentHash, err
+		}
+		payload, err := header.Header()
+		if err != nil {
+			return parentHash, err
+		}
+		return payload.ParentBlockHash(), nil
+	}
+	if blk.Version() >= version.Bellatrix {
+		payload, err := blk.Body().Execution()
+		if err != nil {
+			return parentHash, err
+		}
+		return bytesutil.ToBytes32(payload.ParentHash()), nil
+	}
+	return parentHash, nil
 }

beacon-chain/core/blocks/withdrawals.go

@@ -14,8 +14,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
@@ -115,14 +115,97 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 	return val, nil
 }
 
+func checkWithdrawalsAgainstPayload(
+	executionData interfaces.ExecutionData,
+	numExpected int,
+	expectedRoot [32]byte,
+) error {
+	var wdRoot [32]byte
+	if executionData.IsBlinded() {
+		r, err := executionData.WithdrawalsRoot()
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals root")
+		}
+		copy(wdRoot[:], r)
+	} else {
+		wds, err := executionData.Withdrawals()
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals")
+		}
+
+		if len(wds) != numExpected {
+			return fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), numExpected)
+		}
+
+		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals root")
+		}
+	}
+	if expectedRoot != wdRoot {
+		return fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
+	}
+	return nil
+}
+
+func processWithdrawalStateTransition(
+	st state.BeaconState,
+	expectedWithdrawals []*enginev1.Withdrawal,
+	partialWithdrawalsCount uint64,
+) (err error) {
+	for _, withdrawal := range expectedWithdrawals {
+		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
+		if err != nil {
+			return errors.Wrap(err, "could not decrease balance")
+		}
+	}
+	if st.Version() >= version.Electra {
+		if err := st.DequeuePartialWithdrawals(partialWithdrawalsCount); err != nil {
+			return fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
+		}
+	}
+
+	if len(expectedWithdrawals) > 0 {
+		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
+			return errors.Wrap(err, "could not set next withdrawal index")
+		}
+	}
+	var nextValidatorIndex primitives.ValidatorIndex
+	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
+		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
+		if err != nil {
+			return errors.Wrap(err, "could not get next withdrawal validator index")
+		}
+		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
+		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
+	} else {
+		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
+		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
+			nextValidatorIndex = 0
+		}
+	}
+	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
+		return errors.Wrap(err, "could not set next withdrawal validator index")
+	}
+	return nil
+}
+
 // ProcessWithdrawals processes the validator withdrawals from the provided execution payload
 // into the beacon state.
 //
 // Spec pseudocode definition:
 //
-// def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//		if state.fork.current_version >= EIP7732_FORK_VERSION :
+//			if not is_parent_block_full(state): # [New in EIP-7732]
+//		 		return
 //
-//	expected_withdrawals, processed_partial_withdrawals_count = get_expected_withdrawals(state) # [Modified in Electra:EIP7251]
+//	    expected_withdrawals, partial_withdrawals_count = get_expected_withdrawals(state)  # [Modified in Electra:EIP7251]
+//
+//		if state.fork.current_version >= EIP7732_FORK_VERSION :
+//			state.latest_withdrawals_root = hash_tree_root(expected_withdrawals) # [New in EIP-7732]
+//		else :
+//	    	assert len(payload.withdrawals) == len(expected_withdrawals)
 //
 //	assert len(payload.withdrawals) == len(expected_withdrawals)
 //
@@ -149,76 +232,39 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 //	    next_validator_index = ValidatorIndex(next_index % len(state.validators))
 //	    state.next_withdrawal_validator_index = next_validator_index
 func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
-	expectedWithdrawals, processedPartialWithdrawalsCount, err := st.ExpectedWithdrawals()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get expected withdrawals")
+	if st.Version() >= version.EPBS {
+		IsParentBlockFull, err := st.IsParentBlockFull()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not check if parent block is full")
+		}
+
+		if !IsParentBlockFull {
+			return nil, nil
+		}
 	}
 
-	var wdRoot [32]byte
-	if executionData.IsBlinded() {
-		r, err := executionData.WithdrawalsRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
-		wdRoot = bytesutil.ToBytes32(r)
-	} else {
-		wds, err := executionData.Withdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals")
-		}
-
-		if len(wds) != len(expectedWithdrawals) {
-			return nil, fmt.Errorf("execution payload header has %d withdrawals when %d were expected", len(wds), len(expectedWithdrawals))
-		}
-
-		wdRoot, err = ssz.WithdrawalSliceRoot(wds, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
+	expectedWithdrawals, partialWithdrawalsCount, err := st.ExpectedWithdrawals()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
 
 	expectedRoot, err := ssz.WithdrawalSliceRoot(expectedWithdrawals, fieldparams.MaxWithdrawalsPerPayload)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals root")
 	}
-	if expectedRoot != wdRoot {
-		return nil, fmt.Errorf("expected withdrawals root %#x, got %#x", expectedRoot, wdRoot)
-	}
 
-	for _, withdrawal := range expectedWithdrawals {
-		err := helpers.DecreaseBalance(st, withdrawal.ValidatorIndex, withdrawal.Amount)
+	if st.Version() >= version.EPBS {
+		err = st.SetLastWithdrawalsRoot(expectedRoot[:])
 		if err != nil {
-			return nil, errors.Wrap(err, "could not decrease balance")
+			return nil, errors.Wrap(err, "could not set withdrawals root")
 		}
-	}
-
-	if st.Version() >= version.Electra {
-		if err := st.DequeuePartialWithdrawals(processedPartialWithdrawalsCount); err != nil {
-			return nil, fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
-		}
-	}
-
-	if len(expectedWithdrawals) > 0 {
-		if err := st.SetNextWithdrawalIndex(expectedWithdrawals[len(expectedWithdrawals)-1].Index + 1); err != nil {
-			return nil, errors.Wrap(err, "could not set next withdrawal index")
-		}
-	}
-	var nextValidatorIndex primitives.ValidatorIndex
-	if uint64(len(expectedWithdrawals)) < params.BeaconConfig().MaxWithdrawalsPerPayload {
-		nextValidatorIndex, err = st.NextWithdrawalValidatorIndex()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
-		}
-		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
 	} else {
-		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
-		if nextValidatorIndex == primitives.ValidatorIndex(st.NumValidators()) {
-			nextValidatorIndex = 0
+		if err := checkWithdrawalsAgainstPayload(executionData, len(expectedWithdrawals), expectedRoot); err != nil {
+			return nil, err
 		}
 	}
-	if err := st.SetNextWithdrawalValidatorIndex(nextValidatorIndex); err != nil {
-		return nil, errors.Wrap(err, "could not set next withdrawal validator index")
+	if err := processWithdrawalStateTransition(st, expectedWithdrawals, partialWithdrawalsCount); err != nil {
+		return nil, err
 	}
 	return st, nil
 }

beacon-chain/core/blocks/withdrawals_test.go

@@ -22,6 +22,7 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -1132,13 +1133,407 @@ func TestProcessWithdrawals(t *testing.T) {
 						checkPostState(t, test.Control, post)
 					}
 					params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
-
 				})
 			}
 		})
 	}
 }
 
+func TestProcessWithdrawalsEPBS(t *testing.T) {
+	const (
+		currentEpoch             = primitives.Epoch(10)
+		epochInFuture            = primitives.Epoch(12)
+		epochInPast              = primitives.Epoch(8)
+		numValidators            = 128
+		notWithdrawableIndex     = 127
+		notPartiallyWithdrawable = 126
+		maxSweep                 = uint64(80)
+	)
+	maxEffectiveBalance := params.BeaconConfig().MaxEffectiveBalance
+
+	type args struct {
+		Name                            string
+		NextWithdrawalValidatorIndex    primitives.ValidatorIndex
+		NextWithdrawalIndex             uint64
+		FullWithdrawalIndices           []primitives.ValidatorIndex
+		PendingPartialWithdrawalIndices []primitives.ValidatorIndex
+		Withdrawals                     []*enginev1.Withdrawal
+		PendingPartialWithdrawals       []*ethpb.PendingPartialWithdrawal // Electra
+		LatestBlockHash                 []byte                            // EIP-7732
+	}
+	type control struct {
+		NextWithdrawalValidatorIndex primitives.ValidatorIndex
+		NextWithdrawalIndex          uint64
+		Balances                     map[uint64]uint64
+	}
+	type Test struct {
+		Args    args
+		Control control
+	}
+	executionAddress := func(i primitives.ValidatorIndex) []byte {
+		wc := make([]byte, 20)
+		wc[19] = byte(i)
+		return wc
+	}
+	withdrawalAmount := func(i primitives.ValidatorIndex) uint64 {
+		return maxEffectiveBalance + uint64(i)*100000
+	}
+	fullWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
+		return &enginev1.Withdrawal{
+			Index:          idx,
+			ValidatorIndex: i,
+			Address:        executionAddress(i),
+			Amount:         withdrawalAmount(i),
+		}
+	}
+	PendingPartialWithdrawal := func(i primitives.ValidatorIndex, idx uint64) *enginev1.Withdrawal {
+		return &enginev1.Withdrawal{
+			Index:          idx,
+			ValidatorIndex: i,
+			Address:        executionAddress(i),
+			Amount:         withdrawalAmount(i) - maxEffectiveBalance,
+		}
+	}
+	tests := []Test{
+		{
+			Args: args{
+				Name:                         "success no withdrawals",
+				NextWithdrawalValidatorIndex: 10,
+				NextWithdrawalIndex:          3,
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 90,
+				NextWithdrawalIndex:          3,
+			},
+		},
+		{
+			Args: args{
+				Name:                         "success one full withdrawal",
+				NextWithdrawalIndex:          3,
+				NextWithdrawalValidatorIndex: 5,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{70},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(70, 3),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 85,
+				NextWithdrawalIndex:          4,
+				Balances:                     map[uint64]uint64{70: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success one partial withdrawal",
+				NextWithdrawalIndex:             21,
+				NextWithdrawalValidatorIndex:    120,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(7, 21),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 72,
+				NextWithdrawalIndex:          22,
+				Balances:                     map[uint64]uint64{7: maxEffectiveBalance},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "success many full withdrawals",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          25,
+				Balances:                     map[uint64]uint64{7: 0, 19: 0, 28: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "less than max sweep at end",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{80, 81, 82, 83},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(80, 22), fullWithdrawal(81, 23), fullWithdrawal(82, 24),
+					fullWithdrawal(83, 25),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          26,
+				Balances:                     map[uint64]uint64{80: 0, 81: 0, 82: 0, 83: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "less than max sweep and beginning",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{4, 5, 6},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(4, 22), fullWithdrawal(5, 23), fullWithdrawal(6, 24),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          25,
+				Balances:                     map[uint64]uint64{4: 0, 5: 0, 6: 0},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success many partial withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    4,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{7, 19, 28},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(7, 22), PendingPartialWithdrawal(19, 23), PendingPartialWithdrawal(28, 24),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 84,
+				NextWithdrawalIndex:          25,
+				Balances: map[uint64]uint64{
+					7:  maxEffectiveBalance,
+					19: maxEffectiveBalance,
+					28: maxEffectiveBalance,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success many withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					fullWithdrawal(28, 28),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 40,
+				NextWithdrawalIndex:          29,
+				Balances: map[uint64]uint64{
+					7: 0, 19: 0, 28: 0,
+					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
+					15: maxEffectiveBalance,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success many withdrawals with pending partial withdrawals in state",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    88,
+				FullWithdrawalIndices:           []primitives.ValidatorIndex{7, 19, 28},
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{2, 1, 89, 15},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(89, 22), PendingPartialWithdrawal(1, 23), PendingPartialWithdrawal(2, 24),
+					fullWithdrawal(7, 25), PendingPartialWithdrawal(15, 26), fullWithdrawal(19, 27),
+					fullWithdrawal(28, 28),
+				},
+				PendingPartialWithdrawals: []*ethpb.PendingPartialWithdrawal{
+					{
+						Index:  11,
+						Amount: withdrawalAmount(11) - maxEffectiveBalance,
+					},
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 40,
+				NextWithdrawalIndex:          29,
+				Balances: map[uint64]uint64{
+					7: 0, 19: 0, 28: 0,
+					2: maxEffectiveBalance, 1: maxEffectiveBalance, 89: maxEffectiveBalance,
+					15: maxEffectiveBalance,
+				},
+			},
+		},
+
+		{
+			Args: args{
+				Name:                         "success more than max fully withdrawals",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 0,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(1, 22), fullWithdrawal(2, 23), fullWithdrawal(3, 24),
+					fullWithdrawal(4, 25), fullWithdrawal(5, 26), fullWithdrawal(6, 27),
+					fullWithdrawal(7, 28), fullWithdrawal(8, 29), fullWithdrawal(9, 30),
+					fullWithdrawal(21, 31), fullWithdrawal(22, 32), fullWithdrawal(23, 33),
+					fullWithdrawal(24, 34), fullWithdrawal(25, 35), fullWithdrawal(26, 36),
+					fullWithdrawal(27, 37),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 28,
+				NextWithdrawalIndex:          38,
+				Balances: map[uint64]uint64{
+					1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0,
+					21: 0, 22: 0, 23: 0, 24: 0, 25: 0, 26: 0, 27: 0,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                            "success more than max partially withdrawals",
+				NextWithdrawalIndex:             22,
+				NextWithdrawalValidatorIndex:    0,
+				PendingPartialWithdrawalIndices: []primitives.ValidatorIndex{1, 2, 3, 4, 5, 6, 7, 8, 9, 21, 22, 23, 24, 25, 26, 27, 29, 35, 89},
+				Withdrawals: []*enginev1.Withdrawal{
+					PendingPartialWithdrawal(1, 22), PendingPartialWithdrawal(2, 23), PendingPartialWithdrawal(3, 24),
+					PendingPartialWithdrawal(4, 25), PendingPartialWithdrawal(5, 26), PendingPartialWithdrawal(6, 27),
+					PendingPartialWithdrawal(7, 28), PendingPartialWithdrawal(8, 29), PendingPartialWithdrawal(9, 30),
+					PendingPartialWithdrawal(21, 31), PendingPartialWithdrawal(22, 32), PendingPartialWithdrawal(23, 33),
+					PendingPartialWithdrawal(24, 34), PendingPartialWithdrawal(25, 35), PendingPartialWithdrawal(26, 36),
+					PendingPartialWithdrawal(27, 37),
+				},
+			},
+			Control: control{
+				NextWithdrawalValidatorIndex: 28,
+				NextWithdrawalIndex:          38,
+				Balances: map[uint64]uint64{
+					1:  maxEffectiveBalance,
+					2:  maxEffectiveBalance,
+					3:  maxEffectiveBalance,
+					4:  maxEffectiveBalance,
+					5:  maxEffectiveBalance,
+					6:  maxEffectiveBalance,
+					7:  maxEffectiveBalance,
+					8:  maxEffectiveBalance,
+					9:  maxEffectiveBalance,
+					21: maxEffectiveBalance,
+					22: maxEffectiveBalance,
+					23: maxEffectiveBalance,
+					24: maxEffectiveBalance,
+					25: maxEffectiveBalance,
+					26: maxEffectiveBalance,
+					27: maxEffectiveBalance,
+				},
+			},
+		},
+		{
+			Args: args{
+				Name:                         "Parent Node is not full",
+				NextWithdrawalIndex:          22,
+				NextWithdrawalValidatorIndex: 4,
+				FullWithdrawalIndices:        []primitives.ValidatorIndex{7, 19, 28, 1},
+				Withdrawals: []*enginev1.Withdrawal{
+					fullWithdrawal(7, 22), fullWithdrawal(19, 23), fullWithdrawal(28, 24),
+				},
+				LatestBlockHash: []byte{1, 2, 3},
+			},
+		},
+	}
+
+	checkPostState := func(t *testing.T, expected control, st state.BeaconState) {
+		l, err := st.NextWithdrawalValidatorIndex()
+		require.NoError(t, err)
+		require.Equal(t, expected.NextWithdrawalValidatorIndex, l)
+
+		n, err := st.NextWithdrawalIndex()
+		require.NoError(t, err)
+		require.Equal(t, expected.NextWithdrawalIndex, n)
+		balances := st.Balances()
+		for idx, bal := range expected.Balances {
+			require.Equal(t, bal, balances[idx])
+		}
+	}
+
+	prepareValidators := func(st state.BeaconState, arguments args) error {
+		validators := make([]*ethpb.Validator, numValidators)
+		if err := st.SetBalances(make([]uint64, numValidators)); err != nil {
+			return err
+		}
+		for i := range validators {
+			v := &ethpb.Validator{}
+			v.EffectiveBalance = maxEffectiveBalance
+			v.WithdrawableEpoch = epochInFuture
+			v.WithdrawalCredentials = make([]byte, 32)
+			v.WithdrawalCredentials[31] = byte(i)
+			if err := st.UpdateBalancesAtIndex(primitives.ValidatorIndex(i), v.EffectiveBalance-uint64(rand.Intn(1000))); err != nil {
+				return err
+			}
+			validators[i] = v
+		}
+		for _, idx := range arguments.FullWithdrawalIndices {
+			if idx != notWithdrawableIndex {
+				validators[idx].WithdrawableEpoch = epochInPast
+			}
+			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
+				return err
+			}
+			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+		}
+		for _, idx := range arguments.PendingPartialWithdrawalIndices {
+			validators[idx].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
+			if err := st.UpdateBalancesAtIndex(idx, withdrawalAmount(idx)); err != nil {
+				return err
+			}
+		}
+		return st.SetValidators(validators)
+	}
+
+	for _, test := range tests {
+		t.Run(test.Args.Name, func(t *testing.T) {
+			saved := params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep
+			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = maxSweep
+			if test.Args.Withdrawals == nil {
+				test.Args.Withdrawals = make([]*enginev1.Withdrawal, 0)
+			}
+			if test.Args.FullWithdrawalIndices == nil {
+				test.Args.FullWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
+			}
+			if test.Args.PendingPartialWithdrawalIndices == nil {
+				test.Args.PendingPartialWithdrawalIndices = make([]primitives.ValidatorIndex, 0)
+			}
+			slot, err := slots.EpochStart(currentEpoch)
+			require.NoError(t, err)
+			var st state.BeaconState
+			var p interfaces.ExecutionData
+			spb := &ethpb.BeaconStateEPBS{
+				Slot:                         slot,
+				NextWithdrawalValidatorIndex: test.Args.NextWithdrawalValidatorIndex,
+				NextWithdrawalIndex:          test.Args.NextWithdrawalIndex,
+				PendingPartialWithdrawals:    test.Args.PendingPartialWithdrawals,
+				LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderEPBS{
+					BlockHash: []byte{},
+				},
+				LatestBlockHash: test.Args.LatestBlockHash,
+			}
+			st, err = state_native.InitializeFromProtoUnsafeEpbs(spb)
+			require.NoError(t, err)
+			env := random.ExecutionPayloadEnvelope(t)
+			env.Payload.Withdrawals = test.Args.Withdrawals
+			wp, err := consensusblocks.WrappedROExecutionPayloadEnvelope(env)
+			require.NoError(t, err)
+			p, err = wp.Execution()
+			require.NoError(t, err)
+			err = prepareValidators(st, test.Args)
+			require.NoError(t, err)
+			post, err := blocks.ProcessWithdrawals(st, p)
+			if test.Args.Name == "Parent Node is not full" {
+				require.IsNil(t, post)
+				require.IsNil(t, err)
+			} else {
+				require.NoError(t, err)
+				checkPostState(t, test.Control, post)
+			}
+			params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep = saved
+		})
+	}
+}
+
 func TestProcessBLSToExecutionChanges(t *testing.T) {
 	spb := &ethpb.BeaconStateCapella{
 		Fork: &ethpb.Fork{

beacon-chain/core/electra/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
         "effective_balance_updates.go",
         "registry_updates.go",
         "transition.go",
-        "transition_no_verify_sig.go",
         "upgrade.go",
         "validator.go",
         "withdrawals.go",

beacon-chain/core/epbs/BUILD.bazel

@@ -0,0 +1,52 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "attestation.go",
+        "execution_payload_envelope.go",
+        "execution_payload_header.go",
+        "operations.go",
+        "payload_attestation.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/blocks:go_default_library",
+        "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
+        "//beacon-chain/core/validators:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//network/forks:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = [
+        "attestation_test.go",
+        "execution_payload_envelope_test.go",
+    ],
+    embed = [":go_default_library"],
+    deps = [
+        "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
+    ],
+)

beacon-chain/core/epbs/attestation.go

@@ -0,0 +1,13 @@
+package epbs
+
+import (
+	"fmt"
+)
+
+// RemoveValidatorFlag removes validator flag from existing one.
+func RemoveValidatorFlag(flag, flagPosition uint8) (uint8, error) {
+	if flagPosition > 7 {
+		return flag, fmt.Errorf("flag position %d exceeds length", flagPosition)
+	}
+	return flag & ^(1 << flagPosition), nil
+}

beacon-chain/core/epbs/attestation_test.go

@@ -0,0 +1,93 @@
+package epbs_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestValidatorFlag_Remove(t *testing.T) {
+	tests := []struct {
+		name          string
+		add           []uint8
+		remove        []uint8
+		expectedTrue  []uint8
+		expectedFalse []uint8
+	}{
+		{
+			name:          "none",
+			add:           []uint8{},
+			remove:        []uint8{},
+			expectedTrue:  []uint8{},
+			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+		{
+			name:          "source",
+			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			remove:        []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			expectedTrue:  []uint8{},
+			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+		{
+			name:          "source, target",
+			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex},
+			remove:        []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			expectedTrue:  []uint8{params.BeaconConfig().TimelyTargetFlagIndex},
+			expectedFalse: []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+		{
+			name:          "source, target, head",
+			add:           []uint8{params.BeaconConfig().TimelySourceFlagIndex, params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+			remove:        []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+			expectedTrue:  []uint8{params.BeaconConfig().TimelySourceFlagIndex},
+			expectedFalse: []uint8{params.BeaconConfig().TimelyTargetFlagIndex, params.BeaconConfig().TimelyHeadFlagIndex},
+		},
+	}
+	var err error
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			flag := uint8(0)
+
+			// Add flags.
+			for _, flagPosition := range test.add {
+				flag, err = altair.AddValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+
+				has, err := altair.HasValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+				require.Equal(t, true, has)
+			}
+
+			// Remove flags.
+			for _, flagPosition := range test.remove {
+				flag, err = epbs.RemoveValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+			}
+
+			// Check if flags are set correctly.
+			for _, flagPosition := range test.expectedTrue {
+				has, err := altair.HasValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+				require.Equal(t, true, has)
+			}
+			for _, flagPosition := range test.expectedFalse {
+				has, err := altair.HasValidatorFlag(flag, flagPosition)
+				require.NoError(t, err)
+				require.Equal(t, false, has)
+			}
+		})
+	}
+}
+
+func TestValidatorFlag_Remove_ExceedsLength(t *testing.T) {
+	_, err := epbs.RemoveValidatorFlag(0, 8)
+	require.ErrorContains(t, "flag position 8 exceeds length", err)
+}
+
+func TestValidatorFlag_Remove_NotSet(t *testing.T) {
+	_, err := epbs.RemoveValidatorFlag(0, 1)
+	require.NoError(t, err)
+}

beacon-chain/core/epbs/execution_payload_envelope.go

@@ -0,0 +1,126 @@
+package epbs
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+)
+
+// ValidatePayloadStateTransition performs the process_execution_payload
+// function.
+func ValidatePayloadStateTransition(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	if err := validateAgainstHeader(ctx, preState, envelope); err != nil {
+		return err
+	}
+	committedHeader, err := preState.LatestExecutionPayloadHeaderEPBS()
+	if err != nil {
+		return err
+	}
+	if err := validateAgainstCommittedBid(committedHeader, envelope); err != nil {
+		return err
+	}
+	if err := ProcessPayloadStateTransition(ctx, preState, envelope); err != nil {
+		return err
+	}
+	return checkPostStateRoot(ctx, preState, envelope)
+}
+
+func ProcessPayloadStateTransition(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	er := envelope.ExecutionRequests()
+	preState, err := electra.ProcessDepositRequests(ctx, preState, er.Deposits)
+	if err != nil {
+		return errors.Wrap(err, "could not process deposit receipts")
+	}
+	preState, err = electra.ProcessWithdrawalRequests(ctx, preState, er.Withdrawals)
+	if err != nil {
+		return errors.Wrap(err, "could not process ercution layer withdrawal requests")
+	}
+	if err := electra.ProcessConsolidationRequests(ctx, preState, er.Consolidations); err != nil {
+		return errors.Wrap(err, "could not process consolidation requests")
+	}
+	payload, err := envelope.Execution()
+	if err != nil {
+		return errors.Wrap(err, "could not get execution payload")
+	}
+	if err := preState.SetLatestBlockHash(payload.BlockHash()); err != nil {
+		return err
+	}
+	return preState.SetLatestFullSlot(preState.Slot())
+}
+
+func validateAgainstHeader(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	blockHeader := preState.LatestBlockHeader()
+	if blockHeader == nil {
+		return errors.New("invalid nil latest block header")
+	}
+	if len(blockHeader.StateRoot) == 0 || [32]byte(blockHeader.StateRoot) == [32]byte{} {
+		prevStateRoot, err := preState.HashTreeRoot(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not compute previous state root")
+		}
+		blockHeader.StateRoot = prevStateRoot[:]
+		if err := preState.SetLatestBlockHeader(blockHeader); err != nil {
+			return errors.Wrap(err, "could not set latest block header")
+		}
+	}
+	blockHeaderRoot, err := blockHeader.HashTreeRoot()
+	if err != nil {
+		return err
+	}
+	beaconBlockRoot := envelope.BeaconBlockRoot()
+	if blockHeaderRoot != beaconBlockRoot {
+		return fmt.Errorf("beacon block root does not match previous header, got: %#x wanted: %#x", beaconBlockRoot, blockHeaderRoot)
+	}
+	return nil
+}
+
+func validateAgainstCommittedBid(
+	committedHeader *enginev1.ExecutionPayloadHeaderEPBS,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	builderIndex := envelope.BuilderIndex()
+	if committedHeader.BuilderIndex != builderIndex {
+		return errors.New("builder index does not match committed header")
+	}
+	kzgRoot, err := envelope.BlobKzgCommitmentsRoot()
+	if err != nil {
+		return err
+	}
+	if [32]byte(committedHeader.BlobKzgCommitmentsRoot) != kzgRoot {
+		return errors.New("blob KZG commitments root does not match committed header")
+	}
+	return nil
+}
+
+func checkPostStateRoot(
+	ctx context.Context,
+	preState state.BeaconState,
+	envelope interfaces.ROExecutionPayloadEnvelope,
+) error {
+	stateRoot, err := preState.HashTreeRoot(ctx)
+	if err != nil {
+		return err
+	}
+	envelopeStateRoot := envelope.StateRoot()
+	if stateRoot != envelopeStateRoot {
+		return errors.New("state root mismatch")
+	}
+	return nil
+}

beacon-chain/core/epbs/execution_payload_envelope_test.go

@@ -0,0 +1,109 @@
+package epbs
+
+import (
+	"context"
+	"testing"
+
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func TestProcessPayloadStateTransition(t *testing.T) {
+	bh := [32]byte{'h'}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload.BlockHash = bh[:]
+	p.ExecutionRequests = &enginev1.ExecutionRequests{}
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	validators := make([]*ethpb.Validator, 0)
+	stpb := &ethpb.BeaconStateEPBS{Slot: 3, Validators: validators}
+	st, err := state_native.InitializeFromProtoUnsafeEpbs(stpb)
+	require.NoError(t, err)
+	ctx := context.Background()
+
+	lbh, err := st.LatestBlockHash()
+	require.NoError(t, err)
+	require.Equal(t, [32]byte{}, [32]byte(lbh))
+
+	require.NoError(t, ProcessPayloadStateTransition(ctx, st, e))
+
+	lbh, err = st.LatestBlockHash()
+	require.NoError(t, err)
+	require.Equal(t, bh, [32]byte(lbh))
+
+	lfs, err := st.LatestFullSlot()
+	require.NoError(t, err)
+	require.Equal(t, lfs, st.Slot())
+}
+
+func Test_validateAgainstHeader(t *testing.T) {
+	bh := [32]byte{'h'}
+	payload := &enginev1.ExecutionPayloadElectra{BlockHash: bh[:]}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload = payload
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	stpb := &ethpb.BeaconStateEPBS{Slot: 3}
+	st, err := state_native.InitializeFromProtoUnsafeEpbs(stpb)
+	require.NoError(t, err)
+	ctx := context.Background()
+	require.ErrorContains(t, "invalid nil latest block header", validateAgainstHeader(ctx, st, e))
+
+	prest, _ := util.DeterministicGenesisStateEpbs(t, 64)
+	br := [32]byte{'r'}
+	p.BeaconBlockRoot = br[:]
+	require.ErrorContains(t, "beacon block root does not match previous header", validateAgainstHeader(ctx, prest, e))
+
+	header := prest.LatestBlockHeader()
+	require.NoError(t, err)
+	headerRoot, err := header.HashTreeRoot()
+	require.NoError(t, err)
+	p.BeaconBlockRoot = headerRoot[:]
+	require.NoError(t, validateAgainstHeader(ctx, prest, e))
+}
+
+func Test_validateAgainstCommittedBid(t *testing.T) {
+	payload := &enginev1.ExecutionPayloadElectra{}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload = payload
+	p.BuilderIndex = 1
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	h := &enginev1.ExecutionPayloadHeaderEPBS{}
+	require.ErrorContains(t, "builder index does not match committed header", validateAgainstCommittedBid(h, e))
+
+	h.BuilderIndex = 1
+	p.BlobKzgCommitments = make([][]byte, 6)
+	for i := range p.BlobKzgCommitments {
+		p.BlobKzgCommitments[i] = make([]byte, 48)
+	}
+	h.BlobKzgCommitmentsRoot = make([]byte, 32)
+	require.ErrorContains(t, "blob KZG commitments root does not match committed header", validateAgainstCommittedBid(h, e))
+
+	root, err := e.BlobKzgCommitmentsRoot()
+	require.NoError(t, err)
+	h.BlobKzgCommitmentsRoot = root[:]
+	require.NoError(t, validateAgainstCommittedBid(h, e))
+}
+
+func TestCheckPostStateRoot(t *testing.T) {
+	payload := &enginev1.ExecutionPayloadElectra{}
+	p := random.ExecutionPayloadEnvelope(t)
+	p.Payload = payload
+	p.BuilderIndex = 1
+	e, err := blocks.WrappedROExecutionPayloadEnvelope(p)
+	require.NoError(t, err)
+	ctx := context.Background()
+	st, _ := util.DeterministicGenesisStateEpbs(t, 64)
+	p.StateRoot = make([]byte, 32)
+	require.ErrorContains(t, "state root mismatch", checkPostStateRoot(ctx, st, e))
+	root, err := st.HashTreeRoot(ctx)
+	require.NoError(t, err)
+	p.StateRoot = root[:]
+	require.NoError(t, checkPostStateRoot(ctx, st, e))
+}

beacon-chain/core/epbs/execution_payload_header.go

@@ -0,0 +1,51 @@
+package epbs
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/network/forks"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+// ValidatePayloadHeaderSignature validates the signature of the execution payload header.
+func ValidatePayloadHeaderSignature(st state.ReadOnlyBeaconState, sh interfaces.ROSignedExecutionPayloadHeader) error {
+	h, err := sh.Header()
+	if err != nil {
+		return err
+	}
+
+	pubkey := st.PubkeyAtIndex(h.BuilderIndex())
+	pub, err := bls.PublicKeyFromBytes(pubkey[:])
+	if err != nil {
+		return err
+	}
+
+	s := sh.Signature()
+	sig, err := bls.SignatureFromBytes(s[:])
+	if err != nil {
+		return err
+	}
+
+	currentEpoch := slots.ToEpoch(h.Slot())
+	f, err := forks.Fork(currentEpoch)
+	if err != nil {
+		return err
+	}
+
+	domain, err := signing.Domain(f, currentEpoch, params.BeaconConfig().DomainBeaconBuilder, st.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+	root, err := sh.SigningRoot(domain)
+	if err != nil {
+		return err
+	}
+	if !sig.Verify(pub, root[:]) {
+		return signing.ErrSigFailedToVerify
+	}
+
+	return nil
+}

beacon-chain/core/epbs/operations.go

@@ -1,4 +1,4 @@
-package electra
+package epbs
 
 import (
 	"context"
@@ -6,9 +6,11 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 var (
@@ -62,11 +64,11 @@ func ProcessOperations(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair attester slashing")
 	}
-	st, err = ProcessAttestationsNoVerifySignature(ctx, st, block)
+	st, err = electra.ProcessAttestationsNoVerifySignature(ctx, st, block)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair attestation")
 	}
-	if _, err := ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
+	if _, err := electra.ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
 		return nil, errors.Wrap(err, "could not process altair deposit")
 	}
 	st, err = ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits())
@@ -77,20 +79,27 @@ func ProcessOperations(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process bls-to-execution changes")
 	}
+	// new in ePBS
+	if block.Version() >= version.EPBS {
+		if err := ProcessPayloadAttestations(st, bb); err != nil {
+			return nil, err
+		}
+		return st, nil
+	}
 	// new in electra
 	requests, err := bb.ExecutionRequests()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get execution requests")
 	}
-	st, err = ProcessDepositRequests(ctx, st, requests.Deposits)
+	st, err = electra.ProcessDepositRequests(ctx, st, requests.Deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit receipts")
 	}
-	st, err = ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
+	st, err = electra.ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
 	}
-	if err := ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
+	if err := electra.ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
 		return nil, fmt.Errorf("could not process consolidation requests: %w", err)
 	}
 	return st, nil

beacon-chain/core/epbs/payload_attestation.go

@@ -0,0 +1,125 @@
+package epbs
+
+import (
+	"bytes"
+	"context"
+	"time"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+)
+
+func ProcessPayloadAttestations(state state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
+	atts, err := body.PayloadAttestations()
+	if err != nil {
+		return err
+	}
+	if len(atts) == 0 {
+		return nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 12*time.Second)
+	defer cancel()
+	lbh := state.LatestBlockHeader()
+	proposerIndex := lbh.ProposerIndex
+	var participation []byte
+	if state.Slot()%32 == 0 {
+		participation, err = state.PreviousEpochParticipation()
+	} else {
+		participation, err = state.CurrentEpochParticipation()
+	}
+	if err != nil {
+		return err
+	}
+	totalBalance, err := helpers.TotalActiveBalance(state)
+	if err != nil {
+		return err
+	}
+	baseReward, err := altair.BaseRewardWithTotalBalance(state, proposerIndex, totalBalance)
+	if err != nil {
+		return err
+	}
+	lfs, err := state.LatestFullSlot()
+	if err != nil {
+		return err
+	}
+
+	cfg := params.BeaconConfig()
+	sourceFlagIndex := cfg.TimelySourceFlagIndex
+	targetFlagIndex := cfg.TimelyTargetFlagIndex
+	headFlagIndex := cfg.TimelyHeadFlagIndex
+	penaltyNumerator := uint64(0)
+	rewardNumerator := uint64(0)
+	rewardDenominator := (cfg.WeightDenominator - cfg.ProposerWeight) * cfg.WeightDenominator / cfg.ProposerWeight
+
+	for _, att := range atts {
+		data := att.Data
+		if !bytes.Equal(data.BeaconBlockRoot, lbh.ParentRoot) {
+			return errors.New("invalid beacon block root in payload attestation data")
+		}
+		if data.Slot+1 != state.Slot() {
+			return errors.New("invalid data slot")
+		}
+		indexed, err := helpers.GetIndexedPayloadAttestation(ctx, state, data.Slot, att)
+		if err != nil {
+			return err
+		}
+		valid, err := helpers.IsValidIndexedPayloadAttestation(state, indexed)
+		if err != nil {
+			return err
+		}
+		if !valid {
+			return errors.New("invalid payload attestation")
+		}
+		payloadWasPreset := data.Slot == lfs
+		votedPresent := data.PayloadStatus == primitives.PAYLOAD_PRESENT
+		if votedPresent != payloadWasPreset {
+			for _, idx := range indexed.GetAttestingIndices() {
+				flags := participation[idx]
+				has, err := altair.HasValidatorFlag(flags, targetFlagIndex)
+				if err != nil {
+					return err
+				}
+				if has {
+					penaltyNumerator += baseReward * cfg.TimelyTargetWeight
+				}
+				has, err = altair.HasValidatorFlag(flags, sourceFlagIndex)
+				if err != nil {
+					return err
+				}
+				if has {
+					penaltyNumerator += baseReward * cfg.TimelySourceWeight
+				}
+				has, err = altair.HasValidatorFlag(flags, headFlagIndex)
+				if err != nil {
+					return err
+				}
+				if has {
+					penaltyNumerator += baseReward * cfg.TimelyHeadWeight
+				}
+				participation[idx] = 0
+			}
+		} else {
+			for _, idx := range indexed.GetAttestingIndices() {
+				participation[idx] = (1 << headFlagIndex) | (1 << sourceFlagIndex) | (1 << targetFlagIndex)
+				rewardNumerator += baseReward * (cfg.TimelyHeadWeight + cfg.TimelySourceWeight + cfg.TimelyTargetWeight)
+			}
+		}
+	}
+	if penaltyNumerator > 0 {
+		if err := helpers.DecreaseBalance(state, proposerIndex, penaltyNumerator/rewardDenominator); err != nil {
+			return err
+		}
+	}
+	if rewardNumerator > 0 {
+		if err := helpers.IncreaseBalance(state, proposerIndex, penaltyNumerator/rewardDenominator); err != nil {
+			return err
+		}
+	}
+	return nil
+}

beacon-chain/core/helpers/BUILD.bazel

@@ -8,6 +8,7 @@ go_library(
         "block.go",
         "genesis.go",
         "metrics.go",
+        "payload_attestation.go",
         "randao.go",
         "rewards_penalties.go",
         "shuffle.go",
@@ -20,11 +21,13 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/epbs:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
@@ -53,6 +56,8 @@ go_test(
         "attestation_test.go",
         "beacon_committee_test.go",
         "block_test.go",
+        "exports_test.go",
+        "payload_attestation_test.go",
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
         "randao_test.go",
@@ -69,21 +74,27 @@ go_test(
     tags = ["CI_race_detection"],
     deps = [
         "//beacon-chain/cache:go_default_library",
+        "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/epbs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
+        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
+        "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

beacon-chain/core/helpers/beacon_committee.go

@@ -213,6 +213,7 @@ type CommitteeAssignment struct {
 	Committee      []primitives.ValidatorIndex
 	AttesterSlot   primitives.Slot
 	CommitteeIndex primitives.CommitteeIndex
+	PtcSlot        primitives.Slot
 }
 
 // verifyAssignmentEpoch verifies if the given epoch is valid for assignment based on the provided state.
@@ -294,7 +295,7 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	if err := verifyAssignmentEpoch(epoch, state); err != nil {
 		return nil, err
 	}
-	startSlot, err := slots.EpochStart(epoch)
+	slot, err := slots.EpochStart(epoch)
 	if err != nil {
 		return nil, err
 	}
@@ -303,14 +304,17 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 		vals[v] = struct{}{}
 	}
 	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
+
+	committees, err := BeaconCommittees(ctx, state, slot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute beacon committees")
+	}
+	ptcPerSlot, ptcMembersPerCommittee := PtcAllocation(len(committees))
 	// Compute committee assignments for each slot in the epoch.
-	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
-		committees, err := BeaconCommittees(ctx, state, slot)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute beacon committees")
-		}
+	endSlot := slot + params.BeaconConfig().SlotsPerEpoch
+	for {
 		for j, committee := range committees {
-			for _, vIndex := range committee {
+			for i, vIndex := range committee {
 				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
 					continue
 				}
@@ -320,8 +324,19 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 				assignments[vIndex].Committee = committee
 				assignments[vIndex].AttesterSlot = slot
 				assignments[vIndex].CommitteeIndex = primitives.CommitteeIndex(j)
+				if uint64(j) < ptcPerSlot && uint64(i) < ptcMembersPerCommittee {
+					assignments[vIndex].PtcSlot = slot
+				}
 			}
 		}
+		slot++
+		if slot == endSlot {
+			break
+		}
+		committees, err = BeaconCommittees(ctx, state, slot)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not compute beacon committees")
+		}
 	}
 	return assignments, nil
 }

beacon-chain/core/helpers/beacon_committee_test.go

@@ -3,6 +3,7 @@ package helpers_test
 import (
 	"context"
 	"fmt"
+	"slices"
 	"strconv"
 	"testing"
 
@@ -10,6 +11,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
@@ -722,15 +724,26 @@ func TestCommitteeIndices(t *testing.T) {
 	assert.DeepEqual(t, []primitives.CommitteeIndex{0, 1, 3}, indices)
 }
 
-func TestAttestationCommittees(t *testing.T) {
-	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
+func TestCommitteeAssignments_PTC(t *testing.T) {
+	helpers.ClearCache()
+	// Create 10 committees. Total 40960 validators.
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+	validatorIndices := make([]primitives.ValidatorIndex, validatorCount)
+
 	for i := 0; i < len(validators); i++ {
+		k := make([]byte, 48)
+		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
-			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+			PublicKey:             k,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
 		}
+		validatorIndices[i] = primitives.ValidatorIndex(i)
 	}
 
-	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
 		Validators:  validators,
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
@@ -754,6 +767,31 @@ func TestAttestationCommittees(t *testing.T) {
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[1])))
 	})
+	as, err := helpers.CommitteeAssignments(context.Background(), state, 1, validatorIndices)
+	require.NoError(t, err)
+
+	// Capture all the slots and all the validator index that belonged in a PTC using a map for verification later.
+	slotValidatorMap := make(map[primitives.Slot][]primitives.ValidatorIndex)
+	for i, a := range as {
+		slotValidatorMap[a.PtcSlot] = append(slotValidatorMap[a.PtcSlot], i)
+	}
+
+	// Verify that all the slots have the correct number of PTC.
+	for s, v := range slotValidatorMap {
+		if s == 0 {
+			continue
+		}
+		// Make sure all the PTC are the correct size from the map.
+		require.Equal(t, len(v), field_params.PTCSize)
+
+		// Get the actual PTC from the beacon state using the helper function
+		ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, s)
+		require.NoError(t, err)
+		for _, index := range ptc {
+			i := slices.Index(v, index)
+			require.NotEqual(t, -1, i) // PTC not found from the assignment map
+		}
+	}
 }
 
 func TestBeaconCommittees(t *testing.T) {

beacon-chain/core/helpers/exports_test.go

@@ -0,0 +1,12 @@
+package helpers
+
+var (
+	ErrNilMessage            = errNilMessage
+	ErrNilData               = errNilData
+	ErrNilBeaconBlockRoot    = errNilBeaconBlockRoot
+	ErrNilPayloadAttestation = errNilPayloadAttestation
+	ErrNilSignature          = errNilSignature
+	ErrNilAggregationBits    = errNilAggregationBits
+	ErrPreEPBSState          = errPreEPBSState
+	ErrCommitteeOverflow     = errCommitteeOverflow
+)

beacon-chain/core/helpers/payload_attestation.go

@@ -0,0 +1,296 @@
+package helpers
+
+import (
+	"context"
+	"slices"
+
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/epbs"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+var (
+	errNilMessage            = errors.New("nil PayloadAttestationMessage")
+	errNilData               = errors.New("nil PayloadAttestationData")
+	errNilBeaconBlockRoot    = errors.New("nil BeaconBlockRoot")
+	errNilPayloadAttestation = errors.New("nil PayloadAttestation")
+	errNilSignature          = errors.New("nil Signature")
+	errNilAggregationBits    = errors.New("nil AggregationBits")
+	errPreEPBSState          = errors.New("beacon state pre ePBS fork")
+	errCommitteeOverflow     = errors.New("beacon committee of insufficient size")
+)
+
+// ValidateNilPayloadAttestationData checks if any composite field of the
+// payload attestation data is nil
+func ValidateNilPayloadAttestationData(data *eth.PayloadAttestationData) error {
+	if data == nil {
+		return errNilData
+	}
+	if data.BeaconBlockRoot == nil {
+		return errNilBeaconBlockRoot
+	}
+	return nil
+}
+
+// ValidateNilPayloadAttestationMessage checks if any composite field of the
+// payload attestation message is nil
+func ValidateNilPayloadAttestationMessage(att *eth.PayloadAttestationMessage) error {
+	if att == nil {
+		return errNilMessage
+	}
+	if att.Signature == nil {
+		return errNilSignature
+	}
+	return ValidateNilPayloadAttestationData(att.Data)
+}
+
+// ValidateNilPayloadAttestation checks if any composite field of the
+// payload attestation is nil
+func ValidateNilPayloadAttestation(att *eth.PayloadAttestation) error {
+	if att == nil {
+		return errNilPayloadAttestation
+	}
+	if att.AggregationBits == nil {
+		return errNilAggregationBits
+	}
+	if att.Signature == nil {
+		return errNilSignature
+	}
+	return ValidateNilPayloadAttestationData(att.Data)
+}
+
+// InPayloadTimelinessCommittee returns whether the given index belongs to the
+// PTC computed from the passed state.
+func InPayloadTimelinessCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, idx primitives.ValidatorIndex) (bool, error) {
+	ptc, err := GetPayloadTimelinessCommittee(ctx, state, slot)
+	if err != nil {
+		return false, err
+	}
+	for _, i := range ptc {
+		if i == idx {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
+// GetPayloadTimelinessCommittee returns the PTC for the given slot, computed from the passed state as in the
+// spec function `get_ptc`.
+func GetPayloadTimelinessCommittee(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) (indices []primitives.ValidatorIndex, err error) {
+	if state.Version() < version.EPBS {
+		return nil, errPreEPBSState
+	}
+	committees, err := BeaconCommittees(ctx, state, slot)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get beacon committees")
+	}
+	committeesPerSlot, membersPerCommittee := PtcAllocation(len(committees))
+	for i, committee := range committees {
+		if uint64(i) >= committeesPerSlot {
+			return
+		}
+		if uint64(len(committee)) < membersPerCommittee {
+			return nil, errCommitteeOverflow
+		}
+		indices = append(indices, committee[:membersPerCommittee]...)
+	}
+	return
+}
+
+// PtcAllocation returns:
+// 1. The number of beacon committees that PTC will borrow from in a slot.
+// 2. The number of validators that PTC will borrow from in a beacon committee.
+func PtcAllocation(slotCommittees int) (committeesPerSlot, membersPerCommittee uint64) {
+	committeesPerSlot = math.LargestPowerOfTwo(math.Min(uint64(slotCommittees), fieldparams.PTCSize))
+	membersPerCommittee = fieldparams.PTCSize / committeesPerSlot
+	return
+}
+
+// GetPayloadAttestingIndices returns the set of attester indices corresponding to the given PayloadAttestation.
+//
+// Spec pseudocode definition:
+//
+//	def get_payload_attesting_indices(state: BeaconState, slot: Slot,
+//		payload_attestation: PayloadAttestation) -> Set[ValidatorIndex]:
+//	"""
+//	Return the set of attesting indices corresponding to ``payload_attestation``.
+//	"""
+//	ptc = get_ptc(state, slot)
+//	return set(index for i, index in enumerate(ptc) if payload_attestation.aggregation_bits[i])
+func GetPayloadAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, att *eth.PayloadAttestation) (indices []primitives.ValidatorIndex, err error) {
+	if state.Version() < version.EPBS {
+		return nil, errPreEPBSState
+	}
+
+	ptc, err := GetPayloadTimelinessCommittee(ctx, state, slot)
+	if err != nil {
+		return nil, err
+	}
+
+	for i, validatorIndex := range ptc {
+		if att.AggregationBits.BitAt(uint64(i)) {
+			indices = append(indices, validatorIndex)
+		}
+	}
+
+	return
+}
+
+// GetIndexedPayloadAttestation replaces a PayloadAttestation's AggregationBits with sorted AttestingIndices and returns an IndexedPayloadAttestation.
+//
+// Spec pseudocode definition:
+//
+//	def get_indexed_payload_attestation(state: BeaconState, slot: Slot,
+//		payload_attestation: PayloadAttestation) -> IndexedPayloadAttestation:
+//	"""
+//	Return the indexed payload attestation corresponding to ``payload_attestation``.
+//	"""
+//	attesting_indices = get_payload_attesting_indices(state, slot, payload_attestation)
+//
+//	return IndexedPayloadAttestation(
+//	attesting_indices=sorted(attesting_indices),
+//	data=payload_attestation.data,
+//	signature=payload_attestation.signature,
+//	)
+func GetIndexedPayloadAttestation(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot, att *eth.PayloadAttestation) (*epbs.IndexedPayloadAttestation, error) {
+	if state.Version() < version.EPBS {
+		return nil, errPreEPBSState
+	}
+
+	attestingIndices, err := GetPayloadAttestingIndices(ctx, state, slot, att)
+	if err != nil {
+		return nil, err
+	}
+
+	slices.Sort(attestingIndices)
+
+	return &epbs.IndexedPayloadAttestation{
+		AttestingIndices: attestingIndices,
+		Data:             att.Data,
+		Signature:        att.Signature,
+	}, nil
+}
+
+// IsValidIndexedPayloadAttestation validates the given IndexedPayloadAttestation.
+//
+// Spec pseudocode definition:
+//
+//	def is_valid_indexed_payload_attestation(
+//		state: BeaconState,
+//		indexed_payload_attestation: IndexedPayloadAttestation) -> bool:
+//	"""
+//	Check if ``indexed_payload_attestation`` is not empty, has sorted and unique indices and has
+//	a valid aggregate signature.
+//	"""
+//	# Verify the data is valid
+//	if indexed_payload_attestation.data.payload_status >= PAYLOAD_INVALID_STATUS:
+//		return False
+//
+//	# Verify indices are sorted and unique
+//	indices = indexed_payload_attestation.attesting_indices
+//	if len(indices) == 0 or not indices == sorted(set(indices)):
+//		return False
+//
+//	# Verify aggregate signature
+//	pubkeys = [state.validators[i].pubkey for i in indices]
+//	domain = get_domain(state, DOMAIN_PTC_ATTESTER, None)
+//	signing_root = compute_signing_root(indexed_payload_attestation.data, domain)
+//	return bls.FastAggregateVerify(pubkeys, signing_root, indexed_payload_attestation.signature)
+func IsValidIndexedPayloadAttestation(state state.ReadOnlyBeaconState, att *epbs.IndexedPayloadAttestation) (bool, error) {
+	if state.Version() < version.EPBS {
+		return false, errPreEPBSState
+	}
+
+	// Verify the data is valid.
+	if att.Data.PayloadStatus >= primitives.PAYLOAD_INVALID_STATUS {
+		return false, nil
+	}
+
+	// Verify indices are sorted and unique.
+	indices := att.AttestingIndices
+	slices.Sort(indices)
+	if len(indices) == 0 || !slices.Equal(att.AttestingIndices, indices) {
+		return false, nil
+	}
+
+	// Verify aggregate signature.
+	publicKeys := make([]bls.PublicKey, len(indices))
+	for i, index := range indices {
+		validator, err := state.ValidatorAtIndexReadOnly(index)
+		if err != nil {
+			return false, err
+		}
+
+		publicKeyBytes := validator.PublicKey()
+		publicKey, err := bls.PublicKeyFromBytes(publicKeyBytes[:])
+		if err != nil {
+			return false, err
+		}
+
+		publicKeys[i] = publicKey
+	}
+
+	domain, err := signing.Domain(
+		state.Fork(),
+		slots.ToEpoch(state.Slot()),
+		params.BeaconConfig().DomainPTCAttester,
+		state.GenesisValidatorsRoot(),
+	)
+	if err != nil {
+		return false, err
+	}
+
+	signingRoot, err := signing.ComputeSigningRoot(att.Data, domain)
+	if err != nil {
+		return false, err
+	}
+
+	signature, err := bls.SignatureFromBytes(att.Signature)
+	if err != nil {
+		return false, err
+	}
+
+	return signature.FastAggregateVerify(publicKeys, signingRoot), nil
+}
+
+// ValidatePayloadAttestationMessageSignature verifies the signature of a
+// payload attestation message.
+func ValidatePayloadAttestationMessageSignature(ctx context.Context, st state.ReadOnlyBeaconState, msg *eth.PayloadAttestationMessage) error {
+	if err := ValidateNilPayloadAttestationMessage(msg); err != nil {
+		return err
+	}
+	val, err := st.ValidatorAtIndex(msg.ValidatorIndex)
+	if err != nil {
+		return err
+	}
+	pub, err := bls.PublicKeyFromBytes(val.PublicKey)
+	if err != nil {
+		return err
+	}
+	sig, err := bls.SignatureFromBytes(msg.Signature)
+	if err != nil {
+		return err
+	}
+	currentEpoch := slots.ToEpoch(st.Slot())
+	domain, err := signing.Domain(st.Fork(), currentEpoch, params.BeaconConfig().DomainPTCAttester, st.GenesisValidatorsRoot())
+	if err != nil {
+		return err
+	}
+	root, err := signing.ComputeSigningRoot(msg.Data, domain)
+	if err != nil {
+		return err
+	}
+	if !sig.Verify(pub, root[:]) {
+		return signing.ErrSigFailedToVerify
+	}
+	return nil
+}

beacon-chain/core/helpers/payload_attestation_test.go

@@ -0,0 +1,363 @@
+package helpers_test
+
+import (
+	"context"
+	"slices"
+	"strconv"
+	"testing"
+
+	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/epbs"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
+	"github.com/prysmaticlabs/prysm/v5/math"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+func TestValidateNilPayloadAttestation(t *testing.T) {
+	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestationData(nil))
+	data := &eth.PayloadAttestationData{}
+	require.ErrorIs(t, helpers.ErrNilBeaconBlockRoot, helpers.ValidateNilPayloadAttestationData(data))
+	data.BeaconBlockRoot = make([]byte, 32)
+	require.NoError(t, helpers.ValidateNilPayloadAttestationData(data))
+
+	require.ErrorIs(t, helpers.ErrNilMessage, helpers.ValidateNilPayloadAttestationMessage(nil))
+	message := &eth.PayloadAttestationMessage{}
+	require.ErrorIs(t, helpers.ErrNilSignature, helpers.ValidateNilPayloadAttestationMessage(message))
+	message.Signature = make([]byte, 96)
+	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestationMessage(message))
+	message.Data = data
+	require.NoError(t, helpers.ValidateNilPayloadAttestationMessage(message))
+
+	require.ErrorIs(t, helpers.ErrNilPayloadAttestation, helpers.ValidateNilPayloadAttestation(nil))
+	att := &eth.PayloadAttestation{}
+	require.ErrorIs(t, helpers.ErrNilAggregationBits, helpers.ValidateNilPayloadAttestation(att))
+	att.AggregationBits = bitfield.NewBitvector512()
+	require.ErrorIs(t, helpers.ErrNilSignature, helpers.ValidateNilPayloadAttestation(att))
+	att.Signature = message.Signature
+	require.ErrorIs(t, helpers.ErrNilData, helpers.ValidateNilPayloadAttestation(att))
+	att.Data = data
+	require.NoError(t, helpers.ValidateNilPayloadAttestation(att))
+}
+
+func TestGetPayloadTimelinessCommittee(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create 10 committees
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+
+	for i := 0; i < len(validators); i++ {
+		k := make([]byte, 48)
+		copy(k, strconv.Itoa(i))
+		validators[i] = &ethpb.Validator{
+			PublicKey:             k,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	state, err := state_native.InitializeFromProtoEpbs(random.BeaconState(t))
+	require.NoError(t, err)
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(200))
+
+	ctx := context.Background()
+	indices, err := helpers.BeaconCommitteeFromState(ctx, state, state.Slot(), 1)
+	require.NoError(t, err)
+	require.Equal(t, 128, len(indices))
+
+	epoch := slots.ToEpoch(state.Slot())
+	activeCount, err := helpers.ActiveValidatorCount(ctx, state, epoch)
+	require.NoError(t, err)
+	require.Equal(t, uint64(40960), activeCount)
+
+	computedCommitteeCount := helpers.SlotCommitteeCount(activeCount)
+	require.Equal(t, committeeCount, computedCommitteeCount)
+	committeesPerSlot := math.LargestPowerOfTwo(math.Min(committeeCount, fieldparams.PTCSize))
+	require.Equal(t, uint64(8), committeesPerSlot)
+
+	ptc, err := helpers.GetPayloadTimelinessCommittee(ctx, state, state.Slot())
+	require.NoError(t, err)
+	require.Equal(t, fieldparams.PTCSize, len(ptc))
+
+	committee1, err := helpers.BeaconCommitteeFromState(ctx, state, state.Slot(), 0)
+	require.NoError(t, err)
+
+	require.DeepEqual(t, committee1[:64], ptc[:64])
+}
+
+func Test_PtcAllocation(t *testing.T) {
+	tests := []struct {
+		committeeCount     int
+		memberPerCommittee uint64
+		committeesPerSlot  uint64
+	}{
+		{1, 512, 1},
+		{4, 128, 4},
+		{128, 4, 128},
+		{512, 1, 512},
+		{1024, 1, 512},
+	}
+
+	for _, test := range tests {
+		committeesPerSlot, memberPerCommittee := helpers.PtcAllocation(test.committeeCount)
+		if memberPerCommittee != test.memberPerCommittee {
+			t.Errorf("memberPerCommittee(%d) = %d; expected %d", test.committeeCount, memberPerCommittee, test.memberPerCommittee)
+		}
+		if committeesPerSlot != test.committeesPerSlot {
+			t.Errorf("committeesPerSlot(%d) = %d; expected %d", test.committeeCount, committeesPerSlot, test.committeesPerSlot)
+		}
+	}
+}
+
+func TestGetPayloadAttestingIndices(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create 10 committees. Total 40960 validators.
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+
+	for i := 0; i < len(validators); i++ {
+		pubkey := make([]byte, 48)
+		copy(pubkey, strconv.Itoa(i))
+		validators[i] = &ethpb.Validator{
+			PublicKey:             pubkey,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	// Create a beacon state.
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	// Get PTC.
+	ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, state.Slot())
+	require.NoError(t, err)
+	require.Equal(t, fieldparams.PTCSize, len(ptc))
+
+	// Generate random indices. PTC members at the corresponding indices are considered attested.
+	randGen := rand.NewDeterministicGenerator()
+	attesterCount := randGen.Intn(fieldparams.PTCSize) + 1
+	indices := randGen.Perm(fieldparams.PTCSize)[:attesterCount]
+	slices.Sort(indices)
+	require.Equal(t, attesterCount, len(indices))
+
+	// Create a PayloadAttestation with AggregationBits set true at the indices.
+	aggregationBits := bitfield.NewBitvector512()
+	for _, index := range indices {
+		aggregationBits.SetBitAt(uint64(index), true)
+	}
+
+	payloadAttestation := &eth.PayloadAttestation{
+		AggregationBits: aggregationBits,
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: make([]byte, 32),
+		},
+		Signature: make([]byte, 96),
+	}
+
+	// Get attesting indices.
+	attesters, err := helpers.GetPayloadAttestingIndices(context.Background(), state, state.Slot(), payloadAttestation)
+	require.NoError(t, err)
+	require.Equal(t, len(indices), len(attesters))
+
+	// Check if each attester equals to the PTC member at the corresponding index.
+	for i, index := range indices {
+		require.Equal(t, attesters[i], ptc[index])
+	}
+}
+
+func TestGetIndexedPayloadAttestation(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create 10 committees. Total 40960 validators.
+	committeeCount := uint64(10)
+	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize * uint64(params.BeaconConfig().SlotsPerEpoch)
+	validators := make([]*ethpb.Validator, validatorCount)
+
+	for i := 0; i < len(validators); i++ {
+		publicKey := make([]byte, 48)
+		copy(publicKey, strconv.Itoa(i))
+		validators[i] = &ethpb.Validator{
+			PublicKey:             publicKey,
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	// Create a beacon state.
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	// Get PTC.
+	ptc, err := helpers.GetPayloadTimelinessCommittee(context.Background(), state, state.Slot())
+	require.NoError(t, err)
+	require.Equal(t, fieldparams.PTCSize, len(ptc))
+
+	// Generate random indices. PTC members at the corresponding indices are considered attested.
+	randGen := rand.NewDeterministicGenerator()
+	attesterCount := randGen.Intn(fieldparams.PTCSize) + 1
+	indices := randGen.Perm(fieldparams.PTCSize)[:attesterCount]
+	slices.Sort(indices)
+	require.Equal(t, attesterCount, len(indices))
+
+	// Create a PayloadAttestation with AggregationBits set true at the indices.
+	aggregationBits := bitfield.NewBitvector512()
+	for _, index := range indices {
+		aggregationBits.SetBitAt(uint64(index), true)
+	}
+
+	payloadAttestation := &eth.PayloadAttestation{
+		AggregationBits: aggregationBits,
+		Data: &eth.PayloadAttestationData{
+			BeaconBlockRoot: make([]byte, 32),
+		},
+		Signature: make([]byte, 96),
+	}
+
+	// Get attesting indices.
+	ctx := context.Background()
+	attesters, err := helpers.GetPayloadAttestingIndices(ctx, state, state.Slot(), payloadAttestation)
+	require.NoError(t, err)
+	require.Equal(t, len(indices), len(attesters))
+
+	// Get an IndexedPayloadAttestation.
+	indexedPayloadAttestation, err := helpers.GetIndexedPayloadAttestation(ctx, state, state.Slot(), payloadAttestation)
+	require.NoError(t, err)
+	require.Equal(t, len(indices), len(indexedPayloadAttestation.AttestingIndices))
+	require.DeepEqual(t, payloadAttestation.Data, indexedPayloadAttestation.Data)
+	require.DeepEqual(t, payloadAttestation.Signature, indexedPayloadAttestation.Signature)
+
+	// Check if the attesting indices are the same.
+	slices.Sort(attesters) // GetIndexedPayloadAttestation sorts attesting indices.
+	require.DeepEqual(t, attesters, indexedPayloadAttestation.AttestingIndices)
+}
+
+func TestIsValidIndexedPayloadAttestation(t *testing.T) {
+	helpers.ClearCache()
+
+	// Create validators.
+	validatorCount := uint64(350)
+	validators := make([]*ethpb.Validator, validatorCount)
+	_, secretKeys, err := util.DeterministicDepositsAndKeys(validatorCount)
+	require.NoError(t, err)
+
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             secretKeys[i].PublicKey().Marshal(),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	// Create a beacon state.
+	state, err := state_native.InitializeFromProtoEpbs(&ethpb.BeaconStateEPBS{
+		Validators: validators,
+		Fork: &ethpb.Fork{
+			Epoch:           0,
+			CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
+			PreviousVersion: params.BeaconConfig().GenesisForkVersion,
+		},
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	// Define test cases.
+	tests := []struct {
+		attestation *epbs.IndexedPayloadAttestation
+	}{
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{1},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{13, 19},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{123, 234, 345},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{38, 46, 54, 62, 70, 78, 86, 194},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+		{
+			attestation: &epbs.IndexedPayloadAttestation{
+				AttestingIndices: []primitives.ValidatorIndex{5},
+				Data: &eth.PayloadAttestationData{
+					BeaconBlockRoot: make([]byte, fieldparams.RootLength),
+				},
+				Signature: make([]byte, fieldparams.BLSSignatureLength),
+			},
+		},
+	}
+
+	// Run test cases.
+	for _, test := range tests {
+		signatures := make([]bls.Signature, len(test.attestation.AttestingIndices))
+		for i, index := range test.attestation.AttestingIndices {
+			signedBytes, err := signing.ComputeDomainAndSign(
+				state,
+				slots.ToEpoch(test.attestation.Data.Slot),
+				test.attestation.Data,
+				params.BeaconConfig().DomainPTCAttester,
+				secretKeys[index],
+			)
+			require.NoError(t, err)
+
+			signature, err := bls.SignatureFromBytes(signedBytes)
+			require.NoError(t, err)
+
+			signatures[i] = signature
+		}
+
+		aggregatedSignature := bls.AggregateSignatures(signatures)
+		test.attestation.Signature = aggregatedSignature.Marshal()
+
+		isValid, err := helpers.IsValidIndexedPayloadAttestation(state, test.attestation)
+		require.NoError(t, err)
+		require.Equal(t, true, isValid)
+	}
+}

beacon-chain/core/time/slot_epoch.go

@@ -99,6 +99,12 @@ func CanUpgradeToElectra(slot primitives.Slot) bool {
 	return epochStart && electraEpoch
 }
 
+func CanUpgradeToEpbs(slot primitives.Slot) bool {
+	epochStart := slots.IsEpochStart(slot)
+	epbsEpoch := slots.ToEpoch(slot) == params.BeaconConfig().EPBSForkEpoch
+	return epochStart && epbsEpoch
+}
+
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/transition/BUILD.bazel

@@ -9,6 +9,7 @@ go_library(
         "state-bellatrix.go",
         "trailing_slot_state_cache.go",
         "transition.go",
+        "transition_epbs.go",
         "transition_no_verify_sig.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition",
@@ -20,6 +21,7 @@ go_library(
         "//beacon-chain/core/capella:go_default_library",
         "//beacon-chain/core/deneb:go_default_library",
         "//beacon-chain/core/electra:go_default_library",
+        "//beacon-chain/core/epbs:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/execution:go_default_library",
@@ -45,6 +47,7 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/core/transition/transition.go

@@ -19,6 +19,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/execution"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -26,6 +27,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	prysmTrace "github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"go.opentelemetry.io/otel/trace"
 )
@@ -369,6 +371,15 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
+	if time.CanUpgradeToEpbs(state.Slot()) {
+		state, err = UpgradeToEpbs(state)
+		if err != nil {
+			tracing.AnnotateError(span, err)
+			return nil, err
+		}
+		upgraded = true
+	}
+
 	if upgraded {
 		log.Debugf("upgraded state to %s", version.String(state.Version()))
 	}
@@ -487,3 +498,93 @@ func ProcessEpochPrecompute(ctx context.Context, state state.BeaconState) (state
 	}
 	return state, nil
 }
+
+func UpgradeToEpbs(beaconState state.BeaconState) (state.BeaconState, error) {
+	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := beaconState.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := beaconState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := beaconState.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := beaconState.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := beaconState.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	historicalRoots, err := beaconState.HistoricalRoots()
+	if err != nil {
+		return nil, err
+	}
+
+	s := &ethpb.BeaconStateEPBS{
+		GenesisTime:           beaconState.GenesisTime(),
+		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
+		Slot:                  beaconState.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: beaconState.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+			Epoch:           time.CurrentEpoch(beaconState),
+		},
+		LatestBlockHeader:            beaconState.LatestBlockHeader(),
+		BlockRoots:                   beaconState.BlockRoots(),
+		StateRoots:                   beaconState.StateRoots(),
+		HistoricalRoots:              historicalRoots,
+		Eth1Data:                     beaconState.Eth1Data(),
+		Eth1DataVotes:                beaconState.Eth1DataVotes(),
+		Eth1DepositIndex:             beaconState.Eth1DepositIndex(),
+		Validators:                   beaconState.Validators(),
+		Balances:                     beaconState.Balances(),
+		RandaoMixes:                  beaconState.RandaoMixes(),
+		Slashings:                    beaconState.Slashings(),
+		PreviousEpochParticipation:   prevEpochParticipation,
+		CurrentEpochParticipation:    currentEpochParticipation,
+		JustificationBits:            beaconState.JustificationBits(),
+		PreviousJustifiedCheckpoint:  beaconState.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:   beaconState.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:          beaconState.FinalizedCheckpoint(),
+		InactivityScores:             inactivityScores,
+		CurrentSyncCommittee:         currentSyncCommittee,
+		NextSyncCommittee:            nextSyncCommittee,
+		NextWithdrawalIndex:          wi,
+		NextWithdrawalValidatorIndex: vi,
+		HistoricalSummaries:          summaries,
+
+		DepositRequestsStartIndex:     0,
+		DepositBalanceToConsume:       0,
+		ExitBalanceToConsume:          0,
+		EarliestExitEpoch:             0,
+		ConsolidationBalanceToConsume: 0,
+		EarliestConsolidationEpoch:    0,
+		PendingDeposits:               make([]*ethpb.PendingDeposit, 0),
+		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
+		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
+	}
+
+	post, err := state_native.InitializeFromProtoUnsafeEpbs(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post electra beaconState")
+	}
+
+	return post, nil
+}

beacon-chain/core/transition/transition_epbs.go

@@ -0,0 +1,109 @@
+package transition
+
+import (
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+func processExecution(state state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) (err error) {
+	if body.Version() >= version.EPBS {
+		state, err = blocks.ProcessWithdrawals(state, nil)
+		if err != nil {
+			return errors.Wrap(err, "could not process withdrawals")
+		}
+		return processExecutionPayloadHeader(state, body)
+	}
+	enabled, err := blocks.IsExecutionEnabled(state, body)
+	if err != nil {
+		return errors.Wrap(err, "could not check if execution is enabled")
+	}
+	if !enabled {
+		return nil
+	}
+	executionData, err := body.Execution()
+	if err != nil {
+		return err
+	}
+	if state.Version() >= version.Capella {
+		state, err = blocks.ProcessWithdrawals(state, executionData)
+		if err != nil {
+			return errors.Wrap(err, "could not process withdrawals")
+		}
+	}
+	if err := blocks.ProcessPayload(state, body); err != nil {
+		return errors.Wrap(err, "could not process execution data")
+	}
+	return nil
+}
+
+// This function verifies the signature as it is not necessarily signed by the
+// proposer
+func processExecutionPayloadHeader(state state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) (err error) {
+	sh, err := body.SignedExecutionPayloadHeader()
+	if err != nil {
+		return err
+	}
+	header, err := sh.Header()
+	if err != nil {
+		return err
+	}
+	if err := epbs.ValidatePayloadHeaderSignature(state, sh); err != nil {
+		return err
+	}
+	builderIndex := header.BuilderIndex()
+	builder, err := state.ValidatorAtIndex(builderIndex)
+	if err != nil {
+		return err
+	}
+	epoch := slots.ToEpoch(state.Slot())
+	if builder.ActivationEpoch > epoch || epoch >= builder.ExitEpoch {
+		return errors.New("builder is not active")
+	}
+	if builder.Slashed {
+		return errors.New("builder is slashed")
+	}
+	amount := header.Value()
+	builderBalance, err := state.BalanceAtIndex(builderIndex)
+	if err != nil {
+		return err
+	}
+	if amount > primitives.Gwei(builderBalance) {
+		return errors.New("builder has insufficient balance")
+	}
+	// sate.Slot == block.Slot because of process_slot
+	if header.Slot() != state.Slot() {
+		return errors.New("incorrect header slot")
+	}
+	// the state latest block header has the parent root because of
+	// process_block_header
+	blockHeader := state.LatestBlockHeader()
+	if header.ParentBlockRoot() != [32]byte(blockHeader.ParentRoot) {
+		return errors.New("incorrect parent block root")
+	}
+	lbh, err := state.LatestBlockHash()
+	if err != nil {
+		return err
+	}
+	if header.ParentBlockHash() != [32]byte(lbh) {
+		return errors.New("incorrect latest block hash")
+	}
+	if err := state.UpdateBalancesAtIndex(builderIndex, builderBalance-uint64(amount)); err != nil {
+		return err
+	}
+	if err := helpers.IncreaseBalance(state, blockHeader.ProposerIndex, uint64(amount)); err != nil {
+		return err
+	}
+	headerEPBS, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderEPBS)
+	if !ok {
+		return errors.New("not an ePBS execution payload header")
+	}
+	return state.SetLatestExecutionPayloadHeaderEPBS(headerEPBS)
+}

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -8,7 +8,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	b "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epbs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -272,7 +272,7 @@ func ProcessOperationsNoVerifyAttsSigs(
 			return nil, err
 		}
 	} else {
-		state, err = electra.ProcessOperations(ctx, state, beaconBlock)
+		state, err = epbs.ProcessOperations(ctx, state, beaconBlock)
 		if err != nil {
 			return nil, err
 		}
@@ -318,26 +318,9 @@ func ProcessBlockForStateRoot(
 		return nil, errors.Wrap(err, "could not process block header")
 	}
 
-	enabled, err := b.IsExecutionEnabled(state, blk.Body())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not check if execution is enabled")
+	if err := processExecution(state, blk.Body()); err != nil {
+		return nil, errors.Wrap(err, "could not process execution")
 	}
-	if enabled {
-		executionData, err := blk.Body().Execution()
-		if err != nil {
-			return nil, err
-		}
-		if state.Version() >= version.Capella {
-			state, err = b.ProcessWithdrawals(state, executionData)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not process withdrawals")
-			}
-		}
-		if err = b.ProcessPayload(state, blk.Body()); err != nil {
-			return nil, errors.Wrap(err, "could not process execution data")
-		}
-	}
-
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	state, err = b.ProcessRandaoNoVerify(state, randaoReveal[:])
 	if err != nil {

beacon-chain/core/validators/slashing.go

@@ -22,7 +22,7 @@ func SlashingParamsPerVersion(v int) (slashingQuotient, proposerRewardQuotient,
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
 		proposerRewardQuotient = cfg.ProposerRewardQuotient
 		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
-	case version.Electra:
+	case version.Electra, version.EPBS:
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientElectra
 		proposerRewardQuotient = cfg.ProposerRewardQuotient
 		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotientElectra

beacon-chain/db/iface/interface.go

@@ -25,6 +25,7 @@ import (
 type ReadOnlyDatabase interface {
 	// Block related methods.
 	Block(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error)
+	SignedExecutionPayloadHeader(ctx context.Context, blockRoot [32]byte) (interfaces.ROSignedExecutionPayloadHeader, error)
 	Blocks(ctx context.Context, f *filters.QueryFilter) ([]interfaces.ReadOnlySignedBeaconBlock, [][32]byte, error)
 	BlockRoots(ctx context.Context, f *filters.QueryFilter) ([][32]byte, error)
 	BlocksBySlot(ctx context.Context, slot primitives.Slot) ([]interfaces.ReadOnlySignedBeaconBlock, error)
@@ -55,6 +56,7 @@ type ReadOnlyDatabase interface {
 	DepositContractAddress(ctx context.Context) ([]byte, error)
 	// ExecutionChainData operations.
 	ExecutionChainData(ctx context.Context) (*ethpb.ETH1ChainData, error)
+	SignedBlindPayloadEnvelope(ctx context.Context, blockRoot []byte) (*ethpb.SignedBlindPayloadEnvelope, error)
 	// Fee recipients operations.
 	FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error)
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
@@ -92,6 +94,7 @@ type NoHeadAccessDatabase interface {
 	SaveDepositContractAddress(ctx context.Context, addr common.Address) error
 	// SaveExecutionChainData operations.
 	SaveExecutionChainData(ctx context.Context, data *ethpb.ETH1ChainData) error
+	SaveBlindPayloadEnvelope(ctx context.Context, envelope *ethpb.SignedBlindPayloadEnvelope) error
 	// Run any required database migrations.
 	RunMigrations(ctx context.Context) error
 	// Fee recipients operations.

beacon-chain/db/kv/BUILD.bazel

@@ -6,10 +6,12 @@ go_library(
         "archived_point.go",
         "backfill.go",
         "backup.go",
+        "blind_payload_envelope.go",
         "blocks.go",
         "checkpoint.go",
         "deposit_contract.go",
         "encoding.go",
+        "epbs.go",
         "error.go",
         "execution_chain.go",
         "finalized_block_roots.go",
@@ -70,6 +72,7 @@ go_library(
         "@com_github_schollz_progressbar_v3//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_etcd_go_bbolt//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
@@ -80,10 +83,12 @@ go_test(
         "archived_point_test.go",
         "backfill_test.go",
         "backup_test.go",
+        "blind_payload_envelope_test.go",
         "blocks_test.go",
         "checkpoint_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
+        "epbs_test.go",
         "execution_chain_test.go",
         "finalized_block_roots_test.go",
         "genesis_test.go",
@@ -124,6 +129,7 @@ go_test(
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//testing/util/random:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_golang_snappy//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/db/kv/blind_payload_envelope.go

@@ -0,0 +1,45 @@
+package kv
+
+import (
+	"context"
+
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+// SaveBlindPayloadEnvelope saves a signed execution payload envelope blind in the database.
+func (s *Store) SaveBlindPayloadEnvelope(ctx context.Context, env *ethpb.SignedBlindPayloadEnvelope) error {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveBlindPayloadEnvelope")
+	defer span.End()
+
+	enc, err := encode(ctx, env)
+	if err != nil {
+		return err
+	}
+
+	r := env.Message.BeaconBlockRoot
+	err = s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(executionPayloadEnvelopeBucket)
+		return bucket.Put(r, enc)
+	})
+
+	return err
+}
+
+// SignedBlindPayloadEnvelope retrieves a signed execution payload envelope blind from the database.
+func (s *Store) SignedBlindPayloadEnvelope(ctx context.Context, blockRoot []byte) (*ethpb.SignedBlindPayloadEnvelope, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.SignedBlindPayloadEnvelope")
+	defer span.End()
+
+	env := &ethpb.SignedBlindPayloadEnvelope{}
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(executionPayloadEnvelopeBucket)
+		enc := bkt.Get(blockRoot)
+		if enc == nil {
+			return ErrNotFound
+		}
+		return decode(ctx, enc, env)
+	})
+	return env, err
+}

beacon-chain/db/kv/blind_payload_envelope_test.go

@@ -0,0 +1,23 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func TestStore_SignedBlindPayloadEnvelope(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	_, err := db.SignedBlindPayloadEnvelope(ctx, []byte("test"))
+	require.ErrorIs(t, err, ErrNotFound)
+
+	env := random.SignedBlindPayloadEnvelope(t)
+	err = db.SaveBlindPayloadEnvelope(ctx, env)
+	require.NoError(t, err)
+	got, err := db.SignedBlindPayloadEnvelope(ctx, env.Message.BeaconBlockRoot)
+	require.NoError(t, err)
+	require.DeepEqual(t, got, env)
+}

beacon-chain/db/kv/blocks.go

@@ -823,6 +823,11 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 		if err := rawBlock.UnmarshalSSZ(enc[len(electraBlindKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal blinded Electra block")
 		}
+	case hasEpbsKey(enc):
+		rawBlock = &ethpb.SignedBeaconBlockEpbs{}
+		if err := rawBlock.UnmarshalSSZ(enc[len(epbsKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal EPBS block")
+		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
@@ -852,6 +857,8 @@ func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 
 func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 	switch blk.Version() {
+	case version.EPBS:
+		return epbsKey, nil
 	case version.Electra:
 		if blk.IsBlinded() {
 			return electraBlindKey, nil

beacon-chain/db/kv/blocks_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -146,6 +147,17 @@ var blockTests = []struct {
 			}
 			return blocks.NewSignedBeaconBlock(b)
 		}},
+	{
+		name: "epbs",
+		newBlock: func(slot primitives.Slot, root []byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
+			b := random.SignedBeaconBlock(&testing.T{})
+			b.Block.Slot = slot
+			if root != nil {
+				b.Block.ParentRoot = root
+			}
+			return blocks.NewSignedBeaconBlock(b)
+		},
+	},
 }
 
 func TestStore_SaveBlock_NoDuplicates(t *testing.T) {
@@ -202,7 +214,7 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedBlock, err = db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			wanted := retrievedBlock
-			if retrievedBlock.Version() >= version.Bellatrix {
+			if retrievedBlock.Version() >= version.Bellatrix && retrievedBlock.Version() < version.EPBS {
 				wanted, err = retrievedBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -390,7 +402,7 @@ func TestStore_BlocksCRUD_NoCache(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := blk
-			if blk.Version() >= version.Bellatrix {
+			if blk.Version() >= version.Bellatrix && blk.Version() < version.EPBS {
 				wanted, err = blk.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -609,7 +621,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if block1.Version() >= version.Bellatrix {
+			if block1.Version() >= version.Bellatrix && block1.Version() < version.EPBS {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -627,7 +639,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted2 := block2
-			if block2.Version() >= version.Bellatrix {
+			if block2.Version() >= version.Bellatrix && block2.Version() < version.EPBS {
 				wanted2, err = block2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -645,7 +657,7 @@ func TestStore_SaveBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = block3
-			if block3.Version() >= version.Bellatrix {
+			if block3.Version() >= version.Bellatrix && block3.Version() < version.EPBS {
 				wanted, err = wanted.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -681,7 +693,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err := db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted := block1
-			if block1.Version() >= version.Bellatrix {
+			if block1.Version() >= version.Bellatrix && block1.Version() < version.EPBS {
 				wanted, err = block1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -698,7 +710,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if genesisBlock.Version() >= version.Bellatrix {
+			if genesisBlock.Version() >= version.Bellatrix && genesisBlock.Version() < version.EPBS {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -715,7 +727,7 @@ func TestStore_GenesisBlock_CanGetHighestAt(t *testing.T) {
 			b, err = db.Block(ctx, root)
 			require.NoError(t, err)
 			wanted = genesisBlock
-			if genesisBlock.Version() >= version.Bellatrix {
+			if genesisBlock.Version() >= version.Bellatrix && genesisBlock.Version() < version.EPBS {
 				wanted, err = genesisBlock.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -811,7 +823,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 
 			wanted := b1
-			if b1.Version() >= version.Bellatrix {
+			if b1.Version() >= version.Bellatrix && b1.Version() < version.EPBS {
 				wanted, err = b1.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -827,7 +839,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 				t.Fatalf("Expected 2 blocks, received %d blocks", len(retrievedBlocks))
 			}
 			wanted = b2
-			if b2.Version() >= version.Bellatrix {
+			if b2.Version() >= version.Bellatrix && b2.Version() < version.EPBS {
 				wanted, err = b2.ToBlinded()
 				require.NoError(t, err)
 			}
@@ -837,7 +849,7 @@ func TestStore_BlocksBySlot_BlockRootsBySlot(t *testing.T) {
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(wantedPb, retrieved0Pb), "Wanted: %v, received: %v", retrievedBlocks[0], wanted)
 			wanted = b3
-			if b3.Version() >= version.Bellatrix {
+			if b3.Version() >= version.Bellatrix && b3.Version() < version.EPBS {
 				wanted, err = b3.ToBlinded()
 				require.NoError(t, err)
 			}

beacon-chain/db/kv/encoding.go

@@ -78,6 +78,8 @@ func isSSZStorageFormat(obj interface{}) bool {
 		return true
 	case *ethpb.VoluntaryExit:
 		return true
+	case *ethpb.SignedBlindPayloadEnvelope:
+		return true
 	case *ethpb.ValidatorRegistrationV1:
 		return true
 	default:

beacon-chain/db/kv/epbs.go

@@ -0,0 +1,18 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+)
+
+func (s *Store) SignedExecutionPayloadHeader(ctx context.Context, blockRoot [32]byte) (interfaces.ROSignedExecutionPayloadHeader, error) {
+	b, err := s.Block(ctx, blockRoot)
+	if err != nil {
+		return nil, err
+	}
+	if b.IsNil() {
+		return nil, ErrNotFound
+	}
+	return b.Block().Body().SignedExecutionPayloadHeader()
+}

beacon-chain/db/kv/epbs_test.go

@@ -0,0 +1,28 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
+)
+
+func Test_SignedExecutionPayloadHeader(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	b := random.SignedBeaconBlock(t)
+	blk, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	blockRoot, err := blk.Block().HashTreeRoot()
+	require.NoError(t, err)
+
+	require.NoError(t, db.SaveBlock(ctx, blk))
+	retrievedHeader, err := db.SignedExecutionPayloadHeader(ctx, blockRoot)
+	require.NoError(t, err)
+	wantedHeader, err := blk.Block().Body().SignedExecutionPayloadHeader()
+	require.NoError(t, err)
+	require.DeepEqual(t, wantedHeader, retrievedHeader)
+}

beacon-chain/db/kv/key.go

@@ -65,3 +65,10 @@ func hasElectraBlindKey(enc []byte) bool {
 	}
 	return bytes.Equal(enc[:len(electraBlindKey)], electraBlindKey)
 }
+
+func hasEpbsKey(enc []byte) bool {
+	if len(epbsKey) >= len(enc) {
+		return false
+	}
+	return bytes.Equal(enc[:len(epbsKey)], epbsKey)
+}

beacon-chain/db/kv/kv.go

@@ -119,6 +119,9 @@ var Buckets = [][]byte{
 
 	feeRecipientBucket,
 	registrationBucket,
+
+	// ePBS
+	executionPayloadEnvelopeBucket,
 }
 
 // KVStoreOption is a functional option that modifies a kv.Store.

beacon-chain/db/kv/schema.go

@@ -7,15 +7,16 @@ package kv
 // it easy to scan for keys that have a certain shard number as a prefix and return those
 // corresponding attestations.
 var (
-	blocksBucket          = []byte("blocks")
-	stateBucket           = []byte("state")
-	stateSummaryBucket    = []byte("state-summary")
-	chainMetadataBucket   = []byte("chain-metadata")
-	checkpointBucket      = []byte("check-point")
-	powchainBucket        = []byte("powchain")
-	stateValidatorsBucket = []byte("state-validators")
-	feeRecipientBucket    = []byte("fee-recipient")
-	registrationBucket    = []byte("registration")
+	blocksBucket                   = []byte("blocks")
+	stateBucket                    = []byte("state")
+	stateSummaryBucket             = []byte("state-summary")
+	chainMetadataBucket            = []byte("chain-metadata")
+	checkpointBucket               = []byte("check-point")
+	powchainBucket                 = []byte("powchain")
+	stateValidatorsBucket          = []byte("state-validators")
+	feeRecipientBucket             = []byte("fee-recipient")
+	registrationBucket             = []byte("registration")
+	executionPayloadEnvelopeBucket = []byte("execution-payload-envelope")
 
 	// Light Client Updates Bucket
 	lightClientUpdatesBucket = []byte("light-client-updates")
@@ -53,6 +54,7 @@ var (
 	denebBlindKey              = []byte("blind-deneb")
 	electraKey                 = []byte("electra")
 	electraBlindKey            = []byte("blind-electra")
+	epbsKey                    = []byte("epbs")
 
 	// block root included in the beacon state used by weak subjectivity initial sync
 	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")

beacon-chain/db/kv/state.go

@@ -253,6 +253,10 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl
 			if err := s.processElectra(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
+		case *ethpb.BeaconStateEPBS:
+			if err := s.processEPBS(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
+				return err
+			}
 		default:
 			return errors.New("invalid state type")
 		}
@@ -368,6 +372,24 @@ func (s *Store) processElectra(ctx context.Context, pbState *ethpb.BeaconStateEl
 	return nil
 }
 
+func (s *Store) processEPBS(ctx context.Context, pbState *ethpb.BeaconStateEPBS, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
+	if err != nil {
+		return err
+	}
+	encodedState := snappy.Encode(nil, append(epbsKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
+	}
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (s *Store) storeValidatorEntriesSeparately(ctx context.Context, tx *bolt.Tx, validatorsEntries map[string]*ethpb.Validator) error {
 	valBkt := tx.Bucket(stateValidatorsBucket)
 	for hashStr, validatorEntry := range validatorsEntries {
@@ -517,6 +539,19 @@ func (s *Store) unmarshalState(_ context.Context, enc []byte, validatorEntries [
 	}
 
 	switch {
+	case hasEpbsKey(enc):
+		protoState := &ethpb.BeaconStateEPBS{}
+		if err := protoState.UnmarshalSSZ(enc[len(epbsKey):]); err != nil {
+			return nil, errors.Wrap(err, "failed to unmarshal encoding for EPBS")
+		}
+		ok, err := s.isStateValidatorMigrationOver()
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			protoState.Validators = validatorEntries
+		}
+		return statenative.InitializeFromProtoEpbs(protoState)
 	case hasElectraKey(enc):
 		protoState := &ethpb.BeaconStateElectra{}
 		if err := protoState.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
@@ -676,6 +711,19 @@ func marshalState(ctx context.Context, st state.ReadOnlyBeaconState) ([]byte, er
 			return nil, err
 		}
 		return snappy.Encode(nil, append(electraKey, rawObj...)), nil
+	case *ethpb.BeaconStateEPBS:
+		rState, ok := st.ToProtoUnsafe().(*ethpb.BeaconStateEPBS)
+		if !ok {
+			return nil, errors.New("non valid inner state")
+		}
+		if rState == nil {
+			return nil, errors.New("nil state")
+		}
+		rawObj, err := rState.MarshalSSZ()
+		if err != nil {
+			return nil, err
+		}
+		return snappy.Encode(nil, append(epbsKey, rawObj...)), nil
 	default:
 		return nil, errors.New("invalid inner state")
 	}

beacon-chain/db/kv/state_test.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	statenative "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -20,6 +21,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/prysmaticlabs/prysm/v5/testing/util/random"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -156,6 +158,16 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 			},
 			rootSeed: 'E',
 		},
+		{
+			name: "epbs",
+			s: func() state.BeaconState {
+				stPb := random.BeaconState(t)
+				st, err := statenative.InitializeFromProtoUnsafeEpbs(stPb)
+				require.NoError(t, err)
+				return st
+			},
+			rootSeed: 'F',
+		},
 	}
 
 	db := setupDB(t)
@@ -1110,6 +1122,26 @@ func TestDenebState_CanDelete(t *testing.T) {
 	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
 }
 
+func TestEpbsState_CanDelete(t *testing.T) {
+	db := setupDB(t)
+
+	r := [32]byte{'A'}
+
+	require.Equal(t, false, db.HasState(context.Background(), r))
+
+	s := random.BeaconState(t)
+	st, err := statenative.InitializeFromProtoUnsafeEpbs(s)
+	require.NoError(t, err)
+
+	require.NoError(t, db.SaveState(context.Background(), st, r))
+	require.Equal(t, true, db.HasState(context.Background(), r))
+
+	require.NoError(t, db.DeleteState(context.Background(), r))
+	savedS, err := db.State(context.Background(), r)
+	require.NoError(t, err)
+	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
+}
+
 func TestStateDeneb_CanSaveRetrieveValidatorEntries(t *testing.T) {
 	db := setupDB(t)
 

beacon-chain/forkchoice/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

beacon-chain/forkchoice/doubly-linked-tree/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "doc.go",
+        "epbs.go",
         "errors.go",
         "forkchoice.go",
         "last_root.go",
@@ -31,6 +32,7 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/forkchoice:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
@@ -47,6 +49,7 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
+        "epbs_test.go",
         "ffg_update_test.go",
         "forkchoice_test.go",
         "last_root_test.go",
@@ -71,12 +74,12 @@ go_test(
         "//consensus-types/forkchoice:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
     ],
 )

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

@@ -0,0 +1,83 @@
+package doublylinkedtree
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
+)
+
+func (f *ForkChoice) GetPTCVote() primitives.PTCStatus {
+	highestNode := f.store.highestReceivedNode
+	if highestNode == nil {
+		return primitives.PAYLOAD_ABSENT
+	}
+	if slots.CurrentSlot(f.store.genesisTime) > highestNode.block.slot {
+		return primitives.PAYLOAD_ABSENT
+	}
+	if highestNode.full {
+		return primitives.PAYLOAD_PRESENT
+	}
+	return primitives.PAYLOAD_ABSENT
+}
+
+func (f *ForkChoice) insertExecutionPayload(b *BlockNode, e interfaces.ExecutionData) error {
+	s := f.store
+	hash := [32]byte(e.BlockHash())
+	if _, ok := s.fullNodeByPayload[hash]; ok {
+		// We ignore nodes with the give payload hash already included
+		return nil
+	}
+	n := &Node{
+		block:      b,
+		children:   make([]*Node, 0),
+		full:       true,
+		optimistic: true,
+	}
+	if n.block.parent != nil {
+		n.block.parent.children = append(n.block.parent.children, n)
+	} else {
+		// make this the tree node
+		f.store.treeRootNode = n
+	}
+	s.fullNodeByPayload[hash] = n
+	s.updateWithPayload(n)
+	processedPayloadCount.Inc()
+	payloadCount.Set(float64(len(s.fullNodeByPayload)))
+
+	// make this node head if the empty node was
+	if s.headNode.block == n.block {
+		s.headNode = n
+	}
+	if b.slot == s.highestReceivedNode.block.slot {
+		s.highestReceivedNode = n
+	}
+	return nil
+}
+
+// InsertPayloadEnvelope adds a full node to forkchoice from the given payload
+// envelope.
+func (f *ForkChoice) InsertPayloadEnvelope(envelope interfaces.ROExecutionPayloadEnvelope) error {
+	s := f.store
+	b, ok := s.emptyNodeByRoot[envelope.BeaconBlockRoot()]
+	if !ok {
+		return ErrNilNode
+	}
+	e, err := envelope.Execution()
+	if err != nil {
+		return err
+	}
+	return f.insertExecutionPayload(b.block, e)
+}
+
+func (s *Store) updateWithPayload(n *Node) {
+	for _, node := range s.emptyNodeByRoot {
+		if node.bestDescendant != nil && node.bestDescendant.block == n.block {
+			node.bestDescendant = n
+		}
+	}
+	for _, node := range s.fullNodeByPayload {
+		if node.bestDescendant != nil && node.bestDescendant.block == n.block {
+			node.bestDescendant = n
+		}
+	}
+}

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

@@ -0,0 +1,27 @@
+package doublylinkedtree
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestFullInsertionPreEPBS(t *testing.T) {
+	ctx := context.Background()
+	f := setup(1, 1)
+	require.Equal(t, 1, f.NodeCount())
+
+	payloadHash := [32]byte{'A'}
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, payloadHash, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blk))
+	node, ok := f.store.emptyNodeByRoot[blk.Root()]
+	require.Equal(t, true, ok)
+	require.Equal(t, blk.Root(), node.block.root)
+
+	fullNode, ok := f.store.fullNodeByPayload[payloadHash]
+	require.Equal(t, true, ok)
+	require.Equal(t, payloadHash, fullNode.block.payloadHash)
+}

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

@@ -20,6 +20,8 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	r, err := f.Head(context.Background())
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().ZeroHash, r, "Incorrect head with genesis")
+	// check that the head is the full block
+	require.Equal(t, true, f.store.headNode.full)
 
 	// Define the following tree:
 	//            0 <- justified: 0, finalized: 0
@@ -29,13 +31,13 @@ func TestFFGUpdates_OneBranch(t *testing.T) {
 	//            2 <- justified: 1, finalized: 0
 	//            |
 	//            3 <- justified: 2, finalized: 1
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, indexToHash(101), 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 2, indexToHash(2), indexToHash(1), indexToHash(102), 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 2, 1)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 3, indexToHash(3), indexToHash(2), indexToHash(103), 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
@@ -101,35 +103,35 @@ func TestFFGUpdates_TwoBranches(t *testing.T) {
 	//                                |   |
 	//  justified: 2, finalized: 0 -> 9  10 <- justified: 2, finalized: 0
 	// Left branch.
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 2, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 3, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(7), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 4, indexToHash(7), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(9), indexToHash(7), params.BeaconConfig().ZeroHash, 2, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 4, indexToHash(9), indexToHash(7), params.BeaconConfig().ZeroHash, 2, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	// Right branch.
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 1, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 1, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 2, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(6), indexToHash(4), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 3, indexToHash(6), indexToHash(4), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(8), indexToHash(6), params.BeaconConfig().ZeroHash, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 4, indexToHash(8), indexToHash(6), params.BeaconConfig().ZeroHash, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(10), indexToHash(8), params.BeaconConfig().ZeroHash, 2, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 4, indexToHash(10), indexToHash(8), params.BeaconConfig().ZeroHash, 2, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
@@ -220,12 +222,12 @@ func setup(justifiedEpoch, finalizedEpoch primitives.Epoch) *ForkChoice {
 	f := New()
 	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: justifiedEpoch, Root: params.BeaconConfig().ZeroHash}
 	f.store.finalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: finalizedEpoch, Root: params.BeaconConfig().ZeroHash}
-	state, blkRoot, err := prepareForkchoiceState(ctx, 0, params.BeaconConfig().ZeroHash, [32]byte{}, params.BeaconConfig().ZeroHash, justifiedEpoch, finalizedEpoch)
+	state, blk, err := prepareForkchoiceState(ctx, f, 0, params.BeaconConfig().ZeroHash, [32]byte{}, params.BeaconConfig().ZeroHash, justifiedEpoch, finalizedEpoch)
 	if err != nil {
 		return nil
 	}
 	f.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) { return f.justifiedBalances, nil })
-	err = f.InsertNode(ctx, state, blkRoot)
+	err = f.InsertNode(ctx, state, blk)
 	if err != nil {
 		return nil
 	}

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

@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
 )
@@ -30,8 +31,8 @@ func New() *ForkChoice {
 		prevJustifiedCheckpoint:       &forkchoicetypes.Checkpoint{},
 		finalizedCheckpoint:           &forkchoicetypes.Checkpoint{},
 		proposerBoostRoot:             [32]byte{},
-		nodeByRoot:                    make(map[[fieldparams.RootLength]byte]*Node),
-		nodeByPayload:                 make(map[[fieldparams.RootLength]byte]*Node),
+		emptyNodeByRoot:               make(map[[fieldparams.RootLength]byte]*Node),
+		fullNodeByPayload:             make(map[[fieldparams.RootLength]byte]*Node),
 		slashedIndices:                make(map[primitives.ValidatorIndex]bool),
 		receivedBlocksLastEpoch:       [fieldparams.SlotsPerEpoch]primitives.Slot{},
 	}
@@ -43,7 +44,7 @@ func New() *ForkChoice {
 
 // NodeCount returns the current number of nodes in the Store.
 func (f *ForkChoice) NodeCount() int {
-	return len(f.store.nodeByRoot)
+	return len(f.store.emptyNodeByRoot)
 }
 
 // Head returns the head root from fork choice store.
@@ -79,7 +80,7 @@ func (f *ForkChoice) Head(
 
 // ProcessAttestation processes attestation for vote accounting, it iterates around validator indices
 // and update their votes accordingly.
-func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []uint64, blockRoot [32]byte, targetEpoch primitives.Epoch) {
+func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []uint64, blockRoot [32]byte, attSlot primitives.Slot) {
 	_, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.ProcessAttestation")
 	defer span.End()
 
@@ -93,9 +94,9 @@ func (f *ForkChoice) ProcessAttestation(ctx context.Context, validatorIndices []
 		newVote := f.votes[index].nextRoot == params.BeaconConfig().ZeroHash &&
 			f.votes[index].currentRoot == params.BeaconConfig().ZeroHash
 
-		// Vote gets updated if it's newly allocated or high target epoch.
-		if newVote || targetEpoch > f.votes[index].nextEpoch {
-			f.votes[index].nextEpoch = targetEpoch
+		// Vote gets updated if it's newly allocated or higher attestation slot.
+		if newVote || attSlot > f.votes[index].slot {
+			f.votes[index].slot = attSlot
 			f.votes[index].nextRoot = blockRoot
 		}
 	}
@@ -125,12 +126,29 @@ func (f *ForkChoice) InsertNode(ctx context.Context, state state.BeaconState, ro
 
 	jc, fc = f.store.pullTips(state, node, jc, fc)
 	if err := f.updateCheckpoints(ctx, jc, fc); err != nil {
-		_, remErr := f.store.removeNode(ctx, node)
+		emptyNode := f.store.emptyNodeByRoot[node.root]
+		_, remErr := f.store.removeNode(ctx, emptyNode)
 		if remErr != nil {
 			log.WithError(remErr).Error("could not remove node")
 		}
 		return errors.Wrap(err, "could not update checkpoints")
 	}
+	if roblock.Version() >= version.EPBS {
+		return nil
+	}
+	if roblock.Version() >= version.Bellatrix {
+		e, err := roblock.Block().Body().Execution()
+		if err != nil {
+			return errors.Wrap(err, "could not get execution data")
+		}
+		currentEpoch := slots.EpochsSinceGenesis(time.Unix(int64(f.store.genesisTime), 0))
+		if err := f.store.treeRootNode.updateBestDescendant(ctx, jc.Epoch, fc.Epoch, currentEpoch); err != nil {
+			return err
+		}
+		if err := f.insertExecutionPayload(node, e); err != nil {
+			return errors.Wrap(err, "could not insert execution payload to forkchoice")
+		}
+	}
 	return nil
 }
 
@@ -156,16 +174,28 @@ func (f *ForkChoice) updateCheckpoints(ctx context.Context, jc, fc *ethpb.Checkp
 // HasNode returns true if the node exists in fork choice store,
 // false else wise.
 func (f *ForkChoice) HasNode(root [32]byte) bool {
-	_, ok := f.store.nodeByRoot[root]
+	_, ok := f.store.emptyNodeByRoot[root]
+	return ok
+}
+
+// HasHash returns true if the node with the given payload hash exists in fork choice store,
+// false else wise.
+func (f *ForkChoice) HasHash(hash [32]byte) bool {
+	_, ok := f.store.fullNodeByPayload[hash]
 	return ok
 }
 
 // IsCanonical returns true if the given root is part of the canonical chain.
+// TODO: change the API to pass also full/empty
 func (f *ForkChoice) IsCanonical(root [32]byte) bool {
-	node, ok := f.store.nodeByRoot[root]
+	node, ok := f.store.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		return false
 	}
+	fullNode, ok := f.store.fullNodeByPayload[node.block.payloadHash]
+	if ok {
+		node = fullNode
+	}
 
 	if node.bestDescendant == nil {
 		if f.store.headNode.bestDescendant == nil {
@@ -185,7 +215,7 @@ func (f *ForkChoice) IsOptimistic(root [32]byte) (bool, error) {
 		return true, nil
 	}
 
-	node, ok := f.store.nodeByRoot[root]
+	node, ok := f.store.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		return true, ErrNilNode
 	}
@@ -197,31 +227,37 @@ func (f *ForkChoice) IsOptimistic(root [32]byte) (bool, error) {
 func (f *ForkChoice) AncestorRoot(ctx context.Context, root [32]byte, slot primitives.Slot) ([32]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.AncestorRoot")
 	defer span.End()
+	return f.store.ancestorRoot(ctx, root, slot)
+}
 
-	node, ok := f.store.nodeByRoot[root]
+func (s *Store) ancestorRoot(ctx context.Context, root [32]byte, slot primitives.Slot) ([32]byte, error) {
+	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.AncestorRoot")
+	defer span.End()
+
+	node, ok := s.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		return [32]byte{}, errors.Wrap(ErrNilNode, "could not determine ancestor root")
 	}
 
 	n := node
-	for n != nil && n.slot > slot {
+	for n != nil && n.block.slot > slot {
 		if ctx.Err() != nil {
 			return [32]byte{}, ctx.Err()
 		}
-		n = n.parent
+		n = n.block.parent
 	}
 
 	if n == nil {
 		return [32]byte{}, errors.Wrap(ErrNilNode, "could not determine ancestor root")
 	}
 
-	return n.root, nil
+	return n.block.root, nil
 }
 
 // IsViableForCheckpoint returns whether the root passed is a checkpoint root for any
 // known chain in forkchoice.
 func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool, error) {
-	node, ok := f.store.nodeByRoot[cp.Root]
+	node, ok := f.store.emptyNodeByRoot[cp.Root]
 	if !ok || node == nil {
 		return false, nil
 	}
@@ -229,22 +265,30 @@ func (f *ForkChoice) IsViableForCheckpoint(cp *forkchoicetypes.Checkpoint) (bool
 	if err != nil {
 		return false, err
 	}
-	if node.slot > epochStart {
+	if node.block.slot > epochStart {
 		return false, nil
 	}
 
+	fullNode := f.store.fullNodeByPayload[node.block.payloadHash]
+
 	if len(node.children) == 0 {
-		return true, nil
+		if fullNode != nil && len(fullNode.children) == 0 {
+			return true, nil
+		}
 	}
-	if node.slot == epochStart {
+	if node.block.slot == epochStart {
 		return true, nil
 	}
-	nodeEpoch := slots.ToEpoch(node.slot)
-	if nodeEpoch >= cp.Epoch {
-		return false, nil
-	}
 	for _, child := range node.children {
-		if child.slot > epochStart {
+		if child.block.slot > epochStart {
+			return true, nil
+		}
+	}
+	if fullNode == nil {
+		return false, nil
+	}
+	for _, child := range fullNode.children {
+		if child.block.slot > epochStart {
 			return true, nil
 		}
 	}
@@ -284,34 +328,35 @@ func (f *ForkChoice) updateBalances() error {
 		if vote.currentRoot != vote.nextRoot || oldBalance != newBalance {
 			// Ignore the vote if the root is not in fork choice
 			// store, that means we have not seen the block before.
-			nextNode, ok := f.store.nodeByRoot[vote.nextRoot]
+			nextNode, ok := f.store.emptyNodeByRoot[vote.nextRoot]
 			if ok && vote.nextRoot != zHash {
 				// Protection against nil node
 				if nextNode == nil {
 					return errors.Wrap(ErrNilNode, "could not update balances")
 				}
-				nextNode.balance += newBalance
+				// New votes count both for full and empty nodes
+				nextNode.block.balance += newBalance
 			}
 
-			currentNode, ok := f.store.nodeByRoot[vote.currentRoot]
+			currentNode, ok := f.store.emptyNodeByRoot[vote.currentRoot]
 			if ok && vote.currentRoot != zHash {
 				// Protection against nil node
 				if currentNode == nil {
 					return errors.Wrap(ErrNilNode, "could not update balances")
 				}
-				if currentNode.balance < oldBalance {
+				if currentNode.block.balance < oldBalance {
 					log.WithFields(logrus.Fields{
 						"nodeRoot":                   fmt.Sprintf("%#x", bytesutil.Trunc(vote.currentRoot[:])),
 						"oldBalance":                 oldBalance,
-						"nodeBalance":                currentNode.balance,
-						"nodeWeight":                 currentNode.weight,
+						"nodeBalance":                currentNode.block.balance,
+						"emptyNodeWeight":            currentNode.weight,
 						"proposerBoostRoot":          fmt.Sprintf("%#x", bytesutil.Trunc(f.store.proposerBoostRoot[:])),
 						"previousProposerBoostRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(f.store.previousProposerBoostRoot[:])),
 						"previousProposerBoostScore": f.store.previousProposerBoostScore,
 					}).Warning("node with invalid balance, setting it to zero")
-					currentNode.balance = 0
+					currentNode.block.balance = 0
 				} else {
-					currentNode.balance -= oldBalance
+					currentNode.block.balance -= oldBalance
 				}
 			}
 		}
@@ -336,7 +381,7 @@ func (f *ForkChoice) ProposerBoost() [fieldparams.RootLength]byte {
 
 // SetOptimisticToValid sets the node with the given root as a fully validated node
 func (f *ForkChoice) SetOptimisticToValid(ctx context.Context, root [fieldparams.RootLength]byte) error {
-	node, ok := f.store.nodeByRoot[root]
+	node, ok := f.store.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		return errors.Wrap(ErrNilNode, "could not set node to valid")
 	}
@@ -383,15 +428,15 @@ func (f *ForkChoice) InsertSlashedIndex(_ context.Context, index primitives.Vali
 		return
 	}
 
-	node, ok := f.store.nodeByRoot[f.votes[index].currentRoot]
+	node, ok := f.store.emptyNodeByRoot[f.votes[index].currentRoot]
 	if !ok || node == nil {
 		return
 	}
 
-	if node.balance < f.balances[index] {
-		node.balance = 0
+	if node.block.balance < f.balances[index] {
+		node.block.balance = 0
 	} else {
-		node.balance -= f.balances[index]
+		node.block.balance -= f.balances[index]
 	}
 }
 
@@ -418,21 +463,22 @@ func (f *ForkChoice) UpdateFinalizedCheckpoint(fc *forkchoicetypes.Checkpoint) e
 }
 
 // CommonAncestor returns the common ancestor root and slot between the two block roots r1 and r2.
+// TODO: change the API to pass full/empty not just roots.
 func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byte) ([32]byte, primitives.Slot, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.CommonAncestorRoot")
 	defer span.End()
 
-	n1, ok := f.store.nodeByRoot[r1]
+	n1, ok := f.store.emptyNodeByRoot[r1]
 	if !ok || n1 == nil {
 		return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 	}
 
 	// Do nothing if the input roots are the same.
 	if r1 == r2 {
-		return r1, n1.slot, nil
+		return r1, n1.block.slot, nil
 	}
 
-	n2, ok := f.store.nodeByRoot[r2]
+	n2, ok := f.store.emptyNodeByRoot[r2]
 	if !ok || n2 == nil {
 		return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 	}
@@ -441,23 +487,28 @@ func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byt
 		if ctx.Err() != nil {
 			return [32]byte{}, 0, ctx.Err()
 		}
-		if n1.slot > n2.slot {
-			n1 = n1.parent
+		if n1.block.slot > n2.block.slot {
+			n1 = n1.block.parent
 			// Reaches the end of the tree and unable to find common ancestor.
 			// This should not happen at runtime as the finalized
 			// node has to be a common ancestor
 			if n1 == nil {
 				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 			}
-		} else {
-			n2 = n2.parent
+		} else if n1.block.slot < n2.block.slot {
+			n2 = n2.block.parent
 			// Reaches the end of the tree and unable to find common ancestor.
 			if n2 == nil {
 				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
 			}
-		}
-		if n1 == n2 {
-			return n1.root, n1.slot, nil
+		} else {
+			if n1.block.root == n2.block.root {
+				return n1.block.root, n1.block.slot, nil
+			}
+			n1 = n1.block.parent
+			if n1 == nil {
+				return [32]byte{}, 0, forkchoice.ErrUnknownCommonAncestor
+			}
 		}
 	}
 }
@@ -501,40 +552,40 @@ func (f *ForkChoice) CachedHeadRoot() [32]byte {
 	if node == nil {
 		return [32]byte{}
 	}
-	return f.store.headNode.root
+	return f.store.headNode.block.root
 }
 
 // FinalizedPayloadBlockHash returns the hash of the payload at the finalized checkpoint
 func (f *ForkChoice) FinalizedPayloadBlockHash() [32]byte {
 	root := f.FinalizedCheckpoint().Root
-	node, ok := f.store.nodeByRoot[root]
+	node, ok := f.store.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		// This should not happen
 		return [32]byte{}
 	}
-	return node.payloadHash
+	return node.block.payloadHash
 }
 
 // JustifiedPayloadBlockHash returns the hash of the payload at the justified checkpoint
 func (f *ForkChoice) JustifiedPayloadBlockHash() [32]byte {
 	root := f.JustifiedCheckpoint().Root
-	node, ok := f.store.nodeByRoot[root]
+	node, ok := f.store.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		// This should not happen
 		return [32]byte{}
 	}
-	return node.payloadHash
+	return node.block.payloadHash
 }
 
 // UnrealizedJustifiedPayloadBlockHash returns the hash of the payload at the unrealized justified checkpoint
 func (f *ForkChoice) UnrealizedJustifiedPayloadBlockHash() [32]byte {
 	root := f.store.unrealizedJustifiedCheckpoint.Root
-	node, ok := f.store.nodeByRoot[root]
+	node, ok := f.store.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		// This should not happen
 		return [32]byte{}
 	}
-	return node.payloadHash
+	return node.block.payloadHash
 }
 
 // ForkChoiceDump returns a full dump of forkchoice.
@@ -565,7 +616,7 @@ func (f *ForkChoice) ForkChoiceDump(ctx context.Context) (*forkchoice2.Dump, err
 	}
 	var headRoot [32]byte
 	if f.store.headNode != nil {
-		headRoot = f.store.headNode.root
+		headRoot = f.store.headNode.block.root
 	}
 	resp := &forkchoice2.Dump{
 		JustifiedCheckpoint:           jc,
@@ -587,7 +638,7 @@ func (f *ForkChoice) SetBalancesByRooter(handler forkchoice.BalancesByRooter) {
 
 // Weight returns the weight of the given root if found on the store
 func (f *ForkChoice) Weight(root [32]byte) (uint64, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return 0, ErrNilNode
 	}
@@ -615,11 +666,11 @@ func (f *ForkChoice) updateJustifiedBalances(ctx context.Context, root [32]byte)
 
 // Slot returns the slot of the given root if it's known to forkchoice
 func (f *ForkChoice) Slot(root [32]byte) (primitives.Slot, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return 0, ErrNilNode
 	}
-	return n.slot, nil
+	return n.block.slot, nil
 }
 
 // TargetRootForEpoch returns the root of the target block for a given epoch.
@@ -631,28 +682,25 @@ func (f *ForkChoice) Slot(root [32]byte) (primitives.Slot, error) {
 // which case we return the root of the checkpoint of the chain containing the
 // passed root, at the given epoch
 func (f *ForkChoice) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return [32]byte{}, ErrNilNode
 	}
-	nodeEpoch := slots.ToEpoch(n.slot)
+	nodeEpoch := slots.ToEpoch(n.block.slot)
 	if epoch > nodeEpoch {
-		return n.root, nil
+		return n.block.root, nil
 	}
-	if n.target == nil {
+	targetNode := n.block.target
+	if targetNode == nil {
 		return [32]byte{}, nil
 	}
-	targetRoot := n.target.root
+	targetRoot := targetNode.root
 	if epoch == nodeEpoch {
 		return targetRoot, nil
 	}
-	targetNode, ok := f.store.nodeByRoot[targetRoot]
-	if !ok || targetNode == nil {
-		return [32]byte{}, ErrNilNode
-	}
 	// If slot 0 was not missed we consider a previous block to go back at least one epoch
 	if nodeEpoch == slots.ToEpoch(targetNode.slot) {
-		targetNode = targetNode.parent
+		targetNode = targetNode.parent.block
 		if targetNode == nil {
 			return [32]byte{}, ErrNilNode
 		}
@@ -664,13 +712,13 @@ func (f *ForkChoice) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch) (
 // The exception is for the finalized checkpoint root which we return the zero
 // hash.
 func (f *ForkChoice) ParentRoot(root [32]byte) ([32]byte, error) {
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	if !ok || n == nil {
 		return [32]byte{}, ErrNilNode
 	}
 	// Return the zero hash for the tree root
-	if n.parent == nil {
+	if n.block.parent == nil {
 		return [32]byte{}, nil
 	}
-	return n.parent.root, nil
+	return n.block.parent.block.root, nil
 }

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

@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -23,9 +24,11 @@ import (
 )
 
 // prepareForkchoiceState prepares a beacon State with the given data to mock
-// insert into forkchoice
+// insert into forkchoice. This method prepares full states and blocks for
+// bellatrix, it cannot be used for ePBS tests.
 func prepareForkchoiceState(
 	_ context.Context,
+	f *ForkChoice,
 	slot primitives.Slot,
 	blockRoot [32]byte,
 	parentRoot [32]byte,
@@ -48,7 +51,11 @@ func prepareForkchoiceState(
 	finalizedCheckpoint := &ethpb.Checkpoint{
 		Epoch: finalizedEpoch,
 	}
-
+	var parentHash [32]byte
+	parentNode, ok := f.store.emptyNodeByRoot[parentRoot]
+	if ok {
+		parentHash = parentNode.block.payloadHash
+	}
 	base := &ethpb.BeaconStateBellatrix{
 		Slot:                         slot,
 		RandaoMixes:                  make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
@@ -68,7 +75,8 @@ func prepareForkchoiceState(
 			ParentRoot: parentRoot[:],
 			Body: &ethpb.BeaconBlockBodyBellatrix{
 				ExecutionPayload: &enginev1.ExecutionPayload{
-					BlockHash: payloadHash[:],
+					BlockHash:  payloadHash[:],
+					ParentHash: parentHash[:],
 				},
 			},
 		},
@@ -81,16 +89,24 @@ func prepareForkchoiceState(
 	return st, roblock, err
 }
 
+// Helper function to set all bits in a Bitvector512
+func setAllBits(bv bitfield.Bitvector512) bitfield.Bitvector512 {
+	for i := 0; i < len(bv); i++ {
+		bv[i] = 0xFF
+	}
+	return bv
+}
+
 func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
@@ -105,27 +121,27 @@ func TestForkChoice_UpdateBalancesPositiveChange(t *testing.T) {
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
 	s := f.store
-	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].block.balance)
+	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].block.balance)
+	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].block.balance)
 }
 
 func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].block.balance = 100
 
 	f.balances = []uint64{100, 100, 100}
 	f.votes = []Vote{
@@ -136,27 +152,27 @@ func TestForkChoice_UpdateBalancesNegativeChange(t *testing.T) {
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(10), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(20), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(30), s.nodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(10), s.emptyNodeByRoot[indexToHash(1)].block.balance)
+	assert.Equal(t, uint64(20), s.emptyNodeByRoot[indexToHash(2)].block.balance)
+	assert.Equal(t, uint64(30), s.emptyNodeByRoot[indexToHash(3)].block.balance)
 }
 
 func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].block.balance = 100
 
 	f.balances = []uint64{125, 125, 125}
 	f.votes = []Vote{
@@ -167,30 +183,53 @@ func TestForkChoice_UpdateBalancesUnderflow(t *testing.T) {
 
 	f.justifiedBalances = []uint64{10, 20, 30}
 	require.NoError(t, f.updateBalances())
-	assert.Equal(t, uint64(0), s.nodeByRoot[indexToHash(1)].balance)
-	assert.Equal(t, uint64(0), s.nodeByRoot[indexToHash(2)].balance)
-	assert.Equal(t, uint64(5), s.nodeByRoot[indexToHash(3)].balance)
+	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(1)].block.balance)
+	assert.Equal(t, uint64(0), s.emptyNodeByRoot[indexToHash(2)].block.balance)
+	assert.Equal(t, uint64(5), s.emptyNodeByRoot[indexToHash(3)].block.balance)
 }
 
 func TestForkChoice_IsCanonical(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	// there are two nodes in f, the full and empty nodes
+	require.Equal(t, 1, len(f.store.emptyNodeByRoot))
+	require.Equal(t, 1, len(f.store.fullNodeByPayload))
+	// The full node is the tree root node
+	require.Equal(t, true, f.store.treeRootNode.full)
+	fullRoot := f.store.treeRootNode
+	// Both blocks have nil best descendants
+	emptyRoot := f.store.emptyNodeByRoot[[32]byte{}]
+	require.Equal(t, emptyRoot.block, f.store.treeRootNode.block)
+	require.Equal(t, false, emptyRoot.full)
+	require.IsNil(t, emptyRoot.bestDescendant)
+	require.IsNil(t, fullRoot.bestDescendant)
+	require.Equal(t, fullRoot, f.store.fullNodeByPayload[[32]byte{}])
+	require.Equal(t, fullRoot, f.store.fullNodeByPayload[emptyRoot.block.payloadHash])
+
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, indexToHash(101), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	// This block descends from the full node
+	require.Equal(t, 2, len(fullRoot.children))
+	require.Equal(t, 0, len(emptyRoot.children))
+	// The full block is the head of chain
+	fullOne := f.store.fullNodeByPayload[indexToHash(101)]
+	require.Equal(t, fullRoot.bestDescendant, fullOne)
+	require.Equal(t, true, f.IsCanonical([32]byte{}))
+
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), params.BeaconConfig().ZeroHash, indexToHash(102), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(1), indexToHash(103), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 4, indexToHash(4), indexToHash(2), indexToHash(104), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 5, indexToHash(5), indexToHash(4), indexToHash(105), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 6, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 6, indexToHash(6), indexToHash(5), indexToHash(106), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
@@ -205,40 +244,56 @@ func TestForkChoice_IsCanonical(t *testing.T) {
 
 func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 	f := setup(1, 1)
+	rootNode := f.store.treeRootNode
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, indexToHash(101), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	// We have two children for the full root node
+	require.Equal(t, rootNode, f.store.treeRootNode)
+	require.Equal(t, true, rootNode.full)
+	require.Equal(t, 2, len(rootNode.children))
+
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'2'}, params.BeaconConfig().ZeroHash, indexToHash(102), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1)
+	// We have now 4 children on the rootnode:
+	require.Equal(t, rootNode, f.store.treeRootNode)
+	require.Equal(t, true, rootNode.full)
+	require.Equal(t, 4, len(rootNode.children))
+
+	fullOne := f.store.fullNodeByPayload[indexToHash(101)]
+	require.Equal(t, 0, len(fullOne.children))
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, [32]byte{'3'}, [32]byte{'1'}, indexToHash(103), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 4, [32]byte{'4'}, [32]byte{'2'}, params.BeaconConfig().ZeroHash, 1, 1)
+	require.Equal(t, 2, len(fullOne.children))
+
+	st, roblock, err = prepareForkchoiceState(ctx, f, 4, [32]byte{'4'}, [32]byte{'2'}, indexToHash(104), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 5, [32]byte{'5'}, [32]byte{'4'}, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 5, [32]byte{'5'}, [32]byte{'4'}, indexToHash(105), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 6, [32]byte{'6'}, [32]byte{'5'}, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 6, [32]byte{'6'}, [32]byte{'5'}, indexToHash(106), 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
-	f.store.nodeByRoot[[32]byte{'3'}].balance = 10
+	f.store.fullNodeByPayload[indexToHash(103)].block.balance = 10
 	require.NoError(t, f.store.treeRootNode.applyWeightChanges(ctx))
-	require.Equal(t, uint64(10), f.store.nodeByRoot[[32]byte{'1'}].weight)
-	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'2'}].weight)
+	// We get 20 for 101 because both empty and full nodes contribute to it.
+	require.Equal(t, uint64(10), f.store.fullNodeByPayload[indexToHash(101)].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'2'}].weight)
 
 	require.NoError(t, f.store.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
-	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.root)
+	require.DeepEqual(t, [32]byte{'3'}, f.store.treeRootNode.bestDescendant.block.root)
 
 	r1 := [32]byte{'1'}
 	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 1, Root: r1}
 	h, err := f.store.head(ctx)
 	require.NoError(t, err)
 	require.DeepEqual(t, [32]byte{'3'}, h)
-	require.DeepEqual(t, h, f.store.headNode.root)
+	require.DeepEqual(t, h, f.store.headNode.block.root)
 
 	require.Equal(t, true, f.IsCanonical(params.BeaconConfig().ZeroHash))
 	require.Equal(t, true, f.IsCanonical([32]byte{'1'}))
@@ -252,17 +307,17 @@ func TestForkChoice_IsCanonicalReorg(t *testing.T) {
 func TestForkChoice_AncestorRoot(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 5, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	f.store.treeRootNode = f.store.nodeByRoot[indexToHash(1)]
-	f.store.treeRootNode.parent = nil
+	f.store.treeRootNode = f.store.emptyNodeByRoot[indexToHash(1)]
+	f.store.treeRootNode.block.parent = nil
 
 	r, err := f.AncestorRoot(ctx, indexToHash(3), 6)
 	assert.NoError(t, err)
@@ -284,10 +339,10 @@ func TestForkChoice_AncestorRoot(t *testing.T) {
 func TestForkChoice_AncestorEqualSlot(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
@@ -299,10 +354,10 @@ func TestForkChoice_AncestorEqualSlot(t *testing.T) {
 func TestForkChoice_AncestorLowerSlot(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'1'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 200, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 200, [32]byte{'3'}, [32]byte{'1'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
@@ -315,7 +370,7 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 	// Insert a block it will be head
-	st, roblock, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	head, err := f.Head(ctx)
@@ -323,10 +378,10 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 	require.Equal(t, [32]byte{'a'}, head)
 
 	// Insert two extra blocks
-	st, roblock, err = prepareForkchoiceState(ctx, 2, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	head, err = f.Head(ctx)
@@ -343,21 +398,21 @@ func TestForkChoice_RemoveEquivocating(t *testing.T) {
 
 	// Process b's slashing, c is now head
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].block.balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
 	// Process b's slashing again, should be a noop
 	f.InsertSlashedIndex(ctx, 1)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].balance)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].block.balance)
 	f.justifiedBalances = []uint64{100, 200, 200, 300}
 	head, err = f.Head(ctx)
-	require.Equal(t, uint64(200), f.store.nodeByRoot[[32]byte{'b'}].weight)
-	require.Equal(t, uint64(300), f.store.nodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(200), f.store.emptyNodeByRoot[[32]byte{'b'}].weight)
+	require.Equal(t, uint64(300), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, head)
 
@@ -397,34 +452,34 @@ func TestStore_CommonAncestor(t *testing.T) {
 	//  \-- c -- f
 	//        \-- g
 	//        \ -- h -- i -- j
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'b'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, [32]byte{'d'}, [32]byte{'b'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 4, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 4, [32]byte{'e'}, [32]byte{'d'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 5, [32]byte{'f'}, [32]byte{'c'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 5, [32]byte{'f'}, [32]byte{'c'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 6, [32]byte{'g'}, [32]byte{'c'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 6, [32]byte{'g'}, [32]byte{'c'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 7, [32]byte{'h'}, [32]byte{'c'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 7, [32]byte{'h'}, [32]byte{'c'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 8, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 8, [32]byte{'i'}, [32]byte{'h'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 9, [32]byte{'j'}, [32]byte{'i'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 9, [32]byte{'j'}, [32]byte{'i'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
@@ -517,16 +572,16 @@ func TestStore_CommonAncestor(t *testing.T) {
 
 	// a -- b -- c -- d
 	f = setup(0, 0)
-	st, roblock, err = prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 1, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 2, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 3, [32]byte{'d'}, [32]byte{'c'}, [32]byte{}, 1, 1)
+	st, roblock, err = prepareForkchoiceState(ctx, f, 3, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 	tests = []struct {
@@ -583,16 +638,18 @@ func TestStore_CommonAncestor(t *testing.T) {
 	_, _, err = f.CommonAncestor(ctx, [32]byte{'z'}, [32]byte{'a'})
 	require.ErrorIs(t, err, forkchoice.ErrUnknownCommonAncestor)
 	n := &Node{
-		slot:                     100,
-		root:                     [32]byte{'y'},
-		justifiedEpoch:           1,
-		unrealizedJustifiedEpoch: 1,
-		finalizedEpoch:           1,
-		unrealizedFinalizedEpoch: 1,
-		optimistic:               true,
+		block: &BlockNode{
+			slot:                     100,
+			root:                     [32]byte{'y'},
+			justifiedEpoch:           1,
+			unrealizedJustifiedEpoch: 1,
+			finalizedEpoch:           1,
+			unrealizedFinalizedEpoch: 1,
+		},
+		optimistic: true,
 	}
 
-	f.store.nodeByRoot[[32]byte{'y'}] = n
+	f.store.emptyNodeByRoot[[32]byte{'y'}] = n
 	// broken link
 	_, _, err = f.CommonAncestor(ctx, [32]byte{'y'}, [32]byte{'a'})
 	require.ErrorIs(t, err, forkchoice.ErrUnknownCommonAncestor)
@@ -693,23 +750,23 @@ func TestForkChoice_UpdateCheckpoints(t *testing.T) {
 			fcs.store.finalizedCheckpoint = tt.finalized
 			fcs.store.genesisTime = uint64(time.Now().Unix()) - uint64(tt.currentSlot)*params.BeaconConfig().SecondsPerSlot
 
-			st, roblock, err := prepareForkchoiceState(ctx, 32, [32]byte{'f'},
+			st, roblock, err := prepareForkchoiceState(ctx, fcs, 32, [32]byte{'f'},
 				[32]byte{}, [32]byte{}, tt.finalized.Epoch, tt.finalized.Epoch)
 			require.NoError(t, err)
 			require.NoError(t, fcs.InsertNode(ctx, st, roblock))
-			st, roblock, err = prepareForkchoiceState(ctx, 64, [32]byte{'j'},
+			st, roblock, err = prepareForkchoiceState(ctx, fcs, 64, [32]byte{'j'},
 				[32]byte{'f'}, [32]byte{}, tt.justified.Epoch, tt.finalized.Epoch)
 			require.NoError(t, err)
 			require.NoError(t, fcs.InsertNode(ctx, st, roblock))
-			st, roblock, err = prepareForkchoiceState(ctx, 96, [32]byte{'b'},
+			st, roblock, err = prepareForkchoiceState(ctx, fcs, 96, [32]byte{'b'},
 				[32]byte{'j'}, [32]byte{}, tt.newJustified.Epoch, tt.newFinalized.Epoch)
 			require.NoError(t, err)
 			require.NoError(t, fcs.InsertNode(ctx, st, roblock))
-			st, roblock, err = prepareForkchoiceState(ctx, 96, [32]byte{'c'},
+			st, roblock, err = prepareForkchoiceState(ctx, fcs, 96, [32]byte{'c'},
 				[32]byte{'f'}, [32]byte{}, tt.newJustified.Epoch, tt.newFinalized.Epoch)
 			require.NoError(t, err)
 			require.NoError(t, fcs.InsertNode(ctx, st, roblock))
-			st, roblock, err = prepareForkchoiceState(ctx, 65, [32]byte{'h'},
+			st, roblock, err = prepareForkchoiceState(ctx, fcs, 65, [32]byte{'h'},
 				[32]byte{'f'}, [32]byte{}, tt.newFinalized.Epoch, tt.newFinalized.Epoch)
 			require.NoError(t, err)
 			require.NoError(t, fcs.InsertNode(ctx, st, roblock))
@@ -738,11 +795,11 @@ func TestWeight(t *testing.T) {
 	f := setup(0, 0)
 
 	root := [32]byte{'a'}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, root, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 0, root, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
-	n, ok := f.store.nodeByRoot[root]
+	n, ok := f.store.emptyNodeByRoot[root]
 	require.Equal(t, true, ok)
 	n.weight = 10
 	w, err := f.Weight(root)
@@ -770,7 +827,7 @@ func TestForkChoice_UnrealizedJustifiedPayloadBlockHash(t *testing.T) {
 	ctx := context.Background()
 	f := setup(0, 0)
 
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, roblock))
 
@@ -783,7 +840,7 @@ func TestForkChoiceIsViableForCheckpoint(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
 
-	st, blk, err := prepareForkchoiceState(ctx, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
+	st, blk, err := prepareForkchoiceState(ctx, f, 0, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	// No Node
 	viable, err := f.IsViableForCheckpoint(&forkchoicetypes.Checkpoint{Root: blk.Root()})
@@ -804,7 +861,7 @@ func TestForkChoiceIsViableForCheckpoint(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, viable)
 
-	st, blk2, err := prepareForkchoiceState(ctx, 1, [32]byte{'b'}, blk.Root(), [32]byte{'B'}, 0, 0)
+	st, blk2, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'b'}, blk.Root(), [32]byte{'B'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk2))
 
@@ -826,7 +883,7 @@ func TestForkChoiceIsViableForCheckpoint(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, viable)
 
-	st, blk3, err := prepareForkchoiceState(ctx, 2, [32]byte{'c'}, blk2.Root(), [32]byte{'C'}, 0, 0)
+	st, blk3, err := prepareForkchoiceState(ctx, f, 2, [32]byte{'c'}, blk2.Root(), [32]byte{'C'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk3))
 
@@ -839,7 +896,7 @@ func TestForkChoiceIsViableForCheckpoint(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, false, viable)
 
-	st, blk4, err := prepareForkchoiceState(ctx, params.BeaconConfig().SlotsPerEpoch, [32]byte{'d'}, blk2.Root(), [32]byte{'D'}, 0, 0)
+	st, blk4, err := prepareForkchoiceState(ctx, f, params.BeaconConfig().SlotsPerEpoch, [32]byte{'d'}, blk2.Root(), [32]byte{'D'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk4))
 
@@ -862,7 +919,7 @@ func TestForkChoiceIsViableForCheckpoint(t *testing.T) {
 	require.Equal(t, false, viable)
 
 	// Children in next epoch
-	st, blk5, err := prepareForkchoiceState(ctx, params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'e'}, blk2.Root(), [32]byte{'E'}, 0, 0)
+	st, blk5, err := prepareForkchoiceState(ctx, f, params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'e'}, blk2.Root(), [32]byte{'E'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk5))
 
@@ -874,7 +931,7 @@ func TestForkChoiceIsViableForCheckpoint(t *testing.T) {
 func TestForkChoiceSlot(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	st, blk, err := prepareForkchoiceState(ctx, 3, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
+	st, blk, err := prepareForkchoiceState(ctx, f, 3, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	// No Node
 	_, err = f.Slot(blk.Root())
@@ -890,12 +947,12 @@ func TestForkchoiceParentRoot(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
 	root1 := [32]byte{'a'}
-	st, blk, err := prepareForkchoiceState(ctx, 3, root1, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
+	st, blk, err := prepareForkchoiceState(ctx, f, 3, root1, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 
 	root2 := [32]byte{'b'}
-	st, blk, err = prepareForkchoiceState(ctx, 3, root2, root1, [32]byte{'A'}, 0, 0)
+	st, blk, err = prepareForkchoiceState(ctx, f, 3, root2, root1, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 
@@ -915,7 +972,7 @@ func TestForkchoiceParentRoot(t *testing.T) {
 func TestForkChoice_CleanupInserting(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	st, roblock, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 2, 2)
+	st, roblock, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 2, 2)
 	f.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) {
 		return f.justifiedBalances, errors.New("mock err")
 	})

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

@@ -8,19 +8,19 @@ import (
 // LastRoot returns the last canonical block root in the given epoch
 func (f *ForkChoice) LastRoot(epoch primitives.Epoch) [32]byte {
 	head := f.store.headNode
-	headEpoch := slots.ToEpoch(head.slot)
+	headEpoch := slots.ToEpoch(head.block.slot)
 	epochEnd, err := slots.EpochEnd(epoch)
 	if err != nil {
 		return [32]byte{}
 	}
 	if headEpoch <= epoch {
-		return head.root
+		return head.block.root
 	}
-	for head != nil && head.slot > epochEnd {
-		head = head.parent
+	for head != nil && head.block.slot > epochEnd {
+		head = head.block.parent
 	}
 	if head == nil {
 		return [32]byte{}
 	}
-	return head.root
+	return head.block.root
 }

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

@@ -12,27 +12,27 @@ func TestLastRoot(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
 
-	st, root, err := prepareForkchoiceState(ctx, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
+	st, root, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'1'}, params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 2, [32]byte{'2'}, [32]byte{'1'}, [32]byte{'2'}, 0, 0)
+	st, root, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'2'}, [32]byte{'1'}, [32]byte{'2'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 3, [32]byte{'3'}, [32]byte{'1'}, [32]byte{'3'}, 0, 0)
+	st, root, err = prepareForkchoiceState(ctx, f, 3, [32]byte{'3'}, [32]byte{'1'}, [32]byte{'3'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 32, [32]byte{'4'}, [32]byte{'3'}, [32]byte{'4'}, 0, 0)
+	st, root, err = prepareForkchoiceState(ctx, f, 32, [32]byte{'4'}, [32]byte{'3'}, [32]byte{'4'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 33, [32]byte{'5'}, [32]byte{'2'}, [32]byte{'5'}, 0, 0)
+	st, root, err = prepareForkchoiceState(ctx, f, 33, [32]byte{'5'}, [32]byte{'2'}, [32]byte{'5'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
-	st, root, err = prepareForkchoiceState(ctx, 34, [32]byte{'6'}, [32]byte{'5'}, [32]byte{'6'}, 0, 0)
+	st, root, err = prepareForkchoiceState(ctx, f, 34, [32]byte{'6'}, [32]byte{'5'}, [32]byte{'6'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, root))
-	headNode, _ := f.store.nodeByRoot[[32]byte{'6'}]
+	headNode, _ := f.store.emptyNodeByRoot[[32]byte{'6'}]
 	f.store.headNode = headNode
-	require.Equal(t, [32]byte{'6'}, f.store.headNode.root)
+	require.Equal(t, [32]byte{'6'}, f.store.headNode.block.root)
 	require.Equal(t, [32]byte{'2'}, f.LastRoot(0))
 	require.Equal(t, [32]byte{'6'}, f.LastRoot(1))
 	require.Equal(t, [32]byte{'6'}, f.LastRoot(2))

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

@@ -18,7 +18,13 @@ var (
 	nodeCount = promauto.NewGauge(
 		prometheus.GaugeOpts{
 			Name: "doublylinkedtree_node_count",
-			Help: "The number of nodes in the doubly linked tree based store structure.",
+			Help: "The number of nodes for blocks in the doubly linked tree based store structure.",
+		},
+	)
+	payloadCount = promauto.NewGauge(
+		prometheus.GaugeOpts{
+			Name: "doublylinkedtree_payload_count",
+			Help: "The number of nodes for execution payloads in the doubly linked tree based store structure.",
 		},
 	)
 	headChangesCount = promauto.NewCounter(
@@ -39,6 +45,12 @@ var (
 			Help: "The number of times a block is processed for fork choice.",
 		},
 	)
+	processedPayloadCount = promauto.NewCounter(
+		prometheus.CounterOpts{
+			Name: "doublylinkedtree_payload_processed_count",
+			Help: "The number of times an execution payload is processed for fork choice.",
+		},
+	)
 	processedAttestationCount = promauto.NewCounter(
 		prometheus.CounterOpts{
 			Name: "doublylinkedtree_attestation_processed_count",

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

@@ -25,7 +25,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//         0
 	//        /
 	//       2 <- head
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 0, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), f, 0, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background())
@@ -36,7 +36,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//            0
 	//           / \
 	//  head -> 2  1
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 0, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background())
@@ -49,7 +49,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//  head -> 2  1
 	//             |
 	//             3
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 0, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background())
@@ -62,7 +62,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//          2  1
 	//          |  |
 	//  head -> 4  3
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 0, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background())
@@ -77,7 +77,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//  head -> 4  3
 	//          |
 	//          5 <- justified epoch = 2
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 1)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 0, indexToHash(5), indexToHash(4), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background())
@@ -94,7 +94,7 @@ func TestNoVote_CanFindHead(t *testing.T) {
 	//          5
 	//          |
 	//          6 <- head
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 0, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 2, 1)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 0, indexToHash(6), indexToHash(5), params.BeaconConfig().ZeroHash, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	r, err = f.Head(context.Background())

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

@@ -28,14 +28,37 @@ func (n *Node) applyWeightChanges(ctx context.Context) error {
 			return err
 		}
 		childrenWeight += child.weight
+		if child.full {
+			childrenWeight -= child.block.balance
+		}
 	}
-	if n.root == params.BeaconConfig().ZeroHash {
+	if n.block.root == params.BeaconConfig().ZeroHash {
 		return nil
 	}
-	n.weight = n.balance + childrenWeight
+	n.weight = n.block.balance + childrenWeight
 	return nil
 }
 
+func compareChildren(child, bestChild *Node) *Node {
+	// If both are viable, compare their weights.
+	if child.weight == bestChild.weight {
+		// tie breaker of equal weights for full blocks
+		if child.full != bestChild.full {
+			if child.full {
+				return child
+			}
+		} else {
+			// Tie-breaker of equal weights by root.
+			if bytes.Compare(child.block.root[:], bestChild.block.root[:]) > 0 {
+				return child
+			}
+		}
+	} else if child.weight > bestChild.weight {
+		return child
+	}
+	return bestChild
+}
+
 // updateBestDescendant updates the best descendant of this node and its
 // children.
 func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finalizedEpoch, currentEpoch primitives.Epoch) error {
@@ -48,7 +71,6 @@ func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finaliz
 	}
 
 	var bestChild *Node
-	bestWeight := uint64(0)
 	hasViableDescendant := false
 	for _, child := range n.children {
 		if child == nil {
@@ -61,20 +83,10 @@ func (n *Node) updateBestDescendant(ctx context.Context, justifiedEpoch, finaliz
 		if childLeadsToViableHead && !hasViableDescendant {
 			// The child leads to a viable head, but the current
 			// parent's best child doesn't.
-			bestWeight = child.weight
 			bestChild = child
 			hasViableDescendant = true
 		} else if childLeadsToViableHead {
-			// If both are viable, compare their weights.
-			if child.weight == bestWeight {
-				// Tie-breaker of equal weights by root.
-				if bytes.Compare(child.root[:], bestChild.root[:]) > 0 {
-					bestChild = child
-				}
-			} else if child.weight > bestWeight {
-				bestChild = child
-				bestWeight = child.weight
-			}
+			bestChild = compareChildren(child, bestChild)
 		}
 	}
 	if hasViableDescendant {
@@ -99,7 +111,7 @@ func (n *Node) viableForHead(justifiedEpoch, currentEpoch primitives.Epoch) bool
 	// We use n.justifiedEpoch as the voting source because:
 	//   1. if this node is from current epoch, n.justifiedEpoch is the realized justification epoch.
 	//   2. if this node is from a previous epoch, n.justifiedEpoch has already been updated to the unrealized justification epoch.
-	return n.justifiedEpoch == justifiedEpoch || n.justifiedEpoch+2 >= currentEpoch
+	return n.block.justifiedEpoch == justifiedEpoch || n.block.justifiedEpoch+2 >= currentEpoch
 }
 
 func (n *Node) leadsToViableHead(justifiedEpoch, currentEpoch primitives.Epoch) bool {
@@ -120,10 +132,10 @@ func (n *Node) setNodeAndParentValidated(ctx context.Context) error {
 	}
 	n.optimistic = false
 
-	if n.parent == nil {
+	if n.block.parent == nil {
 		return nil
 	}
-	return n.parent.setNodeAndParentValidated(ctx)
+	return n.block.parent.setNodeAndParentValidated(ctx)
 }
 
 // arrivedEarly returns whether this node was inserted before the first
@@ -131,7 +143,7 @@ func (n *Node) setNodeAndParentValidated(ctx context.Context) error {
 // Note that genesisTime has seconds granularity, therefore we use a strict
 // inequality < here. For example a block that arrives 3.9999 seconds into the
 // slot will have secs = 3 below.
-func (n *Node) arrivedEarly(genesisTime uint64) (bool, error) {
+func (n *BlockNode) arrivedEarly(genesisTime uint64) (bool, error) {
 	secs, err := slots.SecondsSinceSlotStart(n.slot, genesisTime, n.timestamp)
 	votingWindow := params.BeaconConfig().SecondsPerSlot / params.BeaconConfig().IntervalsPerSlot
 	return secs < votingWindow, err
@@ -142,7 +154,7 @@ func (n *Node) arrivedEarly(genesisTime uint64) (bool, error) {
 // Note that genesisTime has seconds granularity, therefore we use an
 // inequality >= here. For example a block that arrives 10.00001 seconds into the
 // slot will have secs = 10 below.
-func (n *Node) arrivedAfterOrphanCheck(genesisTime uint64) (bool, error) {
+func (n *BlockNode) arrivedAfterOrphanCheck(genesisTime uint64) (bool, error) {
 	secs, err := slots.SecondsSinceSlotStart(n.slot, genesisTime, n.timestamp)
 	return secs >= ProcessAttestationsThreshold, err
 }
@@ -153,22 +165,22 @@ func (n *Node) nodeTreeDump(ctx context.Context, nodes []*forkchoice2.Node) ([]*
 		return nil, ctx.Err()
 	}
 	var parentRoot [32]byte
-	if n.parent != nil {
-		parentRoot = n.parent.root
+	if n.block.parent != nil {
+		parentRoot = n.block.parent.block.root
 	}
 	thisNode := &forkchoice2.Node{
-		Slot:                     n.slot,
-		BlockRoot:                n.root[:],
+		Slot:                     n.block.slot,
+		BlockRoot:                n.block.root[:],
 		ParentRoot:               parentRoot[:],
-		JustifiedEpoch:           n.justifiedEpoch,
-		FinalizedEpoch:           n.finalizedEpoch,
-		UnrealizedJustifiedEpoch: n.unrealizedJustifiedEpoch,
-		UnrealizedFinalizedEpoch: n.unrealizedFinalizedEpoch,
-		Balance:                  n.balance,
+		JustifiedEpoch:           n.block.justifiedEpoch,
+		FinalizedEpoch:           n.block.finalizedEpoch,
+		UnrealizedJustifiedEpoch: n.block.unrealizedJustifiedEpoch,
+		UnrealizedFinalizedEpoch: n.block.unrealizedFinalizedEpoch,
+		Balance:                  n.block.balance,
 		Weight:                   n.weight,
 		ExecutionOptimistic:      n.optimistic,
-		ExecutionBlockHash:       n.payloadHash[:],
-		Timestamp:                n.timestamp,
+		ExecutionBlockHash:       n.block.payloadHash[:],
+		Timestamp:                n.block.timestamp,
 	}
 	if n.optimistic {
 		thisNode.Validity = forkchoice2.Optimistic

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

@@ -14,80 +14,65 @@ import (
 func TestNode_ApplyWeightChanges_PositiveChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	// The updated balances of each node is 100
 	s := f.store
 
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].block.balance = 100
 
 	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
 
-	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
+	assert.Equal(t, uint64(300), s.emptyNodeByRoot[indexToHash(1)].weight)
+	assert.Equal(t, uint64(200), s.emptyNodeByRoot[indexToHash(2)].weight)
+	assert.Equal(t, uint64(100), s.emptyNodeByRoot[indexToHash(3)].weight)
 }
 
 func TestNode_ApplyWeightChanges_NegativeChange(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	// The updated balances of each node is 100
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 400
-	s.nodeByRoot[indexToHash(2)].weight = 400
-	s.nodeByRoot[indexToHash(3)].weight = 400
+	s.emptyNodeByRoot[indexToHash(1)].weight = 400
+	s.emptyNodeByRoot[indexToHash(2)].weight = 400
+	s.emptyNodeByRoot[indexToHash(3)].weight = 400
 
-	s.nodeByRoot[indexToHash(1)].balance = 100
-	s.nodeByRoot[indexToHash(2)].balance = 100
-	s.nodeByRoot[indexToHash(3)].balance = 100
+	s.emptyNodeByRoot[indexToHash(1)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(2)].block.balance = 100
+	s.emptyNodeByRoot[indexToHash(3)].block.balance = 100
 
 	assert.NoError(t, s.treeRootNode.applyWeightChanges(ctx))
 
-	assert.Equal(t, uint64(300), s.nodeByRoot[indexToHash(1)].weight)
-	assert.Equal(t, uint64(200), s.nodeByRoot[indexToHash(2)].weight)
-	assert.Equal(t, uint64(100), s.nodeByRoot[indexToHash(3)].weight)
-}
-
-func TestNode_UpdateBestDescendant_NonViableChild(t *testing.T) {
-	f := setup(1, 1)
-	ctx := context.Background()
-	// Input child is not viable.
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 2, 3)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, state, blk))
-
-	// Verify parent's best child and best descendant are `none`.
-	s := f.store
-	assert.Equal(t, 1, len(s.treeRootNode.children))
-	nilBestDescendant := s.treeRootNode.bestDescendant == nil
-	assert.Equal(t, true, nilBestDescendant)
+	assert.Equal(t, uint64(300), s.emptyNodeByRoot[indexToHash(1)].weight)
+	assert.Equal(t, uint64(200), s.emptyNodeByRoot[indexToHash(2)].weight)
+	assert.Equal(t, uint64(100), s.emptyNodeByRoot[indexToHash(3)].weight)
 }
 
 func TestNode_UpdateBestDescendant_ViableChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is the best descendant
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
@@ -100,16 +85,16 @@ func TestNode_UpdateBestDescendant_HigherWeightChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is the best descendant
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 100
-	s.nodeByRoot[indexToHash(2)].weight = 200
+	s.emptyNodeByRoot[indexToHash(1)].weight = 100
+	s.emptyNodeByRoot[indexToHash(2)].weight = 200
 	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
 
 	assert.Equal(t, 2, len(s.treeRootNode.children))
@@ -120,16 +105,16 @@ func TestNode_UpdateBestDescendant_LowerWeightChild(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
 	// Input child is the best descendant
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	s := f.store
-	s.nodeByRoot[indexToHash(1)].weight = 200
-	s.nodeByRoot[indexToHash(2)].weight = 100
+	s.emptyNodeByRoot[indexToHash(1)].weight = 200
+	s.emptyNodeByRoot[indexToHash(2)].weight = 100
 	assert.NoError(t, s.treeRootNode.updateBestDescendant(ctx, 1, 1, 1))
 
 	assert.Equal(t, 2, len(s.treeRootNode.children))
@@ -142,13 +127,13 @@ func TestNode_ViableForHead(t *testing.T) {
 		justifiedEpoch primitives.Epoch
 		want           bool
 	}{
-		{&Node{}, 0, true},
-		{&Node{}, 1, false},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 1}, 1, true},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 1}, 2, false},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 2}, 3, false},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 2}, 4, false},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 3}, 4, true},
+		{&Node{block: &BlockNode{}}, 0, true},
+		{&Node{block: &BlockNode{}}, 1, false},
+		{&Node{block: &BlockNode{finalizedEpoch: 1, justifiedEpoch: 1}}, 1, true},
+		{&Node{block: &BlockNode{finalizedEpoch: 1, justifiedEpoch: 1}}, 2, false},
+		{&Node{block: &BlockNode{finalizedEpoch: 1, justifiedEpoch: 2}}, 3, false},
+		{&Node{block: &BlockNode{finalizedEpoch: 1, justifiedEpoch: 2}}, 4, false},
+		{&Node{block: &BlockNode{finalizedEpoch: 1, justifiedEpoch: 3}}, 4, true},
 	}
 	for _, tc := range tests {
 		got := tc.n.viableForHead(tc.justifiedEpoch, 5)
@@ -159,26 +144,26 @@ func TestNode_ViableForHead(t *testing.T) {
 func TestNode_LeadsToViableHead(t *testing.T) {
 	f := setup(4, 3)
 	ctx := context.Background()
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	state, blk, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 4, 3)
+	state, blk, err = prepareForkchoiceState(ctx, f, 5, indexToHash(5), indexToHash(3), params.BeaconConfig().ZeroHash, 4, 3)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 
 	require.Equal(t, true, f.store.treeRootNode.leadsToViableHead(4, 5))
-	require.Equal(t, true, f.store.nodeByRoot[indexToHash(5)].leadsToViableHead(4, 5))
-	require.Equal(t, false, f.store.nodeByRoot[indexToHash(2)].leadsToViableHead(4, 5))
-	require.Equal(t, false, f.store.nodeByRoot[indexToHash(4)].leadsToViableHead(4, 5))
+	require.Equal(t, true, f.store.emptyNodeByRoot[indexToHash(5)].leadsToViableHead(4, 5))
+	require.Equal(t, false, f.store.emptyNodeByRoot[indexToHash(2)].leadsToViableHead(4, 5))
+	require.Equal(t, false, f.store.emptyNodeByRoot[indexToHash(4)].leadsToViableHead(4, 5))
 }
 
 func TestNode_SetFullyValidated(t *testing.T) {
@@ -192,29 +177,28 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	//               \
 	//                 -- 5 (true)
 	//
-	state, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[1] = f.store.nodeByRoot[blk.Root()]
+	storeNodes[1] = f.store.emptyNodeByRoot[blk.Root()]
 	require.NoError(t, f.SetOptimisticToValid(ctx, params.BeaconConfig().ZeroHash))
-	state, blk, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[2] = f.store.nodeByRoot[blk.Root()]
+	storeNodes[2] = f.store.emptyNodeByRoot[blk.Root()]
 	require.NoError(t, f.SetOptimisticToValid(ctx, indexToHash(1)))
-	state, blk, err = prepareForkchoiceState(ctx, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 3, indexToHash(3), indexToHash(2), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[3] = f.store.nodeByRoot[blk.Root()]
-	state, blk, err = prepareForkchoiceState(ctx, 4, indexToHash(4), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1)
+	storeNodes[3] = f.store.emptyNodeByRoot[blk.Root()]
+	state, blk, err = prepareForkchoiceState(ctx, f, 4, indexToHash(4), indexToHash(3), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[4] = f.store.nodeByRoot[blk.Root()]
-	state, blk, err = prepareForkchoiceState(ctx, 5, indexToHash(5), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	storeNodes[4] = f.store.emptyNodeByRoot[blk.Root()]
+	state, blk, err = prepareForkchoiceState(ctx, f, 5, indexToHash(5), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
-	storeNodes[5] = f.store.nodeByRoot[blk.Root()]
-
+	storeNodes[5] = f.store.emptyNodeByRoot[blk.Root()]
 	opt, err := f.IsOptimistic(indexToHash(5))
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
@@ -223,7 +207,7 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, opt)
 
-	require.NoError(t, f.store.nodeByRoot[indexToHash(4)].setNodeAndParentValidated(ctx))
+	require.NoError(t, f.store.emptyNodeByRoot[indexToHash(4)].setNodeAndParentValidated(ctx))
 
 	// block 5 should still be optimistic
 	opt, err = f.IsOptimistic(indexToHash(5))
@@ -245,16 +229,16 @@ func TestNode_SetFullyValidated(t *testing.T) {
 	require.Equal(t, len(respNodes), f.NodeCount())
 
 	for i, respNode := range respNodes {
-		require.Equal(t, storeNodes[i].slot, respNode.Slot)
-		require.DeepEqual(t, storeNodes[i].root[:], respNode.BlockRoot)
-		require.Equal(t, storeNodes[i].balance, respNode.Balance)
+		require.Equal(t, storeNodes[i].block.slot, respNode.Slot)
+		require.DeepEqual(t, storeNodes[i].block.root[:], respNode.BlockRoot)
+		require.Equal(t, storeNodes[i].block.balance, respNode.Balance)
 		require.Equal(t, storeNodes[i].weight, respNode.Weight)
 		require.Equal(t, storeNodes[i].optimistic, respNode.ExecutionOptimistic)
-		require.Equal(t, storeNodes[i].justifiedEpoch, respNode.JustifiedEpoch)
-		require.Equal(t, storeNodes[i].unrealizedJustifiedEpoch, respNode.UnrealizedJustifiedEpoch)
-		require.Equal(t, storeNodes[i].finalizedEpoch, respNode.FinalizedEpoch)
-		require.Equal(t, storeNodes[i].unrealizedFinalizedEpoch, respNode.UnrealizedFinalizedEpoch)
-		require.Equal(t, storeNodes[i].timestamp, respNode.Timestamp)
+		require.Equal(t, storeNodes[i].block.justifiedEpoch, respNode.JustifiedEpoch)
+		require.Equal(t, storeNodes[i].block.unrealizedJustifiedEpoch, respNode.UnrealizedJustifiedEpoch)
+		require.Equal(t, storeNodes[i].block.finalizedEpoch, respNode.FinalizedEpoch)
+		require.Equal(t, storeNodes[i].block.unrealizedFinalizedEpoch, respNode.UnrealizedFinalizedEpoch)
+		require.Equal(t, storeNodes[i].block.timestamp, respNode.Timestamp)
 	}
 }
 
@@ -266,16 +250,16 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	driftGenesisTime(f, 1, 1)
 	root := [32]byte{'a'}
 	f.justifiedBalances = []uint64{10}
-	state, blk, err := prepareForkchoiceState(ctx, 1, root, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
+	state, blk, err := prepareForkchoiceState(ctx, f, 1, root, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 	headRoot, err := f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err := f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err := f.store.headNode.block.arrivedEarly(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, true, early)
-	late, err := f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err := f.store.headNode.block.arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, late)
 
@@ -283,47 +267,47 @@ func TestNode_TimeStampsChecks(t *testing.T) {
 	// late block
 	driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+1)
 	root = [32]byte{'b'}
-	state, blk, err = prepareForkchoiceState(ctx, 2, root, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
+	state, blk, err = prepareForkchoiceState(ctx, f, 2, root, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err = f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err = f.store.headNode.block.arrivedEarly(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, early)
-	late, err = f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err = f.store.headNode.block.arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, late)
 
 	// very late block
 	driftGenesisTime(f, 3, ProcessAttestationsThreshold+1)
 	root = [32]byte{'c'}
-	state, blk, err = prepareForkchoiceState(ctx, 3, root, [32]byte{'b'}, [32]byte{'C'}, 0, 0)
+	state, blk, err = prepareForkchoiceState(ctx, f, 3, root, [32]byte{'b'}, [32]byte{'C'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err = f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err = f.store.headNode.block.arrivedEarly(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, false, early)
-	late, err = f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err = f.store.headNode.block.arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.NoError(t, err)
 	require.Equal(t, true, late)
 
 	// block from the future
 	root = [32]byte{'d'}
-	state, blk, err = prepareForkchoiceState(ctx, 5, root, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
+	state, blk, err = prepareForkchoiceState(ctx, f, 5, root, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, root, headRoot)
-	early, err = f.store.headNode.arrivedEarly(f.store.genesisTime)
+	early, err = f.store.headNode.block.arrivedEarly(f.store.genesisTime)
 	require.ErrorContains(t, "invalid timestamp", err)
 	require.Equal(t, true, early)
-	late, err = f.store.headNode.arrivedAfterOrphanCheck(f.store.genesisTime)
+	late, err = f.store.headNode.block.arrivedAfterOrphanCheck(f.store.genesisTime)
 	require.ErrorContains(t, "invalid timestamp", err)
 	require.Equal(t, false, late)
 }

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

@@ -59,19 +59,19 @@ func TestStore_NewSlot(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			f := setup(test.args.justified.Epoch, test.args.finalized.Epoch)
-			state, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, [32]byte{}, 0, 0)
+			state, blkRoot, err := prepareForkchoiceState(ctx, f, 0, [32]byte{}, [32]byte{}, [32]byte{}, 0, 0)
 			require.NoError(t, err)
 			require.NoError(t, f.InsertNode(ctx, state, blkRoot)) // genesis
-			state, blkRoot, err = prepareForkchoiceState(ctx, 32, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0)
+			state, blkRoot, err = prepareForkchoiceState(ctx, f, 32, [32]byte{'a'}, [32]byte{}, [32]byte{}, 0, 0)
 			require.NoError(t, err)
 			require.NoError(t, f.InsertNode(ctx, state, blkRoot)) // finalized
-			state, blkRoot, err = prepareForkchoiceState(ctx, 64, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0)
+			state, blkRoot, err = prepareForkchoiceState(ctx, f, 64, [32]byte{'b'}, [32]byte{'a'}, [32]byte{}, 0, 0)
 			require.NoError(t, err)
 			require.NoError(t, f.InsertNode(ctx, state, blkRoot)) // justified
-			state, blkRoot, err = prepareForkchoiceState(ctx, 96, bj, [32]byte{'a'}, [32]byte{}, 0, 0)
+			state, blkRoot, err = prepareForkchoiceState(ctx, f, 96, bj, [32]byte{'a'}, [32]byte{}, 0, 0)
 			require.NoError(t, err)
 			require.NoError(t, f.InsertNode(ctx, state, blkRoot)) // best justified
-			state, blkRoot, err = prepareForkchoiceState(ctx, 97, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0)
+			state, blkRoot, err = prepareForkchoiceState(ctx, f, 97, [32]byte{'d'}, [32]byte{}, [32]byte{}, 0, 0)
 			require.NoError(t, err)
 			require.NoError(t, f.InsertNode(ctx, state, blkRoot)) // bad
 

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

@@ -7,42 +7,79 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 )
 
+func (s *Store) removeNodeIfSynced(ctx context.Context, node *Node) ([][32]byte, error) {
+	invalidRoots := make([][32]byte, 0)
+	if node == nil {
+		return invalidRoots, nil
+	}
+	fullNode := s.fullNodeByPayload[node.block.payloadHash]
+	if fullNode == nil {
+		return invalidRoots, nil
+	}
+	return s.removeNode(ctx, fullNode)
+}
+
 func (s *Store) setOptimisticToInvalid(ctx context.Context, root, parentRoot, lastValidHash [32]byte) ([][32]byte, error) {
 	invalidRoots := make([][32]byte, 0)
-	node, ok := s.nodeByRoot[root]
-	if !ok {
-		node, ok = s.nodeByRoot[parentRoot]
-		if !ok || node == nil {
-			return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid")
+	node, ok := s.emptyNodeByRoot[root]
+	// Check if we have a full node for this root
+	if ok {
+		fullNode, ok := s.fullNodeByPayload[node.block.payloadHash]
+		if ok {
+			node = fullNode
 		}
-		// return early if the parent is LVH
-		if node.payloadHash == lastValidHash {
-			return invalidRoots, nil
-		}
-	} else {
-		if node == nil {
-			return invalidRoots, errors.Wrap(ErrNilNode, "could not set node to invalid")
-		}
-		if node.parent.root != parentRoot {
+		// check consistency of the input
+		parent := node.block.parent
+		if parent.block.root != parentRoot {
 			return invalidRoots, errInvalidParentRoot
 		}
 	}
-	firstInvalid := node
-	for ; firstInvalid.parent != nil && firstInvalid.parent.payloadHash != lastValidHash; firstInvalid = firstInvalid.parent {
-		if ctx.Err() != nil {
-			return invalidRoots, ctx.Err()
+	// if the last valid hash is not known or null, prune only the incoming
+	// block.
+	lastValid, ok := s.fullNodeByPayload[lastValidHash]
+	if !ok || lastValidHash == [32]byte{} {
+		return s.removeNodeIfSynced(ctx, node)
+	}
+	// We have a valid hash, find if it's in the same fork as the last valid
+	// root.
+	ancestor, err := s.ancestorRoot(ctx, parentRoot, lastValid.block.slot)
+	if err != nil {
+		return invalidRoots, errors.Wrap(err, "could not set block as invalid")
+	}
+	if ancestor != lastValid.block.root {
+		return s.removeNodeIfSynced(ctx, node)
+	}
+	// we go up we find a child of the last valid that is full. We find
+	// first the starting node for the loop
+	if node == nil {
+		node = s.emptyNodeByRoot[parentRoot]
+		fullParent, ok := s.fullNodeByPayload[node.block.payloadHash]
+		if ok {
+			// return early if the parent is the LVH
+			if fullParent.block.payloadHash == lastValidHash {
+				return invalidRoots, nil
+			}
+			node = fullParent
+		}
+	} else {
+		fullNode, ok := s.fullNodeByPayload[node.block.payloadHash]
+		if ok {
+			node = fullNode
 		}
 	}
-	// Deal with the case that the last valid payload is in a different fork
-	// This means we are dealing with an EE that does not follow the spec
-	if firstInvalid.parent == nil {
-		// return early if the invalid node was not imported
-		if node.root == parentRoot {
-			return invalidRoots, nil
+	var lastFullNode *Node
+	for ; node.block.fullParent != nil; node = node.block.fullParent {
+		if node.full {
+			lastFullNode = node
+		}
+		if node.block.fullParent.block.payloadHash == lastValidHash {
+			break
 		}
-		firstInvalid = node
 	}
-	return s.removeNode(ctx, firstInvalid)
+	if lastFullNode == nil {
+		return invalidRoots, nil
+	}
+	return s.removeNode(ctx, lastFullNode)
 }
 
 // removeNode removes the node with the given root and all of its children
@@ -53,20 +90,20 @@ func (s *Store) removeNode(ctx context.Context, node *Node) ([][32]byte, error)
 	if node == nil {
 		return invalidRoots, errors.Wrap(ErrNilNode, "could not remove node")
 	}
-	if !node.optimistic || node.parent == nil {
+	if !node.optimistic || node.block.parent == nil {
 		return invalidRoots, errInvalidOptimisticStatus
 	}
 
-	children := node.parent.children
+	children := node.block.parent.children
 	if len(children) == 1 {
-		node.parent.children = []*Node{}
+		node.block.parent.children = []*Node{}
 	} else {
 		for i, n := range children {
 			if n == node {
 				if i != len(children)-1 {
 					children[i] = children[len(children)-1]
 				}
-				node.parent.children = children[:len(children)-1]
+				node.block.parent.children = children[:len(children)-1]
 				break
 			}
 		}
@@ -85,15 +122,20 @@ func (s *Store) removeNodeAndChildren(ctx context.Context, node *Node, invalidRo
 			return invalidRoots, err
 		}
 	}
-	invalidRoots = append(invalidRoots, node.root)
-	if node.root == s.proposerBoostRoot {
+	// Only remove the current node's root when removing the empty node as well
+	if node.full {
+		delete(s.fullNodeByPayload, node.block.payloadHash)
+		return invalidRoots, nil
+	}
+
+	invalidRoots = append(invalidRoots, node.block.root)
+	if node.block.root == s.proposerBoostRoot {
 		s.proposerBoostRoot = [32]byte{}
 	}
-	if node.root == s.previousProposerBoostRoot {
+	if node.block.root == s.previousProposerBoostRoot {
 		s.previousProposerBoostRoot = params.BeaconConfig().ZeroHash
 		s.previousProposerBoostScore = 0
 	}
-	delete(s.nodeByRoot, node.root)
-	delete(s.nodeByPayload, node.payloadHash)
+	delete(s.emptyNodeByRoot, node.block.root)
 	return invalidRoots, nil
 }

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

@@ -6,10 +6,31 @@ import (
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
+func sortRoots(roots [][32]uint8) {
+	sort.Slice(roots, func(i, j int) bool {
+		return roots[i][0] < roots[j][0]
+	})
+}
+
+func deduplicateRoots(roots [][32]uint8) [][32]uint8 {
+	if len(roots) == 0 {
+		return roots
+	}
+	unique := make(map[[32]uint8]struct{})
+	var result [][32]uint8
+
+	for _, root := range roots {
+		if _, exists := unique[root]; !exists {
+			unique[root] = struct{}{}
+			result = append(result, root)
+		}
+	}
+	return result
+}
+
 // We test the algorithm to update a node from SYNCING to INVALID
 // We start with the same diagram as above:
 //
@@ -175,47 +196,50 @@ func TestPruneInvalid(t *testing.T) {
 		ctx := context.Background()
 		f := setup(1, 1)
 
-		state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+		state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{'J'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'j'}, [32]byte{'b'}, [32]byte{'J'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{'E'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{'E'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{'G'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 104, [32]byte{'g'}, [32]byte{'d'}, [32]byte{'G'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{'K'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'k'}, [32]byte{'g'}, [32]byte{'K'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{'I'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 106, [32]byte{'i'}, [32]byte{'h'}, [32]byte{'I'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'L'}, 1, 1)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, 106, [32]byte{'l'}, [32]byte{'k'}, [32]byte{'L'}, 1, 1)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		roots, err := f.store.setOptimisticToInvalid(context.Background(), tc.root, tc.parentRoot, tc.payload)
+		deduped := deduplicateRoots(roots)
 		if tc.wantedErr == nil {
 			require.NoError(t, err)
-			require.DeepEqual(t, tc.wantedRoots, roots)
+			sortRoots(tc.wantedRoots)
+			sortRoots(deduped)
+			require.DeepEqual(t, tc.wantedRoots, deduped)
 			require.Equal(t, tc.wantedNodeNumber, f.NodeCount())
 		} else {
 			require.ErrorIs(t, tc.wantedErr, err)
@@ -228,13 +252,13 @@ func TestSetOptimisticToInvalid_ProposerBoost(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	f.store.proposerBoostRoot = [32]byte{'c'}
@@ -243,7 +267,7 @@ func TestSetOptimisticToInvalid_ProposerBoost(t *testing.T) {
 
 	_, err = f.SetOptimisticToInvalid(ctx, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'A'})
 	require.NoError(t, err)
-	require.Equal(t, uint64(0), f.store.previousProposerBoostScore)
+	require.Equal(t, uint64(10), f.store.previousProposerBoostScore)
 	require.DeepEqual(t, [32]byte{}, f.store.proposerBoostRoot)
 	require.DeepEqual(t, params.BeaconConfig().ZeroHash, f.store.previousProposerBoostRoot)
 }
@@ -260,131 +284,27 @@ func TestSetOptimisticToInvalid_CorrectChildren(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'c'}, [32]byte{'a'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'D'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 103, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'D'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	_, err = f.store.setOptimisticToInvalid(ctx, [32]byte{'d'}, [32]byte{'a'}, [32]byte{'A'})
 	require.NoError(t, err)
-	require.Equal(t, 2, len(f.store.nodeByRoot[[32]byte{'a'}].children))
+	// There are 5 valid children of A, two for B and C and one for D (the
+	// empty D block is valid)
+	require.Equal(t, 5, len(f.store.fullNodeByPayload[[32]byte{'A'}].children))
 
 }
 
-// Pow       |      Pos
-//
-//	CA -- A -- B -- C-----D
-//	 \          \--------------E
-//	  \
-//	   ----------------------F -- G
-//
-// B is INVALID
-func TestSetOptimisticToInvalid_ForkAtMerge(t *testing.T) {
-	ctx := context.Background()
-	f := setup(1, 1)
-
-	st, root, err := prepareForkchoiceState(ctx, 100, [32]byte{'r'}, [32]byte{}, [32]byte{}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 101, [32]byte{'a'}, [32]byte{'r'}, [32]byte{}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 102, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 103, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 104, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 105, [32]byte{'e'}, [32]byte{'b'}, [32]byte{'E'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 106, [32]byte{'f'}, [32]byte{'r'}, [32]byte{'F'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 107, [32]byte{'g'}, [32]byte{'f'}, [32]byte{'G'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	roots, err := f.SetOptimisticToInvalid(ctx, [32]byte{'x'}, [32]byte{'d'}, [32]byte{})
-	require.NoError(t, err)
-	require.Equal(t, 4, len(roots))
-	sort.Slice(roots, func(i, j int) bool {
-		return bytesutil.BytesToUint64BigEndian(roots[i][:]) < bytesutil.BytesToUint64BigEndian(roots[j][:])
-	})
-	require.DeepEqual(t, roots, [][32]byte{{'b'}, {'c'}, {'d'}, {'e'}})
-}
-
-// Pow       |      Pos
-//
-//	CA -------- B -- C-----D
-//	 \           \--------------E
-//	  \
-//	   --A -------------------------F -- G
-//
-// B is INVALID
-func TestSetOptimisticToInvalid_ForkAtMerge_bis(t *testing.T) {
-	ctx := context.Background()
-	f := setup(1, 1)
-
-	st, root, err := prepareForkchoiceState(ctx, 100, [32]byte{'r'}, [32]byte{}, [32]byte{}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 101, [32]byte{'a'}, [32]byte{'r'}, [32]byte{}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 102, [32]byte{'b'}, [32]byte{}, [32]byte{'B'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 103, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 104, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 105, [32]byte{'e'}, [32]byte{'b'}, [32]byte{'E'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 106, [32]byte{'f'}, [32]byte{'a'}, [32]byte{'F'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	st, root, err = prepareForkchoiceState(ctx, 107, [32]byte{'g'}, [32]byte{'f'}, [32]byte{'G'}, 1, 1)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, st, root))
-
-	roots, err := f.SetOptimisticToInvalid(ctx, [32]byte{'x'}, [32]byte{'d'}, [32]byte{})
-	require.NoError(t, err)
-	require.Equal(t, 4, len(roots))
-	sort.Slice(roots, func(i, j int) bool {
-		return bytesutil.BytesToUint64BigEndian(roots[i][:]) < bytesutil.BytesToUint64BigEndian(roots[j][:])
-	})
-	require.DeepEqual(t, roots, [][32]byte{{'b'}, {'c'}, {'d'}, {'e'}})
-}
-
 func TestSetOptimisticToValid(t *testing.T) {
 	f := setup(1, 1)
 	op, err := f.IsOptimistic([32]byte{})

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

@@ -13,21 +13,21 @@ func (f *ForkChoice) applyProposerBoostScore() error {
 	s := f.store
 	proposerScore := uint64(0)
 	if s.previousProposerBoostRoot != params.BeaconConfig().ZeroHash {
-		previousNode, ok := s.nodeByRoot[s.previousProposerBoostRoot]
+		previousNode, ok := s.emptyNodeByRoot[s.previousProposerBoostRoot]
 		if !ok || previousNode == nil {
 			log.WithError(errInvalidProposerBoostRoot).Errorf(fmt.Sprintf("invalid prev root %#x", s.previousProposerBoostRoot))
 		} else {
-			previousNode.balance -= s.previousProposerBoostScore
+			previousNode.block.balance -= s.previousProposerBoostScore
 		}
 	}
 
 	if s.proposerBoostRoot != params.BeaconConfig().ZeroHash {
-		currentNode, ok := s.nodeByRoot[s.proposerBoostRoot]
+		currentNode, ok := s.emptyNodeByRoot[s.proposerBoostRoot]
 		if !ok || currentNode == nil {
 			log.WithError(errInvalidProposerBoostRoot).Errorf(fmt.Sprintf("invalid current root %#x", s.proposerBoostRoot))
 		} else {
 			proposerScore = (s.committeeWeight * params.BeaconConfig().ProposerScoreBoost) / 100
-			currentNode.balance += proposerScore
+			currentNode.block.balance += proposerScore
 		}
 	}
 	s.previousProposerBoostRoot = s.proposerBoostRoot

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

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
 // Helper function to simulate the block being on time or delayed for proposer
@@ -52,6 +53,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err := prepareForkchoiceState(
 			ctx,
+			f,
 			slot,
 			newRoot,
 			headRoot,
@@ -61,7 +63,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fEpoch)
+		fSlot, err := slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, []uint64{0}, newRoot, fSlot)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 1")
@@ -78,6 +82,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			slot,
 			newRoot,
 			headRoot,
@@ -87,7 +92,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fEpoch)
+		fSlot, err = slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, []uint64{1}, newRoot, fSlot)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 2")
@@ -106,6 +113,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			slot,
 			newRoot,
 			headRoot,
@@ -115,7 +123,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fEpoch)
+		fSlot, err = slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, []uint64{2}, newRoot, fSlot)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
@@ -135,6 +145,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			slot,
 			newRoot,
 			indexToHash(2),
@@ -144,7 +155,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fEpoch)
+		fSlot, err = slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, []uint64{3}, newRoot, fSlot)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, newRoot, headRoot, "Incorrect head for justified epoch at slot 3")
@@ -163,18 +176,20 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// (1: 48) -> (2: 38) -> (3: 10)
 		//		    \--------------->(4: 18)
 		//
-		node1 := f.store.nodeByRoot[indexToHash(1)]
+		node1 := f.store.emptyNodeByRoot[indexToHash(1)]
 		require.Equal(t, node1.weight, uint64(48))
-		node2 := f.store.nodeByRoot[indexToHash(2)]
+		node2 := f.store.emptyNodeByRoot[indexToHash(2)]
 		require.Equal(t, node2.weight, uint64(38))
-		node3 := f.store.nodeByRoot[indexToHash(3)]
+		node3 := f.store.emptyNodeByRoot[indexToHash(3)]
 		require.Equal(t, node3.weight, uint64(10))
-		node4 := f.store.nodeByRoot[indexToHash(4)]
+		node4 := f.store.emptyNodeByRoot[indexToHash(4)]
 		require.Equal(t, node4.weight, uint64(18))
 
 		// Regression: process attestations for C, check that it
 		// becomes head, we need two attestations to have C.weight = 30 > 24 = D.weight
-		f.ProcessAttestation(ctx, []uint64{4, 5}, indexToHash(3), fEpoch)
+		fSlot, err = slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, []uint64{4, 5}, indexToHash(3), fSlot)
 		headRoot, err = f.Head(ctx)
 		require.NoError(t, err)
 		assert.Equal(t, indexToHash(3), headRoot, "Incorrect head for justified epoch at slot 4")
@@ -201,6 +216,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		honestBlock := indexToHash(2)
 		state, blkRoot, err := prepareForkchoiceState(
 			ctx,
+			f,
 			honestBlockSlot,
 			honestBlock,
 			zeroHash,
@@ -218,6 +234,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		maliciouslyWithheldBlock := indexToHash(1)
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			maliciouslyWithheldBlockSlot,
 			maliciouslyWithheldBlock,
 			zeroHash,
@@ -235,10 +252,14 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 
 		// The maliciously withheld block has one vote.
 		votes := []uint64{1}
-		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
+		fSlot, err := slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fSlot)
 		// The honest block has one vote.
 		votes = []uint64{2}
-		f.ProcessAttestation(ctx, votes, honestBlock, fEpoch)
+		fSlot, err = slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, votes, honestBlock, fSlot)
 
 		// Ensure the head is STILL C, the honest block, as the honest block had proposer boost.
 		r, err = f.Head(ctx)
@@ -267,6 +288,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		honestBlock := indexToHash(2)
 		state, blkRoot, err := prepareForkchoiceState(
 			ctx,
+			f,
 			honestBlockSlot,
 			honestBlock,
 			zeroHash,
@@ -286,6 +308,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		maliciouslyWithheldBlock := indexToHash(1)
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			maliciouslyWithheldBlockSlot,
 			maliciouslyWithheldBlock,
 			zeroHash,
@@ -304,7 +327,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		// An attestation is received for B that has more voting power than C with the proposer boost,
 		// allowing B to then become the head if their attestation has enough adversarial votes.
 		votes := []uint64{1, 2}
-		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fEpoch)
+		fSlot, err := slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, votes, maliciouslyWithheldBlock, fSlot)
 
 		// Expect the head to have switched to B.
 		r, err = f.Head(ctx)
@@ -342,6 +367,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err := prepareForkchoiceState(
 			ctx,
+			f,
 			cSlot,
 			c,
 			a, // parent
@@ -362,6 +388,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			bSlot,
 			b,
 			a, // parent
@@ -379,7 +406,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 
 		// An attestation for C is received at slot N+3.
 		votes := []uint64{1}
-		f.ProcessAttestation(ctx, votes, c, fEpoch)
+		fSlot, err := slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, votes, c, fSlot)
 
 		// A block D, building on B, is received at slot N+3. It should not be able to win without boosting.
 		dSlot := primitives.Slot(3)
@@ -387,6 +416,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			dSlot,
 			d,
 			b, // parent
@@ -408,6 +438,7 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		f.store.proposerBoostRoot = [32]byte{}
 		state, blkRoot, err = prepareForkchoiceState(
 			ctx,
+			f,
 			dSlot,
 			d2,
 			b, // parent
@@ -419,7 +450,9 @@ func TestForkChoice_BoostProposerRoot_PreventsExAnteAttack(t *testing.T) {
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 		votes = []uint64{2}
-		f.ProcessAttestation(ctx, votes, d2, fEpoch)
+		fSlot, err = slots.EpochStart(fEpoch)
+		require.NoError(t, err)
+		f.ProcessAttestation(ctx, votes, d2, fSlot)
 		// Ensure D becomes the head thanks to boosting.
 		r, err = f.Head(ctx)
 		require.NoError(t, err)
@@ -437,7 +470,7 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		slot := primitives.Slot(0)
 		currentSlot := primitives.Slot(1)
 		driftGenesisTime(f, currentSlot, 0)
-		state, blkRoot, err := prepareForkchoiceState(ctx, slot, root, zeroHash, zeroHash, 0, 0)
+		state, blkRoot, err := prepareForkchoiceState(ctx, f, slot, root, zeroHash, zeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		require.Equal(t, [32]byte{}, f.store.proposerBoostRoot)
@@ -447,7 +480,7 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		slot := primitives.Slot(1)
 		currentSlot := primitives.Slot(1)
 		driftGenesisTime(f, currentSlot, params.BeaconConfig().SecondsPerSlot-1)
-		state, blkRoot, err := prepareForkchoiceState(ctx, slot, root, zeroHash, zeroHash, 0, 0)
+		state, blkRoot, err := prepareForkchoiceState(ctx, f, slot, root, zeroHash, zeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		require.Equal(t, [32]byte{}, f.store.proposerBoostRoot)
@@ -457,7 +490,7 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		slot := primitives.Slot(1)
 		currentSlot := primitives.Slot(1)
 		driftGenesisTime(f, currentSlot, 0)
-		state, blkRoot, err := prepareForkchoiceState(ctx, slot, root, zeroHash, zeroHash, 0, 0)
+		state, blkRoot, err := prepareForkchoiceState(ctx, f, slot, root, zeroHash, zeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		require.Equal(t, root, f.store.proposerBoostRoot)
@@ -467,7 +500,7 @@ func TestForkChoice_BoostProposerRoot(t *testing.T) {
 		slot := primitives.Slot(1)
 		currentSlot := primitives.Slot(1)
 		driftGenesisTime(f, currentSlot, 1)
-		state, blkRoot, err := prepareForkchoiceState(ctx, slot, root, zeroHash, zeroHash, 0, 0)
+		state, blkRoot, err := prepareForkchoiceState(ctx, f, slot, root, zeroHash, zeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 		require.Equal(t, root, f.store.proposerBoostRoot)
@@ -484,7 +517,7 @@ func TestForkChoice_missingProposerBoostRoots(t *testing.T) {
 	}
 	f.justifiedBalances = balances
 	driftGenesisTime(f, 1, 0)
-	st, blk, err := prepareForkchoiceState(ctx, 1, [32]byte{'r'}, [32]byte{}, [32]byte{}, 1, 1)
+	st, blk, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'r'}, [32]byte{}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 
@@ -496,7 +529,7 @@ func TestForkChoice_missingProposerBoostRoots(t *testing.T) {
 
 	f.store.proposerBoostRoot = [32]byte{'p'}
 	driftGenesisTime(f, 3, 0)
-	st, blk, err = prepareForkchoiceState(ctx, 2, [32]byte{'a'}, [32]byte{'r'}, [32]byte{}, 1, 1)
+	st, blk, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'a'}, [32]byte{'r'}, [32]byte{}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 	headRoot, err = f.Head(ctx)

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

@@ -42,16 +42,16 @@ func (f *ForkChoice) ShouldOverrideFCU() (override bool) {
 		return
 	}
 
-	if head.slot != slots.CurrentSlot(f.store.genesisTime) {
+	if head.block.slot != slots.CurrentSlot(f.store.genesisTime) {
 		return
 	}
 
 	// Do not reorg on epoch boundaries
-	if (head.slot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
+	if (head.block.slot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
 		return
 	}
 	// Only reorg blocks that arrive late
-	early, err := head.arrivedEarly(f.store.genesisTime)
+	early, err := head.block.arrivedEarly(f.store.genesisTime)
 	if err != nil {
 		log.WithError(err).Error("could not check if block arrived early")
 		return
@@ -61,15 +61,15 @@ func (f *ForkChoice) ShouldOverrideFCU() (override bool) {
 	}
 	// Only reorg if we have been finalizing
 	finalizedEpoch := f.store.finalizedCheckpoint.Epoch
-	if slots.ToEpoch(head.slot+1) > finalizedEpoch+params.BeaconConfig().ReorgMaxEpochsSinceFinalization {
+	if slots.ToEpoch(head.block.slot+1) > finalizedEpoch+params.BeaconConfig().ReorgMaxEpochsSinceFinalization {
 		return
 	}
 	// Only orphan a single block
-	parent := head.parent
+	parent := head.block.parent
 	if parent == nil {
 		return
 	}
-	if head.slot > parent.slot+1 {
+	if head.block.slot > parent.block.slot+1 {
 		return
 	}
 	// Do not orphan a block that has higher justification than the parent
@@ -83,7 +83,7 @@ func (f *ForkChoice) ShouldOverrideFCU() (override bool) {
 	}
 
 	// Return early if we are checking before 10 seconds into the slot
-	secs, err := slots.SecondsSinceSlotStart(head.slot, f.store.genesisTime, uint64(time.Now().Unix()))
+	secs, err := slots.SecondsSinceSlotStart(head.block.slot, f.store.genesisTime, uint64(time.Now().Unix()))
 	if err != nil {
 		log.WithError(err).Error("could not check current slot")
 		return true
@@ -112,54 +112,54 @@ func (f *ForkChoice) GetProposerHead() [32]byte {
 	}
 
 	// Only reorg blocks from the previous slot.
-	if head.slot+1 != slots.CurrentSlot(f.store.genesisTime) {
-		return head.root
+	if head.block.slot+1 != slots.CurrentSlot(f.store.genesisTime) {
+		return head.block.root
 	}
 	// Do not reorg on epoch boundaries
-	if (head.slot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
-		return head.root
+	if (head.block.slot+1)%params.BeaconConfig().SlotsPerEpoch == 0 {
+		return head.block.root
 	}
 	// Only reorg blocks that arrive late
-	early, err := head.arrivedEarly(f.store.genesisTime)
+	early, err := head.block.arrivedEarly(f.store.genesisTime)
 	if err != nil {
 		log.WithError(err).Error("could not check if block arrived early")
-		return head.root
+		return head.block.root
 	}
 	if early {
-		return head.root
+		return head.block.root
 	}
 	// Only reorg if we have been finalizing
 	finalizedEpoch := f.store.finalizedCheckpoint.Epoch
-	if slots.ToEpoch(head.slot+1) > finalizedEpoch+params.BeaconConfig().ReorgMaxEpochsSinceFinalization {
-		return head.root
+	if slots.ToEpoch(head.block.slot+1) > finalizedEpoch+params.BeaconConfig().ReorgMaxEpochsSinceFinalization {
+		return head.block.root
 	}
 	// Only orphan a single block
-	parent := head.parent
+	parent := head.block.parent
 	if parent == nil {
-		return head.root
+		return head.block.root
 	}
-	if head.slot > parent.slot+1 {
-		return head.root
+	if head.block.slot > parent.block.slot+1 {
+		return head.block.root
 	}
 
 	// Only orphan a block if the head LMD vote is weak
 	if head.weight*100 > f.store.committeeWeight*params.BeaconConfig().ReorgWeightThreshold {
-		return head.root
+		return head.block.root
 	}
 
 	// Only orphan a block if the parent LMD vote is strong
 	if parent.weight*100 < f.store.committeeWeight*params.BeaconConfig().ReorgParentWeightThreshold {
-		return head.root
+		return head.block.root
 	}
 
 	// Only reorg if we are proposing early
-	secs, err := slots.SecondsSinceSlotStart(head.slot+1, f.store.genesisTime, uint64(time.Now().Unix()))
+	secs, err := slots.SecondsSinceSlotStart(head.block.slot+1, f.store.genesisTime, uint64(time.Now().Unix()))
 	if err != nil {
 		log.WithError(err).Error("could not check if proposing early")
-		return head.root
+		return head.block.root
 	}
 	if secs >= orphanLateBlockProposingEarly {
-		return head.root
+		return head.block.root
 	}
-	return parent.root
+	return parent.block.root
 }

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

@@ -19,7 +19,7 @@ func TestForkChoice_ShouldOverrideFCU(t *testing.T) {
 	f.store.committeeWeight /= uint64(params.BeaconConfig().SlotsPerEpoch)
 	ctx := context.Background()
 	driftGenesisTime(f, 1, 0)
-	st, blk, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, [32]byte{}, [32]byte{'A'}, 0, 0)
+	st, blk, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'a'}, [32]byte{}, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 	attesters := make([]uint64, f.numActiveValidators-64)
@@ -30,7 +30,7 @@ func TestForkChoice_ShouldOverrideFCU(t *testing.T) {
 
 	orphanLateBlockFirstThreshold := params.BeaconConfig().SecondsPerSlot / params.BeaconConfig().IntervalsPerSlot
 	driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+1)
-	st, blk, err = prepareForkchoiceState(ctx, 2, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
+	st, blk, err = prepareForkchoiceState(ctx, f, 2, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 	headRoot, err := f.Head(ctx)
@@ -52,51 +52,51 @@ func TestForkChoice_ShouldOverrideFCU(t *testing.T) {
 		driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+1)
 	})
 	t.Run("head is from epoch boundary", func(t *testing.T) {
-		saved := f.store.headNode.slot
+		saved := f.store.headNode.block.slot
 		driftGenesisTime(f, params.BeaconConfig().SlotsPerEpoch-1, 0)
-		f.store.headNode.slot = params.BeaconConfig().SlotsPerEpoch - 1
+		f.store.headNode.block.slot = params.BeaconConfig().SlotsPerEpoch - 1
 		require.Equal(t, false, f.ShouldOverrideFCU())
 		driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+1)
-		f.store.headNode.slot = saved
+		f.store.headNode.block.slot = saved
 	})
 	t.Run("head is early", func(t *testing.T) {
-		saved := f.store.headNode.timestamp
-		f.store.headNode.timestamp = saved - 2
+		saved := f.store.headNode.block.timestamp
+		f.store.headNode.block.timestamp = saved - 2
 		require.Equal(t, false, f.ShouldOverrideFCU())
-		f.store.headNode.timestamp = saved
+		f.store.headNode.block.timestamp = saved
 	})
 	t.Run("chain not finalizing", func(t *testing.T) {
-		saved := f.store.headNode.slot
-		f.store.headNode.slot = 97
+		saved := f.store.headNode.block.slot
+		f.store.headNode.block.slot = 97
 		driftGenesisTime(f, 97, orphanLateBlockFirstThreshold+1)
 		require.Equal(t, false, f.ShouldOverrideFCU())
-		f.store.headNode.slot = saved
+		f.store.headNode.block.slot = saved
 		driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+1)
 	})
 	t.Run("Not single block reorg", func(t *testing.T) {
-		saved := f.store.headNode.parent.slot
-		f.store.headNode.parent.slot = 0
+		saved := f.store.headNode.block.parent.block.slot
+		f.store.headNode.block.parent.block.slot = 0
 		require.Equal(t, false, f.ShouldOverrideFCU())
-		f.store.headNode.parent.slot = saved
+		f.store.headNode.block.parent.block.slot = saved
 	})
 	t.Run("parent is nil", func(t *testing.T) {
-		saved := f.store.headNode.parent
-		f.store.headNode.parent = nil
+		saved := f.store.headNode.block.parent
+		f.store.headNode.block.parent = nil
 		require.Equal(t, false, f.ShouldOverrideFCU())
-		f.store.headNode.parent = saved
+		f.store.headNode.block.parent = saved
 	})
 	t.Run("parent is weak early call", func(t *testing.T) {
-		saved := f.store.headNode.parent.weight
-		f.store.headNode.parent.weight = 0
+		saved := f.store.headNode.block.parent.weight
+		f.store.headNode.block.parent.weight = 0
 		require.Equal(t, true, f.ShouldOverrideFCU())
-		f.store.headNode.parent.weight = saved
+		f.store.headNode.block.parent.weight = saved
 	})
 	t.Run("parent is weak late call", func(t *testing.T) {
-		saved := f.store.headNode.parent.weight
+		saved := f.store.headNode.block.parent.weight
 		driftGenesisTime(f, 2, 11)
-		f.store.headNode.parent.weight = 0
+		f.store.headNode.block.parent.weight = 0
 		require.Equal(t, false, f.ShouldOverrideFCU())
-		f.store.headNode.parent.weight = saved
+		f.store.headNode.block.parent.weight = saved
 		driftGenesisTime(f, 2, orphanLateBlockFirstThreshold+1)
 	})
 	t.Run("Head is strong", func(t *testing.T) {
@@ -117,7 +117,7 @@ func TestForkChoice_GetProposerHead(t *testing.T) {
 	ctx := context.Background()
 	driftGenesisTime(f, 1, 0)
 	parentRoot := [32]byte{'a'}
-	st, blk, err := prepareForkchoiceState(ctx, 1, parentRoot, [32]byte{}, [32]byte{'A'}, 0, 0)
+	st, blk, err := prepareForkchoiceState(ctx, f, 1, parentRoot, [32]byte{}, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 	attesters := make([]uint64, f.numActiveValidators-64)
@@ -128,14 +128,14 @@ func TestForkChoice_GetProposerHead(t *testing.T) {
 
 	driftGenesisTime(f, 3, 1)
 	childRoot := [32]byte{'b'}
-	st, blk, err = prepareForkchoiceState(ctx, 2, childRoot, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
+	st, blk, err = prepareForkchoiceState(ctx, f, 2, childRoot, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, st, blk))
 	headRoot, err := f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, blk.Root(), headRoot)
 	orphanLateBlockFirstThreshold := params.BeaconConfig().SecondsPerSlot / params.BeaconConfig().IntervalsPerSlot
-	f.store.headNode.timestamp -= params.BeaconConfig().SecondsPerSlot - orphanLateBlockFirstThreshold
+	f.store.headNode.block.timestamp -= params.BeaconConfig().SecondsPerSlot - orphanLateBlockFirstThreshold
 	t.Run("head is weak", func(t *testing.T) {
 		require.Equal(t, parentRoot, f.GetProposerHead())
 
@@ -152,44 +152,44 @@ func TestForkChoice_GetProposerHead(t *testing.T) {
 		driftGenesisTime(f, 3, 1)
 	})
 	t.Run("head is from epoch boundary", func(t *testing.T) {
-		saved := f.store.headNode.slot
+		saved := f.store.headNode.block.slot
 		driftGenesisTime(f, params.BeaconConfig().SlotsPerEpoch, 0)
-		f.store.headNode.slot = params.BeaconConfig().SlotsPerEpoch - 1
+		f.store.headNode.block.slot = params.BeaconConfig().SlotsPerEpoch - 1
 		require.Equal(t, childRoot, f.GetProposerHead())
 		driftGenesisTime(f, 3, 1)
-		f.store.headNode.slot = saved
+		f.store.headNode.block.slot = saved
 	})
 	t.Run("head is early", func(t *testing.T) {
-		saved := f.store.headNode.timestamp
-		f.store.headNode.timestamp = saved - 2
+		saved := f.store.headNode.block.timestamp
+		f.store.headNode.block.timestamp = saved - 2
 		require.Equal(t, childRoot, f.GetProposerHead())
-		f.store.headNode.timestamp = saved
+		f.store.headNode.block.timestamp = saved
 	})
 	t.Run("chain not finalizing", func(t *testing.T) {
-		saved := f.store.headNode.slot
-		f.store.headNode.slot = 97
+		saved := f.store.headNode.block.slot
+		f.store.headNode.block.slot = 97
 		driftGenesisTime(f, 98, 0)
 		require.Equal(t, childRoot, f.GetProposerHead())
-		f.store.headNode.slot = saved
+		f.store.headNode.block.slot = saved
 		driftGenesisTime(f, 3, 1)
 	})
 	t.Run("Not single block reorg", func(t *testing.T) {
-		saved := f.store.headNode.parent.slot
-		f.store.headNode.parent.slot = 0
+		saved := f.store.headNode.block.parent.block.slot
+		f.store.headNode.block.parent.block.slot = 0
 		require.Equal(t, childRoot, f.GetProposerHead())
-		f.store.headNode.parent.slot = saved
+		f.store.headNode.block.parent.block.slot = saved
 	})
 	t.Run("parent is nil", func(t *testing.T) {
-		saved := f.store.headNode.parent
-		f.store.headNode.parent = nil
+		saved := f.store.headNode.block.parent
+		f.store.headNode.block.parent = nil
 		require.Equal(t, childRoot, f.GetProposerHead())
-		f.store.headNode.parent = saved
+		f.store.headNode.block.parent = saved
 	})
 	t.Run("parent is weak", func(t *testing.T) {
-		saved := f.store.headNode.parent.weight
-		f.store.headNode.parent.weight = 0
+		saved := f.store.headNode.block.parent.weight
+		f.store.headNode.block.parent.weight = 0
 		require.Equal(t, false, f.ShouldOverrideFCU())
-		f.store.headNode.parent.weight = saved
+		f.store.headNode.block.parent.weight = saved
 	})
 	t.Run("Head is strong", func(t *testing.T) {
 		f.store.headNode.weight = f.store.committeeWeight

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

@@ -26,7 +26,7 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 	}
 
 	// JustifiedRoot has to be known
-	justifiedNode, ok := s.nodeByRoot[s.justifiedCheckpoint.Root]
+	justifiedNode, ok := s.emptyNodeByRoot[s.justifiedCheckpoint.Root]
 	if !ok || justifiedNode == nil {
 		// If the justifiedCheckpoint is from genesis, then the root is
 		// zeroHash. In this case it should be the root of forkchoice
@@ -37,6 +37,11 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 			return [32]byte{}, errors.WithMessage(errUnknownJustifiedRoot, fmt.Sprintf("%#x", s.justifiedCheckpoint.Root))
 		}
 	}
+	// We need to consider descendants of the full justified checkpoint too
+	fullJustifiedNode, ok := s.fullNodeByPayload[justifiedNode.block.payloadHash]
+	if ok && fullJustifiedNode.weight >= justifiedNode.weight {
+		justifiedNode = fullJustifiedNode
+	}
 
 	// If the justified node doesn't have a best descendant,
 	// the best node is itself.
@@ -44,29 +49,72 @@ func (s *Store) head(ctx context.Context) ([32]byte, error) {
 	if bestDescendant == nil {
 		bestDescendant = justifiedNode
 	}
+
 	currentEpoch := slots.EpochsSinceGenesis(time.Unix(int64(s.genesisTime), 0))
 	if !bestDescendant.viableForHead(s.justifiedCheckpoint.Epoch, currentEpoch) {
 		s.allTipsAreInvalid = true
 		return [32]byte{}, fmt.Errorf("head at slot %d with weight %d is not eligible, finalizedEpoch, justified Epoch %d, %d != %d, %d",
-			bestDescendant.slot, bestDescendant.weight/10e9, bestDescendant.finalizedEpoch, bestDescendant.justifiedEpoch, s.finalizedCheckpoint.Epoch, s.justifiedCheckpoint.Epoch)
+			bestDescendant.block.slot, bestDescendant.weight/10e9, bestDescendant.block.finalizedEpoch, bestDescendant.block.justifiedEpoch, s.finalizedCheckpoint.Epoch, s.justifiedCheckpoint.Epoch)
 	}
 	s.allTipsAreInvalid = false
 
 	// Update metrics.
 	if bestDescendant != s.headNode {
 		headChangesCount.Inc()
-		headSlotNumber.Set(float64(bestDescendant.slot))
+		headSlotNumber.Set(float64(bestDescendant.block.slot))
 		s.headNode = bestDescendant
 	}
 
-	return bestDescendant.root, nil
+	return bestDescendant.block.root, nil
+}
+
+// checkProposerBoost checks if the incoming block should receive proposer boost and applies it.
+func (s *Store) checkProposerBoost(block *BlockNode) {
+	timeNow := uint64(time.Now().Unix())
+	if timeNow < s.genesisTime {
+		return
+	}
+	secondsIntoSlot := (timeNow - s.genesisTime) % params.BeaconConfig().SecondsPerSlot
+	currentSlot := slots.CurrentSlot(s.genesisTime)
+	boostThreshold := params.BeaconConfig().SecondsPerSlot / params.BeaconConfig().IntervalsPerSlot
+	isFirstBlock := s.proposerBoostRoot == [32]byte{}
+	if currentSlot == block.slot && secondsIntoSlot < boostThreshold && isFirstBlock {
+		s.proposerBoostRoot = block.root
+	}
+}
+
+// insertChild perform the insertion tasks when the parent node was already in
+// forkchoice, this is
+// - add a child to the parent
+// - apply proposer boost
+// - update best descendants.
+func (s *Store) insertChild(ctx context.Context, parent *Node, child *Node) error {
+	if parent == nil {
+		return nil
+	}
+	parent.children = append(parent.children, child)
+	if !child.full {
+		s.checkProposerBoost(child.block)
+	}
+	// Update best descendants
+	jEpoch := s.justifiedCheckpoint.Epoch
+	fEpoch := s.finalizedCheckpoint.Epoch
+	currentSlot := slots.CurrentSlot(s.genesisTime)
+	if err := s.treeRootNode.updateBestDescendant(ctx, jEpoch, fEpoch, slots.ToEpoch(currentSlot)); err != nil {
+		_, remErr := s.removeNode(ctx, child)
+		if remErr != nil {
+			log.WithError(remErr).Error("could not remove node")
+		}
+		return errors.Wrap(err, "could not update best descendants")
+	}
+	return nil
 }
 
 // insert registers a new block node to the fork choice store's node list.
 // It then updates the new node's parent with the best child and descendant node.
 func (s *Store) insert(ctx context.Context,
 	roblock consensus_blocks.ROBlock,
-	justifiedEpoch, finalizedEpoch primitives.Epoch) (*Node, error) {
+	justifiedEpoch, finalizedEpoch primitives.Epoch) (*BlockNode, error) {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.insert")
 	defer span.End()
 
@@ -74,97 +122,99 @@ func (s *Store) insert(ctx context.Context,
 	block := roblock.Block()
 	slot := block.Slot()
 	parentRoot := block.ParentRoot()
-	var payloadHash [32]byte
-	if block.Version() >= version.Bellatrix {
+	var parentHash, payloadHash [32]byte
+	if block.Version() >= version.EPBS {
+		execution, err := block.Body().SignedExecutionPayloadHeader()
+		if err != nil {
+			return nil, err
+		}
+		header, err := execution.Header()
+		if err != nil {
+			return nil, err
+		}
+		payloadHash = header.BlockHash()
+		parentHash = header.ParentBlockHash()
+	} else if block.Version() >= version.Bellatrix {
 		execution, err := block.Body().Execution()
 		if err != nil {
 			return nil, err
 		}
 		copy(payloadHash[:], execution.BlockHash())
+		copy(parentHash[:], execution.ParentHash())
+		// Before ePBS, if the parent is known and the parent hash is not, then
+		// set the parent hash to zero
+		_, ok := s.fullNodeByPayload[parentHash]
+		if !ok {
+			parentHash = [32]byte{}
+		}
 	}
-
 	// Return if the block has been inserted into Store before.
-	if n, ok := s.nodeByRoot[root]; ok {
-		return n, nil
+	n, rootPresent := s.emptyNodeByRoot[root]
+	if rootPresent {
+		return n.block, nil
 	}
-
-	parent := s.nodeByRoot[parentRoot]
-	n := &Node{
+	parent := s.emptyNodeByRoot[parentRoot]
+	fullParent := s.fullNodeByPayload[parentHash]
+	if fullParent != nil && parent != nil && fullParent.block == parent.block {
+		parent = fullParent
+	}
+	innerBlock := &BlockNode{
 		slot:                     slot,
 		root:                     root,
+		payloadHash:              payloadHash,
 		parent:                   parent,
+		fullParent:               fullParent,
 		justifiedEpoch:           justifiedEpoch,
 		unrealizedJustifiedEpoch: justifiedEpoch,
 		finalizedEpoch:           finalizedEpoch,
 		unrealizedFinalizedEpoch: finalizedEpoch,
-		optimistic:               true,
-		payloadHash:              payloadHash,
 		timestamp:                uint64(time.Now().Unix()),
 	}
-
+	emptyNode := &Node{
+		block:      innerBlock,
+		optimistic: true,
+		children:   make([]*Node, 0),
+		full:       false,
+	}
 	// Set the node's target checkpoint
 	if slot%params.BeaconConfig().SlotsPerEpoch == 0 {
-		n.target = n
+		innerBlock.target = innerBlock
 	} else if parent != nil {
-		if slots.ToEpoch(slot) == slots.ToEpoch(parent.slot) {
-			n.target = parent.target
+		if slots.ToEpoch(slot) == slots.ToEpoch(parent.block.slot) {
+			innerBlock.target = parent.block.target
 		} else {
-			n.target = parent
+			innerBlock.target = parent.block
 		}
 	}
 
-	s.nodeByPayload[payloadHash] = n
-	s.nodeByRoot[root] = n
 	if parent == nil {
 		if s.treeRootNode == nil {
-			s.treeRootNode = n
-			s.headNode = n
-			s.highestReceivedNode = n
+			s.treeRootNode = emptyNode
+			s.headNode = emptyNode
+			s.highestReceivedNode = emptyNode
 		} else {
-			delete(s.nodeByRoot, root)
-			delete(s.nodeByPayload, payloadHash)
-			return nil, errInvalidParentRoot
-		}
-	} else {
-		parent.children = append(parent.children, n)
-		// Apply proposer boost
-		timeNow := uint64(time.Now().Unix())
-		if timeNow < s.genesisTime {
-			return n, nil
-		}
-		secondsIntoSlot := (timeNow - s.genesisTime) % params.BeaconConfig().SecondsPerSlot
-		currentSlot := slots.CurrentSlot(s.genesisTime)
-		boostThreshold := params.BeaconConfig().SecondsPerSlot / params.BeaconConfig().IntervalsPerSlot
-		isFirstBlock := s.proposerBoostRoot == [32]byte{}
-		if currentSlot == slot && secondsIntoSlot < boostThreshold && isFirstBlock {
-			s.proposerBoostRoot = root
-		}
-
-		// Update best descendants
-		jEpoch := s.justifiedCheckpoint.Epoch
-		fEpoch := s.finalizedCheckpoint.Epoch
-		if err := s.treeRootNode.updateBestDescendant(ctx, jEpoch, fEpoch, slots.ToEpoch(currentSlot)); err != nil {
-			_, remErr := s.removeNode(ctx, n)
-			if remErr != nil {
-				log.WithError(remErr).Error("could not remove node")
-			}
-			return nil, errors.Wrap(err, "could not update best descendants")
+			delete(s.emptyNodeByRoot, root)
+			return innerBlock, errInvalidParentRoot
 		}
 	}
+	s.emptyNodeByRoot[root] = emptyNode
+	if err := s.insertChild(ctx, parent, emptyNode); err != nil {
+		return nil, err
+	}
+
 	// Update metrics.
 	processedBlockCount.Inc()
-	nodeCount.Set(float64(len(s.nodeByRoot)))
+	nodeCount.Set(float64(len(s.emptyNodeByRoot)))
 
 	// Only update received block slot if it's within epoch from current time.
 	if slot+params.BeaconConfig().SlotsPerEpoch > slots.CurrentSlot(s.genesisTime) {
 		s.receivedBlocksLastEpoch[slot%params.BeaconConfig().SlotsPerEpoch] = slot
 	}
 	// Update highest slot tracking.
-	if slot > s.highestReceivedNode.slot {
-		s.highestReceivedNode = n
+	if s.highestReceivedNode == nil || slot > s.highestReceivedNode.block.slot {
+		s.highestReceivedNode = emptyNode
 	}
-
-	return n, nil
+	return innerBlock, nil
 }
 
 // pruneFinalizedNodeByRootMap prunes the `nodeByRoot` map
@@ -174,10 +224,12 @@ func (s *Store) pruneFinalizedNodeByRootMap(ctx context.Context, node, finalized
 	if ctx.Err() != nil {
 		return ctx.Err()
 	}
-	if node == finalizedNode {
-		if node.target != node {
-			node.target = nil
+	if node.block == finalizedNode.block {
+		if node.block.target != node.block {
+			node.block.target = nil
 		}
+		node.block.parent = nil
+		node.block.fullParent = nil
 		return nil
 	}
 	for _, child := range node.children {
@@ -187,8 +239,8 @@ func (s *Store) pruneFinalizedNodeByRootMap(ctx context.Context, node, finalized
 	}
 
 	node.children = nil
-	delete(s.nodeByRoot, node.root)
-	delete(s.nodeByPayload, node.payloadHash)
+	delete(s.emptyNodeByRoot, node.block.root)
+	delete(s.fullNodeByPayload, node.block.payloadHash)
 	return nil
 }
 
@@ -200,35 +252,32 @@ func (s *Store) prune(ctx context.Context) error {
 
 	finalizedRoot := s.finalizedCheckpoint.Root
 	finalizedEpoch := s.finalizedCheckpoint.Epoch
-	finalizedNode, ok := s.nodeByRoot[finalizedRoot]
+	finalizedNode, ok := s.emptyNodeByRoot[finalizedRoot]
 	if !ok || finalizedNode == nil {
 		return errors.WithMessage(errUnknownFinalizedRoot, fmt.Sprintf("%#x", finalizedRoot))
 	}
 	// return early if we haven't changed the finalized checkpoint
-	if finalizedNode.parent == nil {
+	if finalizedNode.block.parent == nil {
 		return nil
 	}
-
 	// Prune nodeByRoot starting from root
 	if err := s.pruneFinalizedNodeByRootMap(ctx, s.treeRootNode, finalizedNode); err != nil {
 		return err
 	}
 
-	finalizedNode.parent = nil
 	s.treeRootNode = finalizedNode
-
 	prunedCount.Inc()
 	// Prune all children of the finalized checkpoint block that are incompatible with it
 	checkpointMaxSlot, err := slots.EpochStart(finalizedEpoch)
 	if err != nil {
 		return errors.Wrap(err, "could not compute epoch start")
 	}
-	if finalizedNode.slot == checkpointMaxSlot {
+	if finalizedNode.block.slot == checkpointMaxSlot {
 		return nil
 	}
 
 	for _, child := range finalizedNode.children {
-		if child != nil && child.slot <= checkpointMaxSlot {
+		if child != nil && child.block.slot <= checkpointMaxSlot {
 			if err := s.pruneFinalizedNodeByRootMap(ctx, child, finalizedNode); err != nil {
 				return errors.Wrap(err, "could not prune incompatible finalized child")
 			}
@@ -243,21 +292,21 @@ func (s *Store) tips() ([][32]byte, []primitives.Slot) {
 	var roots [][32]byte
 	var slots []primitives.Slot
 
-	for root, node := range s.nodeByRoot {
+	for _, node := range s.fullNodeByPayload {
 		if len(node.children) == 0 {
-			roots = append(roots, root)
-			slots = append(slots, node.slot)
+			roots = append(roots, node.block.root)
+			slots = append(slots, node.block.slot)
 		}
 	}
 	return roots, slots
 }
 
-// HighestReceivedBlockSlot returns the highest slot received by the forkchoice
-func (f *ForkChoice) HighestReceivedBlockSlot() primitives.Slot {
+// HighestReceivedBlockSlotRoot returns the highest slot and root received by the forkchoice
+func (f *ForkChoice) HighestReceivedBlockSlotRoot() (primitives.Slot, [32]byte) {
 	if f.store.highestReceivedNode == nil {
-		return 0
+		return 0, [32]byte{}
 	}
-	return f.store.highestReceivedNode.slot
+	return f.store.highestReceivedNode.block.slot, f.store.highestReceivedNode.block.root
 }
 
 // HighestReceivedBlockSlotDelay returns the number of slots that the highest
@@ -267,7 +316,7 @@ func (f *ForkChoice) HighestReceivedBlockDelay() primitives.Slot {
 	if n == nil {
 		return 0
 	}
-	secs, err := slots.SecondsSinceSlotStart(n.slot, f.store.genesisTime, n.timestamp)
+	secs, err := slots.SecondsSinceSlotStart(n.block.slot, f.store.genesisTime, n.block.timestamp)
 	if err != nil {
 		return 0
 	}

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

@@ -26,7 +26,7 @@ func TestStore_FinalizedEpoch(t *testing.T) {
 
 func TestStore_NodeCount(t *testing.T) {
 	f := setup(0, 0)
-	state, blk, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(context.Background(), state, blk))
 	require.Equal(t, 2, f.NodeCount())
@@ -35,34 +35,50 @@ func TestStore_NodeCount(t *testing.T) {
 func TestStore_NodeByRoot(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blk, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, indexToHash(101), 0, 0)
 	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, f.InsertNode(ctx, state, blk))
+	state, blk, err = prepareForkchoiceState(context.Background(), f, 2, indexToHash(2), indexToHash(1), indexToHash(102), 0, 0)
 	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	node0 := f.store.treeRootNode
-	node1 := node0.children[0]
-	node2 := node1.children[0]
+	require.NoError(t, f.InsertNode(ctx, state, blk))
+	emptyNode0 := f.store.emptyNodeByRoot[[32]byte{}]
+	fullNode0 := f.store.treeRootNode
+	emptyNode1 := fullNode0.children[0]
+	fullNode1 := fullNode0.children[1]
+	emptyNode2 := fullNode1.children[0]
+	fullNode2 := fullNode1.children[1]
 
 	expectedRoots := map[[32]byte]*Node{
-		params.BeaconConfig().ZeroHash: node0,
-		indexToHash(1):                 node1,
-		indexToHash(2):                 node2,
+		params.BeaconConfig().ZeroHash: emptyNode0,
+		indexToHash(1):                 emptyNode1,
+		indexToHash(2):                 emptyNode2,
 	}
 
 	require.Equal(t, 3, f.NodeCount())
-	for root, node := range f.store.nodeByRoot {
+	for root, node := range f.store.emptyNodeByRoot {
 		v, ok := expectedRoots[root]
 		require.Equal(t, ok, true)
 		require.Equal(t, v, node)
 	}
+
+	require.Equal(t, 3, len(f.store.fullNodeByPayload))
+	expectedPayloads := map[[32]byte]*Node{
+		[32]byte{}:       fullNode0,
+		indexToHash(101): fullNode1,
+		indexToHash(102): fullNode2,
+	}
+
+	for payloadHash, node := range f.store.fullNodeByPayload {
+		v, ok := expectedPayloads[payloadHash]
+		require.Equal(t, true, ok)
+		require.Equal(t, v, node)
+	}
 }
 
 func TestForkChoice_HasNode(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.Equal(t, true, f.HasNode(indexToHash(1)))
@@ -78,7 +94,7 @@ func TestStore_Head_UnknownJustifiedRoot(t *testing.T) {
 
 func TestStore_Head_Itself(t *testing.T) {
 	f := setup(0, 0)
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(context.Background(), state, blkRoot))
 
@@ -93,16 +109,16 @@ func TestStore_Head_Itself(t *testing.T) {
 func TestStore_Head_BestDescendant(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(context.Background(), 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(context.Background(), f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 3, indexToHash(3), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(context.Background(), 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(context.Background(), f, 4, indexToHash(4), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	f.store.justifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 0, Root: indexToHash(1)}
@@ -114,11 +130,11 @@ func TestStore_Head_BestDescendant(t *testing.T) {
 func TestStore_UpdateBestDescendant_ContextCancelled(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	f := setup(0, 0)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	cancel()
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	err = f.InsertNode(ctx, state, blkRoot)
 	require.ErrorContains(t, "context canceled", err)
@@ -126,26 +142,28 @@ func TestStore_UpdateBestDescendant_ContextCancelled(t *testing.T) {
 
 func TestStore_Insert(t *testing.T) {
 	// The new node does not have a parent.
-	treeRootNode := &Node{slot: 0, root: indexToHash(0)}
+	treeRootNode := &Node{block: &BlockNode{slot: 0, root: indexToHash(0)}}
 	nodeByRoot := map[[32]byte]*Node{indexToHash(0): treeRootNode}
 	nodeByPayload := map[[32]byte]*Node{indexToHash(0): treeRootNode}
 	jc := &forkchoicetypes.Checkpoint{Epoch: 0}
 	fc := &forkchoicetypes.Checkpoint{Epoch: 0}
-	s := &Store{nodeByRoot: nodeByRoot, treeRootNode: treeRootNode, nodeByPayload: nodeByPayload, justifiedCheckpoint: jc, finalizedCheckpoint: fc, highestReceivedNode: &Node{}}
+	fcs := setup(0, 0)
+	s := &Store{emptyNodeByRoot: nodeByRoot, treeRootNode: treeRootNode, fullNodeByPayload: nodeByPayload, justifiedCheckpoint: jc, finalizedCheckpoint: fc}
+	fcs.store = s
 	payloadHash := [32]byte{'a'}
 	ctx := context.Background()
-	_, blk, err := prepareForkchoiceState(ctx, 100, indexToHash(100), indexToHash(0), payloadHash, 1, 1)
+	_, blk, err := prepareForkchoiceState(ctx, fcs, 100, indexToHash(100), indexToHash(0), payloadHash, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
-	assert.Equal(t, 2, len(s.nodeByRoot), "Did not insert block")
-	assert.Equal(t, (*Node)(nil), treeRootNode.parent, "Incorrect parent")
+	assert.Equal(t, 2, len(s.emptyNodeByRoot), "Did not insert block")
+	assert.Equal(t, (*Node)(nil), treeRootNode.block.parent, "Incorrect parent")
 	assert.Equal(t, 1, len(treeRootNode.children), "Incorrect children number")
-	assert.Equal(t, payloadHash, treeRootNode.children[0].payloadHash, "Incorrect payload hash")
+	assert.Equal(t, payloadHash, treeRootNode.children[0].block.payloadHash, "Incorrect payload hash")
 	child := treeRootNode.children[0]
-	assert.Equal(t, primitives.Epoch(1), child.justifiedEpoch, "Incorrect justification")
-	assert.Equal(t, primitives.Epoch(1), child.finalizedEpoch, "Incorrect finalization")
-	assert.Equal(t, indexToHash(100), child.root, "Incorrect root")
+	assert.Equal(t, primitives.Epoch(1), child.block.justifiedEpoch, "Incorrect justification")
+	assert.Equal(t, primitives.Epoch(1), child.block.finalizedEpoch, "Incorrect finalization")
+	assert.Equal(t, indexToHash(100), child.block.root, "Incorrect root")
 }
 
 func TestStore_Prune_MoreThanThreshold(t *testing.T) {
@@ -153,11 +171,11 @@ func TestStore_Prune_MoreThanThreshold(t *testing.T) {
 	numOfNodes := uint64(100)
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, indexToHash(1001), 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	for i := uint64(2); i < numOfNodes; i++ {
-		state, blkRoot, err = prepareForkchoiceState(ctx, primitives.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, primitives.Slot(i), indexToHash(i), indexToHash(i-1), indexToHash(1000+i), 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	}
@@ -167,7 +185,7 @@ func TestStore_Prune_MoreThanThreshold(t *testing.T) {
 	// Finalized root is at index 99 so everything before 99 should be pruned.
 	s.finalizedCheckpoint.Root = indexToHash(99)
 	require.NoError(t, s.prune(context.Background()))
-	assert.Equal(t, 1, len(s.nodeByRoot), "Incorrect nodes count")
+	assert.Equal(t, 1, len(s.emptyNodeByRoot), "Incorrect nodes count")
 }
 
 func TestStore_Prune_MoreThanOnce(t *testing.T) {
@@ -175,11 +193,11 @@ func TestStore_Prune_MoreThanOnce(t *testing.T) {
 	numOfNodes := uint64(100)
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	for i := uint64(2); i < numOfNodes; i++ {
-		state, blkRoot, err = prepareForkchoiceState(ctx, primitives.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, primitives.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	}
@@ -189,12 +207,12 @@ func TestStore_Prune_MoreThanOnce(t *testing.T) {
 	// Finalized root is at index 11 so everything before 11 should be pruned.
 	s.finalizedCheckpoint.Root = indexToHash(10)
 	require.NoError(t, s.prune(context.Background()))
-	assert.Equal(t, 90, len(s.nodeByRoot), "Incorrect nodes count")
+	assert.Equal(t, 90, len(s.emptyNodeByRoot), "Incorrect nodes count")
 
 	// One more time.
 	s.finalizedCheckpoint.Root = indexToHash(20)
 	require.NoError(t, s.prune(context.Background()))
-	assert.Equal(t, 80, len(s.nodeByRoot), "Incorrect nodes count")
+	assert.Equal(t, 80, len(s.emptyNodeByRoot), "Incorrect nodes count")
 }
 
 func TestStore_Prune_ReturnEarly(t *testing.T) {
@@ -202,11 +220,11 @@ func TestStore_Prune_ReturnEarly(t *testing.T) {
 	numOfNodes := uint64(100)
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	for i := uint64(2); i < numOfNodes; i++ {
-		state, blkRoot, err = prepareForkchoiceState(ctx, primitives.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
+		state, blkRoot, err = prepareForkchoiceState(ctx, f, primitives.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
 		require.NoError(t, err)
 		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	}
@@ -227,18 +245,18 @@ func TestStore_Prune_ReturnEarly(t *testing.T) {
 func TestStore_Prune_NoDanglingBranch(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{'2'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{'2'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	s := f.store
 	s.finalizedCheckpoint.Root = indexToHash(1)
 	require.NoError(t, s.prune(context.Background()))
-	require.Equal(t, len(s.nodeByRoot), 1)
-	require.Equal(t, len(s.nodeByPayload), 1)
+	require.Equal(t, len(s.emptyNodeByRoot), 1)
+	require.Equal(t, len(s.fullNodeByPayload), 1)
 }
 
 // This test starts with the following branching diagram
@@ -255,40 +273,40 @@ func TestStore_tips(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'j'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'j'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 103, [32]byte{'d'}, [32]byte{'c'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 104, [32]byte{'e'}, [32]byte{'d'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'g'}, [32]byte{'d'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 104, [32]byte{'g'}, [32]byte{'d'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'f'}, [32]byte{'e'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'h'}, [32]byte{'g'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'h'}, [32]byte{'g'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'k'}, [32]byte{'g'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'k'}, [32]byte{'g'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'i'}, [32]byte{'h'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 106, [32]byte{'i'}, [32]byte{'h'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'l'}, [32]byte{'k'}, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 106, [32]byte{'l'}, [32]byte{'k'}, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	expectedMap := map[[32]byte]primitives.Slot{
@@ -308,18 +326,20 @@ func TestStore_tips(t *testing.T) {
 func TestStore_PruneMapsNodes(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), params.BeaconConfig().ZeroHash, [32]byte{'1'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{'2'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 2, indexToHash(2), params.BeaconConfig().ZeroHash, [32]byte{'2'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	s := f.store
 	s.finalizedCheckpoint.Root = indexToHash(1)
+	require.Equal(t, 3, len(s.emptyNodeByRoot))
+	require.Equal(t, 3, len(s.fullNodeByPayload))
 	require.NoError(t, s.prune(context.Background()))
-	require.Equal(t, len(s.nodeByRoot), 1)
-	require.Equal(t, len(s.nodeByPayload), 1)
+	require.Equal(t, len(s.emptyNodeByRoot), 1)
+	require.Equal(t, len(s.fullNodeByPayload), 1)
 
 }
 
@@ -331,19 +351,20 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	// Make sure it doesn't underflow
 	s.genesisTime = uint64(time.Now().Add(time.Duration(-1*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second).Unix())
 	ctx := context.Background()
-	_, blk, err := prepareForkchoiceState(ctx, 1, [32]byte{'a'}, b, b, 1, 1)
+	_, blk, err := prepareForkchoiceState(ctx, f, 1, [32]byte{'a'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
 	count, err := f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
-	require.Equal(t, primitives.Slot(1), f.HighestReceivedBlockSlot())
+	slot, _ := f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(1), slot)
 	require.Equal(t, primitives.Slot(0), f.HighestReceivedBlockDelay())
 
 	// 64
 	// Received block last epoch is 1
-	_, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'A'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 64, [32]byte{'A'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -351,12 +372,13 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
-	require.Equal(t, primitives.Slot(64), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(64), slot)
 	require.Equal(t, primitives.Slot(0), f.HighestReceivedBlockDelay())
 
 	// 64 65
 	// Received block last epoch is 2
-	_, blk, err = prepareForkchoiceState(ctx, 65, [32]byte{'B'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 65, [32]byte{'B'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -364,12 +386,13 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(2), count)
-	require.Equal(t, primitives.Slot(65), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(65), slot)
 	require.Equal(t, primitives.Slot(1), f.HighestReceivedBlockDelay())
 
 	// 64 65 66
 	// Received block last epoch is 3
-	_, blk, err = prepareForkchoiceState(ctx, 66, [32]byte{'C'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 66, [32]byte{'C'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -377,12 +400,13 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(3), count)
-	require.Equal(t, primitives.Slot(66), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(66), slot)
 
 	// 64 65 66
 	//       98
 	// Received block last epoch is 1
-	_, blk, err = prepareForkchoiceState(ctx, 98, [32]byte{'D'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 98, [32]byte{'D'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -390,13 +414,14 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
-	require.Equal(t, primitives.Slot(98), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(98), slot)
 
 	// 64 65 66
 	//       98
 	//              132
 	// Received block last epoch is 1
-	_, blk, err = prepareForkchoiceState(ctx, 132, [32]byte{'E'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 132, [32]byte{'E'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -404,14 +429,15 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
-	require.Equal(t, primitives.Slot(132), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(132), slot)
 
 	// 64 65 66
 	//       98
 	//              132
 	//       99
 	// Received block last epoch is still 1. 99 is outside the window
-	_, blk, err = prepareForkchoiceState(ctx, 99, [32]byte{'F'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 99, [32]byte{'F'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -419,14 +445,15 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
-	require.Equal(t, primitives.Slot(132), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(132), slot)
 
 	// 64 65 66
 	//       98
 	//              132
 	//       99 100
 	// Received block last epoch is still 1. 100 is at the same position as 132
-	_, blk, err = prepareForkchoiceState(ctx, 100, [32]byte{'G'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 100, [32]byte{'G'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -434,14 +461,15 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(1), count)
-	require.Equal(t, primitives.Slot(132), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(132), slot)
 
 	// 64 65 66
 	//       98
 	//              132
 	//       99 100 101
 	// Received block last epoch is 2. 101 is within the window
-	_, blk, err = prepareForkchoiceState(ctx, 101, [32]byte{'H'}, b, b, 1, 1)
+	_, blk, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'H'}, b, b, 1, 1)
 	require.NoError(t, err)
 	_, err = s.insert(ctx, blk, 1, 1)
 	require.NoError(t, err)
@@ -449,7 +477,8 @@ func TestForkChoice_ReceivedBlocksLastEpoch(t *testing.T) {
 	count, err = f.ReceivedBlocksLastEpoch()
 	require.NoError(t, err)
 	require.Equal(t, uint64(2), count)
-	require.Equal(t, primitives.Slot(132), f.HighestReceivedBlockSlot())
+	slot, _ = f.HighestReceivedBlockSlotRoot()
+	require.Equal(t, primitives.Slot(132), slot)
 
 	s.genesisTime = uint64(time.Now().Add(time.Duration(-134*int64(params.BeaconConfig().SecondsPerSlot)) * time.Second).Unix())
 	count, err = f.ReceivedBlocksLastEpoch()
@@ -465,14 +494,14 @@ func TestStore_TargetRootForEpoch(t *testing.T) {
 	ctx := context.Background()
 	f := setup(1, 1)
 
-	state, blk, err := prepareForkchoiceState(ctx, params.BeaconConfig().SlotsPerEpoch, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk, err := prepareForkchoiceState(ctx, f, params.BeaconConfig().SlotsPerEpoch, [32]byte{'a'}, params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk))
 	target, err := f.TargetRootForEpoch(blk.Root(), 1)
 	require.NoError(t, err)
 	require.Equal(t, target, blk.Root())
 
-	state, blk1, err := prepareForkchoiceState(ctx, params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'b'}, blk.Root(), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk1, err := prepareForkchoiceState(ctx, f, params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'b'}, blk.Root(), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk1))
 	target, err = f.TargetRootForEpoch(blk1.Root(), 1)
@@ -481,14 +510,14 @@ func TestStore_TargetRootForEpoch(t *testing.T) {
 
 	// Insert a block for the next epoch (missed slot 0)
 
-	state, blk2, err := prepareForkchoiceState(ctx, 2*params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'c'}, blk1.Root(), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk2, err := prepareForkchoiceState(ctx, f, 2*params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'c'}, blk1.Root(), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk2))
 	target, err = f.TargetRootForEpoch(blk2.Root(), 2)
 	require.NoError(t, err)
 	require.Equal(t, target, blk1.Root())
 
-	state, blk3, err := prepareForkchoiceState(ctx, 2*params.BeaconConfig().SlotsPerEpoch+2, [32]byte{'d'}, blk2.Root(), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk3, err := prepareForkchoiceState(ctx, f, 2*params.BeaconConfig().SlotsPerEpoch+2, [32]byte{'d'}, blk2.Root(), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk3))
 	target, err = f.TargetRootForEpoch(blk2.Root(), 2)
@@ -505,14 +534,14 @@ func TestStore_TargetRootForEpoch(t *testing.T) {
 
 	// Insert a block for next epoch (slot 0 present)
 
-	state, blk4, err := prepareForkchoiceState(ctx, 3*params.BeaconConfig().SlotsPerEpoch, [32]byte{'e'}, blk1.Root(), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk4, err := prepareForkchoiceState(ctx, f, 3*params.BeaconConfig().SlotsPerEpoch, [32]byte{'e'}, blk1.Root(), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk4))
 	target, err = f.TargetRootForEpoch(blk4.Root(), 3)
 	require.NoError(t, err)
 	require.Equal(t, target, blk4.Root())
 
-	state, blk5, err := prepareForkchoiceState(ctx, 3*params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'f'}, blk4.Root(), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk5, err := prepareForkchoiceState(ctx, f, 3*params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'f'}, blk4.Root(), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk5))
 	target, err = f.TargetRootForEpoch(blk5.Root(), 3)
@@ -530,7 +559,7 @@ func TestStore_TargetRootForEpoch(t *testing.T) {
 	require.Equal(t, blk1.Root(), target) // the parent of root4 in epoch 3 is root 1 in epoch 1
 
 	// Target root where the target is two epochs ago, slot 0 was missed
-	state, blk6, err := prepareForkchoiceState(ctx, 4*params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'g'}, blk5.Root(), params.BeaconConfig().ZeroHash, 1, 1)
+	state, blk6, err := prepareForkchoiceState(ctx, f, 4*params.BeaconConfig().SlotsPerEpoch+1, [32]byte{'g'}, blk5.Root(), params.BeaconConfig().ZeroHash, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blk6))
 	target, err = f.TargetRootForEpoch(blk6.Root(), 4)
@@ -551,7 +580,7 @@ func TestStore_TargetRootForEpoch(t *testing.T) {
 func TestStore_CleanupInserting(t *testing.T) {
 	f := setup(0, 0)
 	ctx := context.Background()
-	st, blk, err := prepareForkchoiceState(ctx, 1, indexToHash(1), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
+	st, blk, err := prepareForkchoiceState(ctx, f, 1, indexToHash(1), indexToHash(2), params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NotNil(t, f.InsertNode(ctx, st, blk))
 	require.Equal(t, false, f.HasNode(blk.Root()))

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

@@ -33,8 +33,8 @@ type Store struct {
 	committeeWeight               uint64                                 // tracks the total active validator balance divided by the number of slots per Epoch.
 	treeRootNode                  *Node                                  // the root node of the store tree.
 	headNode                      *Node                                  // last head Node
-	nodeByRoot                    map[[fieldparams.RootLength]byte]*Node // nodes indexed by roots.
-	nodeByPayload                 map[[fieldparams.RootLength]byte]*Node // nodes indexed by payload Hash
+	emptyNodeByRoot               map[[fieldparams.RootLength]byte]*Node // nodes indexed by roots.
+	fullNodeByPayload             map[[fieldparams.RootLength]byte]*Node // nodes indexed by payload Hash
 	slashedIndices                map[primitives.ValidatorIndex]bool     // the list of equivocating validator indices
 	originRoot                    [fieldparams.RootLength]byte           // The genesis block root
 	genesisTime                   uint64
@@ -43,29 +43,38 @@ type Store struct {
 	allTipsAreInvalid             bool                                       // tracks if all tips are not viable for head
 }
 
-// Node defines the individual block which includes its block parent, ancestor and how much weight accounted for it.
+// BlockNode defines the individual block which includes its block parent, ancestor and how much weight accounted for it.
 // This is used as an array based stateful DAG for efficient fork choice look up.
-type Node struct {
+type BlockNode struct {
 	slot                     primitives.Slot              // slot of the block converted to the node.
 	root                     [fieldparams.RootLength]byte // root of the block converted to the node.
-	payloadHash              [fieldparams.RootLength]byte // payloadHash of the block converted to the node.
-	parent                   *Node                        // parent index of this node.
-	target                   *Node                        // target checkpoint for
-	children                 []*Node                      // the list of direct children of this Node
+	payloadHash              [fieldparams.RootLength]byte // payloadHash of the block committed to the node.
+	parent                   *Node                        // parent node of this block
+	fullParent               *Node                        // full parent of this block
+	balance                  uint64                       // the balance that voted for this node directly
+	target                   *BlockNode                   // target checkpoint for
 	justifiedEpoch           primitives.Epoch             // justifiedEpoch of this node.
 	unrealizedJustifiedEpoch primitives.Epoch             // the epoch that would be justified if the block would be advanced to the next epoch.
 	finalizedEpoch           primitives.Epoch             // finalizedEpoch of this node.
 	unrealizedFinalizedEpoch primitives.Epoch             // the epoch that would be finalized if the block would be advanced to the next epoch.
-	balance                  uint64                       // the balance that voted for this node directly
-	weight                   uint64                       // weight of this node: the total balance including children
-	bestDescendant           *Node                        // bestDescendant node of this node.
-	optimistic               bool                         // whether the block has been fully validated or not
 	timestamp                uint64                       // The timestamp when the node was inserted.
 }
 
+// Node is a type that encapsulates a blocknode and whether the payload is
+// present or not, to share resources between the full and empty forkchoice
+// nodes.
+type Node struct {
+	block          *BlockNode
+	children       []*Node // the list of direct children of this Node
+	weight         uint64  // weight of this node: the total balance including children
+	bestDescendant *Node   // bestDescendant node of this node.
+	full           bool    // wether the node represents full or empty forkchoice node
+	optimistic     bool    // whether the payload has been fully validated or not
+}
+
 // Vote defines an individual validator's vote.
 type Vote struct {
 	currentRoot [fieldparams.RootLength]byte // current voting root.
 	nextRoot    [fieldparams.RootLength]byte // next voting root.
-	nextEpoch   primitives.Epoch             // epoch of next voting period.
+	slot        primitives.Slot              // slot of the last vote by this validator
 }

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

@@ -15,63 +15,63 @@ import (
 )
 
 func (s *Store) setUnrealizedJustifiedEpoch(root [32]byte, epoch primitives.Epoch) error {
-	node, ok := s.nodeByRoot[root]
+	node, ok := s.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		return errors.Wrap(ErrNilNode, "could not set unrealized justified epoch")
 	}
-	if epoch < node.unrealizedJustifiedEpoch {
+	if epoch < node.block.unrealizedJustifiedEpoch {
 		return errInvalidUnrealizedJustifiedEpoch
 	}
-	node.unrealizedJustifiedEpoch = epoch
+	node.block.unrealizedJustifiedEpoch = epoch
 	return nil
 }
 
 func (s *Store) setUnrealizedFinalizedEpoch(root [32]byte, epoch primitives.Epoch) error {
-	node, ok := s.nodeByRoot[root]
+	node, ok := s.emptyNodeByRoot[root]
 	if !ok || node == nil {
 		return errors.Wrap(ErrNilNode, "could not set unrealized finalized epoch")
 	}
-	if epoch < node.unrealizedFinalizedEpoch {
+	if epoch < node.block.unrealizedFinalizedEpoch {
 		return errInvalidUnrealizedFinalizedEpoch
 	}
-	node.unrealizedFinalizedEpoch = epoch
+	node.block.unrealizedFinalizedEpoch = epoch
 	return nil
 }
 
 // updateUnrealizedCheckpoints "realizes" the unrealized justified and finalized
 // epochs stored within nodes. It should be called at the beginning of each epoch.
 func (f *ForkChoice) updateUnrealizedCheckpoints(ctx context.Context) error {
-	for _, node := range f.store.nodeByRoot {
-		node.justifiedEpoch = node.unrealizedJustifiedEpoch
-		node.finalizedEpoch = node.unrealizedFinalizedEpoch
-		if node.justifiedEpoch > f.store.justifiedCheckpoint.Epoch {
+	for _, node := range f.store.emptyNodeByRoot {
+		node.block.justifiedEpoch = node.block.unrealizedJustifiedEpoch
+		node.block.finalizedEpoch = node.block.unrealizedFinalizedEpoch
+		if node.block.justifiedEpoch > f.store.justifiedCheckpoint.Epoch {
 			f.store.prevJustifiedCheckpoint = f.store.justifiedCheckpoint
 			f.store.justifiedCheckpoint = f.store.unrealizedJustifiedCheckpoint
 			if err := f.updateJustifiedBalances(ctx, f.store.justifiedCheckpoint.Root); err != nil {
 				return errors.Wrap(err, "could not update justified balances")
 			}
 		}
-		if node.finalizedEpoch > f.store.finalizedCheckpoint.Epoch {
+		if node.block.finalizedEpoch > f.store.finalizedCheckpoint.Epoch {
 			f.store.finalizedCheckpoint = f.store.unrealizedFinalizedCheckpoint
 		}
 	}
 	return nil
 }
 
-func (s *Store) pullTips(state state.BeaconState, node *Node, jc, fc *ethpb.Checkpoint) (*ethpb.Checkpoint, *ethpb.Checkpoint) {
+func (s *Store) pullTips(state state.BeaconState, node *BlockNode, jc, fc *ethpb.Checkpoint) (*ethpb.Checkpoint, *ethpb.Checkpoint) {
 	if node.parent == nil { // Nothing to do if the parent is nil.
 		return jc, fc
 	}
 	currentEpoch := slots.ToEpoch(slots.CurrentSlot(s.genesisTime))
 	stateSlot := state.Slot()
 	stateEpoch := slots.ToEpoch(stateSlot)
-	currJustified := node.parent.unrealizedJustifiedEpoch == currentEpoch
-	prevJustified := node.parent.unrealizedJustifiedEpoch+1 == currentEpoch
+	currJustified := node.parent.block.unrealizedJustifiedEpoch == currentEpoch
+	prevJustified := node.parent.block.unrealizedJustifiedEpoch+1 == currentEpoch
 	tooEarlyForCurr := slots.SinceEpochStarts(stateSlot)*3 < params.BeaconConfig().SlotsPerEpoch*2
 	// Exit early if it's justified or too early to be justified.
 	if currJustified || (stateEpoch == currentEpoch && prevJustified && tooEarlyForCurr) {
-		node.unrealizedJustifiedEpoch = node.parent.unrealizedJustifiedEpoch
-		node.unrealizedFinalizedEpoch = node.parent.unrealizedFinalizedEpoch
+		node.unrealizedJustifiedEpoch = node.parent.block.unrealizedJustifiedEpoch
+		node.unrealizedFinalizedEpoch = node.parent.block.unrealizedFinalizedEpoch
 		return jc, fc
 	}
 

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

@@ -14,21 +14,21 @@ import (
 func TestStore_SetUnrealizedEpochs(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	require.Equal(t, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'b'}].unrealizedJustifiedEpoch)
-	require.Equal(t, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'b'}].unrealizedFinalizedEpoch)
+	require.Equal(t, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'b'}].block.unrealizedJustifiedEpoch)
+	require.Equal(t, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'b'}].block.unrealizedFinalizedEpoch)
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'b'}, 2))
 	require.NoError(t, f.store.setUnrealizedFinalizedEpoch([32]byte{'b'}, 2))
-	require.Equal(t, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'b'}].unrealizedJustifiedEpoch)
-	require.Equal(t, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'b'}].unrealizedFinalizedEpoch)
+	require.Equal(t, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'b'}].block.unrealizedJustifiedEpoch)
+	require.Equal(t, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'b'}].block.unrealizedFinalizedEpoch)
 
 	require.ErrorIs(t, errInvalidUnrealizedJustifiedEpoch, f.store.setUnrealizedJustifiedEpoch([32]byte{'b'}, 0))
 	require.ErrorIs(t, errInvalidUnrealizedFinalizedEpoch, f.store.setUnrealizedFinalizedEpoch([32]byte{'b'}, 0))
@@ -37,13 +37,13 @@ func TestStore_SetUnrealizedEpochs(t *testing.T) {
 func TestStore_UpdateUnrealizedCheckpoints(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
@@ -64,14 +64,14 @@ func TestStore_UpdateUnrealizedCheckpoints(t *testing.T) {
 func TestStore_LongFork(t *testing.T) {
 	f := setup(1, 1)
 	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 75, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 75, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 80, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 80, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'b'}, 2))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 95, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 95, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'c'}, 2))
@@ -79,28 +79,28 @@ func TestStore_LongFork(t *testing.T) {
 	// Add an attestation to c, it is head
 	f.ProcessAttestation(ctx, []uint64{0}, [32]byte{'c'}, 1)
 	f.justifiedBalances = []uint64{100}
-	c := f.store.nodeByRoot[[32]byte{'c'}]
-	require.Equal(t, primitives.Epoch(2), slots.ToEpoch(c.slot))
-	driftGenesisTime(f, c.slot, 0)
+	c := f.store.emptyNodeByRoot[[32]byte{'c'}]
+	require.Equal(t, primitives.Epoch(2), slots.ToEpoch(c.block.slot))
+	driftGenesisTime(f, c.block.slot, 0)
 	headRoot, err := f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
 
 	// c remains the head even if a block d with higher realized justification is seen
 	ha := [32]byte{'a'}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'b'}, [32]byte{'D'}, 2, 1)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 103, [32]byte{'d'}, [32]byte{'b'}, [32]byte{'D'}, 2, 1)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{Epoch: 2, Root: ha}))
-	d := f.store.nodeByRoot[[32]byte{'d'}]
-	require.Equal(t, primitives.Epoch(3), slots.ToEpoch(d.slot))
-	driftGenesisTime(f, d.slot, 0)
-	require.Equal(t, true, d.viableForHead(f.store.justifiedCheckpoint.Epoch, slots.ToEpoch(d.slot)))
+	d := f.store.emptyNodeByRoot[[32]byte{'d'}]
+	require.Equal(t, primitives.Epoch(3), slots.ToEpoch(d.block.slot))
+	driftGenesisTime(f, d.block.slot, 0)
+	require.Equal(t, true, d.viableForHead(f.store.justifiedCheckpoint.Epoch, slots.ToEpoch(d.block.slot)))
 	headRoot, err = f.Head(ctx)
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'c'}, headRoot)
-	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'c'}].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
+	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'c'}].weight)
 }
 
 //	Epoch 1                Epoch 2               Epoch 3
@@ -119,36 +119,36 @@ func TestStore_NoDeadLock(t *testing.T) {
 	ctx := context.Background()
 
 	// Epoch 1 blocks
-	state, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 100, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 101, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 102, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 103, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	// Epoch 2 Blocks
-	state, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{'E'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 104, [32]byte{'e'}, [32]byte{'d'}, [32]byte{'E'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'e'}, 1))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 105, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'f'}, 1))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 106, [32]byte{'g'}, [32]byte{'f'}, [32]byte{'G'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 106, [32]byte{'g'}, [32]byte{'f'}, [32]byte{'G'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'g'}, 2))
 	require.NoError(t, f.store.setUnrealizedFinalizedEpoch([32]byte{'g'}, 1))
 	f.store.unrealizedJustifiedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 2}
 	f.store.unrealizedFinalizedCheckpoint = &forkchoicetypes.Checkpoint{Epoch: 1}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 107, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 0, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 107, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'h'}, 2))
@@ -166,7 +166,7 @@ func TestStore_NoDeadLock(t *testing.T) {
 
 	// Insert Block I, it becomes Head
 	hr := [32]byte{'i'}
-	state, blkRoot, err = prepareForkchoiceState(ctx, 108, hr, [32]byte{'f'}, [32]byte{'I'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 108, hr, [32]byte{'f'}, [32]byte{'I'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	ha := [32]byte{'a'}
@@ -201,27 +201,27 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	ctx := context.Background()
 
 	// Epoch 1 blocks (D does not arrive)
-	state, blkRoot, err := prepareForkchoiceState(ctx, 92, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 0)
+	state, blkRoot, err := prepareForkchoiceState(ctx, f, 92, [32]byte{'a'}, params.BeaconConfig().ZeroHash, [32]byte{'A'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 93, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 93, [32]byte{'b'}, [32]byte{'a'}, [32]byte{'B'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 94, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 94, [32]byte{'c'}, [32]byte{'b'}, [32]byte{'C'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	// Epoch 2 blocks
-	state, blkRoot, err = prepareForkchoiceState(ctx, 96, [32]byte{'e'}, [32]byte{'c'}, [32]byte{'E'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 96, [32]byte{'e'}, [32]byte{'c'}, [32]byte{'E'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 97, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 97, [32]byte{'f'}, [32]byte{'e'}, [32]byte{'F'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 98, [32]byte{'g'}, [32]byte{'f'}, [32]byte{'G'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 98, [32]byte{'g'}, [32]byte{'f'}, [32]byte{'G'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	state, blkRoot, err = prepareForkchoiceState(ctx, 99, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 99, [32]byte{'h'}, [32]byte{'g'}, [32]byte{'H'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
@@ -234,7 +234,7 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.Equal(t, primitives.Epoch(1), f.JustifiedCheckpoint().Epoch)
 
 	// D arrives late, D is head
-	state, blkRoot, err = prepareForkchoiceState(ctx, 95, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 0)
+	state, blkRoot, err = prepareForkchoiceState(ctx, f, 95, [32]byte{'d'}, [32]byte{'c'}, [32]byte{'D'}, 1, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'d'}, 2))
@@ -244,8 +244,8 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'d'}, headRoot)
 	require.Equal(t, primitives.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'h'}].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
+	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].weight)
 	// Set current epoch to 3, and H's unrealized checkpoint. Check it's head
 	driftGenesisTime(f, 99, 0)
 	require.NoError(t, f.store.setUnrealizedJustifiedEpoch([32]byte{'h'}, 2))
@@ -253,89 +253,89 @@ func TestStore_ForkNextEpoch(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, [32]byte{'h'}, headRoot)
 	require.Equal(t, primitives.Epoch(2), f.JustifiedCheckpoint().Epoch)
-	require.Equal(t, uint64(0), f.store.nodeByRoot[[32]byte{'d'}].weight)
-	require.Equal(t, uint64(100), f.store.nodeByRoot[[32]byte{'h'}].weight)
+	require.Equal(t, uint64(0), f.store.emptyNodeByRoot[[32]byte{'d'}].weight)
+	require.Equal(t, uint64(100), f.store.emptyNodeByRoot[[32]byte{'h'}].weight)
 }
 
 func TestStore_PullTips_Heuristics(t *testing.T) {
 	ctx := context.Background()
 	t.Run("Current epoch is justified", func(tt *testing.T) {
 		f := setup(1, 1)
-		st, root, err := prepareForkchoiceState(ctx, 65, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
+		st, root, err := prepareForkchoiceState(ctx, f, 65, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.emptyNodeByRoot[[32]byte{'p'}].block.unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 66, 0)
 
-		st, root, err = prepareForkchoiceState(ctx, 66, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
+		st, root, err = prepareForkchoiceState(ctx, f, 66, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		require.Equal(tt, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
-		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedFinalizedEpoch)
+		require.Equal(tt, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedFinalizedEpoch)
 	})
 
 	t.Run("Previous Epoch is justified and too early for current", func(tt *testing.T) {
 		f := setup(1, 1)
-		st, root, err := prepareForkchoiceState(ctx, 95, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
+		st, root, err := prepareForkchoiceState(ctx, f, 95, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.emptyNodeByRoot[[32]byte{'p'}].block.unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 96, 0)
 
-		st, root, err = prepareForkchoiceState(ctx, 96, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
+		st, root, err = prepareForkchoiceState(ctx, f, 96, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		require.Equal(tt, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
-		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedFinalizedEpoch)
+		require.Equal(tt, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedFinalizedEpoch)
 	})
 	t.Run("Previous Epoch is justified and not too early for current", func(tt *testing.T) {
 		f := setup(1, 1)
-		st, root, err := prepareForkchoiceState(ctx, 95, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
+		st, root, err := prepareForkchoiceState(ctx, f, 95, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.emptyNodeByRoot[[32]byte{'p'}].block.unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 127, 0)
 
-		st, root, err = prepareForkchoiceState(ctx, 127, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
+		st, root, err = prepareForkchoiceState(ctx, f, 127, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
 		// Check that the justification point is not the parent's.
 		// This test checks that the heuristics in pullTips did not apply and
 		// the test continues to compute a bogus unrealized
 		// justification
-		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedJustifiedEpoch)
 	})
 	t.Run("Block from previous Epoch", func(tt *testing.T) {
 		f := setup(1, 1)
-		st, root, err := prepareForkchoiceState(ctx, 94, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
+		st, root, err := prepareForkchoiceState(ctx, f, 94, [32]byte{'p'}, [32]byte{}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
-		f.store.nodeByRoot[[32]byte{'p'}].unrealizedJustifiedEpoch = primitives.Epoch(2)
+		f.store.emptyNodeByRoot[[32]byte{'p'}].block.unrealizedJustifiedEpoch = primitives.Epoch(2)
 		driftGenesisTime(f, 96, 0)
 
-		st, root, err = prepareForkchoiceState(ctx, 95, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
+		st, root, err = prepareForkchoiceState(ctx, f, 95, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 1, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
 		// Check that the justification point is not the parent's.
 		// This test checks that the heuristics in pullTips did not apply and
 		// the test continues to compute a bogus unrealized
 		// justification
-		require.Equal(tt, primitives.Epoch(1), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(1), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedJustifiedEpoch)
 	})
 	t.Run("Previous Epoch is not justified", func(tt *testing.T) {
 		f := setup(1, 1)
-		st, root, err := prepareForkchoiceState(ctx, 128, [32]byte{'p'}, [32]byte{}, [32]byte{}, 2, 1)
+		st, root, err := prepareForkchoiceState(ctx, f, 128, [32]byte{'p'}, [32]byte{}, [32]byte{}, 2, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
 		driftGenesisTime(f, 129, 0)
 
-		st, root, err = prepareForkchoiceState(ctx, 129, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 2, 1)
+		st, root, err = prepareForkchoiceState(ctx, f, 129, [32]byte{'h'}, [32]byte{'p'}, [32]byte{}, 2, 1)
 		require.NoError(tt, err)
 		require.NoError(tt, f.InsertNode(ctx, st, root))
 		// Check that the justification point is not the parent's.
 		// This test checks that the heuristics in pullTips did not apply and
 		// the test continues to compute a bogus unrealized
 		// justification
-		require.Equal(tt, primitives.Epoch(2), f.store.nodeByRoot[[32]byte{'h'}].unrealizedJustifiedEpoch)
+		require.Equal(tt, primitives.Epoch(2), f.store.emptyNodeByRoot[[32]byte{'h'}].block.unrealizedJustifiedEpoch)
 	})
 }