Merge branch 'develop' of https://github.com/prysmaticlabs/geth-sharding into hackSync

Add a Hack
missing save
2026-01-11 06:18:05 -05:00 · 2025-03-05 13:33:53 +08:00 · 2025-03-03 08:52:20 +08:00 · 2025-03-02 16:48:38 -03:00 · 2025-03-02 16:48:16 -03:00 · 2025-03-01 07:39:52 +08:00
272 changed files with 1376 additions and 4510 deletions
--- a/.github/actions/gomodtidy/Dockerfile
+++ b/.github/actions/gomodtidy/Dockerfile
@@ -1,4 +1,4 @@
-FROM golang:1.24-alpine
+FROM golang:1.23-alpine

 COPY entrypoint.sh /entrypoint.sh

--- a/.github/workflows/changelog.yml
+++ b/.github/workflows/changelog.yml
@@ -12,7 +12,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout source code
-        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
+        uses: actions/checkout@v3

      - name: Download unclog binary
        uses: dsaltares/fetch-gh-release-asset@aa2ab1243d6e0d5b405b973c89fa4d06a2d0fff7 # 1.1.2
@@ -23,7 +23,7 @@ jobs:

      - name: Get new changelog files
        id: new-changelog-files
-        uses: OffchainLabs/gh-action-changed-files@9200e69727eb73eb060652b19946b8a2fdfb654b # v4.0.8
+        uses: tj-actions/changed-files@v45
        with:
          files: |
            changelog/**.md
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -28,15 +28,15 @@ jobs:
    steps:
      - name: Checkout
        uses: actions/checkout@v4
-      - name: Set up Go 1.24
+      - name: Set up Go 1.23
        uses: actions/setup-go@v4
        with:
-          go-version: '1.24.0'
+          go-version: '1.23.5'
      - 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.22.1
-          gosec -exclude-generated -exclude=G307,G115 -exclude-dir=crypto/bls/herumi ./...
+          go install github.com/securego/gosec/v2/cmd/gosec@v2.19.0
+          gosec -exclude-generated -exclude=G307 -exclude-dir=crypto/bls/herumi ./...

  lint:
    name: Lint
@@ -45,16 +45,16 @@ jobs:
      - name: Checkout
        uses: actions/checkout@v4

-      - name: Set up Go 1.24
+      - name: Set up Go 1.23
        uses: actions/setup-go@v4
        with:
-          go-version: '1.24.0'
+          go-version: '1.23.5'
          id: go

      - name: Golangci-lint
        uses: golangci/golangci-lint-action@v5
        with:
-          version: v1.64.5
+          version: v1.63.4
          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.24.0'
+          go-version: '1.23.5'
        id: go

      - name: Check out code into the Go module directory
--- a/.golangci.yml
+++ b/.golangci.yml
@@ -75,7 +75,6 @@ linters:
    - tagliatelle
    - thelper
    - unparam
-    - usetesting
    - varnamelen
    - wrapcheck
    - wsl
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -165,7 +165,7 @@ STATICCHECK_ANALYZERS = [
    "sa6006",
    "sa9001",
    "sa9002",
-    "sa9003",
+    #"sa9003", # Doesn't build. See https://github.com/dominikh/go-tools/pull/1483
    "sa9004",
    "sa9005",
    "sa9006",
@@ -197,7 +197,6 @@ nogo(
        "//tools/analyzers/logruswitherror:go_default_library",
        "//tools/analyzers/maligned:go_default_library",
        "//tools/analyzers/nop:go_default_library",
-        "//tools/analyzers/nopanic:go_default_library",
        "//tools/analyzers/properpermissions:go_default_library",
        "//tools/analyzers/recursivelock:go_default_library",
        "//tools/analyzers/shadowpredecl:go_default_library",
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,102 +4,6 @@ All notable changes to this project will be documented in this file.

 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.

-## [v5.3.1](https://github.com/prysmaticlabs/prysm/compare/v5.3.0...v5.3.1) - 2025-03-13
-
-This release is packed with critical fixes for **Electra** and some important fixes for mainnet too. 
-
-The release highlights include:
-
- Ensure that deleting a block from the database clears its entry in the slot->root db index. This issue was causing some operators to have a bricked database, requiring a full resync. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15011)
- Updated go to go1.24.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- Added a feature flag to sync from an arbitrary beacon block root at startup. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15000)
- Updated default gas limit from 30M to 36M. Override this with `--suggested-gas-limit=` in the validator client. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14858)
-
-Known issues in **Electra**:
-
- Duplicate attestations are needlessly processed. This is being addressed in [[PR]](https://github.com/prysmaticlabs/prysm/pull/15034).
-
-Testnet operators are strongly encouraged to update to this release. There are many fixes and improvements from the Holesky upgrade incident.
-
-Mainner operators are recommended to update to this release at their regular cadence. 
-
-### Added
-
- enable E2E for minimal and mainnet tests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14842)
- enable web3signer E2E for electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14936)
- Enable multiclient E2E for electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14946)
- Enable Scenario E2E tests with electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14946)
- Add endpoint for getting pending deposits. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14941)
- Add request hash to header for builder: executable data to block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14955)
- Log execution requests in each block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14956)
- Add endpoint for getting pending partial withdrawals. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14949)
- Tracked validators cache: Added the `ItemCount` method. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14957)
- Tracked validators cache: Added the `Indices` method. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14957)
- Added deposit request testing for electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14964)
- Added support for otel tracing transport in HTTP clients in Prysm. This allows for tracing headers to be sent with http requests such that spans between the validator and beacon chain can be connected in the tracing graph. This change does nothing without `--enable-tracing`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14972)
- Add SSZ support to light client finality and optimistic APIs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14836)
- add log to committee index when committeebits are not the expected length of 1. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14993)
- Add acceptable address types for static peers. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14886)
- Added a feature flag to sync from an arbitrary beacon block root at startup. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15000)
-
-### Changed
-
- updates geth to 1.15.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14842)
- Updates blst to v3.14.0 and fixes the references in our deps.bzl file. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14921)
- Updated tracing exporter from jaeger to otelhttp. This should not be a breaking change. Jaeger supports otel format, however you may need to update your URL as the default otel-collector port is 4318. See the [OpenTelemtry Protocol Exporter docs](https://opentelemetry.io/docs/specs/otel/protocol/exporter/) for more details. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14928)
- Don't use MaxCover for Electra on-chain attestations. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14925)
- Tracked validators cache: Remove validators from the cache if not seen after 1 hour. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14957)
- execution requests errors on ssz length have been improved. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14962)
- deprecate beacon api endpoints based on [3.0.0 release](https://github.com/ethereum/beacon-APIs/pull/506) for electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14967)
- Use go-cmp for printing better diffs for assertions.DeepEqual. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14978)
- Reorganized beacon chain flags in `--help` text into logical sections. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14959)
- `--validators-registration-batch-size`: Change default value from `0` to `200`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14981)
- Updated go to go1.24.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- Updated gosec to v2.22.1 and golangci to v1.64.5. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- Updated github.com/trailofbits/go-mutexasserts. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- Updated rules_go to cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9 to support go1.24.0. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- Validate blob sidecar re-order signature and bad parent block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15013)
- Updated default gas limit from 30M to 36M. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14858)
- Ignore errors from `hasSeenBit` and don't pack unaggregated attestations. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15018)
-
-### Removed
-
- Remove Fulu state and block. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14905)
- Removed the log summarizing all started services. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14958)
-
-### Fixed
-
- fixed max and target blob per block from static to dynamic values. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14911)
- refactored publish block and block ssz functions to fix gocognit. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14913)
- refactored publish blinded block and blinded block ssz to correctly deal with version headers and sent blocks. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14913)
- Only check for electra related engine methods if electra is active. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14924)
- Fixed bug that breaks new blob storage layout code on Windows, caused by accidental use of platform-dependent path parsing package. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14931)
- Fix E2E Process Deposit Evaluator for Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14933)
- Fixed the `bazel run //:gazelle` command in `DEPENDENCIES.md`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14934)
- Fix E2E Deposit Activation Evaluator for Electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14938)
- Dedicated processing of `SingleAttestation` in the monitor service. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14965)
- adding in content type and accept headers for builder API call on registration. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14961)
- fixed gocognit in block conversions between json and proto types. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14953)
- Lint: Fix violations of S1009: should omit nil check; len() for nil slices is defined as zero. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14973)
- Lint: Fix violations of non-constant format string in call. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14974)
- Fixed violations of gosec G301. This is a check that created files and directories have file permissions 0750 and 0600 respectively. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14980)
- Check for the correct attester slashing type during gossip validation. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14985)
- cosmetic fix for post electra validator logs displaying attestation committee information correctly. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14992)
- fix inserting the wrong committee index into the seen cache for electra attestations. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14998)
- Allow any block type to be unmarshaled rather than only phase0 blocks in `slotByBlockRoot`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15008)
- Fixed pruner to not block while pruning large database by introducing batchSize. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14929)
- Decompose Electra block attestations to prevent redundant packing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14896)
- Fixed use of deprecated rand.Seed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- Fixed build issue with SszGen where the go binary was not present in the $PATH. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14969)
- fixed /eth/v1/config/spec displays BLOB_SIDECAR_SUBNET_COUNT,BLOB_SIDECAR_SUBNET_COUNT_ELECTRA. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15016)
- Ensure that deleting a block from the database clears its entry in the slot->root db index. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15011)
- Broadcasting BLS to execution changes should not use the request context in a go routine. Use context.Background() for the broadcasting go routine. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15019)
- /eth/v1/validator/sync_committee_contribution should check for optimistic status and return a 503 if it's optimistic. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15022)
- Fixes printing superfluous response.WriteHeader call from error in builder. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15025)
- Fixes e2e run with builder having wrong gaslimit header due to not being set on eth1 nodes. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15025)
- Fixed a bug in the event stream handler when processing payload attribute events where the timestamp and slot of the event would be based on the head rather than the current slot. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14963)
- Handle unaggregated attestations when decomposing Electra block attestations. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15027)
-
 ## [v5.3.0](https://github.com/prysmaticlabs/prysm/compare/v5.2.0...v5.3.0) - 2025-02-12

 This release includes support for Pectra activation in the [Holesky](https://github.com/eth-clients/holesky) and [Sepolia](https://github.com/eth-clients/sepolia) testnets! The release contains many fixes for Electra that have been found in rigorous testing through devnets in the last few months.
--- a/48
+++ b/48
@@ -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",
    ],
-    strip_prefix = "rules_go-cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9",
+    sha256 = "b2038e2de2cace18f032249cb4bb0048abf583a36369fa98f687af1b3f880b26",
    urls = [
-        "https://github.com/bazel-contrib/rules_go/archive/cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9.tar.gz",
+        "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",
    ],
 )

@@ -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.24.0",
+    go_version = "1.23.5",
    nogo = "@//:nogo",
 )

@@ -255,7 +255,7 @@ filegroup(
    url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )

-consensus_spec_version = "v1.5.0-beta.3"
+consensus_spec_version = "v1.5.0-beta.2"

 bls_test_version = "v0.1.1"

@@ -271,7 +271,7 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    integrity = "sha256-z+j0BEJuXMBKbGL+7jq35zddzZMW1je8/uvTz5+wboQ=",
+    integrity = "sha256-X/bMxbKg1clo2aFEjBoeuFq/U+BF1eQopgRP/7nI3Qg=",
    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )

@@ -287,7 +287,7 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    integrity = "sha256-5/YUOXH65CmM1plZ8twJ3BQxwM51jgSpOB8/VSBI19k=",
+    integrity = "sha256-WSxdri5OJGuNApW+odKle5UzToDyEOx+F3lMiqamJAg=",
    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )

@@ -303,7 +303,7 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    integrity = "sha256-iZ2eNhwRnbxrjR+5gMBUYakaCXicvPChwFUkZtQUbbI=",
+    integrity = "sha256-LYE8l3y/zSt4YVrehrJ3ralqtgeYNildiIp+HR6+xAI=",
    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )

@@ -318,7 +318,7 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    integrity = "sha256-inAXV7xNM5J1aUdP7JNXFO2iFFZ7dth38Ji+mJW50Ts=",
+    integrity = "sha256-jvZQ90qcJMTOqMsPO7sgeEVQmewZTHcz7LVDkNqwTFQ=",
    strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
    url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -365,9 +365,9 @@ filegroup(
    visibility = ["//visibility:public"],
 )
 """,
-    integrity = "sha256-YVFFrCmjoGZ3fXMWpsCpSsYbANy1grnqYwOLKIg2SsA=",
-    strip_prefix = "holesky-32a72e21c6e53c262f27d50dd540cb654517d03a",
-    url = "https://github.com/eth-clients/holesky/archive/32a72e21c6e53c262f27d50dd540cb654517d03a.tar.gz",  # 2025-03-17
+    integrity = "sha256-b7ZTT+olF+VXEJYNTV5jggNtCkt9dOejm1i2VE+zy+0=",
+    strip_prefix = "holesky-874c199423ccd180607320c38cbaca05d9a1573a",
+    url = "https://github.com/eth-clients/holesky/archive/874c199423ccd180607320c38cbaca05d9a1573a.tar.gz",  # 2024-06-18
 )

 http_archive(
@@ -381,25 +381,9 @@ filegroup(
    visibility = ["//visibility:public"],
 )
 """,
-    integrity = "sha256-b5F7Wg9LLMqGRIpP2uqb/YsSFVn2ynzlV7g/Nb1EFLk=",
-    strip_prefix = "sepolia-562d9938f08675e9ba490a1dfba21fb05843f39f",
-    url = "https://github.com/eth-clients/sepolia/archive/562d9938f08675e9ba490a1dfba21fb05843f39f.tar.gz",  # 2025-03-17
-)
-
-http_archive(
-    name = "hoodi_testnet",
-    build_file_content = """
-filegroup(
-    name = "configs",
-    srcs = [
-        "metadata/config.yaml",
-    ],
-    visibility = ["//visibility:public"],
-)
-""",
-    integrity = "sha256-dPiEWUd8QvbYGwGtIm0QtCekitVLOLsW5rpQIGzz8PU=",
-    strip_prefix = "hoodi-828c2c940e1141092bd4bb979cef547ea926d272",
-    url = "https://github.com/eth-clients/hoodi/archive/828c2c940e1141092bd4bb979cef547ea926d272.tar.gz",
+    integrity = "sha256-cY/UgpCcYEhQf7JefD65FI8tn/A+rAvKhcm2/qiVdqY=",
+    strip_prefix = "sepolia-f2c219a93c4491cee3d90c18f2f8e82aed850eab",
+    url = "https://github.com/eth-clients/sepolia/archive/f2c219a93c4491cee3d90c18f2f8e82aed850eab.tar.gz",  # 2024-09-19
 )

 http_archive(
@@ -447,7 +431,7 @@ gometalinter_dependencies()

 load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")

-gazelle_dependencies(go_sdk = "go_sdk")
+gazelle_dependencies()

 load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")

--- a/api/client/beacon/BUILD.bazel
+++ b/api/client/beacon/BUILD.bazel
@@ -7,7 +7,6 @@ go_library(
        "doc.go",
        "health.go",
        "log.go",
-        "template.go",
    ],
    importpath = "github.com/prysmaticlabs/prysm/v5/api/client/beacon",
    visibility = ["//visibility:public"],
--- a/api/client/beacon/client.go
+++ b/api/client/beacon/client.go
@@ -11,6 +11,7 @@ import (
 	"regexp"
 	"sort"
 	"strconv"
+	"text/template"

 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
@@ -63,6 +64,23 @@ func IdFromSlot(s primitives.Slot) StateOrBlockId {
 	return StateOrBlockId(strconv.FormatUint(uint64(s), 10))
 }

+// idTemplate is used to create template functions that can interpolate StateOrBlockId values.
+func idTemplate(ts string) func(StateOrBlockId) string {
+	t := template.Must(template.New("").Parse(ts))
+	f := func(id StateOrBlockId) string {
+		b := bytes.NewBuffer(nil)
+		err := t.Execute(b, struct{ Id string }{Id: string(id)})
+		if err != nil {
+			panic(fmt.Sprintf("invalid idTemplate: %s", ts))
+		}
+		return b.String()
+	}
+	// run the template to ensure that it is valid
+	// this should happen load time (using package scoped vars) to ensure runtime errors aren't possible
+	_ = f(IdGenesis)
+	return f
+}
+
 // RenderGetBlockPath formats a block id into a path for the GetBlock API endpoint.
 func RenderGetBlockPath(id StateOrBlockId) string {
 	return path.Join(getSignedBlockPath, string(id))
@@ -96,6 +114,8 @@ func (c *Client) GetBlock(ctx context.Context, blockId StateOrBlockId) ([]byte,
 	return b, nil
 }

+var getBlockRootTpl = idTemplate(getBlockRootPath)
+
 // GetBlockRoot retrieves the hash_tree_root of the BeaconBlock for the given block id.
 // Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
 // <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
@@ -118,6 +138,8 @@ func (c *Client) GetBlockRoot(ctx context.Context, blockId StateOrBlockId) ([32]
 	return bytesutil.ToBytes32(rs), nil
 }

+var getForkTpl = idTemplate(getForkForStatePath)
+
 // GetFork queries the Beacon Node API for the Fork from the state identified by stateId.
 // Block identifier can be one of: "head" (canonical head in node's view), "genesis", "finalized",
 // <slot>, <hex encoded blockRoot with 0x prefix>. Variables of type StateOrBlockId are exported by this package
--- a/api/client/beacon/template.go
+++ b/api/client/beacon/template.go
@@ -1,34 +0,0 @@
-package beacon
-
-import (
-	"bytes"
-	"fmt"
-	"text/template"
-)
-
-type templateFn func(StateOrBlockId) string
-
-var getBlockRootTpl templateFn
-var getForkTpl templateFn
-
-func init() {
-	// idTemplate is used to create template functions that can interpolate StateOrBlockId values.
-	idTemplate := func(ts string) func(StateOrBlockId) string {
-		t := template.Must(template.New("").Parse(ts))
-		f := func(id StateOrBlockId) string {
-			b := bytes.NewBuffer(nil)
-			err := t.Execute(b, struct{ Id string }{Id: string(id)})
-			if err != nil {
-				panic(fmt.Sprintf("invalid idTemplate: %s", ts))
-			}
-			return b.String()
-		}
-		// run the template to ensure that it is valid
-		// this should happen load time (using package scoped vars) to ensure runtime errors aren't possible
-		_ = f(IdGenesis)
-		return f
-	}
-
-	getBlockRootTpl = idTemplate(getBlockRootPath)
-	getForkTpl = idTemplate(getForkForStatePath)
-}
--- a/api/client/builder/client.go
+++ b/api/client/builder/client.go
@@ -16,7 +16,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/client"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -36,14 +35,9 @@ const (
 	postRegisterValidatorPath  = "/eth/v1/builder/validators"
 )

-var (
-	vrExample             = &ethpb.SignedValidatorRegistrationV1{}
-	vrSize                = vrExample.SizeSSZ()
-	errMalformedHostname  = errors.New("hostname must include port, separated by one colon, like example.com:3500")
-	errMalformedRequest   = errors.New("required request data are missing")
-	errNotBlinded         = errors.New("submitted block is not blinded")
-	errVersionUnsupported = errors.New("version is not supported")
-)
+var errMalformedHostname = errors.New("hostname must include port, separated by one colon, like example.com:3500")
+var errMalformedRequest = errors.New("required request data are missing")
+var errNotBlinded = errors.New("submitted block is not blinded")

 // ClientOpt is a functional option for the Client type (http.Client wrapper)
 type ClientOpt func(*Client)
@@ -58,12 +52,6 @@ func WithObserver(m observer) ClientOpt {
 	}
 }

-func WithSSZ() ClientOpt {
-	return func(c *Client) {
-		c.sszEnabled = true
-	}
-}
-
 type requestLogger struct{}

 func (*requestLogger) observe(r *http.Request) (e error) {
@@ -107,10 +95,9 @@ type BuilderClient interface {

 // Client provides a collection of helper methods for calling Builder API endpoints.
 type Client struct {
-	hc         *http.Client
-	baseURL    *url.URL
-	obvs       []observer
-	sszEnabled bool
+	hc      *http.Client
+	baseURL *url.URL
+	obvs    []observer
 }

 // NewClient constructs a new client with the provided options (ex WithTimeout).
@@ -152,7 +139,7 @@ func (c *Client) NodeURL() string {
 type reqOption func(*http.Request)

 // do is a generic, opinionated request function to reduce boilerplate amongst the methods in this package api/client/builder.
-func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) (res []byte, header http.Header, err error) {
+func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) (res []byte, err error) {
 	ctx, span := trace.StartSpan(ctx, "builder.client.do")
 	defer func() {
 		tracing.AnnotateError(span, err)
@@ -168,6 +155,10 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 	if err != nil {
 		return
 	}
+	if method == http.MethodPost {
+		req.Header.Set("Content-Type", api.JsonMediaType)
+	}
+	req.Header.Set("Accept", api.JsonMediaType)
 	req.Header.Add("User-Agent", version.BuildData())
 	for _, o := range opts {
 		o(req)
@@ -196,7 +187,6 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 		err = errors.Wrap(err, "error reading http response body from builder server")
 		return
 	}
-	header = r.Header
 	return
 }

@@ -226,145 +216,64 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 	if err != nil {
 		return nil, err
 	}
-	var getOpts reqOption
-	if c.sszEnabled {
-		getOpts = func(r *http.Request) {
-			r.Header.Set("Accept", api.OctetStreamMediaType)
-		}
-	} else {
-		getOpts = func(r *http.Request) {
-			r.Header.Set("Accept", api.JsonMediaType)
-		}
-	}
-	data, header, err := c.do(ctx, http.MethodGet, path, nil, getOpts)
+	hb, err := c.do(ctx, http.MethodGet, path, nil)
 	if err != nil {
-		return nil, errors.Wrap(err, "error getting header from builder server")
+		return nil, err
+	}
+	v := &VersionResponse{}
+	if err := json.Unmarshal(hb, v); err != nil {
+		return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
 	}

-	bid, err := c.parseHeaderResponse(data, header)
+	ver, err := version.FromString(strings.ToLower(v.Version))
 	if err != nil {
-		return nil, errors.Wrapf(
-			err,
-			"error rendering exec header template with slot=%d, parentHash=%#x, pubkey=%#x",
-			slot,
-			parentHash,
-			pubkey,
-		)
+		return nil, errors.Wrap(err, fmt.Sprintf("unsupported header version %s", strings.ToLower(v.Version)))
 	}
-	return bid, nil
-}
-
-func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid, error) {
-	var versionHeader string
-	if c.sszEnabled || header.Get(api.VersionHeader) != "" {
-		versionHeader = header.Get(api.VersionHeader)
-	} else {
-		// If we don't have a version header, attempt to parse JSON for version
-		v := &VersionResponse{}
-		if err := json.Unmarshal(data, v); err != nil {
-			return nil, errors.Wrap(
-				err,
-				"error unmarshaling builder GetHeader response",
-			)
-		}
-		versionHeader = strings.ToLower(v.Version)
-	}
-
-	ver, err := version.FromString(versionHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("unsupported header version %s", versionHeader))
-	}
-
 	if ver >= version.Electra {
-		return c.parseHeaderElectra(data)
+		hr := &ExecHeaderResponseElectra{}
+		if err := json.Unmarshal(hb, hr); err != nil {
+			return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
+		}
+		p, err := hr.ToProto()
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not extract proto message from header")
+		}
+		return WrappedSignedBuilderBidElectra(p)
 	}
 	if ver >= version.Deneb {
-		return c.parseHeaderDeneb(data)
+		hr := &ExecHeaderResponseDeneb{}
+		if err := json.Unmarshal(hb, hr); err != nil {
+			return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
+		}
+		p, err := hr.ToProto()
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not extract proto message from header")
+		}
+		return WrappedSignedBuilderBidDeneb(p)
 	}
 	if ver >= version.Capella {
-		return c.parseHeaderCapella(data)
+		hr := &ExecHeaderResponseCapella{}
+		if err := json.Unmarshal(hb, hr); err != nil {
+			return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
+		}
+		p, err := hr.ToProto()
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not extract proto message from header")
+		}
+		return WrappedSignedBuilderBidCapella(p)
 	}
 	if ver >= version.Bellatrix {
-		return c.parseHeaderBellatrix(data)
-	}
-
-	return nil, fmt.Errorf("unsupported header version %s", versionHeader)
-}
-
-func (c *Client) parseHeaderElectra(data []byte) (SignedBid, error) {
-	if c.sszEnabled {
-		sb := &ethpb.SignedBuilderBidElectra{}
-		if err := sb.UnmarshalSSZ(data); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal SignedBuilderBidElectra SSZ")
+		hr := &ExecHeaderResponse{}
+		if err := json.Unmarshal(hb, hr); err != nil {
+			return nil, errors.Wrapf(err, "error unmarshaling the builder GetHeader response, using slot=%d, parentHash=%#x, pubkey=%#x", slot, parentHash, pubkey)
 		}
-		return WrappedSignedBuilderBidElectra(sb)
-	}
-	hr := &ExecHeaderResponseElectra{}
-	if err := json.Unmarshal(data, hr); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal ExecHeaderResponseElectra JSON")
-	}
-	p, err := hr.ToProto()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert ExecHeaderResponseElectra to proto")
-	}
-	return WrappedSignedBuilderBidElectra(p)
-}
-
-func (c *Client) parseHeaderDeneb(data []byte) (SignedBid, error) {
-	if c.sszEnabled {
-		sb := &ethpb.SignedBuilderBidDeneb{}
-		if err := sb.UnmarshalSSZ(data); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal SignedBuilderBidDeneb SSZ")
+		p, err := hr.ToProto()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not extract proto message from header")
 		}
-		return WrappedSignedBuilderBidDeneb(sb)
+		return WrappedSignedBuilderBid(p)
 	}
-	hr := &ExecHeaderResponseDeneb{}
-	if err := json.Unmarshal(data, hr); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal ExecHeaderResponseDeneb JSON")
-	}
-	p, err := hr.ToProto()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert ExecHeaderResponseDeneb to proto")
-	}
-	return WrappedSignedBuilderBidDeneb(p)
-}
-
-func (c *Client) parseHeaderCapella(data []byte) (SignedBid, error) {
-	if c.sszEnabled {
-		sb := &ethpb.SignedBuilderBidCapella{}
-		if err := sb.UnmarshalSSZ(data); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal SignedBuilderBidCapella SSZ")
-		}
-		return WrappedSignedBuilderBidCapella(sb)
-	}
-	hr := &ExecHeaderResponseCapella{}
-	if err := json.Unmarshal(data, hr); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal ExecHeaderResponseCapella JSON")
-	}
-	p, err := hr.ToProto()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert ExecHeaderResponseCapella to proto")
-	}
-	return WrappedSignedBuilderBidCapella(p)
-}
-
-func (c *Client) parseHeaderBellatrix(data []byte) (SignedBid, error) {
-	if c.sszEnabled {
-		sb := &ethpb.SignedBuilderBid{}
-		if err := sb.UnmarshalSSZ(data); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal SignedBuilderBid SSZ")
-		}
-		return WrappedSignedBuilderBid(sb)
-	}
-	hr := &ExecHeaderResponse{}
-	if err := json.Unmarshal(data, hr); err != nil {
-		return nil, errors.Wrap(err, "could not unmarshal ExecHeaderResponse JSON")
-	}
-	p, err := hr.ToProto()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert ExecHeaderResponse to proto")
-	}
-	return WrappedSignedBuilderBid(p)
+	return nil, fmt.Errorf("unsupported header version %s", strings.ToLower(v.Version))
 }

 // RegisterValidator encodes the SignedValidatorRegistrationV1 message to json (including hex-encoding the byte
@@ -379,243 +288,70 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 		tracing.AnnotateError(span, err)
 		return err
 	}
-
-	var (
-		body     []byte
-		err      error
-		postOpts reqOption
-	)
-	if c.sszEnabled {
-		postOpts = func(r *http.Request) {
-			r.Header.Set("Content-Type", api.OctetStreamMediaType)
-			r.Header.Set("Accept", api.OctetStreamMediaType)
-		}
-		body, err = sszValidatorRegisterRequest(svr)
-		if err != nil {
-			err := errors.Wrap(err, "error ssz encoding the SignedValidatorRegistration value body in RegisterValidator")
-			tracing.AnnotateError(span, err)
-			return err
-		}
-	} else {
-		postOpts = func(r *http.Request) {
-			r.Header.Set("Content-Type", api.JsonMediaType)
-			r.Header.Set("Accept", api.JsonMediaType)
-		}
-		body, err = jsonValidatorRegisterRequest(svr)
-		if err != nil {
-			err := errors.Wrap(err, "error json encoding the SignedValidatorRegistration value body in RegisterValidator")
-			tracing.AnnotateError(span, err)
-			return err
-		}
-	}
-
-	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), postOpts); err != nil {
-		return errors.Wrap(err, "do")
-	}
-	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
-	return nil
-}
-
-func jsonValidatorRegisterRequest(svr []*ethpb.SignedValidatorRegistrationV1) ([]byte, error) {
 	vs := make([]*structs.SignedValidatorRegistration, len(svr))
 	for i := 0; i < len(svr); i++ {
 		vs[i] = structs.SignedValidatorRegistrationFromConsensus(svr[i])
 	}
 	body, err := json.Marshal(vs)
 	if err != nil {
-		return nil, err
+		err := errors.Wrap(err, "error encoding the SignedValidatorRegistration value body in RegisterValidator")
+		tracing.AnnotateError(span, err)
+		return err
 	}
-	return body, nil
-}

-func sszValidatorRegisterRequest(svr []*ethpb.SignedValidatorRegistrationV1) ([]byte, error) {
-	if uint64(len(svr)) > params.BeaconConfig().ValidatorRegistryLimit {
-		return nil, errors.Wrap(errMalformedRequest, "validator registry limit exceeded")
+	_, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body))
+	if err != nil {
+		return err
 	}
-	ssz := make([]byte, vrSize*len(svr))
-	for i, vr := range svr {
-		sszrep, err := vr.MarshalSSZ()
-		if err != nil {
-			return nil, errors.Wrap(err, "failed to marshal validator registry ssz")
-		}
-		copy(ssz[i*vrSize:(i+1)*vrSize], sszrep)
-	}
-	return ssz, nil
+	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
+	return nil
 }

 var errResponseVersionMismatch = errors.New("builder API response uses a different version than requested in " + api.VersionHeader + " header")

-func getVersionsBlockToPayload(blockVersion int) (int, error) {
-	if blockVersion >= version.Deneb {
-		return version.Deneb, nil
-	}
-	if blockVersion == version.Capella {
-		return version.Capella, nil
-	}
-	if blockVersion == version.Bellatrix {
-		return version.Bellatrix, nil
-	}
-	return 0, errors.Wrapf(errVersionUnsupported, "block version %d", blockVersion)
-}
-
 // SubmitBlindedBlock calls the builder API endpoint that binds the validator to the builder and submits the block.
 // The response is the full execution payload used to create the blinded block.
 func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
-	body, postOpts, err := c.buildBlindedBlockRequest(sb)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	// post the blinded block - the execution payload response should contain the unblinded payload, along with the
-	// blobs bundle if it is post deneb.
-	data, header, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), postOpts)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
-	}
-
-	ver, err := c.checkBlockVersion(data, header)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	expectedPayloadVer, err := getVersionsBlockToPayload(sb.Version())
-	if err != nil {
-		return nil, nil, err
-	}
-	gotPayloadVer, err := getVersionsBlockToPayload(ver)
-	if err != nil {
-		return nil, nil, err
-	}
-	if expectedPayloadVer != gotPayloadVer {
-		return nil, nil, errors.Wrapf(errResponseVersionMismatch, "expected payload version %d, got %d", expectedPayloadVer, gotPayloadVer)
-	}
-
-	ed, blobs, err := c.parseBlindedBlockResponse(data, ver)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return ed, blobs, nil
-}
-
-func (c *Client) checkBlockVersion(respBytes []byte, header http.Header) (int, error) {
-	var versionHeader string
-	if c.sszEnabled {
-		versionHeader = strings.ToLower(header.Get(api.VersionHeader))
-	} else {
-		// fallback to JSON-based version extraction
-		v := &VersionResponse{}
-		if err := json.Unmarshal(respBytes, v); err != nil {
-			return 0, errors.Wrapf(err, "error unmarshaling JSON version fallback")
-		}
-		versionHeader = strings.ToLower(v.Version)
-	}
-
-	ver, err := version.FromString(versionHeader)
-	if err != nil {
-		return 0, errors.Wrapf(err, "unsupported header version %s", versionHeader)
-	}
-
-	return ver, nil
-}
-
-// Helper: build request body for SubmitBlindedBlock
-func (c *Client) buildBlindedBlockRequest(sb interfaces.ReadOnlySignedBeaconBlock) ([]byte, reqOption, error) {
 	if !sb.IsBlinded() {
 		return nil, nil, errNotBlinded
 	}

-	if c.sszEnabled {
-		body, err := sb.MarshalSSZ()
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "could not marshal SSZ for blinded block")
-		}
-		opt := func(r *http.Request) {
-			r.Header.Set(api.VersionHeader, version.String(sb.Version()))
-			r.Header.Set("Content-Type", api.OctetStreamMediaType)
-			r.Header.Set("Accept", api.OctetStreamMediaType)
-		}
-		return body, opt, nil
-	}
-
+	// massage the proto struct type data into the api response type.
 	mj, err := structs.SignedBeaconBlockMessageJsoner(sb)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "error generating blinded beacon block post request")
 	}
+
 	body, err := json.Marshal(mj)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "error marshaling blinded block to JSON")
+		return nil, nil, errors.Wrap(err, "error marshaling blinded block post request to json")
 	}
-	opt := func(r *http.Request) {
-		r.Header.Set(api.VersionHeader, version.String(sb.Version()))
+	postOpts := func(r *http.Request) {
+		r.Header.Add("Eth-Consensus-Version", version.String(sb.Version()))
 		r.Header.Set("Content-Type", api.JsonMediaType)
 		r.Header.Set("Accept", api.JsonMediaType)
 	}
-	return body, opt, nil
-}
-
-// Helper: parse the response returned by SubmitBlindedBlock
-func (c *Client) parseBlindedBlockResponse(
-	respBytes []byte,
-	forkVersion int,
-) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
-	if c.sszEnabled {
-		return c.parseBlindedBlockResponseSSZ(respBytes, forkVersion)
+	// post the blinded block - the execution payload response should contain the unblinded payload, along with the
+	// blobs bundle if it is post deneb.
+	rb, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), postOpts)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
 	}
-	return c.parseBlindedBlockResponseJSON(respBytes, forkVersion)
-}
-
-func (c *Client) parseBlindedBlockResponseSSZ(
-	respBytes []byte,
-	forkVersion int,
-) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
-	if forkVersion >= version.Deneb {
-		payloadAndBlobs := &v1.ExecutionPayloadDenebAndBlobsBundle{}
-		if err := payloadAndBlobs.UnmarshalSSZ(respBytes); err != nil {
-			return nil, nil, errors.Wrap(err, "unable to unmarshal ExecutionPayloadDenebAndBlobsBundle SSZ")
-		}
-		ed, err := blocks.NewWrappedExecutionData(payloadAndBlobs.Payload)
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "unable to wrap execution data for %s", version.String(forkVersion))
-		}
-		return ed, payloadAndBlobs.BlobsBundle, nil
-	} else if forkVersion >= version.Capella {
-		payload := &v1.ExecutionPayloadCapella{}
-		if err := payload.UnmarshalSSZ(respBytes); err != nil {
-			return nil, nil, errors.Wrap(err, "unable to unmarshal ExecutionPayloadCapella SSZ")
-		}
-		ed, err := blocks.NewWrappedExecutionData(payload)
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "unable to wrap execution data for %s", version.String(forkVersion))
-		}
-		return ed, nil, nil
-	} else if forkVersion >= version.Bellatrix {
-		payload := &v1.ExecutionPayload{}
-		if err := payload.UnmarshalSSZ(respBytes); err != nil {
-			return nil, nil, errors.Wrap(err, "unable to unmarshal ExecutionPayload SSZ")
-		}
-		ed, err := blocks.NewWrappedExecutionData(payload)
-		if err != nil {
-			return nil, nil, errors.Wrapf(err, "unable to wrap execution data for %s", version.String(forkVersion))
-		}
-		return ed, nil, nil
-	} else {
-		return nil, nil, fmt.Errorf("unsupported header version %s", version.String(forkVersion))
-	}
-}
-
-func (c *Client) parseBlindedBlockResponseJSON(
-	respBytes []byte,
-	forkVersion int,
-) (interfaces.ExecutionData, *v1.BlobsBundle, error) {
+	// ExecutionPayloadResponse parses just the outer container and the Value key, enabling it to use the .Value
+	// key to determine which underlying data type to use to finish the unmarshaling.
 	ep := &ExecutionPayloadResponse{}
-	if err := json.Unmarshal(respBytes, ep); err != nil {
-		return nil, nil, errors.Wrap(err, "error unmarshaling ExecutionPayloadResponse")
+	if err := json.Unmarshal(rb, ep); err != nil {
+		return nil, nil, errors.Wrap(err, "error unmarshaling the builder ExecutionPayloadResponse")
 	}
+	if strings.ToLower(ep.Version) != version.String(sb.Version()) {
+		return nil, nil, errors.Wrapf(errResponseVersionMismatch, "req=%s, recv=%s", strings.ToLower(ep.Version), version.String(sb.Version()))
+	}
+	// This parses the rest of the response and returns the inner data field.
 	pp, err := ep.ParsePayload()
 	if err != nil {
-		return nil, nil, errors.Wrapf(err, "failed to parse payload with version=%s", ep.Version)
+		return nil, nil, errors.Wrapf(err, "failed to parse execution payload from builder with version=%s", ep.Version)
 	}
+	// Get the payload as a proto.Message so it can be wrapped as an execution payload interface.
 	pb, err := pp.PayloadProto()
 	if err != nil {
 		return nil, nil, err
@@ -624,13 +360,11 @@ func (c *Client) parseBlindedBlockResponseJSON(
 	if err != nil {
 		return nil, nil, err
 	}
-
-	// Check if it contains blobs
 	bb, ok := pp.(BlobBundler)
 	if ok {
 		bbpb, err := bb.BundleProto()
 		if err != nil {
-			return nil, nil, errors.Wrapf(err, "failed to extract blobs bundle from version=%s", ep.Version)
+			return nil, nil, errors.Wrapf(err, "failed to extract blobs bundle from builder response with version=%s", ep.Version)
 		}
 		return ed, bbpb, nil
 	}
@@ -641,10 +375,7 @@ func (c *Client) parseBlindedBlockResponseJSON(
 // response, and an error response may have an error message. This method will return a nil value for error in the
 // happy path, and an error with information about the server response body for a non-200 response.
 func (c *Client) Status(ctx context.Context) error {
-	getOpts := func(r *http.Request) {
-		r.Header.Set("Accept", api.JsonMediaType)
-	}
-	_, _, err := c.do(ctx, http.MethodGet, getStatus, nil, getOpts)
+	_, err := c.do(ctx, http.MethodGet, getStatus, nil)
 	return err
 }

@@ -659,18 +390,6 @@ func non200Err(response *http.Response) error {
 	}
 	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
 	switch response.StatusCode {
-	case http.StatusUnsupportedMediaType:
-		log.WithError(ErrUnsupportedMediaType).Debug(msg)
-		if jsonErr := json.Unmarshal(bodyBytes, &errMessage); jsonErr != nil {
-			return errors.Wrap(jsonErr, "unable to read response body")
-		}
-		return errors.Wrap(ErrUnsupportedMediaType, errMessage.Message)
-	case http.StatusNotAcceptable:
-		log.WithError(ErrNotAcceptable).Debug(msg)
-		if jsonErr := json.Unmarshal(bodyBytes, &errMessage); jsonErr != nil {
-			return errors.Wrap(jsonErr, "unable to read response body")
-		}
-		return errors.Wrap(ErrNotAcceptable, errMessage.Message)
 	case http.StatusNoContent:
 		log.WithError(ErrNoContent).Debug(msg)
 		return ErrNoContent
--- a/api/client/builder/client_test.go
+++ b/api/client/builder/client_test.go
@@ -8,6 +8,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"testing"

 	"github.com/prysmaticlabs/go-bitfield"
@@ -87,84 +88,39 @@ func TestClient_RegisterValidator(t *testing.T) {
 	ctx := context.Background()
 	expectedBody := `[{"message":{"fee_recipient":"0x0000000000000000000000000000000000000000","gas_limit":"23","timestamp":"42","pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}]`
 	expectedPath := "/eth/v1/builder/validators"
-	t.Run("JSON success", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
-				body, err := io.ReadAll(r.Body)
-				defer func() {
-					require.NoError(t, r.Body.Close())
-				}()
-				require.NoError(t, err)
-				require.Equal(t, expectedBody, string(body))
-				require.Equal(t, expectedPath, r.URL.Path)
-				require.Equal(t, http.MethodPost, r.Method)
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewBuffer(nil)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:      hc,
-			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-		}
-		reg := &eth.SignedValidatorRegistrationV1{
-			Message: &eth.ValidatorRegistrationV1{
-				FeeRecipient: ezDecode(t, params.BeaconConfig().EthBurnAddressHex),
-				GasLimit:     23,
-				Timestamp:    42,
-				Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
-			},
-			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-		}
-		require.NoError(t, c.RegisterValidator(ctx, []*eth.SignedValidatorRegistrationV1{reg}))
-	})
-	t.Run("SSZ success", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				body, err := io.ReadAll(r.Body)
-				defer func() {
-					require.NoError(t, r.Body.Close())
-				}()
-				require.NoError(t, err)
-				request := &eth.SignedValidatorRegistrationV1{}
-				itemBytes := body[:request.SizeSSZ()]
-				require.NoError(t, request.UnmarshalSSZ(itemBytes))
-				jsRequest := structs.SignedValidatorRegistrationFromConsensus(request)
-				js, err := json.Marshal([]*structs.SignedValidatorRegistration{jsRequest})
-				require.NoError(t, err)
-
-				require.Equal(t, expectedBody, string(js))
-				require.Equal(t, expectedPath, r.URL.Path)
-				require.Equal(t, http.MethodPost, r.Method)
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewBuffer(nil)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		reg := &eth.SignedValidatorRegistrationV1{
-			Message: &eth.ValidatorRegistrationV1{
-				FeeRecipient: ezDecode(t, params.BeaconConfig().EthBurnAddressHex),
-				GasLimit:     23,
-				Timestamp:    42,
-				Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
-			},
-			Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-		}
-		require.NoError(t, c.RegisterValidator(ctx, []*eth.SignedValidatorRegistrationV1{reg}))
-	})
+	hc := &http.Client{
+		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
+			require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
+			require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
+			body, err := io.ReadAll(r.Body)
+			defer func() {
+				require.NoError(t, r.Body.Close())
+			}()
+			require.NoError(t, err)
+			require.Equal(t, expectedBody, string(body))
+			require.Equal(t, expectedPath, r.URL.Path)
+			require.Equal(t, http.MethodPost, r.Method)
+			return &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBuffer(nil)),
+				Request:    r.Clone(ctx),
+			}, nil
+		}),
+	}
+	c := &Client{
+		hc:      hc,
+		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
+	}
+	reg := &eth.SignedValidatorRegistrationV1{
+		Message: &eth.ValidatorRegistrationV1{
+			FeeRecipient: ezDecode(t, params.BeaconConfig().EthBurnAddressHex),
+			GasLimit:     23,
+			Timestamp:    42,
+			Pubkey:       ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
+		},
+		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
+	}
+	require.NoError(t, c.RegisterValidator(ctx, []*eth.SignedValidatorRegistrationV1{reg}))
 }

 func TestClient_GetHeader(t *testing.T) {
@@ -220,7 +176,6 @@ func TestClient_GetHeader(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, expectedPath, r.URL.Path)
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				return &http.Response{
 					StatusCode: http.StatusOK,
 					Body:       io.NopCloser(bytes.NewBufferString(testExampleHeaderResponse)),
@@ -252,56 +207,9 @@ func TestClient_GetHeader(t *testing.T) {
 		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
 		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
 	})
-	t.Run("bellatrix ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				require.Equal(t, expectedPath, r.URL.Path)
-				epr := &ExecHeaderResponse{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponse), epr))
-				pro, err := epr.ToProto()
-				require.NoError(t, err)
-				ssz, err := pro.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "bellatrix")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-		require.NoError(t, err)
-		expectedSig := ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505")
-		require.Equal(t, true, bytes.Equal(expectedSig, h.Signature()))
-		expectedTxRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-		bid, err := h.Message()
-		require.NoError(t, err)
-		bidHeader, err := bid.Header()
-		require.NoError(t, err)
-		withdrawalsRoot, err := bidHeader.TransactionsRoot()
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(expectedTxRoot, withdrawalsRoot))
-		require.Equal(t, uint64(1), bidHeader.GasUsed())
-		// this matches the value in the testExampleHeaderResponse
-		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
-		value, err := stringToUint256(bidStr)
-		require.NoError(t, err)
-		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
-		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
-	})
 	t.Run("capella", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				require.Equal(t, expectedPath, r.URL.Path)
 				return &http.Response{
 					StatusCode: http.StatusOK,
@@ -330,52 +238,9 @@ func TestClient_GetHeader(t *testing.T) {
 		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
 		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
 	})
-	t.Run("capella ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				require.Equal(t, expectedPath, r.URL.Path)
-				epr := &ExecHeaderResponseCapella{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponseCapella), epr))
-				pro, err := epr.ToProto()
-				require.NoError(t, err)
-				ssz, err := pro.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "capella")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-		require.NoError(t, err)
-		expectedWithdrawalsRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-		bid, err := h.Message()
-		require.NoError(t, err)
-		bidHeader, err := bid.Header()
-		require.NoError(t, err)
-		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
-		value, err := stringToUint256(bidStr)
-		require.NoError(t, err)
-		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
-		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
-	})
 	t.Run("deneb", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				require.Equal(t, expectedPath, r.URL.Path)
 				return &http.Response{
 					StatusCode: http.StatusOK,
@@ -412,56 +277,6 @@ func TestClient_GetHeader(t *testing.T) {
 			require.Equal(t, len(kcgCommitments[i]) == 48, true)
 		}
 	})
-	t.Run("deneb ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				require.Equal(t, expectedPath, r.URL.Path)
-				epr := &ExecHeaderResponseDeneb{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponseDeneb), epr))
-				pro, err := epr.ToProto()
-				require.NoError(t, err)
-				ssz, err := pro.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "deneb")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-		require.NoError(t, err)
-		expectedWithdrawalsRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-		bid, err := h.Message()
-		require.NoError(t, err)
-		bidHeader, err := bid.Header()
-		require.NoError(t, err)
-		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-
-		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
-		value, err := stringToUint256(bidStr)
-		require.NoError(t, err)
-		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
-		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
-		dbid, ok := bid.(builderBidDeneb)
-		require.Equal(t, true, ok)
-		kcgCommitments := dbid.BlobKzgCommitments()
-		require.Equal(t, len(kcgCommitments) > 0, true)
-		for i := range kcgCommitments {
-			require.Equal(t, len(kcgCommitments[i]) == 48, true)
-		}
-	})
 	t.Run("deneb, too many kzg commitments", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -478,12 +293,11 @@ func TestClient_GetHeader(t *testing.T) {
 			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
 		}
 		_, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-		require.ErrorContains(t, "could not convert ExecHeaderResponseDeneb to proto: too many blob commitments: 7", err)
+		require.ErrorContains(t, "could not extract proto message from header: too many blob commitments: 7", err)
 	})
 	t.Run("electra", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				require.Equal(t, expectedPath, r.URL.Path)
 				return &http.Response{
 					StatusCode: http.StatusOK,
@@ -524,61 +338,6 @@ func TestClient_GetHeader(t *testing.T) {
 		require.Equal(t, 1, len(requests.Withdrawals))
 		require.Equal(t, 1, len(requests.Consolidations))

-	})
-	t.Run("electra ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				require.Equal(t, expectedPath, r.URL.Path)
-				epr := &ExecHeaderResponseElectra{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponseElectra), epr))
-				pro, err := epr.ToProto()
-				require.NoError(t, err)
-				ssz, err := pro.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "electra")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		h, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-		require.NoError(t, err)
-		expectedWithdrawalsRoot := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-		bid, err := h.Message()
-		require.NoError(t, err)
-		bidHeader, err := bid.Header()
-		require.NoError(t, err)
-		withdrawalsRoot, err := bidHeader.WithdrawalsRoot()
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(expectedWithdrawalsRoot, withdrawalsRoot))
-
-		bidStr := "652312848583266388373324160190187140051835877600158453279131187530910662656"
-		value, err := stringToUint256(bidStr)
-		require.NoError(t, err)
-		require.Equal(t, 0, value.Int.Cmp(primitives.WeiToBigInt(bid.Value())))
-		require.Equal(t, bidStr, primitives.WeiToBigInt(bid.Value()).String())
-		ebid, ok := bid.(builderBidElectra)
-		require.Equal(t, true, ok)
-		kcgCommitments := ebid.BlobKzgCommitments()
-		require.Equal(t, len(kcgCommitments) > 0, true)
-		for i := range kcgCommitments {
-			require.Equal(t, len(kcgCommitments[i]) == 48, true)
-		}
-		requests := ebid.ExecutionRequests()
-		require.Equal(t, 1, len(requests.Deposits))
-		require.Equal(t, 1, len(requests.Withdrawals))
-		require.Equal(t, 1, len(requests.Consolidations))
-
 	})
 	t.Run("unsupported version", func(t *testing.T) {
 		hc := &http.Client{
@@ -631,51 +390,11 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		require.Equal(t, fmt.Sprintf("%#x", bfpg.SSZBytes()), fmt.Sprintf("%#x", ep.BaseFeePerGas()))
 		require.Equal(t, uint64(1), ep.GasLimit())
 	})
-	t.Run("bellatrix ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "bellatrix", r.Header.Get(api.VersionHeader))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				epr := &ExecutionPayloadResponse{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), epr))
-				ep := &ExecutionPayload{}
-				require.NoError(t, json.Unmarshal(epr.Data, ep))
-				pro, err := ep.ToProto()
-				require.NoError(t, err)
-				ssz, err := pro.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "bellatrix")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		ep, _, err := c.SubmitBlindedBlock(ctx, sbbb)
-		require.NoError(t, err)
-		require.Equal(t, true, bytes.Equal(ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"), ep.ParentHash()))
-		bfpg, err := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
-		require.NoError(t, err)
-		require.Equal(t, fmt.Sprintf("%#x", bfpg.SSZBytes()), fmt.Sprintf("%#x", ep.BaseFeePerGas()))
-		require.Equal(t, uint64(1), ep.GasLimit())
-	})
 	t.Run("capella", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "capella", r.Header.Get(api.VersionHeader))
+				require.Equal(t, "capella", r.Header.Get("Eth-Consensus-Version"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				return &http.Response{
@@ -701,54 +420,12 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 	})
-	t.Run("capella ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "capella", r.Header.Get(api.VersionHeader))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				epr := &ExecutionPayloadResponse{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadCapella), epr))
-				ep := &ExecutionPayloadCapella{}
-				require.NoError(t, json.Unmarshal(epr.Data, ep))
-				pro, err := ep.ToProto()
-				require.NoError(t, err)
-				ssz, err := pro.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "capella")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		sbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockCapella(t))
-		require.NoError(t, err)
-		ep, _, err := c.SubmitBlindedBlock(ctx, sbb)
-		require.NoError(t, err)
-		withdrawals, err := ep.Withdrawals()
-		require.NoError(t, err)
-		require.Equal(t, 1, len(withdrawals))
-		assert.Equal(t, uint64(1), withdrawals[0].Index)
-		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
-		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
-		assert.Equal(t, uint64(1), withdrawals[0].Amount)
-	})
 	t.Run("deneb", func(t *testing.T) {
 		test := testSignedBlindedBeaconBlockDeneb(t)
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "deneb", r.Header.Get(api.VersionHeader))
+				require.Equal(t, "deneb", r.Header.Get("Eth-Consensus-Version"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
 				var req structs.SignedBlindedBeaconBlockDeneb
@@ -783,140 +460,6 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 		require.NotNil(t, blobBundle)
 	})
-	t.Run("deneb ssz", func(t *testing.T) {
-		test := testSignedBlindedBeaconBlockDeneb(t)
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "deneb", r.Header.Get(api.VersionHeader))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				epr := &ExecPayloadResponseDeneb{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadDeneb), epr))
-				pro, blob, err := epr.ToProto()
-				require.NoError(t, err)
-				combined := &v1.ExecutionPayloadDenebAndBlobsBundle{
-					Payload:     pro,
-					BlobsBundle: blob,
-				}
-				ssz, err := combined.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "deneb")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		sbb, err := blocks.NewSignedBeaconBlock(test)
-		require.NoError(t, err)
-
-		ep, blobBundle, err := c.SubmitBlindedBlock(ctx, sbb)
-		require.NoError(t, err)
-		withdrawals, err := ep.Withdrawals()
-		require.NoError(t, err)
-		require.Equal(t, 1, len(withdrawals))
-		assert.Equal(t, uint64(1), withdrawals[0].Index)
-		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
-		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
-		assert.Equal(t, uint64(1), withdrawals[0].Amount)
-		require.NotNil(t, blobBundle)
-	})
-	t.Run("electra", func(t *testing.T) {
-		test := testSignedBlindedBeaconBlockElectra(t)
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "electra", r.Header.Get(api.VersionHeader))
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
-				var req structs.SignedBlindedBeaconBlockElectra
-				err := json.NewDecoder(r.Body).Decode(&req)
-				require.NoError(t, err)
-				block, err := req.ToConsensus()
-				require.NoError(t, err)
-				require.DeepEqual(t, block, test)
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Body:       io.NopCloser(bytes.NewBufferString(testExampleExecutionPayloadDeneb)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:      hc,
-			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-		}
-
-		sbb, err := blocks.NewSignedBeaconBlock(test)
-		require.NoError(t, err)
-
-		ep, blobBundle, err := c.SubmitBlindedBlock(ctx, sbb)
-		require.NoError(t, err)
-		withdrawals, err := ep.Withdrawals()
-		require.NoError(t, err)
-		require.Equal(t, 1, len(withdrawals))
-		assert.Equal(t, uint64(1), withdrawals[0].Index)
-		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
-		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
-		assert.Equal(t, uint64(1), withdrawals[0].Amount)
-		require.NotNil(t, blobBundle)
-	})
-	t.Run("electra ssz", func(t *testing.T) {
-		test := testSignedBlindedBeaconBlockElectra(t)
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "electra", r.Header.Get(api.VersionHeader))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
-				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
-				epr := &ExecPayloadResponseDeneb{}
-				require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadDeneb), epr))
-				pro, blob, err := epr.ToProto()
-				require.NoError(t, err)
-				combined := &v1.ExecutionPayloadDenebAndBlobsBundle{
-					Payload:     pro,
-					BlobsBundle: blob,
-				}
-				ssz, err := combined.MarshalSSZ()
-				require.NoError(t, err)
-				header := http.Header{}
-				header.Set(api.VersionHeader, "electra")
-				return &http.Response{
-					StatusCode: http.StatusOK,
-					Header:     header,
-					Body:       io.NopCloser(bytes.NewBuffer(ssz)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		sbb, err := blocks.NewSignedBeaconBlock(test)
-		require.NoError(t, err)
-
-		ep, blobBundle, err := c.SubmitBlindedBlock(ctx, sbb)
-		require.NoError(t, err)
-		withdrawals, err := ep.Withdrawals()
-		require.NoError(t, err)
-		require.Equal(t, 1, len(withdrawals))
-		assert.Equal(t, uint64(1), withdrawals[0].Index)
-		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
-		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
-		assert.Equal(t, uint64(1), withdrawals[0].Amount)
-		require.NotNil(t, blobBundle)
-	})
 	t.Run("mismatched versions, expected bellatrix got capella", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
@@ -1043,13 +586,7 @@ func testSignedBlindedBeaconBlockBellatrix(t *testing.T) *eth.SignedBlindedBeaco
 				},
 				Deposits: []*eth.Deposit{
 					{
-						Proof: func() [][]byte {
-							b := make([][]byte, 33)
-							for i := range b {
-								b[i] = ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-							}
-							return b
-						}(),
+						Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
 						Data: &eth.Deposit_Data{
 							PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
 							WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
@@ -1068,8 +605,8 @@ func testSignedBlindedBeaconBlockBellatrix(t *testing.T) *eth.SignedBlindedBeaco
 					},
 				},
 				SyncAggregate: &eth.SyncAggregate{
-					SyncCommitteeSignature: make([]byte, 96),
-					SyncCommitteeBits:      make(bitfield.Bitvector512, 64),
+					SyncCommitteeSignature: make([]byte, 48),
+					SyncCommitteeBits:      bitfield.Bitvector512{0x01},
 				},
 				ExecutionPayloadHeader: &v1.ExecutionPayloadHeader{
 					ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
@@ -1083,7 +620,7 @@ func testSignedBlindedBeaconBlockBellatrix(t *testing.T) *eth.SignedBlindedBeaco
 					GasUsed:          1,
 					Timestamp:        1,
 					ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BaseFeePerGas:    ezDecode(t, "0x4523128485832663883733241601901871400518358776001584532791311875"),
+					BaseFeePerGas:    []byte(strconv.FormatUint(1, 10)),
 					BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
 					TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
 				},
@@ -1191,13 +728,7 @@ func testSignedBlindedBeaconBlockCapella(t *testing.T) *eth.SignedBlindedBeaconB
 				},
 				Deposits: []*eth.Deposit{
 					{
-						Proof: func() [][]byte {
-							b := make([][]byte, 33)
-							for i := range b {
-								b[i] = ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-							}
-							return b
-						}(),
+						Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
 						Data: &eth.Deposit_Data{
 							PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
 							WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
@@ -1216,8 +747,8 @@ func testSignedBlindedBeaconBlockCapella(t *testing.T) *eth.SignedBlindedBeaconB
 					},
 				},
 				SyncAggregate: &eth.SyncAggregate{
-					SyncCommitteeSignature: make([]byte, 96),
-					SyncCommitteeBits:      make(bitfield.Bitvector512, 64),
+					SyncCommitteeSignature: make([]byte, 48),
+					SyncCommitteeBits:      bitfield.Bitvector512{0x01},
 				},
 				ExecutionPayloadHeader: &v1.ExecutionPayloadHeaderCapella{
 					ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
@@ -1231,7 +762,7 @@ func testSignedBlindedBeaconBlockCapella(t *testing.T) *eth.SignedBlindedBeaconB
 					GasUsed:          1,
 					Timestamp:        1,
 					ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BaseFeePerGas:    ezDecode(t, "0x4523128485832663883733241601901871400518358776001584532791311875"),
+					BaseFeePerGas:    []byte(strconv.FormatUint(1, 10)),
 					BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
 					TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
 					WithdrawalsRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
@@ -1344,13 +875,7 @@ func testSignedBlindedBeaconBlockDeneb(t *testing.T) *eth.SignedBlindedBeaconBlo
 				},
 				Deposits: []*eth.Deposit{
 					{
-						Proof: func() [][]byte {
-							b := make([][]byte, 33)
-							for i := range b {
-								b[i] = ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-							}
-							return b
-						}(),
+						Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
 						Data: &eth.Deposit_Data{
 							PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
 							WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
@@ -1397,163 +922,6 @@ func testSignedBlindedBeaconBlockDeneb(t *testing.T) *eth.SignedBlindedBeaconBlo
 	}
 }

-func testSignedBlindedBeaconBlockElectra(t *testing.T) *eth.SignedBlindedBeaconBlockElectra {
-	basebytes, err := bytesutil.Uint256ToSSZBytes("14074904626401341155369551180448584754667373453244490859944217516317499064576")
-	if err != nil {
-		log.Error(err)
-	}
-	return &eth.SignedBlindedBeaconBlockElectra{
-		Message: &eth.BlindedBeaconBlockElectra{
-			Slot:          1,
-			ProposerIndex: 1,
-			ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-			Body: &eth.BlindedBeaconBlockBodyElectra{
-				RandaoReveal: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-				Eth1Data: &eth.Eth1Data{
-					DepositRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					DepositCount: 1,
-					BlockHash:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				},
-				Graffiti: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-				ProposerSlashings: []*eth.ProposerSlashing{
-					{
-						Header_1: &eth.SignedBeaconBlockHeader{
-							Header: &eth.BeaconBlockHeader{
-								Slot:          1,
-								ProposerIndex: 1,
-								ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-						Header_2: &eth.SignedBeaconBlockHeader{
-							Header: &eth.BeaconBlockHeader{
-								Slot:          1,
-								ProposerIndex: 1,
-								ParentRoot:    ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								StateRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								BodyRoot:      ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-					},
-				},
-				AttesterSlashings: []*eth.AttesterSlashingElectra{
-					{
-						Attestation_1: &eth.IndexedAttestationElectra{
-							AttestingIndices: []uint64{1},
-							Data: &eth.AttestationData{
-								Slot:            1,
-								CommitteeIndex:  1,
-								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								Source: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-								Target: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-						Attestation_2: &eth.IndexedAttestationElectra{
-							AttestingIndices: []uint64{1},
-							Data: &eth.AttestationData{
-								Slot:            1,
-								CommitteeIndex:  1,
-								BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								Source: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-								Target: &eth.Checkpoint{
-									Epoch: 1,
-									Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-								},
-							},
-							Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-					},
-				},
-				Attestations: []*eth.AttestationElectra{
-					{
-						AggregationBits: bitfield.Bitlist{0x01},
-						Data: &eth.AttestationData{
-							Slot:            1,
-							CommitteeIndex:  1,
-							BeaconBlockRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							Source: &eth.Checkpoint{
-								Epoch: 1,
-								Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-							Target: &eth.Checkpoint{
-								Epoch: 1,
-								Root:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							},
-						},
-						CommitteeBits: make(bitfield.Bitvector64, 8),
-						Signature:     ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-					},
-				},
-				Deposits: []*eth.Deposit{
-					{
-						Proof: func() [][]byte {
-							b := make([][]byte, 33)
-							for i := range b {
-								b[i] = ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-							}
-							return b
-						}(),
-						Data: &eth.Deposit_Data{
-							PublicKey:             ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"),
-							WithdrawalCredentials: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-							Amount:                1,
-							Signature:             ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-						},
-					},
-				},
-				VoluntaryExits: []*eth.SignedVoluntaryExit{
-					{
-						Exit: &eth.VoluntaryExit{
-							Epoch:          1,
-							ValidatorIndex: 1,
-						},
-						Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-					},
-				},
-				SyncAggregate: &eth.SyncAggregate{
-					SyncCommitteeSignature: make([]byte, 96),
-					SyncCommitteeBits:      ezDecode(t, "0x6451e9f951ebf05edc01de67e593484b672877054f055903ff0df1a1a945cf30ca26bb4d4b154f94a1bc776bcf5d0efb3603e1f9b8ee2499ccdcfe2a18cef458"),
-				},
-				ExecutionRequests: &v1.ExecutionRequests{},
-				ExecutionPayloadHeader: &v1.ExecutionPayloadHeaderDeneb{
-					ParentHash:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					FeeRecipient:     ezDecode(t, "0xabcf8e0d4e9587369b2301d0790347320302cc09"),
-					StateRoot:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					ReceiptsRoot:     ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					LogsBloom:        ezDecode(t, "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
-					PrevRandao:       ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BlockNumber:      1,
-					GasLimit:         1,
-					GasUsed:          1,
-					Timestamp:        1,
-					ExtraData:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BaseFeePerGas:    basebytes,
-					BlockHash:        ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					TransactionsRoot: ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					WithdrawalsRoot:  ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"),
-					BlobGasUsed:      1,
-					ExcessBlobGas:    2,
-				},
-			},
-		},
-		Signature: ezDecode(t, "0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"),
-	}
-}
-
 func TestRequestLogger(t *testing.T) {
 	wo := WithObserver(&requestLogger{})
 	c, err := NewClient("localhost:3500", wo)
--- a/api/client/builder/errors.go
+++ b/api/client/builder/errors.go
@@ -15,9 +15,3 @@ var ErrBadRequest = errors.Wrap(ErrNotOK, "recv 400 BadRequest response from API
 // ErrNoContent specifically means that a '204 - No Content' response was received from the API.
 // Typically, a 204 is a success but in this case for the Header API means No header is available
 var ErrNoContent = errors.New("recv 204 no content response from API, No header is available")
-
-// ErrUnsupportedMediaType specifically means that a '415 - Unsupported Media Type' was received from the API.
-var ErrUnsupportedMediaType = errors.Wrap(ErrNotOK, "The media type in \"Content-Type\" header is unsupported, and the request has been rejected. This occurs when a HTTP request supplies a payload in a content-type that the server is not able to handle.")
-
-// ErrNotAcceptable specifically means that a '406 - Not Acceptable' was received from the API.
-var ErrNotAcceptable = errors.Wrap(ErrNotOK, "The accept header value is not acceptable")
--- a/api/server/structs/endpoints_beacon.go
+++ b/api/server/structs/endpoints_beacon.go
@@ -78,8 +78,8 @@ type GetBlockHeaderResponse struct {
 }

 type GetValidatorsRequest struct {
-	Ids      []string `json:"ids,omitempty"`
-	Statuses []string `json:"statuses,omitempty"`
+	Ids      []string `json:"ids"`
+	Statuses []string `json:"statuses"`
 }

 type GetValidatorsResponse struct {
--- a/api/server/structs/endpoints_events.go
+++ b/api/server/structs/endpoints_events.go
@@ -20,11 +20,6 @@ type BlockEvent struct {
 	ExecutionOptimistic bool   `json:"execution_optimistic"`
 }

-type BlockGossipEvent struct {
-	Slot  string `json:"slot"`
-	Block string `json:"block"`
-}
-
 type AggregatedAttEventSource struct {
 	Aggregate *Attestation `json:"aggregate"`
 }
--- a/async/event/subscription.go
+++ b/async/event/subscription.go
@@ -154,7 +154,7 @@ retry:
 				continue retry
 			}
 			if sub == nil {
-				panic("event: ResubscribeFunc returned nil subscription and no error") // lint:nopanic -- This should never happen.
+				panic("event: ResubscribeFunc returned nil subscription and no error")
 			}
 			return sub
 		case <-s.unsub:
--- a/beacon-chain/blockchain/BUILD.bazel
+++ b/beacon-chain/blockchain/BUILD.bazel
@@ -12,6 +12,7 @@ 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",
@@ -97,7 +98,6 @@ 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",
    ],
@@ -128,7 +128,6 @@ go_test(
        "receive_block_test.go",
        "service_norace_test.go",
        "service_test.go",
-        "setup_forkchoice_test.go",
        "setup_test.go",
        "weak_subjectivity_checks_test.go",
    ],
@@ -157,7 +156,6 @@ 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",
@@ -189,7 +187,6 @@ 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",
--- a/beacon-chain/blockchain/chain_info_test.go
+++ b/beacon-chain/blockchain/chain_info_test.go
@@ -582,7 +582,6 @@ func TestService_IsOptimisticForRoot_StateSummaryRecovered(t *testing.T) {
 	br, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	util.SaveBlock(t, context.Background(), beaconDB, b)
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, [32]byte{}))
 	_, err = c.IsOptimisticForRoot(ctx, br)
 	assert.NoError(t, err)
 	summ, err := beaconDB.StateSummary(ctx, br)
--- a/beacon-chain/blockchain/execution_engine.go
+++ b/beacon-chain/blockchain/execution_engine.go
@@ -69,13 +69,10 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 		SafeBlockHash:      justifiedHash[:],
 		FinalizedBlockHash: finalizedHash[:],
 	}
-	if len(fcs.HeadBlockHash) != 32 || [32]byte(fcs.HeadBlockHash) == [32]byte{} {
-		log.Error("Sending nil head block hash to execution engine")
-		return nil, nil
-	}
 	if arg.attributes == nil {
 		arg.attributes = payloadattribute.EmptyWithVersion(headBlk.Version())
 	}
+	go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), arg)
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, arg.attributes)
 	if err != nil {
 		switch {
@@ -162,7 +159,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 		log.WithFields(logrus.Fields{
 			"blockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(arg.headRoot[:])),
 			"headSlot":  headBlk.Slot(),
-			"nextSlot":  nextSlot,
 			"payloadID": fmt.Sprintf("%#x", bytesutil.Trunc(payloadID[:])),
 		}).Info("Forkchoice updated with payload attributes for proposal")
 		s.cfg.PayloadIDCache.Set(nextSlot, arg.headRoot, pId)
@@ -170,19 +166,40 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 		log.WithFields(logrus.Fields{
 			"blockHash": fmt.Sprintf("%#x", headPayload.BlockHash()),
 			"slot":      headBlk.Slot(),
-			"nextSlot":  nextSlot,
 		}).Error("Received nil payload ID on VALID engine response")
 	}
 	return payloadID, nil
 }

-func firePayloadAttributesEvent(_ context.Context, f event.SubscriberSender, nextSlot primitives.Slot) {
-	// the fcu args have differing amounts of completeness based on the code path,
-	// and there is work we only want to do if a client is actually listening to the events beacon api endpoint.
-	// temporary solution: just fire a blank event and fill in the details in the api handler.
+func firePayloadAttributesEvent(ctx context.Context, f event.SubscriberSender, cfg *fcuConfig) {
+	pidx, err := helpers.BeaconProposerIndex(ctx, cfg.headState)
+	if err != nil {
+		log.WithError(err).
+			WithField("head_root", cfg.headRoot[:]).
+			Error("Could not get proposer index for PayloadAttributes event")
+		return
+	}
+	evd := payloadattribute.EventData{
+		ProposerIndex:   pidx,
+		ProposalSlot:    cfg.headState.Slot(),
+		ParentBlockRoot: cfg.headRoot[:],
+		Attributer:      cfg.attributes,
+		HeadRoot:        cfg.headRoot,
+		HeadState:       cfg.headState,
+		HeadBlock:       cfg.headBlock,
+	}
+	if cfg.headBlock != nil && !cfg.headBlock.IsNil() {
+		headPayload, err := cfg.headBlock.Block().Body().Execution()
+		if err != nil {
+			log.WithError(err).Error("Could not get execution payload for head block")
+			return
+		}
+		evd.ParentBlockHash = headPayload.BlockHash()
+		evd.ParentBlockNumber = headPayload.BlockNumber()
+	}
 	f.Send(&feed.Event{
 		Type: statefeed.PayloadAttributes,
-		Data: payloadattribute.EventData{ProposalSlot: nextSlot},
+		Data: evd,
 	})
 }

--- a/beacon-chain/blockchain/forkchoice_update_execution.go
+++ b/beacon-chain/blockchain/forkchoice_update_execution.go
@@ -102,10 +102,10 @@ func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuCo
 		log.WithError(err).Error("could not save head")
 	}

-	go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), s.CurrentSlot()+1)
-
 	// Only need to prune attestations from pool if the head has changed.
-	s.pruneAttsFromPool(s.ctx, args.headState, args.headBlock)
+	if err := s.pruneAttsFromPool(args.headBlock); err != nil {
+		log.WithError(err).Error("could not prune attestations from pool")
+	}
 	return nil
 }

--- a/beacon-chain/blockchain/holeskyhack.go
+++ b/beacon-chain/blockchain/holeskyhack.go
@@ -0,0 +1,21 @@
+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)
+}
--- a/beacon-chain/blockchain/mock_test.go
+++ b/beacon-chain/blockchain/mock_test.go
@@ -3,7 +3,6 @@ package blockchain
 import (
 	"testing"

-	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	testDB "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
@@ -19,7 +18,6 @@ func testServiceOptsWithDB(t *testing.T) []Option {
 		WithStateGen(stategen.New(beaconDB, fcs)),
 		WithForkChoiceStore(fcs),
 		WithClockSynchronizer(cs),
-		WithStateNotifier(&mock.MockStateNotifier{RecordEvents: true}),
 	}
 }

--- a/beacon-chain/blockchain/process_attestation.go
+++ b/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.AttestationCommitteesFromState(ctx, baseState, a)
+	committees, err := helpers.AttestationCommittees(ctx, baseState, a)
 	if err != nil {
 		return err
 	}
--- a/beacon-chain/blockchain/process_block.go
+++ b/beacon-chain/blockchain/process_block.go
@@ -6,7 +6,6 @@ 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"
@@ -16,7 +15,6 @@ 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"
@@ -175,6 +173,9 @@ 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
@@ -370,7 +371,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.AttestationCommitteesFromState(ctx, st, a)
+		committees, err := helpers.AttestationCommittees(ctx, st, a)
 		if err != nil {
 			return err
 		}
@@ -421,98 +422,24 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 	return nil
 }

-// 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) {
-	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")
-		}
-	}
-}
-
-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:
+// 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 {
-			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")
+			if err := s.cfg.AttestationCache.DeleteCovered(att); err != nil {
+				return errors.Wrap(err, "could not delete attestation")
 			}
-		} else if !a.IsAggregated() {
-			if err = s.cfg.AttPool.DeleteUnaggregatedAttestation(a); err != nil {
-				return errors.Wrap(err, "could not delete unaggregated 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
 			}
-		} 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
 }

@@ -726,9 +653,13 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	attribute := s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
 	// return early if we are not proposing next slot
 	if attribute.IsEmpty() {
-		// notifyForkchoiceUpdate fires the payload attribute event. But in this case, we won't
-		// call notifyForkchoiceUpdate, so the event is fired here.
-		go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), s.CurrentSlot()+1)
+		fcuArgs := &fcuConfig{
+			headState:  headState,
+			headRoot:   headRoot,
+			headBlock:  nil,
+			attributes: attribute,
+		}
+		go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), fcuArgs)
 		return
 	}

--- a/beacon-chain/blockchain/process_block_test.go
+++ b/beacon-chain/blockchain/process_block_test.go
@@ -12,10 +12,8 @@ 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"
@@ -27,7 +25,6 @@ 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"
@@ -48,94 +45,6 @@ import (
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )

-func Test_pruneAttsFromPool_Electra(t *testing.T) {
-	ctx := context.Background()
-	logHook := logTest.NewGlobal()
-
-	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{0b10000000, 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.SaveUnaggregatedAttestation(att1))
-	require.NoError(t, s.cfg.AttPool.SaveAggregatedAttestation(att2))
-	require.NoError(t, s.cfg.AttPool.SaveAggregatedAttestation(att3))
-
-	cb = primitives.NewAttestationCommitteeBits()
-	cb.SetBitAt(0, true)
-	cb.SetBitAt(1, true)
-	onChainAtt := &ethpb.AttestationElectra{
-		AggregationBits: bitfield.Bitlist{0b10000000, 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))
-
-	s.pruneAttsFromPool(ctx, st, rob)
-	require.LogsDoNotContain(t, logHook, "Could not prune attestations")
-
-	attsInPool := s.cfg.AttPool.UnaggregatedAttestations()
-	assert.Equal(t, 0, len(attsInPool))
-	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
@@ -912,8 +821,6 @@ func TestInsertFinalizedDeposits_MultipleFinalizedRoutines(t *testing.T) {
 }

 func TestRemoveBlockAttestationsInPool(t *testing.T) {
-	logHook := logTest.NewGlobal()
-
 	genesis, keys := util.DeterministicGenesisState(t, 64)
 	b, err := util.GenerateFullBlock(genesis, keys, util.DefaultBlockGenConfig(), 1)
 	assert.NoError(t, err)
@@ -933,8 +840,7 @@ func TestRemoveBlockAttestationsInPool(t *testing.T) {
 	require.NoError(t, service.cfg.AttPool.SaveAggregatedAttestations(atts))
 	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
-	service.pruneAttsFromPool(context.Background(), nil /* state not needed pre-Electra */, wsb)
-	require.LogsDoNotContain(t, logHook, "Could not prune attestations")
+	require.NoError(t, service.pruneAttsFromPool(wsb))
 	require.Equal(t, 0, service.cfg.AttPool.AggregatedAttestationCount())
 }

