changelog

* Fix Mesh size in libp2p-pubsub

* Update pubsub.go

* Update CHANGELOG.md

.policy.yml

@@ -26,7 +26,6 @@ approval_rules:
       only_changed_files:
         paths:
           - "*pb.go"
-          - "*pb.gw.go"
           - "*.bazel"
     options:
       ignore_commits_by:
@@ -69,7 +68,6 @@ approval_rules:
       changed_files:
         ignore:
           - "*pb.go"
-          - "*pb.gw.go"
           - "*.bazel"
     options:
       ignore_commits_by:

CHANGELOG.md

@@ -13,10 +13,21 @@ 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
+- Light client support: Implement `BlockToLightClientHeader` function.
+- Light client support: Consensus types.
+- GetBeaconStateV2: add Electra case.
+- Implement [consensus-specs/3875](https://github.com/ethereum/consensus-specs/pull/3875)
+- Tests to ensure sepolia config matches the official upstream yaml
+- HTTP endpoint for PublishBlobs
+- GetBlockV2, GetBlindedBlock, ProduceBlockV2, ProduceBlockV3: add Electra case.
+- Add Electra support and tests for light client functions
+- fastssz version bump (better error messages).
+- SSE implementation that sheds stuck clients. [pr](https://github.com/prysmaticlabs/prysm/pull/14413)
+- Add Bellatrix tests for light client functions
 
 ### Changed
 
+- Electra: Updated interop genesis generator to support Electra.
 - `getLocalPayload` has been refactored to enable work in ePBS branch.
 - `TestNodeServer_GetPeer` and `TestNodeServer_ListPeers` test flakes resolved by iterating the whole peer list to find
   a match rather than taking the first peer in the map.
@@ -37,6 +48,12 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Updated k8s-io/client-go to v0.30.4 and k8s-io/apimachinery to v0.30.4
 - Migrated tracing library from opencensus to opentelemetry for both the beacon node and validator.
 - Refactored light client code to make it more readable and make future PRs easier.
+- Update light client helper functions to reference `dev` branch of CL specs
+- Updated Libp2p Dependencies to allow prysm to use gossipsub v1.2 .
+- Updated Sepolia bootnodes.
+- Make committee aware packing the default by deprecating `--enable-committee-aware-packing`.
+- Moved `ConvertKzgCommitmentToVersionedHash` to the `primitives` package.
+- Fix `engine_exchangeCapabilities` implementation.
 
 ### Deprecated
 - `--disable-grpc-gateway` flag is deprecated due to grpc gateway removal.
@@ -58,9 +75,14 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - validator registration log changed to debug, and the frequency of validator registration calls are reduced
 - Core: Fix process effective balance update to safe copy validator for Electra.
 - `== nil` checks before calling `IsNil()` on interfaces to prevent panics.
-- Core: Fixed slash processing causing extra hashing
-- Core: Fixed extra allocations when processing slashings
+- Core: Fixed slash processing causing extra hashing.
+- 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.
+- Registered `GetDepositSnapshot` Beacon API endpoint.
+- Fixed mesh size by appending `gParams.Dhi = gossipSubDhi`
 
 ### Security
 
@@ -2673,7 +2695,7 @@ on your validators.
 **Beacon chain node**
 
 | Metric                                           | Description                                                                                           | References |
-|--------------------------------------------------|-------------------------------------------------------------------------------------------------------|------------|
+| ------------------------------------------------ | ----------------------------------------------------------------------------------------------------- | ---------- |
 | `p2p_message_ignored_validation_total`           | Count of messages that were ignored in validation                                                     |            |
 | `beacon_current_active_validators`               | Current total active validators                                                                       |            |
 | `beacon_processed_deposits_total`                | Total number of deposits processed                                                                    |            |
@@ -2724,9 +2746,9 @@ on your validators.
 #### Changed Metrics
 
 **Beacon chain node**
-| Metric | Old Name | Description | References |
-|-----------------------|----------------------|------------------------------------------------------|------------|
-| `beacon_reorgs_total` | `beacon_reorg_total` | Count the number of times a beacon chain has a reorg | |
+| Metric                | Old Name             | Description                                          | References |
+| --------------------- | -------------------- | ---------------------------------------------------- | ---------- |
+| `beacon_reorgs_total` | `beacon_reorg_total` | Count the number of times a beacon chain has a reorg |            |
 
 ### Deprecated
 

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.5"
+consensus_spec_version = "v1.5.0-alpha.6"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-R9vG5HEL5eGMOAmbkKfJ2jfelNqL5V0xBUPiXOiGM6U=",
+    integrity = "sha256-M7u/Ot/Vzorww+dFbHp0cxLyM2mezJjijCzq+LY3uvs=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-AEIiEOlf1XuxoRMCsN+kgJMo4LrS05+biTA1p/7Ro00=",
+    integrity = "sha256-deOSeLRsmHXvkRp8n2bs3HXdkGUJWWqu8KFM/QABbZg=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-LH/Xr20yrJRYnbpjRGupMWTIOWt3cpxZJWXgThwVDsk=",
+    integrity = "sha256-Zz7YCf6XVf57nzSEGq9ToflJFHM0lAGwhd18l9Rf3hA=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-mlytz4MPjKh0DwV7FMiAtnRbJw9B6o78/x66/vmnYc8=",
+    integrity = "sha256-BoXckDxXnDcEmAjg/dQgf/tLiJsb6CT0aZvmWHFijrY=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -342,6 +342,22 @@ filegroup(
     url = "https://github.com/eth-clients/holesky/archive/874c199423ccd180607320c38cbaca05d9a1573a.tar.gz",  # 2024-06-18
 )
 
+http_archive(
+    name = "sepolia_testnet",
+    build_file_content = """
+filegroup(
+    name = "configs",
+    srcs = [
+        "metadata/config.yaml",
+    ],
+    visibility = ["//visibility:public"],
+)
+""",
+    integrity = "sha256-cY/UgpCcYEhQf7JefD65FI8tn/A+rAvKhcm2/qiVdqY=",
+    strip_prefix = "sepolia-f2c219a93c4491cee3d90c18f2f8e82aed850eab",
+    url = "https://github.com/eth-clients/sepolia/archive/f2c219a93c4491cee3d90c18f2f8e82aed850eab.tar.gz",  # 2024-09-19
+)
+
 http_archive(
     name = "com_google_protobuf",
     sha256 = "9bd87b8280ef720d3240514f884e56a712f2218f0d693b48050c836028940a42",

api/headers.go

@@ -1,5 +1,7 @@
 package api
 
+import "net/http"
+
 const (
 	VersionHeader                 = "Eth-Consensus-Version"
 	ExecutionPayloadBlindedHeader = "Eth-Execution-Payload-Blinded"
@@ -10,3 +12,9 @@ const (
 	EventStreamMediaType          = "text/event-stream"
 	KeepAlive                     = "keep-alive"
 )
+
+// SetSSEHeaders sets the headers needed for a server-sent event response.
+func SetSSEHeaders(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", EventStreamMediaType)
+	w.Header().Set("Connection", KeepAlive)
+}

api/server/structs/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "block.go",
         "conversions.go",
+        "conversions_blob.go",
         "conversions_block.go",
         "conversions_lightclient.go",
         "conversions_state.go",

api/server/structs/block.go

@@ -365,6 +365,7 @@ type BeaconBlockBodyElectra struct {
 	ExecutionPayload      *ExecutionPayloadElectra      `json:"execution_payload"`
 	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
 	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
+	ExecutionRequests     *ExecutionRequests            `json:"execution_requests"`
 }
 
 type BlindedBeaconBlockElectra struct {
@@ -403,6 +404,7 @@ type BlindedBeaconBlockBodyElectra struct {
 	ExecutionPayloadHeader *ExecutionPayloadHeaderElectra `json:"execution_payload_header"`
 	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
 	BlobKzgCommitments     []string                       `json:"blob_kzg_commitments"`
+	ExecutionRequests      *ExecutionRequests             `json:"execution_requests"`
 }
 
 type SignedBeaconBlockHeaderContainer struct {
@@ -514,6 +516,8 @@ type ExecutionPayloadDeneb struct {
 	ExcessBlobGas string        `json:"excess_blob_gas"`
 }
 
+type ExecutionPayloadElectra = ExecutionPayloadDeneb
+
 type ExecutionPayloadHeaderDeneb struct {
 	ParentHash       string `json:"parent_hash"`
 	FeeRecipient     string `json:"fee_recipient"`
@@ -534,48 +538,10 @@ type ExecutionPayloadHeaderDeneb struct {
 	ExcessBlobGas    string `json:"excess_blob_gas"`
 }
 
-type ExecutionPayloadElectra struct {
-	ParentHash            string                  `json:"parent_hash"`
-	FeeRecipient          string                  `json:"fee_recipient"`
-	StateRoot             string                  `json:"state_root"`
-	ReceiptsRoot          string                  `json:"receipts_root"`
-	LogsBloom             string                  `json:"logs_bloom"`
-	PrevRandao            string                  `json:"prev_randao"`
-	BlockNumber           string                  `json:"block_number"`
-	GasLimit              string                  `json:"gas_limit"`
-	GasUsed               string                  `json:"gas_used"`
-	Timestamp             string                  `json:"timestamp"`
-	ExtraData             string                  `json:"extra_data"`
-	BaseFeePerGas         string                  `json:"base_fee_per_gas"`
-	BlockHash             string                  `json:"block_hash"`
-	Transactions          []string                `json:"transactions"`
-	Withdrawals           []*Withdrawal           `json:"withdrawals"`
-	BlobGasUsed           string                  `json:"blob_gas_used"`
-	ExcessBlobGas         string                  `json:"excess_blob_gas"`
-	DepositRequests       []*DepositRequest       `json:"deposit_requests"`
-	WithdrawalRequests    []*WithdrawalRequest    `json:"withdrawal_requests"`
-	ConsolidationRequests []*ConsolidationRequest `json:"consolidation_requests"`
-}
+type ExecutionPayloadHeaderElectra = ExecutionPayloadHeaderDeneb
 
-type ExecutionPayloadHeaderElectra struct {
-	ParentHash                string `json:"parent_hash"`
-	FeeRecipient              string `json:"fee_recipient"`
-	StateRoot                 string `json:"state_root"`
-	ReceiptsRoot              string `json:"receipts_root"`
-	LogsBloom                 string `json:"logs_bloom"`
-	PrevRandao                string `json:"prev_randao"`
-	BlockNumber               string `json:"block_number"`
-	GasLimit                  string `json:"gas_limit"`
-	GasUsed                   string `json:"gas_used"`
-	Timestamp                 string `json:"timestamp"`
-	ExtraData                 string `json:"extra_data"`
-	BaseFeePerGas             string `json:"base_fee_per_gas"`
-	BlockHash                 string `json:"block_hash"`
-	TransactionsRoot          string `json:"transactions_root"`
-	WithdrawalsRoot           string `json:"withdrawals_root"`
-	BlobGasUsed               string `json:"blob_gas_used"`
-	ExcessBlobGas             string `json:"excess_blob_gas"`
-	DepositRequestsRoot       string `json:"deposit_requests_root"`
-	WithdrawalRequestsRoot    string `json:"withdrawal_requests_root"`
-	ConsolidationRequestsRoot string `json:"consolidation_requests_root"`
+type ExecutionRequests struct {
+	Deposits       []*DepositRequest       `json:"deposits"`
+	Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
+	Consolidations []*ConsolidationRequest `json:"consolidations"`
 }

api/server/structs/conversions.go

@@ -15,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	ethv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -1508,3 +1509,37 @@ func PendingConsolidationsFromConsensus(cs []*eth.PendingConsolidation) []*Pendi
 	}
 	return consolidations
 }
+
+func HeadEventFromV1(event *ethv1.EventHead) *HeadEvent {
+	return &HeadEvent{
+		Slot:                      fmt.Sprintf("%d", event.Slot),
+		Block:                     hexutil.Encode(event.Block),
+		State:                     hexutil.Encode(event.State),
+		EpochTransition:           event.EpochTransition,
+		ExecutionOptimistic:       event.ExecutionOptimistic,
+		PreviousDutyDependentRoot: hexutil.Encode(event.PreviousDutyDependentRoot),
+		CurrentDutyDependentRoot:  hexutil.Encode(event.CurrentDutyDependentRoot),
+	}
+}
+
+func FinalizedCheckpointEventFromV1(event *ethv1.EventFinalizedCheckpoint) *FinalizedCheckpointEvent {
+	return &FinalizedCheckpointEvent{
+		Block:               hexutil.Encode(event.Block),
+		State:               hexutil.Encode(event.State),
+		Epoch:               fmt.Sprintf("%d", event.Epoch),
+		ExecutionOptimistic: event.ExecutionOptimistic,
+	}
+}
+
+func EventChainReorgFromV1(event *ethv1.EventChainReorg) *ChainReorgEvent {
+	return &ChainReorgEvent{
+		Slot:                fmt.Sprintf("%d", event.Slot),
+		Depth:               fmt.Sprintf("%d", event.Depth),
+		OldHeadBlock:        hexutil.Encode(event.OldHeadBlock),
+		NewHeadBlock:        hexutil.Encode(event.NewHeadBlock),
+		OldHeadState:        hexutil.Encode(event.OldHeadState),
+		NewHeadState:        hexutil.Encode(event.NewHeadState),
+		Epoch:               fmt.Sprintf("%d", event.Epoch),
+		ExecutionOptimistic: event.ExecutionOptimistic,
+	}
+}

api/server/structs/conversions_blob.go

@@ -0,0 +1,61 @@
+package structs
+
+import (
+	"strconv"
+
+	"github.com/prysmaticlabs/prysm/v5/api/server"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+)
+
+func (sc *Sidecar) ToConsensus() (*eth.BlobSidecar, error) {
+	if sc == nil {
+		return nil, errNilValue
+	}
+
+	index, err := strconv.ParseUint(sc.Index, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Index")
+	}
+
+	blob, err := bytesutil.DecodeHexWithLength(sc.Blob, 131072)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Blob")
+	}
+
+	kzgCommitment, err := bytesutil.DecodeHexWithLength(sc.KzgCommitment, 48)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "KzgCommitment")
+	}
+
+	kzgProof, err := bytesutil.DecodeHexWithLength(sc.KzgProof, 48)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "KzgProof")
+	}
+
+	header, err := sc.SignedBeaconBlockHeader.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "SignedBeaconBlockHeader")
+	}
+
+	// decode the commitment inclusion proof
+	var commitmentInclusionProof [][]byte
+	for _, proof := range sc.CommitmentInclusionProof {
+		proofBytes, err := bytesutil.DecodeHexWithLength(proof, 32)
+		if err != nil {
+			return nil, server.NewDecodeError(err, "CommitmentInclusionProof")
+		}
+		commitmentInclusionProof = append(commitmentInclusionProof, proofBytes)
+	}
+
+	bsc := &eth.BlobSidecar{
+		Index:                    index,
+		Blob:                     blob,
+		KzgCommitment:            kzgCommitment,
+		KzgProof:                 kzgProof,
+		SignedBlockHeader:        header,
+		CommitmentInclusionProof: commitmentInclusionProof,
+	}
+
+	return bsc, nil
+}

api/server/structs/conversions_block.go

@@ -20,6 +20,9 @@ import (
 var ErrUnsupportedConversion = errors.New("Could not determine api struct type to use for value")
 
 func (h *SignedBeaconBlockHeader) ToConsensus() (*eth.SignedBeaconBlockHeader, error) {
+	if h == nil {
+		return nil, errNilValue
+	}
 	msg, err := h.Message.ToConsensus()
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Message")
@@ -36,6 +39,9 @@ func (h *SignedBeaconBlockHeader) ToConsensus() (*eth.SignedBeaconBlockHeader, e
 }
 
 func (h *BeaconBlockHeader) ToConsensus() (*eth.BeaconBlockHeader, error) {
+	if h == nil {
+		return nil, errNilValue
+	}
 	s, err := strconv.ParseUint(h.Slot, 10, 64)
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Slot")
@@ -2088,27 +2094,31 @@ func (b *BeaconBlockElectra) ToConsensus() (*eth.BeaconBlockElectra, error) {
 		return nil, server.NewDecodeError(err, "Body.ExecutionPayload.ExcessBlobGas")
 	}
 
-	depositRequests := make([]*enginev1.DepositRequest, len(b.Body.ExecutionPayload.DepositRequests))
-	for i, d := range b.Body.ExecutionPayload.DepositRequests {
+	if b.Body.ExecutionRequests == nil {
+		return nil, server.NewDecodeError(errors.New("nil execution requests"), "Body.ExequtionRequests")
+	}
+
+	depositRequests := make([]*enginev1.DepositRequest, len(b.Body.ExecutionRequests.Deposits))
+	for i, d := range b.Body.ExecutionRequests.Deposits {
 		depositRequests[i], err = d.ToConsensus()
 		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionPayload.DepositRequests[%d]", i))
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Deposits[%d]", i))
 		}
 	}
 
-	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(b.Body.ExecutionPayload.WithdrawalRequests))
-	for i, w := range b.Body.ExecutionPayload.WithdrawalRequests {
+	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(b.Body.ExecutionRequests.Withdrawals))
+	for i, w := range b.Body.ExecutionRequests.Withdrawals {
 		withdrawalRequests[i], err = w.ToConsensus()
 		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionPayload.WithdrawalRequests[%d]", i))
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Withdrawals[%d]", i))
 		}
 	}
 
-	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(b.Body.ExecutionPayload.ConsolidationRequests))
-	for i, c := range b.Body.ExecutionPayload.ConsolidationRequests {
+	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(b.Body.ExecutionRequests.Consolidations))
+	for i, c := range b.Body.ExecutionRequests.Consolidations {
 		consolidationRequests[i], err = c.ToConsensus()
 		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionPayload.ConsolidationRequests[%d]", i))
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Consolidations[%d]", i))
 		}
 	}
 
@@ -2151,29 +2161,31 @@ func (b *BeaconBlockElectra) ToConsensus() (*eth.BeaconBlockElectra, error) {
 				SyncCommitteeSignature: syncCommitteeSig,
 			},
 			ExecutionPayload: &enginev1.ExecutionPayloadElectra{
-				ParentHash:            payloadParentHash,
-				FeeRecipient:          payloadFeeRecipient,
-				StateRoot:             payloadStateRoot,
-				ReceiptsRoot:          payloadReceiptsRoot,
-				LogsBloom:             payloadLogsBloom,
-				PrevRandao:            payloadPrevRandao,
-				BlockNumber:           payloadBlockNumber,
-				GasLimit:              payloadGasLimit,
-				GasUsed:               payloadGasUsed,
-				Timestamp:             payloadTimestamp,
-				ExtraData:             payloadExtraData,
-				BaseFeePerGas:         payloadBaseFeePerGas,
-				BlockHash:             payloadBlockHash,
-				Transactions:          txs,
-				Withdrawals:           withdrawals,
-				BlobGasUsed:           payloadBlobGasUsed,
-				ExcessBlobGas:         payloadExcessBlobGas,
-				DepositRequests:       depositRequests,
-				WithdrawalRequests:    withdrawalRequests,
-				ConsolidationRequests: consolidationRequests,
+				ParentHash:    payloadParentHash,
+				FeeRecipient:  payloadFeeRecipient,
+				StateRoot:     payloadStateRoot,
+				ReceiptsRoot:  payloadReceiptsRoot,
+				LogsBloom:     payloadLogsBloom,
+				PrevRandao:    payloadPrevRandao,
+				BlockNumber:   payloadBlockNumber,
+				GasLimit:      payloadGasLimit,
+				GasUsed:       payloadGasUsed,
+				Timestamp:     payloadTimestamp,
+				ExtraData:     payloadExtraData,
+				BaseFeePerGas: payloadBaseFeePerGas,
+				BlockHash:     payloadBlockHash,
+				Transactions:  txs,
+				Withdrawals:   withdrawals,
+				BlobGasUsed:   payloadBlobGasUsed,
+				ExcessBlobGas: payloadExcessBlobGas,
 			},
 			BlsToExecutionChanges: blsChanges,
 			BlobKzgCommitments:    blobKzgCommitments,
+			ExecutionRequests: &enginev1.ExecutionRequests{
+				Deposits:       depositRequests,
+				Withdrawals:    withdrawalRequests,
+				Consolidations: consolidationRequests,
+			},
 		},
 	}, nil
 }
@@ -2383,17 +2395,31 @@ func (b *BlindedBeaconBlockElectra) ToConsensus() (*eth.BlindedBeaconBlockElectr
 	if err != nil {
 		return nil, server.NewDecodeError(err, "Body.ExecutionPayload.ExcessBlobGas")
 	}
-	payloadDepositRequestsRoot, err := bytesutil.DecodeHexWithLength(b.Body.ExecutionPayloadHeader.DepositRequestsRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.ExecutionPayloadHeader.DepositRequestsRoot")
+	if b.Body.ExecutionRequests == nil {
+		return nil, server.NewDecodeError(errors.New("nil execution requests"), "Body.ExecutionRequests")
 	}
-	payloadWithdrawalRequestsRoot, err := bytesutil.DecodeHexWithLength(b.Body.ExecutionPayloadHeader.WithdrawalRequestsRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.ExecutionPayloadHeader.WithdrawalRequestsRoot")
+	depositRequests := make([]*enginev1.DepositRequest, len(b.Body.ExecutionRequests.Deposits))
+	for i, d := range b.Body.ExecutionRequests.Deposits {
+		depositRequests[i], err = d.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Deposits[%d]", i))
+		}
 	}
-	payloadConsolidationRequestsRoot, err := bytesutil.DecodeHexWithLength(b.Body.ExecutionPayloadHeader.ConsolidationRequestsRoot, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Body.ExecutionPayloadHeader.ConsolidationRequestsRoot")
+
+	withdrawalRequests := make([]*enginev1.WithdrawalRequest, len(b.Body.ExecutionRequests.Withdrawals))
+	for i, w := range b.Body.ExecutionRequests.Withdrawals {
+		withdrawalRequests[i], err = w.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Withdrawals[%d]", i))
+		}
+	}
+
+	consolidationRequests := make([]*enginev1.ConsolidationRequest, len(b.Body.ExecutionRequests.Consolidations))
+	for i, c := range b.Body.ExecutionRequests.Consolidations {
+		consolidationRequests[i], err = c.ToConsensus()
+		if err != nil {
+			return nil, server.NewDecodeError(err, fmt.Sprintf("Body.ExecutionRequests.Consolidations[%d]", i))
+		}
 	}
 
 	blsChanges, err := SignedBLSChangesToConsensus(b.Body.BLSToExecutionChanges)
@@ -2436,29 +2462,31 @@ func (b *BlindedBeaconBlockElectra) ToConsensus() (*eth.BlindedBeaconBlockElectr
 				SyncCommitteeSignature: syncCommitteeSig,
 			},
 			ExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderElectra{
-				ParentHash:                payloadParentHash,
-				FeeRecipient:              payloadFeeRecipient,
-				StateRoot:                 payloadStateRoot,
-				ReceiptsRoot:              payloadReceiptsRoot,
-				LogsBloom:                 payloadLogsBloom,
-				PrevRandao:                payloadPrevRandao,
-				BlockNumber:               payloadBlockNumber,
-				GasLimit:                  payloadGasLimit,
-				GasUsed:                   payloadGasUsed,
-				Timestamp:                 payloadTimestamp,
-				ExtraData:                 payloadExtraData,
-				BaseFeePerGas:             payloadBaseFeePerGas,
-				BlockHash:                 payloadBlockHash,
-				TransactionsRoot:          payloadTxsRoot,
-				WithdrawalsRoot:           payloadWithdrawalsRoot,
-				BlobGasUsed:               payloadBlobGasUsed,
-				ExcessBlobGas:             payloadExcessBlobGas,
-				DepositRequestsRoot:       payloadDepositRequestsRoot,
-				WithdrawalRequestsRoot:    payloadWithdrawalRequestsRoot,
-				ConsolidationRequestsRoot: payloadConsolidationRequestsRoot,
+				ParentHash:       payloadParentHash,
+				FeeRecipient:     payloadFeeRecipient,
+				StateRoot:        payloadStateRoot,
+				ReceiptsRoot:     payloadReceiptsRoot,
+				LogsBloom:        payloadLogsBloom,
+				PrevRandao:       payloadPrevRandao,
+				BlockNumber:      payloadBlockNumber,
+				GasLimit:         payloadGasLimit,
+				GasUsed:          payloadGasUsed,
+				Timestamp:        payloadTimestamp,
+				ExtraData:        payloadExtraData,
+				BaseFeePerGas:    payloadBaseFeePerGas,
+				BlockHash:        payloadBlockHash,
+				TransactionsRoot: payloadTxsRoot,
+				WithdrawalsRoot:  payloadWithdrawalsRoot,
+				BlobGasUsed:      payloadBlobGasUsed,
+				ExcessBlobGas:    payloadExcessBlobGas,
 			},
 			BlsToExecutionChanges: blsChanges,
 			BlobKzgCommitments:    blobKzgCommitments,
+			ExecutionRequests: &enginev1.ExecutionRequests{
+				Deposits:       depositRequests,
+				Withdrawals:    withdrawalRequests,
+				Consolidations: consolidationRequests,
+			},
 		},
 	}, nil
 }
@@ -2526,6 +2554,8 @@ func SignedBeaconBlockMessageJsoner(block interfaces.ReadOnlySignedBeaconBlock)
 		return SignedBlindedBeaconBlockDenebFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockDeneb:
 		return SignedBeaconBlockDenebFromConsensus(pbStruct)
+	case *eth.SignedBlindedBeaconBlockElectra:
+		return SignedBlindedBeaconBlockElectraFromConsensus(pbStruct)
 	case *eth.SignedBeaconBlockElectra:
 		return SignedBeaconBlockElectraFromConsensus(pbStruct)
 	default:
@@ -2963,10 +2993,19 @@ func BlindedBeaconBlockElectraFromConsensus(b *eth.BlindedBeaconBlockElectra) (*
 			ExecutionPayloadHeader: payload,
 			BLSToExecutionChanges:  SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
 			BlobKzgCommitments:     blobKzgCommitments,
+			ExecutionRequests:      ExecutionRequestsFromConsensus(b.Body.ExecutionRequests),
 		},
 	}, nil
 }
 
+func ExecutionRequestsFromConsensus(er *enginev1.ExecutionRequests) *ExecutionRequests {
+	return &ExecutionRequests{
+		Deposits:       DepositRequestsFromConsensus(er.Deposits),
+		Withdrawals:    WithdrawalRequestsFromConsensus(er.Withdrawals),
+		Consolidations: ConsolidationRequestsFromConsensus(er.Consolidations),
+	}
+}
+
 func SignedBlindedBeaconBlockElectraFromConsensus(b *eth.SignedBlindedBeaconBlockElectra) (*SignedBlindedBeaconBlockElectra, error) {
 	block, err := BlindedBeaconBlockElectraFromConsensus(b.Message)
 	if err != nil {
@@ -3009,6 +3048,7 @@ func BeaconBlockElectraFromConsensus(b *eth.BeaconBlockElectra) (*BeaconBlockEle
 			ExecutionPayload:      payload,
 			BLSToExecutionChanges: SignedBLSChangesFromConsensus(b.Body.BlsToExecutionChanges),
 			BlobKzgCommitments:    blobKzgCommitments,
+			ExecutionRequests:     ExecutionRequestsFromConsensus(b.Body.ExecutionRequests),
 		},
 	}, nil
 }
@@ -3112,39 +3152,7 @@ func ExecutionPayloadDenebFromConsensus(payload *enginev1.ExecutionPayloadDeneb)
 	}, nil
 }
 
-func ExecutionPayloadElectraFromConsensus(payload *enginev1.ExecutionPayloadElectra) (*ExecutionPayloadElectra, error) {
-	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
-	if err != nil {
-		return nil, err
-	}
-	transactions := make([]string, len(payload.Transactions))
-	for i, tx := range payload.Transactions {
-		transactions[i] = hexutil.Encode(tx)
-	}
-
-	return &ExecutionPayloadElectra{
-		ParentHash:            hexutil.Encode(payload.ParentHash),
-		FeeRecipient:          hexutil.Encode(payload.FeeRecipient),
-		StateRoot:             hexutil.Encode(payload.StateRoot),
-		ReceiptsRoot:          hexutil.Encode(payload.ReceiptsRoot),
-		LogsBloom:             hexutil.Encode(payload.LogsBloom),
-		PrevRandao:            hexutil.Encode(payload.PrevRandao),
-		BlockNumber:           fmt.Sprintf("%d", payload.BlockNumber),
-		GasLimit:              fmt.Sprintf("%d", payload.GasLimit),
-		GasUsed:               fmt.Sprintf("%d", payload.GasUsed),
-		Timestamp:             fmt.Sprintf("%d", payload.Timestamp),
-		ExtraData:             hexutil.Encode(payload.ExtraData),
-		BaseFeePerGas:         baseFeePerGas,
-		BlockHash:             hexutil.Encode(payload.BlockHash),
-		Transactions:          transactions,
-		Withdrawals:           WithdrawalsFromConsensus(payload.Withdrawals),
-		BlobGasUsed:           fmt.Sprintf("%d", payload.BlobGasUsed),
-		ExcessBlobGas:         fmt.Sprintf("%d", payload.ExcessBlobGas),
-		DepositRequests:       DepositRequestsFromConsensus(payload.DepositRequests),
-		WithdrawalRequests:    WithdrawalRequestsFromConsensus(payload.WithdrawalRequests),
-		ConsolidationRequests: ConsolidationRequestsFromConsensus(payload.ConsolidationRequests),
-	}, nil
-}
+var ExecutionPayloadElectraFromConsensus = ExecutionPayloadDenebFromConsensus
 
 func ExecutionPayloadHeaderFromConsensus(payload *enginev1.ExecutionPayloadHeader) (*ExecutionPayloadHeader, error) {
 	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
@@ -3222,32 +3230,4 @@ func ExecutionPayloadHeaderDenebFromConsensus(payload *enginev1.ExecutionPayload
 	}, nil
 }
 
-func ExecutionPayloadHeaderElectraFromConsensus(payload *enginev1.ExecutionPayloadHeaderElectra) (*ExecutionPayloadHeaderElectra, error) {
-	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ExecutionPayloadHeaderElectra{
-		ParentHash:                hexutil.Encode(payload.ParentHash),
-		FeeRecipient:              hexutil.Encode(payload.FeeRecipient),
-		StateRoot:                 hexutil.Encode(payload.StateRoot),
-		ReceiptsRoot:              hexutil.Encode(payload.ReceiptsRoot),
-		LogsBloom:                 hexutil.Encode(payload.LogsBloom),
-		PrevRandao:                hexutil.Encode(payload.PrevRandao),
-		BlockNumber:               fmt.Sprintf("%d", payload.BlockNumber),
-		GasLimit:                  fmt.Sprintf("%d", payload.GasLimit),
-		GasUsed:                   fmt.Sprintf("%d", payload.GasUsed),
-		Timestamp:                 fmt.Sprintf("%d", payload.Timestamp),
-		ExtraData:                 hexutil.Encode(payload.ExtraData),
-		BaseFeePerGas:             baseFeePerGas,
-		BlockHash:                 hexutil.Encode(payload.BlockHash),
-		TransactionsRoot:          hexutil.Encode(payload.TransactionsRoot),
-		WithdrawalsRoot:           hexutil.Encode(payload.WithdrawalsRoot),
-		BlobGasUsed:               fmt.Sprintf("%d", payload.BlobGasUsed),
-		ExcessBlobGas:             fmt.Sprintf("%d", payload.ExcessBlobGas),
-		DepositRequestsRoot:       hexutil.Encode(payload.DepositRequestsRoot),
-		WithdrawalRequestsRoot:    hexutil.Encode(payload.WithdrawalRequestsRoot),
-		ConsolidationRequestsRoot: hexutil.Encode(payload.ConsolidationRequestsRoot),
-	}, nil
-}
+var ExecutionPayloadHeaderElectraFromConsensus = ExecutionPayloadHeaderDenebFromConsensus

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")

api/server/structs/conversions_state.go

@@ -674,7 +674,7 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 	if err != nil {
 		return nil, err
 	}
-	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
+	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
 	if !ok {
 		return nil, errPayloadHeaderNotFound
 	}

api/server/structs/endpoints_blob.go

@@ -12,3 +12,12 @@ type Sidecar struct {
 	KzgProof                 string                   `json:"kzg_proof"`
 	CommitmentInclusionProof []string                 `json:"kzg_commitment_inclusion_proof"`
 }
+
+type BlobSidecars struct {
+	Sidecars []*Sidecar `json:"sidecars"`
+}
+
+type PublishBlobsRequest struct {
+	BlobSidecars *BlobSidecars `json:"blob_sidecars"`
+	BlockRoot    string        `json:"block_root"`
+}

async/event/BUILD.bazel

