Add all the fixes from pre-commit (#14846)

* precommit fixes

* fix remaining

.github/CODEOWNERS

@@ -5,4 +5,4 @@
 *.bzl @prestonvanloon
 
 # Anyone on prylabs team can approve dependency updates.
-deps.bzl @prysmaticlabs/core-team
+deps.bzl @prysmaticlabs/core-team

.github/actions/gomodtidy/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.23-alpine
+FROM golang:1.24-alpine
 
 COPY entrypoint.sh /entrypoint.sh
 

.github/workflows/go.yml

@@ -28,15 +28,15 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Set up Go 1.23
+      - name: Set up Go 1.24
         uses: actions/setup-go@v4
         with:
-          go-version: '1.23.5'
+          go-version: '1.24.0'
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
-          go install github.com/securego/gosec/v2/cmd/gosec@v2.19.0
-          gosec -exclude-generated -exclude=G307 -exclude-dir=crypto/bls/herumi ./...
+          go install github.com/securego/gosec/v2/cmd/gosec@v2.22.1
+          gosec -exclude-generated -exclude=G307,G115 -exclude-dir=crypto/bls/herumi ./...
 
   lint:
     name: Lint
@@ -45,16 +45,16 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Set up Go 1.23
+      - name: Set up Go 1.24
         uses: actions/setup-go@v4
         with:
-          go-version: '1.23.5'
+          go-version: '1.24.0'
           id: go
 
       - name: Golangci-lint
         uses: golangci/golangci-lint-action@v5
         with:
-          version: v1.63.4
+          version: v1.64.5
           args: --config=.golangci.yml --out-${NO_FUTURE}format colored-line-number
 
   build:
@@ -64,7 +64,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v4
         with:
-          go-version: '1.23.5'
+          go-version: '1.24.0'
         id: go
 
       - name: Check out code into the Go module directory

.github/workflows/horusec.yaml

@@ -19,4 +19,4 @@ jobs:
     - name: Running Security Scan
       run: |
         curl -fsSL https://raw.githubusercontent.com/ZupIT/horusec/main/deployments/scripts/install.sh | bash -s latest
-        horusec start -t="10000" -p="./" -e="true" -i="**/crypto/bls/herumi/**, **/**/*_test.go, **/third_party/afl/**, **/crypto/keystore/key.go"
+        horusec start -t="10000" -p="./" -e="true" -i="**/crypto/bls/herumi/**, **/**/*_test.go, **/third_party/afl/**, **/crypto/keystore/key.go"

.golangci.yml

@@ -75,6 +75,7 @@ linters:
     - tagliatelle
     - thelper
     - unparam
+    - usetesting
     - varnamelen
     - wrapcheck
     - wsl

.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+repos:
+  # First run code formatters
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0
+    hooks:
+      - id: end-of-file-fixer # ensures that a file is either empty, or ends with one newline
+        exclude_types: ["proto"]
+      - id: mixed-line-ending # ensures that a file doesn't contain a mix of LF and CRLF
+      - id: no-commit-to-branch # Protect specific branches (default: main/master) from direct checkins
+
+  - repo: local
+    hooks:
+      - id: gci
+        name: goimports
+        entry: bash -c 'command -v gci >/dev/null 2>&1 || go install github.com/daixiang0/gci@latest; gci write --skip-generated -s standard -s default "$@"; goimports -w "$@"' --
+        language: golang
+        files: \.go$
+
+  - repo: https://github.com/dnephin/pre-commit-golang
+    rev: v0.4.0
+    hooks:
+      - id: go-fmt
+        args: [ -w, -s ] # simplify code and write result to (source) file instead of stdout
+      - id: go-mod-tidy
+        files: go.mod
+      - id: golangci-lint
+
+  # Fix bazel build files
+  - repo: local
+    hooks:
+      - id: gazelle
+        name: bazel-fix
+        entry: .pre-commit/fixbazel.sh
+        language: system

.pre-commit/fixbazel.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+
+bazel run //:gazelle -- fix

BUILD.bazel

@@ -165,7 +165,7 @@ STATICCHECK_ANALYZERS = [
     "sa6006",
     "sa9001",
     "sa9002",
-    #"sa9003", # Doesn't build. See https://github.com/dominikh/go-tools/pull/1483
+    "sa9003",
     "sa9004",
     "sa9005",
     "sa9006",

CONTRIBUTING.md

@@ -175,6 +175,23 @@ $ git push myrepo feature-in-progress-branch -f
 
 **22.  Finally, again leave a comment to the Core Contributors on the pull request to let them know that the pull request has been updated.**
 
+### Git hooks and linters.
+
+Prysm is configured with [pre-commit](https://pre-commit.com) **githooks** that ensures pull
+requests adhere to a minimum standard and are consistent. It is highly recommended running the githooks locally while developing for faster feedback.
+
+To install githooks:
+- Follow installation instructions [here](https://pre-commit.com/#installation) to install the `pre-commit` tool.
+- Once installed, run `pre-commit install` in the project's root directory. This will set up the hooks.
+- Note you can skip the hooks by committing with `-n`: `git commit -n -m "look mom no githooks"`
+
+To update githooks:
+```sh
+pre-commit clean
+```
+
+The **linter** used is [golangci-lint](https://golangci-lint.run/). It runs as part of the githooks and is configured in [.golangci.yml](.golangci.yml)
+
 ## Maintaining CHANGELOG.md
 
 This project follows the changelog guidelines from [keepachangelog.com](https://keepachangelog.com/en/1.1.0/). In order to minimize conflicts and workflow headaches, we chose to implement a changelog management

LICENSE.md

@@ -672,4 +672,3 @@ may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
 <http://www.gnu.org/philosophy/why-not-lgpl.html>.
-

TERMS_OF_SERVICE.md

@@ -50,4 +50,3 @@ We reserve the right to revise these Terms, and your rights and obligations are
 These Terms constitute the entire agreement between you and Offchain Labs regarding use of Prysm and will supersede all prior agreements whether, written or oral. No usage of trade or other regular practice or method of dealing between the parties will be used to modify, interpret, supplement, or alter the terms of these Terms.
 
 If any portion of these Terms is held invalid or unenforceable, such invalidity or enforceability will not affect the other provisions of these Terms, which will remain in full force and effect, and the invalid or unenforceable portion will be given effect to the greatest extent possible. The failure of a party to require performance of any provision will not affect that party’s right to require performance at any time thereafter, nor will a waiver of any breach or default of these Terms or any provision of these Terms constitute a waiver of any subsequent breach or default or a waiver of the provision itself.
-

WORKSPACE

@@ -160,15 +160,15 @@ oci_register_toolchains(
 
 http_archive(
     name = "io_bazel_rules_go",
+    integrity = "sha256-JD8o94crTb2DFiJJR8nMAGdBAW95zIENB4cbI+JnrI4=",
     patch_args = ["-p1"],
     patches = [
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "b2038e2de2cace18f032249cb4bb0048abf583a36369fa98f687af1b3f880b26",
+    strip_prefix = "rules_go-cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9",
     urls = [
-        "https://mirror.bazel.build/github.com/bazelbuild/rules_go/releases/download/v0.48.1/rules_go-v0.48.1.zip",
-        "https://github.com/bazelbuild/rules_go/releases/download/v0.48.1/rules_go-v0.48.1.zip",
+        "https://github.com/bazel-contrib/rules_go/archive/cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9.tar.gz",
     ],
 )
 
@@ -210,7 +210,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.23.5",
+    go_version = "1.24.0",
     nogo = "@//:nogo",
 )
 
@@ -431,7 +431,7 @@ gometalinter_dependencies()
 
 load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
 
-gazelle_dependencies()
+gazelle_dependencies(go_sdk = "go_sdk")
 
 load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
 

api/server/httprest/options.go

@@ -1,9 +1,8 @@
 package httprest
 
 import (
-	"time"
-
 	"net/http"
+	"time"
 
 	"github.com/prysmaticlabs/prysm/v5/api/server/middleware"
 )

api/server/structs/endpoints_debug.go

@@ -54,4 +54,5 @@ type ForkChoiceNodeExtraData struct {
 	Balance                  string `json:"balance"`
 	ExecutionOptimistic      bool   `json:"execution_optimistic"`
 	TimeStamp                string `json:"timestamp"`
+	Target                   string `json:"target"`
 }

beacon-chain/blockchain/BUILD.bazel

@@ -26,6 +26,7 @@ go_library(
         "receive_blob.go",
         "receive_block.go",
         "service.go",
+        "setup_forchoice.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
     ],
@@ -96,6 +97,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@org_golang_x_sync//errgroup:go_default_library",
     ],
@@ -154,6 +156,7 @@ go_test(
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
+        "//beacon-chain/operations/attestations/kv:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
@@ -185,6 +188,7 @@ go_test(
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",

beacon-chain/blockchain/forkchoice_update_execution.go

@@ -103,7 +103,7 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuCo
 	}
 
 	// Only need to prune attestations from pool if the head has changed.
-	if err := s.pruneAttsFromPool(args.headBlock); err != nil {
+	if err := s.pruneAttsFromPool(s.ctx, args.headState, args.headBlock); err != nil {
 		log.WithError(err).Error("could not prune attestations from pool")
 	}
 	return nil

beacon-chain/blockchain/kzg/trusted_setup.json

@@ -4164,4 +4164,4 @@
     "0xa92039a08b5502d5b211a7744099c9f93fa8c90cedcb1d05e92f01886219dd464eb5fb0337496ad96ed09c987da4e5f019035c5b01cc09b2a18b8a8dd419bc5895388a07e26958f6bd26751929c25f89b8eb4a299d822e2d26fec9ef350e0d3c",
     "0x92dcc5a1c8c3e1b28b1524e3dd6dbecd63017c9201da9dbe077f1b82adc08c50169f56fc7b5a3b28ec6b89254de3e2fd12838a761053437883c3e01ba616670cea843754548ef84bcc397de2369adcca2ab54cd73c55dc68d87aec3fc2fe4f10"
   ]
-}
+}

beacon-chain/blockchain/options.go

@@ -213,3 +213,10 @@ func WithSyncChecker(checker Checker) Option {
 		return nil
 	}
 }
+
+func WithSlasherEnabled(enabled bool) Option {
+	return func(s *Service) error {
+		s.slasherEnabled = enabled
+		return nil
+	}
+}

beacon-chain/blockchain/process_attestation.go

@@ -80,7 +80,7 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	}
 
 	// Use the target state to verify attesting indices are valid.
-	committees, err := helpers.AttestationCommittees(ctx, baseState, a)
+	committees, err := helpers.AttestationCommitteesFromState(ctx, baseState, a)
 	if err != nil {
 		return err
 	}

beacon-chain/blockchain/process_block.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
@@ -15,6 +16,7 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -368,7 +370,7 @@ func (s *Service) handleEpochBoundary(ctx context.Context, slot primitives.Slot,
 func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock, st state.BeaconState) error {
 	// Feed in block's attestations to fork choice store.
 	for _, a := range blk.Body().Attestations() {
-		committees, err := helpers.AttestationCommittees(ctx, st, a)
+		committees, err := helpers.AttestationCommitteesFromState(ctx, st, a)
 		if err != nil {
 			return err
 		}
@@ -419,27 +421,98 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 	return nil
 }
 
-// This removes the attestations in block `b` from the attestation mem pool.
-func (s *Service) pruneAttsFromPool(headBlock interfaces.ReadOnlySignedBeaconBlock) error {
-	atts := headBlock.Block().Body().Attestations()
-	for _, att := range atts {
-		if features.Get().EnableExperimentalAttestationPool {
-			if err := s.cfg.AttestationCache.DeleteCovered(att); err != nil {
-				return errors.Wrap(err, "could not delete attestation")
-			}
-		} else if att.IsAggregated() {
-			if err := s.cfg.AttPool.DeleteAggregatedAttestation(att); err != nil {
-				return err
-			}
-		} else {
-			if err := s.cfg.AttPool.DeleteUnaggregatedAttestation(att); err != nil {
-				return err
-			}
+// pruneAttsFromPool removes these attestations from the attestation pool
+// which are covered by attestations from the received block.
+func (s *Service) pruneAttsFromPool(ctx context.Context, headState state.BeaconState, headBlock interfaces.ReadOnlySignedBeaconBlock) error {
+	for _, att := range headBlock.Block().Body().Attestations() {
+		if err := s.pruneCoveredAttsFromPool(ctx, headState, att); err != nil {
+			log.WithError(err).Warn("Could not prune attestations covered by a received block's attestation")
 		}
 	}
 	return nil
 }
 
+func (s *Service) pruneCoveredAttsFromPool(ctx context.Context, headState state.BeaconState, att ethpb.Att) error {
+	switch {
+	case !att.IsAggregated():
+		return s.cfg.AttPool.DeleteUnaggregatedAttestation(att)
+	case att.Version() == version.Phase0:
+		if features.Get().EnableExperimentalAttestationPool {
+			return errors.Wrap(s.cfg.AttestationCache.DeleteCovered(att), "could not delete covered attestation")
+		}
+		return errors.Wrap(s.cfg.AttPool.DeleteAggregatedAttestation(att), "could not delete aggregated attestation")
+	default:
+		return s.pruneCoveredElectraAttsFromPool(ctx, headState, att)
+	}
+}
+
+// pruneCoveredElectraAttsFromPool handles removing aggregated Electra attestations from the pool after receiving a block.
+// Because in Electra block attestations can combine aggregates for multiple committees, comparing attestation bits
+// of a block attestation with attestations bits of an aggregate can cause unexpected results, leading to covered
+// aggregates not being removed from the pool.
+//
+// To make sure aggregates are removed, we decompose the block attestation into dummy aggregates, with each
+// aggregate accounting for one committee. This allows us to compare aggregates in the same way it's done for
+// Phase0. Even though we can't provide a valid signature for the dummy aggregate, it does not matter because
+// signatures play no part in pruning attestations.
+func (s *Service) pruneCoveredElectraAttsFromPool(ctx context.Context, headState state.BeaconState, att ethpb.Att) error {
+	if att.Version() == version.Phase0 {
+		log.Error("Called pruneCoveredElectraAttsFromPool with a Phase0 attestation")
+		return nil
+	}
+
+	// We don't want to recompute committees. If they are not cached already,
+	// we allow attestations to stay in the pool. If these attestations are
+	// included in a later block, they will be redundant. But given that
+	// they were not cached in the first place, it's unlikely that they
+	// will be chosen into a block.
+	ok, committees, err := helpers.AttestationCommitteesFromCache(ctx, headState, att)
+	if err != nil {
+		return errors.Wrap(err, "could not get attestation committees")
+	}
+	if !ok {
+		log.Debug("Attestation committees are not cached. Skipping attestation pruning.")
+		return nil
+	}
+
+	committeeIndices := att.CommitteeBitsVal().BitIndices()
+	offset := uint64(0)
+
+	// Sanity check as this should never happen
+	if len(committeeIndices) != len(committees) {
+		return errors.New("committee indices and committees have different lengths")
+	}
+
+	for i, c := range committees {
+		ab := bitfield.NewBitlist(uint64(len(c)))
+		for j := uint64(0); j < uint64(len(c)); j++ {
+			ab.SetBitAt(j, att.GetAggregationBits().BitAt(j+offset))
+		}
+
+		cb := primitives.NewAttestationCommitteeBits()
+		cb.SetBitAt(uint64(committeeIndices[i]), true)
+
+		a := &ethpb.AttestationElectra{
+			AggregationBits: ab,
+			Data:            att.GetData(),
+			CommitteeBits:   cb,
+			Signature:       make([]byte, fieldparams.BLSSignatureLength),
+		}
+
+		if features.Get().EnableExperimentalAttestationPool {
+			if err = s.cfg.AttestationCache.DeleteCovered(a); err != nil {
+				return errors.Wrap(err, "could not delete covered attestation")
+			}
+		} else if err = s.cfg.AttPool.DeleteAggregatedAttestation(a); err != nil {
+			return errors.Wrap(err, "could not delete aggregated attestation")
+		}
+
+		offset += uint64(len(c))
+	}
+
+	return nil
+}
+
 // validateMergeTransitionBlock validates the merge transition block.
 func (s *Service) validateMergeTransitionBlock(ctx context.Context, stateVersion int, stateHeader interfaces.ExecutionData, blk interfaces.ReadOnlySignedBeaconBlock) error {
 	// Skip validation if block is older than Bellatrix.

beacon-chain/blockchain/process_block_helpers.go

@@ -7,13 +7,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"

beacon-chain/blockchain/process_block_test.go

@@ -12,8 +12,10 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	gethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -25,6 +27,7 @@ import (
 	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations/kv"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
@@ -45,6 +48,90 @@ import (
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
+func Test_pruneAttsFromPool_Electra(t *testing.T) {
+	ctx := context.Background()
+
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.TargetCommitteeSize = 8
+	params.OverrideBeaconConfig(cfg)
+
+	s := Service{
+		cfg: &config{
+			AttPool: kv.NewAttCaches(),
+		},
+	}
+
+	data := &ethpb.AttestationData{
+		BeaconBlockRoot: make([]byte, 32),
+		Source:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+		Target:          &ethpb.Checkpoint{Root: make([]byte, 32)},
+	}
+
+	cb := primitives.NewAttestationCommitteeBits()
+	cb.SetBitAt(0, true)
+	att1 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b11110111, 0b00000001},
+		Data:            data,
+		Signature:       make([]byte, 96),
+		CommitteeBits:   cb,
+	}
+
+	cb = primitives.NewAttestationCommitteeBits()
+	cb.SetBitAt(1, true)
+	att2 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b11110111, 0b00000001},
+		Data:            data,
+		Signature:       make([]byte, 96),
+		CommitteeBits:   cb,
+	}
+
+	cb = primitives.NewAttestationCommitteeBits()
+	cb.SetBitAt(3, true)
+	att3 := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b11110111, 0b00000001},
+		Data:            data,
+		Signature:       make([]byte, 96),
+		CommitteeBits:   cb,
+	}
+
+	require.NoError(t, s.cfg.AttPool.SaveAggregatedAttestation(att1))
+	require.NoError(t, s.cfg.AttPool.SaveAggregatedAttestation(att2))
+	require.NoError(t, s.cfg.AttPool.SaveAggregatedAttestation(att3))
+	require.Equal(t, 3, len(s.cfg.AttPool.AggregatedAttestations()))
+
+	cb = primitives.NewAttestationCommitteeBits()
+	cb.SetBitAt(0, true)
+	cb.SetBitAt(1, true)
+	onChainAtt := &ethpb.AttestationElectra{
+		AggregationBits: bitfield.Bitlist{0b11110111, 0b11110111, 0b00000001},
+		Data:            data,
+		Signature:       make([]byte, 96),
+		CommitteeBits:   cb,
+	}
+	bl := &ethpb.SignedBeaconBlockElectra{
+		Block: &ethpb.BeaconBlockElectra{
+			Body: &ethpb.BeaconBlockBodyElectra{
+				Attestations: []*ethpb.AttestationElectra{onChainAtt},
+			},
+		},
+		Signature: make([]byte, 96),
+	}
+	rob, err := consensusblocks.NewSignedBeaconBlock(bl)
+	require.NoError(t, err)
+	st, _ := util.DeterministicGenesisStateElectra(t, 1024)
+	committees, err := helpers.BeaconCommittees(ctx, st, 0)
+	require.NoError(t, err)
+	// Sanity check to make sure the on-chain att will be decomposed
+	// into the correct number of aggregates.
+	require.Equal(t, 4, len(committees))
+
+	require.NoError(t, s.pruneAttsFromPool(ctx, st, rob))
+	attsInPool := s.cfg.AttPool.AggregatedAttestations()
+	require.Equal(t, 1, len(attsInPool))
+	assert.DeepEqual(t, att3, attsInPool[0])
+}
+
 func TestStore_OnBlockBatch(t *testing.T) {
 	service, tr := minimalTestService(t)
 	ctx := tr.ctx
@@ -840,7 +927,7 @@ func TestRemoveBlockAttestationsInPool(t *testing.T) {
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	require.NoError(t, service.pruneAttsFromPool(wsb))
+	require.NoError(t, service.pruneAttsFromPool(context.Background(), nil /* state not needed pre-Electra */, wsb))
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
 }
 
@@ -2039,7 +2126,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.Equal(t, genesisRoot, bytesutil.ToBytes32(headRoot))
 	optimistic, err := service.IsOptimistic(ctx)
 	require.NoError(t, err)
-	require.Equal(t, false, optimistic)
+	require.Equal(t, true, optimistic)
 
 	// Check that the node's justified checkpoint does not agree with the
 	// last valid state's justified checkpoint

beacon-chain/blockchain/receive_block.go

@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -121,7 +120,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		return err
 	}
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
-	if features.Get().EnableSlasher {
+	if s.slasherEnabled {
 		go s.sendBlockAttestationsToSlasher(blockCopy, preState)
 	}
 
@@ -548,7 +547,7 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 	// is done in the background to avoid adding more load to this critical code path.
 	ctx := context.TODO()
 	for _, att := range signed.Block().Body().Attestations() {
-		committees, err := helpers.AttestationCommittees(ctx, preState, att)
+		committees, err := helpers.AttestationCommitteesFromState(ctx, preState, att)
 		if err != nil {
 			log.WithError(err).Error("Could not get attestation committees")
 			return

beacon-chain/blockchain/service.go

@@ -3,7 +3,6 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
 	"runtime"
@@ -23,7 +22,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
 	f "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
-	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/slashings"
@@ -32,7 +30,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -65,6 +62,7 @@ type Service struct {
 	blobNotifiers        *blobNotifierMap
 	blockBeingSynced     *currentlySyncingBlock
 	blobStorage          *filesystem.BlobStorage
+	slasherEnabled       bool
 }
 
 // config options for the service.
@@ -269,69 +267,18 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return err
 	}
 	s.originBlockRoot = originRoot
-
-	if err := s.initializeHeadFromDB(s.ctx); err != nil {
-		return errors.Wrap(err, "could not set up chain info")
+	st, err := s.cfg.StateGen.Resume(s.ctx, s.cfg.FinalizedStateAtStartUp)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized state from db")
 	}
 	spawnCountdownIfPreGenesis(s.ctx, s.genesisTime, s.cfg.BeaconDB)
-
-	justified, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get justified checkpoint")
-	}
-	if justified == nil {
-		return errNilJustifiedCheckpoint
-	}
-	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint")
-	}
-	if finalized == nil {
-		return errNilFinalizedCheckpoint
-	}
-
-	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
-	s.cfg.ForkChoiceStore.Lock()
-	defer s.cfg.ForkChoiceStore.Unlock()
-	if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(s.ctx, &forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
-		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
-	}
-	if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
-		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
-		return errors.Wrap(err, "could not update forkchoice's finalized checkpoint")
-	}
-	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
-
-	st, err := s.cfg.StateGen.StateByRoot(s.ctx, fRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint state")
-	}
-	finalizedBlock, err := s.cfg.BeaconDB.Block(s.ctx, fRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint block")
-	}
-	roblock, err := blocks.NewROBlockWithRoot(finalizedBlock, fRoot)
-	if err != nil {
-		return err
-	}
-	if err := s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, roblock); err != nil {
-		return errors.Wrap(err, "could not insert finalized block to forkchoice")
-	}
-	if !features.Get().EnableStartOptimistic {
-		lastValidatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(s.ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not get last validated checkpoint")
-		}
-		if bytes.Equal(finalized.Root, lastValidatedCheckpoint.Root) {
-			if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(s.ctx, fRoot); err != nil {
-				return errors.Wrap(err, "could not set finalized block as validated")
-			}
-		}
+	if err := s.setupForkchoice(st); err != nil {
+		return errors.Wrap(err, "could not set up forkchoice")
 	}
 	// not attempting to save initial sync blocks here, because there shouldn't be any until
 	// after the statefeed.Initialized event is fired (below)
-	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, finalized.Epoch); err != nil {
+	cp := s.FinalizedCheckpt()
+	if err := s.wsVerifier.VerifyWeakSubjectivity(s.ctx, cp.Epoch); err != nil {
 		// Exit run time if the node failed to verify weak subjectivity checkpoint.
 		return errors.Wrap(err, "could not verify initial checkpoint provided for chain sync")
 	}
@@ -340,7 +287,6 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err := s.clockSetter.SetClock(startup.NewClock(s.genesisTime, vr)); err != nil {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
-
 	return nil
 }
 
@@ -373,23 +319,10 @@ func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error
 // initializeHeadFromDB uses the finalized checkpoint and head block found in the database to set the current head.
 // Note that this may block until stategen replays blocks between the finalized and head blocks
 // if the head sync flag was specified and the gap between the finalized and head blocks is at least 128 epochs long.
-func (s *Service) initializeHeadFromDB(ctx context.Context) error {
-	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint from db")
-	}
-	if finalized == nil {
-		// This should never happen. At chain start, the finalized checkpoint
-		// would be the genesis state and block.
-		return errors.New("no finalized epoch in the database")
-	}
-	finalizedRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
-	var finalizedState state.BeaconState
-
-	finalizedState, err = s.cfg.StateGen.Resume(ctx, s.cfg.FinalizedStateAtStartUp)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized state from db")
-	}
+func (s *Service) initializeHeadFromDB(ctx context.Context, finalizedState state.BeaconState) error {
+	cp := s.FinalizedCheckpt()
+	fRoot := [32]byte(cp.Root)
+	finalizedRoot := s.ensureRootNotZeros(fRoot)
 
 	if finalizedState == nil || finalizedState.IsNil() {
 		return errors.New("finalized state can't be nil")

beacon-chain/blockchain/setup_forchoice.go

@@ -0,0 +1,84 @@
+package blockchain
+
+import (
+	"bytes"
+
+	"github.com/pkg/errors"
+	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+)
+
+func (s *Service) setupForkchoice(st state.BeaconState) error {
+	if err := s.setupForkchoiceCheckpoints(); err != nil {
+		return errors.Wrap(err, "could not set up forkchoice checkpoints")
+	}
+	if err := s.setupForkchoiceRoot(st); err != nil {
+		return errors.Wrap(err, "could not set up forkchoice root")
+	}
+	if err := s.initializeHeadFromDB(s.ctx, st); err != nil {
+		return errors.Wrap(err, "could not initialize head from db")
+	}
+	return nil
+}
+
+func (s *Service) setupForkchoiceRoot(st state.BeaconState) error {
+	cp := s.FinalizedCheckpt()
+	fRoot := s.ensureRootNotZeros([32]byte(cp.Root))
+	finalizedBlock, err := s.cfg.BeaconDB.Block(s.ctx, fRoot)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized checkpoint block")
+	}
+	roblock, err := blocks.NewROBlockWithRoot(finalizedBlock, fRoot)
+	if err != nil {
+		return err
+	}
+	if err := s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, roblock); err != nil {
+		return errors.Wrap(err, "could not insert finalized block to forkchoice")
+	}
+	if !features.Get().EnableStartOptimistic {
+		lastValidatedCheckpoint, err := s.cfg.BeaconDB.LastValidatedCheckpoint(s.ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not get last validated checkpoint")
+		}
+		if bytes.Equal(fRoot[:], lastValidatedCheckpoint.Root) {
+			if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(s.ctx, fRoot); err != nil {
+				return errors.Wrap(err, "could not set finalized block as validated")
+			}
+		}
+	}
+	return nil
+}
+
+func (s *Service) setupForkchoiceCheckpoints() error {
+	justified, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get justified checkpoint")
+	}
+	if justified == nil {
+		return errNilJustifiedCheckpoint
+	}
+	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
+	if err != nil {
+		return errors.Wrap(err, "could not get finalized checkpoint")
+	}
+	if finalized == nil {
+		return errNilFinalizedCheckpoint
+	}
+
+	fRoot := s.ensureRootNotZeros(bytesutil.ToBytes32(finalized.Root))
+	s.cfg.ForkChoiceStore.Lock()
+	defer s.cfg.ForkChoiceStore.Unlock()
+	if err := s.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(s.ctx, &forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
+		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
+		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
+	}
+	if err := s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
+		Root: fRoot}); err != nil {
+		return errors.Wrap(err, "could not update forkchoice's finalized checkpoint")
+	}
+	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(s.genesisTime.Unix()))
+	return nil
+}