@@ -1990,7 +1896,6 @@ func TestNoViableHead_Reboot(t *testing.T) {

 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, genesisRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot), "Could not save genesis state")

 	for i := 1; i < 6; i++ {
 		driftGenesisTime(service, int64(i), 0)
@@ -2125,7 +2030,6 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, jroot))
 	service.cfg.ForkChoiceStore.SetBalancesByRooter(service.cfg.StateGen.ActiveNonSlashedBalancesByRoot)
 	require.NoError(t, service.StartFromSavedState(genesisState))
-	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))

 	// Forkchoice has the genesisRoot loaded at startup
 	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.cfg.ForkChoiceStore.CachedHeadRoot()))
@@ -2135,7 +2039,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
--- a/beacon-chain/blockchain/receive_block.go
+++ b/beacon-chain/blockchain/receive_block.go
@@ -64,6 +64,11 @@ 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")
@@ -547,7 +552,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.AttestationCommitteesFromState(ctx, preState, att)
+		committees, err := helpers.AttestationCommittees(ctx, preState, att)
 		if err != nil {
 			log.WithError(err).Error("Could not get attestation committees")
 			return
--- a/beacon-chain/blockchain/service.go
+++ b/beacon-chain/blockchain/service.go
@@ -340,14 +340,17 @@ func (s *Service) initializeHead(ctx context.Context, st state.BeaconState) erro
 			return errors.Wrap(err, "could not get head state")
 		}
 	}
