adding debounce to remote key manager

2026-01-11 14:28:09 -05:00 · 2025-11-25 16:34:12 -06:00
544 changed files with 4365 additions and 20467 deletions
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -34,5 +34,4 @@ Fixes #

 - [ ] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
 - [ ] I have included a uniquely named [changelog fragment file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd).
- [ ] I have added a description with sufficient context for reviewers to understand this PR.
- [ ] I have tested that my changes work as expected and I added a testing plan to the PR description (if applicable). 
+- [ ] I have added a description to this PR with sufficient context for reviewers to understand this PR.
--- a/.github/workflows/check-logs.yml
+++ b/.github/workflows/check-logs.yml
@@ -1,23 +0,0 @@
-name: Check log.go files
-on: [ pull_request ]
-
-jobs:
-  check-logs:
-    runs-on: ubuntu-4
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Set up Go 1.25.1
-        uses: actions/setup-go@v5
-        with:
-          go-version: '1.25.1'
-
-      - name: Install ripgrep
-        run: sudo apt-get install -y ripgrep
-
-      - name: Check log.go files
-        run: ./hack/check-logs.sh
--- a/.gitignore
+++ b/.gitignore
@@ -44,6 +44,3 @@ tmp

 # spectest coverage reports
 report.txt
-
-# execution client data
-execution/
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -193,7 +193,6 @@ nogo(
        "//tools/analyzers/featureconfig:go_default_library",
        "//tools/analyzers/gocognit:go_default_library",
        "//tools/analyzers/ineffassign:go_default_library",
-        "//tools/analyzers/httpwriter:go_default_library",
        "//tools/analyzers/interfacechecker:go_default_library",
        "//tools/analyzers/logcapitalization:go_default_library",
        "//tools/analyzers/logruswitherror:go_default_library",
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,151 +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.

-## [v7.1.2](https://github.com/prysmaticlabs/prysm/compare/v7.1.1...v7.1.2) - 2026-01-07
-
-Happy new year! This patch release is very small. The main improvement is better management of pending attestation aggregation via [PR 16153](https://github.com/OffchainLabs/prysm/pull/16153).
-
-### Added
-
- `primitives.BuilderIndex`: SSZ `uint64` wrapper for builder registry indices. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16169)
-
-### Changed
-
- the /eth/v2/beacon/pool/attestations and /eth/v1/beacon/pool/sync_committees now returns a 503 error if the node is still syncing, the rest api is also working in a similar process to gRPC broadcasting immediately now. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16152)
- `validateDataColumn`: Remove error logs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16157)
- Pending aggregates: When multiple aggregated attestations only differing by the aggregator index are in the pending queue, only process one of them. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16153)
-
-### Fixed
-
- Fix the missing fork version object mapping for Fulu in light client p2p. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16151)
- Do not process slots and copy states for next epoch proposers after Fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16168)
-
-## [v7.1.1](https://github.com/prysmaticlabs/prysm/compare/v7.1.0...v7.1.1) - 2025-12-18
-
-Release highlights:
-
- Fixed potential deadlock scenario in data column batch verification
- Improved processing and metrics for cells and proofs
-
-We are aware of [an issue](https://github.com/OffchainLabs/prysm/issues/16160) where Prysm struggles to sync from an out of sync state. We will have another release before the end of the year to address this issue.
-
-Our postmortem document from the December 4th mainnet issue has been published on our [documentation site](https://prysm.offchainlabs.com/docs/misc/mainnet-postmortems/)
-
-### Added
-
- Track the dependent root of the latest finalized checkpoint in forkchoice. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16103)
- Proposal design document to implement graffiti. Currently it is empty by default and the idea is to have it of the form GE168dPR63af. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15983)
- Add support for detecting and logging per address reachability via libp2p AutoNAT v2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16100)
- Static analyzer that ensures each `httputil.HandleError` call is followed by a `return` statement. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16134)
- Prometheus histogram `cells_and_proofs_from_structured_computation_milliseconds` to track computation time for cells and proofs from structured blobs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
- Prometheus histogram `get_blobs_v2_latency_milliseconds` to track RPC latency for `getBlobsV2` calls to the execution layer. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
-
-### Changed
-
- Optimise migratetocold by not doing brute force for loop. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16101)
- e2e sync committee evaluator now skips the first slot after startup, we already skip the fork epoch for checks here, this skip only applies on startup, due to altair always from 0 and validators need to warm up. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16145)
- Run `ComputeCellsAndProofsFromFlat` in parallel to improve performance when computing cells and proofs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
- Run `ComputeCellsAndProofsFromStructured` in parallel to improve performance when computing cells and proofs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16115)
-
-### Removed
-
- Unnecessary copy is removed from Eth1DataHasEnoughSupport. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16118)
-
-### Fixed
-
- Incorrect constructor return type [#16084](https://github.com/OffchainLabs/prysm/pull/16084). [[PR]](https://github.com/prysmaticlabs/prysm/pull/16084)
- Fixed possible race when validating two attestations at the same time. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16105)
- Fix missing return after version header check in SubmitAttesterSlashingsV2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16126)
- Fix deadlock in data column gossip KZG batch verification when a caller times out preventing result delivery. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16141)
- Fixed replay state issue in rest api caused by attester and sync committee duties endpoints. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16136)
- Do not error when committee has been computed correctly but updating the cache failed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16142)
- Prevent blocked sends to the KZG batch verifier when the caller context is already canceled, avoiding useless queueing and potential hangs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16144)
-
-## [v7.1.0](https://github.com/prysmaticlabs/prysm/compare/v7.0.0...v7.1.0) - 2025-12-10
-
-This release includes several key features/fixes. If you are running v7.0.0 then you should update to v7.0.1 or later and remove the flag `--disable-last-epoch-targets`. 
-
-Release highlights:
-
- Backfill is now supported in Fulu. Backfill from checkpoint sync now supports data columns. Run with `--enable-backfill` when using checkpoint sync.
- A new node configuration to custody enough data columns to reconstruct blobs. Use flag `--semi-supernode` to custody at least 50% of the data columns.
- Critical fixes in attestation processing.
-
-A post mortem doc with full details on the mainnet attestation processing issue from December 4th is expected in the coming days. 
-
-### Added
-
- add fulu support to light client processing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15995)
- Record data column gossip KZG batch verification latency in both the pooled worker and fallback paths so the `beacon_kzg_verification_data_column_batch_milliseconds` histogram reflects gossip traffic, annotated with `path` labels to distinguish the sources. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16018)
- Implement Gloas state. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15611)
- Add initial configs for the state-diff feature. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15903)
- Add kv functions for the state-diff feature. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15903)
- Add supported version for fork versions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16030)
- prometheus metric `gossip_attestation_verification_milliseconds` to track attestation gossip topic validation latency. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15785)
- Integrate state-diff into `State()`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16033)
- Implement Gloas fork support in consensus-types/blocks with factory methods, getters, setters, and proto handling. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15618)
- Integrate state-diff into `HasState()`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16045)
- Added `--semi-supernode` flag to custody half of a super node's datacolumn requirements but allowing for reconstruction for blob retrieval. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16029)
- Data column backfill. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15580)
- Backfill metrics for columns: backfill_data_column_sidecar_downloaded, backfill_data_column_sidecar_downloaded_bytes, backfill_batch_columns_download_ms, backfill_batch_columns_verify_ms. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15580)
- prometheus summary `gossip_data_column_sidecar_arrival_milliseconds` to track data column sidecar arrival latency since slot start. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16099)
-
-### Changed
-
- Improve readability in slashing import and remove duplicated code. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15957)
- Use dependent root instead of target when possible. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15996)
- Changed `--subscribe-all-data-subnets` flag to `--supernode` and aliased `--subscribe-all-data-subnets` for existing users. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16012)
- Use explicit slot component timing configs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15999)
- Downgraded log level from INFO to DEBUG on PrepareBeaconProposer updated fee recipients. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15998)
- Change the logging behaviour of Updated fee recipients to only log count of validators at Debug level and all validator indices at Trace level. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15998)
- Stop emitting payload attribute events during late block handling when we are not proposing the next slot. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16026)
- Initialize the `ExecutionRequests` field in gossip block map. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16047)
- Avoid redundant WithHttpEndpoint when JWT is provided. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16032)
- Removed dead slot parameter from blobCacheEntry.filter. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16021)
- Added log prefix to the `genesis` package. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16075)
- Added log prefix to the `params` package. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16075)
- `WithGenesisValidatorsRoot`: Use camelCase for log field param. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16075)
- Move `Origin checkpoint found in db` from WARN to INFO, since it is the expected behaviour. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16075)
- backfill metrics that changed name and/or histogram buckets: backfill_batch_time_verify -> backfill_batch_verify_ms, backfill_batch_time_waiting -> backfill_batch_waiting_ms, backfill_batch_time_roundtrip -> backfill_batch_roundtrip_ms, backfill_blocks_bytes_downloaded -> backfill_blocks_downloaded_bytes, backfill_batch_time_verify -> backfill_batch_verify_ms, backfill_batch_blocks_time_download -> backfill_batch_blocks_download_ms, backfill_batch_blobs_time_download -> backfill_batch_blobs_download_ms, backfill_blobs_bytes_downloaded -> backfill_blocks_downloaded_bytes. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15580)
- Move the "Not enough connected peers" (for a given subnet) from WARN to DEBUG. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16087)
- `blobsDataFromStoredDataColumns`: Ask the use to use the `--supernode` flag and shorten the error mesage. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16097)
- Introduced flag `--ignore-unviable-attestations` (replaces and deprecates `--disable-last-epoch-targets`) to drop attestations whose target state is not viable; default remains to process them unless explicitly enabled. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16094)
-
-### Removed
-
- Remove validator cross-client from end-to-end tests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16025)
- `NUMBER_OF_COLUMNS` configuration (not in the specification any more, replaced by a preset). [[PR]](https://github.com/prysmaticlabs/prysm/pull/16073)
- `MAX_CELLS_IN_EXTENDED_MATRIX` configuration (not in the specification any more). [[PR]](https://github.com/prysmaticlabs/prysm/pull/16073)
-
-### Fixed
-
- Nil check for block if it doesn't exist in the DB in fetchOriginSidecars. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16006)
- Fix proposals progress bar count [#16020](https://github.com/OffchainLabs/prysm/pull/16020). [[PR]](https://github.com/prysmaticlabs/prysm/pull/16020)
- Move `BlockGossipReceived` event to the end of gossip validation. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16031)
- Fix state diff repetitive anchor slot bug. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16037)
- Check the JWT secret length is exactly 256 bits (32 bytes) as per Engine API specification. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15939)
- http_error_count now matches the other cases by listing the endpoint name rather than the actual URL requested. This improves metrics cardinality. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16055)
- Fix array out of bounds in static analyzer. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16058)
- fixes E2E tests to be able to start from Electra genesis fork or future forks. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16048)
- Use head state to validate attestations for old blocks if they are compatible. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16095)
-
-## [v7.0.1](https://github.com/prysmaticlabs/prysm/compare/v7.0.0...v7.0.1) - 2025-12-08
-
-This patch release contains 4 cherry-picked changes to address the mainnet attestation processing issue from 2025-12-04. Operators are encouraged to update to this release as soon as practical. As of this release, the feature flag `--disable-last-epoch-targets` has been deprecated and can be safely removed from your node configuration. 
-
-A post mortem doc with full details is expected to be published later this week.
-
-### Changed
-
- Move the "Not enough connected peers" (for a given subnet) from WARN to DEBUG. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16087)
- Use dependent root instead of target when possible. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15996)
- Introduced flag `--ignore-unviable-attestations` (replaces and deprecates `--disable-last-epoch-targets`) to drop attestations whose target state is not viable; default remains to process them unless explicitly enabled. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16094)
-
-### Fixed
-
- Use head state to validate attestations for old blocks if they are compatible. [[PR]](https://github.com/prysmaticlabs/prysm/pull/16095)
-
-
 ## [v7.0.0](https://github.com/prysmaticlabs/prysm/compare/v6.1.4...v7.0.0) - 2025-11-10

 This is our initial mainnet release for the Ethereum mainnet Fulu fork on December 3rd, 2025. All operators MUST update to v7.0.0 or later release prior to the fulu fork epoch `411392`. See the [Ethereum Foundation blog post](https://blog.ethereum.org/2025/11/06/fusaka-mainnet-announcement) for more information on Fulu.
--- a/10
+++ b/10
@@ -273,16 +273,16 @@ filegroup(
    url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )

-consensus_spec_version = "v1.7.0-alpha.0"
+consensus_spec_version = "v1.6.0"

 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")

 consensus_spec_tests(
    name = "consensus_spec_tests",
    flavors = {
-        "general": "sha256-b+rJOuVqq+Dy53quPcNYcQwPFoMU7Wp7tdUVe7n0g8w=",
-        "minimal": "sha256-qxRIxtjPxVsVCY90WsBJKhk0027XDSmhjnRvRN14V1c=",
-        "mainnet": "sha256-NsuOQG3LzeiEE1TrWuvQ6vu6BboHv7h7f/RTS0pWkCs=",
+        "general": "sha256-54hTaUNF9nLg+hRr3oHoq0yjZpW3MNiiUUuCQu6Rajk=",
+        "minimal": "sha256-1JHIGg3gVMjvcGYRHR5cwdDgOvX47oR/MWp6gyAeZfA=",
+        "mainnet": "sha256-292h3W2Ffts0YExgDTyxYe9Os7R0bZIXuAaMO8P6kl4=",
    },
    version = consensus_spec_version,
 )
@@ -298,7 +298,7 @@ filegroup(
    visibility = ["//visibility:public"],
 )
    """,
-    integrity = "sha256-hwNdUBgdBrkk6pWIpNYbzbwswUuOu6AMD2exN8uv+QQ=",
+    integrity = "sha256-VzBgrEokvYSMIIXVnSA5XS9I3m9oxpvToQGxC1N5lzw=",
    strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
    url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
--- a/api/apiutil/BUILD.bazel
+++ b/api/apiutil/BUILD.bazel
@@ -5,7 +5,6 @@ go_library(
    srcs = [
        "common.go",
        "header.go",
-        "log.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/api/apiutil",
    visibility = ["//visibility:public"],
--- a/api/apiutil/header.go
+++ b/api/apiutil/header.go
@@ -5,6 +5,8 @@ import (
 	"sort"
 	"strconv"
 	"strings"
+
+	log "github.com/sirupsen/logrus"
 )

 type mediaRange struct {
--- a/api/apiutil/log.go
+++ b/api/apiutil/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package apiutil
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/apiutil")
--- a/api/client/beacon/log.go
+++ b/api/client/beacon/log.go
@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package beacon

 import "github.com/sirupsen/logrus"

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/client/beacon")
+var log = logrus.WithField("prefix", "beacon")
--- a/api/client/builder/BUILD.bazel
+++ b/api/client/builder/BUILD.bazel
@@ -6,7 +6,6 @@ go_library(
        "bid.go",
        "client.go",
        "errors.go",
-        "log.go",
        "types.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/api/client/builder",
@@ -64,5 +63,6 @@ go_test(
        "@com_github_ethereum_go_ethereum//common/hexutil: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",
    ],
 )
--- a/api/client/builder/client.go
+++ b/api/client/builder/client.go
@@ -25,7 +25,7 @@ import (
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
+	log "github.com/sirupsen/logrus"
 	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 )

@@ -70,7 +70,7 @@ type requestLogger struct{}
 func (*requestLogger) observe(r *http.Request) (e error) {
 	b := bytes.NewBuffer(nil)
 	if r.Body == nil {
-		log.WithFields(logrus.Fields{
+		log.WithFields(log.Fields{
 			"bodyBase64": "(nil value)",
 			"url":        r.URL.String(),
 		}).Info("Builder http request")
@@ -87,7 +87,7 @@ func (*requestLogger) observe(r *http.Request) (e error) {
 		return err
 	}
 	r.Body = io.NopCloser(b)
-	log.WithFields(logrus.Fields{
+	log.WithFields(log.Fields{
 		"bodyBase64": string(body),
 		"url":        r.URL.String(),
 	}).Info("Builder http request")
--- a/api/client/builder/client_test.go
+++ b/api/client/builder/client_test.go
@@ -23,6 +23,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/testing/assert"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
 	"github.com/OffchainLabs/prysm/v7/testing/util"
+	log "github.com/sirupsen/logrus"
 )

 type roundtrip func(*http.Request) (*http.Response, error)
--- a/api/client/builder/log.go
+++ b/api/client/builder/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package builder
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/client/builder")
--- a/api/client/event/BUILD.bazel
+++ b/api/client/event/BUILD.bazel
@@ -4,7 +4,6 @@ go_library(
    name = "go_default_library",
    srcs = [
        "event_stream.go",
-        "log.go",
        "utils.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/api/client/event",
@@ -24,5 +23,8 @@ go_test(
        "utils_test.go",
    ],
    embed = [":go_default_library"],
-    deps = ["//testing/require:go_default_library"],
+    deps = [
+        "//testing/require:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
+    ],
 )
--- a/api/client/event/event_stream.go
+++ b/api/client/event/event_stream.go
@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/api/client"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )

 const (
--- a/api/client/event/event_stream_test.go
+++ b/api/client/event/event_stream_test.go
@@ -8,6 +8,7 @@ import (
 	"time"

 	"github.com/OffchainLabs/prysm/v7/testing/require"
+	log "github.com/sirupsen/logrus"
 )

 func TestNewEventStream(t *testing.T) {
--- a/api/client/event/log.go
+++ b/api/client/event/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package event
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/client/event")
--- a/api/grpc/BUILD.bazel
+++ b/api/grpc/BUILD.bazel
@@ -4,7 +4,6 @@ go_library(
    name = "go_default_library",
    srcs = [
        "grpcutils.go",
-        "log.go",
        "parameters.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/api/grpc",
--- a/api/grpc/grpcutils.go
+++ b/api/grpc/grpcutils.go
@@ -32,7 +32,7 @@ func LogRequests(
 	)
 	start := time.Now()
 	err := invoker(ctx, method, req, reply, cc, opts...)
-	log.WithField("backend", header["x-backend"]).
+	logrus.WithField("backend", header["x-backend"]).
 		WithField("method", method).WithField("duration", time.Since(start)).
 		Debug("gRPC request finished.")
 	return err
@@ -58,7 +58,7 @@ func LogStream(
 		grpc.Header(&header),
 	)
 	strm, err := streamer(ctx, sd, conn, method, opts...)
-	log.WithField("backend", header["x-backend"]).
+	logrus.WithField("backend", header["x-backend"]).
 		WithField("method", method).
 		Debug("gRPC stream started.")
 	return strm, err
@@ -71,7 +71,7 @@ func AppendHeaders(parent context.Context, headers []string) context.Context {
 		if h != "" {
 			keyValue := strings.Split(h, "=")
 			if len(keyValue) < 2 {
-				log.Warnf("Incorrect gRPC header flag format. Skipping %v", keyValue[0])
+				logrus.Warnf("Incorrect gRPC header flag format. Skipping %v", keyValue[0])
 				continue
 			}
 			parent = metadata.AppendToOutgoingContext(parent, keyValue[0], strings.Join(keyValue[1:], "=")) // nolint:fatcontext
--- a/api/grpc/log.go
+++ b/api/grpc/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package grpc
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/grpc")
--- a/api/server/httprest/log.go
+++ b/api/server/httprest/log.go
@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package httprest

 import "github.com/sirupsen/logrus"

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/server/httprest")
+var log = logrus.WithField("prefix", "httprest")
--- a/api/server/middleware/BUILD.bazel
+++ b/api/server/middleware/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",
        "middleware.go",
        "util.go",
    ],
@@ -28,5 +27,6 @@ go_test(
        "//api:go_default_library",
        "//testing/assert:go_default_library",
        "//testing/require:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
    ],
 )
--- a/api/server/middleware/log.go
+++ b/api/server/middleware/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package middleware
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "api/server/middleware")
--- a/api/server/middleware/middleware.go
+++ b/api/server/middleware/middleware.go
@@ -9,6 +9,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/api/apiutil"
 	"github.com/rs/cors"
+	log "github.com/sirupsen/logrus"
 )

 type Middleware func(http.Handler) http.Handler
--- a/api/server/middleware/middleware_test.go
+++ b/api/server/middleware/middleware_test.go
@@ -10,6 +10,7 @@ import (

 	"github.com/OffchainLabs/prysm/v7/api"
 	"github.com/OffchainLabs/prysm/v7/testing/require"
+	log "github.com/sirupsen/logrus"
 )

 // frozenHeaderRecorder allows asserting that response headers were not modified
--- a/async/BUILD.bazel
+++ b/async/BUILD.bazel
@@ -5,7 +5,6 @@ go_library(
    srcs = [
        "debounce.go",
        "every.go",
-        "log.go",
        "multilock.go",
        "scatter.go",
    ],
--- a/async/every.go
+++ b/async/every.go
@@ -6,6 +6,8 @@ import (
 	"reflect"
 	"runtime"
 	"time"
+
+	log "github.com/sirupsen/logrus"
 )

 // RunEvery runs the provided command periodically.
--- a/async/log.go
+++ b/async/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package async
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "async")
--- a/beacon-chain/blockchain/BUILD.bazel
+++ b/beacon-chain/blockchain/BUILD.bazel
@@ -14,7 +14,6 @@ go_library(
        "head_sync_committee_info.go",
        "init_sync_process_block.go",
        "log.go",
-        "log_helpers.go",
        "merge_ascii_art.go",
        "metrics.go",
        "options.go",
--- a/beacon-chain/blockchain/execution_engine.go
+++ b/beacon-chain/blockchain/execution_engine.go
@@ -323,17 +323,14 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 	var ok bool
 	e := slots.ToEpoch(slot)
 	stateEpoch := slots.ToEpoch(st.Slot())
-	fuluAndNextEpoch := st.Version() >= version.Fulu && e == stateEpoch+1
-	if e == stateEpoch || fuluAndNextEpoch {
+	if e == stateEpoch {
 		val, ok = s.trackedProposer(st, slot)
 		if !ok {
 			return emptyAttri
 		}
 	}
+	st = st.Copy()
 	if slot > st.Slot() {
-		// At this point either we know we are proposing on a future slot or we need to still compute the
-		// right proposer index pre-Fulu, either way we need to copy the state to process it.
-		st = st.Copy()
 		var err error
 		st, err = transition.ProcessSlotsUsingNextSlotCache(ctx, st, headRoot, slot)
 		if err != nil {
@@ -341,7 +338,7 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			return emptyAttri
 		}
 	}
-	if e > stateEpoch && !fuluAndNextEpoch {
+	if e > stateEpoch {
 		emptyAttri := payloadattribute.EmptyWithVersion(st.Version())
 		val, ok = s.trackedProposer(st, slot)
 		if !ok {
--- a/beacon-chain/blockchain/execution_engine_test.go
+++ b/beacon-chain/blockchain/execution_engine_test.go
@@ -1053,3 +1053,40 @@ func TestKZGCommitmentToVersionedHashes(t *testing.T) {
 	require.Equal(t, vhs[0].String(), vh0)
 	require.Equal(t, vhs[1].String(), vh1)
 }
+
+func TestComputePayloadAttribute(t *testing.T) {
+	service, tr := minimalTestService(t, WithPayloadIDCache(cache.NewPayloadIDCache()))
+	ctx := tr.ctx
+
+	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
+
+	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, Index: 0})
+	// Cache hit, advance state, no fee recipient
+	slot := primitives.Slot(1)
+	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+	blk := util.NewBeaconBlockBellatrix()
+	signed, err := consensusblocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	roblock, err := consensusblocks.NewROBlockWithRoot(signed, [32]byte{'a'})
+	require.NoError(t, err)
+	cfg := &postBlockProcessConfig{
+		ctx:     ctx,
+		roblock: roblock,
+	}
+	fcu := &fcuConfig{
+		headState:     st,
+		proposingSlot: slot,
+		headRoot:      [32]byte{},
+	}
+	require.NoError(t, service.computePayloadAttributes(cfg, fcu))
+	require.Equal(t, false, fcu.attributes.IsEmpty())
+	require.Equal(t, params.BeaconConfig().EthBurnAddressHex, common.BytesToAddress(fcu.attributes.SuggestedFeeRecipient()).String())
+
+	// Cache hit, advance state, has fee recipient
+	suggestedAddr := common.HexToAddress("123")
+	service.cfg.TrackedValidatorsCache.Set(cache.TrackedValidator{Active: true, FeeRecipient: primitives.ExecutionAddress(suggestedAddr), Index: 0})
+	service.cfg.PayloadIDCache.Set(slot, [32]byte{}, [8]byte{})
+	require.NoError(t, service.computePayloadAttributes(cfg, fcu))
+	require.Equal(t, false, fcu.attributes.IsEmpty())
+	require.Equal(t, suggestedAddr, common.BytesToAddress(fcu.attributes.SuggestedFeeRecipient()))
+}
--- a/beacon-chain/blockchain/forkchoice_update_execution.go
+++ b/beacon-chain/blockchain/forkchoice_update_execution.go
@@ -12,7 +12,6 @@ import (
 	payloadattribute "github.com/OffchainLabs/prysm/v7/consensus-types/payload-attribute"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
@@ -54,53 +53,58 @@ type fcuConfig struct {
 }

 // sendFCU handles the logic to notify the engine of a forckhoice update
-// when processing an incoming block during regular sync. It
-// always updates the shuffling caches and handles epoch transitions .
-func (s *Service) sendFCU(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
-	if cfg.postState.Version() < version.Fulu {
-		// update the caches to compute the right proposer index
-		// this function is called under a forkchoice lock which we need to release.
-		s.ForkChoicer().Unlock()
-		s.updateCachesPostBlockProcessing(cfg)
-		s.ForkChoicer().Lock()
+// for the first time when processing an incoming block during regular sync. It
+// always updates the shuffling caches and handles epoch transitions when the
+// incoming block is late, preparing payload attributes in this case while it
+// only sends a message with empty attributes for early blocks.
+func (s *Service) sendFCU(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
+	if !s.isNewHead(cfg.headRoot) {
+		return nil
 	}
-	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
-		log.WithError(err).Error("Could not get forkchoice update argument")
-		return
-	}
-	// If head has not been updated and attributes are nil, we can skip the FCU.
-	if !s.isNewHead(cfg.headRoot) && (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) {
-		return
-	}
-	// If we are proposing and we aim to reorg the block, we have already sent FCU with attributes on lateBlockTasks
 	if fcuArgs.attributes != nil && !fcuArgs.attributes.IsEmpty() && s.shouldOverrideFCU(cfg.headRoot, s.CurrentSlot()+1) {
+		return nil
+	}
+	return s.forkchoiceUpdateWithExecution(cfg.ctx, fcuArgs)
+}
+
+// sendFCUWithAttributes computes the payload attributes and sends an FCU message
+// to the engine if needed
+func (s *Service) sendFCUWithAttributes(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
+	slotCtx, cancel := context.WithTimeout(context.Background(), slotDeadline)
+	defer cancel()
+	cfg.ctx = slotCtx
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	if err := s.computePayloadAttributes(cfg, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not compute payload attributes")
 		return
 	}
-	if s.inRegularSync() {
-		go s.forkchoiceUpdateWithExecution(cfg.ctx, fcuArgs)
+	if fcuArgs.attributes.IsEmpty() {
+		return
 	}
-
-	if s.isNewHead(fcuArgs.headRoot) {
-		if err := s.saveHead(cfg.ctx, fcuArgs.headRoot, fcuArgs.headBlock, fcuArgs.headState); err != nil {
-			log.WithError(err).Error("Could not save head")
-		}
-		s.pruneAttsFromPool(s.ctx, fcuArgs.headState, fcuArgs.headBlock)
+	if _, err := s.notifyForkchoiceUpdate(cfg.ctx, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not update forkchoice with payload attributes for proposal")
 	}
 }

-// fockchoiceUpdateWithExecution is a wrapper around notifyForkchoiceUpdate. It gets a forkchoice lock and calls the engine.
-// The caller of this function should NOT have a lock in forkchoice store.
-func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuConfig) {
+// fockchoiceUpdateWithExecution is a wrapper around notifyForkchoiceUpdate. It decides whether a new call to FCU should be made.
+func (s *Service) forkchoiceUpdateWithExecution(ctx context.Context, args *fcuConfig) error {
 	_, span := trace.StartSpan(ctx, "beacon-chain.blockchain.forkchoiceUpdateWithExecution")
 	defer span.End()
 	// Note: Use the service context here to avoid the parent context being ended during a forkchoice update.
 	ctx = trace.NewContext(s.ctx, span)
-	s.ForkChoicer().Lock()
-	defer s.ForkChoicer().Unlock()
 	_, err := s.notifyForkchoiceUpdate(ctx, args)
 	if err != nil {
-		log.WithError(err).Error("Could not notify forkchoice update")
+		return errors.Wrap(err, "could not notify forkchoice update")
 	}
+
+	if err := s.saveHead(ctx, args.headRoot, args.headBlock, args.headState); err != nil {
+		log.WithError(err).Error("Could not save head")
+	}
+
+	// Only need to prune attestations from pool if the head has changed.
+	s.pruneAttsFromPool(s.ctx, args.headState, args.headBlock)
+	return nil
 }

 // shouldOverrideFCU checks whether the incoming block is still subject to being
--- a/beacon-chain/blockchain/forkchoice_update_execution_test.go
+++ b/beacon-chain/blockchain/forkchoice_update_execution_test.go
@@ -97,7 +97,7 @@ func TestService_forkchoiceUpdateWithExecution_exceptionalCases(t *testing.T) {
 		headBlock:     wsb,
 		proposingSlot: service.CurrentSlot() + 1,
 	}
-	service.forkchoiceUpdateWithExecution(ctx, args)
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, args))

 	payloadID, has := service.cfg.PayloadIDCache.PayloadID(2, [32]byte{2})
 	require.Equal(t, true, has)
@@ -151,7 +151,7 @@ func TestService_forkchoiceUpdateWithExecution_SameHeadRootNewProposer(t *testin
 		headRoot:      r,
 		proposingSlot: service.CurrentSlot() + 1,
 	}
-	service.forkchoiceUpdateWithExecution(ctx, args)
+	require.NoError(t, service.forkchoiceUpdateWithExecution(ctx, args))
 }

 func TestShouldOverrideFCU(t *testing.T) {
--- a/beacon-chain/blockchain/log.go
+++ b/beacon-chain/blockchain/log.go
@@ -1,9 +1,164 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package blockchain

-import "github.com/sirupsen/logrus"
+import (
+	"encoding/hex"
+	"fmt"
+	"time"

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/blockchain")
+	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
+	"github.com/OffchainLabs/prysm/v7/config/params"
+	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
+	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v7/runtime/version"
+	prysmTime "github.com/OffchainLabs/prysm/v7/time"
+	"github.com/OffchainLabs/prysm/v7/time/slots"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+)
+
+var log = logrus.WithField("prefix", "blockchain")
+
+// logs state transition related data every slot.
+func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
+	log := log.WithField("slot", b.Slot())
+	if len(b.Body().Attestations()) > 0 {
+		log = log.WithField("attestations", len(b.Body().Attestations()))
+	}
+	if len(b.Body().AttesterSlashings()) > 0 {
+		log = log.WithField("attesterSlashings", len(b.Body().AttesterSlashings()))
+	}
+	if len(b.Body().ProposerSlashings()) > 0 {
+		log = log.WithField("proposerSlashings", len(b.Body().ProposerSlashings()))
+	}
+	if len(b.Body().VoluntaryExits()) > 0 {
+		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
+	}
+	if b.Version() >= version.Altair {
+		agg, err := b.Body().SyncAggregate()
+		if err != nil {
+			return err
+		}
+		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
+	}
+	if b.Version() >= version.Bellatrix {
+		p, err := b.Body().Execution()
+		if err != nil {
+			return err
+		}
+		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
+		txs, err := p.Transactions()
+		switch {
+		case errors.Is(err, consensus_types.ErrUnsupportedField):
+		case err != nil:
+			return err
+		default:
+			log = log.WithField("txCount", len(txs))
+			txsPerSlotCount.Set(float64(len(txs)))
+		}
+	}
+	if b.Version() >= version.Deneb {
+		kzgs, err := b.Body().BlobKzgCommitments()
+		if err != nil {
+			log.WithError(err).Error("Failed to get blob KZG commitments")
+		} else if len(kzgs) > 0 {
+			log = log.WithField("kzgCommitmentCount", len(kzgs))
+		}
+	}
+	if b.Version() >= version.Electra {
+		eReqs, err := b.Body().ExecutionRequests()
+		if err != nil {
+			log.WithError(err).Error("Failed to get execution requests")
+		} else {
+			if len(eReqs.Deposits) > 0 {
+				log = log.WithField("depositRequestCount", len(eReqs.Deposits))
+			}
+			if len(eReqs.Consolidations) > 0 {
+				log = log.WithField("consolidationRequestCount", len(eReqs.Consolidations))
+			}
+			if len(eReqs.Withdrawals) > 0 {
+				log = log.WithField("withdrawalRequestCount", len(eReqs.Withdrawals))
+			}
+		}
+	}
+	log.Info("Finished applying state transition")
+	return nil
+}
+
+func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte, justified, finalized *ethpb.Checkpoint, receivedTime time.Time, genesis time.Time, daWaitedTime time.Duration) error {
+	startTime, err := slots.StartTime(genesis, block.Slot())
+	if err != nil {
+		return err
+	}
+	level := log.Logger.GetLevel()
+	if level >= logrus.DebugLevel {
+		parentRoot := block.ParentRoot()
+		lf := logrus.Fields{
+			"slot":                       block.Slot(),
+			"slotInEpoch":                block.Slot() % params.BeaconConfig().SlotsPerEpoch,
+			"block":                      fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+			"epoch":                      slots.ToEpoch(block.Slot()),
+			"justifiedEpoch":             justified.Epoch,
+			"justifiedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]),
+			"finalizedEpoch":             finalized.Epoch,
+			"finalizedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
+			"parentRoot":                 fmt.Sprintf("0x%s...", hex.EncodeToString(parentRoot[:])[:8]),
+			"version":                    version.String(block.Version()),
+			"sinceSlotStartTime":         prysmTime.Now().Sub(startTime),
+			"chainServiceProcessedTime":  prysmTime.Now().Sub(receivedTime) - daWaitedTime,
+			"dataAvailabilityWaitedTime": daWaitedTime,
+		}
+		log.WithFields(lf).Debug("Synced new block")
+	} else {
+		log.WithFields(logrus.Fields{
+			"slot":           block.Slot(),
+			"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
+			"finalizedEpoch": finalized.Epoch,
+			"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
+			"epoch":          slots.ToEpoch(block.Slot()),
+		}).Info("Synced new block")
+	}
+	return nil
+}
+
+// logs payload related data every slot.
+func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
+	isExecutionBlk, err := blocks.IsExecutionBlock(block.Body())
+	if err != nil {
+		return errors.Wrap(err, "could not determine if block is execution block")
+	}
+	if !isExecutionBlk {
+		return nil
+	}
+	payload, err := block.Body().Execution()
+	if err != nil {
+		return err
+	}
+	if payload.GasLimit() == 0 {
+		return errors.New("gas limit should not be 0")
+	}
+	gasUtilized := float64(payload.GasUsed()) / float64(payload.GasLimit())
+	fields := logrus.Fields{
+		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
+		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash())),
+		"blockNumber": payload.BlockNumber(),
+		"gasUtilized": fmt.Sprintf("%.2f", gasUtilized),
+	}
+	if block.Version() >= version.Capella {
+		withdrawals, err := payload.Withdrawals()
+		if err != nil {
+			return errors.Wrap(err, "could not get withdrawals")
+		}
+		fields["withdrawals"] = len(withdrawals)
+		changes, err := block.Body().BLSToExecutionChanges()
+		if err != nil {
+			return errors.Wrap(err, "could not get BLSToExecutionChanges")
+		}
+		if len(changes) > 0 {
+			fields["blsToExecutionChanges"] = len(changes)
+		}
+	}
+	log.WithFields(fields).Debug("Synced new payload")
+	return nil
+}
--- a/beacon-chain/blockchain/log_helpers.go
+++ b/beacon-chain/blockchain/log_helpers.go
@@ -1,162 +0,0 @@
-package blockchain
-
-import (
-	"encoding/hex"
-	"fmt"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	consensus_types "github.com/OffchainLabs/prysm/v7/consensus-types"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	prysmTime "github.com/OffchainLabs/prysm/v7/time"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-)
-
-// logs state transition related data every slot.
-func logStateTransitionData(b interfaces.ReadOnlyBeaconBlock) error {
-	log := log.WithField("slot", b.Slot())
-	if len(b.Body().Attestations()) > 0 {
-		log = log.WithField("attestations", len(b.Body().Attestations()))
-	}
-	if len(b.Body().AttesterSlashings()) > 0 {
-		log = log.WithField("attesterSlashings", len(b.Body().AttesterSlashings()))
-	}
-	if len(b.Body().ProposerSlashings()) > 0 {
-		log = log.WithField("proposerSlashings", len(b.Body().ProposerSlashings()))
-	}
-	if len(b.Body().VoluntaryExits()) > 0 {
-		log = log.WithField("voluntaryExits", len(b.Body().VoluntaryExits()))
-	}
-	if b.Version() >= version.Altair {
-		agg, err := b.Body().SyncAggregate()
-		if err != nil {
-			return err
-		}
-		log = log.WithField("syncBitsCount", agg.SyncCommitteeBits.Count())
-	}
-	if b.Version() >= version.Bellatrix {
-		p, err := b.Body().Execution()
-		if err != nil {
-			return err
-		}
-		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
-		txs, err := p.Transactions()
-		switch {
-		case errors.Is(err, consensus_types.ErrUnsupportedField):
-		case err != nil:
-			return err
-		default:
-			log = log.WithField("txCount", len(txs))
-			txsPerSlotCount.Set(float64(len(txs)))
-		}
-	}
-	if b.Version() >= version.Deneb {
-		kzgs, err := b.Body().BlobKzgCommitments()
-		if err != nil {
-			log.WithError(err).Error("Failed to get blob KZG commitments")
-		} else if len(kzgs) > 0 {
-			log = log.WithField("kzgCommitmentCount", len(kzgs))
-		}
-	}
-	if b.Version() >= version.Electra {
-		eReqs, err := b.Body().ExecutionRequests()
-		if err != nil {
-			log.WithError(err).Error("Failed to get execution requests")
-		} else {
-			if len(eReqs.Deposits) > 0 {
-				log = log.WithField("depositRequestCount", len(eReqs.Deposits))
-			}
-			if len(eReqs.Consolidations) > 0 {
-				log = log.WithField("consolidationRequestCount", len(eReqs.Consolidations))
-			}
-			if len(eReqs.Withdrawals) > 0 {
-				log = log.WithField("withdrawalRequestCount", len(eReqs.Withdrawals))
-			}
-		}
-	}
-	log.Info("Finished applying state transition")
-	return nil
-}
-
-func logBlockSyncStatus(block interfaces.ReadOnlyBeaconBlock, blockRoot [32]byte, justified, finalized *ethpb.Checkpoint, receivedTime time.Time, genesis time.Time, daWaitedTime time.Duration) error {
-	startTime, err := slots.StartTime(genesis, block.Slot())
-	if err != nil {
-		return err
-	}
-	level := log.Logger.GetLevel()
-	if level >= logrus.DebugLevel {
-		parentRoot := block.ParentRoot()
-		lf := logrus.Fields{
-			"slot":                       block.Slot(),
-			"slotInEpoch":                block.Slot() % params.BeaconConfig().SlotsPerEpoch,
-			"block":                      fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
-			"epoch":                      slots.ToEpoch(block.Slot()),
-			"justifiedEpoch":             justified.Epoch,
-			"justifiedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(justified.Root)[:8]),
-			"finalizedEpoch":             finalized.Epoch,
-			"finalizedRoot":              fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
-			"parentRoot":                 fmt.Sprintf("0x%s...", hex.EncodeToString(parentRoot[:])[:8]),
-			"version":                    version.String(block.Version()),
-			"sinceSlotStartTime":         prysmTime.Now().Sub(startTime),
-			"chainServiceProcessedTime":  prysmTime.Now().Sub(receivedTime) - daWaitedTime,
-			"dataAvailabilityWaitedTime": daWaitedTime,
-		}
-		log.WithFields(lf).Debug("Synced new block")
-	} else {
-		log.WithFields(logrus.Fields{
-			"slot":           block.Slot(),
-			"block":          fmt.Sprintf("0x%s...", hex.EncodeToString(blockRoot[:])[:8]),
-			"finalizedEpoch": finalized.Epoch,
-			"finalizedRoot":  fmt.Sprintf("0x%s...", hex.EncodeToString(finalized.Root)[:8]),
-			"epoch":          slots.ToEpoch(block.Slot()),
-		}).Info("Synced new block")
-	}
-	return nil
-}
-
-// logs payload related data every slot.
-func logPayload(block interfaces.ReadOnlyBeaconBlock) error {
-	isExecutionBlk, err := blocks.IsExecutionBlock(block.Body())
-	if err != nil {
-		return errors.Wrap(err, "could not determine if block is execution block")
-	}
-	if !isExecutionBlk {
-		return nil
-	}
-	payload, err := block.Body().Execution()
-	if err != nil {
-		return err
-	}
-	if payload.GasLimit() == 0 {
-		return errors.New("gas limit should not be 0")
-	}
-	gasUtilized := float64(payload.GasUsed()) / float64(payload.GasLimit())
-	fields := logrus.Fields{
-		"blockHash":   fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
-		"parentHash":  fmt.Sprintf("%#x", bytesutil.Trunc(payload.ParentHash())),
-		"blockNumber": payload.BlockNumber(),
-		"gasUtilized": fmt.Sprintf("%.2f", gasUtilized),
-	}
-	if block.Version() >= version.Capella {
-		withdrawals, err := payload.Withdrawals()
-		if err != nil {
-			return errors.Wrap(err, "could not get withdrawals")
-		}
-		fields["withdrawals"] = len(withdrawals)
-		changes, err := block.Body().BLSToExecutionChanges()
-		if err != nil {
-			return errors.Wrap(err, "could not get BLSToExecutionChanges")
-		}
-		if len(changes) > 0 {
-			fields["blsToExecutionChanges"] = len(changes)
-		}
-	}
-	log.WithFields(fields).Debug("Synced new payload")
-	return nil
-}
--- a/beacon-chain/blockchain/log_test.go
+++ b/beacon-chain/blockchain/log_test.go
@@ -34,7 +34,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" package=beacon-chain/blockchain slot=0",
+			want: "\"Finished applying state transition\" prefix=blockchain slot=0",
 		},
 		{name: "has attestation",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -42,7 +42,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" attestations=1 package=beacon-chain/blockchain slot=0",
+			want: "\"Finished applying state transition\" attestations=1 prefix=blockchain slot=0",
 		},
 		{name: "has deposit",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -53,7 +53,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" attestations=1 package=beacon-chain/blockchain slot=0",
+			want: "\"Finished applying state transition\" attestations=1 prefix=blockchain slot=0",
 		},
 		{name: "has attester slashing",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -62,7 +62,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" attesterSlashings=1 package=beacon-chain/blockchain slot=0",
+			want: "\"Finished applying state transition\" attesterSlashings=1 prefix=blockchain slot=0",
 		},
 		{name: "has proposer slashing",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -71,7 +71,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" package=beacon-chain/blockchain proposerSlashings=1 slot=0",
+			want: "\"Finished applying state transition\" prefix=blockchain proposerSlashings=1 slot=0",
 		},
 		{name: "has exit",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -80,7 +80,7 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" package=beacon-chain/blockchain slot=0 voluntaryExits=1",
+			want: "\"Finished applying state transition\" prefix=blockchain slot=0 voluntaryExits=1",
 		},
 		{name: "has everything",
 			b: func() interfaces.ReadOnlyBeaconBlock {
@@ -93,11 +93,11 @@ func Test_logStateTransitionData(t *testing.T) {
 				require.NoError(t, err)
 				return wb
 			},
-			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 package=beacon-chain/blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
+			want: "\"Finished applying state transition\" attestations=1 attesterSlashings=1 prefix=blockchain proposerSlashings=1 slot=0 voluntaryExits=1",
 		},
 		{name: "has payload",
 			b:    func() interfaces.ReadOnlyBeaconBlock { return wrappedPayloadBlk },
-			want: "\"Finished applying state transition\" package=beacon-chain/blockchain payloadHash=0x010203 slot=0 syncBitsCount=0 txCount=2",
+			want: "\"Finished applying state transition\" payloadHash=0x010203 prefix=blockchain slot=0 syncBitsCount=0 txCount=2",
 		},
 	}
 	for _, tt := range tests {
--- a/beacon-chain/blockchain/process_attestation_helpers.go
+++ b/beacon-chain/blockchain/process_attestation_helpers.go
@@ -22,7 +22,10 @@ import (
 // The caller of this function must have a lock on forkchoice.
 func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) state.ReadOnlyBeaconState {
 	headEpoch := slots.ToEpoch(s.HeadSlot())
-	if c.Epoch+1 < headEpoch || c.Epoch == 0 {
+	if c.Epoch < headEpoch {
+		return nil
+	}
+	if !s.cfg.ForkChoiceStore.IsCanonical([32]byte(c.Root)) {
 		return nil
 	}
 	// Only use head state if the head state is compatible with the target checkpoint.
@@ -30,13 +33,11 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 	if err != nil {
 		return nil
 	}
-	// headEpoch - 1 equals c.Epoch if c is from the previous epoch and equals c.Epoch - 1 if c is from the current epoch.
-	// We don't use the smaller c.Epoch - 1 because forkchoice would not have the data to answer that.
-	headDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(headRoot), headEpoch-1)
+	headDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(headRoot), c.Epoch)
 	if err != nil {
 		return nil
 	}
-	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), headEpoch-1)
+	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), c.Epoch)
 	if err != nil {
 		return nil
 	}
@@ -45,18 +46,14 @@ func (s *Service) getRecentPreState(ctx context.Context, c *ethpb.Checkpoint) st
 	}

 	// If the head state alone is enough, we can return it directly read only.
-	if c.Epoch <= headEpoch {
+	if c.Epoch == headEpoch {
 		st, err := s.HeadStateReadOnly(ctx)
 		if err != nil {
 			return nil
 		}
 		return st
 	}
-	// At this point we can only have c.Epoch > headEpoch.
-	if !s.cfg.ForkChoiceStore.IsCanonical([32]byte(c.Root)) {
-		return nil
-	}
-	// Advance the head state to the start of the target epoch.
+	// Otherwise we need to advance the head state to the start of the target epoch.
 	// This point can only be reached if c.Root == headRoot and c.Epoch > headEpoch.
 	slot, err := slots.EpochStart(c.Epoch)
 	if err != nil {
--- a/beacon-chain/blockchain/process_attestation_test.go
+++ b/beacon-chain/blockchain/process_attestation_test.go
@@ -170,141 +170,17 @@ func TestService_GetRecentPreState(t *testing.T) {
 	err = s.SetFinalizedCheckpoint(cp0)
 	require.NoError(t, err)

-	st, blk, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
+	st, root, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, root))
 	service.head = &head{
 		root:  [32]byte(ckRoot),
 		state: s,
-		block: blk,
 		slot:  31,
 	}
 	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 1, Root: ckRoot}))
 }

-func TestService_GetRecentPreState_Epoch_0(t *testing.T) {
-	service, _ := minimalTestService(t)
-	ctx := t.Context()
-	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))
-}
-
-func TestService_GetRecentPreState_Old_Checkpoint(t *testing.T) {
-	service, _ := minimalTestService(t)
-	ctx := t.Context()
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	ckRoot := bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
-	cp0 := &ethpb.Checkpoint{Epoch: 0, Root: ckRoot}
-	err = s.SetFinalizedCheckpoint(cp0)
-	require.NoError(t, err)
-
-	st, blk, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	service.head = &head{
-		root:  [32]byte(ckRoot),
-		state: s,
-		block: blk,
-		slot:  33,
-	}
-	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))
-}
-
-func TestService_GetRecentPreState_Same_DependentRoots(t *testing.T) {
-	service, _ := minimalTestService(t)
-	ctx := t.Context()
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	ckRoot := bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
-	cp0 := &ethpb.Checkpoint{Epoch: 0, Root: ckRoot}
-
-	// Create a fork 31 <-- 32 <--- 64
-	//                 \---------33
-	// With the same dependent root at epoch 0 for a checkpoint at epoch 2
-	st, blk, err := prepareForkchoiceState(ctx, 31, [32]byte(ckRoot), [32]byte{}, [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 32, [32]byte{'S'}, blk.Root(), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'T'}, blk.Root(), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	headBlock := blk
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 33, [32]byte{'U'}, [32]byte(ckRoot), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	cpRoot := blk.Root()
-
-	service.head = &head{
-		root:  [32]byte{'T'},
-		block: headBlock,
-		slot:  64,
-		state: s,
-	}
-	require.NotNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 2, Root: cpRoot[:]}))
-}
-
-func TestService_GetRecentPreState_Different_DependentRoots(t *testing.T) {
-	service, _ := minimalTestService(t)
-	ctx := t.Context()
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	ckRoot := bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
-	cp0 := &ethpb.Checkpoint{Epoch: 0, Root: ckRoot}
-
-	// Create a fork 30 <-- 31 <-- 32 <--- 64
-	//                 \---------33
-	// With the same dependent root at epoch 0 for a checkpoint at epoch 2
-	st, blk, err := prepareForkchoiceState(ctx, 30, [32]byte(ckRoot), [32]byte{}, [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 31, [32]byte{'S'}, blk.Root(), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 32, [32]byte{'T'}, blk.Root(), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 64, [32]byte{'U'}, blk.Root(), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	headBlock := blk
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	st, blk, err = prepareForkchoiceState(ctx, 33, [32]byte{'V'}, [32]byte(ckRoot), [32]byte{}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	cpRoot := blk.Root()
-
-	service.head = &head{
-		root:  [32]byte{'U'},
-		block: headBlock,
-		state: s,
-		slot:  64,
-	}
-	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{Epoch: 2, Root: cpRoot[:]}))
-}
-
-func TestService_GetRecentPreState_Different(t *testing.T) {
-	service, _ := minimalTestService(t)
-	ctx := t.Context()
-	s, err := util.NewBeaconState()
-	require.NoError(t, err)
-	ckRoot := bytesutil.PadTo([]byte{'A'}, fieldparams.RootLength)
-	cp0 := &ethpb.Checkpoint{Epoch: 0, Root: ckRoot}
-	err = s.SetFinalizedCheckpoint(cp0)
-	require.NoError(t, err)
-
-	st, blk, err := prepareForkchoiceState(ctx, 33, [32]byte(ckRoot), [32]byte{}, [32]byte{'R'}, cp0, cp0)
-	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blk))
-	service.head = &head{
-		root:  [32]byte(ckRoot),
-		state: s,
-		block: blk,
-		slot:  33,
-	}
-	require.IsNil(t, service.getRecentPreState(ctx, &ethpb.Checkpoint{}))
-}
-
 func TestService_GetAttPreState_Concurrency(t *testing.T) {
 	service, _ := minimalTestService(t)
 	ctx := t.Context()
--- a/beacon-chain/blockchain/process_block.go
+++ b/beacon-chain/blockchain/process_block.go
@@ -66,6 +66,9 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	startTime := time.Now()
 	fcuArgs := &fcuConfig{}

+	if s.inRegularSync() {
+		defer s.handleSecondFCUCall(cfg, fcuArgs)
+	}
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
 	}
@@ -102,17 +105,14 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
 		return nil
 	}
-	s.sendFCU(cfg, fcuArgs)
-
-	// Pre-Fulu the caches are updated when computing the payload attributes
-	if cfg.postState.Version() >= version.Fulu {
-		go func() {
-			ctx, cancel := context.WithTimeout(s.ctx, slotDeadline)
-			defer cancel()
-			cfg.ctx = ctx
-			s.updateCachesPostBlockProcessing(cfg)
-		}()
+	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not get forkchoice update argument")
+		return nil
 	}
+	if err := s.sendFCU(cfg, fcuArgs); err != nil {
+		return errors.Wrap(err, "could not send FCU to engine")
+	}
+
 	return nil
 }

@@ -134,7 +134,7 @@ func getStateVersionAndPayload(st state.BeaconState) (int, interfaces.ExecutionD
 	return preStateVersion, preStateHeader, nil
 }

-func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlock, avs das.AvailabilityChecker) error {
+func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlock, avs das.AvailabilityStore) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.onBlockBatch")
 	defer span.End()

@@ -295,10 +295,18 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
+	arg := &fcuConfig{
+		headState: preState,
+		headRoot:  lastBR,
+		headBlock: lastB,
+	}
+	if _, err := s.notifyForkchoiceUpdate(ctx, arg); err != nil {
+		return err
+	}
 	return s.saveHeadNoDB(ctx, lastB, lastBR, preState, !isValidPayload)
 }

-func (s *Service) areSidecarsAvailable(ctx context.Context, avs das.AvailabilityChecker, roBlock consensusblocks.ROBlock) error {
+func (s *Service) areSidecarsAvailable(ctx context.Context, avs das.AvailabilityStore, roBlock consensusblocks.ROBlock) error {
 	blockVersion := roBlock.Version()
 	block := roBlock.Block()
 	slot := block.Slot()
@@ -322,7 +330,6 @@ func (s *Service) areSidecarsAvailable(ctx context.Context, avs das.Availability
 	return nil
 }

-// the caller of this function must not hold a lock in forkchoice store.
 func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.BeaconState) error {
 	e := coreTime.CurrentEpoch(st)
 	if err := helpers.UpdateCommitteeCache(ctx, st, e); err != nil {
@@ -352,9 +359,7 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 	if e > 0 {
 		e = e - 1
 	}
-	s.ForkChoicer().RLock()
 	target, err := s.cfg.ForkChoiceStore.TargetRootForEpoch(r, e)
-	s.ForkChoicer().RUnlock()
 	if err != nil {
 		log.WithError(err).Error("Could not update proposer index state-root map")
 		return nil
@@ -367,7 +372,7 @@ func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.Beacon
 }

 // Epoch boundary tasks: it copies the headState and updates the epoch boundary
-// caches. The caller of this function must not hold a lock in forkchoice store.
+// caches.
 func (s *Service) handleEpochBoundary(ctx context.Context, slot primitives.Slot, headState state.BeaconState, blockRoot []byte) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.handleEpochBoundary")
 	defer span.End()
@@ -629,7 +634,9 @@ func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldpa
 		return nil, nil
 	}

-	if len(expected) > fieldparams.NumberOfColumns {
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	if uint64(len(expected)) > numberOfColumns {
 		return nil, errMaxDataColumnsExceeded
 	}

@@ -811,9 +818,10 @@ func (s *Service) areDataColumnsAvailable(

 		case <-ctx.Done():
 			var missingIndices any = "all"
-			missingIndicesCount := len(missing)
+			numberOfColumns := params.BeaconConfig().NumberOfColumns
+			missingIndicesCount := uint64(len(missing))

-			if missingIndicesCount < fieldparams.NumberOfColumns {
+			if missingIndicesCount < numberOfColumns {
 				missingIndices = helpers.SortedPrettySliceFromMap(missing)
 			}

@@ -907,6 +915,8 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if currentSlot == s.HeadSlot() {
 		return
 	}
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
 	// return early if we are in init sync
 	if !s.inRegularSync() {
 		return
@@ -919,32 +929,14 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if lastState == nil {
 		lastRoot, lastState = headRoot[:], headState
 	}
-	// Before Fulu we need to process the next slot to find out if we are proposing.
-	if lastState.Version() < version.Fulu {
-		// Copy all the field tries in our cached state in the event of late
-		// blocks.
-		lastState.CopyAllTries()
-		if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
-			log.WithError(err).Debug("Could not update next slot state cache")
-		}
-		if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
-			log.WithError(err).Error("Could not update epoch boundary caches")
-		}
-	} else {
-		// After Fulu, we can update the caches asynchronously after sending FCU to the engine
-		defer func() {
-			go func() {
-				ctx, cancel := context.WithTimeout(s.ctx, slotDeadline)
-				defer cancel()
-				lastState.CopyAllTries()
-				if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
-					log.WithError(err).Debug("Could not update next slot state cache")
-				}
-				if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
-					log.WithError(err).Error("Could not update epoch boundary caches")
-				}
-			}()
-		}()
+	// Copy all the field tries in our cached state in the event of late
+	// blocks.
+	lastState.CopyAllTries()
+	if err := transition.UpdateNextSlotCache(ctx, lastRoot, lastState); err != nil {
+		log.WithError(err).Debug("Could not update next slot state cache")
+	}
+	if err := s.handleEpochBoundary(ctx, currentSlot, headState, headRoot[:]); err != nil {
+		log.WithError(err).Error("Could not update epoch boundary caches")
 	}
 	// return early if we already started building a block for the current
 	// head root
@@ -974,8 +966,6 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 		headBlock:  headBlock,
 		attributes: attribute,
 	}
-	s.cfg.ForkChoiceStore.Lock()
-	defer s.cfg.ForkChoiceStore.Unlock()
 	_, err = s.notifyForkchoiceUpdate(ctx, fcuArgs)
 	if err != nil {
 		log.WithError(err).Debug("could not perform late block tasks: failed to update forkchoice with engine")
--- a/beacon-chain/blockchain/process_block_helpers.go
+++ b/beacon-chain/blockchain/process_block_helpers.go
@@ -42,8 +42,14 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 	if err := s.getFCUArgsEarlyBlock(cfg, fcuArgs); err != nil {
 		return err
 	}
-	fcuArgs.attributes = s.getPayloadAttribute(cfg.ctx, fcuArgs.headState, fcuArgs.proposingSlot, cfg.headRoot[:])
-	return nil
+	if !s.inRegularSync() {
+		return nil
+	}
+	slot := cfg.roblock.Block().Slot()
+	if slots.WithinVotingWindow(s.genesisTime, slot) {
+		return nil
+	}
+	return s.computePayloadAttributes(cfg, fcuArgs)
 }

 func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
@@ -167,19 +173,26 @@ func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {

 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch
 // boundary in order to compute the right proposer indices after processing
-// state transition. The caller of this function must not hold a lock in forkchoice store.
-func (s *Service) updateCachesPostBlockProcessing(cfg *postBlockProcessConfig) {
+// state transition. This function is called on late blocks while still locked,
+// before sending FCU to the engine.
+func (s *Service) updateCachesPostBlockProcessing(cfg *postBlockProcessConfig) error {
 	slot := cfg.postState.Slot()
 	root := cfg.roblock.Root()
 	if err := transition.UpdateNextSlotCache(cfg.ctx, root[:], cfg.postState); err != nil {
-		log.WithError(err).Error("Could not update next slot state cache")
-		return
+		return errors.Wrap(err, "could not update next slot state cache")
 	}
 	if !slots.IsEpochEnd(slot) {
-		return
+		return nil
 	}
-	if err := s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, root[:]); err != nil {
-		log.WithError(err).Error("Could not handle epoch boundary")
+	return s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, root[:])
+}
+
+// handleSecondFCUCall handles a second call to FCU when syncing a new block.
+// This is useful when proposing in the next block and we want to defer the
+// computation of the next slot shuffling.
+func (s *Service) handleSecondFCUCall(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) {
+	if (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) && cfg.headRoot == cfg.roblock.Root() {
+		go s.sendFCUWithAttributes(cfg, fcuArgs)
 	}
 }

@@ -189,6 +202,20 @@ func reportProcessingTime(startTime time.Time) {
 	onBlockProcessingTime.Observe(float64(time.Since(startTime).Milliseconds()))
 }

+// computePayloadAttributes modifies the passed FCU arguments to
+// contain the right payload attributes with the tracked proposer. It gets
+// called on blocks that arrive after the attestation voting window, or in a
+// background routine after syncing early blocks.
+func (s *Service) computePayloadAttributes(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
+	if cfg.roblock.Root() == cfg.headRoot {
+		if err := s.updateCachesPostBlockProcessing(cfg); err != nil {
+			return err
+		}
+	}
+	fcuArgs.attributes = s.getPayloadAttribute(cfg.ctx, fcuArgs.headState, fcuArgs.proposingSlot, cfg.headRoot[:])
+	return nil
+}
+
 // getBlockPreState returns the pre state of an incoming block. It uses the parent root of the block
 // to retrieve the state in DB. It verifies the pre state's validity and the incoming block
 // is in the correct time window.
--- a/beacon-chain/blockchain/process_block_test.go
+++ b/beacon-chain/blockchain/process_block_test.go
@@ -738,9 +738,7 @@ func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -790,9 +788,7 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -820,9 +816,25 @@ func TestOnBlock_NilBlock(t *testing.T) {
 	service, tr := minimalTestService(t)
 	signed := &consensusblocks.SignedBeaconBlock{}
 	roblock := consensusblocks.ROBlock{ReadOnlySignedBeaconBlock: signed}
-	service.cfg.ForkChoiceStore.Lock()
 	err := service.postBlockProcess(&postBlockProcessConfig{tr.ctx, roblock, [32]byte{}, nil, true})
-	service.cfg.ForkChoiceStore.Unlock()
+	require.Equal(t, true, IsInvalidBlock(err))
+}
+
+func TestOnBlock_InvalidSignature(t *testing.T) {
+	service, tr := minimalTestService(t)
+	ctx := tr.ctx
+
+	gs, keys := util.DeterministicGenesisState(t, 32)
+	require.NoError(t, service.saveGenesisData(ctx, gs))
+
+	blk, err := util.GenerateFullBlock(gs, keys, util.DefaultBlockGenConfig(), 1)
+	require.NoError(t, err)
+	blk.Signature = []byte{'a'} // Mutate the signature.
+	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	preState, err := service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	_, err = service.validateStateTransition(ctx, preState, wsb)
 	require.Equal(t, true, IsInvalidBlock(err))
 }

@@ -854,9 +866,7 @@ func TestOnBlock_CallNewPayloadAndForkchoiceUpdated(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, r, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 		testState, err = service.cfg.StateGen.StateByRoot(ctx, r)
 		require.NoError(t, err)
 	}
@@ -1329,9 +1339,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb1, r1)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1343,9 +1351,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb2, r2)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1357,9 +1363,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb3, r3)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1371,9 +1375,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 			lock.Lock()
 			roblock, err := consensusblocks.NewROBlockWithRoot(wsb4, r4)
 			require.NoError(t, err)
-			service.cfg.ForkChoiceStore.Lock()
 			require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-			service.cfg.ForkChoiceStore.Unlock()
 			lock.Unlock()
 			wg.Done()
 		}()
@@ -1398,6 +1400,197 @@ func Test_verifyBlkFinalizedSlot_invalidBlock(t *testing.T) {
 	require.Equal(t, true, IsInvalidBlock(err))
 }

+// See the description in #10777 and #10782 for the full setup
+// We sync optimistically a chain of blocks. Block 17 is the last block in Epoch
+// 2. Block 18 justifies block 12 (the first in Epoch 2) and Block 19 returns
+// INVALID from FCU, with LVH block 17. No head is viable. We check
+// that the node is optimistic and that we can actually import a block on top of
+// 17 and recover.
+func TestStore_NoViableHead_FCU(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.SlotsPerEpoch = 6
+	config.AltairForkEpoch = 1
+	config.BellatrixForkEpoch = 2
+	params.OverrideBeaconConfig(config)
+
+	mockEngine := &mockExecution.EngineClient{ErrNewPayload: execution.ErrAcceptedSyncingPayloadStatus, ErrForkchoiceUpdated: execution.ErrAcceptedSyncingPayloadStatus}
+	service, tr := minimalTestService(t, WithExecutionEngineCaller(mockEngine))
+	ctx := tr.ctx
+
+	st, keys := 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")
+
+	for i := 1; i < 6; i++ {
+		driftGenesisTime(service, primitives.Slot(i), 0)
+		st, err := service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
+		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))
+		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
+		require.NoError(t, err)
+		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+	}
+
+	for i := 6; i < 12; i++ {
+		driftGenesisTime(service, primitives.Slot(i), 0)
+		st, err := service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlockAltair(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
+		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))
+		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
+		require.NoError(t, err)
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
+	}
+
+	for i := 12; i < 18; i++ {
+		driftGenesisTime(service, primitives.Slot(i), 0)
+		st, err := service.HeadState(ctx)
+		require.NoError(t, err)
+		b, err := util.GenerateFullBlockBellatrix(st, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
+		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))
+		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
+		require.NoError(t, err)
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
+	}
+	// Check that we haven't justified the second epoch yet
+	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
+	require.Equal(t, primitives.Epoch(0), jc.Epoch)
+
+	// import a block that justifies the second epoch
+	driftGenesisTime(service, 18, 0)
+	validHeadState, err := service.HeadState(ctx)
+	require.NoError(t, err)
+	b, err := util.GenerateFullBlockBellatrix(validHeadState, keys, util.DefaultBlockGenConfig(), 18)
+	require.NoError(t, err)
+	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	firstInvalidRoot, 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, firstInvalidRoot, wsb, postState))
+	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, firstInvalidRoot)
+	require.NoError(t, err)
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	require.NoError(t, err)
+	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
+	require.Equal(t, primitives.Epoch(2), jc.Epoch)
+
+	sjc := validHeadState.CurrentJustifiedCheckpoint()
+	require.Equal(t, primitives.Epoch(0), sjc.Epoch)
+	lvh := b.Block.Body.ExecutionPayload.ParentHash
+	// check our head
+	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
+
+	// import another block to find out that it was invalid
+	mockEngine = &mockExecution.EngineClient{ErrNewPayload: execution.ErrAcceptedSyncingPayloadStatus, ErrForkchoiceUpdated: execution.ErrInvalidPayloadStatus, ForkChoiceUpdatedResp: lvh}
+	service.cfg.ExecutionEngineCaller = mockEngine
+	driftGenesisTime(service, 19, 0)
+	st, err = service.HeadState(ctx)
+	require.NoError(t, err)
+	b, err = util.GenerateFullBlockBellatrix(st, keys, util.DefaultBlockGenConfig(), 19)
+	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))
+	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
+	require.NoError(t, err)
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+	require.ErrorContains(t, "received an INVALID payload from execution engine", err)
+	// Check that forkchoice's head is the last invalid block imported. The
+	// store's headroot is the previous head (since the invalid block did
+	// not finish importing) one and that the node is optimistic
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
+	headRoot, err := service.HeadRoot(ctx)
+	require.NoError(t, err)
+	require.Equal(t, firstInvalidRoot, bytesutil.ToBytes32(headRoot))
+	optimistic, err := service.IsOptimistic(ctx)
+	require.NoError(t, err)
+	require.Equal(t, true, optimistic)
+
+	// import another block based on the last valid head state
+	mockEngine = &mockExecution.EngineClient{}
+	service.cfg.ExecutionEngineCaller = mockEngine
+	driftGenesisTime(service, 20, 0)
+	b, err = util.GenerateFullBlockBellatrix(validHeadState, keys, &util.BlockGenConfig{}, 20)
+	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))
+	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
+	require.NoError(t, err)
+	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
+	require.NoError(t, err)
+	// Check the newly imported block is head, it justified the right
+	// checkpoint and the node is no longer optimistic
+	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
+	sjc = service.CurrentJustifiedCheckpt()
+	require.Equal(t, jc.Epoch, sjc.Epoch)
+	require.Equal(t, jc.Root, bytesutil.ToBytes32(sjc.Root))
+	optimistic, err = service.IsOptimistic(ctx)
+	require.NoError(t, err)
+	require.Equal(t, false, optimistic)
+}
+
 // See the description in #10777 and #10782 for the full setup
 // We sync optimistically a chain of blocks. Block 17 is the last block in Epoch
 // 2. Block 18 justifies block 12 (the first in Epoch 2) and Block 19 returns
@@ -1449,9 +1642,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 	}

 	for i := 6; i < 12; i++ {
@@ -1471,9 +1662,8 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}

 	for i := 12; i < 18; i++ {
@@ -1494,9 +1684,8 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 	// Check that we haven't justified the second epoch yet
 	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
@@ -1519,9 +1708,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, firstInvalidRoot, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, firstInvalidRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	jc = service.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	require.Equal(t, primitives.Epoch(2), jc.Epoch)
@@ -1531,10 +1718,6 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	lvh := b.Block.Body.ExecutionPayload.ParentHash
 	// check our head
 	require.Equal(t, firstInvalidRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
-	isBlock18OptimisticAfterImport, err := service.IsOptimisticForRoot(ctx, firstInvalidRoot)
-	require.NoError(t, err)
-	require.Equal(t, true, isBlock18OptimisticAfterImport)
-	time.Sleep(20 * time.Millisecond) // wait for async forkchoice update to be processed

 	// import another block to find out that it was invalid
 	mockEngine = &mockExecution.EngineClient{ErrNewPayload: execution.ErrInvalidPayloadStatus, NewPayloadResp: lvh}
@@ -1585,9 +1768,7 @@ func TestStore_NoViableHead_NewPayload(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	// Check the newly imported block is head, it justified the right
 	// checkpoint and the node is no longer optimistic
@@ -1654,9 +1835,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 	}

 	for i := 6; i < 12; i++ {
@@ -1677,9 +1856,8 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}

 	// import the merge block
@@ -1699,9 +1877,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, lastValidRoot, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, lastValidRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1730,9 +1906,8 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, invalidRoots[i-13], wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, invalidRoots[i-13])
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}
 	// Check that we have justified the second epoch
 	jc := service.cfg.ForkChoiceStore.JustifiedCheckpoint()
@@ -1800,9 +1975,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true}))
-	service.cfg.ForkChoiceStore.Unlock()
 	// Check that the head is still INVALID and the node is still optimistic
 	require.Equal(t, invalidHeadRoot, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	optimistic, err = service.IsOptimistic(ctx)
@@ -1827,9 +2000,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, err)
 		st, err = service.cfg.StateGen.StateByRoot(ctx, root)
 		require.NoError(t, err)
@@ -1857,9 +2028,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err = consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, true})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	require.Equal(t, root, service.cfg.ForkChoiceStore.CachedHeadRoot())
 	sjc = service.CurrentJustifiedCheckpt()
@@ -1903,6 +2072,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot), "Could not save genesis state")

 	for i := 1; i < 6; i++ {
+		t.Log(i)
 		driftGenesisTime(service, primitives.Slot(i), 0)
 		st, err := service.HeadState(ctx)
 		require.NoError(t, err)
@@ -1919,9 +2089,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 	}

 	for i := 6; i < 12; i++ {
@@ -1941,9 +2109,8 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
-		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
+		err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
+		require.NoError(t, err)
 	}

 	// import the merge block
@@ -1963,9 +2130,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, lastValidRoot, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, lastValidRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
 	require.NoError(t, err)
 	// save the post state and the payload Hash of this block since it will
 	// be the LVH
@@ -1996,9 +2161,7 @@ func TestNoViableHead_Reboot(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()
 		require.NoError(t, service.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch))
 		_, err = service.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
 		require.NoError(t, err)
@@ -2119,9 +2282,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()

 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
@@ -2187,9 +2348,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 		roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 		require.NoError(t, err)
-		service.cfg.ForkChoiceStore.Lock()
 		require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-		service.cfg.ForkChoiceStore.Unlock()

 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
@@ -2336,8 +2495,7 @@ func TestMissingBlobIndices(t *testing.T) {
 }

 func TestMissingDataColumnIndices(t *testing.T) {
-	const countPlusOne = fieldparams.NumberOfColumns + 1
-
+	countPlusOne := params.BeaconConfig().NumberOfColumns + 1
 	tooManyColumns := make(map[uint64]bool, countPlusOne)
 	for i := range countPlusOne {
 		tooManyColumns[uint64(i)] = true
@@ -2472,10 +2630,7 @@ func TestRollbackBlock(t *testing.T) {
 	require.NoError(t, err)

 	// Rollback block insertion into db and caches.
-	service.cfg.ForkChoiceStore.Lock()
-	err = service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
-	require.ErrorContains(t, fmt.Sprintf("could not insert block %d to fork choice store", roblock.Block().Slot()), err)
+	require.ErrorContains(t, fmt.Sprintf("could not insert block %d to fork choice store", roblock.Block().Slot()), service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))

 	// The block should no longer exist.
 	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
@@ -2576,9 +2731,7 @@ func TestRollbackBlock_ContextDeadline(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, root, wsb, postState))
 	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, root)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-	service.cfg.ForkChoiceStore.Unlock()

 	b, err = util.GenerateFullBlock(postState, keys, util.DefaultBlockGenConfig(), 34)
 	require.NoError(t, err)
@@ -2612,10 +2765,7 @@ func TestRollbackBlock_ContextDeadline(t *testing.T) {
 	require.NoError(t, postState.SetFinalizedCheckpoint(cj))

 	// Rollback block insertion into db and caches.
-	service.cfg.ForkChoiceStore.Lock()
-	err = service.postBlockProcess(&postBlockProcessConfig{cancCtx, roblock, [32]byte{}, postState, false})
-	service.cfg.ForkChoiceStore.Unlock()
-	require.ErrorContains(t, "context canceled", err)
+	require.ErrorContains(t, "context canceled", service.postBlockProcess(&postBlockProcessConfig{cancCtx, roblock, [32]byte{}, postState, false}))

 	// The block should no longer exist.
 	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
@@ -3111,9 +3261,7 @@ func Test_postBlockProcess_EventSending(t *testing.T) {
 			}

 			// Execute postBlockProcess
-			service.cfg.ForkChoiceStore.Lock()
 			err = service.postBlockProcess(cfg)
-			service.cfg.ForkChoiceStore.Unlock()

 			// Check error expectation
 			if tt.expectError {
--- a/beacon-chain/blockchain/receive_attestation.go
+++ b/beacon-chain/blockchain/receive_attestation.go
@@ -156,15 +156,13 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 	}
 	if s.inRegularSync() {
 		fcuArgs.attributes = s.getPayloadAttribute(ctx, headState, proposingSlot, newHeadRoot[:])
-		if fcuArgs.attributes != nil && s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
-			return
-		}
-		go s.forkchoiceUpdateWithExecution(s.ctx, fcuArgs)
 	}
-	if err := s.saveHead(s.ctx, fcuArgs.headRoot, fcuArgs.headBlock, fcuArgs.headState); err != nil {
-		log.WithError(err).Error("Could not save head")
+	if fcuArgs.attributes != nil && s.shouldOverrideFCU(newHeadRoot, proposingSlot) {
+		return
+	}
+	if err := s.forkchoiceUpdateWithExecution(s.ctx, fcuArgs); err != nil {
+		log.WithError(err).Error("Could not update forkchoice")
 	}
-	s.pruneAttsFromPool(s.ctx, fcuArgs.headState, fcuArgs.headBlock)
 }

 // This processes fork choice attestations from the pool to account for validator votes and fork choice.
--- a/beacon-chain/blockchain/receive_attestation_test.go
+++ b/beacon-chain/blockchain/receive_attestation_test.go
@@ -117,9 +117,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
 	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-	service.cfg.ForkChoiceStore.Unlock()
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
 	require.NoError(t, err)
 	require.Equal(t, 2, fcs.NodeCount())
@@ -179,9 +177,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
 	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
 	require.NoError(t, err)
-	service.cfg.ForkChoiceStore.Lock()
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
-	service.cfg.ForkChoiceStore.Unlock()
 	require.Equal(t, 2, fcs.NodeCount())
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb))
 	require.Equal(t, tRoot, service.head.root)
--- a/beacon-chain/blockchain/receive_block.go
+++ b/beacon-chain/blockchain/receive_block.go
@@ -39,8 +39,8 @@ var epochsSinceFinalityExpandCache = primitives.Epoch(4)

 // BlockReceiver interface defines the methods of chain service for receiving and processing new blocks.
 type BlockReceiver interface {
-	ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityChecker) error
-	ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityChecker) error
+	ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityStore) error
+	ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityStore) error
 	HasBlock(ctx context.Context, root [32]byte) bool
 	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
 	BlockBeingSynced([32]byte) bool
@@ -69,7 +69,7 @@ type SlashingReceiver interface {
 //  1. Validate block, apply state transition and update checkpoints
 //  2. Apply fork choice to the processed block
 //  3. Save latest head info
-func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, avs das.AvailabilityChecker) error {
+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()
 	// Return early if the block is blacklisted
@@ -242,7 +242,7 @@ func (s *Service) validateExecutionAndConsensus(
 	return postState, isValidPayload, nil
 }

-func (s *Service) handleDA(ctx context.Context, avs das.AvailabilityChecker, block blocks.ROBlock) (time.Duration, error) {
+func (s *Service) handleDA(ctx context.Context, avs das.AvailabilityStore, block blocks.ROBlock) (time.Duration, error) {
 	var err error
 	start := time.Now()
 	if avs != nil {
@@ -332,7 +332,7 @@ func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedSta
 // ReceiveBlockBatch processes the whole block batch at once, assuming the block batch is linear ,transitioning
 // the state, performing batch verification of all collected signatures and then performing the appropriate
 // actions for a block post-transition.
-func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityChecker) error {
+func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock, avs das.AvailabilityStore) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.ReceiveBlockBatch")
 	defer span.End()

--- a/beacon-chain/blockchain/receive_block_test.go
+++ b/beacon-chain/blockchain/receive_block_test.go
@@ -17,7 +17,6 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	ethpbv1 "github.com/OffchainLabs/prysm/v7/proto/eth/v1"
@@ -131,10 +130,12 @@ func TestService_ReceiveBlock(t *testing.T) {
 				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-				require.Eventually(t, func() bool {
-					return len(notifier.ReceivedEvents()) >= 1
-				}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+				// Hacky sleep, should use a better way to be able to resolve the race
+				// between event being sent out and processed.
+				time.Sleep(100 * time.Millisecond)
+				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
 			},
 		},
 		{
@@ -221,10 +222,10 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 		require.NoError(t, s.ReceiveBlock(ctx, wsb, root, nil))
 	})
 	wg.Wait()
-	notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-	require.Eventually(t, func() bool {
-		return len(notifier.ReceivedEvents()) >= 1
-	}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+	time.Sleep(100 * time.Millisecond)
+	if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+		t.Errorf("Received %d state notifications, expected at least 1", recvd)
+	}
 	// Verify fork choice has processed the block. (Genesis block and the new block)
 	assert.Equal(t, 2, s.cfg.ForkChoiceStore.NodeCount())
 }
@@ -264,10 +265,10 @@ func TestService_ReceiveBlockBatch(t *testing.T) {
 				block: genFullBlock(t, util.DefaultBlockGenConfig(), 1 /*slot*/),
 			},
 			check: func(t *testing.T, s *Service) {
-				notifier := s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier)
-				require.Eventually(t, func() bool {
-					return len(notifier.ReceivedEvents()) >= 1
-				}, 2*time.Second, 10*time.Millisecond, "Expected at least 1 state notification")
+				time.Sleep(100 * time.Millisecond)
+				if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {
+					t.Errorf("Received %d state notifications, expected at least 1", recvd)
+				}
 			},
 		},
 	}
@@ -511,9 +512,8 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 		s.cfg.StateNotifier = notifier
 		s.executePostFinalizationTasks(s.ctx, headState)

-		require.Eventually(t, func() bool {
-			return len(notifier.ReceivedEvents()) == 1
-		}, 5*time.Second, 50*time.Millisecond, "Expected exactly 1 state notification")
+		time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+		require.Equal(t, 1, len(notifier.ReceivedEvents()))
 		e := notifier.ReceivedEvents()[0]
 		assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
 		fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
@@ -552,9 +552,8 @@ func Test_executePostFinalizationTasks(t *testing.T) {
 		s.cfg.StateNotifier = notifier
 		s.executePostFinalizationTasks(s.ctx, headState)

-		require.Eventually(t, func() bool {
-			return len(notifier.ReceivedEvents()) == 1
-		}, 5*time.Second, 50*time.Millisecond, "Expected exactly 1 state notification")
+		time.Sleep(1 * time.Second) // sleep for a second because event is in a separate go routine
+		require.Equal(t, 1, len(notifier.ReceivedEvents()))
 		e := notifier.ReceivedEvents()[0]
 		assert.Equal(t, statefeed.FinalizedCheckpoint, int(e.Type))
 		fc, ok := e.Data.(*ethpbv1.EventFinalizedCheckpoint)
@@ -597,13 +596,13 @@ func TestProcessLightClientBootstrap(t *testing.T) {

 			s.executePostFinalizationTasks(s.ctx, l.AttestedState)

-			// Wait for the light client bootstrap to be saved (runs in goroutine)
-			var b interfaces.LightClientBootstrap
-			require.Eventually(t, func() bool {
-				var err error
-				b, err = s.lcStore.LightClientBootstrap(ctx, [32]byte(cp.Root))
-				return err == nil && b != nil
-			}, 5*time.Second, 50*time.Millisecond, "Light client bootstrap was not saved within timeout")
+			// wait for the goroutine to finish processing
+			time.Sleep(1 * time.Second)
+
+			// Check that the light client bootstrap is saved
+			b, err := s.lcStore.LightClientBootstrap(ctx, [32]byte(cp.Root))
+			require.NoError(t, err)
+			require.NotNil(t, b)

 			btst, err := lightClient.NewLightClientBootstrapFromBeaconState(ctx, l.FinalizedState.Slot(), l.FinalizedState, l.FinalizedBlock)
 			require.NoError(t, err)
--- a/beacon-chain/blockchain/service.go
+++ b/beacon-chain/blockchain/service.go
@@ -14,7 +14,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v7/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	coreTime "github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/db"
@@ -471,35 +470,30 @@ func (s *Service) removeStartupState() {
 // UpdateCustodyInfoInDB updates the custody information in the database.
 // It returns the (potentially updated) custody group count and the earliest available slot.
 func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot, uint64, error) {
-	isSupernode := flags.Get().Supernode
-	isSemiSupernode := flags.Get().SemiSupernode
+	isSubscribedToAllDataSubnets := flags.Get().SubscribeAllDataSubnets

 	cfg := params.BeaconConfig()
 	custodyRequirement := cfg.CustodyRequirement

 	// Check if the node was previously subscribed to all data subnets, and if so,
 	// store the new status accordingly.
-	wasSupernode, err := s.cfg.BeaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSupernode)
+	wasSubscribedToAllDataSubnets, err := s.cfg.BeaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSubscribedToAllDataSubnets)
 	if err != nil {
-		return 0, 0, errors.Wrap(err, "update subscribed to all data subnets")
+		log.WithError(err).Error("Could not update subscription status to all data subnets")
 	}

-	// Compute the target custody group count based on current flag configuration.
-	targetCustodyGroupCount := custodyRequirement
-
-	// Supernode: custody all groups (either currently set or previously enabled)
-	if isSupernode {
-		targetCustodyGroupCount = cfg.NumberOfCustodyGroups
+	// Warn the user if the node was previously subscribed to all data subnets and is not any more.
+	if wasSubscribedToAllDataSubnets && !isSubscribedToAllDataSubnets {
+		log.Warnf(
+			"Because the flag `--%s` was previously used, the node will still subscribe to all data subnets.",
+			flags.SubscribeAllDataSubnets.Name,
+		)
 	}

-	// Semi-supernode: custody minimum needed for reconstruction, or custody requirement if higher
-	if isSemiSupernode {
-		semiSupernodeCustody, err := peerdas.MinimumCustodyGroupCountToReconstruct()
-		if err != nil {
-			return 0, 0, errors.Wrap(err, "minimum custody group count")
-		}
-
-		targetCustodyGroupCount = max(custodyRequirement, semiSupernodeCustody)
+	// Compute the custody group count.
+	custodyGroupCount := custodyRequirement
+	if isSubscribedToAllDataSubnets {
+		custodyGroupCount = cfg.NumberOfCustodyGroups
 	}

 	// Safely compute the fulu fork slot.
@@ -516,23 +510,12 @@ func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot,
 		}
 	}

-	earliestAvailableSlot, actualCustodyGroupCount, err := s.cfg.BeaconDB.UpdateCustodyInfo(s.ctx, slot, targetCustodyGroupCount)
+	earliestAvailableSlot, custodyGroupCount, err := s.cfg.BeaconDB.UpdateCustodyInfo(s.ctx, slot, custodyGroupCount)
 	if err != nil {
 		return 0, 0, errors.Wrap(err, "update custody info")
 	}

-	if isSupernode {
-		log.WithFields(logrus.Fields{
-			"current": actualCustodyGroupCount,
-			"target":  cfg.NumberOfCustodyGroups,
-		}).Info("Supernode mode enabled. Will custody all data columns going forward.")
-	}
-
-	if wasSupernode && !isSupernode {
-		log.Warningf("Because the `--%s` flag was previously used, the node will continue to act as a super node.", flags.Supernode.Name)
-	}
-
-	return earliestAvailableSlot, actualCustodyGroupCount, nil
+	return earliestAvailableSlot, custodyGroupCount, nil
 }

 func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
--- a/beacon-chain/blockchain/service_test.go
+++ b/beacon-chain/blockchain/service_test.go
@@ -603,6 +603,7 @@ func TestUpdateCustodyInfoInDB(t *testing.T) {
 		custodyRequirement    = uint64(4)
 		earliestStoredSlot    = primitives.Slot(12)
 		numberOfCustodyGroups = uint64(64)
+		numberOfColumns       = uint64(128)
 	)

 	params.SetupTestConfigCleanup(t)
@@ -610,6 +611,7 @@ func TestUpdateCustodyInfoInDB(t *testing.T) {
 	cfg.FuluForkEpoch = fuluForkEpoch
 	cfg.CustodyRequirement = custodyRequirement
 	cfg.NumberOfCustodyGroups = numberOfCustodyGroups
+	cfg.NumberOfColumns = numberOfColumns
 	params.OverrideBeaconConfig(cfg)

 	ctx := t.Context()
@@ -640,7 +642,7 @@ func TestUpdateCustodyInfoInDB(t *testing.T) {

 		resetFlags := flags.Get()
 		gFlags := new(flags.GlobalFlags)
-		gFlags.Supernode = true
+		gFlags.SubscribeAllDataSubnets = true
 		flags.Init(gFlags)
 		defer flags.Init(resetFlags)

@@ -678,7 +680,7 @@ func TestUpdateCustodyInfoInDB(t *testing.T) {
 		// ----------
 		resetFlags := flags.Get()
 		gFlags := new(flags.GlobalFlags)
-		gFlags.Supernode = true
+		gFlags.SubscribeAllDataSubnets = true
 		flags.Init(gFlags)
 		defer flags.Init(resetFlags)

@@ -693,121 +695,4 @@ func TestUpdateCustodyInfoInDB(t *testing.T) {
 		require.Equal(t, slot, actualEas)
 		require.Equal(t, numberOfCustodyGroups, actualCgc)
 	})
-
-	t.Run("Supernode downgrade prevented", func(t *testing.T) {
-		service, requirements := minimalTestService(t)
-		err = requirements.db.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Enable supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.Supernode = true
-		flags.Init(gFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc)
-
-		// Try to downgrade by removing flag
-		gFlags.Supernode = false
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// Should still be supernode
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, numberOfCustodyGroups, actualCgc) // Still 64, not downgraded
-	})
-
-	t.Run("Semi-supernode downgrade prevented", func(t *testing.T) {
-		service, requirements := minimalTestService(t)
-		err = requirements.db.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Enable semi-supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SemiSupernode = true
-		flags.Init(gFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
-		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
-
-		// Try to downgrade by removing flag
-		gFlags.SemiSupernode = false
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// UpdateCustodyInfo should prevent downgrade - custody count should remain at 64
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(slot + 2)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		require.Equal(t, semiSupernodeCustody, actualCgc) // Still 64 due to downgrade prevention by UpdateCustodyInfo
-	})
-
-	t.Run("Semi-supernode to supernode upgrade allowed", func(t *testing.T) {
-		service, requirements := minimalTestService(t)
-		err = requirements.db.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Start with semi-supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SemiSupernode = true
-		flags.Init(gFlags)
-
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
-		require.Equal(t, semiSupernodeCustody, actualCgc) // Semi-supernode custodies 64 groups
-
-		// Upgrade to full supernode
-		gFlags.SemiSupernode = false
-		gFlags.Supernode = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// Should upgrade to full supernode
-		upgradeSlot := slot + 2
-		actualEas, actualCgc, err = service.updateCustodyInfoInDB(upgradeSlot)
-		require.NoError(t, err)
-		require.Equal(t, upgradeSlot, actualEas)           // Earliest slot updates when upgrading
-		require.Equal(t, numberOfCustodyGroups, actualCgc) // Upgraded to 128
-	})
-
-	t.Run("Semi-supernode with high validator requirements uses higher custody", func(t *testing.T) {
-		service, requirements := minimalTestService(t)
-		err = requirements.db.SaveBlock(ctx, roBlock)
-		require.NoError(t, err)
-
-		// Enable semi-supernode
-		resetFlags := flags.Get()
-		gFlags := new(flags.GlobalFlags)
-		gFlags.SemiSupernode = true
-		flags.Init(gFlags)
-		defer flags.Init(resetFlags)
-
-		// Mock a high custody requirement (simulating many validators)
-		// We need to override the custody requirement calculation
-		// For this test, we'll verify the logic by checking if custodyRequirement > 64
-		// Since custodyRequirement in minimalTestService is 4, we can't test the high case here
-		// This would require a different test setup with actual validators
-		slot := fuluForkEpoch*primitives.Slot(cfg.SlotsPerEpoch) + 1
-		actualEas, actualCgc, err := service.updateCustodyInfoInDB(slot)
-		require.NoError(t, err)
-		require.Equal(t, slot, actualEas)
-		semiSupernodeCustody := numberOfCustodyGroups / 2 // 64
-		// With low validator requirements (4), should use semi-supernode minimum (64)
-		require.Equal(t, semiSupernodeCustody, actualCgc)
-	})
 }
--- a/beacon-chain/blockchain/testing/BUILD.bazel
+++ b/beacon-chain/blockchain/testing/BUILD.bazel
@@ -3,10 +3,7 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
    name = "go_default_library",
    testonly = True,
-    srcs = [
-        "log.go",
-        "mock.go",
-    ],
+    srcs = ["mock.go"],
    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/testing",
    visibility = [
        "//beacon-chain:__subpackages__",
--- a/beacon-chain/blockchain/testing/log.go
+++ b/beacon-chain/blockchain/testing/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package testing
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/blockchain/testing")
--- a/beacon-chain/blockchain/testing/mock.go
+++ b/beacon-chain/blockchain/testing/mock.go
@@ -30,6 +30,7 @@ import (
 	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 )

 var ErrNilState = errors.New("nil state")
@@ -266,7 +267,7 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interf
 		if err := s.DB.SaveBlock(ctx, block); err != nil {
 			return err
 		}
-		log.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot())
+		logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot())
 	}
 	s.Root = signingRoot[:]
 	s.Block = block
@@ -274,7 +275,7 @@ func (s *ChainService) ReceiveBlockInitialSync(ctx context.Context, block interf
 }

 // ReceiveBlockBatch processes blocks in batches from initial-sync.
-func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []blocks.ROBlock, _ das.AvailabilityChecker) error {
+func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []blocks.ROBlock, _ das.AvailabilityStore) error {
 	if s.State == nil {
 		return ErrNilState
 	}
@@ -295,7 +296,7 @@ func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []blocks.ROBl
 			if err := s.DB.SaveBlock(ctx, b); err != nil {
 				return err
 			}
-			log.Infof("Saved block with root: %#x at slot %d", signingRoot, b.Block().Slot())
+			logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, b.Block().Slot())
 		}
 		s.Root = signingRoot[:]
 		s.Block = b
@@ -304,7 +305,7 @@ func (s *ChainService) ReceiveBlockBatch(ctx context.Context, blks []blocks.ROBl
 }

 // ReceiveBlock mocks ReceiveBlock method in chain service.
-func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, _ [32]byte, _ das.AvailabilityChecker) error {
+func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, _ [32]byte, _ das.AvailabilityStore) error {
 	if s.ReceiveBlockMockErr != nil {
 		return s.ReceiveBlockMockErr
 	}
@@ -327,7 +328,7 @@ func (s *ChainService) ReceiveBlock(ctx context.Context, block interfaces.ReadOn
 		if err := s.DB.SaveBlock(ctx, block); err != nil {
 			return err
 		}
-		log.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot())
+		logrus.Infof("Saved block with root: %#x at slot %d", signingRoot, block.Block().Slot())
 	}
 	s.Root = signingRoot[:]
 	s.Block = block
@@ -584,11 +585,11 @@ func (s *ChainService) UpdateHead(ctx context.Context, slot primitives.Slot) {
 	ojc := &ethpb.Checkpoint{}
 	st, root, err := prepareForkchoiceState(ctx, slot, bytesutil.ToBytes32(s.Root), [32]byte{}, [32]byte{}, ojc, ojc)
 	if err != nil {
-		log.WithError(err).Error("Could not update head")
+		logrus.WithError(err).Error("Could not update head")
 	}
 	err = s.ForkChoiceStore.InsertNode(ctx, st, root)
 	if err != nil {
-		log.WithError(err).Error("Could not insert node to forkchoice")
+		logrus.WithError(err).Error("Could not insert node to forkchoice")
 	}
 }

--- a/beacon-chain/builder/log.go
+++ b/beacon-chain/builder/log.go
@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package builder

 import "github.com/sirupsen/logrus"

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/builder")
+var log = logrus.WithField("prefix", "builder")
--- a/beacon-chain/cache/BUILD.bazel
+++ b/beacon-chain/cache/BUILD.bazel
@@ -16,7 +16,6 @@ go_library(
        "doc.go",
        "error.go",
        "interfaces.go",
-        "log.go",
        "payload_id.go",
        "proposer_indices.go",
        "proposer_indices_disabled.go",  # keep
--- a/beacon-chain/cache/attestation.go
+++ b/beacon-chain/cache/attestation.go
@@ -9,6 +9,7 @@ import (
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/attestation"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )

 type attGroup struct {
--- a/beacon-chain/cache/committee.go
+++ b/beacon-chain/cache/committee.go
@@ -17,6 +17,7 @@ import (
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	log "github.com/sirupsen/logrus"
 )

 const (
--- a/beacon-chain/cache/depositsnapshot/BUILD.bazel
+++ b/beacon-chain/cache/depositsnapshot/BUILD.bazel
@@ -8,7 +8,6 @@ go_library(
        "deposit_pruner.go",
        "deposit_tree.go",
        "deposit_tree_snapshot.go",
-        "log.go",
        "merkle_tree.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/cache/depositsnapshot",
--- a/beacon-chain/cache/depositsnapshot/deposit_inserter.go
+++ b/beacon-chain/cache/depositsnapshot/deposit_inserter.go
@@ -20,6 +20,7 @@ var (
 		Name: "beacondb_all_deposits_eip4881",
 		Help: "The number of total deposits in memory",
 	})
+	log = logrus.WithField("prefix", "cache")
 )

 // InsertDeposit into the database. If deposit or block number are nil
--- a/beacon-chain/cache/depositsnapshot/log.go
+++ b/beacon-chain/cache/depositsnapshot/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package depositsnapshot
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/cache/depositsnapshot")
--- a/beacon-chain/cache/log.go
+++ b/beacon-chain/cache/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package cache
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/cache")
--- a/beacon-chain/cache/sync_committee.go
+++ b/beacon-chain/cache/sync_committee.go
@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	log "github.com/sirupsen/logrus"
 	"k8s.io/client-go/tools/cache"
 )

--- a/beacon-chain/cache/tracked_validators.go
+++ b/beacon-chain/cache/tracked_validators.go
@@ -9,6 +9,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/sirupsen/logrus"
 )

 const (
@@ -66,7 +67,7 @@ func (t *TrackedValidatorsCache) Validator(index primitives.ValidatorIndex) (Tra

 	val, ok := item.(TrackedValidator)
 	if !ok {
-		log.Errorf("Failed to cast tracked validator from cache, got unexpected item type %T", item)
+		logrus.Errorf("Failed to cast tracked validator from cache, got unexpected item type %T", item)
 		return TrackedValidator{}, false
 	}

@@ -112,7 +113,7 @@ func (t *TrackedValidatorsCache) Indices() map[primitives.ValidatorIndex]bool {
 	for cacheKey := range items {
 		index, err := fromCacheKey(cacheKey)
 		if err != nil {
-			log.WithError(err).Error("Failed to get validator index from cache key")
+			logrus.WithError(err).Error("Failed to get validator index from cache key")
 			continue
 		}

--- a/beacon-chain/core/altair/BUILD.bazel
+++ b/beacon-chain/core/altair/BUILD.bazel
@@ -8,7 +8,6 @@ go_library(
        "deposit.go",
        "epoch_precompute.go",
        "epoch_spec.go",
-        "log.go",
        "reward.go",
        "sync_committee.go",
        "transition.go",
--- a/beacon-chain/core/altair/epoch_spec.go
+++ b/beacon-chain/core/altair/epoch_spec.go
@@ -7,6 +7,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v7/config/params"
+	log "github.com/sirupsen/logrus"
 )

 // ProcessSyncCommitteeUpdates  processes sync client committee updates for the beacon state.
--- a/beacon-chain/core/altair/log.go
+++ b/beacon-chain/core/altair/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package altair
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/altair")
--- a/beacon-chain/core/blocks/BUILD.bazel
+++ b/beacon-chain/core/blocks/BUILD.bazel
@@ -26,7 +26,6 @@ go_library(
        "//beacon-chain/core/time:go_default_library",
        "//beacon-chain/core/validators:go_default_library",
        "//beacon-chain/state:go_default_library",
-        "//config/features:go_default_library",
        "//config/fieldparams:go_default_library",
        "//config/params:go_default_library",
        "//consensus-types:go_default_library",
--- a/beacon-chain/core/blocks/eth1_data.go
+++ b/beacon-chain/core/blocks/eth1_data.go
@@ -60,7 +60,7 @@ func Eth1DataHasEnoughSupport(beaconState state.ReadOnlyBeaconState, data *ethpb
 	voteCount := uint64(0)

 	for _, vote := range beaconState.Eth1DataVotes() {
-		if AreEth1DataEqual(vote, data) {
+		if AreEth1DataEqual(vote, data.Copy()) {
 			voteCount++
 		}
 	}
--- a/beacon-chain/core/blocks/header_test.go
+++ b/beacon-chain/core/blocks/header_test.go
@@ -290,3 +290,52 @@ func TestProcessBlockHeader_OK(t *testing.T) {
 	}
 	assert.Equal(t, true, proto.Equal(nsh, expected), "Expected %v, received %v", expected, nsh)
 }
+
+func TestBlockSignatureSet_OK(t *testing.T) {
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := range validators {
+		validators[i] = &ethpb.Validator{
+			PublicKey:             make([]byte, 32),
+			WithdrawalCredentials: make([]byte, 32),
+			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
+			Slashed:               true,
+		}
+	}
+
+	state, err := util.NewBeaconState()
+	require.NoError(t, err)
+	require.NoError(t, state.SetValidators(validators))
+	require.NoError(t, state.SetSlot(10))
+	require.NoError(t, state.SetLatestBlockHeader(util.HydrateBeaconHeader(&ethpb.BeaconBlockHeader{
+		Slot:          9,
+		ProposerIndex: 0,
+	})))
+
+	latestBlockSignedRoot, err := state.LatestBlockHeader().HashTreeRoot()
+	require.NoError(t, err)
+
+	currentEpoch := time.CurrentEpoch(state)
+	priv, err := bls.RandKey()
+	require.NoError(t, err)
+	pID, err := helpers.BeaconProposerIndex(t.Context(), state)
+	require.NoError(t, err)
+	block := util.NewBeaconBlock()
+	block.Block.Slot = 10
+	block.Block.ProposerIndex = pID
+	block.Block.Body.RandaoReveal = bytesutil.PadTo([]byte{'A', 'B', 'C'}, 96)
+	block.Block.ParentRoot = latestBlockSignedRoot[:]
+	block.Signature, err = signing.ComputeDomainAndSign(state, currentEpoch, block.Block, params.BeaconConfig().DomainBeaconProposer, priv)
+	require.NoError(t, err)
+	proposerIdx, err := helpers.BeaconProposerIndex(t.Context(), state)
+	require.NoError(t, err)
+	validators[proposerIdx].Slashed = false
+	validators[proposerIdx].PublicKey = priv.PublicKey().Marshal()
+	err = state.UpdateValidatorAtIndex(proposerIdx, validators[proposerIdx])
+	require.NoError(t, err)
+	set, err := blocks.BlockSignatureBatch(state, block.Block.ProposerIndex, block.Signature, block.Block.HashTreeRoot)
+	require.NoError(t, err)
+
+	verified, err := set.Verify()
+	require.NoError(t, err)
+	assert.Equal(t, true, verified, "Block signature set returned a set which was unable to be verified")
+}
--- a/beacon-chain/core/blocks/log.go
+++ b/beacon-chain/core/blocks/log.go
@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package blocks

 import "github.com/sirupsen/logrus"

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/blocks")
+var log = logrus.WithField("prefix", "blocks")
--- a/beacon-chain/core/blocks/signature.go
+++ b/beacon-chain/core/blocks/signature.go
@@ -122,6 +122,24 @@ func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState,
 	return nil
 }

+// BlockSignatureBatch retrieves the block signature batch from the provided block and its corresponding state.
+func BlockSignatureBatch(beaconState state.ReadOnlyBeaconState,
+	proposerIndex primitives.ValidatorIndex,
+	sig []byte,
+	rootFunc func() ([32]byte, error)) (*bls.SignatureBatch, error) {
+	currentEpoch := slots.ToEpoch(beaconState.Slot())
+	domain, err := signing.Domain(beaconState.Fork(), currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
+	if err != nil {
+		return nil, err
+	}
+	proposer, err := beaconState.ValidatorAtIndex(proposerIndex)
+	if err != nil {
+		return nil, err
+	}
+	proposerPubKey := proposer.PublicKey
+	return signing.BlockSignatureBatch(proposerPubKey, sig, domain, rootFunc)
+}
+
 // RandaoSignatureBatch retrieves the relevant randao specific signature batch object
 // from a block and its corresponding state.
 func RandaoSignatureBatch(
--- a/beacon-chain/core/blocks/withdrawals.go
+++ b/beacon-chain/core/blocks/withdrawals.go
@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
@@ -213,12 +212,7 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get next withdrawal validator index")
 		}
-		if features.Get().LowValcountSweep {
-			bound := min(uint64(st.NumValidators()), params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-			nextValidatorIndex += primitives.ValidatorIndex(bound)
-		} else {
-			nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
-		}
+		nextValidatorIndex += primitives.ValidatorIndex(params.BeaconConfig().MaxValidatorsPerWithdrawalsSweep)
 		nextValidatorIndex = nextValidatorIndex % primitives.ValidatorIndex(st.NumValidators())
 	} else {
 		nextValidatorIndex = expectedWithdrawals[len(expectedWithdrawals)-1].ValidatorIndex + 1
--- a/beacon-chain/core/electra/BUILD.bazel
+++ b/beacon-chain/core/electra/BUILD.bazel
@@ -9,7 +9,6 @@ go_library(
        "deposits.go",
        "effective_balance_updates.go",
        "error.go",
-        "log.go",
        "registry_updates.go",
        "transition.go",
        "transition_no_verify_sig.go",
--- a/beacon-chain/core/electra/consolidations.go
+++ b/beacon-chain/core/electra/consolidations.go
@@ -17,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )

 // ProcessPendingConsolidations implements the spec definition below. This method makes mutating
@@ -277,12 +278,12 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if uint64(curEpoch) < e {
 			continue
 		}
-		hasBal, err := st.HasPendingBalanceToWithdraw(srcIdx)
+		bal, err := st.PendingBalanceToWithdraw(srcIdx)
 		if err != nil {
 			log.WithError(err).Error("Failed to fetch pending balance to withdraw")
 			continue
 		}
-		if hasBal {
+		if bal > 0 {
 			continue
 		}

--- a/beacon-chain/core/electra/deposits.go
+++ b/beacon-chain/core/electra/deposits.go
@@ -18,6 +18,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )

 // ProcessDeposits is one of the operations performed on each processed
--- a/beacon-chain/core/electra/log.go
+++ b/beacon-chain/core/electra/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package electra
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/electra")
--- a/beacon-chain/core/electra/withdrawals.go
+++ b/beacon-chain/core/electra/withdrawals.go
@@ -17,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )

 // ProcessWithdrawalRequests processes the validator withdrawals from the provided execution payload
--- a/beacon-chain/core/gloas/BUILD.bazel
+++ b/beacon-chain/core/gloas/BUILD.bazel
@@ -1,45 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["bid.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//crypto/bls:go_default_library",
-        "//crypto/bls/common:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["bid_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/interfaces: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",
-        "//proto/prysm/v1alpha1/validator-client:go_default_library",
-        "//runtime/version:go_default_library",
-        "//testing/require:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_prysmaticlabs_fastssz//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
-    ],
-)
--- a/beacon-chain/core/gloas/bid.go
+++ b/beacon-chain/core/gloas/bid.go
@@ -1,197 +0,0 @@
-package gloas
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-// ProcessExecutionPayloadBid processes a signed execution payload bid in the Gloas fork.
-// Spec v1.7.0-alpha.0 (pseudocode):
-// process_execution_payload_bid(state: BeaconState, block: BeaconBlock):
-//
-//	signed_bid = block.body.signed_execution_payload_bid
-//	bid = signed_bid.message
-//	builder_index = bid.builder_index
-//	amount = bid.value
-//	if builder_index == BUILDER_INDEX_SELF_BUILD:
-//	  assert amount == 0
-//	  assert signed_bid.signature == G2_POINT_AT_INFINITY
-//	else:
-//	  assert is_active_builder(state, builder_index)
-//	  assert can_builder_cover_bid(state, builder_index, amount)
-//	  assert verify_execution_payload_bid_signature(state, signed_bid)
-//	assert bid.slot == block.slot
-//	assert bid.parent_block_hash == state.latest_block_hash
-//	assert bid.parent_block_root == block.parent_root
-//	assert bid.prev_randao == get_randao_mix(state, get_current_epoch(state))
-//	if amount > 0:
-//	  state.builder_pending_payments[...] = BuilderPendingPayment(weight=0, withdrawal=BuilderPendingWithdrawal(fee_recipient=bid.fee_recipient, amount=amount, builder_index=builder_index))
-//	state.latest_execution_payload_bid = bid
-func ProcessExecutionPayloadBid(st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) error {
-	signedBid, err := block.Body().SignedExecutionPayloadBid()
-	if err != nil {
-		return fmt.Errorf("failed to get signed execution payload bid: %w", err)
-	}
-
-	wrappedBid, err := blocks.WrappedROSignedExecutionPayloadBid(signedBid)
-	if err != nil {
-		return fmt.Errorf("failed to wrap signed bid: %w", err)
-	}
-
-	bid, err := wrappedBid.Bid()
-	if err != nil {
-		return fmt.Errorf("failed to get bid from wrapped bid: %w", err)
-	}
-
-	builderIndex := bid.BuilderIndex()
-	amount := bid.Value()
-
-	if builderIndex == params.BeaconConfig().BuilderIndexSelfBuild {
-		if amount != 0 {
-			return fmt.Errorf("self-build amount must be zero, got %d", amount)
-		}
-		if wrappedBid.Signature() != common.InfiniteSignature {
-			return errors.New("self-build signature must be point at infinity")
-		}
-	} else {
-		ok, err := st.IsActiveBuilder(builderIndex)
-		if err != nil {
-			return fmt.Errorf("builder active check failed: %w", err)
-		}
-		if !ok {
-			return fmt.Errorf("builder %d is not active", builderIndex)
-		}
-
-		ok, err = st.CanBuilderCoverBid(builderIndex, amount)
-		if err != nil {
-			return fmt.Errorf("builder balance check failed: %w", err)
-		}
-		if !ok {
-			return fmt.Errorf("builder %d cannot cover bid amount %d", builderIndex, amount)
-		}
-
-		if err := validatePayloadBidSignature(st, wrappedBid); err != nil {
-			return fmt.Errorf("bid signature validation failed: %w", err)
-		}
-	}
-
-	if err := validateBidConsistency(st, bid, block); err != nil {
-		return fmt.Errorf("bid consistency validation failed: %w", err)
-	}
-
-	if amount > 0 {
-		feeRecipient := bid.FeeRecipient()
-		pendingPayment := &ethpb.BuilderPendingPayment{
-			Weight: 0,
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: feeRecipient[:],
-				Amount:       amount,
-				BuilderIndex: builderIndex,
-			},
-		}
-		slotIndex := params.BeaconConfig().SlotsPerEpoch + (bid.Slot() % params.BeaconConfig().SlotsPerEpoch)
-		if err := st.SetBuilderPendingPayment(slotIndex, pendingPayment); err != nil {
-			return fmt.Errorf("failed to set pending payment: %w", err)
-		}
-	}
-
-	if err := st.SetExecutionPayloadBid(bid); err != nil {
-		return fmt.Errorf("failed to cache execution payload bid: %w", err)
-	}
-
-	return nil
-}
-
-// validateBidConsistency checks that the bid is consistent with the current beacon state.
-func validateBidConsistency(st state.BeaconState, bid interfaces.ROExecutionPayloadBid, block interfaces.ReadOnlyBeaconBlock) error {
-	if bid.Slot() != block.Slot() {
-		return fmt.Errorf("bid slot %d does not match block slot %d", bid.Slot(), block.Slot())
-	}
-
-	latestBlockHash, err := st.LatestBlockHash()
-	if err != nil {
-		return fmt.Errorf("failed to get latest block hash: %w", err)
-	}
-	if bid.ParentBlockHash() != latestBlockHash {
-		return fmt.Errorf("bid parent block hash mismatch: got %x, expected %x",
-			bid.ParentBlockHash(), latestBlockHash)
-	}
-
-	if bid.ParentBlockRoot() != block.ParentRoot() {
-		return fmt.Errorf("bid parent block root mismatch: got %x, expected %x",
-			bid.ParentBlockRoot(), block.ParentRoot())
-	}
-
-	randaoMix, err := helpers.RandaoMix(st, slots.ToEpoch(st.Slot()))
-	if err != nil {
-		return fmt.Errorf("failed to get randao mix: %w", err)
-	}
-	if bid.PrevRandao() != [32]byte(randaoMix) {
-		return fmt.Errorf("bid prev randao mismatch: got %x, expected %x", bid.PrevRandao(), randaoMix)
-	}
-
-	return nil
-}
-
-// validatePayloadBidSignature verifies the BLS signature on a signed execution payload bid.
-// It validates that the signature was created by the builder specified in the bid
-// using the appropriate domain for the beacon builder.
-func validatePayloadBidSignature(st state.ReadOnlyBeaconState, signedBid interfaces.ROSignedExecutionPayloadBid) error {
-	bid, err := signedBid.Bid()
-	if err != nil {
-		return fmt.Errorf("failed to get bid: %w", err)
-	}
-
-	builder, err := st.BuilderAtIndex(bid.BuilderIndex())
-	if err != nil {
-		return fmt.Errorf("failed to get builder: %w", err)
-	}
-	if len(builder.Pubkey) != fieldparams.BLSPubkeyLength {
-		return fmt.Errorf("invalid builder public key length: %d", len(builder.Pubkey))
-	}
-
-	publicKey, err := bls.PublicKeyFromBytes(builder.Pubkey)
-	if err != nil {
-		return fmt.Errorf("invalid builder public key: %w", err)
-	}
-
-	signatureBytes := signedBid.Signature()
-	signature, err := bls.SignatureFromBytes(signatureBytes[:])
-	if err != nil {
-		return fmt.Errorf("invalid signature format: %w", err)
-	}
-
-	currentEpoch := slots.ToEpoch(bid.Slot())
-	domain, err := signing.Domain(
-		st.Fork(),
-		currentEpoch,
-		params.BeaconConfig().DomainBeaconBuilder,
-		st.GenesisValidatorsRoot(),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing domain: %w", err)
-	}
-
-	signingRoot, err := signedBid.SigningRoot(domain)
-	if err != nil {
-		return fmt.Errorf("failed to compute signing root: %w", err)
-	}
-
-	if !signature.Verify(publicKey, signingRoot[:]) {
-		return fmt.Errorf("signature verification failed: %w", signing.ErrSigFailedToVerify)
-	}
-
-	return nil
-}
--- a/beacon-chain/core/gloas/bid_test.go
+++ b/beacon-chain/core/gloas/bid_test.go
@@ -1,628 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/signing"
-	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls"
-	"github.com/OffchainLabs/prysm/v7/crypto/bls/common"
-	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
-	enginev1 "github.com/OffchainLabs/prysm/v7/proto/engine/v1"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	validatorpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/validator-client"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-	fastssz "github.com/prysmaticlabs/fastssz"
-	"google.golang.org/protobuf/proto"
-)
-
-type stubBlockBody struct {
-	signedBid *ethpb.SignedExecutionPayloadBid
-}
-
-func (s stubBlockBody) Version() int                                 { return version.Gloas }
-func (s stubBlockBody) RandaoReveal() [96]byte                       { return [96]byte{} }
-func (s stubBlockBody) Eth1Data() *ethpb.Eth1Data                    { return nil }
-func (s stubBlockBody) Graffiti() [32]byte                           { return [32]byte{} }
-func (s stubBlockBody) ProposerSlashings() []*ethpb.ProposerSlashing { return nil }
-func (s stubBlockBody) AttesterSlashings() []ethpb.AttSlashing       { return nil }
-func (s stubBlockBody) Attestations() []ethpb.Att                    { return nil }
-func (s stubBlockBody) Deposits() []*ethpb.Deposit                   { return nil }
-func (s stubBlockBody) VoluntaryExits() []*ethpb.SignedVoluntaryExit { return nil }
-func (s stubBlockBody) SyncAggregate() (*ethpb.SyncAggregate, error) { return nil, nil }
-func (s stubBlockBody) IsNil() bool                                  { return s.signedBid == nil }
-func (s stubBlockBody) HashTreeRoot() ([32]byte, error)              { return [32]byte{}, nil }
-func (s stubBlockBody) Proto() (proto.Message, error)                { return nil, nil }
-func (s stubBlockBody) Execution() (interfaces.ExecutionData, error) { return nil, nil }
-func (s stubBlockBody) BLSToExecutionChanges() ([]*ethpb.SignedBLSToExecutionChange, error) {
-	return nil, nil
-}
-func (s stubBlockBody) BlobKzgCommitments() ([][]byte, error) { return nil, nil }
-func (s stubBlockBody) ExecutionRequests() (*enginev1.ExecutionRequests, error) {
-	return nil, nil
-}
-func (s stubBlockBody) PayloadAttestations() ([]*ethpb.PayloadAttestation, error) {
-	return nil, nil
-}
-func (s stubBlockBody) SignedExecutionPayloadBid() (*ethpb.SignedExecutionPayloadBid, error) {
-	return s.signedBid, nil
-}
-func (s stubBlockBody) MarshalSSZ() ([]byte, error)         { return nil, nil }
-func (s stubBlockBody) MarshalSSZTo([]byte) ([]byte, error) { return nil, nil }
-func (s stubBlockBody) UnmarshalSSZ([]byte) error           { return nil }
-func (s stubBlockBody) SizeSSZ() int                        { return 0 }
-
-type stubBlock struct {
-	slot       primitives.Slot
-	proposer   primitives.ValidatorIndex
-	parentRoot [32]byte
-	body       stubBlockBody
-	v          int
-}
-
-func (s stubBlock) Slot() primitives.Slot                    { return s.slot }
-func (s stubBlock) ProposerIndex() primitives.ValidatorIndex { return s.proposer }
-func (s stubBlock) ParentRoot() [32]byte                     { return s.parentRoot }
-func (s stubBlock) StateRoot() [32]byte                      { return [32]byte{} }
-func (s stubBlock) Body() interfaces.ReadOnlyBeaconBlockBody { return s.body }
-func (s stubBlock) IsNil() bool                              { return false }
-func (s stubBlock) IsBlinded() bool                          { return false }
-func (s stubBlock) HashTreeRoot() ([32]byte, error)          { return [32]byte{}, nil }
-func (s stubBlock) Proto() (proto.Message, error)            { return nil, nil }
-func (s stubBlock) MarshalSSZ() ([]byte, error)              { return nil, nil }
-func (s stubBlock) MarshalSSZTo([]byte) ([]byte, error)      { return nil, nil }
-func (s stubBlock) UnmarshalSSZ([]byte) error                { return nil }
-func (s stubBlock) SizeSSZ() int                             { return 0 }
-func (s stubBlock) Version() int                             { return s.v }
-func (s stubBlock) AsSignRequestObject() (validatorpb.SignRequestObject, error) {
-	return nil, nil
-}
-func (s stubBlock) HashTreeRootWith(*fastssz.Hasher) error { return nil }
-
-func buildGloasState(t *testing.T, slot primitives.Slot, proposerIdx primitives.ValidatorIndex, builderIdx primitives.BuilderIndex, balance uint64, randao [32]byte, latestHash [32]byte, builderPubkey [48]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = bytes.Repeat([]byte{0xAA}, 32)
-		stateRoots[i] = bytes.Repeat([]byte{0xBB}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = randao[:]
-	}
-
-	withdrawalCreds := make([]byte, 32)
-	withdrawalCreds[0] = cfg.BuilderWithdrawalPrefixByte
-
-	validatorCount := int(proposerIdx) + 1
-	validators := make([]*ethpb.Validator, validatorCount)
-	balances := make([]uint64, validatorCount)
-	for i := range validatorCount {
-		validators[i] = &ethpb.Validator{
-			PublicKey:                  builderPubkey[:],
-			WithdrawalCredentials:      withdrawalCreds,
-			EffectiveBalance:           balance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 0,
-			ActivationEpoch:            0,
-			ExitEpoch:                  cfg.FarFutureEpoch,
-			WithdrawableEpoch:          cfg.FarFutureEpoch,
-		}
-		balances[i] = balance
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{Withdrawal: &ethpb.BuilderPendingWithdrawal{}}
-	}
-
-	var builders []*ethpb.Builder
-	if builderIdx != params.BeaconConfig().BuilderIndexSelfBuild {
-		builderCount := int(builderIdx) + 1
-		builders = make([]*ethpb.Builder, builderCount)
-		builders[builderCount-1] = &ethpb.Builder{
-			Pubkey:            builderPubkey[:],
-			Version:           []byte{0},
-			ExecutionAddress:  bytes.Repeat([]byte{0x01}, 20),
-			Balance:           primitives.Gwei(balance),
-			DepositEpoch:      0,
-			WithdrawableEpoch: cfg.FarFutureEpoch,
-		}
-	}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  slot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x11}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x22}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x22}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                blockRoots,
-		StateRoots:                stateRoots,
-		RandaoMixes:               randaoMixes,
-		Validators:                validators,
-		Balances:                  balances,
-		LatestBlockHash:           latestHash[:],
-		BuilderPendingPayments:    payments,
-		BuilderPendingWithdrawals: []*ethpb.BuilderPendingWithdrawal{},
-		Builders:                  builders,
-		FinalizedCheckpoint: &ethpb.Checkpoint{
-			Epoch: 1,
-		},
-	}
-
-	st, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return st.(*state_native.BeaconState)
-}
-
-func signBid(t *testing.T, sk common.SecretKey, bid *ethpb.ExecutionPayloadBid, fork *ethpb.Fork, genesisRoot [32]byte) [96]byte {
-	t.Helper()
-	epoch := slots.ToEpoch(primitives.Slot(bid.Slot))
-	domain, err := signing.Domain(fork, epoch, params.BeaconConfig().DomainBeaconBuilder, genesisRoot[:])
-	require.NoError(t, err)
-	root, err := signing.ComputeSigningRoot(bid, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(root[:]).Marshal()
-	var out [96]byte
-	copy(out[:], sig)
-	return out
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildSuccess(t *testing.T) {
-	slot := primitives.Slot(12)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-	pubKey := [48]byte{}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  0,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(0), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-}
-
-func TestProcessExecutionPayloadBid_SelfBuildNonZeroAmountFails(t *testing.T) {
-	slot := primitives.Slot(2)
-	proposerIdx := primitives.ValidatorIndex(0)
-	builderIdx := params.BeaconConfig().BuilderIndexSelfBuild
-	randao := [32]byte{}
-	latestHash := [32]byte{1}
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinActivationBalance+1000, randao, latestHash, [48]byte{})
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:             randao[:],
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
-	}
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: common.InfiniteSignature[:],
-	}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err := ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "self-build amount must be zero", err)
-}
-
-func TestProcessExecutionPayloadBid_PendingPaymentAndCacheBid(t *testing.T) {
-	slot := primitives.Slot(8)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	pub := sk.PublicKey().Marshal()
-	var pubKey [48]byte
-	copy(pubKey[:], pub)
-
-	balance := params.BeaconConfig().MinActivationBalance + 1_000_000
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, balance, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  500_000,
-		ExecutionPayment:       1,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{
-		Message:   bid,
-		Signature: sig[:],
-	}
-
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx, // not self-build
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	require.NoError(t, ProcessExecutionPayloadBid(state, block))
-
-	stateProto, ok := state.ToProto().(*ethpb.BeaconStateGloas)
-	require.Equal(t, true, ok)
-	slotIndex := params.BeaconConfig().SlotsPerEpoch + (slot % params.BeaconConfig().SlotsPerEpoch)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.BuilderPendingPayments[slotIndex].Withdrawal.Amount)
-
-	require.NotNil(t, stateProto.LatestExecutionPayloadBid)
-	require.Equal(t, primitives.BuilderIndex(1), stateProto.LatestExecutionPayloadBid.BuilderIndex)
-	require.Equal(t, primitives.Gwei(500_000), stateProto.LatestExecutionPayloadBid.Value)
-}
-
-func TestProcessExecutionPayloadBid_BuilderNotActive(t *testing.T) {
-	slot := primitives.Slot(4)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x01}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x02}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-	// Make builder inactive by setting withdrawable_epoch.
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	stateProto.Builders[int(builderIdx)].WithdrawableEpoch = 0
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	state = stateIface.(*state_native.BeaconState)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0x03}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x04}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x05}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x06}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "is not active", err)
-}
-
-func TestProcessExecutionPayloadBid_CannotCoverBid(t *testing.T) {
-	slot := primitives.Slot(5)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0x0A}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0x0B}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+10, randao, latestHash, pubKey)
-	stateProto := state.ToProto().(*ethpb.BeaconStateGloas)
-	// Add pending balances to push below required balance.
-	stateProto.BuilderPendingWithdrawals = []*ethpb.BuilderPendingWithdrawal{
-		{Amount: 15, BuilderIndex: builderIdx},
-	}
-	stateProto.BuilderPendingPayments = []*ethpb.BuilderPendingPayment{
-		{Withdrawal: &ethpb.BuilderPendingWithdrawal{Amount: 20, BuilderIndex: builderIdx}},
-	}
-	stateIface, err := state_native.InitializeFromProtoGloas(stateProto)
-	require.NoError(t, err)
-	state = stateIface.(*state_native.BeaconState)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  25,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "cannot cover bid amount", err)
-}
-
-func TestProcessExecutionPayloadBid_InvalidSignature(t *testing.T) {
-	slot := primitives.Slot(6)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xCC}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xDD}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  10,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xEE}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xFF}, 20),
-	}
-	// Use an invalid signature.
-	invalidSig := [96]byte{1}
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: invalidSig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "bid signature validation failed", err)
-}
-
-func TestProcessExecutionPayloadBid_SlotMismatch(t *testing.T) {
-	slot := primitives.Slot(10)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0xAA}, 32),
-		BlockHash:              bytes.Repeat([]byte{0xBB}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot + 1, // mismatch
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0xCC}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0xDD}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "bid slot", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentHashMismatch(t *testing.T) {
-	slot := primitives.Slot(11)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        bytes.Repeat([]byte{0x11}, 32), // mismatch
-		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block hash mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_ParentRootMismatch(t *testing.T) {
-	slot := primitives.Slot(12)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	parentRoot := bytes.Repeat([]byte{0x22}, 32)
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        parentRoot,
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             randao[:],
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bytes.Repeat([]byte{0x99}, 32)), // mismatch
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "parent block root mismatch", err)
-}
-
-func TestProcessExecutionPayloadBid_PrevRandaoMismatch(t *testing.T) {
-	slot := primitives.Slot(13)
-	builderIdx := primitives.BuilderIndex(1)
-	proposerIdx := primitives.ValidatorIndex(2)
-	randao := [32]byte(bytes.Repeat([]byte{0xAA}, 32))
-	latestHash := [32]byte(bytes.Repeat([]byte{0xBB}, 32))
-
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	var pubKey [48]byte
-	copy(pubKey[:], sk.PublicKey().Marshal())
-
-	state := buildGloasState(t, slot, proposerIdx, builderIdx, params.BeaconConfig().MinDepositAmount+1000, randao, latestHash, pubKey)
-
-	bid := &ethpb.ExecutionPayloadBid{
-		ParentBlockHash:        latestHash[:],
-		ParentBlockRoot:        bytes.Repeat([]byte{0x22}, 32),
-		BlockHash:              bytes.Repeat([]byte{0x33}, 32),
-		PrevRandao:             bytes.Repeat([]byte{0x01}, 32), // mismatch
-		GasLimit:               1,
-		BuilderIndex:           builderIdx,
-		Slot:                   slot,
-		Value:                  1,
-		ExecutionPayment:       0,
-		BlobKzgCommitmentsRoot: bytes.Repeat([]byte{0x44}, 32),
-		FeeRecipient:           bytes.Repeat([]byte{0x55}, 20),
-	}
-	genesis := bytesutil.ToBytes32(state.GenesisValidatorsRoot())
-	sig := signBid(t, sk, bid, state.Fork(), genesis)
-	signed := &ethpb.SignedExecutionPayloadBid{Message: bid, Signature: sig[:]}
-	block := stubBlock{
-		slot:       slot,
-		proposer:   proposerIdx,
-		parentRoot: bytesutil.ToBytes32(bid.ParentBlockRoot),
-		body:       stubBlockBody{signedBid: signed},
-		v:          version.Gloas,
-	}
-
-	err = ProcessExecutionPayloadBid(state, block)
-	require.ErrorContains(t, "prev randao mismatch", err)
-}
--- a/beacon-chain/core/helpers/BUILD.bazel
+++ b/beacon-chain/core/helpers/BUILD.bazel
@@ -8,7 +8,6 @@ go_library(
        "block.go",
        "genesis.go",
        "legacy.go",
-        "log.go",
        "metrics.go",
        "randao.go",
        "ranges.go",
--- a/beacon-chain/core/helpers/log.go
+++ b/beacon-chain/core/helpers/log.go
@@ -1,9 +0,0 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
-package helpers
-
-import "github.com/sirupsen/logrus"
-
-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/helpers")
--- a/beacon-chain/core/helpers/sync_committee.go
+++ b/beacon-chain/core/helpers/sync_committee.go
@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v7/time/slots"
 	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
 )

 var (
--- a/beacon-chain/core/helpers/validators.go
+++ b/beacon-chain/core/helpers/validators.go
@@ -21,6 +21,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
+	log "github.com/sirupsen/logrus"
 )

 var (
@@ -151,7 +152,7 @@ func ActiveValidatorIndices(ctx context.Context, s state.ReadOnlyBeaconState, ep
 	}

 	if err := UpdateCommitteeCache(ctx, s, epoch); err != nil {
-		log.WithError(err).Error("Could not update committee cache")
+		return nil, errors.Wrap(err, "could not update committee cache")
 	}

 	return indices, nil
--- a/beacon-chain/core/peerdas/BUILD.bazel
+++ b/beacon-chain/core/peerdas/BUILD.bazel
@@ -45,13 +45,12 @@ go_test(
        "p2p_interface_test.go",
        "reconstruction_helpers_test.go",
        "reconstruction_test.go",
-        "semi_supernode_test.go",
        "utils_test.go",
        "validator_test.go",
        "verification_test.go",
    ],
-    embed = [":go_default_library"],
    deps = [
+        ":go_default_library",
        "//beacon-chain/blockchain/kzg:go_default_library",
        "//beacon-chain/state/state-native:go_default_library",
        "//config/fieldparams:go_default_library",
--- a/beacon-chain/core/peerdas/das_core.go
+++ b/beacon-chain/core/peerdas/das_core.go
@@ -5,7 +5,6 @@ import (
 	"math"
 	"slices"

-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/crypto/hash"
 	"github.com/OffchainLabs/prysm/v7/encoding/bytesutil"
@@ -97,7 +96,8 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 		return nil, ErrCustodyGroupTooLarge
 	}

-	numberOfColumns := uint64(fieldparams.NumberOfColumns)
+	numberOfColumns := cfg.NumberOfColumns
+
 	columnsPerGroup := numberOfColumns / numberOfCustodyGroups

 	columns := make([]uint64, 0, columnsPerGroup)
@@ -112,9 +112,8 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 // ComputeCustodyGroupForColumn computes the custody group for a given column.
 // It is the reciprocal function of ComputeColumnsForCustodyGroup.
 func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
-	const numberOfColumns = fieldparams.NumberOfColumns
-
 	cfg := params.BeaconConfig()
+	numberOfColumns := cfg.NumberOfColumns
 	numberOfCustodyGroups := cfg.NumberOfCustodyGroups

 	if columnIndex >= numberOfColumns {
--- a/beacon-chain/core/peerdas/das_core_test.go
+++ b/beacon-chain/core/peerdas/das_core_test.go
@@ -30,6 +30,7 @@ func TestComputeColumnsForCustodyGroup(t *testing.T) {
 func TestComputeCustodyGroupForColumn(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	config := params.BeaconConfig()
+	config.NumberOfColumns = 128
 	config.NumberOfCustodyGroups = 64
 	params.OverrideBeaconConfig(config)

--- a/beacon-chain/core/peerdas/info.go
+++ b/beacon-chain/core/peerdas/info.go
@@ -2,7 +2,6 @@ package peerdas

 import (
 	"encoding/binary"
-	"maps"
 	"sync"

 	"github.com/ethereum/go-ethereum/p2p/enode"
@@ -108,102 +107,3 @@ func computeInfoCacheKey(nodeID enode.ID, custodyGroupCount uint64) [nodeInfoCac

 	return key
 }
-
-// ColumnIndices represents as a set of ColumnIndices. This could be the set of indices that a node is required to custody,
-// the set that a peer custodies, missing indices for a given block, indices that are present on disk, etc.
-type ColumnIndices map[uint64]struct{}
-
-// Has returns true if the index is present in the ColumnIndices.
-func (ci ColumnIndices) Has(index uint64) bool {
-	_, ok := ci[index]
-	return ok
-}
-
-// Count returns the number of indices present in the ColumnIndices.
-func (ci ColumnIndices) Count() int {
-	return len(ci)
-}
-
-// Set sets the index in the ColumnIndices.
-func (ci ColumnIndices) Set(index uint64) {
-	ci[index] = struct{}{}
-}
-
-// Unset removes the index from the ColumnIndices.
-func (ci ColumnIndices) Unset(index uint64) {
-	delete(ci, index)
-}
-
-// Copy creates a copy of the ColumnIndices.
-func (ci ColumnIndices) Copy() ColumnIndices {
-	newCi := make(ColumnIndices, len(ci))
-	maps.Copy(newCi, ci)
-	return newCi
-}
-
-// Intersection returns a new ColumnIndices that contains only the indices that are present in both ColumnIndices.
-func (ci ColumnIndices) Intersection(other ColumnIndices) ColumnIndices {
-	result := make(ColumnIndices)
-	for index := range ci {
-		if other.Has(index) {
-			result.Set(index)
-		}
-	}
-	return result
-}
-
-// Merge mutates the receiver so that any index that is set in either of
-// the two ColumnIndices is set in the receiver after the function finishes.
-// It does not mutate the other ColumnIndices given as a function argument.
-func (ci ColumnIndices) Merge(other ColumnIndices) {
-	for index := range other {
-		ci.Set(index)
-	}
-}
-
-// ToMap converts a ColumnIndices into a map[uint64]struct{}.
-// In the future ColumnIndices may be changed to a bit map, so using
-// ToMap will ensure forwards-compatibility.
-func (ci ColumnIndices) ToMap() map[uint64]struct{} {
-	return ci.Copy()
-}
-
-// ToSlice converts a ColumnIndices into a slice of uint64 indices.
-func (ci ColumnIndices) ToSlice() []uint64 {
-	indices := make([]uint64, 0, len(ci))
-	for index := range ci {
-		indices = append(indices, index)
-	}
-	return indices
-}
-
-// NewColumnIndicesFromSlice creates a ColumnIndices from a slice of uint64.
-func NewColumnIndicesFromSlice(indices []uint64) ColumnIndices {
-	ci := make(ColumnIndices, len(indices))
-	for _, index := range indices {
-		ci[index] = struct{}{}
-	}
-	return ci
-}
-
-// NewColumnIndicesFromMap creates a ColumnIndices from a map[uint64]bool. This kind of map
-// is used in several places in peerdas code. Converting from this map type to ColumnIndices
-// will allow us to move ColumnIndices underlying type to a bitmap in the future and avoid
-// lots of loops for things like intersections/unions or copies.
-func NewColumnIndicesFromMap(indices map[uint64]bool) ColumnIndices {
-	ci := make(ColumnIndices, len(indices))
-	for index, set := range indices {
-		if !set {
-			continue
-		}
-		ci[index] = struct{}{}
-	}
-	return ci
-}
-
-// NewColumnIndices creates an empty ColumnIndices.
-// In the future ColumnIndices may change from a reference type to a value type,
-// so using this constructor will ensure forwards-compatibility.
-func NewColumnIndices() ColumnIndices {
-	return make(ColumnIndices)
-}
--- a/beacon-chain/core/peerdas/info_test.go
+++ b/beacon-chain/core/peerdas/info_test.go
@@ -25,10 +25,3 @@ func TestInfo(t *testing.T) {
 		require.DeepEqual(t, expectedDataColumnsSubnets, actual.DataColumnsSubnets)
 	}
 }
-
-func TestNewColumnIndicesFromMap(t *testing.T) {
-	t.Run("nil map", func(t *testing.T) {
-		ci := peerdas.NewColumnIndicesFromMap(nil)
-		require.Equal(t, 0, ci.Count())
-	})
-}
--- a/beacon-chain/core/peerdas/metrics.go
+++ b/beacon-chain/core/peerdas/metrics.go
@@ -5,20 +5,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )

-var (
-	dataColumnComputationTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "beacon_data_column_sidecar_computation_milliseconds",
-			Help:    "Captures the time taken to compute data column sidecars from blobs.",
-			Buckets: []float64{25, 50, 100, 250, 500, 750, 1000},
-		},
-	)
-
-	cellsAndProofsFromStructuredComputationTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "cells_and_proofs_from_structured_computation_milliseconds",
-			Help:    "Captures the time taken to compute cells and proofs from structured computation.",
-			Buckets: []float64{10, 20, 30, 40, 50, 100, 200},
-		},
-	)
+var dataColumnComputationTime = promauto.NewHistogram(
+	prometheus.HistogramOpts{
+		Name:    "beacon_data_column_sidecar_computation_milliseconds",
+		Help:    "Captures the time taken to compute data column sidecars from blobs.",
+		Buckets: []float64{25, 50, 100, 250, 500, 750, 1000},
+	},
 )
--- a/beacon-chain/core/peerdas/p2p_interface.go
+++ b/beacon-chain/core/peerdas/p2p_interface.go
@@ -33,7 +33,8 @@ func (Cgc) ENRKey() string { return params.BeaconNetworkConfig().CustodyGroupCou
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar
 func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 	// The sidecar index must be within the valid range.
-	if sidecar.Index >= fieldparams.NumberOfColumns {
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+	if sidecar.Index >= numberOfColumns {
 		return ErrIndexTooLarge
 	}

--- a/beacon-chain/core/peerdas/p2p_interface_test.go
+++ b/beacon-chain/core/peerdas/p2p_interface_test.go
@@ -281,11 +281,8 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_SameCommitments_NoBatch(b *testin
 }

 func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.B) {
-	const (
-		blobCount       = 12
-		numberOfColumns = fieldparams.NumberOfColumns
-	)
-
+	const blobCount = 12
+	numberOfColumns := int64(params.BeaconConfig().NumberOfColumns)
 	err := kzg.Start()
 	require.NoError(b, err)

--- a/beacon-chain/core/peerdas/reconstruction.go
+++ b/beacon-chain/core/peerdas/reconstruction.go
@@ -3,7 +3,6 @@ package peerdas
 import (
 	"sort"
 	"sync"
-	"time"

 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
@@ -27,40 +26,7 @@ var (
 func MinimumColumnCountToReconstruct() uint64 {
 	// If the number of columns is odd, then we need total / 2 + 1 columns to reconstruct.
 	// If the number of columns is even, then we need total / 2 columns to reconstruct.
-	return (fieldparams.NumberOfColumns + 1) / 2
-}
-
-// MinimumCustodyGroupCountToReconstruct returns the minimum number of custody groups needed to
-// custody enough data columns for reconstruction. This accounts for the relationship between
-// custody groups and columns, making it future-proof if these values change.
-// Returns an error if the configuration values are invalid (zero or would cause division by zero).
-func MinimumCustodyGroupCountToReconstruct() (uint64, error) {
-	const numberOfColumns = fieldparams.NumberOfColumns
-	cfg := params.BeaconConfig()
-
-	// Validate configuration values
-	if numberOfColumns == 0 {
-		return 0, errors.New("NumberOfColumns cannot be zero")
-	}
-	if cfg.NumberOfCustodyGroups == 0 {
-		return 0, errors.New("NumberOfCustodyGroups cannot be zero")
-	}
-
-	minimumColumnCount := MinimumColumnCountToReconstruct()
-
-	// Calculate how many columns each custody group represents
-	columnsPerGroup := numberOfColumns / cfg.NumberOfCustodyGroups
-
-	// If there are more groups than columns (columnsPerGroup = 0), this is an invalid configuration
-	// for reconstruction purposes as we cannot determine a meaningful custody group count
-	if columnsPerGroup == 0 {
-		return 0, errors.Errorf("invalid configuration: NumberOfCustodyGroups (%d) exceeds NumberOfColumns (%d)",
-			cfg.NumberOfCustodyGroups, numberOfColumns)
-	}
-
-	// Use ceiling division to ensure we have enough groups to cover the minimum columns
-	// ceiling(a/b) = (a + b - 1) / b
-	return (minimumColumnCount + columnsPerGroup - 1) / columnsPerGroup, nil
+	return (params.BeaconConfig().NumberOfColumns + 1) / 2
 }

 // recoverCellsForBlobs reconstructs cells for specified blobs from the given data column sidecars.
@@ -287,8 +253,7 @@ func ReconstructBlobSidecars(block blocks.ROBlock, verifiedDataColumnSidecars []

 // ComputeCellsAndProofsFromFlat computes the cells and proofs from blobs and cell flat proofs.
 func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg.Cell, [][]kzg.Proof, error) {
-	const numberOfColumns = fieldparams.NumberOfColumns
-
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
 	blobCount := uint64(len(blobs))
 	cellProofsCount := uint64(len(cellProofs))

@@ -297,42 +262,32 @@ func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg
 		return nil, nil, ErrBlobsCellsProofsMismatch
 	}

-	var wg errgroup.Group
-
-	cellsPerBlob := make([][]kzg.Cell, blobCount)
-	proofsPerBlob := make([][]kzg.Proof, blobCount)
-
+	cellsPerBlob := make([][]kzg.Cell, 0, blobCount)
+	proofsPerBlob := make([][]kzg.Proof, 0, blobCount)
 	for i, blob := range blobs {
-		wg.Go(func() error {
-			var kzgBlob kzg.Blob
-			if copy(kzgBlob[:], blob) != len(kzgBlob) {
-				return errors.New("wrong blob size - should never happen")
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blob) != len(kzgBlob) {
+			return nil, nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "compute cells")
+		}
+
+		var proofs []kzg.Proof
+		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
+				return nil, nil, errors.New("wrong KZG proof size - should never happen")
 			}

-			// Compute the extended cells from the (non-extended) blob.
-			cells, err := kzg.ComputeCells(&kzgBlob)
-			if err != nil {
-				return errors.Wrap(err, "compute cells")
-			}
+			proofs = append(proofs, kzgProof)
+		}

-			proofs := make([]kzg.Proof, 0, numberOfColumns)
-			for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
-				var kzgProof kzg.Proof
-				if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
-					return errors.New("wrong KZG proof size - should never happen")
-				}
-
-				proofs = append(proofs, kzgProof)
-			}
-
-			cellsPerBlob[i] = cells
-			proofsPerBlob[i] = proofs
-			return nil
-		})
-	}
-
-	if err := wg.Wait(); err != nil {
-		return nil, nil, err
+		cellsPerBlob = append(cellsPerBlob, cells)
+		proofsPerBlob = append(proofsPerBlob, proofs)
 	}

 	return cellsPerBlob, proofsPerBlob, nil
@@ -340,55 +295,42 @@ func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([][]kzg

 // ComputeCellsAndProofsFromStructured computes the cells and proofs from blobs and cell proofs.
 func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([][]kzg.Cell, [][]kzg.Proof, error) {
-	start := time.Now()
-	defer func() {
-		cellsAndProofsFromStructuredComputationTime.Observe(float64(time.Since(start).Milliseconds()))
-	}()
+	numberOfColumns := params.BeaconConfig().NumberOfColumns

-	var wg errgroup.Group
-
-	cellsPerBlob := make([][]kzg.Cell, len(blobsAndProofs))
-	proofsPerBlob := make([][]kzg.Proof, len(blobsAndProofs))
-
-	for i, blobAndProof := range blobsAndProofs {
+	cellsPerBlob := make([][]kzg.Cell, 0, len(blobsAndProofs))
+	proofsPerBlob := make([][]kzg.Proof, 0, len(blobsAndProofs))
+	for _, blobAndProof := range blobsAndProofs {
 		if blobAndProof == nil {
 			return nil, nil, ErrNilBlobAndProof
 		}

-		wg.Go(func() error {
-			var kzgBlob kzg.Blob
-			if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
-				return errors.New("wrong blob size - should never happen")
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
+			return nil, nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "compute cells")
+		}
+
+		kzgProofs := make([]kzg.Proof, 0, numberOfColumns)
+		for _, kzgProofBytes := range blobAndProof.KzgProofs {
+			if len(kzgProofBytes) != kzg.BytesPerProof {
+				return nil, nil, errors.New("wrong KZG proof size - should never happen")
 			}

-			// Compute the extended cells from the (non-extended) blob.
-			cells, err := kzg.ComputeCells(&kzgBlob)
-			if err != nil {
-				return errors.Wrap(err, "compute cells")
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], kzgProofBytes) != len(kzgProof) {
+				return nil, nil, errors.New("wrong copied KZG proof size - should never happen")
 			}

-			kzgProofs := make([]kzg.Proof, 0, fieldparams.NumberOfColumns)
-			for _, kzgProofBytes := range blobAndProof.KzgProofs {
-				if len(kzgProofBytes) != kzg.BytesPerProof {
-					return errors.New("wrong KZG proof size - should never happen")
-				}
+			kzgProofs = append(kzgProofs, kzgProof)
+		}

-				var kzgProof kzg.Proof
-				if copy(kzgProof[:], kzgProofBytes) != len(kzgProof) {
-					return errors.New("wrong copied KZG proof size - should never happen")
-				}
-
-				kzgProofs = append(kzgProofs, kzgProof)
-			}
-
-			cellsPerBlob[i] = cells
-			proofsPerBlob[i] = kzgProofs
-			return nil
-		})
-	}
-
-	if err := wg.Wait(); err != nil {
-		return nil, nil, err
+		cellsPerBlob = append(cellsPerBlob, cells)
+		proofsPerBlob = append(proofsPerBlob, kzgProofs)
 	}

 	return cellsPerBlob, proofsPerBlob, nil
--- a/beacon-chain/core/peerdas/reconstruction_test.go
+++ b/beacon-chain/core/peerdas/reconstruction_test.go
@@ -17,9 +17,41 @@ import (
 )

 func TestMinimumColumnsCountToReconstruct(t *testing.T) {
-	const expected = uint64(64)
-	actual := peerdas.MinimumColumnCountToReconstruct()
-	require.Equal(t, expected, actual)
+	testCases := []struct {
+		name            string
+		numberOfColumns uint64
+		expected        uint64
+	}{
+		{
+			name:            "numberOfColumns=128",
+			numberOfColumns: 128,
+			expected:        64,
+		},
+		{
+			name:            "numberOfColumns=129",
+			numberOfColumns: 129,
+			expected:        65,
+		},
+		{
+			name:            "numberOfColumns=130",
+			numberOfColumns: 130,
+			expected:        65,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Set the total number of columns.
+			params.SetupTestConfigCleanup(t)
+			cfg := params.BeaconConfig().Copy()
+			cfg.NumberOfColumns = tc.numberOfColumns
+			params.OverrideBeaconConfig(cfg)
+
+			// Compute the minimum number of columns needed to reconstruct.
+			actual := peerdas.MinimumColumnCountToReconstruct()
+			require.Equal(t, tc.expected, actual)
+		})
+	}
 }

 func TestReconstructDataColumnSidecars(t *testing.T) {
@@ -168,6 +200,7 @@ func TestReconstructBlobSidecars(t *testing.T) {

 	t.Run("nominal", func(t *testing.T) {
 		const blobCount = 3
+		numberOfColumns := params.BeaconConfig().NumberOfColumns

 		roBlock, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)

@@ -203,7 +236,7 @@ func TestReconstructBlobSidecars(t *testing.T) {
 		require.NoError(t, err)

 		// Flatten proofs.
-		cellProofs := make([][]byte, 0, blobCount*fieldparams.NumberOfColumns)
+		cellProofs := make([][]byte, 0, blobCount*numberOfColumns)
 		for _, proofs := range inputProofsPerBlob {
 			for _, proof := range proofs {
 				cellProofs = append(cellProofs, proof[:])
@@ -395,12 +428,13 @@ func TestReconstructBlobs(t *testing.T) {
 }

 func TestComputeCellsAndProofsFromFlat(t *testing.T) {
-	const numberOfColumns = fieldparams.NumberOfColumns
 	// Start the trusted setup.
 	err := kzg.Start()
 	require.NoError(t, err)

 	t.Run("mismatched blob and proof counts", func(t *testing.T) {
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+
 		// Create one blob but proofs for two blobs
 		blobs := [][]byte{{}}

@@ -413,6 +447,7 @@ func TestComputeCellsAndProofsFromFlat(t *testing.T) {

 	t.Run("nominal", func(t *testing.T) {
 		const blobCount = 2
+		numberOfColumns := params.BeaconConfig().NumberOfColumns

 		// Generate test blobs
 		_, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)
--- a/beacon-chain/core/peerdas/semi_supernode_test.go
+++ b/beacon-chain/core/peerdas/semi_supernode_test.go
@@ -1,137 +0,0 @@
-package peerdas
-
-import (
-	"testing"
-
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/ethereum/go-ethereum/p2p/enode"
-)
-
-func TestSemiSupernodeCustody(t *testing.T) {
-	const numberOfColumns = fieldparams.NumberOfColumns
-
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.NumberOfCustodyGroups = 128
-	params.OverrideBeaconConfig(cfg)
-
-	// Create a test node ID
-	nodeID := enode.ID([32]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32})
-
-	t.Run("semi-supernode custodies exactly 64 columns", func(t *testing.T) {
-		// Semi-supernode uses 64 custody groups (half of 128)
-		const semiSupernodeCustodyGroupCount = 64
-
-		// Get custody groups for semi-supernode
-		custodyGroups, err := CustodyGroups(nodeID, semiSupernodeCustodyGroupCount)
-		require.NoError(t, err)
-		require.Equal(t, semiSupernodeCustodyGroupCount, len(custodyGroups))
-
-		// Verify we get exactly 64 custody columns
-		custodyColumns, err := CustodyColumns(custodyGroups)
-		require.NoError(t, err)
-		require.Equal(t, semiSupernodeCustodyGroupCount, len(custodyColumns))
-
-		// Verify the columns are valid (within 0-127 range)
-		for columnIndex := range custodyColumns {
-			if columnIndex >= numberOfColumns {
-				t.Fatalf("Invalid column index %d, should be less than %d", columnIndex, numberOfColumns)
-			}
-		}
-	})
-
-	t.Run("64 columns is exactly the minimum for reconstruction", func(t *testing.T) {
-		minimumCount := MinimumColumnCountToReconstruct()
-		require.Equal(t, uint64(64), minimumCount)
-	})
-
-	t.Run("semi-supernode vs supernode custody", func(t *testing.T) {
-		// Semi-supernode (64 custody groups)
-		semiSupernodeGroups, err := CustodyGroups(nodeID, 64)
-		require.NoError(t, err)
-		semiSupernodeColumns, err := CustodyColumns(semiSupernodeGroups)
-		require.NoError(t, err)
-
-		// Supernode (128 custody groups = all groups)
-		supernodeGroups, err := CustodyGroups(nodeID, 128)
-		require.NoError(t, err)
-		supernodeColumns, err := CustodyColumns(supernodeGroups)
-		require.NoError(t, err)
-
-		// Verify semi-supernode has exactly half the columns of supernode
-		require.Equal(t, 64, len(semiSupernodeColumns))
-		require.Equal(t, 128, len(supernodeColumns))
-		require.Equal(t, len(supernodeColumns)/2, len(semiSupernodeColumns))
-
-		// Verify all semi-supernode columns are a subset of supernode columns
-		for columnIndex := range semiSupernodeColumns {
-			if !supernodeColumns[columnIndex] {
-				t.Fatalf("Semi-supernode column %d not found in supernode columns", columnIndex)
-			}
-		}
-	})
-}
-
-func TestMinimumCustodyGroupCountToReconstruct(t *testing.T) {
-	tests := []struct {
-		name           string
-		numberOfGroups uint64
-		expectedResult uint64
-	}{
-		{
-			name:           "Standard 1:1 ratio (128 columns, 128 groups)",
-			numberOfGroups: 128,
-			expectedResult: 64, // Need half of 128 groups
-		},
-		{
-			name:           "2 columns per group (128 columns, 64 groups)",
-			numberOfGroups: 64,
-			expectedResult: 32, // Need 64 columns, which is 32 groups (64/2)
-		},
-		{
-			name:           "4 columns per group (128 columns, 32 groups)",
-			numberOfGroups: 32,
-			expectedResult: 16, // Need 64 columns, which is 16 groups (64/4)
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			params.SetupTestConfigCleanup(t)
-			cfg := params.BeaconConfig()
-			cfg.NumberOfCustodyGroups = tt.numberOfGroups
-			params.OverrideBeaconConfig(cfg)
-
-			result, err := MinimumCustodyGroupCountToReconstruct()
-			require.NoError(t, err)
-			require.Equal(t, tt.expectedResult, result)
-		})
-	}
-}
-
-func TestMinimumCustodyGroupCountToReconstruct_ErrorCases(t *testing.T) {
-	t.Run("Returns error when NumberOfCustodyGroups is zero", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig()
-		cfg.NumberOfCustodyGroups = 0
-		params.OverrideBeaconConfig(cfg)
-
-		_, err := MinimumCustodyGroupCountToReconstruct()
-		require.NotNil(t, err)
-		require.Equal(t, true, err.Error() == "NumberOfCustodyGroups cannot be zero")
-	})
-
-	t.Run("Returns error when NumberOfCustodyGroups exceeds NumberOfColumns", func(t *testing.T) {
-		params.SetupTestConfigCleanup(t)
-		cfg := params.BeaconConfig()
-		cfg.NumberOfCustodyGroups = 256
-		params.OverrideBeaconConfig(cfg)
-
-		_, err := MinimumCustodyGroupCountToReconstruct()
-		require.NotNil(t, err)
-		// Just check that we got an error about the configuration
-		require.Equal(t, true, len(err.Error()) > 0)
-	})
-}
--- a/beacon-chain/core/peerdas/validator.go
+++ b/beacon-chain/core/peerdas/validator.go
@@ -102,13 +102,11 @@ func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validat
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block and
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_column_sidecar
 func DataColumnSidecars(cellsPerBlob [][]kzg.Cell, proofsPerBlob [][]kzg.Proof, src ConstructionPopulator) ([]blocks.RODataColumn, error) {
-	const numberOfColumns = uint64(fieldparams.NumberOfColumns)
-
 	if len(cellsPerBlob) == 0 {
 		return nil, nil
 	}
 	start := time.Now()
-	cells, proofs, err := rotateRowsToCols(cellsPerBlob, proofsPerBlob, numberOfColumns)
+	cells, proofs, err := rotateRowsToCols(cellsPerBlob, proofsPerBlob, params.BeaconConfig().NumberOfColumns)
 	if err != nil {
 		return nil, errors.Wrap(err, "rotate cells and proofs")
 	}
@@ -117,8 +115,9 @@ func DataColumnSidecars(cellsPerBlob [][]kzg.Cell, proofsPerBlob [][]kzg.Proof,
 		return nil, errors.Wrap(err, "extract block info")
 	}

-	roSidecars := make([]blocks.RODataColumn, 0, numberOfColumns)
-	for idx := range numberOfColumns {
+	maxIdx := params.BeaconConfig().NumberOfColumns
+	roSidecars := make([]blocks.RODataColumn, 0, maxIdx)
+	for idx := range maxIdx {
 		sidecar := &ethpb.DataColumnSidecar{
 			Index:                        idx,
 			Column:                       cells[idx],
--- a/beacon-chain/core/peerdas/validator_test.go
+++ b/beacon-chain/core/peerdas/validator_test.go
@@ -6,7 +6,7 @@ import (
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/peerdas"
 	state_native "github.com/OffchainLabs/prysm/v7/beacon-chain/state/state-native"
-	fieldparams "github.com/OffchainLabs/prysm/v7/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v7/config/params"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
@@ -59,8 +59,6 @@ func TestValidatorsCustodyRequirement(t *testing.T) {
 }

 func TestDataColumnSidecars(t *testing.T) {
-	const numberOfColumns = fieldparams.NumberOfColumns
-
 	t.Run("sizes mismatch", func(t *testing.T) {
 		// Create a protobuf signed beacon block.
 		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
@@ -71,10 +69,10 @@ func TestDataColumnSidecars(t *testing.T) {

 		// Create cells and proofs.
 		cellsPerBlob := [][]kzg.Cell{
-			make([]kzg.Cell, numberOfColumns),
+			make([]kzg.Cell, params.BeaconConfig().NumberOfColumns),
 		}
 		proofsPerBlob := [][]kzg.Proof{
-			make([]kzg.Proof, numberOfColumns),
+			make([]kzg.Proof, params.BeaconConfig().NumberOfColumns),
 		}

 		rob, err := blocks.NewROBlock(signedBeaconBlock)
@@ -119,6 +117,7 @@ func TestDataColumnSidecars(t *testing.T) {
 		require.NoError(t, err)

 		// Create cells and proofs with sufficient cells but insufficient proofs.
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
 		cellsPerBlob := [][]kzg.Cell{
 			make([]kzg.Cell, numberOfColumns),
 		}
@@ -150,6 +149,7 @@ func TestDataColumnSidecars(t *testing.T) {
 		require.NoError(t, err)

 		// Create cells and proofs with correct dimensions.
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
 		cellsPerBlob := [][]kzg.Cell{
 			make([]kzg.Cell, numberOfColumns),
 			make([]kzg.Cell, numberOfColumns),
@@ -197,7 +197,6 @@ func TestDataColumnSidecars(t *testing.T) {
 }

 func TestReconstructionSource(t *testing.T) {
-	const numberOfColumns = fieldparams.NumberOfColumns
 	// Create a Fulu block with blob commitments.
 	signedBeaconBlockPb := util.NewBeaconBlockFulu()
 	commitment1 := make([]byte, 48)
@@ -213,6 +212,7 @@ func TestReconstructionSource(t *testing.T) {
 	require.NoError(t, err)

 	// Create cells and proofs with correct dimensions.
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
 	cellsPerBlob := [][]kzg.Cell{
 		make([]kzg.Cell, numberOfColumns),
 		make([]kzg.Cell, numberOfColumns),
--- a/beacon-chain/core/transition/interop/log.go
+++ b/beacon-chain/core/transition/interop/log.go
@@ -1,9 +1,10 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
+// Package interop contains useful utilities for persisting
+// ssz-encoded states and blocks to disk during each state
+// transition for development purposes.
 package interop

-import "github.com/sirupsen/logrus"
+import (
+	"github.com/sirupsen/logrus"
+)

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/transition/interop")
+var log = logrus.WithField("prefix", "interop")
--- a/beacon-chain/core/transition/log.go
+++ b/beacon-chain/core/transition/log.go
@@ -1,9 +1,5 @@
-// Code generated by hack/gen-logs.sh; DO NOT EDIT.
-// This file is created and regenerated automatically. Anything added here might get removed.
 package transition

 import "github.com/sirupsen/logrus"

-// The prefix for logs from this package will be the text after the last slash in the package path.
-// If you wish to change this, you should add your desired name in the runtime/logging/logrus-prefixed-formatter/prefix-replacement.go file.
-var log = logrus.WithField("package", "beacon-chain/core/transition")
+var log = logrus.WithField("prefix", "state")
--- a/beacon-chain/core/transition/transition_no_verify_sig.go
+++ b/beacon-chain/core/transition/transition_no_verify_sig.go
@@ -182,6 +182,12 @@ func ProcessBlockNoVerifyAnySig(
 		return nil, nil, err
 	}

+	sig := signed.Signature()
+	bSet, err := b.BlockSignatureBatch(st, blk.ProposerIndex(), sig[:], blk.HashTreeRoot)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return nil, nil, errors.Wrap(err, "could not retrieve block signature set")
+	}
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	rSet, err := b.RandaoSignatureBatch(ctx, st, randaoReveal[:])
 	if err != nil {
@@ -195,7 +201,7 @@ func ProcessBlockNoVerifyAnySig(

 	// Merge beacon block, randao and attestations signatures into a set.
 	set := bls.NewSet()
-	set.Join(rSet).Join(aSet)
+	set.Join(bSet).Join(rSet).Join(aSet)

 	if blk.Version() >= version.Capella {
 		changes, err := signed.Block().Body().BLSToExecutionChanges()
--- a/beacon-chain/core/transition/transition_no_verify_sig_test.go
+++ b/beacon-chain/core/transition/transition_no_verify_sig_test.go
@@ -157,8 +157,9 @@ func TestProcessBlockNoVerify_SigSetContainsDescriptions(t *testing.T) {
 	set, _, err := transition.ProcessBlockNoVerifyAnySig(t.Context(), beaconState, wsb)
 	require.NoError(t, err)
 	assert.Equal(t, len(set.Signatures), len(set.Descriptions), "Signatures and descriptions do not match up")
-	assert.Equal(t, "randao signature", set.Descriptions[0])
-	assert.Equal(t, "attestation signature", set.Descriptions[1])
+	assert.Equal(t, "block signature", set.Descriptions[0])
+	assert.Equal(t, "randao signature", set.Descriptions[1])
+	assert.Equal(t, "attestation signature", set.Descriptions[2])
 }

 func TestProcessOperationsNoVerifyAttsSigs_OK(t *testing.T) {
--- a/beacon-chain/das/BUILD.bazel
+++ b/beacon-chain/das/BUILD.bazel
@@ -4,19 +4,14 @@ go_library(
    name = "go_default_library",
    srcs = [
        "availability_blobs.go",
-        "availability_columns.go",
-        "bisect.go",
        "blob_cache.go",
        "data_column_cache.go",
        "iface.go",
-        "log.go",
        "mock.go",
-        "needs.go",
    ],
    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/das",
    visibility = ["//visibility:public"],
    deps = [
-        "//beacon-chain/core/peerdas:go_default_library",
        "//beacon-chain/db/filesystem:go_default_library",
        "//beacon-chain/verification:go_default_library",
        "//config/fieldparams:go_default_library",
@@ -26,7 +21,6 @@ go_library(
        "//runtime/logging:go_default_library",
        "//runtime/version:go_default_library",
        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
        "@com_github_sirupsen_logrus//:go_default_library",
    ],
@@ -36,14 +30,11 @@ go_test(
    name = "go_default_test",
    srcs = [
        "availability_blobs_test.go",
-        "availability_columns_test.go",
        "blob_cache_test.go",
        "data_column_cache_test.go",
-        "needs_test.go",
    ],
    embed = [":go_default_library"],
    deps = [
-        "//beacon-chain/core/peerdas:go_default_library",
        "//beacon-chain/db/filesystem:go_default_library",
        "//beacon-chain/verification:go_default_library",
        "//config/fieldparams:go_default_library",
@@ -54,7 +45,6 @@ go_test(
        "//testing/require:go_default_library",
        "//testing/util:go_default_library",
        "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
        "@com_github_pkg_errors//:go_default_library",
    ],
 )
--- a/Show More
+++ b/Show More