@@ -4,26 +4,25 @@ go_library(
     name = "go_default_library",
     srcs = [
         "feed.go",
+        "interface.go",
         "subscription.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/async/event",
     visibility = ["//visibility:public"],
-    deps = ["//time/mclock:go_default_library"],
+    deps = [
+        "//time/mclock:go_default_library",
+        "@com_github_ethereum_go_ethereum//event:go_default_library",
+    ],
 )
 
 go_test(
     name = "go_default_test",
     size = "small",
     srcs = [
-        "example_feed_test.go",
         "example_scope_test.go",
         "example_subscription_test.go",
-        "feed_test.go",
         "subscription_test.go",
     ],
     embed = [":go_default_library"],
-    deps = [
-        "//testing/assert:go_default_library",
-        "//testing/require:go_default_library",
-    ],
+    deps = ["//testing/require:go_default_library"],
 )

async/event/example_feed_test.go

@@ -1,73 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package event_test
-
-import (
-	"fmt"
-
-	"github.com/prysmaticlabs/prysm/v5/async/event"
-)
-
-func ExampleFeed_acknowledgedEvents() {
-	// This example shows how the return value of Send can be used for request/reply
-	// interaction between event consumers and producers.
-	var feed event.Feed
-	type ackedEvent struct {
-		i   int
-		ack chan<- struct{}
-	}
-
-	// Consumers wait for events on the feed and acknowledge processing.
-	done := make(chan struct{})
-	defer close(done)
-	for i := 0; i < 3; i++ {
-		ch := make(chan ackedEvent, 100)
-		sub := feed.Subscribe(ch)
-		go func() {
-			defer sub.Unsubscribe()
-			for {
-				select {
-				case ev := <-ch:
-					fmt.Println(ev.i) // "process" the event
-					ev.ack <- struct{}{}
-				case <-done:
-					return
-				}
-			}
-		}()
-	}
-
-	// The producer sends values of type ackedEvent with increasing values of i.
-	// It waits for all consumers to acknowledge before sending the next event.
-	for i := 0; i < 3; i++ {
-		acksignal := make(chan struct{})
-		n := feed.Send(ackedEvent{i, acksignal})
-		for ack := 0; ack < n; ack++ {
-			<-acksignal
-		}
-	}
-	// Output:
-	// 0
-	// 0
-	// 0
-	// 1
-	// 1
-	// 1
-	// 2
-	// 2
-	// 2
-}

async/event/feed.go

@@ -14,241 +14,12 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
 
-// Package event contains an event feed implementation for process communication.
 package event
 
 import (
-	"errors"
-	"reflect"
-	"slices"
-	"sync"
+	geth_event "github.com/ethereum/go-ethereum/event"
 )
 
-var errBadChannel = errors.New("event: Subscribe argument does not have sendable channel type")
-
-// Feed implements one-to-many subscriptions where the carrier of events is a channel.
-// Values sent to a Feed are delivered to all subscribed channels simultaneously.
-//
-// Feeds can only be used with a single type. The type is determined by the first Send or
-// Subscribe operation. Subsequent calls to these methods panic if the type does not
-// match.
-//
-// The zero value is ready to use.
-type Feed struct {
-	once      sync.Once        // ensures that init only runs once
-	sendLock  chan struct{}    // sendLock has a one-element buffer and is empty when held.It protects sendCases.
-	removeSub chan interface{} // interrupts Send
-	sendCases caseList         // the active set of select cases used by Send
-
-	// The inbox holds newly subscribed channels until they are added to sendCases.
-	mu    sync.Mutex
-	inbox caseList
-	etype reflect.Type
-}
-
-// This is the index of the first actual subscription channel in sendCases.
-// sendCases[0] is a SelectRecv case for the removeSub channel.
-const firstSubSendCase = 1
-
-type feedTypeError struct {
-	got, want reflect.Type
-	op        string
-}
-
-func (e feedTypeError) Error() string {
-	return "event: wrong type in " + e.op + " got " + e.got.String() + ", want " + e.want.String()
-}
-
-func (f *Feed) init() {
-	f.removeSub = make(chan interface{})
-	f.sendLock = make(chan struct{}, 1)
-	f.sendLock <- struct{}{}
-	f.sendCases = caseList{{Chan: reflect.ValueOf(f.removeSub), Dir: reflect.SelectRecv}}
-}
-
-// Subscribe adds a channel to the feed. Future sends will be delivered on the channel
-// until the subscription is canceled. All channels added must have the same element type.
-//
-// The channel should have ample buffer space to avoid blocking other subscribers.
-// Slow subscribers are not dropped.
-func (f *Feed) Subscribe(channel interface{}) Subscription {
-	f.once.Do(f.init)
-
-	chanval := reflect.ValueOf(channel)
-	chantyp := chanval.Type()
-	if chantyp.Kind() != reflect.Chan || chantyp.ChanDir()&reflect.SendDir == 0 {
-		panic(errBadChannel)
-	}
-	sub := &feedSub{feed: f, channel: chanval, err: make(chan error, 1)}
-
-	f.mu.Lock()
-	defer f.mu.Unlock()
-	if !f.typecheck(chantyp.Elem()) {
-		panic(feedTypeError{op: "Subscribe", got: chantyp, want: reflect.ChanOf(reflect.SendDir, f.etype)})
-	}
-	// Add the select case to the inbox.
-	// The next Send will add it to f.sendCases.
-	cas := reflect.SelectCase{Dir: reflect.SelectSend, Chan: chanval}
-	f.inbox = append(f.inbox, cas)
-	return sub
-}
-
-// note: callers must hold f.mu
-func (f *Feed) typecheck(typ reflect.Type) bool {
-	if f.etype == nil {
-		f.etype = typ
-		return true
-	}
-	// In the event the feed's type is an actual interface, we
-	// perform an interface conformance check here.
-	if f.etype.Kind() == reflect.Interface && typ.Implements(f.etype) {
-		return true
-	}
-	return f.etype == typ
-}
-
-func (f *Feed) remove(sub *feedSub) {
-	// Delete from inbox first, which covers channels
-	// that have not been added to f.sendCases yet.
-	ch := sub.channel.Interface()
-	f.mu.Lock()
-	index := f.inbox.find(ch)
-	if index != -1 {
-		f.inbox = f.inbox.delete(index)
-		f.mu.Unlock()
-		return
-	}
-	f.mu.Unlock()
-
-	select {
-	case f.removeSub <- ch:
-		// Send will remove the channel from f.sendCases.
-	case <-f.sendLock:
-		// No Send is in progress, delete the channel now that we have the send lock.
-		f.sendCases = f.sendCases.delete(f.sendCases.find(ch))
-		f.sendLock <- struct{}{}
-	}
-}
-
-// Send delivers to all subscribed channels simultaneously.
-// It returns the number of subscribers that the value was sent to.
-func (f *Feed) Send(value interface{}) (nsent int) {
-	rvalue := reflect.ValueOf(value)
-
-	f.once.Do(f.init)
-	<-f.sendLock
-
-	// Add new cases from the inbox after taking the send lock.
-	f.mu.Lock()
-	f.sendCases = append(f.sendCases, f.inbox...)
-	f.inbox = nil
-
-	if !f.typecheck(rvalue.Type()) {
-		f.sendLock <- struct{}{}
-		f.mu.Unlock()
-		panic(feedTypeError{op: "Send", got: rvalue.Type(), want: f.etype})
-	}
-	f.mu.Unlock()
-
-	// Set the sent value on all channels.
-	for i := firstSubSendCase; i < len(f.sendCases); i++ {
-		f.sendCases[i].Send = rvalue
-	}
-
-	// Send until all channels except removeSub have been chosen. 'cases' tracks a prefix
-	// of sendCases. When a send succeeds, the corresponding case moves to the end of
-	// 'cases' and it shrinks by one element.
-	cases := f.sendCases
-	for {
-		// Fast path: try sending without blocking before adding to the select set.
-		// This should usually succeed if subscribers are fast enough and have free
-		// buffer space.
-		for i := firstSubSendCase; i < len(cases); i++ {
-			if cases[i].Chan.TrySend(rvalue) {
-				nsent++
-				cases = cases.deactivate(i)
-				i--
-			}
-		}
-		if len(cases) == firstSubSendCase {
-			break
-		}
-		// Select on all the receivers, waiting for them to unblock.
-		chosen, recv, _ := reflect.Select(cases)
-		if chosen == 0 /* <-f.removeSub */ {
-			index := f.sendCases.find(recv.Interface())
-			f.sendCases = f.sendCases.delete(index)
-			if index >= 0 && index < len(cases) {
-				// Shrink 'cases' too because the removed case was still active.
-				cases = f.sendCases[:len(cases)-1]
-			}
-		} else {
-			cases = cases.deactivate(chosen)
-			nsent++
-		}
-	}
-
-	// Forget about the sent value and hand off the send lock.
-	for i := firstSubSendCase; i < len(f.sendCases); i++ {
-		f.sendCases[i].Send = reflect.Value{}
-	}
-	f.sendLock <- struct{}{}
-	return nsent
-}
-
-type feedSub struct {
-	feed    *Feed
-	channel reflect.Value
-	errOnce sync.Once
-	err     chan error
-}
-
-// Unsubscribe remove feed subscription.
-func (sub *feedSub) Unsubscribe() {
-	sub.errOnce.Do(func() {
-		sub.feed.remove(sub)
-		close(sub.err)
-	})
-}
-
-// Err returns error channel.
-func (sub *feedSub) Err() <-chan error {
-	return sub.err
-}
-
-type caseList []reflect.SelectCase
-
-// find returns the index of a case containing the given channel.
-func (cs caseList) find(channel interface{}) int {
-	return slices.IndexFunc(cs, func(selectCase reflect.SelectCase) bool {
-		return selectCase.Chan.Interface() == channel
-	})
-}
-
-// delete removes the given case from cs.
-func (cs caseList) delete(index int) caseList {
-	return append(cs[:index], cs[index+1:]...)
-}
-
-// deactivate moves the case at index into the non-accessible portion of the cs slice.
-func (cs caseList) deactivate(index int) caseList {
-	last := len(cs) - 1
-	cs[index], cs[last] = cs[last], cs[index]
-	return cs[:last]
-}
-
-// func (cs caseList) String() string {
-//     s := "["
-//     for i, cas := range cs {
-//             if i != 0 {
-//                     s += ", "
-//             }
-//             switch cas.Dir {
-//             case reflect.SelectSend:
-//                     s += fmt.Sprintf("%v<-", cas.Chan.Interface())
-//             case reflect.SelectRecv:
-//                     s += fmt.Sprintf("<-%v", cas.Chan.Interface())
-//             }
-//     }
-//     return s + "]"
-// }
+// Feed is a re-export of the go-ethereum event feed.
+type Feed = geth_event.Feed
+type Subscription = geth_event.Subscription

async/event/feed_test.go

@@ -1,509 +0,0 @@
-// Copyright 2016 The go-ethereum Authors
-// This file is part of the go-ethereum library.
-//
-// The go-ethereum library is free software: you can redistribute it and/or modify
-// it under the terms of the GNU Lesser General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// The go-ethereum library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU Lesser General Public License for more details.
-//
-// You should have received a copy of the GNU Lesser General Public License
-// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
-
-package event
-
-import (
-	"fmt"
-	"reflect"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-)
-
-func TestFeedPanics(t *testing.T) {
-	{
-		var f Feed
-		f.Send(2)
-		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
-		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
-		// Validate it doesn't deadlock.
-		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
-	}
-	{
-		var f Feed
-		ch := make(chan int)
-		f.Subscribe(ch)
-		want := feedTypeError{op: "Send", got: reflect.TypeOf(uint64(0)), want: reflect.TypeOf(0)}
-		assert.NoError(t, checkPanic(want, func() { f.Send(uint64(2)) }))
-	}
-	{
-		var f Feed
-		f.Send(2)
-		want := feedTypeError{op: "Subscribe", got: reflect.TypeOf(make(chan uint64)), want: reflect.TypeOf(make(chan<- int))}
-		assert.NoError(t, checkPanic(want, func() { f.Subscribe(make(chan uint64)) }))
-	}
-	{
-		var f Feed
-		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(make(<-chan int)) }))
-	}
-	{
-		var f Feed
-		assert.NoError(t, checkPanic(errBadChannel, func() { f.Subscribe(0) }))
-	}
-}
-
-func checkPanic(want error, fn func()) (err error) {
-	defer func() {
-		panicResult := recover()
-		if panicResult == nil {
-			err = fmt.Errorf("didn't panic")
-		} else if !reflect.DeepEqual(panicResult, want) {
-			err = fmt.Errorf("panicked with wrong error: got %q, want %q", panicResult, want)
-		}
-	}()
-	fn()
-	return nil
-}
-
-func TestFeed(t *testing.T) {
-	var feed Feed
-	var done, subscribed sync.WaitGroup
-	subscriber := func(i int) {
-		defer done.Done()
-
-		subchan := make(chan int)
-		sub := feed.Subscribe(subchan)
-		timeout := time.NewTimer(2 * time.Second)
-		subscribed.Done()
-
-		select {
-		case v := <-subchan:
-			if v != 1 {
-				t.Errorf("%d: received value %d, want 1", i, v)
-			}
-		case <-timeout.C:
-			t.Errorf("%d: receive timeout", i)
-		}
-
-		sub.Unsubscribe()
-		select {
-		case _, ok := <-sub.Err():
-			if ok {
-				t.Errorf("%d: error channel not closed after unsubscribe", i)
-			}
-		case <-timeout.C:
-			t.Errorf("%d: unsubscribe timeout", i)
-		}
-	}
-
-	const n = 1000
-	done.Add(n)
-	subscribed.Add(n)
-	for i := 0; i < n; i++ {
-		go subscriber(i)
-	}
-	subscribed.Wait()
-	if nsent := feed.Send(1); nsent != n {
-		t.Errorf("first send delivered %d times, want %d", nsent, n)
-	}
-	if nsent := feed.Send(2); nsent != 0 {
-		t.Errorf("second send delivered %d times, want 0", nsent)
-	}
-	done.Wait()
-}
-
-func TestFeedSubscribeSameChannel(t *testing.T) {
-	var (
-		feed Feed
-		done sync.WaitGroup
-		ch   = make(chan int)
-		sub1 = feed.Subscribe(ch)
-		sub2 = feed.Subscribe(ch)
-		_    = feed.Subscribe(ch)
-	)
-	expectSends := func(value, n int) {
-		if nsent := feed.Send(value); nsent != n {
-			t.Errorf("send delivered %d times, want %d", nsent, n)
-		}
-		done.Done()
-	}
-	expectRecv := func(wantValue, n int) {
-		for i := 0; i < n; i++ {
-			if v := <-ch; v != wantValue {
-				t.Errorf("received %d, want %d", v, wantValue)
-			}
-		}
-	}
-
-	done.Add(1)
-	go expectSends(1, 3)
-	expectRecv(1, 3)
-	done.Wait()
-
-	sub1.Unsubscribe()
-
-	done.Add(1)
-	go expectSends(2, 2)
-	expectRecv(2, 2)
-	done.Wait()
-
-	sub2.Unsubscribe()
-
-	done.Add(1)
-	go expectSends(3, 1)
-	expectRecv(3, 1)
-	done.Wait()
-}
-
-func TestFeedSubscribeBlockedPost(_ *testing.T) {
-	var (
-		feed   Feed
-		nsends = 2000
-		ch1    = make(chan int)
-		ch2    = make(chan int)
-		wg     sync.WaitGroup
-	)
-	defer wg.Wait()
-
-	feed.Subscribe(ch1)
-	wg.Add(nsends)
-	for i := 0; i < nsends; i++ {
-		go func() {
-			feed.Send(99)
-			wg.Done()
-		}()
-	}
-
-	sub2 := feed.Subscribe(ch2)
-	defer sub2.Unsubscribe()
-
-	// We're done when ch1 has received N times.
-	// The number of receives on ch2 depends on scheduling.
-	for i := 0; i < nsends; {
-		select {
-		case <-ch1:
-			i++
-		case <-ch2:
-		}
-	}
-}
-
-func TestFeedUnsubscribeBlockedPost(_ *testing.T) {
-	var (
-		feed   Feed
-		nsends = 200
-		chans  = make([]chan int, 2000)
-		subs   = make([]Subscription, len(chans))
-		bchan  = make(chan int)
-		bsub   = feed.Subscribe(bchan)
-		wg     sync.WaitGroup
-	)
-	for i := range chans {
-		chans[i] = make(chan int, nsends)
-	}
-
-	// Queue up some Sends. None of these can make progress while bchan isn't read.
-	wg.Add(nsends)
-	for i := 0; i < nsends; i++ {
-		go func() {
-			feed.Send(99)
-			wg.Done()
-		}()
-	}
-	// Subscribe the other channels.
-	for i, ch := range chans {
-		subs[i] = feed.Subscribe(ch)
-	}
-	// Unsubscribe them again.
-	for _, sub := range subs {
-		sub.Unsubscribe()
-	}
-	// Unblock the Sends.
-	bsub.Unsubscribe()
-	wg.Wait()
-}
-
-// Checks that unsubscribing a channel during Send works even if that
-// channel has already been sent on.
-func TestFeedUnsubscribeSentChan(_ *testing.T) {
-	var (
-		feed Feed
-		ch1  = make(chan int)
-		ch2  = make(chan int)
-		sub1 = feed.Subscribe(ch1)
-		sub2 = feed.Subscribe(ch2)
-		wg   sync.WaitGroup
-	)
-	defer sub2.Unsubscribe()
-
-	wg.Add(1)
-	go func() {
-		feed.Send(0)
-		wg.Done()
-	}()
-
-	// Wait for the value on ch1.
-	<-ch1
-	// Unsubscribe ch1, removing it from the send cases.
-	sub1.Unsubscribe()
-
-	// Receive ch2, finishing Send.
-	<-ch2
-	wg.Wait()
-
-	// Send again. This should send to ch2 only, so the wait group will unblock
-	// as soon as a value is received on ch2.
-	wg.Add(1)
-	go func() {
-		feed.Send(0)
-		wg.Done()
-	}()
-	<-ch2
-	wg.Wait()
-}
-
-func TestFeedUnsubscribeFromInbox(t *testing.T) {
-	var (
-		feed Feed
-		ch1  = make(chan int)
-		ch2  = make(chan int)
-		sub1 = feed.Subscribe(ch1)
-		sub2 = feed.Subscribe(ch1)
-		sub3 = feed.Subscribe(ch2)
-	)
-	assert.Equal(t, 3, len(feed.inbox))
-	assert.Equal(t, 1, len(feed.sendCases), "sendCases is non-empty after unsubscribe")
-
-	sub1.Unsubscribe()
-	sub2.Unsubscribe()
-	sub3.Unsubscribe()
-	assert.Equal(t, 0, len(feed.inbox), "Inbox is non-empty after unsubscribe")
-	assert.Equal(t, 1, len(feed.sendCases), "sendCases is non-empty after unsubscribe")
-}
-
-func BenchmarkFeedSend1000(b *testing.B) {
-	var (
-		done  sync.WaitGroup
-		feed  Feed
-		nsubs = 1000
-	)
-	subscriber := func(ch <-chan int) {
-		for i := 0; i < b.N; i++ {
-			<-ch
-		}
-		done.Done()
-	}
-	done.Add(nsubs)
-	for i := 0; i < nsubs; i++ {
-		ch := make(chan int, 200)
-		feed.Subscribe(ch)
-		go subscriber(ch)
-	}
-
-	// The actual benchmark.
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		if feed.Send(i) != nsubs {
-			panic("wrong number of sends")
-		}
-	}
-
-	b.StopTimer()
-	done.Wait()
-}
-
-func TestFeed_Send(t *testing.T) {
-	tests := []struct {
-		name        string
-		evFeed      *Feed
-		testSetup   func(fd *Feed, t *testing.T, o interface{})
-		obj         interface{}
-		expectPanic bool
-	}{
-		{
-			name:   "normal struct",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedWithPointer, 1)
-				fd.Subscribe(testChan)
-			},
-			obj: testFeedWithPointer{
-				a: new(uint64),
-				b: new(string),
-			},
-			expectPanic: false,
-		},
-		{
-			name:   "un-implemented interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface, 1)
-				fd.Subscribe(testChan)
-			},
-			obj: testFeedWithPointer{
-				a: new(uint64),
-				b: new(string),
-			},
-			expectPanic: true,
-		},
-		{
-			name:   "semi-implemented interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface, 1)
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed2{
-				a: 0,
-				b: "",
-				c: []byte{'A'},
-			},
-			expectPanic: true,
-		},
-		{
-			name:   "fully-implemented interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface)
-				// Make it unbuffered to allow message to
-				// pass through
-				go func() {
-					a := <-testChan
-					if !reflect.DeepEqual(a, o) {
-						t.Errorf("Got = %v, want = %v", a, o)
-					}
-				}()
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed{
-				a: 0,
-				b: "",
-			},
-			expectPanic: false,
-		},
-		{
-			name:   "fully-implemented interface with additional methods",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeedIface)
-				// Make it unbuffered to allow message to
-				// pass through
-				go func() {
-					a := <-testChan
-					if !reflect.DeepEqual(a, o) {
-						t.Errorf("Got = %v, want = %v", a, o)
-					}
-				}()
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed3{
-				a: 0,
-				b: "",
-				c: []byte{'A'},
-				d: []byte{'B'},
-			},
-			expectPanic: false,
-		},
-		{
-			name:   "concrete types implementing the same interface",
-			evFeed: new(Feed),
-			testSetup: func(fd *Feed, t *testing.T, o interface{}) {
-				testChan := make(chan testFeed, 1)
-				// Make it unbuffered to allow message to
-				// pass through
-				go func() {
-					a := <-testChan
-					if !reflect.DeepEqual(a, o) {
-						t.Errorf("Got = %v, want = %v", a, o)
-					}
-				}()
-				fd.Subscribe(testChan)
-			},
-			obj: testFeed3{
-				a: 0,
-				b: "",
-				c: []byte{'A'},
-				d: []byte{'B'},
-			},
-			expectPanic: true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			defer func() {
-				if r := recover(); r != nil {
-					if !tt.expectPanic {
-						t.Errorf("panic triggered when unexpected: %v", r)
-					}
-				} else {
-					if tt.expectPanic {
-						t.Error("panic not triggered when expected")
-					}
-				}
-			}()
-			tt.testSetup(tt.evFeed, t, tt.obj)
-			if gotNsent := tt.evFeed.Send(tt.obj); gotNsent != 1 {
-				t.Errorf("Send() = %v, want %v", gotNsent, 1)
-			}
-		})
-	}
-}
-
-// The following objects below are a collection of different
-// struct types to test with.
-type testFeed struct {
-	a uint64
-	b string
-}
-
-func (testFeed) method1() {
-
-}
-
-func (testFeed) method2() {
-
-}
-
-type testFeedWithPointer struct {
-	a *uint64
-	b *string
-}
-
-type testFeed2 struct {
-	a uint64
-	b string
-	c []byte
-}
-
-func (testFeed2) method1() {
-
-}
-
-type testFeed3 struct {
-	a    uint64
-	b    string
-	c, d []byte
-}
-
-func (testFeed3) method1() {
-
-}
-
-func (testFeed3) method2() {
-
-}
-
-func (testFeed3) method3() {
-
-}
-
-type testFeedIface interface {
-	method1()
-	method2()
-}

async/event/interface.go

@@ -0,0 +1,8 @@
+package event
+
+// SubscriberSender is an abstract representation of an *event.Feed
+// to use in describing types that accept or return an *event.Feed.
+type SubscriberSender interface {
+	Subscribe(channel interface{}) Subscription
+	Send(value interface{}) (nsent int)
+}

async/event/subscription.go

