Remove test artifacts

-exec sed -i '' 's|OffchainLabs/prysm/v6|OffchainLabs/prysm/v7|g' {} +

.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.

BUILD.bazel

@@ -193,30 +193,10 @@ 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",
         "//tools/analyzers/maligned:go_default_library",
-        "//tools/analyzers/modernize/any:go_default_library",
-        "//tools/analyzers/modernize/appendclipped:go_default_library",
-        "//tools/analyzers/modernize/bloop:go_default_library",
-        "//tools/analyzers/modernize/fmtappendf:go_default_library",
-        "//tools/analyzers/modernize/forvar:go_default_library",
-        "//tools/analyzers/modernize/mapsloop:go_default_library",
-        "//tools/analyzers/modernize/minmax:go_default_library",
-        #"//tools/analyzers/modernize/newexpr:go_default_library", # Disabled until go 1.26.
-        "//tools/analyzers/modernize/omitzero:go_default_library",
-        "//tools/analyzers/modernize/rangeint:go_default_library",
-        "//tools/analyzers/modernize/reflecttypefor:go_default_library",
-        "//tools/analyzers/modernize/slicescontains:go_default_library",
-        #"//tools/analyzers/modernize/slicesdelete:go_default_library", # Disabled, see https://go.dev/issue/73686
-        "//tools/analyzers/modernize/slicessort:go_default_library",
-        "//tools/analyzers/modernize/stringsbuilder:go_default_library",
-        "//tools/analyzers/modernize/stringscutprefix:go_default_library",
-        "//tools/analyzers/modernize/stringsseq:go_default_library",
-        "//tools/analyzers/modernize/testingcontext:go_default_library",
-        "//tools/analyzers/modernize/waitgroup:go_default_library",
         "//tools/analyzers/nop:go_default_library",
         "//tools/analyzers/nopanic:go_default_library",
         "//tools/analyzers/properpermissions:go_default_library",

CHANGELOG.md

@@ -4,172 +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.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.
-
-Other than the mainnet fulu fork schedule, there are a few callouts in this release:
-- `by-epoch` blob storage format is the default for new installations. Users that haven't migrated will see a warning to migrate to the new format. Existing deployments may set `--blob-storage-layout=by-epoch` to perform the migration.
-- Several deprecated flags have been deleted! Please review the "removed" section of this changelog carefully. If you are referencing a removed flag, Prysm will not start! All of these flags had no effect for at least one release.
-- Several deprecated API endpoints have been deleted. Please review the "removed" section of this changelog carefully. 
-- Backfill is not supported in Fulu. This is expected to be fixed in the next release and should be delivered prior to the mainnet activation fork.
-- The builder default gas limit is raised from `45000000` (45 MGas) to `60000000` (60 MGas).
-- Several bug fixes and improvements.
-
-### Added
-
-- Allow custom headers in validator client HTTP requests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15884)
-- Metric to track data columns recovered from execution layer. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15924)
-- Metrics: Add count of peers per direction and type (inbound/outbound), (TCP/QUIC). [[PR]](https://github.com/prysmaticlabs/prysm/pull/15922)
-- `p2p_subscribed_topic_peer_total`: Reset to avoid dangling values. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15922)
-- Add `p2p_minimum_peers_per_subnet` metric. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15922)
-- Added GeneralizedIndicesFromPath function to calculate the GIs for a given sszInfo object and a PathElement. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15873)
-- Add Gloas protobuf definitions with spec tests and SSZ serialization support. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15601)
-- Fulu fork epoch for mainnet configurations set for December 3, 2025, 09:49:11pm UTC. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15975)
-- Added BPO schedules for December 9, 2025, 02:21:11pm UTC and January 7, 2026, 01:01:11am UTC. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15975)
-
-### Changed
-
-- Updated consensus spec tests to v1.6.0-beta.1 with new hashes and URL template. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15918)
-- Use the `by-epoch' blob storage layout by default and log a warning to users who continue to use the flat layout, encouraging them to switch. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15904)
-- Update go-netroute to `v0.3.0`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15934)
-- Introduced Path type for SSZ-QL queries and updated PathElement (removed Length field, kept Index) enforcing that len queries are terminal (at most one per path). [[PR]](https://github.com/prysmaticlabs/prysm/pull/15935)
-- Changed length query syntax from `block.payload.len(transactions)` to `len(block.payload.transactions)`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15935)
-- Update `go-netroute` to `v0.4.0`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15949)
-- Updated consensus spec tests to v1.6.0-beta.2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15960)
-- Updated go bitfield from prysmaticlabs to offchainlabs. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15968)
-- Bump builder default gas limit from `45000000` (45 MGas) to `60000000` (60 MGas). [[PR]](https://github.com/prysmaticlabs/prysm/pull/15979)
-- Use head state for block pubsub validation when possible. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15972)
-- updated consensus spec to 1.6.0 from 1.6.0-beta.2. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15975)
-- Upgrade Prysm v6 to v7. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15989)
-- Use head state readonly when possible to validate data column sidecars. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15977)
-
-### Removed
-
-- log mentioning removed flag `--show-deposit-data`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15926)
-- Remove Beacon API endpoints that were deprecated in Electra: `GET /eth/v1/beacon/deposit_snapshot`, `GET /eth/v1/beacon/blocks/{block_id}/attestations`, `GET /eth/v1/beacon/pool/attestations`, `POST /eth/v1/beacon/pool/attestations`, `GET /eth/v1/beacon/pool/attester_slashings`, `POST /eth/v1/beacon/pool/attester_slashings`, `GET /eth/v1/validator/aggregate_attestation`, `POST /eth/v1/validator/aggregate_and_proofs`, `POST /eth/v1/beacon/blocks`, `POST /eth/v1/beacon/blinded_blocks`, `GET /eth/v1/builder/states/{state_id}/expected_withdrawals`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15962)
-- Deprecated flag `--enable-optional-engine-methods` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-build-block-parallel` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-reorg-late-blocks` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-optional-engine-methods` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-aggregate-parallel` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--enable-eip-4881` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-eip-4881` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--enable-verbose-sig-verification` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--enable-debug-rpc-endpoints` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--beacon-rpc-gateway-provider` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-grpc-gateway` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--enable-experimental-state` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--enable-committee-aware-packing` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--interop-genesis-time` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--interop-num-validators` has been removed (from beacon-chain only; still available in validator client). [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--enable-quic` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--attest-timely` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--disable-experimental-state` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-- Deprecated flag `--p2p-metadata` has been removed. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15986)
-
-### Fixed
-
-- Remove `Reading static P2P private key from a file.` log if Fulu is enabled. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15913)
-- `blobSidecarByRootRPCHandler`: Do not serve a sidecar if the corresponding block is not available. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15933)
-- `dataColumnSidecarByRootRPCHandler`: Do not serve a sidecar if the corresponding block is not available. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15933)
-- Fix incorrect version used when sending attestation version in Fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15950)
-- Changed the behavior of topic subscriptions such that only topics that require the active validator count will compute that value. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15955)
-- Added a Mutex to the computation of active validator count during topic subscription to avoid a race condition where multiple goroutines are computing the same work. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15955)
-- `RODataColumnsVerifier.ValidProposerSignature`: Ensure the expensive signature verification is only performed once for concurrent requests for the same signature data. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15954)
-- use filepath for path operations (clean, join, etc.) to ensure correct behavior on Windows. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15953)
-- Fix #15969: Handle addition overflow in `/eth/v1/beacon/rewards/attestations/{epoch}`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15970)
-- `SidecarProposerExpected`: Add the slot in the single flight key. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15976)
-- Ensures the rate limitation is respected for by root blob and data column sidecars requests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15981)
-- Use head only if its compatible with target for attestation validation. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15965)
-- Backfill disabled if checkpoint sync origin is after fulu fork due to lack of DataColumnSidecar support in backfill. To track the availability of fulu-compatible backfill please watch https://github.com/OffchainLabs/prysm/issues/15982. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15987)
-- `SidecarProposerExpected`: Use the correct value of proposer index in the singleflight group. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15993)
-
 ## [v6.1.4](https://github.com/prysmaticlabs/prysm/compare/v6.1.3...v6.1.4) - 2025-10-24
 
 This release includes a bug fix affecting block proposals in rare cases, along with an important update for Windows users running post-Fusaka fork.
@@ -3986,4 +3820,4 @@ There are no security updates in this release.
 
 # Older than v2.0.0
 
-For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases
+For changelog history for releases older than v2.0.0, please refer to https://github.com/prysmaticlabs/prysm/releases

WORKSPACE

@@ -205,26 +205,6 @@ prysm_image_deps()
 
 load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_dependencies")
 
