Tests

.github/workflows/go.yml

@@ -54,7 +54,7 @@ jobs:
       - name: Golangci-lint
         uses: golangci/golangci-lint-action@v5
         with:
-          version: v1.56.1
+          version: v1.55.2
           args: --config=.golangci.yml --out-${NO_FUTURE}format colored-line-number
 
   build:

.golangci.yml

@@ -73,7 +73,6 @@ linters:
     - promlinter
     - protogetter
     - revive
-    - spancheck
     - staticcheck
     - stylecheck
     - tagalign

CHANGELOG.md

@@ -4,213 +4,7 @@ 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.
 
-## [Unreleased](https://github.com/prysmaticlabs/prysm/compare/v5.2.0...HEAD)
-
-### Added
-
-- Added proper gas limit check for header from the builder.
-- Added an error field to log `Finished building block`.
-- Implemented a new `EmptyExecutionPayloadHeader` function.
-- `Finished building block`: Display error only if not nil.
-- Added support to update target and max blob count to different values per hard fork config.
-- Log before blob filesystem cache warm-up.
-- New design for the attestation pool. [PR](https://github.com/prysmaticlabs/prysm/pull/14324)
-- Add field param placeholder for Electra blob target and max to pass spec tests.
-- Add EIP-7691: Blob throughput increase.
-- SSZ files generation: Remove the `// Hash: ...` header.
-
-### Changed
-
-- Process light client finality updates only for new finalized epochs instead of doing it for every block.
-- Refactor subnets subscriptions.
-- Refactor RPC handlers subscriptions.
-- Go deps upgrade, from `ioutil` to `io`
-- Move successfully registered validator(s) on builder log to debug.
-- Update some test files to use `crypto/rand` instead of `math/rand`
-- Enforce Compound prefix (0x02) for target when processing pending consolidation request.
-- Limit consolidating by validator's effective balance.
-- Use 16-bit random value for proposer and sync committee selection filter.
-- Re-organize the content of the `*.proto` files (No functional change).
-
-### Deprecated
-
-
-### Removed
-
-
-### Fixed
-
-- Added check to prevent nil pointer deference or out of bounds array access when validating the BLSToExecutionChange on an impossibly nil validator.
-- EIP-7691: Ensure new blobs subnets are subscribed on epoch in advance.
-
-### Security
-
-
-## [v5.2.0](https://github.com/prysmaticlabs/prysm/compare/v5.1.2...v5.2.0)
-
-Updating to this release is highly recommended, especially for users running v5.1.1 or v5.1.2.
-This release is **mandatory** for all validator clients using mev-boost with a gas limit increase.
-Without upgrading to this release, validator clients will default to using local execution blocks
-when the gas limit starts to increase.
-
-This release has several fixes and new features. In this release, we have enabled QUIC protocol by
-default, which uses port 13000 for `--p2p-quic-port`. This may be a [breaking change](https://github.com/prysmaticlabs/prysm/pull/14688#issuecomment-2516713826)
-if you're using port 13000 already. This release has some improvements for raising the gas limit,
-but there are [known issues](https://hackmd.io/@ttsao/prysm-gas-limit) with the proposer settings
-file provided gas limit not being respected for mev-boost outsourced blocks. Signalling an increase
-for the gas limit works perfectly for local block production as of this release. See [pumpthegas.org](https://pumpthegas.org) for more info on raising the gas limit on L1.
-
-Notable features:
-- Prysm can reuse blobs from the EL via engine_getBlobsV1, [potentially saving bandwidth](https://hackmd.io/@ttsao/get-blobs-early-results).
-- QUIC is enabled by default. This is a UDP based networking protocol with default port 13000.
-
-### Added
-
-- Electra EIP6110: Queue deposit [pr](https://github.com/prysmaticlabs/prysm/pull/14430).
-- Add Bellatrix tests for light client functions.
-- Add Discovery Rebooter Feature.
-- Added GetBlockAttestationsV2 endpoint.
-- Light client support: Consensus types for Electra.
-- Added SubmitPoolAttesterSlashingV2 endpoint.
-- Added SubmitAggregateAndProofsRequestV2 endpoint.
-- Updated the `beacon-chain/monitor` package to Electra. [PR](https://github.com/prysmaticlabs/prysm/pull/14562)
-- Added ListAttestationsV2 endpoint.
-- Add ability to rollback node's internal state during processing.
-- Change how unsafe protobuf state is created to prevent unnecessary copies.
-- Added benchmarks for process slots for Capella, Deneb, Electra.
-- Add helper to cast bytes to string without allocating memory.
-- Added GetAggregatedAttestationV2 endpoint.
-- Added SubmitAttestationsV2 endpoint.
-- Validator REST mode Electra block support.
-- Added validator index label to `validator_statuses` metric.
-- Added Validator REST mode use of Attestation V2 endpoints and Electra attestations.
-- PeerDAS: Added proto for `DataColumnIdentifier`, `DataColumnSidecar`, `DataColumnSidecarsByRangeRequest` and `MetadataV2`.
-- Better attestation packing for Electra. [PR](https://github.com/prysmaticlabs/prysm/pull/14534)
-- P2P: Add logs when a peer is (dis)connected. Add the reason of the disconnection when we initiate it.
-- Added a Prometheus error counter metric for HTTP requests to track beacon node requests.
-- Added a Prometheus error counter metric for SSE requests.
-- Save light client updates and bootstraps in DB.
-- Added more comprehensive tests for `BlockToLightClientHeader`. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
-- Added light client feature flag check to RPC handlers. [PR](https://github.com/prysmaticlabs/prysm/pull/14736)
-- Light client: Add better error handling. [PR](https://github.com/prysmaticlabs/prysm/pull/14749)
-
-### Changed
-
-- Electra EIP6110: Queue deposit requests changes from consensus spec pr #3818
-- reversed the boolean return on `BatchVerifyDepositsSignatures`, from need verification, to all keys successfully verified
-- Fix `engine_exchangeCapabilities` implementation.
-- Updated the default `scrape-interval` in `Client-stats` to 2 minutes to accommodate Beaconcha.in API rate limits.
-- Switch to compounding when consolidating with source==target.
-- Revert block db save when saving state fails.
-- Return false from HasBlock if the block is being synced. 
-- Cleanup forkchoice on failed insertions.
-- Use read only validator for core processing to avoid unnecessary copying.
-- Use ROBlock across block processing pipeline.
-- Added missing Eth-Consensus-Version headers to GetBlockAttestationsV2 and GetAttesterSlashingsV2 endpoints.
-- When instantiating new validators, explicit set `Slashed` to false and move `EffectiveBalance` to match struct definition.
-- Updated pgo profile for beacon chain with holesky data. This improves the profile guided
-  optimizations in the go compiler.
-- Use read only state when computing the active validator list.
-- Simplified `ExitedValidatorIndices`.
-- Simplified `EjectedValidatorIndices`.
-- `engine_newPayloadV4`,`engine_getPayloadV4` are changes due to new execution request serialization decisions, [PR](https://github.com/prysmaticlabs/prysm/pull/14580)
-- Fixed various small things in state-native code.
-- Use ROBlock earlier in block syncing pipeline. 
-- Changed the signature of `ProcessPayload`.
-- Only Build the Protobuf state once during serialization.
-- Capella blocks are execution.
-- Fixed panic when http request to subscribe to event stream fails.
-- Return early for blob reconstructor during capella fork.
-- Updated block endpoint from V1 to V2.
-- Rename instances of "deposit receipts" to "deposit requests".
-- Non-blocking payload attribute event handling in beacon api [pr](https://github.com/prysmaticlabs/prysm/pull/14644).
-- Updated light client protobufs. [PR](https://github.com/prysmaticlabs/prysm/pull/14650)
-- Added `Eth-Consensus-Version` header to `ListAttestationsV2` and `GetAggregateAttestationV2` endpoints.
-- Updated light client consensus types. [PR](https://github.com/prysmaticlabs/prysm/pull/14652)
-- Update earliest exit epoch for upgrade to electra
-- Add missed exit checks to consolidation processing
-- Fixed pending deposits processing on Electra.
-- Modified `ListAttestationsV2`, `GetAttesterSlashingsV2` and `GetAggregateAttestationV2` endpoints to use slot to determine fork version.
-- Improvements to HTTP response handling. [pr](https://github.com/prysmaticlabs/prysm/pull/14673)
-- Updated `Blobs` endpoint to return additional metadata fields.
-- Made QUIC the default method to connect with peers.
-- Check kzg commitments align with blobs and proofs for beacon api end point.
-- Revert "Proposer checks gas limit before accepting builder's bid".
-- Updated quic-go to v0.48.2 .
-
-### Deprecated
-
-- `/eth/v1alpha1/validator/activation/stream` grpc wait for activation stream is deprecated. [pr](https://github.com/prysmaticlabs/prysm/pull/14514)
-- `--interop-genesis-time` and `--interop-num-validators` have been deprecated in the beacon node as the functionality has been removed. These flags have no effect.
-
-### Removed
-
-- Removed finalized validator index cache, no longer needed.
-- Removed validator queue position log on key reload and wait for activation.
-- Removed outdated spectest exclusions for EIP-6110.
-- Removed support for starting a beacon node with a deterministic interop genesis state via interop flags. Alteratively, create a genesis state with prysmctl and use `--genesis-state`. This removes about 9Mb (~11%) of unnecessary code and dependencies from the final production binary.
-- Removed kzg proof check from blob reconstructor.
-
-### Fixed
-
-- Fixed mesh size by appending `gParams.Dhi = gossipSubDhi`
-- Fix skipping partial withdrawals count.
-- wait for the async StreamEvent writer to exit before leaving the http handler, avoiding race condition panics [pr](https://github.com/prysmaticlabs/prysm/pull/14557)
-- Certain deb files were returning a 404 which made building new docker images without an existing
-  cache impossible. This has been fixed with updates to rules_oci and bazel-lib.
-- Fixed an issue where the length check between block body KZG commitments and the existing cache from the database was incompatible.
-- Fix `--backfill-oldest-slot` handling - this flag was totally broken, the code would always backfill to the default slot [pr](https://github.com/prysmaticlabs/prysm/pull/14584)
-- Fix keymanager API should return corrected error format for malformed tokens
-- Fix keymanager API so that get keys returns an empty response instead of a 500 error when using an unsupported keystore.
-- Small log imporvement, removing some redundant or duplicate logs
-- EIP7521 - Fixes withdrawal bug by accounting for pending partial withdrawals and deducting already withdrawn amounts from the sweep balance. [PR](https://github.com/prysmaticlabs/prysm/pull/14578)
-- unskip electra merkle spec test
-- Fix panic in validator REST mode when checking status after removing all keys
-- Fix panic on attestation interface since we call data before validation
-- corrects nil check on some interface attestation types
-- temporary solution to handling electra attesation and attester_slashing events. [pr](14655)
-- Diverse log improvements and comment additions.
-- Validate that each committee bitfield in an aggregate contains at least one non-zero bit
-- P2P: Avoid infinite loop when looking for peers in small networks.
-- Fixed another rollback bug due to a context deadline.
-- Fix checkpoint sync bug on holesky. [pr](https://github.com/prysmaticlabs/prysm/pull/14689)
-- Fix proposer boost spec tests being flakey by adjusting start time from 3 to 2s into slot.
-- Fix segmentation fault in E2E when light-client feature flag is enabled. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
-- Fix `searchForPeers` infinite loop in small networks.
-- Fix slashing pool behavior to enforce MaxAttesterSlashings limit in Electra version.
-
-### Security
-
-## [v5.1.2](https://github.com/prysmaticlabs/prysm/compare/v5.1.1...v5.1.2) - 2024-10-16 
-
-This is a hotfix release with one change. 
-
-Prysm v5.1.1 contains an updated implementation of the beacon api streaming events endpoint. This
-new implementation contains a bug that can cause a panic in certain conditions. The issue is
-difficult to reproduce reliably and we are still trying to determine the root cause, but in the
-meantime we are issuing a patch that recovers from the panic to prevent the node from crashing.
-
-This only impacts the v5.1.1 release beacon api event stream endpoints. This endpoint is used by the
-prysm REST mode validator (a feature which requires the validator to be configured to use the beacon
-api intead of prysm's stock grpc endpoints) or accessory software that connects to the events api,
-like https://github.com/ethpandaops/ethereum-metrics-exporter
-
-### Fixed 
-
-- Recover from panics when writing the event stream [#14545](https://github.com/prysmaticlabs/prysm/pull/14545)
-
-## [v5.1.1](https://github.com/prysmaticlabs/prysm/compare/v5.1.0...v5.1.1) - 2024-10-15
-
-This release has a number of features and improvements. Most notably, the feature flag 
-`--enable-experimental-state` has been flipped to "opt out" via `--disable-experimental-state`. 
-The experimental state management design has shown significant improvements in memory usage at
-runtime. Updates to libp2p's gossipsub have some bandwidith stability improvements with support for
-IDONTWANT control messages. 
-
-The gRPC gateway has been deprecated from Prysm in this release. If you need JSON data, consider the
-standardized beacon-APIs. 
-
-Updating to this release is recommended at your convenience.
+## [Unreleased](https://github.com/prysmaticlabs/prysm/compare/v5.1.0...HEAD)
 
 ### Added
 
@@ -220,18 +14,14 @@ Updating to this release is recommended at your convenience.
 - Light client support: Add light client database changes.
 - Light client support: Implement capella and deneb changes.
 - Light client support: Implement `BlockToLightClientHeader` function.
-- Light client support: Consensus types.
+- Electra EIP6110: Queue deposit
+- Light client support: Implement `BlockToLightClientHeaderXXX` functions upto Deneb
 - GetBeaconStateV2: add Electra case.
-- Implement [consensus-specs/3875](https://github.com/ethereum/consensus-specs/pull/3875).
-- Tests to ensure sepolia config matches the official upstream yaml.
-- `engine_newPayloadV4`,`engine_getPayloadV4` used for electra payload communication with execution client.  [pr](https://github.com/prysmaticlabs/prysm/pull/14492)
-- HTTP endpoint for PublishBlobs.
+- Implement [consensus-specs/3875](https://github.com/ethereum/consensus-specs/pull/3875)
+- Tests to ensure sepolia config matches the official upstream yaml
+- HTTP endpoint for PublishBlobs
 - GetBlockV2, GetBlindedBlock, ProduceBlockV2, ProduceBlockV3: add Electra case.
-- Add Electra support and tests for light client functions.
-- fastssz version bump (better error messages).
 - SSE implementation that sheds stuck clients. [pr](https://github.com/prysmaticlabs/prysm/pull/14413)
-- Added GetPoolAttesterSlashingsV2 endpoint.
-- Use engine API get-blobs for block subscriber to reduce block import latency and potentially reduce bandwidth.
 
 ### Changed
 
@@ -250,6 +40,7 @@ Updating to this release is recommended at your convenience.
 - `grpc-gateway-corsdomain` is renamed to http-cors-domain. The old name can still be used as an alias.
 - `api-timeout` is changed from int flag to duration flag, default value updated.
 - Light client support: abstracted out the light client headers with different versions.
+- Electra EIP6110: Queue deposit requests changes from consensus spec pr #3818
 - `ApplyToEveryValidator` has been changed to prevent misuse bugs, it takes a closure that takes a `ReadOnlyValidator` and returns a raw pointer to a `Validator`. 
 - Removed gorilla mux library and replaced it with net/http updates in go 1.22.
 - Clean up `ProposeBlock` for validator client to reduce cognitive scoring and enable further changes.
@@ -259,9 +50,7 @@ Updating to this release is recommended at your convenience.
 - Update light client helper functions to reference `dev` branch of CL specs
 - Updated Libp2p Dependencies to allow prysm to use gossipsub v1.2 .
 - Updated Sepolia bootnodes.
-- Make committee aware packing the default by deprecating `--enable-committee-aware-packing`.
-- Moved `ConvertKzgCommitmentToVersionedHash` to the `primitives` package.
-- Updated correlation penalty for EIP-7251. 
+- Switch to compounding when consolidating with source==target.
 
 ### Deprecated
 - `--disable-grpc-gateway` flag is deprecated due to grpc gateway removal.
@@ -269,10 +58,9 @@ Updating to this release is recommended at your convenience.
 
 ### Removed
 
-- Removed gRPC Gateway.
-- Removed unused blobs bundle cache.
+- removed gRPC Gateway
+- Removed unused blobs bundle cache
 - Removed consolidation signing domain from params. The Electra design changed such that EL handles consolidation signature verification.
-- Remove engine_getPayloadBodiesBy{Hash|Range}V2
 
 ### Fixed
 
@@ -291,12 +79,9 @@ Updating to this release is recommended at your convenience.
 - Light client support: fix light client attested header execution fields' wrong version bug.
 - Testing: added custom matcher for better push settings testing.
 - Registered `GetDepositSnapshot` Beacon API endpoint.
-- Fix rolling back of a block due to a context deadline.
 
 ### Security
 
-No notable security updates.
-
 ## [v5.1.0](https://github.com/prysmaticlabs/prysm/compare/v5.0.4...v5.1.0) - 2024-08-20
 
 This release contains 171 new changes and many of these are related to Electra! Along side the Electra changes, there
@@ -502,7 +287,6 @@ block profit. If you want to preserve the existing behavior, set --local-block-v
 - Set default LocalBlockValueBoost to 10
 - Add bid value metrics
 - REST VC metrics
-- `startDB`: Add log when checkpoint sync.
 
 ### Changed
 

CONTRIBUTING.md

@@ -129,7 +129,7 @@ If your change is user facing, you must include a CHANGELOG.md entry. See the [M
 
 **17. Create a pull request.**
 
-Navigate your browser to https://github.com/prysmaticlabs/prysm and click on the new pull request button. In the “base” box on the left, leave the default selection “base develop”, the branch that you want your changes to be applied to. In the “compare” box on the right, select feature-in-progress-branch, the branch containing the changes you want to apply. You will then be asked to answer a few questions about your pull request. After you complete the questionnaire, the pull request will appear in the list of pull requests at https://github.com/prysmaticlabs/prysm/pulls. Ensure that you have added an entry to CHANGELOG.md if your PR is a user-facing change. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
+Navigate your browser to https://github.com/prysmaticlabs/prysm and click on the new pull request button. In the “base” box on the left, leave the default selection “base master”, the branch that you want your changes to be applied to. In the “compare” box on the right, select feature-in-progress-branch, the branch containing the changes you want to apply. You will then be asked to answer a few questions about your pull request. After you complete the questionnaire, the pull request will appear in the list of pull requests at https://github.com/prysmaticlabs/prysm/pulls. Ensure that you have added an entry to CHANGELOG.md if your PR is a user-facing change. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
 
 **18. Respond to comments by Core Contributors.**
 

INTEROP.md

@@ -2,21 +2,18 @@
 
 This README details how to setup Prysm for interop testing for usage with other Ethereum consensus clients.
 
-> [!IMPORTANT]  
-> This guide is likely to be outdated. The Prysm team does not have capacity to troubleshoot
-> outdated interop guides or instructions. If you experience issues with this guide, please file an
-> issue for visibility and propose fixes, if possible.
-
 ## Installation & Setup
 
 1. Install [Bazel](https://docs.bazel.build/versions/master/install.html) **(Recommended)**
 2. `git clone https://github.com/prysmaticlabs/prysm && cd prysm`
-3. `bazel build //cmd/...`
+3. `bazel build //...`
 
 ## Starting from Genesis
 
-Prysm can be started from a built-in mainnet genesis state, or started with a provided genesis state by
-using the `--genesis-state` flag and providing a path to the genesis.ssz file.
+Prysm supports a few ways to quickly launch a beacon node from basic configurations:
+
+- `NumValidators + GenesisTime`: Launches a beacon node by deterministically generating a state from a num-validators flag along with a genesis time **(Recommended)**
+- `SSZ Genesis`: Launches a beacon node  from a .ssz file containing a SSZ-encoded, genesis beacon state
 
 ## Generating a Genesis State
 
@@ -24,34 +21,21 @@ To setup the necessary files for these quick starts, Prysm provides a tool to ge
 a deterministically generated set of validator private keys following the official interop YAML format 
 [here](https://github.com/ethereum/eth2.0-pm/blob/master/interop/mocked_start).
 
-You can use `prysmctl` to create a deterministic genesis state for interop.
+You can use `bazel run //tools/genesis-state-gen` to create a deterministic genesis state for interop.
 
-```sh
-# Download (or create) a chain config file.
-curl https://raw.githubusercontent.com/ethereum/consensus-specs/refs/heads/dev/configs/minimal.yaml -o /tmp/minimal.yaml
+### Usage
+
+- **--genesis-time** uint: Unix timestamp used as the genesis time in the generated genesis state (defaults to now)
+- **--num-validators** int: Number of validators to deterministically include in the generated genesis state
+- **--output-ssz** string: Output filename of the SSZ marshaling of the generated genesis state
+- **--config-name=interop** string: name of the beacon chain config to use when generating the state. ex mainnet|minimal|interop
+
+The example below creates 64 validator keys, instantiates a genesis state with those 64 validators and with genesis unix timestamp 1567542540,
+and finally writes a ssz encoded output to ~/Desktop/genesis.ssz. This file can be used to kickstart the beacon chain in the next section. When using the `--interop-*` flags, the beacon node will assume the `interop` config should be used, unless a different config is specified on the command line.
 
-# Run prysmctl to generate genesis with a 2 minute genesis delay and 256 validators. 
-bazel run //cmd/prysmctl --config=minimal -- \
-  testnet generate-genesis \
-  --genesis-time-delay=120 \
-  --num-validators=256 \
-  --output-ssz=/tmp/genesis.ssz \
-  --chain-config-file=/tmp/minimal.yaml
 ```
-
-The flags are explained below:
-- `bazel run //cmd/prysmctl` is the bazel command to compile and run prysmctl.
-- `--config=minimal` is a bazel build time configuration flag to compile Prysm with minimal state constants.
-- `--` is an argument divider to tell bazel that everything after this divider should be passed as arguments to prysmctl. Without this divider, it isn't clear to bazel if the arguments are meant to be build time arguments or runtime arguments so the operation complains and fails to build without this divider.
-- `testnet` is the primary command argument for prysmctl.
-- `generate-genesis` is the subcommand to `testnet` in prysmctl.
-- `--genesis-time-delay` uint: The number of seconds in the future to define genesis. Example: a value of 60 will set the genesis time to 1 minute in the future. This should be sufficiently large enough to allow for you to start the beacon node before the genesis time. 
-- `--num-validators` int: Number of validators to deterministically include in the generated genesis state
-- `--output-ssz` string: Output filename of the SSZ marshaling of the generated genesis state
-- `--chain-config-file` string: Filepath to a chain config yaml file.
-
-Note: This guide saves items to the `/tmp/` directory which will not persist if your machine is
-restarted. Consider tweaking the arguments if persistence is needed.
+bazel run //tools/genesis-state-gen -- --config-name interop --output-ssz ~/Desktop/genesis.ssz --num-validators 64 --genesis-time 1567542540
+```
 
 ## Launching a Beacon Node + Validator Client
 
@@ -60,33 +44,45 @@ restarted. Consider tweaking the arguments if persistence is needed.
 Open up two terminal windows, run:
 
 ```
-bazel run //cmd/beacon-chain --config=minimal -- \
-  --minimal-config \
-  --bootstrap-node= \
-  --deposit-contract 0x8A04d14125D0FDCDc742F4A05C051De07232EDa4 \
-  --datadir=/tmp/beacon-chain-minimal-devnet \
-  --force-clear-db \
-  --min-sync-peers=0 \
-  --genesis-state=/tmp/genesis.ssz \
-  --chain-config-file=/tmp/minimal.yaml
+bazel run //beacon-chain -- \
+--bootstrap-node= \
+--deposit-contract 0x8A04d14125D0FDCDc742F4A05C051De07232EDa4 \
+--datadir=/tmp/beacon-chain-interop \
+--force-clear-db \
+--min-sync-peers=0 \
+--interop-num-validators 64 \
+--interop-eth1data-votes
 ```
 
-This will start the system with 256 validators. The flags used can be explained as such:
-
-- `bazel run //cmd/beacon-chain --config=minimal` builds and runs the beacon node in minimal build configuration.
-- `--` is a flag divider to distinguish between bazel flags and flags that should be passed to the application. All flags and arguments after this divider are passed to the beacon chain.
-- `--minimal-config` tells the beacon node to use minimal network configuration. This is different from the compile time state configuration flag `--config=minimal` and both are required.
-- `--bootstrap-node=` disables the default bootstrap nodes. This prevents the client from attempting to peer with mainnet nodes.
-- `--datadir=/tmp/beacon-chain-minimal-devnet` sets the data directory in a temporary location. Change this to your preferred destination.
-- `--force-clear-db` will delete the beaconchain.db file without confirming with the user. This is helpful for iteratively running local devnets without changing the datadir, but less helpful for one off runs where there was no database in the data directory.
-- `--min-sync-peers=0` allows the beacon node to skip initial sync without peers. This is essential because Prysm expects at least a few peers to start the blockchain.
-- `--genesis-state=/tmp/genesis.ssz` defines the path to the generated genesis ssz file. The beacon node will use this as the initial genesis state.
-- `--chain-config-file=/tmp/minimal.yaml` defines the path to the yaml file with the chain configuration.
-
-As soon as the beacon node has started, start the validator in the other terminal window. 
+This will deterministically generate a beacon genesis state and start
+the system with 64 validators and the genesis time set to the current unix timestamp.
+Wait a bit until your beacon chain starts, and in the other window:
 
 ```
-bazel run //cmd/validator --config=minimal -- --datadir=/tmp/validator --interop-num-validators=256 --minimal-config --suggested-fee-recipient=0x8A04d14125D0FDCDc742F4A05C051De07232EDa4
+bazel run //validator -- --keymanager=interop --keymanageropts='{"keys":64}'
 ```
 
-This will launch and kickstart the system with your 256 validators performing their duties accordingly.
+This will launch and kickstart the system with your 64 validators performing their duties accordingly.
+
+### Launching from `genesis.ssz`
+
+Assuming you generated a `genesis.ssz` file with 64 validators, open up two terminal windows, run:
+
+```
+ bazel run //beacon-chain -- \
+--bootstrap-node= \
+--deposit-contract 0x8A04d14125D0FDCDc742F4A05C051De07232EDa4 \
+--datadir=/tmp/beacon-chain-interop \
+--force-clear-db \
+--min-sync-peers=0 \
+--interop-genesis-state /path/to/genesis.ssz \
+--interop-eth1data-votes
+```
+
+Wait a bit until your beacon chain starts, and in the other window:
+
+```
+bazel run //validator -- --keymanager=interop --keymanageropts='{"keys":64}'
+```
+
+This will launch and kickstart the system with your 64 validators performing their duties accordingly.

WORKSPACE

@@ -101,9 +101,9 @@ http_archive(
 
 http_archive(
     name = "aspect_bazel_lib",
-    sha256 = "a272d79bb0ac6b6965aa199b1f84333413452e87f043b53eca7f347a23a478e8",
-    strip_prefix = "bazel-lib-2.9.3",
-    url = "https://github.com/bazel-contrib/bazel-lib/releases/download/v2.9.3/bazel-lib-v2.9.3.tar.gz",
+    sha256 = "f5ea76682b209cc0bd90d0f5a3b26d2f7a6a2885f0c5f615e72913f4805dbb0d",
+    strip_prefix = "bazel-lib-2.5.0",
+    url = "https://github.com/aspect-build/bazel-lib/releases/download/v2.5.0/bazel-lib-v2.5.0.tar.gz",
 )
 
 load("@aspect_bazel_lib//lib:repositories.bzl", "aspect_bazel_lib_dependencies", "aspect_bazel_lib_register_toolchains")
@@ -165,7 +165,7 @@ load("@rules_oci//oci:pull.bzl", "oci_pull")
 oci_pull(
     name = "linux_debian11_multiarch_base",  # Debian bullseye
     digest = "sha256:b82f113425c5b5c714151aaacd8039bc141821cdcd3c65202d42bdf9c43ae60b",  # 2023-12-12
-    image = "gcr.io/prysmaticlabs/distroless/cc-debian11",
+    image = "gcr.io/distroless/cc-debian11",
     platforms = [
         "linux/amd64",
         "linux/arm64/v8",
@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.10"
+consensus_spec_version = "v1.5.0-alpha.7"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-NtWIhbO/mVMb1edq5jqABL0o8R1tNFiuG8PCMAsUHcs=",
+    integrity = "sha256-Vo4+1bsRNYMGXjlpIYKEqt2WPjeGSbjeFQFKVUhf1Yc=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
 )
 
@@ -259,7 +259,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-DFlFlnzls1bBrDm+/xD8NK2ivvkhxR+rSNVLLqScVKc=",
+    integrity = "sha256-TsQtQVPyQA6htrTjL1cd/oWEkM83aK4Y0pT9W6ssKYU=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
 )
 
@@ -275,7 +275,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-G9ENPF8udZL/BqRHbi60GhFPnZDPZAH6UjcjRiOlvbk=",
+    integrity = "sha256-4g7EijlsIJVKGADlVL6ka9ikcwow8WuKHaABONA0Cxg=",
     url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
 )
 
@@ -290,7 +290,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-ClOLKkmAcEi8/uKi6LDeqthask5+E3sgxVoA0bqmQ0c=",
+    integrity = "sha256-i5+48P/BqxA+q39OufAiotW2llUq97+4j1++ViI96dM=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/builder/BUILD.bazel

@@ -12,10 +12,8 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api:go_default_library",
-        "//api/client:go_default_library",
         "//api/server/structs:go_default_library",
         "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

api/client/builder/client.go

@@ -14,7 +14,6 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api"
-	"github.com/prysmaticlabs/prysm/v5/api/client"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -177,7 +176,7 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 		err = non200Err(r)
 		return
 	}
-	res, err = io.ReadAll(io.LimitReader(r.Body, client.MaxBodySize))
+	res, err = io.ReadAll(r.Body)
 	if err != nil {
 		err = errors.Wrap(err, "error reading http response body from builder server")
 		return
@@ -282,7 +281,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 	if err != nil {
 		return err
 	}
-	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
+	log.WithField("num_registrations", len(svr)).Info("successfully registered validator(s) on builder")
 	return nil
 }
 
@@ -359,7 +358,7 @@ func (c *Client) Status(ctx context.Context) error {
 }
 
 func non200Err(response *http.Response) error {
-	bodyBytes, err := io.ReadAll(io.LimitReader(response.Body, client.MaxErrBodySize))
+	bodyBytes, err := io.ReadAll(response.Body)
 	var errMessage ErrorMessage
 	var body string
 	if err != nil {

api/client/builder/types.go

@@ -9,7 +9,6 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -1014,7 +1013,7 @@ func (bb *BuilderBidDeneb) ToProto() (*eth.BuilderBidDeneb, error) {
 	if err != nil {
 		return nil, err
 	}
-	if len(bb.BlobKzgCommitments) > params.BeaconConfig().DeprecatedMaxBlobsPerBlock {
+	if len(bb.BlobKzgCommitments) > fieldparams.MaxBlobsPerBlock {
 		return nil, fmt.Errorf("too many blob commitments: %d", len(bb.BlobKzgCommitments))
 	}
 	kzgCommitments := make([][]byte, len(bb.BlobKzgCommitments))

api/client/client.go

@@ -10,18 +10,11 @@ import (
 	"github.com/pkg/errors"
 )
 
-const (
-	MaxBodySize      int64 = 1 << 23 // 8MB default, WithMaxBodySize can override
-	MaxBodySizeState int64 = 1 << 29 // 512MB
-	MaxErrBodySize   int64 = 1 << 17 // 128KB
-)
-
 // Client is a wrapper object around the HTTP client.
 type Client struct {
-	hc          *http.Client
-	baseURL     *url.URL
-	token       string
-	maxBodySize int64
+	hc      *http.Client
+	baseURL *url.URL
+	token   string
 }
 
 // NewClient constructs a new client with the provided options (ex WithTimeout).
@@ -33,9 +26,8 @@ func NewClient(host string, opts ...ClientOpt) (*Client, error) {
 		return nil, err
 	}
 	c := &Client{
-		hc:          &http.Client{},
-		baseURL:     u,
-		maxBodySize: MaxBodySize,
+		hc:      &http.Client{},
+		baseURL: u,
 	}
 	for _, o := range opts {
 		o(c)
@@ -80,7 +72,7 @@ func (c *Client) NodeURL() string {
 // Get is a generic, opinionated GET function to reduce boilerplate amongst the getters in this package.
 func (c *Client) Get(ctx context.Context, path string, opts ...ReqOption) ([]byte, error) {
 	u := c.baseURL.ResolveReference(&url.URL{Path: path})
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), http.NoBody)
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
 	if err != nil {
 		return nil, err
 	}
@@ -97,7 +89,7 @@ func (c *Client) Get(ctx context.Context, path string, opts ...ReqOption) ([]byt
 	if r.StatusCode != http.StatusOK {
 		return nil, Non200Err(r)
 	}
-	b, err := io.ReadAll(io.LimitReader(r.Body, c.maxBodySize))
+	b, err := io.ReadAll(r.Body)
 	if err != nil {
 		return nil, errors.Wrap(err, "error reading http response body")
 	}

api/client/errors.go

@@ -25,16 +25,16 @@ var ErrInvalidNodeVersion = errors.New("invalid node version response")
 var ErrConnectionIssue = errors.New("could not connect")
 
 // Non200Err is a function that parses an HTTP response to handle responses that are not 200 with a formatted error.
-func Non200Err(r *http.Response) error {
-	b, err := io.ReadAll(io.LimitReader(r.Body, MaxErrBodySize))
+func Non200Err(response *http.Response) error {
+	bodyBytes, err := io.ReadAll(response.Body)
 	var body string
 	if err != nil {
 		body = "(Unable to read response body.)"
 	} else {
-		body = "response body:\n" + string(b)
+		body = "response body:\n" + string(bodyBytes)
 	}
-	msg := fmt.Sprintf("code=%d, url=%s, body=%s", r.StatusCode, r.Request.URL, body)
-	switch r.StatusCode {
+	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
+	switch response.StatusCode {
 	case http.StatusNotFound:
 		return errors.Wrap(ErrNotFound, msg)
 	default:

api/client/event/event_stream.go

@@ -93,7 +93,6 @@ func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
 			EventType: EventConnectionError,
 			Data:      []byte(errors.Wrap(err, client.ErrConnectionIssue.Error()).Error()),
 		}
-		return
 	}
 
 	defer func() {

api/client/event/event_stream_test.go

@@ -40,7 +40,7 @@ func TestNewEventStream(t *testing.T) {
 
 func TestEventStream(t *testing.T) {
 	mux := http.NewServeMux()
-	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, _ *http.Request) {
+	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
 		flusher, ok := w.(http.Flusher)
 		require.Equal(t, true, ok)
 		for i := 1; i <= 3; i++ {
@@ -79,23 +79,3 @@ func TestEventStream(t *testing.T) {
 		}
 	}
 }
-
-func TestEventStreamRequestError(t *testing.T) {
-	topics := []string{"head"}
-	eventsChannel := make(chan *Event, 1)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// use valid url that will result in failed request with nil body
-	stream, err := NewEventStream(ctx, http.DefaultClient, "http://badhost:1234", topics)
-	require.NoError(t, err)
-
-	// error will happen when request is made, should be received over events channel
-	go stream.Subscribe(eventsChannel)
-
-	event := <-eventsChannel
-	if event.EventType != EventConnectionError {
-		t.Errorf("Expected event type %q, got %q", EventConnectionError, event.EventType)
-	}
-
-}

api/client/options.go

@@ -46,10 +46,3 @@ func WithAuthenticationToken(token string) ClientOpt {
 		c.token = token
 	}
 }
-
-// WithMaxBodySize overrides the default max body size of 8MB.
-func WithMaxBodySize(size int64) ClientOpt {
-	return func(c *Client) {
-		c.maxBodySize = size
-	}
-}

api/server/structs/BUILD.bazel

@@ -36,8 +36,9 @@ go_library(
         "//math:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

api/server/structs/conversions.go

@@ -1546,10 +1546,3 @@ func EventChainReorgFromV1(event *ethv1.EventChainReorg) *ChainReorgEvent {
 		ExecutionOptimistic: event.ExecutionOptimistic,
 	}
 }
-
-func SyncAggregateFromConsensus(sa *eth.SyncAggregate) *SyncAggregate {
-	return &SyncAggregate{
-		SyncCommitteeBits:      hexutil.Encode(sa.SyncCommitteeBits),
-		SyncCommitteeSignature: hexutil.Encode(sa.SyncCommitteeSignature),
-	}
-}

api/server/structs/conversions_lightclient.go

@@ -3,227 +3,125 @@ package structs
 import (
 	"encoding/json"
 	"fmt"
+	"strconv"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	v1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
+	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	"github.com/prysmaticlabs/prysm/v5/proto/migration"
 )
 
-func LightClientUpdateFromConsensus(update interfaces.LightClientUpdate) (*LightClientUpdate, error) {
-	attestedHeader, err := lightClientHeaderToJSON(update.AttestedHeader())
+func LightClientUpdateFromConsensus(update *v2.LightClientUpdate) (*LightClientUpdate, error) {
+	attestedHeader, err := lightClientHeaderContainerToJSON(update.AttestedHeader)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal attested light client header")
 	}
-	finalizedHeader, err := lightClientHeaderToJSON(update.FinalizedHeader())
+	finalizedHeader, err := lightClientHeaderContainerToJSON(update.FinalizedHeader)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal finalized light client header")
 	}
 
-	var scBranch [][32]byte
-	var finalityBranch [][32]byte
-	if update.Version() >= version.Electra {
-		scb, err := update.NextSyncCommitteeBranchElectra()
-		if err != nil {
-			return nil, err
-		}
-		scBranch = scb[:]
-		fb, err := update.FinalityBranchElectra()
-		if err != nil {
-			return nil, err
-		}
-		finalityBranch = fb[:]
-	} else {
-		scb, err := update.NextSyncCommitteeBranch()
-		if err != nil {
-			return nil, err
-		}
-		scBranch = scb[:]
-		fb, err := update.FinalityBranch()
-		if err != nil {
-			return nil, err
-		}
-		finalityBranch = fb[:]
-	}
-
 	return &LightClientUpdate{
 		AttestedHeader:          attestedHeader,
-		NextSyncCommittee:       SyncCommitteeFromConsensus(update.NextSyncCommittee()),
-		NextSyncCommitteeBranch: branchToJSON(scBranch),
+		NextSyncCommittee:       SyncCommitteeFromConsensus(migration.V2SyncCommitteeToV1Alpha1(update.NextSyncCommittee)),
+		NextSyncCommitteeBranch: branchToJSON(update.NextSyncCommitteeBranch),
 		FinalizedHeader:         finalizedHeader,
-		FinalityBranch:          branchToJSON(finalityBranch),
-		SyncAggregate:           SyncAggregateFromConsensus(update.SyncAggregate()),
-		SignatureSlot:           fmt.Sprintf("%d", update.SignatureSlot()),
+		FinalityBranch:          branchToJSON(update.FinalityBranch),
+		SyncAggregate:           syncAggregateToJSON(update.SyncAggregate),
+		SignatureSlot:           strconv.FormatUint(uint64(update.SignatureSlot), 10),
 	}, nil
 }
 
-func LightClientFinalityUpdateFromConsensus(update interfaces.LightClientFinalityUpdate) (*LightClientFinalityUpdate, error) {
-	attestedHeader, err := lightClientHeaderToJSON(update.AttestedHeader())
+func LightClientFinalityUpdateFromConsensus(update *v2.LightClientFinalityUpdate) (*LightClientFinalityUpdate, error) {
+	attestedHeader, err := lightClientHeaderContainerToJSON(update.AttestedHeader)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal attested light client header")
 	}
-	finalizedHeader, err := lightClientHeaderToJSON(update.FinalizedHeader())
+	finalizedHeader, err := lightClientHeaderContainerToJSON(update.FinalizedHeader)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal finalized light client header")
 	}
 
-	var finalityBranch [][32]byte
-	if update.Version() >= version.Electra {
-		b, err := update.FinalityBranchElectra()
-		if err != nil {
-			return nil, err
-		}
-		finalityBranch = b[:]
-	} else {
-		b, err := update.FinalityBranch()
-		if err != nil {
-			return nil, err
-		}
-		finalityBranch = b[:]
-	}
-
 	return &LightClientFinalityUpdate{
 		AttestedHeader:  attestedHeader,
 		FinalizedHeader: finalizedHeader,
-		FinalityBranch:  branchToJSON(finalityBranch),
-		SyncAggregate:   SyncAggregateFromConsensus(update.SyncAggregate()),
-		SignatureSlot:   fmt.Sprintf("%d", update.SignatureSlot()),
+		FinalityBranch:  branchToJSON(update.FinalityBranch),
+		SyncAggregate:   syncAggregateToJSON(update.SyncAggregate),
+		SignatureSlot:   strconv.FormatUint(uint64(update.SignatureSlot), 10),
 	}, nil
 }
 
-func LightClientOptimisticUpdateFromConsensus(update interfaces.LightClientOptimisticUpdate) (*LightClientOptimisticUpdate, error) {
-	attestedHeader, err := lightClientHeaderToJSON(update.AttestedHeader())
+func LightClientOptimisticUpdateFromConsensus(update *v2.LightClientOptimisticUpdate) (*LightClientOptimisticUpdate, error) {
+	attestedHeader, err := lightClientHeaderContainerToJSON(update.AttestedHeader)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal attested light client header")
 	}
 
 	return &LightClientOptimisticUpdate{
 		AttestedHeader: attestedHeader,
-		SyncAggregate:  SyncAggregateFromConsensus(update.SyncAggregate()),
-		SignatureSlot:  fmt.Sprintf("%d", update.SignatureSlot()),
+		SyncAggregate:  syncAggregateToJSON(update.SyncAggregate),
+		SignatureSlot:  strconv.FormatUint(uint64(update.SignatureSlot), 10),
 	}, nil
 }
 
-func branchToJSON[S [][32]byte](branchBytes S) []string {
+func branchToJSON(branchBytes [][]byte) []string {
 	if branchBytes == nil {
 		return nil
 	}
 	branch := make([]string, len(branchBytes))
 	for i, root := range branchBytes {
-		branch[i] = hexutil.Encode(root[:])
+		branch[i] = hexutil.Encode(root)
 	}
 	return branch
 }
 
-func lightClientHeaderToJSON(header interfaces.LightClientHeader) (json.RawMessage, error) {
+func syncAggregateToJSON(input *v1.SyncAggregate) *SyncAggregate {
+	return &SyncAggregate{
+		SyncCommitteeBits:      hexutil.Encode(input.SyncCommitteeBits),
+		SyncCommitteeSignature: hexutil.Encode(input.SyncCommitteeSignature),
+	}
+}
+
+func lightClientHeaderContainerToJSON(container *v2.LightClientHeaderContainer) (json.RawMessage, error) {
 	// In the case that a finalizedHeader is nil.
-	if header == nil {
+	if container == nil {
 		return nil, nil
 	}
 
-	var result any
+	beacon, err := container.GetBeacon()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get beacon block header")
+	}
 
-	switch v := header.Version(); v {
-	case version.Altair:
-		result = &LightClientHeader{Beacon: BeaconBlockHeaderFromConsensus(header.Beacon())}
-	case version.Capella:
-		exInterface, err := header.Execution()
+	var header any
+
+	switch t := (container.Header).(type) {
+	case *v2.LightClientHeaderContainer_HeaderAltair:
+		header = &LightClientHeader{Beacon: BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(beacon))}
+	case *v2.LightClientHeaderContainer_HeaderCapella:
+		execution, err := ExecutionPayloadHeaderCapellaFromConsensus(t.HeaderCapella.Execution)
 		if err != nil {
 			return nil, err
 		}
-		ex, ok := exInterface.Proto().(*enginev1.ExecutionPayloadHeaderCapella)
-		if !ok {
-			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderCapella{})
-		}
-		execution, err := ExecutionPayloadHeaderCapellaFromConsensus(ex)
-		if err != nil {
-			return nil, err
-		}
-		executionBranch, err := header.ExecutionBranch()
-		if err != nil {
-			return nil, err
-		}
-		result = &LightClientHeaderCapella{
-			Beacon:          BeaconBlockHeaderFromConsensus(header.Beacon()),
+		header = &LightClientHeaderCapella{
+			Beacon:          BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(beacon)),
 			Execution:       execution,
-			ExecutionBranch: branchToJSON(executionBranch[:]),
+			ExecutionBranch: branchToJSON(t.HeaderCapella.ExecutionBranch),
 		}
-	case version.Deneb:
-		exInterface, err := header.Execution()
+	case *v2.LightClientHeaderContainer_HeaderDeneb:
+		execution, err := ExecutionPayloadHeaderDenebFromConsensus(t.HeaderDeneb.Execution)
 		if err != nil {
 			return nil, err
 		}
-		ex, ok := exInterface.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
-		if !ok {
-			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderDeneb{})
-		}
-		execution, err := ExecutionPayloadHeaderDenebFromConsensus(ex)
-		if err != nil {
-			return nil, err
-		}
-		executionBranch, err := header.ExecutionBranch()
-		if err != nil {
-			return nil, err
-		}
-		result = &LightClientHeaderDeneb{
-			Beacon:          BeaconBlockHeaderFromConsensus(header.Beacon()),
+		header = &LightClientHeaderDeneb{
+			Beacon:          BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(beacon)),
 			Execution:       execution,
-			ExecutionBranch: branchToJSON(executionBranch[:]),
-		}
-	case version.Electra:
-		exInterface, err := header.Execution()
-		if err != nil {
-			return nil, err
-		}
-		ex, ok := exInterface.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
-		if !ok {
-			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderElectra{})
-		}
-		execution, err := ExecutionPayloadHeaderElectraFromConsensus(ex)
-		if err != nil {
-			return nil, err
-		}
-		executionBranch, err := header.ExecutionBranch()
-		if err != nil {
-			return nil, err
-		}
-		result = &LightClientHeaderDeneb{
-			Beacon:          BeaconBlockHeaderFromConsensus(header.Beacon()),
-			Execution:       execution,
-			ExecutionBranch: branchToJSON(executionBranch[:]),
+			ExecutionBranch: branchToJSON(t.HeaderDeneb.ExecutionBranch),
 		}
 	default:
-		return nil, fmt.Errorf("unsupported header version %s", version.String(v))
+		return nil, fmt.Errorf("unsupported header type %T", t)
 	}
 
-	return json.Marshal(result)
-}
-
-func LightClientBootstrapFromConsensus(bootstrap interfaces.LightClientBootstrap) (*LightClientBootstrap, error) {
-	header, err := lightClientHeaderToJSON(bootstrap.Header())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not marshal light client header")
-	}
-
-	var scBranch [][32]byte
-	if bootstrap.Version() >= version.Electra {
-		b, err := bootstrap.CurrentSyncCommitteeBranchElectra()
-		if err != nil {
-			return nil, err
-		}
-		scBranch = b[:]
-	} else {
-		b, err := bootstrap.CurrentSyncCommitteeBranch()
-		if err != nil {
-			return nil, err
-		}
-		scBranch = b[:]
-	}
-
-	return &LightClientBootstrap{
-		Header:                     header,
-		CurrentSyncCommittee:       SyncCommitteeFromConsensus(bootstrap.CurrentSyncCommittee()),
-		CurrentSyncCommitteeBranch: branchToJSON(scBranch),
-	}, nil
+	return json.Marshal(header)
 }

api/server/structs/endpoints_beacon.go

@@ -21,12 +21,11 @@ type GetCommitteesResponse struct {
 }
 
 type ListAttestationsResponse struct {
-	Version string          `json:"version,omitempty"`
-	Data    json.RawMessage `json:"data"`
+	Data []*Attestation `json:"data"`
 }
 
 type SubmitAttestationsRequest struct {
-	Data json.RawMessage `json:"data"`
+	Data []*Attestation `json:"data"`
 }
 
 type ListVoluntaryExitsResponse struct {
@@ -134,13 +133,6 @@ type GetBlockAttestationsResponse struct {
 	Data                []*Attestation `json:"data"`
 }
 
-type GetBlockAttestationsV2Response struct {
-	Version             string          `json:"version"`
-	ExecutionOptimistic bool            `json:"execution_optimistic"`
-	Finalized           bool            `json:"finalized"`
-	Data                json.RawMessage `json:"data"` // Accepts both `Attestation` and `AttestationElectra` types
-}
-
 type GetStateRootResponse struct {
 	ExecutionOptimistic bool       `json:"execution_optimistic"`
 	Finalized           bool       `json:"finalized"`
@@ -177,8 +169,7 @@ type BLSToExecutionChangesPoolResponse struct {
 }
 
 type GetAttesterSlashingsResponse struct {
-	Version string          `json:"version,omitempty"`
-	Data    json.RawMessage `json:"data"` // Accepts both `[]*AttesterSlashing` and `[]*AttesterSlashingElectra` types
+	Data []*AttesterSlashing `json:"data"`
 }
 
 type GetProposerSlashingsResponse struct {

api/server/structs/endpoints_blob.go

@@ -1,10 +1,7 @@
 package structs
 
 type SidecarsResponse struct {
-	Version             string     `json:"version"`
-	Data                []*Sidecar `json:"data"`
-	ExecutionOptimistic bool       `json:"execution_optimistic"`
-	Finalized           bool       `json:"finalized"`
+	Data []*Sidecar `json:"data"`
 }
 
 type Sidecar struct {

api/server/structs/endpoints_validator.go

@@ -7,8 +7,7 @@ import (
 )
 
 type AggregateAttestationResponse struct {
-	Version string          `json:"version,omitempty"`
-	Data    json.RawMessage `json:"data"`
+	Data *Attestation `json:"data"`
 }
 
 type SubmitContributionAndProofsRequest struct {
@@ -16,7 +15,7 @@ type SubmitContributionAndProofsRequest struct {
 }
 
 type SubmitAggregateAndProofsRequest struct {
-	Data []json.RawMessage `json:"data"`
+	Data []*SignedAggregateAttestationAndProof `json:"data"`
 }
 
 type SubmitSyncCommitteeSubscriptionsRequest struct {

beacon-chain/blockchain/BUILD.bazel

@@ -84,6 +84,7 @@ go_library(
         "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -140,7 +141,6 @@ go_test(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/das:go_default_library",

beacon-chain/blockchain/chain_info.go

@@ -12,7 +12,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/forkchoice"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -45,7 +44,7 @@ type ForkchoiceFetcher interface {
 	UpdateHead(context.Context, primitives.Slot)
 	HighestReceivedBlockSlot() primitives.Slot
 	ReceivedBlocksLastEpoch() (uint64, error)
-	InsertNode(context.Context, state.BeaconState, consensus_blocks.ROBlock) error
+	InsertNode(context.Context, state.BeaconState, [32]byte) error
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
 	NewSlot(context.Context, primitives.Slot) error
 	ProposerBoost() [32]byte
@@ -243,7 +242,7 @@ func (s *Service) HeadValidatorsIndices(ctx context.Context, epoch primitives.Ep
 	if !s.hasHeadState() {
 		return []primitives.ValidatorIndex{}, nil
 	}
-	return helpers.ActiveValidatorIndices(ctx, s.headStateReadOnly(ctx), epoch)
+	return helpers.ActiveValidatorIndices(ctx, s.headState(ctx), epoch)
 }
 
 // HeadGenesisValidatorsRoot returns genesis validators root of the head state.

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/forkchoice"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
@@ -45,10 +44,10 @@ func (s *Service) ReceivedBlocksLastEpoch() (uint64, error) {
 }
 
 // InsertNode is a wrapper for node insertion which is self locked
-func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, block consensus_blocks.ROBlock) error {
+func (s *Service) InsertNode(ctx context.Context, st state.BeaconState, root [32]byte) error {
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, block)
+	return s.cfg.ForkChoiceStore.InsertNode(ctx, st, root)
 }
 
 // ForkChoiceDump returns the corresponding value from forkchoice

beacon-chain/blockchain/chain_info_test.go

@@ -38,7 +38,7 @@ func prepareForkchoiceState(
 	payloadHash [32]byte,
 	justified *ethpb.Checkpoint,
 	finalized *ethpb.Checkpoint,
-) (state.BeaconState, blocks.ROBlock, error) {
+) (state.BeaconState, [32]byte, error) {
 	blockHeader := &ethpb.BeaconBlockHeader{
 		ParentRoot: parentRoot[:],
 	}
@@ -59,26 +59,7 @@ func prepareForkchoiceState(
 
 	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
 	st, err := state_native.InitializeFromProtoBellatrix(base)
-	if err != nil {
-		return nil, blocks.ROBlock{}, err
-	}
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot:       slot,
-			ParentRoot: parentRoot[:],
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &enginev1.ExecutionPayload{
-					BlockHash: payloadHash[:],
-				},
-			},
-		},
-	}
-	signed, err := blocks.NewSignedBeaconBlock(blk)
-	if err != nil {
-		return nil, blocks.ROBlock{}, err
-	}
-	roblock, err := blocks.NewROBlockWithRoot(signed, blockRoot)
-	return st, roblock, err
+	return st, blockRoot, err
 }
 
 func TestHeadRoot_Nil(t *testing.T) {
@@ -141,9 +122,9 @@ func TestUnrealizedJustifiedBlockHash(t *testing.T) {
 	service := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: []byte{'j'}}
 	ofc := &ethpb.Checkpoint{Root: []byte{'f'}}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	service.cfg.ForkChoiceStore.SetBalancesByRooter(func(_ context.Context, _ [32]byte) ([]uint64, error) { return []uint64{}, nil })
 	require.NoError(t, service.cfg.ForkChoiceStore.UpdateJustifiedCheckpoint(ctx, &forkchoicetypes.Checkpoint{Epoch: 6, Root: [32]byte{'j'}}))
 
@@ -335,24 +316,24 @@ func TestService_ChainHeads(t *testing.T) {
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 102, [32]byte{'c'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 103, [32]byte{'d'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 104, [32]byte{'e'}, [32]byte{'b'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	roots, slots := c.ChainHeads()
 	require.Equal(t, 3, len(roots))
@@ -432,12 +413,12 @@ func TestService_IsOptimistic(t *testing.T) {
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	opt, err := c.IsOptimistic(ctx)
 	require.NoError(t, err)
@@ -468,12 +449,12 @@ func TestService_IsOptimisticForRoot(t *testing.T) {
 	c := &Service{cfg: &config{ForkChoiceStore: doublylinkedtree.New()}, head: &head{root: [32]byte{'b'}}}
 	ojc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
 	ofc := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	st, roblock, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 100, [32]byte{'a'}, [32]byte{}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
-	st, roblock, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	st, blkRoot, err = prepareForkchoiceState(ctx, 101, [32]byte{'b'}, [32]byte{'a'}, params.BeaconConfig().ZeroHash, ojc, ofc)
 	require.NoError(t, err)
-	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, c.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	opt, err := c.IsOptimisticForRoot(ctx, [32]byte{'a'})
 	require.NoError(t, err)

beacon-chain/blockchain/execution_engine.go

@@ -2,15 +2,13 @@ package blockchain
 
 import (
 	"context"
+	"crypto/sha256"
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -30,6 +28,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+const blobCommitmentVersionKZG uint8 = 0x01
+
 var defaultLatestValidHash = bytesutil.PadTo([]byte{0xff}, 32)
 
 // notifyForkchoiceUpdate signals execution engine the fork choice updates. Execution engine should:
@@ -72,7 +72,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	if arg.attributes == nil {
 		arg.attributes = payloadattribute.EmptyWithVersion(headBlk.Version())
 	}
-	go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), arg)
 	payloadID, lastValidHash, err := s.cfg.ExecutionEngineCaller.ForkchoiceUpdated(ctx, fcs, arg.attributes)
 	if err != nil {
 		switch {
@@ -171,38 +170,6 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *fcuConfig) (*
 	return payloadID, nil
 }
 
-func firePayloadAttributesEvent(ctx context.Context, f event.SubscriberSender, cfg *fcuConfig) {
-	pidx, err := helpers.BeaconProposerIndex(ctx, cfg.headState)
-	if err != nil {
-		log.WithError(err).
-			WithField("head_root", cfg.headRoot[:]).
-			Error("Could not get proposer index for PayloadAttributes event")
-		return
-	}
-	evd := payloadattribute.EventData{
-		ProposerIndex:   pidx,
-		ProposalSlot:    cfg.headState.Slot(),
-		ParentBlockRoot: cfg.headRoot[:],
-		Attributer:      cfg.attributes,
-		HeadRoot:        cfg.headRoot,
-		HeadState:       cfg.headState,
-		HeadBlock:       cfg.headBlock,
-	}
-	if cfg.headBlock != nil && !cfg.headBlock.IsNil() {
-		headPayload, err := cfg.headBlock.Block().Body().Execution()
-		if err != nil {
-			log.WithError(err).Error("Could not get execution payload for head block")
-			return
-		}
-		evd.ParentBlockHash = headPayload.BlockHash()
-		evd.ParentBlockNumber = headPayload.BlockNumber()
-	}
-	f.Send(&feed.Event{
-		Type: statefeed.PayloadAttributes,
-		Data: evd,
-	})
-}
-
 // getPayloadHash returns the payload hash given the block root.
 // if the block is before bellatrix fork epoch, it returns the zero hash.
 func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, error) {
@@ -252,25 +219,17 @@ func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
 	}
 
 	var lastValidHash []byte
-	var parentRoot *common.Hash
-	var versionedHashes []common.Hash
-	var requests *enginev1.ExecutionRequests
 	if blk.Version() >= version.Deneb {
+		var versionedHashes []common.Hash
 		versionedHashes, err = kzgCommitmentsToVersionedHashes(blk.Block().Body())
 		if err != nil {
 			return false, errors.Wrap(err, "could not get versioned hashes to feed the engine")
 		}
-		prh := common.Hash(blk.Block().ParentRoot())
-		parentRoot = &prh
+		pr := common.Hash(blk.Block().ParentRoot())
+		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, &pr)
+	} else {
+		lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, []common.Hash{}, &common.Hash{} /*empty version hashes and root before Deneb*/)
 	}
-	if blk.Version() >= version.Electra {
-		requests, err = blk.Block().Body().ExecutionRequests()
-		if err != nil {
-			return false, errors.Wrap(err, "could not get execution requests")
-		}
-	}
-	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests)
-
 	switch {
 	case err == nil:
 		newPayloadValidNodeCount.Inc()
@@ -443,7 +402,13 @@ func kzgCommitmentsToVersionedHashes(body interfaces.ReadOnlyBeaconBlockBody) ([
 
 	versionedHashes := make([]common.Hash, len(commitments))
 	for i, commitment := range commitments {
-		versionedHashes[i] = primitives.ConvertKzgCommitmentToVersionedHash(commitment)
+		versionedHashes[i] = ConvertKzgCommitmentToVersionedHash(commitment)
 	}
 	return versionedHashes, nil
 }
+
+func ConvertKzgCommitmentToVersionedHash(commitment []byte) common.Hash {
+	versionedHash := sha256.Sum256(commitment)
+	versionedHash[0] = blobCommitmentVersionKZG
+	return versionedHash
+}

beacon-chain/blockchain/execution_engine_test.go

@@ -1135,14 +1135,9 @@ func TestComputePayloadAttribute(t *testing.T) {
 	// 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,
+		ctx:       ctx,
+		blockRoot: [32]byte{'a'},
 	}
 	fcu := &fcuConfig{
 		headState:     st,

beacon-chain/blockchain/head.go

@@ -11,7 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -405,19 +404,13 @@ func (s *Service) saveOrphanedOperations(ctx context.Context, orphanedRoot [32]b
 			if a.GetData().Slot+params.BeaconConfig().SlotsPerEpoch < s.CurrentSlot() {
 				continue
 			}
-			if features.Get().EnableExperimentalAttestationPool {
-				if err = s.cfg.AttestationCache.Add(a); err != nil {
+			if helpers.IsAggregated(a) {
+				if err := s.cfg.AttPool.SaveAggregatedAttestation(a); err != nil {
 					return err
 				}
 			} else {
-				if a.IsAggregated() {
-					if err = s.cfg.AttPool.SaveAggregatedAttestation(a); err != nil {
-						return err
-					}
-				} else {
-					if err = s.cfg.AttPool.SaveUnaggregatedAttestation(a); err != nil {
-						return err
-					}
+				if err := s.cfg.AttPool.SaveUnaggregatedAttestation(a); err != nil {
+					return err
 				}
 			}
 			saveOrphanedAttCount.Inc()

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -26,7 +26,8 @@ go_test(
     deps = [
         "//consensus-types/blocks:go_default_library",
         "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
+        "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/blockchain/kzg/validation_test.go

@@ -1,14 +1,51 @@
 package kzg
 
 import (
+	"bytes"
+	"crypto/sha256"
+	"encoding/binary"
 	"testing"
 
+	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"github.com/sirupsen/logrus"
 )
 
+func deterministicRandomness(seed int64) [32]byte {
+	// Converts an int64 to a byte slice
+	buf := new(bytes.Buffer)
+	err := binary.Write(buf, binary.BigEndian, seed)
+	if err != nil {
+		logrus.WithError(err).Error("Failed to write int64 to bytes buffer")
+		return [32]byte{}
+	}
+	bytes := buf.Bytes()
+
+	return sha256.Sum256(bytes)
+}
+
+// Returns a serialized random field element in big-endian
+func GetRandFieldElement(seed int64) [32]byte {
+	bytes := deterministicRandomness(seed)
+	var r fr.Element
+	r.SetBytes(bytes[:])
+
+	return GoKZG.SerializeScalar(r)
+}
+
+// Returns a random blob using the passed seed as entropy
+func GetRandBlob(seed int64) GoKZG.Blob {
+	var blob GoKZG.Blob
+	bytesPerBlob := GoKZG.ScalarsPerBlob * GoKZG.SerializedScalarSize
+	for i := 0; i < bytesPerBlob; i += GoKZG.SerializedScalarSize {
+		fieldElementBytes := GetRandFieldElement(seed + int64(i))
+		copy(blob[i:i+GoKZG.SerializedScalarSize], fieldElementBytes[:])
+	}
+	return blob
+}
+
 func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZGProof, error) {
 	commitment, err := kzgContext.BlobToKZGCommitment(blob, 0)
 	if err != nil {
@@ -37,7 +74,7 @@ func TestBytesToAny(t *testing.T) {
 }
 
 func TestGenerateCommitmentAndProof(t *testing.T) {
-	blob := util.GetRandBlob(123)
+	blob := GetRandBlob(123)
 	commitment, proof, err := GenerateCommitmentAndProof(blob)
 	require.NoError(t, err)
 	expectedCommitment := GoKZG.KZGCommitment{180, 218, 156, 194, 59, 20, 10, 189, 186, 254, 132, 93, 7, 127, 104, 172, 238, 240, 237, 70, 83, 89, 1, 152, 99, 0, 165, 65, 143, 62, 20, 215, 230, 14, 205, 95, 28, 245, 54, 25, 160, 16, 178, 31, 232, 207, 38, 85}

beacon-chain/blockchain/options.go

@@ -85,14 +85,6 @@ func WithTrackedValidatorsCache(c *cache.TrackedValidatorsCache) Option {
 	}
 }
 
-// WithAttestationCache for attestation lifecycle after chain inclusion.
-func WithAttestationCache(c *cache.AttestationCache) Option {
-	return func(s *Service) error {
-		s.cfg.AttestationCache = c
-		return nil
-	}
-}
-
 // WithAttestationPool for attestation lifecycle after chain inclusion.
 func WithAttestationPool(p attestations.Pool) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_attestation_test.go

@@ -32,18 +32,18 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 	util.SaveBlock(t, ctx, beaconDB, blkWithoutState)
 
 	cp := &ethpb.Checkpoint{}
-	st, roblock, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
+	st, blkRoot, err := prepareForkchoiceState(ctx, 0, [32]byte{}, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 
 	blkWithStateBadAtt := util.NewBeaconBlock()
 	blkWithStateBadAtt.Block.Slot = 1
 	r, err := blkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
 	cp = &ethpb.Checkpoint{Root: r[:]}
-	st, roblock, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
+	st, blkRoot, err = prepareForkchoiceState(ctx, blkWithStateBadAtt.Block.Slot, r, [32]byte{}, params.BeaconConfig().ZeroHash, cp, cp)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
 	util.SaveBlock(t, ctx, beaconDB, blkWithStateBadAtt)
 	BlkWithStateBadAttRoot, err := blkWithStateBadAtt.Block.HashTreeRoot()
 	require.NoError(t, err)
@@ -92,12 +92,12 @@ func TestStore_OnAttestation_ErrorConditions(t *testing.T) {
 		{
 			name:      "process nil attestation",
 			a:         nil,
-			wantedErr: "attestation is nil",
+			wantedErr: "attestation can't be nil",
 		},
 		{
 			name:      "process nil field (a.Data) in attestation",
 			a:         &ethpb.Attestation{},
-			wantedErr: "attestation is nil",
+			wantedErr: "attestation's data can't be nil",
 		},
 		{
 			name: "process nil field (a.Target) in attestation",
@@ -139,9 +139,9 @@ func TestStore_OnAttestation_Ok_DoublyLinkedTree(t *testing.T) {
 		require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, copied, tRoot))
 		ojc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
 		ofc := &ethpb.Checkpoint{Epoch: 0, Root: tRoot[:]}
-		state, roblock, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
+		state, blkRoot, err := prepareForkchoiceState(ctx, 0, tRoot, tRoot, params.BeaconConfig().ZeroHash, ojc, ofc)
 		require.NoError(t, err)
-		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, roblock))
+		require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 		require.NoError(t, service.OnAttestation(ctx, att[0], 0))
 	}
 
@@ -318,9 +318,10 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	checkpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r1[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(checkpoint.Root)))
-	st, roblock, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, checkpoint, checkpoint)
+	st, blkRoot, err := prepareForkchoiceState(ctx, blk.Block.Slot, r1, [32]byte{}, params.BeaconConfig().ZeroHash, checkpoint, checkpoint)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, r1))
 	returned, err := service.getAttPreState(ctx, checkpoint)
 	require.NoError(t, err)
 	assert.Equal(t, params.BeaconConfig().SlotsPerEpoch.Mul(uint64(checkpoint.Epoch)), returned.Slot(), "Incorrectly returned base state")
@@ -336,9 +337,10 @@ func TestStore_UpdateCheckpointState(t *testing.T) {
 	require.NoError(t, err)
 	newCheckpoint := &ethpb.Checkpoint{Epoch: epoch, Root: r2[:]}
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, baseState, bytesutil.ToBytes32(newCheckpoint.Root)))
-	st, roblock, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, newCheckpoint, newCheckpoint)
+	st, blkRoot, err = prepareForkchoiceState(ctx, blk.Block.Slot, r2, r1, params.BeaconConfig().ZeroHash, newCheckpoint, newCheckpoint)
 	require.NoError(t, err)
-	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, roblock))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, blkRoot))
+	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, st, r2))
 	returned, err = service.getAttPreState(ctx, newCheckpoint)
 	require.NoError(t, err)
 	s, err := slots.EpochStart(newCheckpoint.Epoch)

beacon-chain/blockchain/process_block.go

@@ -7,6 +7,8 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
+	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
@@ -15,6 +17,7 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -43,7 +46,8 @@ var initialSyncBlockCacheSize = uint64(2 * params.BeaconConfig().SlotsPerEpoch)
 // process the beacon block after validating the state transition function
 type postBlockProcessConfig struct {
 	ctx            context.Context
-	roblock        consensusblocks.ROBlock
+	signed         interfaces.ReadOnlySignedBeaconBlock
+	blockRoot      [32]byte
 	headRoot       [32]byte
 	postState      state.BeaconState
 	isValidPayload bool
@@ -57,7 +61,7 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	ctx, span := trace.StartSpan(cfg.ctx, "blockChain.onBlock")
 	defer span.End()
 	cfg.ctx = ctx
-	if err := consensusblocks.BeaconBlockIsNil(cfg.roblock); err != nil {
+	if err := consensusblocks.BeaconBlockIsNil(cfg.signed); err != nil {
 		return invalidBlock{error: err}
 	}
 	startTime := time.Now()
@@ -66,28 +70,22 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	if s.inRegularSync() {
 		defer s.handleSecondFCUCall(cfg, fcuArgs)
 	}
-	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
-		defer s.processLightClientUpdates(cfg)
-		defer s.saveLightClientUpdate(cfg)
-	}
+	defer s.sendLightClientFeeds(cfg)
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)
-	defer reportAttestationInclusion(cfg.roblock.Block())
+	defer reportAttestationInclusion(cfg.signed.Block())
 
-	err := s.cfg.ForkChoiceStore.InsertNode(ctx, cfg.postState, cfg.roblock)
+	err := s.cfg.ForkChoiceStore.InsertNode(ctx, cfg.postState, cfg.blockRoot)
 	if err != nil {
-		// Do not use parent context in the event it deadlined
-		ctx = trace.NewContext(context.Background(), span)
-		s.rollbackBlock(ctx, cfg.roblock.Root())
-		return errors.Wrapf(err, "could not insert block %d to fork choice store", cfg.roblock.Block().Slot())
+		return errors.Wrapf(err, "could not insert block %d to fork choice store", cfg.signed.Block().Slot())
 	}
-	if err := s.handleBlockAttestations(ctx, cfg.roblock.Block(), cfg.postState); err != nil {
+	if err := s.handleBlockAttestations(ctx, cfg.signed.Block(), cfg.postState); err != nil {
 		return errors.Wrap(err, "could not handle block's attestations")
 	}
 
-	s.InsertSlashingsToForkChoiceStore(ctx, cfg.roblock.Block().Body().AttesterSlashings())
+	s.InsertSlashingsToForkChoiceStore(ctx, cfg.signed.Block().Body().AttesterSlashings())
 	if cfg.isValidPayload {
-		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, cfg.roblock.Root()); err != nil {
+		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, cfg.blockRoot); err != nil {
 			return errors.Wrap(err, "could not set optimistic block to valid")
 		}
 	}
@@ -97,8 +95,8 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 		log.WithError(err).Warn("Could not update head")
 	}
 	newBlockHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
-	if cfg.headRoot != cfg.roblock.Root() {
-		s.logNonCanonicalBlockReceived(cfg.roblock.Root(), cfg.headRoot)
+	if cfg.headRoot != cfg.blockRoot {
+		s.logNonCanonicalBlockReceived(cfg.blockRoot, cfg.headRoot)
 		return nil
 	}
 	if err := s.getFCUArgs(cfg, fcuArgs); err != nil {
@@ -156,7 +154,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	}
 
 	// Fill in missing blocks
-	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0], preState.CurrentJustifiedCheckpoint(), preState.FinalizedCheckpoint()); err != nil {
+	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0].Block(), preState.CurrentJustifiedCheckpoint(), preState.FinalizedCheckpoint()); err != nil {
 		return errors.Wrap(err, "could not fill in missing blocks to forkchoice")
 	}
 
@@ -236,7 +234,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), b); err != nil {
 			return errors.Wrapf(err, "could not validate blob data availability at slot %d", b.Block().Slot())
 		}
-		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
+		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
 		pendingNodes[len(blks)-i-1] = args
@@ -281,7 +279,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 		return errors.Wrap(err, "could not insert batch to forkchoice")
 	}
 	// Insert the last block to forkchoice
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastB); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastBR); err != nil {
 		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
 	}
 	// Set their optimistic status
@@ -378,11 +376,7 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
 			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
-		} else if features.Get().EnableExperimentalAttestationPool {
-			if err = s.cfg.AttestationCache.Add(a); err != nil {
-				return err
-			}
-		} else if err = s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
+		} else if err := s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
 			return err
 		}
 	}
@@ -410,9 +404,6 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 		return errors.Wrapf(err, "could not save block from slot %d", b.Block().Slot())
 	}
 	if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-		// Do not use parent context in the event it deadlined
-		ctx = trace.NewContext(context.Background(), span)
-		s.rollbackBlock(ctx, r)
 		return errors.Wrap(err, "could not save state")
 	}
 	return nil
@@ -422,11 +413,7 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 func (s *Service) pruneAttsFromPool(headBlock interfaces.ReadOnlySignedBeaconBlock) error {
 	atts := headBlock.Block().Body().Attestations()
 	for _, att := range atts {
-		if features.Get().EnableExperimentalAttestationPool {
-			if err := s.cfg.AttestationCache.DeleteCovered(att); err != nil {
-				return errors.Wrap(err, "could not delete attestation")
-			}
-		} else if att.IsAggregated() {
+		if helpers.IsAggregated(att) {
 			if err := s.cfg.AttPool.DeleteAggregatedAttestation(att); err != nil {
 				return err
 			}
@@ -503,15 +490,14 @@ func (s *Service) runLateBlockTasks() {
 // It returns a map where each key represents a missing BlobSidecar index.
 // An empty map means we have all indices; a non-empty map can be used to compare incoming
 // BlobSidecars against the set of known missing sidecars.
-func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte, slot primitives.Slot) (map[uint64]struct{}, error) {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte) (map[uint64]struct{}, error) {
 	if len(expected) == 0 {
 		return nil, nil
 	}
-	if len(expected) > maxBlobsPerBlock {
+	if len(expected) > fieldparams.MaxBlobsPerBlock {
 		return nil, errMaxBlobsExceeded
 	}
-	indices, err := bs.Indices(root, slot)
+	indices, err := bs.Indices(root)
 	if err != nil {
 		return nil, err
 	}
@@ -560,7 +546,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 		return nil
 	}
 	// get a map of BlobSidecar indices that are not currently available.
-	missing, err := missingIndices(s.blobStorage, root, kzgCommitments, block.Slot())
+	missing, err := missingIndices(s.blobStorage, root, kzgCommitments)
 	if err != nil {
 		return err
 	}
@@ -571,7 +557,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 
 	// The gossip handler for blobs writes the index of each verified blob referencing the given
 	// root to the channel returned by blobNotifiers.forRoot.
-	nc := s.blobNotifiers.forRoot(root, block.Slot())
+	nc := s.blobNotifiers.forRoot(root)
 
 	// Log for DA checks that cross over into the next slot; helpful for debugging.
 	nextSlot := slots.BeginsAt(signed.Block().Slot()+1, s.genesisTime)
@@ -628,6 +614,9 @@ func (s *Service) lateBlockTasks(ctx context.Context) {
 	if !s.inRegularSync() {
 		return
 	}
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.MissedSlot,
+	})
 	s.headLock.RLock()
 	headRoot := s.headRoot()
 	headState := s.headState(ctx)
@@ -655,13 +644,6 @@ 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() {
-		fcuArgs := &fcuConfig{
-			headState:  headState,
-			headRoot:   headRoot,
-			headBlock:  nil,
-			attributes: attribute,
-		}
-		go firePayloadAttributesEvent(ctx, s.cfg.StateNotifier.StateFeed(), fcuArgs)
 		return
 	}
 
@@ -702,15 +684,3 @@ func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, bl
 	}
 	return err
 }
-
-// In the event of an issue processing a block we rollback changes done to the db and our caches
-// to always ensure that the node's internal state is consistent.
-func (s *Service) rollbackBlock(ctx context.Context, blockRoot [32]byte) {
-	log.Warnf("Rolling back insertion of block with root %#x due to processing error", blockRoot)
-	if err := s.cfg.StateGen.DeleteStateFromCaches(ctx, blockRoot); err != nil {
-		log.WithError(err).Errorf("Could not delete state from caches with block root %#x", blockRoot)
-	}
-	if err := s.cfg.BeaconDB.DeleteBlock(ctx, blockRoot); err != nil {
-		log.WithError(err).Errorf("Could not delete block with block root %#x", blockRoot)
-	}
-}

beacon-chain/blockchain/process_block_helpers.go

@@ -1,10 +1,8 @@
 package blockchain
 
 import (
-	"bytes"
 	"context"
 	"fmt"
-	"strings"
 	"time"
 
 	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
@@ -17,14 +15,15 @@ import (
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v5/math"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
@@ -43,7 +42,7 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 	if !s.inRegularSync() {
 		return nil
 	}
-	slot := cfg.roblock.Block().Slot()
+	slot := cfg.signed.Block().Slot()
 	if slots.WithinVotingWindow(uint64(s.genesisTime.Unix()), slot) {
 		return nil
 	}
@@ -51,9 +50,9 @@ func (s *Service) getFCUArgs(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) er
 }
 
 func (s *Service) getFCUArgsEarlyBlock(cfg *postBlockProcessConfig, fcuArgs *fcuConfig) error {
-	if cfg.roblock.Root() == cfg.headRoot {
+	if cfg.blockRoot == cfg.headRoot {
 		fcuArgs.headState = cfg.postState
-		fcuArgs.headBlock = cfg.roblock
+		fcuArgs.headBlock = cfg.signed
 		fcuArgs.headRoot = cfg.headRoot
 		fcuArgs.proposingSlot = s.CurrentSlot() + 1
 		return nil
@@ -97,7 +96,7 @@ func (s *Service) fcuArgsNonCanonicalBlock(cfg *postBlockProcessConfig, fcuArgs
 
 // sendStateFeedOnBlock sends an event that a new block has been synced
 func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
-	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(cfg.roblock.Root())
+	optimistic, err := s.cfg.ForkChoiceStore.IsOptimistic(cfg.blockRoot)
 	if err != nil {
 		log.WithError(err).Debug("Could not check if block is optimistic")
 		optimistic = true
@@ -106,156 +105,85 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.BlockProcessed,
 		Data: &statefeed.BlockProcessedData{
-			Slot:        cfg.roblock.Block().Slot(),
-			BlockRoot:   cfg.roblock.Root(),
-			SignedBlock: cfg.roblock,
+			Slot:        cfg.signed.Block().Slot(),
+			BlockRoot:   cfg.blockRoot,
+			SignedBlock: cfg.signed,
 			Verified:    true,
 			Optimistic:  optimistic,
 		},
 	})
 }
 
-func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
-	if err := s.processLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
-		log.WithError(err).Error("Failed to process light client optimistic update")
-	}
-	if err := s.processLightClientFinalityUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
-		log.WithError(err).Error("Failed to process light client finality update")
+// sendLightClientFeeds sends the light client feeds when feature flag is enabled.
+func (s *Service) sendLightClientFeeds(cfg *postBlockProcessConfig) {
+	if features.Get().EnableLightClient {
+		if _, err := s.sendLightClientOptimisticUpdate(cfg.ctx, cfg.signed, cfg.postState); err != nil {
+			log.WithError(err).Error("Failed to send light client optimistic update")
+		}
+
+		// Get the finalized checkpoint
+		finalized := s.ForkChoicer().FinalizedCheckpoint()
+
+		// LightClientFinalityUpdate needs super majority
+		s.tryPublishLightClientFinalityUpdate(cfg.ctx, cfg.signed, finalized, cfg.postState)
 	}
 }
 
-// saveLightClientUpdate saves the light client update for this block
-// if it's better than the already saved one, when feature flag is enabled.
-func (s *Service) saveLightClientUpdate(cfg *postBlockProcessConfig) {
-	attestedRoot := cfg.roblock.Block().ParentRoot()
-	attestedBlock, err := s.getBlock(cfg.ctx, attestedRoot)
+func (s *Service) tryPublishLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, finalized *forkchoicetypes.Checkpoint, postState state.BeaconState) {
+	if finalized.Epoch <= s.lastPublishedLightClientEpoch {
+		return
+	}
+
+	config := params.BeaconConfig()
+	if finalized.Epoch < config.AltairForkEpoch {
+		return
+	}
+
+	syncAggregate, err := signed.Block().Body().SyncAggregate()
+	if err != nil || syncAggregate == nil {
+		return
+	}
+
+	// LightClientFinalityUpdate needs super majority
+	if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 {
+		return
+	}
+
+	_, err = s.sendLightClientFinalityUpdate(ctx, signed, postState)
 	if err != nil {
-		log.WithError(err).Errorf("Saving light client update failed: Could not get attested block for root %#x", attestedRoot)
-		return
-	}
-	if attestedBlock == nil || attestedBlock.IsNil() {
-		log.Error("Saving light client update failed: Attested block is nil")
-		return
-	}
-	attestedState, err := s.cfg.StateGen.StateByRoot(cfg.ctx, attestedRoot)
-	if err != nil {
-		log.WithError(err).Errorf("Saving light client update failed: Could not get attested state for root %#x", attestedRoot)
-		return
-	}
-	if attestedState == nil || attestedState.IsNil() {
-		log.Error("Saving light client update failed: Attested state is nil")
-		return
-	}
-
-	finalizedRoot := attestedState.FinalizedCheckpoint().Root
-	finalizedBlock, err := s.getBlock(cfg.ctx, [32]byte(finalizedRoot))
-	if err != nil {
-		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
-			log.Debugf("Skipping saving light client update: Finalized block is nil for root %#x", finalizedRoot)
-		} else {
-			log.WithError(err).Errorf("Saving light client update failed: Could not get finalized block for root %#x", finalizedRoot)
-		}
-		return
-	}
-
-	update, err := lightclient.NewLightClientUpdateFromBeaconState(
-		cfg.ctx,
-		s.CurrentSlot(),
-		cfg.postState,
-		cfg.roblock,
-		attestedState,
-		attestedBlock,
-		finalizedBlock,
-	)
-	if err != nil {
-		log.WithError(err).Error("Saving light client update failed: Could not create light client update")
-		return
-	}
-
-	period := slots.SyncCommitteePeriod(slots.ToEpoch(attestedState.Slot()))
-
-	oldUpdate, err := s.cfg.BeaconDB.LightClientUpdate(cfg.ctx, period)
-	if err != nil {
-		log.WithError(err).Error("Saving light client update failed: Could not get current light client update")
-		return
-	}
-
-	if oldUpdate == nil {
-		if err := s.cfg.BeaconDB.SaveLightClientUpdate(cfg.ctx, period, update); err != nil {
-			log.WithError(err).Error("Saving light client update failed: Could not save light client update")
-		} else {
-			log.WithField("period", period).Debug("Saving light client update: Saved new update")
-		}
-		return
-	}
-
-	isNewUpdateBetter, err := lightclient.IsBetterUpdate(update, oldUpdate)
-	if err != nil {
-		log.WithError(err).Error("Saving light client update failed: Could not compare light client updates")
-		return
-	}
-
-	if isNewUpdateBetter {
-		if err := s.cfg.BeaconDB.SaveLightClientUpdate(cfg.ctx, period, update); err != nil {
-			log.WithError(err).Error("Saving light client update failed: Could not save light client update")
-		} else {
-			log.WithField("period", period).Debug("Saving light client update: Saved new update")
-		}
+		log.WithError(err).Error("Failed to send light client finality update")
 	} else {
-		log.WithField("period", period).Debug("Saving light client update: New update is not better than the current one. Skipping save.")
+		s.lastPublishedLightClientEpoch = finalized.Epoch
 	}
 }
 
-// saveLightClientBootstrap saves a light client bootstrap for this block
-// when feature flag is enabled.
-func (s *Service) saveLightClientBootstrap(cfg *postBlockProcessConfig) {
-	blockRoot := cfg.roblock.Root()
-	bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(cfg.ctx, s.CurrentSlot(), cfg.postState, cfg.roblock)
-	if err != nil {
-		log.WithError(err).Error("Saving light client bootstrap failed: Could not create light client bootstrap")
-		return
-	}
-	err = s.cfg.BeaconDB.SaveLightClientBootstrap(cfg.ctx, blockRoot[:], bootstrap)
-	if err != nil {
-		log.WithError(err).Error("Saving light client bootstrap failed: Could not save light client bootstrap in DB")
-	}
-}
-
-func (s *Service) processLightClientFinalityUpdate(
-	ctx context.Context,
-	signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState,
-) error {
+// sendLightClientFinalityUpdate sends a light client finality update notification to the state feed.
+func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState) (int, error) {
+	// Get attested state
 	attestedRoot := signed.Block().ParentRoot()
 	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
+		return 0, errors.Wrap(err, "could not get attested block")
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
+		return 0, errors.Wrap(err, "could not get attested state")
 	}
 
-	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
-
-	// Check if the finalized checkpoint has changed
-	if finalizedCheckpoint == nil || bytes.Equal(finalizedCheckpoint.GetRoot(), postState.FinalizedCheckpoint().Root) {
-		return nil
-	}
-
-	finalizedRoot := bytesutil.ToBytes32(finalizedCheckpoint.Root)
-	finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, finalizedRoot)
-	if err != nil {
-		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
-			log.Debugf("Skipping processing light client finality update: Finalized block is nil for root %#x", finalizedRoot)
-			return nil
+	// Get finalized block
+	var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
+	finalizedCheckPoint := attestedState.FinalizedCheckpoint()
+	if finalizedCheckPoint != nil {
+		finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root)
+		finalizedBlock, err = s.cfg.BeaconDB.Block(ctx, finalizedRoot)
+		if err != nil {
+			finalizedBlock = nil
 		}
-		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
 	}
 
 	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
-		postState.Slot(),
 		postState,
 		signed,
 		attestedState,
@@ -264,31 +192,38 @@ func (s *Service) processLightClientFinalityUpdate(
 	)
 
 	if err != nil {
-		return errors.Wrap(err, "could not create light client finality update")
+		return 0, errors.Wrap(err, "could not create light client update")
 	}
 
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+	// Return the result
+	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
+		Version: ethpbv2.Version(signed.Version()),
+		Data:    update,
+	}
+
+	// Send event
+	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.LightClientFinalityUpdate,
-		Data: update,
-	})
-	return nil
+		Data: result,
+	}), nil
 }
 
-func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState) error {
+// sendLightClientOptimisticUpdate sends a light client optimistic update notification to the state feed.
+func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState) (int, error) {
+	// Get attested state
 	attestedRoot := signed.Block().ParentRoot()
 	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
+		return 0, errors.Wrap(err, "could not get attested block")
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
+		return 0, errors.Wrap(err, "could not get attested state")
 	}
 
 	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
 		ctx,
-		postState.Slot(),
 		postState,
 		signed,
 		attestedState,
@@ -296,19 +231,19 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 	)
 
 	if err != nil {
-		if strings.Contains(err.Error(), lightclient.ErrNotEnoughSyncCommitteeBits) {
-			log.WithError(err).Debug("Skipping processing light client optimistic update")
-			return nil
-		}
-		return errors.Wrap(err, "could not create light client optimistic update")
+		return 0, errors.Wrap(err, "could not create light client update")
 	}
 
-	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
-		Type: statefeed.LightClientOptimisticUpdate,
-		Data: update,
-	})
+	// Return the result
+	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
+		Version: ethpbv2.Version(signed.Version()),
+		Data:    update,
+	}
 
-	return nil
+	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: result,
+	}), nil
 }
 
 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch
@@ -317,21 +252,20 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 // 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 {
+	if err := transition.UpdateNextSlotCache(cfg.ctx, cfg.blockRoot[:], cfg.postState); err != nil {
 		return errors.Wrap(err, "could not update next slot state cache")
 	}
 	if !slots.IsEpochEnd(slot) {
 		return nil
 	}
-	return s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, root[:])
+	return s.handleEpochBoundary(cfg.ctx, slot, cfg.postState, cfg.blockRoot[:])
 }
 
 // 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() {
+	if (fcuArgs.attributes == nil || fcuArgs.attributes.IsEmpty()) && cfg.headRoot == cfg.blockRoot {
 		go s.sendFCUWithAttributes(cfg, fcuArgs)
 	}
 }
@@ -347,7 +281,7 @@ func reportProcessingTime(startTime time.Time) {
 // 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 cfg.blockRoot == cfg.headRoot {
 		if err := s.updateCachesPostBlockProcessing(cfg); err != nil {
 			return err
 		}
@@ -504,7 +438,7 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot primitives.
 
 // This retrieves missing blocks from DB (ie. the blocks that couldn't be received over sync) and inserts them to fork choice store.
 // This is useful for block tree visualizer and additional vote accounting.
-func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfaces.ReadOnlyBeaconBlock,
 	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
 	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, 0)
 
@@ -514,15 +448,10 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 	if err != nil {
 		return err
 	}
-	// The first block can have a bogus root since the block is not inserted in forkchoice
-	roblock, err := consensus_blocks.NewROBlockWithRoot(signed, [32]byte{})
-	if err != nil {
-		return err
-	}
-	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: blk,
 		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
 	// As long as parent node is not in fork choice store, and parent node is in DB.
-	root := roblock.Block().ParentRoot()
+	root := blk.ParentRoot()
 	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
 		b, err := s.getBlock(ctx, root)
 		if err != nil {
@@ -531,12 +460,8 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 		if b.Block().Slot() <= fSlot {
 			break
 		}
-		roblock, err := consensus_blocks.NewROBlockWithRoot(b, root)
-		if err != nil {
-			return err
-		}
 		root = b.Block().ParentRoot()
-		args := &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+		args := &forkchoicetypes.BlockAndCheckpoints{Block: b.Block(),
 			JustifiedCheckpoint: jCheckpoint,
 			FinalizedCheckpoint: fCheckpoint}
 		pendingNodes = append(pendingNodes, args)

beacon-chain/blockchain/receive_attestation.go

@@ -9,7 +9,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -167,13 +166,7 @@ func (s *Service) UpdateHead(ctx context.Context, proposingSlot primitives.Slot)
 
 // This processes fork choice attestations from the pool to account for validator votes and fork choice.
 func (s *Service) processAttestations(ctx context.Context, disparity time.Duration) {
-	var atts []ethpb.Att
-	if features.Get().EnableExperimentalAttestationPool {
-		atts = s.cfg.AttestationCache.ForkchoiceAttestations()
-	} else {
-		atts = s.cfg.AttPool.ForkchoiceAttestations()
-	}
-
+	atts := s.cfg.AttPool.ForkchoiceAttestations()
 	for _, a := range atts {
 		// Based on the spec, don't process the attestation until the subsequent slot.
 		// This delays consideration in the fork choice until their slot is in the past.
@@ -189,11 +182,7 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 			continue
 		}
 
-		if features.Get().EnableExperimentalAttestationPool {
-			if err := s.cfg.AttestationCache.DeleteForkchoiceAttestation(a); err != nil {
-				log.WithError(err).Error("Could not delete fork choice attestation in pool")
-			}
-		} else if err := s.cfg.AttPool.DeleteForkchoiceAttestation(a); err != nil {
+		if err := s.cfg.AttPool.DeleteForkchoiceAttestation(a); err != nil {
 			log.WithError(err).Error("Could not delete fork choice attestation in pool")
 		}
 

beacon-chain/blockchain/receive_attestation_test.go

@@ -46,7 +46,7 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r32))
 
-	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32.Root(), params.BeaconConfig().ZeroHash, fc, fc)
+	state, r33, err := prepareForkchoiceState(ctx, 33, [32]byte{'b'}, r32, params.BeaconConfig().ZeroHash, fc, fc)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, r33))
 
@@ -54,12 +54,10 @@ func TestVerifyLMDFFGConsistent(t *testing.T) {
 	a := util.NewAttestation()
 	a.Data.Target.Epoch = 1
 	a.Data.Target.Root = []byte{'c'}
-	r33Root := r33.Root()
-	a.Data.BeaconBlockRoot = r33Root[:]
+	a.Data.BeaconBlockRoot = r33[:]
 	require.ErrorContains(t, wanted, service.VerifyLmdFfgConsistency(context.Background(), a))
 
-	r32Root := r32.Root()
-	a.Data.Target.Root = r32Root[:]
+	a.Data.Target.Root = r32[:]
 	err = service.VerifyLmdFfgConsistency(context.Background(), a)
 	require.NoError(t, err, "Could not verify LMD and FFG votes to be consistent")
 }
@@ -86,7 +84,9 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	attsToSave := make([]ethpb.Att, len(atts))
-	copy(attsToSave, atts)
+	for i, a := range atts {
+		attsToSave[i] = a
+	}
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	service.processAttestations(ctx, 0)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
@@ -116,9 +116,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
-	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
-	require.NoError(t, err)
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, tRoot, [32]byte{}, postState, false}))
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
 	require.NoError(t, err)
 	require.Equal(t, 2, fcs.NodeCount())
@@ -128,7 +126,9 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
 	require.NoError(t, err)
 	attsToSave := make([]ethpb.Att, len(atts))
-	copy(attsToSave, atts)
+	for i, a := range atts {
+		attsToSave[i] = a
+	}
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	// Verify the target is in forkchoice
 	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].GetData().BeaconBlockRoot)))