-	if err := s.setHead(&head{root, blk, st, blk.Block().Slot(), false}); err != nil {
-		return errors.Wrap(err, "could not set head")
-	}
 	log.WithFields(logrus.Fields{
 		"root": fmt.Sprintf("%#x", root),
 		"slot": blk.Block().Slot(),
 	}).Info("Initialized head block from DB")
-	return nil
+	return errors.Wrap(s.setHead(&head{
+		root,
+		blk,
+		st,
+		blk.Block().Slot(),
+		false,
+	}), "could not set head")
 }

 func (s *Service) startFromExecutionChain() error {
--- a/beacon-chain/blockchain/setup_forchoice.go
+++ b/beacon-chain/blockchain/setup_forchoice.go
@@ -59,6 +59,20 @@ func (s *Service) setupForkchoiceTree(st state.BeaconState) error {
 	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.setHead(&head{
+		fRoot,
+		fBlk,
+		st,
+		fBlk.Block().Slot(),
+		false,
+	}); err != nil {
+		return errors.Wrap(err, "could not set head")
+	}
+
 	if headRoot == fRoot {
 		return nil
 	}
@@ -96,9 +110,7 @@ func (s *Service) buildForkchoiceChain(ctx context.Context, head interfaces.Read
 			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. An alternative would be to hook during the
-		// block processing pipeline when setting the head state, to compute the right states for the justified
-		// checkpoint.
+		// 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 {
--- a/beacon-chain/blockchain/setup_forkchoice_test.go
+++ b/beacon-chain/blockchain/setup_forkchoice_test.go
@@ -1,128 +0,0 @@
-package blockchain
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"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/primitives"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-)
-
-func Test_startupHeadRoot(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
-	hook := logTest.NewGlobal()
-	cp := service.FinalizedCheckpt()
-	require.DeepEqual(t, cp.Root, params.BeaconConfig().ZeroHash[:])
-	gr := [32]byte{'r', 'o', 'o', 't'}
-	service.originBlockRoot = gr
-	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, gr))
-	t.Run("start from finalized", func(t *testing.T) {
-		require.Equal(t, service.startupHeadRoot(), gr)
-	})
-	t.Run("head requested, error path", func(t *testing.T) {
-		resetCfg := features.InitWithReset(&features.Flags{
-			ForceHead: "head",
-		})
-		defer resetCfg()
-		require.Equal(t, service.startupHeadRoot(), gr)
-		require.LogsContain(t, hook, "could not get head block root, starting with finalized block as head")
-	})
-
-	st, _ := util.DeterministicGenesisState(t, 64)
-	hr := [32]byte{'h', 'e', 'a', 'd'}
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, hr), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, hr), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, hr))
-
-	t.Run("start from head", func(t *testing.T) {
-		resetCfg := features.InitWithReset(&features.Flags{
-			ForceHead: "head",
-		})
-		defer resetCfg()
-		require.Equal(t, service.startupHeadRoot(), hr)
-	})
-}
-
-func Test_setupForkchoiceTree_Finalized(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
-
-	st, _ := util.DeterministicGenesisState(t, 64)
-	stateRoot, err := st.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-
-	require.NoError(t, service.saveGenesisData(ctx, st))
-
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
-	parentRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}))
-	require.NoError(t, service.cfg.BeaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}))
-	require.NoError(t, service.setupForkchoiceTree(st))
-	require.Equal(t, 1, service.cfg.ForkChoiceStore.NodeCount())
-}
-
-func Test_setupForkchoiceTree_Head(t *testing.T) {
-	service, tr := minimalTestService(t)
-	ctx := tr.ctx
-	resetCfg := features.InitWithReset(&features.Flags{
-		ForceHead: "head",
-	})
-	defer resetCfg()
-
-	genesisState, keys := util.DeterministicGenesisState(t, 64)
-	stateRoot, err := genesisState.HashTreeRoot(ctx)
-	require.NoError(t, err, "Could not hash genesis state")
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
-	require.NoError(t, err)
-	genesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err, "Could not get signing root")
-	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
-
-	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, genesisRoot), "Could not save genesis state")
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, genesisRoot), "Could not save genesis state")
-
-	st, err := service.HeadState(ctx)
-	require.NoError(t, err)
-	b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(1))
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	root, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	preState, err := service.getBlockPreState(ctx, wsb.Block())
-	require.NoError(t, err)
-	postState, err := service.validateStateTransition(ctx, preState, wsb)
-	require.NoError(t, err)
-	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
-
-	b, err = util.GenerateFullBlock(postState, keys, util.DefaultBlockGenConfig(), primitives.Slot(2))
-	require.NoError(t, err)
-	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-	root, err = b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, preState))
-
-	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, root))
-	cp := service.FinalizedCheckpt()
-	fRoot := service.ensureRootNotZeros([32]byte(cp.Root))
-	require.NotEqual(t, fRoot, root)
-	require.Equal(t, root, service.startupHeadRoot())
-	require.NoError(t, service.setupForkchoiceTree(st))
-	require.Equal(t, 2, service.cfg.ForkChoiceStore.NodeCount())
-}
--- a/beacon-chain/builder/BUILD.bazel
+++ b/beacon-chain/builder/BUILD.bazel
@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
    name = "go_default_library",
    srcs = [
-        "log.go",
        "metric.go",
        "option.go",
        "service.go",
--- a/beacon-chain/builder/log.go
+++ b/beacon-chain/builder/log.go
@@ -1,5 +0,0 @@
-package builder
-
-import "github.com/sirupsen/logrus"
-
-var log = logrus.WithField("prefix", "builder")
--- a/beacon-chain/builder/option.go
+++ b/beacon-chain/builder/option.go
@@ -14,16 +14,10 @@ type Option func(s *Service) error
 // FlagOptions for builder service flag configurations.
 func FlagOptions(c *cli.Context) ([]Option, error) {
 	endpoint := c.String(flags.MevRelayEndpoint.Name)
-	sszEnabled := c.Bool(flags.EnableBuilderSSZ.Name)
 	var client *builder.Client
 	if endpoint != "" {
-		var opts []builder.ClientOpt
-		if sszEnabled {
-			log.Info("Using APIs with SSZ enabled")
-			opts = append(opts, builder.WithSSZ())
-		}
 		var err error
-		client, err = builder.NewClient(endpoint, opts...)
+		client, err = builder.NewClient(endpoint)
 		if err != nil {
 			return nil, err
 		}
--- a/beacon-chain/builder/service.go
+++ b/beacon-chain/builder/service.go
@@ -17,6 +17,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	log "github.com/sirupsen/logrus"
 )

 // ErrNoBuilder is used when builder endpoint is not configured.
--- a/beacon-chain/cache/tracked_validators.go
+++ b/beacon-chain/cache/tracked_validators.go
@@ -25,7 +25,7 @@ type (
 	}

 	TrackedValidatorsCache struct {
-		trackedValidators *cache.Cache
+		trackedValidators cache.Cache
 	}
 )

@@ -50,7 +50,7 @@ var (
 // NewTrackedValidatorsCache creates a new cache for tracking validators.
 func NewTrackedValidatorsCache() *TrackedValidatorsCache {
 	return &TrackedValidatorsCache{
-		trackedValidators: cache.New(defaultExpiration, cleanupInterval),
+		trackedValidators: *cache.New(defaultExpiration, cleanupInterval),
 	}
 }

--- a/beacon-chain/core/altair/attestation.go
+++ b/beacon-chain/core/altair/attestation.go
@@ -66,7 +66,7 @@ func ProcessAttestationNoVerifySignature(
 	if err != nil {
 		return nil, err
 	}
-	committees, err := helpers.AttestationCommitteesFromState(ctx, beaconState, att)
+	committees, err := helpers.AttestationCommittees(ctx, beaconState, att)
 	if err != nil {
 		return nil, err
 	}
--- a/beacon-chain/core/blocks/signature.go
+++ b/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.AttestationCommitteesFromState(ctx, beaconState, a)
+		committees, err := helpers.AttestationCommittees(ctx, beaconState, a)
 		if err != nil {
 			return nil, err
 		}
--- a/beacon-chain/core/electra/BUILD.bazel
+++ b/beacon-chain/core/electra/BUILD.bazel
@@ -79,6 +79,7 @@ go_test(
        "//consensus-types/blocks:go_default_library",
        "//consensus-types/primitives:go_default_library",
        "//crypto/bls:go_default_library",
+        "//crypto/bls/common:go_default_library",
        "//encoding/bytesutil:go_default_library",
        "//proto/engine/v1:go_default_library",
        "//proto/prysm/v1alpha1:go_default_library",
--- a/beacon-chain/core/electra/deposits_test.go
+++ b/beacon-chain/core/electra/deposits_test.go
@@ -14,6 +14,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
+	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -195,7 +196,7 @@ func TestProcessPendingDeposits(t *testing.T) {
 			},
 		},
 		{
-			name: "process excess balance as a topup",
+			name: "process excess balance that uses a point to infinity signature, processed as a topup",
 			state: func() state.BeaconState {
 				excessBalance := uint64(100)
 				st := stateWithActiveBalanceETH(t, 32)
@@ -208,6 +209,7 @@ func TestProcessPendingDeposits(t *testing.T) {
 				validators[0].PublicKey = sk.PublicKey().Marshal()
 				validators[0].WithdrawalCredentials = wc
 				dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
+				dep.Signature = common.InfiniteSignature[:]
 				require.NoError(t, st.SetValidators(validators))
 				require.NoError(t, st.SetPendingDeposits([]*eth.PendingDeposit{dep}))
 				return st
@@ -556,6 +558,7 @@ func TestApplyPendingDeposit_TopUp(t *testing.T) {
 	validators[0].PublicKey = sk.PublicKey().Marshal()
 	validators[0].WithdrawalCredentials = wc
 	dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
+	dep.Signature = common.InfiniteSignature[:]
 	require.NoError(t, st.SetValidators(validators))

 	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
--- a/beacon-chain/core/feed/operation/BUILD.bazel
+++ b/beacon-chain/core/feed/operation/BUILD.bazel
@@ -11,7 +11,6 @@ go_library(
    deps = [
        "//async/event:go_default_library",
        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
        "//proto/prysm/v1alpha1:go_default_library",
    ],
 )
--- a/beacon-chain/core/feed/operation/events.go
+++ b/beacon-chain/core/feed/operation/events.go
@@ -3,7 +3,6 @@ package operation

 import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )

@@ -36,9 +35,6 @@ const (

 	// SingleAttReceived is sent after a single attestation object is received from gossip or rpc
 	SingleAttReceived = 9
-
-	// BlockGossipReceived is sent after a block has been received from gossip or API that passes validation rules.
-	BlockGossipReceived = 10
 )

 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -89,9 +85,3 @@ type AttesterSlashingReceivedData struct {
 type SingleAttReceivedData struct {
 	Attestation ethpb.Att
 }
-
-// BlockGossipReceivedData is the data sent with BlockGossipReceived events.
-type BlockGossipReceivedData struct {
-	// SignedBlock is the block that was received.
-	SignedBlock interfaces.ReadOnlySignedBeaconBlock
-}
--- a/beacon-chain/core/helpers/beacon_committee.go
+++ b/beacon-chain/core/helpers/beacon_committee.go
@@ -30,13 +30,6 @@ 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
@@ -66,48 +59,21 @@ func SlotCommitteeCount(activeValidatorCount uint64) uint64 {
 	return committeesPerSlot
 }

-// 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) {
+// 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) {
 	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 := committeeFunc(ctx, st, att.GetData().Slot, primitives.CommitteeIndex(ci))
+			committee, err := BeaconCommitteeFromState(ctx, st, att.GetData().Slot, primitives.CommitteeIndex(ci))
 			if err != nil {
 				return nil, err
 			}
 			committees[i] = committee
 		}
 	} else {
-		committee, err := committeeFunc(ctx, st, att.GetData().Slot, att.GetData().CommitteeIndex)
+		committee, err := BeaconCommitteeFromState(ctx, st, att.GetData().Slot, att.GetData().CommitteeIndex)
 		if err != nil {
 			return nil, err
 		}
@@ -198,27 +164,6 @@ 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.
--- a/beacon-chain/core/helpers/beacon_committee_test.go
+++ b/beacon-chain/core/helpers/beacon_committee_test.go
@@ -729,9 +729,7 @@ func TestCommitteeIndices(t *testing.T) {
 	assert.DeepEqual(t, []primitives.CommitteeIndex{0, 1, 3}, indices)
 }

-func TestAttestationCommitteesFromState(t *testing.T) {
-	ctx := context.Background()
-
+func TestAttestationCommittees(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
 	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
@@ -747,7 +745,7 @@ func TestAttestationCommitteesFromState(t *testing.T) {

 	t.Run("pre-Electra", func(t *testing.T) {
 		att := &ethpb.Attestation{Data: &ethpb.AttestationData{CommitteeIndex: 0}}
-		committees, err := helpers.AttestationCommitteesFromState(ctx, state, att)
+		committees, err := helpers.AttestationCommittees(context.Background(), state, att)
 		require.NoError(t, err)
 		require.Equal(t, 1, len(committees))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
@@ -757,7 +755,7 @@ func TestAttestationCommitteesFromState(t *testing.T) {
 		bits.SetBitAt(0, true)
 		bits.SetBitAt(1, true)
 		att := &ethpb.AttestationElectra{CommitteeBits: bits, Data: &ethpb.AttestationData{}}
-		committees, err := helpers.AttestationCommitteesFromState(ctx, state, att)
+		committees, err := helpers.AttestationCommittees(context.Background(), state, att)
 		require.NoError(t, err)
 		require.Equal(t, 2, len(committees))
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[0])))
@@ -765,58 +763,9 @@ func TestAttestationCommitteesFromState(t *testing.T) {
 	})
 }

-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)
+func TestBeaconCommittees(t *testing.T) {
+	prevConfig := params.BeaconConfig().Copy()
+	defer params.OverrideBeaconConfig(prevConfig)
 	c := params.BeaconConfig().Copy()
 	c.MinGenesisActiveValidatorCount = 128
 	c.SlotsPerEpoch = 4
@@ -825,49 +774,15 @@ func TestBeaconCommitteesFromState(t *testing.T) {

 	state, _ := util.DeterministicGenesisState(t, 256)

-	activeCount, err := helpers.ActiveValidatorCount(ctx, state, 0)
+	activeCount, err := helpers.ActiveValidatorCount(context.Background(), state, 0)
 	require.NoError(t, err)
 	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-	committees, err := helpers.BeaconCommittees(ctx, state, 0)
+	committees, err := helpers.BeaconCommittees(context.Background(), 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(ctx, state, 0, idx)
+		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, 0, idx)
 		require.NoError(t, err)
-		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)
+		require.DeepEqual(t, committees[idx], committee)
 	}
 }
--- a/beacon-chain/db/kv/archived_point.go
+++ b/beacon-chain/db/kv/archived_point.go
@@ -35,7 +35,7 @@ func (s *Store) LastArchivedRoot(ctx context.Context) [32]byte {
 		_, blockRoot = bkt.Cursor().Last()
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
-		panic(err) // lint:nopanic -- View never returns an error.
+		panic(err)
 	}

 	return bytesutil.ToBytes32(blockRoot)
@@ -53,7 +53,7 @@ func (s *Store) ArchivedPointRoot(ctx context.Context, slot primitives.Slot) [32
 		blockRoot = bucket.Get(bytesutil.SlotToBytesBigEndian(slot))
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
-		panic(err) // lint:nopanic -- View never returns an error.
+		panic(err)
 	}

 	return bytesutil.ToBytes32(blockRoot)
@@ -69,7 +69,7 @@ func (s *Store) HasArchivedPoint(ctx context.Context, slot primitives.Slot) bool
 		exists = iBucket.Get(bytesutil.SlotToBytesBigEndian(slot)) != nil
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
-		panic(err) // lint:nopanic -- View never returns an error.
+		panic(err)
 	}
 	return exists
 }
--- a/beacon-chain/db/kv/blocks.go
+++ b/beacon-chain/db/kv/blocks.go
@@ -30,32 +30,22 @@ var errInvalidSlotRange = errors.New("invalid end slot and start slot provided")
 func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.Block")
 	defer span.End()
-	blk, err := s.getBlock(ctx, blockRoot, nil)
-	if errors.Is(err, ErrNotFound) {
-		return nil, nil
-	}
-	return blk, err
-}
-
-func (s *Store) getBlock(ctx context.Context, blockRoot [32]byte, tx *bolt.Tx) (interfaces.ReadOnlySignedBeaconBlock, error) {
+	// Return block from cache if it exists.
 	if v, ok := s.blockCache.Get(string(blockRoot[:])); v != nil && ok {
 		return v.(interfaces.ReadOnlySignedBeaconBlock), nil
 	}
-	// This method allows the caller to pass in its tx if one is already open.
-	// Or if a nil value is used, a transaction will be managed intenally.
-	if tx == nil {
-		var err error
-		tx, err = s.db.Begin(false)
-		if err != nil {
-			return nil, err
+	var blk interfaces.ReadOnlySignedBeaconBlock
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(blocksBucket)
+		enc := bkt.Get(blockRoot[:])
+		if enc == nil {
+			return nil
 		}
-		defer func() {
-			if err := tx.Rollback(); err != nil {
-				log.WithError(err).Error("could not rollback read-only getBlock transaction")
-			}
-		}()
-	}
-	return unmarshalBlock(ctx, tx.Bucket(blocksBucket).Get(blockRoot[:]))
+		var err error
+		blk, err = unmarshalBlock(ctx, enc)
+		return err
+	})
+	return blk, err
 }

 // OriginCheckpointBlockRoot returns the value written to the db in SaveOriginCheckpointBlockRoot
@@ -86,7 +76,7 @@ func (s *Store) HeadBlockRoot() ([32]byte, error) {
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(blocksBucket)
 		headRoot := bkt.Get(headBlockRootKey)
-		if len(headRoot) == 0 {
+		if headRoot == nil {
 			return errors.New("no head block root found")
 		}
 		copy(root[:], headRoot)
@@ -185,7 +175,7 @@ func (s *Store) HasBlock(ctx context.Context, blockRoot [32]byte) bool {
 		exists = bkt.Get(blockRoot[:]) != nil
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
-		panic(err) // lint:nopanic -- View never returns an error.
+		panic(err)
 	}
 	return exists
 }
@@ -239,7 +229,8 @@ func (s *Store) DeleteBlock(ctx context.Context, root [32]byte) error {
 	defer span.End()

 	if err := s.DeleteState(ctx, root); err != nil {
-		return err
+		// TODO: Find out why invalid states are in the db
+		log.WithError(err).Error("Could not delete state")
 	}

 	if err := s.deleteStateSummary(root); err != nil {
@@ -252,21 +243,6 @@ func (s *Store) DeleteBlock(ctx context.Context, root [32]byte) error {
 			return ErrDeleteJustifiedAndFinalized
 		}

-		// Look up the block to find its slot; needed to remove the slot index entry.
-		blk, err := s.getBlock(ctx, root, tx)
-		if err != nil {
-			// getBlock can return ErrNotFound, in which case we won't even try to delete it.
-			if errors.Is(err, ErrNotFound) {
-				return nil
-			}
-			return err
-		}
-		if err := s.deleteSlotIndexEntry(tx, blk.Block().Slot(), root); err != nil {
-			return err
-		}
-		if err := s.deleteMatchingParentIndex(tx, blk.Block().ParentRoot(), root); err != nil {
-			return err
-		}
 		if err := s.deleteBlock(tx, root[:]); err != nil {
 			return err
 		}
@@ -939,9 +915,6 @@ func createBlockIndicesFromFilters(ctx context.Context, f *filters.QueryFilter)

 // unmarshal block from marshaled proto beacon block bytes to versioned beacon block struct type.
 func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
-	if len(enc) == 0 {
-		return nil, errors.Wrap(ErrNotFound, "empty block bytes in db")
-	}
 	var err error
 	enc, err = snappy.Decode(nil, enc)
 	if err != nil {
@@ -1093,47 +1066,6 @@ func (s *Store) deleteBlock(tx *bolt.Tx, root []byte) error {
 	return nil
 }

-func (s *Store) deleteMatchingParentIndex(tx *bolt.Tx, parent, child [32]byte) error {
-	bkt := tx.Bucket(blockParentRootIndicesBucket)
-	if err := deleteRootIndexEntry(bkt, parent[:], child); err != nil {
-		return errors.Wrap(err, "could not delete parent root index entry")
-	}
-	return nil
-}
-
-func (s *Store) deleteSlotIndexEntry(tx *bolt.Tx, slot primitives.Slot, root [32]byte) error {
-	key := bytesutil.SlotToBytesBigEndian(slot)
-	bkt := tx.Bucket(blockSlotIndicesBucket)
-	if err := deleteRootIndexEntry(bkt, key, root); err != nil {
-		return errors.Wrap(err, "could not delete slot index entry")
-	}
-	return nil
-}
-
-func deleteRootIndexEntry(bkt *bolt.Bucket, key []byte, root [32]byte) error {
-	packed := bkt.Get(key)
-	if len(packed) == 0 {
-		return nil
-	}
-	updated, err := removeRoot(packed, root)
-	if err != nil {
-		return err
-	}
-	// Don't update the value if the root was not found.
-	if bytes.Equal(updated, packed) {
-		return nil
-	}
-	// If there are no other roots in the key, just delete it.
-	if len(updated) == 0 {
-		if err := bkt.Delete(key); err != nil {
-			return err
-		}
-		return nil
-	}
-	// Update the key with the root removed.
-	return bkt.Put(key, updated)
-}
-
 func (s *Store) deleteValidatorHashes(tx *bolt.Tx, root []byte) error {
 	ok, err := s.isStateValidatorMigrationOver()
 	if err != nil {
--- a/beacon-chain/db/kv/blocks_test.go
+++ b/beacon-chain/db/kv/blocks_test.go
@@ -196,13 +196,9 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			blockRoot, err := blk.Block().HashTreeRoot()
 			require.NoError(t, err)

-			_, err = db.getBlock(ctx, blockRoot, nil)
-			require.ErrorIs(t, err, ErrNotFound)
 			retrievedBlock, err := db.Block(ctx, blockRoot)
 			require.NoError(t, err)
 			assert.DeepEqual(t, nil, retrievedBlock, "Expected nil block")
-			_, err = db.getBlock(ctx, blockRoot, nil)
-			require.ErrorIs(t, err, ErrNotFound)

 			require.NoError(t, db.SaveBlock(ctx, blk))
 			assert.Equal(t, true, db.HasBlock(ctx, blockRoot), "Expected block to exist in the db")
@@ -218,34 +214,10 @@ func TestStore_BlocksCRUD(t *testing.T) {
 			retrievedPb, err := retrievedBlock.Proto()
 			require.NoError(t, err)
 			assert.Equal(t, true, proto.Equal(wantedPb, retrievedPb), "Wanted: %v, received: %v", wanted, retrievedBlock)
-			// Check that the block is in the slot->block index
-			found, roots, err := db.BlockRootsBySlot(ctx, blk.Block().Slot())
-			require.NoError(t, err)
-			require.Equal(t, true, found)
-			require.Equal(t, 1, len(roots))
-			require.Equal(t, blockRoot, roots[0])
-			// Delete the block, then check that it is no longer in the index.
-
-			parent := blk.Block().ParentRoot()
-			testCheckParentIndices(t, db.db, parent, true)
-			require.NoError(t, db.DeleteBlock(ctx, blockRoot))
-			require.NoError(t, err)
-			testCheckParentIndices(t, db.db, parent, false)
-			found, roots, err = db.BlockRootsBySlot(ctx, blk.Block().Slot())
-			require.NoError(t, err)
-			require.Equal(t, false, found)
-			require.Equal(t, 0, len(roots))
 		})
 	}
 }

-func testCheckParentIndices(t *testing.T, db *bolt.DB, parent [32]byte, expected bool) {
-	require.NoError(t, db.View(func(tx *bolt.Tx) error {
-		require.Equal(t, expected, tx.Bucket(blockParentRootIndicesBucket).Get(parent[:]) != nil)
-		return nil
-	}))
-}
-
 func TestStore_BlocksHandleZeroCase(t *testing.T) {
 	for _, tt := range blockTests {
 		t.Run(tt.name, func(t *testing.T) {
--- a/beacon-chain/db/kv/deposit_contract.go
+++ b/beacon-chain/db/kv/deposit_contract.go
@@ -20,7 +20,7 @@ func (s *Store) DepositContractAddress(ctx context.Context) ([]byte, error) {
 		addr = chainInfo.Get(depositContractAddressKey)
 		return nil
 	}); err != nil { // This view never returns an error, but we'll handle anyway for sanity.
-		panic(err) // lint:nopanic -- View never returns an error.
+		panic(err)
 	}
 	return addr, nil
 }
--- a/beacon-chain/db/kv/state.go
+++ b/beacon-chain/db/kv/state.go
@@ -407,7 +407,7 @@ func (s *Store) HasState(ctx context.Context, blockRoot [32]byte) bool {
 		return nil
 	})
 	if err != nil {
-		panic(err) // lint:nopanic -- View never returns an error.
+		panic(err)
 	}
 	return hasState
 }
--- a/beacon-chain/db/kv/utils.go
+++ b/beacon-chain/db/kv/utils.go
@@ -114,27 +114,3 @@ func splitRoots(b []byte) ([][32]byte, error) {
 	}
 	return rl, nil
 }
-
-func removeRoot(roots []byte, root [32]byte) ([]byte, error) {
-	if len(roots) == 0 {
-		return []byte{}, nil
-	}
-	if len(roots) == 32 && bytes.Equal(roots, root[:]) {
-		return []byte{}, nil
-	}
-	if len(roots)%32 != 0 {
-		return nil, errors.Wrapf(errMisalignedRootList, "root list len=%d", len(roots))
-	}
-
-	search := root[:]
-	for i := 0; i <= len(roots)-32; i += 32 {
-		if bytes.Equal(roots[i:i+32], search) {
-			result := make([]byte, len(roots)-32)
-			copy(result, roots[:i])
-			copy(result[i:], roots[i+32:])
-			return result, nil
-		}
-	}
-
-	return roots, nil
-}
--- a/beacon-chain/db/kv/utils_test.go
+++ b/beacon-chain/db/kv/utils_test.go
@@ -1,7 +1,6 @@
 package kv

 import (
-	"bytes"
 	"context"
 	"crypto/rand"
 	"testing"
@@ -196,85 +195,3 @@ func TestSplitRoots(t *testing.T) {
 		})
 	}
 }
-
-func tPad(p ...[]byte) []byte {
-	r := make([]byte, 32*len(p))
-	for i, b := range p {
-		copy(r[i*32:], b)
-	}
-	return r
-}
-
-func TestRemoveRoot(t *testing.T) {
-	cases := []struct {
-		name   string
-		roots  []byte
-		root   [32]byte
-		expect []byte
-		err    error
-	}{
-		{
-			name:   "empty",
-			roots:  []byte{},
-			root:   [32]byte{0xde, 0xad, 0xbe, 0xef},
-			expect: []byte{},
-		},
-		{
-			name:   "single",
-			roots:  tPad([]byte{0xde, 0xad, 0xbe, 0xef}),
-			root:   [32]byte{0xde, 0xad, 0xbe, 0xef},
-			expect: []byte{},
-		},
-		{
-			name:   "single, different",
-			roots:  tPad([]byte{0xde, 0xad, 0xbe, 0xef}),
-			root:   [32]byte{0xde, 0xad, 0xbe, 0xee},
-			expect: tPad([]byte{0xde, 0xad, 0xbe, 0xef}),
-		},
-		{
-			name:   "multi",
-			roots:  tPad([]byte{0xde, 0xad, 0xbe, 0xef}, []byte{0xac, 0x1d, 0xfa, 0xce}),
-			root:   [32]byte{0xac, 0x1d, 0xfa, 0xce},
-			expect: tPad([]byte{0xde, 0xad, 0xbe, 0xef}),
-		},
-		{
-			name:   "multi, reordered",
-			roots:  tPad([]byte{0xac, 0x1d, 0xfa, 0xce}, []byte{0xde, 0xad, 0xbe, 0xef}),
-			root:   [32]byte{0xac, 0x1d, 0xfa, 0xce},
-			expect: tPad([]byte{0xde, 0xad, 0xbe, 0xef}),
-		},
-		{
-			name:   "multi, 3",
-			roots:  tPad([]byte{0xac, 0x1d, 0xfa, 0xce}, []byte{0xbe, 0xef, 0xca, 0xb5}, []byte{0xde, 0xad, 0xbe, 0xef}),
-			root:   [32]byte{0xac, 0x1d, 0xfa, 0xce},
-			expect: tPad([]byte{0xbe, 0xef, 0xca, 0xb5}, []byte{0xde, 0xad, 0xbe, 0xef}),
-		},
-		{
-			name:   "multi, different",
-			roots:  tPad([]byte{0xde, 0xad, 0xbe, 0xef}, []byte{0xac, 0x1d, 0xfa, 0xce}),
-			root:   [32]byte{0xac, 0x1d, 0xbe, 0xa7},
-			expect: tPad([]byte{0xde, 0xad, 0xbe, 0xef}, []byte{0xac, 0x1d, 0xfa, 0xce}),
-		},
-		{
-			name:  "misaligned",
-			roots: make([]byte, 61),
-			root:  [32]byte{0xac, 0x1d, 0xbe, 0xa7},
-			err:   errMisalignedRootList,
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			before := make([]byte, len(c.roots))
-			copy(before, c.roots)
-			r, err := removeRoot(c.roots, c.root)
-			if c.err != nil {
-				require.ErrorIs(t, err, c.err)
-				return
-			}
-			require.NoError(t, err)
-			require.Equal(t, len(c.expect), len(r))
-			require.Equal(t, true, bytes.Equal(c.expect, r))
-			require.Equal(t, true, bytes.Equal(before, c.roots))
-		})
-	}
-}
--- a/beacon-chain/db/kv/validated_checkpoint.go
+++ b/beacon-chain/db/kv/validated_checkpoint.go
@@ -1,10 +1,8 @@
 package kv

 import (
-	"bytes"
 	"context"

-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
@@ -21,17 +19,7 @@ func (s *Store) LastValidatedCheckpoint(ctx context.Context) (*ethpb.Checkpoint,
 		if enc == nil {
 			var finErr error
 			checkpoint, finErr = s.FinalizedCheckpoint(ctx)
-			if finErr != nil {
-				return finErr
-			}
-			if bytes.Equal(checkpoint.Root, params.BeaconConfig().ZeroHash[:]) {
-				bkt = tx.Bucket(blocksBucket)
-				r := bkt.Get(genesisBlockRootKey)
-				if r != nil {
-					checkpoint.Root = r
-				}
-			}
-			return nil
+			return finErr
 		}
 		checkpoint = &ethpb.Checkpoint{}
 		return decode(ctx, enc, checkpoint)
--- a/beacon-chain/execution/block_cache.go
+++ b/beacon-chain/execution/block_cache.go
@@ -158,7 +158,7 @@ func trim(queue *cache.FIFO, maxSize uint64) {
 	for s := uint64(len(queue.ListKeys())); s > maxSize; s-- {
 		// #nosec G104 popProcessNoopFunc never returns an error
 		if _, err := queue.Pop(popProcessNoopFunc); err != nil { // This never returns an error, but we'll handle anyway for sanity.
-			panic(err) // lint:nopanic -- popProcessNoopFunc never returns an error.
+			panic(err)
 		}
 	}
 }
--- a/beacon-chain/execution/testing/mock_faulty_powchain.go
+++ b/beacon-chain/execution/testing/mock_faulty_powchain.go
@@ -57,7 +57,7 @@ func (*FaultyExecutionChain) ChainStartEth1Data() *ethpb.Eth1Data {
 func (*FaultyExecutionChain) PreGenesisState() state.BeaconState {
 	s, err := state_native.InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
 	if err != nil {
-		panic("could not initialize state") // lint:nopanic -- test code.
+		panic("could not initialize state")
 	}
 	return s
 }
--- a/beacon-chain/node/node.go
+++ b/beacon-chain/node/node.go
@@ -440,7 +440,7 @@ func (b *BeaconNode) Start() {
 				log.WithField("times", i-1).Info("Already shutting down, interrupt more to panic")
 			}
 		}
-		panic("Panic closing the beacon node") // lint:nopanic -- Panic is requested by user.
+		panic("Panic closing the beacon node")
 	}()

 	// Wait for stop channel to be closed.
@@ -706,7 +706,7 @@ func (b *BeaconNode) registerP2P(cliCtx *cli.Context) error {
 func (b *BeaconNode) fetchP2P() p2p.P2P {
 	var p *p2p.Service
 	if err := b.services.FetchService(&p); err != nil {
-		panic(err) // lint:nopanic -- This could panic application start if the services are misconfigured.
+		panic(err)
 	}
 	return p
 }
@@ -714,7 +714,7 @@ func (b *BeaconNode) fetchP2P() p2p.P2P {
 func (b *BeaconNode) fetchBuilderService() *builder.Service {
 	var s *builder.Service
 	if err := b.services.FetchService(&s); err != nil {
-		panic(err) // lint:nopanic -- This could panic application start if the services are misconfigured.
+		panic(err)
 	}
 	return s
 }
@@ -1018,13 +1018,13 @@ func (b *BeaconNode) registerPrometheusService(_ *cli.Context) error {
 	var additionalHandlers []prometheus.Handler
 	var p *p2p.Service
 	if err := b.services.FetchService(&p); err != nil {
-		panic(err) // lint:nopanic -- This could panic application start if the services are misconfigured.
+		panic(err)
 	}
 	additionalHandlers = append(additionalHandlers, prometheus.Handler{Path: "/p2p", Handler: p.InfoHandler})

 	var c *blockchain.Service
 	if err := b.services.FetchService(&c); err != nil {
-		panic(err) // lint:nopanic -- This could panic application start if the services are misconfigured.
+		panic(err)
 	}

 	service := prometheus.NewService(
--- a/beacon-chain/operations/attestations/kv/aggregated.go
+++ b/beacon-chain/operations/attestations/kv/aggregated.go
@@ -23,7 +23,10 @@ import (
 func (c *AttCaches) AggregateUnaggregatedAttestations(ctx context.Context) error {
 	ctx, span := trace.StartSpan(ctx, "operations.attestations.kv.AggregateUnaggregatedAttestations")
 	defer span.End()
-	unaggregatedAtts := c.UnaggregatedAttestations()
+	unaggregatedAtts, err := c.UnaggregatedAttestations()
+	if err != nil {
+		return err
+	}
 	return c.aggregateUnaggregatedAtts(ctx, unaggregatedAtts)
 }

--- a/beacon-chain/operations/attestations/kv/unaggregated.go
+++ b/beacon-chain/operations/attestations/kv/unaggregated.go
@@ -53,7 +53,7 @@ func (c *AttCaches) SaveUnaggregatedAttestations(atts []ethpb.Att) error {
 }

 // UnaggregatedAttestations returns all the unaggregated attestations in cache.
-func (c *AttCaches) UnaggregatedAttestations() []ethpb.Att {
+func (c *AttCaches) UnaggregatedAttestations() ([]ethpb.Att, error) {
 	c.unAggregateAttLock.RLock()
 	defer c.unAggregateAttLock.RUnlock()
 	unAggregatedAtts := c.unAggregatedAtt
@@ -61,14 +61,14 @@ func (c *AttCaches) UnaggregatedAttestations() []ethpb.Att {
 	for _, att := range unAggregatedAtts {
 		seen, err := c.hasSeenBit(att)
 		if err != nil {
-			log.WithError(err).Debug("Could not check if unaggregated attestation's bit has been seen. Attestation will not be returned")
+			log.WithError(err).Debug("Could not check if attestations bits have been seen")
 			continue
 		}
 		if !seen {
 			atts = append(atts, att.Clone())
 		}
 	}
-	return atts
+	return atts, nil
 }

 // UnaggregatedAttestationsBySlotIndex returns the unaggregated attestations in cache,
@@ -139,7 +139,7 @@ func (c *AttCaches) DeleteUnaggregatedAttestation(att ethpb.Att) error {
 	}

 	if err := c.insertSeenBit(att); err != nil {
-		log.WithError(err).Debug("Could not insert seen bit of unaggregated attestation. Attestation will be deleted")
+		return err
 	}

 	id, err := attestation.NewId(att, attestation.Full)
@@ -167,8 +167,9 @@ func (c *AttCaches) DeleteSeenUnaggregatedAttestations() (int, error) {
 		}
 		seen, err := c.hasSeenBit(att)
 		if err != nil {
-			log.WithError(err).Debug("Could not check if unaggregated attestation's bit has been seen. Attestation will be deleted")
-			seen = true
+			log.WithError(err).Debug("Could not check if attestations bits have been seen")
+			delete(c.unAggregatedAtt, r)
+			count++
 		}
 		if seen {
 			delete(c.unAggregatedAtt, r)
--- a/beacon-chain/operations/attestations/kv/unaggregated_test.go
+++ b/beacon-chain/operations/attestations/kv/unaggregated_test.go
@@ -17,23 +17,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )

-func TestKV_Unaggregated_UnaggregatedAttestations(t *testing.T) {
-	t.Run("not returned when hasSeenBit fails", func(t *testing.T) {
-		att := util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b101}})
-		id, err := attestation.NewId(att, attestation.Data)
-		require.NoError(t, err)
-
-		cache := NewAttCaches()
-		require.NoError(t, cache.SaveUnaggregatedAttestation(att))
-		cache.seenAtt.Delete(id.String())
-		// cache a bitlist whose length is different from the attestation bitlist's length
-		cache.seenAtt.Set(id.String(), []bitfield.Bitlist{{0b1001}}, c.DefaultExpiration)
-
-		atts := cache.UnaggregatedAttestations()
-		assert.Equal(t, 0, len(atts))
-	})
-}
-
 func TestKV_Unaggregated_SaveUnaggregatedAttestation(t *testing.T) {
 	tests := []struct {
 		name          string
@@ -168,23 +151,9 @@ func TestKV_Unaggregated_DeleteUnaggregatedAttestation(t *testing.T) {
 		for _, att := range atts {
 			assert.NoError(t, cache.DeleteUnaggregatedAttestation(att))
 		}
-		returned := cache.UnaggregatedAttestations()
-		assert.DeepEqual(t, []ethpb.Att{}, returned)
-	})
-
-	t.Run("deleted when insertSeenBit fails", func(t *testing.T) {
-		att := util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b101}})
-		id, err := attestation.NewId(att, attestation.Data)
+		returned, err := cache.UnaggregatedAttestations()
 		require.NoError(t, err)
-
-		cache := NewAttCaches()
-		require.NoError(t, cache.SaveUnaggregatedAttestation(att))
-		cache.seenAtt.Delete(id.String())
-		// cache a bitlist whose length is different from the attestation bitlist's length
-		cache.seenAtt.Set(id.String(), []bitfield.Bitlist{{0b1001}}, c.DefaultExpiration)
-
-		require.NoError(t, cache.DeleteUnaggregatedAttestation(att))
-		assert.Equal(t, 0, len(cache.unAggregatedAtt), "Attestation was not deleted")
+		assert.DeepEqual(t, []ethpb.Att{}, returned)
 	})
 }

@@ -232,10 +201,11 @@ func TestKV_Unaggregated_DeleteSeenUnaggregatedAttestations(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, 1, count)
 		assert.Equal(t, 2, cache.UnaggregatedAttestationCount())
-		returned := cache.UnaggregatedAttestations()
+		returned, err := cache.UnaggregatedAttestations()
 		sort.Slice(returned, func(i, j int) bool {
 			return bytes.Compare(returned[i].GetAggregationBits(), returned[j].GetAggregationBits()) < 0
 		})
+		require.NoError(t, err)
 		assert.DeepEqual(t, []ethpb.Att{atts[0], atts[2]}, returned)
 	})

