looking for diff algo

* Remove slot from `UpdateDuties`

* Fix slot to epoch conversion

* Add gossip clock disparity

* do not use disparity

* check for nil duties

---------

Co-authored-by: terence tsao <terence@prysmaticlabs.com>
Co-authored-by: james-prysm <90280386+james-prysm@users.noreply.github.com>

CHANGELOG.md

@@ -4,6 +4,64 @@ All notable changes to this project will be documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
+## [v6.0.0](https://github.com/prysmaticlabs/prysm/compare/v5.3.2...v6.0.0) - 2025-04-21
+
+This release introduces Mainnet support for the upcoming Electra + Prague (Pectra) fork. The fork is scheduled for mainnet epoch 364032 (May 7, 2025, 10:05:11 UTC). You MUST update Prysm Beacon Node, Prysm Validator Client, and your execution layer client to the Pectra ready release prior to the fork to stay on the correct chain.
+
+Besides Pectra, we have more light client API support, cleanups, and a few bugfixes. Please review the changelog below and update your client as soon as practical before May 7.
+
+This release is **mandatory** for all operators before May 7.
+
+### Added
+
+- Implemented validator identities Beacon API endpoint. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15086)
+- Add SSZ support to light client updates by range API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15082)
+- Add light client ssz types to the spec test. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15097)
+- Added the ability for execution requests to be tested in e2e with electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14971)
+- Add warning messages for gas limit ranges that might be problematic. Low gas limits (≤10% of default) may cause transactions to fail, while high gas limits (>150% of default) could lead to block propagation issues. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15078)
+- Add light client store object to the beacon node object. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15120)
+- prysmctl option in wrapper script to generate devnet ssz. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15145)
+- Add support for Electra fork epoch. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15132)
+
+### Changed
+
+- The validator client will no longer use the full list of committee values but instead use the committee length and validator committee index. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15039)
+- Remove the header `Content-Disposition` from the `httputil.WriteSSZ` function. No `filename` parameter is needed anymore. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15092)
+- Sort attestations in proposer block by reward. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15093)
+- More efficient query method for stategen to retrieve blocks between a given state and the replay target block. This avoids attempting to look up blocks that are not needed for head replay queries, which may be missing due to a previous rollback bug. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15063)
+- removed old web3signer metrics in favor for a universal one. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14920)
+- Deprecated everything related with the gRPC API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14944)
+- Migrate Prysm repo to Offchain Labs organization ahead of Pectra upgrade v6. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15140)
+
+### Deprecated
+
+- deprecates and removes usage of the `--trace` flag and`--cpuprofile` flag in favor of just using `--pprof`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15083)
+
+### Removed
+
+- Remove /eth/v1/beacon/states/head/committees call when getting duties. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15039)
+- Removed unused hack scripts. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15157)
+- Remove `disable-committee-aware-packing` flag. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15162)
+- Remove deprecated flags for the major release. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15165)
+- Removed Beacon API endpoints which have been deprecated at the Deneb fork. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15166)
+
+### Fixed
+
+- The `--rpc` flag will now properly enable the keymanager APIs without web. The `--web` will enable both validator api endpoints and web. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15080)
+- Use latest state to pack attestation. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15113)
+- Clean up dangling block index entries for blocks that were previously deleted by incomplete cleanup code. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15040)
+- Fixed to use io stream instead of stream read. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15089)
+- When using a DV, send all aggregations for a slot and committee. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15110)
+- Fixed a bug in consolidation request processing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15122)
+- Fix State Getter for pending withdrawal balance. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15123)
+- Fixed a bug in checking for attestation lengths in our block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15134)
+- Fix Committee Index Check For Aggregates. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15146)
+- Fix filtering by committee index post-Electra in `ListAttestationsV2`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15148)
+- Peers giving invalid data in range syncing are now downscored. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15149)
+- Adding fork guard to attestation api endpoints so that it doesn't accidentally include wrong attestation types in the pool. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15161)
+- fixed underflow with balances in leaking edge case with expected withdrawals. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15191)
+- Attribute block and blob issues to correct peers during range syncing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15173)
+
 ## [v5.3.2](https://github.com/prysmaticlabs/prysm/compare/v5.3.1...v5.3.2) - 2025-03-25
 
 This release introduces support for the `Hoodi` testnet.
@@ -3255,4 +3313,4 @@ There are no security updates in this release.
 
 # Older than v2.0.0
 
-For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases
+For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases

api/server/structs/endpoints_beacon.go

@@ -263,6 +263,13 @@ type ChainHead struct {
 	OptimisticStatus           bool   `json:"optimistic_status"`
 }
 
+type GetPendingConsolidationsResponse struct {
+	Version             string                  `json:"version"`
+	ExecutionOptimistic bool                    `json:"execution_optimistic"`
+	Finalized           bool                    `json:"finalized"`
+	Data                []*PendingConsolidation `json:"data"`
+}
+
 type GetPendingDepositsResponse struct {
 	Version             string            `json:"version"`
 	ExecutionOptimistic bool              `json:"execution_optimistic"`

beacon-chain/blockchain/execution_engine.go

@@ -184,13 +184,17 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	return payloadID, nil
 }
 
-func firePayloadAttributesEvent(_ context.Context, f event.SubscriberSender, nextSlot primitives.Slot) {
+func (s *Service) firePayloadAttributesEvent(f event.SubscriberSender, block interfaces.ReadOnlySignedBeaconBlock, root [32]byte, nextSlot primitives.Slot) {
+	// If we're syncing a block in the past and init-sync is still running, we shouldn't fire this event.
+	if !s.cfg.SyncChecker.Synced() {
+		return
+	}
 	// the fcu args have differing amounts of completeness based on the code path,
 	// and there is work we only want to do if a client is actually listening to the events beacon api endpoint.
 	// temporary solution: just fire a blank event and fill in the details in the api handler.
 	f.Send(&feed.Event{
 		Type: statefeed.PayloadAttributes,
-		Data: payloadattribute.EventData{ProposalSlot: nextSlot},
+		Data: payloadattribute.EventData{HeadBlock: block, HeadRoot: root, ProposalSlot: nextSlot},
 	})
 }
 

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -102,7 +102,7 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuCo
 		log.WithError(err).Error("could not save head")
 	}
 
-	go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), s.CurrentSlot()+1)
+	go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), args.headBlock, args.headRoot, s.CurrentSlot()+1)
 
 	// Only need to prune attestations from pool if the head has changed.
 	s.pruneAttsFromPool(s.ctx, args.headState, args.headBlock)

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -3,15 +3,19 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
+        "kzg.go",
         "trusted_setup.go",
         "validation.go",
     ],
-    embedsrcs = ["trusted_setup.json"],
+    embedsrcs = ["trusted_setup_4096.json"],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg",
     visibility = ["//visibility:public"],
     deps = [
         "//consensus-types/blocks:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
+        "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )

beacon-chain/blockchain/kzg/kzg.go

@@ -0,0 +1,143 @@
+package kzg
+
+import (
+	"github.com/pkg/errors"
+
+	ckzg4844 "github.com/ethereum/c-kzg-4844/v2/bindings/go"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
+)
+
+// BytesPerBlob is the number of bytes in a single blob.
+const BytesPerBlob = ckzg4844.BytesPerBlob
+
+// Blob represents a serialized chunk of data.
+type Blob [BytesPerBlob]byte
+
+// BytesPerCell is the number of bytes in a single cell.
+const BytesPerCell = ckzg4844.BytesPerCell
+
+// Cell represents a chunk of an encoded Blob.
+type Cell [BytesPerCell]byte
+
+// Commitment represent a KZG commitment to a Blob.
+type Commitment [48]byte
+
+// Proof represents a KZG proof that attests to the validity of a Blob or parts of it.
+type Proof [48]byte
+
+// Bytes48 is a 48-byte array.
+type Bytes48 = ckzg4844.Bytes48
+
+// Bytes32 is a 32-byte array.
+type Bytes32 = ckzg4844.Bytes32
+
+// CellsAndProofs represents the Cells and Proofs corresponding to a single blob.
+type CellsAndProofs struct {
+	Cells  []Cell
+	Proofs []Proof
+}
+
+// BlobToKZGCommitment computes a KZG commitment from a given blob.
+func BlobToKZGCommitment(blob *Blob) (Commitment, error) {
+	var kzgBlob kzg4844.Blob
+	copy(kzgBlob[:], blob[:])
+
+	commitment, err := kzg4844.BlobToCommitment(&kzgBlob)
+	if err != nil {
+		return Commitment{}, err
+	}
+
+	return Commitment(commitment), nil
+}
+
+// ComputeCells computes the (extended) cells from a given blob.
+func ComputeCells(blob *Blob) ([]Cell, error) {
+	var ckzgBlob ckzg4844.Blob
+	copy(ckzgBlob[:], blob[:])
+
+	ckzgCells, err := ckzg4844.ComputeCells(&ckzgBlob)
+	if err != nil {
+		return nil, errors.Wrap(err, "compute cells")
+	}
+
+	cells := make([]Cell, len(ckzgCells))
+	for i := range ckzgCells {
+		cells[i] = Cell(ckzgCells[i])
+	}
+
+	return cells, nil
+}
+
+// ComputeBlobKZGProof computes the blob KZG proof from a given blob and its commitment.
+func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) {
+	var kzgBlob kzg4844.Blob
+	copy(kzgBlob[:], blob[:])
+
+	proof, err := kzg4844.ComputeBlobProof(&kzgBlob, kzg4844.Commitment(commitment))
+	if err != nil {
+		return [48]byte{}, err
+	}
+	return Proof(proof), nil
+}
+
+// ComputeCellsAndKZGProofs computes the cells and cells KZG proofs from a given blob.
+func ComputeCellsAndKZGProofs(blob *Blob) (CellsAndProofs, error) {
+	var ckzgBlob ckzg4844.Blob
+	copy(ckzgBlob[:], blob[:])
+
+	ckzgCells, ckzgProofs, err := ckzg4844.ComputeCellsAndKZGProofs(&ckzgBlob)
+	if err != nil {
+		return CellsAndProofs{}, err
+	}
+
+	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
+}
+
+// VerifyCellKZGProofBatch verifies the KZG proofs for a given slice of commitments, cells indices, cells and proofs.
+// Note: It is way more efficient to call once this function with big slices than calling it multiple times with small slices.
+func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, cells []Cell, proofsBytes []Bytes48) (bool, error) {
+	// Convert `Cell` type to `ckzg4844.Cell`
+	ckzgCells := make([]ckzg4844.Cell, len(cells))
+
+	for i := range cells {
+		ckzgCells[i] = ckzg4844.Cell(cells[i])
+	}
+
+	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, ckzgCells, proofsBytes)
+}
+
+// RecoverCellsAndKZGProofs recovers the complete cells and KZG proofs from a given set of cell indices and partial cells.
+func RecoverCellsAndKZGProofs(cellIndices []uint64, partialCells []Cell) (CellsAndProofs, error) {
+	// Convert `Cell` type to `ckzg4844.Cell`
+	ckzgPartialCells := make([]ckzg4844.Cell, len(partialCells))
+	for i := range partialCells {
+		ckzgPartialCells[i] = ckzg4844.Cell(partialCells[i])
+	}
+
+	ckzgCells, ckzgProofs, err := ckzg4844.RecoverCellsAndKZGProofs(cellIndices, ckzgPartialCells)
+	if err != nil {
+		return CellsAndProofs{}, errors.Wrap(err, "recover cells and KZG proofs")
+	}
+
+	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
+}
+
+// makeCellsAndProofs converts cells/proofs to the CellsAndProofs type defined in this package.
+func makeCellsAndProofs(ckzgCells []ckzg4844.Cell, ckzgProofs []ckzg4844.KZGProof) (CellsAndProofs, error) {
+	if len(ckzgCells) != len(ckzgProofs) {
+		return CellsAndProofs{}, errors.New("different number of cells/proofs")
+	}
+
+	cells := make([]Cell, 0, len(ckzgCells))
+	proofs := make([]Proof, 0, len(ckzgProofs))
+
+	for i := range ckzgCells {
+		cells = append(cells, Cell(ckzgCells[i]))
+		proofs = append(proofs, Proof(ckzgProofs[i]))
+	}
+
+	return CellsAndProofs{
+		Cells:  cells,
+		Proofs: proofs,
+	}, nil
+}

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -5,24 +5,69 @@ import (
 	"encoding/json"
 
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	CKZG "github.com/ethereum/c-kzg-4844/v2/bindings/go"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 )
 
 var (
-	//go:embed trusted_setup.json
+	// https://github.com/ethereum/consensus-specs/blob/dev/presets/mainnet/trusted_setups/trusted_setup_4096.json
+	//go:embed trusted_setup_4096.json
 	embeddedTrustedSetup []byte // 1.2Mb
 	kzgContext           *GoKZG.Context
+	kzgLoaded            bool
 )
 
+type TrustedSetup struct {
+	G1Monomial [GoKZG.ScalarsPerBlob]GoKZG.G1CompressedHexStr `json:"g1_monomial"`
+	G1Lagrange [GoKZG.ScalarsPerBlob]GoKZG.G1CompressedHexStr `json:"g1_lagrange"`
+	G2Monomial [65]GoKZG.G2CompressedHexStr                   `json:"g2_monomial"`
+}
+
 func Start() error {
-	parsedSetup := GoKZG.JSONTrustedSetup{}
-	err := json.Unmarshal(embeddedTrustedSetup, &parsedSetup)
+	trustedSetup := &TrustedSetup{}
+	err := json.Unmarshal(embeddedTrustedSetup, trustedSetup)
 	if err != nil {
 		return errors.Wrap(err, "could not parse trusted setup JSON")
 	}
-	kzgContext, err = GoKZG.NewContext4096(&parsedSetup)
+
+	kzgContext, err = GoKZG.NewContext4096(&GoKZG.JSONTrustedSetup{
+		SetupG2:         trustedSetup.G2Monomial[:],
+		SetupG1Lagrange: trustedSetup.G1Lagrange,
+	})
 	if err != nil {
 		return errors.Wrap(err, "could not initialize go-kzg context")
 	}
+
+	// Length of a G1 point, converted from hex to binary.
+	g1MonomialBytes := make([]byte, len(trustedSetup.G1Monomial)*(len(trustedSetup.G1Monomial[0])-2)/2)
+	for i, g1 := range &trustedSetup.G1Monomial {
+		copy(g1MonomialBytes[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
+	}
+
+	// Length of a G1 point, converted from hex to binary.
+	g1LagrangeBytes := make([]byte, len(trustedSetup.G1Lagrange)*(len(trustedSetup.G1Lagrange[0])-2)/2)
+	for i, g1 := range &trustedSetup.G1Lagrange {
+		copy(g1LagrangeBytes[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
+	}
+
+	// Length of a G2 point, converted from hex to binary.
+	g2MonomialBytes := make([]byte, len(trustedSetup.G2Monomial)*(len(trustedSetup.G2Monomial[0])-2)/2)
+	for i, g2 := range &trustedSetup.G2Monomial {
+		copy(g2MonomialBytes[i*(len(g2)-2)/2:], hexutil.MustDecode(g2))
+	}
+
+	if !kzgLoaded {
+		const precompute uint = 8
+
+		kzgLoaded = true
+
+		// Free the current trusted setup before running this method.
+		// CKZG panics if the same setup is run multiple times.
+		if err = CKZG.LoadTrustedSetup(g1MonomialBytes, g1LagrangeBytes, g2MonomialBytes, precompute); err != nil {
+			return errors.Wrap(err, "load trust setup")
+		}
+	}
+
 	return nil
 }

beacon-chain/blockchain/mock_test.go

@@ -20,6 +20,7 @@ func testServiceOptsWithDB(t *testing.T) []Option {
 		WithForkChoiceStore(fcs),
 		WithClockSynchronizer(cs),
 		WithStateNotifier(&mock.MockStateNotifier{RecordEvents: true}),
+		WithSyncChecker(&mock.MockSyncChecker{}),
 	}
 }
 

beacon-chain/blockchain/process_block.go

@@ -729,9 +729,13 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	attribute := s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
 	// return early if we are not proposing next slot
 	if attribute.IsEmpty() {
+		headBlock, err := s.headBlock()
+		if err != nil {
+			log.WithError(err).WithField("head_root", headRoot).Error("unable to retrieve head block to fire payload attributes event")
+		}
 		// notifyForkchoiceUpdate fires the payload attribute event. But in this case, we won't
 		// call notifyForkchoiceUpdate, so the event is fired here.
-		go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), s.CurrentSlot()+1)
+		go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), headBlock, headRoot, s.CurrentSlot()+1)
 		return
 	}
 

beacon-chain/blockchain/process_block_helpers.go

@@ -103,15 +103,29 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 		log.WithError(err).Debug("Could not check if block is optimistic")
 		optimistic = true
 	}
+	currEpoch := slots.ToEpoch(s.CurrentSlot())
+	currDependenRoot, err := s.cfg.ForkChoiceStore.DependentRoot(currEpoch)
+	if err != nil {
+		log.WithError(err).Debug("Could not get dependent root")
+	}
+	prevDependentRoot := [32]byte{}
+	if currEpoch > 0 {
+		prevDependentRoot, err = s.cfg.ForkChoiceStore.DependentRoot(currEpoch - 1)
+		if err != nil {
+			log.WithError(err).Debug("Could not get previous dependent root")
+		}
+	}
 	// Send notification of the processed block to the state feed.
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			Slot:        cfg.roblock.Block().Slot(),
-			BlockRoot:   cfg.roblock.Root(),
-			SignedBlock: cfg.roblock,
-			Verified:    true,
-			Optimistic:  optimistic,
+			Slot:              cfg.roblock.Block().Slot(),
+			BlockRoot:         cfg.roblock.Root(),
+			SignedBlock:       cfg.roblock,
+			CurrDependentRoot: currDependenRoot,
+			PrevDependentRoot: prevDependentRoot,
+			Verified:          true,
+			Optimistic:        optimistic,
 		},
 	})
 }

beacon-chain/blockchain/testing/mock.go