beacon-chain/core/altair/attestation.go

@@ -66,7 +66,7 @@ func ProcessAttestationNoVerifySignature(
 	if err != nil {
 		return nil, err
 	}
-	committees, err := helpers.AttestationCommittees(ctx, beaconState, att)
+	committees, err := helpers.AttestationCommitteesFromState(ctx, beaconState, att)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/blocks/signature.go

@@ -192,7 +192,7 @@ func createAttestationSignatureBatch(
 	descs := make([]string, len(atts))
 	for i, a := range atts {
 		sigs[i] = a.GetSignature()
-		committees, err := helpers.AttestationCommittees(ctx, beaconState, a)
+		committees, err := helpers.AttestationCommitteesFromState(ctx, beaconState, a)
 		if err != nil {
 			return nil, err
 		}

beacon-chain/core/helpers/beacon_committee.go

@@ -30,6 +30,13 @@ var (
 	proposerIndicesCache = cache.NewProposerIndicesCache()
 )
 
+type beaconCommitteeFunc = func(
+	ctx context.Context,
+	state state.ReadOnlyBeaconState,
+	slot primitives.Slot,
+	committeeIndex primitives.CommitteeIndex,
+) ([]primitives.ValidatorIndex, error)
+
 // SlotCommitteeCount returns the number of beacon committees of a slot. The
 // active validator count is provided as an argument rather than an imported implementation
 // from the spec definition. Having the active validator count as an argument allows for
@@ -59,21 +66,48 @@ func SlotCommitteeCount(activeValidatorCount uint64) uint64 {
 	return committeesPerSlot
 }
 
-// AttestationCommittees returns beacon state committees that reflect attestation's committee indices.
-func AttestationCommittees(ctx context.Context, st state.ReadOnlyBeaconState, att ethpb.Att) ([][]primitives.ValidatorIndex, error) {
+// AttestationCommitteesFromState returns beacon state committees that reflect attestation's committee indices.
+func AttestationCommitteesFromState(ctx context.Context, st state.ReadOnlyBeaconState, att ethpb.Att) ([][]primitives.ValidatorIndex, error) {
+	return attestationCommittees(ctx, st, att, BeaconCommitteeFromState)
+}
+
+// AttestationCommitteesFromCache has the same functionality as AttestationCommitteesFromState, but only returns a value
+// when all attestation committees are already cached.
+func AttestationCommitteesFromCache(ctx context.Context, st state.ReadOnlyBeaconState, att ethpb.Att) (bool, [][]primitives.ValidatorIndex, error) {
+	committees, err := attestationCommittees(ctx, st, att, BeaconCommitteeFromCache)
+	if err != nil {
+		return false, nil, err
+	}
+	if len(committees) == 0 {
+		return false, nil, nil
+	}
+	for _, c := range committees {
+		if len(c) == 0 {
+			return false, nil, nil
+		}
+	}
+	return true, committees, nil
+}
+
+func attestationCommittees(
+	ctx context.Context,
+	st state.ReadOnlyBeaconState,
+	att ethpb.Att,
+	committeeFunc beaconCommitteeFunc,
+) ([][]primitives.ValidatorIndex, error) {
 	var committees [][]primitives.ValidatorIndex
 	if att.Version() >= version.Electra {
 		committeeIndices := att.CommitteeBitsVal().BitIndices()
 		committees = make([][]primitives.ValidatorIndex, len(committeeIndices))
 		for i, ci := range committeeIndices {
-			committee, err := BeaconCommitteeFromState(ctx, st, att.GetData().Slot, primitives.CommitteeIndex(ci))
+			committee, err := committeeFunc(ctx, st, att.GetData().Slot, primitives.CommitteeIndex(ci))
 			if err != nil {
 				return nil, err
 			}
 			committees[i] = committee
 		}
 	} else {
-		committee, err := BeaconCommitteeFromState(ctx, st, att.GetData().Slot, att.GetData().CommitteeIndex)
+		committee, err := committeeFunc(ctx, st, att.GetData().Slot, att.GetData().CommitteeIndex)
 		if err != nil {
 			return nil, err
 		}
@@ -164,6 +198,27 @@ func BeaconCommitteeFromState(ctx context.Context, state state.ReadOnlyBeaconSta
 	return BeaconCommittee(ctx, activeIndices, seed, slot, committeeIndex)
 }
 
+// BeaconCommitteeFromCache has the same functionality as BeaconCommitteeFromState, but only returns a value
+// when the committee is already cached.
+func BeaconCommitteeFromCache(
+	ctx context.Context,
+	state state.ReadOnlyBeaconState,
+	slot primitives.Slot,
+	committeeIndex primitives.CommitteeIndex,
+) ([]primitives.ValidatorIndex, error) {
+	epoch := slots.ToEpoch(slot)
+	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get seed")
+	}
+
+	committee, err := committeeCache.Committee(ctx, slot, seed, committeeIndex)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not interface with committee cache")
+	}
+	return committee, nil
+}
+
 // BeaconCommittee returns the beacon committee of a given slot and committee index. The
 // validator indices and seed are provided as an argument rather than an imported implementation
 // from the spec definition. Having them as an argument allows for cheaper computation run time.

beacon-chain/core/helpers/beacon_committee_test.go

@@ -729,7 +729,9 @@ func TestCommitteeIndices(t *testing.T) {
 	assert.DeepEqual(t, []primitives.CommitteeIndex{0, 1, 3}, indices)
 }
 
-func TestAttestationCommittees(t *testing.T) {
+func TestAttestationCommitteesFromState(t *testing.T) {
+	ctx := context.Background()
+
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
@@ -745,7 +747,7 @@ func TestAttestationCommittees(t *testing.T) {
 
 	t.Run("pre-Electra", func(t *testing.T) {
 		att := &ethpb.Attestation{Data: &ethpb.AttestationData{CommitteeIndex: 0}}
-		committees, err := helpers.AttestationCommittees(context.Background(), state, att)
+		committees, err := helpers.AttestationCommitteesFromState(ctx, state, att)
 		require.NoError(t, err)
 		require.Equal(t, 1, len(committees))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
@@ -755,7 +757,7 @@ func TestAttestationCommittees(t *testing.T) {
 		bits.SetBitAt(0, true)
 		bits.SetBitAt(1, true)
 		att := &ethpb.AttestationElectra{CommitteeBits: bits, Data: &ethpb.AttestationData{}}
-		committees, err := helpers.AttestationCommittees(context.Background(), state, att)
+		committees, err := helpers.AttestationCommitteesFromState(ctx, state, att)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(committees))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
@@ -763,9 +765,58 @@ func TestAttestationCommittees(t *testing.T) {
 	})
 }
 
-func TestBeaconCommittees(t *testing.T) {
-	prevConfig := params.BeaconConfig().Copy()
-	defer params.OverrideBeaconConfig(prevConfig)
+func TestAttestationCommitteesFromCache(t *testing.T) {
+	ctx := context.Background()
+
+	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+
+	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	})
+	require.NoError(t, err)
+
+	t.Run("pre-Electra", func(t *testing.T) {
+		helpers.ClearCache()
+		att := &ethpb.Attestation{Data: &ethpb.AttestationData{CommitteeIndex: 0}}
+		ok, _, err := helpers.AttestationCommitteesFromCache(ctx, state, att)
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+		require.NoError(t, helpers.UpdateCommitteeCache(ctx, state, 0))
+		ok, committees, err := helpers.AttestationCommitteesFromCache(ctx, state, att)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+		require.Equal(t, 1, len(committees))
+		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
+	})
+	t.Run("post-Electra", func(t *testing.T) {
+		helpers.ClearCache()
+		bits := primitives.NewAttestationCommitteeBits()
+		bits.SetBitAt(0, true)
+		bits.SetBitAt(1, true)
+		att := &ethpb.AttestationElectra{CommitteeBits: bits, Data: &ethpb.AttestationData{}}
+		ok, _, err := helpers.AttestationCommitteesFromCache(ctx, state, att)
+		require.NoError(t, err)
+		require.Equal(t, false, ok)
+		require.NoError(t, helpers.UpdateCommitteeCache(ctx, state, 0))
+		ok, committees, err := helpers.AttestationCommitteesFromCache(ctx, state, att)
+		require.NoError(t, err)
+		require.Equal(t, true, ok)
+		require.Equal(t, 2, len(committees))
+		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
+		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[1])))
+	})
+}
+
+func TestBeaconCommitteesFromState(t *testing.T) {
+	ctx := context.Background()
+
+	params.SetupTestConfigCleanup(t)
 	c := params.BeaconConfig().Copy()
 	c.MinGenesisActiveValidatorCount = 128
 	c.SlotsPerEpoch = 4
@@ -774,15 +825,49 @@ func TestBeaconCommittees(t *testing.T) {
 
 	state, _ := util.DeterministicGenesisState(t, 256)
 
-	activeCount, err := helpers.ActiveValidatorCount(context.Background(), state, 0)
+	activeCount, err := helpers.ActiveValidatorCount(ctx, state, 0)
 	require.NoError(t, err)
 	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-	committees, err := helpers.BeaconCommittees(context.Background(), state, 0)
+	committees, err := helpers.BeaconCommittees(ctx, state, 0)
 	require.NoError(t, err)
 	require.Equal(t, committeesPerSlot, uint64(len(committees)))
 	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
-		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, 0, idx)
+		committee, err := helpers.BeaconCommitteeFromState(ctx, state, 0, idx)
 		require.NoError(t, err)
-		require.DeepEqual(t, committees[idx], committee)
+		assert.DeepEqual(t, committees[idx], committee)
+	}
+}
+
+func TestBeaconCommitteesFromCache(t *testing.T) {
+	ctx := context.Background()
+
+	params.SetupTestConfigCleanup(t)
+	c := params.BeaconConfig().Copy()
+	c.MinGenesisActiveValidatorCount = 128
+	c.SlotsPerEpoch = 4
+	c.TargetCommitteeSize = 16
+	params.OverrideBeaconConfig(c)
+
+	state, _ := util.DeterministicGenesisState(t, 256)
+
+	activeCount, err := helpers.ActiveValidatorCount(ctx, state, 0)
+	require.NoError(t, err)
+	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
+	committees, err := helpers.BeaconCommittees(ctx, state, 0)
+	require.NoError(t, err)
+	require.Equal(t, committeesPerSlot, uint64(len(committees)))
+
+	helpers.ClearCache()
+	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
+		committee, err := helpers.BeaconCommitteeFromCache(ctx, state, 0, idx)
+		require.NoError(t, err)
+		assert.Equal(t, 0, len(committee))
+	}
+
+	require.NoError(t, helpers.UpdateCommitteeCache(ctx, state, 0))
+	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
+		committee, err := helpers.BeaconCommitteeFromCache(ctx, state, 0, idx)
+		require.NoError(t, err)
+		assert.DeepEqual(t, committees[idx], committee)
 	}
 }

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