@@ -258,26 +228,10 @@ func TestKV_Unaggregated_DeleteSeenUnaggregatedAttestations(t *testing.T) {
 		assert.NoError(t, err)
 		assert.Equal(t, 3, count)
 		assert.Equal(t, 0, cache.UnaggregatedAttestationCount())
-		returned := cache.UnaggregatedAttestations()
+		returned, err := cache.UnaggregatedAttestations()
+		require.NoError(t, err)
 		assert.DeepEqual(t, []ethpb.Att{}, returned)
 	})
-
-	t.Run("deleted when hasSeenBit fails", func(t *testing.T) {
-		att := util.HydrateAttestation(&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1}, AggregationBits: bitfield.Bitlist{0b101}})
-		id, err := attestation.NewId(att, attestation.Data)
-		require.NoError(t, err)
-
-		cache := NewAttCaches()
-		require.NoError(t, cache.SaveUnaggregatedAttestation(att))
-		cache.seenAtt.Delete(id.String())
-		// cache a bitlist whose length is different from the attestation bitlist's length
-		cache.seenAtt.Set(id.String(), []bitfield.Bitlist{{0b1001}}, c.DefaultExpiration)
-
-		count, err := cache.DeleteSeenUnaggregatedAttestations()
-		require.NoError(t, err)
-		assert.Equal(t, 1, count)
-		assert.Equal(t, 0, len(cache.unAggregatedAtt), "Attestation was not deleted")
-	})
 }

 func TestKV_Unaggregated_UnaggregatedAttestationsBySlotIndex(t *testing.T) {
--- a/beacon-chain/operations/attestations/mock/mock.go
+++ b/beacon-chain/operations/attestations/mock/mock.go
@@ -1,4 +1,3 @@
-// lint:nopanic -- Mock / test code, panic is allowed.
 package mock

 import (
@@ -80,8 +79,8 @@ func (m *PoolMock) SaveUnaggregatedAttestations(atts []ethpb.Att) error {
 }

 // UnaggregatedAttestations --
-func (m *PoolMock) UnaggregatedAttestations() []ethpb.Att {
-	return m.UnaggregatedAtts
+func (m *PoolMock) UnaggregatedAttestations() ([]ethpb.Att, error) {
+	return m.UnaggregatedAtts, nil
 }

 // UnaggregatedAttestationsBySlotIndex --
--- a/beacon-chain/operations/attestations/pool.go
+++ b/beacon-chain/operations/attestations/pool.go
@@ -26,7 +26,7 @@ type Pool interface {
 	// For unaggregated attestations.
 	SaveUnaggregatedAttestation(att ethpb.Att) error
 	SaveUnaggregatedAttestations(atts []ethpb.Att) error
-	UnaggregatedAttestations() []ethpb.Att
+	UnaggregatedAttestations() ([]ethpb.Att, error)
 	UnaggregatedAttestationsBySlotIndex(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.Attestation
 	UnaggregatedAttestationsBySlotIndexElectra(ctx context.Context, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []*ethpb.AttestationElectra
 	DeleteUnaggregatedAttestation(att ethpb.Att) error
--- a/beacon-chain/operations/attestations/prune_expired.go
+++ b/beacon-chain/operations/attestations/prune_expired.go
@@ -61,8 +61,12 @@ func (s *Service) pruneExpiredAtts() {
 	if _, err := s.cfg.Pool.DeleteSeenUnaggregatedAttestations(); err != nil {
 		log.WithError(err).Error("Cannot delete seen attestations")
 	}
-
-	for _, att := range s.cfg.Pool.UnaggregatedAttestations() {
+	unAggregatedAtts, err := s.cfg.Pool.UnaggregatedAttestations()
+	if err != nil {
+		log.WithError(err).Error("Could not get unaggregated attestations")
+		return
+	}
+	for _, att := range unAggregatedAtts {
 		if s.expired(att.GetData().Slot) {
 			if err := s.cfg.Pool.DeleteUnaggregatedAttestation(att); err != nil {
 				log.WithError(err).Error("Could not delete expired unaggregated attestation")
--- a/beacon-chain/operations/attestations/prune_expired_test.go
+++ b/beacon-chain/operations/attestations/prune_expired_test.go
@@ -54,7 +54,9 @@ func TestPruneExpired_Ticker(t *testing.T) {

 	done := make(chan struct{}, 1)
 	async.RunEvery(ctx, 500*time.Millisecond, func() {
-		for _, attestation := range s.cfg.Pool.UnaggregatedAttestations() {
+		atts, err := s.cfg.Pool.UnaggregatedAttestations()
+		require.NoError(t, err)
+		for _, attestation := range atts {
 			if attestation.GetData().Slot == 0 {
 				return
 			}
--- a/beacon-chain/operations/blstoexec/mock/mock.go
+++ b/beacon-chain/operations/blstoexec/mock/mock.go
@@ -28,10 +28,10 @@ func (m *PoolMock) InsertBLSToExecChange(change *eth.SignedBLSToExecutionChange)

 // MarkIncluded --
 func (*PoolMock) MarkIncluded(_ *eth.SignedBLSToExecutionChange) {
-	panic("implement me") // lint:nopanic -- mock / test code.
+	panic("implement me")
 }

 // ValidatorExists --
 func (*PoolMock) ValidatorExists(_ primitives.ValidatorIndex) bool {
-	panic("implement me") // lint:nopanic -- mock / test code.
+	panic("implement me")
 }
--- a/beacon-chain/operations/slashings/mock/mock.go
+++ b/beacon-chain/operations/slashings/mock/mock.go
@@ -40,10 +40,10 @@ func (*PoolMock) ConvertToElectra() {}

 // MarkIncludedAttesterSlashing --
 func (*PoolMock) MarkIncludedAttesterSlashing(_ ethpb.AttSlashing) {
-	panic("implement me") // lint:nopanic -- Test / mock code.
+	panic("implement me")
 }

 // MarkIncludedProposerSlashing --
 func (*PoolMock) MarkIncludedProposerSlashing(_ *ethpb.ProposerSlashing) {
-	panic("implement me") // lint:nopanic -- Test / mock code.
+	panic("implement me")
 }
--- a/beacon-chain/operations/voluntaryexits/mock/mock.go
+++ b/beacon-chain/operations/voluntaryexits/mock/mock.go
@@ -28,5 +28,5 @@ func (m *PoolMock) InsertVoluntaryExit(exit *eth.SignedVoluntaryExit) {

 // MarkIncluded --
 func (*PoolMock) MarkIncluded(_ *eth.SignedVoluntaryExit) {
-	panic("implement me") // lint:nopanic -- Mock / test code.
+	panic("implement me")
 }
--- a/beacon-chain/p2p/encoder/ssz.go
+++ b/beacon-chain/p2p/encoder/ssz.go
@@ -15,8 +15,9 @@ import (

 var _ NetworkEncoding = (*SszNetworkEncoder)(nil)

-// MaxPayloadSize allowed for gossip and rpc messages.
-var MaxPayloadSize = params.BeaconConfig().MaxPayloadSize // 10 Mib.
+// MaxGossipSize allowed for gossip messages.
+var MaxGossipSize = params.BeaconConfig().GossipMaxSize // 10 Mib.
+var MaxChunkSize = params.BeaconConfig().MaxChunkSize   // 10 Mib.

 // This pool defines the sync pool for our buffered snappy writers, so that they
 // can be constantly reused.
@@ -42,8 +43,8 @@ func (_ SszNetworkEncoder) EncodeGossip(w io.Writer, msg fastssz.Marshaler) (int
 	if err != nil {
 		return 0, err
 	}
-	if uint64(len(b)) > MaxPayloadSize {
-		return 0, errors.Errorf("gossip message exceeds max gossip size: %d bytes > %d bytes", len(b), MaxPayloadSize)
+	if uint64(len(b)) > MaxGossipSize {
+		return 0, errors.Errorf("gossip message exceeds max gossip size: %d bytes > %d bytes", len(b), MaxGossipSize)
 	}
 	b = snappy.Encode(nil /*dst*/, b)
 	return w.Write(b)
@@ -59,11 +60,11 @@ func (_ SszNetworkEncoder) EncodeWithMaxLength(w io.Writer, msg fastssz.Marshale
 	if err != nil {
 		return 0, err
 	}
-	if uint64(len(b)) > MaxPayloadSize {
+	if uint64(len(b)) > MaxChunkSize {
 		return 0, fmt.Errorf(
 			"size of encoded message is %d which is larger than the provided max limit of %d",
 			len(b),
-			MaxPayloadSize,
+			MaxChunkSize,
 		)
 	}
 	// write varint first
@@ -80,10 +81,7 @@ func doDecode(b []byte, to fastssz.Unmarshaler) error {

 // DecodeGossip decodes the bytes to the protobuf gossip message provided.
 func (_ SszNetworkEncoder) DecodeGossip(b []byte, to fastssz.Unmarshaler) error {
-	if uint64(len(b)) > MaxCompressedLen(MaxPayloadSize) {
-		return fmt.Errorf("gossip message exceeds maximum compressed limit: %d", MaxCompressedLen(MaxPayloadSize))
-	}
-	b, err := DecodeSnappy(b, MaxPayloadSize)
+	b, err := DecodeSnappy(b, MaxGossipSize)
 	if err != nil {
 		return err
 	}
@@ -113,11 +111,11 @@ func (e SszNetworkEncoder) DecodeWithMaxLength(r io.Reader, to fastssz.Unmarshal
 	if err != nil {
 		return err
 	}
-	if msgLen > MaxPayloadSize {
+	if msgLen > MaxChunkSize {
 		return fmt.Errorf(
 			"remaining bytes %d goes over the provided max limit of %d",
 			msgLen,
-			MaxPayloadSize,
+			MaxChunkSize,
 		)
 	}
 	msgMax, err := e.MaxLength(msgLen)
@@ -158,18 +156,6 @@ func (_ SszNetworkEncoder) MaxLength(length uint64) (int, error) {
 	return maxLen, nil
 }

-// MaxCompressedLen returns the maximum compressed size for a given payload size.
-//
-// Spec pseudocode definition:
-// def max_compressed_len(n: uint64) -> uint64:
-//
-//	# Worst-case compressed length for a given payload of size n when using snappy:
-//	# https://github.com/google/snappy/blob/32ded457c0b1fe78ceb8397632c416568d6714a0/snappy.cc#L218C1-L218C47
-//	return uint64(32 + n + n / 6)
-func MaxCompressedLen(n uint64) uint64 {
-	return 32 + n + n/6
-}
-
 // Writes a bytes value through a snappy buffered writer.
 func writeSnappyBuffer(w io.Writer, b []byte) (int, error) {
 	bufWriter := newBufferedWriter(w)
--- a/beacon-chain/p2p/encoder/ssz_test.go
+++ b/beacon-chain/p2p/encoder/ssz_test.go
@@ -555,19 +555,11 @@ func TestSszNetworkEncoder_FailsSnappyLength(t *testing.T) {
 	e := &encoder.SszNetworkEncoder{}
 	att := &ethpb.Fork{}
 	data := make([]byte, 32)
-	binary.PutUvarint(data, encoder.MaxPayloadSize+1)
+	binary.PutUvarint(data, encoder.MaxGossipSize+32)
 	err := e.DecodeGossip(data, att)
 	require.ErrorContains(t, "snappy message exceeds max size", err)
 }

-func TestSszNetworkEncoder_ExceedsMaxCompressedLimit(t *testing.T) {
-	e := &encoder.SszNetworkEncoder{}
-	att := &ethpb.Fork{}
-	data := make([]byte, encoder.MaxCompressedLen(encoder.MaxPayloadSize)+1)
-	err := e.DecodeGossip(data, att)
-	require.ErrorContains(t, "gossip message exceeds maximum compressed limit", err)
-}
-
 func testRoundTripWithLength(t *testing.T, e *encoder.SszNetworkEncoder) {
 	buf := new(bytes.Buffer)
 	msg := &ethpb.Fork{
@@ -612,28 +604,31 @@ func TestSszNetworkEncoder_EncodeWithMaxLength(t *testing.T) {
 	e := &encoder.SszNetworkEncoder{}
 	params.SetupTestConfigCleanup(t)
 	c := params.BeaconNetworkConfig()
-	encoder.MaxPayloadSize = uint64(5)
+	encoder.MaxChunkSize = uint64(5)
 	params.OverrideBeaconNetworkConfig(c)
 	_, err := e.EncodeWithMaxLength(buf, msg)
-	wanted := fmt.Sprintf("which is larger than the provided max limit of %d", encoder.MaxPayloadSize)
+	wanted := fmt.Sprintf("which is larger than the provided max limit of %d", encoder.MaxChunkSize)
 	assert.ErrorContains(t, wanted, err)
 }

 func TestSszNetworkEncoder_DecodeWithMaxLength(t *testing.T) {
 	buf := new(bytes.Buffer)
+	msg := &ethpb.Fork{
+		PreviousVersion: []byte("fooo"),
+		CurrentVersion:  []byte("barr"),
+		Epoch:           4242,
+	}
 	e := &encoder.SszNetworkEncoder{}
 	params.SetupTestConfigCleanup(t)
 	c := params.BeaconNetworkConfig()
-	maxPayloadSize := uint64(5)
-	encoder.MaxPayloadSize = maxPayloadSize
-	_, err := buf.Write(gogo.EncodeVarint(maxPayloadSize + 1))
-	require.NoError(t, err)
-	_, err = buf.Write(make([]byte, maxPayloadSize+1))
-	require.NoError(t, err)
+	maxChunkSize := uint64(5)
+	encoder.MaxChunkSize = maxChunkSize
 	params.OverrideBeaconNetworkConfig(c)
+	_, err := e.EncodeGossip(buf, msg)
+	require.NoError(t, err)
 	decoded := &ethpb.Fork{}
 	err = e.DecodeWithMaxLength(buf, decoded)
-	wanted := fmt.Sprintf("goes over the provided max limit of %d", maxPayloadSize)
+	wanted := fmt.Sprintf("goes over the provided max limit of %d", maxChunkSize)
 	assert.ErrorContains(t, wanted, err)
 }

@@ -644,8 +639,8 @@ func TestSszNetworkEncoder_DecodeWithMultipleFrames(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	c := params.BeaconNetworkConfig()
 	// 4 * 1 Mib
-	maxPayloadSize := uint64(1 << 22)
-	encoder.MaxPayloadSize = maxPayloadSize
+	maxChunkSize := uint64(1 << 22)
+	encoder.MaxChunkSize = maxChunkSize
 	params.OverrideBeaconNetworkConfig(c)
 	_, err := e.EncodeWithMaxLength(buf, st.ToProtoUnsafe().(*ethpb.BeaconState))
 	require.NoError(t, err)
--- a/beacon-chain/p2p/message_id.go
+++ b/beacon-chain/p2p/message_id.go
@@ -50,7 +50,7 @@ func MsgID(genesisValidatorsRoot []byte, pmsg *pubsubpb.Message) string {
 	if fEpoch >= params.BeaconConfig().AltairForkEpoch {
 		return postAltairMsgID(pmsg, fEpoch)
 	}
-	decodedData, err := encoder.DecodeSnappy(pmsg.Data, params.BeaconConfig().MaxPayloadSize)
+	decodedData, err := encoder.DecodeSnappy(pmsg.Data, params.BeaconConfig().GossipMaxSize)
 	if err != nil {
 		combinedData := append(params.BeaconConfig().MessageDomainInvalidSnappy[:], pmsg.Data...)
 		h := hash.Hash(combinedData)
@@ -77,9 +77,10 @@ func postAltairMsgID(pmsg *pubsubpb.Message, fEpoch primitives.Epoch) string {
 	topicLen := len(topic)
 	topicLenBytes := bytesutil.Uint64ToBytesLittleEndian(uint64(topicLen)) // topicLen cannot be negative

-	gossipPayloadSize := params.BeaconConfig().MaxPayloadSize
+	// beyond Bellatrix epoch, allow 10 Mib gossip data size
+	gossipPubSubSize := params.BeaconConfig().GossipMaxSize

-	decodedData, err := encoder.DecodeSnappy(pmsg.Data, gossipPayloadSize)
+	decodedData, err := encoder.DecodeSnappy(pmsg.Data, gossipPubSubSize)
 	if err != nil {
 		totalLength, err := math.AddInt(
 			len(params.BeaconConfig().MessageDomainInvalidSnappy),
@@ -94,7 +95,7 @@ func postAltairMsgID(pmsg *pubsubpb.Message, fEpoch primitives.Epoch) string {
 			copy(msg, "invalid")
 			return bytesutil.UnsafeCastToString(msg)
 		}
-		if uint64(totalLength) > gossipPayloadSize {
+		if uint64(totalLength) > gossipPubSubSize {
 			// this should never happen
 			msg := make([]byte, 20)
 			copy(msg, "invalid")
--- a/beacon-chain/p2p/pubsub.go
+++ b/beacon-chain/p2p/pubsub.go
@@ -11,11 +11,9 @@ import (
 	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/encoder"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	mathutil "github.com/prysmaticlabs/prysm/v5/math"
 	pbrpc "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )

@@ -143,7 +141,7 @@ func (s *Service) pubsubOptions() []pubsub.Option {
 		}),
 		pubsub.WithSubscriptionFilter(s),
 		pubsub.WithPeerOutboundQueueSize(int(s.cfg.QueueSize)),
-		pubsub.WithMaxMessageSize(int(MaxMessageSize())), // lint:ignore uintcast -- Max Message Size is a config value and is naturally bounded by networking limitations.
+		pubsub.WithMaxMessageSize(int(params.BeaconConfig().GossipMaxSize)),
 		pubsub.WithValidateQueueSize(int(s.cfg.QueueSize)),
 		pubsub.WithPeerScore(peerScoringParams()),
 		pubsub.WithPeerScoreInspect(s.peerInspector, time.Minute),
@@ -237,14 +235,3 @@ func ExtractGossipDigest(topic string) ([4]byte, error) {
 	}
 	return bytesutil.ToBytes4(digest), nil
 }
-
-// MaxMessageSize returns the maximum allowed compressed message size.
-//
-// Spec pseudocode definition:
-// def max_message_size() -> uint64:
-//
-//	# Allow 1024 bytes for framing and encoding overhead but at least 1MiB in case MAX_PAYLOAD_SIZE is small.
-//	return max(max_compressed_len(MAX_PAYLOAD_SIZE) + 1024, 1024 * 1024)
-func MaxMessageSize() uint64 {
-	return mathutil.Max(encoder.MaxCompressedLen(params.BeaconConfig().MaxPayloadSize)+1024, 1024*1024)
-}
--- a/beacon-chain/rpc/eth/beacon/handlers_pool.go
+++ b/beacon-chain/rpc/eth/beacon/handlers_pool.go
@@ -55,7 +55,11 @@ func (s *Server) ListAttestations(w http.ResponseWriter, r *http.Request) {
 		attestations = s.AttestationCache.GetAll()
 	} else {
 		attestations = s.AttestationsPool.AggregatedAttestations()
-		unaggAtts := s.AttestationsPool.UnaggregatedAttestations()
+		unaggAtts, err := s.AttestationsPool.UnaggregatedAttestations()
+		if err != nil {
+			httputil.HandleError(w, "Could not get unaggregated attestations: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
 		attestations = append(attestations, unaggAtts...)
 	}

@@ -110,7 +114,11 @@ func (s *Server) ListAttestationsV2(w http.ResponseWriter, r *http.Request) {
 		attestations = s.AttestationCache.GetAll()
 	} else {
 		attestations = s.AttestationsPool.AggregatedAttestations()
-		unaggAtts := s.AttestationsPool.UnaggregatedAttestations()
+		unaggAtts, err := s.AttestationsPool.UnaggregatedAttestations()
+		if err != nil {
+			httputil.HandleError(w, "Could not get unaggregated attestations: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
 		attestations = append(attestations, unaggAtts...)
 	}

@@ -625,7 +633,7 @@ func (s *Server) SubmitBLSToExecutionChanges(w http.ResponseWriter, r *http.Requ
 			toBroadcast = append(toBroadcast, sbls)
 		}
 	}
-	go s.broadcastBLSChanges(context.Background(), toBroadcast)
+	go s.broadcastBLSChanges(ctx, toBroadcast)
 	if len(failures) > 0 {
 		failuresErr := &server.IndexedVerificationFailureError{
 			Code:     http.StatusBadRequest,
--- a/beacon-chain/rpc/eth/config/handlers_test.go
+++ b/beacon-chain/rpc/eth/config/handlers_test.go
@@ -160,8 +160,6 @@ func TestGetSpec(t *testing.T) {
 	config.MaxTransactionsPerPayload = 99
 	config.FieldElementsPerBlob = 100
 	config.KzgCommitmentInclusionProofDepth = 101
-	config.BlobsidecarSubnetCount = 102
-	config.BlobsidecarSubnetCountElectra = 103

 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -200,7 +198,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)

-	assert.Equal(t, 169, len(data))
+	assert.Equal(t, 168, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -481,7 +479,9 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "5", v)
 			case "MIN_EPOCHS_FOR_BLOCK_REQUESTS":
 				assert.Equal(t, "33024", v)
-			case "MAX_PAYLOAD_SIZE":
+			case "GOSSIP_MAX_SIZE":
+				assert.Equal(t, "10485760", v)
+			case "MAX_CHUNK_SIZE":
 				assert.Equal(t, "10485760", v)
 			case "ATTESTATION_SUBNET_COUNT":
 				assert.Equal(t, "64", v)
@@ -559,10 +559,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "100", v)
 			case "KZG_COMMITMENT_INCLUSION_PROOF_DEPTH":
 				assert.Equal(t, "101", v)
-			case "BLOB_SIDECAR_SUBNET_COUNT":
-				assert.Equal(t, "102", v)
-			case "BLOB_SIDECAR_SUBNET_COUNT_ELECTRA":
-				assert.Equal(t, "103", v)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}
--- a/beacon-chain/rpc/eth/events/BUILD.bazel
+++ b/beacon-chain/rpc/eth/events/BUILD.bazel
@@ -18,8 +18,7 @@ go_library(
        "//beacon-chain/core/feed/operation:go_default_library",
        "//beacon-chain/core/feed/state:go_default_library",
        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/transition:go_default_library",
-        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
        "//config/params:go_default_library",
        "//consensus-types/interfaces:go_default_library",
        "//consensus-types/payload-attribute:go_default_library",
@@ -59,7 +58,6 @@ go_test(
        "//consensus-types/interfaces:go_default_library",
        "//consensus-types/payload-attribute:go_default_library",
        "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
        "//proto/eth/v1:go_default_library",
        "//proto/prysm/v1alpha1:go_default_library",
        "//testing/require:go_default_library",
--- a/beacon-chain/rpc/eth/events/events.go
+++ b/beacon-chain/rpc/eth/events/events.go
@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"io"
 	"net/http"
-	"runtime/debug"
 	"strconv"
 	"time"

@@ -21,8 +20,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	chaintime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
@@ -45,8 +43,6 @@ const (
 	HeadTopic = "head"
 	// BlockTopic represents a new produced block event topic.
 	BlockTopic = "block"
-	// BlockGossipTopic represents a block received from gossip or API that passes validation rules.
-	BlockGossipTopic = "block_gossip"
 	// AttestationTopic represents a new submitted attestation event topic.
 	AttestationTopic = "attestation"
 	// SingleAttestationTopic represents a new submitted single attestation event topic.
@@ -105,7 +101,6 @@ var opsFeedEventTopics = map[feed.EventType]string{
 	operation.BlobSidecarReceived:               BlobSidecarTopic,
 	operation.AttesterSlashingReceived:          AttesterSlashingTopic,
 	operation.ProposerSlashingReceived:          ProposerSlashingTopic,
-	operation.BlockGossipReceived:               BlockGossipTopic,
 }

 var stateFeedEventTopics = map[feed.EventType]string{
@@ -357,18 +352,9 @@ func writeLazyReaderWithRecover(w *streamingResponseWriterController, lr lazyRea
 		if r := recover(); r != nil {
 			log.WithField("panic", r).Error("Recovered from panic while writing event to client.")
 			err = errWriterUnusable
-			debug.PrintStack()
 		}
 	}()
-	if lr == nil {
-		log.Warn("Event stream skipping a nil lazy event reader callback")
-		return nil
-	}
 	r := lr()
-	if r == nil {
-		log.Warn("Event stream skipping a nil event reader")
-		return nil
-	}
 	out, err := io.ReadAll(r)
 	if err != nil {
 		return err
@@ -446,8 +432,6 @@ func topicForEvent(event *feed.Event) string {
 		return AttesterSlashingTopic
 	case *operation.ProposerSlashingReceivedData:
 		return ProposerSlashingTopic
-	case *operation.BlockGossipReceivedData:
-		return BlockGossipTopic
 	case *ethpb.EventHead:
 		return HeadTopic
 	case *ethpb.EventFinalizedCheckpoint:
@@ -484,18 +468,6 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 		return func() io.Reader {
 			return jsonMarshalReader(eventName, structs.HeadEventFromV1(v))
 		}, nil
-	case *operation.BlockGossipReceivedData:
-		blockRoot, err := v.SignedBlock.Block().HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute block root for BlockGossipReceivedData")
-		}
-		return func() io.Reader {
-			blk := &structs.BlockGossipEvent{
-				Slot:  fmt.Sprintf("%d", v.SignedBlock.Block().Slot()),
-				Block: hexutil.Encode(blockRoot[:]),
-			}
-			return jsonMarshalReader(eventName, blk)
-		}, nil
 	case *operation.AggregatedAttReceivedData:
 		switch att := v.Attestation.AggregateVal().(type) {
 		case *eth.Attestation:
@@ -628,14 +600,27 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi

 var errUnsupportedPayloadAttribute = errors.New("cannot compute payload attributes pre-Bellatrix")

-func (s *Server) computePayloadAttributes(ctx context.Context, st state.ReadOnlyBeaconState, root [32]byte, proposer primitives.ValidatorIndex, timestamp uint64, randao []byte) (payloadattribute.Attributer, error) {
-	v := st.Version()
+func (s *Server) computePayloadAttributes(ctx context.Context, ev payloadattribute.EventData) (payloadattribute.Attributer, error) {
+	v := ev.HeadState.Version()
 	if v < version.Bellatrix {
 		return nil, errors.Wrapf(errUnsupportedPayloadAttribute, "%s is not supported", version.String(v))
 	}

+	t, err := slots.ToTime(ev.HeadState.GenesisTime(), ev.HeadState.Slot())
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get head state slot time")
+	}
+	timestamp := uint64(t.Unix())
+	prevRando, err := helpers.RandaoMix(ev.HeadState, chaintime.CurrentEpoch(ev.HeadState))
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get head state randao mix")
+	}
+	proposerIndex, err := helpers.BeaconProposerIndex(ctx, ev.HeadState)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get head state proposer index")
+	}
 	feeRecpt := params.BeaconConfig().DefaultFeeRecipient.Bytes()
-	tValidator, exists := s.TrackedValidatorsCache.Validator(proposer)
+	tValidator, exists := s.TrackedValidatorsCache.Validator(proposerIndex)
 	if exists {
 		feeRecpt = tValidator.FeeRecipient[:]
 	}
@@ -643,30 +628,34 @@ func (s *Server) computePayloadAttributes(ctx context.Context, st state.ReadOnly
 	if v == version.Bellatrix {
 		return payloadattribute.New(&engine.PayloadAttributes{
 			Timestamp:             timestamp,
-			PrevRandao:            randao,
+			PrevRandao:            prevRando,
 			SuggestedFeeRecipient: feeRecpt,
 		})
 	}

-	w, _, err := st.ExpectedWithdrawals()
+	w, _, err := ev.HeadState.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get withdrawals from head state")
 	}
 	if v == version.Capella {
 		return payloadattribute.New(&engine.PayloadAttributesV2{
 			Timestamp:             timestamp,
-			PrevRandao:            randao,
+			PrevRandao:            prevRando,
 			SuggestedFeeRecipient: feeRecpt,
 			Withdrawals:           w,
 		})
 	}

+	pr, err := ev.HeadBlock.Block().HashTreeRoot()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute head block root")
+	}
 	return payloadattribute.New(&engine.PayloadAttributesV3{
 		Timestamp:             timestamp,
-		PrevRandao:            randao,
+		PrevRandao:            prevRando,
 		SuggestedFeeRecipient: feeRecpt,
 		Withdrawals:           w,
-		ParentBeaconBlockRoot: root[:],
+		ParentBeaconBlockRoot: pr[:],
 	})
 }

@@ -676,75 +665,37 @@ type asyncPayloadAttrData struct {
 	err     error
 }

-var zeroRoot [32]byte
-
-// needsFill allows tests to provide filled EventData values. An ordinary event data value fired by the blockchain package will have
-// all of the checked fields empty, so the logical short circuit should hit immediately.
-func needsFill(ev payloadattribute.EventData) bool {
-	return ev.HeadState == nil || ev.HeadState.IsNil() || ev.HeadState.LatestBlockHeader() == nil ||
-		ev.HeadBlock == nil || ev.HeadBlock.IsNil() ||
-		ev.HeadRoot == zeroRoot || len(ev.ParentBlockRoot) == 0 || len(ev.ParentBlockHash) == 0 ||
-		ev.Attributer == nil || ev.Attributer.IsEmpty()
-}
-
 func (s *Server) fillEventData(ctx context.Context, ev payloadattribute.EventData) (payloadattribute.EventData, error) {
-	var err error
-
-	if !needsFill(ev) {
-		return ev, nil
-	}
-
-	ev.HeadState, err = s.HeadFetcher.HeadState(ctx)
-	if err != nil {
-		return ev, errors.Wrap(err, "could not get head state")
-	}
-
-	ev.HeadBlock, err = s.HeadFetcher.HeadBlock(ctx)
-	if err != nil {
-		return ev, errors.Wrap(err, "could not look up head block")
-	}
-	ev.HeadRoot, err = ev.HeadBlock.Block().HashTreeRoot()
-	if err != nil {
-		return ev, errors.Wrap(err, "could not compute head block root")
-	}
-	pr := ev.HeadBlock.Block().ParentRoot()
-	ev.ParentBlockRoot = pr[:]
-
-	hsr, err := ev.HeadState.LatestBlockHeader().HashTreeRoot()
-	if err != nil {
-		return ev, errors.Wrap(err, "could not compute latest block header root")
-	}
-
-	pse := slots.ToEpoch(ev.ProposalSlot)
-	st := ev.HeadState
-	if slots.ToEpoch(st.Slot()) != pse {
-		st, err = transition.ProcessSlotsUsingNextSlotCache(ctx, st, hsr[:], ev.ProposalSlot)
+	if ev.HeadBlock == nil || ev.HeadBlock.IsNil() {
+		hb, err := s.HeadFetcher.HeadBlock(ctx)
 		if err != nil {
-			return ev, errors.Wrap(err, "could not run process blocks on head state into the proposal slot epoch")
+			return ev, errors.Wrap(err, "Could not look up head block")
 		}
-	}
-	ev.ProposerIndex, err = helpers.BeaconProposerIndexAtSlot(ctx, st, ev.ProposalSlot)
-	if err != nil {
-		return ev, errors.Wrap(err, "failed to compute proposer index")
-	}
-	randao, err := helpers.RandaoMix(st, pse)
-	if err != nil {
-		return ev, errors.Wrap(err, "could not get head state randado")
+		root, err := hb.Block().HashTreeRoot()
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not compute head block root")
+		}
+		if ev.HeadRoot != root {
+			return ev, errors.Wrap(err, "head root changed before payload attribute event handler execution")
+		}
+		ev.HeadBlock = hb
+		payload, err := hb.Block().Body().Execution()
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not get execution payload for head block")
+		}
+		ev.ParentBlockHash = payload.BlockHash()
+		ev.ParentBlockNumber = payload.BlockNumber()
 	}

-	payload, err := ev.HeadBlock.Block().Body().Execution()
-	if err != nil {
-		return ev, errors.Wrap(err, "could not get execution payload for head block")
+	attr := ev.Attributer
+	if attr == nil || attr.IsEmpty() {
+		attr, err := s.computePayloadAttributes(ctx, ev)
+		if err != nil {
+			return ev, errors.Wrap(err, "Could not compute payload attributes")
+		}
+		ev.Attributer = attr
 	}
-	ev.ParentBlockHash = payload.BlockHash()
-	ev.ParentBlockNumber = payload.BlockNumber()
-
-	t, err := slots.ToTime(st.GenesisTime(), ev.ProposalSlot)
-	if err != nil {
-		return ev, errors.Wrap(err, "could not get head state slot time")
-	}
-	ev.Attributer, err = s.computePayloadAttributes(ctx, st, hsr, ev.ProposerIndex, uint64(t.Unix()), randao)
-	return ev, err
+	return ev, nil
 }

 // This event stream is intended to be used by builders and relays.
@@ -753,7 +704,10 @@ func (s *Server) payloadAttributesReader(ctx context.Context, ev payloadattribut
 	ctx, cancel := context.WithTimeout(ctx, payloadAttributeTimeout)
 	edc := make(chan asyncPayloadAttrData)
 	go func() {
-		d := asyncPayloadAttrData{}
+		d := asyncPayloadAttrData{
+			version: version.String(ev.HeadState.Version()),
+		}
+
 		defer func() {
 			edc <- d
 		}()
@@ -762,7 +716,6 @@ func (s *Server) payloadAttributesReader(ctx context.Context, ev payloadattribut
 			d.err = errors.Wrap(err, "Could not fill event data")
 			return
 		}
-		d.version = version.String(ev.HeadBlock.Version())
 		attributesBytes, err := marshalAttributes(ev.Attributer)
 		if err != nil {
 			d.err = errors.Wrap(err, "errors marshaling payload attributes to json")
--- a/beacon-chain/rpc/eth/events/events_test.go
+++ b/beacon-chain/rpc/eth/events/events_test.go
@@ -2,7 +2,6 @@ package events

 import (
 	"context"
-	"encoding/binary"
 	"fmt"
 	"io"
 	"math"
@@ -25,7 +24,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -119,19 +117,12 @@ func operationEventsFixtures(t *testing.T) (*topicRequest, []*feed.Event) {
 		BlobSidecarTopic,
 		AttesterSlashingTopic,
 		ProposerSlashingTopic,
-		BlockGossipTopic,
 	})
 	require.NoError(t, err)
 	ro, err := blocks.NewROBlob(util.HydrateBlobSidecar(&eth.BlobSidecar{}))
 	require.NoError(t, err)
 	vblob := blocks.NewVerifiedROBlob(ro)

-	// Create a test block for block gossip event
-	block := util.NewBeaconBlock()
-	block.Block.Slot = 123
-	signedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
-
 	return topics, []*feed.Event{
 		{
 			Type: operation.UnaggregatedAttReceived,
@@ -294,12 +285,6 @@ func operationEventsFixtures(t *testing.T) (*topicRequest, []*feed.Event) {
 				},
 			},
 		},
-		{
-			Type: operation.BlockGossipReceived,
-			Data: &operation.BlockGossipReceivedData{
-				SignedBlock: signedBlock,
-			},
-		},
 	}
 }

@@ -572,110 +557,6 @@ func TestStreamEvents_OperationsEvents(t *testing.T) {
 	})
 }

-func TestFillEventData(t *testing.T) {
-	ctx := context.Background()
-	t.Run("AlreadyFilledData_ShouldShortCircuitWithoutError", func(t *testing.T) {
-		st, err := util.NewBeaconStateBellatrix()
-		require.NoError(t, err)
-		b, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(&eth.SignedBeaconBlockBellatrix{}))
-		require.NoError(t, err)
-		attributor, err := payloadattribute.New(&enginev1.PayloadAttributes{
-			Timestamp: uint64(time.Now().Unix()),
-		})
-		require.NoError(t, err)
-		alreadyFilled := payloadattribute.EventData{
-			HeadState:       st,
-			HeadBlock:       b,
-			HeadRoot:        [32]byte{1, 2, 3},
-			Attributer:      attributor,
-			ParentBlockRoot: []byte{1, 2, 3},
-			ParentBlockHash: []byte{4, 5, 6},
-		}
-		srv := &Server{} // No real HeadFetcher needed here since it won't be called.
-		result, err := srv.fillEventData(ctx, alreadyFilled)
-		require.NoError(t, err)
-		require.DeepEqual(t, alreadyFilled, result)
-	})
-	t.Run("Electra PartialData_ShouldFetchHeadStateAndBlock", func(t *testing.T) {
-		st, err := util.NewBeaconStateElectra()
-		require.NoError(t, err)
-		valCount := 10
-		setActiveValidators(t, st, valCount)
-		inactivityScores := make([]uint64, valCount)
-		for i := range inactivityScores {
-			inactivityScores[i] = 10
-		}
-		require.NoError(t, st.SetInactivityScores(inactivityScores))
-		b, err := blocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockElectra(&eth.SignedBeaconBlockElectra{}))
-		require.NoError(t, err)
-		attributor, err := payloadattribute.New(&enginev1.PayloadAttributes{
-			Timestamp: uint64(time.Now().Unix()),
-		})
-		require.NoError(t, err)
-		// Create an event data object missing certain fields:
-		partial := payloadattribute.EventData{
-			// The presence of a nil HeadState, nil HeadBlock, zeroed HeadRoot, etc.
-			// will cause fillEventData to try to fill the values.
-			ProposalSlot: 42,         // different epoch from current slot
-			Attributer:   attributor, // Must be Bellatrix or later
-		}
-		currentSlot := primitives.Slot(0)
-		// to avoid slot processing
-		require.NoError(t, st.SetSlot(currentSlot+1))
-		mockChainService := &mockChain.ChainService{
-			Root:  make([]byte, 32),
-			State: st,
-			Block: b,
-			Slot:  &currentSlot,
-		}
-
-		stn := mockChain.NewEventFeedWrapper()
-		opn := mockChain.NewEventFeedWrapper()
-		srv := &Server{
-			StateNotifier:          &mockChain.SimpleNotifier{Feed: stn},
-			OperationNotifier:      &mockChain.SimpleNotifier{Feed: opn},
-			HeadFetcher:            mockChainService,
-			ChainInfoFetcher:       mockChainService,
-			TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
-			EventWriteTimeout:      testEventWriteTimeout,
-		}
-
-		filled, err := srv.fillEventData(ctx, partial)
-		require.NoError(t, err, "expected successful fill of partial event data")
-
-		// Verify that fields have been updated from the mock data:
-		require.NotNil(t, filled.HeadState, "HeadState should be assigned")
-		require.NotNil(t, filled.HeadBlock, "HeadBlock should be assigned")
-		require.NotEqual(t, [32]byte{}, filled.HeadRoot, "HeadRoot should no longer be zero")
-		require.NotEmpty(t, filled.ParentBlockRoot, "ParentBlockRoot should be filled")
-		require.NotEmpty(t, filled.ParentBlockHash, "ParentBlockHash should be filled")
-		require.Equal(t, uint64(0), filled.ParentBlockNumber, "ParentBlockNumber must match mock block")
-
-		// Check that a valid Attributer was set:
-		require.NotNil(t, filled.Attributer, "Should have a valid payload attributes object")
-		require.Equal(t, false, filled.Attributer.IsEmpty(), "Attributer should not be empty after fill")
-	})
-}
-
-func setActiveValidators(t *testing.T, st state.BeaconState, count int) {
-	balances := make([]uint64, count)
-	validators := make([]*eth.Validator, 0, count)
-	for i := 0; i < count; i++ {
-		pubKey := make([]byte, params.BeaconConfig().BLSPubkeyLength)
-		binary.LittleEndian.PutUint64(pubKey, uint64(i))
-		balances[i] = uint64(i)
-		validators = append(validators, &eth.Validator{
-			PublicKey:             pubKey,
-			ActivationEpoch:       0,
-			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			WithdrawalCredentials: make([]byte, 32),
-		})
-	}
-
-	require.NoError(t, st.SetValidators(validators))
-	require.NoError(t, st.SetBalances(balances))
-}
-
 func TestStuckReaderScenarios(t *testing.T) {
 	cases := []struct {
 		name       string
@@ -703,7 +584,7 @@ func TestStuckReaderScenarios(t *testing.T) {

 func wedgedWriterTestCase(t *testing.T, queueDepth func([]*feed.Event) int) {
 	topics, events := operationEventsFixtures(t)
-	require.Equal(t, 11, len(events))
+	require.Equal(t, 10, len(events))

 	// set eventFeedDepth to a number lower than the events we intend to send to force the server to drop the reader.
 	stn := mockChain.NewEventFeedWrapper()
--- a/beacon-chain/rpc/eth/validator/BUILD.bazel
+++ b/beacon-chain/rpc/eth/validator/BUILD.bazel
@@ -37,7 +37,6 @@ go_library(
        "//consensus-types/blocks:go_default_library",
        "//consensus-types/primitives:go_default_library",
        "//consensus-types/validator:go_default_library",
-        "//crypto/bls/common:go_default_library",
        "//encoding/bytesutil:go_default_library",
        "//monitoring/tracing/trace:go_default_library",
        "//network/httputil:go_default_library",
--- a/beacon-chain/rpc/eth/validator/handlers.go
+++ b/beacon-chain/rpc/eth/validator/handlers.go
@@ -162,7 +162,11 @@ func (s *Server) aggregatedAttestation(w http.ResponseWriter, slot primitives.Sl
 		return nil
 	}

-	atts := s.AttestationsPool.UnaggregatedAttestations()
+	atts, err := s.AttestationsPool.UnaggregatedAttestations()
+	if err != nil {
+		httputil.HandleError(w, "Could not get unaggregated attestations: "+err.Error(), http.StatusInternalServerError)
+		return nil
+	}
 	match, err = matchingAtts(atts, slot, attDataRoot, index)
 	if err != nil {
 		httputil.HandleError(w, "Could not get matching attestations: "+err.Error(), http.StatusInternalServerError)
@@ -632,16 +636,6 @@ func (s *Server) ProduceSyncCommitteeContribution(w http.ResponseWriter, r *http
 	ctx, span := trace.StartSpan(r.Context(), "validator.ProduceSyncCommitteeContribution")
 	defer span.End()

-	isOptimistic, err := s.OptimisticModeFetcher.IsOptimistic(ctx)
-	if err != nil {
-		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	if isOptimistic {
-		httputil.HandleError(w, "Beacon node is currently syncing and not serving request on that endpoint", http.StatusServiceUnavailable)
-		return
-	}
-
 	_, index, ok := shared.UintFromQuery(w, r, "subcommittee_index", true)
 	if !ok {
 		return
--- a/beacon-chain/rpc/eth/validator/handlers_block.go
+++ b/beacon-chain/rpc/eth/validator/handlers_block.go
@@ -16,7 +16,6 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
@@ -58,7 +57,7 @@ func (s *Server) ProduceBlockV2(w http.ResponseWriter, r *http.Request) {

 	var randaoReveal []byte
 	if rawSkipRandaoVerification == "true" {
-		randaoReveal = common.InfiniteSignature[:]
+		randaoReveal = primitives.PointAtInfinity
 	} else {
 		rr, err := bytesutil.DecodeHexWithLength(rawRandaoReveal, fieldparams.BLSSignatureLength)
 		if err != nil {
@@ -110,7 +109,7 @@ func (s *Server) ProduceBlindedBlock(w http.ResponseWriter, r *http.Request) {

 	var randaoReveal []byte
 	if rawSkipRandaoVerification == "true" {
-		randaoReveal = common.InfiniteSignature[:]
+		randaoReveal = primitives.PointAtInfinity
 	} else {
 		rr, err := bytesutil.DecodeHexWithLength(rawRandaoReveal, fieldparams.BLSSignatureLength)
 		if err != nil {
@@ -175,7 +174,7 @@ func (s *Server) ProduceBlockV3(w http.ResponseWriter, r *http.Request) {

 	var randaoReveal []byte
 	if rawSkipRandaoVerification == "true" {
-		randaoReveal = common.InfiniteSignature[:]
+		randaoReveal = primitives.PointAtInfinity
 	} else {
 		rr, err := bytesutil.DecodeHexWithLength(rawRandaoReveal, fieldparams.BLSSignatureLength)
 		if err != nil {
--- a/beacon-chain/rpc/eth/validator/handlers_test.go
+++ b/beacon-chain/rpc/eth/validator/handlers_test.go
@@ -118,7 +118,8 @@ func TestGetAggregateAttestation(t *testing.T) {

 		pool := attestations.NewPool()
 		require.NoError(t, pool.SaveUnaggregatedAttestations([]ethpbalpha.Att{unaggSlot3_Root1_1, unaggSlot3_Root1_2, unaggSlot3_Root2, unaggSlot4}), "Failed to save unaggregated attestations")
-		unagg := pool.UnaggregatedAttestations()
+		unagg, err := pool.UnaggregatedAttestations()
+		require.NoError(t, err)
 		require.Equal(t, 4, len(unagg), "Expected 4 unaggregated attestations")
 		require.NoError(t, pool.SaveAggregatedAttestations([]ethpbalpha.Att{aggSlot1_Root1_1, aggSlot1_Root1_2, aggSlot1_Root2, aggSlot2}), "Failed to save aggregated attestations")
 		agg := pool.AggregatedAttestations()
@@ -267,7 +268,8 @@ func TestGetAggregateAttestation(t *testing.T) {

 			pool := attestations.NewPool()
 			require.NoError(t, pool.SaveUnaggregatedAttestations([]ethpbalpha.Att{unaggSlot3_Root1_1, unaggSlot3_Root1_2, unaggSlot3_Root2, unaggSlot4}), "Failed to save unaggregated attestations")
-			unagg := pool.UnaggregatedAttestations()
+			unagg, err := pool.UnaggregatedAttestations()
+			require.NoError(t, err)
 			require.Equal(t, 4, len(unagg), "Expected 4 unaggregated attestations")
 			require.NoError(t, pool.SaveAggregatedAttestations([]ethpbalpha.Att{aggSlot1_Root1_1, aggSlot1_Root1_2, aggSlot1_Root2, aggSlot2, postElectraAtt}), "Failed to save aggregated attestations")
 			agg := pool.AggregatedAttestations()
@@ -371,7 +373,8 @@ func TestGetAggregateAttestation(t *testing.T) {

 			pool := attestations.NewPool()
 			require.NoError(t, pool.SaveUnaggregatedAttestations([]ethpbalpha.Att{unaggSlot3_Root1_1, unaggSlot3_Root1_2, unaggSlot3_Root2, unaggSlot4}), "Failed to save unaggregated attestations")
-			unagg := pool.UnaggregatedAttestations()
+			unagg, err := pool.UnaggregatedAttestations()
+			require.NoError(t, err)
 			require.Equal(t, 4, len(unagg), "Expected 4 unaggregated attestations")
 			require.NoError(t, pool.SaveAggregatedAttestations([]ethpbalpha.Att{aggSlot1_Root1_1, aggSlot1_Root1_2, aggSlot1_Root2, aggSlot2, preElectraAtt}), "Failed to save aggregated attestations")
 			agg := pool.AggregatedAttestations()
@@ -1581,8 +1584,7 @@ func TestProduceSyncCommitteeContribution(t *testing.T) {
 				SyncCommitteeIndices: []primitives.CommitteeIndex{0},
 			},
 		},
-		SyncCommitteePool:     syncCommitteePool,
-		OptimisticModeFetcher: &mockChain.ChainService{},
+		SyncCommitteePool: syncCommitteePool,
 	}
 	t.Run("ok", func(t *testing.T) {
 		url := "http://example.com?slot=1&subcommittee_index=1&beacon_block_root=0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
@@ -1670,8 +1672,7 @@ func TestProduceSyncCommitteeContribution(t *testing.T) {
 					SyncCommitteeIndices: []primitives.CommitteeIndex{0},
 				},
 			},
-			SyncCommitteePool:     syncCommitteePool,
-			OptimisticModeFetcher: &mockChain.ChainService{},
+			SyncCommitteePool: syncCommitteePool,
 		}
 		server.ProduceSyncCommitteeContribution(writer, request)
 		assert.Equal(t, http.StatusNotFound, writer.Code)
@@ -1679,26 +1680,6 @@ func TestProduceSyncCommitteeContribution(t *testing.T) {
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp2))
 		require.ErrorContains(t, "No subcommittee messages found", errors.New(writer.Body.String()))
 	})
-	t.Run("Optimistic returns 503", func(t *testing.T) {
-		url := "http://example.com?slot=1&subcommittee_index=1&beacon_block_root=0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"
-		request := httptest.NewRequest(http.MethodGet, url, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		syncCommitteePool = synccommittee.NewStore()
-		server = Server{
-			CoreService: &core.Service{
-				HeadFetcher: &mockChain.ChainService{
-					SyncCommitteeIndices: []primitives.CommitteeIndex{0},
-				},
-			},
-			SyncCommitteePool: syncCommitteePool,
-			OptimisticModeFetcher: &mockChain.ChainService{
-				Optimistic: true,
-			},
-		}
-		server.ProduceSyncCommitteeContribution(writer, request)
-		assert.Equal(t, http.StatusServiceUnavailable, writer.Code)
-	})
 }

 func TestServer_RegisterValidator(t *testing.T) {
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel
@@ -73,7 +73,6 @@ go_library(
        "//container/trie:go_default_library",
        "//contracts/deposit:go_default_library",
        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
        "//crypto/hash:go_default_library",
        "//crypto/rand:go_default_library",
        "//encoding/bytesutil:go_default_library",
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_altair.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_altair.go
@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
-	"github.com/prysmaticlabs/prysm/v5/crypto/bls/common"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -97,7 +96,7 @@ func (vs *Server) getSyncAggregate(ctx context.Context, slot primitives.Slot, ro
 	syncSig := bls.AggregateSignatures(sigsHolder)
 	var syncSigBytes [96]byte
 	if syncSig == nil {
-		syncSigBytes = common.InfiniteSignature // Infinity signature if itself is nil.
+		syncSigBytes = [96]byte{0xC0} // Infinity signature if itself is nil.
 	} else {
 		syncSigBytes = bytesutil.ToBytes96(syncSig.Marshal())
 	}
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_attestations.go
@@ -39,10 +39,6 @@ func (vs *Server) packAttestations(ctx context.Context, latestState state.Beacon
 	} else {
 		atts = vs.AttPool.AggregatedAttestations()
 		atts = vs.validateAndDeleteAttsInPool(ctx, latestState, atts)
-
-		uAtts := vs.AttPool.UnaggregatedAttestations()
-		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.
--- a/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go
+++ b/beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go
@@ -2949,7 +2949,8 @@ func TestProposer_DeleteAttsInPool_Aggregated(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.deleteAttsInPool(context.Background(), append(aa, unaggregatedAtts...)))
 	assert.Equal(t, 0, len(s.AttPool.AggregatedAttestations()), "Did not delete aggregated attestation")
-	atts := s.AttPool.UnaggregatedAttestations()
+	atts, err := s.AttPool.UnaggregatedAttestations()
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(atts), "Did not delete unaggregated attestation")
 }

--- a/beacon-chain/rpc/testutil/mock_blocker.go
+++ b/beacon-chain/rpc/testutil/mock_blocker.go
@@ -37,5 +37,5 @@ func (m *MockBlocker) Block(_ context.Context, b []byte) (interfaces.ReadOnlySig

 // Blobs --
 func (m *MockBlocker) Blobs(_ context.Context, _ string, _ []uint64) ([]*blocks.VerifiedROBlob, *core.RpcError) {
-	panic("implement me") // lint:nopanic -- Test code.
+	panic("implement me")
 }
--- a/beacon-chain/state/stategen/epoch_boundary_state_cache.go
+++ b/beacon-chain/state/stategen/epoch_boundary_state_cache.go
@@ -178,7 +178,7 @@ func (e *epochBoundaryState) delete(blockRoot [32]byte) error {
 func trim(queue *cache.FIFO, maxSize uint64) {
 	for s := uint64(len(queue.ListKeys())); s > maxSize; s-- {
 		if _, err := queue.Pop(popProcessNoopFunc); err != nil { // This never returns an error, but we'll handle anyway for sanity.
-			panic(err) // lint:nopanic -- Never returns an error.
+			panic(err)
 		}
 	}
 }
--- a/beacon-chain/state/stategen/mock/mock.go
+++ b/beacon-chain/state/stategen/mock/mock.go
@@ -1,4 +1,3 @@
-// lint:nopanic -- Mock code, OK to panic.
 package mock

 import (
--- a/beacon-chain/sync/initial-sync/BUILD.bazel
+++ b/beacon-chain/sync/initial-sync/BUILD.bazel
@@ -38,6 +38,7 @@ 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",
--- a/beacon-chain/sync/initial-sync/blocks_fetcher.go
+++ b/beacon-chain/sync/initial-sync/blocks_fetcher.go
@@ -2,6 +2,7 @@ package initialsync

 import (
 	"context"
+	"encoding/hex"
 	"fmt"
 	"sort"
 	"strings"
@@ -24,6 +25,7 @@ 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"
@@ -67,6 +69,8 @@ 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
@@ -101,6 +105,7 @@ 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.
@@ -126,6 +131,13 @@ 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()
@@ -160,6 +172,7 @@ func newBlocksFetcher(ctx context.Context, cfg *blocksFetcherConfig) *blocksFetc
 		capacityWeight:  capacityWeight,
 		mode:            cfg.mode,
 		quit:            make(chan struct{}),
+		isBannedBlock:   isHoleskyBannedBlock,
 	}
 }

@@ -357,6 +370,13 @@ 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
@@ -727,3 +747,11 @@ 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)
+}
--- a/beacon-chain/sync/initial-sync/round_robin.go
+++ b/beacon-chain/sync/initial-sync/round_robin.go
@@ -125,6 +125,7 @@ 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)
 	}
@@ -169,6 +170,7 @@ 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")
--- a/beacon-chain/sync/initial-sync/service.go
+++ b/beacon-chain/sync/initial-sync/service.go
@@ -192,7 +192,7 @@ func (s *Service) Start() {
 		if errors.Is(s.ctx.Err(), context.Canceled) {
 			return
 		}
-		panic(err) // lint:nopanic -- Unexpected error. This should probably be surfaced with a returned error.
+		panic(err)
 	}
 	log.WithField("slot", s.cfg.Chain.HeadSlot()).Info("Synced up to")
 	s.markSynced()
--- a/beacon-chain/sync/pending_attestations_queue.go
+++ b/beacon-chain/sync/pending_attestations_queue.go
@@ -218,7 +218,7 @@ func (s *Service) processUnaggregated(ctx context.Context, att ethpb.Att) {
 			}
 		}

-		s.setSeenUnaggregatedAtt(att)
+		s.setSeenCommitteeIndicesSlot(data.Slot, attForValidation.GetCommitteeIndex(), attForValidation.GetAggregationBits())

 		valCount, err := helpers.ActiveValidatorCount(ctx, preState, slots.ToEpoch(data.Slot))
 		if err != nil {
--- a/beacon-chain/sync/pending_attestations_queue_test.go
+++ b/beacon-chain/sync/pending_attestations_queue_test.go
@@ -1,16 +1,12 @@
 package sync

 import (
-	"bytes"
 	"context"
-	"fmt"
 	"sync"
 	"testing"
 	"time"

 	"github.com/ethereum/go-ethereum/p2p/enr"
-	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/async/abool"
@@ -24,7 +20,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
 	p2ptest "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
-	mockSync "github.com/prysmaticlabs/prysm/v5/beacon-chain/sync/initial-sync/testing"
 	lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -158,7 +153,8 @@ func TestProcessPendingAtts_HasBlockSaveUnAggregatedAtt(t *testing.T) {
 			}
 		}
 	}()
-	atts := r.cfg.attPool.UnaggregatedAttestations()
+	atts, err := r.cfg.attPool.UnaggregatedAttestations()
+	require.NoError(t, err)
 	assert.Equal(t, 1, len(atts), "Did not save unaggregated att")
 	assert.DeepEqual(t, att, atts[0], "Incorrect saved att")
 	assert.Equal(t, 0, len(r.cfg.attPool.AggregatedAttestations()), "Did save aggregated att")
@@ -252,7 +248,8 @@ func TestProcessPendingAtts_HasBlockSaveUnAggregatedAttElectra(t *testing.T) {
 			}
 		}
 	}()
-	atts := r.cfg.attPool.UnaggregatedAttestations()
+	atts, err := r.cfg.attPool.UnaggregatedAttestations()
+	require.NoError(t, err)
 	require.Equal(t, 1, len(atts), "Did not save unaggregated att")
 	assert.DeepEqual(t, att.ToAttestationElectra(committee), atts[0], "Incorrect saved att")
 	assert.Equal(t, 0, len(r.cfg.attPool.AggregatedAttestations()), "Did save aggregated att")
@@ -261,168 +258,6 @@ func TestProcessPendingAtts_HasBlockSaveUnAggregatedAttElectra(t *testing.T) {
 	cancel()
 }

-func TestProcessPendingAtts_HasBlockSaveUnAggregatedAttElectra_VerifyAlreadySeen(t *testing.T) {
-	// Setup configuration and fork version schedule.
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	fvs := map[[fieldparams.VersionLength]byte]primitives.Epoch{
-		bytesutil.ToBytes4(cfg.GenesisForkVersion):   1,
-		bytesutil.ToBytes4(cfg.AltairForkVersion):    2,
-		bytesutil.ToBytes4(cfg.BellatrixForkVersion): 3,
-		bytesutil.ToBytes4(cfg.CapellaForkVersion):   4,
-		bytesutil.ToBytes4(cfg.DenebForkVersion):     5,
-		bytesutil.ToBytes4(cfg.FuluForkVersion):      6,
-		bytesutil.ToBytes4(cfg.ElectraForkVersion):   0,
-	}
-	cfg.ForkVersionSchedule = fvs
-	params.OverrideBeaconConfig(cfg)
-
-	// Initialize logging, database, and P2P components.
-	hook := logTest.NewGlobal()
-	db := dbtest.SetupDB(t)
-	p1 := p2ptest.NewTestP2P(t)
-	validators := uint64(256)
-
-	// Create genesis state and associated keys.
-	beaconState, privKeys := util.DeterministicGenesisStateElectra(t, validators)
-	require.NoError(t, beaconState.SetSlot(1))
-
-	// Create and save a new Beacon block.
-	sb := util.NewBeaconBlockElectra()
-	util.SaveBlock(t, context.Background(), db, sb)
-
-	// Save state with block root.
-	root, err := sb.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	// Build a new attestation and its aggregate proof.
-	att := &ethpb.SingleAttestation{
-		CommitteeId: 8, // choose a non 0
-		Data: &ethpb.AttestationData{
-			Slot:            1,
-			BeaconBlockRoot: root[:],
-			Source:          &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
-			Target:          &ethpb.Checkpoint{Epoch: 0, Root: root[:]},
-			CommitteeIndex:  0,
-		},
-	}
-	aggregateAndProof := &ethpb.AggregateAttestationAndProofSingle{
-		Aggregate: att,
-	}
-
-	// Retrieve the beacon committee and set the attester index.
-	committee, err := helpers.BeaconCommitteeFromState(context.Background(), beaconState, att.Data.Slot, att.CommitteeId)
-	assert.NoError(t, err)
-	att.AttesterIndex = committee[0]
-
-	// Compute attester domain and signature.
-	attesterDomain, err := signing.Domain(beaconState.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, beaconState.GenesisValidatorsRoot())
-	require.NoError(t, err)
-	hashTreeRoot, err := signing.ComputeSigningRoot(att.Data, attesterDomain)
-	assert.NoError(t, err)
-	att.SetSignature(privKeys[committee[0]].Sign(hashTreeRoot[:]).Marshal())
-
-	// Set the genesis time.
-	require.NoError(t, beaconState.SetGenesisTime(uint64(time.Now().Unix())))
-
-	// Setup the chain service mock.
-	chain := &mock.ChainService{
-		Genesis: time.Now(),
-		State:   beaconState,
-		FinalizedCheckPoint: &ethpb.Checkpoint{
-			Root:  aggregateAndProof.Aggregate.Data.BeaconBlockRoot,
-			Epoch: 0,
-		},
-	}
-
-	// Setup event feed and subscription.
-	done := make(chan *feed.Event, 1)
-	defer close(done)
-	opn := mock.NewEventFeedWrapper()
-	sub := opn.Subscribe(done)
-	defer sub.Unsubscribe()
-
-	// Create context and service configuration.
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	r := &Service{
-		ctx: ctx,
-		cfg: &config{
-			initialSync:         &mockSync.Sync{IsSyncing: false},
-			p2p:                 p1,
-			beaconDB:            db,
-			chain:               chain,
-			clock:               startup.NewClock(chain.Genesis.Add(time.Duration(-1*int(params.BeaconConfig().SecondsPerSlot))*time.Second), chain.ValidatorsRoot),
-			attPool:             attestations.NewPool(),
-			attestationNotifier: &mock.SimpleNotifier{Feed: opn},
-		},
-		blkRootToPendingAtts:             make(map[[32]byte][]ethpb.SignedAggregateAttAndProof),
-		seenUnAggregatedAttestationCache: lruwrpr.New(10),
-		signatureChan:                    make(chan *signatureVerifier, verifierLimit),
-	}
-	go r.verifierRoutine()
-
-	// Save a new beacon state and link it with the block root.
-	s, err := util.NewBeaconStateElectra()
-	require.NoError(t, err)
-	require.NoError(t, r.cfg.beaconDB.SaveState(context.Background(), s, root))
-
-	// Add the pending attestation.
-	r.blkRootToPendingAtts[root] = []ethpb.SignedAggregateAttAndProof{
-		&ethpb.SignedAggregateAttestationAndProofSingle{Message: aggregateAndProof},
-	}
-	require.NoError(t, r.processPendingAtts(context.Background()))
-
-	// Verify that the event feed receives the expected attestation.
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		for {
-			select {
-			case received := <-done:
-				// Ensure a single attestation event was sent.
-				require.Equal(t, operation.SingleAttReceived, int(received.Type))
-				return
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-
-	// Verify unaggregated attestations are saved correctly.
-	atts := r.cfg.attPool.UnaggregatedAttestations()
-	require.Equal(t, 1, len(atts), "Did not save unaggregated att")
-	assert.DeepEqual(t, att.ToAttestationElectra(committee), atts[0], "Incorrect saved att")
-	assert.Equal(t, 0, len(r.cfg.attPool.AggregatedAttestations()), "Did save aggregated att")
-	require.LogsContain(t, hook, "Verified and saved pending attestations to pool")
-
-	// Encode the attestation for pubsub and decode the message.
-	buf := new(bytes.Buffer)
-	_, err = p1.Encoding().EncodeGossip(buf, att)
-	require.NoError(t, err)
-	digest, err := r.currentForkDigest()
-	require.NoError(t, err)
-	topic := fmt.Sprintf("/eth2/%x/beacon_attestation_1", digest)
-	m := &pubsub.Message{
-		Message: &pubsubpb.Message{
-			Data:  buf.Bytes(),
-			Topic: &topic,
-		},
-	}
-	_, err = r.decodePubsubMessage(m)
-	require.NoError(t, err)
-
-	// Validate the pubsub message and ignore it as it should already been seen.
-	res, err := r.validateCommitteeIndexBeaconAttestation(ctx, "", m)
-	require.NoError(t, err)
-	require.Equal(t, pubsub.ValidationIgnore, res)
-
-	// Wait for the event to complete.
-	wg.Wait()
-	cancel()
-}
-
 func TestProcessPendingAtts_NoBroadcastWithBadSignature(t *testing.T) {
 	db := dbtest.SetupDB(t)
 	p1 := p2ptest.NewTestP2P(t)
@@ -622,7 +457,8 @@ func TestProcessPendingAtts_HasBlockSaveAggregatedAtt(t *testing.T) {

 	assert.Equal(t, 1, len(r.cfg.attPool.AggregatedAttestations()), "Did not save aggregated att")
 	assert.DeepEqual(t, att, r.cfg.attPool.AggregatedAttestations()[0], "Incorrect saved att")
-	atts := r.cfg.attPool.UnaggregatedAttestations()
+	atts, err := r.cfg.attPool.UnaggregatedAttestations()
+	require.NoError(t, err)
 	assert.Equal(t, 0, len(atts), "Did save aggregated att")
 	require.LogsContain(t, hook, "Verified and saved pending attestations to pool")
 	cancel()
@@ -870,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)
+	})
+}
--- a/beacon-chain/sync/service.go
+++ b/beacon-chain/sync/service.go
@@ -6,6 +6,7 @@ package sync

 import (
 	"context"
+	"encoding/hex"
 	"sync"
 	"time"

@@ -49,6 +50,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )

+// hack to prevent bad holesky block importation
+var badHoleskyRoot [32]byte
+
 var _ runtime.Service = (*Service)(nil)

 const (
@@ -383,3 +387,13 @@ 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)
+}
--- a/beacon-chain/sync/subscriber.go
+++ b/beacon-chain/sync/subscriber.go
@@ -181,12 +181,12 @@ func (s *Service) subscribe(topic string, validator wrappedVal, handle subHandle
 	_, e, err := forks.RetrieveForkDataFromDigest(digest, genRoot[:])
 	if err != nil {
 		// Impossible condition as it would mean digest does not exist.
-		panic(err) // lint:nopanic -- Impossible condition.
+		panic(err)
 	}
 	base := p2p.GossipTopicMappings(topic, e)
 	if base == nil {
 		// Impossible condition as it would mean topic does not exist.
-		panic(fmt.Sprintf("%s is not mapped to any message in GossipTopicMappings", topic)) // lint:nopanic -- Impossible condition.
+		panic(fmt.Sprintf("%s is not mapped to any message in GossipTopicMappings", topic))
 	}
 	return s.subscribeWithBase(s.addDigestToTopic(topic, digest), validator, handle)
 }
@@ -424,6 +424,7 @@ func (s *Service) subscribeToSubnets(
 	validate wrappedVal,
 	handle subHandler,
 	getSubnetsToSubscribe func(currentSlot primitives.Slot) []uint64,
+	getSubnetsToFindPeersOnly func(currentSlot primitives.Slot) []uint64,
 ) bool {
 	// Do not subscribe if not synced.
 	if s.chainStarted.IsSet() && s.cfg.initialSync.Syncing() {
@@ -496,13 +497,13 @@ func (s *Service) subscribeWithParameters(
 	// Retrieve the epoch of the fork corresponding to the digest.
 	_, epoch, err := forks.RetrieveForkDataFromDigest(digest, genesisValidatorsRoot[:])
 	if err != nil {
-		panic(err) // lint:nopanic -- Impossible condition.
+		panic(err)
 	}

 	// Retrieve the base protobuf message.
 	base := p2p.GossipTopicMappings(topicFormat, epoch)
 	if base == nil {
-		panic(fmt.Sprintf("%s is not mapped to any message in GossipTopicMappings", topicFormat)) // lint:nopanic -- Impossible condition.
+		panic(fmt.Sprintf("%s is not mapped to any message in GossipTopicMappings", topicFormat))
 	}

 	// Retrieve the genesis time.
@@ -516,7 +517,7 @@ func (s *Service) subscribeWithParameters(
 	currentSlot := s.cfg.clock.CurrentSlot()

 	// Subscribe to subnets.
-	s.subscribeToSubnets(topicFormat, digest, genesisValidatorsRoot, genesisTime, subscriptions, currentSlot, validate, handle, getSubnetsToSubscribe)
+	s.subscribeToSubnets(topicFormat, digest, genesisValidatorsRoot, genesisTime, subscriptions, currentSlot, validate, handle, getSubnetsToSubscribe, getSubnetsToFindPeersOnly)

 	// Derive a new context and cancel function.
 	ctx, cancel := context.WithCancel(s.ctx)
@@ -528,7 +529,7 @@ func (s *Service) subscribeWithParameters(
 		for {
 			select {
 			case currentSlot := <-ticker.C():
-				isDigestValid := s.subscribeToSubnets(topicFormat, digest, genesisValidatorsRoot, genesisTime, subscriptions, currentSlot, validate, handle, getSubnetsToSubscribe)
+				isDigestValid := s.subscribeToSubnets(topicFormat, digest, genesisValidatorsRoot, genesisTime, subscriptions, currentSlot, validate, handle, getSubnetsToSubscribe, getSubnetsToFindPeersOnly)

 				// Stop the ticker if the digest is not valid. Likely to happen after a hard fork.
 				if !isDigestValid {
--- a/beacon-chain/sync/subscriber_beacon_aggregate_proof_test.go
+++ b/beacon-chain/sync/subscriber_beacon_aggregate_proof_test.go
@@ -57,6 +57,7 @@ func TestBeaconAggregateProofSubscriber_CanSaveUnaggregatedAttestation(t *testin
 	}
 	require.NoError(t, r.beaconAggregateProofSubscriber(context.Background(), a))

-	atts := r.cfg.attPool.UnaggregatedAttestations()
+	atts, err := r.cfg.attPool.UnaggregatedAttestations()
+	require.NoError(t, err)
 	assert.DeepEqual(t, []ethpb.Att{a.Message.Aggregate}, atts, "Did not save unaggregated attestation")
 }
--- a/beacon-chain/sync/subscriber_beacon_attestation.go
+++ b/beacon-chain/sync/subscriber_beacon_attestation.go
@@ -21,6 +21,14 @@ func (s *Service) committeeIndexBeaconAttestationSubscriber(_ context.Context, m
 		return fmt.Errorf("message was not type eth.Att, type=%T", msg)
 	}

+	data := a.GetData()
+
+	if data == nil {
+		return errors.New("nil attestation")
+	}
+	committeeIndex := a.GetCommitteeIndex()
+	s.setSeenCommitteeIndicesSlot(data.Slot, committeeIndex, a.GetAggregationBits())
+
 	if features.Get().EnableExperimentalAttestationPool {
 		return s.cfg.attestationCache.Add(a)
 	} else {
--- a/beacon-chain/sync/sync_fuzz_test.go
+++ b/beacon-chain/sync/sync_fuzz_test.go
@@ -100,7 +100,6 @@ func FuzzValidateBeaconBlockPubSub_Phase0(f *testing.F) {
 		}
 		r.cfg.chain = cService
 		r.cfg.blockNotifier = cService.BlockNotifier()
-		r.cfg.operationNotifier = cService.OperationNotifier()
 		strTop := string(topic)
 		msg := &pubsub.Message{
 			Message: &pb.Message{
@@ -147,14 +146,13 @@ func FuzzValidateBeaconBlockPubSub_Altair(f *testing.F) {
 	}
 	r := &Service{
 		cfg: &config{
-			beaconDB:          db,
-			p2p:               p,
-			initialSync:       &mockSync.Sync{IsSyncing: false},
-			chain:             chainService,
-			clock:             startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
-			blockNotifier:     chainService.BlockNotifier(),
-			operationNotifier: chainService.OperationNotifier(),
-			stateGen:          stateGen,
+			beaconDB:      db,
+			p2p:           p,
+			initialSync:   &mockSync.Sync{IsSyncing: false},
+			chain:         chainService,
+			blockNotifier: chainService.BlockNotifier(),
+			stateGen:      stateGen,
+			clock:         startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
 		},
 		seenBlockCache:      lruwrpr.New(10),
 		badBlockCache:       lruwrpr.New(10),
@@ -184,7 +182,6 @@ func FuzzValidateBeaconBlockPubSub_Altair(f *testing.F) {
 		}
 		r.cfg.chain = cService
 		r.cfg.blockNotifier = cService.BlockNotifier()
-		r.cfg.operationNotifier = cService.OperationNotifier()
 		strTop := string(topic)
 		msg := &pubsub.Message{
 			Message: &pb.Message{
@@ -231,14 +228,13 @@ func FuzzValidateBeaconBlockPubSub_Bellatrix(f *testing.F) {
 	}
 	r := &Service{
 		cfg: &config{
-			beaconDB:          db,
-			p2p:               p,
-			initialSync:       &mockSync.Sync{IsSyncing: false},
-			chain:             chainService,
-			clock:             startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
-			blockNotifier:     chainService.BlockNotifier(),
-			operationNotifier: chainService.OperationNotifier(),
-			stateGen:          stateGen,
+			beaconDB:      db,
+			p2p:           p,
+			initialSync:   &mockSync.Sync{IsSyncing: false},
+			chain:         chainService,
+			clock:         startup.NewClock(chainService.Genesis, chainService.ValidatorsRoot),
+			blockNotifier: chainService.BlockNotifier(),
+			stateGen:      stateGen,
 		},
 		seenBlockCache:      lruwrpr.New(10),
 		badBlockCache:       lruwrpr.New(10),
@@ -268,7 +264,6 @@ func FuzzValidateBeaconBlockPubSub_Bellatrix(f *testing.F) {
 		}
 		r.cfg.chain = cService
 		r.cfg.blockNotifier = cService.BlockNotifier()
-		r.cfg.operationNotifier = cService.OperationNotifier()
 		strTop := string(topic)
 		msg := &pubsub.Message{
 			Message: &pb.Message{
--- a/beacon-chain/sync/validate_beacon_attestation.go
+++ b/beacon-chain/sync/validate_beacon_attestation.go
@@ -2,7 +2,6 @@ package sync

 import (
 	"context"
-	"encoding/binary"
 	"fmt"
 	"reflect"
 	"strings"
@@ -90,7 +89,7 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(

 	if !s.slasherEnabled {
 		// Verify this the first attestation received for the participating validator for the slot.
-		if s.hasSeenUnaggregatedAtt(att) {
+		if s.hasSeenCommitteeIndicesSlot(data.Slot, committeeIndex, att.GetAggregationBits()) {
 			return pubsub.ValidationIgnore, nil
 		}
 		// Reject an attestation if it references an invalid block.
@@ -209,7 +208,7 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(
 		Data: eventData,
 	})

-	s.setSeenUnaggregatedAtt(att)
+	s.setSeenCommitteeIndicesSlot(data.Slot, committeeIndex, attForValidation.GetAggregationBits())

 	// Attach final validated attestation to the message for further pipeline use
 	msg.ValidatorData = attForValidation
@@ -328,59 +327,21 @@ func validateAttestingIndex(
 }

 // Returns true if the attestation was already seen for the participating validator for the slot.
-func (s *Service) hasSeenUnaggregatedAtt(att eth.Att) bool {
+func (s *Service) hasSeenCommitteeIndicesSlot(slot primitives.Slot, committeeID primitives.CommitteeIndex, aggregateBits []byte) bool {
 	s.seenUnAggregatedAttestationLock.RLock()
 	defer s.seenUnAggregatedAttestationLock.RUnlock()
-
-	var attester uint64
-	if att.Version() >= version.Electra {
-		if !att.IsSingle() {
-			log.Debug("Called hasSeenUnaggregatedAtt with a non-single Electra attestation")
-			return false
-		}
-		attester = uint64(att.GetAttestingIndex())
-	} else {
-		aggBits := att.GetAggregationBits()
-		if aggBits.Count() != 1 {
-			log.Debug("Attestation does not have exactly 1 bit set")
-			return false
-		}
-		attester = uint64(att.GetAggregationBits().BitIndices()[0])
-	}
-
-	b := make([]byte, 24)
-	binary.LittleEndian.PutUint64(b, uint64(att.GetData().Slot))
-	binary.LittleEndian.PutUint64(b[8:16], uint64(att.GetCommitteeIndex()))
-	binary.LittleEndian.PutUint64(b[16:], attester)
+	b := append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeID))...)
+	b = append(b, aggregateBits...)
 	_, seen := s.seenUnAggregatedAttestationCache.Get(string(b))
 	return seen
 }

-// Set an incoming attestation as seen for the participating validator for the slot.
-func (s *Service) setSeenUnaggregatedAtt(att eth.Att) {
+// Set committee's indices and slot as seen for incoming attestations.
+func (s *Service) setSeenCommitteeIndicesSlot(slot primitives.Slot, committeeID primitives.CommitteeIndex, aggregateBits []byte) {
 	s.seenUnAggregatedAttestationLock.Lock()
 	defer s.seenUnAggregatedAttestationLock.Unlock()
-
-	var attester uint64
-	if att.Version() >= version.Electra {
-		if !att.IsSingle() {
-			log.Debug("Called setSeenUnaggregatedAtt with a non-single Electra attestation. It will not be marked as seen")
-			return
-		}
-		attester = uint64(att.GetAttestingIndex())
-	} else {
-		aggBits := att.GetAggregationBits()
-		if aggBits.Count() != 1 {
-			log.Debug("Attestation does not have exactly 1 bit set. It will not be marked as seen")
-			return
-		}
-		attester = uint64(att.GetAggregationBits().BitIndices()[0])
-	}
-
-	b := make([]byte, 24)
-	binary.LittleEndian.PutUint64(b, uint64(att.GetData().Slot))
-	binary.LittleEndian.PutUint64(b[8:16], uint64(att.GetCommitteeIndex()))
-	binary.LittleEndian.PutUint64(b[16:], attester)
+	b := append(bytesutil.Bytes32(uint64(slot)), bytesutil.Bytes32(uint64(committeeID))...)
+	b = append(b, bytesutil.SafeCopyBytes(aggregateBits)...)
 	s.seenUnAggregatedAttestationCache.Add(string(b), true)
 }

--- a/beacon-chain/sync/validate_beacon_attestation_test.go
+++ b/beacon-chain/sync/validate_beacon_attestation_test.go
@@ -23,7 +23,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
@@ -466,130 +465,25 @@ func TestService_validateCommitteeIndexBeaconAttestationElectra(t *testing.T) {
 	}
 }

-func TestService_setSeenUnaggregatedAtt(t *testing.T) {
+func TestService_setSeenCommitteeIndicesSlot(t *testing.T) {
 	s := NewService(context.Background(), WithP2P(p2ptest.NewTestP2P(t)))
+	s.initCaches()

-	t.Run("phase0", func(t *testing.T) {
-		s.initCaches()
+	// Empty cache
+	b0 := []byte{9} // 1001
+	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(0, 0, b0))

-		s0c0a0 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 0, CommitteeIndex: 0},
-			AggregationBits: bitfield.Bitlist{0b1001},
-		}
-		s0c0a1 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 0, CommitteeIndex: 0},
-			AggregationBits: bitfield.Bitlist{0b1010},
-		}
-		s0c0a2 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 0, CommitteeIndex: 0},
-			AggregationBits: bitfield.Bitlist{0b1100},
-		}
-		s0c1a0 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 0, CommitteeIndex: 1},
-			AggregationBits: bitfield.Bitlist{0b1001},
-		}
-		s0c2a0 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 0, CommitteeIndex: 2},
-			AggregationBits: bitfield.Bitlist{0b1001},
-		}
-		s1c0a0 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 1, CommitteeIndex: 0},
-			AggregationBits: bitfield.Bitlist{0b1001},
-		}
-		s2c0a0 := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 2, CommitteeIndex: 0},
-			AggregationBits: bitfield.Bitlist{0b1001},
-		}
+	// Cache some entries but same key
+	s.setSeenCommitteeIndicesSlot(0, 0, b0)
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(0, 0, b0))
+	b1 := []byte{14} // 1110
+	s.setSeenCommitteeIndicesSlot(0, 0, b1)
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(0, 0, b0))
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(0, 0, b1))

-		t.Run("empty cache", func(t *testing.T) {
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s0c0a0))
-		})
-		t.Run("ok", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s0c0a0)
-			assert.Equal(t, true, s.hasSeenUnaggregatedAtt(s0c0a0))
-		})
-		t.Run("different slot", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s1c0a0)
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s2c0a0))
-		})
-		t.Run("different committee index", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s0c1a0)
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s0c2a0))
-		})
-		t.Run("different bit", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s0c0a1)
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s0c0a2))
-		})
-		t.Run("0 bits set is considered not seen", func(t *testing.T) {
-			a := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1000}}
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(a))
-		})
-		t.Run("multiple bits set is considered not seen", func(t *testing.T) {
-			a := &ethpb.Attestation{AggregationBits: bitfield.Bitlist{0b1111}}
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(a))
-		})
-	})
-	t.Run("electra", func(t *testing.T) {
-		s.initCaches()
-
-		s0c0a0 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 0},
-			CommitteeId:   0,
-			AttesterIndex: 0,
-		}
-		s0c0a1 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 0},
-			CommitteeId:   0,
-			AttesterIndex: 1,
-		}
-		s0c0a2 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 0},
-			CommitteeId:   0,
-			AttesterIndex: 2,
-		}
-		s0c1a0 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 0},
-			CommitteeId:   1,
-			AttesterIndex: 0,
-		}
-		s0c2a0 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 0},
-			CommitteeId:   2,
-			AttesterIndex: 0,
-		}
-		s1c0a0 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 1},
-			CommitteeId:   0,
-			AttesterIndex: 0,
-		}
-		s2c0a0 := &ethpb.SingleAttestation{
-			Data:          &ethpb.AttestationData{Slot: 2},
-			CommitteeId:   0,
-			AttesterIndex: 0,
-		}
-
-		t.Run("empty cache", func(t *testing.T) {
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s0c0a0))
-		})
-		t.Run("ok", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s0c0a0)
-			assert.Equal(t, true, s.hasSeenUnaggregatedAtt(s0c0a0))
-		})
-		t.Run("different slot", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s1c0a0)
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s2c0a0))
-		})
-		t.Run("different committee index", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s0c1a0)
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s0c2a0))
-		})
-		t.Run("different attester", func(t *testing.T) {
-			s.setSeenUnaggregatedAtt(s0c0a1)
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(s0c0a2))
-		})
-		t.Run("single attestation is considered not seen", func(t *testing.T) {
-			a := &ethpb.AttestationElectra{}
-			assert.Equal(t, false, s.hasSeenUnaggregatedAtt(a))
-		})
-	})
+	// Cache some entries with diff keys
+	s.setSeenCommitteeIndicesSlot(1, 2, b1)
+	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(1, 0, b1))
+	require.Equal(t, false, s.hasSeenCommitteeIndicesSlot(0, 2, b1))
+	require.Equal(t, true, s.hasSeenCommitteeIndicesSlot(1, 2, b1))
 }
--- a/beacon-chain/sync/validate_beacon_blocks.go
+++ b/beacon-chain/sync/validate_beacon_blocks.go
@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/block"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
 	"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"
@@ -71,17 +70,8 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		return pubsub.ValidationReject, errors.New("block.Block is nil")
 	}

-	// Broadcast the block on both block and operation feeds to notify other services in the beacon node
+	// Broadcast the block on a feed to notify other services in the beacon node
 	// of a received block (even if it does not process correctly through a state transition).
-	if s.cfg.operationNotifier != nil {
-		s.cfg.operationNotifier.OperationFeed().Send(&feed.Event{
-			Type: operation.BlockGossipReceived,
-			Data: &operation.BlockGossipReceivedData{
-				SignedBlock: blk,
-			},
-		})
-	}
-
 	s.cfg.blockNotifier.BlockFeed().Send(&feed.Event{
 		Type: blockfeed.ReceivedBlock,
 		Data: &blockfeed.ReceivedBlockData{
@@ -409,6 +399,9 @@ 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[:]))
--- a/beacon-chain/sync/validate_blob.go
+++ b/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.SidecarParentValid(s.hasBadBlock); err != nil {
+	if err := vf.ValidProposerSignature(ctx); err != nil {
 		return pubsub.ValidationReject, err
 	}

-	if err := vf.ValidProposerSignature(ctx); err != nil {
+	if err := vf.SidecarParentValid(s.hasBadBlock); err != nil {
 		return pubsub.ValidationReject, err
 	}

--- a/build/bazel/bazel.go
+++ b/build/bazel/bazel.go
@@ -60,7 +60,6 @@ func NewTmpDir(prefix string) (string, error) {
 // `@go_sdk//:files` in its `data` -- this will make sure the whole toolchain
 // gets pulled into the sandbox as well. Generally, this function should only
 // be called in init().
-// lint:nopanic -- This method is only used for testing.
 func SetGoEnv() {
 	gobin, err := Runfile("bin/go")
 	if err != nil {
--- a/cache/lru/lru_wrpr.go
+++ b/cache/lru/lru_wrpr.go
@@ -10,7 +10,7 @@ import (
 func New(size int) *lru.Cache {
 	cache, err := lru.New(size)
 	if err != nil {
-		panic(fmt.Errorf("lru new failed: %w", err)) // lint:nopanic -- This should never panic.
+		panic(fmt.Errorf("lru new failed: %w", err))
 	}
 	return cache
 }
@@ -20,7 +20,7 @@ func New(size int) *lru.Cache {
 func NewWithEvict(size int, onEvicted func(key interface{}, value interface{})) *lru.Cache {
 	cache, err := lru.NewWithEvict(size, onEvicted)
 	if err != nil {
-		panic(fmt.Errorf("lru new with evict failed: %w", err)) // lint:nopanic -- This should never panic.
+		panic(fmt.Errorf("lru new with evict failed: %w", err))
 	}
 	return cache
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
nisdas	79657b158c	Merge branch 'develop' of https://github.com/prysmaticlabs/geth-sharding into hackSync	2025-03-05 13:33:53 +08:00
nisdas	2c6e028600	Add a Hack	2025-03-03 08:52:20 +08:00
Potuz	a9dc6a1dbb	missing save	2025-03-02 16:48:38 -03:00
Nishant Das	713fd33eb5	Fix Bugs In Sync From Head (#15006 ) * Fix Bugs * Remove log	2025-03-02 16:48:16 -03:00
nisdas	5f56507bee	Merge branch 'sync_from_head' of https://github.com/prysmaticlabs/geth-sharding into hackSync	2025-03-01 07:39:52 +08:00
rkapka	07f0d5ee72	delete on error	2025-02-28 18:16:30 +01:00
rkapka	23bbf2380f	Ignore errors from `hasSeenBit` and don't pack unaggregated attestations	2025-02-28 18:11:47 +01:00
Potuz	9e96de033b	Add feature flag to start from any beacon block in db The new feature flag called --sync-from takes a string that can take values: - `head` or - a 0x-prefixed hex encoded beacon block root. The beacon block root or the head block root has to be known in db and has to be a descendant of the current justified checkpoint.	2025-02-28 10:47:43 -03:00
nisdas	fd41691178	Revert Fallback Sync	2025-02-27 12:11:12 +08:00
nisdas	5916c6e625	Fix Attester Slashing Validation In Electra	2025-02-26 15:09:59 +08:00
terence tsao	0312cb223a	Move blockRoot == badHoleskyRoot earlier	2025-02-25 13:53:24 -08:00
terence tsao	68cf7a59f2	Update BUILD.bazel	2025-02-25 12:46:40 -08:00
Kasey Kirkham	537ddb1a24	reject bad root in receive block(batch)	2025-02-25 14:44:18 -06:00
Kasey Kirkham	7afaa6994b	hardcode root to remove cache eviction possibility	2025-02-25 14:37:50 -06:00
terence tsao	defb3ab87b	Revert terence's downscore change	2025-02-25 11:45:56 -08:00
terence tsao	81dce25c98	Gazelle	2025-02-25 11:41:28 -08:00
Kasey Kirkham	5c409b90bc	hack to downscore peers with bad holesky root	2025-02-25 13:40:33 -06:00
terence tsao	aa47661602	Downscore	2025-02-25 11:29:53 -08:00
potuz	7259a2b983	blacklist on batches too	2025-02-25 16:16:53 -03:00
terence tsao	e9f511ac00	Update bootnodes	2025-02-25 08:39:17 -08:00
potuz	34a68715b8	blacklist bad block	2025-02-25 11:40:35 -03:00
nisdas	c33e0575ab	do not resync	2025-02-25 17:32:16 +08:00