@@ -28,25 +28,6 @@ import (
 // request backoff time.
 const waitQuotient = 10
 
-// Subscription represents a stream of events. The carrier of the events is typically a
-// channel, but isn't part of the interface.
-//
-// Subscriptions can fail while established. Failures are reported through an error
-// channel. It receives a value if there is an issue with the subscription (e.g. the
-// network connection delivering the events has been closed). Only one value will ever be
-// sent.
-//
-// The error channel is closed when the subscription ends successfully (i.e. when the
-// source of events is closed). It is also closed when Unsubscribe is called.
-//
-// The Unsubscribe method cancels the sending of events. You must call Unsubscribe in all
-// cases to ensure that resources related to the subscription are released. It can be
-// called any number of times.
-type Subscription interface {
-	Err() <-chan error // returns the error channel
-	Unsubscribe()      // cancels sending of events, closing the error channel
-}
-
 // NewSubscription runs a producer function as a subscription in a new goroutine. The
 // channel given to the producer is closed when Unsubscribe is called. If fn returns an
 // error, it is sent on the subscription's error channel.

beacon-chain/blockchain/execution_engine.go

@@ -2,7 +2,6 @@ package blockchain
 
 import (
 	"context"
-	"crypto/sha256"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -28,8 +27,6 @@ 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:
@@ -402,13 +399,7 @@ func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([
 
 	versionedHashes := make([]common.Hash, len(commitments))
 	for i, commitment := range commitments {
-		versionedHashes[i] = ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
 	}
 	return versionedHashes, nil
 }
-
-func ConvertKzgCommitmentToVersionedHash(commitment []byte) common.Hash {
-	versionedHash := sha256.Sum256(commitment)
-	versionedHash[0] = blobCommitmentVersionKZG
-	return versionedHash
-}

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/blockchain/setup_test.go

@@ -32,7 +32,7 @@ type mockBeaconNode struct {
 }
 
 // StateFeed mocks the same method in the beacon node.
-func (mbn *mockBeaconNode) StateFeed() *event.Feed {
+func (mbn *mockBeaconNode) StateFeed() event.SubscriberSender {
 	mbn.mu.Lock()
 	defer mbn.mu.Unlock()
 	if mbn.stateFeed == nil {

beacon-chain/blockchain/testing/mock.go

@@ -98,6 +98,44 @@ func (s *ChainService) BlockNotifier() blockfeed.Notifier {
 	return s.blockNotifier
 }
 
+type EventFeedWrapper struct {
+	feed       *event.Feed
+	subscribed chan struct{} // this channel is closed once a subscription is made
+}
+
+func (w *EventFeedWrapper) Subscribe(channel interface{}) event.Subscription {
+	select {
+	case <-w.subscribed:
+		break // already closed
+	default:
+		close(w.subscribed)
+	}
+	return w.feed.Subscribe(channel)
+}
+
+func (w *EventFeedWrapper) Send(value interface{}) int {
+	return w.feed.Send(value)
+}
+
+// WaitForSubscription allows test to wait for the feed to have a subscription before beginning to send events.
+func (w *EventFeedWrapper) WaitForSubscription(ctx context.Context) error {
+	select {
+	case <-w.subscribed:
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+var _ event.SubscriberSender = &EventFeedWrapper{}
+
+func NewEventFeedWrapper() *EventFeedWrapper {
+	return &EventFeedWrapper{
+		feed:       new(event.Feed),
+		subscribed: make(chan struct{}),
+	}
+}
+
 // MockBlockNotifier mocks the block notifier.
 type MockBlockNotifier struct {
 	feed *event.Feed
@@ -131,7 +169,7 @@ func (msn *MockStateNotifier) ReceivedEvents() []*feed.Event {
 }
 
 // StateFeed returns a state feed.
-func (msn *MockStateNotifier) StateFeed() *event.Feed {
+func (msn *MockStateNotifier) StateFeed() event.SubscriberSender {
 	msn.feedLock.Lock()
 	defer msn.feedLock.Unlock()
 
@@ -159,6 +197,23 @@ func (msn *MockStateNotifier) StateFeed() *event.Feed {
 	return msn.feed
 }
 
+// NewSimpleStateNotifier makes a state feed without the custom mock feed machinery.
+func NewSimpleStateNotifier() *MockStateNotifier {
+	return &MockStateNotifier{feed: new(event.Feed)}
+}
+
+type SimpleNotifier struct {
+	Feed event.SubscriberSender
+}
+
+func (n *SimpleNotifier) StateFeed() event.SubscriberSender {
+	return n.Feed
+}
+
+func (n *SimpleNotifier) OperationFeed() event.SubscriberSender {
+	return n.Feed
+}
+
 // OperationNotifier mocks the same method in the chain service.
 func (s *ChainService) OperationNotifier() opfeed.Notifier {
 	if s.opNotifier == nil {
@@ -173,7 +228,7 @@ type MockOperationNotifier struct {
 }
 
 // OperationFeed returns an operation feed.
-func (mon *MockOperationNotifier) OperationFeed() *event.Feed {
+func (mon *MockOperationNotifier) OperationFeed() event.SubscriberSender {
 	if mon.feed == nil {
 		mon.feed = new(event.Feed)
 	}

beacon-chain/core/blocks/genesis.go

@@ -213,6 +213,11 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 					},
 					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
 					BlobKzgCommitments:    make([][]byte, 0),
+					ExecutionRequests: &enginev1.ExecutionRequests{
+						Withdrawals:    make([]*enginev1.WithdrawalRequest, 0),
+						Deposits:       make([]*enginev1.DepositRequest, 0),
+						Consolidations: make([]*enginev1.ConsolidationRequest, 0),
+					},
 				},
 			},
 			Signature: params.BeaconConfig().EmptySignature[:],

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -78,23 +78,19 @@ func ProcessOperations(
 		return nil, errors.Wrap(err, "could not process bls-to-execution changes")
 	}
 	// new in electra
-	e, err := bb.Execution()
+	requests, err := bb.ExecutionRequests()
 	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution data from block")
+		return nil, errors.Wrap(err, "could not get execution requests")
 	}
-	exe, ok := e.(interfaces.ExecutionDataElectra)
-	if !ok {
-		return nil, errors.New("could not cast execution data to electra execution data")
-	}
-	st, err = ProcessDepositRequests(ctx, st, exe.DepositRequests())
+	st, err = ProcessDepositRequests(ctx, st, requests.Deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit receipts")
 	}
-	st, err = ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
+	st, err = 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, exe.ConsolidationRequests()); err != nil {
+	if err := ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
 		return nil, fmt.Errorf("could not process consolidation requests: %w", err)
 	}
 	return st, nil

beacon-chain/core/electra/upgrade.go

@@ -10,7 +10,6 @@ import (
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -245,26 +244,23 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 		CurrentSyncCommittee:        currentSyncCommittee,
 		NextSyncCommittee:           nextSyncCommittee,
 		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderElectra{
-			ParentHash:                payloadHeader.ParentHash(),
-			FeeRecipient:              payloadHeader.FeeRecipient(),
-			StateRoot:                 payloadHeader.StateRoot(),
-			ReceiptsRoot:              payloadHeader.ReceiptsRoot(),
-			LogsBloom:                 payloadHeader.LogsBloom(),
-			PrevRandao:                payloadHeader.PrevRandao(),
-			BlockNumber:               payloadHeader.BlockNumber(),
-			GasLimit:                  payloadHeader.GasLimit(),
-			GasUsed:                   payloadHeader.GasUsed(),
-			Timestamp:                 payloadHeader.Timestamp(),
-			ExtraData:                 payloadHeader.ExtraData(),
-			BaseFeePerGas:             payloadHeader.BaseFeePerGas(),
-			BlockHash:                 payloadHeader.BlockHash(),
-			TransactionsRoot:          txRoot,
-			WithdrawalsRoot:           wdRoot,
-			ExcessBlobGas:             excessBlobGas,
-			BlobGasUsed:               blobGasUsed,
-			DepositRequestsRoot:       bytesutil.Bytes32(0), // [New in Electra:EIP6110]
-			WithdrawalRequestsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP7002]
-			ConsolidationRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7251]
+			ParentHash:       payloadHeader.ParentHash(),
+			FeeRecipient:     payloadHeader.FeeRecipient(),
+			StateRoot:        payloadHeader.StateRoot(),
+			ReceiptsRoot:     payloadHeader.ReceiptsRoot(),
+			LogsBloom:        payloadHeader.LogsBloom(),
+			PrevRandao:       payloadHeader.PrevRandao(),
+			BlockNumber:      payloadHeader.BlockNumber(),
+			GasLimit:         payloadHeader.GasLimit(),
+			GasUsed:          payloadHeader.GasUsed(),
+			Timestamp:        payloadHeader.Timestamp(),
+			ExtraData:        payloadHeader.ExtraData(),
+			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
+			BlockHash:        payloadHeader.BlockHash(),
+			TransactionsRoot: txRoot,
+			WithdrawalsRoot:  wdRoot,
+			ExcessBlobGas:    excessBlobGas,
+			BlobGasUsed:      blobGasUsed,
 		},
 		NextWithdrawalIndex:          wi,
 		NextWithdrawalValidatorIndex: vi,

beacon-chain/core/electra/upgrade_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	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"
@@ -113,24 +112,21 @@ func TestUpgradeToElectra(t *testing.T) {
 	wdRoot, err := prevHeader.WithdrawalsRoot()
 	require.NoError(t, err)
 	wanted := &enginev1.ExecutionPayloadHeaderElectra{
-		ParentHash:                prevHeader.ParentHash(),
-		FeeRecipient:              prevHeader.FeeRecipient(),
-		StateRoot:                 prevHeader.StateRoot(),
-		ReceiptsRoot:              prevHeader.ReceiptsRoot(),
-		LogsBloom:                 prevHeader.LogsBloom(),
-		PrevRandao:                prevHeader.PrevRandao(),
-		BlockNumber:               prevHeader.BlockNumber(),
-		GasLimit:                  prevHeader.GasLimit(),
-		GasUsed:                   prevHeader.GasUsed(),
-		Timestamp:                 prevHeader.Timestamp(),
-		ExtraData:                 prevHeader.ExtraData(),
-		BaseFeePerGas:             prevHeader.BaseFeePerGas(),
-		BlockHash:                 prevHeader.BlockHash(),
-		TransactionsRoot:          txRoot,
-		WithdrawalsRoot:           wdRoot,
-		DepositRequestsRoot:       bytesutil.Bytes32(0),
-		WithdrawalRequestsRoot:    bytesutil.Bytes32(0),
-		ConsolidationRequestsRoot: bytesutil.Bytes32(0),
+		ParentHash:       prevHeader.ParentHash(),
+		FeeRecipient:     prevHeader.FeeRecipient(),
+		StateRoot:        prevHeader.StateRoot(),
+		ReceiptsRoot:     prevHeader.ReceiptsRoot(),
+		LogsBloom:        prevHeader.LogsBloom(),
+		PrevRandao:       prevHeader.PrevRandao(),
+		BlockNumber:      prevHeader.BlockNumber(),
+		GasLimit:         prevHeader.GasLimit(),
+		GasUsed:          prevHeader.GasUsed(),
+		Timestamp:        prevHeader.Timestamp(),
+		ExtraData:        prevHeader.ExtraData(),
+		BaseFeePerGas:    prevHeader.BaseFeePerGas(),
+		BlockHash:        prevHeader.BlockHash(),
+		TransactionsRoot: txRoot,
+		WithdrawalsRoot:  wdRoot,
 	}
 	require.DeepEqual(t, wanted, protoHeader)
 

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

@@ -4,5 +4,5 @@ import "github.com/prysmaticlabs/prysm/v5/async/event"
 
 // Notifier interface defines the methods of the service that provides beacon block operation updates to consumers.
 type Notifier interface {
-	OperationFeed() *event.Feed
+	OperationFeed() event.SubscriberSender
 }

beacon-chain/core/feed/state/notifier.go

@@ -4,5 +4,5 @@ import "github.com/prysmaticlabs/prysm/v5/async/event"
 
 // Notifier interface defines the methods of the service that provides state updates to consumers.
 type Notifier interface {
-	StateFeed() *event.Feed
+	StateFeed() event.SubscriberSender
 }

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",
@@ -29,11 +27,13 @@ go_test(
     srcs = ["lightclient_test.go"],
     deps = [
         ":go_default_library",
-        "//config/params:go_default_library",
+        "//config/fieldparams: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",
         "//testing/util:go_default_library",
+        "@com_github_pkg_errors//: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 (
@@ -29,16 +25,6 @@ const (
 	executionBranchNumOfLeaves = 4
 )
 
-// createLightClientFinalityUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_finality_update
-// def create_light_client_finality_update(update: LightClientUpdate) -> LightClientFinalityUpdate:
-//
-//	return LightClientFinalityUpdate(
-//	    attested_header=update.attested_header,
-//	    finalized_header=update.finalized_header,
-//	    finality_branch=update.finality_branch,
-//	    sync_aggregate=update.sync_aggregate,
-//	    signature_slot=update.signature_slot,
-//	)
 func createLightClientFinalityUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientFinalityUpdate {
 	finalityUpdate := &ethpbv2.LightClientFinalityUpdate{
 		AttestedHeader:  update.AttestedHeader,
@@ -51,14 +37,6 @@ func createLightClientFinalityUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2
 	return finalityUpdate
 }
 
-// createLightClientOptimisticUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_optimistic_update
-// def create_light_client_optimistic_update(update: LightClientUpdate) -> LightClientOptimisticUpdate:
-//
-//	return LightClientOptimisticUpdate(
-//	    attested_header=update.attested_header,
-//	    sync_aggregate=update.sync_aggregate,
-//	    signature_slot=update.signature_slot,
-//	)
 func createLightClientOptimisticUpdate(update *ethpbv2.LightClientUpdate) *ethpbv2.LightClientOptimisticUpdate {
 	optimisticUpdate := &ethpbv2.LightClientOptimisticUpdate{
 		AttestedHeader: update.AttestedHeader,
@@ -74,9 +52,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 +68,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
 	}
@@ -98,68 +78,12 @@ func NewLightClientOptimisticUpdateFromBeaconState(
 	return createLightClientOptimisticUpdate(update), nil
 }
 
-// NewLightClientUpdateFromBeaconState 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,
-//
-//	                           block: SignedBeaconBlock,
-//	                           attested_state: BeaconState,
-//	                           finalized_block: Optional[SignedBeaconBlock]) -> LightClientUpdate:
-//	assert compute_epoch_at_slot(attested_state.slot) >= ALTAIR_FORK_EPOCH
-//	assert sum(block.message.body.sync_aggregate.sync_committee_bits) >= MIN_SYNC_COMMITTEE_PARTICIPANTS
-//
-//	assert state.slot == state.latest_block_header.slot
-//	header = state.latest_block_header.copy()
-//	header.state_root = hash_tree_root(state)
-//	assert hash_tree_root(header) == hash_tree_root(block.message)
-//	update_signature_period = compute_sync_committee_period(compute_epoch_at_slot(block.message.slot))
-//
-//	assert attested_state.slot == attested_state.latest_block_header.slot
-//	attested_header = attested_state.latest_block_header.copy()
-//	attested_header.state_root = hash_tree_root(attested_state)
-//	assert hash_tree_root(attested_header) == block.message.parent_root
-//	update_attested_period = compute_sync_committee_period(compute_epoch_at_slot(attested_header.slot))
-//
-//	# `next_sync_committee` is only useful if the message is signed by the current sync committee
-//	if update_attested_period == update_signature_period:
-//	    next_sync_committee = attested_state.next_sync_committee
-//	    next_sync_committee_branch = compute_merkle_proof_for_state(attested_state, NEXT_SYNC_COMMITTEE_INDEX)
-//	else:
-//	    next_sync_committee = SyncCommittee()
-//	    next_sync_committee_branch = [Bytes32() for _ in range(floorlog2(NEXT_SYNC_COMMITTEE_INDEX))]
-//
-//	# Indicate finality whenever possible
-//	if finalized_block is not None:
-//	    if finalized_block.message.slot != GENESIS_SLOT:
-//	        finalized_header = BeaconBlockHeader(
-//	            slot=finalized_block.message.slot,
-//	            proposer_index=finalized_block.message.proposer_index,
-//	            parent_root=finalized_block.message.parent_root,
-//	            state_root=finalized_block.message.state_root,
-//	            body_root=hash_tree_root(finalized_block.message.body),
-//	        )
-//	        assert hash_tree_root(finalized_header) == attested_state.finalized_checkpoint.root
-//	    else:
-//	        assert attested_state.finalized_checkpoint.root == Bytes32()
-//	        finalized_header = BeaconBlockHeader()
-//	    finality_branch = compute_merkle_proof_for_state(attested_state, FINALIZED_ROOT_INDEX)
-//	else:
-//	    finalized_header = BeaconBlockHeader()
-//	    finality_branch = [Bytes32() for _ in range(floorlog2(FINALIZED_ROOT_INDEX))]
-//
-//	return LightClientUpdate(
-//	    attested_header=attested_header,
-//	    next_sync_committee=next_sync_committee,
-//	    next_sync_committee_branch=next_sync_committee_branch,
-//	    finalized_header=finalized_header,
-//	    finality_branch=finality_branch,
-//	    sync_aggregate=block.message.body.sync_aggregate,
-//	    signature_slot=block.message.slot,
-//	)
 func NewLightClientUpdateFromBeaconState(
 	ctx context.Context,
 	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 +147,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 +200,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 block.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 +233,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++ {
@@ -421,218 +243,26 @@ func createDefaultLightClientUpdate(v int) (*ethpbv2.LightClientUpdate, error) {
 		Pubkeys:         pubKeys,
 		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
 	}
-	nextSyncCommitteeBranch := make([][]byte, fieldparams.NextSyncCommitteeBranchDepth)
-	for i := 0; i < fieldparams.NextSyncCommitteeBranchDepth; i++ {
+	nextSyncCommitteeBranch := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
+	for i := 0; i < fieldparams.SyncCommitteeBranchDepth; i++ {
 		nextSyncCommitteeBranch[i] = make([]byte, fieldparams.RootLength)
 	}
 	executionBranch := make([][]byte, executionBranchNumOfLeaves)
 	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,8 +299,45 @@ func ComputeWithdrawalsRoot(payload interfaces.ExecutionData) ([]byte, error) {
 	return withdrawalsRoot, nil
 }
 
-func BlockToLightClientHeaderAltair(block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeader, error) {
-	if block.Version() != version.Altair {
+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, version.Electra:
+		denebHeader, err := blockToLightClientHeaderDeneb(context.Background(), block)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get header")
+		}
+		return &ethpbv2.LightClientHeaderContainer{
+			Header: &ethpbv2.LightClientHeaderContainer_HeaderDeneb{
+				HeaderDeneb: denebHeader,
+			},
+		}, nil
+	default:
+		return nil, fmt.Errorf("unsupported block version %s", version.String(block.Version()))
+	}
+}
+
+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()))
 	}
 
@@ -692,8 +359,8 @@ func BlockToLightClientHeaderAltair(block interfaces.ReadOnlySignedBeaconBlock)
 	}, nil
 }
 
-func BlockToLightClientHeaderCapella(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderCapella, error) {
-	if block.Version() != version.Capella {
+func blockToLightClientHeaderCapella(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderCapella, error) {
+	if block.Version() < version.Capella {
 		return nil, fmt.Errorf("block version is %s instead of Capella", version.String(block.Version()))
 	}
 
@@ -754,9 +421,9 @@ func BlockToLightClientHeaderCapella(ctx context.Context, block interfaces.ReadO
 	}, nil
 }
 
-func BlockToLightClientHeaderDeneb(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderDeneb, error) {
-	if block.Version() != version.Deneb {
-		return nil, fmt.Errorf("block version is %s instead of Deneb", version.String(block.Version()))
+func blockToLightClientHeaderDeneb(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (*ethpbv2.LightClientHeaderDeneb, error) {
+	if block.Version() < version.Deneb {
+		return nil, fmt.Errorf("block version is %s instead of Deneb/Electra", version.String(block.Version()))
 	}
 
 	payload, err := block.Block().Body().Execution()

beacon-chain/db/kv/state_test.go

@@ -138,20 +138,17 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 				require.NoError(t, err)
 				require.NoError(t, st.SetSlot(100))
 				p, err := blocks.WrappedExecutionPayloadHeaderElectra(&enginev1.ExecutionPayloadHeaderElectra{
-					ParentHash:                make([]byte, 32),
-					FeeRecipient:              make([]byte, 20),
-					StateRoot:                 make([]byte, 32),
-					ReceiptsRoot:              make([]byte, 32),
-					LogsBloom:                 make([]byte, 256),
-					PrevRandao:                make([]byte, 32),
-					ExtraData:                 []byte("foo"),
-					BaseFeePerGas:             make([]byte, 32),
-					BlockHash:                 make([]byte, 32),
-					TransactionsRoot:          make([]byte, 32),
-					WithdrawalsRoot:           make([]byte, 32),
-					DepositRequestsRoot:       make([]byte, 32),
-					WithdrawalRequestsRoot:    make([]byte, 32),
-					ConsolidationRequestsRoot: make([]byte, 32),
+					ParentHash:       make([]byte, 32),
+					FeeRecipient:     make([]byte, 20),
+					StateRoot:        make([]byte, 32),
+					ReceiptsRoot:     make([]byte, 32),
+					LogsBloom:        make([]byte, 256),
+					PrevRandao:       make([]byte, 32),
+					ExtraData:        []byte("foo"),
+					BaseFeePerGas:    make([]byte, 32),
+					BlockHash:        make([]byte, 32),
+					TransactionsRoot: make([]byte, 32),
+					WithdrawalsRoot:  make([]byte, 32),
 				})
 				require.NoError(t, err)
 				require.NoError(t, st.SetLatestExecutionPayloadHeader(p))

beacon-chain/execution/engine_client.go

@@ -167,15 +167,6 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 		if err != nil {
 			return nil, handleRPCError(err)
 		}
-	case *pb.ExecutionPayloadElectra:
-		payloadPb, ok := payload.Proto().(*pb.ExecutionPayloadElectra)
-		if !ok {
-			return nil, errors.New("execution data must be a Electra execution payload")
-		}
-		err := s.rpcClient.CallContext(ctx, result, NewPayloadMethodV4, payloadPb, versionedHashes, parentBlockRoot)
-		if err != nil {
-			return nil, handleRPCError(err)
-		}
 	default:
 		return nil, errors.New("unknown execution data type")
 	}
@@ -268,9 +259,6 @@ func (s *Service) ForkchoiceUpdated(
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
 	pe := slots.ToEpoch(slot)
-	if pe >= params.BeaconConfig().ElectraForkEpoch {
-		return GetPayloadMethodV4, &pb.ExecutionPayloadElectraWithValueAndBlobsBundle{}
-	}
 	if pe >= params.BeaconConfig().DenebForkEpoch {
 		return GetPayloadMethodV3, &pb.ExecutionPayloadDenebWithValueAndBlobsBundle{}
 	}
@@ -566,7 +554,7 @@ func fullPayloadFromPayloadBody(
 			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
 			Withdrawals:   body.Withdrawals,
 		}) // We can't get the block value and don't care about the block value for this instance
-	case version.Deneb:
+	case version.Deneb, version.Electra:
 		ebg, err := header.ExcessBlobGas()
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
@@ -595,50 +583,6 @@ func fullPayloadFromPayloadBody(
 				ExcessBlobGas: ebg,
 				BlobGasUsed:   bgu,
 			}) // We can't get the block value and don't care about the block value for this instance
-	case version.Electra:
-		ebg, err := header.ExcessBlobGas()
-		if err != nil {
-			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
-		}
-		bgu, err := header.BlobGasUsed()
-		if err != nil {
-			return nil, errors.Wrap(err, "unable to extract BlobGasUsed attribute from execution payload header")
-		}
-		wr, err := pb.JsonWithdrawalRequestsToProto(body.WithdrawalRequests)
-		if err != nil {
-			return nil, err
-		}
-		dr, err := pb.JsonDepositRequestsToProto(body.DepositRequests)
-		if err != nil {
-			return nil, err
-		}
-		cr, err := pb.JsonConsolidationRequestsToProto(body.ConsolidationRequests)
-		if err != nil {
-			return nil, err
-		}
-		return blocks.WrappedExecutionPayloadElectra(
-			&pb.ExecutionPayloadElectra{
-				ParentHash:            header.ParentHash(),
-				FeeRecipient:          header.FeeRecipient(),
-				StateRoot:             header.StateRoot(),
-				ReceiptsRoot:          header.ReceiptsRoot(),
-				LogsBloom:             header.LogsBloom(),
-				PrevRandao:            header.PrevRandao(),
-				BlockNumber:           header.BlockNumber(),
-				GasLimit:              header.GasLimit(),
-				GasUsed:               header.GasUsed(),
-				Timestamp:             header.Timestamp(),
-				ExtraData:             header.ExtraData(),
-				BaseFeePerGas:         header.BaseFeePerGas(),
-				BlockHash:             header.BlockHash(),
-				Transactions:          pb.RecastHexutilByteSlice(body.Transactions),
-				Withdrawals:           body.Withdrawals,
-				ExcessBlobGas:         ebg,
-				BlobGasUsed:           bgu,
-				DepositRequests:       dr,
-				WithdrawalRequests:    wr,
-				ConsolidationRequests: cr,
-			}) // We can't get the block value and don't care about the block value for this instance
 	default:
 		return nil, fmt.Errorf("unknown execution block version for payload %d", bVersion)
 	}
@@ -761,7 +705,7 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			Transactions:  make([][]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
-	case version.Deneb:
+	case version.Deneb, version.Electra:
 		return &pb.ExecutionPayloadDeneb{
 			ParentHash:    make([]byte, fieldparams.RootLength),
 			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
@@ -775,22 +719,6 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			Transactions:  make([][]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
-	case version.Electra:
-		return &pb.ExecutionPayloadElectra{
-			ParentHash:         make([]byte, fieldparams.RootLength),
-			FeeRecipient:       make([]byte, fieldparams.FeeRecipientLength),
-			StateRoot:          make([]byte, fieldparams.RootLength),
-			ReceiptsRoot:       make([]byte, fieldparams.RootLength),
-			LogsBloom:          make([]byte, fieldparams.LogsBloomLength),
-			PrevRandao:         make([]byte, fieldparams.RootLength),
-			ExtraData:          make([]byte, 0),
-			BaseFeePerGas:      make([]byte, fieldparams.RootLength),
-			BlockHash:          make([]byte, fieldparams.RootLength),
-			Transactions:       make([][]byte, 0),
-			Withdrawals:        make([]*pb.Withdrawal, 0),
-			WithdrawalRequests: make([]*pb.WithdrawalRequest, 0),
-			DepositRequests:    make([]*pb.DepositRequest, 0),
-		}, nil
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 	}

beacon-chain/execution/engine_client_test.go

@@ -320,72 +320,6 @@ func TestClient_HTTP(t *testing.T) {
 		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
 		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
 	})
-	t.Run(GetPayloadMethodV4, func(t *testing.T) {
-		payloadId := [8]byte{1}
-		want, ok := fix["ExecutionPayloadElectraWithValue"].(*pb.GetPayloadV4ResponseJson)
-		require.Equal(t, true, ok)
-		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Content-Type", "application/json")
-			defer func() {
-				require.NoError(t, r.Body.Close())
-			}()
-			enc, err := io.ReadAll(r.Body)
-			require.NoError(t, err)
-			jsonRequestString := string(enc)
-
-			reqArg, err := json.Marshal(pb.PayloadIDBytes(payloadId))
-			require.NoError(t, err)
-
-			// We expect the JSON string RPC request contains the right arguments.
-			require.Equal(t, true, strings.Contains(
-				jsonRequestString, string(reqArg),
-			))
-			resp := map[string]interface{}{
-				"jsonrpc": "2.0",
-				"id":      1,
-				"result":  want,
-			}
-			err = json.NewEncoder(w).Encode(resp)
-			require.NoError(t, err)
-		}))
-		defer srv.Close()
-
-		rpcClient, err := rpc.DialHTTP(srv.URL)
-		require.NoError(t, err)
-		defer rpcClient.Close()
-
-		client := &Service{}
-		client.rpcClient = rpcClient
-
-		// We call the RPC method via HTTP and expect a proper result.
-		resp, err := client.GetPayload(ctx, payloadId, 2*params.BeaconConfig().SlotsPerEpoch)
-		require.NoError(t, err)
-		require.Equal(t, true, resp.OverrideBuilder)
-		g, err := resp.ExecutionData.ExcessBlobGas()
-		require.NoError(t, err)
-		require.DeepEqual(t, uint64(3), g)
-		g, err = resp.ExecutionData.BlobGasUsed()
-		require.NoError(t, err)
-		require.DeepEqual(t, uint64(2), g)
-
-		commitments := [][]byte{bytesutil.PadTo([]byte("commitment1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("commitment2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, commitments, resp.BlobsBundle.KzgCommitments)
-		proofs := [][]byte{bytesutil.PadTo([]byte("proof1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("proof2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, proofs, resp.BlobsBundle.Proofs)
-		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
-		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
-		ede, ok := resp.ExecutionData.(interfaces.ExecutionDataElectra)
-		require.Equal(t, true, ok)
-		require.NotNil(t, ede.WithdrawalRequests())
-		wrequestsNotOverMax := len(ede.WithdrawalRequests()) <= int(params.BeaconConfig().MaxWithdrawalRequestsPerPayload)
-		require.Equal(t, true, wrequestsNotOverMax)
-		require.NotNil(t, ede.DepositRequests())
-		drequestsNotOverMax := len(ede.DepositRequests()) <= int(params.BeaconConfig().MaxDepositRequestsPerPayload)
-		require.Equal(t, true, drequestsNotOverMax)
-		require.NotNil(t, ede.ConsolidationRequests())
-		consolidationsNotOverMax := len(ede.ConsolidationRequests()) <= int(params.BeaconConfig().MaxConsolidationsRequestsPerPayload)
-		require.Equal(t, true, consolidationsNotOverMax)
-	})
 	t.Run(ForkchoiceUpdatedMethod+" VALID status", func(t *testing.T) {
 		forkChoiceState := &pb.ForkchoiceState{
 			HeadBlockHash:      []byte("head"),
@@ -568,20 +502,6 @@ func TestClient_HTTP(t *testing.T) {
 		require.NoError(t, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
-	t.Run(NewPayloadMethodV4+" VALID status", func(t *testing.T) {
-		execPayload, ok := fix["ExecutionPayloadElectra"].(*pb.ExecutionPayloadElectra)
-		require.Equal(t, true, ok)
-		want, ok := fix["ValidPayloadStatus"].(*pb.PayloadStatus)
-		require.Equal(t, true, ok)
-		client := newPayloadV4Setup(t, want, execPayload)
-
-		// We call the RPC method via HTTP and expect a proper result.
-		wrappedPayload, err := blocks.WrappedExecutionPayloadElectra(execPayload)
-		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
-		require.NoError(t, err)
-		require.DeepEqual(t, want.LatestValidHash, resp)
-	})
 	t.Run(NewPayloadMethod+" SYNCING status", func(t *testing.T) {
 		execPayload, ok := fix["ExecutionPayload"].(*pb.ExecutionPayload)
 		require.Equal(t, true, ok)
@@ -624,20 +544,6 @@ func TestClient_HTTP(t *testing.T) {
 		require.ErrorIs(t, ErrAcceptedSyncingPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
-	t.Run(NewPayloadMethodV4+" SYNCING status", func(t *testing.T) {
-		execPayload, ok := fix["ExecutionPayloadElectra"].(*pb.ExecutionPayloadElectra)
-		require.Equal(t, true, ok)
-		want, ok := fix["SyncingStatus"].(*pb.PayloadStatus)
-		require.Equal(t, true, ok)
-		client := newPayloadV4Setup(t, want, execPayload)
-
-		// We call the RPC method via HTTP and expect a proper result.
-		wrappedPayload, err := blocks.WrappedExecutionPayloadElectra(execPayload)
-		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
-		require.ErrorIs(t, ErrAcceptedSyncingPayloadStatus, err)
-		require.DeepEqual(t, []uint8(nil), resp)
-	})
 	t.Run(NewPayloadMethod+" INVALID_BLOCK_HASH status", func(t *testing.T) {
 		execPayload, ok := fix["ExecutionPayload"].(*pb.ExecutionPayload)
 		require.Equal(t, true, ok)
@@ -680,20 +586,6 @@ func TestClient_HTTP(t *testing.T) {
 		require.ErrorIs(t, ErrInvalidBlockHashPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
-	t.Run(NewPayloadMethodV4+" INVALID_BLOCK_HASH status", func(t *testing.T) {
-		execPayload, ok := fix["ExecutionPayloadElectra"].(*pb.ExecutionPayloadElectra)
-		require.Equal(t, true, ok)
-		want, ok := fix["InvalidBlockHashStatus"].(*pb.PayloadStatus)
-		require.Equal(t, true, ok)
-		client := newPayloadV4Setup(t, want, execPayload)
-
-		// We call the RPC method via HTTP and expect a proper result.
-		wrappedPayload, err := blocks.WrappedExecutionPayloadElectra(execPayload)
-		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
-		require.ErrorIs(t, ErrInvalidBlockHashPayloadStatus, err)
-		require.DeepEqual(t, []uint8(nil), resp)
-	})
 	t.Run(NewPayloadMethod+" INVALID status", func(t *testing.T) {
 		execPayload, ok := fix["ExecutionPayload"].(*pb.ExecutionPayload)
 		require.Equal(t, true, ok)
@@ -736,20 +628,6 @@ func TestClient_HTTP(t *testing.T) {
 		require.ErrorIs(t, ErrInvalidPayloadStatus, err)
 		require.DeepEqual(t, want.LatestValidHash, resp)
 	})
-	t.Run(NewPayloadMethodV4+" INVALID status", func(t *testing.T) {
-		execPayload, ok := fix["ExecutionPayloadElectra"].(*pb.ExecutionPayloadElectra)
-		require.Equal(t, true, ok)
-		want, ok := fix["InvalidStatus"].(*pb.PayloadStatus)
-		require.Equal(t, true, ok)
-		client := newPayloadV4Setup(t, want, execPayload)
-
-		// We call the RPC method via HTTP and expect a proper result.
-		wrappedPayload, err := blocks.WrappedExecutionPayloadElectra(execPayload)
-		require.NoError(t, err)
-		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{'a'})
-		require.ErrorIs(t, ErrInvalidPayloadStatus, err)
-		require.DeepEqual(t, want.LatestValidHash, resp)
-	})
 	t.Run(NewPayloadMethod+" UNKNOWN status", func(t *testing.T) {
 		execPayload, ok := fix["ExecutionPayload"].(*pb.ExecutionPayload)
 		require.Equal(t, true, ok)
@@ -1417,10 +1295,8 @@ func fixtures() map[string]interface{} {
 		"ExecutionPayload":                  s.ExecutionPayload,
 		"ExecutionPayloadCapella":           s.ExecutionPayloadCapella,
 		"ExecutionPayloadDeneb":             s.ExecutionPayloadDeneb,
-		"ExecutionPayloadElectra":           s.ExecutionPayloadElectra,
 		"ExecutionPayloadCapellaWithValue":  s.ExecutionPayloadWithValueCapella,
 		"ExecutionPayloadDenebWithValue":    s.ExecutionPayloadWithValueDeneb,
-		"ExecutionPayloadElectraWithValue":  s.ExecutionPayloadWithValueElectra,
 		"ValidPayloadStatus":                s.ValidPayloadStatus,
 		"InvalidBlockHashStatus":            s.InvalidBlockHashStatus,
 		"AcceptedStatus":                    s.AcceptedStatus,
@@ -1558,40 +1434,6 @@ func fixturesStruct() *payloadFixtures {
 			TargetPubkey:  &tPubkey,
 		}
 	}
-	dr, err := pb.JsonDepositRequestsToProto(depositRequests)
-	if err != nil {
-		panic(err)
-	}
-	wr, err := pb.JsonWithdrawalRequestsToProto(withdrawalRequests)
-	if err != nil {
-		panic(err)
-	}
-	cr, err := pb.JsonConsolidationRequestsToProto(consolidationRequests)
-	if err != nil {
-		panic(err)
-	}
-	executionPayloadFixtureElectra := &pb.ExecutionPayloadElectra{
-		ParentHash:            foo[:],
-		FeeRecipient:          bar,
-		StateRoot:             foo[:],
-		ReceiptsRoot:          foo[:],
-		LogsBloom:             baz,
-		PrevRandao:            foo[:],
-		BlockNumber:           1,
-		GasLimit:              1,
-		GasUsed:               1,
-		Timestamp:             1,
-		ExtraData:             foo[:],
-		BaseFeePerGas:         bytesutil.PadTo(baseFeePerGas.Bytes(), fieldparams.RootLength),
-		BlockHash:             foo[:],
-		Transactions:          [][]byte{foo[:]},
-		Withdrawals:           []*pb.Withdrawal{},
-		BlobGasUsed:           2,
-		ExcessBlobGas:         3,
-		DepositRequests:       dr,
-		WithdrawalRequests:    wr,
-		ConsolidationRequests: cr,
-	}
 	hexUint := hexutil.Uint64(1)
 	executionPayloadWithValueFixtureCapella := &pb.GetPayloadV2ResponseJson{
 		ExecutionPayload: &pb.ExecutionPayloadCapellaJSON{
@@ -1641,36 +1483,6 @@ func fixturesStruct() *payloadFixtures {
 			Blobs:       []hexutil.Bytes{{'a'}, {'b'}},
 		},
 	}
-	executionPayloadWithValueFixtureElectra := &pb.GetPayloadV4ResponseJson{
-		ShouldOverrideBuilder: true,
-		ExecutionPayload: &pb.ExecutionPayloadElectraJSON{
-			ParentHash:            &common.Hash{'a'},
-			FeeRecipient:          &common.Address{'b'},
-			StateRoot:             &common.Hash{'c'},
-			ReceiptsRoot:          &common.Hash{'d'},
-			LogsBloom:             &hexutil.Bytes{'e'},
-			PrevRandao:            &common.Hash{'f'},
-			BaseFeePerGas:         "0x123",
-			BlockHash:             &common.Hash{'g'},
-			Transactions:          []hexutil.Bytes{{'h'}},
-			Withdrawals:           []*pb.Withdrawal{},
-			BlockNumber:           &hexUint,
-			GasLimit:              &hexUint,
-			GasUsed:               &hexUint,
-			Timestamp:             &hexUint,
-			BlobGasUsed:           &bgu,
-			ExcessBlobGas:         &ebg,
-			DepositRequests:       depositRequests,
-			WithdrawalRequests:    withdrawalRequests,
-			ConsolidationRequests: consolidationRequests,
-		},
-		BlockValue: "0x11fffffffff",
-		BlobsBundle: &pb.BlobBundleJSON{
-			Commitments: []hexutil.Bytes{[]byte("commitment1"), []byte("commitment2")},
-			Proofs:      []hexutil.Bytes{[]byte("proof1"), []byte("proof2")},
-			Blobs:       []hexutil.Bytes{{'a'}, {'b'}},
-		},
-	}
 	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
 	sha3Uncles := bytesutil.PadTo([]byte("sha3Uncles"), fieldparams.RootLength)
 	miner := bytesutil.PadTo([]byte("miner"), fieldparams.FeeRecipientLength)
@@ -1762,10 +1574,8 @@ func fixturesStruct() *payloadFixtures {
 		ExecutionPayloadCapella:           executionPayloadFixtureCapella,
 		ExecutionPayloadDeneb:             executionPayloadFixtureDeneb,
 		EmptyExecutionPayloadDeneb:        emptyExecutionPayloadDeneb,
-		ExecutionPayloadElectra:           executionPayloadFixtureElectra,
 		ExecutionPayloadWithValueCapella:  executionPayloadWithValueFixtureCapella,
 		ExecutionPayloadWithValueDeneb:    executionPayloadWithValueFixtureDeneb,
-		ExecutionPayloadWithValueElectra:  executionPayloadWithValueFixtureElectra,
 		ValidPayloadStatus:                validStatus,
 		InvalidBlockHashStatus:            inValidBlockHashStatus,
 		AcceptedStatus:                    acceptedStatus,
@@ -1787,10 +1597,8 @@ type payloadFixtures struct {
 	ExecutionPayloadCapella           *pb.ExecutionPayloadCapella
 	EmptyExecutionPayloadDeneb        *pb.ExecutionPayloadDeneb
 	ExecutionPayloadDeneb             *pb.ExecutionPayloadDeneb
-	ExecutionPayloadElectra           *pb.ExecutionPayloadElectra
 	ExecutionPayloadWithValueCapella  *pb.GetPayloadV2ResponseJson
 	ExecutionPayloadWithValueDeneb    *pb.GetPayloadV3ResponseJson
-	ExecutionPayloadWithValueElectra  *pb.GetPayloadV4ResponseJson
 	ValidPayloadStatus                *pb.PayloadStatus
 	InvalidBlockHashStatus            *pb.PayloadStatus
 	AcceptedStatus                    *pb.PayloadStatus
@@ -2149,40 +1957,6 @@ func newPayloadV3Setup(t *testing.T, status *pb.PayloadStatus, payload *pb.Execu
 	return service
 }
 
-func newPayloadV4Setup(t *testing.T, status *pb.PayloadStatus, payload *pb.ExecutionPayloadElectra) *Service {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		defer func() {
-			require.NoError(t, r.Body.Close())
-		}()
-		enc, err := io.ReadAll(r.Body)
-		require.NoError(t, err)
-		jsonRequestString := string(enc)
-
-		reqArg, err := json.Marshal(payload)
-		require.NoError(t, err)
-
-		// We expect the JSON string RPC request contains the right arguments.
-		require.Equal(t, true, strings.Contains(
-			jsonRequestString, string(reqArg),
-		))
-		resp := map[string]interface{}{
-			"jsonrpc": "2.0",
-			"id":      1,
-			"result":  status,
-		}
-		err = json.NewEncoder(w).Encode(resp)
-		require.NoError(t, err)
-	}))
-
-	rpcClient, err := rpc.DialHTTP(srv.URL)
-	require.NoError(t, err)
-
-	service := &Service{}
-	service.rpcClient = rpcClient
-	return service
-}
-
 func TestReconstructBlindedBlockBatch(t *testing.T) {
 	t.Run("empty response works", func(t *testing.T) {
 		ctx := context.Background()

beacon-chain/execution/payload_body_test.go

@@ -64,12 +64,6 @@ func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPaylo
 	for i := range txs {
 		body.Transactions = append(body.Transactions, txs[i])
 	}
-	eed, isElectra := ed.(interfaces.ExecutionDataElectra)
-	if isElectra {
-		body.DepositRequests = pb.ProtoDepositRequestsToJson(eed.DepositRequests())
-		body.WithdrawalRequests = pb.ProtoWithdrawalRequestsToJson(eed.WithdrawalRequests())
-		body.ConsolidationRequests = pb.ProtoConsolidationRequestsToJson(eed.ConsolidationRequests())
-	}
 	return body
 }
 
@@ -132,7 +126,7 @@ func testBlindedBlockFixtures(t *testing.T) *blindedBlockFixtures {
 	afterSkipBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, denebSlot(t)+3, 0, util.WithPayloadSetter(afterSkip))
 	fx.afterSkipDeneb = blindedBlockWithHeader(t, afterSkipBlock)
 
-	electra := fixturesStruct().ExecutionPayloadElectra
+	electra := fixturesStruct().ExecutionPayloadDeneb
 	electra.BlockHash = bytesutil.PadTo([]byte("electra"), 32)
 	electra.BlockNumber = 5
 	electraBlock, _ := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, electraSlot(t), 0, util.WithElectraPayload(electra))
@@ -164,6 +158,7 @@ func TestPayloadBodiesViaUnblinder(t *testing.T) {
 
 		payload, err := bbr.payloadForHeader(fx.denebBlock.blinded.header, fx.denebBlock.blinded.block.Version())
 		require.NoError(t, err)
+		require.Equal(t, version.Deneb, fx.denebBlock.blinded.block.Version())
 		unblindFull, err := blocks.BuildSignedBeaconBlockFromExecutionPayload(fx.denebBlock.blinded.block, payload)
 		require.NoError(t, err)
 		testAssertReconstructedEquivalent(t, fx.denebBlock.full, unblindFull)

beacon-chain/execution/service_test.go

@@ -73,7 +73,7 @@ type goodNotifier struct {
 	MockStateFeed *event.Feed
 }
 
-func (g *goodNotifier) StateFeed() *event.Feed {
+func (g *goodNotifier) StateFeed() event.SubscriberSender {
 	if g.MockStateFeed == nil {
 		g.MockStateFeed = new(event.Feed)
 	}

beacon-chain/node/node.go

@@ -398,7 +398,7 @@ func initSyncWaiter(ctx context.Context, complete chan struct{}) func() error {
 }
 
 // StateFeed implements statefeed.Notifier.
-func (b *BeaconNode) StateFeed() *event.Feed {
+func (b *BeaconNode) StateFeed() event.SubscriberSender {
 	return b.stateFeed
 }
 
@@ -408,7 +408,7 @@ func (b *BeaconNode) BlockFeed() *event.Feed {
 }
 
 // OperationFeed implements opfeed.Notifier.
-func (b *BeaconNode) OperationFeed() *event.Feed {
+func (b *BeaconNode) OperationFeed() event.SubscriberSender {
 	return b.opFeed
 }
 

beacon-chain/p2p/BUILD.bazel

@@ -179,8 +179,6 @@ go_test(
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/host/blank:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/net/swarm/testing:go_default_library",
         "@com_github_libp2p_go_libp2p//p2p/security/noise:go_default_library",
         "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",
         "@com_github_libp2p_go_libp2p_pubsub//pb:go_default_library",

beacon-chain/p2p/dial_relay_node_test.go

@@ -5,8 +5,8 @@ import (
 	"fmt"
 	"testing"
 
-	bh "github.com/libp2p/go-libp2p/p2p/host/blank"
-	swarmt "github.com/libp2p/go-libp2p/p2p/net/swarm/testing"
+	"github.com/libp2p/go-libp2p"
+	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
@@ -29,8 +29,10 @@ func TestDialRelayNode_InvalidPeerString(t *testing.T) {
 
 func TestDialRelayNode_OK(t *testing.T) {
 	ctx := context.Background()
-	relay := bh.NewBlankHost(swarmt.GenSwarm(t))
-	host := bh.NewBlankHost(swarmt.GenSwarm(t))
+	relay, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}))
+	require.NoError(t, err)
+	host, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}))
+	require.NoError(t, err)
 	relayAddr := fmt.Sprintf("%s/p2p/%s", relay.Addrs()[0], relay.ID().String())
 
 	assert.NoError(t, dialRelayNode(ctx, host, relayAddr), "Unexpected error when dialing relay node")

beacon-chain/p2p/pubsub.go

@@ -182,6 +182,7 @@ func pubsubGossipParam() pubsub.GossipSubParams {
 	gParams := pubsub.DefaultGossipSubParams()
 	gParams.Dlo = gossipSubDlo
 	gParams.D = gossipSubD
+	gParams.Dhi = gossipSubDhi
 	gParams.HeartbeatInterval = gossipSubHeartbeatInterval
 	gParams.HistoryLength = gossipSubMcacheLen
 	gParams.HistoryGossip = gossipSubMcacheGossip

beacon-chain/p2p/testing/BUILD.bazel

@@ -22,9 +22,11 @@ go_library(
         "//beacon-chain/p2p/peers/scorers:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
+        "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
+        "@com_github_libp2p_go_libp2p//:go_default_library",
         "@com_github_libp2p_go_libp2p//core:go_default_library",
         "@com_github_libp2p_go_libp2p//core/connmgr:go_default_library",
         "@com_github_libp2p_go_libp2p//core/control:go_default_library",
@@ -34,8 +36,7 @@ go_library(
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peerstore:go_default_library",
         "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/host/blank:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/net/swarm/testing:go_default_library",
+        "@com_github_libp2p_go_libp2p//p2p/transport/tcp:go_default_library",
         "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",
         "@com_github_multiformats_go_multiaddr//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",

beacon-chain/p2p/testing/p2p.go

@@ -11,6 +11,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/p2p/enr"
+	"github.com/libp2p/go-libp2p"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	core "github.com/libp2p/go-libp2p/core"
 	"github.com/libp2p/go-libp2p/core/control"
@@ -18,8 +19,7 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/libp2p/go-libp2p/core/protocol"
-	bhost "github.com/libp2p/go-libp2p/p2p/host/blank"
-	swarmt "github.com/libp2p/go-libp2p/p2p/net/swarm/testing"
+	"github.com/libp2p/go-libp2p/p2p/transport/tcp"
 	"github.com/multiformats/go-multiaddr"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/encoder"
@@ -27,6 +27,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers/scorers"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/metadata"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/protobuf/proto"
 )
@@ -52,7 +53,8 @@ type TestP2P struct {
 // NewTestP2P initializes a new p2p test service.
 func NewTestP2P(t *testing.T) *TestP2P {
 	ctx := context.Background()
-	h := bhost.NewBlankHost(swarmt.GenSwarm(t, swarmt.OptDisableQUIC))
+	h, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}), libp2p.Transport(tcp.NewTCPTransport), libp2p.DefaultListenAddrs)
+	require.NoError(t, err)
 	ps, err := pubsub.NewFloodSub(ctx, h,
 		pubsub.WithMessageSigning(false),
 		pubsub.WithStrictSignatureVerification(false),
@@ -86,13 +88,17 @@ func (p *TestP2P) Connect(b *TestP2P) {
 }
 
 func connect(a, b host.Host) error {
-	pinfo := b.Peerstore().PeerInfo(b.ID())
+	pinfo := peer.AddrInfo{
+		ID:    b.ID(),
+		Addrs: b.Addrs(),
+	}
 	return a.Connect(context.Background(), pinfo)
 }
 
 // ReceiveRPC simulates an incoming RPC.
 func (p *TestP2P) ReceiveRPC(topic string, msg proto.Message) {
-	h := bhost.NewBlankHost(swarmt.GenSwarm(p.t))
+	h, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}))
+	require.NoError(p.t, err)
 	if err := connect(h, p.BHost); err != nil {
 		p.t.Fatalf("Failed to connect two peers for RPC: %v", err)
 	}
@@ -122,7 +128,8 @@ func (p *TestP2P) ReceiveRPC(topic string, msg proto.Message) {
 
 // ReceivePubSub simulates an incoming message over pubsub on a given topic.
 func (p *TestP2P) ReceivePubSub(topic string, msg proto.Message) {
-	h := bhost.NewBlankHost(swarmt.GenSwarm(p.t))
+	h, err := libp2p.New(libp2p.ResourceManager(&network.NullResourceManager{}))
+	require.NoError(p.t, err)
 	ps, err := pubsub.NewFloodSub(context.Background(), h,
 		pubsub.WithMessageSigning(false),
 		pubsub.WithStrictSignatureVerification(false),

beacon-chain/rpc/BUILD.bazel

@@ -89,5 +89,6 @@ go_test(
         "//testing/require:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
+        "@org_golang_x_exp//maps:go_default_library",
     ],
 )

beacon-chain/rpc/endpoints.go

@@ -773,6 +773,15 @@ func (s *Service) beaconEndpoints(
 			handler: server.GetValidatorBalances,
 			methods: []string{http.MethodGet, http.MethodPost},
 		},
+		{
+			template: "/eth/v1/beacon/deposit_snapshot",
+			name:     namespace + ".GetDepositSnapshot",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetDepositSnapshot,
+			methods: []string{http.MethodGet},
+		},
 	}
 }
 
@@ -942,6 +951,8 @@ func (s *Service) prysmBeaconEndpoints(
 		ChainInfoFetcher:      s.cfg.ChainInfoFetcher,
 		FinalizationFetcher:   s.cfg.FinalizationFetcher,
 		CoreService:           coreService,
+		Broadcaster:           s.cfg.Broadcaster,
+		BlobReceiver:          s.cfg.BlobReceiver,
 	}
 
 	const namespace = "prysm.beacon"
@@ -992,6 +1003,16 @@ func (s *Service) prysmBeaconEndpoints(
 			handler: server.GetChainHead,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/prysm/v1/beacon/blobs",
+			name:     namespace + ".PublishBlobs",
+			middleware: []middleware.Middleware{
+				middleware.ContentTypeHandler([]string{api.JsonMediaType}),
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.PublishBlobs,
+			methods: []string{http.MethodPost},
+		},
 	}
 }
 

beacon-chain/rpc/endpoints_test.go

@@ -2,9 +2,11 @@ package rpc
 
 import (
 	"net/http"
+	"slices"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
+	"golang.org/x/exp/maps"
 )
 
 func Test_endpoints(t *testing.T) {
@@ -31,7 +33,6 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v2/beacon/blinded_blocks":                              {http.MethodPost},
 		"/eth/v1/beacon/blocks":                                      {http.MethodPost},
 		"/eth/v2/beacon/blocks":                                      {http.MethodPost},
-		"/eth/v1/beacon/blocks/{block_id}":                           {http.MethodGet},
 		"/eth/v2/beacon/blocks/{block_id}":                           {http.MethodGet},
 		"/eth/v1/beacon/blocks/{block_id}/root":                      {http.MethodGet},
 		"/eth/v1/beacon/blocks/{block_id}/attestations":              {http.MethodGet},
@@ -69,7 +70,6 @@ func Test_endpoints(t *testing.T) {
 	}
 
 	debugRoutes := map[string][]string{
-		"/eth/v1/debug/beacon/states/{state_id}": {http.MethodGet},
 		"/eth/v2/debug/beacon/states/{state_id}": {http.MethodGet},
 		"/eth/v2/debug/beacon/heads":             {http.MethodGet},
 		"/eth/v1/debug/fork_choice":              {http.MethodGet},
@@ -115,6 +115,7 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/beacon/states/{state_id}/validator_count":   {http.MethodGet},
 		"/prysm/v1/beacon/states/{state_id}/validator_count": {http.MethodGet},
 		"/prysm/v1/beacon/chain_head":                        {http.MethodGet},
+		"/prysm/v1/beacon/blobs":                             {http.MethodPost},
 	}
 
 	prysmNodeRoutes := map[string][]string{
@@ -133,22 +134,18 @@ func Test_endpoints(t *testing.T) {
 
 	s := &Service{cfg: &Config{}}
 
-	routesMap := combineMaps(beaconRoutes, builderRoutes, configRoutes, debugRoutes, eventsRoutes, nodeRoutes, validatorRoutes, rewardsRoutes, lightClientRoutes, blobRoutes, prysmValidatorRoutes, prysmNodeRoutes, prysmBeaconRoutes)
-	actual := s.endpoints(true, nil, nil, nil, nil, nil, nil)
-	for _, e := range actual {
-		methods, ok := routesMap[e.template]
-		assert.Equal(t, true, ok, "endpoint "+e.template+" not found")
-		if ok {
-			for _, em := range e.methods {
-				methodFound := false
-				for _, m := range methods {
-					if m == em {
-						methodFound = true
-						break
-					}
-				}
-				assert.Equal(t, true, methodFound, "method "+em+" for endpoint "+e.template+" not found")
-			}
+	endpoints := s.endpoints(true, nil, nil, nil, nil, nil, nil)
+	actualRoutes := make(map[string][]string, len(endpoints))
+	for _, e := range endpoints {
+		if _, ok := actualRoutes[e.template]; ok {
+			actualRoutes[e.template] = append(actualRoutes[e.template], e.methods...)
+		} else {
+			actualRoutes[e.template] = e.methods
 		}
 	}
+	expectedRoutes := combineMaps(beaconRoutes, builderRoutes, configRoutes, debugRoutes, eventsRoutes, nodeRoutes, validatorRoutes, rewardsRoutes, lightClientRoutes, blobRoutes, prysmValidatorRoutes, prysmNodeRoutes, prysmBeaconRoutes)
+
+	assert.Equal(t, true, maps.EqualFunc(expectedRoutes, actualRoutes, func(actualMethods []string, expectedMethods []string) bool {
+		return slices.Equal(expectedMethods, actualMethods)
+	}))
 }

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

@@ -1512,10 +1512,6 @@ func (s *Server) GetDepositSnapshot(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetDepositSnapshot")
 	defer span.End()
 
-	if s.BeaconDB == nil {
-		httputil.HandleError(w, "Could not retrieve beaconDB", http.StatusInternalServerError)
-		return
-	}
 	eth1data, err := s.BeaconDB.ExecutionChainData(ctx)
 	if err != nil {
 		httputil.HandleError(w, "Could not retrieve execution chain data: "+err.Error(), http.StatusInternalServerError)
@@ -1527,7 +1523,7 @@ func (s *Server) GetDepositSnapshot(w http.ResponseWriter, r *http.Request) {
 	}
 	snapshot := eth1data.DepositSnapshot
 	if snapshot == nil || len(snapshot.Finalized) == 0 {
-		httputil.HandleError(w, "No Finalized Snapshot Available", http.StatusNotFound)
+		httputil.HandleError(w, "No finalized snapshot available", http.StatusNotFound)
 		return
 	}
 	if len(snapshot.Finalized) > depositsnapshot.DepositContractDepth {

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

@@ -268,6 +268,38 @@ func TestGetBlockV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, blk, b)
 	})
+	t.Run("electra", func(t *testing.T) {
+		b := util.NewBeaconBlockElectra()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
+		mockChainService := &chainMock.ChainService{
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               mockBlockFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
+		request.SetPathValue("block_id", "head")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Electra), resp.Version)
+		sbb := &structs.SignedBeaconBlockElectra{Message: &structs.BeaconBlockElectra{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		blk, err := sbb.ToConsensus()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		b := util.NewBeaconBlockBellatrix()
 		sb, err := blocks.NewSignedBeaconBlock(b)
@@ -461,7 +493,29 @@ func TestGetBlockSSZV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
 	})
+	t.Run("electra", func(t *testing.T) {
+		b := util.NewBeaconBlockElectra()
+		b.Block.Slot = 123
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
 
+		s := &Server{
+			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
+		request.SetPathValue("block_id", "head")
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlockV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		assert.Equal(t, version.String(version.Electra), writer.Header().Get(api.VersionHeader))
+		sszExpected, err := b.MarshalSSZ()
+		require.NoError(t, err)
+		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
+	})
 }
 
 func TestGetBlockAttestations(t *testing.T) {
@@ -759,6 +813,35 @@ func TestGetBlindedBlock(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, blk, b)
 	})
+	t.Run("electra", func(t *testing.T) {
+		b := util.NewBlindedBeaconBlockElectra()
+		sb, err := blocks.NewSignedBeaconBlock(b)
+		require.NoError(t, err)
+
+		mockChainService := &chainMock.ChainService{}
+		s := &Server{
+			OptimisticModeFetcher: mockChainService,
+			FinalizationFetcher:   mockChainService,
+			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
+		request.SetPathValue("block_id", "head")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBlindedBlock(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBlockV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Electra), resp.Version)
+		sbb := &structs.SignedBlindedBeaconBlockElectra{Message: &structs.BlindedBeaconBlockElectra{}}
+		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
+		sbb.Signature = resp.Data.Signature
+		blk, err := sbb.ToConsensus()
+		require.NoError(t, err)
+		assert.DeepEqual(t, blk, b)
+	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		b := util.NewBlindedBeaconBlockBellatrix()
 		sb, err := blocks.NewSignedBeaconBlock(b)

beacon-chain/rpc/eth/debug/handlers.go

@@ -88,6 +88,12 @@ func (s *Server) getBeaconStateV2(ctx context.Context, w http.ResponseWriter, id
 			httputil.HandleError(w, errMsgStateFromConsensus+": "+err.Error(), http.StatusInternalServerError)
 			return
 		}
+	case version.Electra:
+		respSt, err = structs.BeaconStateElectraFromConsensus(st)
+		if err != nil {
+			httputil.HandleError(w, errMsgStateFromConsensus+": "+err.Error(), http.StatusInternalServerError)
+			return
+		}
 	default:
 		httputil.HandleError(w, "Unsupported state version", http.StatusInternalServerError)
 		return

beacon-chain/rpc/eth/debug/handlers_test.go

@@ -167,6 +167,34 @@ func TestGetBeaconStateV2(t *testing.T) {
 		require.NoError(t, json.Unmarshal(resp.Data, st))
 		assert.Equal(t, "123", st.Slot)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		fakeState, err := util.NewBeaconStateElectra()
+		require.NoError(t, err)
+		require.NoError(t, fakeState.SetSlot(123))
+		chainService := &blockchainmock.ChainService{}
+		s := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: fakeState,
+			},
+			HeadFetcher:           chainService,
+			OptimisticModeFetcher: chainService,
+			FinalizationFetcher:   chainService,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
+		request.SetPathValue("state_id", "head")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetBeaconStateV2(writer, request)
+		require.Equal(t, http.StatusOK, writer.Code)
+		resp := &structs.GetBeaconStateV2Response{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
+		assert.Equal(t, version.String(version.Electra), resp.Version)
+		st := &structs.BeaconStateElectra{}
+		require.NoError(t, json.Unmarshal(resp.Data, st))
+		assert.Equal(t, "123", st.Slot)
+	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		parentRoot := [32]byte{'a'}
 		blk := util.NewBeaconBlock()

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

@@ -20,6 +20,7 @@ go_library(
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/eth/v1:go_default_library",
@@ -29,12 +30,16 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )
 
 go_test(
     name = "go_default_test",
-    srcs = ["events_test.go"],
+    srcs = [
+        "events_test.go",
+        "http_test.go",
+    ],
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/blockchain/testing:go_default_library",
@@ -49,9 +54,9 @@ go_test(
         "//consensus-types/primitives:go_default_library",
         "//proto/eth/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",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_r3labs_sse_v2//:go_default_library",
     ],
 )

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

@@ -1,24 +1,26 @@
 package events
 
 import (
+	"bytes"
 	"context"
 	"encoding/json"
 	"fmt"
+	"io"
 	"net/http"
-	time2 "time"
+	"time"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
+	chaintime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
@@ -26,9 +28,13 @@ import (
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	log "github.com/sirupsen/logrus"
 )
 
+const DefaultEventFeedDepth = 1000
+
 const (
+	InvalidTopic = "__invalid__"
 	// HeadTopic represents a new chain head event topic.
 	HeadTopic = "head"
 	// BlockTopic represents a new produced block event topic.
@@ -59,25 +65,83 @@ const (
 	LightClientOptimisticUpdateTopic = "light_client_optimistic_update"
 )
 
-const topicDataMismatch = "Event data type %T does not correspond to event topic %s"
+var (
+	errInvalidTopicName   = errors.New("invalid topic name")
+	errNoValidTopics      = errors.New("no valid topics specified")
+	errSlowReader         = errors.New("client failed to read fast enough to keep outgoing buffer below threshold")
+	errNotRequested       = errors.New("event not requested by client")
+	errUnhandledEventData = errors.New("unable to represent event data in the event stream")
+)
 
-const chanBuffer = 1000
+// StreamingResponseWriter defines a type that can be used by the eventStreamer.
+// This must be an http.ResponseWriter that supports flushing and hijacking.
+type StreamingResponseWriter interface {
+	http.ResponseWriter
+	http.Flusher
+}
 
-var casesHandled = map[string]bool{
-	HeadTopic:                        true,
-	BlockTopic:                       true,
-	AttestationTopic:                 true,
-	VoluntaryExitTopic:               true,
-	FinalizedCheckpointTopic:         true,
-	ChainReorgTopic:                  true,
-	SyncCommitteeContributionTopic:   true,
-	BLSToExecutionChangeTopic:        true,
-	PayloadAttributesTopic:           true,
-	BlobSidecarTopic:                 true,
-	ProposerSlashingTopic:            true,
-	AttesterSlashingTopic:            true,
-	LightClientFinalityUpdateTopic:   true,
-	LightClientOptimisticUpdateTopic: true,
+// The eventStreamer uses lazyReaders to defer serialization until the moment the value is ready to be written to the client.
+type lazyReader func() io.Reader
+
+var opsFeedEventTopics = map[feed.EventType]string{
+	operation.AggregatedAttReceived:             AttestationTopic,
+	operation.UnaggregatedAttReceived:           AttestationTopic,
+	operation.ExitReceived:                      VoluntaryExitTopic,
+	operation.SyncCommitteeContributionReceived: SyncCommitteeContributionTopic,
+	operation.BLSToExecutionChangeReceived:      BLSToExecutionChangeTopic,
+	operation.BlobSidecarReceived:               BlobSidecarTopic,
+	operation.AttesterSlashingReceived:          AttesterSlashingTopic,
+	operation.ProposerSlashingReceived:          ProposerSlashingTopic,
+}
+
+var stateFeedEventTopics = map[feed.EventType]string{
+	statefeed.NewHead:                     HeadTopic,
+	statefeed.MissedSlot:                  PayloadAttributesTopic,
+	statefeed.FinalizedCheckpoint:         FinalizedCheckpointTopic,
+	statefeed.LightClientFinalityUpdate:   LightClientFinalityUpdateTopic,
+	statefeed.LightClientOptimisticUpdate: LightClientOptimisticUpdateTopic,
+	statefeed.Reorg:                       ChainReorgTopic,
+	statefeed.BlockProcessed:              BlockTopic,
+}
+
+var topicsForStateFeed = topicsForFeed(stateFeedEventTopics)
+var topicsForOpsFeed = topicsForFeed(opsFeedEventTopics)
+
+func topicsForFeed(em map[feed.EventType]string) map[string]bool {
+	topics := make(map[string]bool, len(em))
+	for _, topic := range em {
+		topics[topic] = true
+	}
+	return topics
+}
+
+type topicRequest struct {
+	topics        map[string]bool
+	needStateFeed bool
+	needOpsFeed   bool
+}
+
+func (req *topicRequest) requested(topic string) bool {
+	return req.topics[topic]
+}
+
+func newTopicRequest(topics []string) (*topicRequest, error) {
+	req := &topicRequest{topics: make(map[string]bool)}
+	for _, name := range topics {
+		if topicsForStateFeed[name] {
+			req.needStateFeed = true
+		} else if topicsForOpsFeed[name] {
+			req.needOpsFeed = true
+		} else {
+			return nil, errors.Wrapf(errInvalidTopicName, name)
+		}
+		req.topics[name] = true
+	}
+	if len(req.topics) == 0 || (!req.needStateFeed && !req.needOpsFeed) {
+		return nil, errNoValidTopics
+	}
+
+	return req, nil
 }
 
 // StreamEvents provides an endpoint to subscribe to the beacon node Server-Sent-Events stream.
@@ -88,326 +152,412 @@ func (s *Server) StreamEvents(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "events.StreamEvents")
 	defer span.End()
 
-	flusher, ok := w.(http.Flusher)
+	topics, err := newTopicRequest(r.URL.Query()["topics"])
+	if err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	sw, ok := w.(StreamingResponseWriter)
 	if !ok {
-		httputil.HandleError(w, "Streaming unsupported!", http.StatusInternalServerError)
+		msg := "beacon node misconfiguration: http stack may not support required response handling features, like flushing"
+		httputil.HandleError(w, msg, http.StatusInternalServerError)
 		return
 	}
-
-	topics := r.URL.Query()["topics"]
-	if len(topics) == 0 {
-		httputil.HandleError(w, "No topics specified to subscribe to", http.StatusBadRequest)
-		return
+	depth := s.EventFeedDepth
+	if depth == 0 {
+		depth = DefaultEventFeedDepth
 	}
-	topicsMap := make(map[string]bool)
-	for _, topic := range topics {
-		if _, ok := casesHandled[topic]; !ok {
-			httputil.HandleError(w, fmt.Sprintf("Invalid topic: %s", topic), http.StatusBadRequest)
-			return
-		}
-		topicsMap[topic] = true
-	}
-
-	// Subscribe to event feeds from information received in the beacon node runtime.
-	opsChan := make(chan *feed.Event, chanBuffer)
-	opsSub := s.OperationNotifier.OperationFeed().Subscribe(opsChan)
-	stateChan := make(chan *feed.Event, chanBuffer)
-	stateSub := s.StateNotifier.StateFeed().Subscribe(stateChan)
-	defer opsSub.Unsubscribe()
-	defer stateSub.Unsubscribe()
-
-	// Set up SSE response headers
-	w.Header().Set("Content-Type", api.EventStreamMediaType)
-	w.Header().Set("Connection", api.KeepAlive)
-
-	// Handle each event received and context cancellation.
-	// We send a keepalive dummy message immediately to prevent clients
-	// stalling while waiting for the first response chunk.
-	// After that we send a keepalive dummy message every SECONDS_PER_SLOT
-	// to prevent anyone (e.g. proxy servers) from closing connections.
-	if err := sendKeepalive(w, flusher); err != nil {
+	es, err := newEventStreamer(depth, s.KeepAliveInterval)
+	if err != nil {
 		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
 		return
 	}
-	keepaliveTicker := time2.NewTicker(time2.Duration(params.BeaconConfig().SecondsPerSlot) * time2.Second)
 
+	ctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+	api.SetSSEHeaders(sw)
+	go es.outboxWriteLoop(ctx, cancel, sw)
+	if err := es.recvEventLoop(ctx, cancel, topics, s); err != nil {
+		log.WithError(err).Debug("Shutting down StreamEvents handler.")
+	}
+}
+
+func newEventStreamer(buffSize int, ka time.Duration) (*eventStreamer, error) {
+	if ka == 0 {
+		ka = time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
+	}
+	return &eventStreamer{
+		outbox:    make(chan lazyReader, buffSize),
+		keepAlive: ka,
+	}, nil
+}
+
+type eventStreamer struct {
+	outbox    chan lazyReader
+	keepAlive time.Duration
+}
+
+func (es *eventStreamer) recvEventLoop(ctx context.Context, cancel context.CancelFunc, req *topicRequest, s *Server) error {
+	eventsChan := make(chan *feed.Event, len(es.outbox))
+	if req.needOpsFeed {
+		opsSub := s.OperationNotifier.OperationFeed().Subscribe(eventsChan)
+		defer opsSub.Unsubscribe()
+	}
+	if req.needStateFeed {
+		stateSub := s.StateNotifier.StateFeed().Subscribe(eventsChan)
+		defer stateSub.Unsubscribe()
+	}
 	for {
 		select {
-		case event := <-opsChan:
-			if err := handleBlockOperationEvents(w, flusher, topicsMap, event); err != nil {
-				httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
-		case event := <-stateChan:
-			if err := s.handleStateEvents(ctx, w, flusher, topicsMap, event); err != nil {
-				httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
-		case <-keepaliveTicker.C:
-			if err := sendKeepalive(w, flusher); err != nil {
-				httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-				return
-			}
 		case <-ctx.Done():
+			return ctx.Err()
+		case event := <-eventsChan:
+			lr, err := s.lazyReaderForEvent(ctx, event, req)
+			if err != nil {
+				if !errors.Is(err, errNotRequested) {
+					log.WithField("event_type", fmt.Sprintf("%v", event.Data)).WithError(err).Error("StreamEvents API endpoint received an event it was unable to handle.")
+				}
+				continue
+			}
+			// If the client can't keep up, the outbox will eventually completely fill, at which
+			// safeWrite will error, and we'll hit the below return statement, at which point the deferred
+			// Unsuscribe calls will be made and the event feed will stop writing to this channel.
+			// Since the outbox and event stream channels are separately buffered, the event subscription
+			// channel should stay relatively empty, which gives this loop time to unsubscribe
+			// and cleanup before the event stream channel fills and disrupts other readers.
+			if err := es.safeWrite(ctx, lr); err != nil {
+				cancel()
+				// note: we could hijack the connection and close it here. Does that cause issues? What are the benefits?
+				// A benefit of hijack and close is that it may force an error on the remote end, however just closing the context of the
+				// http handler may be sufficient to cause the remote http response reader to close.
+				if errors.Is(err, errSlowReader) {
+					log.WithError(err).Warn("Client is unable to keep up with event stream, shutting down.")
+				}
+				return err
+			}
+		}
+	}
+}
+
+func (es *eventStreamer) safeWrite(ctx context.Context, rf func() io.Reader) error {
+	if rf == nil {
+		return nil
+	}
+	select {
+	case <-ctx.Done():
+		return ctx.Err()
+	case es.outbox <- rf:
+		return nil
+	default:
+		// If this is the case, the select case to write to the outbox could not proceed, meaning the outbox is full.
+		// If a reader can't keep up with the stream, we shut them down.
+		return errSlowReader
+	}
+}
+
+// newlineReader is used to write keep-alives to the client.
+// keep-alives in the sse protocol are a single ':' colon followed by 2 newlines.
+func newlineReader() io.Reader {
+	return bytes.NewBufferString(":\n\n")
+}
+
+// outboxWriteLoop runs in a separate goroutine. Its job is to write the values in the outbox to
+// the client as fast as the client can read them.
+func (es *eventStreamer) outboxWriteLoop(ctx context.Context, cancel context.CancelFunc, w StreamingResponseWriter) {
+	var err error
+	defer func() {
+		if err != nil {
+			log.WithError(err).Debug("Event streamer shutting down due to error.")
+		}
+	}()
+	defer cancel()
+	// Write a keepalive at the start to test the connection and simplify test setup.
+	if err = es.writeOutbox(ctx, w, nil); err != nil {
+		return
+	}
+
+	kaT := time.NewTimer(es.keepAlive)
+	// Ensure the keepalive timer is stopped and drained if it has fired.
+	defer func() {
+		if !kaT.Stop() {
+			<-kaT.C
+		}
+	}()
+	for {
+		select {
+		case <-ctx.Done():
+			err = ctx.Err()
 			return
+		case <-kaT.C:
+			if err = es.writeOutbox(ctx, w, nil); err != nil {
+				return
+			}
+			// In this case the timer doesn't need to be Stopped before the Reset call after the select statement,
+			// because the timer has already fired.
+		case lr := <-es.outbox:
+			if err = es.writeOutbox(ctx, w, lr); err != nil {
+				return
+			}
+			// We don't know if the timer fired concurrently to this case being ready, so we need to check the return
+			// of Stop and drain the timer channel if it fired. We won't need to do this in go 1.23.
+			if !kaT.Stop() {
+				<-kaT.C
+			}
+		}
+		kaT.Reset(es.keepAlive)
+	}
+}
+
+func (es *eventStreamer) writeOutbox(ctx context.Context, w StreamingResponseWriter, first lazyReader) error {
+	needKeepAlive := true
+	if first != nil {
+		if _, err := io.Copy(w, first()); err != nil {
+			return err
+		}
+		needKeepAlive = false
+	}
+	// While the first event was being read by the client, further events may be queued in the outbox.
+	// We can drain them right away rather than go back out to the outer select statement, where the keepAlive timer
+	// may have fired, triggering an unnecessary extra keep-alive write and flush.
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		case rf := <-es.outbox:
+			if _, err := io.Copy(w, rf()); err != nil {
+				return err
+			}
+			needKeepAlive = false
+		default:
+			if needKeepAlive {
+				if _, err := io.Copy(w, newlineReader()); err != nil {
+					return err
+				}
+			}
+			w.Flush()
+			return nil
 		}
 	}
 }
 
-func handleBlockOperationEvents(w http.ResponseWriter, flusher http.Flusher, requestedTopics map[string]bool, event *feed.Event) error {
-	switch event.Type {
-	case operation.AggregatedAttReceived:
-		if _, ok := requestedTopics[AttestationTopic]; !ok {
-			return nil
-		}
-		attData, ok := event.Data.(*operation.AggregatedAttReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, AttestationTopic)
-		}
-		att := structs.AttFromConsensus(attData.Attestation.Aggregate)
-		return send(w, flusher, AttestationTopic, att)
-	case operation.UnaggregatedAttReceived:
-		if _, ok := requestedTopics[AttestationTopic]; !ok {
-			return nil
-		}
-		attData, ok := event.Data.(*operation.UnAggregatedAttReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, AttestationTopic)
-		}
-		a, ok := attData.Attestation.(*eth.Attestation)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, AttestationTopic)
-		}
-		att := structs.AttFromConsensus(a)
-		return send(w, flusher, AttestationTopic, att)
-	case operation.ExitReceived:
-		if _, ok := requestedTopics[VoluntaryExitTopic]; !ok {
-			return nil
-		}
-		exitData, ok := event.Data.(*operation.ExitReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, VoluntaryExitTopic)
-		}
-		exit := structs.SignedExitFromConsensus(exitData.Exit)
-		return send(w, flusher, VoluntaryExitTopic, exit)
-	case operation.SyncCommitteeContributionReceived:
-		if _, ok := requestedTopics[SyncCommitteeContributionTopic]; !ok {
-			return nil
-		}
-		contributionData, ok := event.Data.(*operation.SyncCommitteeContributionReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, SyncCommitteeContributionTopic)
-		}
-		contribution := structs.SignedContributionAndProofFromConsensus(contributionData.Contribution)
-		return send(w, flusher, SyncCommitteeContributionTopic, contribution)
-	case operation.BLSToExecutionChangeReceived:
-		if _, ok := requestedTopics[BLSToExecutionChangeTopic]; !ok {
-			return nil
-		}
-		changeData, ok := event.Data.(*operation.BLSToExecutionChangeReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, BLSToExecutionChangeTopic)
-		}
-		return send(w, flusher, BLSToExecutionChangeTopic, structs.SignedBLSChangeFromConsensus(changeData.Change))
-	case operation.BlobSidecarReceived:
-		if _, ok := requestedTopics[BlobSidecarTopic]; !ok {
-			return nil
-		}
-		blobData, ok := event.Data.(*operation.BlobSidecarReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, BlobSidecarTopic)
-		}
-		versionedHash := blockchain.ConvertKzgCommitmentToVersionedHash(blobData.Blob.KzgCommitment)
-		blobEvent := &structs.BlobSidecarEvent{
-			BlockRoot:     hexutil.Encode(blobData.Blob.BlockRootSlice()),
-			Index:         fmt.Sprintf("%d", blobData.Blob.Index),
-			Slot:          fmt.Sprintf("%d", blobData.Blob.Slot()),
-			VersionedHash: versionedHash.String(),
-			KzgCommitment: hexutil.Encode(blobData.Blob.KzgCommitment),
-		}
-		return send(w, flusher, BlobSidecarTopic, blobEvent)
-	case operation.AttesterSlashingReceived:
-		if _, ok := requestedTopics[AttesterSlashingTopic]; !ok {
-			return nil
-		}
-		attesterSlashingData, ok := event.Data.(*operation.AttesterSlashingReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, AttesterSlashingTopic)
-		}
-		slashing, ok := attesterSlashingData.AttesterSlashing.(*eth.AttesterSlashing)
-		if ok {
-			return send(w, flusher, AttesterSlashingTopic, structs.AttesterSlashingFromConsensus(slashing))
-		}
-		// TODO: extend to Electra
-	case operation.ProposerSlashingReceived:
-		if _, ok := requestedTopics[ProposerSlashingTopic]; !ok {
-			return nil
-		}
-		proposerSlashingData, ok := event.Data.(*operation.ProposerSlashingReceivedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, ProposerSlashingTopic)
-		}
-		return send(w, flusher, ProposerSlashingTopic, structs.ProposerSlashingFromConsensus(proposerSlashingData.ProposerSlashing))
+func jsonMarshalReader(name string, v any) io.Reader {
+	d, err := json.Marshal(v)
+	if err != nil {
+		log.WithError(err).WithField("type_name", fmt.Sprintf("%T", v)).Error("Could not marshal event data.")
+		return nil
 	}
-	return nil
+	return bytes.NewBufferString("event: " + name + "\ndata: " + string(d) + "\n\n")
 }
 
-func (s *Server) handleStateEvents(ctx context.Context, w http.ResponseWriter, flusher http.Flusher, requestedTopics map[string]bool, event *feed.Event) error {
-	switch event.Type {
-	case statefeed.NewHead:
-		if _, ok := requestedTopics[HeadTopic]; ok {
-			headData, ok := event.Data.(*ethpb.EventHead)
-			if !ok {
-				return write(w, flusher, topicDataMismatch, event.Data, HeadTopic)
-			}
-			head := &structs.HeadEvent{
-				Slot:                      fmt.Sprintf("%d", headData.Slot),
-				Block:                     hexutil.Encode(headData.Block),
-				State:                     hexutil.Encode(headData.State),
-				EpochTransition:           headData.EpochTransition,
-				ExecutionOptimistic:       headData.ExecutionOptimistic,
-				PreviousDutyDependentRoot: hexutil.Encode(headData.PreviousDutyDependentRoot),
-				CurrentDutyDependentRoot:  hexutil.Encode(headData.CurrentDutyDependentRoot),
-			}
-			return send(w, flusher, HeadTopic, head)
+func topicForEvent(event *feed.Event) string {
+	switch event.Data.(type) {
+	case *operation.AggregatedAttReceivedData:
+		return AttestationTopic
+	case *operation.UnAggregatedAttReceivedData:
+		return AttestationTopic
+	case *operation.ExitReceivedData:
+		return VoluntaryExitTopic
+	case *operation.SyncCommitteeContributionReceivedData:
+		return SyncCommitteeContributionTopic
+	case *operation.BLSToExecutionChangeReceivedData:
+		return BLSToExecutionChangeTopic
+	case *operation.BlobSidecarReceivedData:
+		return BlobSidecarTopic
+	case *operation.AttesterSlashingReceivedData:
+		return AttesterSlashingTopic
+	case *operation.ProposerSlashingReceivedData:
+		return ProposerSlashingTopic
+	case *ethpb.EventHead:
+		return HeadTopic
+	case *ethpb.EventFinalizedCheckpoint:
+		return FinalizedCheckpointTopic
+	case *ethpbv2.LightClientFinalityUpdateWithVersion:
+		return LightClientFinalityUpdateTopic
+	case *ethpbv2.LightClientOptimisticUpdateWithVersion:
+		return LightClientOptimisticUpdateTopic
+	case *ethpb.EventChainReorg:
+		return ChainReorgTopic
+	case *statefeed.BlockProcessedData:
+		return BlockTopic
+	default:
+		if event.Type == statefeed.MissedSlot {
+			return PayloadAttributesTopic
 		}
-		if _, ok := requestedTopics[PayloadAttributesTopic]; ok {
-			return s.sendPayloadAttributes(ctx, w, flusher)
-		}
-	case statefeed.MissedSlot:
-		if _, ok := requestedTopics[PayloadAttributesTopic]; ok {
-			return s.sendPayloadAttributes(ctx, w, flusher)
-		}
-	case statefeed.FinalizedCheckpoint:
-		if _, ok := requestedTopics[FinalizedCheckpointTopic]; !ok {
-			return nil
-		}
-		checkpointData, ok := event.Data.(*ethpb.EventFinalizedCheckpoint)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, FinalizedCheckpointTopic)
-		}
-		checkpoint := &structs.FinalizedCheckpointEvent{
-			Block:               hexutil.Encode(checkpointData.Block),
-			State:               hexutil.Encode(checkpointData.State),
-			Epoch:               fmt.Sprintf("%d", checkpointData.Epoch),
-			ExecutionOptimistic: checkpointData.ExecutionOptimistic,
-		}
-		return send(w, flusher, FinalizedCheckpointTopic, checkpoint)
-	case statefeed.LightClientFinalityUpdate:
-		if _, ok := requestedTopics[LightClientFinalityUpdateTopic]; !ok {
-			return nil
-		}
-		updateData, ok := event.Data.(*ethpbv2.LightClientFinalityUpdateWithVersion)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, LightClientFinalityUpdateTopic)
-		}
-		update, err := structs.LightClientFinalityUpdateFromConsensus(updateData.Data)
-		if err != nil {
-			return err
-		}
-		updateEvent := &structs.LightClientFinalityUpdateEvent{
-			Version: version.String(int(updateData.Version)),
-			Data:    update,
-		}
-		return send(w, flusher, LightClientFinalityUpdateTopic, updateEvent)
-	case statefeed.LightClientOptimisticUpdate:
-		if _, ok := requestedTopics[LightClientOptimisticUpdateTopic]; !ok {
-			return nil
-		}
-		updateData, ok := event.Data.(*ethpbv2.LightClientOptimisticUpdateWithVersion)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, LightClientOptimisticUpdateTopic)
-		}
-		update, err := structs.LightClientOptimisticUpdateFromConsensus(updateData.Data)
-		if err != nil {
-			return err
-		}
-		updateEvent := &structs.LightClientOptimisticUpdateEvent{
-			Version: version.String(int(updateData.Version)),
-			Data:    update,
-		}
-		return send(w, flusher, LightClientOptimisticUpdateTopic, updateEvent)
-	case statefeed.Reorg:
-		if _, ok := requestedTopics[ChainReorgTopic]; !ok {
-			return nil
-		}
-		reorgData, ok := event.Data.(*ethpb.EventChainReorg)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, ChainReorgTopic)
-		}
-		reorg := &structs.ChainReorgEvent{
-			Slot:                fmt.Sprintf("%d", reorgData.Slot),
-			Depth:               fmt.Sprintf("%d", reorgData.Depth),
-			OldHeadBlock:        hexutil.Encode(reorgData.OldHeadBlock),
-			NewHeadBlock:        hexutil.Encode(reorgData.NewHeadBlock),
-			OldHeadState:        hexutil.Encode(reorgData.OldHeadState),
-			NewHeadState:        hexutil.Encode(reorgData.NewHeadState),
-			Epoch:               fmt.Sprintf("%d", reorgData.Epoch),
-			ExecutionOptimistic: reorgData.ExecutionOptimistic,
-		}
-		return send(w, flusher, ChainReorgTopic, reorg)
-	case statefeed.BlockProcessed:
-		if _, ok := requestedTopics[BlockTopic]; !ok {
-			return nil
-		}
-		blkData, ok := event.Data.(*statefeed.BlockProcessedData)
-		if !ok {
-			return write(w, flusher, topicDataMismatch, event.Data, BlockTopic)
-		}
-		blockRoot, err := blkData.SignedBlock.Block().HashTreeRoot()
-		if err != nil {
-			return write(w, flusher, "Could not get block root: "+err.Error())
-		}
-		blk := &structs.BlockEvent{
-			Slot:                fmt.Sprintf("%d", blkData.Slot),
-			Block:               hexutil.Encode(blockRoot[:]),
-			ExecutionOptimistic: blkData.Optimistic,
-		}
-		return send(w, flusher, BlockTopic, blk)
+		return InvalidTopic
+	}
+}
+
+func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topics *topicRequest) (lazyReader, error) {
+	eventName := topicForEvent(event)
+	if !topics.requested(eventName) {
+		return nil, errNotRequested
+	}
+	if eventName == PayloadAttributesTopic {
+		return s.currentPayloadAttributes(ctx)
+	}
+	if event == nil || event.Data == nil {
+		return nil, errors.New("event or event data is nil")
+	}
+	switch v := event.Data.(type) {
+	case *ethpb.EventHead:
+		// The head event is a special case because, if the client requested the payload attributes topic,
+		// we send two event messages in reaction; the head event and the payload attributes.
+		headReader := func() io.Reader {
+			return jsonMarshalReader(eventName, structs.HeadEventFromV1(v))
+		}
+		// Don't do the expensive attr lookup unless the client requested it.
+		if !topics.requested(PayloadAttributesTopic) {
+			return headReader, nil
+		}
+		// Since payload attributes could change before the outbox is written, we need to do a blocking operation to
+		// get the current payload attributes right here.
+		attrReader, err := s.currentPayloadAttributes(ctx)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get payload attributes for head event")
+		}
+		return func() io.Reader {
+			return io.MultiReader(headReader(), attrReader())
+		}, nil
+	case *operation.AggregatedAttReceivedData:
+		return func() io.Reader {
+			att := structs.AttFromConsensus(v.Attestation.Aggregate)
+			return jsonMarshalReader(eventName, att)
+		}, nil
+	case *operation.UnAggregatedAttReceivedData:
+		att, ok := v.Attestation.(*eth.Attestation)
+		if !ok {
+			return nil, errors.Wrapf(errUnhandledEventData, "Unexpected type %T for the .Attestation field of UnAggregatedAttReceivedData", v.Attestation)
+		}
+		return func() io.Reader {
+			att := structs.AttFromConsensus(att)
+			return jsonMarshalReader(eventName, att)
+		}, nil
+	case *operation.ExitReceivedData:
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.SignedExitFromConsensus(v.Exit))
+		}, nil
+	case *operation.SyncCommitteeContributionReceivedData:
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.SignedContributionAndProofFromConsensus(v.Contribution))
+		}, nil
+	case *operation.BLSToExecutionChangeReceivedData:
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.SignedBLSChangeFromConsensus(v.Change))
+		}, nil
+	case *operation.BlobSidecarReceivedData:
+		return func() io.Reader {
+			versionedHash := primitives.ConvertKzgCommitmentToVersionedHash(v.Blob.KzgCommitment)
+			return jsonMarshalReader(eventName, &structs.BlobSidecarEvent{
+				BlockRoot:     hexutil.Encode(v.Blob.BlockRootSlice()),
+				Index:         fmt.Sprintf("%d", v.Blob.Index),
+				Slot:          fmt.Sprintf("%d", v.Blob.Slot()),
+				VersionedHash: versionedHash.String(),
+				KzgCommitment: hexutil.Encode(v.Blob.KzgCommitment),
+			})
+		}, nil
+	case *operation.AttesterSlashingReceivedData:
+		slashing, ok := v.AttesterSlashing.(*eth.AttesterSlashing)
+		if !ok {
+			return nil, errors.Wrapf(errUnhandledEventData, "Unexpected type %T for the .AttesterSlashing field of AttesterSlashingReceivedData", v.AttesterSlashing)
+		}
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.AttesterSlashingFromConsensus(slashing))
+		}, nil
+	case *operation.ProposerSlashingReceivedData:
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.ProposerSlashingFromConsensus(v.ProposerSlashing))
+		}, nil
+	case *ethpb.EventFinalizedCheckpoint:
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.FinalizedCheckpointEventFromV1(v))
+		}, nil
+	case *ethpbv2.LightClientFinalityUpdateWithVersion:
+		cv, err := structs.LightClientFinalityUpdateFromConsensus(v.Data)
+		if err != nil {
+			return nil, errors.Wrap(err, "LightClientFinalityUpdateWithVersion event conversion failure")
+		}
+		ev := &structs.LightClientFinalityUpdateEvent{
+			Version: version.String(int(v.Version)),
+			Data:    cv,
+		}
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, ev)
+		}, nil
+	case *ethpbv2.LightClientOptimisticUpdateWithVersion:
+		cv, err := structs.LightClientOptimisticUpdateFromConsensus(v.Data)
+		if err != nil {
+			return nil, errors.Wrap(err, "LightClientOptimisticUpdateWithVersion event conversion failure")
+		}
+		ev := &structs.LightClientOptimisticUpdateEvent{
+			Version: version.String(int(v.Version)),
+			Data:    cv,
+		}
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, ev)
+		}, nil
+	case *ethpb.EventChainReorg:
+		return func() io.Reader {
+			return jsonMarshalReader(eventName, structs.EventChainReorgFromV1(v))
+		}, nil
+	case *statefeed.BlockProcessedData:
+		blockRoot, err := v.SignedBlock.Block().HashTreeRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not compute block root for BlockProcessedData state feed event")
+		}
+		return func() io.Reader {
+			blk := &structs.BlockEvent{
+				Slot:                fmt.Sprintf("%d", v.Slot),
+				Block:               hexutil.Encode(blockRoot[:]),
+				ExecutionOptimistic: v.Optimistic,
+			}
+			return jsonMarshalReader(eventName, blk)
+		}, nil
+	default:
+		return nil, errors.Wrapf(errUnhandledEventData, "event data type %T unsupported", v)
 	}
-	return nil
 }
 
 // This event stream is intended to be used by builders and relays.
 // Parent fields are based on state at N_{current_slot}, while the rest of fields are based on state of N_{current_slot + 1}
-func (s *Server) sendPayloadAttributes(ctx context.Context, w http.ResponseWriter, flusher http.Flusher) error {
+func (s *Server) currentPayloadAttributes(ctx context.Context) (lazyReader, error) {
 	headRoot, err := s.HeadFetcher.HeadRoot(ctx)
 	if err != nil {
-		return write(w, flusher, "Could not get head root: "+err.Error())
+		return nil, errors.Wrap(err, "could not get head root")
 	}
 	st, err := s.HeadFetcher.HeadState(ctx)
 	if err != nil {
-		return write(w, flusher, "Could not get head state: "+err.Error())
+		return nil, errors.Wrap(err, "could not get head state")
 	}
 	// advance the head state
 	headState, err := transition.ProcessSlotsIfPossible(ctx, st, s.ChainInfoFetcher.CurrentSlot()+1)
 	if err != nil {
-		return write(w, flusher, "Could not advance head state: "+err.Error())
+		return nil, errors.Wrap(err, "could not advance head state")
 	}
 
 	headBlock, err := s.HeadFetcher.HeadBlock(ctx)
 	if err != nil {
-		return write(w, flusher, "Could not get head block: "+err.Error())
+		return nil, errors.Wrap(err, "could not get head block")
 	}
 
 	headPayload, err := headBlock.Block().Body().Execution()
 	if err != nil {
-		return write(w, flusher, "Could not get execution payload: "+err.Error())
+		return nil, errors.Wrap(err, "could not get execution payload")
 	}
 
 	t, err := slots.ToTime(headState.GenesisTime(), headState.Slot())
 	if err != nil {
-		return write(w, flusher, "Could not get head state slot time: "+err.Error())
+		return nil, errors.Wrap(err, "could not get head state slot time")
 	}
 
-	prevRando, err := helpers.RandaoMix(headState, time.CurrentEpoch(headState))
+	prevRando, err := helpers.RandaoMix(headState, chaintime.CurrentEpoch(headState))
 	if err != nil {
-		return write(w, flusher, "Could not get head state randao mix: "+err.Error())
+		return nil, errors.Wrap(err, "could not get head state randao mix")
 	}
 
 	proposerIndex, err := helpers.BeaconProposerIndex(ctx, headState)
 	if err != nil {
-		return write(w, flusher, "Could not get head state proposer index: "+err.Error())
+		return nil, errors.Wrap(err, "could not get head state proposer index")
 	}
 	feeRecipient := params.BeaconConfig().DefaultFeeRecipient.Bytes()
 	tValidator, exists := s.TrackedValidatorsCache.Validator(proposerIndex)
@@ -425,7 +575,7 @@ func (s *Server) sendPayloadAttributes(ctx context.Context, w http.ResponseWrite
 	case version.Capella:
 		withdrawals, _, err := headState.ExpectedWithdrawals()
 		if err != nil {
-			return write(w, flusher, "Could not get head state expected withdrawals: "+err.Error())
+			return nil, errors.Wrap(err, "could not get head state expected withdrawals")
 		}
 		attributes = &structs.PayloadAttributesV2{
 			Timestamp:             fmt.Sprintf("%d", t.Unix()),
@@ -436,11 +586,11 @@ func (s *Server) sendPayloadAttributes(ctx context.Context, w http.ResponseWrite
 	case version.Deneb, version.Electra:
 		withdrawals, _, err := headState.ExpectedWithdrawals()
 		if err != nil {
-			return write(w, flusher, "Could not get head state expected withdrawals: "+err.Error())
+			return nil, errors.Wrap(err, "could not get head state expected withdrawals")
 		}
 		parentRoot, err := headBlock.Block().HashTreeRoot()
 		if err != nil {
-			return write(w, flusher, "Could not get head block root: "+err.Error())
+			return nil, errors.Wrap(err, "could not get head block root")
 		}
 		attributes = &structs.PayloadAttributesV3{
 			Timestamp:             fmt.Sprintf("%d", t.Unix()),
@@ -450,12 +600,12 @@ func (s *Server) sendPayloadAttributes(ctx context.Context, w http.ResponseWrite
 			ParentBeaconBlockRoot: hexutil.Encode(parentRoot[:]),
 		}
 	default:
-		return write(w, flusher, "Payload version %s is not supported", version.String(headState.Version()))
+		return nil, errors.Wrapf(err, "Payload version %s is not supported", version.String(headState.Version()))
 	}
 
 	attributesBytes, err := json.Marshal(attributes)
 	if err != nil {
-		return write(w, flusher, err.Error())
+		return nil, errors.Wrap(err, "errors marshaling payload attributes to json")
 	}
 	eventData := structs.PayloadAttributesEventData{
 		ProposerIndex:     fmt.Sprintf("%d", proposerIndex),
@@ -467,31 +617,12 @@ func (s *Server) sendPayloadAttributes(ctx context.Context, w http.ResponseWrite
 	}
 	eventDataBytes, err := json.Marshal(eventData)
 	if err != nil {
-		return write(w, flusher, err.Error())
+		return nil, errors.Wrap(err, "errors marshaling payload attributes event data to json")
 	}
-	return send(w, flusher, PayloadAttributesTopic, &structs.PayloadAttributesEvent{
-		Version: version.String(headState.Version()),
-		Data:    eventDataBytes,
-	})
-}
-
-func send(w http.ResponseWriter, flusher http.Flusher, name string, data interface{}) error {
-	j, err := json.Marshal(data)
-	if err != nil {
-		return write(w, flusher, "Could not marshal event to JSON: "+err.Error())
-	}
-	return write(w, flusher, "event: %s\ndata: %s\n\n", name, string(j))
-}
-
-func sendKeepalive(w http.ResponseWriter, flusher http.Flusher) error {
-	return write(w, flusher, ":\n\n")
-}
-
-func write(w http.ResponseWriter, flusher http.Flusher, format string, a ...any) error {
-	_, err := fmt.Fprintf(w, format, a...)
-	if err != nil {
-		return errors.Wrap(err, "could not write to response writer")
-	}
-	flusher.Flush()
-	return nil
+	return func() io.Reader {
+		return jsonMarshalReader(PayloadAttributesTopic, &structs.PayloadAttributesEvent{
+			Version: version.String(headState.Version()),
+			Data:    eventDataBytes,
+		})
+	}, nil
 }

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

@@ -1,6 +1,7 @@
 package events
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"math"
@@ -23,56 +24,99 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	sse "github.com/r3labs/sse/v2"
 )
 
-type flushableResponseRecorder struct {
-	*httptest.ResponseRecorder
-	flushed bool
+func requireAllEventsReceived(t *testing.T, stn, opn *mockChain.EventFeedWrapper, events []*feed.Event, req *topicRequest, s *Server, w *StreamingResponseWriterRecorder) {
+	// maxBufferSize param copied from sse lib client code
+	sseR := sse.NewEventStreamReader(w.Body(), 1<<24)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+
+	expected := make(map[string]bool)
+	for i := range events {
+		ev := events[i]
+		// serialize the event the same way the server will so that we can compare expectation to results.
+		top := topicForEvent(ev)
+		eb, err := s.lazyReaderForEvent(context.Background(), ev, req)
+		require.NoError(t, err)
+		exb, err := io.ReadAll(eb())
+		require.NoError(t, err)
+		exs := string(exb[0 : len(exb)-2]) // remove trailing double newline
+
+		if topicsForOpsFeed[top] {
+			if err := opn.WaitForSubscription(ctx); err != nil {
+				t.Fatal(err)
+			}
+			// Send the event on the feed.
+			s.OperationNotifier.OperationFeed().Send(ev)
+		} else {
+			if err := stn.WaitForSubscription(ctx); err != nil {
+				t.Fatal(err)
+			}
+			// Send the event on the feed.
+			s.StateNotifier.StateFeed().Send(ev)
+		}
+		expected[exs] = true
+	}
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		for {
+			ev, err := sseR.ReadEvent()
+			if err == io.EOF {
+				return
+			}
+			require.NoError(t, err)
+			str := string(ev)
+			delete(expected, str)
+			if len(expected) == 0 {
+				return
+			}
+		}
+	}()
+	select {
+	case <-done:
+		break
+	case <-ctx.Done():
+		t.Fatalf("context canceled / timed out waiting for events, err=%v", ctx.Err())
+	}
+	require.Equal(t, 0, len(expected), "expected events not seen")
 }
 
-func (f *flushableResponseRecorder) Flush() {
-	f.flushed = true
+func (tr *topicRequest) testHttpRequest(_ *testing.T) *http.Request {
+	tq := make([]string, 0, len(tr.topics))
+	for topic := range tr.topics {
+		tq = append(tq, "topics="+topic)
+	}
+	return httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com/eth/v1/events?%s", strings.Join(tq, "&")), nil)
 }
 
-func TestStreamEvents_OperationsEvents(t *testing.T) {
-	t.Run("operations", func(t *testing.T) {
-		s := &Server{
-			StateNotifier:     &mockChain.MockStateNotifier{},
-			OperationNotifier: &mockChain.MockOperationNotifier{},
-		}
+func operationEventsFixtures(t *testing.T) (*topicRequest, []*feed.Event) {
+	topics, err := newTopicRequest([]string{
+		AttestationTopic,
+		VoluntaryExitTopic,
+		SyncCommitteeContributionTopic,
+		BLSToExecutionChangeTopic,
+		BlobSidecarTopic,
+		AttesterSlashingTopic,
+		ProposerSlashingTopic,
+	})
+	require.NoError(t, err)
+	ro, err := blocks.NewROBlob(util.HydrateBlobSidecar(&eth.BlobSidecar{}))
+	require.NoError(t, err)
+	vblob := blocks.NewVerifiedROBlob(ro)
 
-		topics := []string{
-			AttestationTopic,
-			VoluntaryExitTopic,
-			SyncCommitteeContributionTopic,
-			BLSToExecutionChangeTopic,
-			BlobSidecarTopic,
-			AttesterSlashingTopic,
-			ProposerSlashingTopic,
-		}
-		for i, topic := range topics {
-			topics[i] = "topics=" + topic
-		}
-		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com/eth/v1/events?%s", strings.Join(topics, "&")), nil)
-		w := &flushableResponseRecorder{
-			ResponseRecorder: httptest.NewRecorder(),
-		}
-
-		go func() {
-			s.StreamEvents(w, request)
-		}()
-		// wait for initiation of StreamEvents
-		time.Sleep(100 * time.Millisecond)
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+	return topics, []*feed.Event{
+		&feed.Event{
 			Type: operation.UnaggregatedAttReceived,
 			Data: &operation.UnAggregatedAttReceivedData{
 				Attestation: util.HydrateAttestation(&eth.Attestation{}),
 			},
-		})
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.AggregatedAttReceived,
 			Data: &operation.AggregatedAttReceivedData{
 				Attestation: &eth.AggregateAttestationAndProof{
@@ -81,8 +125,8 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					SelectionProof:  make([]byte, 96),
 				},
 			},
-		})
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.ExitReceived,
 			Data: &operation.ExitReceivedData{
 				Exit: &eth.SignedVoluntaryExit{
@@ -93,8 +137,8 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					Signature: make([]byte, 96),
 				},
 			},
-		})
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.SyncCommitteeContributionReceived,
 			Data: &operation.SyncCommitteeContributionReceivedData{
 				Contribution: &eth.SignedContributionAndProof{
@@ -112,8 +156,8 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					Signature: make([]byte, 96),
 				},
 			},
-		})
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.BLSToExecutionChangeReceived,
 			Data: &operation.BLSToExecutionChangeReceivedData{
 				Change: &eth.SignedBLSToExecutionChange{
@@ -125,18 +169,14 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					Signature: make([]byte, 96),
 				},
 			},
-		})
-		ro, err := blocks.NewROBlob(util.HydrateBlobSidecar(&eth.BlobSidecar{}))
-		require.NoError(t, err)
-		vblob := blocks.NewVerifiedROBlob(ro)
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.BlobSidecarReceived,
 			Data: &operation.BlobSidecarReceivedData{
 				Blob: &vblob,
 			},
-		})
-
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.AttesterSlashingReceived,
 			Data: &operation.AttesterSlashingReceivedData{
 				AttesterSlashing: &eth.AttesterSlashing{
@@ -168,9 +208,8 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					},
 				},
 			},
-		})
-
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
+		},
+		&feed.Event{
 			Type: operation.ProposerSlashingReceived,
 			Data: &operation.ProposerSlashingReceivedData{
 				ProposerSlashing: &eth.ProposerSlashing{
@@ -192,100 +231,107 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					},
 				},
 			},
-		})
+		},
+	}
+}
 
-		time.Sleep(1 * time.Second)
-		request.Context().Done()
+func TestStreamEvents_OperationsEvents(t *testing.T) {
+	t.Run("operations", func(t *testing.T) {
+		stn := mockChain.NewEventFeedWrapper()
+		opn := mockChain.NewEventFeedWrapper()
+		s := &Server{
+			StateNotifier:     &mockChain.SimpleNotifier{Feed: stn},
+			OperationNotifier: &mockChain.SimpleNotifier{Feed: opn},
+		}
 
-		resp := w.Result()
-		body, err := io.ReadAll(resp.Body)
-		require.NoError(t, err)
-		require.NotNil(t, body)
-		assert.Equal(t, operationsResult, string(body))
+		topics, events := operationEventsFixtures(t)
+		request := topics.testHttpRequest(t)
+		w := NewStreamingResponseWriterRecorder()
+
+		go func() {
+			s.StreamEvents(w, request)
+		}()
+
+		requireAllEventsReceived(t, stn, opn, events, topics, s, w)
 	})
 	t.Run("state", func(t *testing.T) {
+		stn := mockChain.NewEventFeedWrapper()
+		opn := mockChain.NewEventFeedWrapper()
 		s := &Server{
-			StateNotifier:     &mockChain.MockStateNotifier{},
-			OperationNotifier: &mockChain.MockOperationNotifier{},
+			StateNotifier:     &mockChain.SimpleNotifier{Feed: stn},
+			OperationNotifier: &mockChain.SimpleNotifier{Feed: opn},
 		}
 
-		topics := []string{HeadTopic, FinalizedCheckpointTopic, ChainReorgTopic, BlockTopic}
-		for i, topic := range topics {
-			topics[i] = "topics=" + topic
-		}
-		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com/eth/v1/events?%s", strings.Join(topics, "&")), nil)
-		w := &flushableResponseRecorder{
-			ResponseRecorder: httptest.NewRecorder(),
+		topics, err := newTopicRequest([]string{
+			HeadTopic,
+			FinalizedCheckpointTopic,
+			ChainReorgTopic,
+			BlockTopic,
+		})
+		require.NoError(t, err)
+		request := topics.testHttpRequest(t)
+		w := NewStreamingResponseWriterRecorder()
+
+		b, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlock(&eth.SignedBeaconBlock{}))
+		require.NoError(t, err)
+		events := []*feed.Event{
+			&feed.Event{
+				Type: statefeed.BlockProcessed,
+				Data: &statefeed.BlockProcessedData{
+					Slot:        0,
+					BlockRoot:   [32]byte{},
+					SignedBlock: b,
+					Verified:    true,
+					Optimistic:  false,
+				},
+			},
+			&feed.Event{
+				Type: statefeed.NewHead,
+				Data: &ethpb.EventHead{
+					Slot:                      0,
+					Block:                     make([]byte, 32),
+					State:                     make([]byte, 32),
+					EpochTransition:           true,
+					PreviousDutyDependentRoot: make([]byte, 32),
+					CurrentDutyDependentRoot:  make([]byte, 32),
+					ExecutionOptimistic:       false,
+				},
+			},
+			&feed.Event{
+				Type: statefeed.Reorg,
+				Data: &ethpb.EventChainReorg{
+					Slot:                0,
+					Depth:               0,
+					OldHeadBlock:        make([]byte, 32),
+					NewHeadBlock:        make([]byte, 32),
+					OldHeadState:        make([]byte, 32),
+					NewHeadState:        make([]byte, 32),
+					Epoch:               0,
+					ExecutionOptimistic: false,
+				},
+			},
+			&feed.Event{
+				Type: statefeed.FinalizedCheckpoint,
+				Data: &ethpb.EventFinalizedCheckpoint{
+					Block:               make([]byte, 32),
+					State:               make([]byte, 32),
+					Epoch:               0,
+					ExecutionOptimistic: false,
+				},
+			},
 		}
 
 		go func() {
 			s.StreamEvents(w, request)
 		}()
-		// wait for initiation of StreamEvents
-		time.Sleep(100 * time.Millisecond)
-		s.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.NewHead,
-			Data: &ethpb.EventHead{
-				Slot:                      0,
-				Block:                     make([]byte, 32),
-				State:                     make([]byte, 32),
-				EpochTransition:           true,
-				PreviousDutyDependentRoot: make([]byte, 32),
-				CurrentDutyDependentRoot:  make([]byte, 32),
-				ExecutionOptimistic:       false,
-			},
-		})
-		s.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.FinalizedCheckpoint,
-			Data: &ethpb.EventFinalizedCheckpoint{
-				Block:               make([]byte, 32),
-				State:               make([]byte, 32),
-				Epoch:               0,
-				ExecutionOptimistic: false,
-			},
-		})
-		s.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.Reorg,
-			Data: &ethpb.EventChainReorg{
-				Slot:                0,
-				Depth:               0,
-				OldHeadBlock:        make([]byte, 32),
-				NewHeadBlock:        make([]byte, 32),
-				OldHeadState:        make([]byte, 32),
-				NewHeadState:        make([]byte, 32),
-				Epoch:               0,
-				ExecutionOptimistic: false,
-			},
-		})
-		b, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlock(&eth.SignedBeaconBlock{}))
-		require.NoError(t, err)
-		s.StateNotifier.StateFeed().Send(&feed.Event{
-			Type: statefeed.BlockProcessed,
-			Data: &statefeed.BlockProcessedData{
-				Slot:        0,
-				BlockRoot:   [32]byte{},
-				SignedBlock: b,
-				Verified:    true,
-				Optimistic:  false,
-			},
-		})
 
