Merge branch 'develop' into update-geth-to-v1.14

* Update blobs by range rpc topics to v1

* Update blobs by range rpc topics to v1

* RPC handler comments: Use "Added", "Modified" and "Upgraded".

- Added: No message with this message name was previously existing.
- Upgraded: A message with this message name was existing in the previous fork, but the schema version is upgraded in the current fork.
- Modified: The couple message name, schema version is the same than in the previous fork, but the implementation of the handler is modified in the current fork.

---------

Co-authored-by: Manu NALEPA <enalepa@offchainlabs.com>

.github/workflows/fuzz.yml

@@ -16,7 +16,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.22.3'
+          go-version: '1.22.10'
       - 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.3'
+          go-version: '1.22.10'
       - 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.6'
+          go-version: '1.22.10'
       - 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.6'
+          go-version: '1.22.10'
           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.6'
+          go-version: '1.22.10'
         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.6'
+  go: '1.22.10'
 
 linters:
   enable-all: true

CHANGELOG.md

@@ -4,7 +4,86 @@ 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.1.2...HEAD)
+## [Unreleased](https://github.com/prysmaticlabs/prysm/compare/v5.2.0...HEAD)
+
+### Added
+
+- Added proper gas limit check for header from the builder.
+- Added an error field to log `Finished building block`.
+- Implemented a new `EmptyExecutionPayloadHeader` function.
+- `Finished building block`: Display error only if not nil.
+- Added support to update target and max blob count to different values per hard fork config.
+- Log before blob filesystem cache warm-up.
+- New design for the attestation pool. [PR](https://github.com/prysmaticlabs/prysm/pull/14324)
+- Add field param placeholder for Electra blob target and max to pass spec tests.
+- Add EIP-7691: Blob throughput increase.
+- SSZ files generation: Remove the `// Hash: ...` header.
+- DB optimization for saving light client bootstraps (save unique sync committees only).
+- Trace IDONTWANT Messages in Pubsub.
+- Add Fulu fork boilerplate.
+- Separate type for unaggregated network attestations. [PR](https://github.com/prysmaticlabs/prysm/pull/14659)
+
+### Changed
+
+- Process light client finality updates only for new finalized epochs instead of doing it for every block.
+- Refactor subnets subscriptions.
+- Refactor RPC handlers subscriptions.
+- Go deps upgrade, from `ioutil` to `io`
+- Move successfully registered validator(s) on builder log to debug.
+- Update some test files to use `crypto/rand` instead of `math/rand`
+- Enforce Compound prefix (0x02) for target when processing pending consolidation request.
+- Limit consolidating by validator's effective balance.
+- Use 16-bit random value for proposer and sync committee selection filter.
+- Re-organize the content of the `*.proto` files (No functional change).
+- Updated spec definitions for `process_slashings` in godocs. Simplified `ProcessSlashings` API.
+- Updated spec definition electra `process_registry_updates`.
+- Updated Electra spec definition for `process_epoch`.
+- Update our `go-libp2p-pubsub` dependency.
+- Re-organize the content of files to ease the creation of a new fork boilerplate.
+- Fixed Metadata errors for peers connected via QUIC.
+- Process light client finality updates only for new finalized epochs instead of doing it for every block.
+- Update blobs by rpc topics from V2 to V1.
+- Updated geth to 1.14 ~
+- E2e tests start from bellatrix
+
+### Deprecated
+
+
+### Removed
+
+- Cleanup ProcessSlashings method to remove unnecessary argument.
+- Remove `/proto/eth/v2` directory. [PR](https://github.com/prysmaticlabs/prysm/pull/14765)
+- Remove `/memsize/` pprof endpoint as it will no longer be supported in go 1.23, geth also removed in https://github.com/ethereum/go-ethereum/commit/e4675771eda550e7eeb63a8884816982c1980644
+
+### Fixed
+
+- Added check to prevent nil pointer deference or out of bounds array access when validating the BLSToExecutionChange on an impossibly nil validator.
+- EIP-7691: Ensure new blobs subnets are subscribed on epoch in advance.
+- Fix kzg commitment inclusion proof depth minimal value.
+
+### Security
+
+- go version upgrade to 1.22.10 for CVE CVE-2024-34156
+- Update golang.org/x/crypto to v0.31.0 to address CVE-2024-45337
+- Update golang.org/x/net to v0.33.0 to address CVE-2024-45338
+
+## [v5.2.0](https://github.com/prysmaticlabs/prysm/compare/v5.1.2...v5.2.0)
+
+Updating to this release is highly recommended, especially for users running v5.1.1 or v5.1.2.
+This release is **mandatory** for all validator clients using mev-boost with a gas limit increase.
+Without upgrading to this release, validator clients will default to using local execution blocks
+when the gas limit starts to increase.
+
+This release has several fixes and new features. In this release, we have enabled QUIC protocol by
+default, which uses port 13000 for `--p2p-quic-port`. This may be a [breaking change](https://github.com/prysmaticlabs/prysm/pull/14688#issuecomment-2516713826)
+if you're using port 13000 already. This release has some improvements for raising the gas limit,
+but there are [known issues](https://hackmd.io/@ttsao/prysm-gas-limit) with the proposer settings
+file provided gas limit not being respected for mev-boost outsourced blocks. Signalling an increase
+for the gas limit works perfectly for local block production as of this release. See [pumpthegas.org](https://pumpthegas.org) for more info on raising the gas limit on L1.
+
+Notable features:
+- Prysm can reuse blobs from the EL via engine_getBlobsV1, [potentially saving bandwidth](https://hackmd.io/@ttsao/get-blobs-early-results).
+- QUIC is enabled by default. This is a UDP based networking protocol with default port 13000.
 
 ### Added
 
@@ -33,6 +112,8 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Added a Prometheus error counter metric for SSE requests.
 - Save light client updates and bootstraps in DB.
 - Added more comprehensive tests for `BlockToLightClientHeader`. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
+- Added light client feature flag check to RPC handlers. [PR](https://github.com/prysmaticlabs/prysm/pull/14736)
+- Light client: Add better error handling. [PR](https://github.com/prysmaticlabs/prysm/pull/14749)
 
 ### Changed
 
@@ -88,7 +169,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Removed finalized validator index cache, no longer needed.
 - Removed validator queue position log on key reload and wait for activation.
 - Removed outdated spectest exclusions for EIP-6110.
-- Removed support for starting a beacon node with a deterministic interop genesis state via interop flags. Alteratively, create a genesis state with prysmctl and use `--genesis-state`. This removes about 9Mb (~11%) of unnecessary code and dependencies from the final production binary.
+- Removed 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 kzg proof check from blob reconstructor.
 
 ### Fixed
@@ -102,7 +183,7 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Fix `--backfill-oldest-slot` handling - this flag was totally broken, the code would always backfill to the default slot [pr](https://github.com/prysmaticlabs/prysm/pull/14584)
 - Fix keymanager API should return corrected error format for malformed tokens
 - Fix keymanager API so that get keys returns an empty response instead of a 500 error when using an unsupported keystore.
-- Small log imporvement, removing some redundant or duplicate logs
+- Small log improvement, 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
@@ -132,7 +213,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 intead of prysm's stock grpc endpoints) or accessory software that connects to the events api,
+api instead of prysm's stock grpc endpoints) or accessory software that connects to the events api,
 like https://github.com/ethpandaops/ethereum-metrics-exporter
 
 ### Fixed 
@@ -375,7 +456,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 retrival genesis case
+- Fix dependent root retrieval genesis case
 - Restrict Dials From Discovery
 - Always close cache warm chan to prevent blocking
 - Keep only the latest value in the health channel
@@ -527,7 +608,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 mispelled variable
+- Rename misspelled variable
 - allow blob by root within da period
 - Rewrite Pruning Implementation To Handle EIP 7045
 - Set default fee recipient if tracked val fails
@@ -597,7 +678,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 availablity check in ReceiveBlock
+- da_waited_time_milliseconds tracks total time waiting for data availability 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
@@ -772,7 +853,7 @@ and Raspberry Pi users.
 - Add Goerli Deneb Fork Epoch
 - Use deneb key for deneb state in saveStatesEfficientInternal
 - Initialize Inactivity Scores Correctly
-- Excluse DA wait time for chain processing time
+- Excludes DA wait time for chain processing time
 - Initialize sig cache for verification.Initializer
 - Verify roblobs
 - KZG Commitment inclusion proof verifier
@@ -805,7 +886,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 arugment for sidecar validation
+- Passing block as argument for sidecar validation
 
 #### Blob Management
 
@@ -1102,13 +1183,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
-- DEPRECTATION: Remove exchange transition configuration call
+- DEPRECATION: 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 converstion
+- Fix redundant type conversion
 - docs: fix typo
 - Add Clarification To Sync Committee Cache
 - Fix typos
@@ -1130,7 +1211,7 @@ small set of users.
 
 ### Security
 
-No security issues in thsi release.
+No security issues in this release.
 
 ## [v4.1.0](https://github.com/prysmaticlabs/prysm/compare/v4.0.8...v4.1.0) - 2023-08-22
 
@@ -1646,7 +1727,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 varaible USE_PRYSM_MODERN=true when using prysm.sh.
+attached to releases, or set environment variable USE_PRYSM_MODERN=true when using prysm.sh.
 
 ### Added
 
@@ -1995,7 +2076,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
-- Matric addition
+- Metric addition
 - Identify invalid signature within batch verification
 - Support for getting consensus values from beacon config
 - EIP-4881: Spec implementation
@@ -2061,7 +2142,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.
-- Updted forkchoice endpoint /eth/v1/debug/forkchoice (was /eth/v1/debug/beacon/forkchoice)
+- Updated 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
 
@@ -2293,7 +2374,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-boundry-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-boundary-checks`
 - Validator Web API: Removed unused ImportAccounts and DeleteAccounts rpc options
 
 ### Fixed
@@ -2509,7 +2590,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/next/prysm-usage/checkpoint-sync) for more details.
+  the [documentation](https://docs.prylabs.network/docs/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`.
@@ -2690,7 +2771,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
-- Simplied web password requirements
+- Simplified web password requirements
 - Web JWT tokens no longer expire.
 - Updated keymanager protos
 - Watch and update jwt secret when auth token file updated on disk.
@@ -2701,7 +2782,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 explict error for validator flag checks on out of bound positions
+- Add explicit 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
@@ -2727,7 +2808,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 superflous errors from peer scoring parameters registration
+- Removed superfluous errors from peer scoring parameters registration
 
 ### Fixed
 

CONTRIBUTING.md

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

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 and
+> outdated interop guides or instructions. If you experience issues with this guide, please file an
 > issue for visibility and propose fixes, if possible.
 
 ## Installation & Setup
@@ -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 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.
+- `--` is a flag divider to distinguish between bazel flags and flags that should be passed to the application. All flags and arguments after this divider are passed to the beacon chain.
 - `--minimal-config` tells the beacon node to use minimal network configuration. This is different from the compile time state configuration flag `--config=minimal` and both are required.
 - `--bootstrap-node=` disables the default bootstrap nodes. This prevents the client from attempting to peer with mainnet nodes.
 - `--datadir=/tmp/beacon-chain-minimal-devnet` sets the data directory in a temporary location. Change this to your preferred destination.
 - `--force-clear-db` will delete the beaconchain.db file without confirming with the user. This is helpful for iteratively running local devnets without changing the datadir, but less helpful for one off runs where there was no database in the data directory.
-- `--min-sync-peers=0` allows the beacon node to skip initial sync without peers. This is essential because Prysm expects at least a few peers to start 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 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 --interopt-num-validators=256 --minimal-config --suggested-fee-recipient=0x8A04d14125D0FDCDc742F4A05C051De07232EDa4
+bazel run //cmd/validator --config=minimal -- --datadir=/tmp/validator --interop-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.4",
+    go_version = "1.22.10",
     nogo = "@//:nogo",
 )
 
@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.9"
+consensus_spec_version = "v1.5.0-alpha.10"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-gHbvlnErUeJGWzW8/8JiVlk28JwmXSMhOzkynEIz+8g=",
+    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-hQkQdpm5ng4miGYa5WsOKWa0q8WtZu99Oqbv9QtBeJM=",
+    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-33sBsmApnJpcyYfR3olKaPB+WC1q00ZKNzHa2TczIxk=",
+    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-GQulBKLc2khpql2K/MxV+NG/d2kAhLXl+gLnKIg7rt4=",
+    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/BUILD.bazel

@@ -15,6 +15,7 @@ go_library(
         "//api/client:go_default_library",
         "//api/server/structs:go_default_library",
         "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",

api/client/builder/client.go

@@ -282,7 +282,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 	if err != nil {
 		return err
 	}
-	log.WithField("num_registrations", len(svr)).Info("successfully registered validator(s) on builder")
+	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
 	return nil
 }
 

api/client/builder/client_test.go

@@ -16,7 +16,6 @@ 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"
@@ -124,7 +123,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 types.Slot = 23
+	var slot primitives.Slot = 23
 	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
 	pubkey := ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
 	t.Run("server error", func(t *testing.T) {
@@ -370,7 +369,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, types.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
+		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
 		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 	})
@@ -409,7 +408,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, types.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
+		assert.Equal(t, primitives.ValidatorIndex(1), withdrawals[0].ValidatorIndex)
 		assert.DeepEqual(t, ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943"), withdrawals[0].Address)
 		assert.Equal(t, uint64(1), withdrawals[0].Amount)
 		require.NotNil(t, blobBundle)

api/client/builder/types.go

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

api/server/structs/block.go

@@ -14,6 +14,10 @@ type SignedMessageJsoner interface {
 	SigString() string
 }
 
+// ----------------------------------------------------------------------------
+// Phase 0
+// ----------------------------------------------------------------------------
+
 type SignedBeaconBlock struct {
 	Message   *BeaconBlock `json:"message"`
 	Signature string       `json:"signature"`
@@ -48,6 +52,29 @@ 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"`
@@ -83,6 +110,10 @@ type BeaconBlockBodyAltair struct {
 	SyncAggregate     *SyncAggregate         `json:"sync_aggregate"`
 }
 
+// ----------------------------------------------------------------------------
+// Bellatrix
+// ----------------------------------------------------------------------------
+
 type SignedBeaconBlockBellatrix struct {
 	Message   *BeaconBlockBellatrix `json:"message"`
 	Signature string                `json:"signature"`
@@ -155,6 +186,44 @@ 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"`
@@ -229,6 +298,46 @@ 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"`
@@ -317,6 +426,50 @@ 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"`
@@ -362,7 +515,7 @@ type BeaconBlockBodyElectra struct {
 	Deposits              []*Deposit                    `json:"deposits"`
 	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits"`
 	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayload      *ExecutionPayloadElectra      `json:"execution_payload"`
+	ExecutionPayload      *ExecutionPayloadDeneb        `json:"execution_payload"`
 	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
 	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
 	ExecutionRequests     *ExecutionRequests            `json:"execution_requests"`
@@ -392,156 +545,119 @@ 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 *ExecutionPayloadHeaderElectra `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 *ExecutionPayloadHeaderDeneb  `json:"execution_payload_header"`
+	BLSToExecutionChanges  []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
+	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
+	ExecutionRequests      *ExecutionRequests            `json:"execution_requests"`
 }
 
-type SignedBeaconBlockHeaderContainer struct {
-	Header    *SignedBeaconBlockHeader `json:"header"`
-	Root      string                   `json:"root"`
-	Canonical bool                     `json:"canonical"`
+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 SignedBeaconBlockHeader struct {
-	Message   *BeaconBlockHeader `json:"message"`
-	Signature string             `json:"signature"`
+type BeaconBlockContentsFulu struct {
+	Block     *BeaconBlockFulu `json:"block"`
+	KzgProofs []string         `json:"kzg_proofs"`
+	Blobs     []string         `json:"blobs"`
 }
 
-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"`
+type SignedBeaconBlockFulu struct {
+	Message   *BeaconBlockFulu `json:"message"`
+	Signature string           `json:"signature"`
 }
 
-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"`
+var _ SignedMessageJsoner = &SignedBeaconBlockFulu{}
+
+func (s *SignedBeaconBlockFulu) MessageRawJson() ([]byte, error) {
+	return json.Marshal(s.Message)
 }
 
-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"`
+func (s *SignedBeaconBlockFulu) SigString() string {
+	return s.Signature
 }
 
-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 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 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 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 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 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 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"`
+type SignedBlindedBeaconBlockFulu struct {
+	Message   *BlindedBeaconBlockFulu `json:"message"`
+	Signature string                  `json:"signature"`
 }
 
-type ExecutionPayloadHeaderElectra = ExecutionPayloadHeaderDeneb
+var _ SignedMessageJsoner = &SignedBlindedBeaconBlockFulu{}
 
-type ExecutionRequests struct {
-	Deposits       []*DepositRequest       `json:"deposits"`
-	Withdrawals    []*WithdrawalRequest    `json:"withdrawals"`
-	Consolidations []*ConsolidationRequest `json:"consolidations"`
+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"`
 }

api/server/structs/conversions.go

@@ -432,6 +432,32 @@ func (a *AttestationElectra) ToConsensus() (*eth.AttestationElectra, error) {
 	}, nil
 }
 
+func (a *SingleAttestation) ToConsensus() (*eth.SingleAttestation, error) {
+	ci, err := strconv.ParseUint(a.CommitteeIndex, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "CommitteeIndex")
+	}
+	ai, err := strconv.ParseUint(a.AttesterIndex, 10, 64)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "AttesterIndex")
+	}
+	data, err := a.Data.ToConsensus()
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Data")
+	}
+	sig, err := bytesutil.DecodeHexWithLength(a.Signature, fieldparams.BLSSignatureLength)
+	if err != nil {
+		return nil, server.NewDecodeError(err, "Signature")
+	}
+
+	return &eth.SingleAttestation{
+		CommitteeId:   primitives.CommitteeIndex(ci),
+		AttesterIndex: primitives.ValidatorIndex(ai),
+		Data:          data,
+		Signature:     sig,
+	}, nil
+}
+
 func AttElectraFromConsensus(a *eth.AttestationElectra) *AttestationElectra {
 	return &AttestationElectra{
 		AggregationBits: hexutil.Encode(a.AggregationBits),

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.ExecutionPayloadHeaderElectra)
+		ex, ok := exInterface.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
 		if !ok {
-			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderElectra{})
+			return nil, fmt.Errorf("execution data is not %T", &enginev1.ExecutionPayloadHeaderDeneb{})
 		}
 		execution, err := ExecutionPayloadHeaderElectraFromConsensus(ex)
 		if err != nil {

api/server/structs/conversions_state.go

@@ -11,6 +11,10 @@ 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))
@@ -97,6 +101,10 @@ func BeaconStateFromConsensus(st beaconState.BeaconState) (*BeaconState, error)
 	}, nil
 }
 
+// ----------------------------------------------------------------------------
+// Altair
+// ----------------------------------------------------------------------------
+
 func BeaconStateAltairFromConsensus(st beaconState.BeaconState) (*BeaconStateAltair, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -202,6 +210,10 @@ func BeaconStateAltairFromConsensus(st beaconState.BeaconState) (*BeaconStateAlt
 	}, nil
 }
 
+// ----------------------------------------------------------------------------
+// Bellatrix
+// ----------------------------------------------------------------------------
+
 func BeaconStateBellatrixFromConsensus(st beaconState.BeaconState) (*BeaconStateBellatrix, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -320,6 +332,10 @@ func BeaconStateBellatrixFromConsensus(st beaconState.BeaconState) (*BeaconState
 	}, nil
 }
 
+// ----------------------------------------------------------------------------
+// Capella
+// ----------------------------------------------------------------------------
+
 func BeaconStateCapellaFromConsensus(st beaconState.BeaconState) (*BeaconStateCapella, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -457,6 +473,10 @@ func BeaconStateCapellaFromConsensus(st beaconState.BeaconState) (*BeaconStateCa
 	}, nil
 }
 
+// ----------------------------------------------------------------------------
+// Deneb
+// ----------------------------------------------------------------------------
+
 func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDeneb, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -594,6 +614,10 @@ func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDene
 	}, nil
 }
 
+// ----------------------------------------------------------------------------
+// Electra
+// ----------------------------------------------------------------------------
+
 func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateElectra, error) {
 	srcBr := st.BlockRoots()
 	br := make([]string, len(srcBr))
@@ -775,3 +799,189 @@ 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/other.go

@@ -36,6 +36,13 @@ type AttestationElectra struct {
 	CommitteeBits   string           `json:"committee_bits"`
 }
 
+type SingleAttestation struct {
+	CommitteeIndex string           `json:"committee_index"`
+	AttesterIndex  string           `json:"attester_index"`
+	Data           *AttestationData `json:"data"`
+	Signature      string           `json:"signature"`
+}
+
 type AttestationData struct {
 	Slot            string      `json:"slot"`
 	CommitteeIndex  string      `json:"index"`

api/server/structs/state.go

@@ -142,41 +142,81 @@ 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  *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"`
+	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"`
 }

beacon-chain/blockchain/BUILD.bazel

@@ -140,6 +140,7 @@ go_test(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/das:go_default_library",

beacon-chain/blockchain/execution_engine.go

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

beacon-chain/blockchain/head.go

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

beacon-chain/blockchain/kzg/validation.go

@@ -20,16 +20,17 @@ 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) (ret GoKZG.Blob) {
+func bytesToBlob(blob []byte) *GoKZG.Blob {
+	var ret GoKZG.Blob
 	copy(ret[:], blob)
-	return
+	return &ret
 }
 
 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/options.go

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

beacon-chain/blockchain/process_block.go

@@ -15,7 +15,6 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -70,6 +69,7 @@ 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)
@@ -379,7 +379,11 @@ func (s *Service) handleBlockAttestations(ctx context.Context, blk interfaces.Re
 		r := bytesutil.ToBytes32(a.GetData().BeaconBlockRoot)
 		if s.cfg.ForkChoiceStore.HasNode(r) {
 			s.cfg.ForkChoiceStore.ProcessAttestation(ctx, indices, r, a.GetData().Target.Epoch)
-		} else if err := s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
+		} else if features.Get().EnableExperimentalAttestationPool {
+			if err = s.cfg.AttestationCache.Add(a); err != nil {
+				return err
+			}
+		} else if err = s.cfg.AttPool.SaveBlockAttestation(a); err != nil {
 			return err
 		}
 	}
@@ -419,7 +423,11 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 func (s *Service) pruneAttsFromPool(headBlock interfaces.ReadOnlySignedBeaconBlock) error {
 	atts := headBlock.Block().Body().Attestations()
 	for _, att := range atts {
-		if helpers.IsAggregated(att) {
+		if features.Get().EnableExperimentalAttestationPool {
+			if err := s.cfg.AttestationCache.DeleteCovered(att); err != nil {
+				return errors.Wrap(err, "could not delete attestation")
+			}
+		} else if att.IsAggregated() {
 			if err := s.cfg.AttPool.DeleteAggregatedAttestation(att); err != nil {
 				return err
 			}
@@ -496,14 +504,15 @@ func (s *Service) runLateBlockTasks() {
 // It returns a map where each key represents a missing BlobSidecar index.
 // An empty map means we have all indices; a non-empty map can be used to compare incoming
 // BlobSidecars against the set of known missing sidecars.
-func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte) (map[uint64]struct{}, error) {
+func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte, slot primitives.Slot) (map[uint64]struct{}, error) {
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	if len(expected) == 0 {
 		return nil, nil
 	}
-	if len(expected) > fieldparams.MaxBlobsPerBlock {
+	if len(expected) > maxBlobsPerBlock {
 		return nil, errMaxBlobsExceeded
 	}
-	indices, err := bs.Indices(root)
+	indices, err := bs.Indices(root, slot)
 	if err != nil {
 		return nil, err
 	}
@@ -552,7 +561,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 		return nil
 	}
 	// get a map of BlobSidecar indices that are not currently available.
-	missing, err := missingIndices(s.blobStorage, root, kzgCommitments)
+	missing, err := missingIndices(s.blobStorage, root, kzgCommitments, block.Slot())
 	if err != nil {
 		return err
 	}
@@ -563,7 +572,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 
 	// The gossip handler for blobs writes the index of each verified blob referencing the given
 	// root to the channel returned by blobNotifiers.forRoot.
-	nc := s.blobNotifiers.forRoot(root)
+	nc := s.blobNotifiers.forRoot(root, block.Slot())
 
 	// Log for DA checks that cross over into the next slot; helpful for debugging.
 	nextSlot := slots.BeginsAt(signed.Block().Slot()+1, s.genesisTime)

beacon-chain/blockchain/process_block_helpers.go

@@ -1,8 +1,10 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
@@ -128,7 +130,7 @@ func (s *Service) saveLightClientUpdate(cfg *postBlockProcessConfig) {
 	attestedRoot := cfg.roblock.Block().ParentRoot()
 	attestedBlock, err := s.getBlock(cfg.ctx, attestedRoot)
 	if err != nil {
-		log.WithError(err).Error("Saving light client update failed: Could not get attested block")
+		log.WithError(err).Errorf("Saving light client update failed: Could not get attested block for root %#x", attestedRoot)
 		return
 	}
 	if attestedBlock == nil || attestedBlock.IsNil() {
@@ -137,7 +139,7 @@ func (s *Service) saveLightClientUpdate(cfg *postBlockProcessConfig) {
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(cfg.ctx, attestedRoot)
 	if err != nil {
-		log.WithError(err).Error("Saving light client update failed: Could not get attested state")
+		log.WithError(err).Errorf("Saving light client update failed: Could not get attested state for root %#x", attestedRoot)
 		return
 	}
 	if attestedState == nil || attestedState.IsNil() {
@@ -148,7 +150,11 @@ func (s *Service) saveLightClientUpdate(cfg *postBlockProcessConfig) {
 	finalizedRoot := attestedState.FinalizedCheckpoint().Root
 	finalizedBlock, err := s.getBlock(cfg.ctx, [32]byte(finalizedRoot))
 	if err != nil {
-		log.WithError(err).Error("Saving light client update failed: Could not get finalized block")
+		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
+			log.Debugf("Skipping saving light client update: Finalized block is nil for root %#x", finalizedRoot)
+		} else {
+			log.WithError(err).Errorf("Saving light client update failed: Could not get finalized block for root %#x", finalizedRoot)
+		}
 		return
 	}
 
@@ -223,21 +229,28 @@ func (s *Service) processLightClientFinalityUpdate(
 	attestedRoot := signed.Block().ParentRoot()
 	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrap(err, "could not get attested block")
+		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrap(err, "could not get attested state")
+		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
 	}
 
-	var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
-	finalizedCheckPoint := attestedState.FinalizedCheckpoint()
-	if finalizedCheckPoint != nil {
-		finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root)
-		finalizedBlock, err = s.cfg.BeaconDB.Block(ctx, finalizedRoot)
-		if err != nil {
-			finalizedBlock = nil
+	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
+
+	// Check if the finalized checkpoint has changed
+	if finalizedCheckpoint == nil || bytes.Equal(finalizedCheckpoint.GetRoot(), postState.FinalizedCheckpoint().Root) {
+		return nil
+	}
+
+	finalizedRoot := bytesutil.ToBytes32(finalizedCheckpoint.Root)
+	finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, finalizedRoot)
+	if err != nil {
+		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
+			log.Debugf("Skipping processing light client finality update: Finalized block is nil for root %#x", finalizedRoot)
+			return nil
 		}
+		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
 	}
 
 	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
@@ -266,11 +279,11 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 	attestedRoot := signed.Block().ParentRoot()
 	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrap(err, "could not get attested block")
+		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
-		return errors.Wrap(err, "could not get attested state")
+		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
 	}
 
 	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
@@ -283,6 +296,10 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 	)
 
 	if err != nil {
+		if strings.Contains(err.Error(), lightclient.ErrNotEnoughSyncCommitteeBits) {
+			log.WithError(err).Debug("Skipping processing light client optimistic update")
+			return nil
+		}
 		return errors.Wrap(err, "could not create light client optimistic update")
 	}
 

beacon-chain/blockchain/process_block_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
+	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
@@ -2205,23 +2206,23 @@ func TestMissingIndices(t *testing.T) {
 		},
 		{
 			name:     "expected exceeds max",
-			expected: fakeCommitments(fieldparams.MaxBlobsPerBlock + 1),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0) + 1),
 			err:      errMaxBlobsExceeded,
 		},
 		{
 			name:     "first missing",
-			expected: fakeCommitments(fieldparams.MaxBlobsPerBlock),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			present:  []uint64{1, 2, 3, 4, 5},
 			result:   fakeResult([]uint64{0}),
 		},
 		{
 			name:     "all missing",
-			expected: fakeCommitments(fieldparams.MaxBlobsPerBlock),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			result:   fakeResult([]uint64{0, 1, 2, 3, 4, 5}),
 		},
 		{
 			name:     "none missing",
-			expected: fakeCommitments(fieldparams.MaxBlobsPerBlock),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			present:  []uint64{0, 1, 2, 3, 4, 5},
 			result:   fakeResult([]uint64{}),
 		},
@@ -2255,7 +2256,7 @@ func TestMissingIndices(t *testing.T) {
 		bm, bs := filesystem.NewEphemeralBlobStorageWithMocker(t)
 		t.Run(c.name, func(t *testing.T) {
 			require.NoError(t, bm.CreateFakeIndices(c.root, c.present...))
-			missing, err := missingIndices(bs, c.root, c.expected)
+			missing, err := missingIndices(bs, c.root, c.expected, 0)
 			if c.err != nil {
 				require.ErrorIs(t, err, c.err)
 				return
@@ -2505,173 +2506,500 @@ func fakeResult(missing []uint64) map[uint64]struct{} {
 }
 
 func TestSaveLightClientUpdate(t *testing.T) {
+	featCfg := &features.Flags{}
+	featCfg.EnableLightClient = true
+	reset := features.InitWithReset(featCfg)
+
 	s, tr := minimalTestService(t)
 	ctx := tr.ctx
 
 	t.Run("Altair", func(t *testing.T) {
-		featCfg := &features.Flags{}
-		featCfg.EnableLightClient = true
-		reset := features.InitWithReset(featCfg)
+		t.Run("No old update", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestAltair()
 
-		l := util.NewTestLightClient(t).SetupTestAltair()
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().AltairForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
 
-		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().AltairForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
 
-		err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
-		require.NoError(t, err)
-		attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
-		require.NoError(t, err)
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
 
-		currentBlockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-		roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
-		require.NoError(t, err)
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
 
-		cfg := &postBlockProcessConfig{
-			ctx:            ctx,
-			roblock:        roblock,
-			postState:      l.State,
-			isValidPayload: true,
-		}
+			s.saveLightClientUpdate(cfg)
 
-		s.saveLightClientUpdate(cfg)
+			// Check that the light client update is saved
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
-		// Check that the light client update is saved
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
+			require.Equal(t, u.Version(), version.Altair)
+		})
 
-		u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
-		require.Equal(t, u.Version(), version.Altair)
+		t.Run("New update is better", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestAltair()
 
-		reset()
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().AltairForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
+
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
+
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
+
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+
+			// create and save old update
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+			require.NoError(t, err)
+
+			s.saveLightClientUpdate(cfg)
+
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
+			require.Equal(t, u.Version(), version.Altair)
+		})
+
+		t.Run("Old update is better", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestAltair()
+
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().AltairForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
+
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
+
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
+
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+
+			// create and save old update
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			require.NoError(t, err)
+
+			scb := make([]byte, 64)
+			for i := 0; i < 5; i++ {
+				scb[i] = 0x01
+			}
+			oldUpdate.SetSyncAggregate(&ethpb.SyncAggregate{
+				SyncCommitteeBits:      scb,
+				SyncCommitteeSignature: make([]byte, 96),
+			})
+
+			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+			require.NoError(t, err)
+
+			s.saveLightClientUpdate(cfg)
+
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			require.DeepEqual(t, oldUpdate, u)
+			require.Equal(t, u.Version(), version.Altair)
+		})
 	})
 
 	t.Run("Capella", func(t *testing.T) {
-		featCfg := &features.Flags{}
-		featCfg.EnableLightClient = true
-		reset := features.InitWithReset(featCfg)
+		t.Run("No old update", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestCapella(false)
 
-		l := util.NewTestLightClient(t).SetupTestCapella(false)
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().CapellaForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
 
-		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().CapellaForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
 
-		err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
-		require.NoError(t, err)
-		attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
-		require.NoError(t, err)
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
 
-		currentBlockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-		roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
-		require.NoError(t, err)
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
 
-		cfg := &postBlockProcessConfig{
-			ctx:            ctx,
-			roblock:        roblock,
-			postState:      l.State,
-			isValidPayload: true,
-		}
+			s.saveLightClientUpdate(cfg)
 
-		s.saveLightClientUpdate(cfg)
+			// Check that the light client update is saved
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
+			require.Equal(t, u.Version(), version.Capella)
+		})
 
-		// Check that the light client update is saved
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
-		u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
-		require.Equal(t, u.Version(), version.Capella)
+		t.Run("New update is better", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestCapella(false)
 
-		reset()
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().CapellaForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
+
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
+
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
+
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+
+			// create and save old update
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+			require.NoError(t, err)
+
+			s.saveLightClientUpdate(cfg)
+
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
+			require.Equal(t, u.Version(), version.Capella)
+		})
+
+		t.Run("Old update is better", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestCapella(false)
+
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().CapellaForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
+
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
+
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
+
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+
+			// create and save old update
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			require.NoError(t, err)
+
+			scb := make([]byte, 64)
+			for i := 0; i < 5; i++ {
+				scb[i] = 0x01
+			}
+			oldUpdate.SetSyncAggregate(&ethpb.SyncAggregate{
+				SyncCommitteeBits:      scb,
+				SyncCommitteeSignature: make([]byte, 96),
+			})
+
+			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+			require.NoError(t, err)
+
+			s.saveLightClientUpdate(cfg)
+
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			require.DeepEqual(t, oldUpdate, u)
+			require.Equal(t, u.Version(), version.Capella)
+		})
 	})
 
 	t.Run("Deneb", func(t *testing.T) {
-		featCfg := &features.Flags{}
-		featCfg.EnableLightClient = true
-		reset := features.InitWithReset(featCfg)
+		t.Run("No old update", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
-		l := util.NewTestLightClient(t).SetupTestDeneb(false)
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().DenebForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
 
-		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().DenebForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
 
-		err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
-		require.NoError(t, err)
-		attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
-		require.NoError(t, err)
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
 
-		currentBlockRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-		roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
-		require.NoError(t, err)
-		err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
-		require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
 
-		err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
-		require.NoError(t, err)
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
 
-		cfg := &postBlockProcessConfig{
-			ctx:            ctx,
-			roblock:        roblock,
-			postState:      l.State,
-			isValidPayload: true,
-		}
+			s.saveLightClientUpdate(cfg)
 
-		s.saveLightClientUpdate(cfg)
+			// Check that the light client update is saved
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
+			require.Equal(t, u.Version(), version.Deneb)
+		})
 
-		// Check that the light client update is saved
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
-		u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
-		require.NoError(t, err)
-		require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
-		require.Equal(t, u.Version(), version.Deneb)
+		t.Run("New update is better", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
-		reset()
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().DenebForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
+
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
+
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
+
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+
+			// create and save old update
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+			require.NoError(t, err)
+
+			s.saveLightClientUpdate(cfg)
+
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
+			require.NoError(t, err)
+			require.Equal(t, attestedStateRoot, [32]byte(u.AttestedHeader().Beacon().StateRoot))
+			require.Equal(t, u.Version(), version.Deneb)
+		})
+
+		t.Run("Old update is better", func(t *testing.T) {
+			l := util.NewTestLightClient(t).SetupTestDeneb(false)
+
+			s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().DenebForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
+
+			err := s.cfg.BeaconDB.SaveBlock(ctx, l.AttestedBlock)
+			require.NoError(t, err)
+			attestedBlockRoot, err := l.AttestedBlock.Block().HashTreeRoot()
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.AttestedState, attestedBlockRoot)
+			require.NoError(t, err)
+
+			currentBlockRoot, err := l.Block.Block().HashTreeRoot()
+			require.NoError(t, err)
+			roblock, err := consensusblocks.NewROBlockWithRoot(l.Block, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, roblock)
+			require.NoError(t, err)
+			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
+			require.NoError(t, err)
+
+			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
+			require.NoError(t, err)
+
+			cfg := &postBlockProcessConfig{
+				ctx:            ctx,
+				roblock:        roblock,
+				postState:      l.State,
+				isValidPayload: true,
+			}
+
+			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
+
+			// create and save old update
+			oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(s.CurrentSlot(), l.AttestedState)
+			require.NoError(t, err)
+
+			scb := make([]byte, 64)
+			for i := 0; i < 5; i++ {
+				scb[i] = 0x01
+			}
+			oldUpdate.SetSyncAggregate(&ethpb.SyncAggregate{
+				SyncCommitteeBits:      scb,
+				SyncCommitteeSignature: make([]byte, 96),
+			})
+
+			err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+			require.NoError(t, err)
+
+			s.saveLightClientUpdate(cfg)
+
+			u, err := s.cfg.BeaconDB.LightClientUpdate(ctx, period)
+			require.NoError(t, err)
+			require.NotNil(t, u)
+			require.DeepEqual(t, oldUpdate, u)
+			require.Equal(t, u.Version(), version.Deneb)
+		})
 	})
+
+	reset()
 }
 
 func TestSaveLightClientBootstrap(t *testing.T) {
+	featCfg := &features.Flags{}
+	featCfg.EnableLightClient = true
+	reset := features.InitWithReset(featCfg)
+
 	s, tr := minimalTestService(t)
 	ctx := tr.ctx
 
 	t.Run("Altair", func(t *testing.T) {
-		featCfg := &features.Flags{}
-		featCfg.EnableLightClient = true
-		reset := features.InitWithReset(featCfg)
-
 		l := util.NewTestLightClient(t).SetupTestAltair()
 
 		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().AltairForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
@@ -2704,15 +3032,9 @@ func TestSaveLightClientBootstrap(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
 		require.Equal(t, b.Version(), version.Altair)
-
-		reset()
 	})
 
 	t.Run("Capella", func(t *testing.T) {
-		featCfg := &features.Flags{}
-		featCfg.EnableLightClient = true
-		reset := features.InitWithReset(featCfg)
-
 		l := util.NewTestLightClient(t).SetupTestCapella(false)
 
 		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().CapellaForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
@@ -2745,15 +3067,9 @@ func TestSaveLightClientBootstrap(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
 		require.Equal(t, b.Version(), version.Capella)
-
-		reset()
 	})
 
 	t.Run("Deneb", func(t *testing.T) {
-		featCfg := &features.Flags{}
-		featCfg.EnableLightClient = true
-		reset := features.InitWithReset(featCfg)
-
 		l := util.NewTestLightClient(t).SetupTestDeneb(false)
 
 		s.genesisTime = time.Unix(time.Now().Unix()-(int64(params.BeaconConfig().DenebForkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
@@ -2786,7 +3102,7 @@ func TestSaveLightClientBootstrap(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
 		require.Equal(t, b.Version(), version.Deneb)
-
-		reset()
 	})
+
+	reset()
 }

beacon-chain/blockchain/receive_attestation.go

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

beacon-chain/blockchain/receive_blob.go

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

beacon-chain/blockchain/service.go

@@ -33,10 +33,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -75,6 +75,7 @@ type config struct {
 	DepositCache            cache.DepositCache
 	PayloadIDCache          *cache.PayloadIDCache
 	TrackedValidatorsCache  *cache.TrackedValidatorsCache
+	AttestationCache        *cache.AttestationCache
 	AttPool                 attestations.Pool
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
@@ -104,18 +105,22 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][fieldparams.MaxBlobsPerBlock]bool
+	seenIndex map[[32]byte][]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
-func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
-	if idx >= fieldparams.MaxBlobsPerBlock {
+func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitives.Slot) {
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	if idx >= uint64(maxBlobsPerBlock) {
 		return
 	}
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
+	if seen == nil {
+		seen = make([]bool, maxBlobsPerBlock)
+	}
 	if seen[idx] {
 		bn.Unlock()
 		return
@@ -126,7 +131,7 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
+		c = make(chan uint64, maxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 
@@ -135,12 +140,13 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
 	c <- idx
 }
 
-func (bn *blobNotifierMap) forRoot(root [32]byte) chan uint64 {
+func (bn *blobNotifierMap) forRoot(root [32]byte, slot primitives.Slot) chan uint64 {
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	bn.Lock()
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
+		c = make(chan uint64, maxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -166,7 +172,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
+		seenIndex: make(map[[32]byte][]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,

beacon-chain/blockchain/service_test.go

@@ -587,7 +587,7 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
+		seenIndex: make(map[[32]byte][]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 
@@ -596,7 +596,7 @@ func TestNotifyIndex(t *testing.T) {
 	copy(root[:], "exampleRoot")
 
 	// Test notifying a new index
-	bn.notifyIndex(root, 1)
+	bn.notifyIndex(root, 1, 1)
 	if !bn.seenIndex[root][1] {
 		t.Errorf("Index was not marked as seen")
 	}
@@ -607,13 +607,13 @@ func TestNotifyIndex(t *testing.T) {
 	}
 
 	// Test notifying an already seen index
-	bn.notifyIndex(root, 1)
+	bn.notifyIndex(root, 1, 1)
 	if len(bn.notifiers[root]) > 1 {
 		t.Errorf("Notifier channel should not receive multiple messages for the same index")
 	}
 
 	// Test notifying a new index again
-	bn.notifyIndex(root, 2)
+	bn.notifyIndex(root, 2, 1)
 	if !bn.seenIndex[root][2] {
 		t.Errorf("Index was not marked as seen")
 	}

beacon-chain/cache/BUILD.bazel

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

beacon-chain/cache/attestation.go

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

beacon-chain/cache/attestation_data.go

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

beacon-chain/cache/attestation_data_test.go

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

beacon-chain/cache/attestation_test.go

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

beacon-chain/core/altair/epoch_spec_test.go

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

beacon-chain/core/altair/sync_committee.go

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

beacon-chain/core/altair/transition.go

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

beacon-chain/core/blocks/exports_test.go

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

beacon-chain/core/blocks/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.ExecutionPayloadElectra{
+					ExecutionPayload: &enginev1.ExecutionPayloadDeneb{
 						ParentHash:    make([]byte, 32),
 						FeeRecipient:  make([]byte, 20),
 						StateRoot:     make([]byte, 32),

beacon-chain/core/blocks/payload.go

@@ -8,10 +8,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -210,7 +211,7 @@ func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBod
 	if err != nil {
 		return err
 	}
-	if err := verifyBlobCommitmentCount(body); err != nil {
+	if err := verifyBlobCommitmentCount(st.Slot(), body); err != nil {
 		return err
 	}
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
@@ -225,7 +226,7 @@ func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBod
 	return nil
 }
 
-func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
+func verifyBlobCommitmentCount(slot primitives.Slot, body interfaces.ReadOnlyBeaconBlockBody) error {
 	if body.Version() < version.Deneb {
 		return nil
 	}
@@ -233,7 +234,8 @@ func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
 	if err != nil {
 		return err
 	}
-	if len(kzgs) > field_params.MaxBlobsPerBlock {
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	if len(kzgs) > maxBlobsPerBlock {
 		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
 	}
 	return nil

beacon-chain/core/blocks/payload_test.go

@@ -9,6 +9,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -923,10 +924,10 @@ func TestVerifyBlobCommitmentCount(t *testing.T) {
 	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
 	rb, err := consensusblocks.NewBeaconBlock(b)
 	require.NoError(t, err)
-	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Body()))
+	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Slot(), rb.Body()))
 
-	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, fieldparams.MaxBlobsPerBlock+1)}}
+	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, params.BeaconConfig().MaxBlobsPerBlock(rb.Slot())+1)}}
 	rb, err = consensusblocks.NewBeaconBlock(b)
 	require.NoError(t, err)
-	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", fieldparams.MaxBlobsPerBlock+1), blocks.VerifyBlobCommitmentCount(rb.Body()))
+	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", params.BeaconConfig().MaxBlobsPerBlock(rb.Slot())+1), blocks.VerifyBlobCommitmentCount(rb.Slot(), rb.Body()))
 }

beacon-chain/core/blocks/withdrawals.go

@@ -100,8 +100,11 @@ func ValidateBLSToExecutionChange(st state.ReadOnlyBeaconState, signed *ethpb.Si
 	if err != nil {
 		return nil, err
 	}
+	if val == nil {
+		return nil, errors.Wrap(errInvalidWithdrawalCredentials, "validator is nil") // This should not be possible.
+	}
 	cred := val.WithdrawalCredentials
-	if cred[0] != params.BeaconConfig().BLSWithdrawalPrefixByte {
+	if len(cred) < 2 || cred[0] != params.BeaconConfig().BLSWithdrawalPrefixByte {
 		return nil, errInvalidBLSPrefix
 	}
 

beacon-chain/core/blocks/withdrawals_test.go

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

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

beacon-chain/core/electra/consolidations.go

@@ -37,8 +37,7 @@ import (
 //	        break
 //
 //	    # Calculate the consolidated balance
-//	    max_effective_balance = get_max_effective_balance(source_validator)
-//	    source_effective_balance = min(state.balances[pending_consolidation.source_index], max_effective_balance)
+//	    source_effective_balance = min(state.balances[pending_consolidation.source_index], source_validator.effective_balance)
 //
 //	    # Move active balance to target. Excess balance is withdrawable.
 //	    decrease_balance(state, pending_consolidation.source_index, source_effective_balance)
@@ -78,7 +77,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 		if err != nil {
 			return err
 		}
-		b := min(validatorBalance, helpers.ValidatorMaxEffectiveBalance(sourceValidator))
+		b := min(validatorBalance, sourceValidator.EffectiveBalance())
 
 		if err := helpers.DecreaseBalance(st, pc.SourceIndex, b); err != nil {
 			return err
@@ -141,8 +140,8 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    if not (has_correct_credential and is_correct_source_address):
 //	        return
 //
-//	    # Verify that target has execution withdrawal credentials
-//	    if not has_execution_withdrawal_credential(target_validator):
+//	    # Verify that target has compounding withdrawal credentials
+//	    if not has_compounding_withdrawal_credential(target_validator):
 //	        return
 //
 //	    # Verify the source and the target are active
@@ -175,10 +174,6 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	        source_index=source_index,
 //	        target_index=target_index
 //	    ))
-//
-//	    # Churn any target excess active balance of target and raise its max
-//	    if has_eth1_withdrawal_credential(target_validator):
-//	        switch_to_compounding_validator(state, target_index)
 func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, reqs []*enginev1.ConsolidationRequest) error {
 	if len(reqs) == 0 || st == nil {
 		return nil
@@ -253,7 +248,7 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		}
 
 		// Target validator must have their withdrawal credentials set appropriately.
-		if !helpers.HasExecutionWithdrawalCredentials(tgtV) {
+		if !helpers.HasCompoundingWithdrawalCredential(tgtV) {
 			continue
 		}
 
@@ -298,13 +293,6 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 		if err := st.AppendPendingConsolidation(&eth.PendingConsolidation{SourceIndex: srcIdx, TargetIndex: tgtIdx}); err != nil {
 			return fmt.Errorf("failed to append pending consolidation: %w", err) // This should never happen.
 		}
-
-		if helpers.HasETH1WithdrawalCredential(tgtV) {
-			if err := SwitchToCompoundingValidator(st, tgtIdx); err != nil {
-				log.WithError(err).Error("failed to switch to compounding validator")
-				continue
-			}
-		}
 	}
 
 	return nil

beacon-chain/core/electra/consolidations_test.go

@@ -46,6 +46,7 @@ func TestProcessPendingConsolidations(t *testing.T) {
 					Validators: []*eth.Validator{
 						{
 							WithdrawalCredentials: []byte{0x01, 0xFF},
+							EffectiveBalance:      params.BeaconConfig().MinActivationBalance,
 						},
 						{
 							WithdrawalCredentials: []byte{0x01, 0xAB},
@@ -218,7 +219,7 @@ func TestProcessConsolidationRequests(t *testing.T) {
 				}
 				// Validator scenario setup. See comments in reqs section.
 				st.Validators[3].WithdrawalCredentials = bytesutil.Bytes32(0)
-				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(0)
+				st.Validators[8].WithdrawalCredentials = bytesutil.Bytes32(1)
 				st.Validators[9].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
 				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
 				st.Validators[13].ExitEpoch = 10
@@ -246,7 +247,7 @@ func TestProcessConsolidationRequests(t *testing.T) {
 					SourcePubkey:  []byte("val_5"),
 					TargetPubkey:  []byte("val_6"),
 				},
-				// Target does not have their withdrawal credentials set appropriately.
+				// Target does not have their withdrawal credentials set appropriately. (Using eth1 address prefix)
 				{
 					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(7)),
 					SourcePubkey:  []byte("val_7"),

beacon-chain/core/electra/deposits.go

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

beacon-chain/core/electra/registry_updates.go

@@ -18,23 +18,24 @@ 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):
-//		            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):  # [Modified in Electra:EIP7251]
+//	            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))
+//	        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]
 //
-//	         # 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
+//	    # 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
 func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) error {
 	currentEpoch := time.CurrentEpoch(st)
 	ejectionBal := params.BeaconConfig().EjectionBalance
@@ -90,8 +91,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,14 +40,17 @@ var (
 //	    process_justification_and_finalization(state)
 //	    process_inactivity_updates(state)
 //	    process_rewards_and_penalties(state)
-//	    process_registry_updates(state)
-//	    process_slashings(state)
+//	    process_registry_updates(state)  # [Modified in Electra:EIP7251]
+//	    process_slashings(state)  # [Modified in Electra:EIP7251]
 //	    process_eth1_data_reset(state)
-//	    process_pending_deposits(state)  # New in EIP7251
-//	    process_pending_consolidations(state)  # New in EIP7251
-//	    process_effective_balance_updates(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_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()
@@ -75,24 +78,16 @@ 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")
 	}
-
-	proportionalSlashingMultiplier, err := state.ProportionalSlashingMultiplier()
-	if err != nil {
-		return err
-	}
-	state, err = ProcessSlashings(state, proportionalSlashingMultiplier)
-	if err != nil {
+	if err := ProcessSlashings(state); 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
 	}
@@ -102,7 +97,6 @@ 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
@@ -115,17 +109,14 @@ 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.ExecutionPayloadHeaderElectra{
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
 			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.ExecutionPayloadHeaderElectra)
+	protoHeader, ok := header.Proto().(*enginev1.ExecutionPayloadHeaderDeneb)
 	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.ExecutionPayloadHeaderElectra{
+	wanted := &enginev1.ExecutionPayloadHeaderDeneb{
 		ParentHash:       prevHeader.ParentHash(),
 		FeeRecipient:     prevHeader.FeeRecipient(),
 		StateRoot:        prevHeader.StateRoot(),

beacon-chain/core/epoch/epoch_processing.go

@@ -141,29 +141,76 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 	return st, nil
 }
 
-// ProcessSlashings processes the slashed validators during epoch processing,
+// ProcessSlashings processes the slashed validators during epoch processing. This is a state mutating method.
+//
+// Electra 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)
-//	  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:
+//	    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:
 //	            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)
-func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.BeaconState, error) {
+//	            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")
+	}
 	currentEpoch := time.CurrentEpoch(st)
 	totalBalance, err := helpers.TotalActiveBalance(st)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not get total active balance")
+		return errors.Wrap(err, "could not get total active balance")
 	}
 
 	// Compute slashed balances in the current epoch
@@ -175,7 +222,7 @@ func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.Be
 	for _, slashing := range slashings {
 		totalSlashing, err = math.Add64(totalSlashing, slashing)
 		if err != nil {
-			return nil, err
+			return err
 		}
 	}
 
@@ -209,14 +256,14 @@ func ProcessSlashings(st state.BeaconState, slashingMultiplier uint64) (state.Be
 		return nil
 	})
 	if err != nil {
-		return nil, err
+		return err
 	}
 	if changed {
 		if err := st.SetBalances(bals); err != nil {
-			return nil, err
+			return err
 		}
 	}
-	return st, nil
+	return nil
 }
 
 // ProcessEth1DataReset processes updates to ETH1 data votes during epoch processing.

beacon-chain/core/epoch/epoch_processing_test.go

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

beacon-chain/core/fulu/BUILD.bazel

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,184 @@
+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

@@ -0,0 +1,188 @@
+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,6 +32,9 @@ 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 {
 		return errors.New("attestation's bitfield can't be nil")
 	}
@@ -67,12 +70,6 @@ func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 	return binary.LittleEndian.Uint64(b[:8])%modulo == 0, nil
 }
 
-// IsAggregated returns true if the attestation is an aggregated attestation,
-// false otherwise.
-func IsAggregated(attestation ethpb.Att) bool {
-	return attestation.GetAggregationBits().Count() > 1
-}
-
 // ComputeSubnetForAttestation returns the subnet for which the provided attestation will be broadcasted to.
 // This differs from the spec definition by instead passing in the active validators indices in the attestation's
 // given epoch.

beacon-chain/core/helpers/attestation_test.go

@@ -308,6 +308,16 @@ func TestValidateNilAttestation(t *testing.T) {
 			},
 			errString: "",
 		},
+		{
+			name: "single attestation",
+			attestation: &ethpb.SingleAttestation{
+				Data: &ethpb.AttestationData{
+					Target: &ethpb.Checkpoint{},
+					Source: &ethpb.Checkpoint{},
+				},
+			},
+			errString: "",
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

beacon-chain/core/helpers/beacon_committee_test.go

@@ -97,6 +97,13 @@ 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/helpers/validators.go

@@ -3,6 +3,7 @@ package helpers
 import (
 	"bytes"
 	"context"
+	"encoding/binary"
 
 	"github.com/pkg/errors"
 	"github.com/prometheus/client_golang/prometheus"
@@ -11,6 +12,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
@@ -347,27 +349,33 @@ func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconSt
 // Spec pseudocode definition:
 //
 //	def compute_proposer_index(state: BeaconState, indices: Sequence[ValidatorIndex], seed: Bytes32) -> ValidatorIndex:
-//	  """
-//	  Return from ``indices`` a random index sampled by effective balance.
-//	  """
-//	  assert len(indices) > 0
-//	  MAX_RANDOM_BYTE = 2**8 - 1
-//	  i = uint64(0)
-//	  total = uint64(len(indices))
-//	  while True:
-//	      candidate_index = indices[compute_shuffled_index(i % total, total, seed)]
-//	      random_byte = hash(seed + uint_to_bytes(uint64(i // 32)))[i % 32]
-//	      effective_balance = state.validators[candidate_index].effective_balance
-//	      if effective_balance * MAX_RANDOM_BYTE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_byte: #[Modified in Electra:EIP7251]
-//	          return candidate_index
-//	      i += 1
+//	   """
+//	   Return from ``indices`` a random index sampled by effective balance.
+//	   """
+//	   assert len(indices) > 0
+//	   MAX_RANDOM_VALUE = 2**16 - 1  # [Modified in Electra]
+//	   i = uint64(0)
+//	   total = uint64(len(indices))
+//	   while True:
+//	       candidate_index = indices[compute_shuffled_index(i % total, total, seed)]
+//	       # [Modified in Electra]
+//	       random_bytes = hash(seed + uint_to_bytes(i // 16))
+//	       offset = i % 16 * 2
+//	       random_value = bytes_to_uint64(random_bytes[offset:offset + 2])
+//	       effective_balance = state.validators[candidate_index].effective_balance
+//	       # [Modified in Electra:EIP7251]
+//	       if effective_balance * MAX_RANDOM_VALUE >= MAX_EFFECTIVE_BALANCE_ELECTRA * random_value:
+//	           return candidate_index
+//	       i += 1
 func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []primitives.ValidatorIndex, seed [32]byte) (primitives.ValidatorIndex, error) {
 	length := uint64(len(activeIndices))
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
 	}
-	maxRandomByte := uint64(1<<8 - 1)
 	hashFunc := hash.CustomSHA256Hasher()
+	beaconConfig := params.BeaconConfig()
+	seedBuffer := make([]byte, len(seed)+8)
+	copy(seedBuffer, seed[:])
 
 	for i := uint64(0); ; i++ {
 		candidateIndex, err := ComputeShuffledIndex(primitives.ValidatorIndex(i%length), length, seed, true /* shuffle */)
@@ -378,21 +386,28 @@ func ComputeProposerIndex(bState state.ReadOnlyBeaconState, activeIndices []prim
 		if uint64(candidateIndex) >= uint64(bState.NumValidators()) {
 			return 0, errors.New("active index out of range")
 		}
-		b := append(seed[:], bytesutil.Bytes8(i/32)...)
-		randomByte := hashFunc(b)[i%32]
+
 		v, err := bState.ValidatorAtIndexReadOnly(candidateIndex)
 		if err != nil {
 			return 0, err
 		}
 		effectiveBal := v.EffectiveBalance()
-
-		maxEB := params.BeaconConfig().MaxEffectiveBalance
 		if bState.Version() >= version.Electra {
-			maxEB = params.BeaconConfig().MaxEffectiveBalanceElectra
-		}
+			binary.LittleEndian.PutUint64(seedBuffer[len(seed):], i/16)
+			randomByte := hashFunc(seedBuffer)
+			offset := (i % 16) * 2
+			randomValue := uint64(randomByte[offset]) | uint64(randomByte[offset+1])<<8
 
-		if effectiveBal*maxRandomByte >= maxEB*uint64(randomByte) {
-			return candidateIndex, nil
+			if effectiveBal*fieldparams.MaxRandomValueElectra >= beaconConfig.MaxEffectiveBalanceElectra*randomValue {
+				return candidateIndex, nil
+			}
+		} else {
+			binary.LittleEndian.PutUint64(seedBuffer[len(seed):], i/32)
+			randomByte := hashFunc(seedBuffer)[i%32]
+
+			if effectiveBal*fieldparams.MaxRandomByte >= beaconConfig.MaxEffectiveBalance*uint64(randomByte) {
+				return candidateIndex, nil
+			}
 		}
 	}
 }

beacon-chain/core/helpers/validators_test.go

@@ -841,7 +841,6 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd
 	if length == 0 {
 		return 0, errors.New("empty active indices list")
 	}
-	maxRandomByte := uint64(1<<8 - 1)
 	hashFunc := hash.CustomSHA256Hasher()
 
 	for i := uint64(0); ; i++ {
@@ -860,7 +859,7 @@ func computeProposerIndexWithValidators(validators []*ethpb.Validator, activeInd
 		if v != nil {
 			effectiveBal = v.EffectiveBalance
 		}
-		if effectiveBal*maxRandomByte >= params.BeaconConfig().MaxEffectiveBalance*uint64(randomByte) {
+		if effectiveBal*fieldparams.MaxRandomByte >= params.BeaconConfig().MaxEffectiveBalance*uint64(randomByte) {
 			return candidateIndex, nil
 		}
 	}

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

@@ -6,6 +6,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/execution:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

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

@@ -7,6 +7,7 @@ import (
 	"reflect"
 
 	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -23,6 +24,8 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
+const ErrNotEnoughSyncCommitteeBits = "sync committee bits count is less than required"
+
 func NewLightClientFinalityUpdateFromBeaconState(
 	ctx context.Context,
 	currentSlot primitives.Slot,
@@ -83,7 +86,12 @@ func NewLightClientUpdateFromBeaconState(
 		return nil, errors.Wrap(err, "could not get sync aggregate")
 	}
 	if syncAggregate.SyncCommitteeBits.Count() < params.BeaconConfig().MinSyncCommitteeParticipants {
-		return nil, fmt.Errorf("invalid sync committee bits count %d", syncAggregate.SyncCommitteeBits.Count())
+		return nil, fmt.Errorf(
+			"%s (got %d, need %d)",
+			ErrNotEnoughSyncCommitteeBits,
+			syncAggregate.SyncCommitteeBits.Count(),
+			params.BeaconConfig().MinSyncCommitteeParticipants,
+		)
 	}
 
 	// assert state.slot == state.latest_block_header.slot
@@ -281,56 +289,247 @@ func CreateDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
 		m = &pb.LightClientUpdateAltair{
 			AttestedHeader: &pb.LightClientHeaderAltair{
-				Beacon: &pb.BeaconBlockHeader{},
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
 			},
 			NextSyncCommittee:       nextSyncCommittee,
 			NextSyncCommitteeBranch: nextSyncCommitteeBranch,
 			FinalityBranch:          finalityBranch,
+			FinalizedHeader: &pb.LightClientHeaderAltair{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+			},
+			SyncAggregate: &pb.SyncAggregate{
+				SyncCommitteeBits:      make([]byte, 64),
+				SyncCommitteeSignature: make([]byte, 96),
+			},
 		}
 	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
 		m = &pb.LightClientUpdateCapella{
 			AttestedHeader: &pb.LightClientHeaderCapella{
-				Beacon:          &pb.BeaconBlockHeader{},
-				Execution:       &enginev1.ExecutionPayloadHeaderCapella{},
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				Execution: &enginev1.ExecutionPayloadHeaderCapella{
+					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: executionBranch,
 			},
 			NextSyncCommittee:       nextSyncCommittee,
 			NextSyncCommitteeBranch: nextSyncCommitteeBranch,
 			FinalityBranch:          finalityBranch,
+			FinalizedHeader: &pb.LightClientHeaderCapella{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				Execution: &enginev1.ExecutionPayloadHeaderCapella{
+					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: executionBranch,
+			},
+			SyncAggregate: &pb.SyncAggregate{
+				SyncCommitteeBits:      make([]byte, 64),
+				SyncCommitteeSignature: make([]byte, 96),
+			},
 		}
 	} else if currentEpoch < params.BeaconConfig().ElectraForkEpoch {
 		m = &pb.LightClientUpdateDeneb{
 			AttestedHeader: &pb.LightClientHeaderDeneb{
-				Beacon:          &pb.BeaconBlockHeader{},
-				Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				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),
+					GasLimit:         0,
+					GasUsed:          0,
+				},
 				ExecutionBranch: executionBranch,
 			},
 			NextSyncCommittee:       nextSyncCommittee,
 			NextSyncCommitteeBranch: nextSyncCommitteeBranch,
 			FinalityBranch:          finalityBranch,
+			FinalizedHeader: &pb.LightClientHeaderDeneb{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				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),
+					GasLimit:         0,
+					GasUsed:          0,
+				},
+				ExecutionBranch: executionBranch,
+			},
+			SyncAggregate: &pb.SyncAggregate{
+				SyncCommitteeBits:      make([]byte, 64),
+				SyncCommitteeSignature: make([]byte, 96),
+			},
 		}
 	} else {
 		if attestedState.Version() >= version.Electra {
 			m = &pb.LightClientUpdateElectra{
 				AttestedHeader: &pb.LightClientHeaderDeneb{
-					Beacon:          &pb.BeaconBlockHeader{},
-					Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					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),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
 					ExecutionBranch: executionBranch,
 				},
 				NextSyncCommittee:       nextSyncCommittee,
 				NextSyncCommitteeBranch: nextSyncCommitteeBranch,
 				FinalityBranch:          finalityBranch,
+				FinalizedHeader: &pb.LightClientHeaderDeneb{
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					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),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
+					ExecutionBranch: executionBranch,
+				},
+				SyncAggregate: &pb.SyncAggregate{
+					SyncCommitteeBits:      make([]byte, 64),
+					SyncCommitteeSignature: make([]byte, 96),
+				},
 			}
 		} else {
 			m = &pb.LightClientUpdateDeneb{
 				AttestedHeader: &pb.LightClientHeaderDeneb{
-					Beacon:          &pb.BeaconBlockHeader{},
-					Execution:       &enginev1.ExecutionPayloadHeaderDeneb{},
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					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),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
 					ExecutionBranch: executionBranch,
 				},
 				NextSyncCommittee:       nextSyncCommittee,
 				NextSyncCommitteeBranch: nextSyncCommitteeBranch,
 				FinalityBranch:          finalityBranch,
+				FinalizedHeader: &pb.LightClientHeaderDeneb{
+					Beacon: &pb.BeaconBlockHeader{
+						ParentRoot: make([]byte, 32),
+						StateRoot:  make([]byte, 32),
+						BodyRoot:   make([]byte, 32),
+					},
+					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),
+						GasLimit:         0,
+						GasUsed:          0,
+					},
+					ExecutionBranch: executionBranch,
+				},
+				SyncAggregate: &pb.SyncAggregate{
+					SyncCommitteeBits:      make([]byte, 64),
+					SyncCommitteeSignature: make([]byte, 96),
+				},
 			}
 		}
 	}
@@ -404,18 +603,15 @@ func BlockToLightClientHeader(
 		var payloadProof [][]byte
 
 		if blockEpoch < params.BeaconConfig().CapellaForkEpoch {
-			payloadHeader = &enginev1.ExecutionPayloadHeaderCapella{
-				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),
+			var ok bool
+
+			p, err := execution.EmptyExecutionPayloadHeader(version.Capella)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get payload header")
+			}
+			payloadHeader, ok = p.(*enginev1.ExecutionPayloadHeaderCapella)
+			if !ok {
+				return nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderCapella{})
 			}
 			payloadProof = emptyPayloadProof()
 		} else {
@@ -472,18 +668,15 @@ func BlockToLightClientHeader(
 		var payloadProof [][]byte
 
 		if blockEpoch < params.BeaconConfig().CapellaForkEpoch {
-			payloadHeader = &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),
+			var ok bool
+
+			p, err := execution.EmptyExecutionPayloadHeader(version.Deneb)
+			if err != nil {
+				return nil, errors.Wrap(err, "could not get payload header")
+			}
+			payloadHeader, ok = p.(*enginev1.ExecutionPayloadHeaderDeneb)
+			if !ok {
+				return nil, fmt.Errorf("payload header type %T is not %T", p, &enginev1.ExecutionPayloadHeaderDeneb{})
 			}
 			payloadProof = emptyPayloadProof()
 		} else {

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.ExecutionPayloadHeaderElectra{
+			executionHeader := &v11.ExecutionPayloadHeaderDeneb{
 				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.ExecutionPayloadHeaderElectra{
+			executionHeader := &v11.ExecutionPayloadHeaderDeneb{
 				ParentHash:       payload.ParentHash(),
 				FeeRecipient:     payload.FeeRecipient(),
 				StateRoot:        payload.StateRoot(),

beacon-chain/core/time/slot_epoch.go

@@ -99,6 +99,15 @@ 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,6 +1,7 @@
 package time_test
 
 import (
+	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
@@ -264,107 +265,69 @@ func TestAltairCompatible(t *testing.T) {
 	}
 }
 
-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: "not epoch start",
-			slot: 1,
-			want: false,
-		},
-		{
-			name: "not capella epoch",
-			slot: params.BeaconConfig().SlotsPerEpoch,
-			want: false,
-		},
-		{
-			name: "capella epoch",
-			slot: primitives.Slot(params.BeaconConfig().CapellaForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
-			want: true,
-		},
-	}
-	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 TestCanUpgradeTo(t *testing.T) {
+	beaconConfig := params.BeaconConfig()
 
-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
+	outerTestCases := []struct {
+		name        string
+		forkEpoch   *primitives.Epoch
+		upgradeFunc func(primitives.Slot) bool
 	}{
 		{
-			name: "not epoch start",
-			slot: 1,
-			want: false,
+			name:        "Capella",
+			forkEpoch:   &beaconConfig.CapellaForkEpoch,
+			upgradeFunc: time.CanUpgradeToCapella,
 		},
 		{
-			name: "not deneb epoch",
-			slot: params.BeaconConfig().SlotsPerEpoch,
-			want: false,
+			name:        "Deneb",
+			forkEpoch:   &beaconConfig.DenebForkEpoch,
+			upgradeFunc: time.CanUpgradeToDeneb,
 		},
 		{
-			name: "deneb epoch",
-			slot: primitives.Slot(params.BeaconConfig().DenebForkEpoch) * params.BeaconConfig().SlotsPerEpoch,
-			want: true,
+			name:        "Electra",
+			forkEpoch:   &beaconConfig.ElectraForkEpoch,
+			upgradeFunc: time.CanUpgradeToElectra,
+		},
+		{
+			name:        "Fulu",
+			forkEpoch:   &beaconConfig.FuluForkEpoch,
+			upgradeFunc: time.CanUpgradeToFulu,
 		},
 	}
-	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)
-			}
-		})
+	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)
+				}
+			})
+		}
 	}
 }

beacon-chain/core/transition/BUILD.bazel

@@ -23,6 +23,7 @@ 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,6 +17,7 @@ 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"
@@ -298,7 +299,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())))
 			}
