Merge branch 'single-att' of github.com:prysmaticlabs/prysm into devnet5

# Conflicts:
#	CHANGELOG.md
#	beacon-chain/rpc/eth/beacon/handlers_pool.go
#	beacon-chain/rpc/prysm/v1alpha1/validator/attester.go
#	beacon-chain/rpc/prysm/v1alpha1/validator/server.go
#	beacon-chain/rpc/service.go
#	proto/prysm/v1alpha1/attestation.go

.github/PULL_REQUEST_TEMPLATE.md

@@ -33,5 +33,5 @@ Fixes #
 **Acknowledgements**
 
 - [ ] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
-- [ ] I have included a uniquely named [changelog fragment file](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md#maintaining-changelogmd).
+- [ ] I have made an appropriate entry to [CHANGELOG.md](https://github.com/prysmaticlabs/prysm/blob/develop/CHANGELOG.md).
 - [ ] I have added a description to this PR with sufficient context for reviewers to understand this PR.

.github/workflows/changelog.yml

@@ -1,34 +1,33 @@
-# This workflow will build a golang project
-# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-go
-
-name: changelog
+name: CI
 
 on:
   pull_request:
-    branches: [ "develop" ]
+    branches:
+      - develop
 
 jobs:
-  run-changelog-check:
-    runs-on: ubuntu-latest
+  changed_files:
+    runs-on: ubuntu-latest 
+    name: Check CHANGELOG.md
     steps:
-      - name: Checkout source code
-        uses: actions/checkout@v3
-
-      - name: Download unclog binary
-        uses: dsaltares/fetch-gh-release-asset@aa2ab1243d6e0d5b405b973c89fa4d06a2d0fff7 # 1.1.2
-        with:
-          repo: OffchainLabs/unclog
-          version: "tags/v0.1.3"
-          file: "unclog"
-
-      - name: Get new changelog files
-        id: new-changelog-files
+      - uses: actions/checkout@v4
+      - name: changelog modified
+        id: changelog-modified
         uses: tj-actions/changed-files@v45
         with:
-          files: |
-            changelog/**.md
+          files: CHANGELOG.md
 
-      - name: Run lint command
+      - name: List all changed files
         env:
-          ALL_ADDED_MARKDOWN: ${{ steps.new-changelog-files.outputs.added_files }}
-        run: chmod +x unclog && ./unclog check -fragment-env=ALL_ADDED_MARKDOWN
+          ALL_CHANGED_FILES: ${{ steps.changelog-modified.outputs.all_changed_files }}
+        run: |
+          if [[ ${ALL_CHANGED_FILES[*]} =~ (^|[[:space:]])"CHANGELOG.md"($|[[:space:]]) ]];
+          then
+            echo "CHANGELOG.md was modified.";
+            exit 0;
+          else
+            echo "CHANGELOG.md was not modified.";
+            echo "Please see CHANGELOG.md and follow the instructions to add your changes to that file."
+            echo "In some rare scenarios, a changelog entry is not required and this CI check can be ignored."
+            exit 1;
+          fi

.github/workflows/fuzz.yml

@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.22.10'
+          go-version: '1.22.3'
       - id: list
         uses: shogo82148/actions-go-fuzz/list@v0
         with:
@@ -36,7 +36,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.22.10'
+          go-version: '1.22.3'
       - uses: shogo82148/actions-go-fuzz/run@v0
         with:
           packages: ${{ matrix.package }}

.github/workflows/go.yml

@@ -31,7 +31,7 @@ jobs:
       - name: Set up Go 1.22
         uses: actions/setup-go@v4
         with:
-          go-version: '1.22.10'
+          go-version: '1.22.6'
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
@@ -48,7 +48,7 @@ jobs:
       - name: Set up Go 1.22
         uses: actions/setup-go@v4
         with:
-          go-version: '1.22.10'
+          go-version: '1.22.6'
           id: go
 
       - name: Golangci-lint
@@ -64,7 +64,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v4
         with:
-          go-version: '1.22.10'
+          go-version: '1.22.6'
         id: go
 
       - name: Check out code into the Go module directory

.golangci.yml

@@ -6,7 +6,7 @@ run:
     - proto
     - tools/analyzers
   timeout: 10m
-  go: '1.22.10'
+  go: '1.22.6'
 
 linters:
   enable-all: true

CHANGELOG.md

@@ -4,6 +4,45 @@ 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.
+
+### 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.
+
+### 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.
+
+### 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.
@@ -106,7 +145,7 @@ Notable features:
 - 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. Alternatively, 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 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
@@ -120,7 +159,7 @@ Notable features:
 - 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 improvement, removing some redundant or duplicate logs
+- 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
@@ -150,7 +189,7 @@ meantime we are issuing a patch that recovers from the panic to prevent the node
 
 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 instead of prysm's stock grpc endpoints) or accessory software that connects to the events api,
+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 
@@ -393,7 +432,7 @@ Updating to this release is recommended at your earliest convenience, especially
 - use time.NewTimer() to avoid possible memory leaks
 - paranoid underflow protection without error handling
 - Fix CommitteeAssignments to not return every validator
-- Fix dependent root retrieval genesis case
+- Fix dependent root retrival genesis case
 - Restrict Dials From Discovery
 - Always close cache warm chan to prevent blocking
 - Keep only the latest value in the health channel
@@ -545,7 +584,7 @@ block profit. If you want to preserve the existing behavior, set --local-block-v
 - handle special case of batch size=1
 - Always Set Inprogress Boolean In Cache
 - Builder APIs: adding headers to post endpoint
-- Rename misspelled variable
+- Rename mispelled variable
 - allow blob by root within da period
 - Rewrite Pruning Implementation To Handle EIP 7045
 - Set default fee recipient if tracked val fails
@@ -615,7 +654,7 @@ Known Issues
 - Support beacon_committee_selections
 - /eth/v1/beacon/deposit_snapshot
 - Docker images now have coreutils pre-installed
-- da_waited_time_milliseconds tracks total time waiting for data availability check in ReceiveBlock
+- da_waited_time_milliseconds tracks total time waiting for data availablity check in ReceiveBlock
 - blob_written, blob_disk_count, blob_disk_bytes new metrics for tracking blobs on disk
 - Backfill supports blob backfilling
 - Add mainnet deneb fork epoch config
@@ -790,7 +829,7 @@ and Raspberry Pi users.
 - Add Goerli Deneb Fork Epoch
 - Use deneb key for deneb state in saveStatesEfficientInternal
 - Initialize Inactivity Scores Correctly
-- Excludes DA wait time for chain processing time
+- Excluse DA wait time for chain processing time
 - Initialize sig cache for verification.Initializer
 - Verify roblobs
 - KZG Commitment inclusion proof verifier
@@ -823,7 +862,7 @@ and Raspberry Pi users.
 - Exit early if blob by root request is empty
 - Request missing blobs while processing pending queue
 - Check blob exists before requesting from peer
-- Passing block as argument for sidecar validation
+- Passing block as arugment for sidecar validation
 
 #### Blob Management
 
@@ -1120,13 +1159,13 @@ _Most of the PRs here involve shifting our http endpoints to using vanilla http
 - Remove no-op cancel func
 - Update Terms of Service
 - fix head slot in log
-- DEPRECATION: Remove exchange transition configuration call
+- DEPRECTATION: Remove exchange transition configuration call
 - fix segmentation fork when Capella for epoch is MaxUint64
 - Return Error Gracefully When Removing 4881 Flag
 - Add zero length check on indices during NextSyncCommitteeIndices
 - Replace Empty Slice Literals with Nil Slices
 - Refactor Error String Formatting According to Go Best Practices
-- Fix redundant type conversion
+- Fix redundant type converstion
 - docs: fix typo
 - Add Clarification To Sync Committee Cache
 - Fix typos
@@ -1148,7 +1187,7 @@ small set of users.
 
 ### Security
 
-No security issues in this release.
+No security issues in thsi release.
 
 ## [v4.1.0](https://github.com/prysmaticlabs/prysm/compare/v4.0.8...v4.1.0) - 2023-08-22
 
@@ -1664,7 +1703,7 @@ notes [here](https://hackmd.io/TtyFurRJRKuklG3n8lMO9Q). This release is **strong
 Note: The released docker images are using the portable version of the blst cryptography library. The Prysm team will
 release docker images with the non-portable blst library as the default image. In the meantime, you can compile docker
 images with blst non-portable locally with the `--define=blst_modern=true` bazel flag, use the "-modern-" assets
-attached to releases, or set environment variable USE_PRYSM_MODERN=true when using prysm.sh.
+attached to releases, or set environment varaible USE_PRYSM_MODERN=true when using prysm.sh.
 
 ### Added
 
@@ -2013,7 +2052,7 @@ There are some known issues with this release.
 - Beacon node can bootstrap from non-genesis state (i.e bellatrix state)
 - Refactor bytesutil, add support for go1.20 slice to array conversions
 - Add Span information for attestation record save request
-- Metric addition
+- Matric addition
 - Identify invalid signature within batch verification
 - Support for getting consensus values from beacon config
 - EIP-4881: Spec implementation
@@ -2079,7 +2118,7 @@ See [flashbots/mev-boost#404](https://github.com/flashbots/mev-boost/issues/404)
 - Added more histogram metrics for block arrival latency times block_arrival_latency_milliseconds
 - Priority queue RetrieveByKey now uses read lock instead of write lock
 - Use custom types for certain ethclient requests. Fixes an issue when using prysm on gnosis chain.
-- Updated forkchoice endpoint /eth/v1/debug/forkchoice (was /eth/v1/debug/beacon/forkchoice)
+- Updted forkchoice endpoint /eth/v1/debug/forkchoice (was /eth/v1/debug/beacon/forkchoice)
 - Include empty fields in builder json client.
 - Computing committee assignments for slots older than the oldest historical root in the beacon state is now forbidden
 
@@ -2311,7 +2350,7 @@ There are no security updates in this release.
   removed: `GetBeaconState`, `ProduceBlock`, `ListForkChoiceHeads`, `ListBlocks`, `SubmitValidatorRegistration`, `GetBlock`, `ProposeBlock`
 - API: Forkchoice method `GetForkChoice` has been removed.
 - All previously deprecated feature flags have been
-  removed. `--enable-active-balance-cache`, `--correctly-prune-canonical-atts`, `--correctly-insert-orphaned-atts`, `--enable-next-slot-state-cache`, `--enable-batch-gossip-verification`, `--enable-get-block-optimizations`, `--enable-balance-trie-computation`, `--disable-next-slot-state-cache`, `--attestation-aggregation-strategy`, `--attestation-aggregation-force-opt-maxcover`, `--pyrmont`, `--disable-get-block-optimizations`, `--disable-proposer-atts-selection-using-max-cover`, `--disable-optimized-balance-update`, `--disable-active-balance-cache`, `--disable-balance-trie-computation`, `--disable-batch-gossip-verification`, `--disable-correctly-prune-canonical-atts`, `--disable-correctly-insert-orphaned-atts`, `--enable-native-state`, `--enable-peer-scorer`, `--enable-gossip-batch-aggregation`, `--experimental-disable-boundary-checks`
+  removed. `--enable-active-balance-cache`, `--correctly-prune-canonical-atts`, `--correctly-insert-orphaned-atts`, `--enable-next-slot-state-cache`, `--enable-batch-gossip-verification`, `--enable-get-block-optimizations`, `--enable-balance-trie-computation`, `--disable-next-slot-state-cache`, `--attestation-aggregation-strategy`, `--attestation-aggregation-force-opt-maxcover`, `--pyrmont`, `--disable-get-block-optimizations`, `--disable-proposer-atts-selection-using-max-cover`, `--disable-optimized-balance-update`, `--disable-active-balance-cache`, `--disable-balance-trie-computation`, `--disable-batch-gossip-verification`, `--disable-correctly-prune-canonical-atts`, `--disable-correctly-insert-orphaned-atts`, `--enable-native-state`, `--enable-peer-scorer`, `--enable-gossip-batch-aggregation`, `--experimental-disable-boundry-checks`
 - Validator Web API: Removed unused ImportAccounts and DeleteAccounts rpc options
 
 ### Fixed
@@ -2527,7 +2566,7 @@ There are two known issues with this release:
 - Bellatrix support. See [kiln testnet instructions](https://hackmd.io/OqIoTiQvS9KOIataIFksBQ?view)
 - Weak subjectivity sync / checkpoint sync. This is an experimental feature and may have unintended side effects for
   certain operators serving historical data. See
-  the [documentation](https://docs.prylabs.network/docs/prysm-usage/checkpoint-sync) for more details.
+  the [documentation](https://docs.prylabs.network/docs/next/prysm-usage/checkpoint-sync) for more details.
 - A faster build of blst for beacon chain on linux amd64. Use the environment variable `USE_PRYSM_MODERN=true` with
   prysm.sh, use the "modern" binary, or bazel build with `--define=blst_modern=true`.
 - Vectorized sha256. This may have performance improvements with use of the new flag `--enable-vectorized-htr`.
@@ -2708,7 +2747,7 @@ notes [here](https://github.com/prysmaticlabs/prysm-web-ui/releases/tag/v1.0.0)
 - Added uint64 overflow protection
 - Sync committee pool returns empty slice instead of nil on cache miss
 - Improved description of datadir flag
-- Simplified web password requirements
+- Simplied web password requirements
 - Web JWT tokens no longer expire.
 - Updated keymanager protos
 - Watch and update jwt secret when auth token file updated on disk.
@@ -2719,7 +2758,7 @@ notes [here](https://github.com/prysmaticlabs/prysm-web-ui/releases/tag/v1.0.0)
 - Refactor for weak subjectivity sync implementation
 - Update naming for Atlair previous epoch attester
 - Remove duplicate MerkleizeTrieLeaves method.
-- Add explicit error for validator flag checks on out of bound positions
+- Add explict error for validator flag checks on out of bound positions
 - Simplify method to check if the beacon chain client should update the justified epoch value.
 - Rename web UI performance endpoint to "summary"
 - Refactor powchain service to be more functional
@@ -2745,7 +2784,7 @@ notes [here](https://github.com/prysmaticlabs/prysm-web-ui/releases/tag/v1.0.0)
   Upstream go-ethereum is now used with familiar go.mod tooling.
 - Removed duplicate aggergation validation p2p pipelines.
 - Metrics calculation removed extra condition
-- Removed superfluous errors from peer scoring parameters registration
+- Removed superflous errors from peer scoring parameters registration
 
 ### Fixed
 

CONTRIBUTING.md

@@ -125,7 +125,7 @@ Navigate to your fork of the repo on GitHub. On the upper left where the current
 
 **16. Add an entry to CHANGELOG.md.**
 
-All PRs must must include a changelog fragment file in the `changelog` directory. If your change is not user-facing or should not be mentioned in the changelog for some other reason, you may use the `Ignored` changelog section in your fragment's header to satisfy this requirement without altering the final release changelog. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
+If your change is user facing, you must include a CHANGELOG.md entry. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
 
 **17. Create a pull request.**
 
@@ -177,10 +177,16 @@ $ git push myrepo feature-in-progress-branch -f
 
 ## Maintaining CHANGELOG.md
 
-This project follows the changelog guidelines from [keepachangelog.com](https://keepachangelog.com/en/1.1.0/). In order to minimize conflicts and workflow headaches, we chose to implement a changelog management
-strategy that uses changelog "fragment" files, managed by our changelog management tool called `unclog`. Each PR must include a new changelog fragment file in the `changelog` directory, as specified by unclog's
-[README.md](https://github.com/OffchainLabs/unclog?tab=readme-ov-file#what-is-a-changelog-fragment). As the `unclog` README suggests in the [Best Practices](https://github.com/OffchainLabs/unclog?tab=readme-ov-file#best-practices) section, 
-the standard naming convention for your PR's fragment file, to avoid conflicting with another fragment file, is `changelog/<github user name>_<PR branch name>.md`.
+This project follows the changelog guidelines from [keepachangelog.com](https://keepachangelog.com/en/1.1.0/).
+
+All PRs with user facing changes should have an entry in the CHANGELOG.md file and the change should be categorized in the appropriate category within the "Unreleased" section. The categories are:
+
+-  `Added` for new features.
+-  `Changed` for changes in existing functionality.
+-  `Deprecated` for soon-to-be removed features.
+-  `Removed` for now removed features.
+-  `Fixed` for any bug fixes.
+-  `Security` in case of vulnerabilities. Please see the [Security Policy](SECURITY.md) for responsible disclosure before adding a change with this category.
 
 ### Releasing
 

INTEROP.md

@@ -4,7 +4,7 @@ This README details how to setup Prysm for interop testing for usage with other
 
 > [!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
+> outdated interop guides or instructions. If you experience issues with this guide, please file and
 > issue for visibility and propose fixes, if possible.
 
 ## Installation & Setup
@@ -74,19 +74,19 @@ bazel run //cmd/beacon-chain --config=minimal -- \
 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.
+- `--` is a flag divider to distingish 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.
+- `--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 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. 
 
 ```
-bazel run //cmd/validator --config=minimal -- --datadir=/tmp/validator --interop-num-validators=256 --minimal-config --suggested-fee-recipient=0x8A04d14125D0FDCDc742F4A05C051De07232EDa4
+bazel run //cmd/validator --config=minimal -- --datadir=/tmp/validator --interopt-num-validators=256 --minimal-config --suggested-fee-recipient=0x8A04d14125D0FDCDc742F4A05C051De07232EDa4
 ```
 
 This will launch and kickstart the system with your 256 validators performing their duties accordingly.

WORKSPACE

@@ -182,7 +182,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.22.10",
+    go_version = "1.22.4",
     nogo = "@//:nogo",
 )
 
@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-beta.0"
+consensus_spec_version = "v1.5.0-alpha.10"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-HdMlTN3wv+hUMCkIRPk+EHcLixY1cSZlvkx3obEp4AM=",
+    integrity = "sha256-NtWIhbO/mVMb1edq5jqABL0o8R1tNFiuG8PCMAsUHcs=",
     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-eX/ihmHQ+OvfoGJxSMgy22yAU3SZ3xjsX0FU0EaZrSs=",
+    integrity = "sha256-DFlFlnzls1bBrDm+/xD8NK2ivvkhxR+rSNVLLqScVKc=",
     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-k3Onf42vOzIqyddecR6G82sDy3mmDA+R8RN66QjB0GI=",
+    integrity = "sha256-G9ENPF8udZL/BqRHbi60GhFPnZDPZAH6UjcjRiOlvbk=",
     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-N/d4AwdOSlb70Dr+2l20dfXxNSzJDj/qKA9Rkn8Gb5w=",
+    integrity = "sha256-ClOLKkmAcEi8/uKi6LDeqthask5+E3sgxVoA0bqmQ0c=",
     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/client_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -123,7 +124,7 @@ func TestClient_RegisterValidator(t *testing.T) {
 func TestClient_GetHeader(t *testing.T) {
 	ctx := context.Background()
 	expectedPath := "/eth/v1/builder/header/23/0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2/0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
-	var slot primitives.Slot = 23
+	var slot types.Slot = 23
 	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
 	pubkey := ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
 	t.Run("server error", func(t *testing.T) {
@@ -369,7 +370,7 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, 1, len(withdrawals))
 		assert.Equal(t, uint64(1), withdrawals[0].Index)
-		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
+		assert.Equal(t, types.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
 		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 	})
@@ -408,7 +409,7 @@ func TestSubmitBlindedBlock(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, 1, len(withdrawals))
 		assert.Equal(t, uint64(1), withdrawals[0].Index)
-		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
+		assert.Equal(t, types.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
 		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 		require.NotNil(t, blobBundle)

api/server/structs/block.go

@@ -14,10 +14,6 @@ type SignedMessageJsoner interface {
 	SigString() string
 }
 
-// ----------------------------------------------------------------------------
-// Phase 0
-// ----------------------------------------------------------------------------
-
 type SignedBeaconBlock struct {
 	Message   *BeaconBlock `json:"message"`
 	Signature string       `json:"signature"`
@@ -52,29 +48,6 @@ type BeaconBlockBody struct {
 	VoluntaryExits    []*SignedVoluntaryExit `json:"voluntary_exits"`
 }
 
-type SignedBeaconBlockHeaderContainer struct {
-	Header    *SignedBeaconBlockHeader `json:"header"`
-	Root      string                   `json:"root"`
-	Canonical bool                     `json:"canonical"`
-}
-
-type SignedBeaconBlockHeader struct {
-	Message   *BeaconBlockHeader `json:"message"`
-	Signature string             `json:"signature"`
-}
-
-type BeaconBlockHeader struct {
-	Slot          string `json:"slot"`
-	ProposerIndex string `json:"proposer_index"`
-	ParentRoot    string `json:"parent_root"`
-	StateRoot     string `json:"state_root"`
-	BodyRoot      string `json:"body_root"`
-}
-
-// ----------------------------------------------------------------------------
-// Altair
-// ----------------------------------------------------------------------------
-
 type SignedBeaconBlockAltair struct {
 	Message   *BeaconBlockAltair `json:"message"`
 	Signature string             `json:"signature"`
@@ -110,10 +83,6 @@ type BeaconBlockBodyAltair struct {
 	SyncAggregate     *SyncAggregate         `json:"sync_aggregate"`
 }
 
-// ----------------------------------------------------------------------------
-// Bellatrix
-// ----------------------------------------------------------------------------
-
 type SignedBeaconBlockBellatrix struct {
 	Message   *BeaconBlockBellatrix `json:"message"`
 	Signature string                `json:"signature"`
@@ -186,44 +155,6 @@ type BlindedBeaconBlockBodyBellatrix struct {
 	ExecutionPayloadHeader *ExecutionPayloadHeader `json:"execution_payload_header"`
 }
 
-type ExecutionPayload struct {
-	ParentHash    string   `json:"parent_hash"`
-	FeeRecipient  string   `json:"fee_recipient"`
-	StateRoot     string   `json:"state_root"`
-	ReceiptsRoot  string   `json:"receipts_root"`
-	LogsBloom     string   `json:"logs_bloom"`
-	PrevRandao    string   `json:"prev_randao"`
-	BlockNumber   string   `json:"block_number"`
-	GasLimit      string   `json:"gas_limit"`
-	GasUsed       string   `json:"gas_used"`
-	Timestamp     string   `json:"timestamp"`
-	ExtraData     string   `json:"extra_data"`
-	BaseFeePerGas string   `json:"base_fee_per_gas"`
-	BlockHash     string   `json:"block_hash"`
-	Transactions  []string `json:"transactions"`
-}
-
-type ExecutionPayloadHeader struct {
-	ParentHash       string `json:"parent_hash"`
-	FeeRecipient     string `json:"fee_recipient"`
-	StateRoot        string `json:"state_root"`
-	ReceiptsRoot     string `json:"receipts_root"`
-	LogsBloom        string `json:"logs_bloom"`
-	PrevRandao       string `json:"prev_randao"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	Timestamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data"`
-	BaseFeePerGas    string `json:"base_fee_per_gas"`
-	BlockHash        string `json:"block_hash"`
-	TransactionsRoot string `json:"transactions_root"`
-}
-
-// ----------------------------------------------------------------------------
-// Capella
-// ----------------------------------------------------------------------------
-
 type SignedBeaconBlockCapella struct {
 	Message   *BeaconBlockCapella `json:"message"`
 	Signature string              `json:"signature"`
@@ -298,46 +229,6 @@ type BlindedBeaconBlockBodyCapella struct {
 	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
 }
 
-type ExecutionPayloadCapella struct {
-	ParentHash    string        `json:"parent_hash"`
-	FeeRecipient  string        `json:"fee_recipient"`
-	StateRoot     string        `json:"state_root"`
-	ReceiptsRoot  string        `json:"receipts_root"`
-	LogsBloom     string        `json:"logs_bloom"`
-	PrevRandao    string        `json:"prev_randao"`
-	BlockNumber   string        `json:"block_number"`
-	GasLimit      string        `json:"gas_limit"`
-	GasUsed       string        `json:"gas_used"`
-	Timestamp     string        `json:"timestamp"`
-	ExtraData     string        `json:"extra_data"`
-	BaseFeePerGas string        `json:"base_fee_per_gas"`
-	BlockHash     string        `json:"block_hash"`
-	Transactions  []string      `json:"transactions"`
-	Withdrawals   []*Withdrawal `json:"withdrawals"`
-}
-
-type ExecutionPayloadHeaderCapella struct {
-	ParentHash       string `json:"parent_hash"`
-	FeeRecipient     string `json:"fee_recipient"`
-	StateRoot        string `json:"state_root"`
-	ReceiptsRoot     string `json:"receipts_root"`
-	LogsBloom        string `json:"logs_bloom"`
-	PrevRandao       string `json:"prev_randao"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	Timestamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data"`
-	BaseFeePerGas    string `json:"base_fee_per_gas"`
-	BlockHash        string `json:"block_hash"`
-	TransactionsRoot string `json:"transactions_root"`
-	WithdrawalsRoot  string `json:"withdrawals_root"`
-}
-
-// ----------------------------------------------------------------------------
-// Deneb
-// ----------------------------------------------------------------------------
-
 type SignedBeaconBlockContentsDeneb struct {
 	SignedBlock *SignedBeaconBlockDeneb `json:"signed_block"`
 	KzgProofs   []string                `json:"kzg_proofs"`
@@ -426,50 +317,6 @@ type BlindedBeaconBlockBodyDeneb struct {
 	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
 }
 
-type ExecutionPayloadDeneb struct {
-	ParentHash    string        `json:"parent_hash"`
-	FeeRecipient  string        `json:"fee_recipient"`
-	StateRoot     string        `json:"state_root"`
-	ReceiptsRoot  string        `json:"receipts_root"`
-	LogsBloom     string        `json:"logs_bloom"`
-	PrevRandao    string        `json:"prev_randao"`
-	BlockNumber   string        `json:"block_number"`
-	GasLimit      string        `json:"gas_limit"`
-	GasUsed       string        `json:"gas_used"`
-	Timestamp     string        `json:"timestamp"`
-	ExtraData     string        `json:"extra_data"`
-	BaseFeePerGas string        `json:"base_fee_per_gas"`
-	BlockHash     string        `json:"block_hash"`
-	Transactions  []string      `json:"transactions"`
-	Withdrawals   []*Withdrawal `json:"withdrawals"`
-	BlobGasUsed   string        `json:"blob_gas_used"`
-	ExcessBlobGas string        `json:"excess_blob_gas"`
-}
-
-type ExecutionPayloadHeaderDeneb struct {
-	ParentHash       string `json:"parent_hash"`
-	FeeRecipient     string `json:"fee_recipient"`
-	StateRoot        string `json:"state_root"`
-	ReceiptsRoot     string `json:"receipts_root"`
-	LogsBloom        string `json:"logs_bloom"`
-	PrevRandao       string `json:"prev_randao"`
-	BlockNumber      string `json:"block_number"`
-	GasLimit         string `json:"gas_limit"`
-	GasUsed          string `json:"gas_used"`
-	Timestamp        string `json:"timestamp"`
-	ExtraData        string `json:"extra_data"`
-	BaseFeePerGas    string `json:"base_fee_per_gas"`
-	BlockHash        string `json:"block_hash"`
-	TransactionsRoot string `json:"transactions_root"`
-	WithdrawalsRoot  string `json:"withdrawals_root"`
-	BlobGasUsed      string `json:"blob_gas_used"`
-	ExcessBlobGas    string `json:"excess_blob_gas"`
-}
-
-// ----------------------------------------------------------------------------
-// Electra
-// ----------------------------------------------------------------------------
-
 type SignedBeaconBlockContentsElectra struct {
 	SignedBlock *SignedBeaconBlockElectra `json:"signed_block"`
 	KzgProofs   []string                  `json:"kzg_proofs"`
@@ -515,7 +362,7 @@ type BeaconBlockBodyElectra struct {
 	Deposits              []*Deposit                    `json:"deposits"`
 	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits"`
 	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayload      *ExecutionPayloadDeneb        `json:"execution_payload"`
+	ExecutionPayload      *ExecutionPayloadElectra      `json:"execution_payload"`
 	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
 	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
 	ExecutionRequests     *ExecutionRequests            `json:"execution_requests"`
@@ -545,119 +392,156 @@ func (s *SignedBlindedBeaconBlockElectra) SigString() string {
 }
 
 type BlindedBeaconBlockBodyElectra struct {
-	RandaoReveal           string                        `json:"randao_reveal"`
-	Eth1Data               *Eth1Data                     `json:"eth1_data"`
-	Graffiti               string                        `json:"graffiti"`
-	ProposerSlashings      []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings      []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations           []*AttestationElectra         `json:"attestations"`
-	Deposits               []*Deposit                    `json:"deposits"`
-	VoluntaryExits         []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate          *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayloadHeader *ExecutionPayloadHeaderDeneb  `json:"execution_payload_header"`
-	BLSToExecutionChanges  []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
-	ExecutionRequests      *ExecutionRequests            `json:"execution_requests"`
+	RandaoReveal           string                         `json:"randao_reveal"`
+	Eth1Data               *Eth1Data                      `json:"eth1_data"`
+	Graffiti               string                         `json:"graffiti"`
+	ProposerSlashings      []*ProposerSlashing            `json:"proposer_slashings"`
+	AttesterSlashings      []*AttesterSlashingElectra     `json:"attester_slashings"`
+	Attestations           []*AttestationElectra          `json:"attestations"`
+	Deposits               []*Deposit                     `json:"deposits"`
+	VoluntaryExits         []*SignedVoluntaryExit         `json:"voluntary_exits"`
+	SyncAggregate          *SyncAggregate                 `json:"sync_aggregate"`
+	ExecutionPayloadHeader *ExecutionPayloadHeaderElectra `json:"execution_payload_header"`
+	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
+	BlobKzgCommitments     []string                       `json:"blob_kzg_commitments"`
+	ExecutionRequests      *ExecutionRequests             `json:"execution_requests"`
 }
 
-type (
-	ExecutionRequests struct {
-		Deposits       []*DepositRequest       `json:"deposits"`
-		Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
-		Consolidations []*ConsolidationRequest `json:"consolidations"`
-	}
-)
-
-// ----------------------------------------------------------------------------
-// Fulu
-// ----------------------------------------------------------------------------
-
-type SignedBeaconBlockContentsFulu struct {
-	SignedBlock *SignedBeaconBlockFulu `json:"signed_block"`
-	KzgProofs   []string               `json:"kzg_proofs"`
-	Blobs       []string               `json:"blobs"`
+type SignedBeaconBlockHeaderContainer struct {
+	Header    *SignedBeaconBlockHeader `json:"header"`
+	Root      string                   `json:"root"`
+	Canonical bool                     `json:"canonical"`
 }
 
-type BeaconBlockContentsFulu struct {
-	Block     *BeaconBlockFulu `json:"block"`
-	KzgProofs []string         `json:"kzg_proofs"`
-	Blobs     []string         `json:"blobs"`
+type SignedBeaconBlockHeader struct {
+	Message   *BeaconBlockHeader `json:"message"`
+	Signature string             `json:"signature"`
 }
 
-type SignedBeaconBlockFulu struct {
-	Message   *BeaconBlockFulu `json:"message"`
-	Signature string           `json:"signature"`
+type BeaconBlockHeader struct {
+	Slot          string `json:"slot"`
+	ProposerIndex string `json:"proposer_index"`
+	ParentRoot    string `json:"parent_root"`
+	StateRoot     string `json:"state_root"`
+	BodyRoot      string `json:"body_root"`
 }
 
-var _ SignedMessageJsoner = &SignedBeaconBlockFulu{}
-
-func (s *SignedBeaconBlockFulu) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
+type ExecutionPayload struct {
+	ParentHash    string   `json:"parent_hash"`
+	FeeRecipient  string   `json:"fee_recipient"`
+	StateRoot     string   `json:"state_root"`
+	ReceiptsRoot  string   `json:"receipts_root"`
+	LogsBloom     string   `json:"logs_bloom"`
+	PrevRandao    string   `json:"prev_randao"`
+	BlockNumber   string   `json:"block_number"`
+	GasLimit      string   `json:"gas_limit"`
+	GasUsed       string   `json:"gas_used"`
+	Timestamp     string   `json:"timestamp"`
+	ExtraData     string   `json:"extra_data"`
+	BaseFeePerGas string   `json:"base_fee_per_gas"`
+	BlockHash     string   `json:"block_hash"`
+	Transactions  []string `json:"transactions"`
 }
 
-func (s *SignedBeaconBlockFulu) SigString() string {
-	return s.Signature
+type ExecutionPayloadHeader struct {
+	ParentHash       string `json:"parent_hash"`
+	FeeRecipient     string `json:"fee_recipient"`
+	StateRoot        string `json:"state_root"`
+	ReceiptsRoot     string `json:"receipts_root"`
+	LogsBloom        string `json:"logs_bloom"`
+	PrevRandao       string `json:"prev_randao"`
+	BlockNumber      string `json:"block_number"`
+	GasLimit         string `json:"gas_limit"`
+	GasUsed          string `json:"gas_used"`
+	Timestamp        string `json:"timestamp"`
+	ExtraData        string `json:"extra_data"`
+	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlockHash        string `json:"block_hash"`
+	TransactionsRoot string `json:"transactions_root"`
 }
 
-type BeaconBlockFulu struct {
-	Slot          string               `json:"slot"`
-	ProposerIndex string               `json:"proposer_index"`
-	ParentRoot    string               `json:"parent_root"`
-	StateRoot     string               `json:"state_root"`
-	Body          *BeaconBlockBodyFulu `json:"body"`
+type ExecutionPayloadCapella struct {
+	ParentHash    string        `json:"parent_hash"`
+	FeeRecipient  string        `json:"fee_recipient"`
+	StateRoot     string        `json:"state_root"`
+	ReceiptsRoot  string        `json:"receipts_root"`
+	LogsBloom     string        `json:"logs_bloom"`
+	PrevRandao    string        `json:"prev_randao"`
+	BlockNumber   string        `json:"block_number"`
+	GasLimit      string        `json:"gas_limit"`
+	GasUsed       string        `json:"gas_used"`
+	Timestamp     string        `json:"timestamp"`
+	ExtraData     string        `json:"extra_data"`
+	BaseFeePerGas string        `json:"base_fee_per_gas"`
+	BlockHash     string        `json:"block_hash"`
+	Transactions  []string      `json:"transactions"`
+	Withdrawals   []*Withdrawal `json:"withdrawals"`
 }
 
-type BeaconBlockBodyFulu struct {
-	RandaoReveal          string                        `json:"randao_reveal"`
-	Eth1Data              *Eth1Data                     `json:"eth1_data"`
-	Graffiti              string                        `json:"graffiti"`
-	ProposerSlashings     []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings     []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations          []*AttestationElectra         `json:"attestations"`
-	Deposits              []*Deposit                    `json:"deposits"`
-	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayload      *ExecutionPayloadDeneb        `json:"execution_payload"`
-	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
-	ExecutionRequests     *ExecutionRequests            `json:"execution_requests"`
+type ExecutionPayloadHeaderCapella struct {
+	ParentHash       string `json:"parent_hash"`
+	FeeRecipient     string `json:"fee_recipient"`
+	StateRoot        string `json:"state_root"`
+	ReceiptsRoot     string `json:"receipts_root"`
+	LogsBloom        string `json:"logs_bloom"`
+	PrevRandao       string `json:"prev_randao"`
+	BlockNumber      string `json:"block_number"`
+	GasLimit         string `json:"gas_limit"`
+	GasUsed          string `json:"gas_used"`
+	Timestamp        string `json:"timestamp"`
+	ExtraData        string `json:"extra_data"`
+	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlockHash        string `json:"block_hash"`
+	TransactionsRoot string `json:"transactions_root"`
+	WithdrawalsRoot  string `json:"withdrawals_root"`
 }
 
-type BlindedBeaconBlockFulu struct {
-	Slot          string                      `json:"slot"`
-	ProposerIndex string                      `json:"proposer_index"`
-	ParentRoot    string                      `json:"parent_root"`
-	StateRoot     string                      `json:"state_root"`
-	Body          *BlindedBeaconBlockBodyFulu `json:"body"`
+type ExecutionPayloadDeneb struct {
+	ParentHash    string        `json:"parent_hash"`
+	FeeRecipient  string        `json:"fee_recipient"`
+	StateRoot     string        `json:"state_root"`
+	ReceiptsRoot  string        `json:"receipts_root"`
+	LogsBloom     string        `json:"logs_bloom"`
+	PrevRandao    string        `json:"prev_randao"`
+	BlockNumber   string        `json:"block_number"`
+	GasLimit      string        `json:"gas_limit"`
+	GasUsed       string        `json:"gas_used"`
+	Timestamp     string        `json:"timestamp"`
+	ExtraData     string        `json:"extra_data"`
+	BaseFeePerGas string        `json:"base_fee_per_gas"`
+	BlockHash     string        `json:"block_hash"`
+	Transactions  []string      `json:"transactions"`
+	Withdrawals   []*Withdrawal `json:"withdrawals"`
+	BlobGasUsed   string        `json:"blob_gas_used"`
+	ExcessBlobGas string        `json:"excess_blob_gas"`
 }
 
-type SignedBlindedBeaconBlockFulu struct {
-	Message   *BlindedBeaconBlockFulu `json:"message"`
-	Signature string                  `json:"signature"`
+type ExecutionPayloadElectra = ExecutionPayloadDeneb
+
+type ExecutionPayloadHeaderDeneb struct {
+	ParentHash       string `json:"parent_hash"`
+	FeeRecipient     string `json:"fee_recipient"`
+	StateRoot        string `json:"state_root"`
+	ReceiptsRoot     string `json:"receipts_root"`
+	LogsBloom        string `json:"logs_bloom"`
+	PrevRandao       string `json:"prev_randao"`
+	BlockNumber      string `json:"block_number"`
+	GasLimit         string `json:"gas_limit"`
+	GasUsed          string `json:"gas_used"`
+	Timestamp        string `json:"timestamp"`
+	ExtraData        string `json:"extra_data"`
+	BaseFeePerGas    string `json:"base_fee_per_gas"`
+	BlockHash        string `json:"block_hash"`
+	TransactionsRoot string `json:"transactions_root"`
+	WithdrawalsRoot  string `json:"withdrawals_root"`
+	BlobGasUsed      string `json:"blob_gas_used"`
+	ExcessBlobGas    string `json:"excess_blob_gas"`
 }
 
-var _ SignedMessageJsoner = &SignedBlindedBeaconBlockFulu{}
+type ExecutionPayloadHeaderElectra = ExecutionPayloadHeaderDeneb
 
-func (s *SignedBlindedBeaconBlockFulu) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
-}
-
-func (s *SignedBlindedBeaconBlockFulu) SigString() string {
-	return s.Signature
-}
-
-type BlindedBeaconBlockBodyFulu struct {
-	RandaoReveal           string                        `json:"randao_reveal"`
-	Eth1Data               *Eth1Data                     `json:"eth1_data"`
-	Graffiti               string                        `json:"graffiti"`
-	ProposerSlashings      []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings      []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations           []*AttestationElectra         `json:"attestations"`
-	Deposits               []*Deposit                    `json:"deposits"`
-	VoluntaryExits         []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate          *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayloadHeader *ExecutionPayloadHeaderDeneb  `json:"execution_payload_header"`
-	BLSToExecutionChanges  []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
-	ExecutionRequests      *ExecutionRequests            `json:"execution_requests"`
+type ExecutionRequests struct {
+	Deposits       []*DepositRequest       `json:"deposits"`
+	Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
+	Consolidations []*ConsolidationRequest `json:"consolidations"`
 }

api/server/structs/conversions_lightclient.go

@@ -176,9 +176,9 @@ func lightClientHeaderToJSON(header interfaces.LightClientHeader) (json.RawMessa
 		if err != nil {
 			return nil, err
 		}
-		ex, ok := exInterface.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
+		ex, ok := exInterface.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
 		if !ok {
-			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderDeneb{})
+			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderElectra{})
 		}
 		execution, err := ExecutionPayloadHeaderElectraFromConsensus(ex)
 		if err != nil {

api/server/structs/conversions_state.go

@@ -11,10 +11,6 @@ import (
 
 var errPayloadHeaderNotFound = errors.New("expected payload header not found")
 
-// ----------------------------------------------------------------------------
-// Phase 0
-// ----------------------------------------------------------------------------
-
 func BeaconStateFromConsensus(st beaconState.BeaconState) (*BeaconState, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -101,10 +97,6 @@ func BeaconStateFromConsensus(st beaconState.BeaconState) (*BeaconState, error)
 	}, nil
 }
 
-// ----------------------------------------------------------------------------
-// Altair
-// ----------------------------------------------------------------------------
-
 func BeaconStateAltairFromConsensus(st beaconState.BeaconState) (*BeaconStateAltair, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -210,10 +202,6 @@ func BeaconStateAltairFromConsensus(st beaconState.BeaconState) (*BeaconStateAlt
 	}, nil
 }
 
-// ----------------------------------------------------------------------------
-// Bellatrix
-// ----------------------------------------------------------------------------
-
 func BeaconStateBellatrixFromConsensus(st beaconState.BeaconState) (*BeaconStateBellatrix, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -332,10 +320,6 @@ func BeaconStateBellatrixFromConsensus(st beaconState.BeaconState) (*BeaconState
 	}, nil
 }
 
-// ----------------------------------------------------------------------------
-// Capella
-// ----------------------------------------------------------------------------
-
 func BeaconStateCapellaFromConsensus(st beaconState.BeaconState) (*BeaconStateCapella, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -473,10 +457,6 @@ func BeaconStateCapellaFromConsensus(st beaconState.BeaconState) (*BeaconStateCa
 	}, nil
 }
 
-// ----------------------------------------------------------------------------
-// Deneb
-// ----------------------------------------------------------------------------
-
 func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDeneb, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -614,10 +594,6 @@ func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDene
 	}, nil
 }
 
-// ----------------------------------------------------------------------------
-// Electra
-// ----------------------------------------------------------------------------
-
 func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateElectra, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -799,189 +775,3 @@ func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateEl
 		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
 	}, nil
 }
-
-// ----------------------------------------------------------------------------
-// Fulu
-// ----------------------------------------------------------------------------
-
-func BeaconStateFuluFromConsensus(st beaconState.BeaconState) (*BeaconStateFulu, error) {
-	srcBr := st.BlockRoots()
-	br := make([]string, len(srcBr))
-	for i, r := range srcBr {
-		br[i] = hexutil.Encode(r)
-	}
-	srcSr := st.StateRoots()
-	sr := make([]string, len(srcSr))
-	for i, r := range srcSr {
-		sr[i] = hexutil.Encode(r)
-	}
-	srcHr, err := st.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
-	hr := make([]string, len(srcHr))
-	for i, r := range srcHr {
-		hr[i] = hexutil.Encode(r)
-	}
-	srcVotes := st.Eth1DataVotes()
-	votes := make([]*Eth1Data, len(srcVotes))
-	for i, e := range srcVotes {
-		votes[i] = Eth1DataFromConsensus(e)
-	}
-	srcVals := st.Validators()
-	vals := make([]*Validator, len(srcVals))
-	for i, v := range srcVals {
-		vals[i] = ValidatorFromConsensus(v)
-	}
-	srcBals := st.Balances()
-	bals := make([]string, len(srcBals))
-	for i, b := range srcBals {
-		bals[i] = fmt.Sprintf("%d", b)
-	}
-	srcRm := st.RandaoMixes()
-	rm := make([]string, len(srcRm))
-	for i, m := range srcRm {
-		rm[i] = hexutil.Encode(m)
-	}
-	srcSlashings := st.Slashings()
-	slashings := make([]string, len(srcSlashings))
-	for i, s := range srcSlashings {
-		slashings[i] = fmt.Sprintf("%d", s)
-	}
-	srcPrevPart, err := st.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	prevPart := make([]string, len(srcPrevPart))
-	for i, p := range srcPrevPart {
-		prevPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcCurrPart, err := st.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currPart := make([]string, len(srcCurrPart))
-	for i, p := range srcCurrPart {
-		currPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcIs, err := st.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	is := make([]string, len(srcIs))
-	for i, s := range srcIs {
-		is[i] = fmt.Sprintf("%d", s)
-	}
-	currSc, err := st.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSc, err := st.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	execData, err := st.LatestExecutionPayloadHeader()
-	if err != nil {
-		return nil, err
-	}
-	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
-	if !ok {
-		return nil, errPayloadHeaderNotFound
-	}
-	payload, err := ExecutionPayloadHeaderElectraFromConsensus(srcPayload)
-	if err != nil {
-		return nil, err
-	}
-	srcHs, err := st.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	hs := make([]*HistoricalSummary, len(srcHs))
-	for i, s := range srcHs {
-		hs[i] = HistoricalSummaryFromConsensus(s)
-	}
-	nwi, err := st.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	nwvi, err := st.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	drsi, err := st.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, err
-	}
-	dbtc, err := st.DepositBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ebtc, err := st.ExitBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	eee, err := st.EarliestExitEpoch()
-	if err != nil {
-		return nil, err
-	}
-	cbtc, err := st.ConsolidationBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ece, err := st.EarliestConsolidationEpoch()
-	if err != nil {
-		return nil, err
-	}
-	pbd, err := st.PendingDeposits()
-	if err != nil {
-		return nil, err
-	}
-	ppw, err := st.PendingPartialWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	pc, err := st.PendingConsolidations()
-	if err != nil {
-		return nil, err
-	}
-
-	return &BeaconStateFulu{
-		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
-		Slot:                          fmt.Sprintf("%d", st.Slot()),
-		Fork:                          ForkFromConsensus(st.Fork()),
-		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
-		BlockRoots:                    br,
-		StateRoots:                    sr,
-		HistoricalRoots:               hr,
-		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
-		Eth1DataVotes:                 votes,
-		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
-		Validators:                    vals,
-		Balances:                      bals,
-		RandaoMixes:                   rm,
-		Slashings:                     slashings,
-		PreviousEpochParticipation:    prevPart,
-		CurrentEpochParticipation:     currPart,
-		JustificationBits:             hexutil.Encode(st.JustificationBits()),
-		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
-		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
-		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
-		InactivityScores:              is,
-		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
-		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
-		LatestExecutionPayloadHeader:  payload,
-		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
-		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
-		HistoricalSummaries:           hs,
-		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
-		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
-		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
-		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
-		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
-		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
-		PendingDeposits:               PendingDepositsFromConsensus(pbd),
-		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
-		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
-	}, nil
-}

api/server/structs/state.go

@@ -142,81 +142,41 @@ type BeaconStateDeneb struct {
 }
 
 type BeaconStateElectra struct {
-	GenesisTime                   string                       `json:"genesis_time"`
-	GenesisValidatorsRoot         string                       `json:"genesis_validators_root"`
-	Slot                          string                       `json:"slot"`
-	Fork                          *Fork                        `json:"fork"`
-	LatestBlockHeader             *BeaconBlockHeader           `json:"latest_block_header"`
-	BlockRoots                    []string                     `json:"block_roots"`
-	StateRoots                    []string                     `json:"state_roots"`
-	HistoricalRoots               []string                     `json:"historical_roots"`
-	Eth1Data                      *Eth1Data                    `json:"eth1_data"`
-	Eth1DataVotes                 []*Eth1Data                  `json:"eth1_data_votes"`
-	Eth1DepositIndex              string                       `json:"eth1_deposit_index"`
-	Validators                    []*Validator                 `json:"validators"`
-	Balances                      []string                     `json:"balances"`
-	RandaoMixes                   []string                     `json:"randao_mixes"`
-	Slashings                     []string                     `json:"slashings"`
-	PreviousEpochParticipation    []string                     `json:"previous_epoch_participation"`
-	CurrentEpochParticipation     []string                     `json:"current_epoch_participation"`
-	JustificationBits             string                       `json:"justification_bits"`
-	PreviousJustifiedCheckpoint   *Checkpoint                  `json:"previous_justified_checkpoint"`
-	CurrentJustifiedCheckpoint    *Checkpoint                  `json:"current_justified_checkpoint"`
-	FinalizedCheckpoint           *Checkpoint                  `json:"finalized_checkpoint"`
-	InactivityScores              []string                     `json:"inactivity_scores"`
-	CurrentSyncCommittee          *SyncCommittee               `json:"current_sync_committee"`
-	NextSyncCommittee             *SyncCommittee               `json:"next_sync_committee"`
-	LatestExecutionPayloadHeader  *ExecutionPayloadHeaderDeneb `json:"latest_execution_payload_header"`
-	NextWithdrawalIndex           string                       `json:"next_withdrawal_index"`
-	NextWithdrawalValidatorIndex  string                       `json:"next_withdrawal_validator_index"`
-	HistoricalSummaries           []*HistoricalSummary         `json:"historical_summaries"`
-	DepositRequestsStartIndex     string                       `json:"deposit_requests_start_index"`
-	DepositBalanceToConsume       string                       `json:"deposit_balance_to_consume"`
-	ExitBalanceToConsume          string                       `json:"exit_balance_to_consume"`
-	EarliestExitEpoch             string                       `json:"earliest_exit_epoch"`
-	ConsolidationBalanceToConsume string                       `json:"consolidation_balance_to_consume"`
-	EarliestConsolidationEpoch    string                       `json:"earliest_consolidation_epoch"`
-	PendingDeposits               []*PendingDeposit            `json:"pending_deposits"`
-	PendingPartialWithdrawals     []*PendingPartialWithdrawal  `json:"pending_partial_withdrawals"`
-	PendingConsolidations         []*PendingConsolidation      `json:"pending_consolidations"`
-}
-
-type BeaconStateFulu struct {
-	GenesisTime                   string                       `json:"genesis_time"`
-	GenesisValidatorsRoot         string                       `json:"genesis_validators_root"`
-	Slot                          string                       `json:"slot"`
-	Fork                          *Fork                        `json:"fork"`
-	LatestBlockHeader             *BeaconBlockHeader           `json:"latest_block_header"`
-	BlockRoots                    []string                     `json:"block_roots"`
-	StateRoots                    []string                     `json:"state_roots"`
-	HistoricalRoots               []string                     `json:"historical_roots"`
-	Eth1Data                      *Eth1Data                    `json:"eth1_data"`
-	Eth1DataVotes                 []*Eth1Data                  `json:"eth1_data_votes"`
-	Eth1DepositIndex              string                       `json:"eth1_deposit_index"`
-	Validators                    []*Validator                 `json:"validators"`
-	Balances                      []string                     `json:"balances"`
-	RandaoMixes                   []string                     `json:"randao_mixes"`
-	Slashings                     []string                     `json:"slashings"`
-	PreviousEpochParticipation    []string                     `json:"previous_epoch_participation"`
-	CurrentEpochParticipation     []string                     `json:"current_epoch_participation"`
-	JustificationBits             string                       `json:"justification_bits"`
-	PreviousJustifiedCheckpoint   *Checkpoint                  `json:"previous_justified_checkpoint"`
-	CurrentJustifiedCheckpoint    *Checkpoint                  `json:"current_justified_checkpoint"`
-	FinalizedCheckpoint           *Checkpoint                  `json:"finalized_checkpoint"`
-	InactivityScores              []string                     `json:"inactivity_scores"`
-	CurrentSyncCommittee          *SyncCommittee               `json:"current_sync_committee"`
-	NextSyncCommittee             *SyncCommittee               `json:"next_sync_committee"`
-	LatestExecutionPayloadHeader  *ExecutionPayloadHeaderDeneb `json:"latest_execution_payload_header"`
-	NextWithdrawalIndex           string                       `json:"next_withdrawal_index"`
-	NextWithdrawalValidatorIndex  string                       `json:"next_withdrawal_validator_index"`
-	HistoricalSummaries           []*HistoricalSummary         `json:"historical_summaries"`
-	DepositRequestsStartIndex     string                       `json:"deposit_requests_start_index"`
-	DepositBalanceToConsume       string                       `json:"deposit_balance_to_consume"`
-	ExitBalanceToConsume          string                       `json:"exit_balance_to_consume"`
-	EarliestExitEpoch             string                       `json:"earliest_exit_epoch"`
-	ConsolidationBalanceToConsume string                       `json:"consolidation_balance_to_consume"`
-	EarliestConsolidationEpoch    string                       `json:"earliest_consolidation_epoch"`
-	PendingDeposits               []*PendingDeposit            `json:"pending_deposits"`
-	PendingPartialWithdrawals     []*PendingPartialWithdrawal  `json:"pending_partial_withdrawals"`
-	PendingConsolidations         []*PendingConsolidation      `json:"pending_consolidations"`
+	GenesisTime                   string                         `json:"genesis_time"`
+	GenesisValidatorsRoot         string                         `json:"genesis_validators_root"`
+	Slot                          string                         `json:"slot"`
+	Fork                          *Fork                          `json:"fork"`
+	LatestBlockHeader             *BeaconBlockHeader             `json:"latest_block_header"`
+	BlockRoots                    []string                       `json:"block_roots"`
+	StateRoots                    []string                       `json:"state_roots"`
+	HistoricalRoots               []string                       `json:"historical_roots"`
+	Eth1Data                      *Eth1Data                      `json:"eth1_data"`
+	Eth1DataVotes                 []*Eth1Data                    `json:"eth1_data_votes"`
+	Eth1DepositIndex              string                         `json:"eth1_deposit_index"`
+	Validators                    []*Validator                   `json:"validators"`
+	Balances                      []string                       `json:"balances"`
+	RandaoMixes                   []string                       `json:"randao_mixes"`
+	Slashings                     []string                       `json:"slashings"`
+	PreviousEpochParticipation    []string                       `json:"previous_epoch_participation"`
+	CurrentEpochParticipation     []string                       `json:"current_epoch_participation"`
+	JustificationBits             string                         `json:"justification_bits"`
+	PreviousJustifiedCheckpoint   *Checkpoint                    `json:"previous_justified_checkpoint"`
+	CurrentJustifiedCheckpoint    *Checkpoint                    `json:"current_justified_checkpoint"`
+	FinalizedCheckpoint           *Checkpoint                    `json:"finalized_checkpoint"`
+	InactivityScores              []string                       `json:"inactivity_scores"`
+	CurrentSyncCommittee          *SyncCommittee                 `json:"current_sync_committee"`
+	NextSyncCommittee             *SyncCommittee                 `json:"next_sync_committee"`
+	LatestExecutionPayloadHeader  *ExecutionPayloadHeaderElectra `json:"latest_execution_payload_header"`
+	NextWithdrawalIndex           string                         `json:"next_withdrawal_index"`
+	NextWithdrawalValidatorIndex  string                         `json:"next_withdrawal_validator_index"`
+	HistoricalSummaries           []*HistoricalSummary           `json:"historical_summaries"`
+	DepositRequestsStartIndex     string                         `json:"deposit_requests_start_index"`
+	DepositBalanceToConsume       string                         `json:"deposit_balance_to_consume"`
+	ExitBalanceToConsume          string                         `json:"exit_balance_to_consume"`
+	EarliestExitEpoch             string                         `json:"earliest_exit_epoch"`
+	ConsolidationBalanceToConsume string                         `json:"consolidation_balance_to_consume"`
+	EarliestConsolidationEpoch    string                         `json:"earliest_consolidation_epoch"`
+	PendingDeposits               []*PendingDeposit              `json:"pending_deposits"`
+	PendingPartialWithdrawals     []*PendingPartialWithdrawal    `json:"pending_partial_withdrawals"`
+	PendingConsolidations         []*PendingConsolidation        `json:"pending_consolidations"`
 }

beacon-chain/blockchain/execution_engine.go

@@ -362,16 +362,15 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 		return emptyAttri
 	}
 
-	v := st.Version()
-
-	if v >= version.Deneb {
+	var attr payloadattribute.Attributer
+	switch st.Version() {
+	case version.Deneb, version.Electra:
 		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
 			return emptyAttri
 		}
-
-		attr, err := payloadattribute.New(&enginev1.PayloadAttributesV3{
+		attr, err = payloadattribute.New(&enginev1.PayloadAttributesV3{
 			Timestamp:             uint64(t.Unix()),
 			PrevRandao:            prevRando,
 			SuggestedFeeRecipient: val.FeeRecipient[:],
@@ -382,18 +381,13 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			log.WithError(err).Error("Could not get payload attribute")
 			return emptyAttri
 		}
-
-		return attr
-	}
-
-	if v >= version.Capella {
+	case version.Capella:
 		withdrawals, _, err := st.ExpectedWithdrawals()
 		if err != nil {
 			log.WithError(err).Error("Could not get expected withdrawals to get payload attribute")
 			return emptyAttri
 		}
-
-		attr, err := payloadattribute.New(&enginev1.PayloadAttributesV2{
+		attr, err = payloadattribute.New(&enginev1.PayloadAttributesV2{
 			Timestamp:             uint64(t.Unix()),
 			PrevRandao:            prevRando,
 			SuggestedFeeRecipient: val.FeeRecipient[:],
@@ -403,12 +397,8 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			log.WithError(err).Error("Could not get payload attribute")
 			return emptyAttri
 		}
-
-		return attr
-	}
-
-	if v >= version.Bellatrix {
-		attr, err := payloadattribute.New(&enginev1.PayloadAttributes{
+	case version.Bellatrix:
+		attr, err = payloadattribute.New(&enginev1.PayloadAttributes{
 			Timestamp:             uint64(t.Unix()),
 			PrevRandao:            prevRando,
 			SuggestedFeeRecipient: val.FeeRecipient[:],
@@ -417,12 +407,12 @@ func (s *Service) getPayloadAttribute(ctx context.Context, st state.BeaconState,
 			log.WithError(err).Error("Could not get payload attribute")
 			return emptyAttri
 		}
-
-		return attr
+	default:
+		log.WithField("version", st.Version()).Error("Could not get payload attribute due to unknown state version")
+		return emptyAttri
 	}
 
-	log.WithField("version", version.String(st.Version())).Error("Could not get payload attribute due to unknown state version")
-	return emptyAttri
+	return attr
 }
 
 // removeInvalidBlockAndState removes the invalid block, blob and its corresponding state from the cache and DB.

beacon-chain/blockchain/kzg/validation.go

@@ -20,17 +20,16 @@ func Verify(sidecars ...blocks.ROBlob) error {
 	cmts := make([]GoKZG.KZGCommitment, len(sidecars))
 	proofs := make([]GoKZG.KZGProof, len(sidecars))
 	for i, sidecar := range sidecars {
-		blobs[i] = *bytesToBlob(sidecar.Blob)
+		blobs[i] = bytesToBlob(sidecar.Blob)
 		cmts[i] = bytesToCommitment(sidecar.KzgCommitment)
 		proofs[i] = bytesToKZGProof(sidecar.KzgProof)
 	}
 	return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs)
 }
 
-func bytesToBlob(blob []byte) *GoKZG.Blob {
-	var ret GoKZG.Blob
+func bytesToBlob(blob []byte) (ret GoKZG.Blob) {
 	copy(ret[:], blob)
-	return &ret
+	return
 }
 
 func bytesToCommitment(commitment []byte) (ret GoKZG.KZGCommitment) {

beacon-chain/blockchain/kzg/validation_test.go

@@ -10,11 +10,11 @@ import (
 )
 
 func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZGProof, error) {
-	commitment, err := kzgContext.BlobToKZGCommitment(&blob, 0)
+	commitment, err := kzgContext.BlobToKZGCommitment(blob, 0)
 	if err != nil {
 		return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err
 	}
-	proof, err := kzgContext.ComputeBlobKZGProof(&blob, commitment, 0)
+	proof, err := kzgContext.ComputeBlobKZGProof(blob, commitment, 0)
 	if err != nil {
 		return GoKZG.KZGCommitment{}, GoKZG.KZGProof{}, err
 	}
@@ -31,7 +31,7 @@ func TestBytesToAny(t *testing.T) {
 	blob := GoKZG.Blob{0x01, 0x02}
 	commitment := GoKZG.KZGCommitment{0x01, 0x02}
 	proof := GoKZG.KZGProof{0x01, 0x02}
-	require.DeepEqual(t, blob, *bytesToBlob(bytes))
+	require.DeepEqual(t, blob, bytesToBlob(bytes))
 	require.DeepEqual(t, commitment, bytesToCommitment(bytes))
 	require.DeepEqual(t, proof, bytesToKZGProof(bytes))
 }

beacon-chain/blockchain/process_block.go

@@ -69,7 +69,6 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
 		defer s.processLightClientUpdates(cfg)
 		defer s.saveLightClientUpdate(cfg)
-		defer s.saveLightClientBootstrap(cfg)
 	}
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)

beacon-chain/cache/attestation.go

@@ -53,7 +53,7 @@ func NewAttestationCache() *AttestationCache {
 //
 //   - 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 existing list of attestations 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")

beacon-chain/core/altair/epoch_spec_test.go

@@ -105,9 +105,10 @@ func TestProcessSlashings_NotSlashed(t *testing.T) {
 	}
 	s, err := state_native.InitializeFromProtoAltair(base)
 	require.NoError(t, err)
-	require.NoError(t, epoch.ProcessSlashings(s))
+	newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
+	require.NoError(t, err)
 	wanted := params.BeaconConfig().MaxEffectiveBalance
-	assert.Equal(t, wanted, s.Balances()[0], "Unexpected slashed balance")
+	assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
 }
 
 func TestProcessSlashings_SlashedLess(t *testing.T) {
@@ -175,8 +176,9 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
 			original := proto.Clone(tt.state)
 			s, err := state_native.InitializeFromProtoAltair(tt.state)
 			require.NoError(t, err)
-			require.NoError(t, epoch.ProcessSlashings(s))
-			assert.Equal(t, tt.want, s.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, s.Balances()[0])
+			newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
 		})
 	}
 }
@@ -190,5 +192,6 @@ func TestProcessSlashings_BadValue(t *testing.T) {
 	}
 	s, err := state_native.InitializeFromProtoAltair(base)
 	require.NoError(t, err)
-	require.ErrorContains(t, "addition overflows", epoch.ProcessSlashings(s))
+	_, err = epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplierAltair)
+	require.ErrorContains(t, "addition overflows", err)
 }

beacon-chain/core/altair/transition.go

@@ -69,7 +69,12 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	}
 
 	// Modified in Altair and Bellatrix.
-	if err := e.ProcessSlashings(state); err != nil {
+	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
+	if err != nil {
+		return err
+	}
+	state, err = e.ProcessSlashings(state, proportionalSlashingMultiplier)
+	if err != nil {
 		return err
 	}
 	state, err = e.ProcessEth1DataReset(state)

beacon-chain/core/blocks/genesis.go

@@ -198,7 +198,7 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 						SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
 						SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
 					},
-					ExecutionPayload: &enginev1.ExecutionPayloadDeneb{
+					ExecutionPayload: &enginev1.ExecutionPayloadElectra{
 						ParentHash:    make([]byte, 32),
 						FeeRecipient:  make([]byte, 20),
 						StateRoot:     make([]byte, 32),

beacon-chain/core/blocks/withdrawals_test.go

@@ -1152,7 +1152,7 @@ func TestProcessWithdrawals(t *testing.T) {
 						}
 						st, err = state_native.InitializeFromProtoUnsafeElectra(spb)
 						require.NoError(t, err)
-						p, err = consensusblocks.WrappedExecutionPayloadDeneb(&enginev1.ExecutionPayloadDeneb{Withdrawals: test.Args.Withdrawals})
+						p, err = consensusblocks.WrappedExecutionPayloadElectra(&enginev1.ExecutionPayloadElectra{Withdrawals: test.Args.Withdrawals})
 						require.NoError(t, err)
 					default:
 						t.Fatalf("Add a beacon state setup for version %s", version.String(fork))

beacon-chain/core/electra/deposits.go

@@ -15,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	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"
@@ -272,7 +273,7 @@ func ProcessPendingDeposits(ctx context.Context, st state.BeaconState, activeBal
 	isChurnLimitReached := false
 
 	var pendingDepositsToBatchVerify []*ethpb.PendingDeposit
-	var pendingDepositsToPostpone []*ethpb.PendingDeposit
+	var pendingDepositsToPostpone []*eth.PendingDeposit
 
 	depBalToConsume, err := st.DepositBalanceToConsume()
 	if err != nil {

beacon-chain/core/electra/registry_updates.go

@@ -18,24 +18,23 @@ import (
 //
 // Spec pseudocode definition:
 //
-//	def process_registry_updates(state: BeaconState) -> None:
-//	    # Process activation eligibility and ejections
-//	    for index, validator in enumerate(state.validators):
-//	        if is_eligible_for_activation_queue(validator):  # [Modified in Electra:EIP7251]
-//	            validator.activation_eligibility_epoch = get_current_epoch(state) + 1
+//		def process_registry_updates(state: BeaconState) -> None:
+//		    # Process activation eligibility and ejections
+//		    for index, validator in enumerate(state.validators):
+//		        if is_eligible_for_activation_queue(validator):
+//		            validator.activation_eligibility_epoch = get_current_epoch(state) + 1
 //
-//	        if (
-//	            is_active_validator(validator, get_current_epoch(state))
-//	            and validator.effective_balance <= EJECTION_BALANCE
-//	        ):
-//	            initiate_validator_exit(state, ValidatorIndex(index))  # [Modified in Electra:EIP7251]
+//		        if (
+//		            is_active_validator(validator, get_current_epoch(state))
+//		            and validator.effective_balance <= EJECTION_BALANCE
+//		        ):
+//		            initiate_validator_exit(state, ValidatorIndex(index))
 //
-//	    # Activate all eligible validators
-//	    # [Modified in Electra:EIP7251]
-//	    activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
-//	    for validator in state.validators:
-//	        if is_eligible_for_activation(state, validator):
-//	            validator.activation_epoch = activation_epoch
+//	         # Activate all eligible validators
+//	         activation_epoch = compute_activation_exit_epoch(get_current_epoch(state))
+//	         for validator in state.validators:
+//	             if is_eligible_for_activation(state, validator):
+//	                 validator.activation_epoch = activation_epoch
 func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) error {
 	currentEpoch := time.CurrentEpoch(st)
 	ejectionBal := params.BeaconConfig().EjectionBalance
@@ -91,8 +90,8 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) error {
 		}
 	}
 
-	// Activate all eligible validators.
 	for _, idx := range eligibleForActivation {
+		// Activate all eligible validators.
 		v, err := st.ValidatorAtIndex(idx)
 		if err != nil {
 			return err

beacon-chain/core/electra/transition.go

@@ -40,17 +40,14 @@ var (
 //	    process_justification_and_finalization(state)
 //	    process_inactivity_updates(state)
 //	    process_rewards_and_penalties(state)
-//	    process_registry_updates(state)  # [Modified in Electra:EIP7251]
-//	    process_slashings(state)  # [Modified in Electra:EIP7251]
+//	    process_registry_updates(state)
+//	    process_slashings(state)
 //	    process_eth1_data_reset(state)
-//	    process_pending_deposits(state)  # [New in Electra:EIP7251]
-//	    process_pending_consolidations(state)  # [New in Electra:EIP7251]
-//	    process_effective_balance_updates(state)  # [Modified in Electra:EIP7251]
+//	    process_pending_deposits(state)  # New in EIP7251
+//	    process_pending_consolidations(state)  # New in EIP7251
+//	    process_effective_balance_updates(state)
 //	    process_slashings_reset(state)
 //	    process_randao_mixes_reset(state)
-//	    process_historical_summaries_update(state)
-//	    process_participation_flag_updates(state)
-//	    process_sync_committee_updates(state)
 func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	_, span := trace.StartSpan(ctx, "electra.ProcessEpoch")
 	defer span.End()
@@ -78,16 +75,24 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	if err != nil {
 		return errors.Wrap(err, "could not process rewards and penalties")
 	}
+
 	if err := ProcessRegistryUpdates(ctx, state); err != nil {
 		return errors.Wrap(err, "could not process registry updates")
 	}
-	if err := ProcessSlashings(state); err != nil {
+
+	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
+	if err != nil {
+		return err
+	}
+	state, err = ProcessSlashings(state, proportionalSlashingMultiplier)
+	if err != nil {
 		return err
 	}
 	state, err = ProcessEth1DataReset(state)
 	if err != nil {
 		return err
 	}
+
 	if err = ProcessPendingDeposits(ctx, state, primitives.Gwei(bp.ActiveCurrentEpoch)); err != nil {
 		return err
 	}
@@ -97,6 +102,7 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	if err = ProcessEffectiveBalanceUpdates(state); err != nil {
 		return err
 	}
+
 	state, err = ProcessSlashingsReset(state)
 	if err != nil {
 		return err
@@ -109,14 +115,17 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	if err != nil {
 		return err
 	}
+
 	state, err = ProcessParticipationFlagUpdates(state)
 	if err != nil {
 		return err
 	}
+
 	_, err = ProcessSyncCommitteeUpdates(ctx, state)
 	if err != nil {
 		return err
 	}
+
 	return nil
 }
 

beacon-chain/core/electra/upgrade.go

@@ -240,7 +240,7 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 		InactivityScores:            inactivityScores,
 		CurrentSyncCommittee:        currentSyncCommittee,
 		NextSyncCommittee:           nextSyncCommittee,
-		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderElectra{
 			ParentHash:       payloadHeader.ParentHash(),
 			FeeRecipient:     payloadHeader.FeeRecipient(),
 			StateRoot:        payloadHeader.StateRoot(),

beacon-chain/core/electra/upgrade_test.go

@@ -102,7 +102,7 @@ func TestUpgradeToElectra(t *testing.T) {
 
 	header, err := mSt.LatestExecutionPayloadHeader()
 	require.NoError(t, err)
-	protoHeader, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
+	protoHeader, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
 	require.Equal(t, true, ok)
 	prevHeader, err := preForkState.LatestExecutionPayloadHeader()
 	require.NoError(t, err)
@@ -111,7 +111,7 @@ func TestUpgradeToElectra(t *testing.T) {
 
 	wdRoot, err := prevHeader.WithdrawalsRoot()
 	require.NoError(t, err)
-	wanted := &enginev1.ExecutionPayloadHeaderDeneb{
+	wanted := &enginev1.ExecutionPayloadHeaderElectra{
 		ParentHash:       prevHeader.ParentHash(),
 		FeeRecipient:     prevHeader.FeeRecipient(),
 		StateRoot:        prevHeader.StateRoot(),

beacon-chain/core/epoch/epoch_processing.go

@@ -141,76 +141,29 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 	return st, nil
 }
 
-// ProcessSlashings processes the slashed validators during epoch processing. This is a state mutating method.
-//
-// Electra spec definition:
+// ProcessSlashings processes the slashed validators during epoch processing,
 //
 //	def process_slashings(state: BeaconState) -> None:
-//	    epoch = get_current_epoch(state)
-//	    total_balance = get_total_active_balance(state)
-//	    adjusted_total_slashing_balance = min(
-//	        sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX,
-//	        total_balance
-//	    )
-//	    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:
+//	  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
-//	            # [Modified in Electra:EIP7251]
 //	            penalty = penalty_per_effective_balance_increment * effective_balance_increments
-//	            decrease_balance(state, ValidatorIndex(index), penalty)
-//
-// Bellatrix spec definition:
-//
-//	def process_slashings(state: BeaconState) -> None:
-//	    epoch = get_current_epoch(state)
-//	    total_balance = get_total_active_balance(state)
-//	    adjusted_total_slashing_balance = min(
-//	        sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER_BELLATRIX,  # [Modified in Bellatrix]
-//	        total_balance
-//	    )
-//	    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
-//	            decrease_balance(state, ValidatorIndex(index), penalty)
-//
-// Altair spec definition:
-//
-//	def process_slashings(state: BeaconState) -> None:
-//	    epoch = get_current_epoch(state)
-//	    total_balance = get_total_active_balance(state)
-//	    adjusted_total_slashing_balance = min(sum(state.slashings) * PROPORTIONAL_SLASHING_MULTIPLIER_ALTAIR, total_balance)
-//	    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
-//	            decrease_balance(state, ValidatorIndex(index), penalty)
-//
-// Phase0 spec definition:
-//
-//	def process_slashings(state: BeaconState) -> None:
-//	    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)
-//	    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
-//	            decrease_balance(state, ValidatorIndex(index), penalty)
-func ProcessSlashings(st state.BeaconState) error {
-	slashingMultiplier, err := st.ProportionalSlashingMultiplier()
-	if err != nil {
-		return errors.Wrap(err, "could not get proportional slashing multiplier")
-	}
+//	          decrease_balance(state, ValidatorIndex(index), penalty)
+func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error) {
 	currentEpoch := time.CurrentEpoch(st)
 	totalBalance, err := helpers.TotalActiveBalance(st)
 	if err != nil {
-		return errors.Wrap(err, "could not get total active balance")
+		return nil, errors.Wrap(err, "could not get total active balance")
 	}
 
 	// Compute slashed balances in the current epoch
@@ -222,7 +175,7 @@ func ProcessSlashings(st state.BeaconState) error {
 	for _, slashing := range slashings {
 		totalSlashing, err = math.Add64(totalSlashing, slashing)
 		if err != nil {
-			return err
+			return nil, err
 		}
 	}
 
@@ -256,14 +209,14 @@ func ProcessSlashings(st state.BeaconState) error {
 		return nil
 	})
 	if err != nil {
-		return err
+		return nil, err
 	}
 	if changed {
 		if err := st.SetBalances(bals); err != nil {
-			return err
+			return nil, err
 		}
 	}
-	return nil
+	return st, nil
 }
 
 // ProcessEth1DataReset processes updates to ETH1 data votes during epoch processing.

beacon-chain/core/epoch/epoch_processing_test.go

@@ -32,9 +32,10 @@ func TestProcessSlashings_NotSlashed(t *testing.T) {
 	}
 	s, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	require.NoError(t, epoch.ProcessSlashings(s))
+	newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplier)
+	require.NoError(t, err)
 	wanted := params.BeaconConfig().MaxEffectiveBalance
-	assert.Equal(t, wanted, s.Balances()[0], "Unexpected slashed balance")
+	assert.Equal(t, wanted, newState.Balances()[0], "Unexpected slashed balance")
 }
 
 func TestProcessSlashings_SlashedLess(t *testing.T) {
@@ -110,8 +111,9 @@ func TestProcessSlashings_SlashedLess(t *testing.T) {
 			s, err := state_native.InitializeFromProtoPhase0(tt.state)
 			require.NoError(t, err)
 			helpers.ClearCache()
-			require.NoError(t, epoch.ProcessSlashings(s))
-			assert.Equal(t, tt.want, s.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, s.Balances()[0])
+			newState, err := epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplier)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, newState.Balances()[0], "ProcessSlashings({%v}) = newState; newState.Balances[0] = %d", original, newState.Balances()[0])
 		})
 	}
 }
@@ -363,7 +365,8 @@ func TestProcessSlashings_BadValue(t *testing.T) {
 	}
 	s, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	require.ErrorContains(t, "addition overflows", epoch.ProcessSlashings(s))
+	_, err = epoch.ProcessSlashings(s, params.BeaconConfig().ProportionalSlashingMultiplier)
+	require.ErrorContains(t, "addition overflows", err)
 }
 
 func TestProcessHistoricalDataUpdate(t *testing.T) {
@@ -511,8 +514,9 @@ func TestProcessSlashings_SlashedElectra(t *testing.T) {
 			s, err := state_native.InitializeFromProtoElectra(tt.state)
 			require.NoError(t, err)
 			helpers.ClearCache()
-			require.NoError(t, epoch.ProcessSlashings(s))
-			assert.Equal(t, tt.want, s.Balances()[0], "ProcessSlashings({%v}); s.Balances[0] = %d", original, s.Balances()[0])
+			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/fulu/BUILD.bazel

@@ -1,37 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["upgrade.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/fulu",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["upgrade_test.go"],
-    deps = [
-        ":go_default_library",
-        "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/primitives: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",
-        "//time/slots:go_default_library",
-    ],
-)

beacon-chain/core/fulu/upgrade.go

@@ -1,184 +0,0 @@
-package fulu
-
-import (
-	"sort"
-
-	"github.com/pkg/errors"
-	"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"
-	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"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-)
-
-// UpgradeToFulu updates inputs a generic state to return the version Fulu state.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/fork.md#upgrading-the-state
-func UpgradeToFulu(beaconState state.BeaconState) (state.BeaconState, error) {
-	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSyncCommittee, err := beaconState.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	inactivityScores, err := beaconState.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
-	if err != nil {
-		return nil, err
-	}
-	txRoot, err := payloadHeader.TransactionsRoot()
-	if err != nil {
-		return nil, err
-	}
-	wdRoot, err := payloadHeader.WithdrawalsRoot()
-	if err != nil {
-		return nil, err
-	}
-	wi, err := beaconState.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	vi, err := beaconState.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	summaries, err := beaconState.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	historicalRoots, err := beaconState.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
-	excessBlobGas, err := payloadHeader.ExcessBlobGas()
-	if err != nil {
-		return nil, err
-	}
-	blobGasUsed, err := payloadHeader.BlobGasUsed()
-	if err != nil {
-		return nil, err
-	}
-
-	earliestExitEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(beaconState))
-	preActivationIndices := make([]primitives.ValidatorIndex, 0)
-	compoundWithdrawalIndices := make([]primitives.ValidatorIndex, 0)
-	if err = beaconState.ReadFromEveryValidator(func(index int, val state.ReadOnlyValidator) error {
-		if val.ExitEpoch() != params.BeaconConfig().FarFutureEpoch && val.ExitEpoch() > earliestExitEpoch {
-			earliestExitEpoch = val.ExitEpoch()
-		}
-		if val.ActivationEpoch() == params.BeaconConfig().FarFutureEpoch {
-			preActivationIndices = append(preActivationIndices, primitives.ValidatorIndex(index))
-		}
-		if helpers.HasCompoundingWithdrawalCredential(val) {
-			compoundWithdrawalIndices = append(compoundWithdrawalIndices, primitives.ValidatorIndex(index))
-		}
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	earliestExitEpoch++ // Increment to find the earliest possible exit epoch
-
-	// note: should be the same in prestate and post beaconState.
-	// we are deviating from the specs a bit as it calls for using the post beaconState
-	tab, err := helpers.TotalActiveBalance(beaconState)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to get total active balance")
-	}
-
-	s := &ethpb.BeaconStateFulu{
-		GenesisTime:           beaconState.GenesisTime(),
-		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
-		Slot:                  beaconState.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: beaconState.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().FuluForkVersion,
-			Epoch:           time.CurrentEpoch(beaconState),
-		},
-		LatestBlockHeader:           beaconState.LatestBlockHeader(),
-		BlockRoots:                  beaconState.BlockRoots(),
-		StateRoots:                  beaconState.StateRoots(),
-		HistoricalRoots:             historicalRoots,
-		Eth1Data:                    beaconState.Eth1Data(),
-		Eth1DataVotes:               beaconState.Eth1DataVotes(),
-		Eth1DepositIndex:            beaconState.Eth1DepositIndex(),
-		Validators:                  beaconState.Validators(),
-		Balances:                    beaconState.Balances(),
-		RandaoMixes:                 beaconState.RandaoMixes(),
-		Slashings:                   beaconState.Slashings(),
-		PreviousEpochParticipation:  prevEpochParticipation,
-		CurrentEpochParticipation:   currentEpochParticipation,
-		JustificationBits:           beaconState.JustificationBits(),
-		PreviousJustifiedCheckpoint: beaconState.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:  beaconState.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:         beaconState.FinalizedCheckpoint(),
-		InactivityScores:            inactivityScores,
-		CurrentSyncCommittee:        currentSyncCommittee,
-		NextSyncCommittee:           nextSyncCommittee,
-		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
-			ParentHash:       payloadHeader.ParentHash(),
-			FeeRecipient:     payloadHeader.FeeRecipient(),
-			StateRoot:        payloadHeader.StateRoot(),
-			ReceiptsRoot:     payloadHeader.ReceiptsRoot(),
-			LogsBloom:        payloadHeader.LogsBloom(),
-			PrevRandao:       payloadHeader.PrevRandao(),
-			BlockNumber:      payloadHeader.BlockNumber(),
-			GasLimit:         payloadHeader.GasLimit(),
-			GasUsed:          payloadHeader.GasUsed(),
-			Timestamp:        payloadHeader.Timestamp(),
-			ExtraData:        payloadHeader.ExtraData(),
-			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
-			BlockHash:        payloadHeader.BlockHash(),
-			TransactionsRoot: txRoot,
-			WithdrawalsRoot:  wdRoot,
-			ExcessBlobGas:    excessBlobGas,
-			BlobGasUsed:      blobGasUsed,
-		},
-		NextWithdrawalIndex:          wi,
-		NextWithdrawalValidatorIndex: vi,
-		HistoricalSummaries:          summaries,
-
-		DepositRequestsStartIndex:     params.BeaconConfig().UnsetDepositRequestsStartIndex,
-		DepositBalanceToConsume:       0,
-		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(primitives.Gwei(tab)),
-		EarliestExitEpoch:             earliestExitEpoch,
-		ConsolidationBalanceToConsume: helpers.ConsolidationChurnLimit(primitives.Gwei(tab)),
-		EarliestConsolidationEpoch:    helpers.ActivationExitEpoch(slots.ToEpoch(beaconState.Slot())),
-		PendingDeposits:               make([]*ethpb.PendingDeposit, 0),
-		PendingPartialWithdrawals:     make([]*ethpb.PendingPartialWithdrawal, 0),
-		PendingConsolidations:         make([]*ethpb.PendingConsolidation, 0),
-	}
-
-	// Sorting preActivationIndices based on a custom criteria
-	sort.Slice(preActivationIndices, func(i, j int) bool {
-		// Comparing based on ActivationEligibilityEpoch and then by index if the epochs are the same
-		if s.Validators[preActivationIndices[i]].ActivationEligibilityEpoch == s.Validators[preActivationIndices[j]].ActivationEligibilityEpoch {
-			return preActivationIndices[i] < preActivationIndices[j]
-		}
-		return s.Validators[preActivationIndices[i]].ActivationEligibilityEpoch < s.Validators[preActivationIndices[j]].ActivationEligibilityEpoch
-	})
-
-	// Need to cast the beaconState to use in helper functions
-	post, err := state_native.InitializeFromProtoUnsafeFulu(s)
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to initialize post fulu beaconState")
-	}
-
-	return post, nil
-}

beacon-chain/core/fulu/upgrade_test.go

@@ -1,188 +0,0 @@
-package fulu_test
-
-import (
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/fulu"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-)
-
-func TestUpgradeToFulu(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetHistoricalRoots([][]byte{{1}}))
-	vals := st.Validators()
-	vals[0].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
-	vals[1].WithdrawalCredentials = []byte{params.BeaconConfig().CompoundingWithdrawalPrefixByte}
-	require.NoError(t, st.SetValidators(vals))
-	bals := st.Balances()
-	bals[1] = params.BeaconConfig().MinActivationBalance + 1000
-	require.NoError(t, st.SetBalances(bals))
-
-	preForkState := st.Copy()
-	mSt, err := fulu.UpgradeToFulu(st)
-	require.NoError(t, err)
-
-	require.Equal(t, preForkState.GenesisTime(), mSt.GenesisTime())
-	require.DeepSSZEqual(t, preForkState.GenesisValidatorsRoot(), mSt.GenesisValidatorsRoot())
-	require.Equal(t, preForkState.Slot(), mSt.Slot())
-	require.DeepSSZEqual(t, preForkState.LatestBlockHeader(), mSt.LatestBlockHeader())
-	require.DeepSSZEqual(t, preForkState.BlockRoots(), mSt.BlockRoots())
-	require.DeepSSZEqual(t, preForkState.StateRoots(), mSt.StateRoots())
-	require.DeepSSZEqual(t, preForkState.Validators()[2:], mSt.Validators()[2:])
-	require.DeepSSZEqual(t, preForkState.Balances()[2:], mSt.Balances()[2:])
-	require.DeepSSZEqual(t, preForkState.Eth1Data(), mSt.Eth1Data())
-	require.DeepSSZEqual(t, preForkState.Eth1DataVotes(), mSt.Eth1DataVotes())
-	require.DeepSSZEqual(t, preForkState.Eth1DepositIndex(), mSt.Eth1DepositIndex())
-	require.DeepSSZEqual(t, preForkState.RandaoMixes(), mSt.RandaoMixes())
-	require.DeepSSZEqual(t, preForkState.Slashings(), mSt.Slashings())
-	require.DeepSSZEqual(t, preForkState.JustificationBits(), mSt.JustificationBits())
-	require.DeepSSZEqual(t, preForkState.PreviousJustifiedCheckpoint(), mSt.PreviousJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.CurrentJustifiedCheckpoint(), mSt.CurrentJustifiedCheckpoint())
-	require.DeepSSZEqual(t, preForkState.FinalizedCheckpoint(), mSt.FinalizedCheckpoint())
-
-	require.Equal(t, len(preForkState.Validators()), len(mSt.Validators()))
-
-	preVal, err := preForkState.ValidatorAtIndex(0)
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, preVal.EffectiveBalance)
-
-	preVal2, err := preForkState.ValidatorAtIndex(1)
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxEffectiveBalance, preVal2.EffectiveBalance)
-
-	// TODO: Fix this test
-	// mVal, err := mSt.ValidatorAtIndex(0)
-	_, err = mSt.ValidatorAtIndex(0)
-	require.NoError(t, err)
-	// require.Equal(t, uint64(0), mVal.EffectiveBalance)
-
-	mVal2, err := mSt.ValidatorAtIndex(1)
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MinActivationBalance, mVal2.EffectiveBalance)
-
-	numValidators := mSt.NumValidators()
-	p, err := mSt.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-	p, err = mSt.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]byte, numValidators), p)
-	s, err := mSt.InactivityScores()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, make([]uint64, numValidators), s)
-
-	hr1, err := preForkState.HistoricalRoots()
-	require.NoError(t, err)
-	hr2, err := mSt.HistoricalRoots()
-	require.NoError(t, err)
-	require.DeepEqual(t, hr1, hr2)
-
-	f := mSt.Fork()
-	require.DeepSSZEqual(t, &ethpb.Fork{
-		PreviousVersion: st.Fork().CurrentVersion,
-		CurrentVersion:  params.BeaconConfig().FuluForkVersion,
-		Epoch:           time.CurrentEpoch(st),
-	}, f)
-	csc, err := mSt.CurrentSyncCommittee()
-	require.NoError(t, err)
-	psc, err := preForkState.CurrentSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, psc, csc)
-	nsc, err := mSt.NextSyncCommittee()
-	require.NoError(t, err)
-	psc, err = preForkState.NextSyncCommittee()
-	require.NoError(t, err)
-	require.DeepSSZEqual(t, psc, nsc)
-
-	header, err := mSt.LatestExecutionPayloadHeader()
-	require.NoError(t, err)
-	protoHeader, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
-	require.Equal(t, true, ok)
-	prevHeader, err := preForkState.LatestExecutionPayloadHeader()
-	require.NoError(t, err)
-	txRoot, err := prevHeader.TransactionsRoot()
-	require.NoError(t, err)
-
-	wdRoot, err := prevHeader.WithdrawalsRoot()
-	require.NoError(t, err)
-	wanted := &enginev1.ExecutionPayloadHeaderDeneb{
-		ParentHash:       prevHeader.ParentHash(),
-		FeeRecipient:     prevHeader.FeeRecipient(),
-		StateRoot:        prevHeader.StateRoot(),
-		ReceiptsRoot:     prevHeader.ReceiptsRoot(),
-		LogsBloom:        prevHeader.LogsBloom(),
-		PrevRandao:       prevHeader.PrevRandao(),
-		BlockNumber:      prevHeader.BlockNumber(),
-		GasLimit:         prevHeader.GasLimit(),
-		GasUsed:          prevHeader.GasUsed(),
-		Timestamp:        prevHeader.Timestamp(),
-		ExtraData:        prevHeader.ExtraData(),
-		BaseFeePerGas:    prevHeader.BaseFeePerGas(),
-		BlockHash:        prevHeader.BlockHash(),
-		TransactionsRoot: txRoot,
-		WithdrawalsRoot:  wdRoot,
-	}
-	require.DeepEqual(t, wanted, protoHeader)
-
-	nwi, err := mSt.NextWithdrawalIndex()
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), nwi)
-
-	lwvi, err := mSt.NextWithdrawalValidatorIndex()
-	require.NoError(t, err)
-	require.Equal(t, primitives.ValidatorIndex(0), lwvi)
-
-	summaries, err := mSt.HistoricalSummaries()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(summaries))
-
-	startIndex, err := mSt.DepositRequestsStartIndex()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().UnsetDepositRequestsStartIndex, startIndex)
-
-	balance, err := mSt.DepositBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, primitives.Gwei(0), balance)
-
-	tab, err := helpers.TotalActiveBalance(mSt)
-	require.NoError(t, err)
-
-	ebtc, err := mSt.ExitBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ActivationExitChurnLimit(primitives.Gwei(tab)), ebtc)
-
-	eee, err := mSt.EarliestExitEpoch()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ActivationExitEpoch(primitives.Epoch(1)), eee)
-
-	cbtc, err := mSt.ConsolidationBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ConsolidationChurnLimit(primitives.Gwei(tab)), cbtc)
-
-	earliestConsolidationEpoch, err := mSt.EarliestConsolidationEpoch()
-	require.NoError(t, err)
-	require.Equal(t, helpers.ActivationExitEpoch(slots.ToEpoch(preForkState.Slot())), earliestConsolidationEpoch)
-
-	// TODO: Fix this test
-	// pendingDeposits, err := mSt.PendingDeposits()
-	_, err = mSt.PendingDeposits()
-	require.NoError(t, err)
-	// require.Equal(t, 2, len(pendingDeposits))
-	// require.Equal(t, uint64(1000), pendingDeposits[1].Amount)
-
-	numPendingPartialWithdrawals, err := mSt.NumPendingPartialWithdrawals()
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), numPendingPartialWithdrawals)
-
-	consolidations, err := mSt.PendingConsolidations()
-	require.NoError(t, err)
-	require.Equal(t, 0, len(consolidations))
-}

beacon-chain/core/helpers/attestation.go

@@ -32,10 +32,7 @@ func ValidateNilAttestation(attestation ethpb.Att) error {
 	if attestation.GetData().Target == nil {
 		return errors.New("attestation's target can't be nil")
 	}
-	if attestation.IsSingle() {
-		return nil
-	}
-	if attestation.GetAggregationBits() == nil {
+	if !attestation.IsSingle() && attestation.GetAggregationBits() == nil {
 		return errors.New("attestation's bitfield can't be nil")
 	}
 	return nil

beacon-chain/core/helpers/beacon_committee_test.go

@@ -97,13 +97,6 @@ func TestVerifyBitfieldLength_OK(t *testing.T) {
 	assert.NoError(t, helpers.VerifyBitfieldLength(bf, committeeSize), "Bitfield is not validated when it was supposed to be")
 }
 
-func TestVerifyBitfieldLength_Incorrect(t *testing.T) {
-	helpers.ClearCache()
-
-	bf := bitfield.NewBitlist(1)
-	require.ErrorContains(t, "wanted participants bitfield length 2, got: 1", helpers.VerifyBitfieldLength(bf, 2))
-}
-
 func TestCommitteeAssignments_CannotRetrieveFutureEpoch(t *testing.T) {
 	helpers.ClearCache()
 

beacon-chain/core/light-client/lightclient_test.go

@@ -697,7 +697,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 			excessBlobGas, err := payload.ExcessBlobGas()
 			require.NoError(t, err)
 
-			executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+			executionHeader := &v11.ExecutionPayloadHeaderElectra{
 				ParentHash:       payload.ParentHash(),
 				FeeRecipient:     payload.FeeRecipient(),
 				StateRoot:        payload.StateRoot(),
@@ -762,7 +762,7 @@ func TestLightClient_BlockToLightClientHeader(t *testing.T) {
 			excessBlobGas, err := payload.ExcessBlobGas()
 			require.NoError(t, err)
 
-			executionHeader := &v11.ExecutionPayloadHeaderDeneb{
+			executionHeader := &v11.ExecutionPayloadHeaderElectra{
 				ParentHash:       payload.ParentHash(),
 				FeeRecipient:     payload.FeeRecipient(),
 				StateRoot:        payload.StateRoot(),

beacon-chain/core/time/slot_epoch.go

@@ -99,15 +99,6 @@ func CanUpgradeToElectra(slot primitives.Slot) bool {
 	return epochStart && electraEpoch
 }
 
-// CanUpgradeToFulu returns true if the input `slot` can upgrade to Fulu.
-// Spec code:
-// If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == FULU_FORK_EPOCH
-func CanUpgradeToFulu(slot primitives.Slot) bool {
-	epochStart := slots.IsEpochStart(slot)
-	fuluEpoch := slots.ToEpoch(slot) == params.BeaconConfig().FuluForkEpoch
-	return epochStart && fuluEpoch
-}
-
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/time/slot_epoch_test.go

@@ -1,7 +1,6 @@
 package time_test
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
@@ -84,6 +83,76 @@ func TestNextEpoch_OK(t *testing.T) {
 	}
 }
 
+func TestCanUpgradeToAltair(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	bc := params.BeaconConfig()
+	bc.AltairForkEpoch = 5
+	params.OverrideBeaconConfig(bc)
+	tests := []struct {
+		name string
+		slot primitives.Slot
+		want bool
+	}{
+		{
+			name: "not epoch start",
+			slot: 1,
+			want: false,
+		},
+		{
+			name: "not altair epoch",
+			slot: params.BeaconConfig().SlotsPerEpoch,
+			want: false,
+		},
+		{
+			name: "altair epoch",
+			slot: primitives.Slot(params.BeaconConfig().AltairForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := time.CanUpgradeToAltair(tt.slot); got != tt.want {
+				t.Errorf("canUpgradeToAltair() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCanUpgradeBellatrix(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	bc := params.BeaconConfig()
+	bc.BellatrixForkEpoch = 5
+	params.OverrideBeaconConfig(bc)
+	tests := []struct {
+		name string
+		slot primitives.Slot
+		want bool
+	}{
+		{
+			name: "not epoch start",
+			slot: 1,
+			want: false,
+		},
+		{
+			name: "not bellatrix epoch",
+			slot: params.BeaconConfig().SlotsPerEpoch,
+			want: false,
+		},
+		{
+			name: "bellatrix epoch",
+			slot: primitives.Slot(params.BeaconConfig().BellatrixForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := time.CanUpgradeToBellatrix(tt.slot); got != tt.want {
+				t.Errorf("CanUpgradeToBellatrix() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
 func TestCanProcessEpoch_TrueOnEpochsLastSlot(t *testing.T) {
 	tests := []struct {
 		slot            primitives.Slot
@@ -195,79 +264,107 @@ func TestAltairCompatible(t *testing.T) {
 	}
 }
 
-func TestCanUpgradeTo(t *testing.T) {
-	beaconConfig := params.BeaconConfig()
-
-	outerTestCases := []struct {
-		name        string
-		forkEpoch   *primitives.Epoch
-		upgradeFunc func(primitives.Slot) bool
+func TestCanUpgradeToCapella(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	bc := params.BeaconConfig()
+	bc.CapellaForkEpoch = 5
+	params.OverrideBeaconConfig(bc)
+	tests := []struct {
+		name string
+		slot primitives.Slot
+		want bool
 	}{
 		{
-			name:        "Altair",
-			forkEpoch:   &beaconConfig.AltairForkEpoch,
-			upgradeFunc: time.CanUpgradeToAltair,
+			name: "not epoch start",
+			slot: 1,
+			want: false,
 		},
 		{
-			name:        "Bellatrix",
-			forkEpoch:   &beaconConfig.BellatrixForkEpoch,
-			upgradeFunc: time.CanUpgradeToBellatrix,
+			name: "not capella epoch",
+			slot: params.BeaconConfig().SlotsPerEpoch,
+			want: false,
 		},
 		{
-			name:        "Capella",
-			forkEpoch:   &beaconConfig.CapellaForkEpoch,
-			upgradeFunc: time.CanUpgradeToCapella,
-		},
-		{
-			name:        "Deneb",
-			forkEpoch:   &beaconConfig.DenebForkEpoch,
-			upgradeFunc: time.CanUpgradeToDeneb,
-		},
-		{
-			name:        "Electra",
-			forkEpoch:   &beaconConfig.ElectraForkEpoch,
-			upgradeFunc: time.CanUpgradeToElectra,
-		},
-		{
-			name:        "Fulu",
-			forkEpoch:   &beaconConfig.FuluForkEpoch,
-			upgradeFunc: time.CanUpgradeToFulu,
+			name: "capella epoch",
+			slot: primitives.Slot(params.BeaconConfig().CapellaForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
+			want: true,
 		},
 	}
-
-	for _, otc := range outerTestCases {
-		params.SetupTestConfigCleanup(t)
-		*otc.forkEpoch = 5
-		params.OverrideBeaconConfig(beaconConfig)
-
-		innerTestCases := []struct {
-			name string
-			slot primitives.Slot
-			want bool
-		}{
-			{
-				name: "not epoch start",
-				slot: 1,
-				want: false,
-			},
-			{
-				name: fmt.Sprintf("not %s epoch", otc.name),
-				slot: params.BeaconConfig().SlotsPerEpoch,
-				want: false,
-			},
-			{
-				name: fmt.Sprintf("%s epoch", otc.name),
-				slot: primitives.Slot(*otc.forkEpoch) * params.BeaconConfig().SlotsPerEpoch,
-				want: true,
-			},
-		}
-
-		for _, itc := range innerTestCases {
-			t.Run(fmt.Sprintf("%s-%s", otc.name, itc.name), func(t *testing.T) {
-				if got := otc.upgradeFunc(itc.slot); got != itc.want {
-					t.Errorf("CanUpgradeTo%s() = %v, want %v", otc.name, got, itc.want)
-				}
-			})
-		}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := time.CanUpgradeToCapella(tt.slot); got != tt.want {
+				t.Errorf("CanUpgradeToCapella() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCanUpgradeToDeneb(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	bc := params.BeaconConfig()
+	bc.DenebForkEpoch = 5
+	params.OverrideBeaconConfig(bc)
+	tests := []struct {
+		name string
+		slot primitives.Slot
+		want bool
+	}{
+		{
+			name: "not epoch start",
+			slot: 1,
+			want: false,
+		},
+		{
+			name: "not deneb epoch",
+			slot: params.BeaconConfig().SlotsPerEpoch,
+			want: false,
+		},
+		{
+			name: "deneb epoch",
+			slot: primitives.Slot(params.BeaconConfig().DenebForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := time.CanUpgradeToDeneb(tt.slot); got != tt.want {
+				t.Errorf("CanUpgradeToDeneb() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestCanUpgradeToElectra(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	bc := params.BeaconConfig()
+	bc.ElectraForkEpoch = 5
+	params.OverrideBeaconConfig(bc)
+	tests := []struct {
+		name string
+		slot primitives.Slot
+		want bool
+	}{
+		{
+			name: "not epoch start",
+			slot: 1,
+			want: false,
+		},
+		{
+			name: "not electra epoch",
+			slot: params.BeaconConfig().SlotsPerEpoch,
+			want: false,
+		},
+		{
+			name: "electra epoch",
+			slot: primitives.Slot(params.BeaconConfig().ElectraForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := time.CanUpgradeToElectra(tt.slot); got != tt.want {
+				t.Errorf("CanUpgradeToElectra() = %v, want %v", got, tt.want)
+			}
+		})
 	}
 }

beacon-chain/core/transition/BUILD.bazel

@@ -23,7 +23,6 @@ go_library(
         "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/epoch/precompute:go_default_library",
         "//beacon-chain/core/execution:go_default_library",
-        "//beacon-chain/core/fulu:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",

beacon-chain/core/transition/transition.go

@@ -17,7 +17,6 @@ import (
 	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/execution"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/fulu"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
@@ -299,7 +298,7 @@ func ProcessSlotsCore(ctx context.Context, span trace.Span, state state.BeaconSt
 func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
 	var err error
 	if time.CanProcessEpoch(state) {
-		if state.Version() >= version.Electra {
+		if state.Version() == version.Electra {
 			if err = electra.ProcessEpoch(ctx, state); err != nil {
 				return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
 			}
@@ -323,11 +322,9 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	defer span.End()
 
 	var err error
-
-	slot := state.Slot()
 	upgraded := false
 
-	if time.CanUpgradeToAltair(slot) {
+	if time.CanUpgradeToAltair(state.Slot()) {
 		state, err = altair.UpgradeToAltair(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -336,7 +333,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToBellatrix(slot) {
+	if time.CanUpgradeToBellatrix(state.Slot()) {
 		state, err = execution.UpgradeToBellatrix(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -345,7 +342,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToCapella(slot) {
+	if time.CanUpgradeToCapella(state.Slot()) {
 		state, err = capella.UpgradeToCapella(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -354,7 +351,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToDeneb(slot) {
+	if time.CanUpgradeToDeneb(state.Slot()) {
 		state, err = deneb.UpgradeToDeneb(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -363,7 +360,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToElectra(slot) {
+	if time.CanUpgradeToElectra(state.Slot()) {
 		state, err = electra.UpgradeToElectra(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -372,17 +369,8 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToFulu(slot) {
-		state, err = fulu.UpgradeToFulu(state)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return nil, err
-		}
-		upgraded = true
-	}
-
 	if upgraded {
-		log.WithField("version", version.String(state.Version())).Info("Upgraded state to")
+		log.Debugf("upgraded state to %s", version.String(state.Version()))
 	}
 
 	return state, nil

beacon-chain/core/transition/transition_test.go

@@ -665,20 +665,6 @@ func TestProcessSlots_ThroughElectraEpoch(t *testing.T) {
 	require.Equal(t, params.BeaconConfig().SlotsPerEpoch*10, st.Slot())
 }
 
-func TestProcessSlots_ThroughFuluEpoch(t *testing.T) {
-	transition.SkipSlotCache.Disable()
-	params.SetupTestConfigCleanup(t)
-	conf := params.BeaconConfig()
-	conf.FuluForkEpoch = 5
-	params.OverrideBeaconConfig(conf)
-
-	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	st, err := transition.ProcessSlots(context.Background(), st, params.BeaconConfig().SlotsPerEpoch*10)
-	require.NoError(t, err)
-	require.Equal(t, version.Fulu, st.Version())
-	require.Equal(t, params.BeaconConfig().SlotsPerEpoch*10, st.Slot())
-}
-
 func TestProcessSlotsUsingNextSlotCache(t *testing.T) {
 	s, _ := util.DeterministicGenesisState(t, 1)
 	r := []byte{'a'}

beacon-chain/core/validators/slashing.go

@@ -9,35 +9,25 @@ import (
 // SlashingParamsPerVersion returns the slashing parameters for the given state version.
 func SlashingParamsPerVersion(v int) (slashingQuotient, proposerRewardQuotient, whistleblowerRewardQuotient uint64, err error) {
 	cfg := params.BeaconConfig()
-
-	if v >= version.Electra {
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientElectra
-		proposerRewardQuotient = cfg.ProposerRewardQuotient
-		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotientElectra
-		return
-	}
-
-	if v >= version.Bellatrix {
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
-		proposerRewardQuotient = cfg.ProposerRewardQuotient
-		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
-		return
-	}
-
-	if v >= version.Altair {
-		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
-		proposerRewardQuotient = cfg.ProposerRewardQuotient
-		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
-		return
-	}
-
-	if v >= version.Phase0 {
+	switch v {
+	case version.Phase0:
 		slashingQuotient = cfg.MinSlashingPenaltyQuotient
 		proposerRewardQuotient = cfg.ProposerRewardQuotient
 		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
-		return
+	case version.Altair:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientAltair
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
+	case version.Bellatrix, version.Capella, version.Deneb:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientBellatrix
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
+	case version.Electra:
+		slashingQuotient = cfg.MinSlashingPenaltyQuotientElectra
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotientElectra
+	default:
+		err = errors.New("unknown state version")
 	}
-
-	err = errors.Errorf("unknown state version %s", version.String(v))
 	return
 }

beacon-chain/db/kv/BUILD.bazel

@@ -41,7 +41,6 @@ go_library(
         "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

beacon-chain/db/kv/blocks.go

@@ -823,16 +823,6 @@ func unmarshalBlock(_ context.Context, enc []byte) (interfaces.ReadOnlySignedBea
 		if err := rawBlock.UnmarshalSSZ(enc[len(electraBlindKey):]); err != nil {
 			return nil, errors.Wrap(err, "could not unmarshal blinded Electra block")
 		}
-	case hasFuluKey(enc):
-		rawBlock = &ethpb.SignedBeaconBlockFulu{}
-		if err := rawBlock.UnmarshalSSZ(enc[len(fuluKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Fulu block")
-		}
-	case hasFuluBlindKey(enc):
-		rawBlock = &ethpb.SignedBlindedBeaconBlockFulu{}
-		if err := rawBlock.UnmarshalSSZ(enc[len(fuluBlindKey):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal blinded Fulu block")
-		}
 	default:
 		// Marshal block bytes to phase 0 beacon block.
 		rawBlock = &ethpb.SignedBeaconBlock{}
@@ -861,50 +851,32 @@ func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 }
 
 func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
-	v := blk.Version()
-
-	if v >= version.Fulu {
-		if blk.IsBlinded() {
-			return fuluBlindKey, nil
-		}
-		return fuluKey, nil
-	}
-
-	if v >= version.Electra {
+	switch blk.Version() {
+	case version.Electra:
 		if blk.IsBlinded() {
 			return electraBlindKey, nil
 		}
 		return electraKey, nil
-	}
-
-	if v >= version.Deneb {
+	case version.Deneb:
 		if blk.IsBlinded() {
 			return denebBlindKey, nil
 		}
 		return denebKey, nil
-	}
-
-	if v >= version.Capella {
+	case version.Capella:
 		if blk.IsBlinded() {
 			return capellaBlindKey, nil
 		}
 		return capellaKey, nil
-	}
-
-	if v >= version.Bellatrix {
+	case version.Bellatrix:
 		if blk.IsBlinded() {
 			return bellatrixBlindKey, nil
 		}
 		return bellatrixKey, nil
-	}
-
-	if v >= version.Altair {
+	case version.Altair:
 		return altairKey, nil
-	}
-
-	if v >= version.Phase0 {
+	case version.Phase0:
 		return nil, nil
+	default:
+		return nil, fmt.Errorf("unsupported block version: %v", blk.Version())
 	}
-
-	return nil, fmt.Errorf("unsupported block version: %v", blk.Version())
 }

beacon-chain/db/kv/key.go

@@ -65,17 +65,3 @@ func hasElectraBlindKey(enc []byte) bool {
 	}
 	return bytes.Equal(enc[:len(electraBlindKey)], electraBlindKey)
 }
-
-func hasFuluKey(enc []byte) bool {
-	if len(fuluKey) >= len(enc) {
-		return false
-	}
-	return bytes.Equal(enc[:len(fuluKey)], fuluKey)
-}
-
-func hasFuluBlindKey(enc []byte) bool {
-	if len(fuluBlindKey) >= len(enc) {
-		return false
-	}
-	return bytes.Equal(enc[:len(fuluBlindKey)], fuluBlindKey)
-}

beacon-chain/db/kv/kv.go

@@ -109,7 +109,6 @@ var Buckets = [][]byte{
 	stateValidatorsBucket,
 	lightClientUpdatesBucket,
 	lightClientBootstrapBucket,
-	lightClientSyncCommitteeBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,

beacon-chain/db/kv/lightclient.go

@@ -7,8 +7,6 @@ import (
 
 	"github.com/golang/snappy"
 	"github.com/pkg/errors"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	light_client "github.com/prysmaticlabs/prysm/v5/consensus-types/light-client"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -37,35 +35,9 @@ func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot []byte,
 	_, span := trace.StartSpan(ctx, "BeaconDB.SaveLightClientBootstrap")
 	defer span.End()
 
-	bootstrapCopy, err := light_client.NewWrappedBootstrap(proto.Clone(bootstrap.Proto()))
-	if err != nil {
-		return errors.Wrap(err, "could not clone light client bootstrap")
-	}
-	syncCommitteeHash, err := bootstrapCopy.CurrentSyncCommittee().HashTreeRoot()
-	if err != nil {
-		return errors.Wrap(err, "could not hash current sync committee")
-	}
-
 	return s.db.Update(func(tx *bolt.Tx) error {
-		syncCommitteeBucket := tx.Bucket(lightClientSyncCommitteeBucket)
-		syncCommitteeAlreadyExists := syncCommitteeBucket.Get(syncCommitteeHash[:]) != nil
-		if !syncCommitteeAlreadyExists {
-			enc, err := bootstrapCopy.CurrentSyncCommittee().MarshalSSZ()
-			if err != nil {
-				return errors.Wrap(err, "could not marshal current sync committee")
-			}
-			if err := syncCommitteeBucket.Put(syncCommitteeHash[:], enc); err != nil {
-				return errors.Wrap(err, "could not save current sync committee")
-			}
-		}
-
-		err = bootstrapCopy.SetCurrentSyncCommittee(createEmptySyncCommittee())
-		if err != nil {
-			return errors.Wrap(err, "could not set current sync committee to zero while saving")
-		}
-
 		bkt := tx.Bucket(lightClientBootstrapBucket)
-		enc, err := encodeLightClientBootstrap(bootstrapCopy, syncCommitteeHash)
+		enc, err := encodeLightClientBootstrap(bootstrap)
 		if err != nil {
 			return err
 		}
@@ -78,49 +50,20 @@ func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot []byte) (int
 	defer span.End()
 
 	var bootstrap interfaces.LightClientBootstrap
-	var syncCommitteeHash []byte
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(lightClientBootstrapBucket)
-		syncCommitteeBucket := tx.Bucket(lightClientSyncCommitteeBucket)
 		enc := bkt.Get(blockRoot)
 		if enc == nil {
 			return nil
 		}
 		var err error
-		bootstrap, syncCommitteeHash, err = decodeLightClientBootstrap(enc)
-		if err != nil {
-			return errors.Wrap(err, "could not decode light client bootstrap")
-		}
-		var syncCommitteeBytes = syncCommitteeBucket.Get(syncCommitteeHash)
-		if syncCommitteeBytes == nil {
-			return errors.New("sync committee not found")
-		}
-		syncCommittee := &ethpb.SyncCommittee{}
-		if err := syncCommittee.UnmarshalSSZ(syncCommitteeBytes); err != nil {
-			return errors.Wrap(err, "could not unmarshal sync committee")
-		}
-		err = bootstrap.SetCurrentSyncCommittee(syncCommittee)
-		if err != nil {
-			return errors.Wrap(err, "could not set current sync committee while retrieving")
-		}
+		bootstrap, err = decodeLightClientBootstrap(enc)
 		return err
 	})
 	return bootstrap, err
 }
 
-func createEmptySyncCommittee() *ethpb.SyncCommittee {
-	syncCom := make([][]byte, params.BeaconConfig().SyncCommitteeSize)
-	for i := 0; uint64(i) < params.BeaconConfig().SyncCommitteeSize; i++ {
-		syncCom[i] = make([]byte, fieldparams.BLSPubkeyLength)
-	}
-
-	return &ethpb.SyncCommittee{
-		Pubkeys:         syncCom,
-		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
-	}
-}
-
-func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap, syncCommitteeHash [32]byte) ([]byte, error) {
+func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap) ([]byte, error) {
 	key, err := keyForLightClientUpdate(bootstrap.Version())
 	if err != nil {
 		return nil, err
@@ -129,56 +72,48 @@ func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap, syncC
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal light client bootstrap")
 	}
-	fullEnc := make([]byte, len(key)+32+len(enc))
+	fullEnc := make([]byte, len(key)+len(enc))
 	copy(fullEnc, key)
-	copy(fullEnc[len(key):len(key)+32], syncCommitteeHash[:])
-	copy(fullEnc[len(key)+32:], enc)
-	compressedEnc := snappy.Encode(nil, fullEnc)
-	return compressedEnc, nil
+	copy(fullEnc[len(key):], enc)
+	return snappy.Encode(nil, fullEnc), nil
 }
 
-func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, []byte, error) {
+func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, error) {
 	var err error
 	enc, err = snappy.Decode(nil, enc)
 	if err != nil {
-		return nil, nil, errors.Wrap(err, "could not snappy decode light client bootstrap")
+		return nil, errors.Wrap(err, "could not snappy decode light client bootstrap")
 	}
 	var m proto.Message
-	var syncCommitteeHash []byte
 	switch {
 	case hasAltairKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapAltair{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(altairKey)+32:]); err != nil {
-			return nil, nil, errors.Wrap(err, "could not unmarshal Altair light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Altair light client bootstrap")
 		}
 		m = bootstrap
-		syncCommitteeHash = enc[len(altairKey) : len(altairKey)+32]
 	case hasCapellaKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapCapella{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(capellaKey)+32:]); err != nil {
-			return nil, nil, errors.Wrap(err, "could not unmarshal Capella light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(capellaKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Capella light client bootstrap")
 		}
 		m = bootstrap
-		syncCommitteeHash = enc[len(capellaKey) : len(capellaKey)+32]
 	case hasDenebKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapDeneb{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(denebKey)+32:]); err != nil {
-			return nil, nil, errors.Wrap(err, "could not unmarshal Deneb light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(denebKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Deneb light client bootstrap")
 		}
 		m = bootstrap
-		syncCommitteeHash = enc[len(denebKey) : len(denebKey)+32]
 	case hasElectraKey(enc):
 		bootstrap := &ethpb.LightClientBootstrapElectra{}
-		if err := bootstrap.UnmarshalSSZ(enc[len(electraKey)+32:]); err != nil {
-			return nil, nil, errors.Wrap(err, "could not unmarshal Electra light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Electra light client bootstrap")
 		}
 		m = bootstrap
-		syncCommitteeHash = enc[len(electraKey) : len(electraKey)+32]
 	default:
-		return nil, nil, errors.New("decoding of saved light client bootstrap is unsupported")
+		return nil, errors.New("decoding of saved light client bootstrap is unsupported")
 	}
-	bootstrap, err := light_client.NewWrappedBootstrap(m)
-	return bootstrap, syncCommitteeHash, err
+	return light_client.NewWrappedBootstrap(m)
 }
 
 func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error) {

beacon-chain/db/kv/lightclient_test.go

@@ -18,7 +18,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	bolt "go.etcd.io/bbolt"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -123,7 +122,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 				StateRoot:     sampleRoot,
 				BodyRoot:      sampleRoot,
 			},
-			Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+			Execution: &enginev1.ExecutionPayloadHeaderElectra{
 				ParentHash:       make([]byte, fieldparams.RootLength),
 				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
 				StateRoot:        make([]byte, fieldparams.RootLength),
@@ -141,34 +140,6 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		require.NoError(t, err)
 		st, err = util.NewBeaconStateElectra()
 		require.NoError(t, err)
-	case version.Fulu:
-		slot = primitives.Slot(config.FuluForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
-		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderDeneb{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
-				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
-				ParentRoot:    sampleRoot,
-				StateRoot:     sampleRoot,
-				BodyRoot:      sampleRoot,
-			},
-			Execution: &enginev1.ExecutionPayloadHeaderDeneb{
-				ParentHash:       make([]byte, fieldparams.RootLength),
-				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-				StateRoot:        make([]byte, fieldparams.RootLength),
-				ReceiptsRoot:     make([]byte, fieldparams.RootLength),
-				LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
-				PrevRandao:       make([]byte, fieldparams.RootLength),
-				ExtraData:        make([]byte, 0),
-				BaseFeePerGas:    make([]byte, fieldparams.RootLength),
-				BlockHash:        make([]byte, fieldparams.RootLength),
-				TransactionsRoot: make([]byte, fieldparams.RootLength),
-				WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
-			},
-			ExecutionBranch: sampleExecutionBranch,
-		})
-		require.NoError(t, err)
-		st, err = util.NewBeaconStateFulu()
-		require.NoError(t, err)
 	default:
 		return nil, fmt.Errorf("unsupported version %s", version.String(v))
 	}
@@ -196,7 +167,6 @@ func TestStore_LightClientUpdate_CanSaveRetrieve(t *testing.T) {
 	cfg.CapellaForkEpoch = 1
 	cfg.DenebForkEpoch = 2
 	cfg.ElectraForkEpoch = 3
-	cfg.FuluForkEpoch = 3
 	params.OverrideBeaconConfig(cfg)
 
 	db := setupDB(t)
@@ -243,17 +213,6 @@ func TestStore_LightClientUpdate_CanSaveRetrieve(t *testing.T) {
 		err = db.SaveLightClientUpdate(ctx, period, update)
 		require.NoError(t, err)
 
-		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
-	})
-	t.Run("Fulu", func(t *testing.T) {
-		update, err := createUpdate(t, version.Fulu)
-		require.NoError(t, err)
-		period := uint64(1)
-		err = db.SaveLightClientUpdate(ctx, period, update)
-		require.NoError(t, err)
-
 		retrievedUpdate, err := db.LightClientUpdate(ctx, period)
 		require.NoError(t, err)
 		require.DeepEqual(t, update, retrievedUpdate, "retrieved update does not match saved update")
@@ -612,13 +571,7 @@ func TestStore_LightClientBootstrap_CanSaveRetrieve(t *testing.T) {
 
 		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootAltair"))
 		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
+		require.DeepEqual(t, bootstrap, retrievedBootstrap, "retrieved bootstrap does not match saved bootstrap")
 	})
 
 	t.Run("Capella", func(t *testing.T) {
@@ -633,13 +586,7 @@ func TestStore_LightClientBootstrap_CanSaveRetrieve(t *testing.T) {
 
 		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootCapella"))
 		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
+		require.DeepEqual(t, bootstrap, retrievedBootstrap, "retrieved bootstrap does not match saved bootstrap")
 	})
 
 	t.Run("Deneb", func(t *testing.T) {
@@ -654,13 +601,7 @@ func TestStore_LightClientBootstrap_CanSaveRetrieve(t *testing.T) {
 
 		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootDeneb"))
 		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranch()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
+		require.DeepEqual(t, bootstrap, retrievedBootstrap, "retrieved bootstrap does not match saved bootstrap")
 	})
 
 	t.Run("Electra", func(t *testing.T) {
@@ -675,138 +616,10 @@ func TestStore_LightClientBootstrap_CanSaveRetrieve(t *testing.T) {
 
 		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("blockRootElectra"))
 		require.NoError(t, err)
-		require.DeepEqual(t, bootstrap.Header(), retrievedBootstrap.Header(), "retrieved bootstrap header does not match saved bootstrap header")
-		require.DeepEqual(t, bootstrap.CurrentSyncCommittee(), retrievedBootstrap.CurrentSyncCommittee(), "retrieved bootstrap sync committee does not match saved bootstrap sync committee")
-		savedBranch, err := bootstrap.CurrentSyncCommitteeBranchElectra()
-		require.NoError(t, err)
-		retrievedBranch, err := retrievedBootstrap.CurrentSyncCommitteeBranchElectra()
-		require.NoError(t, err)
-		require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap sync committee branch does not match saved bootstrap sync committee branch")
+		require.DeepEqual(t, bootstrap, retrievedBootstrap, "retrieved bootstrap does not match saved bootstrap")
 	})
 }
 
-func TestStore_LightClientBootstrap_MultipleBootstrapsWithSameSyncCommittee(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch = 0
-	cfg.CapellaForkEpoch = 1
-	cfg.DenebForkEpoch = 2
-	cfg.ElectraForkEpoch = 3
-	cfg.EpochsPerSyncCommitteePeriod = 1
-	params.OverrideBeaconConfig(cfg)
-
-	db := setupDB(t)
-	ctx := context.Background()
-
-	bootstrap1, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().AltairForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-	require.NoError(t, err)
-	bootstrap2, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().AltairForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-	require.NoError(t, err)
-
-	randomSyncCommittee := createRandomSyncCommittee()
-
-	err = bootstrap1.SetCurrentSyncCommittee(randomSyncCommittee)
-	require.NoError(t, err)
-	err = bootstrap2.SetCurrentSyncCommittee(randomSyncCommittee)
-	require.NoError(t, err)
-
-	err = db.SaveLightClientBootstrap(ctx, []byte("blockRootAltair1"), bootstrap1)
-	require.NoError(t, err)
-	err = db.SaveLightClientBootstrap(ctx, []byte("blockRootAltair2"), bootstrap2)
-	require.NoError(t, err)
-
-	retrievedBootstrap1, err := db.LightClientBootstrap(ctx, []byte("blockRootAltair1"))
-	require.NoError(t, err)
-	retrievedBootstrap2, err := db.LightClientBootstrap(ctx, []byte("blockRootAltair2"))
-	require.NoError(t, err)
-
-	require.DeepEqual(t, bootstrap1.Header(), retrievedBootstrap1.Header(), "retrieved bootstrap1 header does not match saved bootstrap1 header")
-	require.DeepEqual(t, randomSyncCommittee, retrievedBootstrap1.CurrentSyncCommittee(), "retrieved bootstrap1 sync committee does not match saved bootstrap1 sync committee")
-	savedBranch, err := bootstrap1.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	retrievedBranch, err := retrievedBootstrap1.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap1 sync committee branch does not match saved bootstrap1 sync committee branch")
-
-	require.DeepEqual(t, bootstrap2.Header(), retrievedBootstrap2.Header(), "retrieved bootstrap1 header does not match saved bootstrap1 header")
-	require.DeepEqual(t, randomSyncCommittee, retrievedBootstrap2.CurrentSyncCommittee(), "retrieved bootstrap1 sync committee does not match saved bootstrap1 sync committee")
-	savedBranch2, err := bootstrap2.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	retrievedBranch2, err := retrievedBootstrap2.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	require.DeepEqual(t, savedBranch2, retrievedBranch2, "retrieved bootstrap1 sync committee branch does not match saved bootstrap1 sync committee branch")
-
-	// Ensure that the sync committee is only stored once
-	err = db.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(lightClientSyncCommitteeBucket)
-		require.NotNil(t, bucket)
-		count := bucket.Stats().KeyN
-		require.Equal(t, 1, count)
-		return nil
-	})
-	require.NoError(t, err)
-}
-
-func TestStore_LightClientBootstrap_MultipleBootstrapsWithDifferentSyncCommittees(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch = 0
-	cfg.CapellaForkEpoch = 1
-	cfg.DenebForkEpoch = 2
-	cfg.ElectraForkEpoch = 3
-	cfg.EpochsPerSyncCommitteePeriod = 1
-	params.OverrideBeaconConfig(cfg)
-
-	db := setupDB(t)
-	ctx := context.Background()
-
-	bootstrap1, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().AltairForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-	require.NoError(t, err)
-	bootstrap2, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().AltairForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
-	require.NoError(t, err)
-
-	err = bootstrap1.SetCurrentSyncCommittee(createRandomSyncCommittee())
-	require.NoError(t, err)
-	err = bootstrap2.SetCurrentSyncCommittee(createRandomSyncCommittee())
-	require.NoError(t, err)
-
-	err = db.SaveLightClientBootstrap(ctx, []byte("blockRootAltair1"), bootstrap1)
-	require.NoError(t, err)
-	err = db.SaveLightClientBootstrap(ctx, []byte("blockRootAltair2"), bootstrap2)
-	require.NoError(t, err)
-
-	retrievedBootstrap1, err := db.LightClientBootstrap(ctx, []byte("blockRootAltair1"))
-	require.NoError(t, err)
-	retrievedBootstrap2, err := db.LightClientBootstrap(ctx, []byte("blockRootAltair2"))
-	require.NoError(t, err)
-
-	require.DeepEqual(t, bootstrap1.Header(), retrievedBootstrap1.Header(), "retrieved bootstrap1 header does not match saved bootstrap1 header")
-	require.DeepEqual(t, bootstrap1.CurrentSyncCommittee(), retrievedBootstrap1.CurrentSyncCommittee(), "retrieved bootstrap1 sync committee does not match saved bootstrap1 sync committee")
-	savedBranch, err := bootstrap1.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	retrievedBranch, err := retrievedBootstrap1.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	require.DeepEqual(t, savedBranch, retrievedBranch, "retrieved bootstrap1 sync committee branch does not match saved bootstrap1 sync committee branch")
-
-	require.DeepEqual(t, bootstrap2.Header(), retrievedBootstrap2.Header(), "retrieved bootstrap1 header does not match saved bootstrap1 header")
-	require.DeepEqual(t, bootstrap2.CurrentSyncCommittee(), retrievedBootstrap2.CurrentSyncCommittee(), "retrieved bootstrap1 sync committee does not match saved bootstrap1 sync committee")
-	savedBranch2, err := bootstrap2.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	retrievedBranch2, err := retrievedBootstrap2.CurrentSyncCommitteeBranch()
-	require.NoError(t, err)
-	require.DeepEqual(t, savedBranch2, retrievedBranch2, "retrieved bootstrap1 sync committee branch does not match saved bootstrap1 sync committee branch")
-
-	// Ensure that the sync committee is stored twice
-	err = db.db.View(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(lightClientSyncCommitteeBucket)
-		require.NotNil(t, bucket)
-		count := bucket.Stats().KeyN
-		require.Equal(t, 2, count)
-		return nil
-	})
-	require.NoError(t, err)
-}
-
 func createDefaultLightClientBootstrap(currentSlot primitives.Slot) (interfaces.LightClientBootstrap, error) {
 	currentEpoch := slots.ToEpoch(currentSlot)
 	syncCommitteeSize := params.BeaconConfig().SyncCommitteeSize

beacon-chain/db/kv/schema.go

@@ -18,9 +18,8 @@ var (
 	registrationBucket    = []byte("registration")
 
 	// Light Client Updates Bucket
-	lightClientUpdatesBucket       = []byte("light-client-updates")
-	lightClientBootstrapBucket     = []byte("light-client-bootstrap")
-	lightClientSyncCommitteeBucket = []byte("light-client-sync-committee")
+	lightClientUpdatesBucket   = []byte("light-client-updates")
+	lightClientBootstrapBucket = []byte("light-client-bootstrap")
 
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")
@@ -55,8 +54,6 @@ var (
 	denebBlindKey              = []byte("blind-deneb")
 	electraKey                 = []byte("electra")
 	electraBlindKey            = []byte("blind-electra")
-	fuluKey                    = []byte("fulu")
-	fuluBlindKey               = []byte("blind-fulu")
 
 	// block root included in the beacon state used by weak subjectivity initial sync
 	originCheckpointBlockRootKey = []byte("origin-checkpoint-block-root")

beacon-chain/db/kv/state.go

@@ -517,19 +517,6 @@ func (s *Store) unmarshalState(_ context.Context, enc []byte, validatorEntries [
 	}
 
 	switch {
-	case hasFuluKey(enc):
-		protoState := &ethpb.BeaconStateFulu{}
-		if err := protoState.UnmarshalSSZ(enc[len(fuluKey):]); err != nil {
-			return nil, errors.Wrap(err, "failed to unmarshal encoding for Electra")
-		}
-		ok, err := s.isStateValidatorMigrationOver()
-		if err != nil {
-			return nil, err
-		}
-		if ok {
-			protoState.Validators = validatorEntries
-		}
-		return statenative.InitializeFromProtoUnsafeFulu(protoState)
 	case hasElectraKey(enc):
 		protoState := &ethpb.BeaconStateElectra{}
 		if err := protoState.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
@@ -689,19 +676,6 @@ func marshalState(ctx context.Context, st state.ReadOnlyBeaconState) ([]byte, er
 			return nil, err
 		}
 		return snappy.Encode(nil, append(electraKey, rawObj...)), nil
-	case version.Fulu:
-		rState, ok := st.ToProtoUnsafe().(*ethpb.BeaconStateFulu)
-		if !ok {
-			return nil, errors.New("non valid inner state")
-		}
-		if rState == nil {
-			return nil, errors.New("nil state")
-		}
-		rawObj, err := rState.MarshalSSZ()
-		if err != nil {
-			return nil, err
-		}
-		return snappy.Encode(nil, append(fuluKey, rawObj...)), nil
 	default:
 		return nil, errors.New("invalid inner state")
 	}

beacon-chain/db/kv/state_test.go

@@ -139,7 +139,7 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 				st, err := util.NewBeaconStateElectra()
 				require.NoError(t, err)
 				require.NoError(t, st.SetSlot(100))
-				p, err := blocks.WrappedExecutionPayloadHeaderDeneb(&enginev1.ExecutionPayloadHeaderDeneb{
+				p, err := blocks.WrappedExecutionPayloadHeaderElectra(&enginev1.ExecutionPayloadHeaderElectra{
 					ParentHash:       make([]byte, 32),
 					FeeRecipient:     make([]byte, 20),
 					StateRoot:        make([]byte, 32),

beacon-chain/execution/BUILD.bazel

@@ -131,11 +131,11 @@ go_test(
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//:go_default_library",
+        "@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
         "@com_github_ethereum_go_ethereum//beacon/engine:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
-        "@com_github_ethereum_go_ethereum//ethclient/simulated:go_default_library",
         "@com_github_ethereum_go_ethereum//rpc:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/execution/block_reader_test.go

@@ -12,7 +12,6 @@ import (
 	dbutil "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/testing"
 	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/types"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	contracts "github.com/prysmaticlabs/prysm/v5/contracts/deposit"
 	"github.com/prysmaticlabs/prysm/v5/contracts/deposit/mock"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
@@ -45,7 +44,7 @@ func TestLatestMainchainInfo_OK(t *testing.T) {
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 	testAcc.Backend.Commit()
 
@@ -142,7 +141,7 @@ func TestBlockExists_ValidHash(t *testing.T) {
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	testAcc.Backend.Commit()
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), big.NewInt(0))
+	block, err := testAcc.Backend.BlockByNumber(context.Background(), big.NewInt(0))
 	assert.NoError(t, err)
 
 	exists, height, err := web3Service.BlockExists(context.Background(), block.Hash())
@@ -202,10 +201,8 @@ func TestBlockExists_UsesCachedBlockInfo(t *testing.T) {
 }
 
 func TestService_BlockNumberByTimestamp(t *testing.T) {
-	ctx := context.Background()
 	beaconDB := dbutil.SetupDB(t)
 	testAcc, err := mock.Setup()
-
 	require.NoError(t, err, "Unable to set up simulated backend")
 	server, endpoint, err := mockExecution.SetupRPCServer()
 	require.NoError(t, err)
@@ -219,22 +216,16 @@ func TestService_BlockNumberByTimestamp(t *testing.T) {
 	require.NoError(t, err)
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	// simulated backend sets eth1 block
-	params.SetupTestConfigCleanup(t)
-	conf := params.BeaconConfig().Copy()
-	conf.SecondsPerETH1Block = 1
-	params.OverrideBeaconConfig(conf)
-	initialHead, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
-	require.NoError(t, err)
+
 	for i := 0; i < 200; i++ {
 		testAcc.Backend.Commit()
 	}
-
-	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
+	ctx := context.Background()
+	hd, err := testAcc.Backend.HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
 	web3Service.latestEth1Data.BlockHeight = hd.Number.Uint64()
-	blk, err := web3Service.BlockByTimestamp(ctx, initialHead.Time+100 /* time */)
+	blk, err := web3Service.BlockByTimestamp(ctx, 1000 /* time */)
 	require.NoError(t, err)
 	if blk.Number.Cmp(big.NewInt(0)) == 0 {
 		t.Error("Returned a block with zero number, expected to be non zero")
@@ -262,7 +253,7 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
 		testAcc.Backend.Commit()
 	}
 	ctx := context.Background()
-	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
+	hd, err := testAcc.Backend.HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
 	// Use extremely small deadline to illustrate that context deadlines are respected.
@@ -300,7 +291,7 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
 		testAcc.Backend.Commit()
 	}
 	ctx := context.Background()
