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

beacon-chain/blockchain/BUILD.bazel

@@ -12,7 +12,6 @@ go_library(
         "forkchoice_update_execution.go",
         "head.go",
         "head_sync_committee_info.go",
-        "holeskyhack.go",
         "init_sync_process_block.go",
         "log.go",
         "merge_ascii_art.go",
@@ -98,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",
     ],
@@ -156,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",
@@ -187,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/holeskyhack.go

@@ -1,21 +0,0 @@
-package blockchain
-
-import (
-	"encoding/hex"
-
-	"github.com/pkg/errors"
-)
-
-var errHoleskyForbiddenRoot = errors.New("refusing to process forbidden holesky block")
-
-// hack to prevent bad holesky block importation
-var badHoleskyRoot [32]byte
-
-func init() {
-	hexStr := "2db899881ed8546476d0b92c6aa9110bea9a4cd0dbeb5519eb0ea69575f1f359"
-	bytes, err := hex.DecodeString(hexStr)
-	if err != nil {
-		panic(err)
-	}
-	badHoleskyRoot = [32]byte(bytes)
-}

beacon-chain/blockchain/kzg/trusted_setup.json

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

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"
@@ -173,9 +175,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	var set *bls.SignatureBatch
 	boundaries := make(map[[32]byte]state.BeaconState)
 	for i, b := range blks {
-		if b.Root() == badHoleskyRoot {
-			return errHoleskyForbiddenRoot
-		}
 		v, h, err := getStateVersionAndPayload(preState)
 		if err != nil {
 			return err
@@ -371,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
 		}
@@ -422,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())
 }
 

beacon-chain/blockchain/receive_block.go

@@ -64,11 +64,6 @@ type SlashingReceiver interface {
 func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityStore) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlock")
 	defer span.End()
-
-	if blockRoot == badHoleskyRoot {
-		return errHoleskyForbiddenRoot
-	}
-
 	// Return early if the block has been synced
 	if s.InForkchoice(blockRoot) {
 		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring already synced block")
@@ -552,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

@@ -39,7 +39,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	"github.com/sirupsen/logrus"
 )
 
 // Service represents a service that handles the internal
@@ -317,40 +316,33 @@ func (s *Service) originRootFromSavedState(ctx context.Context) ([32]byte, error
 	return genesisBlkRoot, nil
 }
 