@@ -53,6 +53,7 @@ type ChainService struct {
 	InitSyncBlockRoots          map[[32]byte]bool
 	DB                          db.Database
 	State                       state.BeaconState
+	HeadStateErr                error
 	Block                       interfaces.ReadOnlySignedBeaconBlock
 	VerifyBlkDescendantErr      error
 	stateNotifier               statefeed.Notifier
@@ -364,6 +365,9 @@ func (s *ChainService) HeadState(context.Context) (state.BeaconState, error) {
 
 // HeadStateReadOnly mocks HeadStateReadOnly method in chain service.
 func (s *ChainService) HeadStateReadOnly(context.Context) (state.ReadOnlyBeaconState, error) {
+	if s.HeadStateErr != nil {
+		return nil, s.HeadStateErr
+	}
 	return s.State, nil
 }
 
@@ -715,3 +719,14 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil
 }
+
+// MockSyncChecker is a mock implementation of blockchain.Checker.
+// We can't make an assertion here that this is true because that would create a circular dependency.
+type MockSyncChecker struct {
+	synced bool
+}
+
+// Synced satisfies the blockchain.Checker interface.
+func (m *MockSyncChecker) Synced() bool {
+	return m.synced
+}

beacon-chain/core/blocks/proposer_slashing.go

@@ -16,6 +16,9 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
+// ErrCouldNotVerifyBlockHeader is returned when a block header's signature cannot be verified.
+var ErrCouldNotVerifyBlockHeader = errors.New("could not verify beacon block header")
+
 type slashValidatorFunc func(
 	ctx context.Context,
 	st state.BeaconState,
@@ -114,7 +117,7 @@ func VerifyProposerSlashing(
 	for _, header := range headers {
 		if err := signing.ComputeDomainVerifySigningRoot(beaconState, pIdx, slots.ToEpoch(hSlot),
 			header.Header, params.BeaconConfig().DomainBeaconProposer, header.Signature); err != nil {
-			return errors.Wrap(err, "could not verify beacon block header")
+			return errors.Wrap(ErrCouldNotVerifyBlockHeader, err.Error())
 		}
 	}
 	return nil

beacon-chain/core/feed/block/events.go

@@ -11,6 +11,8 @@ const (
 
 // ReceivedBlockData is the data sent with ReceivedBlock events.
 type ReceivedBlockData struct {
-	SignedBlock  interfaces.ReadOnlySignedBeaconBlock
-	IsOptimistic bool
+	SignedBlock       interfaces.ReadOnlySignedBeaconBlock
+	CurrDependentRoot [32]byte
+	PrevDependentRoot [32]byte
+	IsOptimistic      bool
 }

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

@@ -43,6 +43,10 @@ type BlockProcessedData struct {
 	BlockRoot [32]byte
 	// SignedBlock is the physical processed block.
 	SignedBlock interfaces.ReadOnlySignedBeaconBlock
+	// CurrDependentRoot is the current dependent root
+	CurrDependentRoot [32]byte
+	// PrevDependentRoot is the previous dependent root
+	PrevDependentRoot [32]byte
 	// Verified is true if the block's BLS contents have been verified.
 	Verified bool
 	// Optimistic is true if the block is optimistic.

beacon-chain/core/fulu/upgrade.go

@@ -11,7 +11,7 @@ import (
 )
 
 // UpgradeToFulu updates inputs a generic state to return the version Fulu state.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/fork.md#upgrading-the-state
+// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/fork.md#upgrading-the-state
 func UpgradeToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
 	if err != nil {
@@ -69,6 +69,10 @@ func UpgradeToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 	if err != nil {
 		return nil, err
 	}
+	depositRequestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, err
+	}
 	depositBalanceToConsume, err := beaconState.DepositBalanceToConsume()
 	if err != nil {
 		return nil, err
@@ -154,7 +158,7 @@ func UpgradeToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
 		NextWithdrawalValidatorIndex: vi,
 		HistoricalSummaries:          summaries,
 
-		DepositRequestsStartIndex:     params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		DepositRequestsStartIndex:     depositRequestsStartIndex,
 		DepositBalanceToConsume:       depositBalanceToConsume,
 		ExitBalanceToConsume:          exitBalanceToConsume,
 		EarliestExitEpoch:             earliestExitEpoch,

beacon-chain/db/kv/state_test.go

@@ -4,7 +4,9 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/binary"
+	"fmt"
 	mathRand "math/rand"
+	"os"
 	"strconv"
 	"testing"
 	"time"
@@ -21,6 +23,8 @@ import (
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/balacode/go-delta"
+	"github.com/golang/snappy"
 	bolt "go.etcd.io/bbolt"
 )
 
@@ -1287,3 +1291,111 @@ func BenchmarkState_CheckStateSaveTime_10(b *testing.B) { checkStateSaveTime(b,
 
 func BenchmarkState_CheckStateReadTime_1(b *testing.B)  { checkStateReadTime(b, 1) }
 func BenchmarkState_CheckStateReadTime_10(b *testing.B) { checkStateReadTime(b, 10) }
+
+func TestDiff_ReadAndUnmarshal(t *testing.T) {
+	d1, err := os.ReadFile("/home/mohamad/Desktop/state1.ssz")
+	require.NoError(t, err)
+	d2, err := os.ReadFile("/home/mohamad/Desktop/state2.ssz")
+	require.NoError(t, err)
+
+	var state1, state2 ethpb.BeaconStateElectra
+	err = state1.UnmarshalSSZ(d1)
+	require.NoError(t, err)
+	err = state2.UnmarshalSSZ(d2)
+	require.NoError(t, err)
+
+	require.DeepNotEqual(t, state1, state2)
+	state1.Balances = []uint64{}
+	state2.Balances = []uint64{}
+	state1.Validators = []*ethpb.Validator{}
+	state2.Validators = []*ethpb.Validator{}
+
+	dd1, err := state1.MarshalSSZ()
+	require.NoError(t, err)
+	dd2, err := state2.MarshalSSZ()
+	require.NoError(t, err)
+
+	d1snappy := snappy.Encode(nil, dd1)
+	d2snappy := snappy.Encode(nil, dd2)
+
+	//var patch []byte
+
+	start := time.Now()
+
+	dlta := delta.Make(d1snappy, d2snappy)
+
+	elapsed := time.Since(start)
+	fmt.Printf("Function took %s\n", elapsed)
+
+	dltabytes := dlta.Bytes()
+	p, err := delta.Load(dltabytes)
+	require.NoError(t, err)
+
+	fmt.Println(len(p.Bytes()))
+
+	start = time.Now()
+
+	newd, err := p.Apply(d1snappy)
+	require.NoError(t, err)
+
+	elapsed = time.Since(start)
+	fmt.Printf("Function2 took %s\n", elapsed)
+
+	newSSZ, err := snappy.Decode(nil, newd)
+	require.NoError(t, err)
+	var state3 ethpb.BeaconStateElectra
+	err = state3.UnmarshalSSZ(newSSZ)
+	require.NoError(t, err)
+
+	//
+	//fmt.Println(state1.Slot, len(d1), state2.Slot, len(d2))
+	//
+	//fmt.Println(state1.Validators[1923842])
+	//fmt.Println(state2.Validators[1923842])
+}
+
+// BeaconStateDiff holds separate compressed diffs for balances, validators, and the rest of the state.
+//type BeaconStateDiff struct {
+//	BalancesDiff   []byte // snappy-compressed XOR diff of balances SSZ
+//	ValidatorsDiff []byte // snappy-compressed XOR diff of validators SSZ
+//	RestDiff       []byte // snappy-compressed XOR diff of the rest of the state SSZ
+//}
+//
+//func stateDiff(s1, s2 *ethpb.BeaconStateElectra) (*BeaconStateDiff, error) {
+//	// 1) Balances
+//	baseBalBytes, err := bytesutil.tobytes
+//	targetBalBytes := ssz.Marshal(s2.Balances)
+//	balDiff, err := xorAndCompress(baseBalBytes, targetBalBytes)
+//	if err != nil {
+//		return nil, fmt.Errorf("balance diff: %w", err)
+//	}
+//
+//	// 2) Validators
+//	baseValBytes, _ := ssz.MarshalSSZ(s1.Validators)
+//	targetValBytes := ssz.Marshal(s2.Validators)
+//	valDiff, err := xorAndCompress(baseValBytes, targetValBytes)
+//	if err != nil {
+//		return nil, fmt.Errorf("validator diff: %w", err)
+//	}
+//
+//	// 3) Rest of state: zero out balances & validators
+//	baseCopy := *s1
+//	baseCopy.Balances = nil
+//	baseCopy.Validators = nil
+//	targCopy := *s2
+//	targCopy.Balances = nil
+//	targCopy.Validators = nil
+//
+//	baseRestBytes := ssz.Marshal(&baseCopy)
+//	targRestBytes := ssz.Marshal(&targCopy)
+//	restDiff, err := xorAndCompress(baseRestBytes, targRestBytes)
+//	if err != nil {
+//		return nil, fmt.Errorf("rest diff: %w", err)
+//	}
+//
+//	return &BeaconStateDiff{
+//		BalancesDiff:   balDiff,
+//		ValidatorsDiff: valDiff,
+//		RestDiff:       restDiff,
+//	}, nil
+//}

beacon-chain/node/node.go

@@ -865,6 +865,7 @@ func (b *BeaconNode) registerSyncService(initialSyncComplete chan struct{}, bFil
 		regularsync.WithVerifierWaiter(b.verifyInitWaiter),
 		regularsync.WithAvailableBlocker(bFillStore),
 		regularsync.WithSlasherEnabled(b.slasherEnabled),
+		regularsync.WithLightClientStore(b.lcStore),
 	)
 	return b.services.RegisterService(rs)
 }

beacon-chain/p2p/BUILD.bazel

@@ -56,6 +56,7 @@ go_library(
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//container/leaky-bucket:go_default_library",
@@ -140,6 +141,7 @@ go_test(
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
@@ -152,6 +154,7 @@ go_test(
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//container/leaky-bucket:go_default_library",
@@ -163,10 +166,12 @@ go_test(
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",

beacon-chain/p2p/broadcaster.go

@@ -10,9 +10,11 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
@@ -268,6 +270,58 @@ func (s *Service) internalBroadcastBlob(ctx context.Context, subnet uint64, blob
 	}
 }
 
+func (s *Service) BroadcastLightClientOptimisticUpdate(ctx context.Context, update interfaces.LightClientOptimisticUpdate) error {
+	ctx, span := trace.StartSpan(ctx, "p2p.BroadcastLightClientOptimisticUpdate")
+	defer span.End()
+
+	if update == nil || update.IsNil() {
+		return errors.New("attempted to broadcast nil light client optimistic update")
+	}
+
+	forkDigest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(update.AttestedHeader().Beacon().Slot), s.genesisValidatorsRoot)
+	if err != nil {
+		err := errors.Wrap(err, "could not retrieve fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	// TODO: should we check if the update is too early or too late to broadcast?
+
+	if err := s.broadcastObject(ctx, update, lcOptimisticToTopic(forkDigest)); err != nil {
+		err := errors.Wrap(err, "could not publish message")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	return nil
+}
+
+func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update interfaces.LightClientFinalityUpdate) error {
+	ctx, span := trace.StartSpan(ctx, "p2p.BroadcastLightClientFinalityUpdate")
+	defer span.End()
+
+	if update == nil || update.IsNil() {
+		return errors.New("attempted to broadcast nil light client finality update")
+	}
+
+	forkDigest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(update.AttestedHeader().Beacon().Slot), s.genesisValidatorsRoot)
+	if err != nil {
+		err := errors.Wrap(err, "could not retrieve fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	// TODO: should we check if the update is too early or too late to broadcast?
+
+	if err := s.broadcastObject(ctx, update, lcFinalityToTopic(forkDigest)); err != nil {
+		err := errors.Wrap(err, "could not publish message")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	return nil
+}
+
 // method to broadcast messages to other peers in our gossip mesh.
 func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic string) error {
 	ctx, span := trace.StartSpan(ctx, "p2p.broadcastObject")
@@ -308,3 +362,11 @@ func syncCommitteeToTopic(subnet uint64, forkDigest [4]byte) string {
 func blobSubnetToTopic(subnet uint64, forkDigest [4]byte) string {
 	return fmt.Sprintf(BlobSubnetTopicFormat, forkDigest, subnet)
 }
+
+func lcOptimisticToTopic(forkDigest [4]byte) string {
+	return fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, forkDigest)
+}
+
+func lcFinalityToTopic(forkDigest [4]byte) string {
+	return fmt.Sprintf(LightClientFinalityUpdateTopicFormat, forkDigest)
+}

beacon-chain/p2p/broadcaster_test.go

@@ -10,17 +10,22 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/wrapper"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	testpb "github.com/OffchainLabs/prysm/v6/proto/testing"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/prysmaticlabs/go-bitfield"
@@ -516,3 +521,137 @@ func TestService_BroadcastBlob(t *testing.T) {
 	require.NoError(t, p.BroadcastBlob(ctx, subnet, blobSidecar))
 	require.Equal(t, false, util.WaitTimeout(&wg, 1*time.Second), "Failed to receive pubsub within 1s")
 }
+
+func TestService_BroadcastLightClientOptimisticUpdate(t *testing.T) {
+	p1 := p2ptest.NewTestP2P(t)
+	p2 := p2ptest.NewTestP2P(t)
+	p1.Connect(p2)
+	require.NotEqual(t, 0, len(p1.BHost.Network().Peers()))
+
+	p := &Service{
+		host:                  p1.BHost,
+		pubsub:                p1.PubSub(),
+		joinedTopics:          map[string]*pubsub.Topic{},
+		cfg:                   &Config{},
+		genesisTime:           time.Now(),
+		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
+		subnetsLock:           make(map[uint64]*sync.RWMutex),
+		subnetsLockLock:       sync.Mutex{},
+		peers: peers.NewStatus(context.Background(), &peers.StatusConfig{
+			ScorerParams: &scorers.Config{},
+		}),
+	}
+
+	l := util.NewTestLightClient(t, version.Altair)
+	msg, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
+	require.NoError(t, err)
+
+	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientOptimisticUpdateTopicFormat
+	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
+	require.NoError(t, err)
+	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, digest)
+
+	// External peer subscribes to the topic.
+	topic += p.Encoding().ProtocolSuffix()
+	sub, err := p2.SubscribeToTopic(topic)
+	require.NoError(t, err)
+
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
+
+	// Async listen for the pubsub, must be before the broadcast.
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func(tt *testing.T) {
+		defer wg.Done()
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+		defer cancel()
+
+		incomingMessage, err := sub.Next(ctx)
+		require.NoError(t, err)
+
+		result := &ethpb.LightClientOptimisticUpdateAltair{}
+		require.NoError(t, p.Encoding().DecodeGossip(incomingMessage.Data, result))
+		if !proto.Equal(result, msg.Proto()) {
+			tt.Errorf("Did not receive expected message, got %+v, wanted %+v", result, msg)
+		}
+	}(t)
+
+	// Broadcasting nil should fail.
+	ctx := context.Background()
+	require.ErrorContains(t, "attempted to broadcast nil", p.BroadcastLightClientOptimisticUpdate(ctx, nil))
+	var nilUpdate interfaces.LightClientOptimisticUpdate
+	require.ErrorContains(t, "attempted to broadcast nil", p.BroadcastLightClientOptimisticUpdate(ctx, nilUpdate))
+
+	// Broadcast to peers and wait.
+	require.NoError(t, p.BroadcastLightClientOptimisticUpdate(ctx, msg))
+	if util.WaitTimeout(&wg, 1*time.Second) {
+		t.Error("Failed to receive pubsub within 1s")
+	}
+}
+
+func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
+	p1 := p2ptest.NewTestP2P(t)
+	p2 := p2ptest.NewTestP2P(t)
+	p1.Connect(p2)
+	require.NotEqual(t, 0, len(p1.BHost.Network().Peers()))
+
+	p := &Service{
+		host:                  p1.BHost,
+		pubsub:                p1.PubSub(),
+		joinedTopics:          map[string]*pubsub.Topic{},
+		cfg:                   &Config{},
+		genesisTime:           time.Now(),
+		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
+		subnetsLock:           make(map[uint64]*sync.RWMutex),
+		subnetsLockLock:       sync.Mutex{},
+		peers: peers.NewStatus(context.Background(), &peers.StatusConfig{
+			ScorerParams: &scorers.Config{},
+		}),
+	}
+
+	l := util.NewTestLightClient(t, version.Altair)
+	msg, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+	require.NoError(t, err)
+
+	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientFinalityUpdateTopicFormat
+	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
+	require.NoError(t, err)
+	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, digest)
+
+	// External peer subscribes to the topic.
+	topic += p.Encoding().ProtocolSuffix()
+	sub, err := p2.SubscribeToTopic(topic)
+	require.NoError(t, err)
+
+	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
+
+	// Async listen for the pubsub, must be before the broadcast.
+	var wg sync.WaitGroup
+	wg.Add(1)
+	go func(tt *testing.T) {
+		defer wg.Done()
+		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+		defer cancel()
+
+		incomingMessage, err := sub.Next(ctx)
+		require.NoError(t, err)
+
+		result := &ethpb.LightClientFinalityUpdateAltair{}
+		require.NoError(t, p.Encoding().DecodeGossip(incomingMessage.Data, result))
+		if !proto.Equal(result, msg.Proto()) {
+			tt.Errorf("Did not receive expected message, got %+v, wanted %+v", result, msg)
+		}
+	}(t)
+
+	// Broadcasting nil should fail.
+	ctx := context.Background()
+	require.ErrorContains(t, "attempted to broadcast nil", p.BroadcastLightClientFinalityUpdate(ctx, nil))
+	var nilUpdate interfaces.LightClientFinalityUpdate
+	require.ErrorContains(t, "attempted to broadcast nil", p.BroadcastLightClientFinalityUpdate(ctx, nilUpdate))
+
+	// Broadcast to peers and wait.
+	require.NoError(t, p.BroadcastLightClientFinalityUpdate(ctx, msg))
+	if util.WaitTimeout(&wg, 1*time.Second) {
+		t.Error("Failed to receive pubsub within 1s")
+	}
+}

beacon-chain/p2p/discovery.go

@@ -105,7 +105,8 @@ func (l *listenerWrapper) RandomNodes() enode.Iterator {
 func (l *listenerWrapper) Ping(node *enode.Node) error {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
-	return l.listener.Ping(node)
+	_, err := l.listener.Ping(node)
+	return err
 }
 
 func (l *listenerWrapper) RequestENR(node *enode.Node) (*enode.Node, error) {

beacon-chain/p2p/gossip_scoring_params.go

@@ -44,6 +44,12 @@ const (
 	// blsToExecutionChangeWeight specifies the scoring weight that we apply to
 	// our bls to execution topic.
 	blsToExecutionChangeWeight = 0.05
+	// lightClientOptimisticUpdateWeight specifies the scoring weight that we apply to
+	// our light client optimistic update topic.
+	lightClientOptimisticUpdateWeight = 0.05
+	// lightClientFinalityUpdateWeight specifies the scoring weight that we apply to
+	// our light client finality update topic.
+	lightClientFinalityUpdateWeight = 0.05
 
 	// maxInMeshScore describes the max score a peer can attain from being in the mesh.
 	maxInMeshScore = 10
@@ -124,6 +130,10 @@ func (s *Service) topicScoreParams(topic string) (*pubsub.TopicScoreParams, erro
 	case strings.Contains(topic, GossipBlobSidecarMessage):
 		// TODO(Deneb): Using the default block scoring. But this should be updated.
 		return defaultBlockTopicParams(), nil
+	case strings.Contains(topic, GossipLightClientOptimisticUpdateMessage):
+		return defaultLightClientOptimisticUpdateTopicParams(), nil
+	case strings.Contains(topic, GossipLightClientFinalityUpdateMessage):
+		return defaultLightClientFinalityUpdateTopicParams(), nil
 	default:
 		return nil, errors.Errorf("unrecognized topic provided for parameter registration: %s", topic)
 	}
@@ -503,6 +513,50 @@ func defaultBlsToExecutionChangeTopicParams() *pubsub.TopicScoreParams {
 	}
 }
 
+func defaultLightClientOptimisticUpdateTopicParams() *pubsub.TopicScoreParams {
+	return &pubsub.TopicScoreParams{
+		TopicWeight:                     lightClientOptimisticUpdateWeight,
+		TimeInMeshWeight:                maxInMeshScore / inMeshCap(),
+		TimeInMeshQuantum:               inMeshTime(),
+		TimeInMeshCap:                   inMeshCap(),
+		FirstMessageDeliveriesWeight:    2,
+		FirstMessageDeliveriesDecay:     scoreDecay(oneHundredEpochs),
+		FirstMessageDeliveriesCap:       5,
+		MeshMessageDeliveriesWeight:     0,
+		MeshMessageDeliveriesDecay:      0,
+		MeshMessageDeliveriesCap:        0,
+		MeshMessageDeliveriesThreshold:  0,
+		MeshMessageDeliveriesWindow:     0,
+		MeshMessageDeliveriesActivation: 0,
+		MeshFailurePenaltyWeight:        0,
+		MeshFailurePenaltyDecay:         0,
+		InvalidMessageDeliveriesWeight:  -2000,
+		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
+	}
+}
+
+func defaultLightClientFinalityUpdateTopicParams() *pubsub.TopicScoreParams {
+	return &pubsub.TopicScoreParams{
+		TopicWeight:                     lightClientFinalityUpdateWeight,
+		TimeInMeshWeight:                maxInMeshScore / inMeshCap(),
+		TimeInMeshQuantum:               inMeshTime(),
+		TimeInMeshCap:                   inMeshCap(),
+		FirstMessageDeliveriesWeight:    2,
+		FirstMessageDeliveriesDecay:     scoreDecay(oneHundredEpochs),
+		FirstMessageDeliveriesCap:       5,
+		MeshMessageDeliveriesWeight:     0,
+		MeshMessageDeliveriesDecay:      0,
+		MeshMessageDeliveriesCap:        0,
+		MeshMessageDeliveriesThreshold:  0,
+		MeshMessageDeliveriesWindow:     0,
+		MeshMessageDeliveriesActivation: 0,
+		MeshFailurePenaltyWeight:        0,
+		MeshFailurePenaltyDecay:         0,
+		InvalidMessageDeliveriesWeight:  -2000,
+		InvalidMessageDeliveriesDecay:   scoreDecay(invalidDecayPeriod),
+	}
+}
+
 func oneSlotDuration() time.Duration {
 	return time.Duration(params.BeaconConfig().SecondsPerSlot) * time.Second
 }

beacon-chain/p2p/gossip_scoring_params_test.go

@@ -75,4 +75,6 @@ func TestLoggingParameters(_ *testing.T) {
 	logGossipParameters("testing", defaultAttesterSlashingTopicParams())
 	logGossipParameters("testing", defaultProposerSlashingTopicParams())
 	logGossipParameters("testing", defaultVoluntaryExitTopicParams())
+	logGossipParameters("testing", defaultLightClientOptimisticUpdateTopicParams())
+	logGossipParameters("testing", defaultLightClientFinalityUpdateTopicParams())
 }

beacon-chain/p2p/gossip_topic_mappings.go

@@ -22,6 +22,8 @@ var gossipTopicMappings = map[string]func() proto.Message{
 	SyncCommitteeSubnetTopicFormat:            func() proto.Message { return &ethpb.SyncCommitteeMessage{} },
 	BlsToExecutionChangeSubnetTopicFormat:     func() proto.Message { return &ethpb.SignedBLSToExecutionChange{} },
 	BlobSubnetTopicFormat:                     func() proto.Message { return &ethpb.BlobSidecar{} },
+	LightClientOptimisticUpdateTopicFormat:    func() proto.Message { return &ethpb.LightClientOptimisticUpdateAltair{} },
+	LightClientFinalityUpdateTopicFormat:      func() proto.Message { return &ethpb.LightClientFinalityUpdateAltair{} },
 }
 
 // GossipTopicMappings is a function to return the assigned data type
@@ -63,6 +65,25 @@ func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 			return &ethpb.SignedAggregateAttestationAndProofElectra{}
 		}
 		return gossipMessage(topic)
+	case LightClientOptimisticUpdateTopicFormat:
+		if epoch >= params.BeaconConfig().DenebForkEpoch {
+			return &ethpb.LightClientOptimisticUpdateDeneb{}
+		}
+		if epoch >= params.BeaconConfig().CapellaForkEpoch {
+			return &ethpb.LightClientOptimisticUpdateCapella{}
+		}
+		return gossipMessage(topic)
+	case LightClientFinalityUpdateTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.LightClientFinalityUpdateElectra{}
+		}
+		if epoch >= params.BeaconConfig().DenebForkEpoch {
+			return &ethpb.LightClientFinalityUpdateDeneb{}
+		}
+		if epoch >= params.BeaconConfig().CapellaForkEpoch {
+			return &ethpb.LightClientFinalityUpdateCapella{}
+		}
+		return gossipMessage(topic)
 	default:
 		return gossipMessage(topic)
 	}
@@ -97,21 +118,28 @@ func init() {
 
 	// Specially handle Altair objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockAltair{})] = BlockSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientFinalityUpdateAltair{})] = LightClientFinalityUpdateTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientOptimisticUpdateAltair{})] = LightClientOptimisticUpdateTopicFormat
 
 	// Specially handle Bellatrix objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockBellatrix{})] = BlockSubnetTopicFormat
 
 	// Specially handle Capella objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockCapella{})] = BlockSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientOptimisticUpdateCapella{})] = LightClientOptimisticUpdateTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientFinalityUpdateCapella{})] = LightClientFinalityUpdateTopicFormat
 
 	// Specially handle Deneb objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockDeneb{})] = BlockSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientOptimisticUpdateDeneb{})] = LightClientOptimisticUpdateTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientFinalityUpdateDeneb{})] = LightClientFinalityUpdateTopicFormat
 
 	// Specially handle Electra objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockElectra{})] = BlockSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SingleAttestation{})] = AttestationSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.AttesterSlashingElectra{})] = AttesterSlashingSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedAggregateAttestationAndProofElectra{})] = AggregateAndProofSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.LightClientFinalityUpdateElectra{})] = LightClientFinalityUpdateTopicFormat
 
 	// Specially handle Fulu objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockFulu{})] = BlockSubnetTopicFormat

beacon-chain/p2p/gossip_topic_mappings_test.go

@@ -73,6 +73,12 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, altairForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientOptimisticUpdateTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientOptimisticUpdateAltair)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientFinalityUpdateTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientFinalityUpdateAltair)
+	assert.Equal(t, true, ok)
 
 	// Bellatrix Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, bellatrixForkEpoch)
@@ -87,6 +93,12 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, bellatrixForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientOptimisticUpdateTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientOptimisticUpdateAltair)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientFinalityUpdateTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientFinalityUpdateAltair)
+	assert.Equal(t, true, ok)
 
 	// Capella Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, capellaForkEpoch)
@@ -101,6 +113,12 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, capellaForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientOptimisticUpdateTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientOptimisticUpdateCapella)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientFinalityUpdateTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientFinalityUpdateCapella)
+	assert.Equal(t, true, ok)
 
 	// Deneb Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, denebForkEpoch)
@@ -115,6 +133,12 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, denebForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientOptimisticUpdateTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientOptimisticUpdateDeneb)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientFinalityUpdateTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientFinalityUpdateDeneb)
+	assert.Equal(t, true, ok)
 
 	// Electra Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, electraForkEpoch)
@@ -129,4 +153,10 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, electraForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProofElectra)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientOptimisticUpdateTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientOptimisticUpdateDeneb)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(LightClientFinalityUpdateTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.LightClientFinalityUpdateElectra)
+	assert.Equal(t, true, ok)
 }

beacon-chain/p2p/peers/scorers/bad_responses.go

