feat: introduce Capella and Deneb full-node.md lc changes

api/server/structs/endpoints_lightclient.go

@@ -4,17 +4,51 @@ type LightClientHeader struct {
 	Beacon *BeaconBlockHeader `json:"beacon"`
 }
 
+type LightClientHeaderCapella struct {
+	Beacon          *BeaconBlockHeader             `json:"beacon"`
+	Execution       *ExecutionPayloadHeaderCapella `json:"execution"`
+	ExecutionBranch [][]byte                       `json:"execution_branch"`
+}
+
+type LightClientHeaderDeneb struct {
+	Beacon          *BeaconBlockHeader           `json:"beacon"`
+	Execution       *ExecutionPayloadHeaderDeneb `json:"execution"`
+	ExecutionBranch [][]byte                     `json:"execution_branch"`
+}
+
 type LightClientBootstrapResponse struct {
 	Version string                `json:"version"`
 	Data    *LightClientBootstrap `json:"data"`
 }
 
+type LightClientBootstrapResponseCapella struct {
+	Version string                       `json:"version"`
+	Data    *LightClientBootstrapCapella `json:"data"`
+}
+
+type LightClientBootstrapResponseDeneb struct {
+	Version string                     `json:"version"`
+	Data    *LightClientBootstrapDeneb `json:"data"`
+}
+
 type LightClientBootstrap struct {
 	Header                     *LightClientHeader `json:"header"`
 	CurrentSyncCommittee       *SyncCommittee     `json:"current_sync_committee"`
 	CurrentSyncCommitteeBranch []string           `json:"current_sync_committee_branch"`
 }
 
