Fix lc execution header bug (#14468)

* create finalized header based on finalized block version

* changelog entry

* pass attested block from handlers

* fix core tests

* add test for attested header exectution fields

* changelog entry

* remove unused functions

* Update beacon-chain/core/light-client/lightclient.go

Co-authored-by: Radosław Kapka <radoslaw.kapka@gmail.com>

* Update beacon-chain/core/light-client/lightclient.go

Co-authored-by: Radosław Kapka <radoslaw.kapka@gmail.com>

* Update beacon-chain/core/light-client/lightclient.go

Co-authored-by: Radosław Kapka <radoslaw.kapka@gmail.com>

* remove finalized header from default update

* remove unused functions

* bazel deps

---------

Co-authored-by: Radosław Kapka <radoslaw.kapka@gmail.com>

CHANGELOG.md

@@ -69,6 +69,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Core: Fixed extra allocations when processing slashings.
 - remove unneeded container in blob sidecar ssz response
 - Light client support: create finalized header based on finalizedBlock's version, not attestedBlock.
+- Light client support: fix light client attested header execution fields' wrong version bug.
 - Testing: added custom matcher for better push settings testing.
 
 ### Security

api/server/structs/conversions_lightclient.go

@@ -84,6 +84,11 @@ func syncAggregateToJSON(input *v1.SyncAggregate) *SyncAggregate {
 }
 
 func lightClientHeaderContainerToJSON(container *v2.LightClientHeaderContainer) (json.RawMessage, error) {
+	// In the case that a finalizedHeader is nil.
+	if container == nil {
+		return nil, nil
+	}
+
 	beacon, err := container.GetBeacon()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get beacon block header")

beacon-chain/blockchain/process_block_helpers.go

@@ -162,6 +162,10 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	postState state.BeaconState) (int, error) {
 	// Get attested state
 	attestedRoot := signed.Block().ParentRoot()
+	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
+	if err != nil {
+		return 0, errors.Wrap(err, "could not get attested block")
+	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get attested state")
@@ -183,6 +187,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		postState,
 		signed,
 		attestedState,
+		attestedBlock,
 		finalizedBlock,
 	)
 
@@ -208,6 +213,10 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	postState state.BeaconState) (int, error) {
 	// Get attested state
 	attestedRoot := signed.Block().ParentRoot()
+	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
+	if err != nil {
+		return 0, errors.Wrap(err, "could not get attested block")
+	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get attested state")
@@ -218,6 +227,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 		postState,
 		signed,
 		attestedState,
+		attestedBlock,
 	)
 
 	if err != nil {

beacon-chain/core/light-client/BUILD.bazel

@@ -12,12 +12,10 @@ go_library(
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
-        "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
-        "//proto/migration:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
@@ -30,10 +28,8 @@ go_test(
     deps = [
         ":go_default_library",
         "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//testing/require:go_default_library",

beacon-chain/core/light-client/lightclient.go

@@ -13,15 +13,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v5/proto/migration"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 )
 
 const (
@@ -74,9 +70,10 @@ func NewLightClientFinalityUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*ethpbv2.LightClientFinalityUpdate, error) {
-	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -89,8 +86,9 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*ethpbv2.LightClientOptimisticUpdate, error) {
-	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, nil)
+	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, nil)
 	if err != nil {
 		return nil, err
 	}
@@ -160,6 +158,7 @@ func NewLightClientUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientUpdate, error) {
 	// assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH
 	attestedEpoch := slots.ToEpoch(attestedState.Slot())
@@ -223,73 +222,30 @@ func NewLightClientUpdateFromBeaconState(
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get attested header root")
 	}
-	if attestedHeaderRoot != block.Block().ParentRoot() {
-		return nil, fmt.Errorf("attested header root %#x not equal to block parent root %#x", attestedHeaderRoot, block.Block().ParentRoot())
+	attestedBlockRoot, err := attestedBlock.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get attested block root")
+	}
+	// assert hash_tree_root(attested_header) == hash_tree_root(attested_block.message) == block.message.parent_root
+	if attestedHeaderRoot != block.Block().ParentRoot() || attestedHeaderRoot != attestedBlockRoot {
+		return nil, fmt.Errorf("attested header root %#x not equal to block parent root %#x or attested block root %#x", attestedHeaderRoot, block.Block().ParentRoot(), attestedBlockRoot)
 	}
 
-	// update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
-	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(attestedHeader.Slot))
+	// update_attested_period = compute_sync_committee_period_at_slot(attested_block.message.slot)
+	updateAttestedPeriod := slots.SyncCommitteePeriod(slots.ToEpoch(attestedBlock.Block().Slot()))
 
 	// update = LightClientUpdate()
-	result, err := createDefaultLightClientUpdate(block.Block().Version())
+	result, err := createDefaultLightClientUpdate()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not create default light client update")
 	}
 
 	// update.attested_header = block_to_light_client_header(attested_block)
-	blockHeader := &ethpbv1.BeaconBlockHeader{
-		Slot:          attestedHeader.Slot,
-		ProposerIndex: attestedHeader.ProposerIndex,
-		ParentRoot:    attestedHeader.ParentRoot,
-		StateRoot:     attestedHeader.StateRoot,
-		BodyRoot:      attestedHeader.BodyRoot,
-	}
-	switch block.Block().Version() {
-	case version.Altair, version.Bellatrix:
-		result.AttestedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-				HeaderAltair: &ethpbv2.LightClientHeader{Beacon: blockHeader},
-			},
-		}
-	case version.Capella:
-		executionPayloadHeader, err := getExecutionPayloadHeaderCapella(block)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get execution payload header")
-		}
-		executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get execution payload proof")
-		}
-		result.AttestedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
-				HeaderCapella: &ethpbv2.LightClientHeaderCapella{
-					Beacon:          blockHeader,
-					Execution:       executionPayloadHeader,
-					ExecutionBranch: executionPayloadProof,
-				},
-			},
-		}
-	case version.Deneb:
-		executionPayloadHeader, err := getExecutionPayloadHeaderDeneb(block)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get execution payload header")
-		}
-		executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get execution payload proof")
-		}
-		result.AttestedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
-				HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
-					Beacon:          blockHeader,
-					Execution:       executionPayloadHeader,
-					ExecutionBranch: executionPayloadProof,
-				},
-			},
-		}
-	default:
-		return nil, fmt.Errorf("unsupported block version %s", version.String(block.Block().Version()))
+	attestedLightClientHeader, err := BlockToLightClientHeader(attestedBlock)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get attested light client header")
 	}
