feat: implement block_to_light_client_header (#14433)

* implement `block_to_light_client_header` upto Deneb

* update `CHANGELOG.md`

* refactor: remove unnecessary variables

* move functions to `core/light-client/lightclient.go`

* feat: add tests

* refactors

* add blinded beacon block support to tests

* revert "add blinded beacon block support to tests"

* add tests for blinded beacon block

* lint

* refactor: move common code outside of if-else

* fix dependencies

CHANGELOG.md

@@ -13,6 +13,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Light client support: Implement `ComputeFieldRootsForBlockBody`.
 - Light client support: Add light client database changes.
 - Light client support: Implement capella and deneb changes.
+- Light client support: Implement `BlockToLightClientHeaderXXX` functions upto Deneb
 
 ### Changed
 

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

@@ -30,7 +30,9 @@ go_test(
     deps = [
         ":go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

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

@@ -13,6 +13,7 @@ import (
 	"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"
@@ -551,3 +552,193 @@ func NewLightClientUpdateFromOptimisticUpdate(update *ethpbv2.LightClientOptimis
 		SignatureSlot:  update.SignatureSlot,
 	}
 }
+
+func ComputeTransactionsRoot(payload interfaces.ExecutionData) ([]byte, error) {
+	transactionsRoot, err := payload.TransactionsRoot()
+	if errors.Is(err, consensus_types.ErrUnsupportedField) {
+		transactions, err := payload.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")
+	}
+	return transactionsRoot, nil
+}
+
+func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
+	withdrawalsRoot, err := payload.WithdrawalsRoot()
+	if errors.Is(err, consensus_types.ErrUnsupportedField) {
+		withdrawals, err := payload.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")
+	}
+	return withdrawalsRoot, nil
+}
+
+func BlockToLightClientHeaderAltair(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeader, error) {
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	return &ethpbv2.LightClientHeader{
+		Beacon: &ethpbv1.BeaconBlockHeader{
+			Slot:          block.Block().Slot(),
+			ProposerIndex: block.Block().ProposerIndex(),
+			ParentRoot:    parentRoot[:],
+			StateRoot:     stateRoot[:],
+			BodyRoot:      bodyRoot[:],
+		},
+	}, nil
+}
+
+func BlockToLightClientHeaderCapella(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderCapella, error) {
+	if block.Version() != version.Capella {
+		return nil, fmt.Errorf("creating Capella light client header is not supported before Capella, invalid slot %d", block.Block().Slot())
+	}
+
+	payload, err := block.Block().Body().Execution()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload")
+	}
+
+	transactionsRoot, err := ComputeTransactionsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+	withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+
+	executionHeader := &v11.ExecutionPayloadHeaderCapella{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload proof")
+	}
+
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	return &ethpbv2.LightClientHeaderCapella{
+		Beacon: &ethpbv1.BeaconBlockHeader{
+			Slot:          block.Block().Slot(),
+			ProposerIndex: block.Block().ProposerIndex(),
+			ParentRoot:    parentRoot[:],
+			StateRoot:     stateRoot[:],
+			BodyRoot:      bodyRoot[:],
+		},
+		Execution:       executionHeader,
+		ExecutionBranch: executionPayloadProof,
+	}, nil
+}
+
+func BlockToLightClientHeaderDeneb(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderDeneb, error) {
+	epoch := slots.ToEpoch(block.Block().Slot())
+	if epoch < params.BeaconConfig().DenebForkEpoch {
+		return nil, fmt.Errorf("creating Deneb light client header is not supported before Deneb, invalid slot %d", block.Block().Slot())
+	}
+
+	payload, err := block.Block().Body().Execution()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload")
+	}
+
+	transactionsRoot, err := ComputeTransactionsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+	withdrawalsRoot, err := ComputeWithdrawalsRoot(payload)
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payload.BlobGasUsed()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get blob gas used")
+	}
+	excessBlobGas, err := payload.ExcessBlobGas()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get excess blob gas")
+	}
+
+	executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+		BlobGasUsed:      blobGasUsed,
+		ExcessBlobGas:    excessBlobGas,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(ctx, block.Block())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get execution payload proof")
+	}
+
+	parentRoot := block.Block().ParentRoot()
+	stateRoot := block.Block().StateRoot()
+	bodyRoot, err := block.Block().Body().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get body root")
+	}
+
+	return &ethpbv2.LightClientHeaderDeneb{
+		Beacon: &ethpbv1.BeaconBlockHeader{
+			Slot:          block.Block().Slot(),
+			ProposerIndex: block.Block().ProposerIndex(),
+			ParentRoot:    parentRoot[:],
+			StateRoot:     stateRoot[:],
+			BodyRoot:      bodyRoot[:],
+		},
+		Execution:       executionHeader,
+		ExecutionBranch: executionPayloadProof,
+	}, nil
+}

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