@@ -102,6 +102,9 @@ func (s *BadResponsesScorer) countNoLock(pid peer.ID) (int, error) {
 // Increment increments the number of bad responses we have received from the given remote peer.
 // If peer doesn't exist this method is no-op.
 func (s *BadResponsesScorer) Increment(pid peer.ID) {
+	if pid == "" {
+		return
+	}
 	s.store.Lock()
 	defer s.store.Unlock()
 

beacon-chain/p2p/peers/scorers/block_providers.go

@@ -124,6 +124,9 @@ func (s *BlockProviderScorer) Params() *BlockProviderScorerConfig {
 
 // IncrementProcessedBlocks increments the number of blocks that have been successfully processed.
 func (s *BlockProviderScorer) IncrementProcessedBlocks(pid peer.ID, cnt uint64) {
+	if pid == "" {
+		return
+	}
 	s.store.Lock()
 	defer s.store.Unlock()
 	defer s.touchNoLock(pid)

beacon-chain/p2p/topics.go

@@ -30,6 +30,10 @@ const (
 	GossipBlsToExecutionChangeMessage = "bls_to_execution_change"
 	// GossipBlobSidecarMessage is the name for the blob sidecar message type.
 	GossipBlobSidecarMessage = "blob_sidecar"
+	// GossipLightClientFinalityUpdateMessage is the name for the light client finality update message type.
+	GossipLightClientFinalityUpdateMessage = "light_client_finality_update"
+	// GossipLightClientOptimisticUpdateMessage is the name for the light client optimistic update message type.
+	GossipLightClientOptimisticUpdateMessage = "light_client_optimistic_update"
 	// Topic Formats
 	//
 	// AttestationSubnetTopicFormat is the topic format for the attestation subnet.
@@ -52,4 +56,8 @@ const (
 	BlsToExecutionChangeSubnetTopicFormat = GossipProtocolAndDigest + GossipBlsToExecutionChangeMessage
 	// BlobSubnetTopicFormat is the topic format for the blob subnet.
 	BlobSubnetTopicFormat = GossipProtocolAndDigest + GossipBlobSidecarMessage + "_%d"
+	// LightClientFinalityUpdateTopicFormat is the topic format for the light client finality update subnet.
+	LightClientFinalityUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientFinalityUpdateMessage
+	// LightClientOptimisticUpdateTopicFormat is the topic format for the light client optimistic update subnet.
+	LightClientOptimisticUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientOptimisticUpdateMessage
 )

beacon-chain/p2p/types/BUILD.bazel

@@ -21,6 +21,7 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/p2p/types/object_mapping.go

@@ -4,6 +4,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	lightclientConsensusTypes "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/wrapper"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
@@ -36,6 +37,12 @@ var (
 	// AttesterSlashingMap maps the fork-version to the underlying data type for that particular
 	// fork period.
 	AttesterSlashingMap map[[4]byte]func() (ethpb.AttSlashing, error)
+	// LightClientOptimisticUpdateMap maps the fork-version to the underlying data type for that
+	// particular fork period.
+	LightClientOptimisticUpdateMap map[[4]byte]func() (interfaces.LightClientOptimisticUpdate, error)
+	// LightClientFinalityUpdateMap maps the fork-version to the underlying data type for that
+	// particular fork period.
+	LightClientFinalityUpdateMap map[[4]byte]func() (interfaces.LightClientFinalityUpdate, error)
 )
 
 // InitializeDataMaps initializes all the relevant object maps. This function is called to
@@ -179,4 +186,42 @@ func InitializeDataMaps() {
 			return &ethpb.AttesterSlashingElectra{}, nil
 		},
 	}
+
+	// Reset our light client optimistic update map.
+	LightClientOptimisticUpdateMap = map[[4]byte]func() (interfaces.LightClientOptimisticUpdate, error){
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateAltair(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateAltair(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateCapella(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientOptimisticUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyOptimisticUpdateDeneb(), nil
+		},
+	}
+
+	// Reset our light client finality update map.
+	LightClientFinalityUpdateMap = map[[4]byte]func() (interfaces.LightClientFinalityUpdate, error){
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateAltair(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateAltair(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateCapella(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateDeneb(), nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.LightClientFinalityUpdate, error) {
+			return lightclientConsensusTypes.NewEmptyFinalityUpdateElectra(), nil
+		},
+	}
 }

beacon-chain/p2p/types/types.go

@@ -162,9 +162,9 @@ func (b *BlobSidecarsByRootReq) MarshalSSZ() ([]byte, error) {
 // BlobSidecarsByRootReq value.
 func (b *BlobSidecarsByRootReq) UnmarshalSSZ(buf []byte) error {
 	bufLen := len(buf)
-	maxLength := int(params.BeaconConfig().MaxRequestBlobSidecars) * blobIdSize
+	maxLength := int(params.BeaconConfig().MaxRequestBlobSidecarsElectra) * blobIdSize
 	if bufLen > maxLength {
-		return errors.Errorf("expected buffer with length of up to %d but received length %d", maxLength, bufLen)
+		return errors.Wrapf(ssz.ErrIncorrectListSize, "expected buffer with length of up to %d but received length %d", maxLength, bufLen)
 	}
 	if bufLen%blobIdSize != 0 {
 		return errors.Wrapf(ssz.ErrIncorrectByteSize, "size=%d", bufLen)

beacon-chain/p2p/types/types_test.go

@@ -43,6 +43,15 @@ func TestBlobSidecarsByRootReq_MarshalSSZ(t *testing.T) {
 			name: "10 item list",
 			ids:  generateBlobIdentifiers(10),
 		},
+		{
+			name: "max list",
+			ids:  generateBlobIdentifiers(int(params.BeaconConfig().MaxRequestBlobSidecarsElectra)),
+		},
+		{
+			name:         "beyond max list",
+			ids:          generateBlobIdentifiers(int(params.BeaconConfig().MaxRequestBlobSidecarsElectra) + 1),
+			unmarshalErr: ssz.ErrIncorrectListSize,
+		},
 		{
 			name: "wonky unmarshal size",
 			ids:  generateBlobIdentifiers(10),

beacon-chain/rpc/endpoints.go

@@ -894,6 +894,15 @@ func (s *Service) beaconEndpoints(
 			handler: server.GetPendingDeposits,
 			methods: []string{http.MethodGet},
 		},
+		{
+			template: "/eth/v1/beacon/states/{state_id}/pending_consolidations",
+			name:     namespace + ".GetPendingConsolidations",
+			middleware: []middleware.Middleware{
+				middleware.AcceptHeaderHandler([]string{api.JsonMediaType}),
+			},
+			handler: server.GetPendingDeposits,
+			methods: []string{http.MethodGet},
+		},
 		{
 			template: "/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals",
 			name:     namespace + ".GetPendingPartialWithdrawals",
@@ -1041,6 +1050,7 @@ func (s *Service) eventsEndpoints() []endpoint {
 		HeadFetcher:            s.cfg.HeadFetcher,
 		ChainInfoFetcher:       s.cfg.ChainInfoFetcher,
 		TrackedValidatorsCache: s.cfg.TrackedValidatorsCache,
+		StateGen:               s.cfg.StateGen,
 	}
 
 	const namespace = "events"

beacon-chain/rpc/endpoints_test.go

@@ -30,6 +30,7 @@ func Test_endpoints(t *testing.T) {
 		"/eth/v1/beacon/states/{state_id}/randao":                      {http.MethodGet},
 		"/eth/v1/beacon/states/{state_id}/pending_deposits":            {http.MethodGet},
 		"/eth/v1/beacon/states/{state_id}/pending_partial_withdrawals": {http.MethodGet},
+		"/eth/v1/beacon/states/{state_id}/pending_consolidations":      {http.MethodGet},
 		"/eth/v1/beacon/headers":                                       {http.MethodGet},
 		"/eth/v1/beacon/headers/{block_id}":                            {http.MethodGet},
 		"/eth/v1/beacon/blinded_blocks":                                {http.MethodPost},

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

@@ -1613,6 +1613,62 @@ func (s *Server) broadcastSeenBlockSidecars(
 	return nil
 }
 
+// GetPendingConsolidations returns pending deposits for state with given 'stateId'.
+// Should return 400 if the state retrieved is prior to Electra.
+// Supports both JSON and SSZ responses based on Accept header.
+func (s *Server) GetPendingConsolidations(w http.ResponseWriter, r *http.Request) {
+	ctx, span := trace.StartSpan(r.Context(), "beacon.GetPendingDeposits")
+	defer span.End()
+
+	stateId := r.PathValue("state_id")
+	if stateId == "" {
+		httputil.HandleError(w, "state_id is required in URL params", http.StatusBadRequest)
+		return
+	}
+	st, err := s.Stater.State(ctx, []byte(stateId))
+	if err != nil {
+		shared.WriteStateFetchError(w, err)
+		return
+	}
+	if st.Version() < version.Electra {
+		httputil.HandleError(w, "state_id is prior to electra", http.StatusBadRequest)
+		return
+	}
+	pd, err := st.PendingConsolidations()
+	if err != nil {
+		httputil.HandleError(w, "Could not get pending consolidations: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set(api.VersionHeader, version.String(st.Version()))
+	if httputil.RespondWithSsz(r) {
+		sszData, err := serializeItems(pd)
+		if err != nil {
+			httputil.HandleError(w, "Failed to serialize pending consolidations: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, sszData)
+	} else {
+		isOptimistic, err := helpers.IsOptimistic(ctx, []byte(stateId), s.OptimisticModeFetcher, s.Stater, s.ChainInfoFetcher, s.BeaconDB)
+		if err != nil {
+			httputil.HandleError(w, "Could not check optimistic status: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		blockRoot, err := st.LatestBlockHeader().HashTreeRoot()
+		if err != nil {
+			httputil.HandleError(w, "Could not calculate root of latest block header: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		isFinalized := s.FinalizationFetcher.IsFinalized(ctx, blockRoot)
+		resp := structs.GetPendingConsolidationsResponse{
+			Version:             version.String(st.Version()),
+			ExecutionOptimistic: isOptimistic,
+			Finalized:           isFinalized,
+			Data:                structs.PendingConsolidationsFromConsensus(pd),
+		}
+		httputil.WriteJson(w, resp)
+	}
+}
+
 // GetPendingDeposits returns pending deposits for state with given 'stateId'.
 // Should return 400 if the state retrieved is prior to Electra.
 // Supports both JSON and SSZ responses based on Accept header.

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

@@ -4755,6 +4755,191 @@ func Test_validateBlobSidecars(t *testing.T) {
 	require.ErrorContains(t, "could not verify blob proof: can't verify opening proof", s.validateBlobSidecars(b, [][]byte{blob[:]}, [][]byte{proof[:]}))
 }
 
+func TestGetPendingConsolidations(t *testing.T) {
+	st, _ := util.DeterministicGenesisStateElectra(t, 10)
+
+	cs := make([]*eth.PendingConsolidation, 10)
+	for i := 0; i < len(cs); i += 1 {
+		cs[i] = &eth.PendingConsolidation{
+			SourceIndex: primitives.ValidatorIndex(i),
+			TargetIndex: primitives.ValidatorIndex(i + 1),
+		}
+	}
+	require.NoError(t, st.SetPendingConsolidations(cs))
+
+	chainService := &chainMock.ChainService{
+		Optimistic:     false,
+		FinalizedRoots: map[[32]byte]bool{},
+	}
+	server := &Server{
+		Stater: &testutil.MockStater{
+			BeaconState: st,
+		},
+		OptimisticModeFetcher: chainService,
+		FinalizationFetcher:   chainService,
+	}
+
+	t.Run("json response", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingConsolidations(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+		require.Equal(t, "electra", rec.Header().Get(api.VersionHeader))
+
+		var resp structs.GetPendingConsolidationsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+
+		expectedVersion := version.String(st.Version())
+		require.Equal(t, expectedVersion, resp.Version)
+
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
+
+		expectedConsolidations := structs.PendingConsolidationsFromConsensus(cs)
+		require.DeepEqual(t, expectedConsolidations, resp.Data)
+	})
+	t.Run("ssz response", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		req.Header.Set("Accept", "application/octet-stream")
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingConsolidations(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+		require.Equal(t, "electra", rec.Header().Get(api.VersionHeader))
+
+		responseBytes := rec.Body.Bytes()
+		var recoveredConsolidations []*eth.PendingConsolidation
+
+		// Verify total size matches expected number of deposits
+		consolidationSize := (&eth.PendingConsolidation{}).SizeSSZ()
+		require.Equal(t, len(responseBytes), consolidationSize*len(cs))
+
+		for i := 0; i < len(cs); i++ {
+			start := i * consolidationSize
+			end := start + consolidationSize
+
+			var c eth.PendingConsolidation
+			require.NoError(t, c.UnmarshalSSZ(responseBytes[start:end]))
+			recoveredConsolidations = append(recoveredConsolidations, &c)
+		}
+		require.DeepEqual(t, cs, recoveredConsolidations)
+	})
+	t.Run("pre electra state", func(t *testing.T) {
+		preElectraSt, _ := util.DeterministicGenesisStateDeneb(t, 1)
+		preElectraServer := &Server{
+			Stater: &testutil.MockStater{
+				BeaconState: preElectraSt,
+			},
+			OptimisticModeFetcher: chainService,
+			FinalizationFetcher:   chainService,
+		}
+
+		// Test JSON request
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		preElectraServer.GetPendingConsolidations(rec, req)
+		require.Equal(t, http.StatusBadRequest, rec.Code)
+
+		var errResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &errResp))
+		require.Equal(t, "state_id is prior to electra", errResp.Message)
+
+		// Test SSZ request
+		sszReq := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		sszReq.Header.Set("Accept", "application/octet-stream")
+		sszReq.SetPathValue("state_id", "head")
+		sszRec := httptest.NewRecorder()
+		sszRec.Body = new(bytes.Buffer)
+
+		preElectraServer.GetPendingConsolidations(sszRec, sszReq)
+		require.Equal(t, http.StatusBadRequest, sszRec.Code)
+
+		var sszErrResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(sszRec.Body.Bytes(), &sszErrResp))
+		require.Equal(t, "state_id is prior to electra", sszErrResp.Message)
+	})
+	t.Run("missing state_id parameter", func(t *testing.T) {
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		// Intentionally not setting state_id
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		server.GetPendingConsolidations(rec, req)
+		require.Equal(t, http.StatusBadRequest, rec.Code)
+
+		var errResp struct {
+			Code    int    `json:"code"`
+			Message string `json:"message"`
+		}
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &errResp))
+		require.Equal(t, "state_id is required in URL params", errResp.Message)
+	})
+	t.Run("optimistic node", func(t *testing.T) {
+		optimisticChainService := &chainMock.ChainService{
+			Optimistic:     true,
+			FinalizedRoots: map[[32]byte]bool{},
+		}
+		optimisticServer := &Server{
+			Stater:                server.Stater,
+			OptimisticModeFetcher: optimisticChainService,
+			FinalizationFetcher:   optimisticChainService,
+		}
+
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		optimisticServer.GetPendingConsolidations(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+
+		var resp structs.GetPendingConsolidationsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+		require.Equal(t, true, resp.ExecutionOptimistic)
+	})
+
+	t.Run("finalized node", func(t *testing.T) {
+		blockRoot, err := st.LatestBlockHeader().HashTreeRoot()
+		require.NoError(t, err)
+
+		finalizedChainService := &chainMock.ChainService{
+			Optimistic:     false,
+			FinalizedRoots: map[[32]byte]bool{blockRoot: true},
+		}
+		finalizedServer := &Server{
+			Stater:                server.Stater,
+			OptimisticModeFetcher: finalizedChainService,
+			FinalizationFetcher:   finalizedChainService,
+		}
+
+		req := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/beacon/states/{state_id}/pending_consolidations", nil)
+		req.SetPathValue("state_id", "head")
+		rec := httptest.NewRecorder()
+		rec.Body = new(bytes.Buffer)
+
+		finalizedServer.GetPendingConsolidations(rec, req)
+		require.Equal(t, http.StatusOK, rec.Code)
+
+		var resp structs.GetPendingConsolidationsResponse
+		require.NoError(t, json.Unmarshal(rec.Body.Bytes(), &resp))
+		require.Equal(t, true, resp.Finalized)
+	})
+}
+
 func TestGetPendingDeposits(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateElectra(t, 10)
 

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

@@ -20,6 +20,7 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/payload-attribute:go_default_library",
@@ -53,6 +54,7 @@ go_test(
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/stategen/mock:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

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

@@ -37,7 +37,6 @@ import (
 )
 
 const DefaultEventFeedDepth = 1000
-const payloadAttributeTimeout = 2 * time.Second
 
 const (
 	InvalidTopic = "__invalid__"
@@ -627,6 +626,7 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 }
 
 var errUnsupportedPayloadAttribute = errors.New("cannot compute payload attributes pre-Bellatrix")
+var errPayloadAttributeExpired = errors.New("skipping payload attribute event for past slot")
 
 func (s *Server) computePayloadAttributes(ctx context.Context, st state.ReadOnlyBeaconState, root [32]byte, proposer primitives.ValidatorIndex, timestamp uint64, randao []byte) (payloadattribute.Attributer, error) {
 	v := st.Version()
@@ -681,48 +681,48 @@ var zeroRoot [32]byte
 // needsFill allows tests to provide filled EventData values. An ordinary event data value fired by the blockchain package will have
 // all of the checked fields empty, so the logical short circuit should hit immediately.
 func needsFill(ev payloadattribute.EventData) bool {
-	return ev.HeadState == nil || ev.HeadState.IsNil() || ev.HeadState.LatestBlockHeader() == nil ||
-		ev.HeadBlock == nil || ev.HeadBlock.IsNil() ||
-		ev.HeadRoot == zeroRoot || len(ev.ParentBlockRoot) == 0 || len(ev.ParentBlockHash) == 0 ||
+	return len(ev.ParentBlockHash) == 0 ||
 		ev.Attributer == nil || ev.Attributer.IsEmpty()
 }
 
 func (s *Server) fillEventData(ctx context.Context, ev payloadattribute.EventData) (payloadattribute.EventData, error) {
-	var err error
-
 	if !needsFill(ev) {
 		return ev, nil
 	}
-
-	ev.HeadState, err = s.HeadFetcher.HeadState(ctx)
-	if err != nil {
-		return ev, errors.Wrap(err, "could not get head state")
+	if ev.HeadBlock == nil || ev.HeadBlock.IsNil() {
+		return ev, errors.New("head block is nil")
+	}
+	if ev.HeadRoot == zeroRoot {
+		return ev, errors.New("head root is empty")
 	}
 
-	ev.HeadBlock, err = s.HeadFetcher.HeadBlock(ctx)
-	if err != nil {
-		return ev, errors.Wrap(err, "could not look up head block")
-	}
-	ev.HeadRoot, err = ev.HeadBlock.Block().HashTreeRoot()
-	if err != nil {
-		return ev, errors.Wrap(err, "could not compute head block root")
-	}
-	pr := ev.HeadBlock.Block().ParentRoot()
-	ev.ParentBlockRoot = pr[:]
-
-	hsr, err := ev.HeadState.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return ev, errors.Wrap(err, "could not compute latest block header root")
-	}
+	var err error
+	var st state.BeaconState
 
+	// If head is in the same block as the proposal slot, we can use the "read only" state cache.
 	pse := slots.ToEpoch(ev.ProposalSlot)
-	st := ev.HeadState
-	if slots.ToEpoch(st.Slot()) != pse {
-		st, err = transition.ProcessSlotsUsingNextSlotCache(ctx, st, hsr[:], ev.ProposalSlot)
+	if slots.ToEpoch(ev.HeadBlock.Block().Slot()) == pse {
+		st = s.StateGen.StateByRootIfCachedNoCopy(ev.HeadRoot)
+	}
+	// If st is nil, we couldn't get the state from the cache, or it isn't in the same epoch.
+	if st == nil || st.IsNil() {
+		st, err = s.StateGen.StateByRoot(ctx, ev.HeadRoot)
 		if err != nil {
-			return ev, errors.Wrap(err, "could not run process blocks on head state into the proposal slot epoch")
+			return ev, errors.Wrap(err, "could not get head state")
+		}
+		// double check that we need to process_slots, just in case we got here via a hot state cache miss.
+		if slots.ToEpoch(st.Slot()) < pse {
+			start, err := slots.EpochStart(pse)
+			if err != nil {
+				return ev, errors.Wrap(err, "invalid state slot; could not compute epoch start")
+			}
+			st, err = transition.ProcessSlotsUsingNextSlotCache(ctx, st, ev.HeadRoot[:], start)
+			if err != nil {
+				return ev, errors.Wrap(err, "could not run process blocks on head state into the proposal slot epoch")
+			}
 		}
 	}
+
 	ev.ProposerIndex, err = helpers.BeaconProposerIndexAtSlot(ctx, st, ev.ProposalSlot)
 	if err != nil {
 		return ev, errors.Wrap(err, "failed to compute proposer index")
@@ -743,14 +743,18 @@ func (s *Server) fillEventData(ctx context.Context, ev payloadattribute.EventDat
 	if err != nil {
 		return ev, errors.Wrap(err, "could not get head state slot time")
 	}
-	ev.Attributer, err = s.computePayloadAttributes(ctx, st, hsr, ev.ProposerIndex, uint64(t.Unix()), randao)
+	ev.Attributer, err = s.computePayloadAttributes(ctx, st, ev.HeadRoot, ev.ProposerIndex, uint64(t.Unix()), randao)
 	return ev, err
 }
 
 // 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) payloadAttributesReader(ctx context.Context, ev payloadattribute.EventData) (lazyReader, error) {
-	ctx, cancel := context.WithTimeout(ctx, payloadAttributeTimeout)
+	deadline := slots.BeginsAt(ev.ProposalSlot, s.ChainInfoFetcher.GenesisTime())
+	if deadline.Before(time.Now()) {
+		return nil, errors.Wrapf(errPayloadAttributeExpired, "proposal slot time %d", deadline.Unix())
+	}
+	ctx, cancel := context.WithDeadline(ctx, deadline)
 	edc := make(chan asyncPayloadAttrData)
 	go func() {
 		d := asyncPayloadAttrData{}
@@ -772,7 +776,7 @@ func (s *Server) payloadAttributesReader(ctx context.Context, ev payloadattribut
 			ProposerIndex:     strconv.FormatUint(uint64(ev.ProposerIndex), 10),
 			ProposalSlot:      strconv.FormatUint(uint64(ev.ProposalSlot), 10),
 			ParentBlockNumber: strconv.FormatUint(ev.ParentBlockNumber, 10),
-			ParentBlockRoot:   hexutil.Encode(ev.ParentBlockRoot),
+			ParentBlockRoot:   hexutil.Encode(ev.HeadRoot[:]),
 			ParentBlockHash:   hexutil.Encode(ev.ParentBlockHash),
 			PayloadAttributes: attributesBytes,
 		})

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

@@ -18,6 +18,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen/mock"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -522,15 +523,22 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 				// to avoid slot processing
 				require.NoError(t, st.SetSlot(currentSlot+1))
 				b := tc.getBlock()
+				genesis := time.Now()
+				require.NoError(t, st.SetGenesisTime(uint64(genesis.Unix())))
 				mockChainService := &mockChain.ChainService{
-					Root:  make([]byte, 32),
-					State: st,
-					Block: b,
-					Slot:  &currentSlot,
+					Root:    make([]byte, 32),
+					State:   st,
+					Block:   b,
+					Slot:    &currentSlot,
+					Genesis: genesis,
 				}
+				headRoot, err := b.Block().HashTreeRoot()
+				require.NoError(t, err)
 
 				stn := mockChain.NewEventFeedWrapper()
 				opn := mockChain.NewEventFeedWrapper()
+				stategen := mock.NewService()
+				stategen.AddStateForRoot(st, headRoot)
 				s := &Server{
 					StateNotifier:          &mockChain.SimpleNotifier{Feed: stn},
 					OperationNotifier:      &mockChain.SimpleNotifier{Feed: opn},
@@ -538,6 +546,7 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 					ChainInfoFetcher:       mockChainService,
 					TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
 					EventWriteTimeout:      testEventWriteTimeout,
+					StateGen:               stategen,
 				}
 				if tc.SetTrackedValidatorsCache != nil {
 					tc.SetTrackedValidatorsCache(s.TrackedValidatorsCache)
@@ -551,13 +560,11 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 						Type: statefeed.PayloadAttributes,
 						Data: payloadattribute.EventData{
 							ProposerIndex:     0,
-							ProposalSlot:      0,
+							ProposalSlot:      mockChainService.CurrentSlot() + 1,
 							ParentBlockNumber: 0,
-							ParentBlockRoot:   make([]byte, 32),
 							ParentBlockHash:   make([]byte, 32),
-							HeadState:         st,
 							HeadBlock:         b,
-							HeadRoot:          [fieldparams.RootLength]byte{},
+							HeadRoot:          headRoot,
 						},
 					},
 				}
@@ -575,8 +582,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 func TestFillEventData(t *testing.T) {
 	ctx := context.Background()
 	t.Run("AlreadyFilledData_ShouldShortCircuitWithoutError", func(t *testing.T) {
-		st, err := util.NewBeaconStateBellatrix()
-		require.NoError(t, err)
 		b, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&eth.SignedBeaconBlockBellatrix{}))
 		require.NoError(t, err)
 		attributor, err := payloadattribute.New(&enginev1.PayloadAttributes{
@@ -584,11 +589,9 @@ func TestFillEventData(t *testing.T) {
 		})
 		require.NoError(t, err)
 		alreadyFilled := payloadattribute.EventData{
-			HeadState:       st,
 			HeadBlock:       b,
 			HeadRoot:        [32]byte{1, 2, 3},
 			Attributer:      attributor,
-			ParentBlockRoot: []byte{1, 2, 3},
 			ParentBlockHash: []byte{4, 5, 6},
 		}
 		srv := &Server{} // No real HeadFetcher needed here since it won't be called.
@@ -612,12 +615,14 @@ func TestFillEventData(t *testing.T) {
 			Timestamp: uint64(time.Now().Unix()),
 		})
 		require.NoError(t, err)
+		headRoot, err := b.Block().HashTreeRoot()
+		require.NoError(t, err)
 		// Create an event data object missing certain fields:
 		partial := payloadattribute.EventData{
-			// The presence of a nil HeadState, nil HeadBlock, zeroed HeadRoot, etc.
-			// will cause fillEventData to try to fill the values.
 			ProposalSlot: 42,         // different epoch from current slot
 			Attributer:   attributor, // Must be Bellatrix or later
+			HeadBlock:    b,
+			HeadRoot:     headRoot,
 		}
 		currentSlot := primitives.Slot(0)
 		// to avoid slot processing
@@ -629,6 +634,8 @@ func TestFillEventData(t *testing.T) {
 			Slot:  &currentSlot,
 		}
 
+		stategen := mock.NewService()
+		stategen.AddStateForRoot(st, headRoot)
 		stn := mockChain.NewEventFeedWrapper()
 		opn := mockChain.NewEventFeedWrapper()
 		srv := &Server{
@@ -638,16 +645,15 @@ func TestFillEventData(t *testing.T) {
 			ChainInfoFetcher:       mockChainService,
 			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
 			EventWriteTimeout:      testEventWriteTimeout,
+			StateGen:               stategen,
 		}
 
 		filled, err := srv.fillEventData(ctx, partial)
 		require.NoError(t, err, "expected successful fill of partial event data")
 
 		// Verify that fields have been updated from the mock data:
-		require.NotNil(t, filled.HeadState, "HeadState should be assigned")
 		require.NotNil(t, filled.HeadBlock, "HeadBlock should be assigned")
 		require.NotEqual(t, [32]byte{}, filled.HeadRoot, "HeadRoot should no longer be zero")
-		require.NotEmpty(t, filled.ParentBlockRoot, "ParentBlockRoot should be filled")
 		require.NotEmpty(t, filled.ParentBlockHash, "ParentBlockHash should be filled")
 		require.Equal(t, uint64(0), filled.ParentBlockNumber, "ParentBlockNumber must match mock block")
 

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

@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	opfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
 )
 
 // Server defines a server implementation of the http events service,
@@ -23,4 +24,5 @@ type Server struct {
 	KeepAliveInterval      time.Duration
 	EventFeedDepth         int
 	EventWriteTimeout      time.Duration
+	StateGen               stategen.StateManager
 }

beacon-chain/rpc/prysm/v1alpha1/beacon/assignments.go

@@ -18,7 +18,7 @@ import (
 
 const errEpoch = "cannot retrieve information about an epoch in the future, current epoch %d, requesting %d"
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListValidatorAssignments retrieves the validator assignments for a given epoch,
 // optional validator indices or public keys may be included to filter validator assignments.

beacon-chain/rpc/prysm/v1alpha1/beacon/attestations.go

@@ -49,7 +49,7 @@ func mapAttestationsByTargetRoot(atts []ethpb.Att) map[[32]byte][]ethpb.Att {
 	return attsMap
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListAttestations retrieves attestations by block root, slot, or epoch.
 // Attestations are sorted by data slot by default.
@@ -115,7 +115,7 @@ func (bs *Server) ListAttestations(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListAttestationsElectra retrieves attestations by block root, slot, or epoch.
 // Attestations are sorted by data slot by default.
@@ -180,7 +180,7 @@ func (bs *Server) ListAttestationsElectra(ctx context.Context, req *ethpb.ListAt
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListIndexedAttestations retrieves indexed attestations by block root.
 // IndexedAttestationsForEpoch are sorted by data slot by default. Start-end epoch
@@ -242,7 +242,7 @@ func (bs *Server) ListIndexedAttestations(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListIndexedAttestationsElectra retrieves indexed attestations by block root.
 // IndexedAttestationsForEpoch are sorted by data slot by default. Start-end epoch
@@ -305,7 +305,7 @@ func (bs *Server) ListIndexedAttestationsElectra(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // AttestationPool retrieves pending attestations.
 //
@@ -350,7 +350,7 @@ func (bs *Server) AttestationPool(_ context.Context, req *ethpb.AttestationPoolR
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 func (bs *Server) AttestationPoolElectra(_ context.Context, req *ethpb.AttestationPoolRequest) (*ethpb.AttestationPoolElectraResponse, error) {
 	var atts []*ethpb.AttestationElectra
 	var err error

beacon-chain/rpc/prysm/v1alpha1/beacon/blocks.go

@@ -26,7 +26,7 @@ type blockContainer struct {
 	isCanonical bool
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListBeaconBlocks retrieves blocks by root, slot, or epoch.
 //
@@ -246,7 +246,7 @@ func (bs *Server) listBlocksForGenesis(ctx context.Context, _ *ethpb.ListBlocksR
 	}}, 1, strconv.Itoa(0), nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetChainHead retrieves information about the head of the beacon chain from
 // the view of the beacon chain node.

beacon-chain/rpc/prysm/v1alpha1/beacon/committees.go

@@ -15,7 +15,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListBeaconCommittees for a given epoch.
 //

beacon-chain/rpc/prysm/v1alpha1/beacon/config.go

@@ -10,7 +10,7 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetBeaconConfig retrieves the current configuration parameters of the beacon chain.
 func (_ *Server) GetBeaconConfig(_ context.Context, _ *emptypb.Empty) (*ethpb.BeaconConfig, error) {

beacon-chain/rpc/prysm/v1alpha1/beacon/slashings.go

@@ -11,7 +11,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitProposerSlashing receives a proposer slashing object via
 // RPC and injects it into the beacon node's operations pool.
@@ -38,12 +38,12 @@ func (bs *Server) SubmitProposerSlashing(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 func (bs *Server) SubmitAttesterSlashing(ctx context.Context, req *ethpb.AttesterSlashing) (*ethpb.SubmitSlashingResponse, error) {
 	return bs.submitAttesterSlashing(ctx, req)
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitAttesterSlashingElectra receives an attester slashing object via
 // RPC and injects it into the beacon node's operations pool.

beacon-chain/rpc/prysm/v1alpha1/beacon/validators.go

@@ -24,7 +24,7 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListValidatorBalances retrieves the validator balances for a given set of public keys.
 // An optional Epoch parameter is provided to request historical validator balances from
@@ -182,7 +182,7 @@ func (bs *Server) ListValidatorBalances(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListValidators retrieves the current list of active validators with an optional historical epoch flag to
 // retrieve validator set in time.
@@ -342,7 +342,7 @@ func (bs *Server) ListValidators(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetValidator information from any validator in the registry by index or public key.
 func (bs *Server) GetValidator(
@@ -388,7 +388,7 @@ func (bs *Server) GetValidator(
 	return nil, status.Error(codes.NotFound, "No validator matched filter criteria")
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetValidatorActiveSetChanges retrieves the active set changes for a given epoch.
 //
@@ -416,7 +416,7 @@ func (bs *Server) GetValidatorActiveSetChanges(
 	return as, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetValidatorParticipation retrieves the validator participation information for a given epoch,
 // it returns the information about validator's participation rate in voting on the proof of stake
@@ -443,7 +443,7 @@ func (bs *Server) GetValidatorParticipation(
 	return vp, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetValidatorQueue retrieves the current validator queue information.
 func (bs *Server) GetValidatorQueue(
@@ -536,7 +536,7 @@ func (bs *Server) GetValidatorQueue(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetValidatorPerformance reports the validator's latest balance along with other important metrics on
 // rewards and penalties throughout its lifecycle in the beacon chain.
@@ -550,7 +550,7 @@ func (bs *Server) GetValidatorPerformance(
 	return response, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetIndividualVotes retrieves individual voting status of validators.
 func (bs *Server) GetIndividualVotes(

beacon-chain/rpc/prysm/v1alpha1/debug/block.go

@@ -17,7 +17,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetBlock in an ssz-encoded format by block root.
 func (ds *Server) GetBlock(
@@ -41,7 +41,7 @@ func (ds *Server) GetBlock(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetInclusionSlot of an attestation in block.
 func (ds *Server) GetInclusionSlot(ctx context.Context, req *pbrpc.InclusionSlotRequest) (*pbrpc.InclusionSlotResponse, error) {

beacon-chain/rpc/prysm/v1alpha1/debug/p2p.go

@@ -13,7 +13,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetPeer returns the data known about the peer defined by the provided peer id.
 func (ds *Server) GetPeer(_ context.Context, peerReq *ethpb.PeerRequest) (*ethpb.DebugPeerResponse, error) {
@@ -24,7 +24,7 @@ func (ds *Server) GetPeer(_ context.Context, peerReq *ethpb.PeerRequest) (*ethpb
 	return ds.getPeer(pid)
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListPeers returns all peers known to the host node, regardless of if they are connected/
 // disconnected.

beacon-chain/rpc/prysm/v1alpha1/debug/state.go

@@ -10,7 +10,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetBeaconState retrieves an ssz-encoded beacon state
 // from the beacon node by either a slot or block root.

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

@@ -49,7 +49,7 @@ type Server struct {
 	BeaconMonitoringPort int
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetHealth checks the health of the node
 func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (*empty.Empty, error) {
@@ -80,7 +80,7 @@ func (ns *Server) GetHealth(ctx context.Context, request *ethpb.HealthRequest) (
 	return &empty.Empty{}, status.Errorf(codes.Unavailable, "service unavailable")
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetSyncStatus checks the current network sync status of the node.
 func (ns *Server) GetSyncStatus(_ context.Context, _ *empty.Empty) (*ethpb.SyncStatus, error) {
@@ -89,7 +89,7 @@ func (ns *Server) GetSyncStatus(_ context.Context, _ *empty.Empty) (*ethpb.SyncS
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetGenesis fetches genesis chain information of Ethereum. Returns unix timestamp 0
 // if a genesis time has yet to be determined.
@@ -115,7 +115,7 @@ func (ns *Server) GetGenesis(ctx context.Context, _ *empty.Empty) (*ethpb.Genesi
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetVersion checks the version information of the beacon node.
 func (_ *Server) GetVersion(_ context.Context, _ *empty.Empty) (*ethpb.Version, error) {
@@ -124,7 +124,7 @@ func (_ *Server) GetVersion(_ context.Context, _ *empty.Empty) (*ethpb.Version,
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListImplementedServices lists the services implemented and enabled by this node.
 //
@@ -143,7 +143,7 @@ func (ns *Server) ListImplementedServices(_ context.Context, _ *empty.Empty) (*e
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetHost returns the p2p data on the current local and host peer.
 func (ns *Server) GetHost(_ context.Context, _ *empty.Empty) (*ethpb.HostData, error) {
@@ -168,7 +168,7 @@ func (ns *Server) GetHost(_ context.Context, _ *empty.Empty) (*ethpb.HostData, e
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetPeer returns the data known about the peer defined by the provided peer id.
 func (ns *Server) GetPeer(_ context.Context, peerReq *ethpb.PeerRequest) (*ethpb.Peer, error) {
@@ -215,7 +215,7 @@ func (ns *Server) GetPeer(_ context.Context, peerReq *ethpb.PeerRequest) (*ethpb
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ListPeers lists the peers connected to this node.
 func (ns *Server) ListPeers(ctx context.Context, _ *empty.Empty) (*ethpb.Peers, error) {
@@ -270,7 +270,7 @@ func (ns *Server) ListPeers(ctx context.Context, _ *empty.Empty) (*ethpb.Peers,
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetETH1ConnectionStatus gets data about the ETH1 endpoints.
 func (ns *Server) GetETH1ConnectionStatus(_ context.Context, _ *empty.Empty) (*ethpb.ETH1ConnectionStatus, error) {
@@ -286,7 +286,7 @@ func (ns *Server) GetETH1ConnectionStatus(_ context.Context, _ *empty.Empty) (*e
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // StreamBeaconLogs from the beacon node via a gRPC server-side stream.
 // DEPRECATED: This endpoint doesn't appear to be used and have been marked for deprecation.

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

@@ -17,7 +17,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitAggregateSelectionProof is called by a validator when its assigned to be an aggregator.
 // The aggregator submits the selection proof to obtain the aggregated attestation
@@ -55,7 +55,7 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 	return &ethpb.AggregateSelectionResponse{AggregateAndProof: attAndProof}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitAggregateSelectionProofElectra is called by a validator when its assigned to be an aggregator.
 // The aggregator submits the selection proof to obtain the aggregated attestation
@@ -149,7 +149,7 @@ func (vs *Server) processAggregateSelection(ctx context.Context, req *ethpb.Aggr
 	return indexInCommittee, validatorIndex, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitSignedAggregateSelectionProof is called by a validator to broadcast a signed
 // aggregated and proof object.
@@ -163,7 +163,7 @@ func (vs *Server) SubmitSignedAggregateSelectionProof(
 	return &ethpb.SignedAggregateSubmitResponse{}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitSignedAggregateSelectionProofElectra is called by a validator to broadcast a signed
 // aggregated and proof object.

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

@@ -22,7 +22,7 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetAttestationData requests that the beacon node produce an attestation data object,
 // which the validator acting as an attester will then sign.
@@ -44,7 +44,7 @@ func (vs *Server) GetAttestationData(ctx context.Context, req *ethpb.Attestation
 	return res, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ProposeAttestation is a function called by an attester to vote
 // on a block via an attestation object as defined in the Ethereum specification.
@@ -74,7 +74,7 @@ func (vs *Server) ProposeAttestation(ctx context.Context, att *ethpb.Attestation
 	return resp, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ProposeAttestationElectra is a function called by an attester to vote
 // on a block via an attestation object as defined in the Ethereum specification.
@@ -114,7 +114,7 @@ func (vs *Server) ProposeAttestationElectra(ctx context.Context, singleAtt *ethp
 	return resp, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubscribeCommitteeSubnets subscribes to the committee ID subnet given subscribe request.
 func (vs *Server) SubscribeCommitteeSubnets(ctx context.Context, req *ethpb.CommitteeSubnetsSubscribeRequest) (*emptypb.Empty, error) {

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

@@ -82,7 +82,7 @@ func TestProposeAttestation(t *testing.T) {
 		config := params.BeaconConfig()
 		config.ElectraForkEpoch = 0
 		params.OverrideBeaconConfig(config)
-		
+
 		state, err := util.NewBeaconState()
 		require.NoError(t, err)
 		require.NoError(t, state.SetSlot(params.BeaconConfig().SlotsPerEpoch+1))

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

@@ -9,13 +9,12 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // StreamBlocksAltair to clients every single time a block is received by the beacon node.
 func (vs *Server) StreamBlocksAltair(req *ethpb.StreamBlocksRequest, stream ethpb.BeaconNodeValidator_StreamBlocksAltairServer) error {
@@ -50,7 +49,7 @@ func (vs *Server) StreamBlocksAltair(req *ethpb.StreamBlocksRequest, stream ethp
 	}
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // StreamSlots sends a the block's slot and dependent roots to clients every single time a block is received by the beacon node.
 func (vs *Server) StreamSlots(req *ethpb.StreamSlotsRequest, stream ethpb.BeaconNodeValidator_StreamSlotsServer) error {
@@ -67,6 +66,7 @@ func (vs *Server) StreamSlots(req *ethpb.StreamSlotsRequest, stream ethpb.Beacon
 		select {
 		case ev := <-ch:
 			var s primitives.Slot
+			var currDependentRoot, prevDependentRoot [32]byte
 			if req.VerifiedOnly {
 				if ev.Type != statefeed.BlockProcessed {
 					continue
@@ -76,6 +76,8 @@ func (vs *Server) StreamSlots(req *ethpb.StreamSlotsRequest, stream ethpb.Beacon
 					continue
 				}
 				s = data.Slot
+				currDependentRoot = data.CurrDependentRoot
+				prevDependentRoot = data.PrevDependentRoot
 			} else {
 				if ev.Type != blockfeed.ReceivedBlock {
 					continue
@@ -85,24 +87,14 @@ func (vs *Server) StreamSlots(req *ethpb.StreamSlotsRequest, stream ethpb.Beacon
 					continue
 				}
 				s = data.SignedBlock.Block().Slot()
-			}
-			currEpoch := slots.ToEpoch(s)
-			currDepRoot, err := vs.ForkchoiceFetcher.DependentRoot(currEpoch)
-			if err != nil {
-				return status.Errorf(codes.Internal, "Could not get dependent root: %v", err)
-			}
-			prevDepRoot := currDepRoot
-			if currEpoch > 0 {
-				prevDepRoot, err = vs.ForkchoiceFetcher.DependentRoot(currEpoch - 1)
-				if err != nil {
-					return status.Errorf(codes.Internal, "Could not get dependent root: %v", err)
-				}
+				currDependentRoot = data.CurrDependentRoot
+				prevDependentRoot = data.PrevDependentRoot
 			}
 			if err := stream.Send(
 				&ethpb.StreamSlotsResponse{
 					Slot:                      s,
-					PreviousDutyDependentRoot: prevDepRoot[:],
-					CurrentDutyDependentRoot:  currDepRoot[:],
+					PreviousDutyDependentRoot: prevDependentRoot[:],
+					CurrentDutyDependentRoot:  currDependentRoot[:],
 				}); err != nil {
 				return status.Errorf(codes.Unavailable, "Could not send over stream: %v", err)
 			}

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

@@ -16,7 +16,7 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetDuties returns the duties assigned to a list of validators specified
 // in the request object.
@@ -178,7 +178,7 @@ func (vs *Server) duties(ctx context.Context, req *ethpb.DutiesRequest) (*ethpb.
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // AssignValidatorToSubnet checks the status and pubkey of a particular validator
 // to discern whether persistent subnets need to be registered for them.

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

@@ -12,7 +12,7 @@ import (
 	"google.golang.org/grpc/status"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ProposeExit proposes an exit for a validator.
 func (vs *Server) ProposeExit(ctx context.Context, req *ethpb.SignedVoluntaryExit) (*ethpb.ProposeExitResponse, error) {

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

@@ -45,7 +45,7 @@ const (
 	defaultBuilderBoostFactor = primitives.Gwei(100)
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetBeaconBlock is called by a proposer during its assigned slot to request a block to sign
 // by passing in the slot and the signed randao reveal of the slot.
@@ -271,7 +271,7 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 	return vs.constructGenericBeaconBlock(sBlk, bundle, winningBid)
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ProposeBeaconBlock handles the proposal of beacon blocks.
 func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
@@ -412,7 +412,7 @@ func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethp
 	return eg.Wait()
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // PrepareBeaconProposer caches and updates the fee recipient for the given proposer.
 func (vs *Server) PrepareBeaconProposer(
@@ -449,7 +449,7 @@ func (vs *Server) PrepareBeaconProposer(
 	return &emptypb.Empty{}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetFeeRecipientByPubKey returns a fee recipient from the beacon node's settings or db based on a given public key
 func (vs *Server) GetFeeRecipientByPubKey(ctx context.Context, request *ethpb.FeeRecipientByPubKeyRequest) (*ethpb.FeeRecipientByPubKeyResponse, error) {
@@ -506,7 +506,7 @@ func (vs *Server) computeStateRoot(ctx context.Context, block interfaces.ReadOnl
 	return root[:], nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitValidatorRegistrations submits validator registrations.
 func (vs *Server) SubmitValidatorRegistrations(ctx context.Context, reg *ethpb.SignedValidatorRegistrationsV1) (*emptypb.Empty, error) {

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

@@ -82,7 +82,7 @@ type Server struct {
 	AttestationStateFetcher blockchain.AttestationStateFetcher
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // WaitForActivation checks if a validator public key exists in the active validator registry of the current
 // beacon state, if not, then it creates a stream which listens for canonical states which contain
@@ -132,7 +132,7 @@ func (vs *Server) WaitForActivation(req *ethpb.ValidatorActivationRequest, strea
 	}
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ValidatorIndex is called by a validator to get its index location in the beacon state.
 func (vs *Server) ValidatorIndex(ctx context.Context, req *ethpb.ValidatorIndexRequest) (*ethpb.ValidatorIndexResponse, error) {
@@ -151,7 +151,7 @@ func (vs *Server) ValidatorIndex(ctx context.Context, req *ethpb.ValidatorIndexR
 	return &ethpb.ValidatorIndexResponse{Index: index}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // DomainData fetches the current domain version information from the beacon state.
 func (vs *Server) DomainData(ctx context.Context, request *ethpb.DomainRequest) (*ethpb.DomainResponse, error) {
@@ -183,7 +183,7 @@ func (vs *Server) DomainData(ctx context.Context, request *ethpb.DomainRequest)
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // WaitForChainStart queries the logs of the Deposit Contract in order to verify the beacon chain
 // has started its runtime and validators begin their responsibilities. If it has not, it then

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

@@ -29,7 +29,7 @@ var nonExistentIndex = primitives.ValidatorIndex(^uint64(0))
 
 var errParticipation = status.Errorf(codes.Internal, "Failed to obtain epoch participation")
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // ValidatorStatus returns the validator status of the current epoch.
 // The status response can be one of the following:
@@ -54,7 +54,7 @@ func (vs *Server) ValidatorStatus(
 	return vStatus, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // MultipleValidatorStatus is the same as ValidatorStatus. Supports retrieval of multiple
 // validator statuses. Takes a list of public keys or a list of validator indices.
@@ -104,7 +104,7 @@ func (vs *Server) MultipleValidatorStatus(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // CheckDoppelGanger checks if the provided keys are currently active in the network.
 func (vs *Server) CheckDoppelGanger(ctx context.Context, req *ethpb.DoppelGangerRequest) (*ethpb.DoppelGangerResponse, error) {

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

@@ -12,7 +12,7 @@ import (
 	"google.golang.org/protobuf/types/known/emptypb"
 )
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetSyncMessageBlockRoot retrieves the sync committee block root of the beacon chain.
 func (vs *Server) GetSyncMessageBlockRoot(
@@ -34,7 +34,7 @@ func (vs *Server) GetSyncMessageBlockRoot(
 	}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitSyncMessage submits the sync committee message to the network.
 // It also saves the sync committee message into the pending pool for block inclusion.
@@ -45,7 +45,7 @@ func (vs *Server) SubmitSyncMessage(ctx context.Context, msg *ethpb.SyncCommitte
 	return &emptypb.Empty{}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetSyncSubcommitteeIndex is called by a sync committee participant to get
 // its subcommittee index for sync message aggregation duty.
@@ -63,7 +63,7 @@ func (vs *Server) GetSyncSubcommitteeIndex(
 	return &ethpb.SyncSubcommitteeIndexResponse{Indices: indices}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // GetSyncCommitteeContribution is called by a sync committee aggregator
 // to retrieve sync committee contribution object.
@@ -106,7 +106,7 @@ func (vs *Server) GetSyncCommitteeContribution(
 	return contribution, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // SubmitSignedContributionAndProof is called by a sync committee aggregator
 // to submit signed contribution and proof object.
@@ -120,7 +120,7 @@ func (vs *Server) SubmitSignedContributionAndProof(
 	return &emptypb.Empty{}, nil
 }
 
-// Deprecated: gRPC API will still be supported for some time, most likely until v8 in 2026, but will be eventually removed in favor of REST API.
+// Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // AggregatedSigAndAggregationBits returns the aggregated signature and aggregation bits
 // associated with a particular set of sync committee messages.

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

@@ -62,9 +62,11 @@ func (b *BeaconState) NextWithdrawalValidatorIndex() (primitives.ValidatorIndex,
 //
 //			validator = state.validators[withdrawal.index]
 //			has_sufficient_effective_balance = validator.effective_balance >= MIN_ACTIVATION_BALANCE
-//			has_excess_balance = state.balances[withdrawal.index] > MIN_ACTIVATION_BALANCE
+//			total_withdrawn = sum(w.amount for w in withdrawals if w.validator_index == withdrawal.validator_index)
+//			balance = state.balances[withdrawal.validator_index] - total_withdrawn
+//			has_excess_balance = balance > MIN_ACTIVATION_BALANCE
 //			if validator.exit_epoch == FAR_FUTURE_EPOCH and has_sufficient_effective_balance and has_excess_balance:
-//				withdrawable_balance = min(state.balances[withdrawal.index] - MIN_ACTIVATION_BALANCE, withdrawal.amount)
+//				withdrawable_balance = min(balance - MIN_ACTIVATION_BALANCE, withdrawal.amount)
 //				withdrawals.append(Withdrawal(
 //					index=withdrawal_index,
 //					validator_index=withdrawal.index,
@@ -132,9 +134,19 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 				return nil, 0, fmt.Errorf("could not retrieve balance at index %d: %w", w.Index, err)
 			}
 			hasSufficientEffectiveBalance := v.EffectiveBalance() >= params.BeaconConfig().MinActivationBalance
-			hasExcessBalance := vBal > params.BeaconConfig().MinActivationBalance
+			var totalWithdrawn uint64
+			for _, wi := range withdrawals {
+				if wi.ValidatorIndex == w.Index {
+					totalWithdrawn += wi.Amount
+				}
+			}
+			balance, err := mathutil.Sub64(vBal, totalWithdrawn)
+			if err != nil {
+				return nil, 0, errors.Wrapf(err, "failed to subtract balance %d with total withdrawn %d", vBal, totalWithdrawn)
+			}
+			hasExcessBalance := balance > params.BeaconConfig().MinActivationBalance
 			if v.ExitEpoch() == params.BeaconConfig().FarFutureEpoch && hasSufficientEffectiveBalance && hasExcessBalance {
-				amount := min(vBal-params.BeaconConfig().MinActivationBalance, w.Amount)
+				amount := min(balance-params.BeaconConfig().MinActivationBalance, w.Amount)
 				withdrawals = append(withdrawals, &enginev1.Withdrawal{
 					Index:          withdrawalIndex,
 					ValidatorIndex: w.Index,
@@ -165,7 +177,10 @@ func (b *BeaconState) ExpectedWithdrawals() ([]*enginev1.Withdrawal, uint64, err
 					partiallyWithdrawnBalance += w.Amount
 				}
 			}
-			balance = balance - partiallyWithdrawnBalance
+			balance, err = mathutil.Sub64(balance, partiallyWithdrawnBalance)
+			if err != nil {
+				return nil, 0, errors.Wrapf(err, "could not subtract balance %d with partial withdrawn balance %d", balance, partiallyWithdrawnBalance)
+			}
 		}
 		if helpers.IsFullyWithdrawableValidator(val, balance, epoch, b.version) {
 			withdrawals = append(withdrawals, &enginev1.Withdrawal{

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

@@ -416,3 +416,37 @@ func TestExpectedWithdrawals(t *testing.T) {
 		require.DeepEqual(t, withdrawalFull, expected[1])
 	})
 }
+
+func TestExpectedWithdrawals_underflow_electra(t *testing.T) {
+	s, err := state_native.InitializeFromProtoUnsafeElectra(&ethpb.BeaconStateElectra{})
+	require.NoError(t, err)
+	vals := make([]*ethpb.Validator, 1)
+	balances := make([]uint64, 1)
+	balances[0] = 2015_000_000_000 //Validator A begins leaking ETH due to inactivity, and over time, its balance decreases to 2,015 ETH
+	val := &ethpb.Validator{
+		WithdrawalCredentials: make([]byte, 32),
+		EffectiveBalance:      params.BeaconConfig().MaxEffectiveBalanceElectra,
+		WithdrawableEpoch:     primitives.Epoch(0),
+		ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+	}
+	val.WithdrawalCredentials[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+	val.WithdrawalCredentials[31] = byte(0)
+	vals[0] = val
+
+	require.NoError(t, s.SetValidators(vals))
+	require.NoError(t, s.SetBalances(balances))
+	require.NoError(t, s.AppendPendingPartialWithdrawal(&ethpb.PendingPartialWithdrawal{
+		Amount:            1008_000_000_000,
+		WithdrawableEpoch: primitives.Epoch(0),
+	}))
+	require.NoError(t, s.AppendPendingPartialWithdrawal(&ethpb.PendingPartialWithdrawal{
+		Amount:            1008_000_000_000,
+		WithdrawableEpoch: primitives.Epoch(0),
+	}))
+	expected, _, err := s.ExpectedWithdrawals()
+	require.NoError(t, err)
+	require.Equal(t, 3, len(expected)) // is a fully withdrawable validator
+	require.Equal(t, uint64(1008_000_000_000), expected[0].Amount)
+	require.Equal(t, uint64(975_000_000_000), expected[1].Amount)
+	require.Equal(t, uint64(32_000_000_000), expected[2].Amount)
+}

beacon-chain/state/stategen/mock/mock.go

@@ -23,8 +23,8 @@ func NewService() *StateManager {
 }
 
 // StateByRootIfCachedNoCopy --
-func (_ *StateManager) StateByRootIfCachedNoCopy(_ [32]byte) state.BeaconState {
-	panic("implement me")
+func (m *StateManager) StateByRootIfCachedNoCopy(root [32]byte) state.BeaconState {
+	return m.StatesByRoot[root]
 }
 
 // Resume --

beacon-chain/sync/BUILD.bazel

@@ -38,6 +38,7 @@ go_library(
         "subscriber_blob_sidecar.go",
         "subscriber_bls_to_execution_change.go",
         "subscriber_handlers.go",
+        "subscriber_light_client.go",
         "subscriber_sync_committee_message.go",
         "subscriber_sync_contribution_proof.go",
         "subscription_topic_handler.go",
@@ -47,6 +48,7 @@ go_library(
         "validate_beacon_blocks.go",
         "validate_blob.go",
         "validate_bls_to_execution_change.go",
+        "validate_light_client.go",
         "validate_proposer_slashing.go",
         "validate_sync_committee_message.go",
         "validate_sync_contribution_proof.go",
@@ -71,6 +73,7 @@ go_library(
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",
@@ -101,6 +104,7 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//container/leaky-bucket:go_default_library",
@@ -182,6 +186,7 @@ go_test(
         "validate_beacon_blocks_test.go",
         "validate_blob_test.go",
         "validate_bls_to_execution_change_test.go",
+        "validate_light_client_test.go",
         "validate_proposer_slashing_test.go",
         "validate_sync_committee_message_test.go",
         "validate_sync_contribution_proof_test.go",
@@ -198,6 +203,7 @@ go_test(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -211,6 +217,7 @@ go_test(
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
+        "//beacon-chain/operations/slashings/mock:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",

beacon-chain/sync/decode_pubsub.go

@@ -89,6 +89,10 @@ func extractValidDataTypeFromTopic(topic string, digest []byte, clock *startup.C
 		return extractDataTypeFromTypeMap(types.AggregateAttestationMap, digest, clock)
 	case p2p.AttesterSlashingSubnetTopicFormat:
 		return extractDataTypeFromTypeMap(types.AttesterSlashingMap, digest, clock)
+	case p2p.LightClientOptimisticUpdateTopicFormat:
+		return extractDataTypeFromTypeMap(types.LightClientOptimisticUpdateMap, digest, clock)
+	case p2p.LightClientFinalityUpdateTopicFormat:
+		return extractDataTypeFromTypeMap(types.LightClientFinalityUpdateMap, digest, clock)
 	}
 	return nil, nil
 }

beacon-chain/sync/initial-sync/BUILD.bazel

@@ -60,6 +60,7 @@ go_test(
         "blocks_fetcher_test.go",
         "blocks_fetcher_utils_test.go",
         "blocks_queue_test.go",
+        "downscore_test.go",
         "fsm_benchmark_test.go",
         "fsm_test.go",
         "initial_sync_test.go",
@@ -70,6 +71,7 @@ go_test(
     tags = ["CI_race_detection"],
     deps = [
         "//async/abool:go_default_library",
+        "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/das:go_default_library",
         "//beacon-chain/db:go_default_library",
@@ -78,6 +80,7 @@ go_test(
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
+        "//beacon-chain/p2p/peers/peerdata:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/p2p/types:go_default_library",
@@ -105,6 +108,7 @@ go_test(
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_paulbellamy_ratecounter//:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
     ],

beacon-chain/sync/initial-sync/blocks_fetcher.go

@@ -120,11 +120,20 @@ type fetchRequestParams struct {
 // fetchRequestResponse is a combined type to hold results of both successful executions and errors.
 // Valid usage pattern will be to check whether result's `err` is nil, before using `blocks`.
 type fetchRequestResponse struct {
-	pid   peer.ID
-	start primitives.Slot
-	count uint64
-	bwb   []blocks.BlockWithROBlobs
-	err   error
+	blocksFrom peer.ID
+	blobsFrom  peer.ID
+	start      primitives.Slot
+	count      uint64
+	bwb        []blocks.BlockWithROBlobs
+	err        error
+}
+
+func (r *fetchRequestResponse) blocksQueueFetchedData() *blocksQueueFetchedData {
+	return &blocksQueueFetchedData{
+		blocksFrom: r.blocksFrom,
+		blobsFrom:  r.blobsFrom,
+		bwb:        r.bwb,
+	}
 }
 
 // newBlocksFetcher creates ready to use fetcher.
@@ -314,13 +323,14 @@ func (f *blocksFetcher) handleRequest(ctx context.Context, start primitives.Slot
 		}
 	}
 
-	response.bwb, response.pid, response.err = f.fetchBlocksFromPeer(ctx, start, count, peers)
+	response.bwb, response.blocksFrom, response.err = f.fetchBlocksFromPeer(ctx, start, count, peers)
 	if response.err == nil {
-		bwb, err := f.fetchBlobsFromPeer(ctx, response.bwb, response.pid, peers)
+		pid, bwb, err := f.fetchBlobsFromPeer(ctx, response.bwb, response.blocksFrom, peers)
 		if err != nil {
 			response.err = err
 		}
 		response.bwb = bwb
+		response.blobsFrom = pid
 	}
 	return response
 }
@@ -537,20 +547,20 @@ func missingCommitError(root [32]byte, slot primitives.Slot, missing [][]byte) e
 }
 
 // fetchBlobsFromPeer fetches blocks from a single randomly selected peer.
-func (f *blocksFetcher) fetchBlobsFromPeer(ctx context.Context, bwb []blocks.BlockWithROBlobs, pid peer.ID, peers []peer.ID) ([]blocks.BlockWithROBlobs, error) {
+func (f *blocksFetcher) fetchBlobsFromPeer(ctx context.Context, bwb []blocks.BlockWithROBlobs, pid peer.ID, peers []peer.ID) (peer.ID, []blocks.BlockWithROBlobs, error) {
 	ctx, span := trace.StartSpan(ctx, "initialsync.fetchBlobsFromPeer")
 	defer span.End()
 	if slots.ToEpoch(f.clock.CurrentSlot()) < params.BeaconConfig().DenebForkEpoch {
-		return bwb, nil
+		return "", bwb, nil
 	}
 	blobWindowStart, err := prysmsync.BlobRPCMinValidSlot(f.clock.CurrentSlot())
 	if err != nil {
-		return nil, err
+		return "", nil, err
 	}
 	// Construct request message based on observed interval of blocks in need of blobs.
 	req := countCommitments(bwb, blobWindowStart).blobRange(f.bs).Request()
 	if req == nil {
-		return bwb, nil
+		return "", bwb, nil
 	}
 	peers = f.filterPeers(ctx, peers, peersPercentagePerRequest)
 	// We dial the initial peer first to ensure that we get the desired set of blobs.
@@ -573,9 +583,9 @@ func (f *blocksFetcher) fetchBlobsFromPeer(ctx context.Context, bwb []blocks.Blo
 			log.WithField("peer", p).WithError(err).Debug("Invalid BeaconBlobsByRange response")
 			continue
 		}
-		return robs, err
+		return p, robs, err
 	}
-	return nil, errNoPeersAvailable
+	return "", nil, errNoPeersAvailable
 }
 
 // requestBlocks is a wrapper for handling BeaconBlocksByRangeRequest requests/streams.

beacon-chain/sync/initial-sync/blocks_fetcher_utils.go

@@ -22,8 +22,9 @@ import (
 // Blocks are stored in an ascending slot order. The first block is guaranteed to have parent
 // either in DB or initial sync cache.
 type forkData struct {
-	peer peer.ID
-	bwb  []blocks.BlockWithROBlobs
+	blocksFrom peer.ID
+	blobsFrom  peer.ID
+	bwb        []blocks.BlockWithROBlobs
 }
 
 // nonSkippedSlotAfter checks slots after the given one in an attempt to find a non-empty future slot.
@@ -280,13 +281,13 @@ func (f *blocksFetcher) findForkWithPeer(ctx context.Context, pid peer.ID, slot
 		}
 		// We need to fetch the blobs for the given alt-chain if any exist, so that we can try to verify and import
 		// the blocks.
-		bwb, err := f.fetchBlobsFromPeer(ctx, altBlocks, pid, []peer.ID{pid})
+		bpid, bwb, err := f.fetchBlobsFromPeer(ctx, altBlocks, pid, []peer.ID{pid})
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to retrieve blobs for blocks found in findForkWithPeer")
 		}
 		// The caller will use the BlocksWith VerifiedBlobs in bwb as the starting point for
 		// round-robin syncing the alternate chain.
-		return &forkData{peer: pid, bwb: bwb}, nil
+		return &forkData{blocksFrom: pid, blobsFrom: bpid, bwb: bwb}, nil
 	}
 	return nil, errNoAlternateBlocks
 }
@@ -302,13 +303,15 @@ func (f *blocksFetcher) findAncestor(ctx context.Context, pid peer.ID, b interfa
 			if err != nil {
 				return nil, errors.Wrap(err, "received invalid blocks in findAncestor")
 			}
-			bwb, err = f.fetchBlobsFromPeer(ctx, bwb, pid, []peer.ID{pid})
+			var bpid peer.ID
+			bpid, bwb, err = f.fetchBlobsFromPeer(ctx, bwb, pid, []peer.ID{pid})
 			if err != nil {
 				return nil, errors.Wrap(err, "unable to retrieve blobs for blocks found in findAncestor")
 			}
 			return &forkData{
-				peer: pid,
-				bwb:  bwb,
+				blocksFrom: pid,
+				bwb:        bwb,
+				blobsFrom:  bpid,
 			}, nil
 		}
 		// Request block's parent.

beacon-chain/sync/initial-sync/blocks_fetcher_utils_test.go

@@ -263,7 +263,7 @@ func TestBlocksFetcher_findFork(t *testing.T) {
 	reqEnd := testForkStartSlot(t, 251) + primitives.Slot(findForkReqRangeSize())
 	require.Equal(t, primitives.Slot(len(chain1)), fork.bwb[0].Block.Block().Slot())
 	require.Equal(t, int(reqEnd-forkSlot1b), len(fork.bwb))
-	require.Equal(t, curForkMoreBlocksPeer, fork.peer)
+	require.Equal(t, curForkMoreBlocksPeer, fork.blocksFrom)
 	// Save all chain1b blocks (so that they do not interfere with alternative fork)
 	for _, blk := range chain1b {
 		util.SaveBlock(t, ctx, beaconDB, blk)
@@ -283,7 +283,7 @@ func TestBlocksFetcher_findFork(t *testing.T) {
 	alternativePeer := connectPeerHavingBlocks(t, p2p, chain2, finalizedSlot, p2p.Peers())
 	fork, err = fetcher.findFork(ctx, 251)
 	require.NoError(t, err)
-	assert.Equal(t, alternativePeer, fork.peer)
+	assert.Equal(t, alternativePeer, fork.blocksFrom)
 	assert.Equal(t, 65, len(fork.bwb))
 	ind := forkSlot
 	for _, blk := range fork.bwb {

beacon-chain/sync/initial-sync/blocks_queue.go

@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	beaconsync "github.com/OffchainLabs/prysm/v6/beacon-chain/sync"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -93,8 +94,9 @@ type blocksQueue struct {
 
 // blocksQueueFetchedData is a data container that is returned from a queue on each step.
 type blocksQueueFetchedData struct {
-	pid peer.ID
-	bwb []blocks.BlockWithROBlobs
+	blocksFrom peer.ID
+	blobsFrom  peer.ID
+	bwb        []blocks.BlockWithROBlobs
 }
 
 // newBlocksQueue creates initialized priority queue.
@@ -337,13 +339,15 @@ func (q *blocksQueue) onDataReceivedEvent(ctx context.Context) eventHandlerFn {
 			}
 			if errors.Is(response.err, beaconsync.ErrInvalidFetchedData) {
 				// Peer returned invalid data, penalize.
-				q.blocksFetcher.p2p.Peers().Scorers().BadResponsesScorer().Increment(m.pid)
-				log.WithField("pid", response.pid).Debug("Peer is penalized for invalid blocks")
+				q.blocksFetcher.p2p.Peers().Scorers().BadResponsesScorer().Increment(response.blocksFrom)
+				log.WithField("pid", response.blocksFrom).Debug("Peer is penalized for invalid blocks")
+			} else if errors.Is(response.err, verification.ErrBlobInvalid) {
+				q.blocksFetcher.p2p.Peers().Scorers().BadResponsesScorer().Increment(response.blobsFrom)
+				log.WithField("pid", response.blobsFrom).Debug("Peer is penalized for invalid blob response")
 			}
 			return m.state, response.err
 		}
-		m.pid = response.pid
-		m.bwb = response.bwb
+		m.fetched = *response
 		return stateDataParsed, nil
 	}
 }
@@ -358,19 +362,15 @@ func (q *blocksQueue) onReadyToSendEvent(ctx context.Context) eventHandlerFn {
 			return m.state, errInvalidInitialState
 		}
 
-		if len(m.bwb) == 0 {
+		if m.numFetched() == 0 {
 			return stateSkipped, nil
 		}
 
 		send := func() (stateID, error) {
-			data := &blocksQueueFetchedData{
-				pid: m.pid,
-				bwb: m.bwb,
-			}
 			select {
 			case <-ctx.Done():
 				return m.state, ctx.Err()
-			case q.fetchedData <- data:
+			case q.fetchedData <- m.fetched.blocksQueueFetchedData():
 			}
 			return stateSent, nil
 		}

beacon-chain/sync/initial-sync/blocks_queue_test.go

@@ -472,8 +472,8 @@ func TestBlocksQueue_onDataReceivedEvent(t *testing.T) {
 		updatedState, err := handlerFn(&stateMachine{
 			state: stateScheduled,
 		}, &fetchRequestResponse{
-			pid: "abc",
-			err: errSlotIsTooHigh,
+			blocksFrom: "abc",
+			err:        errSlotIsTooHigh,
 		})
 		assert.ErrorContains(t, errSlotIsTooHigh.Error(), err)
 		assert.Equal(t, stateScheduled, updatedState)
@@ -495,9 +495,9 @@ func TestBlocksQueue_onDataReceivedEvent(t *testing.T) {
 		updatedState, err := handlerFn(&stateMachine{
 			state: stateScheduled,
 		}, &fetchRequestResponse{
-			pid:   "abc",
-			err:   errSlotIsTooHigh,
-			start: 256,
+			blocksFrom: "abc",
+			err:        errSlotIsTooHigh,
+			start:      256,
 		})
 		assert.ErrorContains(t, errSlotIsTooHigh.Error(), err)
 		assert.Equal(t, stateScheduled, updatedState)
@@ -517,8 +517,8 @@ func TestBlocksQueue_onDataReceivedEvent(t *testing.T) {
 		updatedState, err := handlerFn(&stateMachine{
 			state: stateScheduled,
 		}, &fetchRequestResponse{
-			pid: "abc",
-			err: beaconsync.ErrInvalidFetchedData,
+			blocksFrom: "abc",
+			err:        beaconsync.ErrInvalidFetchedData,
 		})
 		assert.ErrorContains(t, beaconsync.ErrInvalidFetchedData.Error(), err)
 		assert.Equal(t, stateScheduled, updatedState)
@@ -537,7 +537,7 @@ func TestBlocksQueue_onDataReceivedEvent(t *testing.T) {
 		wsbCopy, err := wsb.Copy()
 		require.NoError(t, err)
 		response := &fetchRequestResponse{
-			pid: "abc",
+			blocksFrom: "abc",
 			bwb: []blocks.BlockWithROBlobs{
 				{Block: blocks.ROBlock{ReadOnlySignedBeaconBlock: wsb}},
 				{Block: blocks.ROBlock{ReadOnlySignedBeaconBlock: wsbCopy}},
@@ -546,13 +546,15 @@ func TestBlocksQueue_onDataReceivedEvent(t *testing.T) {
 		fsm := &stateMachine{
 			state: stateScheduled,
 		}
-		assert.Equal(t, peer.ID(""), fsm.pid)
-		assert.Equal(t, 0, len(fsm.bwb))
+		assert.Equal(t, peer.ID(""), fsm.fetched.blocksFrom)
+		assert.Equal(t, peer.ID(""), fsm.fetched.blobsFrom)
+		assert.Equal(t, 0, fsm.numFetched())
 		updatedState, err := handlerFn(fsm, response)
 		assert.NoError(t, err)
 		assert.Equal(t, stateDataParsed, updatedState)
-		assert.Equal(t, response.pid, fsm.pid)
-		assert.DeepSSZEqual(t, response.bwb, fsm.bwb)
+		assert.Equal(t, response.blocksFrom, fsm.fetched.blocksFrom)
+		assert.Equal(t, response.blobsFrom, fsm.fetched.blobsFrom)
+		assert.DeepSSZEqual(t, response.bwb, fsm.fetched.bwb)
 	})
 }
 
@@ -635,10 +637,10 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
 		queue.smm.addStateMachine(256)
 		queue.smm.addStateMachine(320)
 		queue.smm.machines[256].state = stateDataParsed
-		queue.smm.machines[256].pid = pidDataParsed
+		queue.smm.machines[256].fetched.blocksFrom = pidDataParsed
 		rwsb, err := blocks.NewROBlock(wsb)
 		require.NoError(t, err)
-		queue.smm.machines[256].bwb = []blocks.BlockWithROBlobs{
+		queue.smm.machines[256].fetched.bwb = []blocks.BlockWithROBlobs{
 			{Block: rwsb},
 		}
 
@@ -669,10 +671,10 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
 		queue.smm.machines[256].state = stateDataParsed
 		queue.smm.addStateMachine(320)
 		queue.smm.machines[320].state = stateDataParsed
-		queue.smm.machines[320].pid = pidDataParsed
+		queue.smm.machines[320].fetched.blocksFrom = pidDataParsed
 		rwsb, err := blocks.NewROBlock(wsb)
 		require.NoError(t, err)
-		queue.smm.machines[320].bwb = []blocks.BlockWithROBlobs{
+		queue.smm.machines[320].fetched.bwb = []blocks.BlockWithROBlobs{
 			{Block: rwsb},
 		}
 
@@ -700,10 +702,10 @@ func TestBlocksQueue_onReadyToSendEvent(t *testing.T) {
 		queue.smm.machines[256].state = stateSkipped
 		queue.smm.addStateMachine(320)
 		queue.smm.machines[320].state = stateDataParsed
-		queue.smm.machines[320].pid = pidDataParsed
+		queue.smm.machines[320].fetched.blocksFrom = pidDataParsed
 		rwsb, err := blocks.NewROBlock(wsb)
 		require.NoError(t, err)
-		queue.smm.machines[320].bwb = []blocks.BlockWithROBlobs{
+		queue.smm.machines[320].fetched.bwb = []blocks.BlockWithROBlobs{
 			{Block: rwsb},
 		}
 
@@ -1199,17 +1201,17 @@ func TestBlocksQueue_stuckInUnfavourableFork(t *testing.T) {
 		firstFSM, ok := queue.smm.findStateMachine(forkedSlot)
 		require.Equal(t, true, ok)
 		require.Equal(t, stateDataParsed, firstFSM.state)
-		require.Equal(t, forkedPeer, firstFSM.pid)
+		require.Equal(t, forkedPeer, firstFSM.fetched.blocksFrom)
 		reqEnd := testForkStartSlot(t, 251) + primitives.Slot(findForkReqRangeSize())
-		require.Equal(t, int(reqEnd-forkedSlot), len(firstFSM.bwb))
-		require.Equal(t, forkedSlot, firstFSM.bwb[0].Block.Block().Slot())
+		require.Equal(t, int(reqEnd-forkedSlot), len(firstFSM.fetched.bwb))
+		require.Equal(t, forkedSlot, firstFSM.fetched.bwb[0].Block.Block().Slot())
 
 		// Assert that forked data from chain2 is available (within 64 fetched blocks).
 		for i, blk := range chain2[forkedSlot:] {
-			if i >= len(firstFSM.bwb) {
+			if i >= len(firstFSM.fetched.bwb) {
 				break
 			}
-			rootFromFSM := firstFSM.bwb[i].Block.Root()
+			rootFromFSM := firstFSM.fetched.bwb[i].Block.Root()
 			blkRoot, err := blk.Block.HashTreeRoot()
 			require.NoError(t, err)
 			assert.Equal(t, blkRoot, rootFromFSM)
@@ -1217,7 +1219,7 @@ func TestBlocksQueue_stuckInUnfavourableFork(t *testing.T) {
 
 		// Assert that machines are in the expected state.
 		startSlot = forkedEpochStartSlot.Add(1 + blocksPerRequest)
-		require.Equal(t, int(blocksPerRequest)-int(forkedSlot-(forkedEpochStartSlot+1)), len(firstFSM.bwb))
+		require.Equal(t, int(blocksPerRequest)-int(forkedSlot-(forkedEpochStartSlot+1)), len(firstFSM.fetched.bwb))
 		for i := startSlot; i < startSlot.Add(blocksPerRequest*(lookaheadSteps-1)); i += primitives.Slot(blocksPerRequest) {
 			fsm, ok := queue.smm.findStateMachine(i)
 			require.Equal(t, true, ok)

beacon-chain/sync/initial-sync/blocks_queue_utils.go

@@ -24,8 +24,8 @@ func (q *blocksQueue) resetFromFork(fork *forkData) error {
 		return err
 	}
 	fsm := q.smm.addStateMachine(firstBlock.Slot())
-	fsm.pid = fork.peer
-	fsm.bwb = fork.bwb
+	fsm.fetched.bwb = fork.bwb
+	fsm.fetched.blocksFrom, fsm.fetched.blobsFrom = fork.blocksFrom, fork.blobsFrom
 	fsm.state = stateDataParsed
 
 	// The rest of machines are in skipped state.

beacon-chain/sync/initial-sync/downscore_test.go

@@ -0,0 +1,219 @@
+package initialsync
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
+	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/peerdata"
+	p2pt "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/testing/assert"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pkg/errors"
+)
+
+type testDownscorePeer int
+
+const (
+	testDownscoreNeither testDownscorePeer = iota
+	testDownscoreBlock
+	testDownscoreBlob
+)
+
+func peerIDForTestDownscore(w testDownscorePeer, name string) peer.ID {
+	switch w {
+	case testDownscoreBlock:
+		return peer.ID("block" + name)
+	case testDownscoreBlob:
+		return peer.ID("blob" + name)
+	default:
+		return ""
+	}
+}
+
+func TestUpdatePeerScorerStats(t *testing.T) {
+	cases := []struct {
+		name      string
+		err       error
+		processed uint64
+		downPeer  testDownscorePeer
+	}{
+		{
+			name:      "invalid block",
+			err:       blockchain.ErrInvalidPayload,
+			downPeer:  testDownscoreBlock,
+			processed: 10,
+		},
+		{
+			name:      "invalid blob",
+			err:       verification.ErrBlobIndexInvalid,
+			downPeer:  testDownscoreBlob,
+			processed: 3,
+		},
+		{
+			name:      "not validity error",
+			err:       errors.New("test"),
+			processed: 32,
+		},
+		{
+			name:      "no error",
+			processed: 32,
+		},
+	}
+	s := &Service{
+		cfg: &Config{
+			P2P: p2pt.NewTestP2P(t),
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			data := &blocksQueueFetchedData{
+				blocksFrom: peerIDForTestDownscore(testDownscoreBlock, c.name),
+				blobsFrom:  peerIDForTestDownscore(testDownscoreBlob, c.name),
+			}
+			s.updatePeerScorerStats(data, c.processed, c.err)
+			if c.err != nil && c.downPeer != testDownscoreNeither {
+				switch c.downPeer {
+				case testDownscoreBlock:
+					// block should be downscored
+					blocksCount, err := s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Count(data.blocksFrom)
+					require.NoError(t, err)
+					require.Equal(t, 1, blocksCount)
+					// blob should not be downscored - also we expect a not found error since peer scoring did not interact with blobs
+					blobCount, err := s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Count(data.blobsFrom)
+					require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+					require.Equal(t, -1, blobCount)
+				case testDownscoreBlob:
+					// block should not be downscored - also we expect a not found error since peer scoring did not interact with blocks
+					blocksCount, err := s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Count(data.blocksFrom)
+					require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+					require.Equal(t, -1, blocksCount)
+					// blob should be downscored
+					blobCount, err := s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Count(data.blobsFrom)
+					require.NoError(t, err)
+					require.Equal(t, 1, blobCount)
+				}
+				assert.Equal(t, uint64(0), s.cfg.P2P.Peers().Scorers().BlockProviderScorer().ProcessedBlocks(data.blocksFrom))
+				return
+			}
+			// block should not be downscored - also we expect a not found error since peer scoring did not interact with blocks
+			blocksCount, err := s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Count(data.blocksFrom)
+			// The scorer will know about the the block peer because it will have a processed blocks count
+			require.NoError(t, err)
+			require.Equal(t, 0, blocksCount)
+			// no downscore, so scorer doesn't know the peer
+			blobCount, err := s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Count(data.blobsFrom)
+			require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+			require.Equal(t, -1, blobCount)
+
+			assert.Equal(t, c.processed, s.cfg.P2P.Peers().Scorers().BlockProviderScorer().ProcessedBlocks(data.blocksFrom))
+		})
+	}
+}
+
+func TestOnDataReceivedDownscore(t *testing.T) {
+	cases := []struct {
+		name     string
+		err      error
+		downPeer testDownscorePeer
+	}{
+		{
+			name:     "invalid block",
+			err:      sync.ErrInvalidFetchedData,
+			downPeer: testDownscoreBlock,
+		},
+		{
+			name:     "invalid blob",
+			err:      errors.Wrap(verification.ErrBlobInvalid, "test"),
+			downPeer: testDownscoreBlob,
+		},
+		{
+			name: "not validity error",
+			err:  errors.New("test"),
+		},
+		{
+			name: "no error",
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			data := &fetchRequestResponse{
+				blocksFrom: peerIDForTestDownscore(testDownscoreBlock, c.name),
+				blobsFrom:  peerIDForTestDownscore(testDownscoreBlob, c.name),
+				err:        c.err,
+			}
+			if c.downPeer == testDownscoreBlob {
+				require.Equal(t, true, verification.IsBlobValidationFailure(c.err))
+			}
+			ctx := context.Background()
+			p2p := p2pt.NewTestP2P(t)
+			mc := &mock.ChainService{Genesis: time.Now(), ValidatorsRoot: [32]byte{}}
+			fetcher := newBlocksFetcher(ctx, &blocksFetcherConfig{
+				chain: mc,
+				p2p:   p2p,
+				clock: startup.NewClock(mc.Genesis, mc.ValidatorsRoot),
+			})
+			q := newBlocksQueue(ctx, &blocksQueueConfig{
+				p2p:                 p2p,
+				blocksFetcher:       fetcher,
+				highestExpectedSlot: primitives.Slot(32),
+				chain:               mc})
+			sm := q.smm.addStateMachine(0)
+			sm.state = stateScheduled
+			handle := q.onDataReceivedEvent(context.Background())
+			endState, err := handle(sm, data)
+			if c.err != nil {
+				require.ErrorIs(t, err, c.err)
+			} else {
+				require.NoError(t, err)
+			}
+			// state machine should stay in "scheduled" if there's an error
+			// and transition to "data parsed" if there's no error
+			if c.err != nil {
+				require.Equal(t, stateScheduled, endState)
+			} else {
+				require.Equal(t, stateDataParsed, endState)
+			}
+			if c.err != nil && c.downPeer != testDownscoreNeither {
+				switch c.downPeer {
+				case testDownscoreBlock:
+					// block should be downscored
+					blocksCount, err := p2p.Peers().Scorers().BadResponsesScorer().Count(data.blocksFrom)
+					require.NoError(t, err)
+					require.Equal(t, 1, blocksCount)
+					// blob should not be downscored - also we expect a not found error since peer scoring did not interact with blobs
+					blobCount, err := p2p.Peers().Scorers().BadResponsesScorer().Count(data.blobsFrom)
+					require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+					require.Equal(t, -1, blobCount)
+				case testDownscoreBlob:
+					// block should not be downscored - also we expect a not found error since peer scoring did not interact with blocks
+					blocksCount, err := p2p.Peers().Scorers().BadResponsesScorer().Count(data.blocksFrom)
+					require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+					require.Equal(t, -1, blocksCount)
+					// blob should be downscored
+					blobCount, err := p2p.Peers().Scorers().BadResponsesScorer().Count(data.blobsFrom)
+					require.NoError(t, err)
+					require.Equal(t, 1, blobCount)
+				}
+				assert.Equal(t, uint64(0), p2p.Peers().Scorers().BlockProviderScorer().ProcessedBlocks(data.blocksFrom))
+				return
+			}
+			// block should not be downscored - also we expect a not found error since peer scoring did not interact with blocks
+			blocksCount, err := p2p.Peers().Scorers().BadResponsesScorer().Count(data.blocksFrom)
+			// no downscore, so scorer doesn't know the peer
+			require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+			require.Equal(t, -1, blocksCount)
+			blobCount, err := p2p.Peers().Scorers().BadResponsesScorer().Count(data.blobsFrom)
+			// no downscore, so scorer doesn't know the peer
+			require.ErrorIs(t, err, peerdata.ErrPeerUnknown)
+			require.Equal(t, -1, blobCount)
+		})
+	}
+}

beacon-chain/sync/initial-sync/fsm.go

@@ -6,11 +6,9 @@ import (
 	"sort"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	prysmTime "github.com/OffchainLabs/prysm/v6/time"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/libp2p/go-libp2p/core/peer"
 )
 
 const (
@@ -45,8 +43,7 @@ type stateMachine struct {
 	smm     *stateMachineManager
 	start   primitives.Slot
 	state   stateID
-	pid     peer.ID
-	bwb     []blocks.BlockWithROBlobs
+	fetched fetchRequestResponse
 	updated time.Time
 }
 
@@ -78,7 +75,7 @@ func (smm *stateMachineManager) addStateMachine(startSlot primitives.Slot) *stat
 		smm:     smm,
 		start:   startSlot,
 		state:   stateNew,
-		bwb:     []blocks.BlockWithROBlobs{},
+		fetched: fetchRequestResponse{},
 		updated: prysmTime.Now(),
 	}
 	smm.recalculateMachineAttribs()
@@ -90,7 +87,7 @@ func (smm *stateMachineManager) removeStateMachine(startSlot primitives.Slot) er
 	if _, ok := smm.machines[startSlot]; !ok {
 		return fmt.Errorf("state for machine %v is not found", startSlot)
 	}
-	smm.machines[startSlot].bwb = nil
+	smm.machines[startSlot].fetched = fetchRequestResponse{}
 	delete(smm.machines, startSlot)
 	smm.recalculateMachineAttribs()
 	return nil
@@ -187,6 +184,10 @@ func (m *stateMachine) isLast() bool {
 	return m.start == m.smm.keys[len(m.smm.keys)-1]
 }
 
+func (m *stateMachine) numFetched() int {
+	return len(m.fetched.bwb)
+}
+
 // String returns human-readable representation of a FSM state.
 func (m *stateMachine) String() string {
 	return fmt.Sprintf("{%d:%s}", slots.ToEpoch(m.start), m.state)

beacon-chain/sync/initial-sync/round_robin.go

@@ -14,7 +14,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/paulbellamy/ratecounter"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -127,7 +126,7 @@ func (s *Service) syncToNonFinalizedEpoch(ctx context.Context) error {
 	}
 	for data := range queue.fetchedData {
 		count, err := s.processFetchedDataRegSync(ctx, data)
-		s.updatePeerScorerStats(data.pid, count, err)
+		s.updatePeerScorerStats(data, count, err)
 	}
 	log.WithFields(logrus.Fields{
 		"syncedSlot":  s.cfg.Chain.HeadSlot(),
@@ -147,7 +146,7 @@ func (s *Service) processFetchedData(ctx context.Context, data *blocksQueueFetch
 	if err != nil {
 		log.WithError(err).Warn("Skip processing batched blocks")
 	}
-	s.updatePeerScorerStats(data.pid, count, err)
+	s.updatePeerScorerStats(data, count, err)
 }
 
 // processFetchedDataRegSync processes data received from queue.
@@ -339,18 +338,19 @@ func isPunishableError(err error) bool {
 }
 
 // updatePeerScorerStats adjusts monitored metrics for a peer.
-func (s *Service) updatePeerScorerStats(pid peer.ID, count uint64, err error) {
-	if pid == "" {
-		return
-	}
+func (s *Service) updatePeerScorerStats(data *blocksQueueFetchedData, count uint64, err error) {
 	if isPunishableError(err) {
-		log.WithError(err).WithField("peer_id", pid).Warn("Incrementing peers bad response count")
-		s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Increment(pid)
+		if verification.IsBlobValidationFailure(err) {
+			log.WithError(err).WithField("peer_id", data.blobsFrom).Warn("Downscoring peer for invalid blobs")
+			s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Increment(data.blobsFrom)
+		} else {
+			log.WithError(err).WithField("peer_id", data.blocksFrom).Warn("Downscoring peer for invalid blocks")
+			s.cfg.P2P.Peers().Scorers().BadResponsesScorer().Increment(data.blocksFrom)
+		}
 		// If the error is punishable, exit here so that we don't give them credit for providing bad blocks.
 		return
 	}
-	scorer := s.cfg.P2P.Peers().Scorers().BlockProviderScorer()
-	scorer.IncrementProcessedBlocks(pid, count)
+	s.cfg.P2P.Peers().Scorers().BlockProviderScorer().IncrementProcessedBlocks(data.blocksFrom, count)
 }
 
 // isProcessedBlock checks DB and local cache for presence of a given block, to avoid duplicates.

beacon-chain/sync/options.go

@@ -6,6 +6,7 @@ import (
 	blockfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/block"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
@@ -196,3 +197,11 @@ func WithSlasherEnabled(enabled bool) Option {
 		return nil
 	}
 }
+
+// WithLightClientStore allows the sync package to access light client data.
+func WithLightClientStore(lcs *lightClient.Store) Option {
+	return func(s *Service) error {
+		s.lcStore = lcs
+		return nil
+	}
+}

beacon-chain/sync/rpc_blob_sidecars_by_root_test.go

@@ -156,7 +156,7 @@ func readChunkEncodedBlobsLowMax(t *testing.T, s *Service, expect []*expectedBlo
 	}
 	return func(stream network.Stream) {
 		_, err := readChunkEncodedBlobs(stream, encoding, ctxMap, vf, 1)
-		require.ErrorIs(t, err, ErrInvalidFetchedData)
+		require.ErrorIs(t, err, errMaxRequestBlobSidecarsExceeded)
 	}
 }
 

beacon-chain/sync/rpc_send_request.go

@@ -9,6 +9,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	p2ptypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -30,14 +31,14 @@ var errBlobUnmarshal = errors.New("Could not unmarshal chunk-encoded blob")
 var (
 	// ErrInvalidFetchedData is used to signal that an error occurred which should result in peer downscoring.
 	ErrInvalidFetchedData             = errors.New("invalid data returned from peer")
-	errBlobIndexOutOfBounds           = errors.Wrap(ErrInvalidFetchedData, "blob index out of range")
-	errMaxRequestBlobSidecarsExceeded = errors.Wrap(ErrInvalidFetchedData, "peer exceeded req blob chunk tx limit")
-	errChunkResponseSlotNotAsc        = errors.Wrap(ErrInvalidFetchedData, "blob slot not higher than previous block root")
-	errChunkResponseIndexNotAsc       = errors.Wrap(ErrInvalidFetchedData, "blob indices for a block must start at 0 and increase by 1")
-	errUnrequested                    = errors.Wrap(ErrInvalidFetchedData, "received BlobSidecar in response that was not requested")
-	errBlobResponseOutOfBounds        = errors.Wrap(ErrInvalidFetchedData, "received BlobSidecar with slot outside BlobSidecarsByRangeRequest bounds")
-	errChunkResponseBlockMismatch     = errors.Wrap(ErrInvalidFetchedData, "blob block details do not match")
-	errChunkResponseParentMismatch    = errors.Wrap(ErrInvalidFetchedData, "parent root for response element doesn't match previous element root")
+	errBlobIndexOutOfBounds           = errors.Wrap(verification.ErrBlobInvalid, "blob index out of range")
+	errMaxRequestBlobSidecarsExceeded = errors.Wrap(verification.ErrBlobInvalid, "peer exceeded req blob chunk tx limit")
+	errChunkResponseSlotNotAsc        = errors.Wrap(verification.ErrBlobInvalid, "blob slot not higher than previous block root")
+	errChunkResponseIndexNotAsc       = errors.Wrap(verification.ErrBlobInvalid, "blob indices for a block must start at 0 and increase by 1")
+	errUnrequested                    = errors.Wrap(verification.ErrBlobInvalid, "received BlobSidecar in response that was not requested")
+	errBlobResponseOutOfBounds        = errors.Wrap(verification.ErrBlobInvalid, "received BlobSidecar with slot outside BlobSidecarsByRangeRequest bounds")
+	errChunkResponseBlockMismatch     = errors.Wrap(verification.ErrBlobInvalid, "blob block details do not match")
+	errChunkResponseParentMismatch    = errors.Wrap(verification.ErrBlobInvalid, "parent root for response element doesn't match previous element root")
 )
 
 // BeaconBlockProcessor defines a block processing function, which allows to start utilizing

beacon-chain/sync/rpc_send_request_test.go

@@ -12,6 +12,7 @@ import (
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	p2pTypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -877,3 +878,7 @@ func TestSendBlobsByRangeRequest(t *testing.T) {
 		assert.Equal(t, int(totalElectraBlobs), len(blobs))
 	})
 }
+
+func TestErrInvalidFetchedDataDistinction(t *testing.T) {
+	require.Equal(t, false, errors.Is(ErrInvalidFetchedData, verification.ErrBlobInvalid))
+}

beacon-chain/sync/service.go

@@ -9,6 +9,7 @@ import (
 	"sync"
 	"time"
 
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	lru "github.com/hashicorp/golang-lru"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	libp2pcore "github.com/libp2p/go-libp2p/core"
@@ -165,6 +166,7 @@ type Service struct {
 	availableBlocker                 coverage.AvailableBlocker
 	ctxMap                           ContextByteVersions
 	slasherEnabled                   bool
+	lcStore                          *lightClient.Store
 }
 
 // NewService initializes new regular sync service.

beacon-chain/sync/subscriber.go

@@ -350,10 +350,9 @@ func (s *Service) wrapAndReportValidation(topic string, v wrappedVal) (string, p
 	}
 }
 
-// reValidateSubscriptions unsubscribe from topics we are currently subscribed to but that are
+// pruneSubscriptions unsubscribe from topics we are currently subscribed to but that are
 // not in the list of wanted subnets.
-// TODO: Rename this functions as it does not only revalidate subscriptions.
-func (s *Service) reValidateSubscriptions(
+func (s *Service) pruneSubscriptions(
 	subscriptions map[uint64]*pubsub.Subscription,
 	wantedSubs []uint64,
 	topicFormat string,
@@ -452,7 +451,7 @@ func (s *Service) subscribeToSubnets(
 			"digest":  fmt.Sprintf("%#x", digest),
 			"subnets": description,
 		}).Debug("Subnets with this digest are no longer valid, unsubscribing from all of them")
-		s.reValidateSubscriptions(subscriptions, []uint64{}, topicFormat, digest)
+		s.pruneSubscriptions(subscriptions, []uint64{}, topicFormat, digest)
 		return false
 	}
 
@@ -460,7 +459,7 @@ func (s *Service) subscribeToSubnets(
 	subnetsToSubscribeIndex := getSubnetsToSubscribe(currentSlot)
 
 	// Remove subscriptions that are no longer wanted.
-	s.reValidateSubscriptions(subscriptions, subnetsToSubscribeIndex, topicFormat, digest)
+	s.pruneSubscriptions(subscriptions, subnetsToSubscribeIndex, topicFormat, digest)
 
 	// Subscribe to wanted subnets.
 	for _, subnetIndex := range subnetsToSubscribeIndex {

beacon-chain/sync/subscriber_light_client.go

@@ -0,0 +1,66 @@
+package sync
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
+	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	lightclientTypes "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
+	"github.com/sirupsen/logrus"
+	"google.golang.org/protobuf/proto"
+)
+
+func (s *Service) lightClientOptimisticUpdateSubscriber(_ context.Context, msg proto.Message) error {
+	update, err := lightclientTypes.NewWrappedOptimisticUpdate(msg)
+	if err != nil {
+		return err
+	}
+
+	attestedHeaderRoot, err := update.AttestedHeader().Beacon().HashTreeRoot()
+	if err != nil {
+		return err
+	}
+
+	log.WithFields(logrus.Fields{
+		"attestedSlot":       fmt.Sprintf("%d", update.AttestedHeader().Beacon().Slot),
+		"signatureSlot":      fmt.Sprintf("%d", update.SignatureSlot()),
+		"attestedHeaderRoot": fmt.Sprintf("%x", attestedHeaderRoot),
+	}).Debug("Saving newly received light client optimistic update.")
+
+	s.lcStore.SetLastOptimisticUpdate(update)
+
+	s.cfg.stateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: update,
+	})
+
+	return nil
+}
+
+func (s *Service) lightClientFinalityUpdateSubscriber(_ context.Context, msg proto.Message) error {
+	update, err := lightclientTypes.NewWrappedFinalityUpdate(msg)
+	if err != nil {
+		return err
+	}
+
+	attestedHeaderRoot, err := update.AttestedHeader().Beacon().HashTreeRoot()
+	if err != nil {
+		return err
+	}
+
+	log.WithFields(logrus.Fields{
+		"attestedSlot":       fmt.Sprintf("%d", update.AttestedHeader().Beacon().Slot),
+		"signatureSlot":      fmt.Sprintf("%d", update.SignatureSlot()),
+		"attestedHeaderRoot": fmt.Sprintf("%x", attestedHeaderRoot),
+	}).Debug("Saving newly received light client finality update.")
+
+	s.lcStore.SetLastFinalityUpdate(update)
+
+	s.cfg.stateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientFinalityUpdate,
+		Data: update,
+	})
+
+	return nil
+}

beacon-chain/sync/subscriber_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/abool"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	db "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
@@ -27,6 +28,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -308,7 +310,7 @@ func TestRevalidateSubscription_CorrectlyFormatsTopic(t *testing.T) {
 	subscriptions[2], err = r.cfg.p2p.SubscribeToTopic(fullTopic)
 	require.NoError(t, err)
 
-	r.reValidateSubscriptions(subscriptions, []uint64{2}, defaultTopic, digest)
+	r.pruneSubscriptions(subscriptions, []uint64{2}, defaultTopic, digest)
 	require.LogsDoNotContain(t, hook, "Could not unregister topic validator")
 }
 
@@ -638,3 +640,137 @@ func createPeer(t *testing.T, topics ...string) *p2ptest.TestP2P {
 	}
 	return p
 }
+
+func TestSubscribe_ReceivesLCOptimisticUpdate(t *testing.T) {
+	origNC := params.BeaconConfig()
+	// restore network config after test completes
+	defer func() {
+		params.OverrideBeaconConfig(origNC)
+	}()
+
+	params.SetupTestConfigCleanup(t)
+	p2pService := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+	cfg := params.BeaconConfig().Copy()
+	cfg.AltairForkEpoch = 1
+	cfg.ForkVersionSchedule[[4]byte{1, 0, 0, 0}] = 1
+	params.OverrideBeaconConfig(cfg)
+
+	secondsPerSlot := int(params.BeaconConfig().SecondsPerSlot)
+	slotIntervals := int(params.BeaconConfig().IntervalsPerSlot)
+	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
+
+	genesisDrift := slotsPerEpoch*secondsPerSlot + 2*secondsPerSlot + secondsPerSlot/slotIntervals
+	chainService := &mockChain.ChainService{
+		ValidatorsRoot: [32]byte{'A'},
+		Genesis:        time.Unix(time.Now().Unix()-int64(genesisDrift), 0),
+	}
+	d := db.SetupDB(t)
+	r := Service{
+		ctx: ctx,
+		cfg: &config{
+			p2p:           p2pService,
+			initialSync:   &mockSync.Sync{IsSyncing: false},
+			chain:         chainService,
+			beaconDB:      d,
+			clock:         startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
+			stateNotifier: &mockChain.MockStateNotifier{},
+		},
+		chainStarted: abool.New(),
+		lcStore:      &lightClient.Store{},
+		subHandler:   newSubTopicHandler(),
+	}
+	topic := p2p.LightClientOptimisticUpdateTopicFormat
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	var err error
+	p2pService.Digest, err = r.currentForkDigest()
+	require.NoError(t, err)
+	r.subscribe(topic, r.validateLightClientOptimisticUpdate, func(ctx context.Context, msg proto.Message) error {
+		require.NoError(t, r.lightClientOptimisticUpdateSubscriber(ctx, msg))
+		wg.Done()
+		return nil
+	}, p2pService.Digest)
+
+	r.markForChainStart()
+
+	l := util.NewTestLightClient(t, version.Altair, util.WithSupermajority())
+	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
+	require.NoError(t, err, "Error generating light client optimistic update")
+
+	p2pService.ReceivePubSub(topic, update.Proto())
+
+	if util.WaitTimeout(&wg, time.Second) {
+		t.Fatal("Did not receive PubSub in 1 second")
+	}
+	u := r.lcStore.LastOptimisticUpdate()
+	assert.DeepEqual(t, update.Proto(), u.Proto())
+}
+
+func TestSubscribe_ReceivesLCFinalityUpdate(t *testing.T) {
+	origNC := params.BeaconConfig()
+	// restore network config after test completes
+	defer func() {
+		params.OverrideBeaconConfig(origNC)
+	}()
+
+	params.SetupTestConfigCleanup(t)
+	p2pService := p2ptest.NewTestP2P(t)
+	ctx := context.Background()
+	cfg := params.BeaconConfig().Copy()
+	cfg.AltairForkEpoch = 1
+	cfg.ForkVersionSchedule[[4]byte{1, 0, 0, 0}] = 1
+	params.OverrideBeaconConfig(cfg)
+
+	secondsPerSlot := int(params.BeaconConfig().SecondsPerSlot)
+	slotIntervals := int(params.BeaconConfig().IntervalsPerSlot)
+	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
+
+	genesisDrift := slotsPerEpoch*secondsPerSlot + 2*secondsPerSlot + secondsPerSlot/slotIntervals
+	chainService := &mockChain.ChainService{
+		ValidatorsRoot: [32]byte{'A'},
+		Genesis:        time.Unix(time.Now().Unix()-int64(genesisDrift), 0),
+	}
+	d := db.SetupDB(t)
+	r := Service{
+		ctx: ctx,
+		cfg: &config{
+			p2p:           p2pService,
+			initialSync:   &mockSync.Sync{IsSyncing: false},
+			chain:         chainService,
+			beaconDB:      d,
+			clock:         startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
+			stateNotifier: &mockChain.MockStateNotifier{},
+		},
+		chainStarted: abool.New(),
+		lcStore:      &lightClient.Store{},
+		subHandler:   newSubTopicHandler(),
+	}
+	topic := p2p.LightClientFinalityUpdateTopicFormat
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	var err error
+	p2pService.Digest, err = r.currentForkDigest()
+	require.NoError(t, err)
+	r.subscribe(topic, r.validateLightClientFinalityUpdate, func(ctx context.Context, msg proto.Message) error {
+		require.NoError(t, r.lightClientFinalityUpdateSubscriber(ctx, msg))
+		wg.Done()
+		return nil
+	}, p2pService.Digest)
+
+	r.markForChainStart()
+
+	l := util.NewTestLightClient(t, version.Altair, util.WithSupermajority())
+	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+	require.NoError(t, err, "Error generating light client finality update")
+
+	p2pService.ReceivePubSub(topic, update.Proto())
+
+	if util.WaitTimeout(&wg, time.Second) {
+		t.Fatal("Did not receive PubSub in 1 second")
+	}
+	u := r.lcStore.LastFinalityUpdate()
+	assert.DeepEqual(t, update.Proto(), u.Proto())
+}

beacon-chain/sync/validate_beacon_blocks.go

@@ -21,6 +21,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	prysmTime "github.com/OffchainLabs/prysm/v6/time"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -31,8 +32,9 @@ import (
 )
 
 var (
-	ErrOptimisticParent    = errors.New("parent of the block is optimistic")
-	errRejectCommitmentLen = errors.New("[REJECT] The length of KZG commitments is less than or equal to the limitation defined in Consensus Layer")
+	ErrOptimisticParent         = errors.New("parent of the block is optimistic")
+	errRejectCommitmentLen      = errors.New("[REJECT] The length of KZG commitments is less than or equal to the limitation defined in Consensus Layer")
+	ErrSlashingSignatureFailure = errors.New("proposer slashing signature verification failed")
 )
 
 // validateBeaconBlockPubSub checks that the incoming block has a valid BLS signature.
@@ -109,6 +111,16 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 
 	// Verify the block is the first block received for the proposer for the slot.
 	if s.hasSeenBlockIndexSlot(blk.Block().Slot(), blk.Block().ProposerIndex()) {
+		// Attempt to detect and broadcast equivocation before ignoring
+		err = s.detectAndBroadcastEquivocation(ctx, blk)
+		if err != nil {
+			// If signature verification fails, reject the block
+			if errors.Is(err, ErrSlashingSignatureFailure) {
+				return pubsub.ValidationReject, err
+			}
+			// In case there is some other error log but don't reject
+			log.WithError(err).Debug("Could not detect/broadcast equivocation")
+		}
 		return pubsub.ValidationIgnore, nil
 	}
 
@@ -469,3 +481,74 @@ func getBlockFields(b interfaces.ReadOnlySignedBeaconBlock) logrus.Fields {
 		"version":       b.Block().Version(),
 	}
 }
+
+// detectAndBroadcastEquivocation checks if the given block is an equivocating block by comparing it with
+// the head block. If the blocks are from the same slot and proposer but have different signatures,
+// it creates and broadcasts a proposer slashing object after verification.
+func (s *Service) detectAndBroadcastEquivocation(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) error {
+	slot := blk.Block().Slot()
+	proposerIndex := blk.Block().ProposerIndex()
+
+	// Get head block for comparison
+	headBlock, err := s.cfg.chain.HeadBlock(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get head block")
+	}
+
+	// Only proceed if this block is from same slot and proposer as head
+	if headBlock.Block().Slot() != slot || headBlock.Block().ProposerIndex() != proposerIndex {
+		return nil
+	}
+
+	// Compare signatures
+	sig1 := blk.Signature()
+	sig2 := headBlock.Signature()
+
+	// If signatures match, these are the same block
+	if sig1 == sig2 {
+		return nil
+	}
+
+	// Extract headers for slashing
+	header1, err := blk.Header()
+	if err != nil {
+		return errors.Wrap(err, "could not get header from new block")
+	}
+	header2, err := headBlock.Header()
+	if err != nil {
+		return errors.Wrap(err, "could not get header from head block")
+	}
+
+	slashing := &ethpb.ProposerSlashing{
+		Header_1: header1,
+		Header_2: header2,
+	}
+
+	// Get state for verification
+	headState, err := s.cfg.chain.HeadStateReadOnly(ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get head state")
+	}
+
+	// Verify the slashing against current state
+	if err := blocks.VerifyProposerSlashing(headState, slashing); err != nil {
+		if errors.Is(err, blocks.ErrCouldNotVerifyBlockHeader) {
+			return errors.Wrap(ErrSlashingSignatureFailure, err.Error())
+		}
+		return errors.Wrap(err, "could not verify proposer slashing")
+	}
+
+	// Broadcast if verification passes
+	if !features.Get().DisableBroadcastSlashings {
+		if err := s.cfg.p2p.Broadcast(ctx, slashing); err != nil {
+			return errors.Wrap(err, "could not broadcast slashing object")
+		}
+	}
+
+	// Insert into slashing pool
+	if err := s.cfg.slashingPool.InsertProposerSlashing(ctx, headState, slashing); err != nil {
+		return errors.Wrap(err, "could not insert proposer slashing into pool")
+	}
+
+	return nil
+}

beacon-chain/sync/validate_beacon_blocks_test.go

@@ -18,6 +18,7 @@ import (
 	dbtest "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
+	slashingsmock "github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings/mock"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
@@ -713,8 +714,21 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 	msg.Signature, err = signing.ComputeDomainAndSign(beaconState, 0, msg.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[proposerIdx])
 	require.NoError(t, err)
 
-	chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0),
-		State: beaconState,
+	// Create a clone of the same block (same signature, not an equivocation)
+	msgClone := util.NewBeaconBlock()
+	msgClone.Block.Slot = 1
+	msgClone.Block.ProposerIndex = proposerIdx
+	msgClone.Block.ParentRoot = bRoot[:]
+	msgClone.Signature = msg.Signature // Use the same signature
+
+	signedBlock, err := blocks.NewSignedBeaconBlock(msg)
+	require.NoError(t, err)
+
+	slashingPool := &slashingsmock.PoolMock{}
+	chainService := &mock.ChainService{
+		Genesis: time.Unix(time.Now().Unix()-int64(params.BeaconConfig().SecondsPerSlot), 0),
+		State:   beaconState,
+		Block:   signedBlock, // Set the first block as the head block
 		FinalizedCheckPoint: &ethpb.Checkpoint{
 			Epoch: 0,
 			Root:  make([]byte, 32),
@@ -728,6 +742,7 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 			chain:         chainService,
 			clock:         startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
 			blockNotifier: chainService.BlockNotifier(),
+			slashingPool:  slashingPool,
 		},
 		seenBlockCache:      lruwrpr.New(10),
 		badBlockCache:       lruwrpr.New(10),
@@ -735,10 +750,15 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 		seenPendingBlocks:   make(map[[32]byte]bool),
 	}
 
+	// Mark the proposer/slot as seen
+	r.setSeenBlockIndexSlot(msg.Block.Slot, msg.Block.ProposerIndex)
+	time.Sleep(10 * time.Millisecond) // Wait for cached value to pass through buffers
+
+	// Prepare and validate the second message (clone)
 	buf := new(bytes.Buffer)
-	_, err = p.Encoding().EncodeGossip(buf, msg)
+	_, err = p.Encoding().EncodeGossip(buf, msgClone)
 	require.NoError(t, err)
-	topic := p2p.GossipTypeMapping[reflect.TypeOf(msg)]
+	topic := p2p.GossipTypeMapping[reflect.TypeOf(msgClone)]
 	digest, err := r.currentForkDigest()
 	assert.NoError(t, err)
 	topic = r.addDigestToTopic(topic, digest)
@@ -748,11 +768,14 @@ func TestValidateBeaconBlockPubSub_SeenProposerSlot(t *testing.T) {
 			Topic: &topic,
 		},
 	}
-	r.setSeenBlockIndexSlot(msg.Block.Slot, msg.Block.ProposerIndex)
-	time.Sleep(10 * time.Millisecond) // Wait for cached value to pass through buffers.
+
+	// Since this is not an equivocation (same signature), it should be ignored
 	res, err := r.validateBeaconBlockPubSub(ctx, "", m)
 	assert.NoError(t, err)
-	assert.Equal(t, res, pubsub.ValidationIgnore, "seen proposer block should be ignored")
+	assert.Equal(t, pubsub.ValidationIgnore, res, "block with same signature should be ignored")
+
+	// Verify no slashings were created
+	assert.Equal(t, 0, len(slashingPool.PendingPropSlashings), "Expected no slashings for same signature")
 }
 
 func TestValidateBeaconBlockPubSub_FilterByFinalizedEpoch(t *testing.T) {
@@ -1495,3 +1518,218 @@ func Test_validateDenebBeaconBlock(t *testing.T) {
 	require.NoError(t, err)
 	require.ErrorIs(t, validateDenebBeaconBlock(bdb.Block()), errRejectCommitmentLen)
 }
+
+func TestDetectAndBroadcastEquivocation(t *testing.T) {
+	ctx := context.Background()
+	p := p2ptest.NewTestP2P(t)
+	beaconState, privKeys := util.DeterministicGenesisState(t, 100)
+
+	t.Run("no equivocation", func(t *testing.T) {
+		block := util.NewBeaconBlock()
+		block.Block.Slot = 1
+		block.Block.ProposerIndex = 0
+
+		sig, err := signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		block.Signature = sig
+
+		// Create head block with different slot/proposer
+		headBlock := util.NewBeaconBlock()
+		headBlock.Block.Slot = 2          // Different slot
+		headBlock.Block.ProposerIndex = 1 // Different proposer
+		signedHeadBlock, err := blocks.NewSignedBeaconBlock(headBlock)
+		require.NoError(t, err)
+
+		chainService := &mock.ChainService{
+			State:   beaconState,
+			Genesis: time.Now(),
+			Block:   signedHeadBlock,
+		}
+
+		slashingPool := &slashingsmock.PoolMock{}
+		r := &Service{
+			cfg: &config{
+				p2p:          p,
+				chain:        chainService,
+				slashingPool: slashingPool,
+			},
+			seenBlockCache: lruwrpr.New(10),
+		}
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		err = r.detectAndBroadcastEquivocation(ctx, signedBlock)
+		require.NoError(t, err)
+		assert.Equal(t, 0, len(slashingPool.PendingPropSlashings), "Expected no slashings")
+	})
+
+	t.Run("equivocation detected", func(t *testing.T) {
+		// Create head block
+		headBlock := util.NewBeaconBlock()
+		headBlock.Block.Slot = 1
+		headBlock.Block.ProposerIndex = 0
+		headBlock.Block.ParentRoot = bytesutil.PadTo([]byte("parent1"), 32)
+		sig1, err := signing.ComputeDomainAndSign(beaconState, 0, headBlock.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		headBlock.Signature = sig1
+
+		// Create second block with same slot/proposer but different contents
+		newBlock := util.NewBeaconBlock()
+		newBlock.Block.Slot = 1
+		newBlock.Block.ProposerIndex = 0
+		newBlock.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32)
+		sig2, err := signing.ComputeDomainAndSign(beaconState, 0, newBlock.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		newBlock.Signature = sig2
+
+		signedHeadBlock, err := blocks.NewSignedBeaconBlock(headBlock)
+		require.NoError(t, err)
+
+		slashingPool := &slashingsmock.PoolMock{}
+		chainService := &mock.ChainService{
+			State:   beaconState,
+			Genesis: time.Now(),
+			Block:   signedHeadBlock,
+		}
+
+		r := &Service{
+			cfg: &config{
+				p2p:          p,
+				chain:        chainService,
+				slashingPool: slashingPool,
+			},
+			seenBlockCache: lruwrpr.New(10),
+		}
+
+		signedNewBlock, err := blocks.NewSignedBeaconBlock(newBlock)
+		require.NoError(t, err)
+
+		err = r.detectAndBroadcastEquivocation(ctx, signedNewBlock)
+		require.NoError(t, err)
+
+		// Verify slashing was inserted
+		require.Equal(t, 1, len(slashingPool.PendingPropSlashings), "Expected a slashing to be inserted")
+		slashing := slashingPool.PendingPropSlashings[0]
+		assert.Equal(t, primitives.ValidatorIndex(0), slashing.Header_1.Header.ProposerIndex, "Wrong proposer index")
+		assert.Equal(t, primitives.Slot(1), slashing.Header_1.Header.Slot, "Wrong slot")
+	})
+
+	t.Run("same signature", func(t *testing.T) {
+		// Create block
+		block := util.NewBeaconBlock()
+		block.Block.Slot = 1
+		block.Block.ProposerIndex = 0
+		sig, err := signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		block.Signature = sig
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		slashingPool := &slashingsmock.PoolMock{}
+		chainService := &mock.ChainService{
+			State:   beaconState,
+			Genesis: time.Now(),
+			Block:   signedBlock,
+		}
+
+		r := &Service{
+			cfg: &config{
+				p2p:          p,
+				chain:        chainService,
+				slashingPool: slashingPool,
+			},
+			seenBlockCache: lruwrpr.New(10),
+		}
+
+		err = r.detectAndBroadcastEquivocation(ctx, signedBlock)
+		require.NoError(t, err)
+		assert.Equal(t, 0, len(slashingPool.PendingPropSlashings), "Expected no slashings for same signature")
+	})
+
+	t.Run("head state error", func(t *testing.T) {
+		block := util.NewBeaconBlock()
+		block.Block.Slot = 1
+		block.Block.ProposerIndex = 0
+		block.Block.ParentRoot = bytesutil.PadTo([]byte("parent1"), 32)
+		sig1, err := signing.ComputeDomainAndSign(beaconState, 0, block.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		block.Signature = sig1
+
+		headBlock := util.NewBeaconBlock()
+		headBlock.Block.Slot = 1                                            // Same slot
+		headBlock.Block.ProposerIndex = 0                                   // Same proposer
+		headBlock.Block.ParentRoot = bytesutil.PadTo([]byte("parent2"), 32) // Different parent root
+		sig2, err := signing.ComputeDomainAndSign(beaconState, 0, headBlock.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		headBlock.Signature = sig2
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		signedHeadBlock, err := blocks.NewSignedBeaconBlock(headBlock)
+		require.NoError(t, err)
+
+		chainService := &mock.ChainService{
+			State:        nil,
+			Block:        signedHeadBlock,
+			HeadStateErr: errors.New("could not get head state"),
+		}
+
+		r := &Service{
+			cfg: &config{
+				p2p:          p,
+				chain:        chainService,
+				slashingPool: &slashingsmock.PoolMock{},
+			},
+			seenBlockCache: lruwrpr.New(10),
+		}
+
+		err = r.detectAndBroadcastEquivocation(ctx, signedBlock)
+		require.ErrorContains(t, "could not get head state", err)
+	})
+	t.Run("signature verification failure", func(t *testing.T) {
+		// Create head block
+		headBlock := util.NewBeaconBlock()
+		headBlock.Block.Slot = 1
+		headBlock.Block.ProposerIndex = 0
+		sig1, err := signing.ComputeDomainAndSign(beaconState, 0, headBlock.Block, params.BeaconConfig().DomainBeaconProposer, privKeys[0])
+		require.NoError(t, err)
+		headBlock.Signature = sig1
+
+		// Create test block with invalid signature
+		newBlock := util.NewBeaconBlock()
+		newBlock.Block.Slot = 1
+		newBlock.Block.ProposerIndex = 0
+		newBlock.Block.ParentRoot = bytesutil.PadTo([]byte("different"), 32)
+		// generate invalid signature
+		invalidSig := make([]byte, 96)
+		copy(invalidSig, []byte("invalid signature"))
+		newBlock.Signature = invalidSig
+
+		signedHeadBlock, err := blocks.NewSignedBeaconBlock(headBlock)
+		require.NoError(t, err)
+		signedNewBlock, err := blocks.NewSignedBeaconBlock(newBlock)
+		require.NoError(t, err)
+
+		slashingPool := &slashingsmock.PoolMock{}
+		chainService := &mock.ChainService{
+			State:   beaconState,
+			Genesis: time.Now(),
+			Block:   signedHeadBlock,
+		}
+
+		r := &Service{
+			cfg: &config{
+				p2p:          p,
+				chain:        chainService,
+				slashingPool: slashingPool,
+			},
+			seenBlockCache: lruwrpr.New(10),
+		}
+
+		err = r.detectAndBroadcastEquivocation(ctx, signedNewBlock)
+		require.ErrorIs(t, err, ErrSlashingSignatureFailure)
+	})
+}

beacon-chain/sync/validate_light_client.go

@@ -0,0 +1,160 @@
+package sync
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/sirupsen/logrus"
+)
+
+func (s *Service) validateLightClientOptimisticUpdate(ctx context.Context, pid peer.ID, msg *pubsub.Message) (pubsub.ValidationResult, error) {
+	// Validation runs on publish (not just subscriptions), so we should approve any message from
+	// ourselves.
+	if pid == s.cfg.p2p.PeerID() {
+		return pubsub.ValidationAccept, nil
+	}
+
+	// Ignore updates while syncing
+	if s.cfg.initialSync.Syncing() {
+		return pubsub.ValidationIgnore, nil
+	}
+
+	_, span := trace.StartSpan(ctx, "sync.validateLightClientOptimisticUpdate")
+	defer span.End()
+
+	m, err := s.decodePubsubMessage(msg)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return pubsub.ValidationReject, err
+	}
+
+	newUpdate, ok := m.(interfaces.LightClientOptimisticUpdate)
+	if !ok {
+		return pubsub.ValidationReject, errWrongMessage
+	}
+
+	attestedHeaderRoot, err := newUpdate.AttestedHeader().Beacon().HashTreeRoot()
+	if err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+
+	// [IGNORE] The optimistic_update is received after the block at signature_slot was given enough time
+	// to propagate through the network -- i.e. validate that one-third of optimistic_update.signature_slot
+	// has transpired (SECONDS_PER_SLOT / INTERVALS_PER_SLOT seconds after the start of the slot,
+	// with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
+	earliestValidTime := slots.StartTime(uint64(s.cfg.clock.GenesisTime().Unix()), newUpdate.SignatureSlot()).
+		Add(time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot/params.BeaconConfig().IntervalsPerSlot)).
+		Add(-params.BeaconConfig().MaximumGossipClockDisparityDuration())
+	if s.cfg.clock.Now().Before(earliestValidTime) {
+		log.Debug("Newly received light client optimistic update ignored. not enough time passed for block to propagate")
+		return pubsub.ValidationIgnore, nil
+	}
+
+	lastStoredUpdate := s.lcStore.LastOptimisticUpdate()
+	if lastStoredUpdate != nil {
+		lastUpdateSlot := lastStoredUpdate.AttestedHeader().Beacon().Slot
+		newUpdateSlot := newUpdate.AttestedHeader().Beacon().Slot
+
+		// [IGNORE] The attested_header.beacon.slot is greater than that of all previously forwarded optimistic_updates
+		if newUpdateSlot <= lastUpdateSlot {
+			log.Debug("Newly received light client optimistic update ignored. new update is older than stored update")
+			return pubsub.ValidationIgnore, nil
+		}
+	}
+
+	log.WithFields(logrus.Fields{
+		"attestedSlot":       fmt.Sprintf("%d", newUpdate.AttestedHeader().Beacon().Slot),
+		"signatureSlot":      fmt.Sprintf("%d", newUpdate.SignatureSlot()),
+		"attestedHeaderRoot": fmt.Sprintf("%x", attestedHeaderRoot),
+	}).Debug("New gossiped light client optimistic update validated.")
+
+	msg.ValidatorData = newUpdate.Proto()
+	return pubsub.ValidationAccept, nil
+}
+
+func (s *Service) validateLightClientFinalityUpdate(ctx context.Context, pid peer.ID, msg *pubsub.Message) (pubsub.ValidationResult, error) {
+	// Validation runs on publish (not just subscriptions), so we should approve any message from
+	// ourselves.
+	if pid == s.cfg.p2p.PeerID() {
+		return pubsub.ValidationAccept, nil
+	}
+
+	// Ignore updates while syncing
+	if s.cfg.initialSync.Syncing() {
+		return pubsub.ValidationIgnore, nil
+	}
+
+	_, span := trace.StartSpan(ctx, "sync.validateLightClientFinalityUpdate")
+	defer span.End()
+
+	m, err := s.decodePubsubMessage(msg)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return pubsub.ValidationReject, err
+	}
+
+	newUpdate, ok := m.(interfaces.LightClientFinalityUpdate)
+	if !ok {
+		return pubsub.ValidationReject, errWrongMessage
+	}
+
+	attestedHeaderRoot, err := newUpdate.AttestedHeader().Beacon().HashTreeRoot()
+	if err != nil {
+		return pubsub.ValidationIgnore, err
+	}
+
+	// [IGNORE] The optimistic_update is received after the block at signature_slot was given enough time
+	// to propagate through the network -- i.e. validate that one-third of optimistic_update.signature_slot
+	// has transpired (SECONDS_PER_SLOT / INTERVALS_PER_SLOT seconds after the start of the slot,
+	// with a MAXIMUM_GOSSIP_CLOCK_DISPARITY allowance)
+	earliestValidTime := slots.StartTime(uint64(s.cfg.clock.GenesisTime().Unix()), newUpdate.SignatureSlot()).
+		Add(time.Second * time.Duration(params.BeaconConfig().SecondsPerSlot/params.BeaconConfig().IntervalsPerSlot)).
+		Add(-params.BeaconConfig().MaximumGossipClockDisparityDuration())
+	if s.cfg.clock.Now().Before(earliestValidTime) {
+		log.Debug("Newly received light client finality update ignored. not enough time passed for block to propagate")
+		return pubsub.ValidationIgnore, nil
+	}
+
+	lastStoredUpdate := s.lcStore.LastFinalityUpdate()
+	if lastStoredUpdate != nil {
+		lastUpdateSlot := lastStoredUpdate.FinalizedHeader().Beacon().Slot
+		newUpdateSlot := newUpdate.FinalizedHeader().Beacon().Slot
+
+		// [IGNORE] The finalized_header.beacon.slot is greater than that of all previously forwarded finality_updates,
+		// or it matches the highest previously forwarded slot and also has a sync_aggregate indicating supermajority (> 2/3)
+		// sync committee participation while the previously forwarded finality_update for that slot did not indicate supermajority
+		lastUpdateHasSupermajority := lightClient.UpdateHasSupermajority(lastStoredUpdate.SyncAggregate())
+		newUpdateHasSupermajority := lightClient.UpdateHasSupermajority(newUpdate.SyncAggregate())
+
+		if newUpdateSlot < lastUpdateSlot {
+			log.Debug("Newly received light client finality update ignored. new update is older than stored update")
+			return pubsub.ValidationIgnore, nil
+		}
+		if newUpdateSlot == lastUpdateSlot && (lastUpdateHasSupermajority || !newUpdateHasSupermajority) {
+			log.WithFields(logrus.Fields{
+				"attestedSlot":       fmt.Sprintf("%d", newUpdate.AttestedHeader().Beacon().Slot),
+				"signatureSlot":      fmt.Sprintf("%d", newUpdate.SignatureSlot()),
+				"attestedHeaderRoot": fmt.Sprintf("%x", attestedHeaderRoot),
+			}).Debug("Newly received light client finality update ignored. no supermajority advantage.")
+			return pubsub.ValidationIgnore, nil
+		}
+	}
+
+	log.WithFields(logrus.Fields{
+		"attestedSlot":       fmt.Sprintf("%d", newUpdate.AttestedHeader().Beacon().Slot),
+		"signatureSlot":      fmt.Sprintf("%d", newUpdate.SignatureSlot()),
+		"attestedHeaderRoot": fmt.Sprintf("%x", attestedHeaderRoot),
+	}).Debug("New gossiped light client finality update validated.")
+
+	msg.ValidatorData = newUpdate.Proto()
+	return pubsub.ValidationAccept, nil
+}

beacon-chain/sync/validate_light_client_test.go

@@ -0,0 +1,284 @@
+package sync
+
+import (
+	"bytes"
+	"context"
+	"testing"
+	"time"
+
+	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
+	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
+	mockSync "github.com/OffchainLabs/prysm/v6/beacon-chain/sync/initial-sync/testing"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	pb "github.com/libp2p/go-libp2p-pubsub/pb"
+)
+
+func TestValidateLightClientOptimisticUpdate_NilMessageOrTopic(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	ctx := context.Background()
+	p := p2ptest.NewTestP2P(t)
+	s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}}}
+
+	_, err := s.validateLightClientOptimisticUpdate(ctx, "", nil)
+	require.ErrorIs(t, err, errNilPubsubMessage)
+
+	_, err = s.validateLightClientOptimisticUpdate(ctx, "", &pubsub.Message{Message: &pb.Message{}})
+	require.ErrorIs(t, err, errNilPubsubMessage)
+
+	emptyTopic := ""
+	_, err = s.validateLightClientOptimisticUpdate(ctx, "", &pubsub.Message{Message: &pb.Message{
+		Topic: &emptyTopic,
+	}})
+	require.ErrorIs(t, err, errNilPubsubMessage)
+}
+
+func TestValidateLightClientOptimisticUpdate(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.AltairForkEpoch = 1
+	cfg.BellatrixForkEpoch = 2
+	cfg.CapellaForkEpoch = 3
+	cfg.DenebForkEpoch = 4
+	cfg.ElectraForkEpoch = 5
+	cfg.ForkVersionSchedule[[4]byte{1, 0, 0, 0}] = 1
+	cfg.ForkVersionSchedule[[4]byte{2, 0, 0, 0}] = 2
+	cfg.ForkVersionSchedule[[4]byte{3, 0, 0, 0}] = 3
+	cfg.ForkVersionSchedule[[4]byte{4, 0, 0, 0}] = 4
+	cfg.ForkVersionSchedule[[4]byte{5, 0, 0, 0}] = 5
+	params.OverrideBeaconConfig(cfg)
+
+	secondsPerSlot := int(params.BeaconConfig().SecondsPerSlot)
+	slotIntervals := int(params.BeaconConfig().IntervalsPerSlot)
+	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
+
+	tests := []struct {
+		name             string
+		genesisDrift     int
+		oldUpdateOptions []util.LightClientOption
+		newUpdateOptions []util.LightClientOption
+		expectedResult   pubsub.ValidationResult
+		expectedErr      error
+	}{
+		{
+			name:             "no previous update",
+			oldUpdateOptions: nil,
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationAccept,
+		},
+		{
+			name:             "not enough time passed",
+			genesisDrift:     -secondsPerSlot / slotIntervals,
+			oldUpdateOptions: nil,
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationIgnore,
+		},
+		{
+			name:             "new update has no age advantage",
+			oldUpdateOptions: []util.LightClientOption{},
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationIgnore,
+		},
+		{
+			name:             "new update is better - younger",
+			genesisDrift:     secondsPerSlot,
+			oldUpdateOptions: []util.LightClientOption{},
+			newUpdateOptions: []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
+			expectedResult:   pubsub.ValidationAccept,
+		},
+	}
+
+	for _, test := range tests {
+		for v := 1; v < 6; v++ {
+			t.Run(test.name+"_"+version.String(v), func(t *testing.T) {
+				ctx := context.Background()
+				p := p2ptest.NewTestP2P(t)
+				// drift back appropriate number of epochs based on fork + 2 slots for signature slot + time for gossip propagation + any extra drift
+				genesisDrift := v*slotsPerEpoch*secondsPerSlot + 2*secondsPerSlot + secondsPerSlot/slotIntervals + test.genesisDrift
+				chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(genesisDrift), 0)}
+				s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}, lcStore: &lightClient.Store{}}
+
+				var oldUpdate interfaces.LightClientOptimisticUpdate
+				var err error
+				if test.oldUpdateOptions != nil {
+					l := util.NewTestLightClient(t, v, test.oldUpdateOptions...)
+					oldUpdate, err = lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
+					require.NoError(t, err)
+
+					s.lcStore.SetLastOptimisticUpdate(oldUpdate)
+				}
+
+				l := util.NewTestLightClient(t, v, test.newUpdateOptions...)
+				newUpdate, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock)
+				require.NoError(t, err)
+				buf := new(bytes.Buffer)
+				_, err = p.Encoding().EncodeGossip(buf, newUpdate)
+				require.NoError(t, err)
+
+				topic := p2p.LightClientOptimisticUpdateTopicFormat
+				digest, err := s.currentForkDigest()
+				require.NoError(t, err)
+				topic = s.addDigestToTopic(topic, digest)
+
+				r, err := s.validateLightClientOptimisticUpdate(ctx, "", &pubsub.Message{
+					Message: &pb.Message{
+						Data:  buf.Bytes(),
+						Topic: &topic,
+					}})
+				if test.expectedErr != nil {
+					require.ErrorIs(t, err, test.expectedErr)
+				} else {
+					require.NoError(t, err)
+					require.Equal(t, test.expectedResult, r)
+				}
+			})
+		}
+	}
+}
+
+func TestValidateLightClientFinalityUpdate_NilMessageOrTopic(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	ctx := context.Background()
+	p := p2ptest.NewTestP2P(t)
+	s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}}}
+
+	_, err := s.validateLightClientFinalityUpdate(ctx, "", nil)
+	require.ErrorIs(t, err, errNilPubsubMessage)
+
+	_, err = s.validateLightClientFinalityUpdate(ctx, "", &pubsub.Message{Message: &pb.Message{}})
+	require.ErrorIs(t, err, errNilPubsubMessage)
+
+	emptyTopic := ""
+	_, err = s.validateLightClientFinalityUpdate(ctx, "", &pubsub.Message{Message: &pb.Message{
+		Topic: &emptyTopic,
+	}})
+	require.ErrorIs(t, err, errNilPubsubMessage)
+}
+
+func TestValidateLightClientFinalityUpdate(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.AltairForkEpoch = 1
+	cfg.BellatrixForkEpoch = 2
+	cfg.CapellaForkEpoch = 3
+	cfg.DenebForkEpoch = 4
+	cfg.ElectraForkEpoch = 5
+	cfg.ForkVersionSchedule[[4]byte{1, 0, 0, 0}] = 1
+	cfg.ForkVersionSchedule[[4]byte{2, 0, 0, 0}] = 2
+	cfg.ForkVersionSchedule[[4]byte{3, 0, 0, 0}] = 3
+	cfg.ForkVersionSchedule[[4]byte{4, 0, 0, 0}] = 4
+	cfg.ForkVersionSchedule[[4]byte{5, 0, 0, 0}] = 5
+	params.OverrideBeaconConfig(cfg)
+
+	secondsPerSlot := int(params.BeaconConfig().SecondsPerSlot)
+	slotIntervals := int(params.BeaconConfig().IntervalsPerSlot)
+	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
+
+	tests := []struct {
+		name             string
+		genesisDrift     int
+		oldUpdateOptions []util.LightClientOption
+		newUpdateOptions []util.LightClientOption
+		expectedResult   pubsub.ValidationResult
+		expectedErr      error
+	}{
+		{
+			name:             "no previous update",
+			oldUpdateOptions: nil,
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationAccept,
+		},
+		{
+			name:             "not enough time passed",
+			genesisDrift:     -secondsPerSlot / slotIntervals,
+			oldUpdateOptions: nil,
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationIgnore,
+		},
+		{
+			name:             "new update has no advantage",
+			oldUpdateOptions: []util.LightClientOption{},
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationIgnore,
+		},
+		{
+			name:             "new update is better - age",
+			genesisDrift:     secondsPerSlot,
+			oldUpdateOptions: []util.LightClientOption{},
+			newUpdateOptions: []util.LightClientOption{util.WithIncreasedFinalizedSlot(1)},
+			expectedResult:   pubsub.ValidationAccept,
+		},
+		{
+			name:             "new update is better - supermajority",
+			oldUpdateOptions: []util.LightClientOption{},
+			newUpdateOptions: []util.LightClientOption{util.WithSupermajority()},
+			expectedResult:   pubsub.ValidationAccept,
+		},
+		{
+			name:             "old update is better - supermajority",
+			oldUpdateOptions: []util.LightClientOption{util.WithSupermajority()},
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationIgnore,
+		},
+		{
+			name:             "old update is better - age",
+			oldUpdateOptions: []util.LightClientOption{util.WithIncreasedAttestedSlot(1)},
+			newUpdateOptions: []util.LightClientOption{},
+			expectedResult:   pubsub.ValidationIgnore,
+		},
+	}
+
+	for _, test := range tests {
+		for v := 1; v < 6; v++ {
+			t.Run(test.name+"_"+version.String(v), func(t *testing.T) {
+				ctx := context.Background()
+				p := p2ptest.NewTestP2P(t)
+				// drift back appropriate number of epochs based on fork + 2 slots for signature slot + time for gossip propagation + any extra drift
+				genesisDrift := v*slotsPerEpoch*secondsPerSlot + 2*secondsPerSlot + secondsPerSlot/slotIntervals + test.genesisDrift
+				chainService := &mock.ChainService{Genesis: time.Unix(time.Now().Unix()-int64(genesisDrift), 0)}
+				s := &Service{cfg: &config{p2p: p, initialSync: &mockSync.Sync{}, clock: startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot)}, lcStore: &lightClient.Store{}}
+
+				var oldUpdate interfaces.LightClientFinalityUpdate
+				var err error
+				if test.oldUpdateOptions != nil {
+					l := util.NewTestLightClient(t, v, test.oldUpdateOptions...)
+					oldUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+					require.NoError(t, err)
+
+					s.lcStore.SetLastFinalityUpdate(oldUpdate)
+				}
+
+				l := util.NewTestLightClient(t, v, test.newUpdateOptions...)
+				newUpdate, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State.Slot(), l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
+				require.NoError(t, err)
+				buf := new(bytes.Buffer)
+				_, err = p.Encoding().EncodeGossip(buf, newUpdate)
+				require.NoError(t, err)
+
+				topic := p2p.LightClientFinalityUpdateTopicFormat
+				digest, err := s.currentForkDigest()
+				require.NoError(t, err)
+				topic = s.addDigestToTopic(topic, digest)
+
+				r, err := s.validateLightClientFinalityUpdate(ctx, "", &pubsub.Message{
+					Message: &pb.Message{
+						Data:  buf.Bytes(),
+						Topic: &topic,
+					}})
+				if test.expectedErr != nil {
+					require.ErrorIs(t, err, test.expectedErr)
+				} else {
+					require.NoError(t, err)
+					require.Equal(t, test.expectedResult, r)
+				}
+			})
+		}
+	}
+}

beacon-chain/verification/error.go

@@ -16,6 +16,11 @@ func AsVerificationFailure(err error) error {
 	return errors.Join(ErrInvalid, err)
 }
 
+// IsBlobValidationFailure checks if the given error is a blob validation failure.
+func IsBlobValidationFailure(err error) bool {
+	return errors.Is(err, ErrBlobInvalid)
+}
+
 var (
 	// ErrBlobInvalid is joined with all other blob verification errors. This enables other packages to check for any sort of
 	// verification error at one point, like sync code checking for peer scoring purposes.

changelog/bastin_add-lc-p2p-broadcasters.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add light client p2p broadcaster functions.

changelog/bastin_add-lc-p2p-validators-and-subscribers.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add light client p2p validator and subscriber functions.

changelog/bastin_add-lc-types-to-spectest.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add light client ssz types to the spec test

changelog/bastin_add-lcstore-to-beacon-node.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add light client store object to the beacon node object.

changelog/bastin_add-parameters-to-lc-testutils.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- add two parameters `increaseAttestedSlotBy` and `supermajority` to the lc test utils.

changelog/bastin_lightclient-updates-ssz.md

@@ -1,3 +0,0 @@
-### Added
-
-- Add SSZ support to light client updates by range API. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15082)

changelog/bastin_remove-content-disposition-writessz.md

@@ -1,3 +0,0 @@
-### Changed
-
-- Remove the header `Content-Disposition` from the `httputil.WriteSSZ` function. No `filename` parameter is needed anymore.

changelog/gazzua_use_io_stream.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Fixed to use io stream instead of stream read

changelog/james-prysm_apiutil.md

@@ -1,3 +0,0 @@
-### Ignored
-
-- moves some beacon api helper functions to apiutil and removes the string implementation of isvalidroot for the byte validation.

changelog/james-prysm_attestation-api-fork-guard.md

@@ -1,3 +0,0 @@
-### Fixed
-
-- Adding fork guard to attestation api endpoints so that it doesn't accidentally include wrong attestation types in the pool.