-// initializeHeadFromDB uses the finalized checkpoint and head block root from forkchoice to set the current head.
+// 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) initializeHead(ctx context.Context, st state.BeaconState) error {
+func (s *Service) initializeHeadFromDB(ctx context.Context, finalizedState state.BeaconState) error {
 	cp := s.FinalizedCheckpt()
-	fRoot := s.ensureRootNotZeros([32]byte(cp.Root))
-	if st == nil || st.IsNil() {
+	fRoot := [32]byte(cp.Root)
+	finalizedRoot := s.ensureRootNotZeros(fRoot)
+
+	if finalizedState == nil || finalizedState.IsNil() {
 		return errors.New("finalized state can't be nil")
 	}
 
-	s.cfg.ForkChoiceStore.RLock()
-	root := s.cfg.ForkChoiceStore.HighestReceivedBlockRoot()
-	s.cfg.ForkChoiceStore.RUnlock()
-	blk, err := s.cfg.BeaconDB.Block(ctx, root)
+	finalizedBlock, err := s.getBlock(ctx, finalizedRoot)
 	if err != nil {
-		return errors.Wrap(err, "could not get head block")
+		return errors.Wrap(err, "could not get finalized block")
 	}
-	if root != fRoot {
-		st, err = s.cfg.StateGen.StateByRoot(ctx, root)
-		if err != nil {
-			return errors.Wrap(err, "could not get head state")
-		}
-	}
-	log.WithFields(logrus.Fields{
-		"root": fmt.Sprintf("%#x", root),
-		"slot": blk.Block().Slot(),
-	}).Info("Initialized head block from DB")
-	return errors.Wrap(s.setHead(&head{
-		root,
-		blk,
-		st,
-		blk.Block().Slot(),
+	if err := s.setHead(&head{
+		finalizedRoot,
+		finalizedBlock,
+		finalizedState,
+		finalizedBlock.Block().Slot(),
 		false,
-	}), "could not set head")
+	}); err != nil {
+		return errors.Wrap(err, "could not set head")
+	}
+
+	return nil
 }
 
 func (s *Service) startFromExecutionChain() error {

beacon-chain/blockchain/setup_forchoice.go

@@ -2,129 +2,26 @@ package blockchain
 
 import (
 	"bytes"
-	"context"
-	"fmt"
 
 	"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/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
 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.setupForkchoiceTree(st); err != nil {
-		return errors.Wrap(err, "could not set up forkchoice root")
-	}
-	if err := s.initializeHead(s.ctx, st); err != nil {
-		return errors.Wrap(err, "could not initialize head from db")
-	}
-	return nil
-}
-
-func (s *Service) startupHeadRoot() [32]byte {
-	headStr := features.Get().ForceHead
-	cp := s.FinalizedCheckpt()
-	fRoot := s.ensureRootNotZeros([32]byte(cp.Root))
-	if headStr == "" {
-		return fRoot
-	}
-	if headStr == "head" {
-		root, err := s.cfg.BeaconDB.HeadBlockRoot()
-		if err != nil {
-			log.WithError(err).Error("could not get head block root, starting with finalized block as head")
-			return fRoot
-		}
-		log.Infof("Using Head root of %#x", root)
-		return root
-	}
-	root, err := bytesutil.DecodeHexWithLength(headStr, 32)
-	if err != nil {
-		log.WithError(err).Error("could not parse head root, starting with finalized block as head")
-		return fRoot
-	}
-	return [32]byte(root)
-}
-
-func (s *Service) setupForkchoiceTree(st state.BeaconState) error {
-	headRoot := s.startupHeadRoot()
-	cp := s.FinalizedCheckpt()
-	fRoot := s.ensureRootNotZeros([32]byte(cp.Root))
 	if err := s.setupForkchoiceRoot(st); err != nil {
 		return errors.Wrap(err, "could not set up forkchoice root")
 	}
-	fBlk, err := s.cfg.BeaconDB.Block(s.ctx, fRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized block")
+	if err := s.initializeHeadFromDB(s.ctx, st); err != nil {
+		return errors.Wrap(err, "could not initialize head from db")
 	}
-	if err := s.setHead(&head{
-		fRoot,
-		fBlk,
-		st,
-		fBlk.Block().Slot(),
-		false,
-	}); err != nil {
-		return errors.Wrap(err, "could not set head")
-	}
-
-	if headRoot == fRoot {
-		return nil
-	}
-	blk, err := s.cfg.BeaconDB.Block(s.ctx, headRoot)
-	if err != nil {
-		log.WithError(err).Error("could not get head block, starting with finalized block as head")
-		return nil
-	}
-	if slots.ToEpoch(blk.Block().Slot()) < cp.Epoch {
-		log.WithField("headRoot", fmt.Sprintf("%#x", headRoot)).Error("head block is older than finalized block, starting with finalized block as head")
-		return nil
-	}
-	chain, err := s.buildForkchoiceChain(s.ctx, blk)
-	if err != nil {
-		log.WithError(err).Error("could not build forkchoice chain, starting with finalized block as head")
-		return nil
-	}
-	s.cfg.ForkChoiceStore.Lock()
-	defer s.cfg.ForkChoiceStore.Unlock()
-	return s.cfg.ForkChoiceStore.InsertChain(s.ctx, chain)
-}
-
-func (s *Service) buildForkchoiceChain(ctx context.Context, head interfaces.ReadOnlySignedBeaconBlock) ([]*forkchoicetypes.BlockAndCheckpoints, error) {
-	chain := []*forkchoicetypes.BlockAndCheckpoints{}
-	cp := s.FinalizedCheckpt()
-	fRoot := s.ensureRootNotZeros([32]byte(cp.Root))
-	jp := s.CurrentJustifiedCheckpt()
-	root, err := head.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get head block root")
-	}
-	for {
-		roblock, err := blocks.NewROBlockWithRoot(head, root)
-		if err != nil {
-			return nil, err
-		}
-		// This chain sets the justified checkpoint for every block, including some that are older than jp.
-		// This should be however safe for forkchoice at startup.
-		chain = append(chain, &forkchoicetypes.BlockAndCheckpoints{Block: roblock, JustifiedCheckpoint: jp, FinalizedCheckpoint: cp})
-		root = head.Block().ParentRoot()
-		if root == fRoot {
-			break
-		}
-		head, err = s.cfg.BeaconDB.Block(s.ctx, root)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get block")
-		}
-		if slots.ToEpoch(head.Block().Slot()) < cp.Epoch {
-			return nil, errors.New("head block is not a descendant of the finalized checkpoint")
-		}
-	}
-	return chain, nil
+	return nil
 }
 
 func (s *Service) setupForkchoiceRoot(st state.BeaconState) error {

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

@@ -110,7 +110,6 @@ type HeadAccessDatabase interface {
 
 	// Block related methods.
 	HeadBlock(ctx context.Context) (interfaces.ReadOnlySignedBeaconBlock, error)
-	HeadBlockRoot() ([32]byte, error)
 	SaveHeadBlockRoot(ctx context.Context, blockRoot [32]byte) error
 
 	// Genesis operations.

beacon-chain/db/kv/blocks.go

@@ -70,21 +70,6 @@ func (s *Store) OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	return root, err
 }
 
-// HeadBlockRoot returns the latest canonical block root in the Ethereum Beacon Chain.
-func (s *Store) HeadBlockRoot() ([32]byte, error) {
-	var root [32]byte
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(blocksBucket)
-		headRoot := bkt.Get(headBlockRootKey)
-		if headRoot == nil {
-			return errors.New("no head block root found")
-		}
-		copy(root[:], headRoot)
-		return nil
-	})
-	return root, err
-}
-
 // HeadBlock returns the latest canonical block in the Ethereum Beacon Chain.
 func (s *Store) HeadBlock(ctx context.Context) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.HeadBlock")