@@ -3,7 +3,11 @@ package light_client_test
 import (
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+
 	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"
 	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
@@ -12,7 +16,7 @@ import (
 )
 
 func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateCapella(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestCapella()
+	l := util.NewTestLightClient(t).SetupTestCapella(false)
 
 	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
 	require.NoError(t, err)
@@ -44,7 +48,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateAltair(t *test
 }
 
 func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateDeneb(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestDeneb()
+	l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
 	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
 	require.NoError(t, err)
@@ -59,7 +63,7 @@ func TestLightClient_NewLightClientOptimisticUpdateFromBeaconStateDeneb(t *testi
 	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
 }
 func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateCapella(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestCapella()
+	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")
@@ -112,7 +116,7 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateAltair(t *testin
 }
 
 func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateDeneb(t *testing.T) {
-	l := util.NewTestLightClient(t).SetupTestDeneb()
+	l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
 	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
 	require.NoError(t, err)
@@ -139,4 +143,251 @@ func TestLightClient_NewLightClientFinalityUpdateFromBeaconStateDeneb(t *testing
 	}
 }
 
+func TestLightClient_BlockToLightClientHeaderAltair(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestAltair()
+
+	header, err := lightClient.BlockToLightClientHeaderAltair(l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderCapella_NonBlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestCapella(false)
+
+	header, err := lightClient.BlockToLightClientHeaderCapella(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := light_client.ComputeTransactionsRoot(payload)
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := light_client.ComputeWithdrawalsRoot(payload)
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderCapella{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderCapella_BlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestCapella(true)
+
+	header, err := lightClient.BlockToLightClientHeaderCapella(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := payload.TransactionsRoot()
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := payload.WithdrawalsRoot()
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderCapella{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderDeneb_NonBlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestDeneb(false)
+
+	header, err := lightClient.BlockToLightClientHeaderDeneb(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := light_client.ComputeTransactionsRoot(payload)
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := light_client.ComputeWithdrawalsRoot(payload)
+	require.NoError(t, err)
+
+	blobGasUsed, err := payload.BlobGasUsed()
+	require.NoError(t, err)
+
+	excessBlobGas, err := payload.ExcessBlobGas()
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+		BlobGasUsed:      blobGasUsed,
+		ExcessBlobGas:    excessBlobGas,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
+func TestLightClient_BlockToLightClientHeaderDeneb_BlindedBeaconBlock(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestDeneb(true)
+
+	header, err := lightClient.BlockToLightClientHeaderDeneb(l.Ctx, l.Block)
+	require.NoError(t, err)
+	require.NotNil(t, header, "header is nil")
+
+	parentRoot := l.Block.Block().ParentRoot()
+	stateRoot := l.Block.Block().StateRoot()
+	bodyRoot, err := l.Block.Block().Body().HashTreeRoot()
+	require.NoError(t, err)
+
+	payload, err := l.Block.Block().Body().Execution()
+	require.NoError(t, err)
+
+	transactionsRoot, err := payload.TransactionsRoot()
+	require.NoError(t, err)
+
+	withdrawalsRoot, err := payload.WithdrawalsRoot()
+	require.NoError(t, err)
+
+	blobGasUsed, err := payload.BlobGasUsed()
+	require.NoError(t, err)
+
+	excessBlobGas, err := payload.ExcessBlobGas()
+	require.NoError(t, err)
+
+	executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+		ParentHash:       payload.ParentHash(),
+		FeeRecipient:     payload.FeeRecipient(),
+		StateRoot:        payload.StateRoot(),
+		ReceiptsRoot:     payload.ReceiptsRoot(),
+		LogsBloom:        payload.LogsBloom(),
+		PrevRandao:       payload.PrevRandao(),
+		BlockNumber:      payload.BlockNumber(),
+		GasLimit:         payload.GasLimit(),
+		GasUsed:          payload.GasUsed(),
+		Timestamp:        payload.Timestamp(),
+		ExtraData:        payload.ExtraData(),
+		BaseFeePerGas:    payload.BaseFeePerGas(),
+		BlockHash:        payload.BlockHash(),
+		TransactionsRoot: transactionsRoot,
+		WithdrawalsRoot:  withdrawalsRoot,
+		BlobGasUsed:      blobGasUsed,
+		ExcessBlobGas:    excessBlobGas,
+	}
+
+	executionPayloadProof, err := blocks.PayloadProof(l.Ctx, l.Block.Block())
+	require.NoError(t, err)
+
+	require.Equal(t, l.Block.Block().Slot(), header.Beacon.Slot, "Slot is not equal")
+	require.Equal(t, l.Block.Block().ProposerIndex(), header.Beacon.ProposerIndex, "Proposer index is not equal")
+	require.DeepSSZEqual(t, parentRoot[:], header.Beacon.ParentRoot, "Parent root is not equal")
+	require.DeepSSZEqual(t, stateRoot[:], header.Beacon.StateRoot, "State root is not equal")
+	require.DeepSSZEqual(t, bodyRoot[:], header.Beacon.BodyRoot, "Body root is not equal")
+
+	require.DeepSSZEqual(t, executionHeader, header.Execution, "Execution headers are not equal")
+
+	require.DeepSSZEqual(t, executionPayloadProof, header.ExecutionBranch, "Execution payload proofs are not equal")
+}
+
 // TODO - add finality update tests with non-nil finalized block for different versions

testing/util/lightclient.go

@@ -28,7 +28,7 @@ func NewTestLightClient(t *testing.T) *TestLightClient {
 	return &TestLightClient{T: t}
 }
 
-func (l *TestLightClient) SetupTestCapella() *TestLightClient {
+func (l *TestLightClient) SetupTestCapella(blinded bool) *TestLightClient {
 	ctx := context.Background()
 
 	slot := primitives.Slot(params.BeaconConfig().CapellaForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
@@ -66,30 +66,57 @@ func (l *TestLightClient) SetupTestCapella() *TestLightClient {
 	parentRoot, err := signedParent.Block().HashTreeRoot()
 	require.NoError(l.T, err)
 
-	block := NewBeaconBlockCapella()
-	block.Block.Slot = slot
-	block.Block.ParentRoot = parentRoot[:]
+	var signedBlock interfaces.SignedBeaconBlock
+	if blinded {
+		block := NewBlindedBeaconBlockCapella()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
 
-	for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
-		block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(l.T, err)
+
+		err = state.SetLatestBlockHeader(h.Header)
+		require.NoError(l.T, err)
+		stateRoot, err := state.HashTreeRoot(ctx)
+		require.NoError(l.T, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
+	} else {
+		block := NewBeaconBlockCapella()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
+
+		for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(l.T, err)
+
+		err = state.SetLatestBlockHeader(h.Header)
+		require.NoError(l.T, err)
+		stateRoot, err := state.HashTreeRoot(ctx)
+		require.NoError(l.T, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
 	}
 
-	signedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.T, err)
-
-	h, err := signedBlock.Header()
-	require.NoError(l.T, err)
-
-	err = state.SetLatestBlockHeader(h.Header)
-	require.NoError(l.T, err)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	require.NoError(l.T, err)
-
-	// get a new signed block so the root is updated with the new state root
-	block.Block.StateRoot = stateRoot[:]
-	signedBlock, err = blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.T, err)
-
 	l.State = state
 	l.AttestedState = attestedState
 	l.AttestedHeader = attestedHeader
@@ -170,7 +197,7 @@ func (l *TestLightClient) SetupTestAltair() *TestLightClient {
 	return l
 }
 
-func (l *TestLightClient) SetupTestDeneb() *TestLightClient {
+func (l *TestLightClient) SetupTestDeneb(blinded bool) *TestLightClient {
 	ctx := context.Background()
 
 	slot := primitives.Slot(params.BeaconConfig().DenebForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
@@ -208,30 +235,57 @@ func (l *TestLightClient) SetupTestDeneb() *TestLightClient {
 	parentRoot, err := signedParent.Block().HashTreeRoot()
 	require.NoError(l.T, err)
 
-	block := NewBeaconBlockDeneb()
-	block.Block.Slot = slot
-	block.Block.ParentRoot = parentRoot[:]
+	var signedBlock interfaces.SignedBeaconBlock
+	if blinded {
+		block := NewBlindedBeaconBlockDeneb()
+		block.Message.Slot = slot
+		block.Message.ParentRoot = parentRoot[:]
 
-	for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
-		block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
+			block.Message.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(l.T, err)
+
+		err = state.SetLatestBlockHeader(h.Header)
+		require.NoError(l.T, err)
+		stateRoot, err := state.HashTreeRoot(ctx)
+		require.NoError(l.T, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Message.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
+	} else {
+		block := NewBeaconBlockDeneb()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
+
+		for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(l.T, err)
+
+		err = state.SetLatestBlockHeader(h.Header)
+		require.NoError(l.T, err)
+		stateRoot, err := state.HashTreeRoot(ctx)
+		require.NoError(l.T, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(l.T, err)
 	}
 
-	signedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.T, err)
-
-	h, err := signedBlock.Header()
-	require.NoError(l.T, err)
-
-	err = state.SetLatestBlockHeader(h.Header)
-	require.NoError(l.T, err)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	require.NoError(l.T, err)
-
-	// get a new signed block so the root is updated with the new state root
-	block.Block.StateRoot = stateRoot[:]
-	signedBlock, err = blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.T, err)
-
 	l.State = state
 	l.AttestedState = attestedState
 	l.AttestedHeader = attestedHeader