-		// wait for feed
-		time.Sleep(1 * time.Second)
-		request.Context().Done()
-
-		resp := w.Result()
-		body, err := io.ReadAll(resp.Body)
-		require.NoError(t, err)
-		require.NotNil(t, body)
-		assert.Equal(t, stateResult, string(body))
+		requireAllEventsReceived(t, stn, opn, events, topics, s, w)
 	})
 	t.Run("payload attributes", func(t *testing.T) {
 		type testCase struct {
 			name                      string
 			getState                  func() state.BeaconState
 			getBlock                  func() interfaces.SignedBeaconBlock
-			expected                  string
 			SetTrackedValidatorsCache func(*cache.TrackedValidatorsCache)
 		}
 		testCases := []testCase{
@@ -301,7 +347,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					require.NoError(t, err)
 					return b
 				},
-				expected: payloadAttributesBellatrixResult,
 			},
 			{
 				name: "capella",
@@ -315,7 +360,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					require.NoError(t, err)
 					return b
 				},
-				expected: payloadAttributesCapellaResult,
 			},
 			{
 				name: "deneb",
@@ -329,7 +373,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					require.NoError(t, err)
 					return b
 				},
-				expected: payloadAttributesDenebResult,
 			},
 			{
 				name: "electra",
@@ -343,7 +386,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					require.NoError(t, err)
 					return b
 				},
