Add debug log when downcoring a peer for bad response.

* Add a log before filesystem cache warm-up.

* Log `Successfully registered validator(s) on builder` ==> Debug.

CHANGELOG.md

@@ -4,7 +4,56 @@ 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.
+- Debug log when downscoring a peer for bad response reason.
+
+### 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.
+
+### Deprecated
+
+
+### Removed
+
+
+### Fixed
+
+- Added check to prevent nil pointer deference or out of bounds array access when validating the BLSToExecutionChange on an impossibly nil validator.
+
+### Security
+
+
+## [v5.2.0](https://github.com/prysmaticlabs/prysm/compare/v5.1.2...v5.2.0)
+
+Updating to this release is highly recommended, especially for users running v5.1.1 or v5.1.2.
+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
 
@@ -30,6 +79,10 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Better attestation packing for Electra. [PR](https://github.com/prysmaticlabs/prysm/pull/14534)
 - P2P: Add logs when a peer is (dis)connected. Add the reason of the disconnection when we initiate it.
 - Added a Prometheus error counter metric for HTTP requests to track beacon node requests.
+- Added a Prometheus error counter metric for SSE requests.
+- Save light client updates and bootstraps in DB.
+- Added more comprehensive tests for `BlockToLightClientHeader`. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
+- Added light client feature flag check to RPC handlers. [PR](https://github.com/prysmaticlabs/prysm/pull/14736)
 
 ### Changed
 
@@ -64,19 +117,28 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - Updated light client protobufs. [PR](https://github.com/prysmaticlabs/prysm/pull/14650)
 - Added `Eth-Consensus-Version` header to `ListAttestationsV2` and `GetAggregateAttestationV2` endpoints.
 - Updated light client consensus types. [PR](https://github.com/prysmaticlabs/prysm/pull/14652)
+- Update earliest exit epoch for upgrade to electra
+- Add missed exit checks to consolidation processing
 - Fixed pending deposits processing on Electra.
 - Modified `ListAttestationsV2`, `GetAttesterSlashingsV2` and `GetAggregateAttestationV2` endpoints to use slot to determine fork version.
 - Improvements to HTTP response handling. [pr](https://github.com/prysmaticlabs/prysm/pull/14673)
+- Updated `Blobs` endpoint to return additional metadata fields.
+- Made QUIC the default method to connect with peers.
+- Check kzg commitments align with blobs and proofs for beacon api end point.
+- Revert "Proposer checks gas limit before accepting builder's bid".
+- Updated quic-go to v0.48.2 .
 
 ### Deprecated
 
 - `/eth/v1alpha1/validator/activation/stream` grpc wait for activation stream is deprecated. [pr](https://github.com/prysmaticlabs/prysm/pull/14514)
+- `--interop-genesis-time` and `--interop-num-validators` have been deprecated in the beacon node as the functionality has been removed. These flags have no effect.
 
 ### Removed
 
 - Removed finalized validator index cache, no longer needed.
 - Removed validator queue position log on key reload and wait for activation.
 - Removed outdated spectest exclusions for EIP-6110.
+- Removed support for starting a beacon node with a deterministic interop genesis state via interop flags. Alteratively, create a genesis state with prysmctl and use `--genesis-state`. This removes about 9Mb (~11%) of unnecessary code and dependencies from the final production binary.
 - Removed kzg proof check from blob reconstructor.
 
 ### Fixed
@@ -98,8 +160,14 @@ The format is based on Keep a Changelog, and this project adheres to Semantic Ve
 - corrects nil check on some interface attestation types
 - temporary solution to handling electra attesation and attester_slashing events. [pr](14655)
 - Diverse log improvements and comment additions.
+- Validate that each committee bitfield in an aggregate contains at least one non-zero bit
 - P2P: Avoid infinite loop when looking for peers in small networks.
-
+- Fixed another rollback bug due to a context deadline.
+- Fix checkpoint sync bug on holesky. [pr](https://github.com/prysmaticlabs/prysm/pull/14689)
+- Fix proposer boost spec tests being flakey by adjusting start time from 3 to 2s into slot.
+- Fix segmentation fault in E2E when light-client feature flag is enabled. [PR](https://github.com/prysmaticlabs/prysm/pull/14699)
+- Fix `searchForPeers` infinite loop in small networks.
+- Fix slashing pool behavior to enforce MaxAttesterSlashings limit in Electra version.
 
 ### Security
 
@@ -424,6 +492,7 @@ block profit. If you want to preserve the existing behavior, set --local-block-v
 - Set default LocalBlockValueBoost to 10
 - Add bid value metrics
 - REST VC metrics
+- `startDB`: Add log when checkpoint sync.
 
 ### Changed
 

CONTRIBUTING.md

@@ -129,7 +129,7 @@ If your change is user facing, you must include a CHANGELOG.md entry. See the [M
 
 **17. Create a pull request.**
 
-Navigate your browser to https://github.com/prysmaticlabs/prysm and click on the new pull request button. In the “base” box on the left, leave the default selection “base 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

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

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.8"
+consensus_spec_version = "v1.5.0-alpha.9"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-BsGIbEyJuYrzhShGl0tHhR4lP5Qwno8R3k8a6YBR/DA=",
+    integrity = "sha256-gHbvlnErUeJGWzW8/8JiVlk28JwmXSMhOzkynEIz+8g=",
     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-DkdvhPP2KiqUOpwFXQIFDCWCwsUDIC/xhTBD+TZevm0=",
+    integrity = "sha256-hQkQdpm5ng4miGYa5WsOKWa0q8WtZu99Oqbv9QtBeJM=",
     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-vkZqV0HB8A2Uc56C1Us/p5G57iaHL+zw2No93Xt6M/4=",
+    integrity = "sha256-33sBsmApnJpcyYfR3olKaPB+WC1q00ZKNzHa2TczIxk=",
     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-D/HPAW61lKqjoWwl7N0XvhdX+67dCEFAy8JxVzqBGtU=",
+    integrity = "sha256-GQulBKLc2khpql2K/MxV+NG/d2kAhLXl+gLnKIg7rt4=",
     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/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/client/client.go

@@ -11,8 +11,9 @@ import (
 )
 
 const (
-	MaxBodySize    int64 = 1 << 23 // 8MB default, WithMaxBodySize can override
-	MaxErrBodySize int64 = 1 << 17 // 128KB
+	MaxBodySize      int64 = 1 << 23 // 8MB default, WithMaxBodySize can override
+	MaxBodySizeState int64 = 1 << 29 // 512MB
+	MaxErrBodySize   int64 = 1 << 17 // 128KB
 )
 
 // Client is a wrapper object around the HTTP client.

api/server/structs/BUILD.bazel

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

api/server/structs/conversions.go

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

api/server/structs/conversions_lightclient.go

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

api/server/structs/endpoints_blob.go

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

beacon-chain/blockchain/BUILD.bazel

@@ -84,7 +84,6 @@ go_library(
         "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -141,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/chain_info_test.go

@@ -13,7 +13,6 @@ import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
@@ -39,7 +38,7 @@ func prepareForkchoiceState(
 	payloadHash [32]byte,
 	justified *ethpb.Checkpoint,
 	finalized *ethpb.Checkpoint,
-) (state.BeaconState, consensus_blocks.ROBlock, error) {
+) (state.BeaconState, blocks.ROBlock, error) {
 	blockHeader := &ethpb.BeaconBlockHeader{
 		ParentRoot: parentRoot[:],
 	}
@@ -61,7 +60,7 @@ func prepareForkchoiceState(
 	base.BlockRoots[0] = append(base.BlockRoots[0], blockRoot[:]...)
 	st, err := state_native.InitializeFromProtoBellatrix(base)
 	if err != nil {
-		return nil, consensus_blocks.ROBlock{}, err
+		return nil, blocks.ROBlock{}, err
 	}
 	blk := &ethpb.SignedBeaconBlockBellatrix{
 		Block: &ethpb.BeaconBlockBellatrix{
@@ -76,9 +75,9 @@ func prepareForkchoiceState(
 	}
 	signed, err := blocks.NewSignedBeaconBlock(blk)
 	if err != nil {
-		return nil, consensus_blocks.ROBlock{}, err
+		return nil, blocks.ROBlock{}, err
 	}
-	roblock, err := consensus_blocks.NewROBlockWithRoot(signed, blockRoot)
+	roblock, err := blocks.NewROBlockWithRoot(signed, blockRoot)
 	return st, roblock, err
 }
 

beacon-chain/blockchain/kzg/BUILD.bazel

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

beacon-chain/blockchain/kzg/validation_test.go

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

beacon-chain/blockchain/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"
@@ -67,7 +66,10 @@ func (s *Service) postBlockProcess(cfg *postBlockProcessConfig) error {
 	if s.inRegularSync() {
 		defer s.handleSecondFCUCall(cfg, fcuArgs)
 	}
-	defer s.sendLightClientFeeds(cfg)
+	if features.Get().EnableLightClient && slots.ToEpoch(s.CurrentSlot()) >= params.BeaconConfig().AltairForkEpoch {
+		defer s.processLightClientUpdates(cfg)
+		defer s.saveLightClientUpdate(cfg)
+	}
 	defer s.sendStateFeedOnBlock(cfg)
 	defer reportProcessingTime(startTime)
 	defer reportAttestationInclusion(cfg.roblock.Block())
@@ -404,10 +406,9 @@ func (s *Service) savePostStateInfo(ctx context.Context, r [32]byte, b interface
 		return errors.Wrapf(err, "could not save block from slot %d", b.Block().Slot())
 	}
 	if err := s.cfg.StateGen.SaveState(ctx, r, st); err != nil {
-		log.Warnf("Rolling back insertion of block with root %#x", r)
-		if err := s.cfg.BeaconDB.DeleteBlock(ctx, r); err != nil {
-			log.WithError(err).Errorf("Could not delete block with block root %#x", r)
-		}
+		// Do not use parent context in the event it deadlined
+		ctx = trace.NewContext(context.Background(), span)
+		s.rollbackBlock(ctx, r)
 		return errors.Wrap(err, "could not save state")
 	}
 	return nil
@@ -494,14 +495,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
 	}
@@ -550,7 +552,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
 	}
@@ -561,7 +563,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,6 +1,7 @@
 package blockchain
 
 import (
+	"bytes"
 	"context"
 	"fmt"
 	"time"
@@ -15,7 +16,6 @@ import (
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
 	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -24,7 +24,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v5/math"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
@@ -115,64 +114,123 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 	})
 }
 
-// sendLightClientFeeds sends the light client feeds when feature flag is enabled.
-func (s *Service) sendLightClientFeeds(cfg *postBlockProcessConfig) {
-	if features.Get().EnableLightClient {
-		if _, err := s.sendLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
-			log.WithError(err).Error("Failed to send light client optimistic update")
-		}
-
-		// Get the finalized checkpoint
-		finalized := s.ForkChoicer().FinalizedCheckpoint()
-
-		// LightClientFinalityUpdate needs super majority
-		s.tryPublishLightClientFinalityUpdate(cfg.ctx, cfg.roblock, finalized, cfg.postState)
+func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
+	if err := s.processLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
+		log.WithError(err).Error("Failed to process light client optimistic update")
+	}
+	if err := s.processLightClientFinalityUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
+		log.WithError(err).Error("Failed to process light client finality update")
 	}
 }
 
-func (s *Service) tryPublishLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock, finalized *forkchoicetypes.Checkpoint, postState state.BeaconState) {
-	if finalized.Epoch <= s.lastPublishedLightClientEpoch {
-		return
-	}
-
-	config := params.BeaconConfig()
-	if finalized.Epoch < config.AltairForkEpoch {
-		return
-	}
-
-	syncAggregate, err := signed.Block().Body().SyncAggregate()
-	if err != nil || syncAggregate == nil {
-		return
-	}
-
-	// LightClientFinalityUpdate needs super majority
-	if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 {
-		return
-	}
-
-	_, err = s.sendLightClientFinalityUpdate(ctx, signed, postState)
+// saveLightClientUpdate saves the light client update for this block
+// if it's better than the already saved one, when feature flag is enabled.
+func (s *Service) saveLightClientUpdate(cfg *postBlockProcessConfig) {
+	attestedRoot := cfg.roblock.Block().ParentRoot()
+	attestedBlock, err := s.getBlock(cfg.ctx, attestedRoot)
 	if err != nil {
-		log.WithError(err).Error("Failed to send light client finality update")
+		log.WithError(err).Error("Saving light client update failed: Could not get attested block")
+		return
+	}
+	if attestedBlock == nil || attestedBlock.IsNil() {
+		log.Error("Saving light client update failed: Attested block is nil")
+		return
+	}
+	attestedState, err := s.cfg.StateGen.StateByRoot(cfg.ctx, attestedRoot)
+	if err != nil {
+		log.WithError(err).Error("Saving light client update failed: Could not get attested state")
+		return
+	}
+	if attestedState == nil || attestedState.IsNil() {
+		log.Error("Saving light client update failed: Attested state is nil")
+		return
+	}
+
+	finalizedRoot := attestedState.FinalizedCheckpoint().Root
+	finalizedBlock, err := s.getBlock(cfg.ctx, [32]byte(finalizedRoot))
+	if err != nil {
+		log.WithError(err).Error("Saving light client update failed: Could not get finalized block")
+		return
+	}
+
+	update, err := lightclient.NewLightClientUpdateFromBeaconState(
+		cfg.ctx,
+		s.CurrentSlot(),
+		cfg.postState,
+		cfg.roblock,
+		attestedState,
+		attestedBlock,
+		finalizedBlock,
+	)
+	if err != nil {
+		log.WithError(err).Error("Saving light client update failed: Could not create light client update")
+		return
+	}
+
+	period := slots.SyncCommitteePeriod(slots.ToEpoch(attestedState.Slot()))
+
+	oldUpdate, err := s.cfg.BeaconDB.LightClientUpdate(cfg.ctx, period)
+	if err != nil {
+		log.WithError(err).Error("Saving light client update failed: Could not get current light client update")
+		return
+	}
+
+	if oldUpdate == nil {
+		if err := s.cfg.BeaconDB.SaveLightClientUpdate(cfg.ctx, period, update); err != nil {
+			log.WithError(err).Error("Saving light client update failed: Could not save light client update")
+		} else {
+			log.WithField("period", period).Debug("Saving light client update: Saved new update")
+		}
+		return
+	}
+
+	isNewUpdateBetter, err := lightclient.IsBetterUpdate(update, oldUpdate)
+	if err != nil {
+		log.WithError(err).Error("Saving light client update failed: Could not compare light client updates")
+		return
+	}
+
+	if isNewUpdateBetter {
+		if err := s.cfg.BeaconDB.SaveLightClientUpdate(cfg.ctx, period, update); err != nil {
+			log.WithError(err).Error("Saving light client update failed: Could not save light client update")
+		} else {
+			log.WithField("period", period).Debug("Saving light client update: Saved new update")
+		}
 	} else {
-		s.lastPublishedLightClientEpoch = finalized.Epoch
+		log.WithField("period", period).Debug("Saving light client update: New update is not better than the current one. Skipping save.")
 	}
 }
 
-// sendLightClientFinalityUpdate sends a light client finality update notification to the state feed.
-func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState) (int, error) {
-	// Get attested state
+// saveLightClientBootstrap saves a light client bootstrap for this block
+// when feature flag is enabled.
+func (s *Service) saveLightClientBootstrap(cfg *postBlockProcessConfig) {
+	blockRoot := cfg.roblock.Root()
+	bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(cfg.ctx, s.CurrentSlot(), cfg.postState, cfg.roblock)
+	if err != nil {
+		log.WithError(err).Error("Saving light client bootstrap failed: Could not create light client bootstrap")
+		return
+	}
+	err = s.cfg.BeaconDB.SaveLightClientBootstrap(cfg.ctx, blockRoot[:], bootstrap)
+	if err != nil {
+		log.WithError(err).Error("Saving light client bootstrap failed: Could not save light client bootstrap in DB")
+	}
+}
+
+func (s *Service) processLightClientFinalityUpdate(
+	ctx context.Context,
+	signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState,
+) error {
 	attestedRoot := signed.Block().ParentRoot()
 	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
 	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested block")
+		return errors.Wrap(err, "could not get attested block")
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested state")
+		return errors.Wrap(err, "could not get attested state")
 	}
 
-	// Get finalized block
 	var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
 	finalizedCheckPoint := attestedState.FinalizedCheckpoint()
 	if finalizedCheckPoint != nil {
@@ -183,8 +241,14 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		}
 	}
 
+	// Check if the finalized checkpoint has changed
+	if finalizedCheckPoint == nil || bytes.Equal(finalizedCheckPoint.GetRoot(), postState.FinalizedCheckpoint().Root) {
+		return nil
+	}
+
 	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
+		postState.Slot(),
 		postState,
 		signed,
 		attestedState,
@@ -193,38 +257,31 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	)
 
 	if err != nil {
-		return 0, errors.Wrap(err, "could not create light client update")
+		return errors.Wrap(err, "could not create light client finality update")
 	}
 
-	// Return the result
-	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
-		Version: ethpbv2.Version(signed.Version()),
-		Data:    update,
-	}
-
-	// Send event
-	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.LightClientFinalityUpdate,
-		Data: result,
-	}), nil
+		Data: update,
+	})
+	return nil
 }
 
-// sendLightClientOptimisticUpdate sends a light client optimistic update notification to the state feed.
-func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
-	postState state.BeaconState) (int, error) {
-	// Get attested state
+func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState) error {
 	attestedRoot := signed.Block().ParentRoot()
 	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
 	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested block")
+		return errors.Wrap(err, "could not get attested block")
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
 	if err != nil {
-		return 0, errors.Wrap(err, "could not get attested state")
+		return errors.Wrap(err, "could not get attested state")
 	}
 
 	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
 		ctx,
+		postState.Slot(),
 		postState,
 		signed,
 		attestedState,
@@ -232,19 +289,15 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	)
 
 	if err != nil {
-		return 0, errors.Wrap(err, "could not create light client update")
+		return errors.Wrap(err, "could not create light client optimistic update")
 	}
 
-	// Return the result
-	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
-		Version: ethpbv2.Version(signed.Version()),
-		Data:    update,
-	}
-
-	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
+	s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
 		Type: statefeed.LightClientOptimisticUpdate,
-		Data: result,
-	}), nil
+		Data: update,
+	})
+
+	return nil
 }
 
 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch

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"
@@ -40,6 +41,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
+	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
@@ -2204,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{}),
 		},
@@ -2254,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
@@ -2352,6 +2354,62 @@ func TestRollbackBlock(t *testing.T) {
 	require.Equal(t, false, hasState)
 }
 