@@ -176,9 +176,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
-	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
-	require.NoError(t, err)
-	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
+	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, wsb, tRoot, [32]byte{}, postState, false}))
 	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_blob.go

@@ -4,13 +4,12 @@ import (
 	"context"
 
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 // SendNewBlobEvent sends a message to the BlobNotifier channel that the blob
 // for the block root `root` is ready in the database
-func (s *Service) sendNewBlobEvent(root [32]byte, index uint64, slot primitives.Slot) {
-	s.blobNotifiers.notifyIndex(root, index, slot)
+func (s *Service) sendNewBlobEvent(root [32]byte, index uint64) {
+	s.blobNotifiers.notifyIndex(root, index)
 }
 
 // ReceiveBlob saves the blob to database and sends the new event
@@ -19,6 +18,6 @@ func (s *Service) ReceiveBlob(ctx context.Context, b blocks.VerifiedROBlob) erro
 		return err
 	}
 
-	s.sendNewBlobEvent(b.BlockRoot(), b.Index, b.Slot())
+	s.sendNewBlobEvent(b.BlockRoot(), b.Index)
 	return nil
 }

beacon-chain/blockchain/receive_block.go

@@ -83,12 +83,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 
 	currentCheckpoints := s.saveCurrentCheckpoints(preState)