-				expected: payloadAttributesElectraResultWithTVC,
 				SetTrackedValidatorsCache: func(c *cache.TrackedValidatorsCache) {
 					c.Set(cache.TrackedValidator{
 						Active:       true,
@@ -368,9 +410,11 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 				Slot:  &currentSlot,
 			}
 
+			stn := mockChain.NewEventFeedWrapper()
+			opn := mockChain.NewEventFeedWrapper()
 			s := &Server{
-				StateNotifier:          &mockChain.MockStateNotifier{},
-				OperationNotifier:      &mockChain.MockOperationNotifier{},
+				StateNotifier:          &mockChain.SimpleNotifier{Feed: stn},
+				OperationNotifier:      &mockChain.SimpleNotifier{Feed: opn},
 				HeadFetcher:            mockChainService,
 				ChainInfoFetcher:       mockChainService,
 				TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
@@ -378,100 +422,76 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 			if tc.SetTrackedValidatorsCache != nil {
 				tc.SetTrackedValidatorsCache(s.TrackedValidatorsCache)
 			}
-
-			request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://example.com/eth/v1/events?topics=%s", PayloadAttributesTopic), nil)
-			w := &flushableResponseRecorder{
-				ResponseRecorder: httptest.NewRecorder(),
-			}
+			topics, err := newTopicRequest([]string{PayloadAttributesTopic})
+			require.NoError(t, err)
+			request := topics.testHttpRequest(t)
+			w := NewStreamingResponseWriterRecorder()
+			events := []*feed.Event{&feed.Event{Type: statefeed.MissedSlot}}
 
 			go func() {
 				s.StreamEvents(w, request)
 			}()
-			// wait for initiation of StreamEvents
-			time.Sleep(100 * time.Millisecond)
-			s.StateNotifier.StateFeed().Send(&feed.Event{Type: statefeed.MissedSlot})
-
-			// wait for feed
-			time.Sleep(1 * time.Second)
-			request.Context().Done()
-
-			resp := w.Result()
-			body, err := io.ReadAll(resp.Body)
-			require.NoError(t, err)
-			require.NotNil(t, body)
-			assert.Equal(t, tc.expected, string(body), "wrong result for "+tc.name)
+			requireAllEventsReceived(t, stn, opn, events, topics, s, w)
 		}
 	})
 }
 
-const operationsResult = `:
+func TestStuckReader(t *testing.T) {
+	topics, events := operationEventsFixtures(t)
+	require.Equal(t, 8, len(events))
+	// set eventFeedDepth to a number lower than the events we intend to send to force the server to drop the reader.
+	stn := mockChain.NewEventFeedWrapper()
+	opn := mockChain.NewEventFeedWrapper()
+	s := &Server{
+		StateNotifier:     &mockChain.SimpleNotifier{Feed: stn},
+		OperationNotifier: &mockChain.SimpleNotifier{Feed: opn},
+		EventFeedDepth:    len(events) - 1,
+	}
 
-event: attestation
-data: {"aggregation_bits":"0x00","data":{"slot":"0","index":"0","beacon_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","source":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"target":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"}},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	defer cancel()
+	eventsWritten := make(chan struct{})
+	go func() {
+		for i := range events {
+			ev := events[i]
+			top := topicForEvent(ev)
+			if topicsForOpsFeed[top] {
+				err := opn.WaitForSubscription(ctx)
+				require.NoError(t, err)
+				s.OperationNotifier.OperationFeed().Send(ev)
+			} else {
+				err := stn.WaitForSubscription(ctx)
+				require.NoError(t, err)
+				s.StateNotifier.StateFeed().Send(ev)
+			}
+		}
+		close(eventsWritten)
+	}()
 
-event: attestation
-data: {"aggregation_bits":"0x00","data":{"slot":"0","index":"0","beacon_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","source":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"target":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"}},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
+	request := topics.testHttpRequest(t)
+	w := NewStreamingResponseWriterRecorder()
 
-event: voluntary_exit
-data: {"message":{"epoch":"0","validator_index":"0"},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
+	handlerFinished := make(chan struct{})
+	go func() {
+		s.StreamEvents(w, request)
+		close(handlerFinished)
+	}()
 
-event: contribution_and_proof
-data: {"message":{"aggregator_index":"0","contribution":{"slot":"0","beacon_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","subcommittee_index":"0","aggregation_bits":"0x00000000000000000000000000000000","signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"},"selection_proof":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
+	// Make sure that the stream writer shut down when the reader failed to clear the write buffer.
+	select {
+	case <-handlerFinished:
+		// We expect the stream handler to max out the queue buffer and exit gracefully.
+		return
+	case <-ctx.Done():
+		t.Fatalf("context canceled / timed out waiting for handler completion, err=%v", ctx.Err())
+	}
 
-event: bls_to_execution_change
-data: {"message":{"validator_index":"0","from_bls_pubkey":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","to_execution_address":"0x0000000000000000000000000000000000000000"},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}
-
-event: blob_sidecar
-data: {"block_root":"0xc78009fdf07fc56a11f122370658a353aaa542ed63e44c4bc15ff4cd105ab33c","index":"0","slot":"0","kzg_commitment":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","versioned_hash":"0x01b0761f87b081d5cf10757ccc89f12be355c70e2e29df288b65b30710dcbcd1"}
-
-event: attester_slashing
-data: {"attestation_1":{"attesting_indices":["0","1"],"data":{"slot":"0","index":"0","beacon_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","source":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"target":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"}},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"},"attestation_2":{"attesting_indices":["0","1"],"data":{"slot":"0","index":"0","beacon_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","source":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"target":{"epoch":"0","root":"0x0000000000000000000000000000000000000000000000000000000000000000"}},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}}
-
-event: proposer_slashing
-data: {"signed_header_1":{"message":{"slot":"0","proposer_index":"0","parent_root":"0x0000000000000000000000000000000000000000000000000000000000000000","state_root":"0x0000000000000000000000000000000000000000000000000000000000000000","body_root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"},"signed_header_2":{"message":{"slot":"0","proposer_index":"0","parent_root":"0x0000000000000000000000000000000000000000000000000000000000000000","state_root":"0x0000000000000000000000000000000000000000000000000000000000000000","body_root":"0x0000000000000000000000000000000000000000000000000000000000000000"},"signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}}
-
-`
-
-const stateResult = `:
-
-event: head
-data: {"slot":"0","block":"0x0000000000000000000000000000000000000000000000000000000000000000","state":"0x0000000000000000000000000000000000000000000000000000000000000000","epoch_transition":true,"execution_optimistic":false,"previous_duty_dependent_root":"0x0000000000000000000000000000000000000000000000000000000000000000","current_duty_dependent_root":"0x0000000000000000000000000000000000000000000000000000000000000000"}
-
-event: finalized_checkpoint
-data: {"block":"0x0000000000000000000000000000000000000000000000000000000000000000","state":"0x0000000000000000000000000000000000000000000000000000000000000000","epoch":"0","execution_optimistic":false}
-
-event: chain_reorg
-data: {"slot":"0","depth":"0","old_head_block":"0x0000000000000000000000000000000000000000000000000000000000000000","old_head_state":"0x0000000000000000000000000000000000000000000000000000000000000000","new_head_block":"0x0000000000000000000000000000000000000000000000000000000000000000","new_head_state":"0x0000000000000000000000000000000000000000000000000000000000000000","epoch":"0","execution_optimistic":false}
-
-event: block
-data: {"slot":"0","block":"0xeade62f0457b2fdf48e7d3fc4b60736688286be7c7a3ac4c9a16a5e0600bd9e4","execution_optimistic":false}
-
-`
-
-const payloadAttributesBellatrixResult = `:
-
-event: payload_attributes
-data: {"version":"bellatrix","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0x0000000000000000000000000000000000000000"}}}
-
-`
-
-const payloadAttributesCapellaResult = `:
-
-event: payload_attributes
-data: {"version":"capella","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0x0000000000000000000000000000000000000000","withdrawals":[]}}}
-
-`
-
-const payloadAttributesDenebResult = `:
-
-event: payload_attributes
-data: {"version":"deneb","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0x0000000000000000000000000000000000000000","withdrawals":[],"parent_beacon_block_root":"0xbef96cb938fd48b2403d3e662664325abb0102ed12737cbb80d717520e50cf4a"}}}
-
-`
-
-const payloadAttributesElectraResultWithTVC = `:
-
-event: payload_attributes
-data: {"version":"electra","data":{"proposer_index":"0","proposal_slot":"1","parent_block_number":"0","parent_block_root":"0x0000000000000000000000000000000000000000000000000000000000000000","parent_block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000","payload_attributes":{"timestamp":"12","prev_randao":"0x0000000000000000000000000000000000000000000000000000000000000000","suggested_fee_recipient":"0xd2dbd02e4efe087d7d195de828b9dd25f19a89c9","withdrawals":[],"parent_beacon_block_root":"0x66d641f7eae038f2dd28081b09d2ba279462cc47655c7b7e1fd1159a50c8eb32"}}}
-
-`
+	// Also make sure all the events were written.
+	select {
+	case <-eventsWritten:
+		// We expect the stream handler to max out the queue buffer and exit gracefully.
+		return
+	case <-ctx.Done():
+		t.Fatalf("context canceled / timed out waiting to write all events, err=%v", ctx.Err())
+	}
+}

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

@@ -0,0 +1,75 @@
+package events
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+type StreamingResponseWriterRecorder struct {
+	http.ResponseWriter
+	r             io.Reader
+	w             io.Writer
+	statusWritten *int
+	status        chan int
+	bodyRecording []byte
+	flushed       bool
+}
+
+func (w *StreamingResponseWriterRecorder) StatusChan() chan int {
+	return w.status
+}
+
+func NewStreamingResponseWriterRecorder() *StreamingResponseWriterRecorder {
+	r, w := io.Pipe()
+	return &StreamingResponseWriterRecorder{
+		ResponseWriter: httptest.NewRecorder(),
+		r:              r,
+		w:              w,
+		status:         make(chan int, 1),
+	}
+}
+
+// Write implements http.ResponseWriter.
+func (w *StreamingResponseWriterRecorder) Write(data []byte) (int, error) {
+	w.WriteHeader(http.StatusOK)
+	n, err := w.w.Write(data)
+	if err != nil {
+		return n, err
+	}
+	return w.ResponseWriter.Write(data)
+}
+
+// WriteHeader implements http.ResponseWriter.
+func (w *StreamingResponseWriterRecorder) WriteHeader(statusCode int) {
+	if w.statusWritten != nil {
+		return
+	}
+	w.statusWritten = &statusCode
+	w.status <- statusCode
+	w.ResponseWriter.WriteHeader(statusCode)
+}
+
+func (w *StreamingResponseWriterRecorder) Body() io.Reader {
+	return w.r
+}
+
+func (w *StreamingResponseWriterRecorder) RequireStatus(t *testing.T, status int) {
+	if w.statusWritten == nil {
+		t.Fatal("WriteHeader was not called")
+	}
+	require.Equal(t, status, *w.statusWritten)
+}
+
+func (w *StreamingResponseWriterRecorder) Flush() {
+	fw, ok := w.ResponseWriter.(http.Flusher)
+	if ok {
+		fw.Flush()
+	}
+	w.flushed = true
+}
+
+var _ http.ResponseWriter = &StreamingResponseWriterRecorder{}

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

@@ -4,6 +4,8 @@
 package events
 
 import (
+	"time"
+
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	opfeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
@@ -18,4 +20,6 @@ type Server struct {
 	HeadFetcher            blockchain.HeadFetcher
 	ChainInfoFetcher       blockchain.ChainInfoFetcher
 	TrackedValidatorsCache *cache.TrackedValidatorsCache
+	KeepAliveInterval      time.Duration
+	EventFeedDepth         int
 }

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

@@ -20,14 +20,12 @@ go_library(
         "//beacon-chain/state: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",
-        "//encoding/ssz:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil: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_ethereum_go_ethereum//common/hexutil:go_default_library",
@@ -55,7 +53,6 @@ go_test(
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//encoding/bytesutil:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

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

@@ -47,7 +47,7 @@ func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
-	bootstrap, err := createLightClientBootstrap(ctx, state, blk.Block())
+	bootstrap, err := createLightClientBootstrap(ctx, state, blk)
 	if err != nil {
 		httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
 		return
@@ -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/handlers_test.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"strconv"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -19,49 +20,29 @@ import (
 	"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/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
 func TestLightClientHandler_GetLightClientBootstrap_Altair(t *testing.T) {
-	helpers.ClearCache()
-	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
+	l := util.NewTestLightClient(t).SetupTestAltair()
 
-	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()
+	slot := l.State.Slot()
+	stateRoot, err := l.State.HashTreeRoot(l.Ctx)
 	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}
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
 	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
 	s := &Server{
 		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-			slot: bs,
+			slot: l.State,
 		}},
 		Blocker:     mockBlocker,
 		HeadFetcher: mockChainService,
 	}
 	request := httptest.NewRequest("GET", "http://foo.com/", nil)
-	request.SetPathValue("block_root", hexutil.Encode(r[:]))
+	request.SetPathValue("block_root", hexutil.Encode(stateRoot[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -74,47 +55,74 @@ func TestLightClientHandler_GetLightClientBootstrap_Altair(t *testing.T) {
 	err = json.Unmarshal(resp.Data.Header, &respHeader)
 	require.NoError(t, err)
 	require.Equal(t, "altair", resp.Version)
-	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), respHeader.Beacon.BodyRoot)
-	require.NotNil(t, resp.Data)
+
+	blockHeader, err := l.Block.Header()
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(blockHeader.Header.BodyRoot), respHeader.Beacon.BodyRoot)
+	require.Equal(t, strconv.FormatUint(uint64(blockHeader.Header.Slot), 10), respHeader.Beacon.Slot)
+
+	require.NotNil(t, resp.Data.CurrentSyncCommittee)
+	require.NotNil(t, resp.Data.CurrentSyncCommitteeBranch)
+}
+
+func TestLightClientHandler_GetLightClientBootstrap_Bellatrix(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestBellatrix()
+
+	slot := l.State.Slot()
+	stateRoot, err := l.State.HashTreeRoot(l.Ctx)
+	require.NoError(t, err)
+
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+	s := &Server{
+		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+			slot: l.State,
+		}},
+		Blocker:     mockBlocker,
+		HeadFetcher: mockChainService,
+	}
+	request := httptest.NewRequest("GET", "http://foo.com/", nil)
+	request.SetPathValue("block_root", hexutil.Encode(stateRoot[:]))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetLightClientBootstrap(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+	var resp structs.LightClientBootstrapResponse
+	err = json.Unmarshal(writer.Body.Bytes(), &resp)
+	require.NoError(t, err)
+	var respHeader structs.LightClientHeader
+	err = json.Unmarshal(resp.Data.Header, &respHeader)
+	require.NoError(t, err)
+	require.Equal(t, "bellatrix", resp.Version)
+
+	blockHeader, err := l.Block.Header()
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(blockHeader.Header.BodyRoot), respHeader.Beacon.BodyRoot)
+	require.Equal(t, strconv.FormatUint(uint64(blockHeader.Header.Slot), 10), respHeader.Beacon.Slot)
+
+	require.NotNil(t, resp.Data.CurrentSyncCommittee)
+	require.NotNil(t, resp.Data.CurrentSyncCommitteeBranch)
 }
 
 func TestLightClientHandler_GetLightClientBootstrap_Capella(t *testing.T) {
-	helpers.ClearCache()
-	slot := primitives.Slot(params.BeaconConfig().CapellaForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
+	l := util.NewTestLightClient(t).SetupTestCapella(false) // result is same for true and false
 
-	b := util.NewBeaconBlockCapella()
-	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()
+	slot := l.State.Slot()
+	stateRoot, err := l.State.HashTreeRoot(l.Ctx)
 	require.NoError(t, err)
 
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	bs, err := util.NewBeaconStateCapella(func(state *ethpb.BeaconStateCapella) 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}
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
 	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
 	s := &Server{
 		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-			slot: bs,
+			slot: l.State,
 		}},
 		Blocker:     mockBlocker,
 		HeadFetcher: mockChainService,
 	}
 	request := httptest.NewRequest("GET", "http://foo.com/", nil)
-	request.SetPathValue("block_root", hexutil.Encode(r[:]))
+	request.SetPathValue("block_root", hexutil.Encode(stateRoot[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -123,51 +131,38 @@ func TestLightClientHandler_GetLightClientBootstrap_Capella(t *testing.T) {
 	var resp structs.LightClientBootstrapResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
-	var respHeader structs.LightClientHeaderCapella
+	var respHeader structs.LightClientHeader
 	err = json.Unmarshal(resp.Data.Header, &respHeader)
 	require.NoError(t, err)
 	require.Equal(t, "capella", resp.Version)
-	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), respHeader.Beacon.BodyRoot)
-	require.NotNil(t, resp.Data)
+
+	blockHeader, err := l.Block.Header()
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(blockHeader.Header.BodyRoot), respHeader.Beacon.BodyRoot)
+	require.Equal(t, strconv.FormatUint(uint64(blockHeader.Header.Slot), 10), respHeader.Beacon.Slot)
+
+	require.NotNil(t, resp.Data.CurrentSyncCommittee)
+	require.NotNil(t, resp.Data.CurrentSyncCommitteeBranch)
 }
 
 func TestLightClientHandler_GetLightClientBootstrap_Deneb(t *testing.T) {
-	helpers.ClearCache()
-	slot := primitives.Slot(params.BeaconConfig().DenebForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
+	l := util.NewTestLightClient(t).SetupTestDeneb(false) // result is same for true and false
 
-	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()
+	slot := l.State.Slot()
+	stateRoot, err := l.State.HashTreeRoot(l.Ctx)
 	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}
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
 	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
 	s := &Server{
 		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-			slot: bs,
+			slot: l.State,
 		}},
 		Blocker:     mockBlocker,
 		HeadFetcher: mockChainService,
 	}
 	request := httptest.NewRequest("GET", "http://foo.com/", nil)
-	request.SetPathValue("block_root", hexutil.Encode(r[:]))
+	request.SetPathValue("block_root", hexutil.Encode(stateRoot[:]))
 	writer := httptest.NewRecorder()
 	writer.Body = &bytes.Buffer{}
 
@@ -176,12 +171,58 @@ func TestLightClientHandler_GetLightClientBootstrap_Deneb(t *testing.T) {
 	var resp structs.LightClientBootstrapResponse
 	err = json.Unmarshal(writer.Body.Bytes(), &resp)
 	require.NoError(t, err)
-	var respHeader structs.LightClientHeaderDeneb
+	var respHeader structs.LightClientHeader
 	err = json.Unmarshal(resp.Data.Header, &respHeader)
 	require.NoError(t, err)
 	require.Equal(t, "deneb", resp.Version)
-	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), respHeader.Beacon.BodyRoot)
-	require.NotNil(t, resp.Data)
+
+	blockHeader, err := l.Block.Header()
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(blockHeader.Header.BodyRoot), respHeader.Beacon.BodyRoot)
+	require.Equal(t, strconv.FormatUint(uint64(blockHeader.Header.Slot), 10), respHeader.Beacon.Slot)
+
+	require.NotNil(t, resp.Data.CurrentSyncCommittee)
+	require.NotNil(t, resp.Data.CurrentSyncCommitteeBranch)
+}
+
+func TestLightClientHandler_GetLightClientBootstrap_Electra(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTestElectra(false) // result is same for true and false
+
+	slot := l.State.Slot()
+	stateRoot, err := l.State.HashTreeRoot(l.Ctx)
+	require.NoError(t, err)
+
+	mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+	s := &Server{
+		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+			slot: l.State,
+		}},
+		Blocker:     mockBlocker,
+		HeadFetcher: mockChainService,
+	}
+	request := httptest.NewRequest("GET", "http://foo.com/", nil)
+	request.SetPathValue("block_root", hexutil.Encode(stateRoot[:]))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+
+	s.GetLightClientBootstrap(writer, request)
+	require.Equal(t, http.StatusOK, writer.Code)
+	var resp structs.LightClientBootstrapResponse
+	err = json.Unmarshal(writer.Body.Bytes(), &resp)
+	require.NoError(t, err)
+	var respHeader structs.LightClientHeader
+	err = json.Unmarshal(resp.Data.Header, &respHeader)
+	require.NoError(t, err)
+	require.Equal(t, "electra", resp.Version)
+
+	blockHeader, err := l.Block.Header()
+	require.NoError(t, err)
+	require.Equal(t, hexutil.Encode(blockHeader.Header.BodyRoot), respHeader.Beacon.BodyRoot)
+	require.Equal(t, strconv.FormatUint(uint64(blockHeader.Header.Slot), 10), respHeader.Beacon.Slot)
+
+	require.NotNil(t, resp.Data.CurrentSyncCommittee)
+	require.NotNil(t, resp.Data.CurrentSyncCommitteeBranch)
 }
 
 func TestLightClientHandler_GetLightClientUpdatesByRangeAltair(t *testing.T) {

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

@@ -7,10 +7,9 @@ import (
 	"reflect"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/proto/migration"
 
 	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
-	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
@@ -18,18 +17,17 @@ import (
 	"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/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
-func createLightClientBootstrap(ctx context.Context, state state.BeaconState, blk interfaces.ReadOnlyBeaconBlock) (*structs.LightClientBootstrap, error) {
+func createLightClientBootstrap(ctx context.Context, state state.BeaconState, blk interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
 	switch blk.Version() {
 	case version.Phase0:
 		return nil, fmt.Errorf("light client bootstrap is not supported for phase0")
 	case version.Altair, version.Bellatrix:
-		return createLightClientBootstrapAltair(ctx, state)
+		return createLightClientBootstrapAltair(ctx, state, blk)
 	case version.Capella:
 		return createLightClientBootstrapCapella(ctx, state, blk)
 	case version.Deneb, version.Electra:
@@ -38,24 +36,7 @@ func createLightClientBootstrap(ctx context.Context, state state.BeaconState, bl
 	return nil, fmt.Errorf("unsupported block version %s", version.String(blk.Version()))
 }
 
-// createLightClientBootstrapAltair - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_bootstrap
-// def create_light_client_bootstrap(state: BeaconState) -> LightClientBootstrap:
-//
-//	assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH
-//	assert state.slot == state.latest_block_header.slot
-//
-//	return LightClientBootstrap(
-//	    header=BeaconBlockHeader(
-//	        slot=state.latest_block_header.slot,
-//	        proposer_index=state.latest_block_header.proposer_index,
-//	        parent_root=state.latest_block_header.parent_root,
-//	        state_root=hash_tree_root(state),
-//	        body_root=state.latest_block_header.body_root,
-//	    ),
-//	    current_sync_committee=state.current_sync_committee,
-//	    current_sync_committee_branch=compute_merkle_proof_for_state(state, CURRENT_SYNC_COMMITTEE_INDEX)
-//	)
-func createLightClientBootstrapAltair(ctx context.Context, state state.BeaconState) (*structs.LightClientBootstrap, error) {
+func createLightClientBootstrapAltair(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, 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())
@@ -67,55 +48,63 @@ func createLightClientBootstrapAltair(ctx context.Context, state state.BeaconSta
 		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
 	}
 
-	// Prepare data
+	// header.state_root = hash_tree_root(state)
+	stateRoot, err := state.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get state root")
+	}
+	latestBlockHeader.StateRoot = stateRoot[:]
+
+	// assert hash_tree_root(header) == hash_tree_root(block.message)
+	latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get latest block header root")
+	}
+	beaconBlockRoot, err := block.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get block root")
+	}
+	if latestBlockHeaderRoot != beaconBlockRoot {
+		return nil, fmt.Errorf("latest block header root %#x not equal to block root %#x", latestBlockHeaderRoot, beaconBlockRoot)
+	}
+
+	lightClientHeaderContainer, err := lightclient.BlockToLightClientHeader(block)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not convert block to light client header")
+	}
+	lightClientHeader := lightClientHeaderContainer.GetHeaderAltair()
+
+	apiLightClientHeader := &structs.LightClientHeader{
+		Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(lightClientHeader.Beacon)),
+	}
+
+	headerJSON, err := json.Marshal(apiLightClientHeader)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not convert header to raw message")
+	}
 	currentSyncCommittee, err := state.CurrentSyncCommittee()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get current sync committee")
 	}