+func TestRollbackBlock_SavePostStateInfo_ContextDeadline(t *testing.T) {
+	service, tr := minimalTestService(t)
+	ctx := tr.ctx
+
+	st, keys := util.DeterministicGenesisState(t, 64)
+	stateRoot, err := st.HashTreeRoot(ctx)
+	require.NoError(t, err, "Could not hash genesis state")
+
+	require.NoError(t, service.saveGenesisData(ctx, st))
+
+	genesis := blocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
+	require.NoError(t, err)
+	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
+	parentRoot, err := genesis.Block.HashTreeRoot()
+	require.NoError(t, err, "Could not get signing root")
+	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, st, parentRoot), "Could not save genesis state")
+	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, parentRoot), "Could not save genesis state")
+	require.NoError(t, service.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}))
+	require.NoError(t, service.cfg.BeaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: parentRoot[:]}))
+
+	st, err = service.HeadState(ctx)
+	require.NoError(t, err)
+	b, err := util.GenerateFullBlock(st, keys, util.DefaultBlockGenConfig(), 128)
+	require.NoError(t, err)
+	wsb, err = consensusblocks.NewSignedBeaconBlock(b)
+	require.NoError(t, err)
+	root, err := b.Block.HashTreeRoot()
+	require.NoError(t, err)
+	preState, err := service.getBlockPreState(ctx, wsb.Block())
+	require.NoError(t, err)
+	postState, err := service.validateStateTransition(ctx, preState, wsb)
+	require.NoError(t, err)
+
+	// Save state summaries so that the cache is flushed and saved to disk
+	// later.
+	for i := 1; i <= 127; i++ {
+		require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{
+			Slot: primitives.Slot(i),
+			Root: bytesutil.Bytes32(uint64(i)),
+		}))
+	}
+
+	// Set deadlined context when saving block and state
+	cancCtx, canc := context.WithCancel(ctx)
+	canc()
+
+	require.ErrorContains(t, context.Canceled.Error(), service.savePostStateInfo(cancCtx, root, wsb, postState))
+
+	// The block should no longer exist.
+	require.Equal(t, false, service.cfg.BeaconDB.HasBlock(ctx, root))
+	hasState, err := service.cfg.StateGen.HasState(ctx, root)
+	require.NoError(t, err)
+	require.Equal(t, false, hasState)
+}
+
 func TestRollbackBlock_ContextDeadline(t *testing.T) {
 	service, tr := minimalTestService(t)
 	ctx := tr.ctx
@@ -2446,3 +2504,605 @@ func fakeResult(missing []uint64) map[uint64]struct{} {
 	}
 	return r
 }
+
+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) {
+		t.Run("No old update", 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,
+			}
+
+			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.Altair)
+		})
+
+		t.Run("New 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)
+
+			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) {
+		t.Run("No old update", 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,
+			}
+
+			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)
+		})
+
+		t.Run("New 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)
+
+			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) {
+		t.Run("No old update", 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,
+			}
+
+			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)
+		})
+
+		t.Run("New 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)
+
+			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) {
+		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)
+
+		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)
+
+		cfg := &postBlockProcessConfig{
+			ctx:            ctx,
+			roblock:        roblock,
+			postState:      l.State,
+			isValidPayload: true,
+		}
+
+		s.saveLightClientBootstrap(cfg)
+
+		// Check that the light client bootstrap is saved
+		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
+		require.NoError(t, err)
+		require.NotNil(t, b)
+
+		stateRoot, err := l.State.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
+		require.Equal(t, b.Version(), version.Altair)
+	})
+
+	t.Run("Capella", 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)
+
+		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)
+
+		cfg := &postBlockProcessConfig{
+			ctx:            ctx,
+			roblock:        roblock,
+			postState:      l.State,
+			isValidPayload: true,
+		}
+
+		s.saveLightClientBootstrap(cfg)
+
+		// Check that the light client bootstrap is saved
+		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
+		require.NoError(t, err)
+		require.NotNil(t, b)
+
+		stateRoot, err := l.State.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
+		require.Equal(t, b.Version(), version.Capella)
+	})
+
+	t.Run("Deneb", 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)
+
+		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)
+
+		cfg := &postBlockProcessConfig{
+			ctx:            ctx,
+			roblock:        roblock,
+			postState:      l.State,
+			isValidPayload: true,
+		}
+
+		s.saveLightClientBootstrap(cfg)
+
+		// Check that the light client bootstrap is saved
+		b, err := s.cfg.BeaconDB.LightClientBootstrap(ctx, currentBlockRoot[:])
+		require.NoError(t, err)
+		require.NotNil(t, b)
+
+		stateRoot, err := l.State.HashTreeRoot(ctx)
+		require.NoError(t, err)
+		require.Equal(t, stateRoot, [32]byte(b.Header().Beacon().StateRoot))
+		require.Equal(t, b.Version(), version.Deneb)
+	})
+
+	reset()
+}

beacon-chain/blockchain/receive_attestation_test.go

@@ -10,7 +10,6 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -87,9 +86,7 @@ func TestProcessAttestations_Ok(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 	attsToSave := make([]ethpb.Att, len(atts))
-	for i, a := range atts {
-		attsToSave[i] = a
-	}
+	copy(attsToSave, atts)
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	service.processAttestations(ctx, 0)
 	require.Equal(t, 0, len(service.cfg.AttPool.ForkchoiceAttestations()))
@@ -119,7 +116,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
-	roblock, err := consensus_blocks.NewROBlockWithRoot(wsb, tRoot)
+	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
 	require.NoError(t, err)
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
 	copied, err = service.cfg.StateGen.StateByRoot(ctx, tRoot)
@@ -131,9 +128,7 @@ func TestService_ProcessAttestationsAndUpdateHead(t *testing.T) {
 	atts, err := util.GenerateAttestations(copied, pks, 1, 1, false)
 	require.NoError(t, err)
 	attsToSave := make([]ethpb.Att, len(atts))
-	for i, a := range atts {
-		attsToSave[i] = a
-	}
+	copy(attsToSave, atts)
 	require.NoError(t, service.cfg.AttPool.SaveForkchoiceAttestations(attsToSave))
 	// Verify the target is in forkchoice
 	require.Equal(t, true, fcs.HasNode(bytesutil.ToBytes32(atts[0].GetData().BeaconBlockRoot)))
@@ -181,7 +176,7 @@ func TestService_UpdateHead_NoAtts(t *testing.T) {
 	postState, err := service.validateStateTransition(ctx, preState, wsb)
 	require.NoError(t, err)
 	require.NoError(t, service.savePostStateInfo(ctx, tRoot, wsb, postState))
-	roblock, err := consensus_blocks.NewROBlockWithRoot(wsb, tRoot)
+	roblock, err := blocks.NewROBlockWithRoot(wsb, tRoot)
 	require.NoError(t, err)
 	require.NoError(t, service.postBlockProcess(&postBlockProcessConfig{ctx, roblock, [32]byte{}, postState, false}))
 	require.Equal(t, 2, fcs.NodeCount())

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/receive_block.go

@@ -17,8 +17,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	consensusblocks "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"
@@ -85,7 +83,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 
 	currentCheckpoints := s.saveCurrentCheckpoints(preState)
-	roblock, err := consensus_blocks.NewROBlockWithRoot(blockCopy, blockRoot)
+	roblock, err := blocks.NewROBlockWithRoot(blockCopy, blockRoot)
 	if err != nil {
 		return err
 	}
@@ -190,7 +188,7 @@ func (s *Service) updateCheckpoints(
 func (s *Service) validateExecutionAndConsensus(
 	ctx context.Context,
 	preState state.BeaconState,
-	block consensusblocks.ROBlock,
+	block blocks.ROBlock,
 ) (state.BeaconState, bool, error) {
 	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	if err != nil {
@@ -560,7 +558,7 @@ func (s *Service) sendBlockAttestationsToSlasher(signed interfaces.ReadOnlySigne
 }
 
 // validateExecutionOnBlock notifies the engine of the incoming block execution payload and returns true if the payload is valid
-func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, block consensusblocks.ROBlock) (bool, error) {
+func (s *Service) validateExecutionOnBlock(ctx context.Context, ver int, header interfaces.ExecutionData, block blocks.ROBlock) (bool, error) {
 	isValidPayload, err := s.notifyNewPayload(ctx, ver, header, block)
 	if err != nil {
 		s.cfg.ForkChoiceStore.Lock()

beacon-chain/blockchain/service.go

@@ -33,10 +33,8 @@ 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"
-	consensus_blocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -49,25 +47,24 @@ import (
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
-	cfg                           *config
-	ctx                           context.Context
-	cancel                        context.CancelFunc
-	genesisTime                   time.Time
-	head                          *head
-	headLock                      sync.RWMutex
-	originBlockRoot               [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
-	boundaryRoots                 [][32]byte
-	checkpointStateCache          *cache.CheckpointStateCache
-	initSyncBlocks                map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
-	initSyncBlocksLock            sync.RWMutex
-	wsVerifier                    *WeakSubjectivityVerifier
-	clockSetter                   startup.ClockSetter
-	clockWaiter                   startup.ClockWaiter
-	syncComplete                  chan struct{}
-	blobNotifiers                 *blobNotifierMap
-	blockBeingSynced              *currentlySyncingBlock
-	blobStorage                   *filesystem.BlobStorage
-	lastPublishedLightClientEpoch primitives.Epoch
+	cfg                  *config
+	ctx                  context.Context
+	cancel               context.CancelFunc
+	genesisTime          time.Time
+	head                 *head
+	headLock             sync.RWMutex
+	originBlockRoot      [32]byte // genesis root, or weak subjectivity checkpoint root, depending on how the node is initialized
+	boundaryRoots        [][32]byte
+	checkpointStateCache *cache.CheckpointStateCache
+	initSyncBlocks       map[[32]byte]interfaces.ReadOnlySignedBeaconBlock
+	initSyncBlocksLock   sync.RWMutex
+	wsVerifier           *WeakSubjectivityVerifier
+	clockSetter          startup.ClockSetter
+	clockWaiter          startup.ClockWaiter
+	syncComplete         chan struct{}
+	blobNotifiers        *blobNotifierMap
+	blockBeingSynced     *currentlySyncingBlock
+	blobStorage          *filesystem.BlobStorage
 }
 
 // config options for the service.
@@ -107,18 +104,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
@@ -129,7 +130,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
 	}
 
@@ -138,12 +139,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
@@ -169,7 +171,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,
@@ -308,7 +310,7 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint block")
 	}
-	roblock, err := consensus_blocks.NewROBlockWithRoot(finalizedBlock, fRoot)
+	roblock, err := blocks.NewROBlockWithRoot(finalizedBlock, fRoot)
 	if err != nil {
 		return err
 	}
@@ -524,7 +526,7 @@ func (s *Service) saveGenesisData(ctx context.Context, genesisState state.Beacon
 
 	s.cfg.ForkChoiceStore.Lock()
 	defer s.cfg.ForkChoiceStore.Unlock()
-	gb, err := consensus_blocks.NewROBlockWithRoot(genesisBlk, genesisBlkRoot)
+	gb, err := blocks.NewROBlockWithRoot(genesisBlk, genesisBlkRoot)
 	if err != nil {
 		return err
 	}

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/core/blocks/exports_test.go

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

beacon-chain/core/blocks/payload.go

@@ -8,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)

beacon-chain/core/electra/BUILD.bazel

@@ -41,6 +41,7 @@ go_library(
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//common/math:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

beacon-chain/core/electra/consolidations.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"fmt"
 
+	"github.com/ethereum/go-ethereum/common/math"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -156,6 +157,13 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 //	    if target_validator.exit_epoch != FAR_FUTURE_EPOCH:
 //	        return
 //
+//	    # Verify the source has been active long enough
+//	    if current_epoch < source_validator.activation_epoch + SHARD_COMMITTEE_PERIOD:
+//	        return
+//
+//	    # Verify the source has no pending withdrawals in the queue
+//	    if get_pending_balance_to_withdraw(state, source_index) > 0:
+//	        return
 //	    # Initiate source validator exit and append pending consolidation
 //	    source_validator.exit_epoch = compute_consolidation_epoch_and_update_churn(
 //	        state, source_validator.effective_balance
@@ -258,6 +266,23 @@ func ProcessConsolidationRequests(ctx context.Context, st state.BeaconState, req
 			continue
 		}
 
+		e, overflow := math.SafeAdd(uint64(srcV.ActivationEpoch), uint64(params.BeaconConfig().ShardCommitteePeriod))
+		if overflow {
+			log.Error("Overflow when adding activation epoch and shard committee period")
+			continue
+		}
+		if uint64(curEpoch) < e {
+			continue
+		}
+		bal, err := st.PendingBalanceToWithdraw(srcIdx)
+		if err != nil {
+			log.WithError(err).Error("failed to fetch pending balance to withdraw")
+			continue
+		}
+		if bal > 0 {
+			continue
+		}
+
 		// Initiate the exit of the source validator.
 		exitEpoch, err := ComputeConsolidationEpochAndUpdateChurn(ctx, st, primitives.Gwei(srcV.EffectiveBalance))
 		if err != nil {

beacon-chain/core/electra/consolidations_test.go

@@ -213,6 +213,7 @@ func TestProcessConsolidationRequests(t *testing.T) {
 			name: "one valid request",
 			state: func() state.BeaconState {
 				st := &eth.BeaconStateElectra{
+					Slot:       params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
 					Validators: createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
 				}
 				// Validator scenario setup. See comments in reqs section.
@@ -222,6 +223,12 @@ func TestProcessConsolidationRequests(t *testing.T) {
 				st.Validators[12].ActivationEpoch = params.BeaconConfig().FarFutureEpoch
 				st.Validators[13].ExitEpoch = 10
 				st.Validators[16].ExitEpoch = 10
+				st.PendingPartialWithdrawals = []*eth.PendingPartialWithdrawal{
+					{
+						Index:  17,
+						Amount: 100,
+					},
+				}
 				s, err := state_native.InitializeFromProtoElectra(st)
 				require.NoError(t, err)
 				return s
@@ -287,6 +294,12 @@ func TestProcessConsolidationRequests(t *testing.T) {
 					SourcePubkey:  []byte("val_0"),
 					TargetPubkey:  []byte("val_0"),
 				},
+				// Has pending partial withdrawal
+				{
+					SourceAddress: append(bytesutil.PadTo(nil, 19), byte(0)),
+					SourcePubkey:  []byte("val_17"),
+					TargetPubkey:  []byte("val_1"),
+				},
 				// Valid consolidation request. This should be last to ensure invalid requests do
 				// not end the processing early.
 				{
@@ -347,6 +360,7 @@ func TestProcessConsolidationRequests(t *testing.T) {
 			name: "pending consolidations limit reached during processing",
 			state: func() state.BeaconState {
 				st := &eth.BeaconStateElectra{
+					Slot:                  params.BeaconConfig().SlotsPerEpoch.Mul(uint64(params.BeaconConfig().ShardCommitteePeriod)),
 					Validators:            createValidatorsWithTotalActiveBalance(32000000000000000), // 32M ETH
 					PendingConsolidations: make([]*eth.PendingConsolidation, params.BeaconConfig().PendingConsolidationsLimit-1),
 				}

beacon-chain/core/electra/upgrade.go

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

beacon-chain/core/electra/upgrade_test.go

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

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

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

beacon-chain/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/iface/BUILD.bazel

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

beacon-chain/db/iface/interface.go

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

beacon-chain/db/kv/BUILD.bazel

@@ -44,6 +44,7 @@ go_library(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
@@ -53,7 +54,6 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//proto/dbval:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
@@ -112,18 +112,18 @@ go_test(
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
-        "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/testing:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_golang_snappy//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

beacon-chain/db/kv/kv.go

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

beacon-chain/db/kv/lightclient.go

@@ -5,35 +5,126 @@ import (
 	"encoding/binary"
 	"fmt"
 
+	"github.com/golang/snappy"
+	"github.com/pkg/errors"
+	"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"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	bolt "go.etcd.io/bbolt"
+	"google.golang.org/protobuf/proto"
 )
 
-func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update *ethpbv2.LightClientUpdateWithVersion) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.saveLightClientUpdate")
+func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update interfaces.LightClientUpdate) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveLightClientUpdate")
 	defer span.End()
 
 	return s.db.Update(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(lightClientUpdatesBucket)
-		updateMarshalled, err := encode(ctx, update)
+		enc, err := encodeLightClientUpdate(update)
 		if err != nil {
 			return err
 		}
-		return bkt.Put(bytesutil.Uint64ToBytesBigEndian(period), updateMarshalled)
+		return bkt.Put(bytesutil.Uint64ToBytesBigEndian(period), enc)
 	})
 }
 
-func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]*ethpbv2.LightClientUpdateWithVersion, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdates")
+func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot []byte, bootstrap interfaces.LightClientBootstrap) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveLightClientBootstrap")
+	defer span.End()
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(lightClientBootstrapBucket)
+		enc, err := encodeLightClientBootstrap(bootstrap)
+		if err != nil {
+			return err
+		}
+		return bkt.Put(blockRoot, enc)
+	})
+}
+
+func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot []byte) (interfaces.LightClientBootstrap, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.LightClientBootstrap")
+	defer span.End()
+
+	var bootstrap interfaces.LightClientBootstrap
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(lightClientBootstrapBucket)
+		enc := bkt.Get(blockRoot)
+		if enc == nil {
+			return nil
+		}
+		var err error
+		bootstrap, err = decodeLightClientBootstrap(enc)
+		return err
+	})
+	return bootstrap, err
+}
+
+func encodeLightClientBootstrap(bootstrap interfaces.LightClientBootstrap) ([]byte, error) {
+	key, err := keyForLightClientUpdate(bootstrap.Version())
+	if err != nil {
+		return nil, err
+	}
+	enc, err := bootstrap.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not marshal light client bootstrap")
+	}
+	fullEnc := make([]byte, len(key)+len(enc))
+	copy(fullEnc, key)
+	copy(fullEnc[len(key):], enc)
+	return snappy.Encode(nil, fullEnc), nil
+}
+
+func decodeLightClientBootstrap(enc []byte) (interfaces.LightClientBootstrap, 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")
+	}
+	var m proto.Message
+	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")
+		}
+		m = bootstrap
+	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")
+		}
+		m = bootstrap
+	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")
+		}
+		m = bootstrap
+	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")
+		}
+		m = bootstrap
+	default:
+		return nil, errors.New("decoding of saved light client bootstrap is unsupported")
+	}
+	return light_client.NewWrappedBootstrap(m)
+}
+
+func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdates")
 	defer span.End()
 
 	if startPeriod > endPeriod {
 		return nil, fmt.Errorf("start period %d is greater than end period %d", startPeriod, endPeriod)
 	}
 
-	updates := make(map[uint64]*ethpbv2.LightClientUpdateWithVersion)
+	updates := make(map[uint64]interfaces.LightClientUpdate)
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(lightClientUpdatesBucket)
 		c := bkt.Cursor()
@@ -46,11 +137,11 @@ func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod u
 		for k, v := c.Seek(bytesutil.Uint64ToBytesBigEndian(startPeriod)); k != nil && binary.BigEndian.Uint64(k) <= endPeriod; k, v = c.Next() {
 			currentPeriod := binary.BigEndian.Uint64(k)
 
-			var update ethpbv2.LightClientUpdateWithVersion
-			if err := decode(ctx, v, &update); err != nil {
+			update, err := decodeLightClientUpdate(v)
+			if err != nil {
 				return err
 			}
-			updates[currentPeriod] = &update
+			updates[currentPeriod] = update
 		}
 
 		return nil
@@ -62,18 +153,88 @@ func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod u
 	return updates, err
 }
 