+	result.AttestedHeader = attestedLightClientHeader
 
 	// if update_attested_period == update_signature_period
 	if updateAttestedPeriod == updateSignaturePeriod {
@@ -319,70 +275,11 @@ func NewLightClientUpdateFromBeaconState(
 		// if finalized_block.message.slot != GENESIS_SLOT
 		if finalizedBlock.Block().Slot() != 0 {
 			// update.finalized_header = block_to_light_client_header(finalized_block)
-			v1alpha1FinalizedHeader, err := finalizedBlock.Header()
+			finalizedLightClientHeader, err := BlockToLightClientHeader(finalizedBlock)
 			if err != nil {
-				return nil, errors.Wrap(err, "could not get finalized header")
-			}
-			finalizedHeader := migration.V1Alpha1SignedHeaderToV1(v1alpha1FinalizedHeader).GetMessage()
-			finalizedHeaderRoot, err := finalizedHeader.HashTreeRoot()
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get finalized header root")
-			}
-			switch finalizedBlock.Block().Version() {
-			case version.Altair, version.Bellatrix:
-				result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: finalizedHeader},
-					},
-				}
-			case version.Capella:
-				executionPayloadHeader, err := getExecutionPayloadHeaderCapella(finalizedBlock)
-				if err != nil {
-					return nil, errors.Wrap(err, "could not get execution payload header")
-				}
-				executionPayloadProof, err := blocks.PayloadProof(ctx, finalizedBlock.Block())
-				if err != nil {
-					return nil, errors.Wrap(err, "could not get execution payload proof")
-				}
-				result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
-						HeaderCapella: &ethpbv2.LightClientHeaderCapella{
-							Beacon:          finalizedHeader,
-							Execution:       executionPayloadHeader,
-							ExecutionBranch: executionPayloadProof,
-						},
-					},
-				}
-			case version.Deneb:
-				executionPayloadHeader, err := getExecutionPayloadHeaderDeneb(finalizedBlock)
-				if err != nil {
-					return nil, errors.Wrap(err, "could not get execution payload header")
-				}
-				executionPayloadProof, err := blocks.PayloadProof(ctx, finalizedBlock.Block())
-				if err != nil {
-					return nil, errors.Wrap(err, "could not get execution payload proof")
-				}
-				result.FinalizedHeader = &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
-						HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
-							Beacon:          finalizedHeader,
-							Execution:       executionPayloadHeader,
-							ExecutionBranch: executionPayloadProof,
-						},
-					},
-				}
-			default:
-				return nil, fmt.Errorf("unsupported block version %s", version.String(block.Block().Version()))
-			}
-
-			// assert hash_tree_root(update.finalized_header.beacon) == attested_state.finalized_checkpoint.root
-			if finalizedHeaderRoot != bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root) {
-				return nil, fmt.Errorf(
-					"finalized header root %#x not equal to attested finalized checkpoint root %#x",
-					finalizedHeaderRoot,
-					bytesutil.ToBytes32(attestedState.FinalizedCheckpoint().Root),
-				)
+				return nil, errors.Wrap(err, "could not get finalized light client header")
 			}