-
-	committee := structs.SyncCommitteeFromConsensus(currentSyncCommittee)
-
 	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get current sync committee proof")
 	}
 
-	branch := make([]string, fieldparams.NextSyncCommitteeBranchDepth)
+	branch := make([]string, fieldparams.SyncCommitteeBranchDepth)
 	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.LightClientHeader{
-		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, errors.Wrap(err, "could not get state root")
-	}
-	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
-
-	headerJson, err := json.Marshal(header)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert header to raw message")
-	}
-
-	// Return result
 	result := &structs.LightClientBootstrap{
-		Header:                     headerJson,
-		CurrentSyncCommittee:       committee,
+		Header:                     headerJSON,
+		CurrentSyncCommittee:       structs.SyncCommitteeFromConsensus(currentSyncCommittee),
 		CurrentSyncCommitteeBranch: branch,
 	}
 
 	return result, nil
 }
 
-func createLightClientBootstrapCapella(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlyBeaconBlock) (*structs.LightClientBootstrap, error) {
+func createLightClientBootstrapCapella(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
 	// assert compute_epoch_at_slot(state.slot) >= CAPELLA_FORK_EPOCH
 	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().CapellaForkEpoch {
 		return nil, fmt.Errorf("creating Capella light client bootstrap is not supported before Capella, invalid slot %d", state.Slot())
@@ -127,111 +116,63 @@ func createLightClientBootstrapCapella(ctx context.Context, state state.BeaconSt
 		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
 	}
 
-	// Prepare data
+	// header.state_root = hash_tree_root(state)
+	stateRoot, err := state.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get state root")
+	}
+	latestBlockHeader.StateRoot = stateRoot[:]
+
+	// assert hash_tree_root(header) == hash_tree_root(block.message)
+	latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get latest block header root")
+	}
+	beaconBlockRoot, err := block.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get block root")
+	}
+	if latestBlockHeaderRoot != beaconBlockRoot {
+		return nil, fmt.Errorf("latest block header root %#x not equal to block root %#x", latestBlockHeaderRoot, beaconBlockRoot)
+	}
+
+	lightClientHeaderContainer, err := lightclient.BlockToLightClientHeader(block)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not convert block to light client header")
+	}
+	lightClientHeader := lightClientHeaderContainer.GetHeaderCapella()
+
+	apiLightClientHeader := &structs.LightClientHeader{
+		Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(lightClientHeader.Beacon)),
+	}
+
+	headerJSON, err := json.Marshal(apiLightClientHeader)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not convert header to raw message")
+	}
 	currentSyncCommittee, err := state.CurrentSyncCommittee()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get current sync committee")
 	}
-
-	committee := structs.SyncCommitteeFromConsensus(currentSyncCommittee)
-
 	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get current sync committee proof")
 	}
 
-	branch := make([]string, fieldparams.NextSyncCommitteeBranchDepth)
+	branch := make([]string, fieldparams.SyncCommitteeBranchDepth)
 	for i, proof := range currentSyncCommitteeProof {
 		branch[i] = hexutil.Encode(proof)
 	}
-
-	beacon := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
-
-	payloadInterface, err := block.Body().Execution()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution payload")
-	}
-	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[:]
-	}
-	executionPayloadHeader := &structs.ExecutionPayloadHeaderCapella{
-		ParentHash:       hexutil.Encode(payloadInterface.ParentHash()),
-		FeeRecipient:     hexutil.Encode(payloadInterface.FeeRecipient()),
-		StateRoot:        hexutil.Encode(payloadInterface.StateRoot()),
-		ReceiptsRoot:     hexutil.Encode(payloadInterface.ReceiptsRoot()),
-		LogsBloom:        hexutil.Encode(payloadInterface.LogsBloom()),
-		PrevRandao:       hexutil.Encode(payloadInterface.PrevRandao()),
-		BlockNumber:      hexutil.EncodeUint64(payloadInterface.BlockNumber()),
-		GasLimit:         hexutil.EncodeUint64(payloadInterface.GasLimit()),
-		GasUsed:          hexutil.EncodeUint64(payloadInterface.GasUsed()),
-		Timestamp:        hexutil.EncodeUint64(payloadInterface.Timestamp()),
-		ExtraData:        hexutil.Encode(payloadInterface.ExtraData()),
-		BaseFeePerGas:    hexutil.Encode(payloadInterface.BaseFeePerGas()),
-		BlockHash:        hexutil.Encode(payloadInterface.BlockHash()),
-		TransactionsRoot: hexutil.Encode(transactionsRoot),
-		WithdrawalsRoot:  hexutil.Encode(withdrawalsRoot),
-	}
-
-	executionPayloadProof, err := blocks.PayloadProof(ctx, block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution payload proof")
-	}
-	executionPayloadProofStr := make([]string, len(executionPayloadProof))
-	for i, proof := range executionPayloadProof {
-		executionPayloadProofStr[i] = hexutil.Encode(proof)
-	}
-	header := &structs.LightClientHeaderCapella{
-		Beacon:          beacon,
-		Execution:       executionPayloadHeader,
-		ExecutionBranch: executionPayloadProofStr,
-	}
-
-	// 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, errors.Wrap(err, "could not get state root")
-	}
-	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
-
-	headerJson, err := json.Marshal(header)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert header to raw message")
-	}
-
-	// Return result
 	result := &structs.LightClientBootstrap{
-		Header:                     headerJson,
-		CurrentSyncCommittee:       committee,
+		Header:                     headerJSON,
+		CurrentSyncCommittee:       structs.SyncCommitteeFromConsensus(currentSyncCommittee),
 		CurrentSyncCommitteeBranch: branch,
 	}
 
 	return result, nil
 }
 
-func createLightClientBootstrapDeneb(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlyBeaconBlock) (*structs.LightClientBootstrap, error) {
+func createLightClientBootstrapDeneb(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
 	// assert compute_epoch_at_slot(state.slot) >= DENEB_FORK_EPOCH
 	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().DenebForkEpoch {
 		return nil, fmt.Errorf("creating Deneb light client bootstrap is not supported before Deneb, invalid slot %d", state.Slot())
@@ -243,103 +184,61 @@ func createLightClientBootstrapDeneb(ctx context.Context, state state.BeaconStat
 		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, errors.Wrap(err, "could not get current sync committee")
-	}
-
-	committee := structs.SyncCommitteeFromConsensus(currentSyncCommittee)
-
-	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee proof")
-	}
-
-	branch := make([]string, fieldparams.NextSyncCommitteeBranchDepth)
-	for i, proof := range currentSyncCommitteeProof {
-		branch[i] = hexutil.Encode(proof)
-	}
-
-	beacon := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
-
-	payloadInterface, err := block.Body().Execution()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution payload")
-	}
-	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[:]
-	}
-	executionPayloadHeader := &structs.ExecutionPayloadHeaderDeneb{
-		ParentHash:       hexutil.Encode(payloadInterface.ParentHash()),
-		FeeRecipient:     hexutil.Encode(payloadInterface.FeeRecipient()),
-		StateRoot:        hexutil.Encode(payloadInterface.StateRoot()),
-		ReceiptsRoot:     hexutil.Encode(payloadInterface.ReceiptsRoot()),
-		LogsBloom:        hexutil.Encode(payloadInterface.LogsBloom()),
-		PrevRandao:       hexutil.Encode(payloadInterface.PrevRandao()),
-		BlockNumber:      hexutil.EncodeUint64(payloadInterface.BlockNumber()),
-		GasLimit:         hexutil.EncodeUint64(payloadInterface.GasLimit()),
-		GasUsed:          hexutil.EncodeUint64(payloadInterface.GasUsed()),
-		Timestamp:        hexutil.EncodeUint64(payloadInterface.Timestamp()),
-		ExtraData:        hexutil.Encode(payloadInterface.ExtraData()),
-		BaseFeePerGas:    hexutil.Encode(payloadInterface.BaseFeePerGas()),
-		BlockHash:        hexutil.Encode(payloadInterface.BlockHash()),
-		TransactionsRoot: hexutil.Encode(transactionsRoot),
-		WithdrawalsRoot:  hexutil.Encode(withdrawalsRoot),
-	}
-
-	executionPayloadProof, err := blocks.PayloadProof(ctx, block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get execution payload proof")
-	}
-	executionPayloadProofStr := make([]string, len(executionPayloadProof))
-	for i, proof := range executionPayloadProof {
-		executionPayloadProofStr[i] = hexutil.Encode(proof)
-	}
-	header := &structs.LightClientHeaderDeneb{
-		Beacon:          beacon,
-		Execution:       executionPayloadHeader,
-		ExecutionBranch: executionPayloadProofStr,
-	}
-
-	// Above shared util function won't calculate state root, so we need to do it manually
+	// header.state_root = hash_tree_root(state)
 	stateRoot, err := state.HashTreeRoot(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get state root")
 	}
-	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
+	latestBlockHeader.StateRoot = stateRoot[:]
 
-	headerJson, err := json.Marshal(header)
+	// assert hash_tree_root(header) == hash_tree_root(block.message)
+	latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get latest block header root")
+	}
+	beaconBlockRoot, err := block.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get block root")
+	}
+	if latestBlockHeaderRoot != beaconBlockRoot {
+		return nil, fmt.Errorf("latest block header root %#x not equal to block root %#x", latestBlockHeaderRoot, beaconBlockRoot)
+	}
+
+	lightClientHeaderContainer, err := lightclient.BlockToLightClientHeader(block)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not convert block to light client header")
+	}
+	lightClientHeader := lightClientHeaderContainer.GetHeaderDeneb()
+
+	apiLightClientHeader := &structs.LightClientHeader{
+		Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(lightClientHeader.Beacon)),
+	}
+
+	headerJSON, err := json.Marshal(apiLightClientHeader)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert header to raw message")
 	}
-	// Return result
+	currentSyncCommittee, err := state.CurrentSyncCommittee()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get current sync committee")
+	}
+	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get current sync committee proof")
+	}
+	var branch []string
+	switch block.Version() {
+	case version.Deneb:
+		branch = make([]string, fieldparams.SyncCommitteeBranchDepth)
+	case version.Electra:
+		branch = make([]string, fieldparams.SyncCommitteeBranchDepthElectra)
+	}
+	for i, proof := range currentSyncCommitteeProof {
+		branch[i] = hexutil.Encode(proof)
+	}
 	result := &structs.LightClientBootstrap{
-		Header:                     headerJson,
-		CurrentSyncCommittee:       committee,
+		Header:                     headerJSON,
+		CurrentSyncCommittee:       structs.SyncCommitteeFromConsensus(currentSyncCommittee),
 		CurrentSyncCommitteeBranch: branch,
 	}
 
@@ -351,9 +250,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 +266,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 +282,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
 	}
@@ -391,7 +293,7 @@ func newLightClientOptimisticUpdateFromBeaconState(
 }
 
 func IsSyncCommitteeUpdate(update *v2.LightClientUpdate) bool {
-	nextSyncCommitteeBranch := make([][]byte, fieldparams.NextSyncCommitteeBranchDepth)
+	nextSyncCommitteeBranch := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
 	return !reflect.DeepEqual(update.NextSyncCommitteeBranch, nextSyncCommitteeBranch)
 }
 

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

@@ -13,7 +13,7 @@ import (
 
 // When the update has relevant sync committee
 func createNonEmptySyncCommitteeBranch() [][]byte {
-	res := make([][]byte, fieldparams.NextSyncCommitteeBranchDepth)
+	res := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
 	res[0] = []byte("xyz")
 	return res
 }
@@ -101,7 +101,7 @@ func TestIsBetterUpdate(t *testing.T) {
 						}},
 					},
 				},
-				NextSyncCommitteeBranch: make([][]byte, fieldparams.NextSyncCommitteeBranchDepth),
+				NextSyncCommitteeBranch: make([][]byte, fieldparams.SyncCommitteeBranchDepth),
 				SignatureSlot:           9999,
 			},
 			newUpdate: &ethpbv2.LightClientUpdate{
@@ -147,7 +147,7 @@ func TestIsBetterUpdate(t *testing.T) {
 						}},
 					},
 				},
-				NextSyncCommitteeBranch: make([][]byte, fieldparams.NextSyncCommitteeBranchDepth),
+				NextSyncCommitteeBranch: make([][]byte, fieldparams.SyncCommitteeBranchDepth),
 				SignatureSlot:           9999,
 			},
 			expectedResult: false,

beacon-chain/rpc/eth/shared/testing/json.go

@@ -1814,10 +1814,7 @@ var BlindedElectraBlock = fmt.Sprintf(`{
 		"blob_gas_used": "1",
 		"excess_blob_gas": "2",
         "transactions_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-        "withdrawals_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-		"deposit_requests_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-		"withdrawal_requests_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-		"consolidation_requests_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
+        "withdrawals_root": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
       },
       "bls_to_execution_changes": [
         {
@@ -1829,7 +1826,33 @@ var BlindedElectraBlock = fmt.Sprintf(`{
           "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
         }
       ],
- 	  "blob_kzg_commitments":["0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8000"]
+ 	  "blob_kzg_commitments":["0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8000"],
+	  "execution_requests": {
+		"deposits": [
+		  {
+		    "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+		    "withdrawal_credentials": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+		    "amount": "123",
+		    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+		    "index": "123"
+		  }
+		],
+		"withdrawals": [
+		  {
+		    "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+		    "validator_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+		    "amount": "123"
+		  }
+		],
+		"consolidations": [
+		  {
+		    "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+		    "source_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+		    "target_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+		  }
+		]
+	}
+
     }
   },
   "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
@@ -2225,30 +2248,7 @@ var ElectraBlockContents = fmt.Sprintf(`{
 					"address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
 					"amount": "1"
 				  }
-				],
-                "deposit_requests": [
-                  {
-                    "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
-                    "withdrawal_credentials": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-                    "amount": "123",
-                    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
-                    "index": "123"
-                  }
-                ],
-                "withdrawal_requests": [
-                  {
-                    "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-                    "validator_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
-                    "amount": "123"
-                  }
-                ],
-                "consolidation_requests": [
-                  {
-                    "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-                    "source_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
-                    "target_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
-                  }
-                ]
+				]
 			  },
 			  "bls_to_execution_changes": [
 				{
@@ -2260,7 +2260,32 @@ var ElectraBlockContents = fmt.Sprintf(`{
 				  "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"
 				}
 			  ],
-			  "blob_kzg_commitments":["0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8000"]
+			  "blob_kzg_commitments":["0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8000"],
+				  "execution_requests": {
+					"deposits": [
+					  {
+					    "pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+					    "withdrawal_credentials": "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
+					    "amount": "123",
+					    "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505",
+					    "index": "123"
+					  }
+					],
+					"withdrawals": [
+					  {
+					    "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+					    "validator_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+					    "amount": "123"
+					  }
+					],
+					"consolidations": [
+					  {
+					    "source_address": "0xabcf8e0d4e9587369b2301d0790347320302cc09",
+					    "source_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a",
+					    "target_pubkey": "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+					  }
+					]
+				}
 			}
 		  },
 		  "signature": "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"

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

@@ -287,6 +287,18 @@ func (s *Server) produceBlockV3(ctx context.Context, w http.ResponseWriter, r *h
 		handleProduceDenebV3(w, isSSZ, denebBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
 		return
 	}
+	blindedElectraBlockContents, ok := v1alpha1resp.Block.(*eth.GenericBeaconBlock_BlindedElectra)
+	if ok {
+		w.Header().Set(api.VersionHeader, version.String(version.Electra))
+		handleProduceBlindedElectraV3(w, isSSZ, blindedElectraBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
+		return
+	}
+	electraBlockContents, ok := v1alpha1resp.Block.(*eth.GenericBeaconBlock_Electra)
+	if ok {
+		w.Header().Set(api.VersionHeader, version.String(version.Electra))
+		handleProduceElectraV3(w, isSSZ, electraBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
+		return
+	}
 }
 
 func getConsensusBlockValue(ctx context.Context, blockRewardsFetcher rewards.BlockRewardsFetcher, i interface{} /* block as argument */) (string, *httputil.DefaultJsonError) {
@@ -587,3 +599,74 @@ func handleProduceDenebV3(
 		Data:                    jsonBytes,
 	})
 }
+
+func handleProduceBlindedElectraV3(
+	w http.ResponseWriter,
+	isSSZ bool,
+	blk *eth.GenericBeaconBlock_BlindedElectra,
+	executionPayloadValue string,
+	consensusPayloadValue string,
+) {
+	if isSSZ {
+		sszResp, err := blk.BlindedElectra.MarshalSSZ()
+		if err != nil {
+			httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, sszResp, "blindedElectraBlockContents.ssz")
+		return
+	}
+	blindedBlock, err := structs.BlindedBeaconBlockElectraFromConsensus(blk.BlindedElectra)
+	if err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	jsonBytes, err := json.Marshal(blindedBlock)
+	if err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	httputil.WriteJson(w, &structs.ProduceBlockV3Response{
+		Version:                 version.String(version.Electra),
+		ExecutionPayloadBlinded: true,
+		ExecutionPayloadValue:   executionPayloadValue,
+		ConsensusBlockValue:     consensusPayloadValue,
+		Data:                    jsonBytes,
+	})
+}
+
+func handleProduceElectraV3(
+	w http.ResponseWriter,
+	isSSZ bool,
+	blk *eth.GenericBeaconBlock_Electra,
+	executionPayloadValue string,
+	consensusBlockValue string,
+) {
+	if isSSZ {
+		sszResp, err := blk.Electra.MarshalSSZ()
+		if err != nil {
+			httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, sszResp, "electraBlockContents.ssz")
+		return
+	}
+
+	blockContents, err := structs.BeaconBlockContentsElectraFromConsensus(blk.Electra)
+	if err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	jsonBytes, err := json.Marshal(blockContents)
+	if err != nil {
+		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+	httputil.WriteJson(w, &structs.ProduceBlockV3Response{
+		Version:                 version.String(version.Electra),
+		ExecutionPayloadBlinded: false,
+		ExecutionPayloadValue:   executionPayloadValue, // mev not available at this point
+		ConsensusBlockValue:     consensusBlockValue,
+		Data:                    jsonBytes,
+	})
+}

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

@@ -308,6 +308,75 @@ func TestProduceBlockV2(t *testing.T) {
 		assert.Equal(t, http.StatusInternalServerError, e.Code)
 		assert.StringContains(t, "Prepared block is blinded", e.Message)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		var block *structs.SignedBeaconBlockContentsElectra
+		err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &block)
+		require.NoError(t, err)
+		jsonBytes, err := json.Marshal(block.ToUnsigned())
+		require.NoError(t, err)
+
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: true,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.ToUnsigned().ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v2/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		want := fmt.Sprintf(`{"version":"electra","execution_payload_blinded":false,"execution_payload_value":"2000","consensus_block_value":"10000000000","data":%s}`, string(jsonBytes))
+		body := strings.ReplaceAll(writer.Body.String(), "\n", "")
+		require.Equal(t, want, body)
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		var block *structs.SignedBlindedBeaconBlockElectra
+		err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &block)
+		require.NoError(t, err)
+
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: true,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				return block.Message.ToGeneric()
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v2/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV2(writer, request)
+		assert.Equal(t, http.StatusInternalServerError, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusInternalServerError, e.Code)
+		assert.StringContains(t, "Prepared block is blinded", e.Message)
+	})
 	t.Run("invalid query parameter slot empty", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		server := &Server{
@@ -650,6 +719,76 @@ func TestProduceBlockV2SSZ(t *testing.T) {
 			BlockRewardFetcher:    rewardFetcher,
 		}
 
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v2/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV2(writer, request)
+		assert.Equal(t, http.StatusInternalServerError, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusInternalServerError, e.Code)
+		assert.StringContains(t, "Prepared block is blinded", e.Message)
+	})
+	t.Run("Electra", func(t *testing.T) {
+		var block *structs.SignedBeaconBlockContentsElectra
+		err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &block)
+		require.NoError(t, err)
+
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: true,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				return block.ToUnsigned().ToGeneric()
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v2/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		g, err := block.ToUnsigned().ToGeneric()
+		require.NoError(t, err)
+		bl, ok := g.Block.(*eth.GenericBeaconBlock_Electra)
+		require.Equal(t, true, ok)
+		ssz, err := bl.Electra.MarshalSSZ()
+		require.NoError(t, err)
+		require.Equal(t, string(ssz), writer.Body.String())
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		var block *structs.SignedBlindedBeaconBlockElectra
+		err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &block)
+		require.NoError(t, err)
+
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: true,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				return block.Message.ToGeneric()
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+
 		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v2/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
 		request.Header.Set("Accept", api.OctetStreamMediaType)
 		writer := httptest.NewRecorder()
@@ -944,6 +1083,75 @@ func TestProduceBlindedBlock(t *testing.T) {
 		require.Equal(t, want, body)
 		require.Equal(t, "deneb", writer.Header().Get(api.VersionHeader))
 	})
+	t.Run("Electra", func(t *testing.T) {
+		var block *structs.SignedBeaconBlockContentsElectra
+		err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &block)
+		require.NoError(t, err)
+
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				return block.ToUnsigned().ToGeneric()
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v1/validator/blinded_blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusInternalServerError, writer.Code)
+		e := &httputil.DefaultJsonError{}
+		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), e))
+		assert.Equal(t, http.StatusInternalServerError, e.Code)
+		assert.StringContains(t, "Prepared block is not blinded", e.Message)
+	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		var block *structs.SignedBlindedBeaconBlockElectra
+		err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &block)
+		require.NoError(t, err)
+		jsonBytes, err := json.Marshal(block.Message)
+		require.NoError(t, err)
+
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.Message.ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v1/validator/blinded_blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		want := fmt.Sprintf(`{"version":"electra","execution_payload_blinded":true,"execution_payload_value":"2000","consensus_block_value":"10000000000","data":%s}`, string(jsonBytes))
+		body := strings.ReplaceAll(writer.Body.String(), "\n", "")
+		require.Equal(t, want, body)
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+	})
 	t.Run("invalid query parameter slot empty", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		server := &Server{
@@ -1309,6 +1517,82 @@ func TestProduceBlockV3(t *testing.T) {
 		require.Equal(t, "deneb", writer.Header().Get(api.VersionHeader))
 		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
 	})
+	t.Run("Electra", func(t *testing.T) {
+		var block *structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &block)
+		require.NoError(t, err)
+		jsonBytes, err := json.Marshal(block.ToUnsigned())
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.ToUnsigned().ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v3/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV3(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		want := fmt.Sprintf(`{"version":"electra","execution_payload_blinded":false,"execution_payload_value":"2000","consensus_block_value":"10000000000","data":%s}`, string(jsonBytes))
+		body := strings.ReplaceAll(writer.Body.String(), "\n", "")
+		require.Equal(t, want, body)
+		require.Equal(t, "false", writer.Header().Get(api.ExecutionPayloadBlindedHeader))
+		require.Equal(t, "2000", writer.Header().Get(api.ExecutionPayloadValueHeader))
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
+	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		var block *structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &block)
+		require.NoError(t, err)
+		jsonBytes, err := json.Marshal(block.Message)
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.Message.ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v3/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV3(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		want := fmt.Sprintf(`{"version":"electra","execution_payload_blinded":true,"execution_payload_value":"2000","consensus_block_value":"10000000000","data":%s}`, string(jsonBytes))
+		body := strings.ReplaceAll(writer.Body.String(), "\n", "")
+		require.Equal(t, want, body)
+		require.Equal(t, "true", writer.Header().Get(api.ExecutionPayloadBlindedHeader))
+		require.Equal(t, "2000", writer.Header().Get(api.ExecutionPayloadValueHeader))
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
+	})
 	t.Run("invalid query parameter slot empty", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		server := &Server{
@@ -1697,4 +1981,86 @@ func TestProduceBlockV3SSZ(t *testing.T) {
 		require.Equal(t, "deneb", writer.Header().Get(api.VersionHeader))
 		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
 	})
+	t.Run("Electra", func(t *testing.T) {
+		var block *structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &block)
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.ToUnsigned().ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v3/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV3(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		g, err := block.ToUnsigned().ToGeneric()
+		require.NoError(t, err)
+		bl, ok := g.Block.(*eth.GenericBeaconBlock_Electra)
+		require.Equal(t, true, ok)
+		ssz, err := bl.Electra.MarshalSSZ()
+		require.NoError(t, err)
+		require.Equal(t, string(ssz), writer.Body.String())
+		require.Equal(t, "false", writer.Header().Get(api.ExecutionPayloadBlindedHeader))
+		require.Equal(t, "2000", writer.Header().Get(api.ExecutionPayloadValueHeader))
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
+	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		var block *structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &block)
+		require.NoError(t, err)
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().GetBeaconBlock(gomock.Any(), &eth.BlockRequest{
+			Slot:         1,
+			RandaoReveal: bRandao,
+			Graffiti:     bGraffiti,
+			SkipMevBoost: false,
+		}).Return(
+			func() (*eth.GenericBeaconBlock, error) {
+				b, err := block.Message.ToGeneric()
+				require.NoError(t, err)
+				b.PayloadValue = "2000"
+				return b, nil
+			}())
+		server := &Server{
+			V1Alpha1Server:        v1alpha1Server,
+			SyncChecker:           syncChecker,
+			OptimisticModeFetcher: chainService,
+			BlockRewardFetcher:    rewardFetcher,
+		}
+		request := httptest.NewRequest(http.MethodGet, fmt.Sprintf("http://foo.example/eth/v3/validator/blocks/1?randao_reveal=%s&graffiti=%s", randao, graffiti), nil)
+		request.Header.Set("Accept", api.OctetStreamMediaType)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.ProduceBlockV3(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+		g, err := block.Message.ToGeneric()
+		require.NoError(t, err)
+		bl, ok := g.Block.(*eth.GenericBeaconBlock_BlindedElectra)
+		require.Equal(t, true, ok)
+		ssz, err := bl.BlindedElectra.MarshalSSZ()
+		require.NoError(t, err)
+		require.Equal(t, string(ssz), writer.Body.String())
+		require.Equal(t, "true", writer.Header().Get(api.ExecutionPayloadBlindedHeader))
+		require.Equal(t, "2000", writer.Header().Get(api.ExecutionPayloadValueHeader))
+		require.Equal(t, "electra", writer.Header().Get(api.VersionHeader))
+		require.Equal(t, "10000000000", writer.Header().Get(api.ConsensusBlockValueHeader))
+	})
 }

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

@@ -14,6 +14,7 @@ go_library(
         "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db:go_default_library",
+        "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
         "//beacon-chain/rpc/eth/helpers:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
@@ -22,8 +23,10 @@ go_library(
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
+        "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/eth/v1:go_default_library",
@@ -47,13 +50,16 @@ go_test(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
+        "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
+        "//beacon-chain/rpc/prysm/testing:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/state/stategen/mock:go_default_library",
+        "//beacon-chain/sync/initial-sync/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/rpc/prysm/beacon/handlers.go

@@ -15,7 +15,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -183,3 +185,52 @@ func (s *Server) GetChainHead(w http.ResponseWriter, r *http.Request) {
 	}
 	httputil.WriteJson(w, response)
 }
+
+func (s *Server) PublishBlobs(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.PublishBlobs")
+	defer span.End()
+	if shared.IsSyncing(r.Context(), w, s.SyncChecker, s.HeadFetcher, s.TimeFetcher, s.OptimisticModeFetcher) {
+		return
+	}
+
+	var req structs.PublishBlobsRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		httputil.HandleError(w, "Could not decode JSON request body", http.StatusBadRequest)
+		return
+	}
+	if req.BlobSidecars == nil {
+		httputil.HandleError(w, "Missing blob sidecars", http.StatusBadRequest)
+		return
+	}
+
+	root, err := bytesutil.DecodeHexWithLength(req.BlockRoot, 32)
+	if err != nil {
+		httputil.HandleError(w, "Could not decode block root: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	for _, blobSidecar := range req.BlobSidecars.Sidecars {
+		sc, err := blobSidecar.ToConsensus()
+		if err != nil {
+			httputil.HandleError(w, "Could not decode blob sidecar: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+
+		readOnlySc, err := blocks.NewROBlobWithRoot(sc, bytesutil.ToBytes32(root))
+		if err != nil {
+			httputil.HandleError(w, "Could not create read-only blob: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		verifiedBlob := blocks.NewVerifiedROBlob(readOnlySc)
+		if err := s.BlobReceiver.ReceiveBlob(ctx, verifiedBlob); err != nil {
+			httputil.HandleError(w, "Could not receive blob: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		if err := s.Broadcaster.BroadcastBlob(ctx, sc.Index, sc); err != nil {
+			httputil.HandleError(w, "Failed to broadcast blob: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+}

beacon-chain/rpc/prysm/beacon/handlers_test.go

@@ -18,10 +18,13 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	dbTest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
+	mockp2p "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
+	rpctesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/testing"
 	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	mockstategen "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen/mock"
+	mockSync "github.com/prysmaticlabs/prysm/v5/beacon-chain/sync/initial-sync/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -870,3 +873,163 @@ func TestServer_GetChainHead(t *testing.T) {
 	assert.DeepEqual(t, hexutil.Encode(fRoot[:]), ch.FinalizedBlockRoot, "Unexpected FinalizedBlockRoot")
 	assert.Equal(t, false, ch.OptimisticStatus)
 }
+
+func TestPublishBlobs_InvalidJson(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.InvalidJson)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Could not decode JSON request body", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_MissingBlob(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestMissingBlob)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Could not decode blob sidecar", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_MissingSignedBlockHeader(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestMissingSignedBlockHeader)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Could not decode blob sidecar", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_MissingSidecars(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestMissingSidecars)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Missing blob sidecars", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_EmptySidecarsList(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestEmptySidecarsList)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusOK, writer.Code)
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_NullSidecar(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestNullSidecar)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Could not decode blob sidecar", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_SeveralFieldsMissing(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestSeveralFieldsMissing)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Could not decode blob sidecar", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs_BadBlockRoot(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequestBadBlockRoot)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusBadRequest, writer.Code)
+	assert.StringContains(t, "Could not decode block root", writer.Body.String())
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 0)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), false)
+}
+
+func TestPublishBlobs(t *testing.T) {
+	server := &Server{
+		BlobReceiver: &chainMock.ChainService{},
+		Broadcaster:  &mockp2p.MockBroadcaster{},
+		SyncChecker:  &mockSync.Sync{IsSyncing: false},
+	}
+
+	request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.PublishBlobsRequest)))
+	writer := httptest.NewRecorder()
+	writer.Body = &bytes.Buffer{}
+	server.PublishBlobs(writer, request)
+	assert.Equal(t, http.StatusOK, writer.Code)
+
+	assert.Equal(t, len(server.BlobReceiver.(*chainMock.ChainService).Blobs), 1)
+	assert.Equal(t, server.Broadcaster.(*mockp2p.MockBroadcaster).BroadcastCalled.Load(), true)
+}

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

@@ -3,6 +3,7 @@ package beacon
 import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	beacondb "github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
@@ -20,4 +21,6 @@ type Server struct {
 	ChainInfoFetcher      blockchain.ChainInfoFetcher
 	FinalizationFetcher   blockchain.FinalizationFetcher
 	CoreService           *core.Service
+	Broadcaster           p2p.Broadcaster
+	BlobReceiver          blockchain.BlobReceiver
 }

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

@@ -0,0 +1,9 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    testonly = True,
+    srcs = ["json.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/prysm/testing",
+    visibility = ["//visibility:public"],
+)

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

@@ -217,10 +217,10 @@ func (a proposerAtts) sort() (proposerAtts, error) {
 		return a, nil
 	}
 
-	if features.Get().EnableCommitteeAwarePacking {
-		return a.sortBySlotAndCommittee()
+	if features.Get().DisableCommitteeAwarePacking {
+		return a.sortByProfitabilityUsingMaxCover()
 	}
-	return a.sortByProfitabilityUsingMaxCover()
+	return a.sortBySlotAndCommittee()
 }
 
 // Separate attestations by slot, as slot number takes higher precedence when sorting.

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

@@ -21,6 +21,11 @@ import (
 )
 
 func TestProposer_ProposerAtts_sort(t *testing.T) {
+	feat := features.Get()
+	feat.DisableCommitteeAwarePacking = true
+	reset := features.InitWithReset(feat)
+	defer reset()
+
 	type testData struct {
 		slot primitives.Slot
 		bits bitfield.Bitlist
@@ -186,11 +191,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	}
 
 	t.Run("no atts", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		atts := getAtts([]testData{})
 		want := getAtts([]testData{})
 		atts, err := atts.sort()
@@ -201,11 +201,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	})
 
 	t.Run("single att", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		atts := getAtts([]testData{
 			{4, bitfield.Bitlist{0b11100000, 0b1}},
 		})
@@ -220,11 +215,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	})
 
 	t.Run("single att per slot", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		atts := getAtts([]testData{
 			{1, bitfield.Bitlist{0b11000000, 0b1}},
 			{4, bitfield.Bitlist{0b11100000, 0b1}},
@@ -241,10 +231,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	})
 
 	t.Run("two atts on one of the slots", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
 
 		atts := getAtts([]testData{
 			{1, bitfield.Bitlist{0b11000000, 0b1}},
@@ -263,11 +249,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	})
 
 	t.Run("compare to native sort", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		// The max-cover based approach will select 0b00001100 instead, despite lower bit count
 		// (since it has two new/unknown bits).
 		t.Run("max-cover", func(t *testing.T) {
@@ -289,11 +270,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	})
 
 	t.Run("multiple slots", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		atts := getAtts([]testData{
 			{2, bitfield.Bitlist{0b11100000, 0b1}},
 			{4, bitfield.Bitlist{0b11100000, 0b1}},
@@ -316,11 +292,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 	})
 
 	t.Run("follows max-cover", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		// Items at slot 4 must be first split into two lists by max-cover, with
 		// 0b10000011 being selected and 0b11100001 being leftover (despite naive bit count suggesting otherwise).
 		atts := getAtts([]testData{
@@ -350,11 +321,6 @@ func TestProposer_ProposerAtts_committeeAwareSort(t *testing.T) {
 
 func TestProposer_sort_DifferentCommittees(t *testing.T) {
 	t.Run("one att per committee", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 1}})
 		c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11100000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 2}})
 		atts := proposerAtts{c1_a1, c2_a1}
@@ -364,11 +330,6 @@ func TestProposer_sort_DifferentCommittees(t *testing.T) {
 		assert.DeepEqual(t, want, atts)
 	})
 	t.Run("multiple atts per committee", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111100, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 1}})
 		c1_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10000010, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 1}})
 		c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11110000, 0b1}, Data: &ethpb.AttestationData{CommitteeIndex: 2}})
@@ -381,11 +342,6 @@ func TestProposer_sort_DifferentCommittees(t *testing.T) {
 		assert.DeepEqual(t, want, atts)
 	})
 	t.Run("multiple atts per committee, multiple slots", func(t *testing.T) {
-		feat := features.Get()
-		feat.EnableCommitteeAwarePacking = true
-		reset := features.InitWithReset(feat)
-		defer reset()
-
 		s2_c1_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11111100, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1}})
 		s2_c1_a2 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b10000010, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 1}})
 		s2_c2_a1 := util.HydrateAttestation(&ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b11110000, 0b1}, Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 2}})

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

@@ -586,40 +586,6 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 	require.NoError(t, err)
 
 	var scBits [fieldparams.SyncAggregateSyncCommitteeBytesLength]byte