-# Override golang.org/x/tools to use v0.38.0 instead of v0.30.0
-# This is necessary as this dependency is required by rules_go and they do not accept dependency
-# update PRs. Instead, they ask downstream projects to override the dependency. To generate the
-# patches or update this dependency again, check out the rules_go repo then run the releaser tool.
-# bazel run //go/tools/releaser -- upgrade-dep -mirror=false org_golang_x_tools
-# Copy the patches and http_archive updates from rules_go here.
-http_archive(
-    name = "org_golang_x_tools",
-    patch_args = ["-p1"],
-    patches = [
-        "//third_party:org_golang_x_tools-deletegopls.patch",
-        "//third_party:org_golang_x_tools-gazelle.patch",
-    ],
-    sha256 = "8509908cd7fc35aa09ff49d8494e4fd25bab9e6239fbf57e0d8344f6bec5802b",
-    strip_prefix = "tools-0.38.0",
-    urls = [
-        "https://github.com/golang/tools/archive/refs/tags/v0.38.0.zip",
-    ],
-)
-
 go_rules_dependencies()
 
 go_register_toolchains(

api/apiutil/header.go

@@ -56,7 +56,7 @@ func ParseAccept(header string) []mediaRange {
 	}
 
 	var out []mediaRange
-	for field := range strings.SplitSeq(header, ",") {
+	for _, field := range strings.Split(header, ",") {
 		if r, ok := parseMediaRange(field); ok {
 			out = append(out, r)
 		}

api/client/builder/client.go

@@ -421,7 +421,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 
 func jsonValidatorRegisterRequest(svr []*ethpb.SignedValidatorRegistrationV1) ([]byte, error) {
 	vs := make([]*structs.SignedValidatorRegistration, len(svr))
-	for i := range svr {
+	for i := 0; i < len(svr); i++ {
 		vs[i] = structs.SignedValidatorRegistrationFromConsensus(svr[i])
 	}
 	body, err := json.Marshal(vs)

api/client/builder/types.go

@@ -121,7 +121,7 @@ func (s *Uint64String) UnmarshalText(t []byte) error {
 
 // MarshalText returns a byte representation of the text from Uint64String.
 func (s Uint64String) MarshalText() ([]byte, error) {
-	return fmt.Appendf(nil, "%d", s), nil
+	return []byte(fmt.Sprintf("%d", s)), nil
 }
 
 // VersionResponse is a JSON representation of a field in the builder API header response.

api/grpc/grpcutils.go

@@ -15,7 +15,7 @@ import (
 func LogRequests(
 	ctx context.Context,
 	method string, req,
-	reply any,
+	reply interface{},
 	cc *grpc.ClientConn,
 	invoker grpc.UnaryInvoker,
 	opts ...grpc.CallOption,

api/server/structs/endpoints_config.go

@@ -14,5 +14,5 @@ type GetForkScheduleResponse struct {
 }
 
 type GetSpecResponse struct {
-	Data any `json:"data"`
+	Data interface{} `json:"data"`
 }

async/abool/abool_test.go

@@ -93,9 +93,9 @@ func TestToggleMultipleTimes(t *testing.T) {
 
 	v := New()
 	pre := !v.IsSet()
-	for i := range 100 {
+	for i := 0; i < 100; i++ {
 		v.SetTo(false)
-		for range i {
+		for j := 0; j < i; j++ {
 			pre = v.Toggle()
 		}
 
@@ -149,7 +149,7 @@ func TestRace(t *testing.T) {
 
 	// Writer
 	go func() {
-		for range repeat {
+		for i := 0; i < repeat; i++ {
 			v.Set()
 			wg.Done()
 		}
@@ -157,7 +157,7 @@ func TestRace(t *testing.T) {
 
 	// Reader
 	go func() {
-		for range repeat {
+		for i := 0; i < repeat; i++ {
 			v.IsSet()
 			wg.Done()
 		}
@@ -165,7 +165,7 @@ func TestRace(t *testing.T) {
 
 	// Writer
 	go func() {
-		for range repeat {
+		for i := 0; i < repeat; i++ {
 			v.UnSet()
 			wg.Done()
 		}
@@ -173,7 +173,7 @@ func TestRace(t *testing.T) {
 
 	// Reader And Writer
 	go func() {
-		for range repeat {
+		for i := 0; i < repeat; i++ {
 			v.Toggle()
 			wg.Done()
 		}
@@ -198,8 +198,8 @@ func ExampleAtomicBool() {
 func BenchmarkMutexRead(b *testing.B) {
 	var m sync.RWMutex
 	var v bool
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		m.RLock()
 		_ = v
 		m.RUnlock()
@@ -208,16 +208,16 @@ func BenchmarkMutexRead(b *testing.B) {
 
 func BenchmarkAtomicValueRead(b *testing.B) {
 	var v atomic.Value
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		_ = v.Load() != nil
 	}
 }
 
 func BenchmarkAtomicBoolRead(b *testing.B) {
 	v := New()
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		_ = v.IsSet()
 	}
 }
@@ -227,8 +227,8 @@ func BenchmarkAtomicBoolRead(b *testing.B) {
 func BenchmarkMutexWrite(b *testing.B) {
 	var m sync.RWMutex
 	var v bool
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		m.RLock()
 		v = true
 		m.RUnlock()
@@ -239,16 +239,16 @@ func BenchmarkMutexWrite(b *testing.B) {
 
 func BenchmarkAtomicValueWrite(b *testing.B) {
 	var v atomic.Value
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		v.Store(true)
 	}
 }
 
 func BenchmarkAtomicBoolWrite(b *testing.B) {
 	v := New()
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		v.Set()
 	}
 }
@@ -258,8 +258,8 @@ func BenchmarkAtomicBoolWrite(b *testing.B) {
 func BenchmarkMutexCAS(b *testing.B) {
 	var m sync.RWMutex
 	var v bool
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		m.Lock()
 		if !v {
 			v = true
@@ -270,8 +270,8 @@ func BenchmarkMutexCAS(b *testing.B) {
 
 func BenchmarkAtomicBoolCAS(b *testing.B) {
 	v := New()
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		v.SetToIf(false, true)
 	}
 }
@@ -281,8 +281,8 @@ func BenchmarkAtomicBoolCAS(b *testing.B) {
 func BenchmarkMutexToggle(b *testing.B) {
 	var m sync.RWMutex
 	var v bool
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		m.Lock()
 		v = !v
 		m.Unlock()
@@ -291,8 +291,8 @@ func BenchmarkMutexToggle(b *testing.B) {
 
 func BenchmarkAtomicBoolToggle(b *testing.B) {
 	v := New()
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		v.Toggle()
 	}
 }

async/benchmark_test.go

@@ -21,7 +21,7 @@ const (
 
 func init() {
 	input = make([][]byte, benchmarkElements)
-	for i := range benchmarkElements {
+	for i := 0; i < benchmarkElements; i++ {
 		input[i] = make([]byte, benchmarkElementSize)
 		_, err := rand.Read(input[i])
 		if err != nil {
@@ -35,7 +35,7 @@ func hash(input [][]byte) [][]byte {
 	output := make([][]byte, len(input))
 	for i := range input {
 		copy(output, input)
-		for range benchmarkHashRuns {
+		for j := 0; j < benchmarkHashRuns; j++ {
 			hash := sha256.Sum256(output[i])
 			output[i] = hash[:]
 		}
@@ -44,15 +44,15 @@ func hash(input [][]byte) [][]byte {
 }
 
 func BenchmarkHash(b *testing.B) {
-	for b.Loop() {
+	for i := 0; i < b.N; i++ {
 		hash(input)
 	}
 }
 
 func BenchmarkHashMP(b *testing.B) {
 	output := make([][]byte, len(input))
-	for b.Loop() {
-		workerResults, err := async.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (any, error) {
+	for i := 0; i < b.N; i++ {
+		workerResults, err := async.Scatter(len(input), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
 			return hash(input[offset : offset+entries]), nil
 		})
 		require.NoError(b, err)

async/debounce.go

@@ -7,7 +7,7 @@ import (
 
 // Debounce events fired over a channel by a specified duration, ensuring no events
 // are handled until a certain interval of time has passed.
-func Debounce(ctx context.Context, interval time.Duration, eventsChan <-chan any, handler func(any)) {
+func Debounce(ctx context.Context, interval time.Duration, eventsChan <-chan interface{}, handler func(interface{})) {
 	var timer *time.Timer
 	defer func() {
 		if timer != nil {

async/debounce_test.go

@@ -14,7 +14,7 @@ import (
 )
 
 func TestDebounce_NoEvents(t *testing.T) {
-	eventsChan := make(chan any, 100)
+	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(t.Context())
 	interval := time.Second
 	timesHandled := int32(0)
@@ -26,7 +26,7 @@ func TestDebounce_NoEvents(t *testing.T) {
 		})
 	}()
 	go func() {
-		async.Debounce(ctx, interval, eventsChan, func(event any) {
+		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 			atomic.AddInt32(&timesHandled, 1)
 		})
 		wg.Done()
@@ -38,7 +38,7 @@ func TestDebounce_NoEvents(t *testing.T) {
 }
 
 func TestDebounce_CtxClosing(t *testing.T) {
-	eventsChan := make(chan any, 100)
+	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(t.Context())
 	interval := time.Second
 	timesHandled := int32(0)
@@ -62,7 +62,7 @@ func TestDebounce_CtxClosing(t *testing.T) {
 		})
 	}()
 	go func() {
-		async.Debounce(ctx, interval, eventsChan, func(event any) {
+		async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 			atomic.AddInt32(&timesHandled, 1)
 		})
 		wg.Done()
@@ -74,14 +74,14 @@ func TestDebounce_CtxClosing(t *testing.T) {
 }
 
 func TestDebounce_SingleHandlerInvocation(t *testing.T) {
-	eventsChan := make(chan any, 100)
+	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(t.Context())
 	interval := time.Second
 	timesHandled := int32(0)
-	go async.Debounce(ctx, interval, eventsChan, func(event any) {
+	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 		atomic.AddInt32(&timesHandled, 1)
 	})
-	for range 100 {
+	for i := 0; i < 100; i++ {
 		eventsChan <- struct{}{}
 	}
 	// We should expect 100 rapid fire changes to only have caused
@@ -92,14 +92,14 @@ func TestDebounce_SingleHandlerInvocation(t *testing.T) {
 }
 
 func TestDebounce_MultipleHandlerInvocation(t *testing.T) {
-	eventsChan := make(chan any, 100)
+	eventsChan := make(chan interface{}, 100)
 	ctx, cancel := context.WithCancel(t.Context())
 	interval := time.Second
 	timesHandled := int32(0)
-	go async.Debounce(ctx, interval, eventsChan, func(event any) {
+	go async.Debounce(ctx, interval, eventsChan, func(event interface{}) {
 		atomic.AddInt32(&timesHandled, 1)
 	})
-	for range 100 {
+	for i := 0; i < 100; i++ {
 		eventsChan <- struct{}{}
 	}
 	require.Equal(t, int32(0), atomic.LoadInt32(&timesHandled), "Events must prevent from handler execution")

async/event/example_scope_test.go

@@ -93,7 +93,9 @@ func ExampleSubscriptionScope() {
 	// Run a subscriber in the background.
 	divsub := app.SubscribeResults('/', divs)
 	mulsub := app.SubscribeResults('*', muls)
-	wg.Go(func() {
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
 		defer fmt.Println("subscriber exited")
 		defer divsub.Unsubscribe()
 		defer mulsub.Unsubscribe()
@@ -109,7 +111,7 @@ func ExampleSubscriptionScope() {
 				return
 			}
 		}
-	})
+	}()
 
 	// Interact with the app.
 	app.Calc('/', 22, 11)

async/event/example_subscription_test.go

@@ -26,7 +26,7 @@ func ExampleNewSubscription() {
 	// Create a subscription that sends 10 integers on ch.
 	ch := make(chan int)
 	sub := event.NewSubscription(func(quit <-chan struct{}) error {
-		for i := range 10 {
+		for i := 0; i < 10; i++ {
 			select {
 			case ch <- i:
 			case <-quit:

async/event/interface.go

@@ -3,6 +3,6 @@ package event
 // SubscriberSender is an abstract representation of an *event.Feed
 // to use in describing types that accept or return an *event.Feed.
 type SubscriberSender interface {
-	Subscribe(channel any) Subscription
-	Send(value any) (nsent int)
+	Subscribe(channel interface{}) Subscription
+	Send(value interface{}) (nsent int)
 }

async/event/subscription_test.go

@@ -30,7 +30,7 @@ var errInts = errors.New("error in subscribeInts")
 
 func subscribeInts(max, fail int, c chan<- int) Subscription {
 	return NewSubscription(func(quit <-chan struct{}) error {
-		for i := range max {
+		for i := 0; i < max; i++ {
 			if i >= fail {
 				return errInts
 			}
@@ -50,7 +50,7 @@ func TestNewSubscriptionError(t *testing.T) {
 	channel := make(chan int)
 	sub := subscribeInts(10, 2, channel)
 loop:
-	for want := range 10 {
+	for want := 0; want < 10; want++ {
 		select {
 		case got := <-channel:
 			require.Equal(t, want, got)

async/multilock_test.go

@@ -107,13 +107,15 @@ func TestLockUnlock(_ *testing.T) {
 
 func TestLockUnlock_CleansUnused(t *testing.T) {
 	var wg sync.WaitGroup
-	wg.Go(func() {
+	wg.Add(1)
+	go func() {
 		lock := NewMultilock("dog", "cat", "owl")
 		lock.Lock()
 		assert.Equal(t, 3, len(locks.list))
 		lock.Unlock()
 
-	})
+		wg.Done()
+	}()
 	wg.Wait()
 	// We expect that unlocking completely cleared the locks list
 	// given all 3 lock keys were unused at time of unlock.

async/scatter.go

@@ -9,14 +9,14 @@ import (
 // WorkerResults are the results of a scatter worker.
 type WorkerResults struct {
 	Offset int
-	Extent any
+	Extent interface{}
 }
 
 // Scatter scatters a computation across multiple goroutines.
 // This breaks the task in to a number of chunks and executes those chunks in parallel with the function provided.
 // Results returned are collected and presented as a set of WorkerResults, which can be reassembled by the calling function.
 // Any error that occurs in the workers will be passed back to the calling function.
-func Scatter(inputLen int, sFunc func(int, int, *sync.RWMutex) (any, error)) ([]*WorkerResults, error) {
+func Scatter(inputLen int, sFunc func(int, int, *sync.RWMutex) (interface{}, error)) ([]*WorkerResults, error) {
 	if inputLen <= 0 {
 		return nil, errors.New("input length must be greater than 0")
 	}

async/scatter_test.go

@@ -46,9 +46,9 @@ func TestDouble(t *testing.T) {
 				inValues[i] = i
 			}
 			outValues := make([]int, test.inValues)
-			workerResults, err := async.Scatter(len(inValues), func(offset int, entries int, _ *sync.RWMutex) (any, error) {
+			workerResults, err := async.Scatter(len(inValues), func(offset int, entries int, _ *sync.RWMutex) (interface{}, error) {
 				extent := make([]int, entries)
-				for i := range entries {
+				for i := 0; i < entries; i++ {
 					extent[i] = inValues[offset+i] * 2
 				}
 				return extent, nil
@@ -72,8 +72,8 @@ func TestDouble(t *testing.T) {
 func TestMutex(t *testing.T) {
 	totalRuns := 1048576
 	val := 0
-	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (any, error) {
-		for range entries {
+	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
+		for i := 0; i < entries; i++ {
 			mu.Lock()
 			val++
 			mu.Unlock()
@@ -90,8 +90,8 @@ func TestMutex(t *testing.T) {
 func TestError(t *testing.T) {
 	totalRuns := 1024
 	val := 0
-	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (any, error) {
-		for range entries {
+	_, err := async.Scatter(totalRuns, func(offset int, entries int, mu *sync.RWMutex) (interface{}, error) {
+		for i := 0; i < entries; i++ {
 			mu.Lock()
 			val++
 			if val == 1011 {

beacon-chain/blockchain/chain_info.go

@@ -79,7 +79,6 @@ type HeadFetcher interface {
 	HeadPublicKeyToValidatorIndex(pubKey [fieldparams.BLSPubkeyLength]byte) (primitives.ValidatorIndex, bool)
 	HeadValidatorIndexToPublicKey(ctx context.Context, index primitives.ValidatorIndex) ([fieldparams.BLSPubkeyLength]byte, error)
 	ChainHeads() ([][32]byte, []primitives.Slot)
-	DependentRootForEpoch([32]byte, primitives.Epoch) ([32]byte, error)
 	TargetRootForEpoch([32]byte, primitives.Epoch) ([32]byte, error)
 	HeadSyncCommitteeFetcher
 	HeadDomainFetcher
@@ -471,13 +470,6 @@ func (s *Service) IsOptimisticForRoot(ctx context.Context, root [32]byte) (bool,
 	return !isCanonical, nil
 }
 
-// DependentRootForEpoch wraps the corresponding method in forkchoice
-func (s *Service) DependentRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.DependentRootForEpoch(root, epoch)
-}
-
 // TargetRootForEpoch wraps the corresponding method in forkchoice
 func (s *Service) TargetRootForEpoch(root [32]byte, epoch primitives.Epoch) ([32]byte, error) {
 	s.cfg.ForkChoiceStore.RLock()

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 {

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()))
+}

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

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

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -23,7 +23,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "kzg_test.go",
         "trusted_setup_test.go",
         "validation_test.go",
     ],

beacon-chain/blockchain/kzg/kzg.go

@@ -34,6 +34,12 @@ type Bytes48 = ckzg4844.Bytes48
 // Bytes32 is a 32-byte array.
 type Bytes32 = ckzg4844.Bytes32
 
+// CellsAndProofs represents the Cells and Proofs corresponding to a single blob.
+type CellsAndProofs struct {
+	Cells  []Cell
+	Proofs []Proof
+}
+
 // BlobToKZGCommitment computes a KZG commitment from a given blob.
 func BlobToKZGCommitment(blob *Blob) (Commitment, error) {
 	var kzgBlob kzg4844.Blob
@@ -59,7 +65,7 @@ func ComputeCells(blob *Blob) ([]Cell, error) {
 
 	cells := make([]Cell, len(ckzgCells))
 	for i := range ckzgCells {
-		copy(cells[i][:], ckzgCells[i][:])
+		cells[i] = Cell(ckzgCells[i])
 	}
 
 	return cells, nil
@@ -72,35 +78,22 @@ func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) {
 
 	proof, err := kzg4844.ComputeBlobProof(&kzgBlob, kzg4844.Commitment(commitment))
 	if err != nil {
-		return Proof{}, err
+		return [48]byte{}, err
 	}
-	var result Proof
-	copy(result[:], proof[:])
-	return result, nil
+	return Proof(proof), nil
 }
 
 // ComputeCellsAndKZGProofs computes the cells and cells KZG proofs from a given blob.
-func ComputeCellsAndKZGProofs(blob *Blob) ([]Cell, []Proof, error) {
+func ComputeCellsAndKZGProofs(blob *Blob) (CellsAndProofs, error) {
 	var ckzgBlob ckzg4844.Blob
 	copy(ckzgBlob[:], blob[:])
 
 	ckzgCells, ckzgProofs, err := ckzg4844.ComputeCellsAndKZGProofs(&ckzgBlob)
 	if err != nil {
-		return nil, nil, err
+		return CellsAndProofs{}, err
 	}
 
-	if len(ckzgCells) != len(ckzgProofs) {
-		return nil, nil, errors.New("mismatched cells and proofs length")
-	}
-
-	cells := make([]Cell, len(ckzgCells))
-	proofs := make([]Proof, len(ckzgProofs))
-	for i := range ckzgCells {
-		copy(cells[i][:], ckzgCells[i][:])
-		copy(proofs[i][:], ckzgProofs[i][:])
-	}
-
-	return cells, proofs, nil
+	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
 }
 
 // VerifyCellKZGProofBatch verifies the KZG proofs for a given slice of commitments, cells indices, cells and proofs.
@@ -110,57 +103,44 @@ func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, c
 	ckzgCells := make([]ckzg4844.Cell, len(cells))
 
 	for i := range cells {
-		copy(ckzgCells[i][:], cells[i][:])
+		ckzgCells[i] = ckzg4844.Cell(cells[i])
 	}
 	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, ckzgCells, proofsBytes)
 }
 
-// RecoverCells recovers the complete cells from a given set of cell indices and partial cells.
-// Note: `len(cellIndices)` must be equal to `len(partialCells)` and `cellIndices` must be sorted in ascending order.
-func RecoverCells(cellIndices []uint64, partialCells []Cell) ([]Cell, error) {
-	// Convert `Cell` type to `ckzg4844.Cell`
-	ckzgPartialCells := make([]ckzg4844.Cell, len(partialCells))
-	for i := range partialCells {
-		copy(ckzgPartialCells[i][:], partialCells[i][:])
-	}
-
-	ckzgCells, err := ckzg4844.RecoverCells(cellIndices, ckzgPartialCells)
-	if err != nil {
-		return nil, errors.Wrap(err, "recover cells")
-	}
-
-	cells := make([]Cell, len(ckzgCells))
-	for i := range ckzgCells {
-		copy(cells[i][:], ckzgCells[i][:])
-	}
-
-	return cells, nil
-}
-
 // RecoverCellsAndKZGProofs recovers the complete cells and KZG proofs from a given set of cell indices and partial cells.
 // Note: `len(cellIndices)` must be equal to `len(partialCells)` and `cellIndices` must be sorted in ascending order.
-func RecoverCellsAndKZGProofs(cellIndices []uint64, partialCells []Cell) ([]Cell, []Proof, error) {
+func RecoverCellsAndKZGProofs(cellIndices []uint64, partialCells []Cell) (CellsAndProofs, error) {
 	// Convert `Cell` type to `ckzg4844.Cell`
 	ckzgPartialCells := make([]ckzg4844.Cell, len(partialCells))
 	for i := range partialCells {
-		copy(ckzgPartialCells[i][:], partialCells[i][:])
+		ckzgPartialCells[i] = ckzg4844.Cell(partialCells[i])
 	}
 
 	ckzgCells, ckzgProofs, err := ckzg4844.RecoverCellsAndKZGProofs(cellIndices, ckzgPartialCells)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "recover cells and KZG proofs")
+		return CellsAndProofs{}, errors.Wrap(err, "recover cells and KZG proofs")
 	}
 
-	if len(ckzgCells) != len(ckzgProofs) {
-		return nil, nil, errors.New("mismatched cells and proofs length")
-	}
-
-	cells := make([]Cell, len(ckzgCells))
-	proofs := make([]Proof, len(ckzgProofs))
-	for i := range ckzgCells {
-		copy(cells[i][:], ckzgCells[i][:])
-		copy(proofs[i][:], ckzgProofs[i][:])
-	}
-
-	return cells, proofs, nil
+	return makeCellsAndProofs(ckzgCells[:], ckzgProofs[:])
+}
+
+// makeCellsAndProofs converts cells/proofs to the CellsAndProofs type defined in this package.
+func makeCellsAndProofs(ckzgCells []ckzg4844.Cell, ckzgProofs []ckzg4844.KZGProof) (CellsAndProofs, error) {
+	if len(ckzgCells) != len(ckzgProofs) {
+		return CellsAndProofs{}, errors.New("different number of cells/proofs")
+	}
+
+	cells := make([]Cell, 0, len(ckzgCells))
+	proofs := make([]Proof, 0, len(ckzgProofs))
+
+	for i := range ckzgCells {
+		cells = append(cells, Cell(ckzgCells[i]))
+		proofs = append(proofs, Proof(ckzgProofs[i]))
+	}
+
+	return CellsAndProofs{
+		Cells:  cells,
+		Proofs: proofs,
+	}, nil
 }

beacon-chain/blockchain/kzg/kzg_test.go

@@ -1,236 +0,0 @@
-package kzg
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v7/crypto/random"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-)
-
-func TestComputeCells(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("valid blob", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		cells, err := ComputeCells(&blob)
-		require.NoError(t, err)
-		require.Equal(t, 128, len(cells))
-	})
-}
-
-func TestComputeBlobKZGProof(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("valid blob and commitment", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		proof, err := ComputeBlobKZGProof(&blob, commitment)
-		require.NoError(t, err)
-		require.Equal(t, BytesPerProof, len(proof))
-		require.NotEqual(t, Proof{}, proof, "proof should not be empty")
-	})
-}
-
-func TestComputeCellsAndKZGProofs(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("valid blob returns matching cells and proofs", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		cells, proofs, err := ComputeCellsAndKZGProofs(&blob)
-		require.NoError(t, err)
-		require.Equal(t, 128, len(cells))
-		require.Equal(t, 128, len(proofs))
-		require.Equal(t, len(cells), len(proofs), "cells and proofs should have matching lengths")
-	})
-}
-
-func TestVerifyCellKZGProofBatch(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("valid proof batch", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		cells, proofs, err := ComputeCellsAndKZGProofs(&blob)
-		require.NoError(t, err)
-
-		// Verify a subset of cells
-		cellIndices := []uint64{0, 1, 2, 3, 4}
-		selectedCells := make([]Cell, len(cellIndices))
-		commitmentsBytes := make([]Bytes48, len(cellIndices))
-		proofsBytes := make([]Bytes48, len(cellIndices))
-
-		for i, idx := range cellIndices {
-			selectedCells[i] = cells[idx]
-			copy(commitmentsBytes[i][:], commitment[:])
-			copy(proofsBytes[i][:], proofs[idx][:])
-		}
-
-		valid, err := VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, selectedCells, proofsBytes)
-		require.NoError(t, err)
-		require.Equal(t, true, valid)
-	})
-
-	t.Run("invalid proof should fail", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		cells, _, err := ComputeCellsAndKZGProofs(&blob)
-		require.NoError(t, err)
-
-		// Use invalid proofs
-		cellIndices := []uint64{0}
-		selectedCells := []Cell{cells[0]}
-		commitmentsBytes := make([]Bytes48, 1)
-		copy(commitmentsBytes[0][:], commitment[:])
-
-		// Create an invalid proof
-		invalidProof := Bytes48{}
-		proofsBytes := []Bytes48{invalidProof}
-
-		valid, err := VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, selectedCells, proofsBytes)
-		require.NotNil(t, err)
-		require.Equal(t, false, valid)
-	})
-}
-
-func TestRecoverCells(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("recover from partial cells", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		cells, err := ComputeCells(&blob)
-		require.NoError(t, err)
-
-		// Use half of the cells
-		partialIndices := make([]uint64, 64)
-		partialCells := make([]Cell, 64)
-		for i := range 64 {
-			partialIndices[i] = uint64(i)
-			partialCells[i] = cells[i]
-		}
-
-		recoveredCells, err := RecoverCells(partialIndices, partialCells)
-		require.NoError(t, err)
-		require.Equal(t, 128, len(recoveredCells))
-
-		// Verify recovered cells match original
-		for i := range cells {
-			require.Equal(t, cells[i], recoveredCells[i])
-		}
-	})
-
-	t.Run("insufficient cells should fail", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		cells, err := ComputeCells(&blob)
-		require.NoError(t, err)
-
-		// Use only 32 cells (less than 50% required)
-		partialIndices := make([]uint64, 32)
-		partialCells := make([]Cell, 32)
-		for i := range 32 {
-			partialIndices[i] = uint64(i)
-			partialCells[i] = cells[i]
-		}
-
-		_, err = RecoverCells(partialIndices, partialCells)
-		require.NotNil(t, err)
-	})
-}
-
-func TestRecoverCellsAndKZGProofs(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("recover cells and proofs from partial cells", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		cells, proofs, err := ComputeCellsAndKZGProofs(&blob)
-		require.NoError(t, err)
-
-		// Use half of the cells
-		partialIndices := make([]uint64, 64)
-		partialCells := make([]Cell, 64)
-		for i := range 64 {
-			partialIndices[i] = uint64(i)
-			partialCells[i] = cells[i]
-		}
-
-		recoveredCells, recoveredProofs, err := RecoverCellsAndKZGProofs(partialIndices, partialCells)
-		require.NoError(t, err)
-		require.Equal(t, 128, len(recoveredCells))
-		require.Equal(t, 128, len(recoveredProofs))
-		require.Equal(t, len(recoveredCells), len(recoveredProofs), "recovered cells and proofs should have matching lengths")
-
-		// Verify recovered cells match original
-		for i := range cells {
-			require.Equal(t, cells[i], recoveredCells[i])
-			require.Equal(t, proofs[i], recoveredProofs[i])
-		}
-	})
-
-	t.Run("insufficient cells should fail", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		cells, err := ComputeCells(&blob)
-		require.NoError(t, err)
-
-		// Use only 32 cells (less than 50% required)
-		partialIndices := make([]uint64, 32)
-		partialCells := make([]Cell, 32)
-		for i := range 32 {
-			partialIndices[i] = uint64(i)
-			partialCells[i] = cells[i]
-		}
-
-		_, _, err = RecoverCellsAndKZGProofs(partialIndices, partialCells)
-		require.NotNil(t, err)
-	})
-}
-
-func TestBlobToKZGCommitment(t *testing.T) {
-	require.NoError(t, Start())
-
-	t.Run("valid blob", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-		require.Equal(t, 48, len(commitment))
-
-		// Verify commitment is deterministic
-		commitment2, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-		require.Equal(t, commitment, commitment2)
-	})
-}

beacon-chain/blockchain/kzg/validation_test.go

@@ -70,7 +70,7 @@ func TestVerifyBlobKZGProofBatch(t *testing.T) {
 		commitments := make([][]byte, blobCount)
 		proofs := make([][]byte, blobCount)
 
-		for i := range blobCount {
+		for i := 0; i < blobCount; i++ {
 			blob := random.GetRandBlob(int64(i))
 			commitment, proof, err := GenerateCommitmentAndProof(blob)
 			require.NoError(t, err)
@@ -203,13 +203,13 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 		require.NoError(t, err)
 
 		// Compute cells and proofs
-		_, proofs, err := ComputeCellsAndKZGProofs(&blob)
+		cellsAndProofs, err := ComputeCellsAndKZGProofs(&blob)
 		require.NoError(t, err)
 
 		// Create flattened cell proofs (like execution client format)
 		cellProofs := make([][]byte, numberOfColumns)
 		for i := range numberOfColumns {
-			cellProofs[i] = proofs[i][:]
+			cellProofs[i] = cellsAndProofs.Proofs[i][:]
 		}
 
 		blobs := [][]byte{blob[:]}
@@ -236,7 +236,7 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 			require.NoError(t, err)
 
 			// Compute cells and proofs
-			_, proofs, err := ComputeCellsAndKZGProofs(&blob)
+			cellsAndProofs, err := ComputeCellsAndKZGProofs(&blob)
 			require.NoError(t, err)
 
 			blobs[i] = blob[:]
@@ -244,7 +244,7 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 
 			// Add cell proofs for this blob
 			for j := range numberOfColumns {
-				allCellProofs = append(allCellProofs, proofs[j][:])
+				allCellProofs = append(allCellProofs, cellsAndProofs.Proofs[j][:])
 			}
 		}
 
@@ -319,7 +319,7 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 		randBlob := random.GetRandBlob(123)
 		var blob Blob
 		copy(blob[:], randBlob[:])
-		_, proofs, err := ComputeCellsAndKZGProofs(&blob)
+		cellsAndProofs, err := ComputeCellsAndKZGProofs(&blob)
 		require.NoError(t, err)
 
 		// Generate wrong commitment from different blob
@@ -331,7 +331,7 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 
 		cellProofs := make([][]byte, numberOfColumns)
 		for i := range numberOfColumns {
-			cellProofs[i] = proofs[i][:]
+			cellProofs[i] = cellsAndProofs.Proofs[i][:]
 		}
 
 		blobs := [][]byte{blob[:]}
@@ -432,8 +432,8 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 		commitments[1] = make([]byte, 32) // Wrong size
 
 		// Add cell proofs for both blobs
-		for range blobCount {
-			for range numberOfColumns {
+		for i := 0; i < blobCount; i++ {
+			for j := uint64(0); j < numberOfColumns; j++ {
 				allCellProofs = append(allCellProofs, make([]byte, 48))
 			}
 		}
@@ -450,7 +450,7 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 		commitments := make([][]byte, blobCount)
 		var allCellProofs [][]byte
 
-		for i := range blobCount {
+		for i := 0; i < blobCount; i++ {
 			randBlob := random.GetRandBlob(int64(i))
 			var blob Blob
 			copy(blob[:], randBlob[:])
@@ -461,7 +461,7 @@ func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
 			commitments[i] = commitment[:]
 
 			// Add cell proofs - make some invalid in the second blob
-			for j := range numberOfColumns {
+			for j := uint64(0); j < numberOfColumns; j++ {
 				if i == 1 && j == 64 {
 					// Invalid proof size in middle of second blob's proofs
 					allCellProofs = append(allCellProofs, make([]byte, 20))

beacon-chain/blockchain/process_attestation_helpers.go

@@ -1,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"strconv"
@@ -22,7 +23,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,33 +34,23 @@ 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)
+	headTarget, err := s.cfg.ForkChoiceStore.TargetRootForEpoch([32]byte(headRoot), c.Epoch)
 	if err != nil {
 		return nil
 	}
-	targetDependent, err := s.cfg.ForkChoiceStore.DependentRootForEpoch([32]byte(c.Root), headEpoch-1)
-	if err != nil {
-		return nil
-	}
-	if targetDependent != headDependent {
+	if !bytes.Equal(c.Root, headTarget[:]) {
 		return nil
 	}
 
 	// 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 {

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()
@@ -333,14 +209,16 @@ func TestService_GetAttPreState_Concurrency(t *testing.T) {
 	var wg sync.WaitGroup
 	errChan := make(chan error, 1000)
 
-	for range 1000 {
-		wg.Go(func() {
+	for i := 0; i < 1000; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
 			cp1 := &ethpb.Checkpoint{Epoch: 1, Root: ckRoot}
 			_, err := service.getAttPreState(ctx, cp1)
 			if err != nil {
 				errChan <- err
 			}
-		})
+		}()
 	}
 
 	go func() {

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
 	}
 
@@ -810,10 +817,11 @@ func (s *Service) areDataColumnsAvailable(
 			}
 
 		case <-ctx.Done():
-			var missingIndices any = "all"
-			missingIndicesCount := len(missing)
+			var missingIndices interface{} = "all"
+			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
@@ -956,6 +948,13 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	attribute := s.getPayloadAttribute(ctx, headState, s.CurrentSlot()+1, headRoot[:])
 	// return early if we are not proposing next slot
 	if attribute.IsEmpty() {
+		headBlock, err := s.headBlock()
+		if err != nil {
+			log.WithError(err).WithField("head_root", headRoot).Error("Unable to retrieve head block to fire payload attributes event")
+		}
+		// notifyForkchoiceUpdate fires the payload attribute event. But in this case, we won't
+		// call notifyForkchoiceUpdate, so the event is fired here.
+		go s.firePayloadAttributesEvent(s.cfg.StateNotifier.StateFeed(), headBlock, headRoot, s.CurrentSlot()+1)
 		return
 	}
 
@@ -974,8 +973,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")

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.

beacon-chain/blockchain/process_block_test.go

@@ -147,7 +147,7 @@ func TestStore_OnBlockBatch(t *testing.T) {
 	bState := st.Copy()
 
 	var blks []consensusblocks.ROBlock
-	for i := range 97 {
+	for i := 0; i < 97; i++ {
 		b, err := util.GenerateFullBlock(bState, keys, util.DefaultBlockGenConfig(), primitives.Slot(i))
 		require.NoError(t, err)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
@@ -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)
 	}
@@ -1313,7 +1323,7 @@ func TestOnBlock_ProcessBlocksParallel(t *testing.T) {
 	require.NoError(t, err)
 
 	logHook := logTest.NewGlobal()
-	for range 10 {
+	for i := 0; i < 10; i++ {
 		fc := &ethpb.Checkpoint{}
 		st, blkRoot, err := prepareForkchoiceState(ctx, 0, wsb1.Block().ParentRoot(), [32]byte{}, [32]byte{}, fc, fc)
 		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()
@@ -1774,7 +1949,7 @@ func TestStore_NoViableHead_Liveness(t *testing.T) {
 	require.Equal(t, true, optimistic)
 
 	// Check that the invalid blocks are not in database
-	for i := range 19 - 13 {
+	for i := 0; i < 19-13; i++ {
 		require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, invalidRoots[i]))
 	}
 
@@ -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))
@@ -2654,11 +2804,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 	require.NoError(t, s.cfg.BeaconDB.SaveState(ctx, headState, [32]byte{1, 2}))
 	require.NoError(t, s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, [32]byte{1, 2}))
 
-	for _, testVersion := range version.All()[1:] {
-		if testVersion == version.Gloas {
-			// TODO(16027): Unskip light client tests for Gloas
-			continue
-		}
+	for testVersion := version.Altair; testVersion <= version.Electra; testVersion++ {
 		t.Run(version.String(testVersion), func(t *testing.T) {
 			l := util.NewTestLightClient(t, testVersion)
 
@@ -2733,7 +2879,7 @@ func TestProcessLightClientUpdate(t *testing.T) {
 
 				// set a better sync aggregate
 				scb := make([]byte, 64)
-				for i := range 5 {
+				for i := 0; i < 5; i++ {
 					scb[i] = 0x01
 				}
 				oldUpdate.SetSyncAggregate(&ethpb.SyncAggregate{
@@ -3111,9 +3257,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 {

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.

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)

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

beacon-chain/blockchain/receive_block_test.go

@@ -216,11 +216,13 @@ func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	wg := sync.WaitGroup{}
-	wg.Go(func() {
+	wg.Add(1)
+	go func() {
 		wsb, err := blocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
 		require.NoError(t, s.ReceiveBlock(ctx, wsb, root, nil))
-	})
+		wg.Done()
+	}()
 	wg.Wait()
 	time.Sleep(100 * time.Millisecond)
 	if recvd := len(s.cfg.StateNotifier.(*blockchainTesting.MockStateNotifier).ReceivedEvents()); recvd < 1 {

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

beacon-chain/blockchain/service_test.go

@@ -412,7 +412,8 @@ func BenchmarkHasBlockDB(b *testing.B) {
 	r, err := blk.Block.HashTreeRoot()
 	require.NoError(b, err)
 
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		require.Equal(b, true, s.cfg.BeaconDB.HasBlock(ctx, r), "Block is not in DB")
 	}
 }
@@ -431,7 +432,8 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	require.NoError(b, err)
 	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
 
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		require.Equal(b, true, s.cfg.ForkChoiceStore.HasNode(r), "Block is not in fork choice store")
 	}
 }
@@ -603,6 +605,7 @@ func TestUpdateCustodyInfoInDB(t *testing.T) {
 		custodyRequirement    = uint64(4)
 		earliestStoredSlot    = primitives.Slot(12)
 		numberOfCustodyGroups = uint64(64)
+		numberOfColumns       = uint64(128)
 	)
 
 	params.SetupTestConfigCleanup(t)
@@ -610,6 +613,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 +644,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 +682,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 +697,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)
-	})
 }

beacon-chain/blockchain/testing/mock.go

@@ -106,7 +106,7 @@ type EventFeedWrapper struct {
 	subscribed chan struct{} // this channel is closed once a subscription is made
 }
 
-func (w *EventFeedWrapper) Subscribe(channel any) event.Subscription {
+func (w *EventFeedWrapper) Subscribe(channel interface{}) event.Subscription {
 	select {
 	case <-w.subscribed:
 		break // already closed
@@ -116,7 +116,7 @@ func (w *EventFeedWrapper) Subscribe(channel any) event.Subscription {
 	return w.feed.Subscribe(channel)
 }
 
-func (w *EventFeedWrapper) Send(value any) int {
+func (w *EventFeedWrapper) Send(value interface{}) int {
 	return w.feed.Send(value)
 }
 
@@ -275,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
 	}
@@ -305,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
 	}
@@ -758,11 +758,6 @@ func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) err
 	return nil
 }
 
-// DependentRootForEpoch mocks the same method in the chain service
-func (c *ChainService) DependentRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
-	return c.TargetRoot, nil
-}
-
 // TargetRootForEpoch mocks the same method in the chain service
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/builder/service.go

@@ -166,7 +166,7 @@ func (s *Service) RegisterValidator(ctx context.Context, reg []*ethpb.SignedVali
 	indexToRegistration := make(map[primitives.ValidatorIndex]*ethpb.ValidatorRegistrationV1)
 
 	valid := make([]*ethpb.SignedValidatorRegistrationV1, 0)
-	for i := range reg {
+	for i := 0; i < len(reg); i++ {
 		r := reg[i]
 		nx, exists := s.cfg.headFetcher.HeadPublicKeyToValidatorIndex(bytesutil.ToBytes48(r.Message.Pubkey))
 		if !exists {

beacon-chain/cache/active_balance_test.go

@@ -17,7 +17,7 @@ import (
 
 func TestBalanceCache_AddGetBalance(t *testing.T) {
 	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := range blockRoots {
+	for i := 0; i < len(blockRoots); i++ {
 		b := make([]byte, 8)
 		binary.LittleEndian.PutUint64(b, uint64(i))
 		blockRoots[i] = b
@@ -61,7 +61,7 @@ func TestBalanceCache_AddGetBalance(t *testing.T) {
 
 func TestBalanceCache_BalanceKey(t *testing.T) {
 	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerHistoricalRoot)
-	for i := range blockRoots {
+	for i := 0; i < len(blockRoots); i++ {
 		b := make([]byte, 8)
 		binary.LittleEndian.PutUint64(b, uint64(i))
 		blockRoots[i] = b

beacon-chain/cache/committee.go

@@ -51,7 +51,7 @@ type CommitteeCache struct {
 }
 
 // committeeKeyFn takes the seed as the key to retrieve shuffled indices of a committee in a given epoch.
-func committeeKeyFn(obj any) (string, error) {
+func committeeKeyFn(obj interface{}) (string, error) {
 	info, ok := obj.(*Committees)
 	if !ok {
 		return "", ErrNotCommittee

beacon-chain/cache/committee_fuzz_test.go

@@ -14,7 +14,7 @@ func TestCommitteeKeyFuzz_OK(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	c := &Committees{}
 
-	for range 100000 {
+	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
 		k, err := committeeKeyFn(c)
 		require.NoError(t, err)
@@ -27,7 +27,7 @@ func TestCommitteeCache_FuzzCommitteesByEpoch(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	c := &Committees{}
 
-	for range 100000 {
+	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
 		require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), c))
 		_, err := cache.Committee(t.Context(), 0, c.Seed, 0)
@@ -42,7 +42,7 @@ func TestCommitteeCache_FuzzActiveIndices(t *testing.T) {
 	fuzzer := fuzz.NewWithSeed(0)
 	c := &Committees{}
 
-	for range 100000 {
+	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(c)
 		require.NoError(t, cache.AddCommitteeShuffledList(t.Context(), c))
 

beacon-chain/cache/common.go

@@ -17,6 +17,6 @@ func trim(queue *cache.FIFO, maxSize uint64) {
 }
 
 // popProcessNoopFunc is a no-op function that never returns an error.
-func popProcessNoopFunc(_ any, _ bool) error {
+func popProcessNoopFunc(_ interface{}, _ bool) error {
 	return nil
 }

beacon-chain/cache/depositsnapshot/deposit_cache_test.go

@@ -769,7 +769,7 @@ func TestFinalizedDeposits_ReturnsTrieCorrectly(t *testing.T) {
 	}
 
 	var ctrs []*ethpb.DepositContainer
-	for i := range 2000 {
+	for i := 0; i < 2000; i++ {
 		ctrs = append(ctrs, generateCtr(uint64(10+(i/2)), int64(i)))
 	}
 
@@ -948,9 +948,9 @@ func rootCreator(rn byte) []byte {
 func BenchmarkDepositTree_InsertNewImplementation(b *testing.B) {
 	totalDeposits := 10000
 	input := bytesutil.ToBytes32([]byte("foo"))
-	for b.Loop() {
+	for i := 0; i < b.N; i++ {
 		dt := NewDepositTree()
-		for range totalDeposits {
+		for j := 0; j < totalDeposits; j++ {
 			err := dt.Insert(input[:], 0)
 			require.NoError(b, err)
 		}
@@ -959,10 +959,10 @@ func BenchmarkDepositTree_InsertNewImplementation(b *testing.B) {
 func BenchmarkDepositTree_InsertOldImplementation(b *testing.B) {
 	totalDeposits := 10000
 	input := bytesutil.ToBytes32([]byte("foo"))
-	for b.Loop() {
+	for i := 0; i < b.N; i++ {
 		dt, err := trie.NewTrie(33)
 		require.NoError(b, err)
-		for range totalDeposits {
+		for j := 0; j < totalDeposits; j++ {
 			err := dt.Insert(input[:], 0)
 			require.NoError(b, err)
 		}
@@ -980,8 +980,8 @@ func BenchmarkDepositTree_HashTreeRootNewImplementation(b *testing.B) {
 	}
 
 	b.ReportAllocs()
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		_, err = tr.HashTreeRoot()
 		require.NoError(b, err)
 	}
@@ -999,8 +999,8 @@ func BenchmarkDepositTree_HashTreeRootOldImplementation(b *testing.B) {
 	}
 
 	b.ReportAllocs()
-
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		_, err = dt.HashTreeRoot()
 		require.NoError(b, err)
 	}

beacon-chain/cache/depositsnapshot/deposit_tree_snapshot.go

@@ -20,7 +20,7 @@ func (ds *DepositTreeSnapshot) CalculateRoot() ([32]byte, error) {
 	size := ds.depositCount
 	index := len(ds.finalized)
 	root := trie.ZeroHashes[0]
-	for i := range DepositContractDepth {
+	for i := 0; i < DepositContractDepth; i++ {
 		if (size & 1) == 1 {
 			if index == 0 {
 				break

beacon-chain/cache/skip_slot_cache_test.go

@@ -47,13 +47,15 @@ func TestSkipSlotCache_DisabledAndEnabled(t *testing.T) {
 
 	c.Enable()
 	wg := new(sync.WaitGroup)
-	wg.Go(func() {
+	wg.Add(1)
+	go func() {
 		// Get call will only terminate when
 		// it is not longer in progress.
 		obj, err := c.Get(ctx, r)
 		require.NoError(t, err)
 		require.IsNil(t, obj)
-	})
+		wg.Done()
+	}()
 
 	c.MarkNotInProgress(r)
 	wg.Wait()

beacon-chain/cache/sync_committee.go

@@ -236,7 +236,7 @@ func (s *SyncCommitteeCache) UpdatePositionsInCommittee(syncCommitteeBoundaryRoo
 // Given the `syncCommitteeIndexPosition` object, this returns the key of the object.
 // The key is the `currentSyncCommitteeRoot` within the field.
 // Error gets returned if input does not comply with `currentSyncCommitteeRoot` object.
-func keyFn(obj any) (string, error) {
+func keyFn(obj interface{}) (string, error) {
 	info, ok := obj.(*syncCommitteeIndexPosition)
 	if !ok {
 		return "", errNotSyncCommitteeIndexPosition

beacon-chain/cache/sync_subnet_ids_test.go

@@ -12,12 +12,12 @@ import (
 func TestSyncSubnetIDsCache_Roundtrip(t *testing.T) {
 	c := newSyncSubnetIDs()
 
-	for i := range 20 {
+	for i := 0; i < 20; i++ {
 		pubkey := [fieldparams.BLSPubkeyLength]byte{byte(i)}
 		c.AddSyncCommitteeSubnets(pubkey[:], 100, []uint64{uint64(i)}, 0)
 	}
 
-	for i := range uint64(20) {
+	for i := uint64(0); i < 20; i++ {
 		pubkey := [fieldparams.BLSPubkeyLength]byte{byte(i)}
 
 		idxs, _, ok, _ := c.GetSyncCommitteeSubnets(pubkey[:], 100)
@@ -34,7 +34,7 @@ func TestSyncSubnetIDsCache_Roundtrip(t *testing.T) {
 func TestSyncSubnetIDsCache_ValidateCurrentEpoch(t *testing.T) {
 	c := newSyncSubnetIDs()
 
-	for i := range 20 {
+	for i := 0; i < 20; i++ {
 		pubkey := [fieldparams.BLSPubkeyLength]byte{byte(i)}
 		c.AddSyncCommitteeSubnets(pubkey[:], 100, []uint64{uint64(i)}, 0)
 	}
@@ -42,7 +42,7 @@ func TestSyncSubnetIDsCache_ValidateCurrentEpoch(t *testing.T) {
 	coms := c.GetAllSubnets(50)
 	assert.Equal(t, 0, len(coms))
 
-	for i := range uint64(20) {
+	for i := uint64(0); i < 20; i++ {
 		pubkey := [fieldparams.BLSPubkeyLength]byte{byte(i)}
 
 		_, jEpoch, ok, _ := c.GetSyncCommitteeSubnets(pubkey[:], 100)

beacon-chain/core/altair/BUILD.bazel

@@ -19,7 +19,6 @@ go_library(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
-        "//beacon-chain/core/gloas:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",

beacon-chain/core/altair/attestation.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
@@ -17,7 +16,6 @@ import (
 	"github.com/OffchainLabs/prysm/v7/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1/attestation"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
 	"github.com/pkg/errors"
 )
 
@@ -77,12 +75,7 @@ func ProcessAttestationNoVerifySignature(
 		return nil, err
 	}
 
-	beaconState, err = gloas.UpdatePendingPaymentWeight(beaconState, att, indices, participatedFlags)
-	if err != nil {
-		return nil, err
-	}
-
-	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance, att)
+	return SetParticipationAndRewardProposer(ctx, beaconState, att.GetData().Target.Epoch, indices, participatedFlags, totalBalance)
 }
 
 // SetParticipationAndRewardProposer retrieves and sets the epoch participation bits in state. Based on the epoch participation, it rewards
@@ -112,9 +105,7 @@ func SetParticipationAndRewardProposer(
 	beaconState state.BeaconState,
 	targetEpoch primitives.Epoch,
 	indices []uint64,
-	participatedFlags map[uint8]bool,
-	totalBalance uint64,
-	att ethpb.Att) (state.BeaconState, error) {
+	participatedFlags map[uint8]bool, totalBalance uint64) (state.BeaconState, error) {
 	var proposerRewardNumerator uint64
 	currentEpoch := time.CurrentEpoch(beaconState)
 	var stateErr error
@@ -308,40 +299,6 @@ func AttestationParticipationFlagIndices(beaconState state.ReadOnlyBeaconState,
 		participatedFlags[targetFlagIndex] = true
 	}
 	matchedSrcTgtHead := matchedHead && matchedSrcTgt
-
-	// Spec v1.6.1 (pseudocode excerpt):
-	//
-	//	# [New in Gloas:EIP7732]
-	//	if is_attestation_same_slot(state, data):
-	//	    assert data.index == 0
-	//	    payload_matches = True
-	//	else:
-	//	    slot_index = data.slot % SLOTS_PER_HISTORICAL_ROOT
-	//	    payload_index = state.execution_payload_availability[slot_index]
-	//	    payload_matches = data.index == payload_index
-	//
-	//	# [Modified in Gloas:EIP7732]
-	//	is_matching_head = is_matching_target and head_root_matches and payload_matches
-	var matchingPayload bool
-	if beaconState.Version() >= version.Gloas {
-		ok, err := gloas.SameSlotAttestation(beaconState, [32]byte(data.BeaconBlockRoot), data.Slot)
-		if err != nil {
-			return nil, err
-		}
-		if ok {
-			if data.CommitteeIndex != 0 {
-				return nil, fmt.Errorf("committee index %d for same slot attestation must be 0", data.CommitteeIndex)
-			}
-			matchingPayload = true
-		} else {
-			executionPayloadAvail, err := beaconState.ExecutionPayloadAvailability(data.Slot)
-			if err != nil {
-				return nil, err
-			}
-			matchingPayload = executionPayloadAvail == uint64(data.CommitteeIndex)
-		}
-		matchedSrcTgtHead = matchedSrcTgtHead && matchingPayload
-	}
 	if matchedSrcTgtHead && delay == cfg.MinAttestationInclusionDelay {
 		participatedFlags[headFlagIndex] = true
 	}

beacon-chain/core/altair/attestation_test.go

@@ -1,9 +1,7 @@
 package altair_test
 
 import (
-	"bytes"
 	"fmt"
-	"reflect"
 	"testing"
 
 	"github.com/OffchainLabs/go-bitfield"
@@ -463,7 +461,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	st := &ethpb.BeaconStateAltair{}
 	b := &ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{}}
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(st)
 		fuzzer.Fuzz(b)
 		if b.Block == nil {
@@ -558,7 +556,7 @@ func TestSetParticipationAndRewardProposer(t *testing.T) {
 
 			b, err := helpers.TotalActiveBalance(beaconState)
 			require.NoError(t, err)
-			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b, &ethpb.Attestation{})
+			st, err := altair.SetParticipationAndRewardProposer(t.Context(), beaconState, test.epoch, test.indices, test.participatedFlags, b)
 			require.NoError(t, err)
 
 			i, err := helpers.BeaconProposerIndex(t.Context(), st)
@@ -777,67 +775,11 @@ func TestAttestationParticipationFlagIndices(t *testing.T) {
 				headFlagIndex:   true,
 			},
 		},
-		{
-			name: "gloas same-slot committee index non-zero errors",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				prevRoot := bytes.Repeat([]byte{0xCC}, 32)
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, prevRoot, 0, 0)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1, // invalid for same-slot
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay:           1,
-			participationIndices: nil,
-		},
-		{
-			name: "gloas payload availability matches committee index",
-			inputState: func() state.BeaconState {
-				stateSlot := primitives.Slot(5)
-				slot := primitives.Slot(3)
-				targetRoot := bytes.Repeat([]byte{0xAA}, 32)
-				headRoot := bytes.Repeat([]byte{0xBB}, 32)
-				// Same prev root to make SameSlotAttestation false and use payload availability.
-				return buildGloasStateForFlags(t, stateSlot, slot, targetRoot, headRoot, headRoot, 1, slot)
-			}(),
-			inputData: &ethpb.AttestationData{
-				Slot:            3,
-				CommitteeIndex:  1,
-				BeaconBlockRoot: bytes.Repeat([]byte{0xBB}, 32),
-				Source:          &ethpb.Checkpoint{Root: bytes.Repeat([]byte{0xDD}, 32)},
-				Target: &ethpb.Checkpoint{
-					Epoch: 0,
-					Root:  bytes.Repeat([]byte{0xAA}, 32),
-				},
-			},
-			inputDelay: 1,
-			participationIndices: map[uint8]bool{
-				sourceFlagIndex: true,
-				targetFlagIndex: true,
-				headFlagIndex:   true,
-			},
-		},
 	}
 	for _, test := range tests {
 		flagIndices, err := altair.AttestationParticipationFlagIndices(test.inputState, test.inputData, test.inputDelay)
-		if test.participationIndices == nil {
-			require.ErrorContains(t, "committee index", err)
-			continue
-		}
 		require.NoError(t, err)
-		if !reflect.DeepEqual(test.participationIndices, flagIndices) {
-			t.Fatalf("unexpected participation indices: got %v want %v", flagIndices, test.participationIndices)
-		}
+		require.DeepEqual(t, test.participationIndices, flagIndices)
 	}
 }
 
@@ -916,61 +858,3 @@ func TestMatchingStatus(t *testing.T) {
 		require.Equal(t, test.matchedHead, head)
 	}
 }
-
-func buildGloasStateForFlags(t *testing.T, stateSlot, slot primitives.Slot, targetRoot, headRoot, prevRoot []byte, availabilityBit uint8, availabilitySlot primitives.Slot) state.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	blockRoots[0] = targetRoot
-	blockRoots[slot%cfg.SlotsPerHistoricalRoot] = headRoot
-	blockRoots[(slot-1)%cfg.SlotsPerHistoricalRoot] = prevRoot
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-	idx := availabilitySlot % cfg.SlotsPerHistoricalRoot
-	byteIndex := idx / 8
-	bitIndex := idx % 8
-	if availabilityBit == 1 {
-		execPayloadAvailability[byteIndex] |= 1 << bitIndex
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xDD}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Root: checkpointRoot}
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return beaconState
-}

beacon-chain/core/altair/block_test.go

@@ -240,7 +240,7 @@ func TestProcessSyncCommittee_processSyncAggregate(t *testing.T) {
 	proposerIndex, err := helpers.BeaconProposerIndex(t.Context(), beaconState)
 	require.NoError(t, err)
 
-	for i := range syncBits {
+	for i := 0; i < len(syncBits); i++ {
 		if syncBits.BitAt(uint64(i)) {
 			pk := bytesutil.ToBytes48(committeeKeys[i])
 			require.DeepEqual(t, true, votedMap[pk])

beacon-chain/core/altair/deposit.go

@@ -195,7 +195,10 @@ func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdr
 //	    withdrawable_epoch=FAR_FUTURE_EPOCH,
 //	)
 func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
-	effectiveBalance := min(params.BeaconConfig().MaxEffectiveBalance, amount-(amount%params.BeaconConfig().EffectiveBalanceIncrement))
+	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+	}
 
 	return &ethpb.Validator{
 		PublicKey:                  pubKey,

beacon-chain/core/altair/deposit_fuzz_test.go

@@ -16,7 +16,7 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 	state := &ethpb.BeaconStateAltair{}
 	deposits := make([]*ethpb.Deposit, 100)
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		for i := range deposits {
 			fuzzer.Fuzz(deposits[i])
@@ -37,7 +37,7 @@ func TestFuzzProcessPreGenesisDeposit_10000(t *testing.T) {
 	deposit := &ethpb.Deposit{}
 	ctx := t.Context()
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafeAltair(state)
@@ -56,7 +56,7 @@ func TestFuzzProcessPreGenesisDeposit_Phase0_10000(t *testing.T) {
 	deposit := &ethpb.Deposit{}
 	ctx := t.Context()
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -74,7 +74,7 @@ func TestFuzzProcessDeposit_Phase0_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	deposit := &ethpb.Deposit{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -92,7 +92,7 @@ func TestFuzzProcessDeposit_10000(t *testing.T) {
 	state := &ethpb.BeaconStateAltair{}
 	deposit := &ethpb.Deposit{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafeAltair(state)

beacon-chain/core/altair/epoch_precompute.go

@@ -122,8 +122,11 @@ func ProcessInactivityScores(
 		}
 
 		if !helpers.IsInInactivityLeak(prevEpoch, finalizedEpoch) {
+			score := recoveryRate
 			// Prevents underflow below 0.
-			score := min(recoveryRate, v.InactivityScore)
+			if score > v.InactivityScore {
+				score = v.InactivityScore
+			}
 			v.InactivityScore -= score
 		}
 		inactivityScores[i] = v.InactivityScore
@@ -239,7 +242,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 	}
 
 	balances := beaconState.Balances()
-	for i := range numOfVals {
+	for i := 0; i < numOfVals; i++ {
 		vals[i].BeforeEpochTransitionBalance = balances[i]
 
 		// Compute the post balance of the validator after accounting for the

beacon-chain/core/altair/sync_committee_test.go

@@ -21,7 +21,7 @@ import (
 func TestSyncCommitteeIndices_CanGet(t *testing.T) {
 	getState := func(t *testing.T, count uint64, vers int) state.BeaconState {
 		validators := make([]*ethpb.Validator, count)
-		for i := range validators {
+		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
 				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
 				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
@@ -113,7 +113,7 @@ func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) {
 	helpers.ClearCache()
 	getState := func(t *testing.T, count uint64) state.BeaconState {
 		validators := make([]*ethpb.Validator, count)
-		for i := range validators {
+		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
 				ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
 				EffectiveBalance: params.BeaconConfig().MinDepositAmount,
@@ -147,7 +147,7 @@ func TestSyncCommitteeIndices_DifferentPeriods(t *testing.T) {
 func TestSyncCommittee_CanGet(t *testing.T) {
 	getState := func(t *testing.T, count uint64) state.BeaconState {
 		validators := make([]*ethpb.Validator, count)
-		for i := range validators {
+		for i := 0; i < len(validators); i++ {
 			blsKey, err := bls.RandKey()
 			require.NoError(t, err)
 			validators[i] = &ethpb.Validator{
@@ -394,7 +394,7 @@ func Test_ValidateSyncMessageTime(t *testing.T) {
 
 func getState(t *testing.T, count uint64) state.BeaconState {
 	validators := make([]*ethpb.Validator, count)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		blsKey, err := bls.RandKey()
 		require.NoError(t, err)
 		validators[i] = &ethpb.Validator{

beacon-chain/core/altair/upgrade_test.go

@@ -33,7 +33,7 @@ func TestTranslateParticipation(t *testing.T) {
 	r, err := helpers.BlockRootAtSlot(s, 0)
 	require.NoError(t, err)
 	var pendingAtts []*ethpb.PendingAttestation
-	for i := range 3 {
+	for i := 0; i < 3; i++ {
 		pendingAtts = append(pendingAtts, &ethpb.PendingAttestation{
 			Data: &ethpb.AttestationData{
 				CommitteeIndex:  primitives.CommitteeIndex(i),

beacon-chain/core/blocks/attestation.go

@@ -111,16 +111,7 @@ func VerifyAttestationNoVerifySignature(
 	var indexedAtt ethpb.IndexedAtt
 
 	if att.Version() >= version.Electra {
-		// Spec v1.6.1 (pseudocode excerpt):
-		//
-		//	# [Modified in Gloas:EIP7732]
-		//	assert data.index < 2
-		//
-		if beaconState.Version() >= version.Gloas {
-			if att.GetData().CommitteeIndex >= 2 {
-				return fmt.Errorf("incorrect committee index %d", att.GetData().CommitteeIndex)
-			}
-		} else if att.GetData().CommitteeIndex != 0 {
+		if att.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
 
@@ -266,7 +257,7 @@ func VerifyIndexedAttestation(ctx context.Context, beaconState state.ReadOnlyBea
 	}
 	indices := indexedAtt.GetAttestingIndices()
 	var pubkeys []bls.PublicKey
-	for i := range indices {
+	for i := 0; i < len(indices); i++ {
 		pubkeyAtIdx := beaconState.PubkeyAtIndex(primitives.ValidatorIndex(indices[i]))
 		pk, err := bls.PublicKeyFromBytes(pubkeyAtIdx[:])
 		if err != nil {

beacon-chain/core/blocks/attestation_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"bytes"
 	"context"
 	"testing"
 
@@ -315,79 +314,10 @@ func TestVerifyAttestationNoVerifySignature_Electra(t *testing.T) {
 	})
 }
 
-func TestVerifyAttestationNoVerifySignature_GloasCommitteeIndexLimit(t *testing.T) {
-	cfg := params.BeaconConfig()
-	stateSlot := cfg.MinAttestationInclusionDelay + 1
-
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range blockRoots {
-		blockRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = make([]byte, fieldparams.RootLength)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = make([]byte, fieldparams.RootLength)
-	}
-
-	checkpointRoot := bytes.Repeat([]byte{0xAA}, fieldparams.RootLength)
-	justified := &ethpb.Checkpoint{Epoch: 0, Root: checkpointRoot}
-
-	gloasStateProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x11}, fieldparams.RootLength),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: make([]byte, cfg.SlotsPerHistoricalRoot/8),
-		CurrentJustifiedCheckpoint:   justified,
-		PreviousJustifiedCheckpoint:  justified,
-		Validators: []*ethpb.Validator{
-			{
-				EffectiveBalance:      cfg.MinActivationBalance,
-				WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x01}, 31)...),
-			},
-		},
-		Balances:               []uint64{cfg.MinActivationBalance},
-		BuilderPendingPayments: make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x01}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x01}, 4),
-			Epoch:           0,
-		},
-	}
-
-	beaconState, err := state_native.InitializeFromProtoGloas(gloasStateProto)
-	require.NoError(t, err)
-
-	committeeBits := bitfield.NewBitvector64()
-	committeeBits.SetBitAt(0, true)
-	aggBits := bitfield.NewBitlist(1)
-	aggBits.SetBitAt(0, true)
-
-	att := &ethpb.AttestationElectra{
-		Data: &ethpb.AttestationData{
-			Slot:            0,
-			CommitteeIndex:  2, // invalid for Gloas (must be <2)
-			BeaconBlockRoot: blockRoots[0],
-			Source:          justified,
-			Target:          justified,
-		},
-		AggregationBits: aggBits,
-		CommitteeBits:   committeeBits,
-		Signature:       bytes.Repeat([]byte{0x00}, fieldparams.BLSSignatureLength),
-	}
-
-	err = blocks.VerifyAttestationNoVerifySignature(context.TODO(), beaconState, att)
-	assert.ErrorContains(t, "incorrect committee index 2", err)
-}
-
 func TestConvertToIndexed_OK(t *testing.T) {
 	helpers.ClearCache()
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -443,7 +373,7 @@ func TestVerifyIndexedAttestation_OK(t *testing.T) {
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := util.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
 			PublicKey:             keys[i].PublicKey().Marshal(),
@@ -551,7 +481,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 	sig := keys[0].Sign([]byte{'t', 'e', 's', 't'})
 	list := bitfield.Bitlist{0b11111}
 	var atts []ethpb.Att
-	for range uint64(1000) {
+	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
 			Data: &ethpb.AttestationData{
 				CommitteeIndex: 1,
@@ -568,7 +498,7 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 
 	atts = []ethpb.Att{}
 	list = bitfield.Bitlist{0b10000}
-	for range uint64(1000) {
+	for i := uint64(0); i < 1000; i++ {
 		atts = append(atts, &ethpb.Attestation{
 			Data: &ethpb.AttestationData{
 				CommitteeIndex: 1,
@@ -594,7 +524,7 @@ func TestVerifyAttestations_HandlesPlannedFork(t *testing.T) {
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := util.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
 			PublicKey:             keys[i].PublicKey().Marshal(),
@@ -658,7 +588,7 @@ func TestRetrieveAttestationSignatureSet_VerifiesMultipleAttestations(t *testing
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := util.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
 			PublicKey:             keys[i].PublicKey().Marshal(),
@@ -777,7 +707,7 @@ func TestRetrieveAttestationSignatureSet_AcrossFork(t *testing.T) {
 	validators := make([]*ethpb.Validator, numOfValidators)
 	_, keys, err := util.DeterministicDepositsAndKeys(numOfValidators)
 	require.NoError(t, err)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
 			PublicKey:             keys[i].PublicKey().Marshal(),

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -21,7 +21,7 @@ func TestFuzzProcessAttestationNoVerify_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	att := &ethpb.Attestation{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(att)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -37,7 +37,7 @@ func TestFuzzProcessBlockHeader_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	block := &ethpb.SignedBeaconBlock{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(block)
 
@@ -63,7 +63,7 @@ func TestFuzzverifyDepositDataSigningRoot_10000(_ *testing.T) {
 	var p []byte
 	var s []byte
 	var d []byte
-	for range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(&ba)
 		fuzzer.Fuzz(&pubkey)
 		fuzzer.Fuzz(&sig)
@@ -83,7 +83,7 @@ func TestFuzzProcessEth1DataInBlock_10000(t *testing.T) {
 	e := &ethpb.Eth1Data{}
 	state, err := state_native.InitializeFromProtoUnsafePhase0(&ethpb.BeaconState{})
 	require.NoError(t, err)
-	for range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
 		s, err := ProcessEth1DataInBlock(t.Context(), state, e)
@@ -98,7 +98,7 @@ func TestFuzzareEth1DataEqual_10000(_ *testing.T) {
 	eth1data := &ethpb.Eth1Data{}
 	eth1data2 := &ethpb.Eth1Data{}
 
-	for range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(eth1data)
 		fuzzer.Fuzz(eth1data2)
 		AreEth1DataEqual(eth1data, eth1data2)
@@ -110,7 +110,7 @@ func TestFuzzEth1DataHasEnoughSupport_10000(t *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	eth1data := &ethpb.Eth1Data{}
 	var stateVotes []*ethpb.Eth1Data
-	for i := range 100000 {
+	for i := 0; i < 100000; i++ {
 		fuzzer.Fuzz(eth1data)
 		fuzzer.Fuzz(&stateVotes)
 		s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
@@ -129,7 +129,7 @@ func TestFuzzProcessBlockHeaderNoVerify_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	block := &ethpb.BeaconBlock{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(block)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -145,7 +145,7 @@ func TestFuzzProcessRandao_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	b := &ethpb.SignedBeaconBlock{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(b)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -168,7 +168,7 @@ func TestFuzzProcessRandaoNoVerify_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	blockBody := &ethpb.BeaconBlockBody{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(blockBody)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -186,7 +186,7 @@ func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	p := &ethpb.ProposerSlashing{}
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(p)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -203,7 +203,7 @@ func TestFuzzVerifyProposerSlashing_10000(t *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	proposerSlashing := &ethpb.ProposerSlashing{}
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(proposerSlashing)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -219,7 +219,7 @@ func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	a := &ethpb.AttesterSlashing{}
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(a)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -237,7 +237,7 @@ func TestFuzzVerifyAttesterSlashing_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	attesterSlashing := &ethpb.AttesterSlashing{}
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(attesterSlashing)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -253,7 +253,7 @@ func TestFuzzIsSlashableAttestationData_10000(_ *testing.T) {
 	attestationData := &ethpb.AttestationData{}
 	attestationData2 := &ethpb.AttestationData{}
 
-	for range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(attestationData)
 		fuzzer.Fuzz(attestationData2)
 		IsSlashableAttestationData(attestationData, attestationData2)
@@ -264,7 +264,7 @@ func TestFuzzslashableAttesterIndices_10000(_ *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	attesterSlashing := &ethpb.AttesterSlashing{}
 
-	for range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(attesterSlashing)
 		SlashableAttesterIndices(attesterSlashing)
 	}
@@ -275,7 +275,7 @@ func TestFuzzProcessAttestationsNoVerify_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	b := &ethpb.SignedBeaconBlock{}
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(b)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -298,7 +298,7 @@ func TestFuzzVerifyIndexedAttestationn_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	idxAttestation := &ethpb.IndexedAttestation{}
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(idxAttestation)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -313,7 +313,7 @@ func TestFuzzverifyDeposit_10000(t *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	deposit := &ethpb.Deposit{}
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -329,7 +329,7 @@ func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
 	state := &ethpb.BeaconState{}
 	e := &ethpb.SignedVoluntaryExit{}
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -346,7 +346,7 @@ func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	state := &ethpb.BeaconState{}
 	e := &ethpb.SignedVoluntaryExit{}
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(e)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
@@ -366,7 +366,7 @@ func TestFuzzVerifyExit_10000(t *testing.T) {
 	fork := &ethpb.Fork{}
 	var slot primitives.Slot
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(ve)
 		fuzzer.Fuzz(rawVal)
 		fuzzer.Fuzz(fork)

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++
 		}
 	}

beacon-chain/core/blocks/eth1_data_test.go

@@ -19,7 +19,7 @@ import (
 
 func FakeDeposits(n uint64) []*ethpb.Eth1Data {
 	deposits := make([]*ethpb.Eth1Data, n)
-	for i := range n {
+	for i := uint64(0); i < n; i++ {
 		deposits[i] = &ethpb.Eth1Data{
 			DepositCount: 1,
 			DepositRoot:  bytesutil.PadTo([]byte("root"), 32),
@@ -175,7 +175,7 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 	}
 
 	period := uint64(params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().EpochsPerEth1VotingPeriod)))
-	for range period {
+	for i := uint64(0); i < period; i++ {
 		processedState, err := blocks.ProcessEth1DataInBlock(t.Context(), beaconState, b.Block.Body.Eth1Data)
 		require.NoError(t, err)
 		require.Equal(t, true, processedState.Version() == version.Phase0)

beacon-chain/core/blocks/header_test.go

@@ -27,7 +27,7 @@ func init() {
 
 func TestProcessBlockHeader_ImproperBlockSlot(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, 32),
 			WithdrawalCredentials: make([]byte, 32),
@@ -104,7 +104,7 @@ func TestProcessBlockHeader_WrongProposerSig(t *testing.T) {
 
 func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, 32),
 			WithdrawalCredentials: make([]byte, 32),
@@ -148,7 +148,7 @@ func TestProcessBlockHeader_DifferentSlots(t *testing.T) {
 
 func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, 48),
 			WithdrawalCredentials: make([]byte, 32),
@@ -189,7 +189,7 @@ func TestProcessBlockHeader_PreviousBlockRootNotSignedRoot(t *testing.T) {
 
 func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, 48),
 			WithdrawalCredentials: make([]byte, 32),
@@ -233,7 +233,7 @@ func TestProcessBlockHeader_SlashedProposer(t *testing.T) {
 
 func TestProcessBlockHeader_OK(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, 32),
 			WithdrawalCredentials: make([]byte, 32),
@@ -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 := 0; i < len(validators); i++ {
+		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")
+}

beacon-chain/core/blocks/payload.go

@@ -90,9 +90,6 @@ func IsExecutionEnabled(st state.ReadOnlyBeaconState, body interfaces.ReadOnlyBe
 	if st == nil || body == nil {
 		return false, errors.New("nil state or block body")
 	}
-	if st.Version() >= version.Capella {
-		return true, nil
-	}
 	if IsPreBellatrixVersion(st.Version()) {
 		return false, nil
 	}

beacon-chain/core/blocks/payload_test.go

@@ -260,12 +260,11 @@ func Test_IsExecutionBlockCapella(t *testing.T) {
 
 func Test_IsExecutionEnabled(t *testing.T) {
 	tests := []struct {
-		name         string
-		payload      *enginev1.ExecutionPayload
-		header       interfaces.ExecutionData
-		useAltairSt  bool
-		useCapellaSt bool
-		want         bool
+		name        string
+		payload     *enginev1.ExecutionPayload
+		header      interfaces.ExecutionData
+		useAltairSt bool
+		want        bool
 	}{
 		{
 			name:    "use older than bellatrix state",
@@ -332,17 +331,6 @@ func Test_IsExecutionEnabled(t *testing.T) {
 			}(),
 			want: true,
 		},
-		{
-			name:    "capella state always enabled",
-			payload: emptyPayload(),
-			header: func() interfaces.ExecutionData {
-				h, err := emptyPayloadHeader()
-				require.NoError(t, err)
-				return h
-			}(),
-			useCapellaSt: true,
-			want:         true,
-		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
@@ -354,8 +342,6 @@ func Test_IsExecutionEnabled(t *testing.T) {
 			require.NoError(t, err)
 			if tt.useAltairSt {
 				st, _ = util.DeterministicGenesisStateAltair(t, 1)
-			} else if tt.useCapellaSt {
-				st, _ = util.DeterministicGenesisStateCapella(t, 1)
 			}
 			got, err := blocks.IsExecutionEnabled(st, body)
 			require.NoError(t, err)
@@ -865,7 +851,8 @@ func BenchmarkBellatrixComplete(b *testing.B) {
 	require.NoError(b, err)
 	require.NoError(b, st.SetLatestExecutionPayloadHeader(h))
 
-	for b.Loop() {
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
 		_, err := blocks.IsMergeTransitionComplete(st)
 		require.NoError(b, err)
 	}

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(

beacon-chain/core/electra/churn_test.go

@@ -28,7 +28,7 @@ func createValidatorsWithTotalActiveBalance(totalBal primitives.Gwei) []*eth.Val
 			ActivationEpoch:       primitives.Epoch(0),
 			EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
 			ExitEpoch:             params.BeaconConfig().FarFutureEpoch,
-			PublicKey:             fmt.Appendf(nil, "val_%d", i),
+			PublicKey:             []byte(fmt.Sprintf("val_%d", i)),
 			WithdrawableEpoch:     params.BeaconConfig().FarFutureEpoch,
 			WithdrawalCredentials: wd,
 		}

beacon-chain/core/electra/consolidations.go

@@ -278,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
 		}
 

beacon-chain/core/electra/deposit_fuzz_test.go

@@ -16,7 +16,7 @@ func TestFuzzProcessDeposits_10000(t *testing.T) {
 	state := &ethpb.BeaconStateElectra{}
 	deposits := make([]*ethpb.Deposit, 100)
 	ctx := t.Context()
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		for i := range deposits {
 			fuzzer.Fuzz(deposits[i])
@@ -36,7 +36,7 @@ func TestFuzzProcessDeposit_10000(t *testing.T) {
 	state := &ethpb.BeaconStateElectra{}
 	deposit := &ethpb.Deposit{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(state)
 		fuzzer.Fuzz(deposit)
 		s, err := state_native.InitializeFromProtoUnsafeElectra(state)

beacon-chain/core/electra/deposits_test.go

@@ -95,7 +95,7 @@ func TestProcessPendingDeposits(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, primitives.Gwei(100), res)
 				// Validators 0..9 should have their balance increased
-				for i := range primitives.ValidatorIndex(10) {
+				for i := primitives.ValidatorIndex(0); i < 10; i++ {
 					b, err := st.BalanceAtIndex(i)
 					require.NoError(t, err)
 					require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(amountAvailForProcessing)/10, b)
@@ -122,7 +122,7 @@ func TestProcessPendingDeposits(t *testing.T) {
 			check: func(t *testing.T, st state.BeaconState) {
 				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
 				// Validators 0..9 should have their balance increased
-				for i := range primitives.ValidatorIndex(2) {
+				for i := primitives.ValidatorIndex(0); i < 2; i++ {
 					b, err := st.BalanceAtIndex(i)
 					require.NoError(t, err)
 					require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(amountAvailForProcessing), b)
@@ -149,7 +149,7 @@ func TestProcessPendingDeposits(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, primitives.Gwei(0), res)
 				// Validators 0..4 should have their balance increased
-				for i := range primitives.ValidatorIndex(4) {
+				for i := primitives.ValidatorIndex(0); i < 4; i++ {
 					b, err := st.BalanceAtIndex(i)
 					require.NoError(t, err)
 					require.Equal(t, params.BeaconConfig().MinActivationBalance+uint64(amountAvailForProcessing)/5, b)
@@ -528,7 +528,7 @@ func stateWithActiveBalanceETH(t *testing.T, balETH uint64) state.BeaconState {
 
 	vals := make([]*eth.Validator, numVals)
 	bals := make([]uint64, numVals)
-	for i := range numVals {
+	for i := uint64(0); i < numVals; i++ {
 		wc := make([]byte, 32)
 		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 		wc[31] = byte(i)

beacon-chain/core/electra/registry_updates_test.go

@@ -56,7 +56,7 @@ func TestProcessRegistryUpdates(t *testing.T) {
 					Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
 					FinalizedCheckpoint: &eth.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
 				}
-				for range uint64(10) {
+				for i := uint64(0); i < 10; i++ {
 					base.Validators = append(base.Validators, &eth.Validator{
 						ActivationEligibilityEpoch: finalizedEpoch,
 						EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
@@ -82,7 +82,7 @@ func TestProcessRegistryUpdates(t *testing.T) {
 					Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
 					FinalizedCheckpoint: &eth.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
 				}
-				for range uint64(10) {
+				for i := uint64(0); i < 10; i++ {
 					base.Validators = append(base.Validators, &eth.Validator{
 						EffectiveBalance:  params.BeaconConfig().EjectionBalance - 1,
 						ExitEpoch:         params.BeaconConfig().FarFutureEpoch,
@@ -108,7 +108,7 @@ func TestProcessRegistryUpdates(t *testing.T) {
 					Slot:                5 * params.BeaconConfig().SlotsPerEpoch,
 					FinalizedCheckpoint: &eth.Checkpoint{Epoch: finalizedEpoch, Root: make([]byte, fieldparams.RootLength)},
 				}
-				for range uint64(10) {
+				for i := uint64(0); i < 10; i++ {
 					base.Validators = append(base.Validators, &eth.Validator{
 						EffectiveBalance:  params.BeaconConfig().EjectionBalance - 1,
 						ExitEpoch:         10,
@@ -157,7 +157,7 @@ func Benchmark_ProcessRegistryUpdates_MassEjection(b *testing.B) {
 	st, err := util.NewBeaconStateElectra()
 	require.NoError(b, err)
 
-	for b.Loop() {
+	for i := 0; i < b.N; i++ {
 		b.StopTimer()
 		if err := st.SetValidators(genValidators(100000)); err != nil {
 			panic(err)

beacon-chain/core/epoch/epoch_processing.go

@@ -329,7 +329,10 @@ func ProcessEffectiveBalanceUpdates(st state.BeaconState) (state.BeaconState, er
 		balance := bals[idx]
 
 		if balance+downwardThreshold < val.EffectiveBalance() || val.EffectiveBalance()+upwardThreshold < balance {
-			effectiveBal := min(maxEffBalance, balance-balance%effBalanceInc)
+			effectiveBal := maxEffBalance
+			if effectiveBal > balance-balance%effBalanceInc {
+				effectiveBal = balance - balance%effBalanceInc
+			}
 			if effectiveBal != val.EffectiveBalance() {
 				newVal = val.Copy()
 				newVal.EffectiveBalance = effectiveBal

beacon-chain/core/epoch/epoch_processing_fuzz_test.go

@@ -14,7 +14,7 @@ func TestFuzzFinalUpdates_10000(t *testing.T) {
 	fuzzer := gofuzz.NewWithSeed(0)
 	base := &ethpb.BeaconState{}
 
-	for i := range 10000 {
+	for i := 0; i < 10000; i++ {
 		fuzzer.Fuzz(base)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(base)
 		require.NoError(t, err)

beacon-chain/core/epoch/epoch_processing_test.go

@@ -218,7 +218,7 @@ func TestProcessRegistryUpdates_EligibleToActivate_Cancun(t *testing.T) {
 	cfg.ChurnLimitQuotient = 1
 	params.OverrideBeaconConfig(cfg)
 
-	for range uint64(10) {
+	for i := uint64(0); i < 10; i++ {
 		base.Validators = append(base.Validators, &ethpb.Validator{
 			ActivationEligibilityEpoch: finalizedEpoch,
 			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
@@ -314,28 +314,28 @@ func TestProcessRegistryUpdates_CanExits(t *testing.T) {
 
 func buildState(t testing.TB, slot primitives.Slot, validatorCount uint64) state.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
 			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
 		}
 	}
 	validatorBalances := make([]uint64, len(validators))
-	for i := range validatorBalances {
+	for i := 0; i < len(validatorBalances); i++ {
 		validatorBalances[i] = params.BeaconConfig().MaxEffectiveBalance
 	}
 	latestActiveIndexRoots := make(
 		[][]byte,
 		params.BeaconConfig().EpochsPerHistoricalVector,
 	)
-	for i := range latestActiveIndexRoots {
+	for i := 0; i < len(latestActiveIndexRoots); i++ {
 		latestActiveIndexRoots[i] = params.BeaconConfig().ZeroHash[:]
 	}
 	latestRandaoMixes := make(
 		[][]byte,
 		params.BeaconConfig().EpochsPerHistoricalVector,
 	)
-	for i := range latestRandaoMixes {
+	for i := 0; i < len(latestRandaoMixes); i++ {
 		latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
 	}
 	s, err := util.NewBeaconState()

beacon-chain/core/epoch/precompute/justification_finalization_test.go

@@ -19,7 +19,7 @@ func TestProcessJustificationAndFinalizationPreCompute_ConsecutiveEpochs(t *test
 	e := params.BeaconConfig().FarFutureEpoch
 	a := params.BeaconConfig().MaxEffectiveBalance
 	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerEpoch*2+1)
-	for i := range blockRoots {
+	for i := 0; i < len(blockRoots); i++ {
 		blockRoots[i] = []byte{byte(i)}
 	}
 	base := &ethpb.BeaconState{
@@ -56,7 +56,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyCurrentEpoch(t *te
 	e := params.BeaconConfig().FarFutureEpoch
 	a := params.BeaconConfig().MaxEffectiveBalance
 	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerEpoch*2+1)
-	for i := range blockRoots {
+	for i := 0; i < len(blockRoots); i++ {
 		blockRoots[i] = []byte{byte(i)}
 	}
 	base := &ethpb.BeaconState{
@@ -93,7 +93,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testi
 	e := params.BeaconConfig().FarFutureEpoch
 	a := params.BeaconConfig().MaxEffectiveBalance
 	blockRoots := make([][]byte, params.BeaconConfig().SlotsPerEpoch*2+1)
-	for i := range blockRoots {
+	for i := 0; i < len(blockRoots); i++ {
 		blockRoots[i] = []byte{byte(i)}
 	}
 	base := &ethpb.BeaconState{
@@ -128,7 +128,7 @@ func TestProcessJustificationAndFinalizationPreCompute_JustifyPrevEpoch(t *testi
 func TestUnrealizedCheckpoints(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
 	balances := make([]uint64, len(validators))
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
 			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,

beacon-chain/core/epoch/precompute/reward_penalty.go

@@ -42,7 +42,7 @@ func ProcessRewardsAndPenaltiesPrecompute(
 		return nil, errors.Wrap(err, "could not get proposer attestation delta")
 	}
 	validatorBals := state.Balances()
-	for i := range numOfVals {
+	for i := 0; i < numOfVals; i++ {
 		vp[i].BeforeEpochTransitionBalance = validatorBals[i]
 
 		// Compute the post balance of the validator after accounting for the

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -24,7 +24,7 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	validatorCount := uint64(2048)
 	base := buildState(e+3, validatorCount)
 	atts := make([]*ethpb.PendingAttestation, 3)
-	for i := range atts {
+	for i := 0; i < len(atts); i++ {
 		atts[i] = &ethpb.PendingAttestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
@@ -63,7 +63,7 @@ func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 	base := buildState(e+2, validatorCount)
 	atts := make([]*ethpb.PendingAttestation, 3)
 	var emptyRoot [32]byte
-	for i := range atts {
+	for i := 0; i < len(atts); i++ {
 		atts[i] = &ethpb.PendingAttestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
@@ -99,7 +99,7 @@ func TestAttestationDeltas_ZeroInclusionDelay(t *testing.T) {
 	base := buildState(e+2, validatorCount)
 	atts := make([]*ethpb.PendingAttestation, 3)
 	var emptyRoot [32]byte
-	for i := range atts {
+	for i := 0; i < len(atts); i++ {
 		atts[i] = &ethpb.PendingAttestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{
@@ -131,7 +131,7 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 	validatorCount := uint64(2048)
 	base := buildState(e+3, validatorCount)
 	atts := make([]*ethpb.PendingAttestation, 3)
-	for i := range atts {
+	for i := 0; i < len(atts); i++ {
 		atts[i] = &ethpb.PendingAttestation{
 			Data: &ethpb.AttestationData{
 				Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
@@ -176,28 +176,28 @@ func TestProcessRewardsAndPenaltiesPrecompute_SlashedInactivePenalty(t *testing.
 
 func buildState(slot primitives.Slot, validatorCount uint64) *ethpb.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
 			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
 		}
 	}
 	validatorBalances := make([]uint64, len(validators))
-	for i := range validatorBalances {
+	for i := 0; i < len(validatorBalances); i++ {
 		validatorBalances[i] = params.BeaconConfig().MaxEffectiveBalance
 	}
 	latestActiveIndexRoots := make(
 		[][]byte,
 		params.BeaconConfig().EpochsPerHistoricalVector,
 	)
-	for i := range latestActiveIndexRoots {
+	for i := 0; i < len(latestActiveIndexRoots); i++ {
 		latestActiveIndexRoots[i] = params.BeaconConfig().ZeroHash[:]
 	}
 	latestRandaoMixes := make(
 		[][]byte,
 		params.BeaconConfig().EpochsPerHistoricalVector,
 	)
-	for i := range latestRandaoMixes {
+	for i := 0; i < len(latestRandaoMixes); i++ {
 		latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
 	}
 	return &ethpb.BeaconState{

beacon-chain/core/feed/event.go

@@ -17,5 +17,5 @@ type Event struct {
 	// Type is the type of event.
 	Type EventType
 	// Data is event-specific data.
-	Data any
+	Data interface{}
 }

beacon-chain/core/gloas/BUILD.bazel

@@ -1,31 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["attestation.go"],
-    importpath = "github.com/OffchainLabs/prysm/v7/beacon-chain/core/gloas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["attestation_test.go"],
-    embed = [":go_default_library"],
-    deps = [
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/require:go_default_library",
-        "//time/slots:go_default_library",
-    ],
-)

beacon-chain/core/gloas/attestation.go

@@ -1,144 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v7/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v7/config/params"
-	"github.com/OffchainLabs/prysm/v7/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/runtime/version"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-// SameSlotAttestation checks if the attestation is for the same slot as the block root in the state.
-// Spec v1.6.1 (pseudocode excerpt):
-//
-//	is_attestation_same_slot(state, data):
-//	    block_root_at_slot = get_block_root_at_slot(state, data.slot)
-//	    block_root_at_prev_slot = get_block_root_at_slot(state, data.slot - 1)
-//	    return block_root_at_slot == data.beacon_block_root and block_root_at_prev_slot != data.beacon_block_root
-func SameSlotAttestation(state state.ReadOnlyBeaconState, blockRoot [32]byte, slot primitives.Slot) (bool, error) {
-	if slot == 0 {
-		return true, nil
-	}
-
-	blockRootAtSlot, err := helpers.BlockRootAtSlot(state, slot)
-	if err != nil {
-		return false, err
-	}
-	matchingBlockRoot := bytes.Equal(blockRoot[:], blockRootAtSlot)
-
-	blockRootAtPrevSlot, err := helpers.BlockRootAtSlot(state, slot-1)
-	if err != nil {
-		return false, err
-	}
-	matchingPrevBlockRoot := bytes.Equal(blockRoot[:], blockRootAtPrevSlot)
-
-	return matchingBlockRoot && !matchingPrevBlockRoot, nil
-}
-
-// UpdatePendingPaymentWeight updates the builder pending payment weight based on attestation participation.
-// Spec v1.6.1 (pseudocode excerpt):
-//
-//	if data.target.epoch == get_current_epoch(state):
-//	    epoch_participation = state.current_epoch_participation
-//	    payment = state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH]
-//	else:
-//	    epoch_participation = state.previous_epoch_participation
-//	    payment = state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH]
-//
-//	for index in get_attesting_indices(state, attestation):
-//	    will_set_new_flag = False
-//	    for flag_index, weight in enumerate(PARTICIPATION_FLAG_WEIGHTS):
-//	        if flag_index in participation_flag_indices and not has_flag(epoch_participation[index], flag_index):
-//	            epoch_participation[index] = add_flag(epoch_participation[index], flag_index)
-//	            proposer_reward_numerator += get_base_reward(state, index) * weight
-//	            will_set_new_flag = True
-//	    if will_set_new_flag and is_attestation_same_slot(state, data) and payment.withdrawal.amount > 0:
-//	        payment.weight += state.validators[index].effective_balance
-//
-//	if current_epoch_target:
-//	    state.builder_pending_payments[SLOTS_PER_EPOCH + data.slot % SLOTS_PER_EPOCH] = payment
-//	else:
-//	    state.builder_pending_payments[data.slot % SLOTS_PER_EPOCH] = payment
-func UpdatePendingPaymentWeight(beaconState state.BeaconState, att ethpb.Att, indices []uint64, participatedFlags map[uint8]bool) (state.BeaconState, error) {
-	if beaconState.Version() < version.Gloas {
-		return beaconState, nil
-	}
-
-	data := att.GetData()
-	epoch := slots.ToEpoch(beaconState.Slot())
-
-	isSameSlot, err := SameSlotAttestation(beaconState, [32]byte(data.BeaconBlockRoot), data.Slot)
-	if err != nil {
-		return nil, err
-	}
-	if !isSameSlot {
-		return beaconState, nil
-	}
-
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	var (
-		paymentSlot        primitives.Slot
-		payment            *ethpb.BuilderPendingPayment
-		epochParticipation []byte
-	)
-	if data.Target.Epoch == epoch {
-		paymentSlot = slotsPerEpoch + (data.Slot % slotsPerEpoch)
-		payment, err = beaconState.BuilderPendingPayment(uint64(paymentSlot))
-		if err != nil {
-			return nil, err
-		}
-		epochParticipation, err = beaconState.CurrentEpochParticipation()
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		paymentSlot = data.Slot % slotsPerEpoch
-		payment, err = beaconState.BuilderPendingPayment(uint64(paymentSlot))
-		if err != nil {
-			return nil, err
-		}
-		epochParticipation, err = beaconState.PreviousEpochParticipation()
-		if err != nil {
-			return nil, err
-		}
-	}
-	if payment.Withdrawal.Amount == 0 {
-		return beaconState, nil
-	}
-
-	cfg := params.BeaconConfig()
-	flagIndices := []uint8{cfg.TimelySourceFlagIndex, cfg.TimelyTargetFlagIndex, cfg.TimelyHeadFlagIndex}
-	hasNewFlag := func(idx uint64) bool {
-		participation := epochParticipation[idx]
-		for _, f := range flagIndices {
-			if !participatedFlags[f] {
-				continue
-			}
-			if participation&(1<<f) == 0 {
-				return true
-			}
-		}
-		return false
-	}
-
-	for _, idx := range indices {
-		if !hasNewFlag(idx) {
-			continue
-		}
-		validator, err := beaconState.ValidatorAtIndex(primitives.ValidatorIndex(idx))
-		if err != nil {
-			return nil, err
-		}
-		payment.Weight += primitives.Gwei(validator.EffectiveBalance)
-	}
-
-	if err := beaconState.SetBuilderPendingPayment(uint64(paymentSlot), payment); err != nil {
-		return nil, err
-	}
-
-	return beaconState, nil
-}

beacon-chain/core/gloas/attestation_test.go

@@ -1,288 +0,0 @@
-package gloas
-
-import (
-	"bytes"
-	"testing"
-
-	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/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v7/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v7/testing/require"
-	"github.com/OffchainLabs/prysm/v7/time/slots"
-)
-
-func buildStateWithBlockRoots(t *testing.T, stateSlot primitives.Slot, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x11}, 32)
-	}
-
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x22}, 32)
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                  stateSlot,
-		GenesisValidatorsRoot: bytes.Repeat([]byte{0x33}, 32),
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x44}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x44}, 4),
-			Epoch:           0,
-		},
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{},
-		Balances:                     []uint64{},
-		BuilderPendingPayments:       make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2),
-		BuilderPendingWithdrawals:    []*ethpb.BuilderPendingWithdrawal{},
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestSameSlotAttestation(t *testing.T) {
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-	rootC := bytes.Repeat([]byte{0xCC}, 32)
-
-	tests := []struct {
-		name      string
-		stateSlot primitives.Slot
-		slot      primitives.Slot
-		blockRoot []byte
-		roots     map[primitives.Slot][]byte
-		want      bool
-	}{
-		{
-			name:      "slot zero always true",
-			stateSlot: 1,
-			slot:      0,
-			blockRoot: rootA,
-			roots:     map[primitives.Slot][]byte{},
-			want:      true,
-		},
-		{
-			name:      "matching current different previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: true,
-		},
-		{
-			name:      "matching current same previous",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootA,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootA,
-			},
-			want: false,
-		},
-		{
-			name:      "non matching current",
-			stateSlot: 6,
-			slot:      4,
-			blockRoot: rootC,
-			roots: map[primitives.Slot][]byte{
-				4: rootA,
-				3: rootB,
-			},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			state := buildStateWithBlockRoots(t, tt.stateSlot, tt.roots)
-			var rootArr [32]byte
-			copy(rootArr[:], tt.blockRoot)
-
-			got, err := SameSlotAttestation(state, rootArr, tt.slot)
-			require.NoError(t, err)
-			require.Equal(t, tt.want, got)
-		})
-	}
-}
-
-func buildStateForPaymentTest(t *testing.T, stateSlot primitives.Slot, paymentIdx int, amount primitives.Gwei, weight primitives.Gwei, roots map[primitives.Slot][]byte) *state_native.BeaconState {
-	t.Helper()
-
-	cfg := params.BeaconConfig()
-	blockRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for slot, root := range roots {
-		blockRoots[slot%cfg.SlotsPerHistoricalRoot] = root
-	}
-
-	stateRoots := make([][]byte, cfg.SlotsPerHistoricalRoot)
-	for i := range stateRoots {
-		stateRoots[i] = bytes.Repeat([]byte{0x44}, 32)
-	}
-	randaoMixes := make([][]byte, cfg.EpochsPerHistoricalVector)
-	for i := range randaoMixes {
-		randaoMixes[i] = bytes.Repeat([]byte{0x55}, 32)
-	}
-
-	validator := &ethpb.Validator{
-		PublicKey:             bytes.Repeat([]byte{0x01}, 48),
-		WithdrawalCredentials: append([]byte{cfg.ETH1AddressWithdrawalPrefixByte}, bytes.Repeat([]byte{0x02}, 31)...),
-		EffectiveBalance:      cfg.MinActivationBalance,
-	}
-
-	payments := make([]*ethpb.BuilderPendingPayment, cfg.SlotsPerEpoch*2)
-	for i := range payments {
-		payments[i] = &ethpb.BuilderPendingPayment{
-			Withdrawal: &ethpb.BuilderPendingWithdrawal{
-				FeeRecipient: make([]byte, 20),
-			},
-		}
-	}
-	payments[paymentIdx] = &ethpb.BuilderPendingPayment{
-		Weight: weight,
-		Withdrawal: &ethpb.BuilderPendingWithdrawal{
-			FeeRecipient: make([]byte, 20),
-			Amount:       amount,
-		},
-	}
-
-	execPayloadAvailability := make([]byte, cfg.SlotsPerHistoricalRoot/8)
-
-	stProto := &ethpb.BeaconStateGloas{
-		Slot:                         stateSlot,
-		GenesisValidatorsRoot:        bytes.Repeat([]byte{0x33}, 32),
-		BlockRoots:                   blockRoots,
-		StateRoots:                   stateRoots,
-		RandaoMixes:                  randaoMixes,
-		ExecutionPayloadAvailability: execPayloadAvailability,
-		Validators:                   []*ethpb.Validator{validator},
-		Balances:                     []uint64{cfg.MinActivationBalance},
-		CurrentEpochParticipation:    []byte{0},
-		PreviousEpochParticipation:   []byte{0},
-		BuilderPendingPayments:       payments,
-		Fork: &ethpb.Fork{
-			CurrentVersion:  bytes.Repeat([]byte{0x66}, 4),
-			PreviousVersion: bytes.Repeat([]byte{0x66}, 4),
-			Epoch:           0,
-		},
-	}
-
-	state, err := state_native.InitializeFromProtoGloas(stProto)
-	require.NoError(t, err)
-	return state.(*state_native.BeaconState)
-}
-
-func TestUpdatePendingPaymentWeight(t *testing.T) {
-	cfg := params.BeaconConfig()
-	slotsPerEpoch := cfg.SlotsPerEpoch
-	slot := primitives.Slot(4)
-	stateSlot := slot + 1
-	currentEpoch := slots.ToEpoch(stateSlot)
-
-	rootA := bytes.Repeat([]byte{0xAA}, 32)
-	rootB := bytes.Repeat([]byte{0xBB}, 32)
-
-	tests := []struct {
-		name          string
-		targetEpoch   primitives.Epoch
-		blockRoot     []byte
-		initialAmount primitives.Gwei
-		initialWeight primitives.Gwei
-		wantWeight    primitives.Gwei
-	}{
-		{
-			name:          "same slot current epoch adds weight",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootA,
-			initialAmount: 10,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-		{
-			name:          "same slot zero amount no weight change",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootA,
-			initialAmount: 0,
-			initialWeight: 5,
-			wantWeight:    5,
-		},
-		{
-			name:          "non matching block root no change",
-			targetEpoch:   currentEpoch,
-			blockRoot:     rootB,
-			initialAmount: 10,
-			initialWeight: 7,
-			wantWeight:    7,
-		},
-		{
-			name:          "previous epoch target uses earlier slot",
-			targetEpoch:   currentEpoch - 1,
-			blockRoot:     rootA,
-			initialAmount: 20,
-			initialWeight: 0,
-			wantWeight:    primitives.Gwei(cfg.MinActivationBalance),
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			var paymentIdx int
-			if tt.targetEpoch == currentEpoch {
-				paymentIdx = int(slotsPerEpoch + (slot % slotsPerEpoch))
-			} else {
-				paymentIdx = int(slot % slotsPerEpoch)
-			}
-			state := buildStateForPaymentTest(t, stateSlot, paymentIdx, tt.initialAmount, tt.initialWeight, map[primitives.Slot][]byte{
-				slot:     tt.blockRoot,
-				slot - 1: rootB,
-			})
-
-			att := &ethpb.Attestation{
-				Data: &ethpb.AttestationData{
-					Slot:            slot,
-					CommitteeIndex:  0,
-					BeaconBlockRoot: tt.blockRoot,
-					Source:          &ethpb.Checkpoint{},
-					Target: &ethpb.Checkpoint{
-						Epoch: tt.targetEpoch,
-					},
-				},
-			}
-
-			participatedFlags := map[uint8]bool{
-				cfg.TimelySourceFlagIndex: true,
-				cfg.TimelyTargetFlagIndex: true,
-				cfg.TimelyHeadFlagIndex:   true,
-			}
-			indices := []uint64{0}
-
-			gotState, err := UpdatePendingPaymentWeight(state, att, indices, participatedFlags)
-			require.NoError(t, err)
-
-			payment, err := gotState.BuilderPendingPayment(uint64(paymentIdx))
-			require.NoError(t, err)
-			require.Equal(t, tt.wantWeight, payment.Weight)
-		})
-	}
-}

beacon-chain/core/helpers/attestation_test.go

@@ -54,7 +54,7 @@ func TestAttestation_ComputeSubnetForAttestation(t *testing.T) {
 	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize
 	validators := make([]*ethpb.Validator, validatorCount)
 
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{

beacon-chain/core/helpers/beacon_committee.go

@@ -5,7 +5,7 @@ package helpers
 import (
 	"context"
 	"fmt"
-	"slices"
+	"sort"
 
 	"github.com/OffchainLabs/go-bitfield"
 	"github.com/OffchainLabs/prysm/v7/beacon-chain/cache"
@@ -515,7 +515,9 @@ func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState,
 	// used for failing verify signature fallback.
 	sortedIndices := make([]primitives.ValidatorIndex, len(shuffledIndices))
 	copy(sortedIndices, shuffledIndices)
-	slices.Sort(sortedIndices)
+	sort.Slice(sortedIndices, func(i, j int) bool {
+		return sortedIndices[i] < sortedIndices[j]
+	})
 
 	if err := committeeCache.AddCommitteeShuffledList(ctx, &cache.Committees{
 		ShuffledIndices: shuffledIndices,

beacon-chain/core/helpers/beacon_committee_test.go

@@ -29,7 +29,7 @@ func TestComputeCommittee_WithoutCache(t *testing.T) {
 	validatorCount := committeeCount * params.BeaconConfig().TargetCommitteeSize
 	validators := make([]*ethpb.Validator, validatorCount)
 
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -122,7 +122,7 @@ func TestCommitteeAssignments_NoProposerForSlot0(t *testing.T) {
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		var activationEpoch primitives.Epoch
 		if i >= len(validators)/2 {
 			activationEpoch = 3
@@ -151,7 +151,7 @@ func TestCommitteeAssignments_CanRetrieve(t *testing.T) {
 	// Initialize test with 256 validators, each slot and each index gets 4 validators.
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
 	validatorIndices := make([]primitives.ValidatorIndex, len(validators))
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		// First 2 epochs only half validators are activated.
 		var activationEpoch primitives.Epoch
 		if i >= len(validators)/2 {
@@ -234,7 +234,7 @@ func TestCommitteeAssignments_CannotRetrieveFuture(t *testing.T) {
 
 	// Initialize test with 256 validators, each slot and each index gets 4 validators.
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		// First 2 epochs only half validators are activated.
 		var activationEpoch primitives.Epoch
 		if i >= len(validators)/2 {
@@ -266,7 +266,7 @@ func TestCommitteeAssignments_CannotRetrieveOlderThanSlotsPerHistoricalRoot(t *t
 
 	// Initialize test with 256 validators, each slot and each index gets 4 validators.
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -287,7 +287,7 @@ func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) {
 
 	// Initialize test with 256 validators, each slot and each index gets 4 validators.
 	validators := make([]*ethpb.Validator, 4*params.BeaconConfig().SlotsPerEpoch)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ActivationEpoch: 0,
 			ExitEpoch:       params.BeaconConfig().FarFutureEpoch,
@@ -323,7 +323,7 @@ func TestCommitteeAssignments_EverySlotHasMin1Proposer(t *testing.T) {
 func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 	validators := make([]*ethpb.Validator, 2*params.BeaconConfig().SlotsPerEpoch)
 	activeRoots := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -489,7 +489,7 @@ func TestUpdateCommitteeCache_CanUpdateAcrossEpochs(t *testing.T) {
 
 func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
 	validators := make([]*ethpb.Validator, 300000)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -512,7 +512,8 @@ func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
 		panic(err)
 	}
 
-	for b.Loop() {
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
 		_, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
 		if err != nil {
 			panic(err)
@@ -522,7 +523,7 @@ func BenchmarkComputeCommittee300000_WithPreCache(b *testing.B) {
 
 func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) {
 	validators := make([]*ethpb.Validator, 3000000)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -545,7 +546,8 @@ func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) {
 		panic(err)
 	}
 
-	for b.Loop() {
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
 		_, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
 		if err != nil {
 			panic(err)
@@ -555,7 +557,7 @@ func BenchmarkComputeCommittee3000000_WithPreCache(b *testing.B) {
 
 func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) {
 	validators := make([]*ethpb.Validator, 128000)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -574,8 +576,8 @@ func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) {
 
 	i := uint64(0)
 	index := uint64(0)
-
-	for b.Loop() {
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
 		i++
 		_, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
 		if err != nil {
@@ -590,7 +592,7 @@ func BenchmarkComputeCommittee128000_WithOutPreCache(b *testing.B) {
 
 func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) {
 	validators := make([]*ethpb.Validator, 1000000)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -609,8 +611,8 @@ func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) {
 
 	i := uint64(0)
 	index := uint64(0)
-
-	for b.Loop() {
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
 		i++
 		_, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
 		if err != nil {
@@ -625,7 +627,7 @@ func BenchmarkComputeCommittee1000000_WithOutCache(b *testing.B) {
 
 func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
 	validators := make([]*ethpb.Validator, 4000000)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -644,8 +646,8 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
 
 	i := uint64(0)
 	index := uint64(0)
-
-	for b.Loop() {
+	b.ResetTimer()
+	for n := 0; n < b.N; n++ {
 		i++
 		_, err := helpers.ComputeCommittee(indices, seed, index, params.BeaconConfig().MaxCommitteesPerSlot)
 		if err != nil {
@@ -661,7 +663,7 @@ func BenchmarkComputeCommittee4000000_WithOutCache(b *testing.B) {
 func TestBeaconCommitteeFromState_UpdateCacheForPreviousEpoch(t *testing.T) {
 	committeeSize := uint64(16)
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(committeeSize))
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -686,7 +688,7 @@ func TestBeaconCommitteeFromState_UpdateCacheForPreviousEpoch(t *testing.T) {
 
 func TestPrecomputeProposerIndices_Ok(t *testing.T) {
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -730,7 +732,7 @@ func TestAttestationCommitteesFromState(t *testing.T) {
 	ctx := t.Context()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -766,7 +768,7 @@ func TestAttestationCommitteesFromCache(t *testing.T) {
 	ctx := t.Context()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().TargetCommitteeSize))
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -932,7 +934,7 @@ func TestInitializeProposerLookahead_RegressionTest(t *testing.T) {
 	proposerLookahead, err := helpers.InitializeProposerLookahead(ctx, state, epoch)
 	require.NoError(t, err)
 	slotsPerEpoch := int(params.BeaconConfig().SlotsPerEpoch)
-	for epochOffset := range primitives.Epoch(2) {
+	for epochOffset := primitives.Epoch(0); epochOffset < 2; epochOffset++ {
 		targetEpoch := epoch + epochOffset
 
 		activeIndices, err := helpers.ActiveValidatorIndices(ctx, state, targetEpoch)

beacon-chain/core/helpers/randao_test.go

@@ -16,7 +16,7 @@ import (
 
 func TestRandaoMix_OK(t *testing.T) {
 	randaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
-	for i := range randaoMixes {
+	for i := 0; i < len(randaoMixes); i++ {
 		intInBytes := make([]byte, 32)
 		binary.LittleEndian.PutUint64(intInBytes, uint64(i))
 		randaoMixes[i] = intInBytes
@@ -52,7 +52,7 @@ func TestRandaoMix_OK(t *testing.T) {
 
 func TestRandaoMix_CopyOK(t *testing.T) {
 	randaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
-	for i := range randaoMixes {
+	for i := 0; i < len(randaoMixes); i++ {
 		intInBytes := make([]byte, 32)
 		binary.LittleEndian.PutUint64(intInBytes, uint64(i))
 		randaoMixes[i] = intInBytes
@@ -96,7 +96,7 @@ func TestGenerateSeed_OK(t *testing.T) {
 	helpers.ClearCache()
 
 	randaoMixes := make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector)
-	for i := range randaoMixes {
+	for i := 0; i < len(randaoMixes); i++ {
 		intInBytes := make([]byte, 32)
 		binary.LittleEndian.PutUint64(intInBytes, uint64(i))
 		randaoMixes[i] = intInBytes

beacon-chain/core/helpers/rewards_penalties_test.go

@@ -239,28 +239,28 @@ func TestIsInInactivityLeak(t *testing.T) {
 
 func buildState(slot primitives.Slot, validatorCount uint64) *ethpb.BeaconState {
 	validators := make([]*ethpb.Validator, validatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
 			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
 		}
 	}
 	validatorBalances := make([]uint64, len(validators))
-	for i := range validatorBalances {
+	for i := 0; i < len(validatorBalances); i++ {
 		validatorBalances[i] = params.BeaconConfig().MaxEffectiveBalance
 	}
 	latestActiveIndexRoots := make(
 		[][]byte,
 		params.BeaconConfig().EpochsPerHistoricalVector,
 	)
-	for i := range latestActiveIndexRoots {
+	for i := 0; i < len(latestActiveIndexRoots); i++ {
 		latestActiveIndexRoots[i] = params.BeaconConfig().ZeroHash[:]
 	}
 	latestRandaoMixes := make(
 		[][]byte,
 		params.BeaconConfig().EpochsPerHistoricalVector,
 	)
-	for i := range latestRandaoMixes {
+	for i := 0; i < len(latestRandaoMixes); i++ {
 		latestRandaoMixes[i] = params.BeaconConfig().ZeroHash[:]
 	}
 	return &ethpb.BeaconState{

beacon-chain/core/helpers/shuffle.go

@@ -23,7 +23,7 @@ var maxShuffleListSize uint64 = 1 << 40
 func SplitIndices(l []uint64, n uint64) [][]uint64 {
 	var divided [][]uint64
 	var lSize = uint64(len(l))
-	for i := range n {
+	for i := uint64(0); i < n; i++ {
 		start := slice.SplitOffset(lSize, n, i)
 		end := slice.SplitOffset(lSize, n, i+1)
 		divided = append(divided, l[start:end])
@@ -103,7 +103,10 @@ func ComputeShuffledIndex(index primitives.ValidatorIndex, indexCount uint64, se
 		pivot := hash8Int % indexCount
 		flip := (pivot + indexCount - uint64(index)) % indexCount
 		// Consider every pair only once by picking the highest pair index to retrieve randomness.
-		position := max(flip, uint64(index))
+		position := uint64(index)
+		if flip > position {
+			position = flip
+		}
 		// Add position except its last byte to []buf for randomness,
 		// it will be used later to select a bit from the resulting hash.
 		binary.LittleEndian.PutUint64(posBuffer[:8], position>>8)

beacon-chain/core/helpers/shuffle_test.go

@@ -30,7 +30,7 @@ func TestShuffleList_OK(t *testing.T) {
 	var list1 []primitives.ValidatorIndex
 	seed1 := [32]byte{1, 128, 12}
 	seed2 := [32]byte{2, 128, 12}
-	for i := range 10 {
+	for i := 0; i < 10; i++ {
 		list1 = append(list1, primitives.ValidatorIndex(i))
 	}
 
@@ -55,7 +55,7 @@ func TestSplitIndices_OK(t *testing.T) {
 
 	var l []uint64
 	numValidators := uint64(64000)
-	for i := range numValidators {
+	for i := uint64(0); i < numValidators; i++ {
 		l = append(l, i)
 	}
 	split := SplitIndices(l, uint64(params.BeaconConfig().SlotsPerEpoch))
@@ -104,7 +104,7 @@ func BenchmarkIndexComparison(b *testing.B) {
 	seed := [32]byte{123, 42}
 	for _, listSize := range listSizes {
 		b.Run(fmt.Sprintf("Indexwise_ShuffleList_%d", listSize), func(ib *testing.B) {
-			for ib.Loop() {
+			for i := 0; i < ib.N; i++ {
 				// Simulate a list-shuffle by running shuffle-index listSize times.
 				for j := primitives.ValidatorIndex(0); uint64(j) < listSize; j++ {
 					_, err := ShuffledIndex(j, listSize, seed)
@@ -120,11 +120,11 @@ func BenchmarkShuffleList(b *testing.B) {
 	seed := [32]byte{123, 42}
 	for _, listSize := range listSizes {
 		testIndices := make([]primitives.ValidatorIndex, listSize)
-		for i := range listSize {
+		for i := uint64(0); i < listSize; i++ {
 			testIndices[i] = primitives.ValidatorIndex(i)
 		}
 		b.Run(fmt.Sprintf("ShuffleList_%d", listSize), func(ib *testing.B) {
-			for ib.Loop() {
+			for i := 0; i < ib.N; i++ {
 				_, err := ShuffleList(testIndices, seed)
 				assert.NoError(b, err)
 			}
@@ -161,12 +161,12 @@ func TestSplitIndicesAndOffset_OK(t *testing.T) {
 
 	var l []uint64
 	validators := uint64(64000)
-	for i := range validators {
+	for i := uint64(0); i < validators; i++ {
 		l = append(l, i)
 	}
 	chunks := uint64(6)
 	split := SplitIndices(l, chunks)
-	for i := range chunks {
+	for i := uint64(0); i < chunks; i++ {
 		if !reflect.DeepEqual(split[i], l[slice.SplitOffset(uint64(len(l)), chunks, i):slice.SplitOffset(uint64(len(l)), chunks, i+1)]) {
 			t.Errorf("Want: %v got: %v", l[slice.SplitOffset(uint64(len(l)), chunks, i):slice.SplitOffset(uint64(len(l)), chunks, i+1)], split[i])
 			break

beacon-chain/core/helpers/sync_committee_test.go

@@ -24,7 +24,7 @@ func TestCurrentPeriodPositions(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		Pubkeys: make([][]byte, params.BeaconConfig().SyncCommitteeSize),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -56,7 +56,7 @@ func TestIsCurrentEpochSyncCommittee_UsingCache(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -87,7 +87,7 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -116,7 +116,7 @@ func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -144,7 +144,7 @@ func TestIsNextEpochSyncCommittee_UsingCache(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -175,7 +175,7 @@ func TestIsNextEpochSyncCommittee_UsingCommittee(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -203,7 +203,7 @@ func TestIsNextEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -231,7 +231,7 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCache(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -262,7 +262,7 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -304,7 +304,7 @@ func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -332,7 +332,7 @@ func TestNextEpochSyncSubcommitteeIndices_UsingCache(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -363,7 +363,7 @@ func TestNextEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -391,7 +391,7 @@ func TestNextEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{
@@ -449,7 +449,7 @@ func TestIsCurrentEpochSyncCommittee_SameBlockRoot(t *testing.T) {
 	syncCommittee := &ethpb.SyncCommittee{
 		AggregatePubkey: bytesutil.PadTo([]byte{}, params.BeaconConfig().BLSPubkeyLength),
 	}
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		k := make([]byte, 48)
 		copy(k, strconv.Itoa(i))
 		validators[i] = &ethpb.Validator{

beacon-chain/core/helpers/validators.go

@@ -152,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

beacon-chain/core/helpers/validators_test.go

@@ -184,7 +184,7 @@ func TestBeaconProposerIndex_OK(t *testing.T) {
 	c.MinGenesisActiveValidatorCount = 16384
 	params.OverrideBeaconConfig(c)
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount/8)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -241,7 +241,7 @@ func TestBeaconProposerIndex_BadState(t *testing.T) {
 	c.MinGenesisActiveValidatorCount = 16384
 	params.OverrideBeaconConfig(c)
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount/8)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -270,7 +270,7 @@ func TestComputeProposerIndex_Compatibility(t *testing.T) {
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -322,7 +322,7 @@ func TestActiveValidatorCount_Genesis(t *testing.T) {
 
 	c := 1000
 	validators := make([]*ethpb.Validator, c)
-	for i := range validators {
+	for i := 0; i < len(validators); i++ {
 		validators[i] = &ethpb.Validator{
 			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 		}
@@ -357,7 +357,7 @@ func TestChurnLimit_OK(t *testing.T) {
 		helpers.ClearCache()
 
 		validators := make([]*ethpb.Validator, test.validatorCount)
-		for i := range validators {
+		for i := 0; i < len(validators); i++ {
 			validators[i] = &ethpb.Validator{
 				ExitEpoch: params.BeaconConfig().FarFutureEpoch,
 			}
@@ -861,7 +861,7 @@ func TestLastActivatedValidatorIndex_OK(t *testing.T) {
 
 	validators := make([]*ethpb.Validator, 4)
 	balances := make([]uint64, len(validators))
-	for i := range uint64(4) {
+	for i := uint64(0); i < 4; i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, params.BeaconConfig().BLSPubkeyLength),
 			WithdrawalCredentials: make([]byte, 32),

beacon-chain/core/helpers/weak_subjectivity_test.go

@@ -270,7 +270,7 @@ func genState(t *testing.T, valCount, avgBalance uint64) state.BeaconState {
 
 	validators := make([]*ethpb.Validator, valCount)
 	balances := make([]uint64, len(validators))
-	for i := range valCount {
+	for i := uint64(0); i < valCount; i++ {
 		validators[i] = &ethpb.Validator{
 			PublicKey:             make([]byte, params.BeaconConfig().BLSPubkeyLength),
 			WithdrawalCredentials: make([]byte, 32),

beacon-chain/core/peerdas/BUILD.bazel

@@ -43,15 +43,13 @@ go_test(
         "das_core_test.go",
         "info_test.go",
         "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",

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 {

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)
 

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

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())
-	})
-}