-	roblock, err := blocks.NewROBlockWithRoot(blockCopy, blockRoot)
-	if err != nil {
-		return err
-	}
-
-	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, roblock)
+	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, blockCopy, blockRoot)
 	if err != nil {
 		return err
 	}
@@ -107,7 +102,8 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 	args := &postBlockProcessConfig{
 		ctx:            ctx,
-		roblock:        roblock,
+		signed:         blockCopy,
+		blockRoot:      blockRoot,
 		postState:      postState,
 		isValidPayload: isValidPayload,
 	}
@@ -188,7 +184,8 @@ func (s *Service) updateCheckpoints(
 func (s *Service) validateExecutionAndConsensus(
 	ctx context.Context,
 	preState state.BeaconState,
-	block blocks.ROBlock,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [32]byte,
 ) (state.BeaconState, bool, error) {
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	if err != nil {
@@ -207,7 +204,7 @@ func (s *Service) validateExecutionAndConsensus(
 	var isValidPayload bool
 	eg.Go(func() error {
 		var err error
-		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block)
+		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block, blockRoot)
 		if err != nil {
 			return errors.Wrap(err, "could not notify the engine of the new payload")
 		}
@@ -276,6 +273,7 @@ func (s *Service) reportPostBlockProcessing(
 func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {
 	finalized := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	go func() {
+		finalizedState.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
 		s.sendNewFinalizedEvent(ctx, finalizedState)
 	}()
 	depCtx, cancel := context.WithTimeout(context.Background(), depositDeadline)
@@ -352,9 +350,6 @@ func (s *Service) ReceiveBlockBatch(ctx context.Context, blocks []blocks.ROBlock
 
 // HasBlock returns true if the block of the input root exists in initial sync blocks cache or DB.
 func (s *Service) HasBlock(ctx context.Context, root [32]byte) bool {
-	if s.BlockBeingSynced(root) {
-		return false
-	}
 	return s.hasBlockInInitSyncOrDB(ctx, root)
 }
 
@@ -558,16 +553,16 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 }
 
 // validateExecutionOnBlock notifies the engine of the incoming block execution payload and returns true if the payload is valid
-func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, block blocks.ROBlock) (bool, error) {
-	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, block)
+func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, signed interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) (bool, error) {
+	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, signed)
 	if err != nil {
 		s.cfg.ForkChoiceStore.Lock()
-		err = s.handleInvalidExecutionError(ctx, err, block.Root(), block.Block().ParentRoot())
+		err = s.handleInvalidExecutionError(ctx, err, blockRoot, signed.Block().ParentRoot())
 		s.cfg.ForkChoiceStore.Unlock()
 		return false, err
 	}
-	if block.Block().Version() < version.Capella && isValidPayload {
-		if err := s.validateMergeTransitionBlock(ctx, ver, header, block); err != nil {
+	if signed.Version() < version.Capella && isValidPayload {
+		if err := s.validateMergeTransitionBlock(ctx, ver, header, signed); err != nil {
 			return isValidPayload, err
 		}
 	}

beacon-chain/blockchain/receive_block_test.go

@@ -278,8 +278,6 @@ func TestService_HasBlock(t *testing.T) {
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.Equal(t, true, s.HasBlock(context.Background(), r))
-	s.blockBeingSynced.set(r)
-	require.Equal(t, false, s.HasBlock(context.Background(), r))
 }
 
 func TestCheckSaveHotStateDB_Enabling(t *testing.T) {

beacon-chain/blockchain/service.go

@@ -33,6 +33,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -47,24 +48,25 @@ import (
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                  *config
-	ctx                  context.Context
-	cancel               context.CancelFunc
-	genesisTime          time.Time
-	head                 *head
-	headLock             sync.RWMutex
-	originBlockRoot      [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	boundaryRoots        [][32]byte
-	checkpointStateCache *cache.CheckpointStateCache
-	initSyncBlocks       map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
-	initSyncBlocksLock   sync.RWMutex
-	wsVerifier           *WeakSubjectivityVerifier
-	clockSetter          startup.ClockSetter
-	clockWaiter          startup.ClockWaiter
-	syncComplete         chan struct{}
-	blobNotifiers        *blobNotifierMap
-	blockBeingSynced     *currentlySyncingBlock
-	blobStorage          *filesystem.BlobStorage
+	cfg                           *config
+	ctx                           context.Context
+	cancel                        context.CancelFunc
+	genesisTime                   time.Time
+	head                          *head
+	headLock                      sync.RWMutex
+	originBlockRoot               [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	boundaryRoots                 [][32]byte
+	checkpointStateCache          *cache.CheckpointStateCache
+	initSyncBlocks                map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
+	initSyncBlocksLock            sync.RWMutex
+	wsVerifier                    *WeakSubjectivityVerifier
+	clockSetter                   startup.ClockSetter
+	clockWaiter                   startup.ClockWaiter
+	syncComplete                  chan struct{}
+	blobNotifiers                 *blobNotifierMap
+	blockBeingSynced              *currentlySyncingBlock
+	blobStorage                   *filesystem.BlobStorage
+	lastPublishedLightClientEpoch primitives.Epoch
 }
 
 // config options for the service.
@@ -75,7 +77,6 @@ type config struct {
 	DepositCache            cache.DepositCache
 	PayloadIDCache          *cache.PayloadIDCache
 	TrackedValidatorsCache  *cache.TrackedValidatorsCache
-	AttestationCache        *cache.AttestationCache
 	AttPool                 attestations.Pool
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
@@ -105,22 +106,18 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][]bool
+	seenIndex map[[32]byte][fieldparams.MaxBlobsPerBlock]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
-func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitives.Slot) {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
-	if idx >= uint64(maxBlobsPerBlock) {
+func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
+	if idx >= fieldparams.MaxBlobsPerBlock {
 		return
 	}
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
-	if seen == nil {
-		seen = make([]bool, maxBlobsPerBlock)
-	}
 	if seen[idx] {
 		bn.Unlock()
 		return
@@ -131,7 +128,7 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, maxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 
@@ -140,13 +137,12 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 	c <- idx
 }
 
-func (bn *blobNotifierMap) forRoot(root [32]byte, slot primitives.Slot) chan uint64 {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+func (bn *blobNotifierMap) forRoot(root [32]byte) chan uint64 {
 	bn.Lock()
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, maxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -172,7 +168,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][]bool),
+		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,
@@ -307,15 +303,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint state")
 	}
-	finalizedBlock, err := s.cfg.BeaconDB.Block(s.ctx, fRoot)
-	if err != nil {
-		return errors.Wrap(err, "could not get finalized checkpoint block")
-	}
-	roblock, err := blocks.NewROBlockWithRoot(finalizedBlock, fRoot)
-	if err != nil {
-		return err
-	}
-	if err := s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, roblock); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(s.ctx, st, fRoot); err != nil {
 		return errors.Wrap(err, "could not insert finalized block to forkchoice")
 	}
 	if !features.Get().EnableStartOptimistic {
@@ -341,6 +329,8 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
 
+	saved.SaveValidatorIndices() // used to handle Validator index invariant from EIP6110
+
 	return nil
 }
 
@@ -527,11 +517,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	gb, err := blocks.NewROBlockWithRoot(genesisBlk, genesisBlkRoot)
-	if err != nil {
-		return err
-	}
-	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, gb); err != nil {
+	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, genesisState, genesisBlkRoot); err != nil {
 		log.WithError(err).Fatal("Could not process genesis block for fork choice")
 	}
 	s.cfg.ForkChoiceStore.SetOriginRoot(genesisBlkRoot)

beacon-chain/blockchain/service_test.go

@@ -376,15 +376,11 @@ func TestHasBlock_ForkChoiceAndDB_DoublyLinkedTree(t *testing.T) {
 		cfg: &config{ForkChoiceStore: doublylinkedtree.New(), BeaconDB: beaconDB},
 	}
 	b := util.NewBeaconBlock()
-	wsb, err := consensusblocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
 	r, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-	require.NoError(t, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(t, err)
-	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
+	require.NoError(t, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
 
 	assert.Equal(t, false, s.hasBlock(ctx, [32]byte{}), "Should not have block")
 	assert.Equal(t, true, s.hasBlock(ctx, r), "Should have block")
@@ -457,11 +453,7 @@ func BenchmarkHasBlockForkChoiceStore_DoublyLinkedTree(b *testing.B) {
 	require.NoError(b, err)
 	beaconState, err := util.NewBeaconState()
 	require.NoError(b, err)
-	wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
-	require.NoError(b, err)
-	roblock, err := consensusblocks.NewROBlockWithRoot(wsb, r)
-	require.NoError(b, err)
-	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, roblock))
+	require.NoError(b, s.cfg.ForkChoiceStore.InsertNode(ctx, beaconState, r))
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -587,7 +579,7 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][]bool),
+		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 
@@ -596,7 +588,7 @@ func TestNotifyIndex(t *testing.T) {
 	copy(root[:], "exampleRoot")
 
 	// Test notifying a new index
-	bn.notifyIndex(root, 1, 1)
+	bn.notifyIndex(root, 1)
 	if !bn.seenIndex[root][1] {
 		t.Errorf("Index was not marked as seen")
 	}
@@ -607,13 +599,13 @@ func TestNotifyIndex(t *testing.T) {
 	}
 
 	// Test notifying an already seen index
-	bn.notifyIndex(root, 1, 1)
+	bn.notifyIndex(root, 1)
 	if len(bn.notifiers[root]) > 1 {
 		t.Errorf("Notifier channel should not receive multiple messages for the same index")
 	}
 
 	// Test notifying a new index again
-	bn.notifyIndex(root, 2, 1)
+	bn.notifyIndex(root, 2)
 	if !bn.seenIndex[root][2] {
 		t.Errorf("Index was not marked as seen")
 	}

beacon-chain/blockchain/testing/mock.go

@@ -567,7 +567,7 @@ func prepareForkchoiceState(
 	payloadHash [32]byte,
 	justified *ethpb.Checkpoint,
 	finalized *ethpb.Checkpoint,
-) (state.BeaconState, blocks.ROBlock, error) {
+) (state.BeaconState, [32]byte, error) {
 	blockHeader := &ethpb.BeaconBlockHeader{
 		ParentRoot: parentRoot[:],
 	}
@@ -588,26 +588,7 @@ func prepareForkchoiceState(
 
 	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
 	st, err := state_native.InitializeFromProtoBellatrix(base)
-	if err != nil {
-		return nil, blocks.ROBlock{}, err
-	}
-	blk := &ethpb.SignedBeaconBlockBellatrix{
-		Block: &ethpb.BeaconBlockBellatrix{
-			Slot:       slot,
-			ParentRoot: parentRoot[:],
-			Body: &ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: &enginev1.ExecutionPayload{
-					BlockHash: payloadHash[:],
-				},
-			},
-		},
-	}
-	signed, err := blocks.NewSignedBeaconBlock(blk)
-	if err != nil {
-		return nil, blocks.ROBlock{}, err
-	}
-	roblock, err := blocks.NewROBlockWithRoot(signed, blockRoot)
-	return st, roblock, err
+	return st, blockRoot, err
 }
 
 // CachedHeadRoot mocks the same method in the chain service
@@ -650,9 +631,9 @@ func (s *ChainService) HighestReceivedBlockSlot() primitives.Slot {
 }
 
 // InsertNode mocks the same method in the chain service
-func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, block blocks.ROBlock) error {
+func (s *ChainService) InsertNode(ctx context.Context, st state.BeaconState, root [32]byte) error {
 	if s.ForkChoiceStore != nil {
-		return s.ForkChoiceStore.InsertNode(ctx, st, block)
+		return s.ForkChoiceStore.InsertNode(ctx, st, root)
 	}
 	return nil
 }

beacon-chain/cache/BUILD.bazel

@@ -5,7 +5,6 @@ go_library(
     srcs = [
         "active_balance.go",
         "active_balance_disabled.go",  # keep
-        "attestation.go",
         "attestation_data.go",
         "balance_cache_key.go",
         "checkpoint_state.go",
@@ -37,21 +36,18 @@ go_library(
     ],
     deps = [
         "//beacon-chain/forkchoice/types:go_default_library",
-        "//beacon-chain/operations/attestations/attmap:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//cache/lru:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
-        "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//crypto/rand:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
@@ -70,7 +66,6 @@ go_test(
     srcs = [
         "active_balance_test.go",
         "attestation_data_test.go",
-        "attestation_test.go",
         "cache_test.go",
         "checkpoint_state_test.go",
         "committee_fuzz_test.go",
@@ -93,17 +88,14 @@ go_test(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//crypto/bls/blst:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
         "@com_github_hashicorp_golang_lru//:go_default_library",
-        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_stretchr_testify//require:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],

beacon-chain/cache/attestation.go

@@ -1,275 +0,0 @@
-package cache
-
-import (
-	"sync"
-
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations/attmap"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
-	log "github.com/sirupsen/logrus"
-)
-
-type attGroup struct {
-	slot primitives.Slot
-	atts []ethpb.Att
-}
-
-// AttestationCache holds a map of attGroup items that group together all attestations for a single slot.
-// When we add an attestation to the cache by calling Add, we either create a new group with this attestation
-// (if this is the first attestation for some slot) or two things can happen:
-//
-//   - If the attestation is unaggregated, we add its attestation bit to attestation bits of the first
-//     attestation in the group.
-//   - If the attestation is aggregated, we append it to the group. There should be no redundancy
-//     in the list because we ignore redundant aggregates in gossip.
-//
-// The first bullet point above means that we keep one aggregate attestation to which we keep appending bits
-// as new single-bit attestations arrive. This means that at any point during seconds 0-4 of a slot
-// we will have only one attestation for this slot in the cache.
-//
-// NOTE: This design in principle can result in worse aggregates since we lose the ability to aggregate some
-// single bit attestations in case of overlaps with incoming aggregates.
-//
-// The cache also keeps forkchoice attestations in a separate struct. These attestations are used for
-// forkchoice-related operations.
-type AttestationCache struct {
-	atts map[attestation.Id]*attGroup
-	sync.RWMutex
-	forkchoiceAtts *attmap.Attestations
-}
-
-// NewAttestationCache creates a new cache instance.
-func NewAttestationCache() *AttestationCache {
-	return &AttestationCache{
-		atts:           make(map[attestation.Id]*attGroup),
-		forkchoiceAtts: attmap.New(),
-	}
-}
-
-// Add does one of two things:
-//
-//   - For unaggregated attestations, it adds the attestation bit to attestation bits of the running aggregate,
-//     which is the first aggregate for the slot.
-//   - For aggregated attestations, it appends the attestation to the existng list of attestations for the slot.
-func (c *AttestationCache) Add(att ethpb.Att) error {
-	if att.IsNil() {
-		log.Debug("Attempted to add a nil attestation to the attestation cache")
-		return nil
-	}
-	if len(att.GetAggregationBits().BitIndices()) == 0 {
-		log.Debug("Attempted to add an attestation with 0 bits set to the attestation cache")
-		return nil
-	}
-
-	c.Lock()
-	defer c.Unlock()
-
-	id, err := attestation.NewId(att, attestation.Data)
-	if err != nil {
-		return errors.Wrapf(err, "could not create attestation ID")
-	}
-
-	group := c.atts[id]
-	if group == nil {
-		group = &attGroup{
-			slot: att.GetData().Slot,
-			atts: []ethpb.Att{att},
-		}
-		c.atts[id] = group
-		return nil
-	}
-
-	if att.IsAggregated() {
-		group.atts = append(group.atts, att.Clone())
-		return nil
-	}
-
-	// This should never happen because we return early for a new group.
-	if len(group.atts) == 0 {
-		log.Error("Attestation group contains no attestations, skipping insertion")
-		return nil
-	}
-
-	a := group.atts[0]
-
-	// Indexing is safe because we have guarded against 0 bits set.
-	bit := att.GetAggregationBits().BitIndices()[0]
-	if a.GetAggregationBits().BitAt(uint64(bit)) {
-		return nil
-	}
-	sig, err := aggregateSig(a, att)
-	if err != nil {
-		return errors.Wrapf(err, "could not aggregate signatures")
-	}
-
-	a.GetAggregationBits().SetBitAt(uint64(bit), true)
-	a.SetSignature(sig)
-
-	return nil
-}
-
-// GetAll returns all attestations in the cache, excluding forkchoice attestations.
-func (c *AttestationCache) GetAll() []ethpb.Att {
-	c.RLock()
-	defer c.RUnlock()
-
-	var result []ethpb.Att
-	for _, group := range c.atts {
-		result = append(result, group.atts...)
-	}
-	return result
-}
-
-// Count returns the number of all attestations in the cache, excluding forkchoice attestations.
-func (c *AttestationCache) Count() int {
-	c.RLock()
-	defer c.RUnlock()
-
-	count := 0
-	for _, group := range c.atts {
-		count += len(group.atts)
-	}
-	return count
-}
-
-// DeleteCovered removes all attestations whose attestation bits are a proper subset of the passed-in attestation.
-func (c *AttestationCache) DeleteCovered(att ethpb.Att) error {
-	if att.IsNil() {
-		return nil
-	}
-
-	c.Lock()
-	defer c.Unlock()
-
-	id, err := attestation.NewId(att, attestation.Data)
-	if err != nil {
-		return errors.Wrapf(err, "could not create attestation ID")
-	}
-
-	group := c.atts[id]
-	if group == nil {
-		return nil
-	}
-
-	idx := 0
-	for _, a := range group.atts {
-		if covered, err := att.GetAggregationBits().Contains(a.GetAggregationBits()); err != nil {
-			return err
-		} else if !covered {
-			group.atts[idx] = a
-			idx++
-		}
-	}
-	group.atts = group.atts[:idx]
-
-	if len(group.atts) == 0 {
-		delete(c.atts, id)
-	}
-
-	return nil
-}
-
-// PruneBefore removes all attestations whose slot is earlier than the passed-in slot.
-func (c *AttestationCache) PruneBefore(slot primitives.Slot) uint64 {
-	c.Lock()
-	defer c.Unlock()
-
-	var pruneCount int
-	for id, group := range c.atts {
-		if group.slot < slot {
-			pruneCount += len(group.atts)
-			delete(c.atts, id)
-		}
-	}
-	return uint64(pruneCount)
-}
-
-// AggregateIsRedundant checks whether all attestation bits of the passed-in aggregate
-// are already included by any aggregate in the cache.
-func (c *AttestationCache) AggregateIsRedundant(att ethpb.Att) (bool, error) {
-	if att.IsNil() {
-		return true, nil
-	}
-
-	c.RLock()
-	defer c.RUnlock()
-
-	id, err := attestation.NewId(att, attestation.Data)
-	if err != nil {
-		return true, errors.Wrapf(err, "could not create attestation ID")
-	}
-
-	group := c.atts[id]
-	if group == nil {
-		return false, nil
-	}
-
-	for _, a := range group.atts {
-		if redundant, err := a.GetAggregationBits().Contains(att.GetAggregationBits()); err != nil {
-			return true, err
-		} else if redundant {
-			return true, nil
-		}
-	}
-
-	return false, nil
-}
-
-// SaveForkchoiceAttestations saves forkchoice attestations.
-func (c *AttestationCache) SaveForkchoiceAttestations(att []ethpb.Att) error {
-	return c.forkchoiceAtts.SaveMany(att)
-}
-
-// ForkchoiceAttestations returns all forkchoice attestations.
-func (c *AttestationCache) ForkchoiceAttestations() []ethpb.Att {
-	return c.forkchoiceAtts.GetAll()
-}
-
-// DeleteForkchoiceAttestation deletes a forkchoice attestation.
-func (c *AttestationCache) DeleteForkchoiceAttestation(att ethpb.Att) error {
-	return c.forkchoiceAtts.Delete(att)
-}
-
-// GetBySlotAndCommitteeIndex returns all attestations in the cache that match the provided slot
-// and committee index. Forkchoice attestations are not returned.
-//
-// NOTE: This function cannot be declared as a method on the AttestationCache because it is a generic function.
-func GetBySlotAndCommitteeIndex[T ethpb.Att](c *AttestationCache, slot primitives.Slot, committeeIndex primitives.CommitteeIndex) []T {
-	c.RLock()
-	defer c.RUnlock()
-
-	var result []T
-
-	for _, group := range c.atts {
-		if len(group.atts) > 0 {
-			// We can safely compare the first attestation because all attestations in a group
-			// must have the same slot and committee index, since they are under the same key.
-			a, ok := group.atts[0].(T)
-			if ok && a.GetData().Slot == slot && a.CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
-				for _, a := range group.atts {
-					a, ok := a.(T)
-					if ok {
-						result = append(result, a)
-					}
-				}
-			}
-		}
-	}
-
-	return result
-}
-
-func aggregateSig(agg ethpb.Att, att ethpb.Att) ([]byte, error) {
-	aggSig, err := bls.SignatureFromBytesNoValidation(agg.GetSignature())
-	if err != nil {
-		return nil, err
-	}
-	attSig, err := bls.SignatureFromBytesNoValidation(att.GetSignature())
-	if err != nil {
-		return nil, err
-	}
-	return bls.AggregateSignatures([]bls.Signature{aggSig, attSig}).Marshal(), nil
-}

beacon-chain/cache/attestation_data.go

@@ -15,24 +15,24 @@ type AttestationConsensusData struct {
 	Source   forkchoicetypes.Checkpoint
 }
 
-// AttestationDataCache stores cached results of AttestationData requests.
-type AttestationDataCache struct {
+// AttestationCache stores cached results of AttestationData requests.
+type AttestationCache struct {
 	a *AttestationConsensusData
 	sync.RWMutex
 }
 
-// NewAttestationDataCache creates a new instance of AttestationDataCache.
-func NewAttestationDataCache() *AttestationDataCache {
-	return &AttestationDataCache{}
+// NewAttestationCache creates a new instance of AttestationCache.
+func NewAttestationCache() *AttestationCache {
+	return &AttestationCache{}
 }
 
 // Get retrieves cached attestation data, recording a cache hit or miss. This method is lock free.
-func (c *AttestationDataCache) Get() *AttestationConsensusData {
+func (c *AttestationCache) Get() *AttestationConsensusData {
 	return c.a
 }
 
 // Put adds a response to the cache. This method is lock free.
-func (c *AttestationDataCache) Put(a *AttestationConsensusData) error {
+func (c *AttestationCache) Put(a *AttestationConsensusData) error {
 	if a == nil {
 		return errors.New("attestation cannot be nil")
 	}

beacon-chain/cache/attestation_data_test.go

@@ -9,7 +9,7 @@ import (
 )
 
 func TestAttestationCache_RoundTrip(t *testing.T) {
-	c := cache.NewAttestationDataCache()
+	c := cache.NewAttestationCache()
 
 	a := c.Get()
 	require.Nil(t, a)

beacon-chain/cache/attestation_test.go

@@ -1,353 +0,0 @@
-package cache
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/crypto/bls/blst"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-)
-
-func TestAdd(t *testing.T) {
-	k, err := blst.RandKey()
-	require.NoError(t, err)
-	sig := k.Sign([]byte{'X'})
-
-	t.Run("new ID", func(t *testing.T) {
-		t.Run("first ID ever", func(t *testing.T) {
-			c := NewAttestationCache()
-			ab := bitfield.NewBitlist(8)
-			ab.SetBitAt(0, true)
-			att := &ethpb.Attestation{
-				Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-				AggregationBits: ab,
-				Signature:       sig.Marshal(),
-			}
-			id, err := attestation.NewId(att, attestation.Data)
-			require.NoError(t, err)
-			require.NoError(t, c.Add(att))
-
-			require.Equal(t, 1, len(c.atts))
-			group, ok := c.atts[id]
-			require.Equal(t, true, ok)
-			assert.Equal(t, primitives.Slot(123), group.slot)
-			require.Equal(t, 1, len(group.atts))
-			assert.DeepEqual(t, group.atts[0], att)
-		})
-		t.Run("other ID exists", func(t *testing.T) {
-			c := NewAttestationCache()
-			ab := bitfield.NewBitlist(8)
-			ab.SetBitAt(0, true)
-			existingAtt := &ethpb.Attestation{
-				Data:            &ethpb.AttestationData{BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-				AggregationBits: ab,
-				Signature:       sig.Marshal(),
-			}
-			existingId, err := attestation.NewId(existingAtt, attestation.Data)
-			require.NoError(t, err)
-			c.atts[existingId] = &attGroup{slot: existingAtt.Data.Slot, atts: []ethpb.Att{existingAtt}}
-
-			att := &ethpb.Attestation{
-				Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-				AggregationBits: ab,
-				Signature:       sig.Marshal(),
-			}
-			id, err := attestation.NewId(att, attestation.Data)
-			require.NoError(t, err)
-			require.NoError(t, c.Add(att))
-
-			require.Equal(t, 2, len(c.atts))
-			group, ok := c.atts[id]
-			require.Equal(t, true, ok)
-			assert.Equal(t, primitives.Slot(123), group.slot)
-			require.Equal(t, 1, len(group.atts))
-			assert.DeepEqual(t, group.atts[0], att)
-		})
-	})
-	t.Run("aggregated", func(t *testing.T) {
-		c := NewAttestationCache()
-		existingAtt := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		id, err := attestation.NewId(existingAtt, attestation.Data)
-		require.NoError(t, err)
-		c.atts[id] = &attGroup{slot: existingAtt.Data.Slot, atts: []ethpb.Att{existingAtt}}
-
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-		att.AggregationBits.SetBitAt(1, true)
-		require.NoError(t, c.Add(att))
-
-		require.Equal(t, 1, len(c.atts))
-		group, ok := c.atts[id]
-		require.Equal(t, true, ok)
-		assert.Equal(t, primitives.Slot(123), group.slot)
-		require.Equal(t, 2, len(group.atts))
-		assert.DeepEqual(t, group.atts[0], existingAtt)
-		assert.DeepEqual(t, group.atts[1], att)
-	})
-	t.Run("unaggregated - existing bit", func(t *testing.T) {
-		c := NewAttestationCache()
-		existingAtt := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		existingAtt.AggregationBits.SetBitAt(0, true)
-		id, err := attestation.NewId(existingAtt, attestation.Data)
-		require.NoError(t, err)
-		c.atts[id] = &attGroup{slot: existingAtt.Data.Slot, atts: []ethpb.Att{existingAtt}}
-
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-		require.NoError(t, c.Add(att))
-
-		require.Equal(t, 1, len(c.atts))
-		group, ok := c.atts[id]
-		require.Equal(t, true, ok)
-		assert.Equal(t, primitives.Slot(123), group.slot)
-		require.Equal(t, 1, len(group.atts))
-		assert.DeepEqual(t, []int{0}, group.atts[0].GetAggregationBits().BitIndices())
-	})
-	t.Run("unaggregated - new bit", func(t *testing.T) {
-		c := NewAttestationCache()
-		existingAtt := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		existingAtt.AggregationBits.SetBitAt(0, true)
-		id, err := attestation.NewId(existingAtt, attestation.Data)
-		require.NoError(t, err)
-		c.atts[id] = &attGroup{slot: existingAtt.Data.Slot, atts: []ethpb.Att{existingAtt}}
-
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(1, true)
-		require.NoError(t, c.Add(att))
-
-		require.Equal(t, 1, len(c.atts))
-		group, ok := c.atts[id]
-		require.Equal(t, true, ok)
-		assert.Equal(t, primitives.Slot(123), group.slot)
-		require.Equal(t, 1, len(group.atts))
-		assert.DeepEqual(t, []int{0, 1}, group.atts[0].GetAggregationBits().BitIndices())
-	})
-}
-
-func TestGetAll(t *testing.T) {
-	c := NewAttestationCache()
-	c.atts[bytesutil.ToBytes32([]byte("id1"))] = &attGroup{atts: []ethpb.Att{&ethpb.Attestation{}, &ethpb.Attestation{}}}
-	c.atts[bytesutil.ToBytes32([]byte("id2"))] = &attGroup{atts: []ethpb.Att{&ethpb.Attestation{}}}
-
-	assert.Equal(t, 3, len(c.GetAll()))
-}
-
-func TestCount(t *testing.T) {
-	c := NewAttestationCache()
-	c.atts[bytesutil.ToBytes32([]byte("id1"))] = &attGroup{atts: []ethpb.Att{&ethpb.Attestation{}, &ethpb.Attestation{}}}
-	c.atts[bytesutil.ToBytes32([]byte("id2"))] = &attGroup{atts: []ethpb.Att{&ethpb.Attestation{}}}
-
-	assert.Equal(t, 3, c.Count())
-}
-
-func TestDeleteCovered(t *testing.T) {
-	k, err := blst.RandKey()
-	require.NoError(t, err)
-	sig := k.Sign([]byte{'X'})
-
-	att1 := &ethpb.Attestation{
-		Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-		AggregationBits: bitfield.NewBitlist(8),
-		Signature:       sig.Marshal(),
-	}
-	att1.AggregationBits.SetBitAt(0, true)
-
-	att2 := &ethpb.Attestation{
-		Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-		AggregationBits: bitfield.NewBitlist(8),
-		Signature:       sig.Marshal(),
-	}
-	att2.AggregationBits.SetBitAt(1, true)
-	att2.AggregationBits.SetBitAt(2, true)
-
-	att3 := &ethpb.Attestation{
-		Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-		AggregationBits: bitfield.NewBitlist(8),
-		Signature:       sig.Marshal(),
-	}
-	att3.AggregationBits.SetBitAt(1, true)
-	att3.AggregationBits.SetBitAt(3, true)
-	att3.AggregationBits.SetBitAt(4, true)
-
-	c := NewAttestationCache()
-	id, err := attestation.NewId(att1, attestation.Data)
-	require.NoError(t, err)
-	c.atts[id] = &attGroup{slot: att1.Data.Slot, atts: []ethpb.Att{att1, att2, att3}}
-
-	t.Run("no matching group", func(t *testing.T) {
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 456, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-		att.AggregationBits.SetBitAt(1, true)
-		att.AggregationBits.SetBitAt(2, true)
-		att.AggregationBits.SetBitAt(3, true)
-		att.AggregationBits.SetBitAt(4, true)
-		require.NoError(t, c.DeleteCovered(att))
-
-		assert.Equal(t, 3, len(c.atts[id].atts))
-	})
-	t.Run("covered atts deleted", func(t *testing.T) {
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-		att.AggregationBits.SetBitAt(1, true)
-		att.AggregationBits.SetBitAt(3, true)
-		att.AggregationBits.SetBitAt(4, true)
-		require.NoError(t, c.DeleteCovered(att))
-
-		atts := c.atts[id].atts
-		require.Equal(t, 1, len(atts))
-		assert.DeepEqual(t, att2, atts[0])
-	})
-	t.Run("last att in group deleted", func(t *testing.T) {
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-		att.AggregationBits.SetBitAt(1, true)
-		att.AggregationBits.SetBitAt(2, true)
-		att.AggregationBits.SetBitAt(3, true)
-		att.AggregationBits.SetBitAt(4, true)
-		require.NoError(t, c.DeleteCovered(att))
-
-		assert.Equal(t, 0, len(c.atts))
-	})
-}
-
-func TestPruneBefore(t *testing.T) {
-	c := NewAttestationCache()
-	c.atts[bytesutil.ToBytes32([]byte("id1"))] = &attGroup{slot: 1, atts: []ethpb.Att{&ethpb.Attestation{}, &ethpb.Attestation{}}}
-	c.atts[bytesutil.ToBytes32([]byte("id2"))] = &attGroup{slot: 3, atts: []ethpb.Att{&ethpb.Attestation{}}}
-	c.atts[bytesutil.ToBytes32([]byte("id3"))] = &attGroup{slot: 2, atts: []ethpb.Att{&ethpb.Attestation{}}}
-
-	count := c.PruneBefore(3)
-
-	require.Equal(t, 1, len(c.atts))
-	_, ok := c.atts[bytesutil.ToBytes32([]byte("id2"))]
-	assert.Equal(t, true, ok)
-	assert.Equal(t, uint64(3), count)
-}
-
-func TestAggregateIsRedundant(t *testing.T) {
-	k, err := blst.RandKey()
-	require.NoError(t, err)
-	sig := k.Sign([]byte{'X'})
-
-	c := NewAttestationCache()
-	existingAtt := &ethpb.Attestation{
-		Data:            &ethpb.AttestationData{Slot: 123, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-		AggregationBits: bitfield.NewBitlist(8),
-		Signature:       sig.Marshal(),
-	}
-	existingAtt.AggregationBits.SetBitAt(0, true)
-	existingAtt.AggregationBits.SetBitAt(1, true)
-	id, err := attestation.NewId(existingAtt, attestation.Data)
-	require.NoError(t, err)
-	c.atts[id] = &attGroup{slot: existingAtt.Data.Slot, atts: []ethpb.Att{existingAtt}}
-
-	t.Run("no matching group", func(t *testing.T) {
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: 456, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-
-		redundant, err := c.AggregateIsRedundant(att)
-		require.NoError(t, err)
-		assert.Equal(t, false, redundant)
-	})
-	t.Run("redundant", func(t *testing.T) {
-		att := &ethpb.Attestation{
-			Data:            &ethpb.AttestationData{Slot: existingAtt.Data.Slot, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-			AggregationBits: bitfield.NewBitlist(8),
-			Signature:       sig.Marshal(),
-		}
-		att.AggregationBits.SetBitAt(0, true)
-
-		redundant, err := c.AggregateIsRedundant(att)
-		require.NoError(t, err)
-		assert.Equal(t, true, redundant)
-	})
-	t.Run("not redundant", func(t *testing.T) {
-		t.Run("strictly better", func(t *testing.T) {
-			att := &ethpb.Attestation{
-				Data:            &ethpb.AttestationData{Slot: existingAtt.Data.Slot, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-				AggregationBits: bitfield.NewBitlist(8),
-				Signature:       sig.Marshal(),
-			}
-			att.AggregationBits.SetBitAt(0, true)
-			att.AggregationBits.SetBitAt(1, true)
-			att.AggregationBits.SetBitAt(2, true)
-
-			redundant, err := c.AggregateIsRedundant(att)
-			require.NoError(t, err)
-			assert.Equal(t, false, redundant)
-		})
-		t.Run("overlapping and new bits", func(t *testing.T) {
-			att := &ethpb.Attestation{
-				Data:            &ethpb.AttestationData{Slot: existingAtt.Data.Slot, BeaconBlockRoot: make([]byte, 32), Source: &ethpb.Checkpoint{Root: make([]byte, 32)}, Target: &ethpb.Checkpoint{Root: make([]byte, 32)}},
-				AggregationBits: bitfield.NewBitlist(8),
-				Signature:       sig.Marshal(),
-			}
-			att.AggregationBits.SetBitAt(0, true)
-			att.AggregationBits.SetBitAt(2, true)
-
-			redundant, err := c.AggregateIsRedundant(att)
-			require.NoError(t, err)
-			assert.Equal(t, false, redundant)
-		})
-	})
-}
-
-func TestGetBySlotAndCommitteeIndex(t *testing.T) {
-	c := NewAttestationCache()
-	c.atts[bytesutil.ToBytes32([]byte("id1"))] = &attGroup{slot: 1, atts: []ethpb.Att{&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1}}, &ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 1, CommitteeIndex: 1}}}}
-	c.atts[bytesutil.ToBytes32([]byte("id2"))] = &attGroup{slot: 2, atts: []ethpb.Att{&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 2}}}}
-	c.atts[bytesutil.ToBytes32([]byte("id3"))] = &attGroup{slot: 1, atts: []ethpb.Att{&ethpb.Attestation{Data: &ethpb.AttestationData{Slot: 2, CommitteeIndex: 2}}}}
-
-	// committeeIndex has to be small enough to fit in the bitvector
-	atts := GetBySlotAndCommitteeIndex[*ethpb.Attestation](c, 1, 1)
-	require.Equal(t, 2, len(atts))
-	assert.Equal(t, primitives.Slot(1), atts[0].Data.Slot)
-	assert.Equal(t, primitives.Slot(1), atts[1].Data.Slot)
-	assert.Equal(t, primitives.CommitteeIndex(1), atts[0].Data.CommitteeIndex)
-	assert.Equal(t, primitives.CommitteeIndex(1), atts[1].Data.CommitteeIndex)
-}

beacon-chain/core/altair/deposit.go

@@ -7,10 +7,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 // ProcessPreGenesisDeposits processes a deposit for the beacon state before chainstart.
@@ -37,7 +35,7 @@ func ProcessDeposits(
 	beaconState state.BeaconState,
 	deposits []*ethpb.Deposit,
 ) (state.BeaconState, error) {
-	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, err
 	}
@@ -46,7 +44,7 @@ func ProcessDeposits(
 		if deposit == nil || deposit.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, err = ProcessDeposit(beaconState, deposit, allSignaturesVerified)
+		beaconState, err = ProcessDeposit(beaconState, deposit, batchVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(deposit.Data.PublicKey))
 		}
@@ -81,7 +79,7 @@ func ProcessDeposits(
 //	  amount=deposit.data.amount,
 //	  signature=deposit.data.signature,
 //	 )
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
 	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
@@ -92,7 +90,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 		return nil, err
 	}
 
-	return ApplyDeposit(beaconState, deposit.Data, allSignaturesVerified)
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
 }
 
 // ApplyDeposit
@@ -115,13 +113,13 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 //	    # Increase balance by deposit amount
 //	    index = ValidatorIndex(validator_pubkeys.index(pubkey))
 //	    increase_balance(state, index, amount)
-func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSignaturesVerified bool) (state.BeaconState, error) {
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
 	pubKey := data.PublicKey
 	amount := data.Amount
 	withdrawalCredentials := data.WithdrawalCredentials
 	index, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
-		if !allSignaturesVerified {
+		if verifySignature {
 			valid, err := blocks.IsValidDepositSignature(data)
 			if err != nil {
 				return nil, err
@@ -130,7 +128,7 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSi
 				return beaconState, nil
 			}
 		}
-		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
+		if err := blocks.AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, amount); err != nil {
 			return nil, err
 		}
 	} else {
@@ -140,74 +138,3 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSi
 	}
 	return beaconState, nil
 }
-
-// AddValidatorToRegistry updates the beacon state with validator information
-// def add_validator_to_registry(state: BeaconState,
-//
-//	                          pubkey: BLSPubkey,
-//	                          withdrawal_credentials: Bytes32,
-//	                          amount: uint64) -> None:
-//	index = get_index_for_new_validator(state)
-//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
-//	set_or_append_list(state.validators, index, validator)
-//	set_or_append_list(state.balances, index, 0)
-//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
-//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
-//	set_or_append_list(state.inactivity_scores, index, uint64(0)) // New in Altair
-func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
-	val := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
-	if err := beaconState.AppendValidator(val); err != nil {
-		return err
-	}
-	if err := beaconState.AppendBalance(amount); err != nil {
-		return err
-	}
-
-	// only active in altair and only when it's a new validator (after append balance)
-	if beaconState.Version() >= version.Altair {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
-			return err
-		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// GetValidatorFromDeposit gets a new validator object with provided parameters
-//
-// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
-//
-//	effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
-//
-//	return Validator(
-//	    pubkey=pubkey,
-//	    withdrawal_credentials=withdrawal_credentials,
-//	    effective_balance=effective_balance,
-//	    slashed=False,
-//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
-//	    activation_epoch=FAR_FUTURE_EPOCH,
-//	    exit_epoch=FAR_FUTURE_EPOCH,
-//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
-//	)
-func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
-	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
-	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
-		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
-	}
-
-	return &ethpb.Validator{
-		PublicKey:                  pubKey,
-		WithdrawalCredentials:      withdrawalCredentials,
-		EffectiveBalance:           effectiveBalance,
-		Slashed:                    false,
-		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
-		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-	}
-}

beacon-chain/core/altair/deposit_test.go

@@ -199,7 +199,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := altair.ProcessDeposit(beaconState, dep[0], false)
+	newState, err := altair.ProcessDeposit(beaconState, dep[0], true)
 	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
 
 	if newState.Eth1DepositIndex() != 1 {

beacon-chain/core/altair/sync_committee.go

@@ -2,7 +2,6 @@ package altair
 
 import (
 	"context"
-	"encoding/binary"
 	goErrors "errors"
 	"fmt"
 	"time"
@@ -23,6 +22,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
+const maxRandomByte = uint64(1<<8 - 1)
+
 var (
 	ErrTooLate = errors.New("sync message is too late")
 )
@@ -90,22 +91,19 @@ func NextSyncCommittee(ctx context.Context, s state.BeaconState) (*ethpb.SyncCom
 //	"""
 //	epoch = Epoch(get_current_epoch(state) + 1)
 //
-//	MAX_RANDOM_VALUE = 2**16 - 1  # [Modified in Electra]
+//	MAX_RANDOM_BYTE = 2**8 - 1
 //	active_validator_indices = get_active_validator_indices(state, epoch)
 //	active_validator_count = uint64(len(active_validator_indices))
 //	seed = get_seed(state, epoch, DOMAIN_SYNC_COMMITTEE)
-//	i = uint64(0)
+//	i = 0
 //	sync_committee_indices: List[ValidatorIndex] = []
 //	while len(sync_committee_indices) < SYNC_COMMITTEE_SIZE:
 //	    shuffled_index = compute_shuffled_index(uint64(i % active_validator_count), active_validator_count, seed)
 //	    candidate_index = active_validator_indices[shuffled_index]
-//	    # [Modified in Electra]
-//	    random_bytes = hash(seed + uint_to_bytes(i // 16))
-//	    offset = i % 16 * 2
-//	    random_value = bytes_to_uint64(random_bytes[offset:offset + 2])
+//	    random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
 //	    effective_balance = state.validators[candidate_index].effective_balance
 //	    # [Modified in Electra:EIP7251]
-//	    if effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value:
+//	    if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte:
 //	        sync_committee_indices.append(candidate_index)
 //	    i += 1
 //	return sync_committee_indices
@@ -125,11 +123,12 @@ func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconState) ([]primi
 	cIndices := make([]primitives.ValidatorIndex, 0, syncCommitteeSize)
 	hashFunc := hash.CustomSHA256Hasher()
 
-	// Preallocate buffers to avoid repeated allocations
-	seedBuffer := make([]byte, len(seed)+8)
-	copy(seedBuffer, seed[:])
+	maxEB := cfg.MaxEffectiveBalanceElectra
+	if s.Version() < version.Electra {
+		maxEB = cfg.MaxEffectiveBalance
+	}
 
-	for i := primitives.ValidatorIndex(0); uint64(len(cIndices)) < syncCommitteeSize; i++ {
+	for i := primitives.ValidatorIndex(0); uint64(len(cIndices)) < params.BeaconConfig().SyncCommitteeSize; i++ {
 		if ctx.Err() != nil {
 			return nil, ctx.Err()
 		}
@@ -138,30 +137,18 @@ func NextSyncCommitteeIndices(ctx context.Context, s state.BeaconState) ([]primi
 		if err != nil {
 			return nil, err
 		}
+
+		b := append(seed[:], bytesutil.Bytes8(uint64(i.Div(32)))...)
+		randomByte := hashFunc(b)[i%32]
 		cIndex := indices[sIndex]
 		v, err := s.ValidatorAtIndexReadOnly(cIndex)
 		if err != nil {
 			return nil, err
 		}
+
 		effectiveBal := v.EffectiveBalance()
-
-		if s.Version() >= version.Electra {
-			// Use the preallocated seed buffer
-			binary.LittleEndian.PutUint64(seedBuffer[len(seed):], uint64(i/16))
-			randomByte := hashFunc(seedBuffer)
-			offset := (i % 16) * 2
-			randomValue := uint64(randomByte[offset]) | uint64(randomByte[offset+1])<<8
-
-			if effectiveBal*fieldparams.MaxRandomValueElectra >= cfg.MaxEffectiveBalanceElectra*randomValue {
-				cIndices = append(cIndices, cIndex)
-			}
-		} else {
-			// Use the preallocated seed buffer
-			binary.LittleEndian.PutUint64(seedBuffer[len(seed):], uint64(i/32))
-			randomByte := hashFunc(seedBuffer)[i%32]
-			if effectiveBal*fieldparams.MaxRandomByte >= cfg.MaxEffectiveBalance*uint64(randomByte) {
-				cIndices = append(cIndices, cIndex)
-			}
+		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
+			cIndices = append(cIndices, cIndex)
 		}
 	}
 

beacon-chain/core/blocks/attestation_test.go

@@ -448,7 +448,6 @@ func TestValidateIndexedAttestation_AboveMaxLength(t *testing.T) {
 			Target: &ethpb.Checkpoint{
 				Epoch: primitives.Epoch(i),
 			},
-			Source: &ethpb.Checkpoint{},
 		}
 	}
 
@@ -490,7 +489,6 @@ func TestValidateIndexedAttestation_BadAttestationsSignatureSet(t *testing.T) {
 				Target: &ethpb.Checkpoint{
 					Root: []byte{},
 				},
-				Source: &ethpb.Checkpoint{},
 			},
 			Signature:       sig.Marshal(),
 			AggregationBits: list,

beacon-chain/core/blocks/deposit.go

@@ -14,8 +14,78 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
+// AddValidatorToRegistry updates the beacon state with validator information
+// def add_validator_to_registry(state: BeaconState,
+//
+//	                          pubkey: BLSPubkey,
+//	                          withdrawal_credentials: Bytes32,
+//	                          amount: uint64) -> None:
+//	index = get_index_for_new_validator(state)
+//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials)
+//	set_or_append_list(state.validators, index, validator)
+//	set_or_append_list(state.balances, index, 0)
+//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000)) // New in Altair
+//	set_or_append_list(state.inactivity_scores, index, uint64(0)) // New in Altair
+func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
+	val := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
+	if err := beaconState.AppendValidator(val); err != nil {
+		return err
+	}
+	if err := beaconState.AppendBalance(amount); err != nil {
+		return err
+	}
+
+	// only active in altair and only when it's a new validator (after append balance)
+	if beaconState.Version() >= version.Altair {
+		if err := beaconState.AppendInactivityScore(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
+			return err
+		}
+		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// GetValidatorFromDeposit gets a new validator object with provided parameters
+//
+// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
+//
+//	effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, MAX_EFFECTIVE_BALANCE)
+//
+//	return Validator(
+//	    pubkey=pubkey,
+//	    withdrawal_credentials=withdrawal_credentials,
+//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
+//	    activation_epoch=FAR_FUTURE_EPOCH,
+//	    exit_epoch=FAR_FUTURE_EPOCH,
+//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
+//	    effective_balance=effective_balance,
+//	)
+func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) *ethpb.Validator {
+	effectiveBalance := amount - (amount % params.BeaconConfig().EffectiveBalanceIncrement)
+	if params.BeaconConfig().MaxEffectiveBalance < effectiveBalance {
+		effectiveBalance = params.BeaconConfig().MaxEffectiveBalance
+	}
+
+	return &ethpb.Validator{
+		PublicKey:                  pubKey,
+		WithdrawalCredentials:      withdrawalCredentials,
+		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
+		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
+		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
+		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
+		EffectiveBalance:           effectiveBalance,
+	}
+}
+
 // ActivateValidatorWithEffectiveBalance updates validator's effective balance, and if it's above MaxEffectiveBalance, validator becomes active in genesis.
 func ActivateValidatorWithEffectiveBalance(beaconState state.BeaconState, deposits []*ethpb.Deposit) (state.BeaconState, error) {
 	for _, d := range deposits {
@@ -55,11 +125,12 @@ func BatchVerifyDepositsSignatures(ctx context.Context, deposits []*ethpb.Deposi
 		return false, err
 	}
 
+	verified := false
 	if err := verifyDepositDataWithDomain(ctx, deposits, domain); err != nil {
 		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
-		return false, nil
+		verified = true
 	}
-	return true, nil
+	return verified, nil
 }
 
 // BatchVerifyPendingDepositsSignatures batch verifies pending deposit signatures.
@@ -70,11 +141,12 @@ func BatchVerifyPendingDepositsSignatures(ctx context.Context, deposits []*ethpb
 		return false, err
 	}
 
+	verified := false
 	if err := verifyPendingDepositDataWithDomain(ctx, deposits, domain); err != nil {
 		log.WithError(err).Debug("Failed to batch verify deposits signatures, will try individual verify")
-		return false, nil
+		verified = true
 	}
-	return true, nil
+	return verified, nil
 }
 
 // IsValidDepositSignature returns whether deposit_data is valid

beacon-chain/core/blocks/deposit_test.go

@@ -17,41 +17,6 @@ import (
 )
 
 func TestBatchVerifyDepositsSignatures_Ok(t *testing.T) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	require.NoError(t, err)
-	deposit := &ethpb.Deposit{
-		Data: &ethpb.Deposit_Data{
-			PublicKey:             sk.PublicKey().Marshal(),
-			WithdrawalCredentials: make([]byte, 32),
-			Amount:                3000,
-		},
-	}
-	sr, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
-		PublicKey:             deposit.Data.PublicKey,
-		WithdrawalCredentials: deposit.Data.WithdrawalCredentials,
-		Amount:                3000,
-	}, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	deposit.Data.Signature = sig.Marshal()
-	leaf, err := deposit.Data.HashTreeRoot()
-	require.NoError(t, err)
-	// We then create a merkle branch for the test.
-	depositTrie, err := trie.GenerateTrieFromItems([][]byte{leaf[:]}, params.BeaconConfig().DepositContractTreeDepth)
-	require.NoError(t, err, "Could not generate trie")
-	proof, err := depositTrie.MerkleProof(0)
-	require.NoError(t, err, "Could not generate proof")
-
-	deposit.Proof = proof
-	require.NoError(t, err)
-	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
-	require.NoError(t, err)
-	require.Equal(t, true, verified)
-}
-
-func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 	deposit := &ethpb.Deposit{
 		Data: &ethpb.Deposit_Data{
 			PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
@@ -69,9 +34,9 @@ func TestBatchVerifyDepositsSignatures_InvalidSignature(t *testing.T) {
 
 	deposit.Proof = proof
 	require.NoError(t, err)
-	verified, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
+	ok, err := blocks.BatchVerifyDepositsSignatures(context.Background(), []*ethpb.Deposit{deposit})
 	require.NoError(t, err)
-	require.Equal(t, false, verified)
+	require.Equal(t, true, ok)
 }
 
 func TestVerifyDeposit_MerkleBranchFailsVerification(t *testing.T) {
@@ -128,54 +93,3 @@ func TestIsValidDepositSignature_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, true, valid)
 }
-
-func TestBatchVerifyPendingDepositsSignatures_Ok(t *testing.T) {
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	domain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, nil, nil)
-	require.NoError(t, err)
-	pendingDeposit := &ethpb.PendingDeposit{
-		PublicKey:             sk.PublicKey().Marshal(),
-		WithdrawalCredentials: make([]byte, 32),
-		Amount:                3000,
-	}
-	sr, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
-		PublicKey:             pendingDeposit.PublicKey,
-		WithdrawalCredentials: pendingDeposit.WithdrawalCredentials,
-		Amount:                3000,
-	}, domain)
-	require.NoError(t, err)
-	sig := sk.Sign(sr[:])
-	pendingDeposit.Signature = sig.Marshal()
-
-	sk2, err := bls.RandKey()
-	require.NoError(t, err)
-	pendingDeposit2 := &ethpb.PendingDeposit{
-		PublicKey:             sk2.PublicKey().Marshal(),
-		WithdrawalCredentials: make([]byte, 32),
-		Amount:                4000,
-	}
-	sr2, err := signing.ComputeSigningRoot(&ethpb.DepositMessage{
-		PublicKey:             pendingDeposit2.PublicKey,
-		WithdrawalCredentials: pendingDeposit2.WithdrawalCredentials,
-		Amount:                4000,
-	}, domain)
-	require.NoError(t, err)
-	sig2 := sk2.Sign(sr2[:])
-	pendingDeposit2.Signature = sig2.Marshal()
-
-	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit, pendingDeposit2})
-	require.NoError(t, err)
-	require.Equal(t, true, verified)
-}
-
-func TestBatchVerifyPendingDepositsSignatures_InvalidSignature(t *testing.T) {
-	pendingDeposit := &ethpb.PendingDeposit{
-		PublicKey:             bytesutil.PadTo([]byte{1, 2, 3}, 48),
-		WithdrawalCredentials: make([]byte, 32),
-		Signature:             make([]byte, 96),
-	}
-	verified, err := blocks.BatchVerifyPendingDepositsSignatures(context.Background(), []*ethpb.PendingDeposit{pendingDeposit})
-	require.NoError(t, err)
-	require.Equal(t, false, verified)
-}

beacon-chain/core/blocks/exports_test.go

@@ -1,5 +1,5 @@
 package blocks
 
 var ProcessBLSToExecutionChange = processBLSToExecutionChange
-var ErrInvalidBLSPrefix = errInvalidBLSPrefix
+
 var VerifyBlobCommitmentCount = verifyBlobCommitmentCount

beacon-chain/core/blocks/payload.go

@@ -8,11 +8,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -62,9 +61,6 @@ func IsExecutionBlock(body interfaces.ReadOnlyBeaconBlockBody) (bool, error) {
 	if body == nil {
 		return false, errors.New("nil block body")
 	}
-	if body.Version() >= version.Capella {
-		return true, nil
-	}
 	payload, err := body.Execution()
 	switch {
 	case errors.Is(err, consensus_types.ErrUnsupportedField):
@@ -206,27 +202,27 @@ func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) err
 //	    block_hash=payload.block_hash,
 //	    transactions_root=hash_tree_root(payload.transactions),
 //	)
-func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) error {
+func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) (state.BeaconState, error) {
 	payload, err := body.Execution()
 	if err != nil {
-		return err
+		return nil, err
 	}
-	if err := verifyBlobCommitmentCount(st.Slot(), body); err != nil {
-		return err
+	if err := verifyBlobCommitmentCount(body); err != nil {
+		return nil, err
 	}
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
-		return err
+		return nil, err
 	}
 	if err := ValidatePayload(st, payload); err != nil {
-		return err
+		return nil, err
 	}
 	if err := st.SetLatestExecutionPayloadHeader(payload); err != nil {
-		return err
+		return nil, err
 	}
-	return nil
+	return st, nil
 }
 
-func verifyBlobCommitmentCount(slot primitives.Slot, body interfaces.ReadOnlyBeaconBlockBody) error {
+func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
 	if body.Version() < version.Deneb {
 		return nil
 	}
@@ -234,8 +230,7 @@ func verifyBlobCommitmentCount(slot primitives.Slot, body interfaces.ReadOnlyBea
 	if err != nil {
 		return err
 	}
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
-	if len(kzgs) > maxBlobsPerBlock {
+	if len(kzgs) > field_params.MaxBlobsPerBlock {
 		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
 	}
 	return nil

beacon-chain/core/blocks/payload_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -254,8 +253,7 @@ func Test_IsExecutionBlockCapella(t *testing.T) {
 	require.NoError(t, err)
 	got, err := blocks.IsExecutionBlock(wrappedBlock.Body())
 	require.NoError(t, err)
-	// #14614
-	require.Equal(t, true, got)
+	require.Equal(t, false, got)
 }
 
 func Test_IsExecutionEnabled(t *testing.T) {
@@ -589,7 +587,8 @@ func Test_ProcessPayload(t *testing.T) {
 				ExecutionPayload: tt.payload,
 			})
 			require.NoError(t, err)
-			if err := blocks.ProcessPayload(st, body); err != nil {
+			st, err := blocks.ProcessPayload(st, body)
+			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
@@ -620,7 +619,8 @@ func Test_ProcessPayloadCapella(t *testing.T) {
 		ExecutionPayload: payload,
 	})
 	require.NoError(t, err)
-	require.NoError(t, blocks.ProcessPayload(st, body))
+	_, err = blocks.ProcessPayload(st, body)
+	require.NoError(t, err)
 }
 
 func Test_ProcessPayload_Blinded(t *testing.T) {
@@ -677,7 +677,8 @@ func Test_ProcessPayload_Blinded(t *testing.T) {
 				ExecutionPayloadHeader: p,
 			})
 			require.NoError(t, err)
-			if err := blocks.ProcessPayload(st, body); err != nil {
+			st, err := blocks.ProcessPayload(st, body)
+			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
@@ -924,10 +925,10 @@ func TestVerifyBlobCommitmentCount(t *testing.T) {
 	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
 	rb, err := consensusblocks.NewBeaconBlock(b)
 	require.NoError(t, err)
-	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Slot(), rb.Body()))
+	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Body()))
 
-	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, params.BeaconConfig().MaxBlobsPerBlock(rb.Slot())+1)}}
+	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, fieldparams.MaxBlobsPerBlock+1)}}
 	rb, err = consensusblocks.NewBeaconBlock(b)
 	require.NoError(t, err)
-	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", params.BeaconConfig().MaxBlobsPerBlock(rb.Slot())+1), blocks.VerifyBlobCommitmentCount(rb.Slot(), rb.Body()))
+	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", fieldparams.MaxBlobsPerBlock+1), blocks.VerifyBlobCommitmentCount(rb.Body()))
 }

beacon-chain/core/blocks/withdrawals.go

@@ -100,11 +100,8 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 	if err != nil {
 		return nil, err
 	}
-	if val == nil {
-		return nil, errors.Wrap(errInvalidWithdrawalCredentials, "validator is nil") // This should not be possible.
-	}
 	cred := val.WithdrawalCredentials
-	if len(cred) < 2 || cred[0] != params.BeaconConfig().BLSWithdrawalPrefixByte {
+	if cred[0] != params.BeaconConfig().BLSWithdrawalPrefixByte {
 		return nil, errInvalidBLSPrefix
 	}
 
@@ -123,36 +120,35 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 //
 // Spec pseudocode definition:
 //
-// def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	def process_withdrawals(state: BeaconState, payload: ExecutionPayload) -> None:
+//	    expected_withdrawals, partial_withdrawals_count = get_expected_withdrawals(state)  # [Modified in Electra:EIP7251]
 //
-//	expected_withdrawals, processed_partial_withdrawals_count = get_expected_withdrawals(state) # [Modified in Electra:EIP7251]
+//	    assert len(payload.withdrawals) == len(expected_withdrawals)
 //
-//	assert len(payload.withdrawals) == len(expected_withdrawals)
+//	    for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
+//	        assert withdrawal == expected_withdrawal
+//	        decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
 //
-//	for expected_withdrawal, withdrawal in zip(expected_withdrawals, payload.withdrawals):
-//	     assert withdrawal == expected_withdrawal
-//	     decrease_balance(state, withdrawal.validator_index, withdrawal.amount)
+//	    # Update pending partial withdrawals [New in Electra:EIP7251]
+//	    state.pending_partial_withdrawals = state.pending_partial_withdrawals[partial_withdrawals_count:]
 //
-//	# Update pending partial withdrawals [New in Electra:EIP7251]
-//	state.pending_partial_withdrawals = state.pending_partial_withdrawals[processed_partial_withdrawals_count:]
+//	    # Update the next withdrawal index if this block contained withdrawals
+//	    if len(expected_withdrawals) != 0:
+//	        latest_withdrawal = expected_withdrawals[-1]
+//	        state.next_withdrawal_index = WithdrawalIndex(latest_withdrawal.index + 1)
 //
-//	# Update the next withdrawal index if this block contained withdrawals
-//	if len(expected_withdrawals) != 0:
-//	    latest_withdrawal = expected_withdrawals[-1]
-//	    state.next_withdrawal_index = WithdrawalIndex(latest_withdrawal.index + 1)
-//
-//	# Update the next validator index to start the next withdrawal sweep
-//	if len(expected_withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
-//	    # Next sweep starts after the latest withdrawal's validator index
-//	    next_validator_index = ValidatorIndex((expected_withdrawals[-1].validator_index + 1) % len(state.validators))
-//	    state.next_withdrawal_validator_index = next_validator_index
-//	else:
-//	    # Advance sweep by the max length of the sweep if there was not a full set of withdrawals
-//	    next_index = state.next_withdrawal_validator_index + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP
-//	    next_validator_index = ValidatorIndex(next_index % len(state.validators))
-//	    state.next_withdrawal_validator_index = next_validator_index
+//	    # Update the next validator index to start the next withdrawal sweep
+//	    if len(expected_withdrawals) == MAX_WITHDRAWALS_PER_PAYLOAD:
+//	        # Next sweep starts after the latest withdrawal's validator index
+//	        next_validator_index = ValidatorIndex((expected_withdrawals[-1].validator_index + 1) % len(state.validators))
+//	        state.next_withdrawal_validator_index = next_validator_index
+//	    else:
+//	        # Advance sweep by the max length of the sweep if there was not a full set of withdrawals
+//	        next_index = state.next_withdrawal_validator_index + MAX_VALIDATORS_PER_WITHDRAWALS_SWEEP
+//	        next_validator_index = ValidatorIndex(next_index % len(state.validators))
+//	        state.next_withdrawal_validator_index = next_validator_index
 func ProcessWithdrawals(st state.BeaconState, executionData interfaces.ExecutionData) (state.BeaconState, error) {
-	expectedWithdrawals, processedPartialWithdrawalsCount, err := st.ExpectedWithdrawals()
+	expectedWithdrawals, partialWithdrawalsCount, err := st.ExpectedWithdrawals()
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get expected withdrawals")
 	}
@@ -196,7 +192,7 @@ func ProcessWithdrawals(st state.BeaconState, executionData interfaces.Execution
 	}
 
 	if st.Version() >= version.Electra {
-		if err := st.DequeuePendingPartialWithdrawals(processedPartialWithdrawalsCount); err != nil {
+		if err := st.DequeuePartialWithdrawals(partialWithdrawalsCount); err != nil {
 			return nil, fmt.Errorf("unable to dequeue partial withdrawals from state: %w", err)
 		}
 	}

beacon-chain/core/blocks/withdrawals_test.go

@@ -113,42 +113,7 @@ func TestProcessBLSToExecutionChange(t *testing.T) {
 		require.NoError(t, err)
 		require.DeepEqual(t, digest[:], val.WithdrawalCredentials)
 	})
-	t.Run("nil validator does not panic", func(t *testing.T) {
-		priv, err := bls.RandKey()
-		require.NoError(t, err)
-		pubkey := priv.PublicKey().Marshal()
 
-		message := &ethpb.BLSToExecutionChange{
-			ToExecutionAddress: []byte{0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13},
-			ValidatorIndex:     0,
-			FromBlsPubkey:      pubkey,
-		}
-
-		registry := []*ethpb.Validator{
-			nil,
-		}
-		st, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-			Validators: registry,
-			Fork: &ethpb.Fork{
-				CurrentVersion:  params.BeaconConfig().GenesisForkVersion,
-				PreviousVersion: params.BeaconConfig().GenesisForkVersion,
-			},
-			Slot: params.BeaconConfig().SlotsPerEpoch * 5,
-		})
-		require.NoError(t, err)
-
-		signature, err := signing.ComputeDomainAndSign(st, time.CurrentEpoch(st), message, params.BeaconConfig().DomainBLSToExecutionChange, priv)
-		require.NoError(t, err)
-
-		signed := &ethpb.SignedBLSToExecutionChange{
-			Message:   message,
-			Signature: signature,
-		}
-		_, err = blocks.ValidateBLSToExecutionChange(st, signed)
-		// The state should return an empty validator, even when the validator object in the registry is
-		// nil. This error should return when the withdrawal credentials are invalid or too short.
-		require.ErrorIs(t, err, blocks.ErrInvalidBLSPrefix)
-	})
 	t.Run("non-existent validator", func(t *testing.T) {
 		priv, err := bls.RandKey()
 		require.NoError(t, err)

beacon-chain/core/electra/BUILD.bazel

@@ -38,10 +38,8 @@ go_library(
         "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -55,15 +53,14 @@ go_test(
         "deposit_fuzz_test.go",
         "deposits_test.go",
         "effective_balance_updates_test.go",
-        "export_test.go",
         "registry_updates_test.go",
         "transition_test.go",
         "upgrade_test.go",
         "validator_test.go",
         "withdrawals_test.go",
     ],
-    embed = [":go_default_library"],
     deps = [
+        ":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/electra/churn_test.go

@@ -20,7 +20,7 @@ func createValidatorsWithTotalActiveBalance(totalBal primitives.Gwei) []*eth.Val
 	vals := make([]*eth.Validator, num)
 	for i := range vals {
 		wd := make([]byte, 32)
-		wd[0] = params.BeaconConfig().CompoundingWithdrawalPrefixByte
+		wd[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 		wd[31] = byte(i)
 
 		vals[i] = &eth.Validator{

beacon-chain/core/electra/consolidations.go

@@ -5,7 +5,6 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -16,7 +15,6 @@ import (
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	log "github.com/sirupsen/logrus"
 )
 
 // ProcessPendingConsolidations implements the spec definition below. This method makes mutating
@@ -24,6 +22,7 @@ import (
 //
 // Spec definition:
 //
+//	            continue
 // def process_pending_consolidations(state: BeaconState) -> None:
 //
 //	next_epoch = Epoch(get_current_epoch(state) + 1)
@@ -37,7 +36,8 @@ import (
 //	        break
 //
 //	    # Calculate the consolidated balance
-//	    source_effective_balance = min(state.balances[pending_consolidation.source_index], source_validator.effective_balance)
+//	    max_effective_balance = get_max_effective_balance(source_validator)
+//	    source_effective_balance = min(state.balances[pending_consolidation.source_index], max_effective_balance)
 //
 //	    # Move active balance to target. Excess balance is withdrawable.
 //	    decrease_balance(state, pending_consolidation.source_index, source_effective_balance)
@@ -55,34 +55,38 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 
 	nextEpoch := slots.ToEpoch(st.Slot()) + 1
 
+	var nextPendingConsolidation uint64
 	pendingConsolidations, err := st.PendingConsolidations()
 	if err != nil {
 		return err
 	}
-	var nextPendingConsolidation uint64
+
 	for _, pc := range pendingConsolidations {
-		sourceValidator, err := st.ValidatorAtIndexReadOnly(pc.SourceIndex)
+		sourceValidator, err := st.ValidatorAtIndex(pc.SourceIndex)
 		if err != nil {
 			return err
 		}
-		if sourceValidator.Slashed() {
+		if sourceValidator.Slashed {
 			nextPendingConsolidation++
 			continue
 		}
-		if sourceValidator.WithdrawableEpoch() > nextEpoch {
+		if sourceValidator.WithdrawableEpoch > nextEpoch {
 			break
 		}
 
+		sourceEffectiveBalance := helpers.ValidatorMaxEffectiveBalance(sourceValidator)
 		validatorBalance, err := st.BalanceAtIndex(pc.SourceIndex)
 		if err != nil {
 			return err
 		}
-		b := min(validatorBalance, sourceValidator.EffectiveBalance())
+		if sourceEffectiveBalance > validatorBalance {
+			sourceEffectiveBalance = validatorBalance
+		}
 
-		if err := helpers.DecreaseBalance(st, pc.SourceIndex, b); err != nil {
+		if err := helpers.DecreaseBalance(st, pc.SourceIndex, sourceEffectiveBalance); err != nil {
 			return err
 		}
-		if err := helpers.IncreaseBalance(st, pc.TargetIndex, b); err != nil {
+		if err := helpers.IncreaseBalance(st, pc.TargetIndex, sourceEffectiveBalance); err != nil {
 			return err
 		}
 		nextPendingConsolidation++
@@ -140,8 +144,8 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    if not (has_correct_credential and is_correct_source_address):
 //	        return
 //
-//	    # Verify that target has compounding withdrawal credentials
-//	    if not has_compounding_withdrawal_credential(target_validator):
+//	    # Verify that target has execution withdrawal credentials
+//	    if not has_execution_withdrawal_credential(target_validator):
 //	        return
 //
 //	    # Verify the source and the target are active
@@ -156,13 +160,6 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
 //	        return
 //
-//	    # Verify the source has been active long enough
-//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
-//	        return
-//
-//	    # Verify the source has no pending withdrawals in the queue
-//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
-//	        return
 //	    # Initiate source validator exit and append pending consolidation
 //	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
 //	        state, source_validator.effective_balance
@@ -174,6 +171,10 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	        source_index=source_index,
 //	        target_index=target_index
 //	    ))
+//
+//	    # Churn any target excess active balance of target and raise its max
+//	    if has_eth1_withdrawal_credential(target_validator):
+//	        switch_to_compounding_validator(state, target_index)
 func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
 	if len(reqs) == 0 || st == nil {
 		return nil
@@ -187,16 +188,19 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if ctx.Err() != nil {
 			return fmt.Errorf("cannot process consolidation requests: %w", ctx.Err())
 		}
-		if IsValidSwitchToCompoundingRequest(st, cr) {
+		canSwitch, err := IsValidSwitchToCompoundingRequest(ctx, st, cr)
+		if err != nil {
+			return fmt.Errorf("failed to validate consolidation request: %w", err)
+		}
+		if canSwitch {
 			srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(cr.SourcePubkey))
 			if !ok {
-				log.Error("failed to find source validator index")
-				continue
+				return errors.New("could not find validator in registry")
 			}
 			if err := SwitchToCompoundingValidator(st, srcIdx); err != nil {
-				log.WithError(err).Error("failed to switch to compounding validator")
+				return fmt.Errorf("failed to switch to compounding validator: %w", err)
 			}
-			continue
+			return nil
 		}
 		sourcePubkey := bytesutil.ToBytes48(cr.SourcePubkey)
 		targetPubkey := bytesutil.ToBytes48(cr.TargetPubkey)
@@ -248,7 +252,7 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		}
 
 		// Target validator must have their withdrawal credentials set appropriately.
-		if !helpers.HasCompoundingWithdrawalCredential(tgtV) {
+		if !helpers.HasExecutionWithdrawalCredentials(tgtV) {
 			continue
 		}
 
@@ -261,28 +265,10 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 			continue
 		}
 
-		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
-		if overflow {
-			log.Error("Overflow when adding activation epoch and shard committee period")
-			continue
-		}
-		if uint64(curEpoch) < e {
-			continue
-		}
-		bal, err := st.PendingBalanceToWithdraw(srcIdx)
-		if err != nil {
-			log.WithError(err).Error("failed to fetch pending balance to withdraw")
-			continue
-		}
-		if bal > 0 {
-			continue
-		}
-
 		// Initiate the exit of the source validator.
 		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
 		if err != nil {
-			log.WithError(err).Error("failed to compute consolidation epoch")
-			continue
+			return fmt.Errorf("failed to compute consolidaiton epoch: %w", err)
 		}
 		srcV.ExitEpoch = exitEpoch
 		srcV.WithdrawableEpoch = exitEpoch + minValWithdrawDelay
@@ -293,6 +279,12 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
 			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
 		}
+
+		if helpers.HasETH1WithdrawalCredential(tgtV) {
+			if err := SwitchToCompoundingValidator(st, tgtIdx); err != nil {
+				return fmt.Errorf("failed to switch to compounding validator: %w", err)
+			}
+		}
 	}
 
 	return nil
@@ -334,47 +326,47 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 //	if not is_active_validator(source_validator, current_epoch):
 //	    return False
 //
-//	# Verify exit for source has not been initiated
+//	# Verify exit for source have not been initiated
 //	if source_validator.exit_epoch != FAR_FUTURE_EPOCH:
 //	    return False
 //
 //	return True
-func IsValidSwitchToCompoundingRequest(st state.BeaconState, req *enginev1.ConsolidationRequest) bool {
+func IsValidSwitchToCompoundingRequest(ctx context.Context, st state.BeaconState, req *enginev1.ConsolidationRequest) (bool, error) {
 	if req.SourcePubkey == nil || req.TargetPubkey == nil {
-		return false
+		return false, errors.New("nil source or target pubkey")
 	}
 
-	if !bytes.Equal(req.SourcePubkey, req.TargetPubkey) {
-		return false
+	sourcePubKey := bytesutil.ToBytes48(req.SourcePubkey)
+	targetPubKey := bytesutil.ToBytes48(req.TargetPubkey)
+	if sourcePubKey != targetPubKey {
+		return false, nil
 	}
 
-	srcIdx, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.SourcePubkey))
+	srcIdx, ok := st.ValidatorIndexByPubkey(sourcePubKey)
 	if !ok {
-		return false
+		return false, nil
 	}
-	// As per the consensus specification, this error is not considered an assertion.
-	// Therefore, if the source_pubkey is not found in validator_pubkeys, we simply return false.
-	srcV, err := st.ValidatorAtIndexReadOnly(srcIdx)
+	srcV, err := st.ValidatorAtIndex(srcIdx)
 	if err != nil {
-		return false
+		return false, err
 	}
 	sourceAddress := req.SourceAddress
-	withdrawalCreds := srcV.GetWithdrawalCredentials()
+	withdrawalCreds := srcV.WithdrawalCredentials
 	if len(withdrawalCreds) != 32 || len(sourceAddress) != 20 || !bytes.HasSuffix(withdrawalCreds, sourceAddress) {
-		return false
+		return false, nil
 	}
 
 	if !helpers.HasETH1WithdrawalCredential(srcV) {
-		return false
+		return false, nil
 	}
 
 	curEpoch := slots.ToEpoch(st.Slot())
-	if !helpers.IsActiveValidatorUsingTrie(srcV, curEpoch) {
-		return false
+	if !helpers.IsActiveValidator(srcV, curEpoch) {
+		return false, nil
 	}
 
-	if srcV.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
-		return false
+	if srcV.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+		return false, nil
 	}
-	return true
+	return true, nil
 }

beacon-chain/core/electra/consolidations_test.go

@@ -46,7 +46,6 @@ func TestProcessPendingConsolidations(t *testing.T) {
 					Validators: []*eth.Validator{
 						{
 							WithdrawalCredentials: []byte{0x01, 0xFF},
-							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
 						},
 						{
 							WithdrawalCredentials: []byte{0x01, 0xAB},
@@ -82,10 +81,10 @@ func TestProcessPendingConsolidations(t *testing.T) {
 				require.NoError(t, err)
 				require.Equal(t, uint64(0), num)
 
-				// v1 withdrawal credentials should not be updated.
+				// v1 is switched to compounding validator.
 				v1, err := st.ValidatorAtIndex(1)
 				require.NoError(t, err)
-				require.Equal(t, params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, v1.WithdrawalCredentials[0])
+				require.Equal(t, params.BeaconConfig().CompoundingWithdrawalPrefixByte, v1.WithdrawalCredentials[0])
 			},
 			wantErr: false,
 		},
@@ -214,22 +213,15 @@ func TestProcessConsolidationRequests(t *testing.T) {
 			name: "one valid request",
 			state: func() state.BeaconState {
 				st := &eth.BeaconStateElectra{
-					Slot:       params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
 					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
 				}
 				// Validator scenario setup. See comments in reqs section.
 				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
-				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(1)
+				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(0)
 				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
 				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
 				st.Validators[13].ExitEpoch = 10
 				st.Validators[16].ExitEpoch = 10
-				st.PendingPartialWithdrawals = []*eth.PendingPartialWithdrawal{
-					{
-						Index:  17,
-						Amount: 100,
-					},
-				}
 				s, err := state_native.InitializeFromProtoElectra(st)
 				require.NoError(t, err)
 				return s
@@ -247,7 +239,7 @@ func TestProcessConsolidationRequests(t *testing.T) {
 					SourcePubkey:  []byte("val_5"),
 					TargetPubkey:  []byte("val_6"),
 				},
-				// Target does not have their withdrawal credentials set appropriately. (Using eth1 address prefix)
+				// Target does not have their withdrawal credentials set appropriately.
 				{
 					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
 					SourcePubkey:  []byte("val_7"),
@@ -295,12 +287,6 @@ func TestProcessConsolidationRequests(t *testing.T) {
 					SourcePubkey:  []byte("val_0"),
 					TargetPubkey:  []byte("val_0"),
 				},
-				// Has pending partial withdrawal
-				{
-					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
-					SourcePubkey:  []byte("val_17"),
-					TargetPubkey:  []byte("val_1"),
-				},
 				// Valid consolidation request. This should be last to ensure invalid requests do
 				// not end the processing early.
 				{
@@ -361,7 +347,6 @@ func TestProcessConsolidationRequests(t *testing.T) {
 			name: "pending consolidations limit reached during processing",
 			state: func() state.BeaconState {
 				st := &eth.BeaconStateElectra{
-					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
 					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
 					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
 				}
@@ -414,45 +399,51 @@ func TestProcessConsolidationRequests(t *testing.T) {
 }
 
 func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
+	ctx := context.Background()
 	st, _ := util.DeterministicGenesisStateElectra(t, 1)
 	t.Run("nil source pubkey", func(t *testing.T) {
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			SourcePubkey: nil,
 			TargetPubkey: []byte{'a'},
 		})
+		require.ErrorContains(t, "nil source or target pubkey", err)
 		require.Equal(t, false, ok)
 	})
 	t.Run("nil target pubkey", func(t *testing.T) {
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			TargetPubkey: nil,
 			SourcePubkey: []byte{'a'},
 		})
+		require.ErrorContains(t, "nil source or target pubkey", err)
 		require.Equal(t, false, ok)
 	})
 	t.Run("different source and target pubkey", func(t *testing.T) {
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			TargetPubkey: []byte{'a'},
 			SourcePubkey: []byte{'b'},
 		})
+		require.NoError(t, err)
 		require.Equal(t, false, ok)
 	})
 	t.Run("source validator not found in state", func(t *testing.T) {
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			SourceAddress: make([]byte, 20),
 			TargetPubkey:  []byte{'a'},
 			SourcePubkey:  []byte{'a'},
 		})
+		require.NoError(t, err)
 		require.Equal(t, false, ok)
 	})
 	t.Run("incorrect source address", func(t *testing.T) {
 		v, err := st.ValidatorAtIndex(0)
 		require.NoError(t, err)
 		pubkey := v.PublicKey
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			SourceAddress: make([]byte, 20),
 			TargetPubkey:  pubkey,
 			SourcePubkey:  pubkey,
 		})
+		require.NoError(t, err)
 		require.Equal(t, false, ok)
 	})
 	t.Run("incorrect eth1 withdrawal credential", func(t *testing.T) {
@@ -460,11 +451,12 @@ func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
 		require.NoError(t, err)
 		pubkey := v.PublicKey
 		wc := v.WithdrawalCredentials
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			SourceAddress: wc[12:],
 			TargetPubkey:  pubkey,
 			SourcePubkey:  pubkey,
 		})
+		require.NoError(t, err)
 		require.Equal(t, false, ok)
 	})
 	t.Run("is valid compounding request", func(t *testing.T) {
@@ -474,11 +466,12 @@ func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
 		wc := v.WithdrawalCredentials
 		v.WithdrawalCredentials[0] = 1
 		require.NoError(t, st.UpdateValidatorAtIndex(0, v))
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			SourceAddress: wc[12:],
 			TargetPubkey:  pubkey,
 			SourcePubkey:  pubkey,
 		})
+		require.NoError(t, err)
 		require.Equal(t, true, ok)
 	})
 	t.Run("already has an exit epoch", func(t *testing.T) {
@@ -488,11 +481,12 @@ func TestIsValidSwitchToCompoundingRequest(t *testing.T) {
 		wc := v.WithdrawalCredentials
 		v.ExitEpoch = 100
 		require.NoError(t, st.UpdateValidatorAtIndex(0, v))
-		ok := electra.IsValidSwitchToCompoundingRequest(st, &enginev1.ConsolidationRequest{
+		ok, err := electra.IsValidSwitchToCompoundingRequest(ctx, st, &enginev1.ConsolidationRequest{
 			SourceAddress: wc[12:],
 			TargetPubkey:  pubkey,
 			SourcePubkey:  pubkey,
 		})
+		require.NoError(t, err)
 		require.Equal(t, false, ok)
 	})
 }

beacon-chain/core/electra/deposits.go

@@ -8,7 +8,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	state_native "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/contracts/deposit"
@@ -17,7 +16,6 @@ import (
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	log "github.com/sirupsen/logrus"
 )
@@ -39,7 +37,7 @@ func ProcessDeposits(
 	defer span.End()
 	// Attempt to verify all deposit signatures at once, if this fails then fall back to processing
 	// individual deposits with signature verification enabled.
-	allSignaturesVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
+	batchVerified, err := blocks.BatchVerifyDepositsSignatures(ctx, deposits)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not verify deposit signatures in batch")
 	}
@@ -48,7 +46,7 @@ func ProcessDeposits(
 		if d == nil || d.Data == nil {
 			return nil, errors.New("got a nil deposit in block")
 		}
-		beaconState, err = ProcessDeposit(beaconState, d, allSignaturesVerified)
+		beaconState, err = ProcessDeposit(beaconState, d, batchVerified)
 		if err != nil {
 			return nil, errors.Wrapf(err, "could not process deposit from %#x", bytesutil.Trunc(d.Data.PublicKey))
 		}
@@ -83,7 +81,7 @@ func ProcessDeposits(
 //	  amount=deposit.data.amount,
 //	  signature=deposit.data.signature,
 //	 )
-func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSignaturesVerified bool) (state.BeaconState, error) {
+func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, verifySignature bool) (state.BeaconState, error) {
 	if err := blocks.VerifyDeposit(beaconState, deposit); err != nil {
 		if deposit == nil || deposit.Data == nil {
 			return nil, err
@@ -93,12 +91,10 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 	if err := beaconState.SetEth1DepositIndex(beaconState.Eth1DepositIndex() + 1); err != nil {
 		return nil, err
 	}
-	return ApplyDeposit(beaconState, deposit.Data, allSignaturesVerified)
+	return ApplyDeposit(beaconState, deposit.Data, verifySignature)
 }
 
-// ApplyDeposit adds the incoming deposit as a pending deposit on the state
-//
-// Spec pseudocode definition:
+// ApplyDeposit
 // def apply_deposit(state: BeaconState,
 //
 //	              pubkey: BLSPubkey,
@@ -116,7 +112,7 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 //	            withdrawal_credentials=withdrawal_credentials,
 //	            amount=amount,
 //	            signature=signature,
-//	            slot=GENESIS_SLOT,  # Use GENESIS_SLOT to distinguish from a pending deposit request
+//	            slot=GENESIS_SLOT,
 //	        ))
 //	else:
 //	    # Increase balance by deposit amount
@@ -126,16 +122,16 @@ func ProcessDeposit(beaconState state.BeaconState, deposit *ethpb.Deposit, allSi
 //	        withdrawal_credentials=withdrawal_credentials,
 //	        amount=amount,
 //	        signature=signature,
-//	        slot=GENESIS_SLOT  # Use GENESIS_SLOT to distinguish from a pending deposit request
+//	        slot=GENESIS_SLOT
 //	    ))
-func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSignaturesVerified bool) (state.BeaconState, error) {
+func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, verifySignature bool) (state.BeaconState, error) {
 	pubKey := data.PublicKey
 	amount := data.Amount
 	withdrawalCredentials := data.WithdrawalCredentials
 	signature := data.Signature
 	_, ok := beaconState.ValidatorIndexByPubkey(bytesutil.ToBytes48(pubKey))
 	if !ok {
-		if !allSignaturesVerified {
+		if verifySignature {
 			valid, err := IsValidDepositSignature(data)
 			if err != nil {
 				return nil, errors.Wrap(err, "could not verify deposit signature")
@@ -145,7 +141,7 @@ func ApplyDeposit(beaconState state.BeaconState, data *ethpb.Deposit_Data, allSi
 			}
 		}
 
-		if err := AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, 0); err != nil { // # [Modified in Electra:EIP7251]
+		if err := blocks.AddValidatorToRegistry(beaconState, pubKey, withdrawalCredentials, 0); err != nil { // # [Modified in Electra:EIP7251]
 			return nil, errors.Wrap(err, "could not add validator to registry")
 		}
 	}
@@ -195,69 +191,69 @@ func verifyDepositDataSigningRoot(obj *ethpb.Deposit_Data, domain []byte) error
 //
 // Spec definition:
 //
-// def process_pending_deposits(state: BeaconState) -> None:
+//		def process_pending_deposits(state: BeaconState) -> None:
+//	   available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
+//	   processed_amount = 0
+//	   next_deposit_index = 0
+//	   deposits_to_postpone = []
+//	   is_churn_limit_reached = False
+//	   finalized_slot = compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)
 //
-//	next_epoch = Epoch(get_current_epoch(state) + 1)
-//	available_for_processing = state.deposit_balance_to_consume + get_activation_exit_churn_limit(state)
-//	processed_amount = 0
-//	next_deposit_index = 0
-//	deposits_to_postpone = []
-//	is_churn_limit_reached = False
-//	finalized_slot = compute_start_slot_at_epoch(state.finalized_checkpoint.epoch)
+//	   for deposit in state.pending_deposits:
+//	       # Do not process deposit requests if Eth1 bridge deposits are not yet applied.
+//	       if (
+//	           # Is deposit request
+//	           deposit.slot > GENESIS_SLOT and
+//	           # There are pending Eth1 bridge deposits
+//	           state.eth1_deposit_index < state.deposit_requests_start_index
+//	       ):
+//	           break
 //
-//	for deposit in state.pending_deposits:
-//	    # Do not process deposit requests if Eth1 bridge deposits are not yet applied.
-//	    if (
-//	        # Is deposit request
-//	        deposit.slot > GENESIS_SLOT and
-//	        # There are pending Eth1 bridge deposits
-//	        state.eth1_deposit_index < state.deposit_requests_start_index
-//	    ):
-//	        break
+//	       # Check if deposit has been finalized, otherwise, stop processing.
+//	       if deposit.slot > finalized_slot:
+//	           break
 //
-//	    # Check if deposit has been finalized, otherwise, stop processing.
-//	    if deposit.slot > finalized_slot:
-//	        break
+//	       # Check if number of processed deposits has not reached the limit, otherwise, stop processing.
+//	       if next_deposit_index >= MAX_PENDING_DEPOSITS_PER_EPOCH:
+//	           break
 //
-//	    # Check if number of processed deposits has not reached the limit, otherwise, stop processing.
-//	    if next_deposit_index >= MAX_PENDING_DEPOSITS_PER_EPOCH:
-//	        break
+//	       # Read validator state
+//	       is_validator_exited = False
+//	       is_validator_withdrawn = False
+//	       validator_pubkeys = [v.pubkey for v in state.validators]
+//	       if deposit.pubkey in validator_pubkeys:
+//	           validator = state.validators[ValidatorIndex(validator_pubkeys.index(deposit.pubkey))]
+//	           is_validator_exited = validator.exit_epoch < FAR_FUTURE_EPOCH
+//	           is_validator_withdrawn = validator.withdrawable_epoch < get_current_epoch(state)
 //
-//	    # Read validator state
-//	    is_validator_exited = False
-//	    is_validator_withdrawn = False
-//	    validator_pubkeys = [v.pubkey for v in state.validators]
-//	    if deposit.pubkey in validator_pubkeys:
-//	        validator = state.validators[ValidatorIndex(validator_pubkeys.index(deposit.pubkey))]
-//	        is_validator_exited = validator.exit_epoch < FAR_FUTURE_EPOCH
-//	        is_validator_withdrawn = validator.withdrawable_epoch < next_epoch
+//	       if is_validator_withdrawn:
+//	           # Deposited balance will never become active. Increase balance but do not consume churn
+//	           apply_pending_deposit(state, deposit)
+//	       elif is_validator_exited:
+//	           # Validator is exiting, postpone the deposit until after withdrawable epoch
+//	           deposits_to_postpone.append(deposit)
+//	       else:
+//	           # Check if deposit fits in the churn, otherwise, do no more deposit processing in this epoch.
+//	           is_churn_limit_reached = processed_amount + deposit.amount > available_for_processing
+//	           if is_churn_limit_reached:
+//	               break
 //
-//	    if is_validator_withdrawn:
-//	        # Deposited balance will never become active. Increase balance but do not consume churn
-//	        apply_pending_deposit(state, deposit)
-//	    elif is_validator_exited:
-//	        # Validator is exiting, postpone the deposit until after withdrawable epoch
-//	        deposits_to_postpone.append(deposit)
-//	    else:
-//	        # Check if deposit fits in the churn, otherwise, do no more deposit processing in this epoch.
-//	        is_churn_limit_reached = processed_amount + deposit.amount > available_for_processing
-//	        if is_churn_limit_reached:
-//	            break
+//	           # Consume churn and apply deposit.
+//	           processed_amount += deposit.amount
+//	           apply_pending_deposit(state, deposit)
 //
-//	        # Consume churn and apply deposit.
-//	        processed_amount += deposit.amount
-//	        apply_pending_deposit(state, deposit)
+//	       # Regardless of how the deposit was handled, we move on in the queue.
+//	       next_deposit_index += 1
 //
-//	    # Regardless of how the deposit was handled, we move on in the queue.
-//	    next_deposit_index += 1
+//	   state.pending_deposits = state.pending_deposits[next_deposit_index:]
 //
-//	state.pending_deposits = state.pending_deposits[next_deposit_index:] + deposits_to_postpone
+//	   # Accumulate churn only if the churn limit has been hit.
+//	   if is_churn_limit_reached:
+//	       state.deposit_balance_to_consume = available_for_processing - processed_amount
+//	   else:
+//	       state.deposit_balance_to_consume = Gwei(0)
 //
-//	# Accumulate churn only if the churn limit has been hit.
-//	if is_churn_limit_reached:
-//	    state.deposit_balance_to_consume = available_for_processing - processed_amount
-//	else:
-//	    state.deposit_balance_to_consume = Gwei(0)
+//	   state.pending_deposits += deposits_to_postpone
 func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBalance primitives.Gwei) error {
 	_, span := trace.StartSpan(ctx, "electra.ProcessPendingDeposits")
 	defer span.End()
@@ -266,36 +262,36 @@ func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBal
 		return errors.New("nil state")
 	}
 
-	// constants & initializations
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
-	processedAmount := uint64(0)
-	nextDepositIndex := uint64(0)
-	isChurnLimitReached := false
-
-	var pendingDepositsToBatchVerify []*ethpb.PendingDeposit
-	var pendingDepositsToPostpone []*eth.PendingDeposit
-
 	depBalToConsume, err := st.DepositBalanceToConsume()
 	if err != nil {
-		return errors.Wrap(err, "could not get deposit balance to consume")
+		return err
 	}
 	availableForProcessing := depBalToConsume + helpers.ActivationExitChurnLimit(activeBalance)
+	processedAmount := uint64(0)
+	nextDepositIndex := uint64(0)
+	var depositsToPostpone []*eth.PendingDeposit
 
+	deposits, err := st.PendingDeposits()
+	if err != nil {
+		return err
+	}
+	isChurnLimitReached := false
 	finalizedSlot, err := slots.EpochStart(st.FinalizedCheckpoint().Epoch)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized slot")
 	}
+	// constants
+	ffe := params.BeaconConfig().FarFutureEpoch
+	curEpoch := slots.ToEpoch(st.Slot())
 
-	startIndex, err := st.DepositRequestsStartIndex()
-	if err != nil {
-		return errors.Wrap(err, "could not get starting pendingDeposit index")
-	}
+	// Slice to collect deposits needing signature verification
+	var depositsToVerify []*ethpb.PendingDeposit
+	for _, pendingDeposit := range deposits {
+		startIndex, err := st.DepositRequestsStartIndex()
+		if err != nil {
+			return errors.Wrap(err, "could not get starting pendingDeposit index")
+		}
 
-	pendingDeposits, err := st.PendingDeposits()
-	if err != nil {
-		return err
-	}
-	for _, pendingDeposit := range pendingDeposits {
 		// Do not process pendingDeposit requests if Eth1 bridge deposits are not yet applied.
 		if pendingDeposit.Slot > params.BeaconConfig().GenesisSlot && st.Eth1DepositIndex() < startIndex {
 			break
@@ -319,32 +315,33 @@ func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBal
 			if err != nil {
 				return errors.Wrap(err, "could not get validator")
 			}
-			isValidatorExited = val.ExitEpoch() < params.BeaconConfig().FarFutureEpoch
-			isValidatorWithdrawn = val.WithdrawableEpoch() < nextEpoch
+			isValidatorExited = val.ExitEpoch() < ffe
+			isValidatorWithdrawn = val.WithdrawableEpoch() < curEpoch
 		}
 
 		if isValidatorWithdrawn {
-			// note: the validator will never be active, just increase the balance
-			if err := helpers.IncreaseBalance(st, index, pendingDeposit.Amount); err != nil {
-				return errors.Wrap(err, "could not increase balance")
+			// Deposited balance will never become active. Increase balance but do not consume churn
+			if err := ApplyPendingDeposit(ctx, st, pendingDeposit, true); err != nil {
+				return errors.Wrap(err, "could not apply pending deposit")
 			}
 		} else if isValidatorExited {
-			pendingDepositsToPostpone = append(pendingDepositsToPostpone, pendingDeposit)
+			// Validator is exiting, postpone the pendingDeposit until after withdrawable epoch
+			depositsToPostpone = append(depositsToPostpone, pendingDeposit)
 		} else {
+			// Check if pendingDeposit fits in the churn, otherwise, do no more pendingDeposit processing in this epoch.
 			isChurnLimitReached = primitives.Gwei(processedAmount+pendingDeposit.Amount) > availableForProcessing
-			if isChurnLimitReached {
+			if isChurnLimitReached { // Is churn limit reached?
 				break
 			}
+			// Consume churn and apply pendingDeposit.
 			processedAmount += pendingDeposit.Amount
-
-			// note: the following code deviates from the spec in order to perform batch signature verification
 			if found {
-				if err := helpers.IncreaseBalance(st, index, pendingDeposit.Amount); err != nil {
-					return errors.Wrap(err, "could not increase balance")
+				if err := ApplyPendingDeposit(ctx, st, pendingDeposit, true); err != nil {
+					return errors.Wrap(err, "could not apply pending deposit")
 				}
 			} else {
 				// Collect deposit for batch signature verification
-				pendingDepositsToBatchVerify = append(pendingDepositsToBatchVerify, pendingDeposit)
+				depositsToVerify = append(depositsToVerify, pendingDeposit)
 			}
 		}
 
@@ -352,9 +349,19 @@ func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBal
 		nextDepositIndex++
 	}
 
-	// Perform batch signature verification on pending deposits that require validator registration
-	if err = batchProcessNewPendingDeposits(ctx, st, pendingDepositsToBatchVerify); err != nil {
-		return errors.Wrap(err, "could not process pending deposits with new public keys")
+	// Perform batch signature verification on deposits on unfound validators
+	if len(depositsToVerify) > 0 {
+		batchVerified, err := blocks.BatchVerifyPendingDepositsSignatures(ctx, depositsToVerify)
+		if err != nil {
+			return errors.Wrap(err, "could not batch verify deposit signatures")
+		}
+
+		// Apply deposits that passed verification
+		for _, dep := range depositsToVerify {
+			if err := ApplyPendingDeposit(ctx, st, dep, batchVerified); err != nil {
+				return errors.Wrap(err, "could not apply pending deposit")
+			}
+		}
 	}
 
 	// Combined operation:
@@ -362,8 +369,8 @@ func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBal
 	// - state.pending_deposits += deposits_to_postpone
 	// However, the number of remaining deposits must be maintained to properly update the pendingDeposit
 	// balance to consume.
-	pendingDeposits = append(pendingDeposits[nextDepositIndex:], pendingDepositsToPostpone...)
-	if err := st.SetPendingDeposits(pendingDeposits); err != nil {
+	deposits = append(deposits[nextDepositIndex:], depositsToPostpone...)
+	if err := st.SetPendingDeposits(deposits); err != nil {
 		return errors.Wrap(err, "could not set pending deposits")
 	}
 	// Accumulate churn only if the churn limit has been hit.
@@ -373,63 +380,7 @@ func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBal
 	return st.SetDepositBalanceToConsume(0)
 }
 
-// batchProcessNewPendingDeposits should only be used to process new deposits that require validator registration
-func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState, pendingDeposits []*ethpb.PendingDeposit) error {
-	// Return early if there are no deposits to process
-	if len(pendingDeposits) == 0 {
-		return nil
-	}
-
-	// Try batch verification of all deposit signatures
-	allSignaturesVerified, err := blocks.BatchVerifyPendingDepositsSignatures(ctx, pendingDeposits)
-	if err != nil {
-		return errors.Wrap(err, "batch signature verification failed")
-	}
-
-	pubKeyMap := make(map[[48]byte]struct{}, len(pendingDeposits))
-
-	// Process each deposit individually
-	for _, pendingDeposit := range pendingDeposits {
-		_, found := pubKeyMap[bytesutil.ToBytes48(pendingDeposit.PublicKey)]
-		if !found {
-			pubKeyMap[bytesutil.ToBytes48(pendingDeposit.PublicKey)] = struct{}{}
-		}
-		validSignature := allSignaturesVerified
-
-		// If batch verification failed, check the individual deposit signature
-		if !allSignaturesVerified {
-			validSignature, err = blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
-				PublicKey:             bytesutil.SafeCopyBytes(pendingDeposit.PublicKey),
-				WithdrawalCredentials: bytesutil.SafeCopyBytes(pendingDeposit.WithdrawalCredentials),
-				Amount:                pendingDeposit.Amount,
-				Signature:             bytesutil.SafeCopyBytes(pendingDeposit.Signature),
-			})
-			if err != nil {
-				return errors.Wrap(err, "individual deposit signature verification failed")
-			}
-		}
-
-		// Add validator to the registry if the signature is valid
-		if validSignature {
-			if found {
-				index, _ := state.ValidatorIndexByPubkey(bytesutil.ToBytes48(pendingDeposit.PublicKey))
-				if err := helpers.IncreaseBalance(state, index, pendingDeposit.Amount); err != nil {
-					return errors.Wrap(err, "could not increase balance")
-				}
-			} else {
-				err = AddValidatorToRegistry(state, pendingDeposit.PublicKey, pendingDeposit.WithdrawalCredentials, pendingDeposit.Amount)
-				if err != nil {
-					return errors.Wrap(err, "failed to add validator to registry")
-				}
-			}
-		}
-	}
-
-	return nil
-}
-
 // ApplyPendingDeposit implements the spec definition below.
-// Note : This function is NOT used by ProcessPendingDeposits due to simplified logic for more readable batch processing
 //
 // Spec Definition:
 //
@@ -452,23 +403,25 @@ func batchProcessNewPendingDeposits(ctx context.Context, state state.BeaconState
 //	    validator_index = ValidatorIndex(validator_pubkeys.index(deposit.pubkey))
 //	    # Increase balance
 //	    increase_balance(state, validator_index, deposit.amount)
-func ApplyPendingDeposit(ctx context.Context, st state.BeaconState, deposit *ethpb.PendingDeposit) error {
+func ApplyPendingDeposit(ctx context.Context, st state.BeaconState, deposit *ethpb.PendingDeposit, isSigVerified bool) error {
 	_, span := trace.StartSpan(ctx, "electra.ApplyPendingDeposit")
 	defer span.End()
 	index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(deposit.PublicKey))
 	if !ok {
-		verified, err := blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
-			PublicKey:             bytesutil.SafeCopyBytes(deposit.PublicKey),
-			WithdrawalCredentials: bytesutil.SafeCopyBytes(deposit.WithdrawalCredentials),
-			Amount:                deposit.Amount,
-			Signature:             bytesutil.SafeCopyBytes(deposit.Signature),
-		})
-		if err != nil {
-			return errors.Wrap(err, "could not verify deposit signature")
+		var err error
+		if !isSigVerified {
+			isSigVerified, err = blocks.IsValidDepositSignature(&ethpb.Deposit_Data{
+				PublicKey:             bytesutil.SafeCopyBytes(deposit.PublicKey),
+				WithdrawalCredentials: bytesutil.SafeCopyBytes(deposit.WithdrawalCredentials),
+				Amount:                deposit.Amount,
+				Signature:             bytesutil.SafeCopyBytes(deposit.Signature),
+			})
+			if err != nil {
+				return errors.Wrap(err, "could not verify deposit signature")
+			}
 		}
-
-		if verified {
-			if err := AddValidatorToRegistry(st, deposit.PublicKey, deposit.WithdrawalCredentials, deposit.Amount); err != nil {
+		if isSigVerified {
+			if err := blocks.AddValidatorToRegistry(st, deposit.PublicKey, deposit.WithdrawalCredentials, deposit.Amount); err != nil {
 				return errors.Wrap(err, "could not add validator to registry")
 			}
 		}
@@ -477,83 +430,6 @@ func ApplyPendingDeposit(ctx context.Context, st state.BeaconState, deposit *eth
 	return helpers.IncreaseBalance(st, index, deposit.Amount)
 }
 
-// AddValidatorToRegistry updates the beacon state with validator information
-// def add_validator_to_registry(state: BeaconState, pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> None:
-//
-//	index = get_index_for_new_validator(state)
-//	validator = get_validator_from_deposit(pubkey, withdrawal_credentials, amount)  # [Modified in Electra:EIP7251]
-//	set_or_append_list(state.validators, index, validator)
-//	set_or_append_list(state.balances, index, amount)
-//	set_or_append_list(state.previous_epoch_participation, index, ParticipationFlags(0b0000_0000))
-//	set_or_append_list(state.current_epoch_participation, index, ParticipationFlags(0b0000_0000))
-//	set_or_append_list(state.inactivity_scores, index, uint64(0))
-func AddValidatorToRegistry(beaconState state.BeaconState, pubKey []byte, withdrawalCredentials []byte, amount uint64) error {
-	val, err := GetValidatorFromDeposit(pubKey, withdrawalCredentials, amount)
-	if err != nil {
-		return errors.Wrap(err, "could not get validator from deposit")
-	}
-	if err := beaconState.AppendValidator(val); err != nil {
-		return err
-	}
-	if err := beaconState.AppendBalance(amount); err != nil {
-		return err
-	}
-
-	// only active in altair and only when it's a new validator (after append balance)
-	if beaconState.Version() >= version.Altair {
-		if err := beaconState.AppendInactivityScore(0); err != nil {
-			return err
-		}
-		if err := beaconState.AppendPreviousParticipationBits(0); err != nil {
-			return err
-		}
-		if err := beaconState.AppendCurrentParticipationBits(0); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// GetValidatorFromDeposit gets a new validator object with provided parameters
-//
-// def get_validator_from_deposit(pubkey: BLSPubkey, withdrawal_credentials: Bytes32, amount: uint64) -> Validator:
-//
-//	validator = Validator(
-//	    pubkey=pubkey,
-//	    withdrawal_credentials=withdrawal_credentials,
-//	    effective_balance=Gwei(0),
-//	    slashed=False,
-//	    activation_eligibility_epoch=FAR_FUTURE_EPOCH,
-//	    activation_epoch=FAR_FUTURE_EPOCH,
-//	    exit_epoch=FAR_FUTURE_EPOCH,
-//	    withdrawable_epoch=FAR_FUTURE_EPOCH,
-//	)
-//
-//	# [Modified in Electra:EIP7251]
-//	max_effective_balance = get_max_effective_balance(validator)
-//	validator.effective_balance = min(amount - amount % EFFECTIVE_BALANCE_INCREMENT, max_effective_balance)
-//
-//	return validator
-func GetValidatorFromDeposit(pubKey []byte, withdrawalCredentials []byte, amount uint64) (*ethpb.Validator, error) {
-	validator := &ethpb.Validator{
-		PublicKey:                  pubKey,
-		WithdrawalCredentials:      withdrawalCredentials,
-		EffectiveBalance:           0,
-		Slashed:                    false,
-		ActivationEligibilityEpoch: params.BeaconConfig().FarFutureEpoch,
-		ActivationEpoch:            params.BeaconConfig().FarFutureEpoch,
-		ExitEpoch:                  params.BeaconConfig().FarFutureEpoch,
-		WithdrawableEpoch:          params.BeaconConfig().FarFutureEpoch,
-	}
-	v, err := state_native.NewValidator(validator)
-	if err != nil {
-		return nil, err
-	}
-	maxEffectiveBalance := helpers.ValidatorMaxEffectiveBalance(v)
-	validator.EffectiveBalance = min(amount-(amount%params.BeaconConfig().EffectiveBalanceIncrement), maxEffectiveBalance)
-	return validator, nil
-}
-
 // ProcessDepositRequests is a function as part of electra to process execution layer deposits
 func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) (state.BeaconState, error) {
 	_, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
@@ -573,21 +449,20 @@ func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState,
 	return beaconState, nil
 }
 
-// processDepositRequest processes the specific deposit request
+// processDepositRequest processes the specific deposit receipt
 // def process_deposit_request(state: BeaconState, deposit_request: DepositRequest) -> None:
 //
-//	# Set deposit request start index
-//	if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUESTS_START_INDEX:
-//	    state.deposit_requests_start_index = deposit_request.index
+//		# Set deposit request start index
+//		if state.deposit_requests_start_index == UNSET_DEPOSIT_REQUEST_START_INDEX:
+//		    state.deposit_requests_start_index = deposit_request.index
 //
-//	# Create pending deposit
-//	state.pending_deposits.append(PendingDeposit(
-//	    pubkey=deposit_request.pubkey,
-//	    withdrawal_credentials=deposit_request.withdrawal_credentials,
-//	    amount=deposit_request.amount,
-//	    signature=deposit_request.signature,
-//	    slot=state.slot,
-//	))
+//		state.pending_deposits.append(PendingDeposit(
+//	       pubkey=deposit_request.pubkey,
+//	       withdrawal_credentials=deposit_request.withdrawal_credentials,
+//	       amount=deposit_request.amount,
+//	       signature=deposit_request.signature,
+//	       slot=state.slot,
+//	   ))
 func processDepositRequest(beaconState state.BeaconState, request *enginev1.DepositRequest) (state.BeaconState, error) {
 	requestsStartIndex, err := beaconState.DepositRequestsStartIndex()
 	if err != nil {
@@ -603,8 +478,8 @@ func processDepositRequest(beaconState state.BeaconState, request *enginev1.Depo
 	}
 	if err := beaconState.AppendPendingDeposit(&ethpb.PendingDeposit{
 		PublicKey:             bytesutil.SafeCopyBytes(request.Pubkey),
-		WithdrawalCredentials: bytesutil.SafeCopyBytes(request.WithdrawalCredentials),
 		Amount:                request.Amount,
+		WithdrawalCredentials: bytesutil.SafeCopyBytes(request.WithdrawalCredentials),
 		Signature:             bytesutil.SafeCopyBytes(request.Signature),
 		Slot:                  beaconState.Slot(),
 	}); err != nil {

beacon-chain/core/electra/deposits_test.go

@@ -22,40 +22,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestProcessPendingDepositsMultiplesSameDeposits(t *testing.T) {
-	st := stateWithActiveBalanceETH(t, 1000)
-	deps := make([]*eth.PendingDeposit, 2) // Make same deposit twice
-	validators := st.Validators()
-	sk, err := bls.RandKey()
-	require.NoError(t, err)
-	for i := 0; i < len(deps); i += 1 {
-		wc := make([]byte, 32)
-		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-		wc[31] = byte(i)
-		validators[i].PublicKey = sk.PublicKey().Marshal()
-		validators[i].WithdrawalCredentials = wc
-		deps[i] = stateTesting.GeneratePendingDeposit(t, sk, 32, bytesutil.ToBytes32(wc), 0)
-	}
-	require.NoError(t, st.SetPendingDeposits(deps))
-
-	err = electra.ProcessPendingDeposits(context.TODO(), st, 10000)
-	require.NoError(t, err)
-
-	val := st.Validators()
-	seenPubkeys := make(map[string]struct{})
-	for i := 0; i < len(val); i += 1 {
-		if len(val[i].PublicKey) == 0 {
-			continue
-		}
-		_, ok := seenPubkeys[string(val[i].PublicKey)]
-		if ok {
-			t.Fatalf("duplicated pubkeys")
-		} else {
-			seenPubkeys[string(val[i].PublicKey)] = struct{}{}
-		}
-	}
-}
-
 func TestProcessPendingDeposits(t *testing.T) {
 	tests := []struct {
 		name    string
@@ -108,33 +74,6 @@ func TestProcessPendingDeposits(t *testing.T) {
 				require.Equal(t, 10, len(remaining))
 			},
 		},
-		{
-			name: "withdrawn validators should not consume churn",
-			state: func() state.BeaconState {
-				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-				depositAmount := uint64(amountAvailForProcessing)
-				// set the pending deposits to the maximum churn limit
-				st := stateWithPendingDeposits(t, 1_000, 2, depositAmount)
-				vals := st.Validators()
-				vals[1].WithdrawableEpoch = 0
-				require.NoError(t, st.SetValidators(vals))
-				return st
-			}(),
-			check: func(t *testing.T, st state.BeaconState) {
-				amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-				// Validators 0..9 should have their balance increased
-				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)
-				}
-
-				// All pending deposits should have been processed
-				remaining, err := st.PendingDeposits()
-				require.NoError(t, err)
-				require.Equal(t, 0, len(remaining))
-			},
-		},
 		{
 			name: "less deposits than balance to consume processes all deposits",
 			state: func() state.BeaconState {
@@ -211,6 +150,7 @@ func TestProcessPendingDeposits(t *testing.T) {
 				dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
 				dep.Signature = common.InfiniteSignature[:]
 				require.NoError(t, st.SetValidators(validators))
+				st.SaveValidatorIndices()
 				require.NoError(t, st.SetPendingDeposits([]*eth.PendingDeposit{dep}))
 				return st
 			}(),
@@ -308,27 +248,6 @@ func TestProcessPendingDeposits(t *testing.T) {
 	}
 }
 
-func TestBatchProcessNewPendingDeposits(t *testing.T) {
-	t.Run("invalid batch initiates correct individual validation", func(t *testing.T) {
-		st := stateWithActiveBalanceETH(t, 0)
-		require.Equal(t, 0, len(st.Validators()))
-		require.Equal(t, 0, len(st.Balances()))
-		sk, err := bls.RandKey()
-		require.NoError(t, err)
-		wc := make([]byte, 32)
-		wc[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
-		wc[31] = byte(0)
-		validDep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
-		invalidDep := &eth.PendingDeposit{PublicKey: make([]byte, 48)}
-		// have a combination of valid and invalid deposits
-		deps := []*eth.PendingDeposit{validDep, invalidDep}
-		require.NoError(t, electra.BatchProcessNewPendingDeposits(context.Background(), st, deps))
-		// successfully added to register
-		require.Equal(t, 1, len(st.Validators()))
-		require.Equal(t, 1, len(st.Balances()))
-	})
-}
-
 func TestProcessDepositRequests(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateElectra(t, 1)
 	sk, err := bls.RandKey()
@@ -442,7 +361,7 @@ func TestProcessDeposit_SkipsInvalidDeposit(t *testing.T) {
 		},
 	})
 	require.NoError(t, err)
-	newState, err := electra.ProcessDeposit(beaconState, dep[0], false)
+	newState, err := electra.ProcessDeposit(beaconState, dep[0], true)
 	require.NoError(t, err, "Expected invalid block deposit to be ignored without error")
 
 	if newState.Eth1DepositIndex() != 1 {
@@ -479,7 +398,7 @@ func TestApplyDeposit_TopUps_WithBadSignature(t *testing.T) {
 	vals[0].PublicKey = sk.PublicKey().Marshal()
 	vals[0].WithdrawalCredentials[0] = params.BeaconConfig().ETH1AddressWithdrawalPrefixByte
 	require.NoError(t, st.SetValidators(vals))
-	adSt, err := electra.ApplyDeposit(st, depositData, false)
+	adSt, err := electra.ApplyDeposit(st, depositData, true)
 	require.NoError(t, err)
 	pbd, err := adSt.PendingDeposits()
 	require.NoError(t, err)
@@ -541,6 +460,7 @@ func stateWithPendingDeposits(t *testing.T, balETH uint64, numDeposits, amount u
 		deps[i] = stateTesting.GeneratePendingDeposit(t, sk, amount, bytesutil.ToBytes32(wc), 0)
 	}
 	require.NoError(t, st.SetValidators(validators))
+	st.SaveValidatorIndices()
 	require.NoError(t, st.SetPendingDeposits(deps))
 	return st
 }
@@ -559,8 +479,9 @@ func TestApplyPendingDeposit_TopUp(t *testing.T) {
 	dep := stateTesting.GeneratePendingDeposit(t, sk, excessBalance, bytesutil.ToBytes32(wc), 0)
 	dep.Signature = common.InfiniteSignature[:]
 	require.NoError(t, st.SetValidators(validators))
+	st.SaveValidatorIndices()
 
-	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep, false))
 
 	b, err := st.BalanceAtIndex(0)
 	require.NoError(t, err)
@@ -576,7 +497,7 @@ func TestApplyPendingDeposit_UnknownKey(t *testing.T) {
 	wc[31] = byte(0)
 	dep := stateTesting.GeneratePendingDeposit(t, sk, params.BeaconConfig().MinActivationBalance, bytesutil.ToBytes32(wc), 0)
 	require.Equal(t, 0, len(st.Validators()))
-	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep, false))
 	// activates new validator
 	require.Equal(t, 1, len(st.Validators()))
 	b, err := st.BalanceAtIndex(0)
@@ -598,7 +519,7 @@ func TestApplyPendingDeposit_InvalidSignature(t *testing.T) {
 		Amount:                100,
 	}
 	require.Equal(t, 0, len(st.Validators()))
-	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep))
+	require.NoError(t, electra.ApplyPendingDeposit(context.Background(), st, dep, false))
 	// no validator added
 	require.Equal(t, 0, len(st.Validators()))
 	// no topup either

beacon-chain/core/electra/export_test.go

@@ -1,3 +0,0 @@
-package electra
-
-var BatchProcessNewPendingDeposits = batchProcessNewPendingDeposits

beacon-chain/core/electra/transition.go

@@ -29,6 +29,7 @@ var (
 	ProcessParticipationFlagUpdates      = altair.ProcessParticipationFlagUpdates
 	ProcessSyncCommitteeUpdates          = altair.ProcessSyncCommitteeUpdates
 	AttestationsDelta                    = altair.AttestationsDelta
+	ProcessSyncAggregate                 = altair.ProcessSyncAggregate
 )
 
 // ProcessEpoch describes the per epoch operations that are performed on the beacon state.

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -84,11 +84,11 @@ func ProcessOperations(
 	}
 	st, err = ProcessDepositRequests(ctx, st, requests.Deposits)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not process deposit requests")
+		return nil, errors.Wrap(err, "could not process deposit receipts")
 	}
 	st, err = ProcessWithdrawalRequests(ctx, st, requests.Withdrawals)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not process withdrawal requests")
+		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
 	}
 	if err := ProcessConsolidationRequests(ctx, st, requests.Consolidations); err != nil {
 		return nil, fmt.Errorf("could not process consolidation requests: %w", err)

beacon-chain/core/electra/upgrade.go

@@ -16,20 +16,36 @@ import (
 )
 
 // UpgradeToElectra updates inputs a generic state to return the version Electra state.
-//
-// nolint:dupword
-// Spec code:
 // def upgrade_to_electra(pre: deneb.BeaconState) -> BeaconState:
 //
 //	epoch = deneb.get_current_epoch(pre)
-//	latest_execution_payload_header = pre.latest_execution_payload_header
+//	latest_execution_payload_header = ExecutionPayloadHeader(
+//	    parent_hash=pre.latest_execution_payload_header.parent_hash,
+//	    fee_recipient=pre.latest_execution_payload_header.fee_recipient,
+//	    state_root=pre.latest_execution_payload_header.state_root,
+//	    receipts_root=pre.latest_execution_payload_header.receipts_root,
+//	    logs_bloom=pre.latest_execution_payload_header.logs_bloom,
+//	    prev_randao=pre.latest_execution_payload_header.prev_randao,
+//	    block_number=pre.latest_execution_payload_header.block_number,
+//	    gas_limit=pre.latest_execution_payload_header.gas_limit,
+//	    gas_used=pre.latest_execution_payload_header.gas_used,
+//	    timestamp=pre.latest_execution_payload_header.timestamp,
+//	    extra_data=pre.latest_execution_payload_header.extra_data,
+//	    base_fee_per_gas=pre.latest_execution_payload_header.base_fee_per_gas,
+//	    block_hash=pre.latest_execution_payload_header.block_hash,
+//	    transactions_root=pre.latest_execution_payload_header.transactions_root,
+//	    withdrawals_root=pre.latest_execution_payload_header.withdrawals_root,
+//	    blob_gas_used=pre.latest_execution_payload_header.blob_gas_used,
+//	    excess_blob_gas=pre.latest_execution_payload_header.excess_blob_gas,
+//	    deposit_requests_root=Root(),  # [New in Electra:EIP6110]
+//	    withdrawal_requests_root=Root(),  # [New in Electra:EIP7002],
+//	    consolidation_requests_root=Root(),  # [New in Electra:EIP7251]
+//	)
 //
-//	earliest_exit_epoch = compute_activation_exit_epoch(get_current_epoch(pre))
-//	for validator in pre.validators:
-//	    if validator.exit_epoch != FAR_FUTURE_EPOCH:
-//	        if validator.exit_epoch > earliest_exit_epoch:
-//	            earliest_exit_epoch = validator.exit_epoch
-//	earliest_exit_epoch += Epoch(1)
+//	exit_epochs = [v.exit_epoch for v in pre.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
+//	if not exit_epochs:
+//	    exit_epochs = [get_current_epoch(pre)]
+//	earliest_exit_epoch = max(exit_epochs) + 1
 //
 //	post = BeaconState(
 //	    # Versioning
@@ -104,20 +120,7 @@ import (
 //	))
 //
 //	for index in pre_activation:
-//	    balance = post.balances[index]
-//	    post.balances[index] = 0
-//	    validator = post.validators[index]
-//	    validator.effective_balance = 0
-//	    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
-//	    # Use bls.G2_POINT_AT_INFINITY as a signature field placeholder
-//	    # and GENESIS_SLOT to distinguish from a pending deposit request
-//	    post.pending_deposits.append(PendingDeposit(
-//	        pubkey=validator.pubkey,
-//	        withdrawal_credentials=validator.withdrawal_credentials,
-//	        amount=balance,
-//	        signature=bls.G2_POINT_AT_INFINITY,
-//	        slot=GENESIS_SLOT,
-//	    ))
+//	    queue_entire_balance_and_reset_validator(post, ValidatorIndex(index))
 //
 //	# Ensure early adopters of compounding credentials go through the activation churn
 //	for index, validator in enumerate(post.validators):
@@ -184,7 +187,7 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 	}
 
 	// [New in Electra:EIP7251]
-	earliestExitEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(beaconState))
+	earliestExitEpoch := time.CurrentEpoch(beaconState)
 	preActivationIndices := make([]primitives.ValidatorIndex, 0)
 	compoundWithdrawalIndices := make([]primitives.ValidatorIndex, 0)
 	if err = beaconState.ReadFromEveryValidator(func(index int, val state.ReadOnlyValidator) error {

beacon-chain/core/electra/upgrade_test.go

@@ -159,7 +159,7 @@ func TestUpgradeToElectra(t *testing.T) {
 
 	eee, err := mSt.EarliestExitEpoch()
 	require.NoError(t, err)
-	require.Equal(t, helpers.ActivationExitEpoch(primitives.Epoch(1)), eee)
+	require.Equal(t, primitives.Epoch(1), eee)
 
 	cbtc, err := mSt.ConsolidationBalanceToConsume()
 	require.NoError(t, err)

beacon-chain/core/electra/validator.go

@@ -14,11 +14,10 @@ import (
 //
 // Spec definition:
 //
-// def switch_to_compounding_validator(state: BeaconState, index: ValidatorIndex) -> None:
-//
-//	validator = state.validators[index]
-//	validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
-//	queue_excess_active_balance(state, index)
+//	 def switch_to_compounding_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//		validator = state.validators[index]
+//		validator.withdrawal_credentials = COMPOUNDING_WITHDRAWAL_PREFIX + validator.withdrawal_credentials[1:]
+//		queue_excess_active_balance(state, index)
 func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	v, err := s.ValidatorAtIndex(idx)
 	if err != nil {
@@ -39,20 +38,19 @@ func SwitchToCompoundingValidator(s state.BeaconState, idx primitives.ValidatorI
 //
 // Spec definition:
 //
-// def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
-//
-//	balance = state.balances[index]
-//	if balance > MIN_ACTIVATION_BALANCE:
-//		excess_balance = balance - MIN_ACTIVATION_BALANCE
-//		state.balances[index] = MIN_ACTIVATION_BALANCE
-//		validator = state.validators[index]
-//	 state.pending_deposits.append(PendingDeposit(
-//	   pubkey=validator.pubkey,
-//	   withdrawal_credentials=validator.withdrawal_credentials,
-//	   amount=excess_balance,
-//	   signature=bls.G2_POINT_AT_INFINITY,
-//	   slot=GENESIS_SLOT,
-//	 ))
+//		def queue_excess_active_balance(state: BeaconState, index: ValidatorIndex) -> None:
+//		    balance = state.balances[index]
+//		    if balance > MIN_ACTIVATION_BALANCE:
+//		        excess_balance = balance - MIN_ACTIVATION_BALANCE
+//		        state.balances[index] = MIN_ACTIVATION_BALANCE
+//		        validator = state.validators[index]
+//	         state.pending_deposits.append(PendingDeposit(
+//	           pubkey=validator.pubkey,
+//	           withdrawal_credentials=validator.withdrawal_credentials,
+//	           amount=excess_balance,
+//	           signature=bls.G2_POINT_AT_INFINITY,
+//	           slot=GENESIS_SLOT,
+//	         ))
 func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex) error {
 	bal, err := s.BalanceAtIndex(idx)
 	if err != nil {
@@ -60,18 +58,17 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 	}
 
 	if bal > params.BeaconConfig().MinActivationBalance {
-		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
-			return err
-		}
-		excessBalance := bal - params.BeaconConfig().MinActivationBalance
-		val, err := s.ValidatorAtIndexReadOnly(idx)
+		val, err := s.ValidatorAtIndex(idx)
 		if err != nil {
 			return err
 		}
-		pk := val.PublicKey()
+		excessBalance := bal - params.BeaconConfig().MinActivationBalance
+		if err := s.UpdateBalancesAtIndex(idx, params.BeaconConfig().MinActivationBalance); err != nil {
+			return err
+		}
 		return s.AppendPendingDeposit(&ethpb.PendingDeposit{
-			PublicKey:             pk[:],
-			WithdrawalCredentials: val.GetWithdrawalCredentials(),
+			PublicKey:             val.PublicKey,
+			WithdrawalCredentials: val.WithdrawalCredentials,
 			Amount:                excessBalance,
 			Signature:             common.InfiniteSignature[:],
 			Slot:                  params.BeaconConfig().GenesisSlot,
@@ -84,21 +81,19 @@ func QueueExcessActiveBalance(s state.BeaconState, idx primitives.ValidatorIndex
 //
 // Spec definition:
 //
-// def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
-//
-//		balance = state.balances[index]
-//		state.balances[index] = 0
-//		validator = state.validators[index]
-//		validator.effective_balance = 0
-//		validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
-//		state.pending_deposits.append(PendingDeposit(
-//	  		pubkey=validator.pubkey,
-//	  		withdrawal_credentials=validator.withdrawal_credentials,
-//	  		amount=balance,
-//	  		signature=bls.G2_POINT_AT_INFINITY,
-//	  		slot=GENESIS_SLOT,
-//
-// ))
+//		def queue_entire_balance_and_reset_validator(state: BeaconState, index: ValidatorIndex) -> None:
+//		    balance = state.balances[index]
+//		    state.balances[index] = 0
+//		    validator = state.validators[index]
+//		    validator.effective_balance = 0
+//		    validator.activation_eligibility_epoch = FAR_FUTURE_EPOCH
+//		    state.pending_deposits.append(PendingDeposit(
+//	       pubkey=validator.pubkey,
+//	       withdrawal_credentials=validator.withdrawal_credentials,
+//	       amount=balance,
+//	       signature=bls.G2_POINT_AT_INFINITY,
+//	       slot=GENESIS_SLOT,
+//	     ))
 //
 //nolint:dupword
 func QueueEntireBalanceAndResetValidator(s state.BeaconState, idx primitives.ValidatorIndex) error {

beacon-chain/core/electra/withdrawals.go

@@ -111,31 +111,30 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 			log.Debugf("Skipping execution layer withdrawal request, validator index for %s not found\n", hexutil.Encode(wr.ValidatorPubkey))
 			continue
 		}
-		validator, err := st.ValidatorAtIndexReadOnly(vIdx)
+		validator, err := st.ValidatorAtIndex(vIdx)
 		if err != nil {
 			return nil, err
 		}
 		// Verify withdrawal credentials
 		hasCorrectCredential := helpers.HasExecutionWithdrawalCredentials(validator)
-		wc := validator.GetWithdrawalCredentials()
-		isCorrectSourceAddress := bytes.Equal(wc[12:], wr.SourceAddress)
+		isCorrectSourceAddress := bytes.Equal(validator.WithdrawalCredentials[12:], wr.SourceAddress)
 		if !hasCorrectCredential || !isCorrectSourceAddress {
 			log.Debugln("Skipping execution layer withdrawal request, wrong withdrawal credentials")
 			continue
 		}
 
 		// Verify the validator is active.
-		if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
+		if !helpers.IsActiveValidator(validator, currentEpoch) {
 			log.Debugln("Skipping execution layer withdrawal request, validator not active")
 			continue
 		}
 		// Verify the validator has not yet submitted an exit.
-		if validator.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
+		if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
 			log.Debugln("Skipping execution layer withdrawal request, validator has submitted an exit already")
 			continue
 		}
 		// Verify the validator has been active long enough.
-		if currentEpoch < validator.ActivationEpoch().AddEpoch(params.BeaconConfig().ShardCommitteePeriod) {
+		if currentEpoch < validator.ActivationEpoch.AddEpoch(params.BeaconConfig().ShardCommitteePeriod) {
 			log.Debugln("Skipping execution layer withdrawal request, validator has not been active long enough")
 			continue
 		}
@@ -157,7 +156,7 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 			continue
 		}
 
-		hasSufficientEffectiveBalance := validator.EffectiveBalance() >= params.BeaconConfig().MinActivationBalance
+		hasSufficientEffectiveBalance := validator.EffectiveBalance >= params.BeaconConfig().MinActivationBalance
 		vBal, err := st.BalanceAtIndex(vIdx)
 		if err != nil {
 			return nil, err

beacon-chain/core/epoch/epoch_processing.go

@@ -147,17 +147,11 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 //	  epoch = get_current_epoch(state)
 //	  total_balance = get_total_active_balance(state)
 //	  adjusted_total_slashing_balance = min(sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER, total_balance)
-//	  if state.version == electra:
-//		 increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from total balance to avoid uint64 overflow
-//	  penalty_per_effective_balance_increment = adjusted_total_slashing_balance // (total_balance // increment)
 //	  for index, validator in enumerate(state.validators):
 //	      if validator.slashed and epoch + EPOCHS_PER_SLASHINGS_VECTOR // 2 == validator.withdrawable_epoch:
 //	          increment = EFFECTIVE_BALANCE_INCREMENT  # Factored out from penalty numerator to avoid uint64 overflow
 //	          penalty_numerator = validator.effective_balance // increment * adjusted_total_slashing_balance
 //	          penalty = penalty_numerator // total_balance * increment
-//	          if state.version == electra:
-//	            effective_balance_increments = validator.effective_balance // increment
-//	            penalty = penalty_per_effective_balance_increment * effective_balance_increments
 //	          decrease_balance(state, ValidatorIndex(index), penalty)
 func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error) {
 	currentEpoch := time.CurrentEpoch(st)
@@ -183,26 +177,13 @@ func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.Be
 	// below equally.
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
 	minSlashing := math.Min(totalSlashing*slashingMultiplier, totalBalance)
-
-	// Modified in Electra:EIP7251
-	var penaltyPerEffectiveBalanceIncrement uint64
-	if st.Version() >= version.Electra {
-		penaltyPerEffectiveBalanceIncrement = minSlashing / (totalBalance / increment)
-	}
-
 	bals := st.Balances()
 	changed := false
 	err = st.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		correctEpoch := (currentEpoch + exitLength/2) == val.WithdrawableEpoch()
 		if val.Slashed() && correctEpoch {
-			var penalty uint64
-			if st.Version() >= version.Electra {
-				effectiveBalanceIncrements := val.EffectiveBalance() / increment
-				penalty = penaltyPerEffectiveBalanceIncrement * effectiveBalanceIncrements
-			} else {
-				penaltyNumerator := val.EffectiveBalance() / increment * minSlashing
-				penalty = penaltyNumerator / totalBalance * increment
-			}
+			penaltyNumerator := val.EffectiveBalance() / increment * minSlashing
+			penalty := penaltyNumerator / totalBalance * increment
 			bals[idx] = helpers.DecreaseBalanceWithVal(bals[idx], penalty)
 			changed = true
 		}

beacon-chain/core/epoch/epoch_processing_test.go

@@ -448,75 +448,3 @@ func TestProcessHistoricalDataUpdate(t *testing.T) {
 		})
 	}
 }
-
-func TestProcessSlashings_SlashedElectra(t *testing.T) {
-	tests := []struct {
-		state *ethpb.BeaconStateElectra
-		want  uint64
-	}{
-		{
-			state: &ethpb.BeaconStateElectra{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance}},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
-				Slashings: []uint64{0, 1e9},
-			},
-			want: uint64(29000000000),
-		},
-		{
-			state: &ethpb.BeaconStateElectra{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance},
-				},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance, params.BeaconConfig().MaxEffectiveBalance},
-				Slashings: []uint64{0, 1e9},
-			},
-			want: uint64(30500000000),
-		},
-		{
-			state: &ethpb.BeaconStateElectra{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra},
-				},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalance * 10, params.BeaconConfig().MaxEffectiveBalance * 20},
-				Slashings: []uint64{0, 2 * 1e9},
-			},
-			want: uint64(317000001536),
-		},
-		{
-			state: &ethpb.BeaconStateElectra{
-				Validators: []*ethpb.Validator{
-					{Slashed: true,
-						WithdrawableEpoch: params.BeaconConfig().EpochsPerSlashingsVector / 2,
-						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement},
-					{ExitEpoch: params.BeaconConfig().FarFutureEpoch, EffectiveBalance: params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement}},
-				Balances:  []uint64{params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalanceElectra - params.BeaconConfig().EffectiveBalanceIncrement},
-				Slashings: []uint64{0, 1e9},
-			},
-			want: uint64(2044000000727),
-		},
-	}
-
-	for i, tt := range tests {
-		t.Run(fmt.Sprint(i), func(t *testing.T) {
-			original := proto.Clone(tt.state)
-			s, err := state_native.InitializeFromProtoElectra(tt.state)
-			require.NoError(t, err)
-			helpers.ClearCache()
-			newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierBellatrix)
-			require.NoError(t, err)
-			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
-		})
-	}
-}

beacon-chain/core/feed/state/events.go

@@ -31,8 +31,6 @@ const (
 	LightClientFinalityUpdate
 	// LightClientOptimisticUpdate event
 	LightClientOptimisticUpdate
-	// PayloadAttributes events are fired upon a missed slot or new head.
-	PayloadAttributes
 )
 
 // BlockProcessedData is the data sent with BlockProcessed events.

beacon-chain/core/helpers/BUILD.bazel

@@ -63,7 +63,6 @@ go_test(
         "validators_test.go",
         "weak_subjectivity_test.go",
     ],
-    data = glob(["testdata/**"]),
     embed = [":go_default_library"],
     shard_count = 2,
     tags = ["CI_race_detection"],

beacon-chain/core/helpers/attestation.go

@@ -23,8 +23,11 @@ var (
 // Access to these nil fields will result in run time panic,
 // it is recommended to run these checks as first line of defense.
 func ValidateNilAttestation(attestation ethpb.Att) error {
-	if attestation == nil || attestation.IsNil() {
-		return errors.New("attestation is nil")
+	if attestation == nil {
+		return errors.New("attestation can't be nil")
+	}
+	if attestation.GetData() == nil {
+		return errors.New("attestation's data can't be nil")
 	}
 	if attestation.GetData().Source == nil {
 		return errors.New("attestation's source can't be nil")
@@ -67,6 +70,12 @@ func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 	return binary.LittleEndian.Uint64(b[:8])%modulo == 0, nil
 }
 
+// IsAggregated returns true if the attestation is an aggregated attestation,
+// false otherwise.
+func IsAggregated(attestation ethpb.Att) bool {
+	return attestation.GetAggregationBits().Count() > 1
+}
+
 // ComputeSubnetForAttestation returns the subnet for which the provided attestation will be broadcasted to.
 // This differs from the spec definition by instead passing in the active validators indices in the attestation's
 // given epoch.

beacon-chain/core/helpers/attestation_test.go

@@ -260,12 +260,12 @@ func TestValidateNilAttestation(t *testing.T) {
 		{
 			name:        "nil attestation",
 			attestation: nil,
-			errString:   "attestation is nil",
+			errString:   "attestation can't be nil",
 		},
 		{
 			name:        "nil attestation data",
 			attestation: &ethpb.Attestation{},
-			errString:   "attestation is nil",
+			errString:   "attestation's data can't be nil",
 		},
 		{
 			name: "nil attestation source",

beacon-chain/core/helpers/sync_committee.go

@@ -69,16 +69,15 @@ func IsNextPeriodSyncCommittee(
 	}
 	indices, err := syncCommitteeCache.NextPeriodIndexPosition(root, valIdx)
 	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
-		val, err := st.ValidatorAtIndexReadOnly(valIdx)
+		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return false, err
 		}
-		pk := val.PublicKey()
 		committee, err := st.NextSyncCommittee()
 		if err != nil {
 			return false, err
 		}
-		return len(findSubCommitteeIndices(pk[:], committee.Pubkeys)) > 0, nil
+		return len(findSubCommitteeIndices(val.PublicKey, committee.Pubkeys)) > 0, nil
 	}
 	if err != nil {
 		return false, err
@@ -97,11 +96,10 @@ func CurrentPeriodSyncSubcommitteeIndices(
 	}
 	indices, err := syncCommitteeCache.CurrentPeriodIndexPosition(root, valIdx)
 	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
-		val, err := st.ValidatorAtIndexReadOnly(valIdx)
+		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return nil, err
 		}
-		pk := val.PublicKey()
 		committee, err := st.CurrentSyncCommittee()
 		if err != nil {
 			return nil, err
@@ -114,7 +112,7 @@ func CurrentPeriodSyncSubcommitteeIndices(
 			}
 		}()
 
-		return findSubCommitteeIndices(pk[:], committee.Pubkeys), nil
+		return findSubCommitteeIndices(val.PublicKey, committee.Pubkeys), nil
 	}
 	if err != nil {
 		return nil, err
@@ -132,16 +130,15 @@ func NextPeriodSyncSubcommitteeIndices(
 	}
 	indices, err := syncCommitteeCache.NextPeriodIndexPosition(root, valIdx)
 	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
-		val, err := st.ValidatorAtIndexReadOnly(valIdx)
+		val, err := st.ValidatorAtIndex(valIdx)
 		if err != nil {
 			return nil, err
 		}
-		pk := val.PublicKey()
 		committee, err := st.NextSyncCommittee()
 		if err != nil {
 			return nil, err
 		}
-		return findSubCommitteeIndices(pk[:], committee.Pubkeys), nil
+		return findSubCommitteeIndices(val.PublicKey, committee.Pubkeys), nil
 	}
 	if err != nil {
 		return nil, err

beacon-chain/core/helpers/validators.go

@@ -3,7 +3,6 @@ package helpers
 import (
 	"bytes"
 	"context"
-	"encoding/binary"
 
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
@@ -12,7 +11,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -349,33 +347,27 @@ func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconSt
 // Spec pseudocode definition:
 //
 //	def compute_proposer_index(state: BeaconState, indices: Sequence[ValidatorIndex], seed: Bytes32) -> ValidatorIndex:
-//	   """
-//	   Return from ``indices`` a random index sampled by effective balance.
-//	   """
-//	   assert len(indices) > 0
-//	   MAX_RANDOM_VALUE = 2**16 - 1  # [Modified in Electra]
-//	   i = uint64(0)
-//	   total = uint64(len(indices))
-//	   while True:
-//	       candidate_index = indices[compute_shuffled_index(i % total, total, seed)]
-//	       # [Modified in Electra]
-//	       random_bytes = hash(seed + uint_to_bytes(i // 16))
-//	       offset = i % 16 * 2
-//	       random_value = bytes_to_uint64(random_bytes[offset:offset + 2])
-//	       effective_balance = state.validators[candidate_index].effective_balance
-//	       # [Modified in Electra:EIP7251]
-//	       if effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value:
-//	           return candidate_index
-//	       i += 1
+//	  """
+//	  Return from ``indices`` a random index sampled by effective balance.
+//	  """
+//	  assert len(indices) > 0
+//	  MAX_RANDOM_BYTE = 2**8 - 1
+//	  i = uint64(0)
+//	  total = uint64(len(indices))
+//	  while True:
+//	      candidate_index = indices[compute_shuffled_index(i % total, total, seed)]
+//	      random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
+//	      effective_balance = state.validators[candidate_index].effective_balance
+//	      if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte: #[Modified in Electra:EIP7251]
+//	          return candidate_index
+//	      i += 1
 func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, seed [32]byte) (primitives.ValidatorIndex, error) {
 	length := uint64(len(activeIndices))
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
 	}
+	maxRandomByte := uint64(1<<8 - 1)
 	hashFunc := hash.CustomSHA256Hasher()
-	beaconConfig := params.BeaconConfig()
-	seedBuffer := make([]byte, len(seed)+8)
-	copy(seedBuffer, seed[:])
 
 	for i := uint64(0); ; i++ {
 		candidateIndex, err := ComputeShuffledIndex(primitives.ValidatorIndex(i%length), length, seed, true /* shuffle */)
@@ -386,28 +378,21 @@ func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []prim
 		if uint64(candidateIndex) >= uint64(bState.NumValidators()) {
 			return 0, errors.New("active index out of range")
 		}
-
+		b := append(seed[:], bytesutil.Bytes8(i/32)...)
+		randomByte := hashFunc(b)[i%32]
 		v, err := bState.ValidatorAtIndexReadOnly(candidateIndex)
 		if err != nil {
 			return 0, err
 		}
 		effectiveBal := v.EffectiveBalance()
+
+		maxEB := params.BeaconConfig().MaxEffectiveBalance
 		if bState.Version() >= version.Electra {
-			binary.LittleEndian.PutUint64(seedBuffer[len(seed):], i/16)
-			randomByte := hashFunc(seedBuffer)
-			offset := (i % 16) * 2
-			randomValue := uint64(randomByte[offset]) | uint64(randomByte[offset+1])<<8
+			maxEB = params.BeaconConfig().MaxEffectiveBalanceElectra
+		}
 
-			if effectiveBal*fieldparams.MaxRandomValueElectra >= beaconConfig.MaxEffectiveBalanceElectra*randomValue {
-				return candidateIndex, nil
-			}
-		} else {
-			binary.LittleEndian.PutUint64(seedBuffer[len(seed):], i/32)
-			randomByte := hashFunc(seedBuffer)[i%32]
-
-			if effectiveBal*fieldparams.MaxRandomByte >= beaconConfig.MaxEffectiveBalance*uint64(randomByte) {
-				return candidateIndex, nil
-			}
+		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
+			return candidateIndex, nil
 		}
 	}
 }
@@ -599,23 +584,23 @@ func IsSameWithdrawalCredentials(a, b *ethpb.Validator) bool {
 //	        and validator.withdrawable_epoch <= epoch
 //	        and balance > 0
 //	    )
-func IsFullyWithdrawableValidator(val state.ReadOnlyValidator, balance uint64, epoch primitives.Epoch, fork int) bool {
+func IsFullyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch, fork int) bool {
 	if val == nil || balance <= 0 {
 		return false
 	}
 
 	// Electra / EIP-7251 logic
 	if fork >= version.Electra {
-		return HasExecutionWithdrawalCredentials(val) && val.WithdrawableEpoch() <= epoch
+		return HasExecutionWithdrawalCredentials(val) && val.WithdrawableEpoch <= epoch
 	}
 
-	return HasETH1WithdrawalCredential(val) && val.WithdrawableEpoch() <= epoch
+	return HasETH1WithdrawalCredential(val) && val.WithdrawableEpoch <= epoch
 }
 
 // IsPartiallyWithdrawableValidator returns whether the validator is able to perform a
 // partial withdrawal. This function assumes that the caller has a lock on the state.
 // This method conditionally calls the fork appropriate implementation based on the epoch argument.
-func IsPartiallyWithdrawableValidator(val state.ReadOnlyValidator, balance uint64, epoch primitives.Epoch, fork int) bool {
+func IsPartiallyWithdrawableValidator(val *ethpb.Validator, balance uint64, epoch primitives.Epoch, fork int) bool {
 	if val == nil {
 		return false
 	}
@@ -645,9 +630,9 @@ func IsPartiallyWithdrawableValidator(val state.ReadOnlyValidator, balance uint6
 //	    and has_max_effective_balance
 //	    and has_excess_balance
 //	)
-func isPartiallyWithdrawableValidatorElectra(val state.ReadOnlyValidator, balance uint64, epoch primitives.Epoch) bool {
+func isPartiallyWithdrawableValidatorElectra(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
 	maxEB := ValidatorMaxEffectiveBalance(val)
-	hasMaxBalance := val.EffectiveBalance() == maxEB
+	hasMaxBalance := val.EffectiveBalance == maxEB
 	hasExcessBalance := balance > maxEB
 
 	return HasExecutionWithdrawalCredentials(val) &&
@@ -667,8 +652,8 @@ func isPartiallyWithdrawableValidatorElectra(val state.ReadOnlyValidator, balanc
 //	    has_max_effective_balance = validator.effective_balance == MAX_EFFECTIVE_BALANCE
 //	    has_excess_balance = balance > MAX_EFFECTIVE_BALANCE
 //	    return has_eth1_withdrawal_credential(validator) and has_max_effective_balance and has_excess_balance
-func isPartiallyWithdrawableValidatorCapella(val state.ReadOnlyValidator, balance uint64, epoch primitives.Epoch) bool {
-	hasMaxBalance := val.EffectiveBalance() == params.BeaconConfig().MaxEffectiveBalance
+func isPartiallyWithdrawableValidatorCapella(val *ethpb.Validator, balance uint64, epoch primitives.Epoch) bool {
+	hasMaxBalance := val.EffectiveBalance == params.BeaconConfig().MaxEffectiveBalance
 	hasExcessBalance := balance > params.BeaconConfig().MaxEffectiveBalance
 	return HasETH1WithdrawalCredential(val) && hasExcessBalance && hasMaxBalance
 }
@@ -685,7 +670,7 @@ func isPartiallyWithdrawableValidatorCapella(val state.ReadOnlyValidator, balanc
 //	        return MAX_EFFECTIVE_BALANCE_ELECTRA
 //	    else:
 //	        return MIN_ACTIVATION_BALANCE
-func ValidatorMaxEffectiveBalance(val state.ReadOnlyValidator) uint64 {
+func ValidatorMaxEffectiveBalance(val *ethpb.Validator) uint64 {
 	if HasCompoundingWithdrawalCredential(val) {
 		return params.BeaconConfig().MaxEffectiveBalanceElectra
 	}

beacon-chain/core/helpers/validators_test.go

@@ -841,6 +841,7 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
 	}
+	maxRandomByte := uint64(1<<8 - 1)
 	hashFunc := hash.CustomSHA256Hasher()
 
 	for i := uint64(0); ; i++ {
@@ -859,7 +860,7 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd
 		if v != nil {
 			effectiveBal = v.EffectiveBalance
 		}
-		if effectiveBal*fieldparams.MaxRandomByte >= params.BeaconConfig().MaxEffectiveBalance*uint64(randomByte) {
+		if effectiveBal*maxRandomByte >= params.BeaconConfig().MaxEffectiveBalance*uint64(randomByte) {
 			return candidateIndex, nil
 		}
 	}
@@ -973,6 +974,13 @@ func TestIsFullyWithdrawableValidator(t *testing.T) {
 		fork      int
 		want      bool
 	}{
+		{
+			name:      "Handles nil case",
+			validator: nil,
+			balance:   0,
+			epoch:     0,
+			want:      false,
+		},
 		{
 			name: "No ETH1 prefix",
 			validator: &ethpb.Validator{
@@ -1028,9 +1036,7 @@ func TestIsFullyWithdrawableValidator(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			v, err := state_native.NewValidator(tt.validator)
-			require.NoError(t, err)
-			assert.Equal(t, tt.want, helpers.IsFullyWithdrawableValidator(v, tt.balance, tt.epoch, tt.fork))
+			assert.Equal(t, tt.want, helpers.IsFullyWithdrawableValidator(tt.validator, tt.balance, tt.epoch, tt.fork))
 		})
 	}
 }
@@ -1044,6 +1050,13 @@ func TestIsPartiallyWithdrawableValidator(t *testing.T) {
 		fork      int
 		want      bool
 	}{
+		{
+			name:      "Handles nil case",
+			validator: nil,
+			balance:   0,
+			epoch:     0,
+			want:      false,
+		},
 		{
 			name: "No ETH1 prefix",
 			validator: &ethpb.Validator{
@@ -1100,9 +1113,7 @@ func TestIsPartiallyWithdrawableValidator(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			v, err := state_native.NewValidator(tt.validator)
-			require.NoError(t, err)
-			assert.Equal(t, tt.want, helpers.IsPartiallyWithdrawableValidator(v, tt.balance, tt.epoch, tt.fork))
+			assert.Equal(t, tt.want, helpers.IsPartiallyWithdrawableValidator(tt.validator, tt.balance, tt.epoch, tt.fork))
 		})
 	}
 }
@@ -1156,12 +1167,15 @@ func TestValidatorMaxEffectiveBalance(t *testing.T) {
 			validator: &ethpb.Validator{WithdrawalCredentials: []byte{params.BeaconConfig().ETH1AddressWithdrawalPrefixByte, 0xCC}},
 			want:      params.BeaconConfig().MinActivationBalance,
 		},
+		{
+			"Handles nil case",
+			nil,
+			params.BeaconConfig().MinActivationBalance,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			v, err := state_native.NewValidator(tt.validator)
-			require.NoError(t, err)
-			assert.Equal(t, tt.want, helpers.ValidatorMaxEffectiveBalance(v))
+			assert.Equal(t, tt.want, helpers.ValidatorMaxEffectiveBalance(tt.validator))
 		})
 	}
 	// Sanity check that MinActivationBalance equals (pre-electra) MaxEffectiveBalance

beacon-chain/core/light-client/BUILD.bazel

@@ -6,22 +6,19 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client",
     visibility = ["//visibility:public"],
     deps = [
-        "//beacon-chain/execution:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
-        "//consensus-types/light-client:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
 
@@ -31,14 +28,10 @@ go_test(
     deps = [
         ":go_default_library",
         "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/light-client:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -333,7 +333,8 @@ func ProcessBlockForStateRoot(
 				return nil, errors.Wrap(err, "could not process withdrawals")
 			}
 		}
-		if err = b.ProcessPayload(state, blk.Body()); err != nil {
+		state, err = b.ProcessPayload(state, blk.Body())
+		if err != nil {
 			return nil, errors.Wrap(err, "could not process execution data")
 		}
 	}

beacon-chain/core/transition/transition_test.go

@@ -698,45 +698,3 @@ func TestProcessSlotsConditionally(t *testing.T) {
 		assert.Equal(t, primitives.Slot(6), s.Slot())
 	})
 }
-
-func BenchmarkProcessSlots_Capella(b *testing.B) {
-	st, _ := util.DeterministicGenesisStateCapella(b, params.BeaconConfig().MaxValidatorsPerCommittee)
-
-	var err error
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		st, err = transition.ProcessSlots(context.Background(), st, st.Slot()+1)
-		if err != nil {
-			b.Fatalf("Failed to process slot %v", err)
-		}
-	}
-}
-
-func BenchmarkProcessSlots_Deneb(b *testing.B) {
-	st, _ := util.DeterministicGenesisStateDeneb(b, params.BeaconConfig().MaxValidatorsPerCommittee)
-
-	var err error
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		st, err = transition.ProcessSlots(context.Background(), st, st.Slot()+1)
-		if err != nil {
-			b.Fatalf("Failed to process slot %v", err)
-		}
-	}
-}
-
-func BenchmarkProcessSlots_Electra(b *testing.B) {
-	st, _ := util.DeterministicGenesisStateElectra(b, params.BeaconConfig().MaxValidatorsPerCommittee)
-
-	var err error
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		st, err = transition.ProcessSlots(context.Background(), st, st.Slot()+1)
-		if err != nil {
-			b.Fatalf("Failed to process slot %v", err)
-		}
-	}
-}

beacon-chain/core/validators/validator.go

@@ -241,35 +241,76 @@ func SlashedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validat
 	return slashed
 }
 
-// ExitedValidatorIndices returns the indices of validators who exited during the specified epoch.
-//
-// A validator is considered to have exited during an epoch if their ExitEpoch equals the epoch and
-// excludes validators that have been ejected.
-// This function simplifies the exit determination by directly checking the validator's ExitEpoch,
-// avoiding the complexities and potential inaccuracies of calculating withdrawable epochs.
-func ExitedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator) ([]primitives.ValidatorIndex, error) {
+// ExitedValidatorIndices determines the indices exited during the current epoch.
+func ExitedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator, activeValidatorCount uint64) ([]primitives.ValidatorIndex, error) {
 	exited := make([]primitives.ValidatorIndex, 0)
+	exitEpochs := make([]primitives.Epoch, 0)
+	for i := 0; i < len(validators); i++ {
+		val := validators[i]
+		if val.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+			exitEpochs = append(exitEpochs, val.ExitEpoch)
+		}
+	}
+	exitQueueEpoch := primitives.Epoch(0)
+	for _, i := range exitEpochs {
+		if exitQueueEpoch < i {
+			exitQueueEpoch = i
+		}
+	}
+
+	// We use the exit queue churn to determine if we have passed a churn limit.
+	exitQueueChurn := uint64(0)
+	for _, val := range validators {
+		if val.ExitEpoch == exitQueueEpoch {
+			exitQueueChurn++
+		}
+	}
+	churn := helpers.ValidatorExitChurnLimit(activeValidatorCount)
+	if churn < exitQueueChurn {
+		exitQueueEpoch++
+	}
+	withdrawableEpoch := exitQueueEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
 	for i, val := range validators {
-		if val.ExitEpoch == epoch && val.EffectiveBalance > params.BeaconConfig().EjectionBalance {
+		if val.ExitEpoch == epoch && val.WithdrawableEpoch == withdrawableEpoch &&
+			val.EffectiveBalance > params.BeaconConfig().EjectionBalance {
 			exited = append(exited, primitives.ValidatorIndex(i))
 		}
 	}
 	return exited, nil
 }
 
-// EjectedValidatorIndices returns the indices of validators who were ejected during the specified epoch.
-//
-// A validator is considered ejected during an epoch if:
-// - Their ExitEpoch equals the epoch.
-// - Their EffectiveBalance is less than or equal to the EjectionBalance threshold.
-//
-// This function simplifies the ejection determination by directly checking the validator's ExitEpoch
-// and EffectiveBalance, avoiding the complexities and potential inaccuracies of calculating
-// withdrawable epochs.
-func EjectedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator) ([]primitives.ValidatorIndex, error) {
+// EjectedValidatorIndices determines the indices ejected during the given epoch.
+func EjectedValidatorIndices(epoch primitives.Epoch, validators []*ethpb.Validator, activeValidatorCount uint64) ([]primitives.ValidatorIndex, error) {
 	ejected := make([]primitives.ValidatorIndex, 0)
+	exitEpochs := make([]primitives.Epoch, 0)
+	for i := 0; i < len(validators); i++ {
+		val := validators[i]
+		if val.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
+			exitEpochs = append(exitEpochs, val.ExitEpoch)
+		}
+	}
+	exitQueueEpoch := primitives.Epoch(0)
+	for _, i := range exitEpochs {
+		if exitQueueEpoch < i {
+			exitQueueEpoch = i
+		}
+	}
+
+	// We use the exit queue churn to determine if we have passed a churn limit.
+	exitQueueChurn := uint64(0)
+	for _, val := range validators {
+		if val.ExitEpoch == exitQueueEpoch {
+			exitQueueChurn++
+		}
+	}
+	churn := helpers.ValidatorExitChurnLimit(activeValidatorCount)
+	if churn < exitQueueChurn {
+		exitQueueEpoch++
+	}
+	withdrawableEpoch := exitQueueEpoch + params.BeaconConfig().MinValidatorWithdrawabilityDelay
 	for i, val := range validators {
-		if val.ExitEpoch == epoch && val.EffectiveBalance <= params.BeaconConfig().EjectionBalance {
+		if val.ExitEpoch == epoch && val.WithdrawableEpoch == withdrawableEpoch &&
+			val.EffectiveBalance <= params.BeaconConfig().EjectionBalance {
 			ejected = append(ejected, primitives.ValidatorIndex(i))
 		}
 	}

beacon-chain/core/validators/validator_test.go

@@ -217,7 +217,6 @@ func TestSlashValidator_OK(t *testing.T) {
 }
 
 func TestSlashValidator_Electra(t *testing.T) {
-	helpers.ClearCache()
 	validatorCount := 100
 	registry := make([]*ethpb.Validator, 0, validatorCount)
 	balances := make([]uint64, 0, validatorCount)
@@ -390,16 +389,19 @@ func TestExitedValidatorIndices(t *testing.T) {
 			state: &ethpb.BeaconState{
 				Validators: []*ethpb.Validator{
 					{
-						EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-						ExitEpoch:        0,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance,
+						ExitEpoch:         0,
+						WithdrawableEpoch: params.BeaconConfig().MinValidatorWithdrawabilityDelay,
 					},
 					{
-						EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-						ExitEpoch:        10,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance,
+						ExitEpoch:         0,
+						WithdrawableEpoch: 10,
 					},
 					{
-						EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
-						ExitEpoch:        0,
+						EffectiveBalance:  params.BeaconConfig().MaxEffectiveBalance,
+						ExitEpoch:         0,
+						WithdrawableEpoch: params.BeaconConfig().MinValidatorWithdrawabilityDelay,
 					},
 				},
 			},
@@ -431,7 +433,11 @@ func TestExitedValidatorIndices(t *testing.T) {
 		},
 	}
 	for _, tt := range tests {
-		exitedIndices, err := validators.ExitedValidatorIndices(0, tt.state.Validators)
+		s, err := state_native.InitializeFromProtoPhase0(tt.state)
+		require.NoError(t, err)
+		activeCount, err := helpers.ActiveValidatorCount(context.Background(), s, time.PrevEpoch(s))
+		require.NoError(t, err)
+		exitedIndices, err := validators.ExitedValidatorIndices(0, tt.state.Validators, activeCount)
 		require.NoError(t, err)
 		assert.DeepEqual(t, tt.wanted, exitedIndices)
 	}

beacon-chain/das/BUILD.bazel

@@ -13,6 +13,7 @@ go_library(
     deps = [
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -34,6 +35,7 @@ go_test(
     deps = [
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",

beacon-chain/das/availability.go

@@ -83,10 +83,10 @@ func (s *LazilyPersistentStore) Persist(current primitives.Slot, sc ...blocks.RO
 func (s *LazilyPersistentStore) IsDataAvailable(ctx context.Context, current primitives.Slot, b blocks.ROBlock) error {
 	blockCommitments, err := commitmentsToCheck(b, current)
 	if err != nil {
-		return errors.Wrapf(err, "could not check data availability for block %#x", b.Root())
+		return errors.Wrapf(err, "could check data availability for block %#x", b.Root())
 	}
 	// Return early for blocks that are pre-deneb or which do not have any commitments.
-	if len(blockCommitments) == 0 {
+	if blockCommitments.count() == 0 {
 		return nil
 	}
 
@@ -106,7 +106,7 @@ func (s *LazilyPersistentStore) IsDataAvailable(ctx context.Context, current pri
 	// Verify we have all the expected sidecars, and fail fast if any are missing or inconsistent.
 	// We don't try to salvage problematic batches because this indicates a misbehaving peer and we'd rather
 	// ignore their response and decrease their peer score.
-	sidecars, err := entry.filter(root, blockCommitments, b.Block().Slot())
+	sidecars, err := entry.filter(root, blockCommitments)
 	if err != nil {
 		return errors.Wrap(err, "incomplete BlobSidecar batch")
 	}
@@ -137,28 +137,22 @@ func (s *LazilyPersistentStore) IsDataAvailable(ctx context.Context, current pri
 	return nil
 }
 
-func commitmentsToCheck(b blocks.ROBlock, current primitives.Slot) ([][]byte, error) {
+func commitmentsToCheck(b blocks.ROBlock, current primitives.Slot) (safeCommitmentArray, error) {
+	var ar safeCommitmentArray
 	if b.Version() < version.Deneb {
-		return nil, nil
+		return ar, nil
 	}
-
-	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUEST
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
 	if !params.WithinDAPeriod(slots.ToEpoch(b.Block().Slot()), slots.ToEpoch(current)) {
-		return nil, nil
+		return ar, nil
 	}
-
-	kzgCommitments, err := b.Block().Body().BlobKzgCommitments()
+	kc, err := b.Block().Body().BlobKzgCommitments()
 	if err != nil {
-		return nil, err
+		return ar, err
 	}
-
-	maxBlobCount := params.BeaconConfig().MaxBlobsPerBlock(b.Block().Slot())
-	if len(kzgCommitments) > maxBlobCount {
-		return nil, errIndexOutOfBounds
+	if len(kc) > len(ar) {
+		return ar, errIndexOutOfBounds
 	}
-
-	result := make([][]byte, len(kzgCommitments))
-	copy(result, kzgCommitments)
-
-	return result, nil
+	copy(ar[:], kc)
+	return ar, nil
 }

beacon-chain/das/availability_test.go

@@ -8,6 +8,7 @@ import (
 	errors "github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -88,7 +89,7 @@ func Test_commitmentsToCheck(t *testing.T) {
 				require.NoError(t, err)
 				c, err := rb.Block().Body().BlobKzgCommitments()
 				require.NoError(t, err)
-				require.Equal(t, true, len(c) > params.BeaconConfig().MaxBlobsPerBlock(sb.Block().Slot()))
+				require.Equal(t, true, len(c) > fieldparams.MaxBlobsPerBlock)
 				return rb
 			},
 			slot: windowSlots + 1,
@@ -104,7 +105,7 @@ func Test_commitmentsToCheck(t *testing.T) {
 			} else {
 				require.NoError(t, err)
 			}
-			require.Equal(t, len(c.commits), len(co))
+			require.Equal(t, len(c.commits), co.count())
 			for i := 0; i < len(c.commits); i++ {
 				require.Equal(t, true, bytes.Equal(c.commits[i], co[i]))
 			}

beacon-chain/das/cache.go

@@ -5,7 +5,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
@@ -60,7 +60,7 @@ func (c *cache) delete(key cacheKey) {
 
 // cacheEntry holds a fixed-length cache of BlobSidecars.
 type cacheEntry struct {
-	scs         []*blocks.ROBlob
+	scs         [fieldparams.MaxBlobsPerBlock]*blocks.ROBlob
 	diskSummary filesystem.BlobStorageSummary
 }
 
@@ -72,13 +72,9 @@ func (e *cacheEntry) setDiskSummary(sum filesystem.BlobStorageSummary) {
 // Only the first BlobSidecar of a given Index will be kept in the cache.
 // stash will return an error if the given blob is already in the cache, or if the Index is out of bounds.
 func (e *cacheEntry) stash(sc *blocks.ROBlob) error {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(sc.Slot())
-	if sc.Index >= uint64(maxBlobsPerBlock) {
+	if sc.Index >= fieldparams.MaxBlobsPerBlock {
 		return errors.Wrapf(errIndexOutOfBounds, "index=%d", sc.Index)
 	}
-	if e.scs == nil {
-		e.scs = make([]*blocks.ROBlob, maxBlobsPerBlock)
-	}
 	if e.scs[sc.Index] != nil {
 		return errors.Wrapf(ErrDuplicateSidecar, "root=%#x, index=%d, commitment=%#x", sc.BlockRoot(), sc.Index, sc.KzgCommitment)
 	}
@@ -92,13 +88,12 @@ func (e *cacheEntry) stash(sc *blocks.ROBlob) error {
 // commitments were found in the cache and the sidecar slice return value can be used
 // to perform a DA check against the cached sidecars.
 // filter only returns blobs that need to be checked. Blobs already available on disk will be excluded.
-func (e *cacheEntry) filter(root [32]byte, kc [][]byte, slot primitives.Slot) ([]blocks.ROBlob, error) {
-	count := len(kc)
-	if e.diskSummary.AllAvailable(count) {
+func (e *cacheEntry) filter(root [32]byte, kc safeCommitmentArray) ([]blocks.ROBlob, error) {
+	if e.diskSummary.AllAvailable(kc.count()) {
 		return nil, nil
 	}
-	scs := make([]blocks.ROBlob, 0, count)
-	for i := uint64(0); i < uint64(count); i++ {
+	scs := make([]blocks.ROBlob, 0, kc.count())
+	for i := uint64(0); i < fieldparams.MaxBlobsPerBlock; i++ {
 		// We already have this blob, we don't need to write it or validate it.
 		if e.diskSummary.HasIndex(i) {
 			continue
@@ -121,3 +116,16 @@ func (e *cacheEntry) filter(root [32]byte, kc [][]byte, slot primitives.Slot) ([
 
 	return scs, nil
 }
+
+// safeCommitmentArray is a fixed size array of commitment byte slices. This is helpful for avoiding
+// gratuitous bounds checks.
+type safeCommitmentArray [fieldparams.MaxBlobsPerBlock][]byte
+
+func (s safeCommitmentArray) count() int {
+	for i := range s {
+		if s[i] == nil {
+			return i
+		}
+	}
+	return fieldparams.MaxBlobsPerBlock
+}

beacon-chain/das/cache_test.go

@@ -29,10 +29,10 @@ func TestCacheEnsureDelete(t *testing.T) {
 	require.Equal(t, nilEntry, c.entries[k])
 }
 
-type filterTestCaseSetupFunc func(t *testing.T) (*cacheEntry, [][]byte, []blocks.ROBlob)
+type filterTestCaseSetupFunc func(t *testing.T) (*cacheEntry, safeCommitmentArray, []blocks.ROBlob)
 
 func filterTestCaseSetup(slot primitives.Slot, nBlobs int, onDisk []int, numExpected int) filterTestCaseSetupFunc {
-	return func(t *testing.T) (*cacheEntry, [][]byte, []blocks.ROBlob) {
+	return func(t *testing.T) (*cacheEntry, safeCommitmentArray, []blocks.ROBlob) {
 		blk, blobs := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, nBlobs)
 		commits, err := commitmentsToCheck(blk, blk.Block().Slot())
 		require.NoError(t, err)
@@ -44,7 +44,7 @@ func filterTestCaseSetup(slot primitives.Slot, nBlobs int, onDisk []int, numExpe
 			entry.setDiskSummary(sum)
 		}
 		expected := make([]blocks.ROBlob, 0, nBlobs)
-		for i := 0; i < len(commits); i++ {
+		for i := 0; i < commits.count(); i++ {
 			if entry.diskSummary.HasIndex(uint64(i)) {
 				continue
 			}
@@ -113,7 +113,7 @@ func TestFilterDiskSummary(t *testing.T) {
 		t.Run(c.name, func(t *testing.T) {
 			entry, commits, expected := c.setup(t)
 			// first (root) argument doesn't matter, it is just for logs
-			got, err := entry.filter([32]byte{}, commits, 100)
+			got, err := entry.filter([32]byte{}, commits)
 			require.NoError(t, err)
 			require.Equal(t, len(expected), len(got))
 		})
@@ -125,12 +125,12 @@ func TestFilter(t *testing.T) {
 	require.NoError(t, err)
 	cases := []struct {
 		name  string
-		setup func(t *testing.T) (*cacheEntry, [][]byte, []blocks.ROBlob)
+		setup func(t *testing.T) (*cacheEntry, safeCommitmentArray, []blocks.ROBlob)
 		err   error
 	}{
 		{
 			name: "commitments mismatch - extra sidecar",
-			setup: func(t *testing.T) (*cacheEntry, [][]byte, []blocks.ROBlob) {
+			setup: func(t *testing.T) (*cacheEntry, safeCommitmentArray, []blocks.ROBlob) {
 				entry, commits, expected := filterTestCaseSetup(denebSlot, 6, []int{0, 1}, 4)(t)
 				commits[5] = nil
 				return entry, commits, expected
@@ -139,7 +139,7 @@ func TestFilter(t *testing.T) {
 		},
 		{
 			name: "sidecar missing",
-			setup: func(t *testing.T) (*cacheEntry, [][]byte, []blocks.ROBlob) {
+			setup: func(t *testing.T) (*cacheEntry, safeCommitmentArray, []blocks.ROBlob) {
 				entry, commits, expected := filterTestCaseSetup(denebSlot, 6, []int{0, 1}, 4)(t)
 				entry.scs[5] = nil
 				return entry, commits, expected
@@ -148,7 +148,7 @@ func TestFilter(t *testing.T) {
 		},
 		{
 			name: "commitments mismatch - different bytes",
-			setup: func(t *testing.T) (*cacheEntry, [][]byte, []blocks.ROBlob) {
+			setup: func(t *testing.T) (*cacheEntry, safeCommitmentArray, []blocks.ROBlob) {
 				entry, commits, expected := filterTestCaseSetup(denebSlot, 6, []int{0, 1}, 4)(t)
 				entry.scs[5].KzgCommitment = []byte("nope")
 				return entry, commits, expected
@@ -160,7 +160,7 @@ func TestFilter(t *testing.T) {
 		t.Run(c.name, func(t *testing.T) {
 			entry, commits, expected := c.setup(t)
 			// first (root) argument doesn't matter, it is just for logs
-			got, err := entry.filter([32]byte{}, commits, 100)
+			got, err := entry.filter([32]byte{}, commits)
 			if c.err != nil {
 				require.ErrorIs(t, err, c.err)
 				return

beacon-chain/db/filesystem/BUILD.bazel

@@ -42,7 +42,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/verification:go_default_library",
-        "//config/params:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/db/filesystem/blob.go

@@ -13,7 +13,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -25,7 +25,7 @@ import (
 )
 
 var (
-	errIndexOutOfBounds    = errors.New("blob index in file name >= DeprecatedMaxBlobsPerBlock")
+	errIndexOutOfBounds    = errors.New("blob index in file name >= MaxBlobsPerBlock")
 	errEmptyBlobWritten    = errors.New("zero bytes written to disk when saving blob sidecar")
 	errSidecarEmptySSZData = errors.New("sidecar marshalled to an empty ssz byte slice")
 	errNoBasePath          = errors.New("BlobStorage base path not specified in init")
@@ -109,11 +109,10 @@ func (bs *BlobStorage) WarmCache() {
 	}
 	go func() {
 		start := time.Now()
-		log.Info("Blob filesystem cache warm-up started. This may take a few minutes.")
 		if err := bs.pruner.warmCache(); err != nil {
 			log.WithError(err).Error("Error encountered while warming up blob pruner cache")
 		}
-		log.WithField("elapsed", time.Since(start)).Info("Blob filesystem cache warm-up complete")
+		log.WithField("elapsed", time.Since(start)).Info("Blob filesystem cache warm-up complete.")
 	}()
 }
 
@@ -219,7 +218,6 @@ func (bs *BlobStorage) Save(sidecar blocks.VerifiedROBlob) error {
 	partialMoved = true
 	blobsWrittenCounter.Inc()
 	blobSaveLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-
 	return nil
 }
 
@@ -257,10 +255,8 @@ func (bs *BlobStorage) Remove(root [32]byte) error {
 // Indices generates a bitmap representing which BlobSidecar.Index values are present on disk for a given root.
 // This value can be compared to the commitments observed in a block to determine which indices need to be found
 // on the network to confirm data availability.
-func (bs *BlobStorage) Indices(root [32]byte, s primitives.Slot) ([]bool, error) {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(s)
-	mask := make([]bool, maxBlobsPerBlock)
-
+func (bs *BlobStorage) Indices(root [32]byte) ([fieldparams.MaxBlobsPerBlock]bool, error) {
+	var mask [fieldparams.MaxBlobsPerBlock]bool
 	rootDir := blobNamer{root: root}.dir()
 	entries, err := afero.ReadDir(bs.fs, rootDir)
 	if err != nil {
@@ -269,7 +265,6 @@ func (bs *BlobStorage) Indices(root [32]byte, s primitives.Slot) ([]bool, error)
 		}
 		return mask, err
 	}
-
 	for i := range entries {
 		if entries[i].IsDir() {
 			continue
@@ -286,7 +281,7 @@ func (bs *BlobStorage) Indices(root [32]byte, s primitives.Slot) ([]bool, error)
 		if err != nil {
 			return mask, errors.Wrapf(err, "unexpected directory entry breaks listing, %s", parts[0])
 		}
-		if u >= uint64(maxBlobsPerBlock) {
+		if u >= fieldparams.MaxBlobsPerBlock {
 			return mask, errIndexOutOfBounds
 		}
 		mask[u] = true

beacon-chain/db/filesystem/blob_test.go

@@ -10,7 +10,7 @@ import (
 
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -20,7 +20,7 @@ import (
 )
 
 func TestBlobStorage_SaveBlobData(t *testing.T) {
-	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, params.BeaconConfig().MaxBlobsPerBlock(1))
+	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, fieldparams.MaxBlobsPerBlock)
 	testSidecars, err := verification.BlobSidecarSliceNoop(sidecars)
 	require.NoError(t, err)
 
@@ -56,10 +56,10 @@ func TestBlobStorage_SaveBlobData(t *testing.T) {
 		require.NoError(t, bs.Save(sc))
 		actualSc, err := bs.Get(sc.BlockRoot(), sc.Index)
 		require.NoError(t, err)
-		expectedIdx := []bool{false, false, true, false, false, false}
-		actualIdx, err := bs.Indices(actualSc.BlockRoot(), 100)
+		expectedIdx := [fieldparams.MaxBlobsPerBlock]bool{false, false, true}
+		actualIdx, err := bs.Indices(actualSc.BlockRoot())
 		require.NoError(t, err)
-		require.DeepEqual(t, expectedIdx, actualIdx)
+		require.Equal(t, expectedIdx, actualIdx)
 	})
 
 	t.Run("round trip write then read", func(t *testing.T) {
@@ -132,19 +132,19 @@ func TestBlobIndicesBounds(t *testing.T) {
 	fs, bs := NewEphemeralBlobStorageWithFs(t)
 	root := [32]byte{}
 
-	okIdx := uint64(params.BeaconConfig().MaxBlobsPerBlock(0)) - 1
+	okIdx := uint64(fieldparams.MaxBlobsPerBlock - 1)
 	writeFakeSSZ(t, fs, root, okIdx)
-	indices, err := bs.Indices(root, 100)
+	indices, err := bs.Indices(root)
 	require.NoError(t, err)
-	expected := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+	var expected [fieldparams.MaxBlobsPerBlock]bool
 	expected[okIdx] = true
 	for i := range expected {
 		require.Equal(t, expected[i], indices[i])
 	}
 
-	oobIdx := uint64(params.BeaconConfig().MaxBlobsPerBlock(0))
+	oobIdx := uint64(fieldparams.MaxBlobsPerBlock)
 	writeFakeSSZ(t, fs, root, oobIdx)
-	_, err = bs.Indices(root, 100)
+	_, err = bs.Indices(root)
 	require.ErrorIs(t, err, errIndexOutOfBounds)
 }
 
@@ -163,7 +163,7 @@ func TestBlobStoragePrune(t *testing.T) {
 	fs, bs := NewEphemeralBlobStorageWithFs(t)
 
 	t.Run("PruneOne", func(t *testing.T) {
-		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 300, params.BeaconConfig().MaxBlobsPerBlock(0))
+		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 300, fieldparams.MaxBlobsPerBlock)
 		testSidecars, err := verification.BlobSidecarSliceNoop(sidecars)
 		require.NoError(t, err)
 
@@ -178,7 +178,7 @@ func TestBlobStoragePrune(t *testing.T) {
 		require.Equal(t, 0, len(remainingFolders))
 	})
 	t.Run("Prune dangling blob", func(t *testing.T) {
-		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 299, params.BeaconConfig().MaxBlobsPerBlock(0))
+		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 299, fieldparams.MaxBlobsPerBlock)
 		testSidecars, err := verification.BlobSidecarSliceNoop(sidecars)
 		require.NoError(t, err)
 
@@ -198,7 +198,7 @@ func TestBlobStoragePrune(t *testing.T) {
 
 		for j := 0; j <= blockQty; j++ {
 			root := bytesutil.ToBytes32(bytesutil.ToBytes(uint64(slot), 32))
-			_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, root, slot, params.BeaconConfig().MaxBlobsPerBlock(0))
+			_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, root, slot, fieldparams.MaxBlobsPerBlock)
 			testSidecars, err := verification.BlobSidecarSliceNoop(sidecars)
 			require.NoError(t, err)
 			require.NoError(t, bs.Save(testSidecars[0]))
@@ -224,7 +224,7 @@ func BenchmarkPruning(b *testing.B) {
 
 	for j := 0; j <= blockQty; j++ {
 		root := bytesutil.ToBytes32(bytesutil.ToBytes(uint64(slot), 32))
-		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, root, slot, params.BeaconConfig().MaxBlobsPerBlock(0))
+		_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, root, slot, fieldparams.MaxBlobsPerBlock)
 		testSidecars, err := verification.BlobSidecarSliceNoop(sidecars)
 		require.NoError(t, err)
 		require.NoError(t, bs.Save(testSidecars[0]))

beacon-chain/db/filesystem/cache.go

@@ -9,7 +9,7 @@ import (
 )
 
 // blobIndexMask is a bitmask representing the set of blob indices that are currently set.
-type blobIndexMask []bool
+type blobIndexMask [fieldparams.MaxBlobsPerBlock]bool
 
 // BlobStorageSummary represents cached information about the BlobSidecars on disk for each root the cache knows about.
 type BlobStorageSummary struct {
@@ -20,11 +20,7 @@ type BlobStorageSummary struct {
 // HasIndex returns true if the BlobSidecar at the given index is available in the filesystem.
 func (s BlobStorageSummary) HasIndex(idx uint64) bool {
 	// Protect from panic, but assume callers are sophisticated enough to not need an error telling them they have an invalid idx.
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(s.slot)
-	if idx >= uint64(maxBlobsPerBlock) {
-		return false
-	}
-	if idx >= uint64(len(s.mask)) {
+	if idx >= fieldparams.MaxBlobsPerBlock {
 		return false
 	}
 	return s.mask[idx]
@@ -32,11 +28,7 @@ func (s BlobStorageSummary) HasIndex(idx uint64) bool {
 
 // AllAvailable returns true if we have all blobs for all indices from 0 to count-1.
 func (s BlobStorageSummary) AllAvailable(count int) bool {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(s.slot)
-	if count > maxBlobsPerBlock {
-		return false
-	}
-	if count > len(s.mask) {
+	if count > fieldparams.MaxBlobsPerBlock {
 		return false
 	}
 	for i := 0; i < count; i++ {
@@ -76,17 +68,13 @@ func (s *blobStorageCache) Summary(root [32]byte) BlobStorageSummary {
 }
 
 func (s *blobStorageCache) ensure(key [32]byte, slot primitives.Slot, idx uint64) error {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
-	if idx >= uint64(maxBlobsPerBlock) {
+	if idx >= fieldparams.MaxBlobsPerBlock {
 		return errIndexOutOfBounds
 	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	v := s.cache[key]
 	v.slot = slot
-	if v.mask == nil {
-		v.mask = make(blobIndexMask, maxBlobsPerBlock)
-	}
 	if !v.mask[idx] {
 		s.updateMetrics(1)
 	}

beacon-chain/db/filesystem/cache_test.go

@@ -3,17 +3,13 @@ package filesystem
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/config/params"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
 func TestSlotByRoot_Summary(t *testing.T) {
-	noneSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
-	allSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
-	firstSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
-	lastSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
-	oneSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+	var noneSet, allSet, firstSet, lastSet, oneSet blobIndexMask
 	firstSet[0] = true
 	lastSet[len(lastSet)-1] = true
 	oneSet[1] = true
@@ -23,49 +19,49 @@ func TestSlotByRoot_Summary(t *testing.T) {
 	cases := []struct {
 		name     string
 		root     [32]byte
-		expected blobIndexMask
+		expected *blobIndexMask
 	}{
 		{
 			name: "not found",
 		},
 		{
 			name:     "none set",
-			expected: noneSet,
+			expected: &noneSet,
 		},
 		{
 			name:     "index 1 set",
-			expected: oneSet,
+			expected: &oneSet,
 		},
 		{
 			name:     "all set",
-			expected: allSet,
+			expected: &allSet,
 		},
 		{
 			name:     "first set",
-			expected: firstSet,
+			expected: &firstSet,
 		},
 		{
 			name:     "last set",
-			expected: lastSet,
+			expected: &lastSet,
 		},
 	}
 	sc := newBlobStorageCache()
 	for _, c := range cases {
 		if c.expected != nil {
 			key := bytesutil.ToBytes32([]byte(c.name))
-			sc.cache[key] = BlobStorageSummary{slot: 0, mask: c.expected}
+			sc.cache[key] = BlobStorageSummary{slot: 0, mask: *c.expected}
 		}
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
 			key := bytesutil.ToBytes32([]byte(c.name))
 			sum := sc.Summary(key)
-			for i, has := range c.expected {
+			for i := range c.expected {
 				ui := uint64(i)
 				if c.expected == nil {
 					require.Equal(t, false, sum.HasIndex(ui))
 				} else {
-					require.Equal(t, has, sum.HasIndex(ui))
+					require.Equal(t, c.expected[i], sum.HasIndex(ui))
 				}
 			}
 		})
@@ -125,13 +121,13 @@ func TestAllAvailable(t *testing.T) {
 		},
 		{
 			name:  "out of bound is safe",
-			count: params.BeaconConfig().MaxBlobsPerBlock(0) + 1,
+			count: fieldparams.MaxBlobsPerBlock + 1,
 			aa:    false,
 		},
 		{
 			name:   "max present",
-			count:  params.BeaconConfig().MaxBlobsPerBlock(0),
-			idxSet: idxUpTo(params.BeaconConfig().MaxBlobsPerBlock(0)),
+			count:  fieldparams.MaxBlobsPerBlock,
+			idxSet: idxUpTo(fieldparams.MaxBlobsPerBlock),
 			aa:     true,
 		},
 		{
@@ -143,7 +139,7 @@ func TestAllAvailable(t *testing.T) {
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			mask := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+			var mask blobIndexMask
 			for _, idx := range c.idxSet {
 				mask[idx] = true
 			}

beacon-chain/db/filesystem/pruner_test.go

@@ -12,7 +12,7 @@ import (
 	"time"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -25,7 +25,7 @@ func TestTryPruneDir_CachedNotExpired(t *testing.T) {
 	pr, err := newBlobPruner(fs, 0)
 	require.NoError(t, err)
 	slot := pr.windowSize
-	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, params.BeaconConfig().MaxBlobsPerBlock(slot))
+	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, fieldparams.MaxBlobsPerBlock)
 	sc, err := verification.BlobSidecarNoop(sidecars[0])
 	require.NoError(t, err)
 	rootStr := rootString(sc.BlockRoot())

beacon-chain/db/iface/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//monitoring/backup:go_default_library",
         "//proto/dbval:go_default_library",
+        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
     ],

beacon-chain/db/iface/interface.go

@@ -7,6 +7,8 @@ import (
 	"context"
 	"io"
 
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filters"
 	slashertypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
@@ -57,9 +59,8 @@ type ReadOnlyDatabase interface {
 	FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error)
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
 	// light client operations
-	LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error)
-	LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error)
-	LightClientBootstrap(ctx context.Context, blockRoot []byte) (interfaces.LightClientBootstrap, error)
+	LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]*ethpbv2.LightClientUpdateWithVersion, error)
+	LightClientUpdate(ctx context.Context, period uint64) (*ethpbv2.LightClientUpdateWithVersion, error)
 
 	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
@@ -97,8 +98,7 @@ type NoHeadAccessDatabase interface {
 	SaveFeeRecipientsByValidatorIDs(ctx context.Context, ids []primitives.ValidatorIndex, addrs []common.Address) error
 	SaveRegistrationsByValidatorIDs(ctx context.Context, ids []primitives.ValidatorIndex, regs []*ethpb.ValidatorRegistrationV1) error
 	// light client operations
-	SaveLightClientUpdate(ctx context.Context, period uint64, update interfaces.LightClientUpdate) error
-	SaveLightClientBootstrap(ctx context.Context, blockRoot []byte, bootstrap interfaces.LightClientBootstrap) error
+	SaveLightClientUpdate(ctx context.Context, period uint64, update *ethpbv2.LightClientUpdateWithVersion) error
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
 }