-	blk := &ethpb.SignedBeaconBlockElectra{
-		Block: &ethpb.BeaconBlockElectra{
-			Slot:       electraSlot + 1,
-			ParentRoot: parentRoot[:],
-			StateRoot:  genesis.Block.StateRoot,
-			Body: &ethpb.BeaconBlockBodyElectra{
-				RandaoReveal:  genesis.Block.Body.RandaoReveal,
-				Graffiti:      genesis.Block.Body.Graffiti,
-				Eth1Data:      genesis.Block.Body.Eth1Data,
-				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
-				ExecutionPayload: &enginev1.ExecutionPayloadElectra{
-					ParentHash:    make([]byte, fieldparams.RootLength),
-					FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
-					StateRoot:     make([]byte, fieldparams.RootLength),
-					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
-					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-					PrevRandao:    make([]byte, fieldparams.RootLength),
-					BaseFeePerGas: make([]byte, fieldparams.RootLength),
-					BlockHash:     make([]byte, fieldparams.RootLength),
-				},
-			},
-		},
-	}
-
-	blkRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
-	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
-
-	random, err := helpers.RandaoMix(beaconState, slots.ToEpoch(beaconState.Slot()))
-	require.NoError(t, err)
-	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), electraSlot+1)
-	require.NoError(t, err)
 	dr := []*enginev1.DepositRequest{{
 		Pubkey:                bytesutil.PadTo(privKeys[0].PublicKey().Marshal(), 48),
 		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
@@ -641,21 +607,56 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 			TargetPubkey:  bytesutil.PadTo(privKeys[2].PublicKey().Marshal(), 48),
 		},
 	}
-	payload := &enginev1.ExecutionPayloadElectra{
-		Timestamp:             uint64(timeStamp.Unix()),
-		ParentHash:            make([]byte, fieldparams.RootLength),
-		FeeRecipient:          make([]byte, fieldparams.FeeRecipientLength),
-		StateRoot:             make([]byte, fieldparams.RootLength),
-		ReceiptsRoot:          make([]byte, fieldparams.RootLength),
-		LogsBloom:             make([]byte, fieldparams.LogsBloomLength),
-		PrevRandao:            random,
-		BaseFeePerGas:         make([]byte, fieldparams.RootLength),
-		BlockHash:             make([]byte, fieldparams.RootLength),
-		DepositRequests:       dr,
-		WithdrawalRequests:    wr,
-		ConsolidationRequests: cr,
+	blk := &ethpb.SignedBeaconBlockElectra{
+		Block: &ethpb.BeaconBlockElectra{
+			Slot:       electraSlot + 1,
+			ParentRoot: parentRoot[:],
+			StateRoot:  genesis.Block.StateRoot,
+			Body: &ethpb.BeaconBlockBodyElectra{
+				RandaoReveal:  genesis.Block.Body.RandaoReveal,
+				Graffiti:      genesis.Block.Body.Graffiti,
+				Eth1Data:      genesis.Block.Body.Eth1Data,
+				SyncAggregate: &ethpb.SyncAggregate{SyncCommitteeBits: scBits[:], SyncCommitteeSignature: make([]byte, 96)},
+				ExecutionPayload: &enginev1.ExecutionPayloadElectra{
+					ParentHash:    make([]byte, fieldparams.RootLength),
+					FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+					StateRoot:     make([]byte, fieldparams.RootLength),
+					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+					PrevRandao:    make([]byte, fieldparams.RootLength),
+					BaseFeePerGas: make([]byte, fieldparams.RootLength),
+					BlockHash:     make([]byte, fieldparams.RootLength),
+				},
+				ExecutionRequests: &enginev1.ExecutionRequests{
+					Withdrawals:    wr,
+					Deposits:       dr,
+					Consolidations: cr,
+				},
+			},
+		},
 	}
 
+	blkRoot, err := blk.Block.HashTreeRoot()
+	require.NoError(t, err)
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, db.SaveState(ctx, beaconState, blkRoot), "Could not save genesis state")
+	require.NoError(t, db.SaveHeadBlockRoot(ctx, blkRoot), "Could not save genesis state")
+
+	random, err := helpers.RandaoMix(beaconState, slots.ToEpoch(beaconState.Slot()))
+	require.NoError(t, err)
+	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), electraSlot+1)
+	require.NoError(t, err)
+	payload := &enginev1.ExecutionPayloadElectra{
+		Timestamp:     uint64(timeStamp.Unix()),
+		ParentHash:    make([]byte, fieldparams.RootLength),
+		FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+		StateRoot:     make([]byte, fieldparams.RootLength),
+		ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+		LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+		PrevRandao:    random,
+		BaseFeePerGas: make([]byte, fieldparams.RootLength),
+		BlockHash:     make([]byte, fieldparams.RootLength),
+	}
 	proposerServer := getProposerServer(db, beaconState, parentRoot[:])
 	ed, err := blocks.NewWrappedExecutionData(payload)
 	require.NoError(t, err)
@@ -675,11 +676,8 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 		Graffiti:     graffiti[:],
 	}
 
-	got, err := proposerServer.GetBeaconBlock(ctx, req)
+	_, err = proposerServer.GetBeaconBlock(ctx, req)
 	require.NoError(t, err)