+			result.FinalizedHeader = finalizedLightClientHeader
 		} else {
 			// assert attested_state.finalized_checkpoint.root == Bytes32()
 			if !bytes.Equal(attestedState.FinalizedCheckpoint().Root, make([]byte, 32)) {
@@ -411,7 +308,7 @@ func NewLightClientUpdateFromBeaconState(
 	return result, nil
 }
 
-func createDefaultLightClientUpdate(v int) (*ethpbv2.LightClientUpdate, error) {
+func createDefaultLightClientUpdate() (*ethpbv2.LightClientUpdate, error) {
 	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize
 	pubKeys := make([][]byte, syncCommitteeSize)
 	for i := uint64(0); i < syncCommitteeSize; i++ {
@@ -429,210 +326,18 @@ func createDefaultLightClientUpdate(v int) (*ethpbv2.LightClientUpdate, error) {
 	for i := 0; i < executionBranchNumOfLeaves; i++ {
 		executionBranch[i] = make([]byte, 32)
 	}
-	finalizedBlockHeader := &ethpbv1.BeaconBlockHeader{
-		Slot:          0,
-		ProposerIndex: 0,
-		ParentRoot:    make([]byte, 32),
-		StateRoot:     make([]byte, 32),
-		BodyRoot:      make([]byte, 32),
-	}
 	finalityBranch := make([][]byte, FinalityBranchNumOfLeaves)
 	for i := 0; i < FinalityBranchNumOfLeaves; i++ {
 		finalityBranch[i] = make([]byte, 32)
 	}
 
-	var finalizedHeader *ethpbv2.LightClientHeaderContainer
-	switch v {
-	case version.Altair, version.Bellatrix:
-		finalizedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-				HeaderAltair: &ethpbv2.LightClientHeader{
-					Beacon: finalizedBlockHeader,
-				},
-			},
-		}
-	case version.Capella:
-		finalizedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
-				HeaderCapella: &ethpbv2.LightClientHeaderCapella{
-					Beacon:          finalizedBlockHeader,
-					Execution:       createEmptyExecutionPayloadHeaderCapella(),
-					ExecutionBranch: executionBranch,
-				},
-			},
-		}
-	case version.Deneb:
-		finalizedHeader = &ethpbv2.LightClientHeaderContainer{
-			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
-				HeaderDeneb: &ethpbv2.LightClientHeaderDeneb{
-					Beacon:          finalizedBlockHeader,
-					Execution:       createEmptyExecutionPayloadHeaderDeneb(),
-					ExecutionBranch: executionBranch,
-				},
-			},
-		}
-	default:
-		return nil, fmt.Errorf("unsupported block version %s", version.String(v))
-	}
-
 	return &ethpbv2.LightClientUpdate{
 		NextSyncCommittee:       nextSyncCommittee,
 		NextSyncCommitteeBranch: nextSyncCommitteeBranch,
-		FinalizedHeader:         finalizedHeader,
 		FinalityBranch:          finalityBranch,
 	}, nil
 }
 