@@ -322,9 +323,11 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 	defer span.End()
 
 	var err error
+
+	slot := state.Slot()
 	upgraded := false
 
-	if time.CanUpgradeToAltair(state.Slot()) {
+	if time.CanUpgradeToAltair(slot) {
 		state, err = altair.UpgradeToAltair(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -333,7 +336,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToBellatrix(state.Slot()) {
+	if time.CanUpgradeToBellatrix(slot) {
 		state, err = execution.UpgradeToBellatrix(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -342,7 +345,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToCapella(state.Slot()) {
+	if time.CanUpgradeToCapella(slot) {
 		state, err = capella.UpgradeToCapella(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -351,7 +354,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToDeneb(state.Slot()) {
+	if time.CanUpgradeToDeneb(slot) {
 		state, err = deneb.UpgradeToDeneb(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -360,7 +363,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
-	if time.CanUpgradeToElectra(state.Slot()) {
+	if time.CanUpgradeToElectra(slot) {
 		state, err = electra.UpgradeToElectra(state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
@@ -369,8 +372,17 @@ 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.Debugf("upgraded state to %s", version.String(state.Version()))
+		log.WithField("version", version.String(state.Version())).Info("Upgraded state to")
 	}
 
 	return state, nil

beacon-chain/core/transition/transition_test.go

@@ -665,6 +665,20 @@ 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,25 +9,35 @@ import (
 // SlashingParamsPerVersion returns the slashing parameters for the given state version.
 func SlashingParamsPerVersion(v int) (slashingQuotient, proposerRewardQuotient, whistleblowerRewardQuotient uint64, err error) {
 	cfg := params.BeaconConfig()
-	switch v {
-	case version.Phase0:
-		slashingQuotient = cfg.MinSlashingPenaltyQuotient
-		proposerRewardQuotient = cfg.ProposerRewardQuotient
-		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
-	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:
+
+	if v >= version.Electra {
 		slashingQuotient = cfg.MinSlashingPenaltyQuotientElectra
 		proposerRewardQuotient = cfg.ProposerRewardQuotient
 		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotientElectra
-	default:
-		err = errors.New("unknown state version")
+		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 {
+		slashingQuotient = cfg.MinSlashingPenaltyQuotient
+		proposerRewardQuotient = cfg.ProposerRewardQuotient
+		whistleblowerRewardQuotient = cfg.WhistleBlowerRewardQuotient
+		return
+	}
+
+	err = errors.Errorf("unknown state version %s", version.String(v))
 	return
 }

beacon-chain/core/validators/validator_test.go

@@ -217,6 +217,7 @@ func TestSlashValidator_OK(t *testing.T) {
 }
 
 func TestSlashValidator_Electra(t *testing.T) {
+	helpers.ClearCache()
 	validatorCount := 100
 	registry := make([]*ethpb.Validator, 0, validatorCount)
 	balances := make([]uint64, 0, validatorCount)

beacon-chain/das/BUILD.bazel

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

beacon-chain/das/availability.go

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

beacon-chain/das/availability_test.go

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

beacon-chain/das/cache.go

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

beacon-chain/das/cache_test.go

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

beacon-chain/db/filesystem/BUILD.bazel

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

beacon-chain/db/filesystem/blob.go

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

beacon-chain/db/filesystem/blob_test.go

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

beacon-chain/db/filesystem/cache.go

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

beacon-chain/db/filesystem/cache_test.go

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

beacon-chain/db/filesystem/pruner_test.go

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

beacon-chain/db/kv/BUILD.bazel

@@ -41,6 +41,7 @@ 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,6 +823,16 @@ 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{}
@@ -851,32 +861,50 @@ func encodeBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
 }
 
 func keyForBlock(blk interfaces.ReadOnlySignedBeaconBlock) ([]byte, error) {
-	switch blk.Version() {
-	case version.Electra:
+	v := blk.Version()
+
+	if v >= version.Fulu {
+		if blk.IsBlinded() {
+			return fuluBlindKey, nil
+		}
+		return fuluKey, nil
+	}
+
+	if v >= version.Electra {
 		if blk.IsBlinded() {
 			return electraBlindKey, nil
 		}
 		return electraKey, nil
-	case version.Deneb:
+	}
+
+	if v >= version.Deneb {
 		if blk.IsBlinded() {
 			return denebBlindKey, nil
 		}
 		return denebKey, nil
-	case version.Capella:
+	}
+
+	if v >= version.Capella {
 		if blk.IsBlinded() {
 			return capellaBlindKey, nil
 		}
 		return capellaKey, nil
-	case version.Bellatrix:
+	}
+
+	if v >= version.Bellatrix {
 		if blk.IsBlinded() {
 			return bellatrixBlindKey, nil
 		}
 		return bellatrixKey, nil
-	case version.Altair:
-		return altairKey, nil
-	case version.Phase0:
-		return nil, nil
-	default:
-		return nil, fmt.Errorf("unsupported block version: %v", blk.Version())
 	}
+
+	if v >= version.Altair {
+		return altairKey, nil
+	}
+
+	if v >= version.Phase0 {
+		return nil, nil
+	}
+
+	return nil, fmt.Errorf("unsupported block version: %v", blk.Version())
 }

beacon-chain/db/kv/key.go

@@ -65,3 +65,17 @@ 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,6 +109,7 @@ var Buckets = [][]byte{
 	stateValidatorsBucket,
 	lightClientUpdatesBucket,
 	lightClientBootstrapBucket,
+	lightClientSyncCommitteeBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,

beacon-chain/db/kv/lightclient.go

@@ -7,6 +7,8 @@ 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"
@@ -35,9 +37,35 @@ 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(bootstrap)
+		enc, err := encodeLightClientBootstrap(bootstrapCopy, syncCommitteeHash)
 		if err != nil {
 			return err
 		}
@@ -50,20 +78,49 @@ 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, err = decodeLightClientBootstrap(enc)
+		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")
+		}
 		return err
 	})
 	return bootstrap, err
 }
 
-func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap) ([]byte, error) {
+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) {
 	key, err := keyForLightClientUpdate(bootstrap.Version())
 	if err != nil {
 		return nil, err
@@ -72,48 +129,56 @@ func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap) ([]by
 	if err != nil {
 		return nil, errors.Wrap(err, "could not marshal light client bootstrap")
 	}
-	fullEnc := make([]byte, len(key)+len(enc))
+	fullEnc := make([]byte, len(key)+32+len(enc))
 	copy(fullEnc, key)
-	copy(fullEnc[len(key):], enc)
-	return snappy.Encode(nil, fullEnc), nil
+	copy(fullEnc[len(key):len(key)+32], syncCommitteeHash[:])
+	copy(fullEnc[len(key)+32:], enc)
+	compressedEnc := snappy.Encode(nil, fullEnc)
+	return compressedEnc, nil
 }
 
-func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, error) {
+func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, []byte, error) {
 	var err error
 	enc, err = snappy.Decode(nil, enc)
 	if err != nil {
-		return nil, errors.Wrap(err, "could not snappy decode light client bootstrap")
+		return nil, 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):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Altair light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(altairKey)+32:]); err != nil {
+			return nil, 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):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Capella light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(capellaKey)+32:]); err != nil {
+			return nil, 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):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Deneb light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(denebKey)+32:]); err != nil {
+			return nil, 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):]); err != nil {
-			return nil, errors.Wrap(err, "could not unmarshal Electra light client bootstrap")
+		if err := bootstrap.UnmarshalSSZ(enc[len(electraKey)+32:]); err != nil {
+			return nil, nil, errors.Wrap(err, "could not unmarshal Electra light client bootstrap")
 		}
 		m = bootstrap
+		syncCommitteeHash = enc[len(electraKey) : len(electraKey)+32]
 	default:
-		return nil, errors.New("decoding of saved light client bootstrap is unsupported")
+		return nil, nil, errors.New("decoding of saved light client bootstrap is unsupported")
 	}
-	return light_client.NewWrappedBootstrap(m)
+	bootstrap, err := light_client.NewWrappedBootstrap(m)
+	return bootstrap, syncCommitteeHash, err
 }
 
 func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error) {

beacon-chain/db/kv/lightclient_test.go

@@ -18,6 +18,7 @@ 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"
 )
 
@@ -122,7 +123,7 @@ func createUpdate(t *testing.T, v int) (interfaces.LightClientUpdate, error) {
 				StateRoot:     sampleRoot,
 				BodyRoot:      sampleRoot,
 			},
-			Execution: &enginev1.ExecutionPayloadHeaderElectra{
+			Execution: &enginev1.ExecutionPayloadHeaderDeneb{
 				ParentHash:       make([]byte, fieldparams.RootLength),
 				FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
 				StateRoot:        make([]byte, fieldparams.RootLength),
@@ -140,6 +141,34 @@ 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))
 	}
@@ -167,6 +196,7 @@ 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)
@@ -213,6 +243,17 @@ 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")
@@ -539,3 +580,377 @@ func createDefaultLightClientUpdate(currentSlot primitives.Slot, attestedState s
 
 	return light_client.NewWrappedUpdate(m)
 }
+
+func TestStore_LightClientBootstrap_CanSaveRetrieve(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()
+
+	t.Run("Nil", func(t *testing.T) {
+		retrievedBootstrap, err := db.LightClientBootstrap(ctx, []byte("NilBlockRoot"))
+		require.NoError(t, err)
+		require.IsNil(t, retrievedBootstrap)
+	})
+
+	t.Run("Altair", func(t *testing.T) {
+		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().AltairForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
+		require.NoError(t, err)
+
+		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
+		require.NoError(t, err)
+
+		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootAltair"), bootstrap)
+		require.NoError(t, err)
+
+		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")
+	})
+
+	t.Run("Capella", func(t *testing.T) {
+		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().CapellaForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
+		require.NoError(t, err)
+
+		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
+		require.NoError(t, err)
+
+		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootCapella"), bootstrap)
+		require.NoError(t, err)
+
+		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")
+	})
+
+	t.Run("Deneb", func(t *testing.T) {
+		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().DenebForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
+		require.NoError(t, err)
+
+		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
+		require.NoError(t, err)
+
+		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootDeneb"), bootstrap)
+		require.NoError(t, err)
+
+		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")
+	})
+
+	t.Run("Electra", func(t *testing.T) {
+		bootstrap, err := createDefaultLightClientBootstrap(primitives.Slot(uint64(params.BeaconConfig().ElectraForkEpoch) * uint64(params.BeaconConfig().SlotsPerEpoch)))
+		require.NoError(t, err)
+
+		err = bootstrap.SetCurrentSyncCommittee(createRandomSyncCommittee())
+		require.NoError(t, err)
+
+		err = db.SaveLightClientBootstrap(ctx, []byte("blockRootElectra"), bootstrap)
+		require.NoError(t, err)
+
+		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")
+	})
+}
+
+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
+	pubKeys := make([][]byte, syncCommitteeSize)
+	for i := uint64(0); i < syncCommitteeSize; i++ {
+		pubKeys[i] = make([]byte, fieldparams.BLSPubkeyLength)
+	}
+	currentSyncCommittee := &pb.SyncCommittee{
+		Pubkeys:         pubKeys,
+		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
+	}
+
+	var currentSyncCommitteeBranch [][]byte
+	if currentEpoch >= params.BeaconConfig().ElectraForkEpoch {
+		currentSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepthElectra)
+	} else {
+		currentSyncCommitteeBranch = make([][]byte, fieldparams.SyncCommitteeBranchDepth)
+	}
+	for i := 0; i < len(currentSyncCommitteeBranch); i++ {
+		currentSyncCommitteeBranch[i] = make([]byte, fieldparams.RootLength)
+	}
+
+	executionBranch := make([][]byte, fieldparams.ExecutionBranchDepth)
+	for i := 0; i < fieldparams.ExecutionBranchDepth; i++ {
+		executionBranch[i] = make([]byte, 32)
+	}
+
+	// TODO: can this be based on the current epoch?
+	var m proto.Message
+	if currentEpoch < params.BeaconConfig().CapellaForkEpoch {
+		m = &pb.LightClientBootstrapAltair{
+			Header: &pb.LightClientHeaderAltair{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	} else if currentEpoch < params.BeaconConfig().DenebForkEpoch {
+		m = &pb.LightClientBootstrapCapella{
+			Header: &pb.LightClientHeaderCapella{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				Execution: &enginev1.ExecutionPayloadHeaderCapella{
+					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: executionBranch,
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	} else if currentEpoch < params.BeaconConfig().ElectraForkEpoch {
+		m = &pb.LightClientBootstrapDeneb{
+			Header: &pb.LightClientHeaderDeneb{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				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),
+					GasLimit:         0,
+					GasUsed:          0,
+				},
+				ExecutionBranch: executionBranch,
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	} else {
+		m = &pb.LightClientBootstrapElectra{
+			Header: &pb.LightClientHeaderDeneb{
+				Beacon: &pb.BeaconBlockHeader{
+					ParentRoot: make([]byte, 32),
+					StateRoot:  make([]byte, 32),
+					BodyRoot:   make([]byte, 32),
+				},
+				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),
+					GasLimit:         0,
+					GasUsed:          0,
+				},
+				ExecutionBranch: executionBranch,
+			},
+			CurrentSyncCommittee:       currentSyncCommittee,
+			CurrentSyncCommitteeBranch: currentSyncCommitteeBranch,
+		}
+	}
+
+	return light_client.NewWrappedBootstrap(m)
+}
+
+func createRandomSyncCommittee() *pb.SyncCommittee {
+	// random number between 2 and 128
+	base := rand.Int()%127 + 2
+
+	syncCom := make([][]byte, params.BeaconConfig().SyncCommitteeSize)
+	for i := 0; uint64(i) < params.BeaconConfig().SyncCommitteeSize; i++ {
+		if i%base == 0 {
+			syncCom[i] = make([]byte, fieldparams.BLSPubkeyLength)
+			syncCom[i][0] = 1
+			continue
+		}
+		syncCom[i] = make([]byte, fieldparams.BLSPubkeyLength)
+	}
+
+	return &pb.SyncCommittee{
+		Pubkeys:         syncCom,
+		AggregatePubkey: make([]byte, fieldparams.BLSPubkeyLength),
+	}
+}

beacon-chain/db/kv/schema.go

@@ -18,8 +18,9 @@ var (
 	registrationBucket    = []byte("registration")
 
 	// Light Client Updates Bucket
-	lightClientUpdatesBucket   = []byte("light-client-updates")
-	lightClientBootstrapBucket = []byte("light-client-bootstrap")
+	lightClientUpdatesBucket       = []byte("light-client-updates")
+	lightClientBootstrapBucket     = []byte("light-client-bootstrap")
+	lightClientSyncCommitteeBucket = []byte("light-client-sync-committee")
 
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")
@@ -54,6 +55,8 @@ 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

@@ -676,6 +676,19 @@ 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

@@ -2,8 +2,10 @@ package kv
 
 import (
 	"context"
+	"crypto/rand"
 	"encoding/binary"
-	"math/rand"
+	mathRand "math/rand"
+
 	"strconv"
 	"testing"
 	"time"
@@ -137,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.WrappedExecutionPayloadHeaderElectra(&enginev1.ExecutionPayloadHeaderElectra{
+				p, err := blocks.WrappedExecutionPayloadHeaderDeneb(&enginev1.ExecutionPayloadHeaderDeneb{
 					ParentHash:       make([]byte, 32),
 					FeeRecipient:     make([]byte, 20),
 					StateRoot:        make([]byte, 32),
@@ -878,16 +880,16 @@ func validators(limit int) []*ethpb.Validator {
 	var vals []*ethpb.Validator
 	for i := 0; i < limit; i++ {
 		pubKey := make([]byte, params.BeaconConfig().BLSPubkeyLength)
-		binary.LittleEndian.PutUint64(pubKey, rand.Uint64())
+		binary.LittleEndian.PutUint64(pubKey, mathRand.Uint64())
 		val := &ethpb.Validator{
 			PublicKey:                  pubKey,
-			WithdrawalCredentials:      bytesutil.ToBytes(rand.Uint64(), 32),
-			EffectiveBalance:           rand.Uint64(),
+			WithdrawalCredentials:      bytesutil.ToBytes(mathRand.Uint64(), 32),
+			EffectiveBalance:           mathRand.Uint64(),
 			Slashed:                    i%2 != 0,
-			ActivationEligibilityEpoch: primitives.Epoch(rand.Uint64()),
-			ActivationEpoch:            primitives.Epoch(rand.Uint64()),
-			ExitEpoch:                  primitives.Epoch(rand.Uint64()),
-			WithdrawableEpoch:          primitives.Epoch(rand.Uint64()),
+			ActivationEligibilityEpoch: primitives.Epoch(mathRand.Uint64()),
+			ActivationEpoch:            primitives.Epoch(mathRand.Uint64()),
+			ExitEpoch:                  primitives.Epoch(mathRand.Uint64()),
+			WithdrawableEpoch:          primitives.Epoch(mathRand.Uint64()),
 		}
 		vals = append(vals, val)
 	}
@@ -913,8 +915,8 @@ func checkStateSaveTime(b *testing.B, saveCount int) {
 		allValidators := append(initialSetOfValidators, validatosToAddInTest...)
 
 		// shuffle validators.
-		rand.Seed(time.Now().UnixNano())
-		rand.Shuffle(len(allValidators), func(i, j int) { allValidators[i], allValidators[j] = allValidators[j], allValidators[i] })
+		mathRand.New(mathRand.NewSource(time.Now().UnixNano()))
+		mathRand.Shuffle(len(allValidators), func(i, j int) { allValidators[i], allValidators[j] = allValidators[j], allValidators[i] })
 
 		require.NoError(b, st.SetValidators(allValidators))
 		require.NoError(b, db.SaveState(context.Background(), st, bytesutil.ToBytes32(key)))
@@ -959,8 +961,8 @@ func checkStateReadTime(b *testing.B, saveCount int) {
 		allValidators := append(initialSetOfValidators, validatosToAddInTest...)
 
 		// shuffle validators.
-		rand.Seed(time.Now().UnixNano())
-		rand.Shuffle(len(allValidators), func(i, j int) { allValidators[i], allValidators[j] = allValidators[j], allValidators[i] })
+		mathRand.New(mathRand.NewSource(time.Now().UnixNano()))
+		mathRand.Shuffle(len(allValidators), func(i, j int) { allValidators[i], allValidators[j] = allValidators[j], allValidators[i] })
 
 		require.NoError(b, st.SetValidators(allValidators))
 		require.NoError(b, db.SaveState(context.Background(), st, bytesutil.ToBytes32(key)))

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,6 +12,7 @@ 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"
@@ -44,7 +45,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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 	testAcc.Backend.Commit()
 
@@ -141,7 +142,7 @@ func TestBlockExists_ValidHash(t *testing.T) {
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	testAcc.Backend.Commit()
-	block, err := testAcc.Backend.BlockByNumber(context.Background(), big.NewInt(0))
+	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), big.NewInt(0))
 	assert.NoError(t, err)
 
 	exists, height, err := web3Service.BlockExists(context.Background(), block.Hash())
@@ -201,8 +202,10 @@ 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)
@@ -216,16 +219,22 @@ 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()
 	}
-	ctx := context.Background()
-	hd, err := testAcc.Backend.HeaderByNumber(ctx, nil)
+
+	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
 	web3Service.latestEth1Data.BlockHeight = hd.Number.Uint64()
-	blk, err := web3Service.BlockByTimestamp(ctx, 1000 /* time */)
+	blk, err := web3Service.BlockByTimestamp(ctx, initialHead.Time+100 /* 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")
@@ -253,7 +262,7 @@ func TestService_BlockNumberByTimestampLessTargetTime(t *testing.T) {
 		testAcc.Backend.Commit()
 	}
 	ctx := context.Background()
-	hd, err := testAcc.Backend.HeaderByNumber(ctx, nil)
+	hd, err := testAcc.Backend.Client().HeaderByNumber(ctx, nil)
 	require.NoError(t, err)
 	web3Service.latestEth1Data.BlockTime = hd.Time
 	// Use extremely small deadline to illustrate that context deadlines are respected.
@@ -291,7 +300,7 @@ func TestService_BlockNumberByTimestampMoreTargetTime(t *testing.T) {
 		testAcc.Backend.Commit()
 	}
 	ctx := context.Background()
-	hd, err := testAcc.Backend.HeaderByNumber(ctx, nil)
+	hd, err := testAcc.Backend.Client().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

@@ -136,30 +136,18 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 	defer cancel()
 	result := &pb.PayloadStatus{}
 
-	switch payload.Proto().(type) {
+	switch payloadPb := payload.Proto().(type) {
 	case *pb.ExecutionPayload:
-		payloadPb, ok := payload.Proto().(*pb.ExecutionPayload)
-		if !ok {
-			return nil, errors.New("execution data must be a Bellatrix or Capella execution payload")
-		}
 		err := s.rpcClient.CallContext(ctx, result, NewPayloadMethod, payloadPb)
 		if err != nil {
 			return nil, handleRPCError(err)
 		}
 	case *pb.ExecutionPayloadCapella:
-		payloadPb, ok := payload.Proto().(*pb.ExecutionPayloadCapella)
-		if !ok {
-			return nil, errors.New("execution data must be a Capella execution payload")
-		}
 		err := s.rpcClient.CallContext(ctx, result, NewPayloadMethodV2, payloadPb)
 		if err != nil {
 			return nil, handleRPCError(err)
 		}
 	case *pb.ExecutionPayloadDeneb:
-		payloadPb, ok := payload.Proto().(*pb.ExecutionPayloadDeneb)
-		if !ok {
-			return nil, errors.New("execution data must be a Deneb execution payload")
-		}
 		if executionRequests == nil {
 			err := s.rpcClient.CallContext(ctx, result, NewPayloadMethodV3, payloadPb, versionedHashes, parentBlockRoot)
 			if err != nil {
@@ -233,7 +221,7 @@ func (s *Service) ForkchoiceUpdated(
 		if err != nil {
 			return nil, nil, handleRPCError(err)
 		}
-	case version.Deneb, version.Electra:
+	case version.Deneb, version.Electra, version.Fulu:
 		a, err := attrs.PbV3()
 		if err != nil {
 			return nil, nil, err
@@ -643,43 +631,7 @@ func fullPayloadFromPayloadBody(
 		return nil, errors.New("execution block and header cannot be nil")
 	}
 
-	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:
+	if bVersion >= version.Deneb {
 		ebg, err := header.ExcessBlobGas()
 		if err != nil {
 			return nil, errors.Wrap(err, "unable to extract ExcessBlobGas attribute from execution payload header")
@@ -708,9 +660,48 @@ 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.
@@ -802,35 +793,7 @@ func tDStringToUint256(td string) (*uint256.Int, error) {
 }
 
 func EmptyExecutionPayload(v int) (proto.Message, error) {
-	switch v {
-	case version.Bellatrix:
-		return &pb.ExecutionPayload{
-			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),
-			Transactions:  make([][]byte, 0),
-		}, nil
-	case version.Capella:
-		return &pb.ExecutionPayloadCapella{
-			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),
-			Transactions:  make([][]byte, 0),
-			Withdrawals:   make([]*pb.Withdrawal, 0),
-		}, nil
-	case version.Deneb, version.Electra:
+	if v >= version.Deneb {
 		return &pb.ExecutionPayloadDeneb{
 			ParentHash:    make([]byte, fieldparams.RootLength),
 			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
@@ -844,9 +807,90 @@ func EmptyExecutionPayload(v int) (proto.Message, error) {
 			Transactions:  make([][]byte, 0),
 			Withdrawals:   make([]*pb.Withdrawal, 0),
 		}, nil
-	default:
-		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
 	}
+
+	if v >= version.Capella {
+		return &pb.ExecutionPayloadCapella{
+			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),
+			Transactions:  make([][]byte, 0),
+			Withdrawals:   make([]*pb.Withdrawal, 0),
+		}, nil
+	}
+
+	if v >= version.Bellatrix {
+		return &pb.ExecutionPayload{
+			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),
+			Transactions:  make([][]byte, 0),
+		}, nil
+	}
+
+	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),
+		}, nil
+	}
+
+	if v >= version.Capella {
+		return &pb.ExecutionPayloadHeaderCapella{
+			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
+	}
+
+	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),
+		}, nil
+	}
+
+	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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -72,7 +72,7 @@ func TestProcessDepositLog_OK(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.Client().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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -144,7 +144,7 @@ func TestProcessDepositLog_InsertsPendingDeposit(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.Client().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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -199,7 +199,7 @@ func TestUnpackDepositLogData_OK(t *testing.T) {
 		},
 	}
 
-	logz, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
+	logz, err := testAcc.Backend.Client().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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
 	params.SetupTestConfigCleanup(t)
@@ -269,7 +269,7 @@ func TestProcessETH2GenesisLog_8DuplicatePubkeys(t *testing.T) {
 		},
 	}
 
-	logs, err := testAcc.Backend.FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.Client().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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	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.FilterLogs(web3Service.ctx, query)
+	logs, err := testAcc.Backend.Client().FilterLogs(web3Service.ctx, query)
 	require.NoError(t, err, "Unable to retrieve logs")
 	require.Equal(t, depositsReqForChainStart, len(logs))
 
@@ -400,16 +400,18 @@ 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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.httpLogger = testAcc.Backend
+	web3Service.httpLogger = testAcc.Backend.Client()
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
+	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
+	web3Service.latestEth1Data.BlockTime = block.Time()
 	bConfig := params.MinimalSpecConfig().Copy()
 	bConfig.MinGenesisTime = 0
-	bConfig.SecondsPerETH1Block = 10
+	bConfig.SecondsPerETH1Block = 1
 	params.OverrideBeaconConfig(bConfig)
 	nConfig := params.BeaconNetworkConfig()
 	nConfig.ContractDeploymentBlock = 0
@@ -444,8 +446,10 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
+	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
+	web3Service.latestEth1Data.BlockTime = b.Time()
 
 	// Set up our subscriber now to listen for the chain started event.
 	stateChannel := make(chan *feed.Event, 1)
@@ -497,13 +501,15 @@ 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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.httpLogger = testAcc.Backend
+	web3Service.httpLogger = testAcc.Backend.Client()
 	web3Service.latestEth1Data.LastRequestedBlock = 0
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
+	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
+	web3Service.latestEth1Data.BlockTime = b.Time()
 	bConfig := params.MinimalSpecConfig().Copy()
 	bConfig.SecondsPerETH1Block = 10
 	params.OverrideBeaconConfig(bConfig)
@@ -540,14 +546,19 @@ func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	for i := uint64(0); i < 1500; i++ {
 		testAcc.Backend.Commit()
 	}
-	wantedGenesisTime := testAcc.Backend.Blockchain().CurrentBlock().Time
+	genesisBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+
+	wantedGenesisTime := genesisBlock.Time()
 
 	// Forward the chain to account for the follow distance
 	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
 		testAcc.Backend.Commit()
 	}
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
+	currBlock, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = currBlock.NumberU64()
+	web3Service.latestEth1Data.BlockTime = currBlock.Time()
 
 	// Set the genesis time 500 blocks ahead of the last
 	// deposit log.
@@ -608,7 +619,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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(eth1Backend.ContractAddr, eth1Backend.Backend.Client())
 	require.NoError(t, err)
 
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: eth1Backend.Backend}

beacon-chain/execution/payload_body_test.go

@@ -17,14 +17,6 @@ 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()
@@ -45,6 +37,7 @@ type blindedBlockFixtures struct {
 	emptyDenebBlock *fullAndBlinded
 	afterSkipDeneb  *fullAndBlinded
 	electra         *fullAndBlinded
+	fulu            *fullAndBlinded
 }
 
 type fullAndBlinded struct {
@@ -77,6 +70,12 @@ 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{}
@@ -104,11 +103,18 @@ 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.HackElectraMaxuint(t)()
+	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
 	fx := testBlindedBlockFixtures(t)
 	t.Run("mix of non-empty and empty", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
@@ -145,7 +151,7 @@ func TestPayloadBodiesViaUnblinder(t *testing.T) {
 }
 
 func TestFixtureEquivalence(t *testing.T) {
-	defer util.HackElectraMaxuint(t)()
+	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
 	fx := testBlindedBlockFixtures(t)
 	t.Run("full and blinded block equivalence", func(t *testing.T) {
 		testAssertReconstructedEquivalent(t, fx.denebBlock.blinded.block, fx.denebBlock.full)
@@ -248,7 +254,7 @@ func TestComputeRanges(t *testing.T) {
 }
 
 func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
-	defer util.HackElectraMaxuint(t)()
+	defer util.HackForksMaxuint(t, []int{version.Electra, version.Fulu})()
 	ctx := context.Background()
 	t.Run("fallback fails", func(t *testing.T) {
 		cli, srv := newMockEngine(t)
@@ -333,18 +339,19 @@ func TestReconstructBlindedBlockBatchFallbackToRange(t *testing.T) {
 	})
 }
 
-func TestReconstructBlindedBlockBatchDenebAndElectra(t *testing.T) {
-	defer util.HackElectraMaxuint(t)()
-	t.Run("deneb and electra", func(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) {
 		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)}
+			executionPayloadBodies := []*pb.ExecutionPayloadBody{payloadToBody(t, fx.denebBlock.blinded.header), payloadToBody(t, fx.electra.blinded.header), payloadToBody(t, fx.fulu.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 *backends.SimulatedBackend
+	backend *simulated.Backend
 }
 
 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.SubscribeFilterLogs(ctx, q, ch)
+	return g.backend.Client().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.FilterLogs(ctx, q)
+	return g.backend.Client().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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
 	testAcc.Backend.Commit()
@@ -186,10 +186,12 @@ 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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
-	currTime := testAcc.Backend.Blockchain().CurrentHeader().Time
+	header, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	currTime := header.Time
 	now := time.Now()
 	assert.NoError(t, testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0))))
 	testAcc.Backend.Commit()
@@ -212,22 +214,29 @@ 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 = 10
+	conf.SecondsPerETH1Block = 1
 	params.OverrideBeaconConfig(conf)
 
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	baseHeight := testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
+	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	baseHeight := block.NumberU64()
 	// process follow_distance blocks
+	var lastHash common.Hash
 	for i := 0; i < int(params.BeaconConfig().Eth1FollowDistance); i++ {
-		testAcc.Backend.Commit()
+		lastHash = testAcc.Backend.Commit()
 	}
+	lb, err := testAcc.Backend.Client().BlockByHash(context.Background(), lastHash)
+	require.NoError(t, err)
+	log.Println(lb.NumberU64())
 	// set current height
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
+	block, err = testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
+	web3Service.latestEth1Data.BlockTime = block.Time()
 
 	h, err := web3Service.followedBlockHeight(context.Background())
 	require.NoError(t, err)
@@ -238,9 +247,12 @@ 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 = testAcc.Backend.Blockchain().CurrentBlock().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentBlock().Time
+	web3Service.latestEth1Data.BlockHeight = newBlock.NumberU64()
+	web3Service.latestEth1Data.BlockTime = newBlock.Time()
 
 	h, err = web3Service.followedBlockHeight(context.Background())
 	require.NoError(t, err)
@@ -325,11 +337,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)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
 	require.NoError(t, err)
 
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
-	web3Service.httpLogger = testAcc.Backend
+	web3Service.httpLogger = testAcc.Backend.Client()
 	for i := 0; i < 30; i++ {
 		testAcc.Backend.Commit()
 	}
@@ -485,15 +497,18 @@ func TestNewService_EarliestVotingBlock(t *testing.T) {
 	for i := 0; i < numToForward; i++ {
 		testAcc.Backend.Commit()
 	}
-	currTime := testAcc.Backend.Blockchain().CurrentHeader().Time
+	currHeader, err := testAcc.Backend.Client().HeaderByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	currTime := currHeader.Time
 	now := time.Now()
 	err = testAcc.Backend.AdjustTime(now.Sub(time.Unix(int64(currTime), 0)))
 	require.NoError(t, err)
 	testAcc.Backend.Commit()
-
-	currTime = testAcc.Backend.Blockchain().CurrentHeader().Time
-	web3Service.latestEth1Data.BlockHeight = testAcc.Backend.Blockchain().CurrentHeader().Number.Uint64()
-	web3Service.latestEth1Data.BlockTime = testAcc.Backend.Blockchain().CurrentHeader().Time
+	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
 	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",