-func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (*ethpbv2.LightClientUpdateWithVersion, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdate")
+func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdate")
 	defer span.End()
 
-	var update ethpbv2.LightClientUpdateWithVersion
+	var update interfaces.LightClientUpdate
 	err := s.db.View(func(tx *bolt.Tx) error {
 		bkt := tx.Bucket(lightClientUpdatesBucket)
 		updateBytes := bkt.Get(bytesutil.Uint64ToBytesBigEndian(period))
 		if updateBytes == nil {
 			return nil
 		}
-		return decode(ctx, updateBytes, &update)
+		var err error
+		update, err = decodeLightClientUpdate(updateBytes)
+		return err
 	})
-	return &update, err
+	return update, err
+}
+
+func encodeLightClientUpdate(update interfaces.LightClientUpdate) ([]byte, error) {
+	key, err := keyForLightClientUpdate(update.Version())
+	if err != nil {
+		return nil, err
+	}
+	enc, err := update.MarshalSSZ()
+	if err != nil {
+		return nil, errors.Wrap(err, "could not marshal light client update")
+	}
+	fullEnc := make([]byte, len(key)+len(enc))
+	copy(fullEnc, key)
+	copy(fullEnc[len(key):], enc)
+	return snappy.Encode(nil, fullEnc), nil
+}
+
+func decodeLightClientUpdate(enc []byte) (interfaces.LightClientUpdate, error) {
+	var err error
+	enc, err = snappy.Decode(nil, enc)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not snappy decode light client update")
+	}
+	var m proto.Message
+	switch {
+	case hasAltairKey(enc):
+		update := &ethpb.LightClientUpdateAltair{}
+		if err := update.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Altair light client update")
+		}
+		m = update
+	case hasCapellaKey(enc):
+		update := &ethpb.LightClientUpdateCapella{}
+		if err := update.UnmarshalSSZ(enc[len(capellaKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Capella light client update")
+		}
+		m = update
+	case hasDenebKey(enc):
+		update := &ethpb.LightClientUpdateDeneb{}
+		if err := update.UnmarshalSSZ(enc[len(denebKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Deneb light client update")
+		}
+		m = update
+	case hasElectraKey(enc):
+		update := &ethpb.LightClientUpdateElectra{}
+		if err := update.UnmarshalSSZ(enc[len(electraKey):]); err != nil {
+			return nil, errors.Wrap(err, "could not unmarshal Electra light client update")
+		}
+		m = update
+	default:
+		return nil, errors.New("decoding of saved light client update is unsupported")
+	}
+	return light_client.NewWrappedUpdate(m)
+}
+
+func keyForLightClientUpdate(v int) ([]byte, error) {
+	switch v {
+	case version.Electra:
+		return electraKey, nil
+	case version.Deneb:
+		return denebKey, nil
+	case version.Capella:
+		return capellaKey, nil
+	case version.Altair:
+		return altairKey, nil
+	default:
+		return nil, fmt.Errorf("unsupported light client update version %s", version.String(v))
+	}
 }

beacon-chain/db/kv/schema.go

@@ -18,7 +18,8 @@ var (
 	registrationBucket    = []byte("registration")
 
 	// Light Client Updates Bucket
-	lightClientUpdatesBucket = []byte("light-client-updates")
+	lightClientUpdatesBucket   = []byte("light-client-updates")
+	lightClientBootstrapBucket = []byte("light-client-bootstrap")
 
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")

beacon-chain/deterministic-genesis/BUILD.bazel

@@ -1,24 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "log.go",
-        "service.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/deterministic-genesis",
-    visibility = ["//beacon-chain:__subpackages__"],
-    deps = [
-        "//beacon-chain/cache:go_default_library",
-        "//beacon-chain/db:go_default_library",
-        "//beacon-chain/execution:go_default_library",
-        "//beacon-chain/state:go_default_library",
-        "//beacon-chain/state/state-native:go_default_library",
-        "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "//runtime:go_default_library",
-        "//runtime/interop:go_default_library",
-        "//time/slots:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)

beacon-chain/deterministic-genesis/log.go

@@ -1,7 +0,0 @@
-package interopcoldstart
-
-import (
-	"github.com/sirupsen/logrus"
-)
-
-var log = logrus.WithField("prefix", "deterministic-genesis")

beacon-chain/deterministic-genesis/service.go

@@ -1,206 +0,0 @@
-// Package interopcoldstart allows for spinning up a deterministic-genesis
-// local chain without the need for eth1 deposits useful for
-// local client development and interoperability testing.
-package interopcoldstart
-
-import (
-	"context"
-	"math/big"
-	"os"
-	"time"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
-	"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/consensus-types/primitives"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime"
-	"github.com/prysmaticlabs/prysm/v5/runtime/interop"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-)
-
-var _ runtime.Service = (*Service)(nil)
-var _ cache.FinalizedFetcher = (*Service)(nil)
-var _ execution.ChainStartFetcher = (*Service)(nil)
-
-// Service spins up an client interoperability service that handles responsibilities such
-// as kickstarting a genesis state for the beacon node from cli flags or a genesis.ssz file.
-type Service struct {
-	cfg                *Config
-	ctx                context.Context
-	cancel             context.CancelFunc
-	chainStartDeposits []*ethpb.Deposit
-}
-
-// All of these methods are stubs as they are not used by a node running with deterministic-genesis.
-
-func (s *Service) AllDepositContainers(ctx context.Context) []*ethpb.DepositContainer {
-	log.Errorf("AllDepositContainers should not be called")
-	return nil
-}
-
-func (s *Service) InsertPendingDeposit(ctx context.Context, d *ethpb.Deposit, blockNum uint64, index int64, depositRoot [32]byte) {
-	log.Errorf("InsertPendingDeposit should not be called")
-}
-
-func (s *Service) PendingDeposits(ctx context.Context, untilBlk *big.Int) []*ethpb.Deposit {
-	log.Errorf("PendingDeposits should not be called")
-	return nil
-}
-
-func (s *Service) PendingContainers(ctx context.Context, untilBlk *big.Int) []*ethpb.DepositContainer {
-	log.Errorf("PendingContainers should not be called")
-	return nil
-}
-
-func (s *Service) PrunePendingDeposits(ctx context.Context, merkleTreeIndex int64) {
-	log.Errorf("PrunePendingDeposits should not be called")
-}
-
-func (s *Service) PruneProofs(ctx context.Context, untilDepositIndex int64) error {
-	log.Errorf("PruneProofs should not be called")
-	return nil
-}
-
-// Config options for the interop service.
-type Config struct {
-	GenesisTime   uint64
-	NumValidators uint64
-	BeaconDB      db.HeadAccessDatabase
-	DepositCache  cache.DepositCache
-	GenesisPath   string
-}
-
-// NewService is an interoperability testing service to inject a deterministically generated genesis state
-// into the beacon chain database and running services at start up. This service should not be used in production
-// as it does not have any value other than ease of use for testing purposes.
-func NewService(ctx context.Context, cfg *Config) *Service {
-	ctx, cancel := context.WithCancel(ctx)
-
-	return &Service{
-		cfg:    cfg,
-		ctx:    ctx,
-		cancel: cancel,
-	}
-}
-
-// Start initializes the genesis state from configured flags.
-func (s *Service) Start() {
-	log.Warn("Saving generated genesis state in database for interop testing")
-
-	if s.cfg.GenesisPath != "" {
-		data, err := os.ReadFile(s.cfg.GenesisPath)
-		if err != nil {
-			log.WithError(err).Fatal("Could not read pre-loaded state")
-		}
-		genesisState := &ethpb.BeaconState{}
-		if err := genesisState.UnmarshalSSZ(data); err != nil {
-			log.WithError(err).Fatal("Could not unmarshal pre-loaded state")
-		}
-		genesisTrie, err := state_native.InitializeFromProtoPhase0(genesisState)
-		if err != nil {
-			log.WithError(err).Fatal("Could not get state trie")
-		}
-		if err := s.saveGenesisState(s.ctx, genesisTrie); err != nil {
-			log.WithError(err).Fatal("Could not save interop genesis state")
-		}
-		return
-	}
-
-	// Save genesis state in db
-	genesisState, _, err := interop.GenerateGenesisState(s.ctx, s.cfg.GenesisTime, s.cfg.NumValidators)
-	if err != nil {
-		log.WithError(err).Fatal("Could not generate interop genesis state")
-	}
-	genesisTrie, err := state_native.InitializeFromProtoPhase0(genesisState)
-	if err != nil {
-		log.WithError(err).Fatal("Could not get state trie")
-	}
-	if s.cfg.GenesisTime == 0 {
-		// Generated genesis time; fetch it
-		s.cfg.GenesisTime = genesisTrie.GenesisTime()
-	}
-	gRoot, err := genesisTrie.HashTreeRoot(s.ctx)
-	if err != nil {
-		log.WithError(err).Fatal("Could not hash tree root genesis state")
-	}
-	go slots.CountdownToGenesis(s.ctx, time.Unix(int64(s.cfg.GenesisTime), 0), s.cfg.NumValidators, gRoot)
-
-	if err := s.saveGenesisState(s.ctx, genesisTrie); err != nil {
-		log.WithError(err).Fatal("Could not save interop genesis state")
-	}
-}
-
-// Stop does nothing.
-func (_ *Service) Stop() error {
-	return nil
-}
-
-// Status always returns nil.
-func (_ *Service) Status() error {
-	return nil
-}
-
-// AllDeposits mocks out the deposit cache functionality for interop.
-func (_ *Service) AllDeposits(_ context.Context, _ *big.Int) []*ethpb.Deposit {
-	return []*ethpb.Deposit{}
-}
-
-// ChainStartEth1Data mocks out the powchain functionality for interop.
-func (_ *Service) ChainStartEth1Data() *ethpb.Eth1Data {
-	return &ethpb.Eth1Data{}
-}
-
-// PreGenesisState returns an empty beacon state.
-func (_ *Service) PreGenesisState() state.BeaconState {
-	s, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{})
-	if err != nil {
-		panic("could not initialize state")
-	}
-	return s
-}
-
-// ClearPreGenesisData --
-func (_ *Service) ClearPreGenesisData() {
-	// no-op
-}
-
-// DepositByPubkey mocks out the deposit cache functionality for interop.
-func (_ *Service) DepositByPubkey(_ context.Context, _ []byte) (*ethpb.Deposit, *big.Int) {
-	return &ethpb.Deposit{}, nil
-}
-
-// DepositsNumberAndRootAtHeight mocks out the deposit cache functionality for interop.
-func (_ *Service) DepositsNumberAndRootAtHeight(_ context.Context, _ *big.Int) (uint64, [32]byte) {
-	return 0, [32]byte{}
-}
-
-// FinalizedDeposits mocks out the deposit cache functionality for interop.
-func (_ *Service) FinalizedDeposits(ctx context.Context) (cache.FinalizedDeposits, error) {
-	return nil, nil
-}
-
-// NonFinalizedDeposits mocks out the deposit cache functionality for interop.
-func (_ *Service) NonFinalizedDeposits(_ context.Context, _ int64, _ *big.Int) []*ethpb.Deposit {
-	return []*ethpb.Deposit{}
-}
-
-func (s *Service) saveGenesisState(ctx context.Context, genesisState state.BeaconState) error {
-	if err := s.cfg.BeaconDB.SaveGenesisData(ctx, genesisState); err != nil {
-		return err
-	}
-
-	s.chainStartDeposits = make([]*ethpb.Deposit, genesisState.NumValidators())
-
-	for i := primitives.ValidatorIndex(0); uint64(i) < uint64(genesisState.NumValidators()); i++ {
-		pk := genesisState.PubkeyAtIndex(i)
-		s.chainStartDeposits[i] = &ethpb.Deposit{
-			Data: &ethpb.Deposit_Data{
-				PublicKey: pk[:],
-			},
-		}
-	}
-	return nil
-}

beacon-chain/execution/engine_client.go

@@ -801,7 +801,7 @@ func tDStringToUint256(td string) (*uint256.Int, error) {
 	return i, nil
 }
 
-func buildEmptyExecutionPayload(v int) (proto.Message, error) {
+func EmptyExecutionPayload(v int) (proto.Message, error) {
 	switch v {
 	case version.Bellatrix:
 		return &pb.ExecutionPayload{
@@ -849,6 +849,53 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 	}
 }
 
+func EmptyExecutionPayloadHeader(v int) (proto.Message, error) {
+	switch v {
+	case version.Bellatrix:
+		return &pb.ExecutionPayloadHeader{
+			ParentHash:    make([]byte, fieldparams.RootLength),
+			FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:     make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+			LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:    make([]byte, fieldparams.RootLength),
+			ExtraData:     make([]byte, 0),
+			BaseFeePerGas: make([]byte, fieldparams.RootLength),
+			BlockHash:     make([]byte, fieldparams.RootLength),
+		}, nil
+	case 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
+	case version.Deneb, version.Electra:
+		return &pb.ExecutionPayloadHeaderDeneb{
+			ParentHash:       make([]byte, fieldparams.RootLength),
+			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
+			StateRoot:        make([]byte, fieldparams.RootLength),
+			ReceiptsRoot:     make([]byte, fieldparams.RootLength),
+			LogsBloom:        make([]byte, fieldparams.LogsBloomLength),
+			PrevRandao:       make([]byte, fieldparams.RootLength),
+			ExtraData:        make([]byte, 0),
+			BaseFeePerGas:    make([]byte, fieldparams.RootLength),
+			BlockHash:        make([]byte, fieldparams.RootLength),
+			TransactionsRoot: make([]byte, fieldparams.RootLength),
+			WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+		}, nil
+	default:
+		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))
+	}
+}
+
 func toBlockNumArg(number *big.Int) string {
 	if number == nil {
 		return "latest"

beacon-chain/execution/payload_body.go

@@ -205,7 +205,7 @@ func (r *blindedBlockReconstructor) requestBodiesByHash(ctx context.Context, cli
 func (r *blindedBlockReconstructor) payloadForHeader(header interfaces.ExecutionData, v int) (proto.Message, error) {
 	bodyKey := bytesutil.ToBytes32(header.BlockHash())
 	if bodyKey == params.BeaconConfig().ZeroHash {
-		payload, err := buildEmptyExecutionPayload(v)
+		payload, err := EmptyExecutionPayload(v)
 		if err != nil {
 			return nil, errors.Wrapf(err, "failed to reconstruct payload for body hash %#x", bodyKey)
 		}

beacon-chain/node/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/db/slasherkv:go_default_library",
-        "//beacon-chain/deterministic-genesis:go_default_library",
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
@@ -92,12 +91,9 @@ go_test(
         "//cmd:go_default_library",
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
-        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
         "//runtime:go_default_library",
-        "//runtime/interop:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",

beacon-chain/node/config.go

@@ -144,23 +144,6 @@ func configureNetwork(cliCtx *cli.Context) {
 	}
 }
 
-func configureInteropConfig(cliCtx *cli.Context) error {
-	// an explicit chain config was specified, don't mess with it
-	if cliCtx.IsSet(cmd.ChainConfigFileFlag.Name) {
-		return nil
-	}
-	genTimeIsSet := cliCtx.IsSet(flags.InteropGenesisTimeFlag.Name)
-	numValsIsSet := cliCtx.IsSet(flags.InteropNumValidatorsFlag.Name)
-	votesIsSet := cliCtx.IsSet(flags.InteropMockEth1DataVotesFlag.Name)
-
-	if genTimeIsSet || numValsIsSet || votesIsSet {
-		if err := params.SetActive(params.InteropConfig().Copy()); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 func configureExecutionSetting(cliCtx *cli.Context) error {
 	if cliCtx.IsSet(flags.TerminalTotalDifficultyOverride.Name) {
 		c := params.BeaconConfig()

beacon-chain/node/config_test.go

@@ -169,66 +169,6 @@ func TestConfigureNetwork_ConfigFile(t *testing.T) {
 	require.NoError(t, os.Remove("flags_test.yaml"))
 }
 
-func TestConfigureInterop(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-
-	tests := []struct {
-		name       string
-		flagSetter func() *cli.Context
-		configName string
-	}{
-		{
-			"nothing set",
-			func() *cli.Context {
-				app := cli.App{}
-				set := flag.NewFlagSet("test", 0)
-				return cli.NewContext(&app, set, nil)
-			},
-			"mainnet",
-		},
-		{
-			"mock votes set",
-			func() *cli.Context {
-				app := cli.App{}
-				set := flag.NewFlagSet("test", 0)
-				set.Bool(flags.InteropMockEth1DataVotesFlag.Name, false, "")
-				assert.NoError(t, set.Set(flags.InteropMockEth1DataVotesFlag.Name, "true"))
-				return cli.NewContext(&app, set, nil)
-			},
-			"interop",
-		},
-		{
-			"validators set",
-			func() *cli.Context {
-				app := cli.App{}
-				set := flag.NewFlagSet("test", 0)
-				set.Uint64(flags.InteropNumValidatorsFlag.Name, 0, "")
-				assert.NoError(t, set.Set(flags.InteropNumValidatorsFlag.Name, "20"))
-				return cli.NewContext(&app, set, nil)
-			},
-			"interop",
-		},
-		{
-			"genesis time set",
-			func() *cli.Context {
-				app := cli.App{}
-				set := flag.NewFlagSet("test", 0)
-				set.Uint64(flags.InteropGenesisTimeFlag.Name, 0, "")
-				assert.NoError(t, set.Set(flags.InteropGenesisTimeFlag.Name, "200"))
-				return cli.NewContext(&app, set, nil)
-			},
-			"interop",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			require.NoError(t, configureInteropConfig(tt.flagSetter()))
-			assert.DeepEqual(t, tt.configName, params.BeaconConfig().ConfigName)
-		})
-	}
-}
-
 func TestAliasFlag(t *testing.T) {
 	// Create a new app with the flag
 	app := &cli.App{

beacon-chain/node/node.go

@@ -30,7 +30,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/kv"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/slasherkv"
-	interopcoldstart "github.com/prysmaticlabs/prysm/v5/beacon-chain/deterministic-genesis"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/doubly-linked-tree"
@@ -261,10 +260,6 @@ func configureBeacon(cliCtx *cli.Context) error {
 
 	configureNetwork(cliCtx)
 
-	if err := configureInteropConfig(cliCtx); err != nil {
-		return errors.Wrap(err, "could not configure interop config")
-	}
-
 	if err := configureExecutionSetting(cliCtx); err != nil {
 		return errors.Wrap(err, "could not configure execution setting")
 	}
@@ -324,11 +319,6 @@ func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *sta
 		return errors.Wrap(err, "could not register attestation pool service")
 	}
 
-	log.Debugln("Registering Deterministic Genesis Service")
-	if err := beacon.registerDeterministicGenesisService(); err != nil {
-		return errors.Wrap(err, "could not register deterministic genesis service")
-	}
-
 	log.Debugln("Registering Blockchain Service")
 	if err := beacon.registerBlockchainService(beacon.forkChoicer, synchronizer, beacon.initialSyncComplete); err != nil {
 		return errors.Wrap(err, "could not register blockchain service")
@@ -567,6 +557,7 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 	}
 
 	if b.CheckpointInitializer != nil {
+		log.Info("Checkpoint sync - Downloading origin state and block")
 		if err := b.CheckpointInitializer.Initialize(b.ctx, d); err != nil {
 			return err
 		}
@@ -921,20 +912,8 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 		}
 	}
 
-	genesisValidators := b.cliCtx.Uint64(flags.InteropNumValidatorsFlag.Name)
-	var depositFetcher cache.DepositFetcher
-	var chainStartFetcher execution.ChainStartFetcher
-	if genesisValidators > 0 {
-		var interopService *interopcoldstart.Service
-		if err := b.services.FetchService(&interopService); err != nil {
-			return err
-		}
-		depositFetcher = interopService
-		chainStartFetcher = interopService
-	} else {
-		depositFetcher = b.depositCache
-		chainStartFetcher = web3Service
-	}
+	depositFetcher := b.depositCache
+	chainStartFetcher := web3Service
 
 	host := b.cliCtx.String(flags.RPCHost.Name)
 	port := b.cliCtx.String(flags.RPCPort.Name)
@@ -1056,32 +1035,6 @@ func (b *BeaconNode) registerHTTPService(router *http.ServeMux) error {
 	return b.services.RegisterService(g)
 }
 
-func (b *BeaconNode) registerDeterministicGenesisService() error {
-	genesisTime := b.cliCtx.Uint64(flags.InteropGenesisTimeFlag.Name)
-	genesisValidators := b.cliCtx.Uint64(flags.InteropNumValidatorsFlag.Name)
-
-	if genesisValidators > 0 {
-		svc := interopcoldstart.NewService(b.ctx, &interopcoldstart.Config{
-			GenesisTime:   genesisTime,
-			NumValidators: genesisValidators,
-			BeaconDB:      b.db,
-			DepositCache:  b.depositCache,
-		})
-		svc.Start()
-
-		// Register genesis state as start-up state when interop mode.
-		// The start-up state gets reused across services.
-		st, err := b.db.GenesisState(b.ctx)
-		if err != nil {
-			return err
-		}
-		b.finalizedStateAtStartUp = st
-
-		return b.services.RegisterService(svc)
-	}
-	return nil
-}
-
 func (b *BeaconNode) registerValidatorMonitorService(initialSyncComplete chan struct{}) error {
 	cliSlice := b.cliCtx.IntSlice(cmd.ValidatorMonitorIndicesFlag.Name)
 	if cliSlice == nil {

beacon-chain/node/node_test.go

@@ -6,9 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"net/http/httptest"
-	"os"
 	"path/filepath"
-	"strconv"
 	"testing"
 	"time"
 
@@ -21,13 +19,8 @@ import (
 	mockExecution "github.com/prysmaticlabs/prysm/v5/beacon-chain/execution/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/monitor"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
-	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime"
-	"github.com/prysmaticlabs/prysm/v5/runtime/interop"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	logTest "github.com/sirupsen/logrus/hooks/test"
@@ -117,55 +110,6 @@ func TestNodeStart_SyncChecker(t *testing.T) {
 	require.LogsContain(t, hook, "Starting beacon node")
 }
 
-func TestNodeStart_Ok_registerDeterministicGenesisService(t *testing.T) {
-	numValidators := uint64(1)
-	hook := logTest.NewGlobal()
-	app := cli.App{}
-	tmp := fmt.Sprintf("%s/datadirtest2", t.TempDir())
-	set := flag.NewFlagSet("test", 0)
-	set.String("datadir", tmp, "node data directory")
-	set.Uint64(flags.InteropNumValidatorsFlag.Name, numValidators, "")
-	set.String("suggested-fee-recipient", "0x6e35733c5af9B61374A128e6F85f553aF09ff89A", "fee recipient")
-	require.NoError(t, set.Set("suggested-fee-recipient", "0x6e35733c5af9B61374A128e6F85f553aF09ff89A"))
-	genesisState, _, err := interop.GenerateGenesisState(context.Background(), 0, numValidators)
-	require.NoError(t, err, "Could not generate genesis beacon state")
-	for i := uint64(1); i < 2; i++ {
-		var someRoot [32]byte
-		var someKey [fieldparams.BLSPubkeyLength]byte
-		copy(someRoot[:], strconv.Itoa(int(i)))
-		copy(someKey[:], strconv.Itoa(int(i)))
-		genesisState.Validators = append(genesisState.Validators, &ethpb.Validator{
-			PublicKey:                  someKey[:],
-			WithdrawalCredentials:      someRoot[:],
-			EffectiveBalance:           params.BeaconConfig().MaxEffectiveBalance,
-			Slashed:                    false,
-			ActivationEligibilityEpoch: 1,
-			ActivationEpoch:            1,
-			ExitEpoch:                  1,
-			WithdrawableEpoch:          1,
-		})
-		genesisState.Balances = append(genesisState.Balances, params.BeaconConfig().MaxEffectiveBalance)
-	}
-	genesisBytes, err := genesisState.MarshalSSZ()
-	require.NoError(t, err)
-	require.NoError(t, os.WriteFile("genesis_ssz.json", genesisBytes, 0666))
-	set.String("genesis-state", "genesis_ssz.json", "")
-	ctx, cancel := newCliContextWithCancel(&app, set)
-	node, err := New(ctx, cancel, WithBlockchainFlagOptions([]blockchain.Option{}),
-		WithBuilderFlagOptions([]builder.Option{}),
-		WithExecutionChainOptions([]execution.Option{}),
-		WithBlobStorage(filesystem.NewEphemeralBlobStorage(t)))
-	require.NoError(t, err)
-	node.services = &runtime.ServiceRegistry{}
-	go func() {
-		node.Start()
-	}()
-	time.Sleep(3 * time.Second)
-	node.Close()
-	require.LogsContain(t, hook, "Starting beacon node")
-	require.NoError(t, os.Remove("genesis_ssz.json"))
-}
-
 // TestClearDB tests clearing the database
 func TestClearDB(t *testing.T) {
 	hook := logTest.NewGlobal()

beacon-chain/operations/slashings/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//container/slice:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/operations/slashings/service.go

@@ -15,6 +15,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/trailofbits/go-mutexasserts"
 )
 
@@ -43,6 +44,11 @@ func (p *Pool) PendingAttesterSlashings(ctx context.Context, state state.ReadOnl
 
 	// Allocate pending slice with a capacity of maxAttesterSlashings or len(p.pendingAttesterSlashing)) depending on the request.
 	maxSlashings := params.BeaconConfig().MaxAttesterSlashings
+
+	// EIP-7549: Beginning from Electra, the max attester slashings is reduced to 1.
+	if state.Version() >= version.Electra {
+		maxSlashings = params.BeaconConfig().MaxAttesterSlashingsElectra
+	}
 	if noLimit {
 		maxSlashings = uint64(len(p.pendingAttesterSlashing))
 	}

beacon-chain/operations/slashings/service_attester_test.go

@@ -516,6 +516,70 @@ func TestPool_PendingAttesterSlashings(t *testing.T) {
 	}
 }
 
+func TestPool_PendingAttesterSlashings_AfterElectra(t *testing.T) {
+	type fields struct {
+		pending []*PendingAttesterSlashing
+		all     bool
+	}
+	params.SetupTestConfigCleanup(t)
+	beaconState, privKeys := util.DeterministicGenesisStateElectra(t, 64)
+
+	pendingSlashings := make([]*PendingAttesterSlashing, 20)
+	slashings := make([]ethpb.AttSlashing, 20)
+	for i := 0; i < len(pendingSlashings); i++ {
+		sl, err := util.GenerateAttesterSlashingForValidator(beaconState, privKeys[i], primitives.ValidatorIndex(i))
+		require.NoError(t, err)
+		pendingSlashings[i] = &PendingAttesterSlashing{
+			attesterSlashing: sl,
+			validatorToSlash: primitives.ValidatorIndex(i),
+		}
+		slashings[i] = sl
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []ethpb.AttSlashing
+	}{
+		{
+			name: "Empty list",
+			fields: fields{
+				pending: []*PendingAttesterSlashing{},
+			},
+			want: []ethpb.AttSlashing{},
+		},
+		{
+			name: "All pending",
+			fields: fields{
+				pending: pendingSlashings,
+				all:     true,
+			},
+			want: slashings,
+		},
+		{
+			name: "All eligible",
+			fields: fields{
+				pending: pendingSlashings,
+			},
+			want: slashings[0:1],
+		},
+		{
+			name: "Multiple indices",
+			fields: fields{
+				pending: pendingSlashings[3:6],
+			},
+			want: slashings[3:4],
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			p := &Pool{
+				pendingAttesterSlashing: tt.fields.pending,
+			}
+			assert.DeepEqual(t, tt.want, p.PendingAttesterSlashings(context.Background(), beaconState, tt.fields.all))
+		})
+	}
+}
+
 func TestPool_PendingAttesterSlashings_Slashed(t *testing.T) {
 	type fields struct {
 		pending []*PendingAttesterSlashing

beacon-chain/p2p/broadcaster_test.go

@@ -225,13 +225,6 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	require.NoError(t, err)
 	defer bootListener.Close()
 
-	// Use smaller batch size for testing.
-	currentBatchSize := batchSize
-	batchSize = 2
-	defer func() {
-		batchSize = currentBatchSize
-	}()
-
 	bootNode := bootListener.Self()
 	subnet := uint64(5)
 
@@ -240,7 +233,7 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 	// setup other nodes.
 	cfg = &Config{
 		Discv5BootStrapAddrs: []string{bootNode.String()},
-		MaxPeers:             30,
+		MaxPeers:             2,
 	}
 	// Setup 2 different hosts
 	for i := 1; i <= 2; i++ {

beacon-chain/p2p/discovery.go

@@ -329,7 +329,7 @@ func (s *Service) listenForNewNodes() {
 			}
 
 			// Search for new peers.
-			wantedNodes := searchForPeers(iterator, batchSize, missingPeerCount, s.filterPeer)
+			wantedNodes := searchForPeers(iterator, batchPeriod, missingPeerCount, s.filterPeer)
 
 			wg := new(sync.WaitGroup)
 			for i := 0; i < len(wantedNodes); i++ {
@@ -349,7 +349,7 @@ func (s *Service) listenForNewNodes() {
 				wg.Add(1)
 				go func(info *peer.AddrInfo) {
 					if err := s.connectWithPeer(s.ctx, *info); err != nil {
-						log.WithError(err).Tracef("Could not connect with peer %s", info.String())
+						log.WithError(err).WithField("peerID", info.ID).Debug("Could not connect with peer")
 					}
 					wg.Done()
 				}(peerInfo)

beacon-chain/p2p/handshake.go

@@ -214,7 +214,11 @@ func (s *Service) AddDisconnectionHandler(handler func(ctx context.Context, id p
 				// Only log disconnections if we were fully connected.
 				if priorState == peers.Connected {
 					activePeersCount := len(s.peers.Active())
-					log.WithField("remainingActivePeers", activePeersCount).Debug("Peer disconnected")
+					log.WithFields(logrus.Fields{
+						"remainingActivePeers": activePeersCount,
+						"direction":            conn.Stat().Direction.String(),
+						"peerID":               peerID,
+					}).Debug("Peer disconnected")
 				}
 			}()
 		},

beacon-chain/p2p/peers/scorers/bad_responses.go

@@ -101,18 +101,22 @@ func (s *BadResponsesScorer) countNoLock(pid peer.ID) (int, error) {
 
 // Increment increments the number of bad responses we have received from the given remote peer.
 // If peer doesn't exist this method is no-op.
-func (s *BadResponsesScorer) Increment(pid peer.ID) {
+func (s *BadResponsesScorer) Increment(pid peer.ID) int {
+	const defaultBadResponses = 1
+
 	s.store.Lock()
 	defer s.store.Unlock()
 
 	peerData, ok := s.store.PeerData(pid)
 	if !ok {
 		s.store.SetPeerData(pid, &peerdata.PeerData{
-			BadResponses: 1,
+			BadResponses: defaultBadResponses,
 		})
-		return
+		return defaultBadResponses
 	}
 	peerData.BadResponses++
+
+	return peerData.BadResponses
 }
 
 // IsBadPeer states if the peer is to be considered bad.

beacon-chain/p2p/service.go

@@ -44,8 +44,8 @@ var _ runtime.Service = (*Service)(nil)
 var pollingPeriod = 6 * time.Second
 
 // When looking for new nodes, if not enough nodes are found,
-// we stop after this amount of iterations.
-var batchSize = 2_000
+// we stop after this spent time.
+var batchPeriod = 2 * time.Second
 
 // Refresh rate of ENR set at twice per slot.
 var refreshRate = slots.DivideSlotBy(2)
@@ -443,7 +443,7 @@ func (s *Service) connectWithAllTrustedPeers(multiAddrs []multiaddr.Multiaddr) {
 		// make each dial non-blocking
 		go func(info peer.AddrInfo) {
 			if err := s.connectWithPeer(s.ctx, info); err != nil {
-				log.WithError(err).Tracef("Could not connect with peer %s", info.String())
+				log.WithError(err).WithField("peerID", info.ID).Debug("Could not connect with trusted peer")
 			}
 		}(info)
 	}
@@ -459,7 +459,7 @@ func (s *Service) connectWithAllPeers(multiAddrs []multiaddr.Multiaddr) {
 		// make each dial non-blocking
 		go func(info peer.AddrInfo) {
 			if err := s.connectWithPeer(s.ctx, info); err != nil {
-				log.WithError(err).Tracef("Could not connect with peer %s", info.String())
+				log.WithError(err).WithField("peerID", info.ID).Debug("Could not connect with peer")
 			}
 		}(info)
 	}
@@ -478,8 +478,8 @@ func (s *Service) connectWithPeer(ctx context.Context, info peer.AddrInfo) error
 	ctx, cancel := context.WithTimeout(ctx, maxDialTimeout)
 	defer cancel()
 	if err := s.host.Connect(ctx, info); err != nil {
-		s.Peers().Scorers().BadResponsesScorer().Increment(info.ID)
-		return err
+		score := s.Peers().Scorers().BadResponsesScorer().Increment(info.ID)
+		return errors.Wrapf(err, "connect to peer %s - new bad responses score: %d", info.ID, score)
 	}
 	return nil
 }

beacon-chain/p2p/subnets.go

@@ -66,12 +66,14 @@ func (s *Service) nodeFilter(topic string, index uint64) (func(node *enode.Node)
 // - Iterator is exhausted.
 func searchForPeers(
 	iterator enode.Iterator,
-	batchSize int,
+	batchPeriod time.Duration,
 	peersToFindCount uint,
 	filter func(node *enode.Node) bool,
 ) []*enode.Node {
-	nodeFromNodeID := make(map[enode.ID]*enode.Node, batchSize)
-	for i := 0; i < batchSize && uint(len(nodeFromNodeID)) <= peersToFindCount && iterator.Next(); i++ {
+	nodeFromNodeID := make(map[enode.ID]*enode.Node)
+	start := time.Now()
+
+	for time.Since(start) < batchPeriod && uint(len(nodeFromNodeID)) < peersToFindCount && iterator.Next() {
 		node := iterator.Node()
 
 		// Filter out nodes that do not meet the criteria.
@@ -111,7 +113,7 @@ func (s *Service) dialPeer(ctx context.Context, wg *sync.WaitGroup, node *enode.
 	wg.Add(1)
 	go func() {
 		if err := s.connectWithPeer(ctx, *info); err != nil {
-			log.WithError(err).Tracef("Could not connect with peer %s", info.String())
+			log.WithError(err).WithField("peerID", info.ID).Debug("Could not connect with peer")
 		}
 
 		wg.Done()
@@ -191,7 +193,7 @@ func (s *Service) FindPeersWithSubnet(
 		}
 
 		// Search for new peers in the network.
-		nodes := searchForPeers(iterator, batchSize, uint(missingPeerCountForTopic), filter)
+		nodes := searchForPeers(iterator, batchPeriod, uint(missingPeerCountForTopic), filter)
 
 		// Restrict dials if limit is applied.
 		maxConcurrentDials := math.MaxInt

beacon-chain/rpc/endpoints.go

@@ -62,6 +62,13 @@ func (e *endpoint) handlerWithMiddleware() http.HandlerFunc {
 	)
 
 	return func(w http.ResponseWriter, r *http.Request) {
+		// SSE errors are handled separately to avoid interference with the streaming
+		// mechanism and ensure accurate error tracking.
+		if e.template == "/eth/v1/events" {
+			handler.ServeHTTP(w, r)
+			return
+		}
+
 		rw := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
 		handler.ServeHTTP(rw, r)
 
@@ -165,9 +172,12 @@ func (s *Service) builderEndpoints(stater lookup.Stater) []endpoint {
 	}
 }
 
-func (*Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
+func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 	server := &blob.Server{
-		Blocker: blocker,
+		Blocker:               blocker,
+		OptimisticModeFetcher: s.cfg.OptimisticModeFetcher,
+		FinalizationFetcher:   s.cfg.FinalizationFetcher,
+		TimeFetcher:           s.cfg.GenesisTimeFetcher,
 	}
 
 	const namespace = "blob"
@@ -909,10 +919,11 @@ func (*Service) configEndpoints() []endpoint {
 
 func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Stater) []endpoint {
 	server := &lightclient.Server{
-		Blocker:     blocker,
-		Stater:      stater,
-		HeadFetcher: s.cfg.HeadFetcher,
-		BeaconDB:    s.cfg.BeaconDB,
+		Blocker:          blocker,
+		Stater:           stater,
+		HeadFetcher:      s.cfg.HeadFetcher,
+		ChainInfoFetcher: s.cfg.ChainInfoFetcher,
+		BeaconDB:         s.cfg.BeaconDB,
 	}
 
 	const namespace = "lightclient"

beacon-chain/rpc/eth/beacon/BUILD.bazel

@@ -58,6 +58,7 @@ go_library(
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
+        "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
@@ -118,6 +119,7 @@ go_test(
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

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

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/crypto/kzg4844"
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/api"
@@ -1032,21 +1033,17 @@ func unmarshalStrict(data []byte, v interface{}) error {
 func (s *Server) validateBroadcast(ctx context.Context, r *http.Request, blk *eth.GenericSignedBeaconBlock) error {
 	switch r.URL.Query().Get(broadcastValidationQueryParam) {
 	case broadcastValidationConsensus:
-		b, err := blocks.NewSignedBeaconBlock(blk.Block)
-		if err != nil {
-			return errors.Wrapf(err, "could not create signed beacon block")
-		}
-		if err = s.validateConsensus(ctx, b); err != nil {
+		if err := s.validateConsensus(ctx, blk); err != nil {
 			return errors.Wrap(err, "consensus validation failed")
 		}
 	case broadcastValidationConsensusAndEquivocation:
+		if err := s.validateConsensus(r.Context(), blk); err != nil {
+			return errors.Wrap(err, "consensus validation failed")
+		}
 		b, err := blocks.NewSignedBeaconBlock(blk.Block)
 		if err != nil {
 			return errors.Wrapf(err, "could not create signed beacon block")
 		}
-		if err = s.validateConsensus(r.Context(), b); err != nil {
-			return errors.Wrap(err, "consensus validation failed")
-		}
 		if err = s.validateEquivocation(b.Block()); err != nil {
 			return errors.Wrap(err, "equivocation validation failed")
 		}
@@ -1056,7 +1053,12 @@ func (s *Server) validateBroadcast(ctx context.Context, r *http.Request, blk *et
 	return nil
 }
 
-func (s *Server) validateConsensus(ctx context.Context, blk interfaces.ReadOnlySignedBeaconBlock) error {
+func (s *Server) validateConsensus(ctx context.Context, b *eth.GenericSignedBeaconBlock) error {
+	blk, err := blocks.NewSignedBeaconBlock(b.Block)
+	if err != nil {
+		return errors.Wrapf(err, "could not create signed beacon block")
+	}
+
 	parentBlockRoot := blk.Block().ParentRoot()
 	parentBlock, err := s.Blocker.Block(ctx, parentBlockRoot[:])
 	if err != nil {
@@ -1076,6 +1078,24 @@ func (s *Server) validateConsensus(ctx context.Context, blk interfaces.ReadOnlyS
 	if err != nil {
 		return errors.Wrap(err, "could not execute state transition")
 	}
+
+	var blobs [][]byte
+	var proofs [][]byte
+	switch {
+	case blk.Version() == version.Electra:
+		blobs = b.GetElectra().Blobs
+		proofs = b.GetElectra().KzgProofs
+	case blk.Version() == version.Deneb:
+		blobs = b.GetDeneb().Blobs
+		proofs = b.GetDeneb().KzgProofs
+	default:
+		return nil
+	}
+
+	if err := s.validateBlobSidecars(blk, blobs, proofs); err != nil {
+		return err
+	}
+
 	return nil
 }
 
@@ -1086,6 +1106,25 @@ func (s *Server) validateEquivocation(blk interfaces.ReadOnlyBeaconBlock) error
 	return nil
 }
 
+func (s *Server) validateBlobSidecars(blk interfaces.SignedBeaconBlock, blobs [][]byte, proofs [][]byte) error {
+	if blk.Version() < version.Deneb {
+		return nil
+	}
+	kzgs, err := blk.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return errors.Wrap(err, "could not get blob kzg commitments")
+	}
+	if len(blobs) != len(proofs) || len(blobs) != len(kzgs) {
+		return errors.New("number of blobs, proofs, and commitments do not match")
+	}
+	for i, blob := range blobs {
+		if err := kzg4844.VerifyBlobProof(kzg4844.Blob(blob), kzg4844.Commitment(kzgs[i]), kzg4844.Proof(proofs[i])); err != nil {
+			return errors.Wrap(err, "could not verify blob proof")
+		}
+	}
+	return nil
+}
+
 // GetBlockRoot retrieves the root of a block.
 func (s *Server) GetBlockRoot(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.GetBlockRoot")

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

@@ -12,6 +12,7 @@ import (
 	"testing"
 	"time"
 
+	GoKZG "github.com/crate-crypto/go-kzg-4844"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
@@ -33,6 +34,7 @@ import (
 	"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/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -2922,8 +2924,6 @@ func TestValidateConsensus(t *testing.T) {
 	require.NoError(t, err)
 	block, err := util.GenerateFullBlock(st, privs, util.DefaultBlockGenConfig(), st.Slot())
 	require.NoError(t, err)
-	sbb, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(t, err)
 	parentRoot, err := parentSbb.Block().HashTreeRoot()
 	require.NoError(t, err)
 	server := &Server{
@@ -2931,7 +2931,11 @@ func TestValidateConsensus(t *testing.T) {
 		Stater:  &testutil.MockStater{StatesByRoot: map[[32]byte]state.BeaconState{bytesutil.ToBytes32(parentBlock.Block.StateRoot): parentState}},
 	}
 
-	require.NoError(t, server.validateConsensus(ctx, sbb))
+	require.NoError(t, server.validateConsensus(ctx, &eth.GenericSignedBeaconBlock{
+		Block: &eth.GenericSignedBeaconBlock_Phase0{
+			Phase0: block,
+		},
+	}))
 }
 
 func TestValidateEquivocation(t *testing.T) {
@@ -4152,3 +4156,24 @@ func TestServer_broadcastBlobSidecars(t *testing.T) {
 	require.NoError(t, server.broadcastSeenBlockSidecars(context.Background(), blk, b.GetDeneb().Blobs, b.GetDeneb().KzgProofs))
 	require.LogsContain(t, hook, "Broadcasted blob sidecar for already seen block")
 }
+
+func Test_validateBlobSidecars(t *testing.T) {
+	blob := util.GetRandBlob(123)
+	commitment := GoKZG.KZGCommitment{180, 218, 156, 194, 59, 20, 10, 189, 186, 254, 132, 93, 7, 127, 104, 172, 238, 240, 237, 70, 83, 89, 1, 152, 99, 0, 165, 65, 143, 62, 20, 215, 230, 14, 205, 95, 28, 245, 54, 25, 160, 16, 178, 31, 232, 207, 38, 85}
+	proof := GoKZG.KZGProof{128, 110, 116, 170, 56, 111, 126, 87, 229, 234, 211, 42, 110, 150, 129, 206, 73, 142, 167, 243, 90, 149, 240, 240, 236, 204, 143, 182, 229, 249, 81, 27, 153, 171, 83, 70, 144, 250, 42, 1, 188, 215, 71, 235, 30, 7, 175, 86}
+	blk := util.NewBeaconBlockDeneb()
+	blk.Block.Body.BlobKzgCommitments = [][]byte{commitment[:]}
+	b, err := blocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	s := &Server{}
+	require.NoError(t, s.validateBlobSidecars(b, [][]byte{blob[:]}, [][]byte{proof[:]}))
+
+	require.ErrorContains(t, "number of blobs, proofs, and commitments do not match", s.validateBlobSidecars(b, [][]byte{blob[:]}, [][]byte{}))
+
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	blk.Block.Body.BlobKzgCommitments = [][]byte{sk.PublicKey().Marshal()}
+	b, err = blocks.NewSignedBeaconBlock(blk)
+	require.NoError(t, err)
+	require.ErrorContains(t, "could not verify blob proof: can't verify opening proof", s.validateBlobSidecars(b, [][]byte{blob[:]}, [][]byte{proof[:]}))
+}

beacon-chain/rpc/eth/blob/BUILD.bazel

@@ -10,12 +10,16 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//api/server/structs:go_default_library",
+        "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
         "//beacon-chain/rpc/lookup: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",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
+        "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],

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

@@ -12,9 +12,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/core"
 	field_params "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/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
 // Blobs is an HTTP handler for Beacon API getBlobs.
@@ -22,7 +25,7 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 	ctx, span := trace.StartSpan(r.Context(), "beacon.Blobs")
 	defer span.End()
 
-	indices, err := parseIndices(r.URL)
+	indices, err := parseIndices(r.URL, s.TimeFetcher.CurrentSlot())
 	if err != nil {
 		httputil.HandleError(w, err.Error(), http.StatusBadRequest)
 		return
@@ -59,13 +62,36 @@ func (s *Server) Blobs(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	httputil.WriteJson(w, buildSidecarsJsonResponse(verifiedBlobs))
+	blk, err := s.Blocker.Block(ctx, []byte(blockId))
+	if err != nil {
+		httputil.HandleError(w, "Could not fetch block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	blkRoot, err := blk.Block().HashTreeRoot()
+	if err != nil {
+		httputil.HandleError(w, "Could not hash block: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	isOptimistic, err := s.OptimisticModeFetcher.IsOptimisticForRoot(ctx, blkRoot)
+	if err != nil {
+		httputil.HandleError(w, "Could not check if block is optimistic: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	data := buildSidecarsJsonResponse(verifiedBlobs)
+	resp := &structs.SidecarsResponse{
+		Version:             version.String(blk.Version()),
+		Data:                data,
+		ExecutionOptimistic: isOptimistic,
+		Finalized:           s.FinalizationFetcher.IsFinalized(ctx, blkRoot),
+	}
+	httputil.WriteJson(w, resp)
 }
 
 // parseIndices filters out invalid and duplicate blob indices
-func parseIndices(url *url.URL) ([]uint64, error) {
+func parseIndices(url *url.URL, s primitives.Slot) ([]uint64, error) {
 	rawIndices := url.Query()["indices"]
-	indices := make([]uint64, 0, field_params.MaxBlobsPerBlock)
+	indices := make([]uint64, 0, params.BeaconConfig().MaxBlobsPerBlock(s))
 	invalidIndices := make([]string, 0)
 loop:
 	for _, raw := range rawIndices {
@@ -74,7 +100,7 @@ loop:
 			invalidIndices = append(invalidIndices, raw)
 			continue
 		}
-		if ix >= field_params.MaxBlobsPerBlock {
+		if ix >= uint64(params.BeaconConfig().MaxBlobsPerBlock(s)) {
 			invalidIndices = append(invalidIndices, raw)
 			continue
 		}
@@ -92,14 +118,14 @@ loop:
 	return indices, nil
 }
 
-func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) *structs.SidecarsResponse {
-	resp := &structs.SidecarsResponse{Data: make([]*structs.Sidecar, len(verifiedBlobs))}
+func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) []*structs.Sidecar {
+	sidecars := make([]*structs.Sidecar, len(verifiedBlobs))
 	for i, sc := range verifiedBlobs {
 		proofs := make([]string, len(sc.CommitmentInclusionProof))
 		for j := range sc.CommitmentInclusionProof {
 			proofs[j] = hexutil.Encode(sc.CommitmentInclusionProof[j])
 		}
-		resp.Data[i] = &structs.Sidecar{
+		sidecars[i] = &structs.Sidecar{
 			Index:                    strconv.FormatUint(sc.Index, 10),
 			Blob:                     hexutil.Encode(sc.Blob),
 			KzgCommitment:            hexutil.Encode(sc.KzgCommitment),
@@ -108,7 +134,7 @@ func buildSidecarsJsonResponse(verifiedBlobs []*blocks.VerifiedROBlob) *structs.
 			CommitmentInclusionProof: proofs,
 		}
 	}
-	return resp
+	return sidecars
 }
 
 func buildSidecarsSSZResponse(verifiedBlobs []*blocks.VerifiedROBlob) ([]byte, error) {

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

@@ -46,16 +46,21 @@ func TestBlobs(t *testing.T) {
 	}
 	blockRoot := blobs[0].BlockRoot()
 
+	mockChainService := &mockChain.ChainService{
+		FinalizedRoots: map[[32]byte]bool{},
+	}
+	s := &Server{
+		OptimisticModeFetcher: mockChainService,
+		FinalizationFetcher:   mockChainService,
+		TimeFetcher:           mockChainService,
+	}
+
 	t.Run("genesis", func(t *testing.T) {
 		u := "http://foo.example/genesis"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{}
-		s := &Server{
-			Blocker: blocker,
-		}
-
+		s.Blocker = &lookup.BeaconDbBlocker{}
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
@@ -69,18 +74,14 @@ func TestBlobs(t *testing.T) {
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{Root: blockRoot[:]},
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Root: blockRoot[:], Block: denebBlock},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
-
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusOK, writer.Code)
@@ -111,118 +112,96 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, hexutil.Encode(blobs[3].Blob), sidecar.Blob)
 		assert.Equal(t, hexutil.Encode(blobs[3].KzgCommitment), sidecar.KzgCommitment)
 		assert.Equal(t, hexutil.Encode(blobs[3].KzgProof), sidecar.KzgProof)
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("finalized", func(t *testing.T) {
 		u := "http://foo.example/finalized"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
-
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		require.Equal(t, 4, len(resp.Data))
-	})
-	t.Run("justified", func(t *testing.T) {
-		u := "http://foo.example/justified"
-		request := httptest.NewRequest("GET", u, nil)
-		writer := httptest.NewRecorder()
-		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{CurrentJustifiedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
-			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
-				Genesis: time.Now(),
-			},
-			BeaconDB:    db,
-			BlobStorage: bs,
-		}
-		s := &Server{
-			Blocker: blocker,
-		}
 
-		s.Blobs(writer, request)
-
-		assert.Equal(t, http.StatusOK, writer.Code)
-		resp := &structs.SidecarsResponse{}
-		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		require.Equal(t, 4, len(resp.Data))
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("root", func(t *testing.T) {
 		u := "http://foo.example/" + hexutil.Encode(blockRoot[:])
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			BeaconDB: db,
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
-
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("slot", func(t *testing.T) {
 		u := "http://foo.example/123"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			BeaconDB: db,
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{Block: denebBlock},
+			BeaconDB:         db,
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
-
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		require.Equal(t, 4, len(resp.Data))
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("one blob only", func(t *testing.T) {
 		u := "http://foo.example/123?indices=2"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
-
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusOK, writer.Code)
@@ -235,45 +214,47 @@ func TestBlobs(t *testing.T) {
 		assert.Equal(t, hexutil.Encode(blobs[2].Blob), sidecar.Blob)
 		assert.Equal(t, hexutil.Encode(blobs[2].KzgCommitment), sidecar.KzgCommitment)
 		assert.Equal(t, hexutil.Encode(blobs[2].KzgProof), sidecar.KzgProof)
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("no blobs returns an empty array", func(t *testing.T) {
 		u := "http://foo.example/123"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: filesystem.NewEphemeralBlobStorage(t), // new ephemeral storage
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
 
 		s.Blobs(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		require.Equal(t, len(resp.Data), 0)
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("outside retention period returns 200 w/ empty list ", func(t *testing.T) {
 		u := "http://foo.example/123"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		moc := &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}}
-		blocker := &lookup.BeaconDbBlocker{
+		moc := &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock}
+		s.Blocker = &lookup.BeaconDbBlocker{
 			ChainInfoFetcher:   moc,
 			GenesisTimeFetcher: moc, // genesis time is set to 0 here, so it results in current epoch being extremely large
 			BeaconDB:           db,
 			BlobStorage:        bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
 
 		s.Blobs(writer, request)
 
@@ -281,6 +262,10 @@ func TestBlobs(t *testing.T) {
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		require.Equal(t, 0, len(resp.Data))
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("block without commitments returns 200 w/empty list ", func(t *testing.T) {
 		denebBlock, _ := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 333, 0)
@@ -293,17 +278,14 @@ func TestBlobs(t *testing.T) {
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
-			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
+		s.Blocker = &lookup.BeaconDbBlocker{
+			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}, Block: denebBlock},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
 			},
 			BeaconDB:    db,
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
 
 		s.Blobs(writer, request)
 
@@ -311,16 +293,17 @@ func TestBlobs(t *testing.T) {
 		resp := &structs.SidecarsResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 		require.Equal(t, 0, len(resp.Data))
+
+		require.Equal(t, "deneb", resp.Version)
+		require.Equal(t, false, resp.ExecutionOptimistic)
+		require.Equal(t, false, resp.Finalized)
 	})
 	t.Run("slot before Deneb fork", func(t *testing.T) {
 		u := "http://foo.example/31"
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{}
-		s := &Server{
-			Blocker: blocker,
-		}
+		s.Blocker = &lookup.BeaconDbBlocker{}
 
 		s.Blobs(writer, request)
 
@@ -335,11 +318,7 @@ func TestBlobs(t *testing.T) {
 		request := httptest.NewRequest("GET", u, nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{}
-		s := &Server{
-			Blocker: blocker,
-		}
-
+		s.Blocker = &lookup.BeaconDbBlocker{}
 		s.Blobs(writer, request)
 
 		assert.Equal(t, http.StatusBadRequest, writer.Code)
@@ -354,7 +333,7 @@ func TestBlobs(t *testing.T) {
 		request.Header.Add("Accept", "application/octet-stream")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
+		s.Blocker = &lookup.BeaconDbBlocker{
 			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
@@ -362,10 +341,8 @@ func TestBlobs(t *testing.T) {
 			BeaconDB:    db,
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
 		s.Blobs(writer, request)
+
 		assert.Equal(t, http.StatusOK, writer.Code)
 		require.Equal(t, len(writer.Body.Bytes()), fieldparams.BlobSidecarSize) // size of each sidecar
 		// can directly unmarshal to sidecar since there's only 1
@@ -379,7 +356,7 @@ func TestBlobs(t *testing.T) {
 		request.Header.Add("Accept", "application/octet-stream")
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
-		blocker := &lookup.BeaconDbBlocker{
+		s.Blocker = &lookup.BeaconDbBlocker{
 			ChainInfoFetcher: &mockChain.ChainService{FinalizedCheckPoint: &eth.Checkpoint{Root: blockRoot[:]}},
 			GenesisTimeFetcher: &testutil.MockGenesisTimeFetcher{
 				Genesis: time.Now(),
@@ -387,10 +364,8 @@ func TestBlobs(t *testing.T) {
 			BeaconDB:    db,
 			BlobStorage: bs,
 		}
-		s := &Server{
-			Blocker: blocker,
-		}
 		s.Blobs(writer, request)
+
 		assert.Equal(t, http.StatusOK, writer.Code)
 		require.Equal(t, len(writer.Body.Bytes()), fieldparams.BlobSidecarSize*4) // size of each sidecar
 	})
@@ -426,7 +401,7 @@ func Test_parseIndices(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := parseIndices(&url.URL{RawQuery: tt.query})
+			got, err := parseIndices(&url.URL{RawQuery: tt.query}, 0)
 			if err != nil && tt.wantErr != "" {
 				require.StringContains(t, tt.wantErr, err.Error())
 				return

beacon-chain/rpc/eth/blob/server.go

@@ -1,9 +1,13 @@
 package blob
 
 import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
 )
 
 type Server struct {
-	Blocker lookup.Blocker
+	Blocker               lookup.Blocker
+	OptimisticModeFetcher blockchain.OptimisticModeFetcher
+	FinalizationFetcher   blockchain.FinalizationFetcher
+	TimeFetcher           blockchain.TimeFetcher
 }

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

@@ -190,7 +190,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 156, len(data))
+	assert.Equal(t, 159, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -335,7 +335,7 @@ func TestGetSpec(t *testing.T) {
 			case "MAX_VOLUNTARY_EXITS":
 				assert.Equal(t, "52", v)
 			case "MAX_BLOBS_PER_BLOCK":
-				assert.Equal(t, "4", v)
+				assert.Equal(t, "6", v)
 			case "TIMELY_HEAD_FLAG_INDEX":
 				assert.Equal(t, "0x35", v)
 			case "TIMELY_SOURCE_FLAG_INDEX":
@@ -529,6 +529,10 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "93", v)
 			case "MAX_PENDING_DEPOSITS_PER_EPOCH":
 				assert.Equal(t, "94", v)
+			case "TARGET_BLOBS_PER_BLOCK_ELECTRA":
+				assert.Equal(t, "6", v)
+			case "MAX_BLOBS_PER_BLOCK_ELECTRA":
+				assert.Equal(t, "9", v)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}

beacon-chain/rpc/eth/events/BUILD.bazel

@@ -20,18 +20,20 @@ go_library(
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/payload-attribute:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus:go_default_library",
+        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

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

@@ -12,6 +12,8 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promauto"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
@@ -20,13 +22,13 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	chaintime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	engine "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -76,6 +78,14 @@ var (
 	errWriterUnusable     = errors.New("http response writer is unusable")
 )
 
+var httpSSEErrorCount = promauto.NewCounterVec(
+	prometheus.CounterOpts{
+		Name: "http_sse_error_count",
+		Help: "Total HTTP errors for server sent events endpoint",
+	},
+	[]string{"endpoint", "error"},
+)
+
 // The eventStreamer uses lazyReaders to defer serialization until the moment the value is ready to be written to the client.
 type lazyReader func() io.Reader
 
@@ -145,6 +155,13 @@ func newTopicRequest(topics []string) (*topicRequest, error) {
 // Servers may send SSE comments beginning with ':' for any purpose,
 // including to keep the event stream connection alive in the presence of proxy servers.
 func (s *Server) StreamEvents(w http.ResponseWriter, r *http.Request) {
+	var err error
+	defer func() {
+		if err != nil {
+			httpSSEErrorCount.WithLabelValues(r.URL.Path, err.Error()).Inc()
+		}
+	}()
+
 	log.Debug("Starting StreamEvents handler")
 	ctx, span := trace.StartSpan(r.Context(), "events.StreamEvents")
 	defer span.End()
@@ -174,7 +191,7 @@ func (s *Server) StreamEvents(w http.ResponseWriter, r *http.Request) {
 	defer cancel()
 	es := newEventStreamer(buffSize, ka)
 
-	go es.outboxWriteLoop(ctx, cancel, sw)
+	go es.outboxWriteLoop(ctx, cancel, sw, r.URL.Path)
 	if err := es.recvEventLoop(ctx, cancel, topics, s); err != nil {
 		log.WithError(err).Debug("Shutting down StreamEvents handler.")
 	}
@@ -264,11 +281,12 @@ func newlineReader() io.Reader {
 
 // outboxWriteLoop runs in a separate goroutine. Its job is to write the values in the outbox to
 // the client as fast as the client can read them.
-func (es *eventStreamer) outboxWriteLoop(ctx context.Context, cancel context.CancelFunc, w *streamingResponseWriterController) {
+func (es *eventStreamer) outboxWriteLoop(ctx context.Context, cancel context.CancelFunc, w *streamingResponseWriterController, endpoint string) {
 	var err error
 	defer func() {
 		if err != nil {
 			log.WithError(err).Debug("Event streamer shutting down due to error.")
+			httpSSEErrorCount.WithLabelValues(endpoint, err.Error()).Inc()
 		}
 		es.exit()
 	}()
@@ -413,9 +431,9 @@ func topicForEvent(event *feed.Event) string {
 		return HeadTopic
 	case *ethpb.EventFinalizedCheckpoint:
 		return FinalizedCheckpointTopic
-	case *ethpbv2.LightClientFinalityUpdateWithVersion:
+	case interfaces.LightClientFinalityUpdate:
 		return LightClientFinalityUpdateTopic
-	case *ethpbv2.LightClientOptimisticUpdateWithVersion:
+	case interfaces.LightClientOptimisticUpdate:
 		return LightClientOptimisticUpdateTopic
 	case *ethpb.EventChainReorg:
 		return ChainReorgTopic
@@ -509,25 +527,25 @@ func (s *Server) lazyReaderForEvent(ctx context.Context, event *feed.Event, topi
 		return func() io.Reader {
 			return jsonMarshalReader(eventName, structs.FinalizedCheckpointEventFromV1(v))
 		}, nil
-	case *ethpbv2.LightClientFinalityUpdateWithVersion:
-		cv, err := structs.LightClientFinalityUpdateFromConsensus(v.Data)
+	case interfaces.LightClientFinalityUpdate:
+		cv, err := structs.LightClientFinalityUpdateFromConsensus(v)
 		if err != nil {
-			return nil, errors.Wrap(err, "LightClientFinalityUpdateWithVersion event conversion failure")
+			return nil, errors.Wrap(err, "LightClientFinalityUpdate conversion failure")
 		}
 		ev := &structs.LightClientFinalityUpdateEvent{
-			Version: version.String(int(v.Version)),
+			Version: version.String(v.Version()),
 			Data:    cv,
 		}
 		return func() io.Reader {
 			return jsonMarshalReader(eventName, ev)
 		}, nil
-	case *ethpbv2.LightClientOptimisticUpdateWithVersion:
-		cv, err := structs.LightClientOptimisticUpdateFromConsensus(v.Data)
+	case interfaces.LightClientOptimisticUpdate:
+		cv, err := structs.LightClientOptimisticUpdateFromConsensus(v)
 		if err != nil {
-			return nil, errors.Wrap(err, "LightClientOptimisticUpdateWithVersion event conversion failure")
+			return nil, errors.Wrap(err, "LightClientOptimisticUpdate conversion failure")
 		}
 		ev := &structs.LightClientOptimisticUpdateEvent{
-			Version: version.String(int(v.Version)),
+			Version: version.String(v.Version()),
 			Data:    cv,
 		}
 		return func() io.Reader {

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

@@ -12,7 +12,7 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 )
 
-// Server defines a server implementation of the gRPC events service,
+// Server defines a server implementation of the http events service,
 // providing RPC endpoints to subscribe to events from the beacon node.
 type Server struct {
 	StateNotifier          statefeed.Notifier

beacon-chain/rpc/eth/light-client/BUILD.bazel

@@ -18,16 +18,13 @@ go_library(
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//config/fieldparams:go_default_library",
+        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network/httputil:go_default_library",
-        "//proto/eth/v2:go_default_library",
-        "//proto/migration:go_default_library",
         "//runtime/version:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_wealdtech_go_bytesutil//:go_default_library",
@@ -46,17 +43,19 @@ go_test(
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
+        "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
-        "//proto/eth/v1:go_default_library",
-        "//proto/eth/v2:go_default_library",
+        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
-        "//testing/assert:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",

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

@@ -10,11 +10,11 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/api"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	types "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
@@ -23,6 +23,11 @@ import (
 
 // GetLightClientBootstrap - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/bootstrap.yaml
 func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Request) {
+	if !features.Get().EnableLightClient {
+		httputil.HandleError(w, "Light client feature flag is not enabled", http.StatusNotFound)
+		return
+	}
+
 	// Prepare
 	ctx, span := trace.StartSpan(req.Context(), "beacon.GetLightClientBootstrap")
 	defer span.End()
@@ -47,42 +52,51 @@ func (s *Server) GetLightClientBootstrap(w http.ResponseWriter, req *http.Reques
 		return
 	}
 
-	bootstrap, err := createLightClientBootstrap(ctx, state, blk)
+	bootstrap, err := lightclient.NewLightClientBootstrapFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), state, blk)
 	if err != nil {
 		httputil.HandleError(w, "could not get light client bootstrap: "+err.Error(), http.StatusInternalServerError)
 		return
 	}
-	response := &structs.LightClientBootstrapResponse{
-		Version: version.String(blk.Version()),
-		Data:    bootstrap,
-	}
-	w.Header().Set(api.VersionHeader, version.String(version.Deneb))
+	w.Header().Set(api.VersionHeader, version.String(bootstrap.Version()))
 
-	httputil.WriteJson(w, response)
+	if httputil.RespondWithSsz(req) {
+		ssz, err := bootstrap.MarshalSSZ()
+		if err != nil {
+			httputil.HandleError(w, "could not marshal bootstrap to SSZ: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		httputil.WriteSsz(w, ssz, "light_client_bootstrap.ssz")
+	} else {
+		data, err := structs.LightClientBootstrapFromConsensus(bootstrap)
+		if err != nil {
+			httputil.HandleError(w, "could not marshal bootstrap to JSON: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		response := &structs.LightClientBootstrapResponse{
+			Version: version.String(bootstrap.Version()),
+			Data:    data,
+		}
+		httputil.WriteJson(w, response)
+	}
 }
 
 // GetLightClientUpdatesByRange - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/updates.yaml
 func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.Request) {
-	// Prepare
+	if !features.Get().EnableLightClient {
+		httputil.HandleError(w, "Light client feature flag is not enabled", http.StatusNotFound)
+		return
+	}
+
 	ctx, span := trace.StartSpan(req.Context(), "beacon.GetLightClientUpdatesByRange")
 	defer span.End()
 
-	// Determine slots per period
 	config := params.BeaconConfig()
-	slotsPerPeriod := uint64(config.EpochsPerSyncCommitteePeriod) * uint64(config.SlotsPerEpoch)
 
-	// Adjust count based on configuration
 	_, count, gotCount := shared.UintFromQuery(w, req, "count", true)
 	if !gotCount {
 		return
 	} else if count == 0 {
-		httputil.HandleError(w, fmt.Sprintf("got invalid 'count' query variable '%d': count must be greater than 0", count), http.StatusInternalServerError)
-		return
-	}
-
-	// Determine the start and end periods
-	_, startPeriod, gotStartPeriod := shared.UintFromQuery(w, req, "start_period", true)
-	if !gotStartPeriod {
+		httputil.HandleError(w, fmt.Sprintf("Got invalid 'count' query variable '%d': count must be greater than 0", count), http.StatusBadRequest)
 		return
 	}
 
@@ -90,142 +104,50 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 		count = config.MaxRequestLightClientUpdates
 	}
 
-	// max possible slot is current head
-	headState, err := s.HeadFetcher.HeadState(ctx)
-	if err != nil {
-		httputil.HandleError(w, "could not get head state: "+err.Error(), http.StatusInternalServerError)
+	_, startPeriod, gotStartPeriod := shared.UintFromQuery(w, req, "start_period", true)
+	if !gotStartPeriod {
 		return
 	}
 
-	maxSlot := uint64(headState.Slot())
-
-	// min possible slot is Altair fork period
-	minSlot := uint64(config.AltairForkEpoch) * uint64(config.SlotsPerEpoch)
-
-	// Adjust startPeriod, the end of start period must be later than Altair fork epoch, otherwise, can not get the sync committee votes
-	startPeriodEndSlot := (startPeriod+1)*slotsPerPeriod - 1
-	if startPeriodEndSlot < minSlot {
-		startPeriod = minSlot / slotsPerPeriod
-	}
-
-	// Get the initial endPeriod, then we will adjust
 	endPeriod := startPeriod + count - 1
 
-	// Adjust endPeriod, the end of end period must be earlier than current head slot
-	endPeriodEndSlot := (endPeriod+1)*slotsPerPeriod - 1
-	if endPeriodEndSlot > maxSlot {
-		endPeriod = maxSlot / slotsPerPeriod
+	// get updates
+	updatesMap, err := s.BeaconDB.LightClientUpdates(ctx, startPeriod, endPeriod)
+	if err != nil {
+		httputil.HandleError(w, "Could not get light client updates from DB: "+err.Error(), http.StatusInternalServerError)
+		return
 	}
 
-	// Populate updates
-	var updates []*structs.LightClientUpdateResponse
-	for period := startPeriod; period <= endPeriod; period++ {
-		// Get the last known state of the period,
-		//    1. We wish the block has a parent in the same period if possible
-		//	  2. We wish the block has a state in the same period
-		lastSlotInPeriod := period*slotsPerPeriod + slotsPerPeriod - 1
-		if lastSlotInPeriod > maxSlot {
-			lastSlotInPeriod = maxSlot
-		}
-		firstSlotInPeriod := period * slotsPerPeriod
-
-		// Let's not use the first slot in the period, otherwise the attested header will be in previous period
-		firstSlotInPeriod++
-
-		var state state.BeaconState
-		var block interfaces.ReadOnlySignedBeaconBlock
-		for slot := lastSlotInPeriod; slot >= firstSlotInPeriod; slot-- {
-			state, err = s.Stater.StateBySlot(ctx, types.Slot(slot))
-			if err != nil {
-				continue
-			}
-
-			// Get the block
-			latestBlockHeader := state.LatestBlockHeader()
-			latestStateRoot, err := state.HashTreeRoot(ctx)
-			if err != nil {
-				continue
-			}
-			latestBlockHeader.StateRoot = latestStateRoot[:]
-			blockRoot, err := latestBlockHeader.HashTreeRoot()
-			if err != nil {
-				continue
-			}
-
-			block, err = s.Blocker.Block(ctx, blockRoot[:])
-			if err != nil || block == nil {
-				continue
-			}
-
-			syncAggregate, err := block.Block().Body().SyncAggregate()
-			if err != nil || syncAggregate == nil {
-				continue
-			}
-
-			if syncAggregate.SyncCommitteeBits.Count()*3 < config.SyncCommitteeSize*2 {
-				// Not enough votes
-				continue
-			}
+	updates := make([]*structs.LightClientUpdateResponse, 0, len(updatesMap))
 
+	for i := startPeriod; i <= endPeriod; i++ {
+		update, ok := updatesMap[i]
+		if !ok {
+			// Only return the first contiguous range of updates
 			break
 		}
 
-		if block == nil {
-			// No valid block found for the period
-			continue
-		}
-
-		// Get attested state
-		attestedRoot := block.Block().ParentRoot()
-		attestedBlock, err := s.Blocker.Block(ctx, attestedRoot[:])
-		if err != nil || attestedBlock == nil {
-			continue
-		}
-
-		attestedSlot := attestedBlock.Block().Slot()
-		attestedState, err := s.Stater.StateBySlot(ctx, attestedSlot)
+		updateJson, err := structs.LightClientUpdateFromConsensus(update)
 		if err != nil {
-			continue
+			httputil.HandleError(w, "Could not convert light client update: "+err.Error(), http.StatusInternalServerError)
+			return
 		}
-
-		// Get finalized block
-		var finalizedBlock interfaces.ReadOnlySignedBeaconBlock
-		finalizedCheckPoint := attestedState.FinalizedCheckpoint()
-		if finalizedCheckPoint != nil {
-			finalizedRoot := bytesutil.ToBytes32(finalizedCheckPoint.Root)
-			finalizedBlock, err = s.Blocker.Block(ctx, finalizedRoot[:])
-			if err != nil {
-				finalizedBlock = nil
-			}
-		}
-
-		update, err := newLightClientUpdateFromBeaconState(
-			ctx,
-			state,
-			block,
-			attestedState,
-			attestedBlock,
-			finalizedBlock,
-		)
-
-		if err == nil {
-			updates = append(updates, &structs.LightClientUpdateResponse{
-				Version: version.String(attestedState.Version()),
-				Data:    update,
-			})
+		updateResponse := &structs.LightClientUpdateResponse{
+			Version: version.String(update.Version()),
+			Data:    updateJson,
 		}
+		updates = append(updates, updateResponse)
 	}
-
-	if len(updates) == 0 {
-		httputil.HandleError(w, "no updates found", http.StatusNotFound)
-		return
-	}
-
 	httputil.WriteJson(w, updates)
 }
 
 // GetLightClientFinalityUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/finality_update.yaml
 func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.Request) {
+	if !features.Get().EnableLightClient {
+		httputil.HandleError(w, "Light client feature flag is not enabled", http.StatusNotFound)
+		return
+	}
+
 	ctx, span := trace.StartSpan(req.Context(), "beacon.GetLightClientFinalityUpdate")
 	defer span.End()
 
@@ -268,7 +190,7 @@ func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.R
 		return
 	}
 
-	update, err := newLightClientFinalityUpdateFromBeaconState(ctx, st, block, attestedState, attestedBlock, finalizedBlock)
+	update, err := newLightClientFinalityUpdateFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), st, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client finality update: "+err.Error(), http.StatusInternalServerError)
 		return
@@ -284,6 +206,11 @@ func (s *Server) GetLightClientFinalityUpdate(w http.ResponseWriter, req *http.R
 
 // GetLightClientOptimisticUpdate - implements https://github.com/ethereum/beacon-APIs/blob/263f4ed6c263c967f13279c7a9f5629b51c5fc55/apis/beacon/light_client/optimistic_update.yaml
 func (s *Server) GetLightClientOptimisticUpdate(w http.ResponseWriter, req *http.Request) {
+	if !features.Get().EnableLightClient {
+		httputil.HandleError(w, "Light client feature flag is not enabled", http.StatusNotFound)
+		return
+	}
+
 	ctx, span := trace.StartSpan(req.Context(), "beacon.GetLightClientOptimisticUpdate")
 	defer span.End()
 
@@ -313,7 +240,7 @@ func (s *Server) GetLightClientOptimisticUpdate(w http.ResponseWriter, req *http
 		return
 	}
 
-	update, err := newLightClientOptimisticUpdateFromBeaconState(ctx, st, block, attestedState, attestedBlock)
+	update, err := newLightClientOptimisticUpdateFromBeaconState(ctx, s.ChainInfoFetcher.CurrentSlot(), st, block, attestedState, attestedBlock)
 	if err != nil {
 		httputil.HandleError(w, "Could not get light client optimistic update: "+err.Error(), http.StatusInternalServerError)
 		return

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

@@ -2,274 +2,25 @@ package lightclient
 
 import (
 	"context"
-	"encoding/json"
-	"fmt"
-	"reflect"
 
-	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/proto/migration"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 
-	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	v2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
-func createLightClientBootstrap(ctx context.Context, state state.BeaconState, blk interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
-	switch blk.Version() {
-	case version.Phase0:
-		return nil, fmt.Errorf("light client bootstrap is not supported for phase0")
-	case version.Altair, version.Bellatrix:
-		return createLightClientBootstrapAltair(ctx, state, blk)
-	case version.Capella:
-		return createLightClientBootstrapCapella(ctx, state, blk)
-	case version.Deneb, version.Electra:
-		return createLightClientBootstrapDeneb(ctx, state, blk)
-	}
-	return nil, fmt.Errorf("unsupported block version %s", version.String(blk.Version()))
-}
-
-func createLightClientBootstrapAltair(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
-	// assert compute_epoch_at_slot(state.slot) >= ALTAIR_FORK_EPOCH
-	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().AltairForkEpoch {
-		return nil, fmt.Errorf("light client bootstrap is not supported before Altair, invalid slot %d", state.Slot())
-	}
-
-	// assert state.slot == state.latest_block_header.slot
-	latestBlockHeader := state.LatestBlockHeader()
-	if state.Slot() != latestBlockHeader.Slot {
-		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
-	}
-
-	// header.state_root = hash_tree_root(state)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get state root")
-	}
-	latestBlockHeader.StateRoot = stateRoot[:]
-
-	// assert hash_tree_root(header) == hash_tree_root(block.message)
-	latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get latest block header root")
-	}
-	beaconBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get block root")
-	}
-	if latestBlockHeaderRoot != beaconBlockRoot {
-		return nil, fmt.Errorf("latest block header root %#x not equal to block root %#x", latestBlockHeaderRoot, beaconBlockRoot)
-	}
-
-	lightClientHeaderContainer, err := lightclient.BlockToLightClientHeader(block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert block to light client header")
-	}
-	lightClientHeader := lightClientHeaderContainer.GetHeaderAltair()
-
-	apiLightClientHeader := &structs.LightClientHeader{
-		Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(lightClientHeader.Beacon)),
-	}
-
-	headerJSON, err := json.Marshal(apiLightClientHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert header to raw message")
-	}
-	currentSyncCommittee, err := state.CurrentSyncCommittee()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee")
-	}
-	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee proof")
-	}
-
-	branch := make([]string, fieldparams.SyncCommitteeBranchDepth)
-	for i, proof := range currentSyncCommitteeProof {
-		branch[i] = hexutil.Encode(proof)
-	}
-	result := &structs.LightClientBootstrap{
-		Header:                     headerJSON,
-		CurrentSyncCommittee:       structs.SyncCommitteeFromConsensus(currentSyncCommittee),
-		CurrentSyncCommitteeBranch: branch,
-	}
-
-	return result, nil
-}
-
-func createLightClientBootstrapCapella(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
-	// assert compute_epoch_at_slot(state.slot) >= CAPELLA_FORK_EPOCH
-	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().CapellaForkEpoch {
-		return nil, fmt.Errorf("creating Capella light client bootstrap is not supported before Capella, invalid slot %d", state.Slot())
-	}
-
-	// assert state.slot == state.latest_block_header.slot
-	latestBlockHeader := state.LatestBlockHeader()
-	if state.Slot() != latestBlockHeader.Slot {
-		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
-	}
-
-	// header.state_root = hash_tree_root(state)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get state root")
-	}
-	latestBlockHeader.StateRoot = stateRoot[:]
-
-	// assert hash_tree_root(header) == hash_tree_root(block.message)
-	latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get latest block header root")
-	}
-	beaconBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get block root")
-	}
-	if latestBlockHeaderRoot != beaconBlockRoot {
-		return nil, fmt.Errorf("latest block header root %#x not equal to block root %#x", latestBlockHeaderRoot, beaconBlockRoot)
-	}
-
-	lightClientHeaderContainer, err := lightclient.BlockToLightClientHeader(block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert block to light client header")
-	}
-	lightClientHeader := lightClientHeaderContainer.GetHeaderCapella()
-
-	apiLightClientHeader := &structs.LightClientHeader{
-		Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(lightClientHeader.Beacon)),
-	}
-
-	headerJSON, err := json.Marshal(apiLightClientHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert header to raw message")
-	}
-	currentSyncCommittee, err := state.CurrentSyncCommittee()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee")
-	}
-	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee proof")
-	}
-
-	branch := make([]string, fieldparams.SyncCommitteeBranchDepth)
-	for i, proof := range currentSyncCommitteeProof {
-		branch[i] = hexutil.Encode(proof)
-	}
-	result := &structs.LightClientBootstrap{
-		Header:                     headerJSON,
-		CurrentSyncCommittee:       structs.SyncCommitteeFromConsensus(currentSyncCommittee),
-		CurrentSyncCommitteeBranch: branch,
-	}
-
-	return result, nil
-}
-
-func createLightClientBootstrapDeneb(ctx context.Context, state state.BeaconState, block interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientBootstrap, error) {
-	// assert compute_epoch_at_slot(state.slot) >= DENEB_FORK_EPOCH
-	if slots.ToEpoch(state.Slot()) < params.BeaconConfig().DenebForkEpoch {
-		return nil, fmt.Errorf("creating Deneb light client bootstrap is not supported before Deneb, invalid slot %d", state.Slot())
-	}
-
-	// assert state.slot == state.latest_block_header.slot
-	latestBlockHeader := state.LatestBlockHeader()
-	if state.Slot() != latestBlockHeader.Slot {
-		return nil, fmt.Errorf("state slot %d not equal to latest block header slot %d", state.Slot(), latestBlockHeader.Slot)
-	}
-
-	// header.state_root = hash_tree_root(state)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get state root")
-	}
-	latestBlockHeader.StateRoot = stateRoot[:]
-
-	// assert hash_tree_root(header) == hash_tree_root(block.message)
-	latestBlockHeaderRoot, err := latestBlockHeader.HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get latest block header root")
-	}
-	beaconBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get block root")
-	}
-	if latestBlockHeaderRoot != beaconBlockRoot {
-		return nil, fmt.Errorf("latest block header root %#x not equal to block root %#x", latestBlockHeaderRoot, beaconBlockRoot)
-	}
-
-	lightClientHeaderContainer, err := lightclient.BlockToLightClientHeader(block)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert block to light client header")
-	}
-	lightClientHeader := lightClientHeaderContainer.GetHeaderDeneb()
-
-	apiLightClientHeader := &structs.LightClientHeader{
-		Beacon: structs.BeaconBlockHeaderFromConsensus(migration.V1HeaderToV1Alpha1(lightClientHeader.Beacon)),
-	}
-
-	headerJSON, err := json.Marshal(apiLightClientHeader)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not convert header to raw message")
-	}
-	currentSyncCommittee, err := state.CurrentSyncCommittee()
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee")
-	}
-	currentSyncCommitteeProof, err := state.CurrentSyncCommitteeProof(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get current sync committee proof")
-	}
-	var branch []string
-	switch block.Version() {
-	case version.Deneb:
-		branch = make([]string, fieldparams.SyncCommitteeBranchDepth)
-	case version.Electra:
-		branch = make([]string, fieldparams.SyncCommitteeBranchDepthElectra)
-	}
-	for i, proof := range currentSyncCommitteeProof {
-		branch[i] = hexutil.Encode(proof)
-	}
-	result := &structs.LightClientBootstrap{
-		Header:                     headerJSON,
-		CurrentSyncCommittee:       structs.SyncCommitteeFromConsensus(currentSyncCommittee),
-		CurrentSyncCommitteeBranch: branch,
-	}
-
-	return result, nil
-}
-
-func newLightClientUpdateFromBeaconState(
-	ctx context.Context,
-	state state.BeaconState,
-	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState,
-	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
-) (*structs.LightClientUpdate, error) {
-	result, err := lightclient.NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
-	if err != nil {
-		return nil, err
-	}
-
-	return structs.LightClientUpdateFromConsensus(result)
-}
-
 func newLightClientFinalityUpdateFromBeaconState(
 	ctx context.Context,
+	currentSlot primitives.Slot,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*structs.LightClientFinalityUpdate, error) {
-	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
+	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, currentSlot, state, block, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -279,94 +30,16 @@ func newLightClientFinalityUpdateFromBeaconState(
 
 func newLightClientOptimisticUpdateFromBeaconState(
 	ctx context.Context,
+	currentSlot primitives.Slot,
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) (*structs.LightClientOptimisticUpdate, error) {
-	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock)
+	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, currentSlot, state, block, attestedState, attestedBlock)
 	if err != nil {
 		return nil, err
 	}
 
 	return structs.LightClientOptimisticUpdateFromConsensus(result)
 }
-
-func IsSyncCommitteeUpdate(update *v2.LightClientUpdate) bool {
-	nextSyncCommitteeBranch := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
-	return !reflect.DeepEqual(update.NextSyncCommitteeBranch, nextSyncCommitteeBranch)
-}
-
-func IsFinalityUpdate(update *v2.LightClientUpdate) bool {
-	finalityBranch := make([][]byte, lightclient.FinalityBranchNumOfLeaves)
-	return !reflect.DeepEqual(update.FinalityBranch, finalityBranch)
-}
-
-func IsBetterUpdate(newUpdate, oldUpdate *v2.LightClientUpdate) (bool, error) {
-	maxActiveParticipants := newUpdate.SyncAggregate.SyncCommitteeBits.Len()
-	newNumActiveParticipants := newUpdate.SyncAggregate.SyncCommitteeBits.Count()
-	oldNumActiveParticipants := oldUpdate.SyncAggregate.SyncCommitteeBits.Count()
-	newHasSupermajority := newNumActiveParticipants*3 >= maxActiveParticipants*2
-	oldHasSupermajority := oldNumActiveParticipants*3 >= maxActiveParticipants*2
-
-	if newHasSupermajority != oldHasSupermajority {
-		return newHasSupermajority, nil
-	}
-	if !newHasSupermajority && newNumActiveParticipants != oldNumActiveParticipants {
-		return newNumActiveParticipants > oldNumActiveParticipants, nil
-	}
-
-	newUpdateAttestedHeaderBeacon, err := newUpdate.AttestedHeader.GetBeacon()
-	if err != nil {
-		return false, errors.Wrap(err, "could not get attested header beacon")
-	}
-	oldUpdateAttestedHeaderBeacon, err := oldUpdate.AttestedHeader.GetBeacon()
-	if err != nil {
-		return false, errors.Wrap(err, "could not get attested header beacon")
-	}
-
-	// Compare presence of relevant sync committee
-	newHasRelevantSyncCommittee := IsSyncCommitteeUpdate(newUpdate) && (slots.SyncCommitteePeriod(slots.ToEpoch(newUpdateAttestedHeaderBeacon.Slot)) == slots.SyncCommitteePeriod(slots.ToEpoch(newUpdate.SignatureSlot)))
-	oldHasRelevantSyncCommittee := IsSyncCommitteeUpdate(oldUpdate) && (slots.SyncCommitteePeriod(slots.ToEpoch(oldUpdateAttestedHeaderBeacon.Slot)) == slots.SyncCommitteePeriod(slots.ToEpoch(oldUpdate.SignatureSlot)))
-
-	if newHasRelevantSyncCommittee != oldHasRelevantSyncCommittee {
-		return newHasRelevantSyncCommittee, nil
-	}
-
-	// Compare indication of any finality
-	newHasFinality := IsFinalityUpdate(newUpdate)
-	oldHasFinality := IsFinalityUpdate(oldUpdate)
-	if newHasFinality != oldHasFinality {
-		return newHasFinality, nil
-	}
-
-	newUpdateFinalizedHeaderBeacon, err := newUpdate.FinalizedHeader.GetBeacon()
-	if err != nil {
-		return false, errors.Wrap(err, "could not get finalized header beacon")
-	}
-	oldUpdateFinalizedHeaderBeacon, err := oldUpdate.FinalizedHeader.GetBeacon()
-	if err != nil {
-		return false, errors.Wrap(err, "could not get finalized header beacon")
-	}
-
-	// Compare sync committee finality
-	if newHasFinality {
-		newHasSyncCommitteeFinality := slots.SyncCommitteePeriod(slots.ToEpoch(newUpdateFinalizedHeaderBeacon.Slot)) == slots.SyncCommitteePeriod(slots.ToEpoch(newUpdateAttestedHeaderBeacon.Slot))
-		oldHasSyncCommitteeFinality := slots.SyncCommitteePeriod(slots.ToEpoch(oldUpdateFinalizedHeaderBeacon.Slot)) == slots.SyncCommitteePeriod(slots.ToEpoch(oldUpdateAttestedHeaderBeacon.Slot))
-
-		if newHasSyncCommitteeFinality != oldHasSyncCommitteeFinality {
-			return newHasSyncCommitteeFinality, nil
-		}
-	}
-
-	// Tiebreaker 1: Sync committee participation beyond supermajority
-	if newNumActiveParticipants != oldNumActiveParticipants {
-		return newNumActiveParticipants > oldNumActiveParticipants, nil
-	}
-
-	// Tiebreaker 2: Prefer older data (fewer changes to best)
-	if newUpdateAttestedHeaderBeacon.Slot != oldUpdateAttestedHeaderBeacon.Slot {
-		return newUpdateAttestedHeaderBeacon.Slot < oldUpdateAttestedHeaderBeacon.Slot, nil
-	}
-	return newUpdate.SignatureSlot < oldUpdate.SignatureSlot, nil
-}

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

@@ -1,616 +1 @@
 package lightclient
-
-import (
-	"testing"
-
-	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
-
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	"github.com/prysmaticlabs/prysm/v5/testing/assert"
-)
-
-// When the update has relevant sync committee
-func createNonEmptySyncCommitteeBranch() [][]byte {
-	res := make([][]byte, fieldparams.SyncCommitteeBranchDepth)
-	res[0] = []byte("xyz")
-	return res
-}
-
-// When the update has finality
-func createNonEmptyFinalityBranch() [][]byte {
-	res := make([][]byte, lightclient.FinalityBranchNumOfLeaves)
-	res[0] = []byte("xyz")
-	return res
-}
-
-func TestIsBetterUpdate(t *testing.T) {
-	testCases := []struct {
-		name           string
-		oldUpdate      *ethpbv2.LightClientUpdate
-		newUpdate      *ethpbv2.LightClientUpdate
-		expectedResult bool
-	}{
-		{
-			name: "new has supermajority but old doesn't",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b11111100, 0b1}, // [0,0,1,1,1,1,1,1]
-				},
-			},
-			expectedResult: true,
-		},
-		{
-			name: "old has supermajority but new doesn't",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b11111100, 0b1}, // [0,0,1,1,1,1,1,1]
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-				},
-			},
-			expectedResult: false,
-		},
-		{
-			name: "new doesn't have supermajority and newNumActiveParticipants is greater than oldNumActiveParticipants",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-				},
-			},
-			expectedResult: true,
-		},
-		{
-			name: "new doesn't have supermajority and newNumActiveParticipants is lesser than oldNumActiveParticipants",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,0,1,1,1,1,1,0]
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-			},
-			expectedResult: false,
-		},
-		{
-			name: "new has relevant sync committee but old doesn't",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: make([][]byte, fieldparams.SyncCommitteeBranchDepth),
-				SignatureSlot:           9999,
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000001,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           1000000,
-			},
-			expectedResult: true,
-		},
-		{
-			name: "old has relevant sync committee but new doesn't",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000001,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           1000000,
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: make([][]byte, fieldparams.SyncCommitteeBranchDepth),
-				SignatureSlot:           9999,
-			},
-			expectedResult: false,
-		},
-		{
-			name: "new has finality but old doesn't",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          make([][]byte, lightclient.FinalityBranchNumOfLeaves),
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-			},
-			expectedResult: true,
-		},
-		{
-			name: "old has finality but new doesn't",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          make([][]byte, lightclient.FinalityBranchNumOfLeaves),
-			},
-			expectedResult: false,
-		},
-		{
-			name: "new has finality and sync committee finality both but old doesn't have sync committee finality",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           999999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 999999,
-						}},
-					},
-				},
-			},
-			expectedResult: true,
-		},
-		{
-			name: "new has finality but doesn't have sync committee finality and old has sync committee finality",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           999999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 999999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: false,
-		},
-		{
-			name: "new has more active participants than old",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,1,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: true,
-		},
-		{
-			name: "new has less active participants than old",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b01111100, 0b1}, // [0,1,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: false,
-		},
-		{
-			name: "new's attested header's slot is lesser than old's attested header's slot",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 999999,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: true,
-		},
-		{
-			name: "new's attested header's slot is greater than old's attested header's slot",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 999999,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: false,
-		},
-		{
-			name: "none of the above conditions are met and new signature's slot is less than old signature's slot",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9998,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: true,
-		},
-		{
-			name: "none of the above conditions are met and new signature's slot is greater than old signature's slot",
-			oldUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9998,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			newUpdate: &ethpbv2.LightClientUpdate{
-				SyncAggregate: &ethpbv1.SyncAggregate{
-					SyncCommitteeBits: []byte{0b00111100, 0b1}, // [0,0,1,1,1,1,0,0]
-				},
-				AttestedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 1000000,
-						}},
-					},
-				},
-				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
-				SignatureSlot:           9999,
-				FinalityBranch:          createNonEmptyFinalityBranch(),
-				FinalizedHeader: &ethpbv2.LightClientHeaderContainer{
-					Header: &ethpbv2.LightClientHeaderContainer_HeaderAltair{
-						HeaderAltair: &ethpbv2.LightClientHeader{Beacon: &ethpbv1.BeaconBlockHeader{
-							Slot: 9999,
-						}},
-					},
-				},
-			},
-			expectedResult: false,
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			result, err := IsBetterUpdate(testCase.newUpdate, testCase.oldUpdate)
-			assert.NoError(t, err)
-			assert.Equal(t, testCase.expectedResult, result)
-		})
-	}
-}

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

@@ -7,8 +7,9 @@ import (
 )
 
 type Server struct {
-	Blocker     lookup.Blocker
-	Stater      lookup.Stater
-	HeadFetcher blockchain.HeadFetcher
-	BeaconDB    db.HeadAccessDatabase
+	Blocker          lookup.Blocker
+	Stater           lookup.Stater
+	HeadFetcher      blockchain.HeadFetcher
+	ChainInfoFetcher blockchain.ChainInfoFetcher
+	BeaconDB         db.HeadAccessDatabase
 }

beacon-chain/rpc/lookup/blocker.go

@@ -235,7 +235,7 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []uint64
 		return make([]*blocks.VerifiedROBlob, 0), nil
 	}
 	if len(indices) == 0 {
-		m, err := p.BlobStorage.Indices(bytesutil.ToBytes32(root))
+		m, err := p.BlobStorage.Indices(bytesutil.ToBytes32(root), b.Block().Slot())
 		if err != nil {
 			log.WithFields(log.Fields{
 				"blockRoot": hexutil.Encode(root),
@@ -244,6 +244,9 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []uint64
 		}
 		for k, v := range m {
 			if v {
+				if k >= len(commitments) {
+					return nil, &core.RpcError{Err: fmt.Errorf("blob index %d is more than blob kzg commitments :%dd", k, len(commitments)), Reason: core.BadRequest}
+				}
 				indices = append(indices, uint64(k))
 			}
 		}

beacon-chain/rpc/prysm/v1alpha1/beacon/attestations_test.go

@@ -765,6 +765,8 @@ func TestServer_ListIndexedAttestationsElectra(t *testing.T) {
 		cb := primitives.NewAttestationCommitteeBits()
 		cb.SetBitAt(0, true)
 		blockExample := util.NewBeaconBlockElectra()
+		ab := bitfield.NewBitlist(128 / uint64(params.BeaconConfig().SlotsPerEpoch))
+		ab.SetBitAt(0, true)
 		blockExample.Block.Body.Attestations = []*ethpb.AttestationElectra{
 			{
 				Signature: make([]byte, fieldparams.BLSSignatureLength),
@@ -778,7 +780,7 @@ func TestServer_ListIndexedAttestationsElectra(t *testing.T) {
 					},
 					Slot: i,
 				},
-				AggregationBits: bitfield.NewBitlist(128 / uint64(params.BeaconConfig().SlotsPerEpoch)),
+				AggregationBits: ab,
 				CommitteeBits:   cb,
 			},
 		}

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

@@ -99,14 +99,18 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	}
 
 	resp, err := vs.BuildBlockParallel(ctx, sBlk, head, req.SkipMevBoost, builderBoostFactor)
-	log.WithFields(logrus.Fields{
+	log := log.WithFields(logrus.Fields{
 		"slot":               req.Slot,
 		"sinceSlotStartTime": time.Since(t),
 		"validator":          sBlk.Block().ProposerIndex(),
-	}).Info("Finished building block")
+	})
+
 	if err != nil {
+		log.WithError(err).Error("Finished building block")
 		return nil, errors.Wrap(err, "could not build block in parallel")
 	}
+
+	log.Info("Finished building block")
 	return resp, nil
 }
 
@@ -236,7 +240,12 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 		// There's no reason to try to get a builder bid if local override is true.
 		var builderBid builderapi.Bid
 		if !(local.OverrideBuilder || skipMevBoost) {
-			builderBid, err = vs.getBuilderPayloadAndBlobs(ctx, sBlk.Block().Slot(), sBlk.Block().ProposerIndex())
+			latestHeader, err := head.LatestExecutionPayloadHeader()
+			if err != nil {
+				return nil, status.Errorf(codes.Internal, "Could not get latest execution payload header: %v", err)
+			}
+			parentGasLimit := latestHeader.GasLimit()
+			builderBid, err = vs.getBuilderPayloadAndBlobs(ctx, sBlk.Block().Slot(), sBlk.Block().ProposerIndex(), parentGasLimit)
 			if err != nil {
 				builderGetPayloadMissCount.Inc()
 				log.WithError(err).Error("Could not get builder payload")

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

@@ -51,6 +51,7 @@ var emptyTransactionsRoot = [32]byte{127, 254, 36, 30, 166, 1, 135, 253, 176, 24
 // blockBuilderTimeout is the maximum amount of time allowed for a block builder to respond to a
 // block request. This value is known as `BUILDER_PROPOSAL_DELAY_TOLERANCE` in builder spec.
 const blockBuilderTimeout = 1 * time.Second
+const gasLimitAdjustmentFactor = 1024
 
 // Sets the execution data for the block. Execution data can come from local EL client or remote builder depends on validator registration and circuit breaker conditions.
 func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse, bid builder.Bid, builderBoostFactor primitives.Gwei) (primitives.Wei, *enginev1.BlobsBundle, error) {
@@ -170,7 +171,11 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 
 // This function retrieves the payload header and kzg commitments given the slot number and the validator index.
 // It's a no-op if the latest head block is not versioned bellatrix.
-func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot primitives.Slot, idx primitives.ValidatorIndex) (builder.Bid, error) {
+func (vs *Server) getPayloadHeaderFromBuilder(
+	ctx context.Context,
+	slot primitives.Slot,
+	idx primitives.ValidatorIndex,
+	parentGasLimit uint64) (builder.Bid, error) {
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.getPayloadHeaderFromBuilder")
 	defer span.End()
 
@@ -247,8 +252,9 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot primitiv
 	if err != nil {
 		log.WithError(err).Warn("Proposer: failed to get registration by validator ID, could not check gas limit")
 	} else {
-		if reg.GasLimit != header.GasLimit() {
-			return nil, fmt.Errorf("incorrect header gas limit %d != %d", reg.GasLimit, header.GasLimit())
+		gasLimit := expectedGasLimit(parentGasLimit, reg.GasLimit)
+		if gasLimit != header.GasLimit() {
+			return nil, fmt.Errorf("incorrect header gas limit %d != %d", gasLimit, header.GasLimit())
 		}
 	}
 
@@ -264,13 +270,14 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot primitiv
 		return nil, errors.Wrap(err, "could not validate builder signature")
 	}
 
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	var kzgCommitments [][]byte
 	if bid.Version() >= version.Deneb {
 		kzgCommitments, err = bid.BlobKzgCommitments()
 		if err != nil {
 			return nil, errors.Wrap(err, "could not get blob kzg commitments")
 		}
-		if len(kzgCommitments) > fieldparams.MaxBlobsPerBlock {
+		if len(kzgCommitments) > maxBlobsPerBlock {
 			return nil, fmt.Errorf("builder returned too many kzg commitments: %d", len(kzgCommitments))
 		}
 		for _, c := range kzgCommitments {
@@ -402,3 +409,32 @@ func setExecution(blk interfaces.SignedBeaconBlock, execution interfaces.Executi
 
 	return nil
 }
+
+// Calculates expected gas limit based on parent gas limit and target gas limit.
+// Spec code:
+//
+//	def expected_gas_limit(parent_gas_limit, target_gas_limit, adjustment_factor):
+//	 max_gas_limit_difference = (parent_gas_limit // adjustment_factor) - 1
+//	 if target_gas_limit > parent_gas_limit:
+//	     gas_diff = target_gas_limit - parent_gas_limit
+//	     return parent_gas_limit + min(gas_diff, max_gas_limit_difference)
+//	 else:
+//	     gas_diff = parent_gas_limit - target_gas_limit
+//	     return parent_gas_limit - min(gas_diff, max_gas_limit_difference)
+func expectedGasLimit(parentGasLimit, proposerGasLimit uint64) uint64 {
+	maxGasLimitDiff := uint64(0)
+	if parentGasLimit > gasLimitAdjustmentFactor {
+		maxGasLimitDiff = parentGasLimit/gasLimitAdjustmentFactor - 1
+	}
+	if proposerGasLimit > parentGasLimit {
+		if proposerGasLimit-parentGasLimit > maxGasLimitDiff {
+			return parentGasLimit + maxGasLimitDiff
+		}
+		return proposerGasLimit
+	}
+
+	if parentGasLimit-proposerGasLimit > maxGasLimitDiff {
+		return parentGasLimit - maxGasLimitDiff
+	}
+	return proposerGasLimit
+}

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

@@ -94,14 +94,14 @@ func TestServer_setExecutionData(t *testing.T) {
 		ForkchoiceFetcher:      &blockchainTest.ChainService{},
 		TrackedValidatorsCache: cache.NewTrackedValidatorsCache(),
 	}
-
+	gasLimit := uint64(30000000)
 	t.Run("No builder configured. Use local block", func(t *testing.T) {
 		blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockCapella())
 		require.NoError(t, err)
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		require.IsNil(t, builderBid)
 		_, bundle, err := setExecutionData(context.Background(), blk, res, builderBid, defaultBuilderBoostFactor)
@@ -115,7 +115,11 @@ func TestServer_setExecutionData(t *testing.T) {
 		blk, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockCapella())
 		require.NoError(t, err)
 		require.NoError(t, vs.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{blk.Block().ProposerIndex()},
-			[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: make([]byte, fieldparams.FeeRecipientLength), Timestamp: uint64(time.Now().Unix()), Pubkey: make([]byte, fieldparams.BLSPubkeyLength)}}))
+			[]*ethpb.ValidatorRegistrationV1{{
+				FeeRecipient: make([]byte, fieldparams.FeeRecipientLength),
+				Timestamp:    uint64(time.Now().Unix()),
+				GasLimit:     gasLimit,
+				Pubkey:       make([]byte, fieldparams.BLSPubkeyLength)}}))
 		ti, err := slots.ToTime(uint64(time.Now().Unix()), 0)
 		require.NoError(t, err)
 		sk, err := bls.RandKey()
@@ -135,6 +139,7 @@ func TestServer_setExecutionData(t *testing.T) {
 				BlockHash:        make([]byte, fieldparams.RootLength),
 				TransactionsRoot: bytesutil.PadTo([]byte{1}, fieldparams.RootLength),
 				WithdrawalsRoot:  make([]byte, fieldparams.RootLength),
+				GasLimit:         gasLimit,
 			},
 			Pubkey: sk.PublicKey().Marshal(),
 			Value:  bytesutil.PadTo([]byte{1}, 32),
@@ -164,7 +169,7 @@ func TestServer_setExecutionData(t *testing.T) {
 
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		_, err = builderBid.Header()
 		require.NoError(t, err)
@@ -184,7 +189,11 @@ func TestServer_setExecutionData(t *testing.T) {
 		blk, err := blocks.NewSignedBeaconBlock(util.NewBlindedBeaconBlockCapella())
 		require.NoError(t, err)
 		require.NoError(t, vs.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{blk.Block().ProposerIndex()},
-			[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: make([]byte, fieldparams.FeeRecipientLength), Timestamp: uint64(time.Now().Unix()), Pubkey: make([]byte, fieldparams.BLSPubkeyLength)}}))
+			[]*ethpb.ValidatorRegistrationV1{{
+				FeeRecipient: make([]byte, fieldparams.FeeRecipientLength),
+				Timestamp:    uint64(time.Now().Unix()),
+				GasLimit:     gasLimit,
+				Pubkey:       make([]byte, fieldparams.BLSPubkeyLength)}}))
 		ti, err := slots.ToTime(uint64(time.Now().Unix()), 0)
 		require.NoError(t, err)
 		sk, err := bls.RandKey()
@@ -207,6 +216,7 @@ func TestServer_setExecutionData(t *testing.T) {
 				BlockHash:        make([]byte, fieldparams.RootLength),
 				TransactionsRoot: bytesutil.PadTo([]byte{1}, fieldparams.RootLength),
 				WithdrawalsRoot:  wr[:],
+				GasLimit:         gasLimit,
 			},
 			Pubkey: sk.PublicKey().Marshal(),
 			Value:  bytesutil.PadTo(builderValue, 32),
@@ -236,7 +246,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		_, err = builderBid.Header()
 		require.NoError(t, err)
@@ -256,7 +266,11 @@ func TestServer_setExecutionData(t *testing.T) {
 		blk, err := blocks.NewSignedBeaconBlock(util.NewBlindedBeaconBlockCapella())
 		require.NoError(t, err)
 		require.NoError(t, vs.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{blk.Block().ProposerIndex()},
-			[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: make([]byte, fieldparams.FeeRecipientLength), Timestamp: uint64(time.Now().Unix()), Pubkey: make([]byte, fieldparams.BLSPubkeyLength)}}))
+			[]*ethpb.ValidatorRegistrationV1{{
+				FeeRecipient: make([]byte, fieldparams.FeeRecipientLength),
+				Timestamp:    uint64(time.Now().Unix()),
+				GasLimit:     gasLimit,
+				Pubkey:       make([]byte, fieldparams.BLSPubkeyLength)}}))
 		ti, err := slots.ToTime(uint64(time.Now().Unix()), 0)
 		require.NoError(t, err)
 		sk, err := bls.RandKey()
@@ -278,6 +292,7 @@ func TestServer_setExecutionData(t *testing.T) {
 				Timestamp:        uint64(ti.Unix()),
 				BlockNumber:      2,
 				WithdrawalsRoot:  wr[:],
+				GasLimit:         gasLimit,
 			},
 			Pubkey: sk.PublicKey().Marshal(),
 			Value:  bytesutil.PadTo(builderValue, 32),
@@ -307,7 +322,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		_, err = builderBid.Header()
 		require.NoError(t, err)
@@ -327,7 +342,11 @@ func TestServer_setExecutionData(t *testing.T) {
 		blk, err := blocks.NewSignedBeaconBlock(util.NewBlindedBeaconBlockCapella())
 		require.NoError(t, err)
 		require.NoError(t, vs.BeaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{blk.Block().ProposerIndex()},
-			[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: make([]byte, fieldparams.FeeRecipientLength), Timestamp: uint64(time.Now().Unix()), Pubkey: make([]byte, fieldparams.BLSPubkeyLength)}}))
+			[]*ethpb.ValidatorRegistrationV1{{
+				FeeRecipient: make([]byte, fieldparams.FeeRecipientLength),
+				Timestamp:    uint64(time.Now().Unix()),
+				GasLimit:     gasLimit,
+				Pubkey:       make([]byte, fieldparams.BLSPubkeyLength)}}))
 		ti, err := slots.ToTime(uint64(time.Now().Unix()), 0)
 		require.NoError(t, err)
 		sk, err := bls.RandKey()
@@ -349,6 +368,7 @@ func TestServer_setExecutionData(t *testing.T) {
 				Timestamp:        uint64(ti.Unix()),
 				BlockNumber:      2,
 				WithdrawalsRoot:  wr[:],
+				GasLimit:         gasLimit,
 			},
 			Pubkey: sk.PublicKey().Marshal(),
 			Value:  bytesutil.PadTo(builderValue, 32),
@@ -378,7 +398,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		_, err = builderBid.Header()
 		require.NoError(t, err)
@@ -404,7 +424,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		_, err = builderBid.Header()
 		require.NoError(t, err)
@@ -436,7 +456,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		_, err = builderBid.Header()
 		require.NoError(t, err)
@@ -471,7 +491,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		builderKzgCommitments, err := builderBid.BlobKzgCommitments()
 		if builderBid.Version() >= version.Deneb {
@@ -503,7 +523,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		b := blk.Block()
 		res, err := vs.getLocalPayload(ctx, b, capellaTransitionState)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, b.Slot(), b.ProposerIndex(), gasLimit)
 		require.ErrorIs(t, consensus_types.ErrNilObjectWrapped, err) // Builder returns fault. Use local block
 		require.IsNil(t, builderBid)
 		_, bundle, err := setExecutionData(context.Background(), blk, res, nil, defaultBuilderBoostFactor)
@@ -578,6 +598,7 @@ func TestServer_setExecutionData(t *testing.T) {
 				WithdrawalsRoot:  wr[:],
 				BlobGasUsed:      123,
 				ExcessBlobGas:    456,
+				GasLimit:         gasLimit,
 			},
 			Pubkey:             sk.PublicKey().Marshal(),
 			Value:              bytesutil.PadTo(builderValue, 32),
@@ -599,7 +620,11 @@ func TestServer_setExecutionData(t *testing.T) {
 			Cfg:           &builderTest.Config{BeaconDB: beaconDB},
 		}
 		require.NoError(t, beaconDB.SaveRegistrationsByValidatorIDs(ctx, []primitives.ValidatorIndex{blk.Block().ProposerIndex()},
-			[]*ethpb.ValidatorRegistrationV1{{FeeRecipient: make([]byte, fieldparams.FeeRecipientLength), Timestamp: uint64(time.Now().Unix()), Pubkey: make([]byte, fieldparams.BLSPubkeyLength)}}))
+			[]*ethpb.ValidatorRegistrationV1{{
+				FeeRecipient: make([]byte, fieldparams.FeeRecipientLength),
+				Timestamp:    uint64(time.Now().Unix()),
+				GasLimit:     gasLimit,
+				Pubkey:       make([]byte, fieldparams.BLSPubkeyLength)}}))
 
 		wb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockDeneb())
 		require.NoError(t, err)
@@ -619,7 +644,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		require.NoError(t, err)
 		blk.SetSlot(primitives.Slot(params.BeaconConfig().DenebForkEpoch) * params.BeaconConfig().SlotsPerEpoch)
 		require.NoError(t, err)
-		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, blk.Block().Slot(), blk.Block().ProposerIndex())
+		builderBid, err := vs.getBuilderPayloadAndBlobs(ctx, blk.Block().Slot(), blk.Block().ProposerIndex(), gasLimit)
 		require.NoError(t, err)
 		builderPayload, err := builderBid.Header()
 		require.NoError(t, err)
@@ -660,6 +685,8 @@ func TestServer_getPayloadHeader(t *testing.T) {
 
 	sk, err := bls.RandKey()
 	require.NoError(t, err)
+
+	gasLimit := uint64(30000000)
 	bid := &ethpb.BuilderBid{
 		Header: &v1.ExecutionPayloadHeader{
 			FeeRecipient:     make([]byte, fieldparams.FeeRecipientLength),
@@ -672,6 +699,7 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			TransactionsRoot: bytesutil.PadTo([]byte{1}, fieldparams.RootLength),
 			ParentHash:       params.BeaconConfig().ZeroHash[:],
 			Timestamp:        uint64(ti.Unix()),
+			GasLimit:         gasLimit,
 		},
 		Pubkey: sk.PublicKey().Marshal(),
 		Value:  bytesutil.PadTo([]byte{1, 2, 3}, 32),
@@ -709,6 +737,7 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			ParentHash:       params.BeaconConfig().ZeroHash[:],
 			Timestamp:        uint64(tiCapella.Unix()),
 			WithdrawalsRoot:  wr[:],
+			GasLimit:         gasLimit,
 		},
 		Pubkey: sk.PublicKey().Marshal(),
 		Value:  bytesutil.PadTo([]byte{1, 2, 3}, 32),
@@ -732,7 +761,7 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			TransactionsRoot: bytesutil.PadTo([]byte{1}, fieldparams.RootLength),
 			ParentHash:       params.BeaconConfig().ZeroHash[:],
 			Timestamp:        uint64(tiCapella.Unix()),
-			GasLimit:         100,
+			GasLimit:         31000000,
 		},
 		Pubkey: sk.PublicKey().Marshal(),
 		Value:  bytesutil.PadTo([]byte{1, 2, 3}, 32),
@@ -743,7 +772,6 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			Signature: sk.Sign(srCapella[:]).Marshal(),
 		}
 
-	require.NoError(t, err)
 	tests := []struct {
 		name                  string
 		head                  interfaces.ReadOnlySignedBeaconBlock
@@ -855,21 +883,6 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			},
 			err: "is different from head block version",
 		},
-		{
-			name: "incorrect gas limit",
-			mock: &builderTest.MockBuilderService{
-				Bid: signedIncorrectGasLimitBid,
-			},
-			fetcher: &blockchainTest.ChainService{
-				Block: func() interfaces.ReadOnlySignedBeaconBlock {
-					wb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockBellatrix())
-					require.NoError(t, err)
-					wb.SetSlot(primitives.Slot(params.BeaconConfig().BellatrixForkEpoch) * params.BeaconConfig().SlotsPerEpoch)
-					return wb
-				}(),
-			},
-			err: "incorrect header gas limit 0 != 100",
-		},
 		{
 			name: "different bid version during hard fork",
 			mock: &builderTest.MockBuilderService{
@@ -885,6 +898,21 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			},
 			returnedHeaderCapella: bidCapella.Header,
 		},
+		{
+			name: "incorrect gas limit",
+			mock: &builderTest.MockBuilderService{
+				Bid: signedIncorrectGasLimitBid,
+			},
+			fetcher: &blockchainTest.ChainService{
+				Block: func() interfaces.ReadOnlySignedBeaconBlock {
+					wb, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockBellatrix())
+					require.NoError(t, err)
+					wb.SetSlot(primitives.Slot(params.BeaconConfig().BellatrixForkEpoch) * params.BeaconConfig().SlotsPerEpoch)
+					return wb
+				}(),
+			},
+			err: "incorrect header gas limit 30000000 != 31000000",
+		},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
@@ -894,7 +922,7 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			regCache := cache.NewRegistrationCache()
 			regCache.UpdateIndexToRegisteredMap(context.Background(), map[primitives.ValidatorIndex]*ethpb.ValidatorRegistrationV1{
 				0: {
-					GasLimit:     0,
+					GasLimit:     gasLimit,
 					FeeRecipient: make([]byte, 20),
 					Pubkey:       make([]byte, 48),
 				},
@@ -902,7 +930,7 @@ func TestServer_getPayloadHeader(t *testing.T) {
 			tc.mock.RegistrationCache = regCache
 			hb, err := vs.HeadFetcher.HeadBlock(context.Background())
 			require.NoError(t, err)
-			bid, err := vs.getPayloadHeaderFromBuilder(context.Background(), hb.Block().Slot(), 0)
+			bid, err := vs.getPayloadHeaderFromBuilder(context.Background(), hb.Block().Slot(), 0, 30000000)
 			if tc.err != "" {
 				require.ErrorContains(t, tc.err, err)
 			} else {
@@ -1018,3 +1046,87 @@ func TestEmptyTransactionsRoot(t *testing.T) {
 	require.NoError(t, err)
 	require.DeepEqual(t, r, emptyTransactionsRoot)
 }
+
+func Test_expectedGasLimit(t *testing.T) {
+	type args struct {
+		parentGasLimit uint64
+		targetGasLimit uint64
+	}
+	tests := []struct {
+		name string
+		args args
+		want uint64
+	}{
+		{
+			name: "Increase within limit",
+			args: args{
+				parentGasLimit: 15000000,
+				targetGasLimit: 15000100,
+			},
+			want: 15000100,
+		},
+		{
+			name: "Increase exceeding limit",
+			args: args{
+				parentGasLimit: 15000000,
+				targetGasLimit: 16000000,
+			},
+			want: 15014647, // maxGasLimitDiff = (15000000 / 1024) - 1 = 1464
+		},
+		{
+			name: "Decrease within limit",
+			args: args{
+				parentGasLimit: 15000000,
+				targetGasLimit: 14999990,
+			},
+			want: 14999990,
+		},
+		{
+			name: "Decrease exceeding limit",
+			args: args{
+				parentGasLimit: 15000000,
+				targetGasLimit: 14000000,
+			},
+			want: 14985353, // maxGasLimitDiff = (15000000 / 1024) - 1 = 1464
+		},
+		{
+			name: "Target equals parent",
+			args: args{
+				parentGasLimit: 15000000,
+				targetGasLimit: 15000000,
+			},
+			want: 15000000, // No change
+		},
+		{
+			name: "Very small parent gas limit",
+			args: args{
+				parentGasLimit: 1025,
+				targetGasLimit: 2000,
+			},
+			want: 1025 + ((1025 / 1024) - 1),
+		},
+		{
+			name: "Target far below parent but limited",
+			args: args{
+				parentGasLimit: 20000000,
+				targetGasLimit: 10000000,
+			},
+			want: 19980470, // maxGasLimitDiff = (20000000 / 1024) - 1
+		},
+		{
+			name: "Parent gas limit under flows",
+			args: args{
+				parentGasLimit: 1023,
+				targetGasLimit: 30000000,
+			},
+			want: 1023,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := expectedGasLimit(tt.args.parentGasLimit, tt.args.targetGasLimit); got != tt.want {
+				t.Errorf("expectedGasLimit() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

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

@@ -239,7 +239,8 @@ func (vs *Server) getTerminalBlockHashIfExists(ctx context.Context, transitionTi
 
 func (vs *Server) getBuilderPayloadAndBlobs(ctx context.Context,
 	slot primitives.Slot,
-	vIdx primitives.ValidatorIndex) (builder.Bid, error) {
+	vIdx primitives.ValidatorIndex,
+	parentGasLimit uint64) (builder.Bid, error) {
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.getBuilderPayloadAndBlobs")
 	defer span.End()
 
@@ -255,7 +256,7 @@ func (vs *Server) getBuilderPayloadAndBlobs(ctx context.Context,
 		return nil, nil
 	}
 
-	return vs.getPayloadHeaderFromBuilder(ctx, slot, vIdx)
+	return vs.getPayloadHeaderFromBuilder(ctx, slot, vIdx, parentGasLimit)
 }
 
 var errActivationNotReached = errors.New("activation epoch not reached")

beacon-chain/sync/BUILD.bazel

@@ -244,6 +244,7 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",

beacon-chain/sync/backfill/blobs.go

@@ -9,6 +9,7 @@ import (
 	"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"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -44,7 +45,7 @@ func newBlobSync(current primitives.Slot, vbs verifiedROBlocks, cfg *blobSyncCon
 	return &blobSync{current: current, expected: expected, bbv: bbv, store: as}, nil
 }
 
-type blobVerifierMap map[[32]byte][fieldparams.MaxBlobsPerBlock]verification.BlobVerifier
+type blobVerifierMap map[[32]byte][]verification.BlobVerifier
 
 type blobSync struct {
 	store    das.AvailabilityStore
@@ -106,7 +107,10 @@ type blobBatchVerifier struct {
 }
 
 func (bbv *blobBatchVerifier) newVerifier(rb blocks.ROBlob) verification.BlobVerifier {
-	m := bbv.verifiers[rb.BlockRoot()]
+	m, ok := bbv.verifiers[rb.BlockRoot()]
+	if !ok {
+		m = make([]verification.BlobVerifier, params.BeaconConfig().MaxBlobsPerBlock(rb.Slot()))
+	}
 	m[rb.Index] = bbv.newBlobVerifier(rb, verification.BackfillBlobSidecarRequirements)
 	bbv.verifiers[rb.BlockRoot()] = m
 	return m[rb.Index]