-func createEmptyExecutionPayloadHeaderCapella() *enginev1.ExecutionPayloadHeaderCapella {
-	return &enginev1.ExecutionPayloadHeaderCapella{
-		ParentHash:       make([]byte, 32),
-		FeeRecipient:     make([]byte, 20),
-		StateRoot:        make([]byte, 32),
-		ReceiptsRoot:     make([]byte, 32),
-		LogsBloom:        make([]byte, 256),
-		PrevRandao:       make([]byte, 32),
-		BlockNumber:      0,
-		GasLimit:         0,
-		GasUsed:          0,
-		Timestamp:        0,
-		ExtraData:        make([]byte, 32),
-		BaseFeePerGas:    make([]byte, 32),
-		BlockHash:        make([]byte, 32),
-		TransactionsRoot: make([]byte, 32),
-		WithdrawalsRoot:  make([]byte, 32),
-	}
-}
-
-func createEmptyExecutionPayloadHeaderDeneb() *enginev1.ExecutionPayloadHeaderDeneb {
-	return &enginev1.ExecutionPayloadHeaderDeneb{
-		ParentHash:       make([]byte, 32),
-		FeeRecipient:     make([]byte, 20),
-		StateRoot:        make([]byte, 32),
-		ReceiptsRoot:     make([]byte, 32),
-		LogsBloom:        make([]byte, 256),
-		PrevRandao:       make([]byte, 32),
-		BlockNumber:      0,
-		GasLimit:         0,
-		GasUsed:          0,
-		Timestamp:        0,
-		ExtraData:        make([]byte, 32),
-		BaseFeePerGas:    make([]byte, 32),
-		BlockHash:        make([]byte, 32),
-		TransactionsRoot: make([]byte, 32),
-		WithdrawalsRoot:  make([]byte, 32),
-	}
-}
-
-func getExecutionPayloadHeaderCapella(block interfaces.ReadOnlySignedBeaconBlock) (*enginev1.ExecutionPayloadHeaderCapella, error) {
-	payloadInterface, err := block.Block().Body().Execution()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution data")
-	}
-	transactionsRoot, err := payloadInterface.TransactionsRoot()
-	if errors.Is(err, consensus_types.ErrUnsupportedField) {
-		transactions, err := payloadInterface.Transactions()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get transactions")
-		}
-		transactionsRootArray, err := ssz.TransactionsRoot(transactions)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get transactions root")
-		}
-		transactionsRoot = transactionsRootArray[:]
-	} else if err != nil {
-		return nil, errors.Wrap(err, "could not get transactions root")
-	}
-	withdrawalsRoot, err := payloadInterface.WithdrawalsRoot()
-	if errors.Is(err, consensus_types.ErrUnsupportedField) {
-		withdrawals, err := payloadInterface.Withdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals")
-		}
-		withdrawalsRootArray, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
-		withdrawalsRoot = withdrawalsRootArray[:]
-	} else if err != nil {
-		return nil, errors.Wrap(err, "could not get withdrawals root")
-	}
-
-	execution := &enginev1.ExecutionPayloadHeaderCapella{
-		ParentHash:       payloadInterface.ParentHash(),
-		FeeRecipient:     payloadInterface.FeeRecipient(),
-		StateRoot:        payloadInterface.StateRoot(),
-		ReceiptsRoot:     payloadInterface.ReceiptsRoot(),
-		LogsBloom:        payloadInterface.LogsBloom(),
-		PrevRandao:       payloadInterface.PrevRandao(),
-		BlockNumber:      payloadInterface.BlockNumber(),
-		GasLimit:         payloadInterface.GasLimit(),
-		GasUsed:          payloadInterface.GasUsed(),
-		Timestamp:        payloadInterface.Timestamp(),
-		ExtraData:        payloadInterface.ExtraData(),
-		BaseFeePerGas:    payloadInterface.BaseFeePerGas(),
-		BlockHash:        payloadInterface.BlockHash(),
-		TransactionsRoot: transactionsRoot,
-		WithdrawalsRoot:  withdrawalsRoot,
-	}
-
-	return execution, nil
-}
-
-func getExecutionPayloadHeaderDeneb(block interfaces.ReadOnlySignedBeaconBlock) (*enginev1.ExecutionPayloadHeaderDeneb, error) {
-	payloadInterface, err := block.Block().Body().Execution()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution data")
-	}
-	transactionsRoot, err := payloadInterface.TransactionsRoot()
-	if errors.Is(err, consensus_types.ErrUnsupportedField) {
-		transactions, err := payloadInterface.Transactions()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get transactions")
-		}
-		transactionsRootArray, err := ssz.TransactionsRoot(transactions)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get transactions root")
-		}
-		transactionsRoot = transactionsRootArray[:]
-	} else if err != nil {
-		return nil, errors.Wrap(err, "could not get transactions root")
-	}
-	withdrawalsRoot, err := payloadInterface.WithdrawalsRoot()
-	if errors.Is(err, consensus_types.ErrUnsupportedField) {
-		withdrawals, err := payloadInterface.Withdrawals()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals")
-		}
-		withdrawalsRootArray, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get withdrawals root")
-		}
-		withdrawalsRoot = withdrawalsRootArray[:]
-	} else if err != nil {
-		return nil, errors.Wrap(err, "could not get withdrawals root")
-	}
-
-	execution := &enginev1.ExecutionPayloadHeaderDeneb{
-		ParentHash:       payloadInterface.ParentHash(),
-		FeeRecipient:     payloadInterface.FeeRecipient(),
-		StateRoot:        payloadInterface.StateRoot(),
-		ReceiptsRoot:     payloadInterface.ReceiptsRoot(),
-		LogsBloom:        payloadInterface.LogsBloom(),
-		PrevRandao:       payloadInterface.PrevRandao(),
-		BlockNumber:      payloadInterface.BlockNumber(),
-		GasLimit:         payloadInterface.GasLimit(),
-		GasUsed:          payloadInterface.GasUsed(),
-		Timestamp:        payloadInterface.Timestamp(),
-		ExtraData:        payloadInterface.ExtraData(),
-		BaseFeePerGas:    payloadInterface.BaseFeePerGas(),
-		BlockHash:        payloadInterface.BlockHash(),
-		TransactionsRoot: transactionsRoot,
-		WithdrawalsRoot:  withdrawalsRoot,
-	}
-
-	return execution, nil
-}
-
 func ComputeTransactionsRoot(payload interfaces.ExecutionData) ([]byte, error) {
 	transactionsRoot, err := payload.TransactionsRoot()
 	if errors.Is(err, consensus_types.ErrUnsupportedField) {
@@ -669,6 +374,45 @@ func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
 	return withdrawalsRoot, nil
 }
 
+func BlockToLightClientHeader(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderContainer, error) {
+	switch block.Version() {
+	case version.Altair, version.Bellatrix:
+		altairHeader, err := BlockToLightClientHeaderAltair(block)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get header")
+		}
+		return &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
+				HeaderAltair: altairHeader,
+			},
+		}, nil
+	case version.Capella:
+		capellaHeader, err := BlockToLightClientHeaderCapella(context.Background(), block)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get capella header")
+		}
+		return &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderCapella{
+				HeaderCapella: capellaHeader,
+			},
+		}, nil
+	case version.Deneb:
+		denebHeader, err := BlockToLightClientHeaderDeneb(context.Background(), block)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get deneb header")
+		}
+		return &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
+				HeaderDeneb: denebHeader,
+			},
+		}, nil
+	default:
+		return nil, fmt.Errorf("unsupported block version %s", version.String(block.Version()))
+	}
+}
+
+// TODO: make below functions private
+
 func BlockToLightClientHeaderAltair(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeader, error) {
 	if block.Version() != version.Altair {
 		return nil, fmt.Errorf("block version is %s instead of Altair", version.String(block.Version()))

beacon-chain/core/light-client/lightclient_test.go

@@ -12,8 +12,6 @@ import (
 
 	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	light_client "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
@@ -22,10 +20,9 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Altair", func(t *testing.T) {
 		l := util.NewTestLightClient(t).SetupTestAltair()
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
-
 		require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
 
 		l.CheckSyncAggregate(update.SyncAggregate)
@@ -35,7 +32,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Capella", func(t *testing.T) {
 		l := util.NewTestLightClient(t).SetupTestCapella(false)
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
 
@@ -48,7 +45,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T)
 	t.Run("Deneb", func(t *testing.T) {
 		l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
-		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
+		update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
 		require.NoError(t, err)
 		require.NotNil(t, update, "update is nil")
 
@@ -63,33 +60,8 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 	t.Run("Altair", func(t *testing.T) {
 		l := util.NewTestLightClient(t).SetupTestAltair()
 
-		t.Run("FinalizedBlock Nil", func(t *testing.T) {
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
-			require.NoError(t, err)
-			require.NotNil(t, update, "update is nil")
-
-			require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-			l.CheckSyncAggregate(update.SyncAggregate)
-			l.CheckAttestedHeader(update.AttestedHeader)
-
-			zeroHash := params.BeaconConfig().ZeroHash[:]
-			require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
-			updateFinalizedHeaderBeacon, err := update.FinalizedHeader.GetBeacon()
-			require.NoError(t, err)
-			require.Equal(t, primitives.Slot(0), updateFinalizedHeaderBeacon.Slot, "Finalized header slot is not zero")
-			require.Equal(t, primitives.ValidatorIndex(0), updateFinalizedHeaderBeacon.ProposerIndex, "Finalized header proposer index is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.ParentRoot, "Finalized header parent root is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.StateRoot, "Finalized header state root is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.BodyRoot, "Finalized header body root is not zero")
-			require.Equal(t, lightClient.FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
-			for _, leaf := range update.FinalityBranch {
-				require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
-			}
-		})
-
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -121,35 +93,10 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 	})
 
 	t.Run("Capella", func(t *testing.T) {
-		t.Run("FinalizedBlock Nil", func(t *testing.T) {
-			l := util.NewTestLightClient(t).SetupTestCapella(false)
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
-			require.NoError(t, err)
-			require.NotNil(t, update, "update is nil")
-
-			require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-			l.CheckSyncAggregate(update.SyncAggregate)
-			l.CheckAttestedHeader(update.AttestedHeader)
-
-			zeroHash := params.BeaconConfig().ZeroHash[:]
-			require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
-			updateFinalizedHeaderBeacon, err := update.FinalizedHeader.GetBeacon()
-			require.NoError(t, err)
-			require.Equal(t, primitives.Slot(0), updateFinalizedHeaderBeacon.Slot, "Finalized header slot is not zero")
-			require.Equal(t, primitives.ValidatorIndex(0), updateFinalizedHeaderBeacon.ProposerIndex, "Finalized header proposer index is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.ParentRoot, "Finalized header parent root is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.StateRoot, "Finalized header state root is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.BodyRoot, "Finalized header body root is not zero")
-			require.Equal(t, lightClient.FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
-			for _, leaf := range update.FinalityBranch {
-				require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
-			}
-		})
 
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
 			l := util.NewTestLightClient(t).SetupTestCapella(false)
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -220,7 +167,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 
 		t.Run("FinalizedBlock In Previous Fork", func(t *testing.T) {
 			l := util.NewTestLightClient(t).SetupTestCapellaFinalizedBlockAltair(false)
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -249,38 +196,11 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 	})
 
 	t.Run("Deneb", func(t *testing.T) {
-		t.Run("FinalizedBlock Nil", func(t *testing.T) {
-			l := util.NewTestLightClient(t).SetupTestDeneb(false)
-
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
-			require.NoError(t, err)
-			require.NotNil(t, update, "update is nil")
-
-			require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-			l.CheckSyncAggregate(update.SyncAggregate)
-			l.CheckAttestedHeader(update.AttestedHeader)
-
-			zeroHash := params.BeaconConfig().ZeroHash[:]
-			require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
-			updateFinalizedHeaderBeacon, err := update.FinalizedHeader.GetBeacon()
-			require.NoError(t, err)
-			require.Equal(t, primitives.Slot(0), updateFinalizedHeaderBeacon.Slot, "Finalized header slot is not zero")
-			require.Equal(t, primitives.ValidatorIndex(0), updateFinalizedHeaderBeacon.ProposerIndex, "Finalized header proposer index is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.ParentRoot, "Finalized header parent root is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.StateRoot, "Finalized header state root is not zero")
-			require.DeepSSZEqual(t, zeroHash, updateFinalizedHeaderBeacon.BodyRoot, "Finalized header body root is not zero")
-			require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.GetHeaderDeneb().Execution.BlockHash, "Execution BlockHash is not zero")
-			require.Equal(t, lightClient.FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
-			for _, leaf := range update.FinalityBranch {
-				require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
-			}
-		})
 
 		t.Run("FinalizedBlock Not Nil", func(t *testing.T) {
 			l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 
@@ -353,7 +273,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
 		t.Run("FinalizedBlock In Previous Fork", func(t *testing.T) {
 			l := util.NewTestLightClient(t).SetupTestDenebFinalizedBlockCapella(false)
 
-			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.FinalizedBlock)
+			update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
 			require.NoError(t, err)
 			require.NotNil(t, update, "update is nil")
 

beacon-chain/rpc/eth/light-client/handlers.go

@@ -204,6 +204,7 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 			state,
 			block,
 			attestedState,
+			attestedBlock,
 			finalizedBlock,
 		)
 
@@ -267,7 +268,7 @@ func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.R
 		return
 	}
 
-	update, err := newLightClientFinalityUpdateFromBeaconState(ctx, st, block, attestedState, finalizedBlock)
+	update, err := newLightClientFinalityUpdateFromBeaconState(ctx, st, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client finality update: "+err.Error(), http.StatusInternalServerError)
 		return
@@ -312,7 +313,7 @@ func (s *Server) GetLightClientOptimisticUpdate(w http.ResponseWriter, req *http
 		return
 	}
 
-	update, err := newLightClientOptimisticUpdateFromBeaconState(ctx, st, block, attestedState)
+	update, err := newLightClientOptimisticUpdateFromBeaconState(ctx, st, block, attestedState, attestedBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client optimistic update: "+err.Error(), http.StatusInternalServerError)
 		return

beacon-chain/rpc/eth/light-client/helpers.go

@@ -351,9 +351,10 @@ func newLightClientUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*structs.LightClientUpdate, error) {
-	result, err := lightclient.NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	result, err := lightclient.NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -366,9 +367,10 @@ func newLightClientFinalityUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*structs.LightClientFinalityUpdate, error) {
-	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -381,8 +383,9 @@ func newLightClientOptimisticUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
+	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*structs.LightClientOptimisticUpdate, error) {
-	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState)
+	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock)
 	if err != nil {
 		return nil, err
 	}

testing/util/BUILD.bazel

@@ -43,6 +43,7 @@ go_library(
         "//beacon-chain/state/stateutil:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -51,6 +52,7 @@ go_library(
         "//crypto/hash:go_default_library",
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//encoding/ssz:go_default_library",
         "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",

testing/util/lightclient.go

@@ -4,14 +4,20 @@ import (
 	"context"
 	"testing"
 
+	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
+	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
@@ -21,7 +27,7 @@ type TestLightClient struct {
 	State          state.BeaconState
 	Block          interfaces.ReadOnlySignedBeaconBlock
 	AttestedState  state.BeaconState
-	AttestedHeader *ethpb.BeaconBlockHeader
+	AttestedBlock  interfaces.ReadOnlySignedBeaconBlock
 	FinalizedBlock interfaces.ReadOnlySignedBeaconBlock
 }
 
@@ -133,7 +139,7 @@ func (l *TestLightClient) SetupTestCapella(blinded bool) *TestLightClient {
 
 	l.State = state
 	l.AttestedState = attestedState
-	l.AttestedHeader = attestedHeader
+	l.AttestedBlock = signedParent
 	l.Block = signedBlock
 	l.Ctx = ctx
 	l.FinalizedBlock = finalizedBlock
@@ -245,7 +251,7 @@ func (l *TestLightClient) SetupTestCapellaFinalizedBlockAltair(blinded bool) *Te
 
 	l.State = state
 	l.AttestedState = attestedState
-	l.AttestedHeader = attestedHeader
+	l.AttestedBlock = signedParent
 	l.Block = signedBlock
 	l.Ctx = ctx
 	l.FinalizedBlock = finalizedBlock
@@ -330,10 +336,10 @@ func (l *TestLightClient) SetupTestAltair() *TestLightClient {
 
 	l.State = state
 	l.AttestedState = attestedState
-	l.AttestedHeader = attestedHeader
 	l.Block = signedBlock
 	l.Ctx = ctx
 	l.FinalizedBlock = finalizedBlock
+	l.AttestedBlock = signedParent
 
 	return l
 }
@@ -442,7 +448,7 @@ func (l *TestLightClient) SetupTestDeneb(blinded bool) *TestLightClient {
 
 	l.State = state
 	l.AttestedState = attestedState
-	l.AttestedHeader = attestedHeader
+	l.AttestedBlock = signedParent
 	l.Block = signedBlock
 	l.Ctx = ctx
 	l.FinalizedBlock = finalizedBlock
@@ -554,7 +560,7 @@ func (l *TestLightClient) SetupTestDenebFinalizedBlockCapella(blinded bool) *Tes
 
 	l.State = state
 	l.AttestedState = attestedState
-	l.AttestedHeader = attestedHeader
+	l.AttestedBlock = signedParent
 	l.Block = signedBlock
 	l.Ctx = ctx
 	l.FinalizedBlock = finalizedBlock
@@ -565,14 +571,124 @@ func (l *TestLightClient) SetupTestDenebFinalizedBlockCapella(blinded bool) *Tes
 func (l *TestLightClient) CheckAttestedHeader(container *ethpbv2.LightClientHeaderContainer) {
 	updateAttestedHeaderBeacon, err := container.GetBeacon()
 	require.NoError(l.T, err)
-	require.Equal(l.T, l.AttestedHeader.Slot, updateAttestedHeaderBeacon.Slot, "Attested header slot is not equal")
-	require.Equal(l.T, l.AttestedHeader.ProposerIndex, updateAttestedHeaderBeacon.ProposerIndex, "Attested header proposer index is not equal")
-	require.DeepSSZEqual(l.T, l.AttestedHeader.ParentRoot, updateAttestedHeaderBeacon.ParentRoot, "Attested header parent root is not equal")
-	require.DeepSSZEqual(l.T, l.AttestedHeader.BodyRoot, updateAttestedHeaderBeacon.BodyRoot, "Attested header body root is not equal")
+	testAttestedHeader, err := l.AttestedBlock.Header()
+	require.NoError(l.T, err)
+	require.Equal(l.T, l.AttestedBlock.Block().Slot(), updateAttestedHeaderBeacon.Slot, "Attested block slot is not equal")
+	require.Equal(l.T, testAttestedHeader.Header.ProposerIndex, updateAttestedHeaderBeacon.ProposerIndex, "Attested block proposer index is not equal")
+	require.DeepSSZEqual(l.T, testAttestedHeader.Header.ParentRoot, updateAttestedHeaderBeacon.ParentRoot, "Attested block parent root is not equal")
+	require.DeepSSZEqual(l.T, testAttestedHeader.Header.BodyRoot, updateAttestedHeaderBeacon.BodyRoot, "Attested block body root is not equal")
 
 	attestedStateRoot, err := l.AttestedState.HashTreeRoot(l.Ctx)
 	require.NoError(l.T, err)
-	require.DeepSSZEqual(l.T, attestedStateRoot[:], updateAttestedHeaderBeacon.StateRoot, "Attested header state root is not equal")
+	require.DeepSSZEqual(l.T, attestedStateRoot[:], updateAttestedHeaderBeacon.StateRoot, "Attested block state root is not equal")
+
+	if l.AttestedBlock.Version() == version.Capella {
+		payloadInterface, err := l.AttestedBlock.Block().Body().Execution()
+		require.NoError(l.T, err)
+		transactionsRoot, err := payloadInterface.TransactionsRoot()
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			transactions, err := payloadInterface.Transactions()
+			require.NoError(l.T, err)
+			transactionsRootArray, err := ssz.TransactionsRoot(transactions)
+			require.NoError(l.T, err)
+			transactionsRoot = transactionsRootArray[:]
+		} else {
+			require.NoError(l.T, err)
+		}
+		withdrawalsRoot, err := payloadInterface.WithdrawalsRoot()
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			withdrawals, err := payloadInterface.Withdrawals()
+			require.NoError(l.T, err)
+			withdrawalsRootArray, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+			require.NoError(l.T, err)
+			withdrawalsRoot = withdrawalsRootArray[:]
+		} else {
+			require.NoError(l.T, err)
+		}
+		execution := &v11.ExecutionPayloadHeaderCapella{
+			ParentHash:       payloadInterface.ParentHash(),
+			FeeRecipient:     payloadInterface.FeeRecipient(),
+			StateRoot:        payloadInterface.StateRoot(),
+			ReceiptsRoot:     payloadInterface.ReceiptsRoot(),
+			LogsBloom:        payloadInterface.LogsBloom(),
+			PrevRandao:       payloadInterface.PrevRandao(),
+			BlockNumber:      payloadInterface.BlockNumber(),
+			GasLimit:         payloadInterface.GasLimit(),
+			GasUsed:          payloadInterface.GasUsed(),
+			Timestamp:        payloadInterface.Timestamp(),
+			ExtraData:        payloadInterface.ExtraData(),
+			BaseFeePerGas:    payloadInterface.BaseFeePerGas(),
+			BlockHash:        payloadInterface.BlockHash(),
+			TransactionsRoot: transactionsRoot,
+			WithdrawalsRoot:  withdrawalsRoot,
+		}
+
+		updateAttestedHeaderExecution, err := container.GetExecutionHeaderCapella()
+		require.NoError(l.T, err)
+		require.DeepSSZEqual(l.T, execution, updateAttestedHeaderExecution, "Attested Block Execution is not equal")
+
+		executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.AttestedBlock.Block())
+		require.NoError(l.T, err)
+		updateAttestedHeaderExecutionBranch, err := container.GetExecutionBranch()
+		require.NoError(l.T, err)
+		for i, leaf := range updateAttestedHeaderExecutionBranch {
+			require.DeepSSZEqual(l.T, executionPayloadProof[i], leaf, "Leaf is not equal")
+		}
+	}
+
+	if l.AttestedBlock.Version() == version.Deneb {
+		payloadInterface, err := l.AttestedBlock.Block().Body().Execution()
+		require.NoError(l.T, err)
+		transactionsRoot, err := payloadInterface.TransactionsRoot()
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			transactions, err := payloadInterface.Transactions()
+			require.NoError(l.T, err)
+			transactionsRootArray, err := ssz.TransactionsRoot(transactions)
+			require.NoError(l.T, err)
+			transactionsRoot = transactionsRootArray[:]
+		} else {
+			require.NoError(l.T, err)
+		}
+		withdrawalsRoot, err := payloadInterface.WithdrawalsRoot()
+		if errors.Is(err, consensus_types.ErrUnsupportedField) {
+			withdrawals, err := payloadInterface.Withdrawals()
+			require.NoError(l.T, err)
+			withdrawalsRootArray, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
+			require.NoError(l.T, err)
+			withdrawalsRoot = withdrawalsRootArray[:]
+		} else {
+			require.NoError(l.T, err)
+		}
+		execution := &v11.ExecutionPayloadHeaderDeneb{
+			ParentHash:       payloadInterface.ParentHash(),
+			FeeRecipient:     payloadInterface.FeeRecipient(),
+			StateRoot:        payloadInterface.StateRoot(),
+			ReceiptsRoot:     payloadInterface.ReceiptsRoot(),
+			LogsBloom:        payloadInterface.LogsBloom(),
+			PrevRandao:       payloadInterface.PrevRandao(),
+			BlockNumber:      payloadInterface.BlockNumber(),
+			GasLimit:         payloadInterface.GasLimit(),
+			GasUsed:          payloadInterface.GasUsed(),
+			Timestamp:        payloadInterface.Timestamp(),
+			ExtraData:        payloadInterface.ExtraData(),
+			BaseFeePerGas:    payloadInterface.BaseFeePerGas(),
+			BlockHash:        payloadInterface.BlockHash(),
+			TransactionsRoot: transactionsRoot,
+			WithdrawalsRoot:  withdrawalsRoot,
+		}
+
+		updateAttestedHeaderExecution, err := container.GetExecutionHeaderDeneb()
+		require.NoError(l.T, err)
+		require.DeepSSZEqual(l.T, execution, updateAttestedHeaderExecution, "Attested Block Execution is not equal")
+
+		executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.AttestedBlock.Block())
+		require.NoError(l.T, err)
+		updateAttestedHeaderExecutionBranch, err := container.GetExecutionBranch()
+		require.NoError(l.T, err)
+		for i, leaf := range updateAttestedHeaderExecutionBranch {
+			require.DeepSSZEqual(l.T, executionPayloadProof[i], leaf, "Leaf is not equal")
+		}
+	}
 }
 
 func (l *TestLightClient) CheckSyncAggregate(sa *ethpbv1.SyncAggregate) {