+type LightClientBootstrapCapella struct {
+	Header                     *LightClientHeaderCapella `json:"header"`
+	CurrentSyncCommittee       *SyncCommittee            `json:"current_sync_committee"`
+	CurrentSyncCommitteeBranch []string                  `json:"current_sync_committee_branch"`
+}
+
+type LightClientBootstrapDeneb struct {
+	Header                     *LightClientHeaderDeneb `json:"header"`
+	CurrentSyncCommittee       *SyncCommittee          `json:"current_sync_committee"`
+	CurrentSyncCommitteeBranch []string                `json:"current_sync_committee_branch"`
+}
+
 type LightClientUpdate struct {
 	AttestedHeader          *BeaconBlockHeader `json:"attested_header"`
 	NextSyncCommittee       *SyncCommittee     `json:"next_sync_committee,omitempty"`

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

@@ -46,18 +46,52 @@ func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
-	bootstrap, err := createLightClientBootstrap(ctx, state)
-	if err != nil {
-		httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
+	ver := blk.Version()
+	if ver >= version.Deneb {
+		bootstrap, err := createLightClientBootstrapDeneb(ctx, state)
+		if err != nil {
+			httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		response := &structs.LightClientBootstrapResponseDeneb{
+			Version: version.String(blk.Version()),
+			Data:    bootstrap,
+		}
+
+		httputil.WriteJson(w, response)
 		return
 	}
 
-	response := &structs.LightClientBootstrapResponse{
-		Version: version.String(blk.Version()),
-		Data:    bootstrap,
+	if ver >= version.Capella {
+		bootstrap, err := createLightClientBootstrapCapella(ctx, state)
+		if err != nil {
+			httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		response := &structs.LightClientBootstrapResponseCapella{
+			Version: version.String(blk.Version()),
+			Data:    bootstrap,
+		}
+		httputil.WriteJson(w, response)
+		return
 	}
 
-	httputil.WriteJson(w, response)
+	if ver >= version.Altair {
+		bootstrap, err := createLightClientBootstrap(ctx, state)
+		if err != nil {
+			httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		response := &structs.LightClientBootstrapResponse{
+			Version: version.String(blk.Version()),
+			Data:    bootstrap,
+		}
+		httputil.WriteJson(w, response)
+		return
+	}
 }
 
 // GetLightClientUpdatesByRange - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/updates.yaml

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

@@ -26,7 +26,58 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
+func TestLightClientHandler_GetLightClientBootstrap_Altair(t *testing.T) {
+	helpers.ClearCache()
+	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
+
+	b := util.NewBeaconBlockAltair()
+	b.Block.StateRoot = bytesutil.PadTo([]byte("foo"), 32)
+	b.Block.Slot = slot
+
+	signedBlock, err := blocks.NewSignedBeaconBlock(b)
+
+	require.NoError(t, err)
+	header, err := signedBlock.Header()
+	require.NoError(t, err)
+
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	bs, err := util.NewBeaconStateAltair(func(state *ethpb.BeaconStateAltair) error {
+		state.BlockRoots[0] = r[:]
+		return nil
+	})
+	require.NoError(t, err)
+
+	require.NoError(t, bs.SetSlot(slot))
+	require.NoError(t, bs.SetLatestBlockHeader(header.Header))
+
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: signedBlock}
+	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+	s := &Server{
+		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+			slot: bs,
+		}},
+		Blocker:     mockBlocker,
+		HeadFetcher: mockChainService,
+	}
+	muxVars := make(map[string]string)
+	muxVars["block_root"] = hexutil.Encode(r[:])
+	request := httptest.NewRequest("GET", "http://foo.com/", nil)
+	request = mux.SetURLVars(request, muxVars)
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetLightClientBootstrap(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+	resp := &structs.LightClientBootstrapResponse{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, "altair", resp.Version)
+	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.Beacon.BodyRoot)
+	require.NotNil(t, resp.Data)
+}
+
+func TestLightClientHandler_GetLightClientBootstrap_Capella(t *testing.T) {
 	helpers.ClearCache()
 	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
 
@@ -70,13 +121,64 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 
 	s.GetLightClientBootstrap(writer, request)
 	require.Equal(t, http.StatusOK, writer.Code)
-	resp := &structs.LightClientBootstrapResponse{}
+	resp := &structs.LightClientBootstrapResponseCapella{}
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 	require.Equal(t, "capella", resp.Version)
 	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.Beacon.BodyRoot)
 	require.NotNil(t, resp.Data)
 }
 
+func TestLightClientHandler_GetLightClientBootstrap_Deneb(t *testing.T) {
+	helpers.ClearCache()
+	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
+
+	b := util.NewBeaconBlockDeneb()
+	b.Block.StateRoot = bytesutil.PadTo([]byte("foo"), 32)
+	b.Block.Slot = slot
+
+	signedBlock, err := blocks.NewSignedBeaconBlock(b)
+
+	require.NoError(t, err)
+	header, err := signedBlock.Header()
+	require.NoError(t, err)
+
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	bs, err := util.NewBeaconStateDeneb(func(state *ethpb.BeaconStateDeneb) error {
+		state.BlockRoots[0] = r[:]
+		return nil
+	})
+	require.NoError(t, err)
+
+	require.NoError(t, bs.SetSlot(slot))
+	require.NoError(t, bs.SetLatestBlockHeader(header.Header))
+
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: signedBlock}
+	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+	s := &Server{
+		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+			slot: bs,
+		}},
+		Blocker:     mockBlocker,
+		HeadFetcher: mockChainService,
+	}
+	muxVars := make(map[string]string)
+	muxVars["block_root"] = hexutil.Encode(r[:])
+	request := httptest.NewRequest("GET", "http://foo.com/", nil)
+	request = mux.SetURLVars(request, muxVars)
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetLightClientBootstrap(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+	resp := &structs.LightClientBootstrapResponseDeneb{}
+	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+	require.Equal(t, "deneb", resp.Version)
+	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.Beacon.BodyRoot)
+	require.NotNil(t, resp.Data)
+}
+
 func TestLightClientHandler_GetLightClientUpdatesByRange(t *testing.T) {
 	helpers.ClearCache()
 	ctx := context.Background()

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

@@ -92,6 +92,116 @@ func createLightClientBootstrap(ctx context.Context, state state.BeaconState) (*
 	return result, nil
 }
 
+func createLightClientBootstrapCapella(ctx context.Context, state state.BeaconState) (*structs.LightClientBootstrapCapella, error) {
+	// assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH
+	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().AltairForkEpoch {
+		return nil, fmt.Errorf("light client bootstrap is not supported before Altair, invalid slot %d", state.Slot())
+	}
+
+	// assert state.slot == state.latest_block_header.slot
+	latestBlockHeader := state.LatestBlockHeader()
+	if state.Slot() != latestBlockHeader.Slot {
+		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
+	}
+
+	// Prepare data
+	currentSyncCommittee, err := state.CurrentSyncCommittee()
+	if err != nil {
+		return nil, fmt.Errorf("could not get current sync committee: %s", err.Error())
+	}
+
+	committee := structs.SyncCommitteeFromConsensus(currentSyncCommittee)
+
+	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("could not get current sync committee proof: %s", err.Error())
+	}
+
+	branch := make([]string, fieldparams.NextSyncCommitteeBranchDepth)
+	for i, proof := range currentSyncCommitteeProof {
+		branch[i] = hexutil.Encode(proof)
+	}
+
+	beacon := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
+	if beacon == nil {
+		return nil, fmt.Errorf("could not get beacon block header")
+	}
+	header := &structs.LightClientHeaderCapella{
+		Beacon: beacon,
+	}
+
+	// Above shared util function won't calculate state root, so we need to do it manually
+	stateRoot, err := state.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("could not get state root: %s", err.Error())
+	}
+	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
+
+	// Return result
+	result := &structs.LightClientBootstrapCapella{
+		Header:                     header,
+		CurrentSyncCommittee:       committee,
+		CurrentSyncCommitteeBranch: branch,
+	}
+
+	return result, nil
+}
+
+func createLightClientBootstrapDeneb(ctx context.Context, state state.BeaconState) (*structs.LightClientBootstrapDeneb, error) {
+	// assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH
+	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().AltairForkEpoch {
+		return nil, fmt.Errorf("light client bootstrap is not supported before Altair, invalid slot %d", state.Slot())
+	}
+
+	// assert state.slot == state.latest_block_header.slot
+	latestBlockHeader := state.LatestBlockHeader()
+	if state.Slot() != latestBlockHeader.Slot {
+		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
+	}
+
+	// Prepare data
+	currentSyncCommittee, err := state.CurrentSyncCommittee()
+	if err != nil {
+		return nil, fmt.Errorf("could not get current sync committee: %s", err.Error())
+	}
+
+	committee := structs.SyncCommitteeFromConsensus(currentSyncCommittee)
+
+	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("could not get current sync committee proof: %s", err.Error())
+	}
+
+	branch := make([]string, fieldparams.NextSyncCommitteeBranchDepth)
+	for i, proof := range currentSyncCommitteeProof {
+		branch[i] = hexutil.Encode(proof)
+	}
+
+	beacon := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
+	if beacon == nil {
+		return nil, fmt.Errorf("could not get beacon block header")
+	}
+	header := &structs.LightClientHeaderDeneb{
+		Beacon: beacon,
+	}
+
+	// Above shared util function won't calculate state root, so we need to do it manually
+	stateRoot, err := state.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("could not get state root: %s", err.Error())
+	}
+	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
+
+	// Return result
+	result := &structs.LightClientBootstrapDeneb{
+		Header:                     header,
+		CurrentSyncCommittee:       committee,
+		CurrentSyncCommitteeBranch: branch,
+	}
+
+	return result, nil
+}
+
 // createLightClientUpdate - implements https://github.
 // com/ethereum/consensus-specs/blob/d70dcd9926a4bbe987f1b4e65c3e05bd029fcfb8/specs/altair/light-client/full-node.md#create_light_client_update
 // def create_light_client_update(state: BeaconState,