-	p := got.GetElectra().Block.Body.ExecutionPayload
-	require.DeepEqual(t, dr, p.DepositRequests)
-	require.DeepEqual(t, wr, p.WithdrawalRequests)
 }
 
 func TestServer_GetBeaconBlock_Optimistic(t *testing.T) {

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

@@ -55,7 +55,6 @@ type BeaconState struct {
 	latestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader
 	latestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella
 	latestExecutionPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb
-	latestExecutionPayloadHeaderElectra *enginev1.ExecutionPayloadHeaderElectra
 	nextWithdrawalIndex                 uint64
 	nextWithdrawalValidatorIndex        primitives.ValidatorIndex
 
@@ -114,7 +113,6 @@ type beaconStateMarshalable struct {
 	LatestExecutionPayloadHeader        *enginev1.ExecutionPayloadHeader        `json:"latest_execution_payload_header" yaml:"latest_execution_payload_header"`
 	LatestExecutionPayloadHeaderCapella *enginev1.ExecutionPayloadHeaderCapella `json:"latest_execution_payload_header_capella" yaml:"latest_execution_payload_header_capella"`
 	LatestExecutionPayloadHeaderDeneb   *enginev1.ExecutionPayloadHeaderDeneb   `json:"latest_execution_payload_header_deneb" yaml:"latest_execution_payload_header_deneb"`
-	LatestExecutionPayloadHeaderElectra *enginev1.ExecutionPayloadHeaderElectra `json:"latest_execution_payload_header_electra" yaml:"latest_execution_payload_header_electra"`
 	NextWithdrawalIndex                 uint64                                  `json:"next_withdrawal_index" yaml:"next_withdrawal_index"`
 	NextWithdrawalValidatorIndex        primitives.ValidatorIndex               `json:"next_withdrawal_validator_index" yaml:"next_withdrawal_validator_index"`
 	DepositRequestsStartIndex           uint64                                  `json:"deposit_requests_start_index" yaml:"deposit_requests_start_index"`
@@ -184,7 +182,6 @@ func (b *BeaconState) MarshalJSON() ([]byte, error) {
 		LatestExecutionPayloadHeader:        b.latestExecutionPayloadHeader,
 		LatestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapella,
 		LatestExecutionPayloadHeaderDeneb:   b.latestExecutionPayloadHeaderDeneb,
-		LatestExecutionPayloadHeaderElectra: b.latestExecutionPayloadHeaderElectra,
 		NextWithdrawalIndex:                 b.nextWithdrawalIndex,
 		NextWithdrawalValidatorIndex:        b.nextWithdrawalValidatorIndex,
 		DepositRequestsStartIndex:           b.depositRequestsStartIndex,

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

@@ -22,10 +22,8 @@ func (b *BeaconState) LatestExecutionPayloadHeader() (interfaces.ExecutionData,
 		return blocks.WrappedExecutionPayloadHeader(b.latestExecutionPayloadHeader.Copy())
 	case version.Capella:
 		return blocks.WrappedExecutionPayloadHeaderCapella(b.latestExecutionPayloadHeaderCapella.Copy())
-	case version.Deneb:
+	case version.Deneb, version.Electra:
 		return blocks.WrappedExecutionPayloadHeaderDeneb(b.latestExecutionPayloadHeaderDeneb.Copy())
-	case version.Electra:
-		return blocks.WrappedExecutionPayloadHeaderElectra(b.latestExecutionPayloadHeaderElectra.Copy())
 	default:
 		return nil, fmt.Errorf("unsupported version (%s) for latest execution payload header", version.String(b.version))
 	}

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

@@ -198,7 +198,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			InactivityScores:              b.inactivityScoresVal(),
 			CurrentSyncCommittee:          b.currentSyncCommittee,
 			NextSyncCommittee:             b.nextSyncCommittee,
-			LatestExecutionPayloadHeader:  b.latestExecutionPayloadHeaderElectra,
+			LatestExecutionPayloadHeader:  b.latestExecutionPayloadHeaderDeneb,
 			NextWithdrawalIndex:           b.nextWithdrawalIndex,
 			NextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
 			HistoricalSummaries:           b.historicalSummaries,
@@ -404,7 +404,7 @@ func (b *BeaconState) ToProto() interface{} {
 			InactivityScores:              b.inactivityScoresVal(),
 			CurrentSyncCommittee:          b.currentSyncCommitteeVal(),
 			NextSyncCommittee:             b.nextSyncCommitteeVal(),
-			LatestExecutionPayloadHeader:  b.latestExecutionPayloadHeaderElectra.Copy(),
+			LatestExecutionPayloadHeader:  b.latestExecutionPayloadHeaderDeneb.Copy(),
 			NextWithdrawalIndex:           b.nextWithdrawalIndex,
 			NextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
 			HistoricalSummaries:           b.historicalSummariesVal(),

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

@@ -243,7 +243,7 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		fieldRoots[types.LatestExecutionPayloadHeaderCapella.RealPosition()] = executionPayloadRoot[:]
 	}
 
-	if state.version == version.Deneb {
+	if state.version >= version.Deneb {
 		// Execution payload root.
 		executionPayloadRoot, err := state.latestExecutionPayloadHeaderDeneb.HashTreeRoot()
 		if err != nil {
@@ -252,15 +252,6 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 		fieldRoots[types.LatestExecutionPayloadHeaderDeneb.RealPosition()] = executionPayloadRoot[:]
 	}
 
-	if state.version == version.Electra {
-		// Execution payload root.
-		executionPayloadRoot, err := state.latestExecutionPayloadHeaderElectra.HashTreeRoot()
-		if err != nil {
-			return nil, err
-		}
-		fieldRoots[types.LatestExecutionPayloadHeaderElectra.RealPosition()] = executionPayloadRoot[:]
-	}
-
 	if state.version >= version.Capella {
 		// Next withdrawal index root.
 		nextWithdrawalIndexRoot := make([]byte, 32)

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

@@ -45,7 +45,7 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderCapella)
 		return nil
 	case *enginev1.ExecutionPayloadDeneb:
-		if b.version != version.Deneb {
+		if b.version != version.Deneb && b.version != version.Electra {
 			return fmt.Errorf("wrong state version (%s) for deneb execution payload", version.String(b.version))
 		}
 		latest, err := consensusblocks.PayloadToHeaderDeneb(val)
@@ -55,21 +55,6 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.latestExecutionPayloadHeaderDeneb = latest
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderDeneb)
 		return nil
-	case *enginev1.ExecutionPayloadElectra:
-		if b.version != version.Electra {
-			return fmt.Errorf("wrong state version (%s) for electra execution payload", version.String(b.version))
-		}
-		eVal, ok := val.(interfaces.ExecutionDataElectra)
-		if !ok {
-			return fmt.Errorf("could not cast %T to ExecutionDataElectra: %w", val, interfaces.ErrInvalidCast)
-		}
-		latest, err := consensusblocks.PayloadToHeaderElectra(eVal)
-		if err != nil {
-			return errors.Wrap(err, "could not convert payload to header")
-		}
-		b.latestExecutionPayloadHeaderElectra = latest
-		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderElectra)
-		return nil
 	case *enginev1.ExecutionPayloadHeader:
 		if b.version != version.Bellatrix {
 			return fmt.Errorf("wrong state version (%s) for bellatrix execution payload header", version.String(b.version))
@@ -85,19 +70,12 @@ func (b *BeaconState) SetLatestExecutionPayloadHeader(val interfaces.ExecutionDa
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderCapella)
 		return nil
 	case *enginev1.ExecutionPayloadHeaderDeneb:
-		if b.version != version.Deneb {
+		if b.version != version.Deneb && b.version != version.Electra {
 			return fmt.Errorf("wrong state version (%s) for deneb execution payload header", version.String(b.version))
 		}
 		b.latestExecutionPayloadHeaderDeneb = header
 		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderDeneb)
 		return nil
-	case *enginev1.ExecutionPayloadHeaderElectra:
-		if b.version != version.Electra {
-			return fmt.Errorf("wrong state version (%s) for electra execution payload header", version.String(b.version))
-		}
-		b.latestExecutionPayloadHeaderElectra = header
-		b.markFieldAsDirty(types.LatestExecutionPayloadHeaderElectra)
-		return nil
 	default:
 		return errors.New("value must be an execution payload header")
 	}

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

@@ -62,7 +62,7 @@ func TestSetLatestExecutionPayloadHeader(t *testing.T) {
 		}(),
 		func() interfaces.ExecutionData {
 			e := util.NewBlindedBeaconBlockElectra().Message.Body.ExecutionPayloadHeader
-			ee, err := blocks.WrappedExecutionPayloadHeaderElectra(e)
+			ee, err := blocks.WrappedExecutionPayloadHeaderDeneb(e)
 			require.NoError(t, err)
 			return ee
 		}(),
@@ -93,6 +93,13 @@ func TestSetLatestExecutionPayloadHeader(t *testing.T) {
 				if i == j {
 					continue
 				}
+				// Skip Deneb-Electra combinations
+				if i == len(payloads)-1 && j == len(payloads)-2 {
+					continue
+				}
+				if i == len(payloads)-2 && j == len(payloads)-1 {
+					continue
+				}
 				t.Run(fmt.Sprintf("%s state with %s payload", version.String(i+versionOffset), version.String(j+versionOffset)), func(t *testing.T) {
 					s := state_native.EmptyStateFromVersion(t, i+versionOffset)
 					p := payloads[j]

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

@@ -99,7 +99,7 @@ var electraFields = append(
 	types.NextWithdrawalIndex,
 	types.NextWithdrawalValidatorIndex,
 	types.HistoricalSummaries,
-	types.LatestExecutionPayloadHeaderElectra,
+	types.LatestExecutionPayloadHeaderDeneb,
 	types.DepositRequestsStartIndex,
 	types.DepositBalanceToConsume,
 	types.ExitBalanceToConsume,
@@ -726,38 +726,38 @@ func InitializeFromProtoUnsafeElectra(st *ethpb.BeaconStateElectra) (state.Beaco
 
 	fieldCount := params.BeaconConfig().BeaconStateElectraFieldCount
 	b := &BeaconState{
-		version:                             version.Electra,
-		genesisTime:                         st.GenesisTime,
-		genesisValidatorsRoot:               bytesutil.ToBytes32(st.GenesisValidatorsRoot),
-		slot:                                st.Slot,
-		fork:                                st.Fork,
-		latestBlockHeader:                   st.LatestBlockHeader,
-		historicalRoots:                     hRoots,
-		eth1Data:                            st.Eth1Data,
-		eth1DataVotes:                       st.Eth1DataVotes,
-		eth1DepositIndex:                    st.Eth1DepositIndex,
-		slashings:                           st.Slashings,
-		previousEpochParticipation:          st.PreviousEpochParticipation,
-		currentEpochParticipation:           st.CurrentEpochParticipation,
-		justificationBits:                   st.JustificationBits,
-		previousJustifiedCheckpoint:         st.PreviousJustifiedCheckpoint,
-		currentJustifiedCheckpoint:          st.CurrentJustifiedCheckpoint,
-		finalizedCheckpoint:                 st.FinalizedCheckpoint,
-		currentSyncCommittee:                st.CurrentSyncCommittee,
-		nextSyncCommittee:                   st.NextSyncCommittee,
-		latestExecutionPayloadHeaderElectra: st.LatestExecutionPayloadHeader,
-		nextWithdrawalIndex:                 st.NextWithdrawalIndex,
-		nextWithdrawalValidatorIndex:        st.NextWithdrawalValidatorIndex,
-		historicalSummaries:                 st.HistoricalSummaries,
-		depositRequestsStartIndex:           st.DepositRequestsStartIndex,
-		depositBalanceToConsume:             st.DepositBalanceToConsume,
-		exitBalanceToConsume:                st.ExitBalanceToConsume,
-		earliestExitEpoch:                   st.EarliestExitEpoch,
-		consolidationBalanceToConsume:       st.ConsolidationBalanceToConsume,
-		earliestConsolidationEpoch:          st.EarliestConsolidationEpoch,
-		pendingBalanceDeposits:              st.PendingBalanceDeposits,
-		pendingPartialWithdrawals:           st.PendingPartialWithdrawals,
-		pendingConsolidations:               st.PendingConsolidations,
+		version:                           version.Electra,
+		genesisTime:                       st.GenesisTime,
+		genesisValidatorsRoot:             bytesutil.ToBytes32(st.GenesisValidatorsRoot),
+		slot:                              st.Slot,
+		fork:                              st.Fork,
+		latestBlockHeader:                 st.LatestBlockHeader,
+		historicalRoots:                   hRoots,
+		eth1Data:                          st.Eth1Data,
+		eth1DataVotes:                     st.Eth1DataVotes,
+		eth1DepositIndex:                  st.Eth1DepositIndex,
+		slashings:                         st.Slashings,
+		previousEpochParticipation:        st.PreviousEpochParticipation,
+		currentEpochParticipation:         st.CurrentEpochParticipation,
+		justificationBits:                 st.JustificationBits,
+		previousJustifiedCheckpoint:       st.PreviousJustifiedCheckpoint,
+		currentJustifiedCheckpoint:        st.CurrentJustifiedCheckpoint,
+		finalizedCheckpoint:               st.FinalizedCheckpoint,
+		currentSyncCommittee:              st.CurrentSyncCommittee,
+		nextSyncCommittee:                 st.NextSyncCommittee,
+		latestExecutionPayloadHeaderDeneb: st.LatestExecutionPayloadHeader,
+		nextWithdrawalIndex:               st.NextWithdrawalIndex,
+		nextWithdrawalValidatorIndex:      st.NextWithdrawalValidatorIndex,
+		historicalSummaries:               st.HistoricalSummaries,
+		depositRequestsStartIndex:         st.DepositRequestsStartIndex,
+		depositBalanceToConsume:           st.DepositBalanceToConsume,
+		exitBalanceToConsume:              st.ExitBalanceToConsume,
+		earliestExitEpoch:                 st.EarliestExitEpoch,
+		consolidationBalanceToConsume:     st.ConsolidationBalanceToConsume,
+		earliestConsolidationEpoch:        st.EarliestConsolidationEpoch,
+		pendingBalanceDeposits:            st.PendingBalanceDeposits,
+		pendingPartialWithdrawals:         st.PendingPartialWithdrawals,
+		pendingConsolidations:             st.PendingConsolidations,
 
 		dirtyFields:         make(map[types.FieldIndex]bool, fieldCount),
 		dirtyIndices:        make(map[types.FieldIndex][]uint64, fieldCount),
@@ -818,11 +818,11 @@ func InitializeFromProtoUnsafeElectra(st *ethpb.BeaconStateElectra) (state.Beaco
 	b.sharedFieldReferences[types.Slashings] = stateutil.NewRef(1)
 	b.sharedFieldReferences[types.PreviousEpochParticipationBits] = stateutil.NewRef(1)
 	b.sharedFieldReferences[types.CurrentEpochParticipationBits] = stateutil.NewRef(1)
-	b.sharedFieldReferences[types.LatestExecutionPayloadHeaderElectra] = stateutil.NewRef(1) // New in Electra.
-	b.sharedFieldReferences[types.HistoricalSummaries] = stateutil.NewRef(1)                 // New in Capella.
-	b.sharedFieldReferences[types.PendingBalanceDeposits] = stateutil.NewRef(1)              // New in Electra.
-	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)           // New in Electra.
-	b.sharedFieldReferences[types.PendingConsolidations] = stateutil.NewRef(1)               // New in Electra.
+	b.sharedFieldReferences[types.LatestExecutionPayloadHeaderDeneb] = stateutil.NewRef(1) // New in Electra.
+	b.sharedFieldReferences[types.HistoricalSummaries] = stateutil.NewRef(1)               // New in Capella.
+	b.sharedFieldReferences[types.PendingBalanceDeposits] = stateutil.NewRef(1)            // New in Electra.
+	b.sharedFieldReferences[types.PendingPartialWithdrawals] = stateutil.NewRef(1)         // New in Electra.
+	b.sharedFieldReferences[types.PendingConsolidations] = stateutil.NewRef(1)             // New in Electra.
 	if !features.Get().EnableExperimentalState {
 		b.sharedFieldReferences[types.BlockRoots] = stateutil.NewRef(1)
 		b.sharedFieldReferences[types.StateRoots] = stateutil.NewRef(1)
@@ -916,7 +916,6 @@ func (b *BeaconState) Copy() state.BeaconState {
 		latestExecutionPayloadHeader:        b.latestExecutionPayloadHeader.Copy(),
 		latestExecutionPayloadHeaderCapella: b.latestExecutionPayloadHeaderCapella.Copy(),
 		latestExecutionPayloadHeaderDeneb:   b.latestExecutionPayloadHeaderDeneb.Copy(),
-		latestExecutionPayloadHeaderElectra: b.latestExecutionPayloadHeaderElectra.Copy(),
 
 		id: types.Enumerator.Inc(),
 
@@ -1284,8 +1283,6 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return b.latestExecutionPayloadHeaderCapella.HashTreeRoot()
 	case types.LatestExecutionPayloadHeaderDeneb:
 		return b.latestExecutionPayloadHeaderDeneb.HashTreeRoot()
-	case types.LatestExecutionPayloadHeaderElectra:
-		return b.latestExecutionPayloadHeaderElectra.HashTreeRoot()
 	case types.NextWithdrawalIndex:
 		return ssz.Uint64Root(b.nextWithdrawalIndex), nil
 	case types.NextWithdrawalValidatorIndex:

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

@@ -88,8 +88,6 @@ func (f FieldIndex) String() string {
 		return "latestExecutionPayloadHeaderCapella"
 	case LatestExecutionPayloadHeaderDeneb:
 		return "latestExecutionPayloadHeaderDeneb"
-	case LatestExecutionPayloadHeaderElectra:
-		return "latestExecutionPayloadHeaderElectra"
 	case NextWithdrawalIndex:
 		return "nextWithdrawalIndex"
 	case NextWithdrawalValidatorIndex:
@@ -171,7 +169,7 @@ func (f FieldIndex) RealPosition() int {
 		return 22
 	case NextSyncCommittee:
 		return 23
-	case LatestExecutionPayloadHeader, LatestExecutionPayloadHeaderCapella, LatestExecutionPayloadHeaderDeneb, LatestExecutionPayloadHeaderElectra:
+	case LatestExecutionPayloadHeader, LatestExecutionPayloadHeaderCapella, LatestExecutionPayloadHeaderDeneb:
 		return 24
 	case NextWithdrawalIndex:
 		return 25
@@ -249,7 +247,6 @@ const (
 	LatestExecutionPayloadHeader
 	LatestExecutionPayloadHeaderCapella
 	LatestExecutionPayloadHeaderDeneb
-	LatestExecutionPayloadHeaderElectra
 	NextWithdrawalIndex
 	NextWithdrawalValidatorIndex
 	HistoricalSummaries

beacon-chain/sync/decode_pubsub_test.go

@@ -269,7 +269,7 @@ func TestExtractDataType(t *testing.T) {
 				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
 			},
 			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
-				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadElectra{}}}})
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}})
 				require.NoError(t, err)
 				return wsb
 			}(),

beacon-chain/sync/rpc_beacon_blocks_by_range_test.go

@@ -433,11 +433,12 @@ func TestRPCBeaconBlocksByRange_RPCHandlerRateLimitOverflow(t *testing.T) {
 	}
 	sendRequest := func(p1, p2 *p2ptest.TestP2P, r *Service,
 		req *ethpb.BeaconBlocksByRangeRequest, validateBlocks bool, success bool) error {
-		var wg sync.WaitGroup
-		wg.Add(1)
 		pcl := protocol.ID(p2p.RPCBlocksByRangeTopicV1)
+		reqAnswered := false
 		p2.BHost.SetStreamHandler(pcl, func(stream network.Stream) {
-			defer wg.Done()
+			defer func() {
+				reqAnswered = true
+			}()
 			if !validateBlocks {
 				return
 			}
@@ -458,9 +459,8 @@ func TestRPCBeaconBlocksByRange_RPCHandlerRateLimitOverflow(t *testing.T) {
 		if err := r.beaconBlocksByRangeRPCHandler(context.Background(), req, stream); err != nil {
 			return err
 		}
-		if util.WaitTimeout(&wg, 1*time.Second) {
-			t.Fatal("Did not receive stream within 1 sec")
-		}
+		time.Sleep(100 * time.Millisecond)
+		assert.Equal(t, reqAnswered, true)
 		return nil
 	}
 

config/features/config.go

@@ -48,7 +48,7 @@ type Flags struct {
 	EnableDoppelGanger                  bool // EnableDoppelGanger enables doppelganger protection on startup for the validator.
 	EnableHistoricalSpaceRepresentation bool // EnableHistoricalSpaceRepresentation enables the saving of registry validators in separate buckets to save space
 	EnableBeaconRESTApi                 bool // EnableBeaconRESTApi enables experimental usage of the beacon REST API by the validator when querying a beacon node
-	EnableCommitteeAwarePacking         bool // EnableCommitteeAwarePacking TODO
+	DisableCommitteeAwarePacking        bool // DisableCommitteeAwarePacking changes the attestation packing algorithm to one that is not aware of attesting committees.
 	// Logging related toggles.
 	DisableGRPCConnectionLogs bool // Disables logging when a new grpc client has connected.
 	EnableFullSSZDataLogging  bool // Enables logging for full ssz data on rejected gossip messages
@@ -256,9 +256,9 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		logEnabled(EnableQUIC)
 		cfg.EnableQUIC = true
 	}
-	if ctx.IsSet(EnableCommitteeAwarePacking.Name) {
-		logEnabled(EnableCommitteeAwarePacking)
-		cfg.EnableCommitteeAwarePacking = true
+	if ctx.IsSet(DisableCommitteeAwarePacking.Name) {
+		logEnabled(DisableCommitteeAwarePacking)
+		cfg.DisableCommitteeAwarePacking = true
 	}
 
 	cfg.AggregateIntervals = [3]time.Duration{aggregateFirstInterval.Value, aggregateSecondInterval.Value, aggregateThirdInterval.Value}

config/features/deprecated_flags.go

@@ -77,6 +77,12 @@ var (
 		Usage:  deprecatedUsage,
 		Hidden: true,
 	}
+
+	deprecatedEnableCommitteeAwarePacking = &cli.BoolFlag{
+		Name:   "enable-committee-aware-packing",
+		Usage:  deprecatedUsage,
+		Hidden: true,
+	}
 )
 
 // Deprecated flags for both the beacon node and validator client.
@@ -94,6 +100,7 @@ var deprecatedFlags = []cli.Flag{
 	deprecatedBeaconRPCGatewayProviderFlag,
 	deprecatedDisableGRPCGateway,
 	deprecatedEnableExperimentalState,
+	deprecatedEnableCommitteeAwarePacking,
 }
 
 // deprecatedBeaconFlags contains flags that are still used by other components

config/features/flags.go

@@ -166,9 +166,9 @@ var (
 		Name:  "enable-quic",
 		Usage: "Enables connection using the QUIC protocol for peers which support it.",
 	}
-	EnableCommitteeAwarePacking = &cli.BoolFlag{
-		Name:  "enable-committee-aware-packing",
-		Usage: "Changes the attestation packing algorithm to one that is aware of attesting committees.",
+	DisableCommitteeAwarePacking = &cli.BoolFlag{
+		Name:  "disable-committee-aware-packing",
+		Usage: "Changes the attestation packing algorithm to one that is not aware of attesting committees.",
 	}
 )
 
@@ -226,7 +226,7 @@ var BeaconChainFlags = append(deprecatedBeaconFlags, append(deprecatedFlags, []c
 	EnableLightClient,
 	BlobSaveFsync,
 	EnableQUIC,
-	EnableCommitteeAwarePacking,
+	DisableCommitteeAwarePacking,
 }...)...)
 
 // E2EBeaconChainFlags contains a list of the beacon chain feature flags to be tested in E2E.

config/fieldparams/mainnet.go

@@ -33,7 +33,10 @@ const (
 	BlobSize                              = 131072        // defined to match blob.size in bazel ssz codegen
 	BlobSidecarSize                       = 131928        // defined to match blob sidecar size in bazel ssz codegen
 	KzgCommitmentInclusionProofDepth      = 17            // Merkle proof depth for blob_kzg_commitments list item
-	NextSyncCommitteeBranchDepth          = 5             // NextSyncCommitteeBranchDepth defines the depth of the next sync committee branch.
+	ExecutionBranchDepth                  = 4             // ExecutionBranchDepth defines the number of leaves in a merkle proof of the execution payload header.
+	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
+	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
+	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
 	PendingBalanceDepositsLimit           = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 134217728     // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 262144        // Maximum number of pending consolidations in the beacon state.

config/fieldparams/minimal.go

@@ -33,7 +33,10 @@ const (
 	BlobSize                              = 131072        // defined to match blob.size in bazel ssz codegen
 	BlobSidecarSize                       = 131928        // defined to match blob sidecar size in bazel ssz codegen
 	KzgCommitmentInclusionProofDepth      = 17            // Merkle proof depth for blob_kzg_commitments list item
-	NextSyncCommitteeBranchDepth          = 5             // NextSyncCommitteeBranchDepth defines the depth of the next sync committee branch.
+	ExecutionBranchDepth                  = 4             // ExecutionBranchDepth defines the number of leaves in a merkle proof of the execution payload header.
+	SyncCommitteeBranchDepth              = 5             // SyncCommitteeBranchDepth defines the number of leaves in a merkle proof of a sync committee.
+	SyncCommitteeBranchDepthElectra       = 6             // SyncCommitteeBranchDepthElectra defines the number of leaves in a merkle proof of a sync committee.
+	FinalityBranchDepth                   = 6             // FinalityBranchDepth defines the number of leaves in a merkle proof of the finalized checkpoint root.
 	PendingBalanceDepositsLimit           = 134217728     // Maximum number of pending balance deposits in the beacon state.
 	PendingPartialWithdrawalsLimit        = 64            // Maximum number of pending partial withdrawals in the beacon state.
 	PendingConsolidationsLimit            = 64            // Maximum number of pending consolidations in the beacon state.

config/params/BUILD.bazel

@@ -49,6 +49,7 @@ go_test(
         "mainnet_config_test.go",
         "testnet_config_test.go",
         "testnet_holesky_config_test.go",
+        "testnet_sepolia_config_test.go",
     ],
     data = glob(["*.yaml"]) + [
         "testdata/e2e_config.yaml",
@@ -57,6 +58,7 @@ go_test(
         "@consensus_spec_tests_minimal//:test_data",
         "@eth2_networks//:configs",
         "@holesky_testnet//:configs",
+        "@sepolia_testnet//:configs",
     ],
     embed = [":go_default_library"],
     gotags = ["develop"],

config/params/loader_test.go

@@ -40,6 +40,7 @@ var placeholderFields = []string{
 	"MAX_BLOB_COMMITMENTS_PER_BLOCK", // Compile time constant on BeaconBlockBodyDeneb.blob_kzg_commitments.
 	"MAX_BYTES_PER_TRANSACTION",      // Used for ssz of EL transactions. Unused in Prysm.
 	"MAX_EXTRA_DATA_BYTES",           // Compile time constant on ExecutionPayload.extra_data.
+	"MAX_REQUEST_PAYLOADS",           // Compile time constant on BeaconBlockBody.ExecutionRequests
 	"MAX_TRANSACTIONS_PER_PAYLOAD",   // Compile time constant on ExecutionPayload.transactions.
 	"REORG_HEAD_WEIGHT_THRESHOLD",
 	"SAMPLES_PER_SLOT",

config/params/testnet_sepolia_config.go

@@ -11,11 +11,15 @@ func UseSepoliaNetworkConfig() {
 	cfg := BeaconNetworkConfig().Copy()
 	cfg.ContractDeploymentBlock = 1273020
 	cfg.BootstrapNodes = []string{
-		// EF boot nodes
+		"enr:-Ku4QDZ_rCowZFsozeWr60WwLgOfHzv1Fz2cuMvJqN5iJzLxKtVjoIURY42X_YTokMi3IGstW5v32uSYZyGUXj9Q_IECh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIpEe5iJc2VjcDI1NmsxoQNHTpFdaNSCEWiN_QqT396nb0PzcUpLe3OVtLph-AciBYN1ZHCCIy0",
+		"enr:-Ku4QHRyRwEPT7s0XLYzJ_EeeWvZTXBQb4UCGy1F_3m-YtCNTtDlGsCMr4UTgo4uR89pv11uM-xq4w6GKfKhqU31hTgCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIrFM7WJc2VjcDI1NmsxoQI4diTwChN3zAAkarf7smOHCdFb1q3DSwdiQ_Lc_FdzFIN1ZHCCIy0",
+		"enr:-Ku4QOkvvf0u5Hg4-HhY-SJmEyft77G5h3rUM8VF_e-Hag5cAma3jtmFoX4WElLAqdILCA-UWFRN1ZCDJJVuEHrFeLkDh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhJK-AWeJc2VjcDI1NmsxoQLFcT5VE_NMiIC8Ll7GypWDnQ4UEmuzD7hF_Hf4veDJwIN1ZHCCIy0",
+		"enr:-Ku4QH6tYsHKITYeHUu5kdfXgEZWI18EWk_2RtGOn1jBPlx2UlS_uF3Pm5Dx7tnjOvla_zs-wwlPgjnEOcQDWXey51QCh2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhIs7Mc6Jc2VjcDI1NmsxoQIET4Mlv9YzhrYhX_H9D7aWMemUrvki6W4J2Qo0YmFMp4N1ZHCCIy0",
+		"enr:-Ku4QDmz-4c1InchGitsgNk4qzorWMiFUoaPJT4G0IiF8r2UaevrekND1o7fdoftNucirj7sFFTTn2-JdC2Ej0p1Mn8Ch2F0dG5ldHOIAAAAAAAAAACEZXRoMpCo_ujukAAAaf__________gmlkgnY0gmlwhKpA-liJc2VjcDI1NmsxoQMpHP5U1DK8O_JQU6FadmWbE42qEdcGlllR8HcSkkfWq4N1ZHCCIy0",
+		"enr:-KO4QP7MmB3juk8rUjJHcUoxZDU9Np4FlW0HyDEGIjSO7GD9PbSsabu7713cWSUWKDkxIypIXg1A-6lG7ySRGOMZHeGCAmuEZXRoMpDTH2GRkAAAc___________gmlkgnY0gmlwhBSoyGOJc2VjcDI1NmsxoQNta5b_bexSSwwrGW2Re24MjfMntzFd0f2SAxQtMj3ueYN0Y3CCIyiDdWRwgiMo",
+		"enr:-KG4QJejf8KVtMeAPWFhN_P0c4efuwu1pZHELTveiXUeim6nKYcYcMIQpGxxdgT2Xp9h-M5pr9gn2NbbwEAtxzu50Y8BgmlkgnY0gmlwhEEVkQCDaXA2kCoBBPnAEJg4AAAAAAAAAAGJc2VjcDI1NmsxoQLEh_eVvk07AQABvLkTGBQTrrIOQkzouMgSBtNHIRUxOIN1ZHCCIyiEdWRwNoIjKA",
 		"enr:-Iq4QMCTfIMXnow27baRUb35Q8iiFHSIDBJh6hQM5Axohhf4b6Kr_cOCu0htQ5WvVqKvFgY28893DHAg8gnBAXsAVqmGAX53x8JggmlkgnY0gmlwhLKAlv6Jc2VjcDI1NmsxoQK6S-Cii_KmfFdUJL2TANL3ksaKUnNXvTCv1tLwXs0QgIN1ZHCCIyk",
-		"enr:-KG4QE5OIg5ThTjkzrlVF32WT_-XT14WeJtIz2zoTqLLjQhYAmJlnk4ItSoH41_2x0RX0wTFIe5GgjRzU2u7Q1fN4vADhGV0aDKQqP7o7pAAAHAyAAAAAAAAAIJpZIJ2NIJpcISlFsStiXNlY3AyNTZrMaEC-Rrd_bBZwhKpXzFCrStKp1q_HmGOewxY3KwM8ofAj_ODdGNwgiMog3VkcIIjKA",
-		// Teku boot node
-		"enr:-Ly4QFoZTWR8ulxGVsWydTNGdwEESueIdj-wB6UmmjUcm-AOPxnQi7wprzwcdo7-1jBW_JxELlUKJdJES8TDsbl1EdNlh2F0dG5ldHOI__78_v2bsV-EZXRoMpA2-lATkAAAcf__________gmlkgnY0gmlwhBLYJjGJc2VjcDI1NmsxoQI0gujXac9rMAb48NtMqtSTyHIeNYlpjkbYpWJw46PmYYhzeW5jbmV0cw-DdGNwgiMog3VkcIIjKA",
+		"enr:-L64QC9Hhov4DhQ7mRukTOz4_jHm4DHlGL726NWH4ojH1wFgEwSin_6H95Gs6nW2fktTWbPachHJ6rUFu0iJNgA0SB2CARqHYXR0bmV0c4j__________4RldGgykDb6UBOQAABx__________-CaWSCdjSCaXCEA-2vzolzZWNwMjU2azGhA17lsUg60R776rauYMdrAz383UUgESoaHEzMkvm4K6k6iHN5bmNuZXRzD4N0Y3CCIyiDdWRwgiMo",
 	}
 	OverrideBeaconNetworkConfig(cfg)
 }

config/params/testnet_sepolia_config_test.go

@@ -0,0 +1,28 @@
+package params_test
+
+import (
+	"path"
+	"testing"
+
+	"github.com/bazelbuild/rules_go/go/tools/bazel"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestSepoliaConfigMatchesUpstreamYaml(t *testing.T) {
+	presetFPs := presetsFilePath(t, "mainnet")
+	mn, err := params.ByName(params.MainnetName)
+	require.NoError(t, err)
+	cfg := mn.Copy()
+	for _, fp := range presetFPs {
+		cfg, err = params.UnmarshalConfigFile(fp, cfg)
+		require.NoError(t, err)
+	}
+	fPath, err := bazel.Runfile("external/sepolia_testnet")
+	require.NoError(t, err)
+	configFP := path.Join(fPath, "metadata", "config.yaml")
+	pcfg, err := params.UnmarshalConfigFile(configFP, nil)
+	require.NoError(t, err)
+	fields := fieldsFromYamls(t, append(presetFPs, configFP))
+	assertYamlFieldsMatch(t, "sepolia", fields, pcfg, params.SepoliaConfig())
+}

consensus-types/blocks/execution.go

@@ -14,8 +14,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-var _ interfaces.ExecutionDataElectra = (*executionPayloadElectra)(nil)
-
 // executionPayload is a convenience wrapper around a beacon block body's execution payload data structure
 // This wrapper allows us to conform to a common interface so that beacon
 // blocks for future forks can also be applied across Prysm without issues.
@@ -39,10 +37,6 @@ func NewWrappedExecutionData(v proto.Message) (interfaces.ExecutionData, error)
 		return WrappedExecutionPayloadDeneb(pbStruct)
 	case *enginev1.ExecutionPayloadDenebWithValueAndBlobsBundle:
 		return WrappedExecutionPayloadDeneb(pbStruct.Payload)
-	case *enginev1.ExecutionPayloadElectra:
-		return WrappedExecutionPayloadElectra(pbStruct)
-	case *enginev1.ExecutionPayloadElectraWithValueAndBlobsBundle:
-		return WrappedExecutionPayloadElectra(pbStruct.Payload)
 	default:
 		return nil, ErrUnsupportedVersion
 	}
@@ -787,74 +781,7 @@ func PayloadToHeaderDeneb(payload interfaces.ExecutionData) (*enginev1.Execution
 	}, nil
 }
 
-// PayloadToHeaderElectra converts `payload` into execution payload header format.
-func PayloadToHeaderElectra(payload interfaces.ExecutionDataElectra) (*enginev1.ExecutionPayloadHeaderElectra, error) {
-	txs, err := payload.Transactions()
-	if err != nil {
-		return nil, err
-	}
-	txRoot, err := ssz.TransactionsRoot(txs)
-	if err != nil {
-		return nil, err
-	}
-	withdrawals, err := payload.Withdrawals()
-	if err != nil {
-		return nil, err
-	}
-	withdrawalsRoot, err := ssz.WithdrawalSliceRoot(withdrawals, fieldparams.MaxWithdrawalsPerPayload)
-	if err != nil {
-		return nil, err
-	}
-	blobGasUsed, err := payload.BlobGasUsed()
-	if err != nil {
-		return nil, err
-	}
-	excessBlobGas, err := payload.ExcessBlobGas()
-	if err != nil {
-		return nil, err
-	}
-
-	depositRequests := payload.DepositRequests()
-	depositRequestsRoot, err := ssz.DepositRequestsSliceRoot(depositRequests, fieldparams.MaxDepositRequestsPerPayload)
-	if err != nil {
-		return nil, err
-	}
-
-	withdrawalRequests := payload.WithdrawalRequests()
-	withdrawalRequestsRoot, err := ssz.WithdrawalRequestsSliceRoot(withdrawalRequests, fieldparams.MaxWithdrawalRequestsPerPayload)
-	if err != nil {
-		return nil, err
-	}
-
-	consolidationRequests := payload.ConsolidationRequests()
-	consolidationRequestsRoot, err := ssz.ConsolidationRequestsSliceRoot(consolidationRequests, fieldparams.MaxConsolidationRequestsPerPayload)
-	if err != nil {
-		return nil, err
-	}
-
-	return &enginev1.ExecutionPayloadHeaderElectra{
-		ParentHash:                bytesutil.SafeCopyBytes(payload.ParentHash()),
-		FeeRecipient:              bytesutil.SafeCopyBytes(payload.FeeRecipient()),
-		StateRoot:                 bytesutil.SafeCopyBytes(payload.StateRoot()),
-		ReceiptsRoot:              bytesutil.SafeCopyBytes(payload.ReceiptsRoot()),
-		LogsBloom:                 bytesutil.SafeCopyBytes(payload.LogsBloom()),
-		PrevRandao:                bytesutil.SafeCopyBytes(payload.PrevRandao()),
-		BlockNumber:               payload.BlockNumber(),
-		GasLimit:                  payload.GasLimit(),
-		GasUsed:                   payload.GasUsed(),
-		Timestamp:                 payload.Timestamp(),
-		ExtraData:                 bytesutil.SafeCopyBytes(payload.ExtraData()),
-		BaseFeePerGas:             bytesutil.SafeCopyBytes(payload.BaseFeePerGas()),
-		BlockHash:                 bytesutil.SafeCopyBytes(payload.BlockHash()),
-		TransactionsRoot:          txRoot[:],
-		WithdrawalsRoot:           withdrawalsRoot[:],
-		BlobGasUsed:               blobGasUsed,
-		ExcessBlobGas:             excessBlobGas,
-		DepositRequestsRoot:       depositRequestsRoot[:],
-		WithdrawalRequestsRoot:    withdrawalRequestsRoot[:],
-		ConsolidationRequestsRoot: consolidationRequestsRoot[:],
-	}, nil
-}
+var PayloadToHeaderElectra = PayloadToHeaderDeneb
 
 // IsEmptyExecutionData checks if an execution data is empty underneath. If a single field has
 // a non-zero value, this function will return false.
@@ -913,20 +840,6 @@ func IsEmptyExecutionData(data interfaces.ExecutionData) (bool, error) {
 	if data.Timestamp() != 0 {
 		return false, nil
 	}
-
-	epe, postElectra := data.(interfaces.ExecutionDataElectra)
-	if postElectra {
-		drs := epe.DepositRequests()
-		if len(drs) != 0 {
-			return false, nil
-		}
-
-		wrs := epe.WithdrawalRequests()
-		if len(wrs) != 0 {
-			return false, nil
-		}
-	}
-
 	return true, nil
 }
 
@@ -948,6 +861,8 @@ func WrappedExecutionPayloadHeaderDeneb(p *enginev1.ExecutionPayloadHeaderDeneb)
 	return w, nil
 }
 
+var WrappedExecutionPayloadHeaderElectra = WrappedExecutionPayloadHeaderDeneb
+
 // IsNil checks if the underlying data is nil.
 func (e executionPayloadHeaderDeneb) IsNil() bool {
 	return e.p == nil
@@ -1106,6 +1021,8 @@ func WrappedExecutionPayloadDeneb(p *enginev1.ExecutionPayloadDeneb) (interfaces
 	return w, nil
 }
 
+var WrappedExecutionPayloadElectra = WrappedExecutionPayloadDeneb
+
 // IsNil checks if the underlying data is nil.
 func (e executionPayloadDeneb) IsNil() bool {
 	return e.p == nil
@@ -1243,342 +1160,3 @@ func (e executionPayloadDeneb) ExcessBlobGas() (uint64, error) {
 func (e executionPayloadDeneb) IsBlinded() bool {
 	return false
 }
-
-// executionPayloadHeaderElectra is a convenience wrapper around a blinded beacon block body's execution header data structure.
-// This wrapper allows us to conform to a common interface so that beacon
-// blocks for future forks can also be applied across Prysm without issues.
-type executionPayloadHeaderElectra struct {
-	p *enginev1.ExecutionPayloadHeaderElectra
-}
-
-var _ interfaces.ExecutionData = &executionPayloadElectra{}
-
-// WrappedExecutionPayloadHeaderElectra is a constructor which wraps a protobuf execution header into an interface.
-func WrappedExecutionPayloadHeaderElectra(p *enginev1.ExecutionPayloadHeaderElectra) (interfaces.ExecutionData, error) {
-	w := executionPayloadHeaderElectra{p: p}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-// IsNil checks if the underlying data is nil.
-func (e executionPayloadHeaderElectra) IsNil() bool {
-	return e.p == nil
-}
-
-// MarshalSSZ --
-func (e executionPayloadHeaderElectra) MarshalSSZ() ([]byte, error) {
-	return e.p.MarshalSSZ()
-}
-
-// MarshalSSZTo --
-func (e executionPayloadHeaderElectra) MarshalSSZTo(dst []byte) ([]byte, error) {
-	return e.p.MarshalSSZTo(dst)
-}
-
-// SizeSSZ --
-func (e executionPayloadHeaderElectra) SizeSSZ() int {
-	return e.p.SizeSSZ()
-}
-
-// UnmarshalSSZ --
-func (e executionPayloadHeaderElectra) UnmarshalSSZ(buf []byte) error {
-	return e.p.UnmarshalSSZ(buf)
-}
-
-// HashTreeRoot --
-func (e executionPayloadHeaderElectra) HashTreeRoot() ([32]byte, error) {
-	return e.p.HashTreeRoot()
-}
-
-// HashTreeRootWith --
-func (e executionPayloadHeaderElectra) HashTreeRootWith(hh *fastssz.Hasher) error {
-	return e.p.HashTreeRootWith(hh)
-}
-
-// Proto --
-func (e executionPayloadHeaderElectra) Proto() proto.Message {
-	return e.p
-}
-
-// ParentHash --
-func (e executionPayloadHeaderElectra) ParentHash() []byte {
-	return e.p.ParentHash
-}
-
-// FeeRecipient --
-func (e executionPayloadHeaderElectra) FeeRecipient() []byte {
-	return e.p.FeeRecipient
-}
-
-// StateRoot --
-func (e executionPayloadHeaderElectra) StateRoot() []byte {
-	return e.p.StateRoot
-}
-
-// ReceiptsRoot --
-func (e executionPayloadHeaderElectra) ReceiptsRoot() []byte {
-	return e.p.ReceiptsRoot
-}
-
-// LogsBloom --
-func (e executionPayloadHeaderElectra) LogsBloom() []byte {
-	return e.p.LogsBloom
-}
-
-// PrevRandao --
-func (e executionPayloadHeaderElectra) PrevRandao() []byte {
-	return e.p.PrevRandao
-}
-
-// BlockNumber --
-func (e executionPayloadHeaderElectra) BlockNumber() uint64 {
-	return e.p.BlockNumber
-}
-
-// GasLimit --
-func (e executionPayloadHeaderElectra) GasLimit() uint64 {
-	return e.p.GasLimit
-}
-
-// GasUsed --
-func (e executionPayloadHeaderElectra) GasUsed() uint64 {
-	return e.p.GasUsed
-}
-
-// Timestamp --
-func (e executionPayloadHeaderElectra) Timestamp() uint64 {
-	return e.p.Timestamp
-}
-
-// ExtraData --
-func (e executionPayloadHeaderElectra) ExtraData() []byte {
-	return e.p.ExtraData
-}
-
-// BaseFeePerGas --
-func (e executionPayloadHeaderElectra) BaseFeePerGas() []byte {
-	return e.p.BaseFeePerGas
-}
-
-// BlockHash --
-func (e executionPayloadHeaderElectra) BlockHash() []byte {
-	return e.p.BlockHash
-}
-
-// Transactions --
-func (executionPayloadHeaderElectra) Transactions() ([][]byte, error) {
-	return nil, consensus_types.ErrUnsupportedField
-}
-
-// TransactionsRoot --
-func (e executionPayloadHeaderElectra) TransactionsRoot() ([]byte, error) {
-	return e.p.TransactionsRoot, nil
-}
-
-// Withdrawals --
-func (e executionPayloadHeaderElectra) Withdrawals() ([]*enginev1.Withdrawal, error) {
-	return nil, consensus_types.ErrUnsupportedField
-}
-
-// WithdrawalsRoot --
-func (e executionPayloadHeaderElectra) WithdrawalsRoot() ([]byte, error) {
-	return e.p.WithdrawalsRoot, nil
-}
-
-// BlobGasUsed --
-func (e executionPayloadHeaderElectra) BlobGasUsed() (uint64, error) {
-	return e.p.BlobGasUsed, nil
-}
-
-// ExcessBlobGas --
-func (e executionPayloadHeaderElectra) ExcessBlobGas() (uint64, error) {
-	return e.p.ExcessBlobGas, nil
-}
-
-// DepositRequests --
-func (e executionPayloadHeaderElectra) DepositRequests() ([]*enginev1.DepositRequest, error) {
-	return nil, consensus_types.ErrUnsupportedField
-}
-
-// WithdrawalRequests --
-func (e executionPayloadHeaderElectra) WithdrawalRequests() ([]*enginev1.WithdrawalRequest, error) {
-	return nil, consensus_types.ErrUnsupportedField
-}
-
-// IsBlinded returns true if the underlying data is blinded.
-func (e executionPayloadHeaderElectra) IsBlinded() bool {
-	return true
-}
-
-// executionPayloadElectra is a convenience wrapper around a beacon block body's execution payload data structure
-// This wrapper allows us to conform to a common interface so that beacon
-// blocks for future forks can also be applied across Prysm without issues.
-type executionPayloadElectra struct {
-	p *enginev1.ExecutionPayloadElectra
-}
-
-// WrappedExecutionPayloadElectra is a constructor which wraps a protobuf execution payload into an interface.
-func WrappedExecutionPayloadElectra(p *enginev1.ExecutionPayloadElectra) (interfaces.ExecutionData, error) {
-	w := executionPayloadElectra{p: p}
-	if w.IsNil() {
-		return nil, consensus_types.ErrNilObjectWrapped
-	}
-	return w, nil
-}
-
-var _ interfaces.ExecutionData = &executionPayloadElectra{}
-
-// IsNil checks if the underlying data is nil.
-func (e executionPayloadElectra) IsNil() bool {
-	return e.p == nil
-}
-
-// MarshalSSZ --
-func (e executionPayloadElectra) MarshalSSZ() ([]byte, error) {
-	return e.p.MarshalSSZ()
-}
-
-// MarshalSSZTo --
-func (e executionPayloadElectra) MarshalSSZTo(dst []byte) ([]byte, error) {
-	return e.p.MarshalSSZTo(dst)
-}
-
-// SizeSSZ --
-func (e executionPayloadElectra) SizeSSZ() int {
-	return e.p.SizeSSZ()
-}
-
-// UnmarshalSSZ --
-func (e executionPayloadElectra) UnmarshalSSZ(buf []byte) error {
-	return e.p.UnmarshalSSZ(buf)
-}
-
-// HashTreeRoot --
-func (e executionPayloadElectra) HashTreeRoot() ([32]byte, error) {
-	return e.p.HashTreeRoot()
-}
-
-// HashTreeRootWith --
-func (e executionPayloadElectra) HashTreeRootWith(hh *fastssz.Hasher) error {
-	return e.p.HashTreeRootWith(hh)
-}
-
-// Proto --
-func (e executionPayloadElectra) Proto() proto.Message {
-	return e.p
-}
-
-// ParentHash --
-func (e executionPayloadElectra) ParentHash() []byte {
-	return e.p.ParentHash
-}
-
-// FeeRecipient --
-func (e executionPayloadElectra) FeeRecipient() []byte {
-	return e.p.FeeRecipient
-}
-
-// StateRoot --
-func (e executionPayloadElectra) StateRoot() []byte {
-	return e.p.StateRoot
-}
-
-// ReceiptsRoot --
-func (e executionPayloadElectra) ReceiptsRoot() []byte {
-	return e.p.ReceiptsRoot
-}
-
-// LogsBloom --
-func (e executionPayloadElectra) LogsBloom() []byte {
-	return e.p.LogsBloom
-}
-
-// PrevRandao --
-func (e executionPayloadElectra) PrevRandao() []byte {
-	return e.p.PrevRandao
-}
-
-// BlockNumber --
-func (e executionPayloadElectra) BlockNumber() uint64 {
-	return e.p.BlockNumber
-}
-
-// GasLimit --
-func (e executionPayloadElectra) GasLimit() uint64 {
-	return e.p.GasLimit
-}
-
-// GasUsed --
-func (e executionPayloadElectra) GasUsed() uint64 {
-	return e.p.GasUsed
-}
-
-// Timestamp --
-func (e executionPayloadElectra) Timestamp() uint64 {
-	return e.p.Timestamp
-}
-
-// ExtraData --
-func (e executionPayloadElectra) ExtraData() []byte {
-	return e.p.ExtraData
-}
-
-// BaseFeePerGas --
-func (e executionPayloadElectra) BaseFeePerGas() []byte {
-	return e.p.BaseFeePerGas
-}
-
-// BlockHash --
-func (e executionPayloadElectra) BlockHash() []byte {
-	return e.p.BlockHash
-}
-
-// Transactions --
-func (e executionPayloadElectra) Transactions() ([][]byte, error) {
-	return e.p.Transactions, nil
-}
-
-// TransactionsRoot --
-func (e executionPayloadElectra) TransactionsRoot() ([]byte, error) {
-	return nil, consensus_types.ErrUnsupportedField
-}
-
-// Withdrawals --
-func (e executionPayloadElectra) Withdrawals() ([]*enginev1.Withdrawal, error) {
-	return e.p.Withdrawals, nil
-}
-
-// WithdrawalsRoot --
-func (e executionPayloadElectra) WithdrawalsRoot() ([]byte, error) {
-	return nil, consensus_types.ErrUnsupportedField
-}
-
-func (e executionPayloadElectra) BlobGasUsed() (uint64, error) {
-	return e.p.BlobGasUsed, nil
-}
-
-func (e executionPayloadElectra) ExcessBlobGas() (uint64, error) {
-	return e.p.ExcessBlobGas, nil
-}
-
-// DepositRequests --
-func (e executionPayloadElectra) DepositRequests() []*enginev1.DepositRequest {
-	return e.p.DepositRequests
-}
-
-// WithdrawalRequests --
-func (e executionPayloadElectra) WithdrawalRequests() []*enginev1.WithdrawalRequest {
-	return e.p.WithdrawalRequests
-}
-
-// ConsolidationRequests --
-func (e executionPayloadElectra) ConsolidationRequests() []*enginev1.ConsolidationRequest {
-	return e.p.ConsolidationRequests
-}
-
-// IsBlinded returns true if the underlying data is blinded.
-func (e executionPayloadElectra) IsBlinded() bool {
-	return false
-}

consensus-types/blocks/factory.go

@@ -238,6 +238,46 @@ func BuildSignedBeaconBlock(blk interfaces.ReadOnlyBeaconBlock, signature []byte
 	}
 }
 
+func getWrappedPayload(payload interface{}) (wrappedPayload interfaces.ExecutionData, wrapErr error) {
+	switch p := payload.(type) {
+	case *enginev1.ExecutionPayload:
+		wrappedPayload, wrapErr = WrappedExecutionPayload(p)
+	case *enginev1.ExecutionPayloadCapella:
+		wrappedPayload, wrapErr = WrappedExecutionPayloadCapella(p)
+	case *enginev1.ExecutionPayloadDeneb:
+		wrappedPayload, wrapErr = WrappedExecutionPayloadDeneb(p)
+	default:
+		wrappedPayload, wrapErr = nil, fmt.Errorf("%T is not a type of execution payload", p)
+	}
+	return wrappedPayload, wrapErr
+}
+
+func checkPayloadAgainstHeader(wrappedPayload, payloadHeader interfaces.ExecutionData) error {
+	empty, err := IsEmptyExecutionData(wrappedPayload)
+	if err != nil {
+		return err
+	}
+	if empty {
+		return nil
+	}
+	payloadRoot, err := wrappedPayload.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not hash tree root execution payload")
+	}
+	payloadHeaderRoot, err := payloadHeader.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not hash tree root payload header")
+	}
+	if payloadRoot != payloadHeaderRoot {
+		return fmt.Errorf(
+			"payload %#x and header %#x roots do not match",
+			payloadRoot,
+			payloadHeaderRoot,
+		)
+	}
+	return nil
+}
+
 // BuildSignedBeaconBlockFromExecutionPayload takes a signed, blinded beacon block and converts into
 // a full, signed beacon block by specifying an execution payload.
 func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBeaconBlock, payload interface{}) (interfaces.SignedBeaconBlock, error) { // nolint:gocognit
@@ -253,43 +293,12 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 		return nil, errors.Wrap(err, "could not get execution payload header")
 	}
 
-	var wrappedPayload interfaces.ExecutionData
-	var wrapErr error
-	switch p := payload.(type) {
-	case *enginev1.ExecutionPayload:
-		wrappedPayload, wrapErr = WrappedExecutionPayload(p)
-	case *enginev1.ExecutionPayloadCapella:
-		wrappedPayload, wrapErr = WrappedExecutionPayloadCapella(p)
-	case *enginev1.ExecutionPayloadDeneb:
-		wrappedPayload, wrapErr = WrappedExecutionPayloadDeneb(p)
-	case *enginev1.ExecutionPayloadElectra:
-		wrappedPayload, wrapErr = WrappedExecutionPayloadElectra(p)
-	default:
-		return nil, fmt.Errorf("%T is not a type of execution payload", p)
-	}
-	if wrapErr != nil {
-		return nil, wrapErr
-	}
-	empty, err := IsEmptyExecutionData(wrappedPayload)
+	wrappedPayload, err := getWrappedPayload(payload)
 	if err != nil {
 		return nil, err
 	}
-	if !empty {
-		payloadRoot, err := wrappedPayload.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not hash tree root execution payload")
-		}
-		payloadHeaderRoot, err := payloadHeader.HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not hash tree root payload header")
-		}
-		if payloadRoot != payloadHeaderRoot {
-			return nil, fmt.Errorf(
-				"payload %#x and header %#x roots do not match",
-				payloadRoot,
-				payloadHeaderRoot,
-			)
-		}
+	if err := checkPayloadAgainstHeader(wrappedPayload, payloadHeader); err != nil {
+		return nil, err
 	}
 	syncAgg, err := b.Body().SyncAggregate()
 	if err != nil {
@@ -302,8 +311,12 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 	sig := blk.Signature()
 
 	var fullBlock interface{}
-	switch p := payload.(type) {
-	case *enginev1.ExecutionPayload:
+	switch blk.Version() {
+	case version.Bellatrix:
+		p, ok := payload.(*enginev1.ExecutionPayload)
+		if !ok {
+			return nil, errors.New("payload not of Bellatrix type")
+		}
 		var atts []*eth.Attestation
 		if b.Body().Attestations() != nil {
 			atts = make([]*eth.Attestation, len(b.Body().Attestations()))
@@ -347,7 +360,11 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 			},
 			Signature: sig[:],
 		}
-	case *enginev1.ExecutionPayloadCapella:
+	case version.Capella:
+		p, ok := payload.(*enginev1.ExecutionPayloadCapella)
+		if !ok {
+			return nil, errors.New("payload not of Capella type")
+		}
 		blsToExecutionChanges, err := b.Body().BLSToExecutionChanges()
 		if err != nil {
 			return nil, err
@@ -396,7 +413,11 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 			},
 			Signature: sig[:],
 		}
-	case *enginev1.ExecutionPayloadDeneb:
+	case version.Deneb:
+		p, ok := payload.(*enginev1.ExecutionPayloadDeneb)
+		if !ok {
+			return nil, errors.New("payload not of Deneb type")
+		}
 		blsToExecutionChanges, err := b.Body().BLSToExecutionChanges()
 		if err != nil {
 			return nil, err
@@ -450,7 +471,11 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 			},
 			Signature: sig[:],
 		}
-	case *enginev1.ExecutionPayloadElectra:
+	case version.Electra:
+		p, ok := payload.(*enginev1.ExecutionPayloadElectra)
+		if !ok {
+			return nil, errors.New("payload not of Electra type")
+		}
 		blsToExecutionChanges, err := b.Body().BLSToExecutionChanges()
 		if err != nil {
 			return nil, err
@@ -481,6 +506,12 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 				attSlashings[i] = s
 			}
 		}
+
+		er, err := b.Body().ExecutionRequests()
+		if err != nil {
+			return nil, err
+		}
+
 		fullBlock = &eth.SignedBeaconBlockElectra{
 			Block: &eth.BeaconBlockElectra{
 				Slot:          b.Slot(),
@@ -500,12 +531,13 @@ func BuildSignedBeaconBlockFromExecutionPayload(blk interfaces.ReadOnlySignedBea
 					ExecutionPayload:      p,
 					BlsToExecutionChanges: blsToExecutionChanges,
 					BlobKzgCommitments:    commitments,
+					ExecutionRequests:     er,
 				},
 			},
 			Signature: sig[:],
 		}
 	default:
-		return nil, fmt.Errorf("%T is not a type of execution payload", p)
+		return nil, errors.New("Block not of known type")
 	}
 
 	return NewSignedBeaconBlock(fullBlock)

consensus-types/blocks/getters.go

@@ -152,6 +152,42 @@ func (b *SignedBeaconBlock) ToBlinded() (interfaces.ReadOnlySignedBeaconBlock, e
 		return nil, err
 	}
 
+	if b.version >= version.Electra {
+		p, ok := payload.Proto().(*enginev1.ExecutionPayloadElectra)
+		if !ok {
+			return nil, fmt.Errorf("%T is not an execution payload header of Deneb version", p)
+		}
+		header, err := PayloadToHeaderElectra(payload)
+		if err != nil {
+			return nil, err
+		}
+		return initBlindedSignedBlockFromProtoElectra(
+			&eth.SignedBlindedBeaconBlockElectra{
+				Message: &eth.BlindedBeaconBlockElectra{
+					Slot:          b.block.slot,
+					ProposerIndex: b.block.proposerIndex,
+					ParentRoot:    b.block.parentRoot[:],
+					StateRoot:     b.block.stateRoot[:],
+					Body: &eth.BlindedBeaconBlockBodyElectra{
+						RandaoReveal:           b.block.body.randaoReveal[:],
+						Eth1Data:               b.block.body.eth1Data,
+						Graffiti:               b.block.body.graffiti[:],
+						ProposerSlashings:      b.block.body.proposerSlashings,
+						AttesterSlashings:      b.block.body.attesterSlashingsElectra,
+						Attestations:           b.block.body.attestationsElectra,
+						Deposits:               b.block.body.deposits,
+						VoluntaryExits:         b.block.body.voluntaryExits,
+						SyncAggregate:          b.block.body.syncAggregate,
+						ExecutionPayloadHeader: header,
+						BlsToExecutionChanges:  b.block.body.blsToExecutionChanges,
+						BlobKzgCommitments:     b.block.body.blobKzgCommitments,
+						ExecutionRequests:      b.block.body.executionRequests,
+					},
+				},
+				Signature: b.signature[:],
+			})
+	}
+
 	switch p := payload.Proto().(type) {
 	case *enginev1.ExecutionPayload:
 		header, err := PayloadToHeader(payload)
@@ -237,39 +273,6 @@ func (b *SignedBeaconBlock) ToBlinded() (interfaces.ReadOnlySignedBeaconBlock, e
 				},
 				Signature: b.signature[:],
 			})
-	case *enginev1.ExecutionPayloadElectra:
-		pe, ok := payload.(interfaces.ExecutionDataElectra)
-		if !ok {
-			return nil, interfaces.ErrIncompatibleFork
-		}
-		header, err := PayloadToHeaderElectra(pe)
-		if err != nil {
-			return nil, err
-		}
-		return initBlindedSignedBlockFromProtoElectra(
-			&eth.SignedBlindedBeaconBlockElectra{
-				Message: &eth.BlindedBeaconBlockElectra{
-					Slot:          b.block.slot,
-					ProposerIndex: b.block.proposerIndex,
-					ParentRoot:    b.block.parentRoot[:],
-					StateRoot:     b.block.stateRoot[:],
-					Body: &eth.BlindedBeaconBlockBodyElectra{
-						RandaoReveal:           b.block.body.randaoReveal[:],
-						Eth1Data:               b.block.body.eth1Data,
-						Graffiti:               b.block.body.graffiti[:],
-						ProposerSlashings:      b.block.body.proposerSlashings,
-						AttesterSlashings:      b.block.body.attesterSlashingsElectra,
-						Attestations:           b.block.body.attestationsElectra,
-						Deposits:               b.block.body.deposits,
-						VoluntaryExits:         b.block.body.voluntaryExits,
-						SyncAggregate:          b.block.body.syncAggregate,
-						ExecutionPayloadHeader: header,
-						BlsToExecutionChanges:  b.block.body.blsToExecutionChanges,
-						BlobKzgCommitments:     b.block.body.blobKzgCommitments,
-					},
-				},
-				Signature: b.signature[:],
-			})
 	default:
 		return nil, fmt.Errorf("%T is not an execution payload header", p)
 	}
@@ -1110,6 +1113,14 @@ func (b *BeaconBlockBody) BlobKzgCommitments() ([][]byte, error) {
 	}
 }
 
+// ExecutionRequests returns the execution requests
+func (b *BeaconBlockBody) ExecutionRequests() (*enginev1.ExecutionRequests, error) {
+	if b.version < version.Electra {
+		return nil, consensus_types.ErrNotSupported("ExecutionRequests", b.version)
+	}
+	return b.executionRequests, nil
+}
+
 // Version returns the version of the beacon block body
 func (b *BeaconBlockBody) Version() int {
 	return b.version

consensus-types/blocks/getters_test.go

@@ -614,26 +614,22 @@ func hydrateBeaconBlockBodyElectra() *eth.BeaconBlockBodyElectra {
 			SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
 		},
 		ExecutionPayload: &pb.ExecutionPayloadElectra{
-			ParentHash:            make([]byte, fieldparams.RootLength),
-			FeeRecipient:          make([]byte, 20),
-			StateRoot:             make([]byte, fieldparams.RootLength),
-			ReceiptsRoot:          make([]byte, fieldparams.RootLength),
-			LogsBloom:             make([]byte, 256),
-			PrevRandao:            make([]byte, fieldparams.RootLength),
-			ExtraData:             make([]byte, 0),
-			BaseFeePerGas:         make([]byte, fieldparams.RootLength),
-			BlockHash:             make([]byte, fieldparams.RootLength),
-			Transactions:          make([][]byte, 0),
-			Withdrawals:           make([]*pb.Withdrawal, 0),
-			DepositRequests:       make([]*pb.DepositRequest, 0),
-			WithdrawalRequests:    make([]*pb.WithdrawalRequest, 0),
-			ConsolidationRequests: make([]*pb.ConsolidationRequest, 0),
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, 20),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, 256),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			ExtraData:     make([]byte, 0),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+			Transactions:  make([][]byte, 0),
+			Withdrawals:   make([]*pb.Withdrawal, 0),
+		},
+		ExecutionRequests: &pb.ExecutionRequests{
+			Deposits:       make([]*pb.DepositRequest, 0),
+			Withdrawals:    make([]*pb.WithdrawalRequest, 0),
+			Consolidations: make([]*pb.ConsolidationRequest, 0),
 		},
 	}
 }
-
-func TestPreElectraFailsInterfaceAssertion(t *testing.T) {
-	var epd interfaces.ExecutionData = &executionPayloadDeneb{}
-	_, ok := epd.(interfaces.ExecutionDataElectra)
-	require.Equal(t, false, ok)
-}

consensus-types/blocks/kzg.go

@@ -12,7 +12,7 @@ import (
 )
 
 const (
-	bodyLength    = 12 // The number of elements in the BeaconBlockBody Container
+	bodyLength    = 13 // The number of elements in the BeaconBlockBody Container for Electra
 	logBodyLength = 4  // The log 2 of bodyLength
 	kzgPosition   = 11 // The index of the KZG commitment list in the Body
 	kzgRootIndex  = 54 // The Merkle index of the KZG commitment list's root in the Body's Merkle tree
@@ -229,5 +229,18 @@ func topLevelRoots(body interfaces.ReadOnlyBeaconBlockBody) ([][]byte, error) {
 	copy(layer[10], root[:])
 
 	// KZG commitments is not needed
+
+	// Execution requests
+	if body.Version() >= version.Electra {
+		er, err := body.ExecutionRequests()
+		if err != nil {
+			return nil, err
+		}
+		root, err = er.HashTreeRoot()
+		if err != nil {
+			return nil, err
+		}
+		copy(layer[12], root[:])
+	}
 	return layer, nil
 }

consensus-types/blocks/proofs.go

@@ -42,7 +42,7 @@ func ComputeBlockBodyFieldRoots(ctx context.Context, blockBody *BeaconBlockBody)
 	case version.Deneb:
 		fieldRoots = make([][]byte, 12)
 	case version.Electra:
-		fieldRoots = make([][]byte, 12)
+		fieldRoots = make([][]byte, 13)
 	default:
 		return nil, fmt.Errorf("unknown block body version %s", version.String(blockBody.version))
 	}
@@ -179,6 +179,18 @@ func ComputeBlockBodyFieldRoots(ctx context.Context, blockBody *BeaconBlockBody)
 		copy(fieldRoots[11], root[:])
 	}
 
+	if blockBody.version >= version.Electra {
+		// Execution Requests
+		er, err := blockBody.ExecutionRequests()
+		if err != nil {
+			return nil, err
+		}
+		root, err := er.HashTreeRoot()
+		if err != nil {
+			return nil, err
+		}
+		copy(fieldRoots[12], root[:])
+	}
 	return fieldRoots, nil
 }
 

consensus-types/blocks/proto.go

@@ -531,6 +531,7 @@ func (b *BeaconBlockBody) Proto() (proto.Message, error) {
 				ExecutionPayloadHeader: ph,
 				BlsToExecutionChanges:  b.blsToExecutionChanges,
 				BlobKzgCommitments:     b.blobKzgCommitments,
+				ExecutionRequests:      b.executionRequests,
 			}, nil
 		}
 		var p *enginev1.ExecutionPayloadElectra
@@ -554,6 +555,7 @@ func (b *BeaconBlockBody) Proto() (proto.Message, error) {
 			ExecutionPayload:      p,
 			BlsToExecutionChanges: b.blsToExecutionChanges,
 			BlobKzgCommitments:    b.blobKzgCommitments,
+			ExecutionRequests:     b.executionRequests,
 		}, nil
 
 	default:
@@ -1142,6 +1144,10 @@ func initBlockBodyFromProtoElectra(pb *eth.BeaconBlockBodyElectra) (*BeaconBlock
 	if err != nil && !errors.Is(err, consensus_types.ErrNilObjectWrapped) {
 		return nil, err
 	}
+	er := pb.ExecutionRequests
+	if er == nil {
+		er = &enginev1.ExecutionRequests{}
+	}
 	b := &BeaconBlockBody{
 		version:                  version.Electra,
 		randaoReveal:             bytesutil.ToBytes96(pb.RandaoReveal),
@@ -1156,6 +1162,7 @@ func initBlockBodyFromProtoElectra(pb *eth.BeaconBlockBodyElectra) (*BeaconBlock
 		executionPayload:         p,
 		blsToExecutionChanges:    pb.BlsToExecutionChanges,
 		blobKzgCommitments:       pb.BlobKzgCommitments,
+		executionRequests:        er,
 	}
 	return b, nil
 }
@@ -1170,6 +1177,10 @@ func initBlindedBlockBodyFromProtoElectra(pb *eth.BlindedBeaconBlockBodyElectra)
 	if err != nil && !errors.Is(err, consensus_types.ErrNilObjectWrapped) {
 		return nil, err
 	}
+	er := pb.ExecutionRequests
+	if er == nil {
+		er = &enginev1.ExecutionRequests{}
+	}
 	b := &BeaconBlockBody{
 		version:                  version.Electra,
 		randaoReveal:             bytesutil.ToBytes96(pb.RandaoReveal),
@@ -1184,6 +1195,7 @@ func initBlindedBlockBodyFromProtoElectra(pb *eth.BlindedBeaconBlockBodyElectra)
 		executionPayloadHeader:   ph,
 		blsToExecutionChanges:    pb.BlsToExecutionChanges,
 		blobKzgCommitments:       pb.BlobKzgCommitments,
+		executionRequests:        er,
 	}
 	return b, nil
 }

consensus-types/blocks/types.go

@@ -5,6 +5,7 @@ import (
 	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"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"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -54,6 +55,7 @@ type BeaconBlockBody struct {
 	executionPayloadHeader   interfaces.ExecutionData
 	blsToExecutionChanges    []*eth.SignedBLSToExecutionChange
 	blobKzgCommitments       [][]byte
+	executionRequests        *enginev1.ExecutionRequests
 }
 
 var _ interfaces.ReadOnlyBeaconBlockBody = &BeaconBlockBody{}

consensus-types/interfaces/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "beacon_block.go",
         "error.go",
+        "light_client.go",
         "utils.go",
         "validator.go",
     ],

consensus-types/interfaces/beacon_block.go

@@ -69,6 +69,7 @@ type ReadOnlyBeaconBlockBody interface {
 	Execution() (ExecutionData, error)
 	BLSToExecutionChanges() ([]*ethpb.SignedBLSToExecutionChange, error)
 	BlobKzgCommitments() ([][]byte, error)
+	ExecutionRequests() (*enginev1.ExecutionRequests, error)
 }
 
 type SignedBeaconBlock interface {
@@ -122,10 +123,3 @@ type ExecutionData interface {
 	Withdrawals() ([]*enginev1.Withdrawal, error)
 	WithdrawalsRoot() ([]byte, error)
 }
-
-type ExecutionDataElectra interface {
-	ExecutionData
-	DepositRequests() []*enginev1.DepositRequest
-	WithdrawalRequests() []*enginev1.WithdrawalRequest
-	ConsolidationRequests() []*enginev1.ConsolidationRequest
-}