@@ -229,8 +214,7 @@ func (s *Store) DeleteBlock(ctx context.Context, root [32]byte) error {
 	defer span.End()
 
 	if err := s.DeleteState(ctx, root); err != nil {
-		// TODO: Find out why invalid states are in the db
-		log.WithError(err).Error("Could not delete state")
+		return err
 	}
 
 	if err := s.deleteStateSummary(root); err != nil {

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/store.go

@@ -252,13 +252,6 @@ func (s *Store) tips() ([][32]byte, []primitives.Slot) {
 	return roots, slots
 }
 
-func (f *ForkChoice) HighestReceivedBlockRoot() [32]byte {
-	if f.store.highestReceivedNode == nil {
-		return [32]byte{}
-	}
-	return f.store.highestReceivedNode.root
-}
-
 // HighestReceivedBlockSlot returns the highest slot received by the forkchoice
 func (f *ForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	if f.store.highestReceivedNode == nil {

beacon-chain/forkchoice/interfaces.go

@@ -65,7 +65,6 @@ type FastGetter interface {
 	FinalizedPayloadBlockHash() [32]byte
 	HasNode([32]byte) bool
 	HighestReceivedBlockSlot() primitives.Slot
-	HighestReceivedBlockRoot() [32]byte
 	HighestReceivedBlockDelay() primitives.Slot
 	IsCanonical(root [32]byte) bool
 	IsOptimistic(root [32]byte) (bool, error)

beacon-chain/forkchoice/ro.go

@@ -114,13 +114,6 @@ func (ro *ROForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	return ro.getter.HighestReceivedBlockSlot()
 }
 
-// HighestReceivedBlockRoot delegates to the underlying forkchoice call, under a lock.
-func (ro *ROForkChoice) HighestReceivedBlockRoot() [32]byte {
-	ro.l.RLock()
-	defer ro.l.RUnlock()
-	return ro.getter.HighestReceivedBlockRoot()
-}
-
 // HighestReceivedBlockDelay delegates to the underlying forkchoice call, under a lock.
 func (ro *ROForkChoice) HighestReceivedBlockDelay() primitives.Slot {
 	ro.l.RLock()

beacon-chain/forkchoice/ro_test.go

@@ -29,7 +29,6 @@ const (
 	unrealizedJustifiedPayloadBlockHashCalled
 	nodeCountCalled
 	highestReceivedBlockSlotCalled
-	highestReceivedBlockRootCalled
 	highestReceivedBlockDelayCalled
 	receivedBlocksLastEpochCalled
 	weightCalled
@@ -253,11 +252,6 @@ func (ro *mockROForkchoice) HighestReceivedBlockSlot() primitives.Slot {
 	return 0
 }
 
-func (ro *mockROForkchoice) HighestReceivedBlockRoot() [32]byte {
-	ro.calls = append(ro.calls, highestReceivedBlockRootCalled)
-	return [32]byte{}
-}
-
 func (ro *mockROForkchoice) HighestReceivedBlockDelay() primitives.Slot {
 	ro.calls = append(ro.calls, highestReceivedBlockDelayCalled)
 	return 0

beacon-chain/operations/attestations/kv/unaggregated.go

@@ -9,7 +9,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	log "github.com/sirupsen/logrus"
 )
 
 // SaveUnaggregatedAttestation saves an unaggregated attestation in cache.
@@ -61,8 +60,7 @@ func (c *AttCaches) UnaggregatedAttestations() ([]ethpb.Att, error) {
 	for _, att := range unAggregatedAtts {
 		seen, err := c.hasSeenBit(att)
 		if err != nil {
-			log.WithError(err).Debug("Could not check if attestations bits have been seen")
-			continue
+			return nil, err
 		}
 		if !seen {
 			atts = append(atts, att.Clone())
@@ -165,13 +163,7 @@ func (c *AttCaches) DeleteSeenUnaggregatedAttestations() (int, error) {
 		if att == nil || att.IsNil() || att.IsAggregated() {
 			continue
 		}
-		seen, err := c.hasSeenBit(att)
-		if err != nil {
-			log.WithError(err).Debug("Could not check if attestations bits have been seen")
-			delete(c.unAggregatedAtt, r)
-			count++
-		}
-		if seen {
+		if seen, err := c.hasSeenBit(att); err == nil && seen {
 			delete(c.unAggregatedAtt, r)
 			count++
 		}

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/prysm/v1alpha1/validator/proposer_attestations.go

@@ -39,6 +39,13 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 	} else {
 		atts = vs.AttPool.AggregatedAttestations()
 		atts = vs.validateAndDeleteAttsInPool(ctx, latestState, atts)
+
+		uAtts, err := vs.AttPool.UnaggregatedAttestations()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get unaggregated attestations")
+		}
+		uAtts = vs.validateAndDeleteAttsInPool(ctx, latestState, uAtts)
+		atts = append(atts, uAtts...)
 	}
 
 	// Checking the state's version here will give the wrong result if the last slot of Deneb is missed.

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/sync/initial-sync/BUILD.bazel

@@ -38,7 +38,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//container/leaky-bucket:go_default_library",
         "//crypto/rand:go_default_library",
-        "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

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

@@ -2,7 +2,6 @@ package initialsync
 
 import (
 	"context"
-	"encoding/hex"
 	"fmt"
 	"sort"
 	"strings"
@@ -25,7 +24,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	leakybucket "github.com/prysmaticlabs/prysm/v5/container/leaky-bucket"
 	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	p2ppb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -69,8 +67,6 @@ var (
 // Period to calculate expected limit for a single peer.
 var blockLimiterPeriod = 30 * time.Second
 
-type isBannedBlock func(root [32]byte) bool
-
 // blocksFetcherConfig is a config to setup the block fetcher.
 type blocksFetcherConfig struct {
 	clock                    *startup.Clock
@@ -105,7 +101,6 @@ type blocksFetcher struct {
 	capacityWeight  float64       // how remaining capacity affects peer selection
 	mode            syncMode      // allows to use fetcher in different sync scenarios
 	quit            chan struct{} // termination notifier
-	isBannedBlock   isBannedBlock
 }
 
 // peerLock restricts fetcher actions on per peer basis. Currently, used for rate limiting.
@@ -131,13 +126,6 @@ type fetchRequestResponse struct {
 	err   error
 }
 
-// set in init()
-var holeskyBadRoot [32]byte
-
-func isHoleskyBannedBlock(root [32]byte) bool {
-	return root == holeskyBadRoot
-}
-
 // newBlocksFetcher creates ready to use fetcher.
 func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetcher {
 	blockBatchLimit := maxBatchLimit()
@@ -172,7 +160,6 @@ func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetc
 		capacityWeight:  capacityWeight,
 		mode:            cfg.mode,
 		quit:            make(chan struct{}),
-		isBannedBlock:   isHoleskyBannedBlock,
 	}
 }
 
@@ -370,13 +357,6 @@ func (f *blocksFetcher) fetchBlocksFromPeer(
 			log.WithField("peer", p).WithError(err).Debug("invalid BeaconBlocksByRange response")
 			continue
 		}
-		if f.isBannedBlock != nil {
-			for _, b := range robs {
-				if f.isBannedBlock(b.Block.Root()) {
-					return nil, p, prysmsync.ErrInvalidFetchedData
-				}
-			}
-		}
 		return robs, p, err
 	}
 	return nil, "", errNoPeersAvailable
@@ -747,11 +727,3 @@ func dedupPeers(peers []peer.ID) []peer.ID {
 	}
 	return newPeerList
 }
-
-func init() {
-	bytes, err := hex.DecodeString("2db899881ed8546476d0b92c6aa9110bea9a4cd0dbeb5519eb0ea69575f1f359")
-	if err != nil {
-		panic(err)
-	}
-	holeskyBadRoot = bytesutil.ToBytes32(bytes)
-}

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

@@ -125,7 +125,6 @@ func (s *Service) syncToNonFinalizedEpoch(ctx context.Context, genesis time.Time
 	if err != nil {
 		return err
 	}
-
 	for data := range queue.fetchedData {
 		s.processFetchedDataRegSync(ctx, genesis, s.cfg.Chain.HeadSlot(), data)
 	}
@@ -170,7 +169,6 @@ func (s *Service) processFetchedDataRegSync(
 		"firstSlot":        data.bwb[0].Block.Block().Slot(),
 		"firstUnprocessed": bwb[0].Block.Block().Slot(),
 	}
-
 	for _, b := range bwb {
 		if err := avs.Persist(s.clock.CurrentSlot(), b.Blobs...); err != nil {
 			log.WithError(err).WithFields(batchFields).WithFields(syncFields(b.Block)).Warn("Batch failure due to BlobSidecar issues")

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

@@ -6,7 +6,6 @@ package sync
 
 import (
 	"context"
-	"encoding/hex"
 	"sync"
 	"time"
 
@@ -16,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"
@@ -48,11 +45,9 @@ 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"
 )
 
-// hack to prevent bad holesky block importation
-var badHoleskyRoot [32]byte
-
 var _ runtime.Service = (*Service)(nil)
 
 const (
@@ -387,13 +382,3 @@ type Checker interface {
 	Status() error
 	Resync() error
 }
-
-func init() {
-	hexStr := "2db899881ed8546476d0b92c6aa9110bea9a4cd0dbeb5519eb0ea69575f1f359"
-	bytes, err := hex.DecodeString(hexStr)
-	if err != nil {
-		log.WithError(err).Error("Could not decode hex string")
-		return
-	}
-	badHoleskyRoot = [32]byte(bytes)
-}

beacon-chain/sync/validate_beacon_blocks.go

@@ -399,9 +399,6 @@ func (s *Service) setSeenBlockIndexSlot(slot primitives.Slot, proposerIdx primit
 
 // Returns true if the block is marked as a bad block.
 func (s *Service) hasBadBlock(root [32]byte) bool {
-	if root == badHoleskyRoot {
-		return true
-	}
 	s.badBlockLock.RLock()
 	defer s.badBlockLock.RUnlock()
 	_, seen := s.badBlockCache.Get(string(root[:]))

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

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

changelog/dB2510_precommit.md

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

changelog/james-prysm_attestation-cleanup-suggestions.md

@@ -1,4 +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

@@ -1,3 +1,3 @@
 ### Added
 
-- add log to committee index when committeebits are not the expected length of 1
+- 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

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

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

@@ -1,3 +1,3 @@
 ### Fixed
 
-- fix inserting the wrong committee index into the seen cache for electra attestations
+- 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

@@ -1,3 +1,3 @@
 ## Changed
 
-- `--validators-registration-batch-size`: Change default value from `0` to `200`.
+- `--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

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

changelog/nisdas_fix_block_decoding.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- Allow any block type to be unmarshaled rather than only phase0 blocks in `slotByBlockRoot`. 
+- 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_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/potuz_sync_from_head.md

@@ -1,3 +0,0 @@
-### Added
-
-- Added a feature flag to sync from an arbitrary beacon block root at startup. 

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.

changelog/radek_monitor-single-atts.md

@@ -1,3 +1,3 @@
 ### Fixed
 
-- Dedicated processing of `SingleAttestation` in the monitor service.
+- Dedicated processing of `SingleAttestation` in the monitor service.

changelog/radek_no-maxcover-for-electra.md

@@ -1,3 +1,3 @@
 ### Changed
 
-- Don't use MaxCover for Electra on-chain attestations.
+- Don't use MaxCover for Electra on-chain attestations.

changelog/radek_rename-slashing-files.md

@@ -1,3 +1,3 @@
 ### Ignored
 
-- Rename files in `beacon-chain/operations/slashings`.
+- Rename files in `beacon-chain/operations/slashings`.

changelog/saolyn_add-GetPendingDeposits.md

@@ -1,3 +1,3 @@
 ### Added
 
-- Add endpoint for getting pending deposits.
+- Add endpoint for getting pending deposits.

changelog/syjn99_cli-peer-address-format.md

@@ -0,0 +1,3 @@
+### Added
+
+- Add acceptable address types for static peers

changelog/tt_add_block_hash.md

@@ -1,3 +1,3 @@
 ### Added
 
-- Add request hash to header for builder: executable data to block
+- Add request hash to header for builder: executable data to block

changelog/tt_blob_by_range_electra_test.md

@@ -1,3 +1,3 @@
 ### Ignored
 
-- Add blobs by range electra test
+- Add blobs by range electra test

changelog/tt_fork_digest.md

@@ -1,3 +1,3 @@
 ### Ignored
 
-- Add more debugging information to mismatch fork digest error message
+- Add more debugging information to mismatch fork digest error message

changelog/tt_validate_block.md

@@ -0,0 +1,3 @@
+### Changed
+
+- Validate blob sidecar re-order signature and bad parent block.

changelog/tt_validate_range.md

@@ -1,3 +1,3 @@
 ### Ignored
 
-- Add more debugging information to validate range debug message
+- Add more debugging information to validate range debug message

cmd/flags.go

@@ -93,15 +93,20 @@ var (
 		Name:  "no-discovery",
 		Usage: "Enable only local network p2p and do not connect to cloud bootstrap nodes",
 	}
-	// StaticPeers specifies a set of peers to connect to explicitly.
+	// StaticPeers specifies a set of peers to connect to explicitly, accepting following format of addresses:
+	// enode, multiaddr, enr.
 	StaticPeers = &cli.StringSliceFlag{
-		Name:  "peer",
-		Usage: "Connect with this peer, this flag may be used multiple times. This peer is recognized as a trusted peer.",
+		Name: "peer",
+		Usage: "Connect with this peer, this flag may be used multiple times. " +
+			"This peer is recognized as a trusted peer." +
+			"Accepts enode, multiaddr, and enr formats.",
 	}
 	// BootstrapNode tells the beacon node which bootstrap node to connect to
 	BootstrapNode = &cli.StringSliceFlag{
-		Name:  "bootstrap-node",
-		Usage: "The address of bootstrap node. Beacon node will connect for peer discovery via DHT.  Multiple nodes can be passed by using the flag multiple times but not comma-separated. You can also pass YAML files containing multiple nodes.",
+		Name: "bootstrap-node",
+		Usage: "The enr/enode address of bootstrap node. Beacon node will connect for peer discovery via DHT. " +
+			"Multiple nodes can be passed by using the flag multiple times but not comma-separated. " +
+			"You can also pass YAML files containing multiple nodes.",
 		Value: cli.NewStringSlice(params.BeaconNetworkConfig().BootstrapNodes...),
 	}
 	// RelayNode tells the beacon node which relay node to connect to.

cmd/prysmctl/validator/testdata/change-operations-multiple.json

@@ -1 +1 @@
-[{"message":{"validator_index":"0","from_bls_pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xb6e640f0fc58e9f22585dbf434b6a0e8fc36b98e2f2a963e158716cfc84034141289f7898027de1ec56754937f1a837e01c7b066a6a56af7a379f8aec823d050788a5ecc799e9bc39f73d45b7c389c961cbaace61823e4c7bf2f93bd06c03127"},{"message":{"validator_index":"1","from_bls_pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xa97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5"}]
+[{"message":{"validator_index":"0","from_bls_pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xb6e640f0fc58e9f22585dbf434b6a0e8fc36b98e2f2a963e158716cfc84034141289f7898027de1ec56754937f1a837e01c7b066a6a56af7a379f8aec823d050788a5ecc799e9bc39f73d45b7c389c961cbaace61823e4c7bf2f93bd06c03127"},{"message":{"validator_index":"1","from_bls_pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xa97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5"}]

cmd/prysmctl/validator/testdata/change-operations-multiple_notfound.json

@@ -1 +1 @@
-[{"message":{"validator_index":"3","from_bls_pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xb6e640f0fc58e9f22585dbf434b6a0e8fc36b98e2f2a963e158716cfc84034141289f7898027de1ec56754937f1a837e01c7b066a6a56af7a379f8aec823d050788a5ecc799e9bc39f73d45b7c389c961cbaace61823e4c7bf2f93bd06c03127"},{"message":{"validator_index":"5","from_bls_pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xa97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5"}]
+[{"message":{"validator_index":"3","from_bls_pubkey":"0xa99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xb6e640f0fc58e9f22585dbf434b6a0e8fc36b98e2f2a963e158716cfc84034141289f7898027de1ec56754937f1a837e01c7b066a6a56af7a379f8aec823d050788a5ecc799e9bc39f73d45b7c389c961cbaace61823e4c7bf2f93bd06c03127"},{"message":{"validator_index":"5","from_bls_pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xa97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5"}]

cmd/prysmctl/validator/testdata/change-operations.json

@@ -1 +1 @@
-[{"message":{"validator_index":"1","from_bls_pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xa97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5"}]
+[{"message":{"validator_index":"1","from_bls_pubkey":"0xb89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"0xa97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5"}]

cmd/prysmctl/validator/testdata/staking-cli-change-operations-multiple.json

@@ -1 +1 @@
-[{"message":{"validator_index":"0","from_bls_pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","to_execution_address":"a94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"b6e640f0fc58e9f22585dbf434b6a0e8fc36b98e2f2a963e158716cfc84034141289f7898027de1ec56754937f1a837e01c7b066a6a56af7a379f8aec823d050788a5ecc799e9bc39f73d45b7c389c961cbaace61823e4c7bf2f93bd06c03127", "metadata":{ "network_name": "mainnet", "genesis_validators_root": "4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95", "deposit_cli_version": "2.4.0"}},{"message":{"validator_index":"1","from_bls_pubkey":"b89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"a94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"a97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5", "metadata":{ "network_name": "mainnet", "genesis_validators_root": "4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95", "deposit_cli_version": "2.4.0"}}]
+[{"message":{"validator_index":"0","from_bls_pubkey":"a99a76ed7796f7be22d5b7e85deeb7c5677e88e511e0b337618f8c4eb61349b4bf2d153f649f7b53359fe8b94a38e44c","to_execution_address":"a94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"b6e640f0fc58e9f22585dbf434b6a0e8fc36b98e2f2a963e158716cfc84034141289f7898027de1ec56754937f1a837e01c7b066a6a56af7a379f8aec823d050788a5ecc799e9bc39f73d45b7c389c961cbaace61823e4c7bf2f93bd06c03127", "metadata":{ "network_name": "mainnet", "genesis_validators_root": "4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95", "deposit_cli_version": "2.4.0"}},{"message":{"validator_index":"1","from_bls_pubkey":"b89bebc699769726a318c8e9971bd3171297c61aea4a6578a7a4f94b547dcba5bac16a89108b6b6a1fe3695d1a874a0b","to_execution_address":"a94f5374fce5edbc8e2a8697c15331677e6ebf0b"},"signature":"a97103e15d3dbdaa75fb15cea782e4a11329eea77d155864ec682d7907b3b70c7771960bef7be1b1c4e08fe735888b950c1a22053f6049b35736f48e6dd018392efa3896c9e427ea4e100e86e9131b5ea2673388a4bf188407a630ba405b7dc5", "metadata":{ "network_name": "mainnet", "genesis_validators_root": "4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95", "deposit_cli_version": "2.4.0"}}]

config/features/config.go

@@ -86,9 +86,6 @@ type Flags struct {
 
 	// AggregateIntervals specifies the time durations at which we aggregate attestations preparing for forkchoice.
 	AggregateIntervals [3]time.Duration
-
-	// Feature related flags (alignment forced in the end)
-	ForceHead string // ForceHead forces the head block to be a specific block root, the last head block, or the last finalized block.
 }
 
 var featureConfig *Flags
@@ -271,10 +268,6 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		logEnabled(enableExperimentalAttestationPool)
 		cfg.EnableExperimentalAttestationPool = true
 	}
-	if ctx.IsSet(forceHeadFlag.Name) {
-		logEnabled(forceHeadFlag)
-		cfg.ForceHead = ctx.String(forceHeadFlag.Name)
-	}
 
 	cfg.AggregateIntervals = [3]time.Duration{aggregateFirstInterval.Value, aggregateSecondInterval.Value, aggregateThirdInterval.Value}
 	Init(cfg)

config/features/flags.go

@@ -174,12 +174,6 @@ var (
 		Name:  "enable-experimental-attestation-pool",
 		Usage: "Enables an experimental attestation pool design.",
 	}
-	// forceHeadFlag is a flag to force the head of the beacon chain to a specific block.
-	forceHeadFlag = &cli.StringFlag{
-		Name: "sync-from",
-		Usage: "Forces the head of the beacon chain to a specific block root. Values can be 'head' or a block root." +
-			" The block root has to be known to the beacon node and correspond to a block newer than the current finalized checkpoint.",
-	}
 )
 
 // devModeFlags holds list of flags that are set when development mode is on.
@@ -236,7 +230,6 @@ var BeaconChainFlags = combinedFlags([]cli.Flag{
 	DisableCommitteeAwarePacking,
 	EnableDiscoveryReboot,
 	enableExperimentalAttestationPool,
-	forceHeadFlag,
 }, deprecatedBeaconFlags, deprecatedFlags, upcomingDeprecation)
 
 func combinedFlags(flags ...[]cli.Flag) []cli.Flag {

config/params/testdata/e2e_config.yaml

@@ -123,5 +123,3 @@ CONFIG_NAME: "end-to-end"
 SLOTS_PER_EPOCH: 6
 EPOCHS_PER_ETH1_VOTING_PERIOD: 2
 MAX_SEED_LOOKAHEAD: 1
-
-