@@ -5,15 +5,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	light_client "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-
 	"github.com/pkg/errors"
 	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensustypes "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	light_client "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	v11 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"

beacon-chain/db/iface/interface.go

@@ -101,7 +101,7 @@ type NoHeadAccessDatabase interface {
 	SaveLightClientBootstrap(ctx context.Context, blockRoot []byte, bootstrap interfaces.LightClientBootstrap) error
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
-	DeleteHistoricalDataBeforeSlot(ctx context.Context, slot primitives.Slot) error
+	DeleteHistoricalDataBeforeSlot(ctx context.Context, slot primitives.Slot, batchSize int) (int, error)
 }
 
 // HeadAccessDatabase defines a struct with access to reading chain head data.

beacon-chain/db/kv/blocks.go

@@ -245,77 +245,82 @@ func (s *Store) DeleteBlock(ctx context.Context, root [32]byte) error {
 // - blockRootValidatorHashesBucket
 // - blockSlotIndicesBucket
 // - stateSlotIndicesBucket
-func (s *Store) DeleteHistoricalDataBeforeSlot(ctx context.Context, cutoffSlot primitives.Slot) error {
+func (s *Store) DeleteHistoricalDataBeforeSlot(ctx context.Context, cutoffSlot primitives.Slot, batchSize int) (int, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.DeleteHistoricalDataBeforeSlot")
 	defer span.End()
 
 	// Collect slot/root pairs to perform deletions in a separate read only transaction.
-	var (
-		roots [][]byte
-		slts  []primitives.Slot
-	)
-	err := s.db.View(func(tx *bolt.Tx) error {
-		var err error
-		roots, slts, err = blockRootsBySlotRange(ctx, tx.Bucket(blockSlotIndicesBucket), primitives.Slot(0), cutoffSlot, nil, nil, nil)
-		if err != nil {
-			return errors.Wrap(err, "could not retrieve block roots")
-		}
-		return nil
-	})
+	slotRoots, err := s.slotRootsInRange(ctx, primitives.Slot(0), cutoffSlot, batchSize)
 	if err != nil {
-		return errors.Wrap(err, "could not retrieve block roots and slots")
+		return 0, err
+	}
+
+	// Return early if there's nothing to delete.
+	if len(slotRoots) == 0 {
+		return 0, nil
 	}
 
 	// Perform all deletions in a single transaction for atomicity
-	return s.db.Update(func(tx *bolt.Tx) error {
-		for _, root := range roots {
+	var numSlotsDeleted int
+	err = s.db.Update(func(tx *bolt.Tx) error {
+		for _, sr := range slotRoots {
+			// Return if context is cancelled or deadline is exceeded.
+			if ctx.Err() != nil {
+				//nolint:nilerr
+				return nil
+			}
+
 			// Delete block
-			if err = s.deleteBlock(tx, root); err != nil {
+			if err = s.deleteBlock(tx, sr.root[:]); err != nil {
 				return err
 			}
 
 			// Delete finalized block roots index
-			if err = tx.Bucket(finalizedBlockRootsIndexBucket).Delete(root); err != nil {
+			if err = tx.Bucket(finalizedBlockRootsIndexBucket).Delete(sr.root[:]); err != nil {
 				return errors.Wrap(err, "could not delete finalized block root index")
 			}
 
 			// Delete state
-			if err = tx.Bucket(stateBucket).Delete(root); err != nil {
+			if err = tx.Bucket(stateBucket).Delete(sr.root[:]); err != nil {
 				return errors.Wrap(err, "could not delete state")
 			}
 
 			// Delete state summary
-			if err = tx.Bucket(stateSummaryBucket).Delete(root); err != nil {
+			if err = tx.Bucket(stateSummaryBucket).Delete(sr.root[:]); err != nil {
 				return errors.Wrap(err, "could not delete state summary")
 			}
 
 			// Delete validator entries
-			if err = s.deleteValidatorHashes(tx, root); err != nil {
+			if err = s.deleteValidatorHashes(tx, sr.root[:]); err != nil {
 				return errors.Wrap(err, "could not delete validators")
 			}
+
+			numSlotsDeleted++
 		}
 
-		for _, slot := range slts {
+		for _, sr := range slotRoots {
 			// Delete slot indices
-			if err = tx.Bucket(blockSlotIndicesBucket).Delete(bytesutil.SlotToBytesBigEndian(slot)); err != nil {
+			if err = tx.Bucket(blockSlotIndicesBucket).Delete(bytesutil.SlotToBytesBigEndian(sr.slot)); err != nil {
 				return errors.Wrap(err, "could not delete block slot index")
 			}
-			if err = tx.Bucket(stateSlotIndicesBucket).Delete(bytesutil.SlotToBytesBigEndian(slot)); err != nil {
+			if err = tx.Bucket(stateSlotIndicesBucket).Delete(bytesutil.SlotToBytesBigEndian(sr.slot)); err != nil {
 				return errors.Wrap(err, "could not delete state slot index")
 			}
 		}
 
 		// Delete all caches after we have deleted everything from buckets.
 		// This is done after the buckets are deleted to avoid any issues in case of transaction rollback.
-		for _, root := range roots {
+		for _, sr := range slotRoots {
 			// Delete block from cache
-			s.blockCache.Del(string(root))
+			s.blockCache.Del(string(sr.root[:]))
 			// Delete state summary from cache
-			s.stateSummaryCache.delete([32]byte(root))
+			s.stateSummaryCache.delete(sr.root)
 		}
 
 		return nil
 	})
+
+	return numSlotsDeleted, err
 }
 
 // SaveBlock to the db.
@@ -336,7 +341,7 @@ func (s *Store) SaveBlock(ctx context.Context, signed interfaces.ReadOnlySignedB
 // if a `saveBlindedBeaconBlocks` key exists in the database. Otherwise, we check if the last
 // blocked stored to check if it is blinded, and then write that `saveBlindedBeaconBlocks` key
 // to the DB for future checks.
-func (s *Store) shouldSaveBlinded(ctx context.Context) (bool, error) {
+func (s *Store) shouldSaveBlinded() (bool, error) {
 	var saveBlinded bool
 	if err := s.db.View(func(tx *bolt.Tx) error {
 		metadataBkt := tx.Bucket(chainMetadataBucket)
@@ -398,7 +403,7 @@ func prepareBlockBatch(blks []blocks.ROBlock, shouldBlind bool) ([]blockBatchEnt
 }
 
 func (s *Store) SaveROBlocks(ctx context.Context, blks []blocks.ROBlock, cache bool) error {
-	shouldBlind, err := s.shouldSaveBlinded(ctx)
+	shouldBlind, err := s.shouldSaveBlinded()
 	if err != nil {
 		return err
 	}
@@ -669,6 +674,49 @@ func (s *Store) SaveRegistrationsByValidatorIDs(ctx context.Context, ids []primi
 	})
 }
 
+type slotRoot struct {
+	slot primitives.Slot
+	root [32]byte
+}
+
+// slotRootsInRange returns slot and block root pairs of length min(batchSize, end-slot)
+func (s *Store) slotRootsInRange(ctx context.Context, start, end primitives.Slot, batchSize int) ([]slotRoot, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.slotRootsInRange")
+	defer span.End()
+	if end < start {
+		return nil, errInvalidSlotRange
+	}
+
+	var pairs []slotRoot
+	key := bytesutil.SlotToBytesBigEndian(end)
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(blockSlotIndicesBucket)
+		c := bkt.Cursor()
+		for k, v := c.Seek(key); k != nil; k, v = c.Prev() {
+			slot := bytesutil.BytesToSlotBigEndian(k)
+			if slot > end {
+				continue // Seek will seek to the next key *after* the given one if not present
+			}
+			if slot < start {
+				return nil
+			}
+			roots, err := splitRoots(v)
+			if err != nil {
+				return errors.Wrapf(err, "corrupt value %v in block slot index for slot=%d", v, slot)
+			}
+			for _, r := range roots {
+				pairs = append(pairs, slotRoot{slot: slot, root: r})
+			}
+			if len(pairs) >= batchSize {
+				return nil // allows code to easily cap the number of items pruned
+			}
+		}
+		return nil
+	})
+
+	return pairs, err
+}
+
 // blockRootsByFilter retrieves the block roots given the filter criteria.
 func blockRootsByFilter(ctx context.Context, tx *bolt.Tx, f *filters.QueryFilter) ([][]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.blockRootsByFilter")
@@ -689,7 +737,7 @@ func blockRootsByFilter(ctx context.Context, tx *bolt.Tx, f *filters.QueryFilter
 
 	// We retrieve block roots that match a filter criteria of slot ranges, if specified.
 	filtersMap := f.Filters()
-	rootsBySlotRange, _, err := blockRootsBySlotRange(
+	rootsBySlotRange, err := blockRootsBySlotRange(
 		ctx,
 		tx.Bucket(blockSlotIndicesBucket),
 		filtersMap[filters.StartSlot],
@@ -734,13 +782,13 @@ func blockRootsBySlotRange(
 	ctx context.Context,
 	bkt *bolt.Bucket,
 	startSlotEncoded, endSlotEncoded, startEpochEncoded, endEpochEncoded, slotStepEncoded interface{},
-) ([][]byte, []primitives.Slot, error) {
+) ([][]byte, error) {
 	_, span := trace.StartSpan(ctx, "BeaconDB.blockRootsBySlotRange")
 	defer span.End()
 
 	// Return nothing when all slot parameters are missing
 	if startSlotEncoded == nil && endSlotEncoded == nil && startEpochEncoded == nil && endEpochEncoded == nil {
-		return [][]byte{}, nil, nil
+		return [][]byte{}, nil
 	}
 
 	var startSlot, endSlot primitives.Slot
@@ -761,11 +809,11 @@ func blockRootsBySlotRange(
 	if startEpochOk && endEpochOk {
 		startSlot, err = slots.EpochStart(startEpoch)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 		endSlot, err = slots.EpochStart(endEpoch)
 		if err != nil {
-			return nil, nil, err
+			return nil, err
 		}
 		endSlot = endSlot + params.BeaconConfig().SlotsPerEpoch - 1
 	}
@@ -776,11 +824,10 @@ func blockRootsBySlotRange(
 		return key != nil && bytes.Compare(key, max) <= 0
 	}
 	if endSlot < startSlot {
-		return nil, nil, errInvalidSlotRange
+		return nil, errInvalidSlotRange
 	}
 	rootsRange := endSlot.SubSlot(startSlot).Div(step)
 	roots := make([][]byte, 0, rootsRange)
-	var slts []primitives.Slot
 	c := bkt.Cursor()
 	for k, v := c.Seek(min); conditional(k, max); k, v = c.Next() {
 		slot := bytesutil.BytesToSlotBigEndian(k)
@@ -795,9 +842,8 @@ func blockRootsBySlotRange(
 			splitRoots = append(splitRoots, v[i:i+32])
 		}
 		roots = append(roots, splitRoots...)
-		slts = append(slts, slot)
 	}
-	return roots, slts, nil
+	return roots, nil
 }
 
 // blockRootsBySlot retrieves the block roots by slot

beacon-chain/db/kv/blocks_test.go

@@ -359,184 +359,221 @@ func TestStore_DeleteFinalizedBlock(t *testing.T) {
 
 func TestStore_HistoricalDataBeforeSlot(t *testing.T) {
 	slotsPerEpoch := uint64(params.BeaconConfig().SlotsPerEpoch)
-	db := setupDB(t)
 	ctx := context.Background()
 
-	// Save genesis block root
-	require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisBlockRoot))
+	tests := []struct {
+		name             string
+		batchSize        int
+		numOfEpochs      uint64
+		deleteBeforeSlot uint64
+	}{
+		{
+			name:             "batchSize less than delete range",
+			batchSize:        10,
+			numOfEpochs:      4,
+			deleteBeforeSlot: 25,
+		},
+		{
+			name:             "batchSize greater than delete range",
+			batchSize:        30,
+			numOfEpochs:      4,
+			deleteBeforeSlot: 15,
+		},
+	}
 
-	// Create and save blocks for 4 epochs
-	blks := makeBlocks(t, 0, slotsPerEpoch*4, genesisBlockRoot)
-	require.NoError(t, db.SaveBlocks(ctx, blks))
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			db := setupDB(t)
+			// Save genesis block root
+			require.NoError(t, db.SaveGenesisBlockRoot(ctx, genesisBlockRoot))
 
-	// Mark state validator migration as complete
-	err := db.db.Update(func(tx *bolt.Tx) error {
-		return tx.Bucket(migrationsBucket).Put(migrationStateValidatorsKey, migrationCompleted)
-	})
-	require.NoError(t, err)
+			// Create and save blocks for given epochs
+			blks := makeBlocks(t, 0, slotsPerEpoch*tt.numOfEpochs, genesisBlockRoot)
+			require.NoError(t, db.SaveBlocks(ctx, blks))
 
-	migrated, err := db.isStateValidatorMigrationOver()
-	require.NoError(t, err)
-	require.Equal(t, true, migrated)
+			// Mark state validator migration as complete
+			err := db.db.Update(func(tx *bolt.Tx) error {
+				return tx.Bucket(migrationsBucket).Put(migrationStateValidatorsKey, migrationCompleted)
+			})
+			require.NoError(t, err)
 
-	// Create state summaries and states for each block
-	ss := make([]*ethpb.StateSummary, len(blks))
-	states := make([]state.BeaconState, len(blks))
+			migrated, err := db.isStateValidatorMigrationOver()
+			require.NoError(t, err)
+			require.Equal(t, true, migrated)
 
-	for i, blk := range blks {
-		slot := blk.Block().Slot()
-		r, err := blk.Block().HashTreeRoot()
-		require.NoError(t, err)
+			// Create state summaries and states for each block
+			ss := make([]*ethpb.StateSummary, len(blks))
+			states := make([]state.BeaconState, len(blks))
 
-		// Create and save state summary
-		ss[i] = &ethpb.StateSummary{
-			Slot: slot,
-			Root: r[:],
-		}
+			for i, blk := range blks {
+				slot := blk.Block().Slot()
+				r, err := blk.Block().HashTreeRoot()
+				require.NoError(t, err)
 
-		// Create and save state with validator entries
-		vals := make([]*ethpb.Validator, 2)
-		for j := range vals {
-			vals[j] = &ethpb.Validator{
-				PublicKey:             bytesutil.PadTo([]byte{byte(i*j + 1)}, 48),
-				WithdrawalCredentials: bytesutil.PadTo([]byte{byte(i*j + 2)}, 32),
+				// Create and save state summary
+				ss[i] = &ethpb.StateSummary{
+					Slot: slot,
+					Root: r[:],
+				}
+
+				// Create and save state with validator entries
+				vals := make([]*ethpb.Validator, 2)
+				for j := range vals {
+					vals[j] = &ethpb.Validator{
+						PublicKey:             bytesutil.PadTo([]byte{byte(i*j + 1)}, 48),
+						WithdrawalCredentials: bytesutil.PadTo([]byte{byte(i*j + 2)}, 32),
+					}
+				}
+
+				st, err := util.NewBeaconState(func(state *ethpb.BeaconState) error {
+					state.Validators = vals
+					state.Slot = slot
+					return nil
+				})
+				require.NoError(t, err)
+				require.NoError(t, db.SaveState(ctx, st, r))
+				states[i] = st
+
+				// Verify validator entries are saved to db
+				valsActual, err := db.validatorEntries(ctx, r)
+				require.NoError(t, err)
+				for j, val := range valsActual {
+					require.DeepEqual(t, vals[j], val)
+				}
 			}
-		}
+			require.NoError(t, db.SaveStateSummaries(ctx, ss))
 
-		st, err := util.NewBeaconState(func(state *ethpb.BeaconState) error {
-			state.Validators = vals
-			state.Slot = slot
-			return nil
-		})
-		require.NoError(t, err)
-		require.NoError(t, db.SaveState(ctx, st, r))
-		states[i] = st
-
-		// Verify validator entries are saved to db
-		valsActual, err := db.validatorEntries(ctx, r)
-		require.NoError(t, err)
-		for j, val := range valsActual {
-			require.DeepEqual(t, vals[j], val)
-		}
-	}
-	require.NoError(t, db.SaveStateSummaries(ctx, ss))
-
-	// Verify slot indices exist before deletion
-	err = db.db.View(func(tx *bolt.Tx) error {
-		blockSlotBkt := tx.Bucket(blockSlotIndicesBucket)
-		stateSlotBkt := tx.Bucket(stateSlotIndicesBucket)
-
-		for i := uint64(0); i < slotsPerEpoch; i++ {
-			slot := bytesutil.SlotToBytesBigEndian(primitives.Slot(i + 1))
-			assert.NotNil(t, blockSlotBkt.Get(slot), "Expected block slot index to exist")
-			assert.NotNil(t, stateSlotBkt.Get(slot), "Expected state slot index to exist", i)
-		}
-		return nil
-	})
-	require.NoError(t, err)
-
-	// Delete data before slot at epoch 1
-	require.NoError(t, db.DeleteHistoricalDataBeforeSlot(ctx, primitives.Slot(slotsPerEpoch)))
-
-	// Verify blocks from epoch 0 are deleted
-	for i := uint64(0); i < slotsPerEpoch; i++ {
-		root, err := blks[i].Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		// Check block is deleted
-		retrievedBlocks, err := db.BlocksBySlot(ctx, primitives.Slot(i))
-		require.NoError(t, err)
-		assert.Equal(t, 0, len(retrievedBlocks))
-
-		// Verify block does not exist
-		assert.Equal(t, false, db.HasBlock(ctx, root))
-
-		// Verify block parent root does not exist
-		err = db.db.View(func(tx *bolt.Tx) error {
-			require.Equal(t, 0, len(tx.Bucket(blockParentRootIndicesBucket).Get(root[:])))
-			return nil
-		})
-		require.NoError(t, err)
-
-		// Verify state is deleted
-		hasState := db.HasState(ctx, root)
-		assert.Equal(t, false, hasState)
-
-		// Verify state summary is deleted
-		hasSummary := db.HasStateSummary(ctx, root)
-		assert.Equal(t, false, hasSummary)
-
-		// Verify validator hashes for block roots are deleted
-		err = db.db.View(func(tx *bolt.Tx) error {
-			assert.Equal(t, 0, len(tx.Bucket(blockRootValidatorHashesBucket).Get(root[:])))
-			return nil
-		})
-		require.NoError(t, err)
-	}
-
-	// Verify slot indices are deleted
-	err = db.db.View(func(tx *bolt.Tx) error {
-		blockSlotBkt := tx.Bucket(blockSlotIndicesBucket)
-		stateSlotBkt := tx.Bucket(stateSlotIndicesBucket)
-
-		for i := uint64(0); i < slotsPerEpoch; i++ {
-			slot := bytesutil.SlotToBytesBigEndian(primitives.Slot(i + 1))
-			assert.Equal(t, 0, len(blockSlotBkt.Get(slot)), fmt.Sprintf("Expected block slot index to be deleted, slot: %d", slot))
-			assert.Equal(t, 0, len(stateSlotBkt.Get(slot)), fmt.Sprintf("Expected state slot index to be deleted, slot: %d", slot))
-		}
-		return nil
-	})
-	require.NoError(t, err)
-
-	// Verify blocks from epochs 1-3 still exist
-	for i := slotsPerEpoch; i < slotsPerEpoch*4; i++ {
-		root, err := blks[i].Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		// Verify block exists
-		assert.Equal(t, true, db.HasBlock(ctx, root))
-
-		// Verify remaining block parent root exists, except last slot since we store parent roots of each block.
-		if i < slotsPerEpoch*4-1 {
+			// Verify slot indices exist before deletion
 			err = db.db.View(func(tx *bolt.Tx) error {
-				require.NotNil(t, tx.Bucket(blockParentRootIndicesBucket).Get(root[:]), fmt.Sprintf("Expected block parent index to be deleted, slot: %d", i))
+				blockSlotBkt := tx.Bucket(blockSlotIndicesBucket)
+				stateSlotBkt := tx.Bucket(stateSlotIndicesBucket)
+
+				for i := uint64(0); i < uint64(tt.deleteBeforeSlot); i++ {
+					slot := bytesutil.SlotToBytesBigEndian(primitives.Slot(i + 1))
+					assert.NotNil(t, blockSlotBkt.Get(slot), "Expected block slot index to exist")
+					assert.NotNil(t, stateSlotBkt.Get(slot), "Expected state slot index to exist", i)
+				}
 				return nil
 			})
 			require.NoError(t, err)
-		}
 
-		// Verify state exists
-		hasState := db.HasState(ctx, root)
-		assert.Equal(t, true, hasState)
+			// Delete data before slot
+			slotsDeleted, err := db.DeleteHistoricalDataBeforeSlot(ctx, primitives.Slot(tt.deleteBeforeSlot), tt.batchSize)
+			require.NoError(t, err)
 
-		// Verify state summary exists
-		hasSummary := db.HasStateSummary(ctx, root)
-		assert.Equal(t, true, hasSummary)
+			var startSlotDeleted, endSlotDeleted uint64
+			if tt.batchSize >= int(tt.deleteBeforeSlot) {
+				startSlotDeleted = 1
+				endSlotDeleted = tt.deleteBeforeSlot
+			} else {
+				startSlotDeleted = tt.deleteBeforeSlot - uint64(tt.batchSize) + 1
+				endSlotDeleted = tt.deleteBeforeSlot
+			}
 
-		// Verify slot indices still exist
-		err = db.db.View(func(tx *bolt.Tx) error {
-			blockSlotBkt := tx.Bucket(blockSlotIndicesBucket)
-			stateSlotBkt := tx.Bucket(stateSlotIndicesBucket)
+			require.Equal(t, endSlotDeleted-startSlotDeleted+1, uint64(slotsDeleted))
 
-			slot := bytesutil.SlotToBytesBigEndian(primitives.Slot(i + 1))
-			assert.NotNil(t, blockSlotBkt.Get(slot), "Expected block slot index to exist")
-			assert.NotNil(t, stateSlotBkt.Get(slot), "Expected state slot index to exist")
-			return nil
+			// Verify blocks before given slot/batch are deleted
+			for i := startSlotDeleted; i < endSlotDeleted; i++ {
+				root, err := blks[i].Block().HashTreeRoot()
+				require.NoError(t, err)
+
+				// Check block is deleted
+				retrievedBlocks, err := db.BlocksBySlot(ctx, primitives.Slot(i))
+				require.NoError(t, err)
+				assert.Equal(t, 0, len(retrievedBlocks), fmt.Sprintf("Expected %d blocks, got %d for slot %d", 0, len(retrievedBlocks), i))
+
+				// Verify block does not exist
+				assert.Equal(t, false, db.HasBlock(ctx, root), fmt.Sprintf("Expected block index to not exist for slot %d", i))
+
+				// Verify block parent root does not exist
+				err = db.db.View(func(tx *bolt.Tx) error {
+					require.Equal(t, 0, len(tx.Bucket(blockParentRootIndicesBucket).Get(root[:])))
+					return nil
+				})
+				require.NoError(t, err)
+
+				// Verify state is deleted
+				hasState := db.HasState(ctx, root)
+				assert.Equal(t, false, hasState)
+
+				// Verify state summary is deleted
+				hasSummary := db.HasStateSummary(ctx, root)
+				assert.Equal(t, false, hasSummary)
+
+				// Verify validator hashes for block roots are deleted
+				err = db.db.View(func(tx *bolt.Tx) error {
+					assert.Equal(t, 0, len(tx.Bucket(blockRootValidatorHashesBucket).Get(root[:])))
+					return nil
+				})
+				require.NoError(t, err)
+			}
+
+			// Verify slot indices are deleted
+			err = db.db.View(func(tx *bolt.Tx) error {
+				blockSlotBkt := tx.Bucket(blockSlotIndicesBucket)
+				stateSlotBkt := tx.Bucket(stateSlotIndicesBucket)
+
+				for i := startSlotDeleted; i < endSlotDeleted; i++ {
+					slot := bytesutil.SlotToBytesBigEndian(primitives.Slot(i + 1))
+					assert.Equal(t, 0, len(blockSlotBkt.Get(slot)), fmt.Sprintf("Expected block slot index to be deleted, slot: %d", slot))
+					assert.Equal(t, 0, len(stateSlotBkt.Get(slot)), fmt.Sprintf("Expected state slot index to be deleted, slot: %d", slot))
+				}
+				return nil
+			})
+			require.NoError(t, err)
+
+			// Verify blocks from expectedLastDeletedSlot till numEpochs still exist
+			for i := endSlotDeleted; i < slotsPerEpoch*tt.numOfEpochs; i++ {
+				root, err := blks[i].Block().HashTreeRoot()
+				require.NoError(t, err)
+
+				// Verify block exists
+				assert.Equal(t, true, db.HasBlock(ctx, root))
+
+				// Verify remaining block parent root exists, except last slot since we store parent roots of each block.
+				if i < slotsPerEpoch*tt.numOfEpochs-1 {
+					err = db.db.View(func(tx *bolt.Tx) error {
+						require.NotNil(t, tx.Bucket(blockParentRootIndicesBucket).Get(root[:]), fmt.Sprintf("Expected block parent index to be deleted, slot: %d", i))
+						return nil
+					})
+					require.NoError(t, err)
+				}
+
+				// Verify state exists
+				hasState := db.HasState(ctx, root)
+				assert.Equal(t, true, hasState)
+
+				// Verify state summary exists
+				hasSummary := db.HasStateSummary(ctx, root)
+				assert.Equal(t, true, hasSummary)
+
+				// Verify slot indices still exist
+				err = db.db.View(func(tx *bolt.Tx) error {
+					blockSlotBkt := tx.Bucket(blockSlotIndicesBucket)
+					stateSlotBkt := tx.Bucket(stateSlotIndicesBucket)
+
+					slot := bytesutil.SlotToBytesBigEndian(primitives.Slot(i + 1))
+					assert.NotNil(t, blockSlotBkt.Get(slot), "Expected block slot index to exist")
+					assert.NotNil(t, stateSlotBkt.Get(slot), "Expected state slot index to exist")
+					return nil
+				})
+				require.NoError(t, err)
+
+				// Verify validator entries still exist
+				valsActual, err := db.validatorEntries(ctx, root)
+				require.NoError(t, err)
+				assert.NotNil(t, valsActual)
+
+				// Verify remaining validator hashes for block roots exists
+				err = db.db.View(func(tx *bolt.Tx) error {
+					assert.NotNil(t, tx.Bucket(blockRootValidatorHashesBucket).Get(root[:]))
+					return nil
+				})
+				require.NoError(t, err)
+			}
 		})
-		require.NoError(t, err)
-
-		// Verify validator entries still exist
-		valsActual, err := db.validatorEntries(ctx, root)
-		require.NoError(t, err)
-		assert.NotNil(t, valsActual)
-
-		// Verify remaining validator hashes for block roots exists
-		err = db.db.View(func(tx *bolt.Tx) error {
-			assert.NotNil(t, tx.Bucket(blockRootValidatorHashesBucket).Get(root[:]))
-			return nil
-		})
-		require.NoError(t, err)
 	}
+
 }
 
 func TestStore_GenesisBlock(t *testing.T) {

beacon-chain/db/kv/state.go

@@ -820,30 +820,25 @@ func (s *Store) slotByBlockRoot(ctx context.Context, tx *bolt.Tx, blockRoot []by
 			// no need to construct the validator entries as it is not used here.
 			s, err := s.unmarshalState(ctx, enc, nil)
 			if err != nil {
-				return 0, err
+				return 0, errors.Wrap(err, "could not unmarshal state")
 			}
 			if s == nil || s.IsNil() {
 				return 0, errors.New("state can't be nil")
 			}
 			return s.Slot(), nil
 		}
-		b := &ethpb.SignedBeaconBlock{}
-		err := decode(ctx, enc, b)
+		b, err := unmarshalBlock(ctx, enc)
 		if err != nil {
+			return 0, errors.Wrap(err, "could not unmarshal block")
+		}
+		if err := blocks.BeaconBlockIsNil(b); err != nil {
 			return 0, err
 		}
-		wsb, err := blocks.NewSignedBeaconBlock(b)
-		if err != nil {
-			return 0, err
-		}
-		if err := blocks.BeaconBlockIsNil(wsb); err != nil {
-			return 0, err
-		}
-		return b.Block.Slot, nil
+		return b.Block().Slot(), nil
 	}
 	stateSummary := &ethpb.StateSummary{}
 	if err := decode(ctx, enc, stateSummary); err != nil {
-		return 0, err
+		return 0, errors.Wrap(err, "could not unmarshal state summary")
 	}
 	return stateSummary.Slot, nil
 }

beacon-chain/db/kv/state_test.go

@@ -5,7 +5,6 @@ import (
 	"crypto/rand"
 	"encoding/binary"
 	mathRand "math/rand"
-
 	"strconv"
 	"testing"
 	"time"
@@ -1070,6 +1069,31 @@ func TestBellatrixState_CanDelete(t *testing.T) {
 	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
 }
 
+func TestBellatrixState_CanDeleteWithBlock(t *testing.T) {
+	db := setupDB(t)
+
+	b := util.NewBeaconBlockBellatrix()
+	b.Block.Slot = 100
+	r, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	wsb, err := blocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(context.Background(), wsb))
+
+	require.Equal(t, false, db.HasState(context.Background(), r))
+
+	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+	require.NoError(t, st.SetSlot(100))
+
+	require.NoError(t, db.SaveState(context.Background(), st, r))
+	require.Equal(t, true, db.HasState(context.Background(), r))
+
+	require.NoError(t, db.DeleteState(context.Background(), r))
+	savedS, err := db.State(context.Background(), r)
+	require.NoError(t, err)
+	require.Equal(t, state.ReadOnlyBeaconState(nil), savedS, "Unsaved state should've been nil")
+}
+
 func TestDenebState_CanSaveRetrieve(t *testing.T) {
 	db := setupDB(t)
 

beacon-chain/db/pruner/pruner.go

@@ -16,6 +16,15 @@ import (
 
 var log = logrus.WithField("prefix", "db-pruner")
 
+const (
+	// defaultPrunableBatchSize is the number of slots that can be pruned at once.
+	defaultPrunableBatchSize = 32
+	// defaultPruningWindow is the duration of one pruning window.
+	defaultPruningWindow = time.Second * 3
+	// defaultNumBatchesToPrune is the number of batches to prune in one pruning window.
+	defaultNumBatchesToPrune = 15
+)
+
 type ServiceOption func(*Service)
 
 // WithRetentionPeriod allows the user to specify a different data retention period than the spec default.
@@ -143,14 +152,17 @@ func (p *Service) prune(slot primitives.Slot) error {
 	}).Debug("Pruning chain data")
 
 	tt := time.Now()
-	if err := p.db.DeleteHistoricalDataBeforeSlot(p.ctx, pruneUpto); err != nil {
-		return errors.Wrapf(err, "could not delete upto slot %d", pruneUpto)
+	numBatches, err := p.pruneBatches(pruneUpto)
+	if err != nil {
+		return errors.Wrap(err, "failed to prune batches")
 	}
 
 	log.WithFields(logrus.Fields{
 		"prunedUpto":  pruneUpto,
 		"duration":    time.Since(tt),
 		"currentSlot": slot,
+		"batchSize":   defaultPrunableBatchSize,
+		"numBatches":  numBatches,
 	}).Debug("Successfully pruned chain data")
 
 	// Update pruning checkpoint.
@@ -159,6 +171,33 @@ func (p *Service) prune(slot primitives.Slot) error {
 	return nil
 }
 
+func (p *Service) pruneBatches(pruneUpto primitives.Slot) (int, error) {
+	ctx, cancel := context.WithTimeout(p.ctx, defaultPruningWindow)
+	defer cancel()
+
+	numBatches := 0
+	for {
+		select {
+		case <-ctx.Done():
+			return numBatches, nil
+		default:
+			for i := 0; i < defaultNumBatchesToPrune; i++ {
+				slotsDeleted, err := p.db.DeleteHistoricalDataBeforeSlot(ctx, pruneUpto, defaultPrunableBatchSize)
+				if err != nil {
+					return 0, errors.Wrapf(err, "could not delete upto slot %d", pruneUpto)
+				}
+
+				// Return if there's nothing to delete.
+				if slotsDeleted == 0 {
+					return numBatches, nil
+				}
+
+				numBatches++
+			}
+		}
+	}
+}
+
 // pruneStartSlotFunc returns the function to determine the start slot to start pruning.
 func pruneStartSlotFunc(retentionEpochs primitives.Epoch) func(primitives.Slot) primitives.Slot {
 	return func(current primitives.Slot) primitives.Slot {

beacon-chain/db/pruner/pruner_test.go

@@ -5,17 +5,15 @@ import (
 	"testing"
 	"time"
 
+	dbtest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	slottest "github.com/prysmaticlabs/prysm/v5/time/slots/testing"
 	"github.com/sirupsen/logrus"
-
-	dbtest "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 

beacon-chain/execution/testdata/fuzz/FuzzExecutionBlock/4448e6f5eccdfd2f5acea73e8b44f817a0161a6a

@@ -1,2 +1,2 @@
 go test fuzz v1
-[]byte("{\"baseFeePerGas\":\"0x7fffffffffffffff\",\"difficulty\":\"0x7fffffffffffffff\",\"extraData\":\"0x\",\"gasLimit\":\"0xffffffffffffffff\",\"gasUsed\":\"0xffffffffffffffff\",\"hash\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"logsBloom\":\"0x6a756e6b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\"miner\":\"0x0000000000000000000000000000000000000000\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"nonce\":\"0x0000000000000000\",\"number\":\"0x7fffffffffffffff\",\"parentHash\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"receiptsRoot\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"sha3Uncles\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"stateRoot\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"timestamp\":\"0x64\",\"totalDifficulty\":\"999999999999999999999999999999999999999\",\"transactions\":[{\"type\":\"0x2\",\"nonce\":\"0xffffffffffffffff\",\"gasPrice\":null,\"maxPriorityFeePerGas\":\"0x7fffffffffffffff\",\"maxFeePerGas\":\"0x7fffffffffffffff\",\"gas\":\"0xffffffffffffffff\",\"value\":\"0x7fffffffffffffff\",\"input\":\"0x72616e646f6d\",\"v\":\"0x0\",\"r\":\"0x7fffffffffffffff\",\"s\":\"0x7fffffffffffffff\",\"to\":\"0x095e7baea6a6c7c4c2dfeb977efac326af552d87\",\"chainId\":\"0x7fffffffffffffff\",\"accessList\":[],\"hash\":\"0x26db3ef2c0e5945b24088d6a4165d0bb2959abd848b57891aa041b72518548ab\"},{\"type\":\"0x2\",\"nonce\":\"0xffffffffffffffff\",\"gasPrice\":null,\"maxPriorityFeePerGas\":\"0x7fffffffffffffff\",\"maxFeePerGas\":\"0x7fffffffffffffff\",\"gas\":\"0xfffffffffffaffff\",\"value\":\"0x7fffffffffffffff\",\"input\":\"0x72616e646f6d\",\"v\":\"0x0\",\"r\":\"0x7fffffffffffffff\",\"s\":\"0x7fffffffffffffff\",\"to\":\"0x095e7baea6a6c7c4c2dfeb977efac326af552d87\",\"chainId\":\"0x7fffffffffffffff\",\"accessList\":[],\"hash\":\"0x26db3ef2c0e5945b24088d6a4165d0bb2959abd848b57891aa041b72518548ab\"}],\"transactionsRoot\":\"0x0000000000000000000000000000000000000000000000000000000000000000\"}")
+[]byte("{\"baseFeePerGas\":\"0x7fffffffffffffff\",\"difficulty\":\"0x7fffffffffffffff\",\"extraData\":\"0x\",\"gasLimit\":\"0xffffffffffffffff\",\"gasUsed\":\"0xffffffffffffffff\",\"hash\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"logsBloom\":\"0x6a756e6b000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\",\"miner\":\"0x0000000000000000000000000000000000000000\",\"mixHash\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"nonce\":\"0x0000000000000000\",\"number\":\"0x7fffffffffffffff\",\"parentHash\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"receiptsRoot\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"sha3Uncles\":\"0x0000000000000000000000000000000000000000000000000000000000000000\",\"stateRoot\":\"0xff01ff01ff01ff01ff01ff01ff01ff0100000000000000000000000000000000\",\"timestamp\":\"0x64\",\"totalDifficulty\":\"999999999999999999999999999999999999999\",\"transactions\":[{\"type\":\"0x2\",\"nonce\":\"0xffffffffffffffff\",\"gasPrice\":null,\"maxPriorityFeePerGas\":\"0x7fffffffffffffff\",\"maxFeePerGas\":\"0x7fffffffffffffff\",\"gas\":\"0xffffffffffffffff\",\"value\":\"0x7fffffffffffffff\",\"input\":\"0x72616e646f6d\",\"v\":\"0x0\",\"r\":\"0x7fffffffffffffff\",\"s\":\"0x7fffffffffffffff\",\"to\":\"0x095e7baea6a6c7c4c2dfeb977efac326af552d87\",\"chainId\":\"0x7fffffffffffffff\",\"accessList\":[],\"hash\":\"0x26db3ef2c0e5945b24088d6a4165d0bb2959abd848b57891aa041b72518548ab\"},{\"type\":\"0x2\",\"nonce\":\"0xffffffffffffffff\",\"gasPrice\":null,\"maxPriorityFeePerGas\":\"0x7fffffffffffffff\",\"maxFeePerGas\":\"0x7fffffffffffffff\",\"gas\":\"0xfffffffffffaffff\",\"value\":\"0x7fffffffffffffff\",\"input\":\"0x72616e646f6d\",\"v\":\"0x0\",\"r\":\"0x7fffffffffffffff\",\"s\":\"0x7fffffffffffffff\",\"to\":\"0x095e7baea6a6c7c4c2dfeb977efac326af552d87\",\"chainId\":\"0x7fffffffffffffff\",\"accessList\":[],\"hash\":\"0x26db3ef2c0e5945b24088d6a4165d0bb2959abd848b57891aa041b72518548ab\"}],\"transactionsRoot\":\"0x0000000000000000000000000000000000000000000000000000000000000000\"}")

beacon-chain/execution/testdata/fuzz/FuzzForkChoiceResponse/2d0486b744e252db538db5a44bfd6e6e22ff2723

@@ -1,2 +1,2 @@
 go test fuzz v1
-[]byte("{\"0000000000000\":{},\"pAYloAdId\":\"\"}")
+[]byte("{\"0000000000000\":{},\"pAYloAdId\":\"\"}")

beacon-chain/forkchoice/doubly-linked-tree/node.go

@@ -156,6 +156,10 @@ func (n *Node) nodeTreeDump(ctx context.Context, nodes []*forkchoice2.Node) ([]*
 	if n.parent != nil {
 		parentRoot = n.parent.root
 	}
+	target := [32]byte{}
+	if n.target != nil {
+		target = n.target.root
+	}
 	thisNode := &forkchoice2.Node{
 		Slot:                     n.slot,
 		BlockRoot:                n.root[:],
@@ -169,6 +173,7 @@ func (n *Node) nodeTreeDump(ctx context.Context, nodes []*forkchoice2.Node) ([]*
 		ExecutionOptimistic:      n.optimistic,
 		ExecutionBlockHash:       n.payloadHash[:],
 		Timestamp:                n.timestamp,
+		Target:                   target[:],
 	}
 	if n.optimistic {
 		thisNode.Validity = forkchoice2.Optimistic

beacon-chain/node/node.go

@@ -122,6 +122,7 @@ type BeaconNode struct {
 	BlobStorageOptions      []filesystem.BlobStorageOption
 	verifyInitWaiter        *verification.InitializerWaiter
 	syncChecker             *initialsync.SyncChecker
+	slasherEnabled          bool
 }
 
 // New creates a new node instance, sets up configuration options, and registers
@@ -159,6 +160,7 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		serviceFlagOpts:         &serviceFlagOpts{},
 		initialSyncComplete:     make(chan struct{}),
 		syncChecker:             &initialsync.SyncChecker{},
+		slasherEnabled:          cliCtx.Bool(flags.SlasherFlag.Name),
 	}
 
 	for _, opt := range opts {
@@ -342,7 +344,7 @@ func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *sta
 		return errors.Wrap(err, "could not register slashing pool service")
 	}
 
-	log.Debugln("Registering Slasher Service")
+	log.WithField("enabled", beacon.slasherEnabled).Debugln("Registering Slasher Service")
 	if err := beacon.registerSlasherService(); err != nil {
 		return errors.Wrap(err, "could not register slasher service")
 	}
@@ -587,7 +589,7 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 }
 
 func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context) error {
-	if !features.Get().EnableSlasher {
+	if !b.slasherEnabled {
 		return nil
 	}
 	baseDir := cliCtx.String(cmd.DataDirFlag.Name)
@@ -775,6 +777,7 @@ func (b *BeaconNode) registerBlockchainService(fc forkchoice.ForkChoicer, gs *st
 		blockchain.WithTrackedValidatorsCache(b.trackedValidatorsCache),
 		blockchain.WithPayloadIDCache(b.payloadIDCache),
 		blockchain.WithSyncChecker(b.syncChecker),
+		blockchain.WithSlasherEnabled(b.slasherEnabled),
 	)
 
 	blockchainService, err := blockchain.NewService(b.ctx, opts...)
@@ -859,6 +862,7 @@ func (b *BeaconNode) registerSyncService(initialSyncComplete chan struct{}, bFil
 		regularsync.WithBlobStorage(b.BlobStorage),
 		regularsync.WithVerifierWaiter(b.verifyInitWaiter),
 		regularsync.WithAvailableBlocker(bFillStore),
+		regularsync.WithSlasherEnabled(b.slasherEnabled),
 	)
 	return b.services.RegisterService(rs)
 }
@@ -887,7 +891,7 @@ func (b *BeaconNode) registerInitialSyncService(complete chan struct{}) error {
 }
 
 func (b *BeaconNode) registerSlasherService() error {
-	if !features.Get().EnableSlasher {
+	if !b.slasherEnabled {
 		return nil
 	}
 	var chainService *blockchain.Service
@@ -934,7 +938,7 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 	}
 
 	var slasherService *slasher.Service
-	if features.Get().EnableSlasher {
+	if b.slasherEnabled {
 		if err := b.services.FetchService(&slasherService); err != nil {
 			return err
 		}

beacon-chain/p2p/types/object_mapping.go

@@ -33,6 +33,9 @@ var (
 	// AggregateAttestationMap maps the fork-version to the underlying data type for that
 	// particular fork period.
 	AggregateAttestationMap map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error)
+	// AttesterSlashingMap maps the fork-version to the underlying data type for that particular
+	// fork period.
+	AttesterSlashingMap map[[4]byte]func() (ethpb.AttSlashing, error)
 )
 
 // InitializeDataMaps initializes all the relevant object maps. This function is called to
@@ -151,4 +154,29 @@ func InitializeDataMaps() {
 			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
 	}
+
+	// Reset our aggregate attestation map.
+	AttesterSlashingMap = map[[4]byte]func() (ethpb.AttSlashing, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashing{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashingElectra{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.AttSlashing, error) {
+			return &ethpb.AttesterSlashingElectra{}, nil
+		},
+	}
 }

beacon-chain/p2p/types/object_mapping_test.go

@@ -76,6 +76,13 @@ func TestInitializeDataMaps(t *testing.T) {
 				require.NoError(t, err)
 				assert.Equal(t, version.Phase0, agg.Version())
 			}
+			attSlashFunc, ok := AttesterSlashingMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			assert.Equal(t, tt.exists, ok)
+			if tt.exists {
+				attSlash, err := attSlashFunc()
+				require.NoError(t, err)
+				assert.Equal(t, version.Phase0, attSlash.Version())
+			}
 		})
 	}
 }

beacon-chain/package/postinst.sh

@@ -2,4 +2,4 @@
 
 set -e
 
-chown prysm-beacon:prysm-beacon /etc/prysm/beacon-chain.yaml
+chown prysm-beacon:prysm-beacon /etc/prysm/beacon-chain.yaml

beacon-chain/package/preinst.sh

@@ -10,4 +10,4 @@ getent passwd $SERVICE_USER > /dev/null || useradd -s /bin/false --no-create-hom
 # Create directories
 mkdir -p /etc/prysm
 mkdir -p /var/lib/prysm
-install -d -m 0700 -o $SERVICE_USER -g $SERVICE_USER /var/lib/prysm/beacon-chain
+install -d -m 0700 -o $SERVICE_USER -g $SERVICE_USER /var/lib/prysm/beacon-chain

beacon-chain/package/prysm-beacon-chain.service

@@ -34,4 +34,4 @@ RestrictSUIDSGID=yes
 RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX AF_NETLINK
 
 [Install]
-WantedBy=multi-user.target
+WantedBy=multi-user.target

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

@@ -190,6 +190,7 @@ func (s *Server) GetForkChoice(w http.ResponseWriter, r *http.Request) {
 				Balance:                  fmt.Sprintf("%d", n.Balance),
 				ExecutionOptimistic:      n.ExecutionOptimistic,
 				TimeStamp:                fmt.Sprintf("%d", n.Timestamp),
+				Target:                   fmt.Sprintf("%#x", n.Target),
 			},
 		}
 	}

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

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "handlers.go",
-        "helpers.go",
         "server.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/light-client",
@@ -17,11 +16,9 @@ go_library(
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
-        "//beacon-chain/state: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",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//runtime/version:go_default_library",

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

@@ -10,6 +10,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -182,18 +183,31 @@ func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.R
 		return
 	}
 
-	update, err := newLightClientFinalityUpdateFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), st, block, attestedState, attestedBlock, finalizedBlock)
+	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), st, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client finality update: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	response := &structs.LightClientFinalityUpdateResponse{
-		Version: version.String(attestedState.Version()),
-		Data:    update,
+	if httputil.RespondWithSsz(req) {
+		ssz, err := update.MarshalSSZ()
+		if err != nil {
+			httputil.HandleError(w, "Could not marshal finality update to SSZ: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, ssz, "light_client_finality_update.ssz")
+	} else {
+		updateStruct, err := structs.LightClientFinalityUpdateFromConsensus(update)
+		if err != nil {
+			httputil.HandleError(w, "Could not convert light client finality update to API struct: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		response := &structs.LightClientFinalityUpdateResponse{
+			Version: version.String(attestedState.Version()),
+			Data:    updateStruct,
+		}
+		httputil.WriteJson(w, response)
 	}
-
-	httputil.WriteJson(w, response)
 }
 
 // GetLightClientOptimisticUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/optimistic_update.yaml
@@ -232,18 +246,31 @@ func (s *Server) GetLightClientOptimisticUpdate(w http.ResponseWriter, req *http
 		return
 	}
 
-	update, err := newLightClientOptimisticUpdateFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), st, block, attestedState, attestedBlock)
+	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), st, block, attestedState, attestedBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client optimistic update: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
 
-	response := &structs.LightClientOptimisticUpdateResponse{
-		Version: version.String(attestedState.Version()),
-		Data:    update,
+	if httputil.RespondWithSsz(req) {
+		ssz, err := update.MarshalSSZ()
+		if err != nil {
+			httputil.HandleError(w, "Could not marshal optimistic update to SSZ: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, ssz, "light_client_optimistic_update.ssz")
+	} else {
+		updateStruct, err := structs.LightClientOptimisticUpdateFromConsensus(update)
+		if err != nil {
+			httputil.HandleError(w, "Could not convert light client optimistic update to API struct: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		response := &structs.LightClientOptimisticUpdateResponse{
+			Version: version.String(attestedState.Version()),
+			Data:    updateStruct,
+		}
+		httputil.WriteJson(w, response)
 	}
-
-	httputil.WriteJson(w, response)
 }
 
 // suitableBlock returns the latest block that satisfies all criteria required for creating a new update

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

@@ -1105,116 +1105,226 @@ func TestLightClientHandler_GetLightClientFinalityUpdate(t *testing.T) {
 		EnableLightClient: true,
 	})
 	defer resetFn()
-
 	helpers.ClearCache()
-	ctx := context.Background()
 	config := params.BeaconConfig()
-	slot := primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 
-	attestedState, err := util.NewBeaconStateAltair()
-	require.NoError(t, err)
-	err = attestedState.SetSlot(slot.Sub(1))
-	require.NoError(t, err)
+	t.Run("altair", func(t *testing.T) {
+		ctx := context.Background()
+		slot := primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
 
-	require.NoError(t, attestedState.SetFinalizedCheckpoint(&pb.Checkpoint{
-		Epoch: config.AltairForkEpoch - 10,
-		Root:  make([]byte, 32),
-	}))
+		attestedState, err := util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = attestedState.SetSlot(slot.Sub(1))
+		require.NoError(t, err)
 
-	parent := util.NewBeaconBlockAltair()
-	parent.Block.Slot = slot.Sub(1)
+		require.NoError(t, attestedState.SetFinalizedCheckpoint(&pb.Checkpoint{
+			Epoch: config.AltairForkEpoch - 10,
+			Root:  make([]byte, 32),
+		}))
 
-	signedParent, err := blocks.NewSignedBeaconBlock(parent)
-	require.NoError(t, err)
+		parent := util.NewBeaconBlockAltair()
+		parent.Block.Slot = slot.Sub(1)
 
-	parentHeader, err := signedParent.Header()
-	require.NoError(t, err)
-	attestedHeader := parentHeader.Header
+		signedParent, err := blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
 
-	err = attestedState.SetLatestBlockHeader(attestedHeader)
-	require.NoError(t, err)
-	attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
-	require.NoError(t, err)
+		parentHeader, err := signedParent.Header()
+		require.NoError(t, err)
+		attestedHeader := parentHeader.Header
 
-	// get a new signed block so the root is updated with the new state root
-	parent.Block.StateRoot = attestedStateRoot[:]
-	signedParent, err = blocks.NewSignedBeaconBlock(parent)
-	require.NoError(t, err)
+		err = attestedState.SetLatestBlockHeader(attestedHeader)
+		require.NoError(t, err)
+		attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
 
-	st, err := util.NewBeaconStateAltair()
-	require.NoError(t, err)
-	err = st.SetSlot(slot)
-	require.NoError(t, err)
+		// get a new signed block so the root is updated with the new state root
+		parent.Block.StateRoot = attestedStateRoot[:]
+		signedParent, err = blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
 
-	parentRoot, err := signedParent.Block().HashTreeRoot()
-	require.NoError(t, err)
+		st, err := util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = st.SetSlot(slot)
+		require.NoError(t, err)
 
-	block := util.NewBeaconBlockAltair()
-	block.Block.Slot = slot
-	block.Block.ParentRoot = parentRoot[:]
+		parentRoot, err := signedParent.Block().HashTreeRoot()
+		require.NoError(t, err)
 
-	for i := uint64(0); i < config.SyncCommitteeSize; i++ {
-		block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
-	}
+		block := util.NewBeaconBlockAltair()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
 
-	signedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
+		for i := uint64(0); i < config.SyncCommitteeSize; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
 
-	h, err := signedBlock.Header()
-	require.NoError(t, err)
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
 
-	err = st.SetLatestBlockHeader(h.Header)
-	require.NoError(t, err)
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err)
+		h, err := signedBlock.Header()
+		require.NoError(t, err)
 
-	// get a new signed block so the root is updated with the new state root
-	block.Block.StateRoot = stateRoot[:]
-	signedBlock, err = blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
+		err = st.SetLatestBlockHeader(h.Header)
+		require.NoError(t, err)
+		stateRoot, err := st.HashTreeRoot(ctx)
+		require.NoError(t, err)
 
-	root, err := block.Block.HashTreeRoot()
-	require.NoError(t, err)
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
 
-	mockBlocker := &testutil.MockBlocker{
-		RootBlockMap: map[[32]byte]interfaces.ReadOnlySignedBeaconBlock{
-			parentRoot: signedParent,
-			root:       signedBlock,
-		},
-		SlotBlockMap: map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock{
-			slot.Sub(1): signedParent,
-			slot:        signedBlock,
-		},
-	}
-	mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot, State: st, FinalizedRoots: map[[32]byte]bool{
-		root: true,
-	}}
-	mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
-	s := &Server{
-		Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
-			slot.Sub(1): attestedState,
-			slot:        st,
-		}},
-		Blocker:          mockBlocker,
-		HeadFetcher:      mockChainService,
-		ChainInfoFetcher: mockChainInfoFetcher,
-	}
-	request := httptest.NewRequest("GET", "http://foo.com", nil)
-	writer := httptest.NewRecorder()
-	writer.Body = &bytes.Buffer{}
+		root, err := block.Block.HashTreeRoot()
+		require.NoError(t, err)
 
-	s.GetLightClientFinalityUpdate(writer, request)
+		mockBlocker := &testutil.MockBlocker{
+			RootBlockMap: map[[32]byte]interfaces.ReadOnlySignedBeaconBlock{
+				parentRoot: signedParent,
+				root:       signedBlock,
+			},
+			SlotBlockMap: map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock{
+				slot.Sub(1): signedParent,
+				slot:        signedBlock,
+			},
+		}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot, State: st, FinalizedRoots: map[[32]byte]bool{
+			root: true,
+		}}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
+		s := &Server{
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot.Sub(1): attestedState,
+				slot:        st,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
+		}
+		request := httptest.NewRequest("GET", "http://foo.com", nil)
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
 
-	require.Equal(t, http.StatusOK, writer.Code)
-	var resp *structs.LightClientUpdateResponse
-	err = json.Unmarshal(writer.Body.Bytes(), &resp)
-	require.NoError(t, err)
-	var respHeader structs.LightClientHeader
-	err = json.Unmarshal(resp.Data.AttestedHeader, &respHeader)
-	require.NoError(t, err)
-	require.Equal(t, "altair", resp.Version)
-	require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), respHeader.Beacon.BodyRoot)
-	require.NotNil(t, resp.Data)
+		s.GetLightClientFinalityUpdate(writer, request)
+
+		require.Equal(t, http.StatusOK, writer.Code)
+		var resp *structs.LightClientUpdateResponse
+		err = json.Unmarshal(writer.Body.Bytes(), &resp)
+		require.NoError(t, err)
+		var respHeader structs.LightClientHeader
+		err = json.Unmarshal(resp.Data.AttestedHeader, &respHeader)
+		require.NoError(t, err)
+		require.Equal(t, "altair", resp.Version)
+		require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), respHeader.Beacon.BodyRoot)
+		require.NotNil(t, resp.Data)
+	})
+
+	t.Run("altair SSZ", func(t *testing.T) {
+		ctx := context.Background()
+		slot := primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
+
+		attestedState, err := util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = attestedState.SetSlot(slot.Sub(1))
+		require.NoError(t, err)
+
+		require.NoError(t, attestedState.SetFinalizedCheckpoint(&pb.Checkpoint{
+			Epoch: config.AltairForkEpoch - 10,
+			Root:  make([]byte, 32),
+		}))
+
+		parent := util.NewBeaconBlockAltair()
+		parent.Block.Slot = slot.Sub(1)
+
+		signedParent, err := blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		parentHeader, err := signedParent.Header()
+		require.NoError(t, err)
+		attestedHeader := parentHeader.Header
+
+		err = attestedState.SetLatestBlockHeader(attestedHeader)
+		require.NoError(t, err)
+		attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		parent.Block.StateRoot = attestedStateRoot[:]
+		signedParent, err = blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		st, err := util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = st.SetSlot(slot)
+		require.NoError(t, err)
+
+		parentRoot, err := signedParent.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		block := util.NewBeaconBlockAltair()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
+
+		for i := uint64(0); i < config.SyncCommitteeSize; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(t, err)
+
+		err = st.SetLatestBlockHeader(h.Header)
+		require.NoError(t, err)
+		stateRoot, err := st.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		root, err := block.Block.HashTreeRoot()
+		require.NoError(t, err)
+
+		mockBlocker := &testutil.MockBlocker{
+			RootBlockMap: map[[32]byte]interfaces.ReadOnlySignedBeaconBlock{
+				parentRoot: signedParent,
+				root:       signedBlock,
+			},
+			SlotBlockMap: map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock{
+				slot.Sub(1): signedParent,
+				slot:        signedBlock,
+			},
+		}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot, State: st, FinalizedRoots: map[[32]byte]bool{
+			root: true,
+		}}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
+		s := &Server{
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot.Sub(1): attestedState,
+				slot:        st,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
+		}
+		request := httptest.NewRequest("GET", "http://foo.com", nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetLightClientFinalityUpdate(writer, request)
+
+		require.Equal(t, http.StatusOK, writer.Code)
+
+		var resp pb.LightClientFinalityUpdateAltair
+		err = resp.UnmarshalSSZ(writer.Body.Bytes())
+		require.NoError(t, err)
+		require.Equal(t, attestedHeader.Slot, resp.AttestedHeader.Beacon.Slot)
+		require.DeepEqual(t, attestedHeader.BodyRoot, resp.AttestedHeader.Beacon.BodyRoot)
+	})
 }
 
 func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
@@ -1335,6 +1445,114 @@ func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
 		require.NotNil(t, resp.Data)
 	})
 
+	t.Run("altair SSZ", func(t *testing.T) {
+		ctx := context.Background()
+		slot := primitives.Slot(config.AltairForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
+
+		attestedState, err := util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = attestedState.SetSlot(slot.Sub(1))
+		require.NoError(t, err)
+
+		require.NoError(t, attestedState.SetFinalizedCheckpoint(&pb.Checkpoint{
+			Epoch: config.AltairForkEpoch - 10,
+			Root:  make([]byte, 32),
+		}))
+
+		parent := util.NewBeaconBlockAltair()
+		parent.Block.Slot = slot.Sub(1)
+
+		signedParent, err := blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		parentHeader, err := signedParent.Header()
+		require.NoError(t, err)
+		attestedHeader := parentHeader.Header
+
+		err = attestedState.SetLatestBlockHeader(attestedHeader)
+		require.NoError(t, err)
+		attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		parent.Block.StateRoot = attestedStateRoot[:]
+		signedParent, err = blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		st, err := util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = st.SetSlot(slot)
+		require.NoError(t, err)
+
+		parentRoot, err := signedParent.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		block := util.NewBeaconBlockAltair()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
+
+		for i := uint64(0); i < config.SyncCommitteeSize; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(t, err)
+
+		err = st.SetLatestBlockHeader(h.Header)
+		require.NoError(t, err)
+		stateRoot, err := st.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		root, err := block.Block.HashTreeRoot()
+		require.NoError(t, err)
+
+		mockBlocker := &testutil.MockBlocker{
+			RootBlockMap: map[[32]byte]interfaces.ReadOnlySignedBeaconBlock{
+				parentRoot: signedParent,
+				root:       signedBlock,
+			},
+			SlotBlockMap: map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock{
+				slot.Sub(1): signedParent,
+				slot:        signedBlock,
+			},
+		}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot, State: st, FinalizedRoots: map[[32]byte]bool{
+			root: true,
+		}}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
+		s := &Server{
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot.Sub(1): attestedState,
+				slot:        st,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
+		}
+		request := httptest.NewRequest("GET", "http://foo.com", nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetLightClientOptimisticUpdate(writer, request)
+
+		require.Equal(t, http.StatusOK, writer.Code)
+
+		var resp pb.LightClientOptimisticUpdateAltair
+		err = resp.UnmarshalSSZ(writer.Body.Bytes())
+		require.NoError(t, err)
+		require.Equal(t, resp.AttestedHeader.Beacon.Slot, attestedHeader.Slot)
+		require.DeepEqual(t, resp.AttestedHeader.Beacon.BodyRoot, attestedHeader.BodyRoot)
+	})
+
 	t.Run("capella", func(t *testing.T) {
 		ctx := context.Background()
 		slot := primitives.Slot(config.CapellaForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
@@ -1445,6 +1663,114 @@ func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
 		require.NotNil(t, resp.Data)
 	})
 
+	t.Run("capella SSZ", func(t *testing.T) {
+		ctx := context.Background()
+		slot := primitives.Slot(config.CapellaForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
+
+		attestedState, err := util.NewBeaconStateCapella()
+		require.NoError(t, err)
+		err = attestedState.SetSlot(slot.Sub(1))
+		require.NoError(t, err)
+
+		require.NoError(t, attestedState.SetFinalizedCheckpoint(&pb.Checkpoint{
+			Epoch: config.AltairForkEpoch - 10,
+			Root:  make([]byte, 32),
+		}))
+
+		parent := util.NewBeaconBlockCapella()
+		parent.Block.Slot = slot.Sub(1)
+
+		signedParent, err := blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		parentHeader, err := signedParent.Header()
+		require.NoError(t, err)
+		attestedHeader := parentHeader.Header
+
+		err = attestedState.SetLatestBlockHeader(attestedHeader)
+		require.NoError(t, err)
+		attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		parent.Block.StateRoot = attestedStateRoot[:]
+		signedParent, err = blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		st, err := util.NewBeaconStateCapella()
+		require.NoError(t, err)
+		err = st.SetSlot(slot)
+		require.NoError(t, err)
+
+		parentRoot, err := signedParent.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		block := util.NewBeaconBlockCapella()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
+
+		for i := uint64(0); i < config.SyncCommitteeSize; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(t, err)
+
+		err = st.SetLatestBlockHeader(h.Header)
+		require.NoError(t, err)
+		stateRoot, err := st.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		root, err := block.Block.HashTreeRoot()
+		require.NoError(t, err)
+
+		mockBlocker := &testutil.MockBlocker{
+			RootBlockMap: map[[32]byte]interfaces.ReadOnlySignedBeaconBlock{
+				parentRoot: signedParent,
+				root:       signedBlock,
+			},
+			SlotBlockMap: map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock{
+				slot.Sub(1): signedParent,
+				slot:        signedBlock,
+			},
+		}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot, State: st, FinalizedRoots: map[[32]byte]bool{
+			root: true,
+		}}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
+		s := &Server{
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot.Sub(1): attestedState,
+				slot:        st,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
+		}
+		request := httptest.NewRequest("GET", "http://foo.com", nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetLightClientOptimisticUpdate(writer, request)
+
+		require.Equal(t, http.StatusOK, writer.Code)
+
+		var resp pb.LightClientOptimisticUpdateCapella
+		err = resp.UnmarshalSSZ(writer.Body.Bytes())
+		require.NoError(t, err)
+		require.Equal(t, resp.AttestedHeader.Beacon.Slot, attestedHeader.Slot)
+		require.DeepEqual(t, resp.AttestedHeader.Beacon.BodyRoot, attestedHeader.BodyRoot)
+	})
+
 	t.Run("deneb", func(t *testing.T) {
 		ctx := context.Background()
 		slot := primitives.Slot(config.DenebForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
@@ -1554,6 +1880,114 @@ func TestLightClientHandler_GetLightClientOptimisticUpdate(t *testing.T) {
 		require.Equal(t, hexutil.Encode(attestedHeader.BodyRoot), respHeader.Beacon.BodyRoot)
 		require.NotNil(t, resp.Data)
 	})
+
+	t.Run("deneb SSZ", func(t *testing.T) {
+		ctx := context.Background()
+		slot := primitives.Slot(config.DenebForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
+
+		attestedState, err := util.NewBeaconStateDeneb()
+		require.NoError(t, err)
+		err = attestedState.SetSlot(slot.Sub(1))
+		require.NoError(t, err)
+
+		require.NoError(t, attestedState.SetFinalizedCheckpoint(&pb.Checkpoint{
+			Epoch: config.AltairForkEpoch - 10,
+			Root:  make([]byte, 32),
+		}))
+
+		parent := util.NewBeaconBlockDeneb()
+		parent.Block.Slot = slot.Sub(1)
+
+		signedParent, err := blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		parentHeader, err := signedParent.Header()
+		require.NoError(t, err)
+		attestedHeader := parentHeader.Header
+
+		err = attestedState.SetLatestBlockHeader(attestedHeader)
+		require.NoError(t, err)
+		attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		parent.Block.StateRoot = attestedStateRoot[:]
+		signedParent, err = blocks.NewSignedBeaconBlock(parent)
+		require.NoError(t, err)
+
+		st, err := util.NewBeaconStateDeneb()
+		require.NoError(t, err)
+		err = st.SetSlot(slot)
+		require.NoError(t, err)
+
+		parentRoot, err := signedParent.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		block := util.NewBeaconBlockDeneb()
+		block.Block.Slot = slot
+		block.Block.ParentRoot = parentRoot[:]
+
+		for i := uint64(0); i < config.SyncCommitteeSize; i++ {
+			block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+		}
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		h, err := signedBlock.Header()
+		require.NoError(t, err)
+
+		err = st.SetLatestBlockHeader(h.Header)
+		require.NoError(t, err)
+		stateRoot, err := st.HashTreeRoot(ctx)
+		require.NoError(t, err)
+
+		// get a new signed block so the root is updated with the new state root
+		block.Block.StateRoot = stateRoot[:]
+		signedBlock, err = blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		root, err := block.Block.HashTreeRoot()
+		require.NoError(t, err)
+
+		mockBlocker := &testutil.MockBlocker{
+			RootBlockMap: map[[32]byte]interfaces.ReadOnlySignedBeaconBlock{
+				parentRoot: signedParent,
+				root:       signedBlock,
+			},
+			SlotBlockMap: map[primitives.Slot]interfaces.ReadOnlySignedBeaconBlock{
+				slot.Sub(1): signedParent,
+				slot:        signedBlock,
+			},
+		}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot, State: st, FinalizedRoots: map[[32]byte]bool{
+			root: true,
+		}}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
+		s := &Server{
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot.Sub(1): attestedState,
+				slot:        st,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
+		}
+		request := httptest.NewRequest("GET", "http://foo.com", nil)
+		request.Header.Add("Accept", "application/octet-stream")
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+
+		s.GetLightClientOptimisticUpdate(writer, request)
+
+		require.Equal(t, http.StatusOK, writer.Code)
+
+		var resp pb.LightClientOptimisticUpdateDeneb
+		err = resp.UnmarshalSSZ(writer.Body.Bytes())
+		require.NoError(t, err)
+		require.Equal(t, resp.AttestedHeader.Beacon.Slot, attestedHeader.Slot)
+		require.DeepEqual(t, resp.AttestedHeader.Beacon.BodyRoot, attestedHeader.BodyRoot)
+	})
 }
 
 func TestLightClientHandler_GetLightClientEventBlock(t *testing.T) {

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

@@ -1,45 +0,0 @@
-package lightclient
-
-import (
-	"context"
-
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-
-	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
-	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-)
-
-func newLightClientFinalityUpdateFromBeaconState(
-	ctx context.Context,
-	currentSlot primitives.Slot,
-	state state.BeaconState,
-	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState,
-	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
-) (*structs.LightClientFinalityUpdate, error) {
-	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, currentSlot, state, block, attestedState, attestedBlock, finalizedBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	return structs.LightClientFinalityUpdateFromConsensus(result)
-}
-
-func newLightClientOptimisticUpdateFromBeaconState(
-	ctx context.Context,
-	currentSlot primitives.Slot,
-	state state.BeaconState,
-	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState,
-	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
-) (*structs.LightClientOptimisticUpdate, error) {
-	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, currentSlot, state, block, attestedState, attestedBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	return structs.LightClientOptimisticUpdateFromConsensus(result)
-}

beacon-chain/state/state-native/README.md

@@ -21,4 +21,4 @@ between states.
 `finalizerCleanup()` (applies only to multi-value slice fields).
 - If the field is a slice, add it to the field map in `types.go`.
 - If the field is a slice, update the `fieldConverters()` function in `/beacon-chain/state/fieldtrie/field_trie_helpers.go`. The exact implementation will vary
-depending on a few factors (is the field similar to an existing one, is it a multi-value slice etc.)
+depending on a few factors (is the field similar to an existing one, is it a multi-value slice etc.)

beacon-chain/state/stategen/service.go

@@ -121,9 +121,10 @@ func (s *State) Resume(ctx context.Context, fState state.BeaconState) (state.Bea
 		return nil, err
 	}
 	fRoot := bytesutil.ToBytes32(c.Root)
+	st := fState
 	// Resume as genesis state if last finalized root is zero hashes.
 	if fRoot == params.BeaconConfig().ZeroHash {
-		st, err := s.beaconDB.GenesisState(ctx)
+		st, err = s.beaconDB.GenesisState(ctx)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get genesis state")
 		}
@@ -132,10 +133,13 @@ func (s *State) Resume(ctx context.Context, fState state.BeaconState) (state.Bea
 		if err != nil {
 			return nil, stderrors.Join(ErrNoGenesisBlock, err)
 		}
-		return st, s.SaveState(ctx, gbr, st)
+		fRoot = gbr
+		if err := s.SaveState(ctx, gbr, st); err != nil {
+			return nil, errors.Wrap(err, "could not save genesis state")
+		}
 	}
 
-	if fState == nil || fState.IsNil() {
+	if st == nil || st.IsNil() {
 		return nil, errors.New("finalized state is nil")
 	}
 
@@ -145,20 +149,22 @@ func (s *State) Resume(ctx context.Context, fState state.BeaconState) (state.Bea
 		}
 	}()
 
-	s.finalizedInfo = &finalizedInfo{slot: fState.Slot(), root: fRoot, state: fState.Copy()}
-	fEpoch := slots.ToEpoch(fState.Slot())
+	s.finalizedInfo = &finalizedInfo{slot: st.Slot(), root: fRoot, state: st.Copy()}
+	populatePubkeyCache(ctx, st)
+	return st, nil
+}
 
-	// Pre-populate the pubkey cache with the validator public keys from the finalized state.
-	// This process takes about 30 seconds on mainnet with 450,000 validators.
+func populatePubkeyCache(ctx context.Context, st state.BeaconState) {
+	epoch := slots.ToEpoch(st.Slot())
 	go populatePubkeyCacheOnce.Do(func() {
 		log.Debug("Populating pubkey cache")
 		start := time.Now()
-		if err := fState.ReadFromEveryValidator(func(_ int, val state.ReadOnlyValidator) error {
+		if err := st.ReadFromEveryValidator(func(_ int, val state.ReadOnlyValidator) error {
 			if ctx.Err() != nil {
 				return ctx.Err()
 			}
 			// Do not cache for non-active validators.
-			if !helpers.IsActiveValidatorUsingTrie(val, fEpoch) {
+			if !helpers.IsActiveValidatorUsingTrie(val, epoch) {
 				return nil
 			}
 			pub := val.PublicKey()
@@ -169,8 +175,6 @@ func (s *State) Resume(ctx context.Context, fState state.BeaconState) (state.Bea
 		}
 		log.WithField("duration", time.Since(start)).Debug("Done populating pubkey cache")
 	})
-
-	return fState, nil
 }
 
 // SaveFinalizedState saves the finalized slot, root and state into memory to be used by state gen service.

beacon-chain/sync/decode_pubsub.go

@@ -87,6 +87,8 @@ func extractValidDataTypeFromTopic(topic string, digest []byte, clock *startup.C
 		return extractDataTypeFromTypeMap(types.AttestationMap, digest, clock)
 	case p2p.AggregateAndProofSubnetTopicFormat:
 		return extractDataTypeFromTypeMap(types.AggregateAttestationMap, digest, clock)
+	case p2p.AttesterSlashingSubnetTopicFormat:
+		return extractDataTypeFromTypeMap(types.AttesterSlashingMap, digest, clock)
 	}
 	return nil, nil
 }

beacon-chain/sync/decode_pubsub_test.go

@@ -137,13 +137,14 @@ func TestExtractDataType(t *testing.T) {
 		chain  blockchain.ChainInfoFetcher
 	}
 	tests := []struct {
-		name          string
-		args          args
-		wantBlock     interfaces.ReadOnlySignedBeaconBlock
-		wantMd        metadata.Metadata
-		wantAtt       ethpb.Att
-		wantAggregate ethpb.SignedAggregateAttAndProof
-		wantErr       bool
+		name            string
+		args            args
+		wantBlock       interfaces.ReadOnlySignedBeaconBlock
+		wantMd          metadata.Metadata
+		wantAtt         ethpb.Att
+		wantAggregate   ethpb.SignedAggregateAttAndProof
+		wantAttSlashing ethpb.AttSlashing
+		wantErr         bool
 	}{
 		{
 			name: "no digest",
@@ -156,10 +157,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "invalid digest",
@@ -167,11 +169,12 @@ func TestExtractDataType(t *testing.T) {
 				digest: []byte{0x00, 0x01},
 				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
 			},
-			wantBlock:     nil,
-			wantMd:        nil,
-			wantAtt:       nil,
-			wantAggregate: nil,
-			wantErr:       true,
+			wantBlock:       nil,
+			wantMd:          nil,
+			wantAtt:         nil,
+			wantAggregate:   nil,
+			wantAttSlashing: nil,
+			wantErr:         true,
 		},
 		{
 			name: "non existent digest",
@@ -179,11 +182,12 @@ func TestExtractDataType(t *testing.T) {
 				digest: []byte{0x00, 0x01, 0x02, 0x03},
 				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
 			},
-			wantBlock:     nil,
-			wantMd:        nil,
-			wantAtt:       nil,
-			wantAggregate: nil,
-			wantErr:       true,
+			wantBlock:       nil,
+			wantMd:          nil,
+			wantAtt:         nil,
+			wantAggregate:   nil,
+			wantAttSlashing: nil,
+			wantErr:         true,
 		},
 		{
 			name: "genesis fork version",
@@ -196,9 +200,10 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "altair fork version",
@@ -211,10 +216,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "bellatrix fork version",
@@ -227,10 +233,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "capella fork version",
@@ -243,10 +250,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "deneb fork version",
@@ -259,10 +267,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.Attestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.Attestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProof{},
+			wantAttSlashing: &ethpb.AttesterSlashing{},
+			wantErr:         false,
 		},
 		{
 			name: "electra fork version",
@@ -275,10 +284,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.SingleAttestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProofElectra{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.SingleAttestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProofElectra{},
+			wantAttSlashing: &ethpb.AttesterSlashingElectra{},
+			wantErr:         false,
 		},
 		{
 			name: "fulu fork version",
@@ -291,10 +301,11 @@ func TestExtractDataType(t *testing.T) {
 				require.NoError(t, err)
 				return wsb
 			}(),
-			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
-			wantAtt:       &ethpb.SingleAttestation{},
-			wantAggregate: &ethpb.SignedAggregateAttestationAndProofElectra{},
-			wantErr:       false,
+			wantMd:          wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:         &ethpb.SingleAttestation{},
+			wantAggregate:   &ethpb.SignedAggregateAttestationAndProofElectra{},
+			wantAttSlashing: &ethpb.AttesterSlashingElectra{},
+			wantErr:         false,
 		},
 	}
 	for _, tt := range tests {
@@ -323,6 +334,14 @@ func TestExtractDataType(t *testing.T) {
 			if !reflect.DeepEqual(gotAggregate, tt.wantAggregate) {
 				t.Errorf("aggregate: got = %v, want %v", gotAggregate, tt.wantAggregate)
 			}
+			gotAttSlashing, err := extractDataTypeFromTypeMap(types.AttesterSlashingMap, tt.args.digest, tt.args.chain)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("attester slashing: error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAttSlashing, tt.wantAttSlashing) {
+				t.Errorf("attester slashin: got = %v, want %v", gotAttSlashing, tt.wantAttSlashing)
+			}
 		})
 	}
 }

beacon-chain/sync/options.go

@@ -188,3 +188,11 @@ func WithAvailableBlocker(avb coverage.AvailableBlocker) Option {
 		return nil
 	}
 }
+
+// WithSlasherEnabled configures the sync package to support slashing detection.
+func WithSlasherEnabled(enabled bool) Option {
+	return func(s *Service) error {
+		s.slasherEnabled = enabled
+		return nil
+	}
+}

beacon-chain/sync/pending_attestations_queue.go

@@ -140,8 +140,7 @@ func (s *Service) processUnaggregated(ctx context.Context, att ethpb.Att) {
 	data := att.GetData()
 
 	// This is an important validation before retrieving attestation pre state to defend against
-	// attestation's target intentionally reference checkpoint that's long ago.
-	// Verify current finalized checkpoint is an ancestor of the block defined by the attestation's beacon block root.
+	// attestation's target intentionally referencing a checkpoint that's long ago.
 	if !s.cfg.chain.InForkchoice(bytesutil.ToBytes32(data.BeaconBlockRoot)) {
 		log.WithError(blockchain.ErrNotDescendantOfFinalized).Debug("Could not verify finalized consistency")
 		return
@@ -169,35 +168,57 @@ func (s *Service) processUnaggregated(ctx context.Context, att ethpb.Att) {
 		return
 	}
 
-	var singleAtt *ethpb.SingleAttestation
+	// Decide if the attestation is an Electra SingleAttestation or a Phase0 unaggregated attestation
+	var (
+		attForValidation ethpb.Att
+		broadcastAtt     ethpb.Att
+		eventType        feed.EventType
+		eventData        interface{}
+	)
+
 	if att.Version() >= version.Electra {
-		var ok bool
-		singleAtt, ok = att.(*ethpb.SingleAttestation)
+		singleAtt, ok := att.(*ethpb.SingleAttestation)
 		if !ok {
 			log.Debugf("Attestation has wrong type (expected %T, got %T)", &ethpb.SingleAttestation{}, att)
 			return
 		}
-		att = singleAtt.ToAttestationElectra(committee)
+		// Convert Electra SingleAttestation to unaggregated ElectraAttestation. This is needed because many parts of the codebase assume that attestations have a certain structure and SingleAttestation validates these assumptions.
+		attForValidation = singleAtt.ToAttestationElectra(committee)
+		broadcastAtt = singleAtt
+		eventType = operation.SingleAttReceived
+		eventData = &operation.SingleAttReceivedData{
+			Attestation: singleAtt,
+		}
+	} else {
+		// Phase0 attestation
+		attForValidation = att
+		broadcastAtt = att
+		eventType = operation.UnaggregatedAttReceived
+		eventData = &operation.UnAggregatedAttReceivedData{
+			Attestation: att,
+		}
 	}
 
-	valid, err = s.validateUnaggregatedAttWithState(ctx, att, preState)
+	valid, err = s.validateUnaggregatedAttWithState(ctx, attForValidation, preState)
 	if err != nil {
 		log.WithError(err).Debug("Pending unaggregated attestation failed validation")
 		return
 	}
+
 	if valid == pubsub.ValidationAccept {
 		if features.Get().EnableExperimentalAttestationPool {
-			if err = s.cfg.attestationCache.Add(att); err != nil {
+			if err = s.cfg.attestationCache.Add(attForValidation); err != nil {
 				log.WithError(err).Debug("Could not save unaggregated attestation")
 				return
 			}
 		} else {
-			if err := s.cfg.attPool.SaveUnaggregatedAttestation(att); err != nil {
+			if err := s.cfg.attPool.SaveUnaggregatedAttestation(attForValidation); err != nil {
 				log.WithError(err).Debug("Could not save unaggregated attestation")
 				return
 			}
 		}
-		s.setSeenCommitteeIndicesSlot(data.Slot, data.CommitteeIndex, att.GetAggregationBits())
+
+		s.setSeenCommitteeIndicesSlot(data.Slot, attForValidation.GetCommitteeIndex(), attForValidation.GetAggregationBits())
 
 		valCount, err := helpers.ActiveValidatorCount(ctx, preState, slots.ToEpoch(data.Slot))
 		if err != nil {
@@ -205,34 +226,16 @@ func (s *Service) processUnaggregated(ctx context.Context, att ethpb.Att) {
 			return
 		}
 
-		// Broadcasting the signed attestation again once a node is able to process it.
-		var attToBroadcast ethpb.Att
-		if singleAtt != nil {
-			attToBroadcast = singleAtt
-		} else {
-			attToBroadcast = att
-		}
-		if err := s.cfg.p2p.BroadcastAttestation(ctx, helpers.ComputeSubnetForAttestation(valCount, attToBroadcast), attToBroadcast); err != nil {
+		// Broadcast the final 'broadcastAtt' object
+		if err := s.cfg.p2p.BroadcastAttestation(ctx, helpers.ComputeSubnetForAttestation(valCount, broadcastAtt), broadcastAtt); err != nil {
 			log.WithError(err).Debug("Could not broadcast")
 		}
 
-		// Broadcast the unaggregated attestation on a feed to notify other services in the beacon node
-		// of a received unaggregated attestation.
-		if singleAtt != nil {
-			s.cfg.attestationNotifier.OperationFeed().Send(&feed.Event{
-				Type: operation.SingleAttReceived,
-				Data: &operation.SingleAttReceivedData{
-					Attestation: singleAtt,
-				},
-			})
-		} else {
-			s.cfg.attestationNotifier.OperationFeed().Send(&feed.Event{
-				Type: operation.UnaggregatedAttReceived,
-				Data: &operation.UnAggregatedAttReceivedData{
-					Attestation: att,
-				},
-			})
-		}
+		// Feed event notification for other services
+		s.cfg.attestationNotifier.OperationFeed().Send(&feed.Event{
+			Type: eventType,
+			Data: eventData,
+		})
 	}
 }
 

beacon-chain/sync/pending_attestations_queue_test.go

@@ -706,3 +706,41 @@ func Test_attsAreEqual_Committee(t *testing.T) {
 		assert.Equal(t, false, attsAreEqual(att1, att2))
 	})
 }
+
+func Test_SeenCommitteeIndicesSlot(t *testing.T) {
+	t.Run("phase 0 success", func(t *testing.T) {
+		s := &Service{
+			seenUnAggregatedAttestationCache: lruwrpr.New(1),
+		}
+		data := &ethpb.AttestationData{Slot: 1, CommitteeIndex: 44}
+		att := &ethpb.Attestation{
+			AggregationBits: bitfield.Bitlist{0x01},
+			Data:            data,
+		}
+		s.setSeenCommitteeIndicesSlot(data.Slot, att.GetCommitteeIndex(), att.GetAggregationBits())
+		b := append(bytesutil.Bytes32(uint64(1)), bytesutil.Bytes32(uint64(44))...)
+		b = append(b, bytesutil.SafeCopyBytes(att.GetAggregationBits())...)
+		_, ok := s.seenUnAggregatedAttestationCache.Get(string(b))
+		require.Equal(t, true, ok)
+	})
+	t.Run("electra success", func(t *testing.T) {
+		s := &Service{
+			seenUnAggregatedAttestationCache: lruwrpr.New(1),
+		}
+		// committee index is 0 post electra for attestation electra
+		data := &ethpb.AttestationData{Slot: 1, CommitteeIndex: 0}
+		cb := primitives.NewAttestationCommitteeBits()
+		cb.SetBitAt(uint64(63), true)
+		att := &ethpb.AttestationElectra{
+			AggregationBits: bitfield.Bitlist{0x01},
+			Data:            data,
+			CommitteeBits:   cb,
+		}
+		ci := att.GetCommitteeIndex()
+		s.setSeenCommitteeIndicesSlot(data.Slot, ci, att.GetAggregationBits())
+		b := append(bytesutil.Bytes32(uint64(1)), bytesutil.Bytes32(uint64(63))...)
+		b = append(b, bytesutil.SafeCopyBytes(att.GetAggregationBits())...)
+		_, ok := s.seenUnAggregatedAttestationCache.Get(string(b))
+		require.Equal(t, true, ok)
+	})
+}

beacon-chain/sync/rate_limiter.go

@@ -7,13 +7,12 @@ import (
 
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-	"github.com/trailofbits/go-mutexasserts"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	p2ptypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	leakybucket "github.com/prysmaticlabs/prysm/v5/container/leaky-bucket"
+	"github.com/sirupsen/logrus"
+	"github.com/trailofbits/go-mutexasserts"
 )
 
 const defaultBurstLimit = 5

beacon-chain/sync/service.go

@@ -15,8 +15,6 @@ import (
 	"github.com/libp2p/go-libp2p/core/peer"
 	gcache "github.com/patrickmn/go-cache"
 	"github.com/pkg/errors"
-	"github.com/trailofbits/go-mutexasserts"
-
 	"github.com/prysmaticlabs/prysm/v5/async"
 	"github.com/prysmaticlabs/prysm/v5/async/abool"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
@@ -47,6 +45,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/runtime"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"github.com/trailofbits/go-mutexasserts"
 )
 
 var _ runtime.Service = (*Service)(nil)
@@ -164,6 +163,7 @@ type Service struct {
 	newBlobVerifier                  verification.NewBlobVerifier
 	availableBlocker                 coverage.AvailableBlocker
 	ctxMap                           ContextByteVersions
+	slasherEnabled                   bool
 }
 
 // NewService initializes new regular sync service.

beacon-chain/sync/validate_beacon_attestation.go

@@ -17,7 +17,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
@@ -34,7 +33,11 @@ import (
 // - The attestation is unaggregated -- that is, it has exactly one participating validator (len(get_attesting_indices(state, attestation.data, attestation.aggregation_bits)) == 1).
 // - attestation.data.slot is within the last ATTESTATION_PROPAGATION_SLOT_RANGE slots (attestation.data.slot + ATTESTATION_PROPAGATION_SLOT_RANGE >= current_slot >= attestation.data.slot).
 // - The signature of attestation is valid.
-func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, pid peer.ID, msg *pubsub.Message) (pubsub.ValidationResult, error) {
+func (s *Service) validateCommitteeIndexBeaconAttestation(
+	ctx context.Context,
+	pid peer.ID,
+	msg *pubsub.Message,
+) (pubsub.ValidationResult, error) {
 	if pid == s.cfg.p2p.PeerID() {
 		return pubsub.ValidationAccept, nil
 	}
@@ -64,6 +67,7 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 	if err := helpers.ValidateNilAttestation(att); err != nil {
 		return pubsub.ValidationReject, err
 	}
+
 	data := att.GetData()
 
 	// Do not process slot 0 attestations.
@@ -73,8 +77,7 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 
 	// Attestation's slot is within ATTESTATION_PROPAGATION_SLOT_RANGE and early attestation
 	// processing tolerance.
-	if err := helpers.ValidateAttestationTime(data.Slot, s.cfg.clock.GenesisTime(),
-		earlyAttestationProcessingTolerance); err != nil {
+	if err := helpers.ValidateAttestationTime(data.Slot, s.cfg.clock.GenesisTime(), earlyAttestationProcessingTolerance); err != nil {
 		tracing.AnnotateError(span, err)
 		return pubsub.ValidationIgnore, err
 	}
@@ -84,12 +87,11 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 
 	committeeIndex := att.GetCommitteeIndex()
 
-	if !features.Get().EnableSlasher {
+	if !s.slasherEnabled {
 		// Verify this the first attestation received for the participating validator for the slot.
 		if s.hasSeenCommitteeIndicesSlot(data.Slot, committeeIndex, att.GetAggregationBits()) {
 			return pubsub.ValidationIgnore, nil
 		}
-
 		// Reject an attestation if it references an invalid block.
 		if s.hasBadBlock(bytesutil.ToBytes32(data.BeaconBlockRoot)) ||
 			s.hasBadBlock(bytesutil.ToBytes32(data.Target.Root)) ||
@@ -99,15 +101,12 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 		}
 	}
 
-	var validationRes pubsub.ValidationResult
-
 	// Verify the block being voted and the processed state is in beaconDB and the block has passed validation if it's in the beaconDB.
 	blockRoot := bytesutil.ToBytes32(data.BeaconBlockRoot)
 	if !s.hasBlockAndState(ctx, blockRoot) {
 		return s.saveToPendingAttPool(att)
 	}
-
-	if !s.cfg.chain.InForkchoice(bytesutil.ToBytes32(data.BeaconBlockRoot)) {
+	if !s.cfg.chain.InForkchoice(blockRoot) {
 		tracing.AnnotateError(span, blockchain.ErrNotDescendantOfFinalized)
 		return pubsub.ValidationIgnore, blockchain.ErrNotDescendantOfFinalized
 	}
@@ -123,12 +122,12 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 		return pubsub.ValidationIgnore, err
 	}
 
-	validationRes, err = s.validateUnaggregatedAttTopic(ctx, att, preState, *msg.Topic)
+	validationRes, err := s.validateUnaggregatedAttTopic(ctx, att, preState, *msg.Topic)
 	if validationRes != pubsub.ValidationAccept {
 		return validationRes, err
 	}
 
-	committee, err := helpers.BeaconCommitteeFromState(ctx, preState, att.GetData().Slot, committeeIndex)
+	committee, err := helpers.BeaconCommitteeFromState(ctx, preState, data.Slot, committeeIndex)
 	if err != nil {
 		tracing.AnnotateError(span, err)
 		return pubsub.ValidationIgnore, err
@@ -139,21 +138,42 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 		return validationRes, err
 	}
 
-	var singleAtt *eth.SingleAttestation
+	// Consolidated handling of Electra SingleAttestation vs Phase0 unaggregated attestation
+	var (
+		attForValidation eth.Att // what we'll pass to further validation
+		eventType        feed.EventType
+		eventData        interface{}
+	)
+
 	if att.Version() >= version.Electra {
-		singleAtt, ok = att.(*eth.SingleAttestation)
+		singleAtt, ok := att.(*eth.SingleAttestation)
 		if !ok {
-			return pubsub.ValidationIgnore, fmt.Errorf("attestation has wrong type (expected %T, got %T)", &eth.SingleAttestation{}, att)
+			return pubsub.ValidationIgnore, fmt.Errorf(
+				"attestation has wrong type (expected %T, got %T)",
+				&eth.SingleAttestation{}, att,
+			)
+		}
+		// Convert Electra SingleAttestation to unaggregated ElectraAttestation. This is needed because many parts of the codebase assume that attestations have a certain structure and SingleAttestation validates these assumptions.
+		attForValidation = singleAtt.ToAttestationElectra(committee)
+		eventType = operation.SingleAttReceived
+		eventData = &operation.SingleAttReceivedData{
+			Attestation: singleAtt,
+		}
+	} else {
+		// Phase0 unaggregated attestation
+		attForValidation = att
+		eventType = operation.UnaggregatedAttReceived
+		eventData = &operation.UnAggregatedAttReceivedData{
+			Attestation: att,
 		}
-		att = singleAtt.ToAttestationElectra(committee)
 	}
 
-	validationRes, err = s.validateUnaggregatedAttWithState(ctx, att, preState)
+	validationRes, err = s.validateUnaggregatedAttWithState(ctx, attForValidation, preState)
 	if validationRes != pubsub.ValidationAccept {
 		return validationRes, err
 	}
 
-	if features.Get().EnableSlasher {
+	if s.slasherEnabled {
 		// Feed the indexed attestation to slasher if enabled. This action
 		// is done in the background to avoid adding more load to this critical code path.
 		go func() {
@@ -172,7 +192,7 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 				tracing.AnnotateError(span, err)
 				return
 			}
-			indexedAtt, err := attestation.ConvertToIndexed(ctx, att, committee)
+			indexedAtt, err := attestation.ConvertToIndexed(ctx, attForValidation, committee)
 			if err != nil {
 				log.WithError(err).Error("Could not convert to indexed attestation")
 				tracing.AnnotateError(span, err)
@@ -182,27 +202,16 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 		}()
 	}
 
-	// Broadcast the unaggregated attestation on a feed to notify other services in the beacon node
-	// of a received unaggregated attestation.
-	if singleAtt != nil {
-		s.cfg.attestationNotifier.OperationFeed().Send(&feed.Event{
-			Type: operation.SingleAttReceived,
-			Data: &operation.SingleAttReceivedData{
-				Attestation: singleAtt,
-			},
-		})
-	} else {
-		s.cfg.attestationNotifier.OperationFeed().Send(&feed.Event{
-			Type: operation.UnaggregatedAttReceived,
-			Data: &operation.UnAggregatedAttReceivedData{
-				Attestation: att,
-			},
-		})
-	}
+	// Notify other services in the beacon node
+	s.cfg.attestationNotifier.OperationFeed().Send(&feed.Event{
+		Type: eventType,
+		Data: eventData,
+	})
 
-	s.setSeenCommitteeIndicesSlot(data.Slot, committeeIndex, att.GetAggregationBits())
+	s.setSeenCommitteeIndicesSlot(data.Slot, committeeIndex, attForValidation.GetAggregationBits())
 
-	msg.ValidatorData = att
+	// Attach final validated attestation to the message for further pipeline use
+	msg.ValidatorData = attForValidation
 
 	return pubsub.ValidationAccept, nil
 }

beacon-chain/sync/validate_beacon_blocks.go

@@ -15,7 +15,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -80,7 +79,7 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		},
 	})
 
-	if features.Get().EnableSlasher {
+	if s.slasherEnabled {
 		// Feed the block header to slasher if enabled. This action
 		// is done in the background to avoid adding more load to this critical code path.
 		go func() {

beacon-chain/sync/validate_blob.go

@@ -92,11 +92,11 @@ func (s *Service) validateBlob(ctx context.Context, pid peer.ID, msg *pubsub.Mes
 		return pubsub.ValidationIgnore, err
 	}
 
-	if err := vf.ValidProposerSignature(ctx); err != nil {
+	if err := vf.SidecarParentValid(s.hasBadBlock); err != nil {
 		return pubsub.ValidationReject, err
 	}
 
-	if err := vf.SidecarParentValid(s.hasBadBlock); err != nil {
+	if err := vf.ValidProposerSignature(ctx); err != nil {
 		return pubsub.ValidationReject, err
 	}
 

changelog/bastin_lightclient-finality-optimistic-ssz.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add SSZ support to light client finality and optimistic APIs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14836)

changelog/dB2510_fixpruner.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed pruner to not block while pruning large database by introducing batchSize

changelog/dB2510_precommit.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add pre-commit hooks for faster feedback loop

changelog/james-prysm_attestation-cleanup-suggestions.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Cleanup single attestation code for readability.

changelog/james-prysm_blockv2-cognit.md

@@ -1,4 +1,4 @@
 ### Fixed
 
 - refactored publish block and block ssz functions to fix gocognit 
-- refactored publish blinded block and blinded block ssz to correctly deal with version headers and sent blocks
+- refactored publish blinded block and blinded block ssz to correctly deal with version headers and sent blocks

changelog/james-prysm_cleanup-payload-conversions.md

@@ -4,4 +4,4 @@
 
 ### Fixed
 
-- fixed gocognit in block conversions between json and proto types
+- fixed gocognit in block conversions between json and proto types

changelog/james-prysm_committee-index-log.md

@@ -0,0 +1,3 @@
+### Added
+
+- add log to committee index when committeebits are not the expected length of 1

changelog/james-prysm_deprecate-apis-for-electra.md

@@ -1,3 +1,3 @@
 ### Changed
 
-- deprecate beacon api endpoints based on [3.0.0 release](https://github.com/ethereum/beacon-APIs/pull/506) for electra
+- deprecate beacon api endpoints based on [3.0.0 release](https://github.com/ethereum/beacon-APIs/pull/506) for electra

changelog/james-prysm_dynamic-max-blobs.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- fixed max and target blob per block from static to dynamic values
+- fixed max and target blob per block from static to dynamic values

changelog/james-prysm_fix-builder-post-header.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- adding in content type and accept headers for builder API call on registration
+- adding in content type and accept headers for builder API call on registration

changelog/james-prysm_fix-electra-committee-log.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- cosmetic fix for post electra validator logs displaying attestation committee information correctly.

changelog/james-prysm_fix-wrong-committee-seen.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- fix inserting the wrong committee index into the seen cache for electra attestations

changelog/james-prysm_improve-execution-request-errors.md

@@ -1,3 +1,3 @@
 ### Changed
 
-- execution requests errors on ssz length have been improved
+- execution requests errors on ssz length have been improved

changelog/james-prysm_web3signer-electra-e2e.md

@@ -1,3 +1,3 @@
 ### Added
 
-- enable web3signer E2E for electra 
+- enable web3signer E2E for electra 

changelog/manu_fix_dependencies_doc.md

@@ -1,2 +1,2 @@
 ### Fixed
-- Fixed the `bazel run //:gazelle` command in `DEPENDENCIES.md`.
+- Fixed the `bazel run //:gazelle` command in `DEPENDENCIES.md`.

changelog/manu_remove_fulu_state_block.md

@@ -1,3 +1,3 @@
 ### Removed
 
-- Remove Fulu state and block
+- Remove Fulu state and block

changelog/manu_services_start_log_removal.md

@@ -1,2 +1,2 @@
 ### Removed
-- Removed the log summarizing all started services.
+- Removed the log summarizing all started services.

changelog/manu_tracked_validators_ttl.md

@@ -5,4 +5,4 @@
 
 ### Changed
 
-- Tracked validators cache: Remove validators from the cache if not seen after 1 hour.
+- Tracked validators cache: Remove validators from the cache if not seen after 1 hour.

changelog/manu_validators_registration_default_batch.md

@@ -0,0 +1,3 @@
+## Changed
+
+- `--validators-registration-batch-size`: Change default value from `0` to `200`.

changelog/nisdas_add_deposit_request_testing.md

@@ -1,3 +1,3 @@
 ### Added
 
-- Added deposit request testing for electra.
+- Added deposit request testing for electra.

changelog/nisdas_enable_multiclient_e2e_electra.md

@@ -1,4 +1,4 @@
 ### Added
 
 - Enable multiclient E2E for electra
-- Enable Scenario E2E tests with electra
+- Enable Scenario E2E tests with electra

changelog/nisdas_fix_attester_slashing_validation.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Check for the correct attester slashing type during gossip validation.

changelog/nisdas_fix_block_decoding.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Allow any block type to be unmarshaled rather than only phase0 blocks in `slotByBlockRoot`. 

changelog/nisdas_fix_capabilites.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- Only check for electra related engine methods if electra is active.
+- Only check for electra related engine methods if electra is active.

changelog/nisdas_fix_deposit_active_evaluator.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- Fix E2E Deposit Activation Evaluator for Electra.
+- Fix E2E Deposit Activation Evaluator for Electra.

changelog/nisdas_fix_process_deposit_evaluator.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- Fix E2E Process Deposit Evaluator for Electra.
+- Fix E2E Process Deposit Evaluator for Electra.

changelog/nisdas_log_execution_requests.md

@@ -1,3 +1,3 @@
 ### Added
 
-- Log execution requests in each block.
+- Log execution requests in each block.

changelog/nisdas_update_blst.md

@@ -1,3 +1,3 @@
 ### Changed
 
-- Updates blst to v3.14.0 and fixes the references in our deps.bzl file.
+- Updates blst to v3.14.0 and fixes the references in our deps.bzl file.

changelog/potuz_add_target_to_fc_dump.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Add target root to forkchoice dump

changelog/potuz_forkchoice_startup.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Split out forkchoice startup from the main service startup. 

changelog/potuz_populate_pubkey.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- Populate pubkey cache at genesis.

changelog/potuz_rpc_handler_log.md

@@ -1,3 +1,3 @@
 ### Ignored
 
-- Add logs for RPC handlers added/removed at forks. 
+- Add logs for RPC handlers added/removed at forks. 

changelog/pvl_beacon_flags.md

@@ -0,0 +1,2 @@
+### Changed
+- Reorganized beacon chain flags in `--help` text into logical sections.

changelog/pvl_g301.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Fixed violations of gosec G301. This is a check that created files and directories have file permissions 0750 and 0600 respectively.

changelog/pvl_go-cmp.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Use go-cmp for printing better diffs for assertions.DeepEqual

changelog/pvl_go1.24.md

@@ -0,0 +1,11 @@
+### Changed
+
+- Updated go to go1.24.0.
+- Updated gosec to v2.22.1 and golangci to v1.64.5.
+- Updated github.com/trailofbits/go-mutexasserts.
+- Updated rules_go to cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9 to support go1.24.0.
+
+### Fixed
+
+- Fixed use of deprecated rand.Seed. 
+- Fixed build issue with SszGen where the go binary was not present in the $PATH.

changelog/radek_electra-packing-fix.md

@@ -0,0 +1,3 @@
+### Fixed
+
+- Decompose Electra block attestations to prevent redundant packing.