-	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
+	hd, err := testAcc.Backend.HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
 	// Use extremely small deadline to illustrate that context deadlines are respected.

beacon-chain/execution/engine_client.go

@@ -221,7 +221,7 @@ func (s *Service) ForkchoiceUpdated(
 		if err != nil {
 			return nil, nil, handleRPCError(err)
 		}
-	case version.Deneb, version.Electra, version.Fulu:
+	case version.Deneb, version.Electra:
 		a, err := attrs.PbV3()
 		if err != nil {
 			return nil, nil, err
@@ -631,7 +631,43 @@ func fullPayloadFromPayloadBody(
 		return nil, errors.New("execution block and header cannot be nil")
 	}
 
-	if bVersion >= version.Deneb {
+	switch bVersion {
+	case version.Bellatrix:
+		return blocks.WrappedExecutionPayload(&pb.ExecutionPayload{
+			ParentHash:    header.ParentHash(),
+			FeeRecipient:  header.FeeRecipient(),
+			StateRoot:     header.StateRoot(),
+			ReceiptsRoot:  header.ReceiptsRoot(),
+			LogsBloom:     header.LogsBloom(),
+			PrevRandao:    header.PrevRandao(),
+			BlockNumber:   header.BlockNumber(),
+			GasLimit:      header.GasLimit(),
+			GasUsed:       header.GasUsed(),
+			Timestamp:     header.Timestamp(),
+			ExtraData:     header.ExtraData(),
+			BaseFeePerGas: header.BaseFeePerGas(),
+			BlockHash:     header.BlockHash(),
+			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
+		})
+	case version.Capella:
+		return blocks.WrappedExecutionPayloadCapella(&pb.ExecutionPayloadCapella{
+			ParentHash:    header.ParentHash(),
+			FeeRecipient:  header.FeeRecipient(),
+			StateRoot:     header.StateRoot(),
+			ReceiptsRoot:  header.ReceiptsRoot(),
+			LogsBloom:     header.LogsBloom(),
+			PrevRandao:    header.PrevRandao(),
+			BlockNumber:   header.BlockNumber(),
+			GasLimit:      header.GasLimit(),
+			GasUsed:       header.GasUsed(),
+			Timestamp:     header.Timestamp(),
+			ExtraData:     header.ExtraData(),
+			BaseFeePerGas: header.BaseFeePerGas(),
+			BlockHash:     header.BlockHash(),
+			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
+			Withdrawals:   body.Withdrawals,
+		}) // We can't get the block value and don't care about the block value for this instance
+	case version.Deneb, version.Electra:
 		ebg, err := header.ExcessBlobGas()
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
@@ -660,48 +696,9 @@ func fullPayloadFromPayloadBody(
 				ExcessBlobGas: ebg,
 				BlobGasUsed:   bgu,
 			}) // We can't get the block value and don't care about the block value for this instance
+	default:
+		return nil, fmt.Errorf("unknown execution block version for payload %d", bVersion)
 	}
-
-	if bVersion >= version.Capella {
-		return blocks.WrappedExecutionPayloadCapella(&pb.ExecutionPayloadCapella{
-			ParentHash:    header.ParentHash(),
-			FeeRecipient:  header.FeeRecipient(),
-			StateRoot:     header.StateRoot(),
-			ReceiptsRoot:  header.ReceiptsRoot(),
-			LogsBloom:     header.LogsBloom(),
-			PrevRandao:    header.PrevRandao(),
-			BlockNumber:   header.BlockNumber(),
-			GasLimit:      header.GasLimit(),
-			GasUsed:       header.GasUsed(),
-			Timestamp:     header.Timestamp(),
-			ExtraData:     header.ExtraData(),
-			BaseFeePerGas: header.BaseFeePerGas(),
-			BlockHash:     header.BlockHash(),
-			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
-			Withdrawals:   body.Withdrawals,
-		}) // We can't get the block value and don't care about the block value for this instance
-	}
-
-	if bVersion >= version.Bellatrix {
-		return blocks.WrappedExecutionPayload(&pb.ExecutionPayload{
-			ParentHash:    header.ParentHash(),
-			FeeRecipient:  header.FeeRecipient(),
-			StateRoot:     header.StateRoot(),
-			ReceiptsRoot:  header.ReceiptsRoot(),
-			LogsBloom:     header.LogsBloom(),
-			PrevRandao:    header.PrevRandao(),
-			BlockNumber:   header.BlockNumber(),
-			GasLimit:      header.GasLimit(),
-			GasUsed:       header.GasUsed(),
-			Timestamp:     header.Timestamp(),
-			ExtraData:     header.ExtraData(),
-			BaseFeePerGas: header.BaseFeePerGas(),
-			BlockHash:     header.BlockHash(),
-			Transactions:  pb.RecastHexutilByteSlice(body.Transactions),
-		})
-	}
-
-	return nil, fmt.Errorf("unknown execution block version for payload %s", version.String(bVersion))
 }
 
 // Handles errors received from the RPC server according to the specification.
@@ -793,8 +790,9 @@ func tDStringToUint256(td string) (*uint256.Int, error) {
 }
 
 func EmptyExecutionPayload(v int) (proto.Message, error) {
-	if v >= version.Deneb {
-		return &pb.ExecutionPayloadDeneb{
+	switch v {
+	case version.Bellatrix:
+		return &pb.ExecutionPayload{
 			ParentHash:    make([]byte, fieldparams.RootLength),
 			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
 			StateRoot:     make([]byte, fieldparams.RootLength),
@@ -805,11 +803,8 @@ func EmptyExecutionPayload(v int) (proto.Message, error) {
 			BaseFeePerGas: make([]byte, fieldparams.RootLength),
 			BlockHash:     make([]byte, fieldparams.RootLength),
 			Transactions:  make([][]byte, 0),
-			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
-	}
-
-	if v >= version.Capella {
+	case version.Capella:
 		return &pb.ExecutionPayloadCapella{
 			ParentHash:    make([]byte, fieldparams.RootLength),
 			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
@@ -823,10 +818,8 @@ func EmptyExecutionPayload(v int) (proto.Message, error) {
 			Transactions:  make([][]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
-	}
-
-	if v >= version.Bellatrix {
-		return &pb.ExecutionPayload{
+	case version.Deneb, version.Electra:
+		return &pb.ExecutionPayloadDeneb{
 			ParentHash:    make([]byte, fieldparams.RootLength),
 			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
 			StateRoot:     make([]byte, fieldparams.RootLength),
@@ -837,30 +830,28 @@ func EmptyExecutionPayload(v int) (proto.Message, error) {
 			BaseFeePerGas: make([]byte, fieldparams.RootLength),
 			BlockHash:     make([]byte, fieldparams.RootLength),
 			Transactions:  make([][]byte, 0),
+			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
+	default:
+		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 	}
-
-	return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 }
 
 func EmptyExecutionPayloadHeader(v int) (proto.Message, error) {
-	if v >= version.Deneb {
-		return &pb.ExecutionPayloadHeaderDeneb{
-			ParentHash:       make([]byte, fieldparams.RootLength),
-			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-			StateRoot:        make([]byte, fieldparams.RootLength),
-			ReceiptsRoot:     make([]byte, fieldparams.RootLength),
-			LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
-			PrevRandao:       make([]byte, fieldparams.RootLength),
-			ExtraData:        make([]byte, 0),
-			BaseFeePerGas:    make([]byte, fieldparams.RootLength),
-			BlockHash:        make([]byte, fieldparams.RootLength),
-			TransactionsRoot: make([]byte, fieldparams.RootLength),
-			WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+	switch v {
+	case version.Bellatrix:
+		return &pb.ExecutionPayloadHeader{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			ExtraData:     make([]byte, 0),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
 		}, nil
-	}
-
-	if v >= version.Capella {
+	case version.Capella:
 		return &pb.ExecutionPayloadHeaderCapella{
 			ParentHash:       make([]byte, fieldparams.RootLength),
 			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
@@ -874,23 +865,23 @@ func EmptyExecutionPayloadHeader(v int) (proto.Message, error) {
 			TransactionsRoot: make([]byte, fieldparams.RootLength),
 			WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
 		}, nil
-	}
-
-	if v >= version.Bellatrix {
-		return &pb.ExecutionPayloadHeader{
-			ParentHash:    make([]byte, fieldparams.RootLength),
-			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
-			StateRoot:     make([]byte, fieldparams.RootLength),
-			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
-			LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
-			PrevRandao:    make([]byte, fieldparams.RootLength),
-			ExtraData:     make([]byte, 0),
-			BaseFeePerGas: make([]byte, fieldparams.RootLength),
-			BlockHash:     make([]byte, fieldparams.RootLength),
+	case version.Deneb, version.Electra:
+		return &pb.ExecutionPayloadHeaderDeneb{
+			ParentHash:       make([]byte, fieldparams.RootLength),
+			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:        make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+			LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:       make([]byte, fieldparams.RootLength),
+			ExtraData:        make([]byte, 0),
+			BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+			BlockHash:        make([]byte, fieldparams.RootLength),
+			TransactionsRoot: make([]byte, fieldparams.RootLength),
+			WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
 		}, nil
+	default:
+		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 	}
-
-	return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 }
 
 func toBlockNumArg(number *big.Int) string {

beacon-chain/execution/log_processing_test.go

@@ -47,7 +47,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -72,7 +72,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
 	require.NoError(t, err, "Unable to retrieve logs")
 
 	if len(logs) == 0 {
@@ -116,7 +116,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -144,7 +144,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
 	require.NoError(t, err, "Unable to retrieve logs")
 
 	web3Service.chainStartData.Chainstarted = true
@@ -176,7 +176,7 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -199,7 +199,7 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
 		},
 	}
 
-	logz, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
+	logz, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
 	require.NoError(t, err, "Unable to retrieve logs")
 
 	loggedPubkey, withCreds, _, loggedSig, index, err := contracts.UnpackDepositLogData(logz[0].Data)
@@ -232,7 +232,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
 	params.SetupTestConfigCleanup(t)
@@ -269,7 +269,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
 	require.NoError(t, err, "Unable to retrieve logs")
 
 	for i := range logs {
@@ -307,7 +307,7 @@ func TestProcessETH2GenesisLog(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	require.NoError(t, err)
 	params.SetupTestConfigCleanup(t)
@@ -342,7 +342,7 @@ func TestProcessETH2GenesisLog(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
 	require.NoError(t, err, "Unable to retrieve logs")
 	require.Equal(t, depositsReqForChainStart, len(logs))
 
@@ -400,18 +400,16 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.httpLogger = testAcc.Backend.Client()
+	web3Service.httpLogger = testAcc.Backend
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
-	web3Service.latestEth1Data.BlockTime = block.Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 	bConfig := params.MinimalSpecConfig().Copy()
 	bConfig.MinGenesisTime = 0
-	bConfig.SecondsPerETH1Block = 1
+	bConfig.SecondsPerETH1Block = 10
 	params.OverrideBeaconConfig(bConfig)
 	nConfig := params.BeaconNetworkConfig()
 	nConfig.ContractDeploymentBlock = 0
@@ -446,10 +444,8 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
-	web3Service.latestEth1Data.BlockTime = b.Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	// Set up our subscriber now to listen for the chain started event.
 	stateChannel := make(chan *feed.Event, 1)
@@ -501,15 +497,13 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.httpLogger = testAcc.Backend.Client()
+	web3Service.httpLogger = testAcc.Backend
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
-	web3Service.latestEth1Data.BlockTime = b.Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 	bConfig := params.MinimalSpecConfig().Copy()
 	bConfig.SecondsPerETH1Block = 10
 	params.OverrideBeaconConfig(bConfig)
@@ -546,19 +540,14 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	for i := uint64(0); i < 1500; i++ {
 		testAcc.Backend.Commit()
 	}
-	genesisBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-
-	wantedGenesisTime := genesisBlock.Time()
+	wantedGenesisTime := testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	// Forward the chain to account for the follow distance
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	currBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	web3Service.latestEth1Data.BlockHeight = currBlock.NumberU64()
-	web3Service.latestEth1Data.BlockTime = currBlock.Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	// Set the genesis time 500 blocks ahead of the last
 	// deposit log.
@@ -619,7 +608,7 @@ func newPowchainService(t *testing.T, eth1Backend *mock.TestAccount, beaconDB db
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(eth1Backend.ContractAddr, eth1Backend.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(eth1Backend.ContractAddr, eth1Backend.Backend)
 	require.NoError(t, err)
 
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: eth1Backend.Backend}

beacon-chain/execution/payload_body_test.go

@@ -17,6 +17,14 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
+type versioner struct {
+	version int
+}
+
+func (v versioner) Version() int {
+	return v.version
+}
+
 func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPayloadBody {
 	body := &pb.ExecutionPayloadBody{}
 	txs, err := ed.Transactions()
@@ -37,7 +45,6 @@ type blindedBlockFixtures struct {
 	emptyDenebBlock *fullAndBlinded
 	afterSkipDeneb  *fullAndBlinded
 	electra         *fullAndBlinded
-	fulu            *fullAndBlinded
 }
 
 type fullAndBlinded struct {
@@ -70,12 +77,6 @@ func electraSlot(t *testing.T) primitives.Slot {
 	return s
 }
 
-func fuluSlot(t *testing.T) primitives.Slot {
-	s, err := slots.EpochStart(params.BeaconConfig().FuluForkEpoch)
-	require.NoError(t, err)
-	return s
-}
-
 func testBlindedBlockFixtures(t *testing.T) *blindedBlockFixtures {
 	pfx := fixturesStruct()
 	fx := &blindedBlockFixtures{}
@@ -103,18 +104,11 @@ func testBlindedBlockFixtures(t *testing.T) *blindedBlockFixtures {
 	electra.BlockNumber = 5
 	electraBlock, _ := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, electraSlot(t), 0, util.WithElectraPayload(electra))
 	fx.electra = blindedBlockWithHeader(t, electraBlock)
-
-	fulu := fixturesStruct().ExecutionPayloadDeneb
-	fulu.BlockHash = bytesutil.PadTo([]byte("fulu"), 32)
-	fulu.BlockNumber = 6
-	fuluBlock, _ := util.GenerateTestElectraBlockWithSidecar(t, [32]byte{}, fuluSlot(t), 0, util.WithElectraPayload(fulu))
-	fx.fulu = blindedBlockWithHeader(t, fuluBlock)
-
 	return fx
 }
 
 func TestPayloadBodiesViaUnblinder(t *testing.T) {
-	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
+	defer util.HackElectraMaxuint(t)()
 	fx := testBlindedBlockFixtures(t)
 	t.Run("mix of non-empty and empty", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
@@ -151,7 +145,7 @@ func TestPayloadBodiesViaUnblinder(t *testing.T) {
 }
 
 func TestFixtureEquivalence(t *testing.T) {
-	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
+	defer util.HackElectraMaxuint(t)()
 	fx := testBlindedBlockFixtures(t)
 	t.Run("full and blinded block equivalence", func(t *testing.T) {
 		testAssertReconstructedEquivalent(t, fx.denebBlock.blinded.block, fx.denebBlock.full)
@@ -254,7 +248,7 @@ func TestComputeRanges(t *testing.T) {
 }
 
 func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
-	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
+	defer util.HackElectraMaxuint(t)()
 	ctx := context.Background()
 	t.Run("fallback fails", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
@@ -339,19 +333,18 @@ func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
 	})
 }
 
-func TestReconstructBlindedBlockBatchDenebAndBeyond(t *testing.T) {
-	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
-	t.Run("deneb and beyond", func(t *testing.T) {
+func TestReconstructBlindedBlockBatchDenebAndElectra(t *testing.T) {
+	defer util.HackElectraMaxuint(t)()
+	t.Run("deneb and electra", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
 		fx := testBlindedBlockFixtures(t)
 		srv.register(GetPayloadBodiesByHashV1, func(msg *jsonrpcMessage, w http.ResponseWriter, r *http.Request) {
-			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header), payloadToBody(t, fx.electra.blinded.header), payloadToBody(t, fx.fulu.blinded.header)}
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header), payloadToBody(t, fx.electra.blinded.header)}
 			mockWriteResult(t, w, msg, executionPayloadBodies)
 		})
 		blinded := []interfaces.ReadOnlySignedBeaconBlock{
 			fx.denebBlock.blinded.block,
 			fx.electra.blinded.block,
-			fx.fulu.blinded.block,
 		}
 		unblinded, err := reconstructBlindedBlockBatch(context.Background(), cli, blinded)
 		require.NoError(t, err)

beacon-chain/execution/service_test.go

@@ -8,10 +8,10 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
@@ -44,7 +44,7 @@ var _ POWBlockFetcher = (*Service)(nil)
 var _ Chain = (*Service)(nil)
 
 type goodLogger struct {
-	backend *simulated.Backend
+	backend *backends.SimulatedBackend
 }
 
 func (_ *goodLogger) Close() {}
@@ -53,7 +53,7 @@ func (g *goodLogger) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQ
 	if g.backend == nil {
 		return new(event.Feed).Subscribe(ch), nil
 	}
-	return g.backend.Client().SubscribeFilterLogs(ctx, q, ch)
+	return g.backend.SubscribeFilterLogs(ctx, q, ch)
 }
 
 func (g *goodLogger) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]gethTypes.Log, error) {
@@ -69,7 +69,7 @@ func (g *goodLogger) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]
 		}
 		return logs, nil
 	}
-	return g.backend.Client().FilterLogs(ctx, q)
+	return g.backend.FilterLogs(ctx, q)
 }
 
 type goodNotifier struct {
@@ -109,7 +109,7 @@ func TestStart_OK(t *testing.T) {
 	require.NoError(t, err, "unable to setup execution service")
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 	testAcc.Backend.Commit()
 
@@ -156,7 +156,7 @@ func TestStop_OK(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -186,12 +186,10 @@ func TestService_Eth1Synced(t *testing.T) {
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
-	header, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	currTime := header.Time
+	currTime := testAcc.Backend.Blockchain().CurrentHeader().Time
 	now := time.Now()
 	assert.NoError(t, testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0))))
 	testAcc.Backend.Commit()
@@ -214,29 +212,22 @@ func TestFollowBlock_OK(t *testing.T) {
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 
 	// simulated backend sets eth1 block
+	// time as 10 seconds
 	params.SetupTestConfigCleanup(t)
 	conf := params.BeaconConfig().Copy()
-	conf.SecondsPerETH1Block = 1
+	conf.SecondsPerETH1Block = 10
 	params.OverrideBeaconConfig(conf)
 
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	baseHeight := block.NumberU64()
+	baseHeight := testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
 	// process follow_distance blocks
-	var lastHash common.Hash
 	for i := 0; i < int(params.BeaconConfig().Eth1FollowDistance); i++ {
-		lastHash = testAcc.Backend.Commit()
+		testAcc.Backend.Commit()
 	}
-	lb, err := testAcc.Backend.Client().BlockByHash(context.Background(), lastHash)
-	require.NoError(t, err)
-	log.Println(lb.NumberU64())
 	// set current height
-	block, err = testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
-	web3Service.latestEth1Data.BlockTime = block.Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	h, err := web3Service.followedBlockHeight(context.Background())
 	require.NoError(t, err)
@@ -247,12 +238,9 @@ func TestFollowBlock_OK(t *testing.T) {
 	for i := uint64(0); i < numToForward; i++ {
 		testAcc.Backend.Commit()
 	}
-
-	newBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
-	require.NoError(t, err)
 	// set current height
-	web3Service.latestEth1Data.BlockHeight = newBlock.NumberU64()
-	web3Service.latestEth1Data.BlockTime = newBlock.Time()
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
 
 	h, err = web3Service.followedBlockHeight(context.Background())
 	require.NoError(t, err)
@@ -337,11 +325,11 @@ func TestLogTillGenesis_OK(t *testing.T) {
 		WithDatabase(beaconDB),
 	)
 	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
-	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
 	require.NoError(t, err)
 
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.httpLogger = testAcc.Backend.Client()
+	web3Service.httpLogger = testAcc.Backend
 	for i := 0; i < 30; i++ {
 		testAcc.Backend.Commit()
 	}
@@ -497,18 +485,15 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {
 	for i := 0; i < numToForward; i++ {
 		testAcc.Backend.Commit()
 	}
-	currHeader, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	currTime := currHeader.Time
+	currTime := testAcc.Backend.Blockchain().CurrentHeader().Time
 	now := time.Now()
 	err = testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0)))
 	require.NoError(t, err)
 	testAcc.Backend.Commit()
-	currHeader, err = testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
-	require.NoError(t, err)
-	currTime = currHeader.Time
-	web3Service.latestEth1Data.BlockHeight = currHeader.Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = currHeader.Time
+
+	currTime = testAcc.Backend.Blockchain().CurrentHeader().Time
+	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentHeader().Number.Uint64()
+	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentHeader().Time
 	web3Service.chainStartData.GenesisTime = currTime
 
 	// With a current slot of zero, only request follow_blocks behind.

beacon-chain/execution/testing/BUILD.bazel

@@ -25,10 +25,10 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
-        "@com_github_ethereum_go_ethereum//ethclient/simulated:go_default_library",
         "@com_github_ethereum_go_ethereum//rpc:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/execution/testing/mock_execution_chain.go

@@ -9,10 +9,10 @@ import (
 	"net/http/httptest"
 	"time"
 
+	"github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	gethTypes "github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/ethclient/simulated"
 	"github.com/ethereum/go-ethereum/rpc"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/async/event"
@@ -141,7 +141,7 @@ func (m *Chain) ETH1ConnectionErrors() []error {
 
 // RPCClient defines the mock rpc client.
 type RPCClient struct {
-	Backend     *simulated.Backend
+	Backend     *backends.SimulatedBackend
 	BlockNumMap map[uint64]*types.HeaderInfo
 }
 
@@ -195,7 +195,7 @@ func (r *RPCClient) CallContext(ctx context.Context, obj interface{}, methodName
 				return err
 			}
 		}
-		h, err := r.Backend.Client().HeaderByNumber(ctx, num)
+		h, err := r.Backend.HeaderByNumber(ctx, num)
 		if err != nil {
 			return err
 		}
@@ -213,7 +213,7 @@ func (r *RPCClient) CallContext(ctx context.Context, obj interface{}, methodName
 		if !ok {
 			return errors.Errorf("wrong argument type provided: %T", args[0])
 		}
-		h, err := r.Backend.Client().HeaderByHash(ctx, val)
+		h, err := r.Backend.HeaderByHash(ctx, val)
 		if err != nil {
 			return err
 		}
@@ -241,7 +241,7 @@ func (r *RPCClient) BatchCall(b []rpc.BatchElem) error {
 		if err != nil {
 			return err
 		}
-		h, err := r.Backend.Client().HeaderByNumber(context.Background(), num)
+		h, err := r.Backend.HeaderByNumber(context.Background(), num)
 		if err != nil {
 			return err
 		}

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

@@ -236,7 +236,7 @@ func (c *AttCaches) AggregatedAttestationsBySlotIndexElectra(
 	c.aggregatedAttLock.RLock()
 	defer c.aggregatedAttLock.RUnlock()
 	for _, as := range c.aggregatedAtt {
-		if as[0].Version() >= version.Electra && slot == as[0].GetData().Slot && as[0].CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
+		if as[0].Version() == version.Electra && slot == as[0].GetData().Slot && as[0].CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
 			for _, a := range as {
 				att, ok := a.(*ethpb.AttestationElectra)
 				// This will never fail in practice because we asserted the version

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

@@ -115,7 +115,7 @@ func (c *AttCaches) UnaggregatedAttestationsBySlotIndexElectra(
 
 	unAggregatedAtts := c.unAggregatedAtt
 	for _, a := range unAggregatedAtts {
-		if a.Version() >= version.Electra && slot == a.GetData().Slot && a.CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
+		if a.Version() == version.Electra && slot == a.GetData().Slot && a.CommitteeBitsVal().BitAt(uint64(committeeIndex)) {
 			att, ok := a.(*ethpb.AttestationElectra)
 			// This will never fail in practice because we asserted the version
 			if ok {

beacon-chain/p2p/broadcaster.go

@@ -163,7 +163,7 @@ func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMs
 
 	// Ensure we have peers with this subnet.
 	// This adds in a special value to the subnet
-	// to ensure that we can reuse the same subnet locker.
+	// to ensure that we can re-use the same subnet locker.
 	wrappedSubIdx := subnet + syncLockerVal
 	s.subnetLocker(wrappedSubIdx).RLock()
 	hasPeer := s.hasPeerWithSubnet(syncCommitteeToTopic(subnet, forkDigest))

beacon-chain/p2p/broadcaster_test.go

@@ -209,7 +209,7 @@ func TestService_BroadcastAttestation(t *testing.T) {
 
 func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	// Setup bootnode.
-	cfg := &Config{PingInterval: testPingInterval}
+	cfg := &Config{}
 	port := 2000
 	cfg.UDPPort = uint(port)
 	_, pkey := createAddrAndPrivKey(t)
@@ -234,16 +234,12 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	cfg = &Config{
 		Discv5BootStrapAddrs: []string{bootNode.String()},
 		MaxPeers:             2,
-		PingInterval:         testPingInterval,
 	}
 	// Setup 2 different hosts
 	for i := 1; i <= 2; i++ {
 		h, pkey, ipAddr := createHost(t, port+i)
 		cfg.UDPPort = uint(port + i)
 		cfg.TCPPort = uint(port + i)
-		if len(listeners) > 0 {
-			cfg.Discv5BootStrapAddrs = append(cfg.Discv5BootStrapAddrs, listeners[len(listeners)-1].Self().String())
-		}
 		s := &Service{
 			cfg:                   cfg,
 			genesisTime:           genesisTime,

beacon-chain/p2p/config.go

@@ -1,8 +1,6 @@
 package p2p
 
 import (
-	"time"
-
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
@@ -17,7 +15,6 @@ type Config struct {
 	NoDiscovery          bool
 	EnableUPnP           bool
 	StaticPeerID         bool
-	DisableLivenessCheck bool
 	StaticPeers          []string
 	Discv5BootStrapAddrs []string
 	RelayNodeAddr        string
@@ -30,7 +27,6 @@ type Config struct {
 	QUICPort             uint
 	TCPPort              uint
 	UDPPort              uint
-	PingInterval         time.Duration
 	MaxPeers             uint
 	QueueSize            uint
 	AllowListCIDR        string

beacon-chain/p2p/discovery.go

@@ -418,10 +418,8 @@ func (s *Service) createListener(
 	}
 
 	dv5Cfg := discover.Config{
-		PrivateKey:              privKey,
-		Bootnodes:               bootNodes,
-		PingInterval:            s.cfg.PingInterval,
-		NoFindnodeLivenessCheck: s.cfg.DisableLivenessCheck,
+		PrivateKey: privKey,
+		Bootnodes:  bootNodes,
 	}
 
 	listener, err := discover.ListenV5(conn, localNode, dv5Cfg)

beacon-chain/p2p/discovery_test.go

@@ -87,7 +87,7 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 	genesisTime := time.Now()
 	genesisValidatorsRoot := make([]byte, 32)
 	s := &Service{
-		cfg:                   &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
+		cfg:                   &Config{UDPPort: uint(port)},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
 	}
@@ -95,10 +95,6 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 	require.NoError(t, err)
 	defer bootListener.Close()
 
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
-
 	bootNode := bootListener.Self()
 
 	var listeners []*listenerWrapper
@@ -107,8 +103,6 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 		cfg := &Config{
 			Discv5BootStrapAddrs: []string{bootNode.String()},
 			UDPPort:              uint(port),
-			PingInterval:         testPingInterval,
-			DisableLivenessCheck: true,
 		}
 		ipAddr, pkey := createAddrAndPrivKey(t)
 		s = &Service{
@@ -140,6 +134,9 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 
 func TestCreateLocalNode(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.Eip7594ForkEpoch = 1
+	params.OverrideBeaconConfig(cfg)
 	testCases := []struct {
 		name          string
 		cfg           *Config
@@ -354,10 +351,10 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) {
 }
 
 func TestHostIsResolved(t *testing.T) {
-	// ip.addr.tools - construct domain names that resolve to any given IP address
-	// ex: 192-0-2-1.ip.addr.tools resolves to 192.0.2.1. 
-	exampleHost := "96-7-129-13.ip.addr.tools"
-	exampleIP := "96.7.129.13"
+	// As defined in RFC 2606 , example.org is a
+	// reserved example domain name.
+	exampleHost := "example.org"
+	exampleIP := "93.184.215.14"
 
 	s := &Service{
 		cfg: &Config{
@@ -610,12 +607,16 @@ func TestRefreshPersistentSubnets(t *testing.T) {
 	defer cache.SubnetIDs.EmptyAllCaches()
 	defer cache.SyncSubnetIDs.EmptyAllCaches()
 
-	const altairForkEpoch = 5
+	const (
+		altairForkEpoch  = 5
+		eip7594ForkEpoch = 10
+	)
 
 	// Set up epochs.
 	defaultCfg := params.BeaconConfig()
 	cfg := defaultCfg.Copy()
 	cfg.AltairForkEpoch = altairForkEpoch
+	cfg.Eip7594ForkEpoch = eip7594ForkEpoch
 	params.OverrideBeaconConfig(cfg)
 
 	// Compute the number of seconds per epoch.

beacon-chain/p2p/fork_test.go

@@ -34,10 +34,8 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) {
 	genesisValidatorsRoot := make([]byte, fieldparams.RootLength)
 	s := &Service{
 		cfg: &Config{
-			UDPPort:              uint(port),
-			StateNotifier:        &mock.MockStateNotifier{},
-			PingInterval:         testPingInterval,
-			DisableLivenessCheck: true,
+			UDPPort:       uint(port),
+			StateNotifier: &mock.MockStateNotifier{},
 		},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
@@ -46,17 +44,11 @@ func TestStartDiscv5_DifferentForkDigests(t *testing.T) {
 	require.NoError(t, err)
 	defer bootListener.Close()
 
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
-
 	bootNode := bootListener.Self()
 	cfg := &Config{
 		Discv5BootStrapAddrs: []string{bootNode.String()},
 		UDPPort:              uint(port),
 		StateNotifier:        &mock.MockStateNotifier{},
-		PingInterval:         testPingInterval,
-		DisableLivenessCheck: true,
 	}
 
 	var listeners []*listenerWrapper
@@ -132,7 +124,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
 	genesisTime := time.Now()
 	genesisValidatorsRoot := make([]byte, 32)
 	s := &Service{
-		cfg:                   &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
+		cfg:                   &Config{UDPPort: uint(port)},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
 	}
@@ -140,16 +132,10 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
 	require.NoError(t, err)
 	defer bootListener.Close()
 
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
-
 	bootNode := bootListener.Self()
 	cfg := &Config{
 		Discv5BootStrapAddrs: []string{bootNode.String()},
 		UDPPort:              uint(port),
-		PingInterval:         testPingInterval,
-		DisableLivenessCheck: true,
 	}
 
 	var listeners []*listenerWrapper
@@ -157,6 +143,7 @@ func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
 		port := 3000 + i
 		cfg.UDPPort = uint(port)
 		ipAddr, pkey := createAddrAndPrivKey(t)
+
 		c := params.BeaconConfig().Copy()
 		nextForkEpoch := primitives.Epoch(i)
 		c.ForkVersionSchedule[[4]byte{'A', 'B', 'C', 'D'}] = nextForkEpoch

beacon-chain/p2p/fork_watcher.go

@@ -18,8 +18,7 @@ func (s *Service) forkWatcher() {
 				currEpoch == params.BeaconConfig().BellatrixForkEpoch ||
 				currEpoch == params.BeaconConfig().CapellaForkEpoch ||
 				currEpoch == params.BeaconConfig().DenebForkEpoch ||
-				currEpoch == params.BeaconConfig().ElectraForkEpoch ||
-				currEpoch == params.BeaconConfig().FuluForkEpoch {
+				currEpoch == params.BeaconConfig().ElectraForkEpoch {
 				// If we are in the fork epoch, we update our enr with
 				// the updated fork digest. These repeatedly does
 				// this over the epoch, which might be slightly wasteful

beacon-chain/p2p/gossip_topic_mappings.go

@@ -29,9 +29,6 @@ var gossipTopicMappings = map[string]func() proto.Message{
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 	switch topic {
 	case BlockSubnetTopicFormat:
-		if epoch >= params.BeaconConfig().FuluForkEpoch {
-			return &ethpb.SignedBeaconBlockFulu{}
-		}
 		if epoch >= params.BeaconConfig().ElectraForkEpoch {
 			return &ethpb.SignedBeaconBlockElectra{}
 		}
@@ -94,25 +91,17 @@ func init() {
 	for k, v := range gossipTopicMappings {
 		GossipTypeMapping[reflect.TypeOf(v())] = k
 	}
-
 	// Specially handle Altair objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockAltair{})] = BlockSubnetTopicFormat
-
 	// Specially handle Bellatrix objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockBellatrix{})] = BlockSubnetTopicFormat
-
 	// Specially handle Capella objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockCapella{})] = BlockSubnetTopicFormat
-
 	// Specially handle Deneb objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockDeneb{})] = BlockSubnetTopicFormat
-
 	// Specially handle Electra objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockElectra{})] = BlockSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SingleAttestation{})] = AttestationSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.AttesterSlashingElectra{})] = AttesterSlashingSubnetTopicFormat
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedAggregateAttestationAndProofElectra{})] = AggregateAndProofSubnetTopicFormat
-
-	// Specially handle Fulu objects.
-	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockFulu{})] = BlockSubnetTopicFormat
 }

beacon-chain/p2p/gossip_topic_mappings_test.go

@@ -30,20 +30,17 @@ func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	capellaForkEpoch := primitives.Epoch(300)
 	denebForkEpoch := primitives.Epoch(400)
 	electraForkEpoch := primitives.Epoch(500)
-	fuluForkEpoch := primitives.Epoch(600)
 
 	bCfg.AltairForkEpoch = altairForkEpoch
 	bCfg.BellatrixForkEpoch = bellatrixForkEpoch
 	bCfg.CapellaForkEpoch = capellaForkEpoch
 	bCfg.DenebForkEpoch = denebForkEpoch
 	bCfg.ElectraForkEpoch = electraForkEpoch
-	bCfg.FuluForkEpoch = fuluForkEpoch
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.AltairForkVersion)] = primitives.Epoch(100)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.BellatrixForkVersion)] = primitives.Epoch(200)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.CapellaForkVersion)] = primitives.Epoch(300)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.DenebForkVersion)] = primitives.Epoch(400)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.ElectraForkVersion)] = primitives.Epoch(500)
-	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.FuluForkVersion)] = primitives.Epoch(600)
 	params.OverrideBeaconConfig(bCfg)
 
 	// Phase 0

beacon-chain/p2p/pubsub_filter.go

@@ -77,11 +77,6 @@ func (s *Service) CanSubscribe(topic string) bool {
 		log.WithError(err).Error("Could not determine Electra fork digest")
 		return false
 	}
-	fuluForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().FuluForkEpoch, s.genesisValidatorsRoot)
-	if err != nil {
-		log.WithError(err).Error("Could not determine Fulu fork digest")
-		return false
-	}
 	switch parts[2] {
 	case fmt.Sprintf("%x", phase0ForkDigest):
 	case fmt.Sprintf("%x", altairForkDigest):
@@ -89,7 +84,6 @@ func (s *Service) CanSubscribe(topic string) bool {
 	case fmt.Sprintf("%x", capellaForkDigest):
 	case fmt.Sprintf("%x", denebForkDigest):
 	case fmt.Sprintf("%x", electraForkDigest):
-	case fmt.Sprintf("%x", fuluForkDigest):
 	default:
 		return false
 	}

beacon-chain/p2p/pubsub_tracer.go

@@ -108,7 +108,6 @@ func (g gossipTracer) setMetricFromRPC(act action, subCtr prometheus.Counter, pu
 		ctrlCtr.WithLabelValues("prune").Add(float64(len(rpc.Control.Prune)))
 		ctrlCtr.WithLabelValues("ihave").Add(float64(len(rpc.Control.Ihave)))
 		ctrlCtr.WithLabelValues("iwant").Add(float64(len(rpc.Control.Iwant)))
-		ctrlCtr.WithLabelValues("idontwant").Add(float64(len(rpc.Control.Idontwant)))
 	}
 	for _, msg := range rpc.Publish {
 		// For incoming messages from pubsub, we do not record metrics for them as these values

beacon-chain/p2p/rpc_topic_mappings.go

@@ -73,6 +73,9 @@ const (
 	RPCBlocksByRootTopicV2 = protocolPrefix + BeaconBlocksByRootsMessageName + SchemaVersionV2
 	// RPCMetaDataTopicV2 defines the v2 topic for the metadata rpc method.
 	RPCMetaDataTopicV2 = protocolPrefix + MetadataMessageName + SchemaVersionV2
+
+	RPCBlobSidecarsByRangeTopicV2 = protocolPrefix + BlobSidecarsByRangeName + SchemaVersionV2
+	RPCBlobSidecarsByRootTopicV2  = protocolPrefix + BlobSidecarsByRootName + SchemaVersionV2
 )
 
 // RPC errors for topic parsing.

beacon-chain/p2p/service_test.go

@@ -28,8 +28,6 @@ import (
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
-const testPingInterval = 100 * time.Millisecond
-
 type mockListener struct {
 	localNode *enode.LocalNode
 }
@@ -188,7 +186,7 @@ func TestListenForNewNodes(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	// Setup bootnode.
 	notifier := &mock.MockStateNotifier{}
-	cfg := &Config{StateNotifier: notifier, PingInterval: testPingInterval, DisableLivenessCheck: true}
+	cfg := &Config{StateNotifier: notifier}
 	port := 2000
 	cfg.UDPPort = uint(port)
 	_, pkey := createAddrAndPrivKey(t)
@@ -204,10 +202,6 @@ func TestListenForNewNodes(t *testing.T) {
 	require.NoError(t, err)
 	defer bootListener.Close()
 
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
-
 	// Use shorter period for testing.
 	currentPeriod := pollingPeriod
 	pollingPeriod = 1 * time.Second
@@ -223,8 +217,6 @@ func TestListenForNewNodes(t *testing.T) {
 	cs := startup.NewClockSynchronizer()
 	cfg = &Config{
 		Discv5BootStrapAddrs: []string{bootNode.String()},
-		PingInterval:         testPingInterval,
-		DisableLivenessCheck: true,
 		MaxPeers:             30,
 		ClockWaiter:          cs,
 	}

beacon-chain/p2p/subnets.go

@@ -473,7 +473,7 @@ func syncBitvector(record *enr.Record) (bitfield.Bitvector4, error) {
 }
 
 // The subnet locker is a map which keeps track of all
-// mutexes stored per subnet. This locker is reused
+// mutexes stored per subnet. This locker is re-used
 // between both the attestation, sync and blob subnets.
 // Sync subnets are stored by (subnet+syncLockerVal).
 // Blob subnets are stored by (subnet+blobSubnetLockerVal).

beacon-chain/p2p/subnets_test.go

@@ -66,7 +66,7 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
 	genesisTime := time.Now()
 
 	bootNodeService := &Service{
-		cfg:                   &Config{UDPPort: 2000, TCPPort: 3000, QUICPort: 3000, DisableLivenessCheck: true, PingInterval: testPingInterval},
+		cfg:                   &Config{UDPPort: 2000, TCPPort: 3000, QUICPort: 3000},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
 	}
@@ -78,10 +78,6 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
 	require.NoError(t, err)
 	defer bootListener.Close()
 
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
-
 	bootNodeENR := bootListener.Self().String()
 
 	// Create 3 nodes, each subscribed to a different subnet.
@@ -96,8 +92,6 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
 			UDPPort:              uint(2000 + i),
 			TCPPort:              uint(3000 + i),
 			QUICPort:             uint(3000 + i),
-			PingInterval:         testPingInterval,
-			DisableLivenessCheck: true,
 		})
 
 		require.NoError(t, err)
@@ -139,8 +133,6 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
 
 	cfg := &Config{
 		Discv5BootStrapAddrs: []string{bootNodeENR},
-		PingInterval:         testPingInterval,
-		DisableLivenessCheck: true,
 		MaxPeers:             30,
 		UDPPort:              2010,
 		TCPPort:              3010,

beacon-chain/p2p/testing/p2p.go

@@ -65,10 +65,7 @@ func NewTestP2P(t *testing.T, userOptions ...config.Option) *TestP2P {
 		libp2p.DefaultListenAddrs,
 	}
 
-	// Favour user options if provided.
-	if len(userOptions) > 0 {
-		options = append(userOptions, options...)
-	}
+	options = append(options, userOptions...)
 
 	h, err := libp2p.New(options...)
 	require.NoError(t, err)

beacon-chain/p2p/types/object_mapping.go

@@ -67,12 +67,7 @@ func InitializeDataMaps() {
 		},
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (interfaces.ReadOnlySignedBeaconBlock, error) {
 			return blocks.NewSignedBeaconBlock(
-				&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
-			)
-		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (interfaces.ReadOnlySignedBeaconBlock, error) {
-			return blocks.NewSignedBeaconBlock(
-				&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockFulu{Body: &ethpb.BeaconBlockBodyFulu{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}},
+				&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadElectra{}}}},
 			)
 		},
 	}
@@ -97,9 +92,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (metadata.Metadata, error) {
 			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
-		},
 	}
 
 	// Reset our attestation map.
@@ -122,9 +114,6 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.Att, error) {
 			return &ethpb.SingleAttestation{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.Att, error) {
-			return &ethpb.AttestationElectra{}, nil
-		},
 	}
 
 	// Reset our aggregate attestation map.
@@ -147,8 +136,5 @@ func InitializeDataMaps() {
 		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
 			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
-			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
-		},
 	}
 }

beacon-chain/rpc/eth/beacon/handlers.go

@@ -354,29 +354,6 @@ func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWrit
 		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
 	}
 
-	fuluBlock := &eth.SignedBlindedBeaconBlockFulu{}
-	if err = fuluBlock.UnmarshalSSZ(body); err == nil {
-		genericBlock := &eth.GenericSignedBeaconBlock{
-			Block: &eth.GenericSignedBeaconBlock_BlindedFulu{
-				BlindedFulu: fuluBlock,
-			},
-		}
-		if err = s.validateBroadcast(ctx, r, genericBlock); err != nil {
-			httputil.HandleError(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		s.proposeBlock(ctx, w, genericBlock)
-		return
-	}
-	if versionHeader == version.String(version.Fulu) {
-		httputil.HandleError(
-			w,
-			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Fulu), err.Error()),
-			http.StatusBadRequest,
-		)
-		return
-	}
-
 	electraBlock := &eth.SignedBlindedBeaconBlockElectra{}
 	if err = electraBlock.UnmarshalSSZ(body); err == nil {
 		genericBlock := &eth.GenericSignedBeaconBlock{
@@ -531,27 +508,6 @@ func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter,
 
 	var consensusBlock *eth.GenericSignedBeaconBlock
 
-	var fuluBlock *structs.SignedBlindedBeaconBlockFulu
-	if err = unmarshalStrict(body, &fuluBlock); err == nil {
-		consensusBlock, err = fuluBlock.ToGeneric()
-		if err == nil {
-			if err = s.validateBroadcast(ctx, r, consensusBlock); err != nil {
-				httputil.HandleError(w, err.Error(), http.StatusBadRequest)
-				return
-			}
-			s.proposeBlock(ctx, w, consensusBlock)
-			return
-		}
-	}
-	if versionHeader == version.String(version.Fulu) {
-		httputil.HandleError(
-			w,
-			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Fulu), err.Error()),
-			http.StatusBadRequest,
-		)
-		return
-	}
-
 	var electraBlock *structs.SignedBlindedBeaconBlockElectra
 	if err = unmarshalStrict(body, &electraBlock); err == nil {
 		consensusBlock, err = electraBlock.ToGeneric()
@@ -736,39 +692,6 @@ func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *
 		return
 	}
 
-	fuluBlock := &eth.SignedBeaconBlockContentsFulu{}
-	if err = fuluBlock.UnmarshalSSZ(body); err == nil {
-		genericBlock := &eth.GenericSignedBeaconBlock{
-			Block: &eth.GenericSignedBeaconBlock_Fulu{
-				Fulu: fuluBlock,
-			},
-		}
-		if err = s.validateBroadcast(ctx, r, genericBlock); err != nil {
-			if errors.Is(err, errEquivocatedBlock) {
-				b, err := blocks.NewSignedBeaconBlock(genericBlock)
-				if err != nil {
-					httputil.HandleError(w, err.Error(), http.StatusBadRequest)
-					return
-				}
-				if err := s.broadcastSeenBlockSidecars(ctx, b, genericBlock.GetFulu().Blobs, genericBlock.GetFulu().KzgProofs); err != nil {
-					log.WithError(err).Error("Failed to broadcast blob sidecars")
-				}
-			}
-			httputil.HandleError(w, err.Error(), http.StatusBadRequest)
-			return
-		}
-		s.proposeBlock(ctx, w, genericBlock)
-		return
-	}
-	if versionHeader == version.String(version.Fulu) {
-		httputil.HandleError(
-			w,
-			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Fulu), err.Error()),
-			http.StatusBadRequest,
-		)
-		return
-	}
-
 	electraBlock := &eth.SignedBeaconBlockContentsElectra{}
 	if err = electraBlock.UnmarshalSSZ(body); err == nil {
 		genericBlock := &eth.GenericSignedBeaconBlock{
@@ -944,37 +867,6 @@ func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *htt
 
 	var consensusBlock *eth.GenericSignedBeaconBlock
 
-	var fuluBlockContents *structs.SignedBeaconBlockContentsFulu
-	if err = unmarshalStrict(body, &fuluBlockContents); err == nil {
-		consensusBlock, err = fuluBlockContents.ToGeneric()
-		if err == nil {
-			if err = s.validateBroadcast(ctx, r, consensusBlock); err != nil {
-				if errors.Is(err, errEquivocatedBlock) {
-					b, err := blocks.NewSignedBeaconBlock(consensusBlock)
-					if err != nil {
-						httputil.HandleError(w, err.Error(), http.StatusBadRequest)
-						return
-					}
-					if err := s.broadcastSeenBlockSidecars(ctx, b, consensusBlock.GetFulu().Blobs, consensusBlock.GetFulu().KzgProofs); err != nil {
-						log.WithError(err).Error("Failed to broadcast blob sidecars")
-					}
-				}
-				httputil.HandleError(w, err.Error(), http.StatusBadRequest)
-				return
-			}
-			s.proposeBlock(ctx, w, consensusBlock)
-			return
-		}
-	}
-	if versionHeader == version.String(version.Fulu) {
-		httputil.HandleError(
-			w,
-			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Fulu), err.Error()),
-			http.StatusBadRequest,
-		)
-		return
-	}
-
 	var electraBlockContents *structs.SignedBeaconBlockContentsElectra
 	if err = unmarshalStrict(body, &electraBlockContents); err == nil {
 		consensusBlock, err = electraBlockContents.ToGeneric()
@@ -1189,16 +1081,13 @@ func (s *Server) validateConsensus(ctx context.Context, b *eth.GenericSignedBeac
 
 	var blobs [][]byte
 	var proofs [][]byte
-	switch blk.Version() {
-	case version.Deneb:
-		blobs = b.GetDeneb().Blobs
-		proofs = b.GetDeneb().KzgProofs
-	case version.Electra:
+	switch {
+	case blk.Version() == version.Electra:
 		blobs = b.GetElectra().Blobs
 		proofs = b.GetElectra().KzgProofs
-	case version.Fulu:
-		blobs = b.GetFulu().Blobs
-		proofs = b.GetFulu().KzgProofs
+	case blk.Version() == version.Deneb:
+		blobs = b.GetDeneb().Blobs
+		proofs = b.GetDeneb().KzgProofs
 	default:
 		return nil
 	}
@@ -1229,8 +1118,7 @@ func (s *Server) validateBlobSidecars(blk interfaces.SignedBeaconBlock, blobs []
 		return errors.New("number of blobs, proofs, and commitments do not match")
 	}
 	for i, blob := range blobs {
-		b := kzg4844.Blob(blob)
-		if err := kzg4844.VerifyBlobProof(&b, kzg4844.Commitment(kzgs[i]), kzg4844.Proof(proofs[i])); err != nil {
+		if err := kzg4844.VerifyBlobProof(kzg4844.Blob(blob), kzg4844.Commitment(kzgs[i]), kzg4844.Proof(proofs[i])); err != nil {
 			return errors.Wrap(err, "could not verify blob proof")
 		}
 	}

beacon-chain/rpc/eth/beacon/handlers_pool.go

@@ -319,23 +319,27 @@ func (s *Server) handleAttestationsElectra(
 		validAttestations = append(validAttestations, att)
 	}
 
-	for i, singleAtt := range validAttestations {
-		targetState, err := s.AttestationStateFetcher.AttestationTargetState(ctx, singleAtt.Data.Target)
+	for i, att := range validAttestations {
+		targetState, err := s.AttestationStateFetcher.AttestationTargetState(ctx, att.Data.Target)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not get target state for attestation")
 		}
-		committee, err := corehelpers.BeaconCommitteeFromState(ctx, targetState, singleAtt.Data.Slot, singleAtt.CommitteeId)
+		committee, err := corehelpers.BeaconCommitteeFromState(ctx, targetState, att.Data.Slot, att.CommitteeId)
 		if err != nil {
 			return nil, nil, errors.Wrap(err, "could not get committee for attestation")
 		}
-		att := singleAtt.ToAttestationElectra(committee)
 
-		s.OperationNotifier.OperationFeed().Send(&feed.Event{
-			Type: operation.UnaggregatedAttReceived,
-			Data: &operation.UnAggregatedAttReceivedData{
-				Attestation: att,
-			},
-		})
+		// Broadcast the unaggregated attestation on a feed to notify other services in the beacon node
+		// of a received unaggregated attestation.
+		// Note we can't send for aggregated att because we don't have selection proof.
+		if !att.IsAggregated() {
+			s.OperationNotifier.OperationFeed().Send(&feed.Event{
+				Type: operation.UnaggregatedAttReceived,
+				Data: &operation.UnAggregatedAttReceivedData{
+					Attestation: att.ToAttestationElectra(committee),
+				},
+			})
+		}
 
 		wantedEpoch := slots.ToEpoch(att.Data.Slot)
 		vals, err := s.HeadFetcher.HeadValidatorsIndices(ctx, wantedEpoch)
@@ -344,18 +348,18 @@ func (s *Server) handleAttestationsElectra(
 			continue
 		}
 		subnet := corehelpers.ComputeSubnetFromCommitteeAndSlot(uint64(len(vals)), att.GetCommitteeIndex(), att.Data.Slot)
-		if err = s.Broadcaster.BroadcastAttestation(ctx, subnet, singleAtt); err != nil {
+		if err = s.Broadcaster.BroadcastAttestation(ctx, subnet, att); err != nil {
 			log.WithError(err).Errorf("could not broadcast attestation at index %d", i)
 			failedBroadcasts = append(failedBroadcasts, strconv.Itoa(i))
 			continue
 		}
 
 		if features.Get().EnableExperimentalAttestationPool {
-			if err = s.AttestationCache.Add(att); err != nil {
+			if err = s.AttestationCache.Add(att.ToAttestationElectra(committee)); err != nil {
 				log.WithError(err).Error("could not save attestation")
 			}
 		} else {
-			if err = s.AttestationsPool.SaveUnaggregatedAttestation(att); err != nil {
+			if err = s.AttestationsPool.SaveUnaggregatedAttestation(att.ToAttestationElectra(committee)); err != nil {
 				log.WithError(err).Error("could not save attestation")
 			}
 		}

beacon-chain/rpc/eth/beacon/handlers_pool_test.go

@@ -1996,7 +1996,7 @@ func TestSubmitAttesterSlashings(t *testing.T) {
 			_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashing)
 			assert.Equal(t, true, ok)
 		})
-		t.Run("across-fork", func(t *testing.T) {
+		t.Run("accross-fork", func(t *testing.T) {
 			attestationData1.Slot = params.BeaconConfig().SlotsPerEpoch
 			attestationData2.Slot = params.BeaconConfig().SlotsPerEpoch
 			slashing := &ethpbv1alpha1.AttesterSlashing{
@@ -2152,7 +2152,7 @@ func TestSubmitAttesterSlashings(t *testing.T) {
 			_, ok := broadcaster.BroadcastMessages[0].(*ethpbv1alpha1.AttesterSlashingElectra)
 			assert.Equal(t, true, ok)
 		})
-		t.Run("across-fork", func(t *testing.T) {
+		t.Run("accross-fork", func(t *testing.T) {
 			attestationData1.Slot = params.BeaconConfig().SlotsPerEpoch
 			attestationData2.Slot = params.BeaconConfig().SlotsPerEpoch
 			slashing := &ethpbv1alpha1.AttesterSlashingElectra{

beacon-chain/rpc/eth/beacon/handlers_test.go

@@ -302,38 +302,6 @@ func TestGetBlockV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, blk, b)
 	})
-	t.Run("fulu", func(t *testing.T) {
-		b := util.NewBeaconBlockFulu()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		mockBlockFetcher := &testutil.MockBlocker{BlockToReturn: sb}
-		mockChainService := &chainMock.ChainService{
-			FinalizedRoots: map[[32]byte]bool{},
-		}
-		s := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               mockBlockFetcher,
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request.SetPathValue("block_id", "head")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetBlockV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetBlockV2Response{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, version.String(version.Fulu), resp.Version)
-		sbb := &structs.SignedBeaconBlockFulu{Message: &structs.BeaconBlockFulu{}}
-		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
-		sbb.Signature = resp.Data.Signature
-		blk, err := sbb.ToConsensus()
-		require.NoError(t, err)
-		assert.DeepEqual(t, blk, b)
-	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		b := util.NewBeaconBlockBellatrix()
 		sb, err := blocks.NewSignedBeaconBlock(b)
@@ -550,29 +518,6 @@ func TestGetBlockSSZV2(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
 	})
-	t.Run("fulu", func(t *testing.T) {
-		b := util.NewBeaconBlockFulu()
-		b.Block.Slot = 123
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		s := &Server{
-			Blocker: &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v2/beacon/blocks/{block_id}", nil)
-		request.SetPathValue("block_id", "head")
-		request.Header.Set("Accept", api.OctetStreamMediaType)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetBlockV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-		assert.Equal(t, version.String(version.Fulu), writer.Header().Get(api.VersionHeader))
-		sszExpected, err := b.MarshalSSZ()
-		require.NoError(t, err)
-		assert.DeepEqual(t, sszExpected, writer.Body.Bytes())
-	})
 }
 
 func TestGetBlockAttestations(t *testing.T) {
@@ -1090,35 +1035,6 @@ func TestGetBlindedBlock(t *testing.T) {
 		require.NoError(t, err)
 		assert.DeepEqual(t, blk, b)
 	})
-	t.Run("fulu", func(t *testing.T) {
-		b := util.NewBlindedBeaconBlockFulu()
-		sb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-
-		mockChainService := &chainMock.ChainService{}
-		s := &Server{
-			OptimisticModeFetcher: mockChainService,
-			FinalizationFetcher:   mockChainService,
-			Blocker:               &testutil.MockBlocker{BlockToReturn: sb},
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://foo.example/eth/v1/beacon/blinded_blocks/{block_id}", nil)
-		request.SetPathValue("block_id", "head")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetBlindedBlock(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetBlockV2Response{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, version.String(version.Fulu), resp.Version)
-		sbb := &structs.SignedBlindedBeaconBlockFulu{Message: &structs.BlindedBeaconBlockFulu{}}
-		require.NoError(t, json.Unmarshal(resp.Data.Message, sbb.Message))
-		sbb.Signature = resp.Data.Signature
-		blk, err := sbb.ToConsensus()
-		require.NoError(t, err)
-		assert.DeepEqual(t, blk, b)
-	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		b := util.NewBlindedBeaconBlockBellatrix()
 		sb, err := blocks.NewSignedBeaconBlock(b)
@@ -1433,12 +1349,11 @@ func TestPublishBlock(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
-			converted, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			converted, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBeaconBlockContentsFulu
-			err = json.Unmarshal([]byte(rpctesting.FuluBlockContents), &signedblock)
+			var signedblock *structs.SignedBeaconBlockContentsElectra
+			err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock)
 			return ok
@@ -1454,29 +1369,6 @@ func TestPublishBlock(t *testing.T) {
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
-	t.Run("Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
-			converted, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
-			require.NoError(t, err)
-			var signedblock *structs.SignedBeaconBlockContentsFulu
-			err = json.Unmarshal([]byte(rpctesting.FuluBlockContents), &signedblock)
-			require.NoError(t, err)
-			require.DeepEqual(t, converted, signedblock)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.FuluBlockContents)))
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlock(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1663,8 +1555,7 @@ func TestPublishBlockSSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
 			return ok
 		}))
 		server := &Server{
@@ -1672,42 +1563,16 @@ func TestPublishBlockSSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		var blk structs.SignedBeaconBlockContentsFulu
-		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blk)
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlock(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
-	t.Run("Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		var blk structs.SignedBeaconBlockContentsFulu
-		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blk)
-		require.NoError(t, err)
-		genericBlock, err := blk.ToGeneric()
-		require.NoError(t, err)
-		ssz, err := genericBlock.GetFulu().MarshalSSZ()
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlock(writer, request)
@@ -1895,12 +1760,11 @@ func TestPublishBlindedBlock(t *testing.T) {
 	t.Run("Blinded Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock.Message)
 			return ok
@@ -1917,30 +1781,6 @@ func TestPublishBlindedBlock(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
-	t.Run("Blinded Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
-			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
-			require.NoError(t, err)
-			require.DeepEqual(t, converted, signedblock.Message)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedFuluBlock)))
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlindedBlock(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -2128,8 +1968,7 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
 			return ok
 		}))
 		server := &Server{
@@ -2137,42 +1976,16 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		var blk structs.SignedBlindedBeaconBlockFulu
-		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlindedBlock(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
-	t.Run("Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		var blk structs.SignedBlindedBeaconBlockFulu
-		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
-		require.NoError(t, err)
-		genericBlock, err := blk.ToGeneric()
-		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)
@@ -2352,12 +2165,11 @@ func TestPublishBlockV2(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
-			converted, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			converted, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBeaconBlockContentsFulu
-			err = json.Unmarshal([]byte(rpctesting.FuluBlockContents), &signedblock)
+			var signedblock *structs.SignedBeaconBlockContentsElectra
+			err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock)
 			return ok
@@ -2374,30 +2186,6 @@ func TestPublishBlockV2(t *testing.T) {
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
-	t.Run("Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
-			converted, err := structs.SignedBeaconBlockContentsFuluFromConsensus(block.Fulu)
-			require.NoError(t, err)
-			var signedblock *structs.SignedBeaconBlockContentsFulu
-			err = json.Unmarshal([]byte(rpctesting.FuluBlockContents), &signedblock)
-			require.NoError(t, err)
-			require.DeepEqual(t, converted, signedblock)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.FuluBlockContents)))
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlockV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -2597,8 +2385,7 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
 			return ok
 		}))
 		server := &Server{
@@ -2606,42 +2393,16 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		var blk structs.SignedBeaconBlockContentsFulu
-		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blk)
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlockV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
-	t.Run("Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Fulu)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		var blk structs.SignedBeaconBlockContentsFulu
-		err := json.Unmarshal([]byte(rpctesting.FuluBlockContents), &blk)
-		require.NoError(t, err)
-		genericBlock, err := blk.ToGeneric()
-		require.NoError(t, err)
-		ssz, err := genericBlock.GetFulu().MarshalSSZ()
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlockV2(writer, request)
@@ -2842,12 +2603,11 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 	t.Run("Blinded Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
 			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
 			require.NoError(t, err)
 			require.DeepEqual(t, converted, signedblock.Message)
 			return ok
@@ -2864,30 +2624,6 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
-	t.Run("Blinded Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			converted, err := structs.BlindedBeaconBlockFuluFromConsensus(block.BlindedFulu.Message)
-			require.NoError(t, err)
-			var signedblock *structs.SignedBlindedBeaconBlockFulu
-			err = json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &signedblock)
-			require.NoError(t, err)
-			require.DeepEqual(t, converted, signedblock.Message)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedFuluBlock)))
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlindedBlockV2(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -3087,8 +2823,7 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 	t.Run("Electra", func(t *testing.T) {
 		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
 		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			// Convert back Fulu to Electra when there is at least one difference between Electra and Fulu blocks.
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
 			return ok
 		}))
 		server := &Server{
@@ -3096,42 +2831,16 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 			SyncChecker:             &mockSync.Sync{IsSyncing: false},
 		}
 
-		var blk structs.SignedBlindedBeaconBlockFulu
-		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
 		require.NoError(t, err)
 		genericBlock, err := blk.ToGeneric()
 		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
 		require.NoError(t, err)
 		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
 		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		server.PublishBlindedBlock(writer, request)
-		assert.Equal(t, http.StatusOK, writer.Code)
-	})
-	t.Run("Fulu", func(t *testing.T) {
-		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
-		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
-			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedFulu)
-			return ok
-		}))
-		server := &Server{
-			V1Alpha1ValidatorServer: v1alpha1Server,
-			SyncChecker:             &mockSync.Sync{IsSyncing: false},
-		}
-
-		var blk structs.SignedBlindedBeaconBlockFulu
-		err := json.Unmarshal([]byte(rpctesting.BlindedFuluBlock), &blk)
-		require.NoError(t, err)
-		genericBlock, err := blk.ToGeneric()
-		require.NoError(t, err)
-		ssz, err := genericBlock.GetBlindedFulu().MarshalSSZ()
-		require.NoError(t, err)
-		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
-		request.Header.Set("Content-Type", api.OctetStreamMediaType)
-		request.Header.Set(api.VersionHeader, version.String(version.Fulu))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 		server.PublishBlindedBlock(writer, request)

beacon-chain/rpc/eth/config/handlers_test.go

@@ -79,8 +79,7 @@ func TestGetSpec(t *testing.T) {
 	config.DenebForkEpoch = 105
 	config.ElectraForkVersion = []byte("ElectraForkVersion")
 	config.ElectraForkEpoch = 107
-	config.FuluForkVersion = []byte("FuluForkVersion")
-	config.FuluForkEpoch = 109
+	config.Eip7594ForkEpoch = 109
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
 	config.GenesisDelay = 24
@@ -191,7 +190,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 161, len(data))
+	assert.Equal(t, 160, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -269,9 +268,7 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x"+hex.EncodeToString([]byte("ElectraForkVersion")), v)
 			case "ELECTRA_FORK_EPOCH":
 				assert.Equal(t, "107", v)
-			case "FULU_FORK_VERSION":
-				assert.Equal(t, "0x"+hex.EncodeToString([]byte("FuluForkVersion")), v)
-			case "FULU_FORK_EPOCH":
+			case "EIP7594_FORK_EPOCH":
 				assert.Equal(t, "109", v)
 			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
 				assert.Equal(t, "1000", v)

beacon-chain/rpc/eth/debug/handlers.go

@@ -94,12 +94,6 @@ func (s *Server) getBeaconStateV2(ctx context.Context, w http.ResponseWriter, id
 			httputil.HandleError(w, errMsgStateFromConsensus+": "+err.Error(), http.StatusInternalServerError)
 			return
 		}
-	case version.Fulu:
-		respSt, err = structs.BeaconStateFuluFromConsensus(st)
-		if err != nil {
-			httputil.HandleError(w, errMsgStateFromConsensus+": "+err.Error(), http.StatusInternalServerError)
-			return
-		}
 	default:
 		httputil.HandleError(w, "Unsupported state version", http.StatusInternalServerError)
 		return

beacon-chain/rpc/eth/debug/handlers_test.go

@@ -195,34 +195,6 @@ func TestGetBeaconStateV2(t *testing.T) {
 		require.NoError(t, json.Unmarshal(resp.Data, st))
 		assert.Equal(t, "123", st.Slot)
 	})
-	t.Run("Fulu", func(t *testing.T) {
-		fakeState, err := util.NewBeaconStateFulu()
-		require.NoError(t, err)
-		require.NoError(t, fakeState.SetSlot(123))
-		chainService := &blockchainmock.ChainService{}
-		s := &Server{
-			Stater: &testutil.MockStater{
-				BeaconState: fakeState,
-			},
-			HeadFetcher:           chainService,
-			OptimisticModeFetcher: chainService,
-			FinalizationFetcher:   chainService,
-		}
-
-		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v2/debug/beacon/states/{state_id}", nil)
-		request.SetPathValue("state_id", "head")
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetBeaconStateV2(writer, request)
-		require.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.GetBeaconStateV2Response{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		assert.Equal(t, version.String(version.Fulu), resp.Version)
-		st := &structs.BeaconStateElectra{}
-		require.NoError(t, json.Unmarshal(resp.Data, st))
-		assert.Equal(t, "123", st.Slot)
-	})
 	t.Run("execution optimistic", func(t *testing.T) {
 		parentRoot := [32]byte{'a'}
 		blk := util.NewBeaconBlock()

beacon-chain/rpc/eth/events/events.go

@@ -380,7 +380,7 @@ func (es *eventStreamer) writeOutbox(ctx context.Context, w *streamingResponseWr
 		case <-ctx.Done():
 			return ctx.Err()
 		case rf := <-es.outbox:
-			// We don't want to call Flush until we've exhausted all the writes - it's always preferable to
+			// We don't want to call Flush until we've exhausted all the writes - it's always preferrable to
 			// just keep draining the outbox and rely on the underlying Write code to flush+block when it
 			// needs to based on buffering. Whenever we fill the buffer with a string of writes, the underlying
 			// code will flush on its own, so it's better to explicitly flush only once, after we've totally

beacon-chain/rpc/eth/light-client/handlers.go

@@ -10,6 +10,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -34,34 +35,41 @@ func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Reques
 	// Get the block
 	blockRootParam, err := hexutil.Decode(req.PathValue("block_root"))
 	if err != nil {
-		httputil.HandleError(w, "Invalid block root: "+err.Error(), http.StatusBadRequest)
+		httputil.HandleError(w, "invalid block root: "+err.Error(), http.StatusBadRequest)
 		return
 	}
 
 	blockRoot := bytesutil.ToBytes32(blockRootParam)
-	bootstrap, err := s.BeaconDB.LightClientBootstrap(ctx, blockRoot[:])
-	if err != nil {
-		httputil.HandleError(w, "Could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
-		return
-	}
-	if bootstrap == nil {
-		httputil.HandleError(w, "Light client bootstrap not found", http.StatusNotFound)
+	blk, err := s.Blocker.Block(ctx, blockRoot[:])
+	if !shared.WriteBlockFetchError(w, blk, err) {
 		return
 	}
 
+	// Get the state
+	state, err := s.Stater.StateBySlot(ctx, blk.Block().Slot())
+	if err != nil {
+		httputil.HandleError(w, "could not get state: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), state, blk)
+	if err != nil {
+		httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
 	w.Header().Set(api.VersionHeader, version.String(bootstrap.Version()))
 
 	if httputil.RespondWithSsz(req) {
 		ssz, err := bootstrap.MarshalSSZ()
 		if err != nil {
-			httputil.HandleError(w, "Could not marshal bootstrap to SSZ: "+err.Error(), http.StatusInternalServerError)
+			httputil.HandleError(w, "could not marshal bootstrap to SSZ: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
 		httputil.WriteSsz(w, ssz, "light_client_bootstrap.ssz")
 	} else {
 		data, err := structs.LightClientBootstrapFromConsensus(bootstrap)
 		if err != nil {
-			httputil.HandleError(w, "Could not marshal bootstrap to JSON: "+err.Error(), http.StatusInternalServerError)
+			httputil.HandleError(w, "could not marshal bootstrap to JSON: "+err.Error(), http.StatusInternalServerError)
 			return
 		}
 		response := &structs.LightClientBootstrapResponse{

beacon-chain/rpc/eth/light-client/handlers_test.go

@@ -46,35 +46,33 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 	cfg.CapellaForkEpoch = 2
 	cfg.DenebForkEpoch = 3
 	cfg.ElectraForkEpoch = 4
-	cfg.FuluForkEpoch = 5
 	params.OverrideBeaconConfig(cfg)
 
 	t.Run("altair", func(t *testing.T) {
 		l := util.NewTestLightClient(t).SetupTestAltair()
 
 		slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
-		blockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(l.Ctx, slot, l.State, l.Block)
-		require.NoError(t, err)
-
-		db := dbtesting.SetupDB(t)
-
-		err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
+		stateRoot, err := l.State.HashTreeRoot(l.Ctx)
 		require.NoError(t, err)
 
+		mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
 		s := &Server{
-			BeaconDB: db,
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot: l.State,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
 		}
 		request := httptest.NewRequest("GET", "http://foo.com/", nil)
-		request.SetPathValue("block_root", hexutil.Encode(blockRoot[:]))
+		request.SetPathValue("block_root", hexutil.Encode(stateRoot[:]))
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
 		s.GetLightClientBootstrap(writer, request)
 		require.Equal(t, http.StatusOK, writer.Code)
-
 		var resp structs.LightClientBootstrapResponse
 		err = json.Unmarshal(writer.Body.Bytes(), &resp)
 		require.NoError(t, err)
@@ -91,32 +89,6 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 		require.NotNil(t, resp.Data.CurrentSyncCommittee)
 		require.NotNil(t, resp.Data.CurrentSyncCommitteeBranch)
 	})
-	t.Run("altair - no bootstrap found", func(t *testing.T) {
-		l := util.NewTestLightClient(t).SetupTestAltair()
-
-		slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
-		blockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(l.Ctx, slot, l.State, l.Block)
-		require.NoError(t, err)
-
-		db := dbtesting.SetupDB(t)
-
-		err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[1:], bootstrap)
-		require.NoError(t, err)
-
-		s := &Server{
-			BeaconDB: db,
-		}
-		request := httptest.NewRequest("GET", "http://foo.com/", nil)
-		request.SetPathValue("block_root", hexutil.Encode(blockRoot[:]))
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-
-		s.GetLightClientBootstrap(writer, request)
-		require.Equal(t, http.StatusNotFound, writer.Code)
-	})
 	t.Run("bellatrix", func(t *testing.T) {
 		l := util.NewTestLightClient(t).SetupTestBellatrix()
 
@@ -124,16 +96,16 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 		blockRoot, err := l.Block.Block().HashTreeRoot()
 		require.NoError(t, err)
 
-		bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(l.Ctx, slot, l.State, l.Block)
-		require.NoError(t, err)
-
-		db := dbtesting.SetupDB(t)
-
-		err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
-		require.NoError(t, err)
-
+		mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
 		s := &Server{
-			BeaconDB: db,
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot: l.State,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
 		}
 		request := httptest.NewRequest("GET", "http://foo.com/", nil)
 		request.SetPathValue("block_root", hexutil.Encode(blockRoot[:]))
@@ -165,16 +137,16 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 		blockRoot, err := l.Block.Block().HashTreeRoot()
 		require.NoError(t, err)
 
-		bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(l.Ctx, slot, l.State, l.Block)
-		require.NoError(t, err)
-
-		db := dbtesting.SetupDB(t)
-
-		err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
-		require.NoError(t, err)
-
+		mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
 		s := &Server{
-			BeaconDB: db,
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot: l.State,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
 		}
 		request := httptest.NewRequest("GET", "http://foo.com/", nil)
 		request.SetPathValue("block_root", hexutil.Encode(blockRoot[:]))
@@ -206,16 +178,16 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 		blockRoot, err := l.Block.Block().HashTreeRoot()
 		require.NoError(t, err)
 
-		bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(l.Ctx, slot, l.State, l.Block)
-		require.NoError(t, err)
-
-		db := dbtesting.SetupDB(t)
-
-		err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
-		require.NoError(t, err)
-
+		mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
 		s := &Server{
-			BeaconDB: db,
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot: l.State,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
 		}
 		request := httptest.NewRequest("GET", "http://foo.com/", nil)
 		request.SetPathValue("block_root", hexutil.Encode(blockRoot[:]))
@@ -247,16 +219,16 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 		blockRoot, err := l.Block.Block().HashTreeRoot()
 		require.NoError(t, err)
 
-		bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(l.Ctx, slot, l.State, l.Block)
-		require.NoError(t, err)
-
-		db := dbtesting.SetupDB(t)
-
-		err = db.SaveLightClientBootstrap(l.Ctx, blockRoot[:], bootstrap)
-		require.NoError(t, err)
-
+		mockBlocker := &testutil.MockBlocker{BlockToReturn: l.Block}
+		mockChainService := &mock.ChainService{Optimistic: true, Slot: &slot}
+		mockChainInfoFetcher := &mock.ChainService{Slot: &slot}
 		s := &Server{
-			BeaconDB: db,
+			Stater: &testutil.MockStater{StatesBySlot: map[primitives.Slot]state.BeaconState{
+				slot: l.State,
+			}},
+			Blocker:          mockBlocker,
+			HeadFetcher:      mockChainService,
+			ChainInfoFetcher: mockChainInfoFetcher,
 		}
 		request := httptest.NewRequest("GET", "http://foo.com/", nil)
 		request.SetPathValue("block_root", hexutil.Encode(blockRoot[:]))
@@ -1849,7 +1821,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 				StateRoot:     sampleRoot,
 				BodyRoot:      sampleRoot,
 			},
-			Execution: &enginev1.ExecutionPayloadHeaderDeneb{
+			Execution: &enginev1.ExecutionPayloadHeaderElectra{
 				ParentHash:       make([]byte, fieldparams.RootLength),
 				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
 				StateRoot:        make([]byte, fieldparams.RootLength),
@@ -1867,34 +1839,6 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 		require.NoError(t, err)
 		st, err = util.NewBeaconStateElectra()
 		require.NoError(t, err)
-	case version.Fulu:
-		slot = primitives.Slot(config.FuluForkEpoch * primitives.Epoch(config.SlotsPerEpoch)).Add(1)
-		header, err = light_client.NewWrappedHeader(&pb.LightClientHeaderDeneb{
-			Beacon: &pb.BeaconBlockHeader{
-				Slot:          1,
-				ProposerIndex: primitives.ValidatorIndex(rand.Int()),
-				ParentRoot:    sampleRoot,
-				StateRoot:     sampleRoot,
-				BodyRoot:      sampleRoot,
-			},
-			Execution: &enginev1.ExecutionPayloadHeaderDeneb{
-				ParentHash:       make([]byte, fieldparams.RootLength),
-				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
-				StateRoot:        make([]byte, fieldparams.RootLength),
-				ReceiptsRoot:     make([]byte, fieldparams.RootLength),
-				LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
-				PrevRandao:       make([]byte, fieldparams.RootLength),
-				ExtraData:        make([]byte, 0),
-				BaseFeePerGas:    make([]byte, fieldparams.RootLength),
-				BlockHash:        make([]byte, fieldparams.RootLength),
-				TransactionsRoot: make([]byte, fieldparams.RootLength),
-				WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
-			},
-			ExecutionBranch: sampleExecutionBranch,
-		})
-		require.NoError(t, err)
-		st, err = util.NewBeaconStateFulu()
-		require.NoError(t, err)
 	default:
 		return nil, fmt.Errorf("unsupported version %s", version.String(v))
 	}

beacon-chain/rpc/eth/validator/handlers.go

@@ -198,20 +198,31 @@ func matchingAtts(atts []ethpbalpha.Att, slot primitives.Slot, attDataRoot []byt
 			continue
 		}
 
-		root, err := att.GetData().HashTreeRoot()
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get attestation data root")
-		}
-		if !bytes.Equal(root[:], attDataRoot) {
-			continue
-		}
-
 		// We ignore the committee index from the request before Electra.
 		// This is because before Electra the committee index is part of the attestation data,
 		// meaning that comparing the data root is sufficient.
 		// Post-Electra the committee index in the data root is always 0, so we need to
 		// compare the committee index separately.
-		if (!postElectra && att.Version() < version.Electra) || (postElectra && att.Version() >= version.Electra && att.GetCommitteeIndex() == index) {
+		if postElectra {
+			if att.Version() >= version.Electra {
+				if att.GetCommitteeIndex() != index {
+					continue
+				}
+			} else {
+				continue
+			}
+		} else {
+			// If postElectra is false and att.Version >= version.Electra, ignore the attestation.
+			if att.Version() >= version.Electra {
+				continue
+			}
+		}
+
+		root, err := att.GetData().HashTreeRoot()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not get attestation data root")
+		}
+		if bytes.Equal(root[:], attDataRoot) {
 			result = append(result, att)
 		}
 	}

beacon-chain/rpc/eth/validator/handlers_block.go

@@ -299,18 +299,6 @@ func (s *Server) produceBlockV3(ctx context.Context, w http.ResponseWriter, r *h
 		handleProduceElectraV3(w, isSSZ, electraBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
 		return
 	}
-	blindedFuluBlockContents, ok := v1alpha1resp.Block.(*eth.GenericBeaconBlock_BlindedFulu)
-	if ok {
-		w.Header().Set(api.VersionHeader, version.String(version.Fulu))
-		handleProduceBlindedFuluV3(w, isSSZ, blindedFuluBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
-		return
-	}
-	fuluBlockContents, ok := v1alpha1resp.Block.(*eth.GenericBeaconBlock_Fulu)
-	if ok {
-		w.Header().Set(api.VersionHeader, version.String(version.Fulu))
-		handleProduceFuluV3(w, isSSZ, fuluBlockContents, v1alpha1resp.PayloadValue, consensusBlockValue)
-		return
-	}
 }
 
 func getConsensusBlockValue(ctx context.Context, blockRewardsFetcher rewards.BlockRewardsFetcher, i interface{} /* block as argument */) (string, *httputil.DefaultJsonError) {
@@ -682,74 +670,3 @@ func handleProduceElectraV3(
 		Data:                    jsonBytes,
 	})
 }
-
-func handleProduceBlindedFuluV3(
-	w http.ResponseWriter,
-	isSSZ bool,
-	blk *eth.GenericBeaconBlock_BlindedFulu,
-	executionPayloadValue string,
-	consensusPayloadValue string,
-) {
-	if isSSZ {
-		sszResp, err := blk.BlindedFulu.MarshalSSZ()
-		if err != nil {
-			httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		httputil.WriteSsz(w, sszResp, "blindedFuluBlockContents.ssz")
-		return
-	}
-	blindedBlock, err := structs.BlindedBeaconBlockFuluFromConsensus(blk.BlindedFulu)
-	if err != nil {
-		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	jsonBytes, err := json.Marshal(blindedBlock)
-	if err != nil {
-		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	httputil.WriteJson(w, &structs.ProduceBlockV3Response{
-		Version:                 version.String(version.Fulu),
-		ExecutionPayloadBlinded: true,
-		ExecutionPayloadValue:   executionPayloadValue,
-		ConsensusBlockValue:     consensusPayloadValue,
-		Data:                    jsonBytes,
-	})
-}
-
-func handleProduceFuluV3(
-	w http.ResponseWriter,
-	isSSZ bool,
-	blk *eth.GenericBeaconBlock_Fulu,
-	executionPayloadValue string,
-	consensusBlockValue string,
-) {
-	if isSSZ {
-		sszResp, err := blk.Fulu.MarshalSSZ()
-		if err != nil {
-			httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		httputil.WriteSsz(w, sszResp, "fuluBlockContents.ssz")
-		return
-	}
-
-	blockContents, err := structs.BeaconBlockContentsFuluFromConsensus(blk.Fulu)
-	if err != nil {
-		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	jsonBytes, err := json.Marshal(blockContents)
-	if err != nil {
-		httputil.HandleError(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-	httputil.WriteJson(w, &structs.ProduceBlockV3Response{
-		Version:                 version.String(version.Fulu),
-		ExecutionPayloadBlinded: false,
-		ExecutionPayloadValue:   executionPayloadValue, // mev not available at this point
-		ConsensusBlockValue:     consensusBlockValue,
-		Data:                    jsonBytes,
-	})
-}

beacon-chain/rpc/prysm/v1alpha1/debug/server.go

@@ -56,7 +56,9 @@ func (_ *Server) SetLoggingLevel(_ context.Context, req *pbrpc.LoggingLevelReque
 		// Libp2p specific logging.
 		golog.SetAllLoggers(golog.LevelDebug)
 		// Geth specific logging.
-		gethlog.SetDefault(gethlog.NewLogger(gethlog.NewTerminalHandlerWithLevel(os.Stderr, gethlog.LvlTrace, true)))
+		glogger := gethlog.NewGlogHandler(gethlog.StreamHandler(os.Stderr, gethlog.TerminalFormat(true)))
+		glogger.Verbosity(gethlog.LvlTrace)
+		gethlog.Root().SetHandler(glogger)
 	}
 	return &empty.Empty{}, nil
 }

beacon-chain/rpc/prysm/v1alpha1/validator/attester.go

@@ -70,35 +70,34 @@ func (vs *Server) ProposeAttestation(ctx context.Context, att *ethpb.Attestation
 
 // ProposeAttestationElectra is a function called by an attester to vote
 // on a block via an attestation object as defined in the Ethereum specification.
-func (vs *Server) ProposeAttestationElectra(ctx context.Context, singleAtt *ethpb.SingleAttestation) (*ethpb.AttestResponse, error) {
+func (vs *Server) ProposeAttestationElectra(ctx context.Context, att *ethpb.SingleAttestation) (*ethpb.AttestResponse, error) {
 	ctx, span := trace.StartSpan(ctx, "AttesterServer.ProposeAttestationElectra")
 	defer span.End()
 
-	targetState, err := vs.AttestationStateFetcher.AttestationTargetState(ctx, singleAtt.Data.Target)
+	targetState, err := vs.AttestationStateFetcher.AttestationTargetState(ctx, att.Data.Target)
 	if err != nil {
 		return nil, status.Error(codes.Internal, "Could not get target state")
 	}
-	committeeIndex := singleAtt.GetCommitteeIndex()
-	committee, err := helpers.BeaconCommitteeFromState(ctx, targetState, singleAtt.Data.Slot, committeeIndex)
+	committeeIndex := att.GetCommitteeIndex()
+	committee, err := helpers.BeaconCommitteeFromState(ctx, targetState, att.Data.Slot, committeeIndex)
 	if err != nil {
 		return nil, status.Error(codes.Internal, "Could not get committee")
 	}
 
-	resp, err := vs.proposeAtt(ctx, singleAtt, committee, committeeIndex)
+	resp, err := vs.proposeAtt(ctx, att, committee, committeeIndex)
 	if err != nil {
 		return nil, err
 	}
 
-	singleAttCopy := singleAtt.Copy()
-	att := singleAttCopy.ToAttestationElectra(committee)
 	if features.Get().EnableExperimentalAttestationPool {
-		if err = vs.AttestationCache.Add(att); err != nil {
+		if err = vs.AttestationCache.Add(att.ToAttestationElectra(committee)); err != nil {
 			log.WithError(err).Error("Could not save attestation")
 		}
 	} else {
 		go func() {
 			ctx = trace.NewContext(context.Background(), trace.FromContext(ctx))
-			if err := vs.AttPool.SaveUnaggregatedAttestation(att); err != nil {
+			attCopy := att.Copy()
+			if err := vs.AttPool.SaveUnaggregatedAttestation(attCopy.ToAttestationElectra(committee)); err != nil {
 				log.WithError(err).Error("Could not save unaggregated attestation")
 				return
 			}

beacon-chain/rpc/prysm/v1alpha1/validator/blocks.go

@@ -170,17 +170,6 @@ func sendVerifiedBlocks(stream ethpb.BeaconNodeValidator_StreamBlocksAltairServe
 			return nil
 		}
 		b.Block = &ethpb.StreamBlocksResponse_ElectraBlock{ElectraBlock: phBlk}
-	case version.Fulu:
-		pb, err := data.SignedBlock.Proto()
-		if err != nil {
-			return errors.Wrap(err, "could not get protobuf block")
-		}
-		phBlk, ok := pb.(*ethpb.SignedBeaconBlockFulu)
-		if !ok {
-			log.Warn("Mismatch between version and block type, was expecting SignedBeaconBlockFulu")
-			return nil
-		}
-		b.Block = &ethpb.StreamBlocksResponse_FuluBlock{FuluBlock: phBlk}
 	}
 
 	if err := stream.Send(b); err != nil {

beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block.go

@@ -26,46 +26,34 @@ func (vs *Server) constructGenericBeaconBlock(sBlk interfaces.SignedBeaconBlock,
 	bidStr := primitives.WeiToBigInt(winningBid).String()
 
 	switch sBlk.Version() {
-	case version.Phase0:
-		return vs.constructPhase0Block(blockProto), nil
-	case version.Altair:
-		return vs.constructAltairBlock(blockProto), nil
-	case version.Bellatrix:
-		return vs.constructBellatrixBlock(blockProto, isBlinded, bidStr), nil
-	case version.Capella:
-		return vs.constructCapellaBlock(blockProto, isBlinded, bidStr), nil
-	case version.Deneb:
-		return vs.constructDenebBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
 	case version.Electra:
 		return vs.constructElectraBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
-	case version.Fulu:
-		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
+	case version.Deneb:
+		return vs.constructDenebBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
+	case version.Capella:
+		return vs.constructCapellaBlock(blockProto, isBlinded, bidStr), nil
+	case version.Bellatrix:
+		return vs.constructBellatrixBlock(blockProto, isBlinded, bidStr), nil
+	case version.Altair:
+		return vs.constructAltairBlock(blockProto), nil
+	case version.Phase0:
+		return vs.constructPhase0Block(blockProto), nil
 	default:
 		return nil, fmt.Errorf("unknown block version: %d", sBlk.Version())
 	}
 }
 
 // Helper functions for constructing blocks for each version
-func (vs *Server) constructPhase0Block(pb proto.Message) *ethpb.GenericBeaconBlock {
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: pb.(*ethpb.BeaconBlock)}}
-}
-
-func (vs *Server) constructAltairBlock(pb proto.Message) *ethpb.GenericBeaconBlock {
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: pb.(*ethpb.BeaconBlockAltair)}}
-}
-
-func (vs *Server) constructBellatrixBlock(pb proto.Message, isBlinded bool, payloadValue string) *ethpb.GenericBeaconBlock {
+func (vs *Server) constructElectraBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
 	if isBlinded {
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*ethpb.BlindedBeaconBlockBellatrix)}, IsBlinded: true, PayloadValue: payloadValue}
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedElectra{BlindedElectra: blockProto.(*ethpb.BlindedBeaconBlockElectra)}, IsBlinded: true, PayloadValue: payloadValue}
 	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: pb.(*ethpb.BeaconBlockBellatrix)}, IsBlinded: false, PayloadValue: payloadValue}
-}
-
-func (vs *Server) constructCapellaBlock(pb proto.Message, isBlinded bool, payloadValue string) *ethpb.GenericBeaconBlock {
-	if isBlinded {
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedCapella{BlindedCapella: pb.(*ethpb.BlindedBeaconBlockCapella)}, IsBlinded: true, PayloadValue: payloadValue}
+	electraContents := &ethpb.BeaconBlockContentsElectra{Block: blockProto.(*ethpb.BeaconBlockElectra)}
+	if bundle != nil {
+		electraContents.KzgProofs = bundle.Proofs
+		electraContents.Blobs = bundle.Blobs
 	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: pb.(*ethpb.BeaconBlockCapella)}, IsBlinded: false, PayloadValue: payloadValue}
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: electraContents}, IsBlinded: false, PayloadValue: payloadValue}
 }
 
 func (vs *Server) constructDenebBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
@@ -80,26 +68,24 @@ func (vs *Server) constructDenebBlock(blockProto proto.Message, isBlinded bool,
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Deneb{Deneb: denebContents}, IsBlinded: false, PayloadValue: payloadValue}
 }
 
-func (vs *Server) constructElectraBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
+func (vs *Server) constructCapellaBlock(pb proto.Message, isBlinded bool, payloadValue string) *ethpb.GenericBeaconBlock {
 	if isBlinded {
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedElectra{BlindedElectra: blockProto.(*ethpb.BlindedBeaconBlockElectra)}, IsBlinded: true, PayloadValue: payloadValue}
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedCapella{BlindedCapella: pb.(*ethpb.BlindedBeaconBlockCapella)}, IsBlinded: true, PayloadValue: payloadValue}
 	}
-	electraContents := &ethpb.BeaconBlockContentsElectra{Block: blockProto.(*ethpb.BeaconBlockElectra)}
-	if bundle != nil {
-		electraContents.KzgProofs = bundle.Proofs
-		electraContents.Blobs = bundle.Blobs
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: electraContents}, IsBlinded: false, PayloadValue: payloadValue}
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Capella{Capella: pb.(*ethpb.BeaconBlockCapella)}, IsBlinded: false, PayloadValue: payloadValue}
 }
 
-func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
+func (vs *Server) constructBellatrixBlock(pb proto.Message, isBlinded bool, payloadValue string) *ethpb.GenericBeaconBlock {
 	if isBlinded {
-		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blockProto.(*ethpb.BlindedBeaconBlockFulu)}, IsBlinded: true, PayloadValue: payloadValue}
+		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedBellatrix{BlindedBellatrix: pb.(*ethpb.BlindedBeaconBlockBellatrix)}, IsBlinded: true, PayloadValue: payloadValue}
 	}
-	fuluContents := &ethpb.BeaconBlockContentsFulu{Block: blockProto.(*ethpb.BeaconBlockFulu)}
-	if bundle != nil {
-		fuluContents.KzgProofs = bundle.Proofs
-		fuluContents.Blobs = bundle.Blobs
-	}
-	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Fulu{Fulu: fuluContents}, IsBlinded: false, PayloadValue: payloadValue}
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Bellatrix{Bellatrix: pb.(*ethpb.BeaconBlockBellatrix)}, IsBlinded: false, PayloadValue: payloadValue}
+}
+
+func (vs *Server) constructAltairBlock(pb proto.Message) *ethpb.GenericBeaconBlock {
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Altair{Altair: pb.(*ethpb.BeaconBlockAltair)}}
+}
+
+func (vs *Server) constructPhase0Block(pb proto.Message) *ethpb.GenericBeaconBlock {
+	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Phase0{Phase0: pb.(*ethpb.BeaconBlock)}}
 }

beacon-chain/rpc/prysm/v1alpha1/validator/construct_generic_block_test.go

@@ -22,21 +22,6 @@ func TestConstructGenericBeaconBlock(t *testing.T) {
 		require.ErrorContains(t, "block cannot be nil", err)
 	})
 
-	// Test for Fulu version
-	t.Run("fulu block", func(t *testing.T) {
-		eb := util.NewBeaconBlockFulu()
-		b, err := blocks.NewSignedBeaconBlock(eb)
-		require.NoError(t, err)
-		r1, err := eb.Block.HashTreeRoot()
-		require.NoError(t, err)
-		result, err := vs.constructGenericBeaconBlock(b, nil, primitives.ZeroWei())
-		require.NoError(t, err)
-		r2, err := result.GetFulu().Block.HashTreeRoot()
-		require.NoError(t, err)
-		require.Equal(t, r1, r2)
-		require.Equal(t, result.IsBlinded, false)
-	})
-
 	// Test for Electra version
 	t.Run("electra block", func(t *testing.T) {
 		eb := util.NewBeaconBlockElectra()
@@ -84,6 +69,7 @@ func TestConstructGenericBeaconBlock(t *testing.T) {
 		require.Equal(t, result.IsBlinded, false)
 	})
 
+	// Test for blind Deneb version
 	t.Run("blind deneb block", func(t *testing.T) {
 		b, err := blocks.NewSignedBeaconBlock(util.NewBlindedBeaconBlockDeneb())
 		require.NoError(t, err)
@@ -113,6 +99,7 @@ func TestConstructGenericBeaconBlock(t *testing.T) {
 		require.Equal(t, result.IsBlinded, false)
 	})
 
+	// Test for blind Capella version
 	t.Run("blind capella block", func(t *testing.T) {
 		b, err := blocks.NewSignedBeaconBlock(util.NewBlindedBeaconBlockCapella())
 		require.NoError(t, err)

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -519,9 +519,6 @@ func blobsAndProofs(req *ethpb.GenericSignedBeaconBlock) ([][]byte, [][]byte, er
 	case req.GetElectra() != nil:
 		dbBlockContents := req.GetElectra()
 		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
-	case req.GetFulu() != nil:
-		dbBlockContents := req.GetFulu()
-		return dbBlockContents.Blobs, dbBlockContents.KzgProofs, nil
 	default:
 		return nil, nil, errors.Errorf("unknown request type provided: %T", req)
 	}

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_builder_test.go

@@ -18,6 +18,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
+	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
@@ -158,7 +159,7 @@ func createState(
 		BlockRoots:                 make([][]byte, 1),
 		CurrentJustifiedCheckpoint: justified,
 		FinalizedCheckpoint:        finalized,
-		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeader{
+		LatestExecutionPayloadHeader: &v1.ExecutionPayloadHeader{
 			BlockHash: payloadHash[:],
 		},
 		LatestBlockHeader: &ethpb.BeaconBlockHeader{

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_empty_block.go

@@ -16,11 +16,6 @@ func getEmptyBlock(slot primitives.Slot) (interfaces.SignedBeaconBlock, error) {
 	var err error
 	epoch := slots.ToEpoch(slot)
 	switch {
-	case epoch >= params.BeaconConfig().FuluForkEpoch:
-		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{Block: &ethpb.BeaconBlockFulu{Body: &ethpb.BeaconBlockBodyFulu{}}})
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not initialize block for proposal: %v", err)
-		}
 	case epoch >= params.BeaconConfig().ElectraForkEpoch:
 		sBlk, err = blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{}}})
 		if err != nil {