Update CHANGELOG.md

* reduce validator registration logs

* reverting a log change that's probably better as warn

* Update CHANGELOG.md

---------

Co-authored-by: Preston Van Loon <pvanloon@offchainlabs.com>
Co-authored-by: Preston Van Loon <preston@pvl.dev>

.github/PULL_REQUEST_TEMPLATE.md

@@ -10,6 +10,7 @@
    in review.
 4. Note that PRs updating dependencies and new Go versions are not accepted.
    Please file an issue instead.
+5. A changelog entry is required for user facing issues.
 -->
 
 **What type of PR is this?**
@@ -28,3 +29,9 @@
 Fixes #
 
 **Other notes for review**
+
+**Acknowledgements**
+
+- [ ] I have read [CONTRIBUTING.md](https://github.com/prysmaticlabs/prysm/blob/develop/CONTRIBUTING.md).
+- [ ] I have made an appropriate entry to [CHANGELOG.md](https://github.com/prysmaticlabs/prysm/blob/develop/CHANGELOG.md).
+- [ ] I have added a description to this PR with sufficient context for reviewers to understand this PR.

.github/workflows/changelog.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - develop
+
+jobs:
+  changed_files:
+    runs-on: ubuntu-latest 
+    name: Check CHANGELOG.md
+    steps:
+      - uses: actions/checkout@v4
+      - name: changelog modified
+        id: changelog-modified
+        uses: tj-actions/changed-files@v45
+        with:
+          files: CHANGELOG.md
+
+      - name: List all changed files
+        env:
+          ALL_CHANGED_FILES: ${{ steps.changelog-modified.outputs.all_changed_files }}
+        run: |
+          if [[ ${ALL_CHANGED_FILES[*]} =~ (^|[[:space:]])"CHANGELOG.md"($|[[:space:]]) ]];
+          then
+            echo "CHANGELOG.md was modified.";
+            exit 0;
+          else
+            echo "CHANGELOG.md was not modified.";
+            echo "Please see CHANGELOG.md and follow the instructions to add your changes to that file."
+            echo "In some rare scenarios, a changelog entry is not required and this CI check can be ignored."
+            exit 1;
+          fi

CONTRIBUTING.md

@@ -6,6 +6,8 @@ Excited by our work and want to get involved in building out our sharding releas
 
 You can explore our [Open Issues](https://github.com/prysmaticlabs/prysm/issues) in-the works for our different releases. Feel free to fork our repo and start creating PR’s after assigning yourself to an issue of interest. We are always chatting on [Discord](https://discord.gg/CTYGPUJ) drop us a line there if you want to get more involved or have any questions on our implementation!
 
+Please, do not send pull requests for trivial changes, such as typos, these will be rejected. These types of pull requests incur a cost to reviewers and do not provide much value to the project. If you are unsure, please open an issue first to discuss the change.
+
 ## Contribution Steps
 
 **1. Set up Prysm following the instructions in README.md.**
@@ -120,15 +122,19 @@ $ git push myrepo feature-in-progress-branch
 
 Navigate to your fork of the repo on GitHub. On the upper left where the current branch is listed, change the branch to your feature-in-progress-branch. Open the files that you have worked on and check to make sure they include your changes.
 
-**16. Create a pull request.**
+**16. Add an entry to CHANGELOG.md.**
 
-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.
+If your change is user facing, you must include a CHANGELOG.md entry. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
 
-**17. Respond to comments by Core Contributors.**
+**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.
+
+**18. Respond to comments by Core Contributors.**
 
 Core Contributors may ask questions and request that you make edits. If you set notifications at the top of the page to “not watching,” you will still be notified by email whenever someone comments on the page of a pull request you have created. If you are asked to modify your pull request, repeat steps 8 through 15, then leave a comment to notify the Core Contributors that the pull request is ready for further review.
 
-**18. If the number of commits becomes excessive, you may be asked to squash your commits.**
+**19. If the number of commits becomes excessive, you may be asked to squash your commits.**
 
  You can do this with an interactive rebase. Start by running the following command to determine the commit that is the base of your branch...
 
@@ -136,7 +142,7 @@ Core Contributors may ask questions and request that you make edits. If you set
 $ git merge-base feature-in-progress-branch prysm/master
 ```
 
-**19. The previous command will return a commit-hash that you should use in the following command.**
+**20. The previous command will return a commit-hash that you should use in the following command.**
 
 ```
 $ git rebase -i commit-hash
@@ -160,13 +166,30 @@ squash  hash 	add a feature
 
 Save and close the file, then a commit command will appear in the terminal that squashes the smaller commits into one. Check to be sure the commit message accurately reflects your changes and then hit enter to execute it.
 
-**20. Update your pull request with the following command.**
+**21. Update your pull request with the following command.**
 
 ```
 $ git push myrepo feature-in-progress-branch -f
 ```
 
-**21.  Finally, again leave a comment to the Core Contributors on the pull request to let them know that the pull request has been updated.**
+**22.  Finally, again leave a comment to the Core Contributors on the pull request to let them know that the pull request has been updated.**
+
+## Maintaining CHANGELOG.md
+
+This project follows the changelog guidelines from [keepachangelog.com](https://keepachangelog.com/en/1.1.0/).
+
+All PRs with user facing changes should have an entry in the CHANGELOG.md file and the change should be categorized in the appropriate category within the "Unreleased" section. The categories are:
+
+-  `Added` for new features.
+-  `Changed` for changes in existing functionality.
+-  `Deprecated` for soon-to-be removed features.
+-  `Removed` for now removed features.
+-  `Fixed` for any bug fixes.
+-  `Security` in case of vulnerabilities. Please see the [Security Policy](SECURITY.md) for responsible disclosure before adding a change with this category.
+
+### Releasing
+
+When a new release is made, the "Unreleased" section should be moved to a new section with the release version and the current date. Then a new "Unreleased" section is made at the top of the file with the categories listed above.
 
 ## Contributor Responsibilities
 

WORKSPACE

@@ -227,7 +227,7 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0-alpha.4"
+consensus_spec_version = "v1.5.0-alpha.5"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-sSw6c9IR/ZiWjyk1cbfVGC/aUkId4r7+eSl3haWsq0E=",
+    integrity = "sha256-R9vG5HEL5eGMOAmbkKfJ2jfelNqL5V0xBUPiXOiGM6U=",
     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-OGlKhbA6TjTP0p1ojXVCJPzLEHJzewKkhAa+PQggoiU=",
+    integrity = "sha256-AEIiEOlf1XuxoRMCsN+kgJMo4LrS05+biTA1p/7Ro00=",
     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-ah2Gj4ci5hw5vQgpUWkNjEQutoBCepg5jcpTi0DKVB0=",
+    integrity = "sha256-LH/Xr20yrJRYnbpjRGupMWTIOWt3cpxZJWXgThwVDsk=",
     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-I+llAsIF6lPP8RUtZ2DFsJqtCs4UPh+st3hFs12FWpY=",
+    integrity = "sha256-mlytz4MPjKh0DwV7FMiAtnRbJw9B6o78/x66/vmnYc8=",
     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/server/structs/endpoints_lightclient.go

@@ -1,12 +1,16 @@
 package structs
 
+type LightClientHeader struct {
+	Beacon *BeaconBlockHeader `json:"beacon"`
+}
+
 type LightClientBootstrapResponse struct {
 	Version string                `json:"version"`
 	Data    *LightClientBootstrap `json:"data"`
 }
 
 type LightClientBootstrap struct {
-	Header                     *BeaconBlockHeader `json:"header"`
+	Header                     *LightClientHeader `json:"header"`
 	CurrentSyncCommittee       *SyncCommittee     `json:"current_sync_committee"`
 	CurrentSyncCommitteeBranch []string           `json:"current_sync_committee_branch"`
 }

beacon-chain/blockchain/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
         "head.go",
         "head_sync_committee_info.go",
         "init_sync_process_block.go",
-        "lightclient.go",
         "log.go",
         "merge_ascii_art.go",
         "metrics.go",
@@ -48,6 +47,7 @@ go_library(
         "//beacon-chain/core/feed: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/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -84,7 +84,6 @@ go_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",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -117,7 +116,6 @@ go_test(
         "head_test.go",
         "init_sync_process_block_test.go",
         "init_test.go",
-        "lightclient_test.go",
         "log_test.go",
         "metrics_test.go",
         "mock_test.go",
@@ -174,7 +172,6 @@ go_test(
         "//encoding/bytesutil: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",
         "//testing/assert:go_default_library",

beacon-chain/blockchain/lightclient_test.go

@@ -1,160 +0,0 @@
-package blockchain
-
-import (
-	"context"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	v1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-)
-
-type testlc struct {
-	t              *testing.T
-	ctx            context.Context
-	state          state.BeaconState
-	block          interfaces.ReadOnlySignedBeaconBlock
-	attestedState  state.BeaconState
-	attestedHeader *ethpb.BeaconBlockHeader
-}
-
-func newTestLc(t *testing.T) *testlc {
-	return &testlc{t: t}
-}
-
-func (l *testlc) setupTest() *testlc {
-	ctx := context.Background()
-
-	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
-
-	attestedState, err := util.NewBeaconStateCapella()
-	require.NoError(l.t, err)
-	err = attestedState.SetSlot(slot)
-	require.NoError(l.t, err)
-
-	parent := util.NewBeaconBlockCapella()
-	parent.Block.Slot = slot
-
-	signedParent, err := blocks.NewSignedBeaconBlock(parent)
-	require.NoError(l.t, err)
-
-	parentHeader, err := signedParent.Header()
-	require.NoError(l.t, err)
-	attestedHeader := parentHeader.Header
-
-	err = attestedState.SetLatestBlockHeader(attestedHeader)
-	require.NoError(l.t, err)
-	attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
-	require.NoError(l.t, err)
-
-	// get a new signed block so the root is updated with the new state root
-	parent.Block.StateRoot = attestedStateRoot[:]
-	signedParent, err = blocks.NewSignedBeaconBlock(parent)
-	require.NoError(l.t, err)
-
-	state, err := util.NewBeaconStateCapella()
-	require.NoError(l.t, err)
-	err = state.SetSlot(slot)
-	require.NoError(l.t, err)
-
-	parentRoot, err := signedParent.Block().HashTreeRoot()
-	require.NoError(l.t, err)
-
-	block := util.NewBeaconBlockCapella()
-	block.Block.Slot = slot
-	block.Block.ParentRoot = parentRoot[:]
-
-	for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
-		block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
-	}
-
-	signedBlock, err := blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.t, err)
-
-	h, err := signedBlock.Header()
-	require.NoError(l.t, err)
-
-	err = state.SetLatestBlockHeader(h.Header)
-	require.NoError(l.t, err)
-	stateRoot, err := state.HashTreeRoot(ctx)
-	require.NoError(l.t, err)
-
-	// get a new signed block so the root is updated with the new state root
-	block.Block.StateRoot = stateRoot[:]
-	signedBlock, err = blocks.NewSignedBeaconBlock(block)
-	require.NoError(l.t, err)
-
-	l.state = state
-	l.attestedState = attestedState
-	l.attestedHeader = attestedHeader
-	l.block = signedBlock
-	l.ctx = ctx
-
-	return l
-}
-
-func (l *testlc) checkAttestedHeader(update *ethpbv2.LightClientUpdate) {
-	require.Equal(l.t, l.attestedHeader.Slot, update.AttestedHeader.Slot, "Attested header slot is not equal")
-	require.Equal(l.t, l.attestedHeader.ProposerIndex, update.AttestedHeader.ProposerIndex, "Attested header proposer index is not equal")
-	require.DeepSSZEqual(l.t, l.attestedHeader.ParentRoot, update.AttestedHeader.ParentRoot, "Attested header parent root is not equal")
-	require.DeepSSZEqual(l.t, l.attestedHeader.BodyRoot, update.AttestedHeader.BodyRoot, "Attested header body root is not equal")
-
-	attestedStateRoot, err := l.attestedState.HashTreeRoot(l.ctx)
-	require.NoError(l.t, err)
-	require.DeepSSZEqual(l.t, attestedStateRoot[:], update.AttestedHeader.StateRoot, "Attested header state root is not equal")
-}
-
-func (l *testlc) checkSyncAggregate(update *ethpbv2.LightClientUpdate) {
-	syncAggregate, err := l.block.Block().Body().SyncAggregate()
-	require.NoError(l.t, err)
-	require.DeepSSZEqual(l.t, syncAggregate.SyncCommitteeBits, update.SyncAggregate.SyncCommitteeBits, "SyncAggregate bits is not equal")
-	require.DeepSSZEqual(l.t, syncAggregate.SyncCommitteeSignature, update.SyncAggregate.SyncCommitteeSignature, "SyncAggregate signature is not equal")
-}
-
-func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T) {
-	l := newTestLc(t).setupTest()
-
-	update, err := NewLightClientOptimisticUpdateFromBeaconState(l.ctx, l.state, l.block, l.attestedState)
-	require.NoError(t, err)
-	require.NotNil(t, update, "update is nil")
-
-	require.Equal(t, l.block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-	l.checkSyncAggregate(update)
-	l.checkAttestedHeader(update)
-
-	require.Equal(t, (*v1.BeaconBlockHeader)(nil), update.FinalizedHeader, "Finalized header is not nil")
-	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
-}
-
-func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
-	l := newTestLc(t).setupTest()
-
-	update, err := NewLightClientFinalityUpdateFromBeaconState(l.ctx, l.state, l.block, l.attestedState, nil)
-	require.NoError(t, err)
-	require.NotNil(t, update, "update is nil")
-
-	require.Equal(t, l.block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
-
-	l.checkSyncAggregate(update)
-	l.checkAttestedHeader(update)
-
-	zeroHash := params.BeaconConfig().ZeroHash[:]
-	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
-	require.Equal(t, primitives.Slot(0), update.FinalizedHeader.Slot, "Finalized header slot is not zero")
-	require.Equal(t, primitives.ValidatorIndex(0), update.FinalizedHeader.ProposerIndex, "Finalized header proposer index is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.ParentRoot, "Finalized header parent root is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.StateRoot, "Finalized header state root is not zero")
-	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.BodyRoot, "Finalized header body root is not zero")
-	require.Equal(t, FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
-	for _, leaf := range update.FinalityBranch {
-		require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
-	}
-}

beacon-chain/blockchain/process_block_helpers.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"time"
 
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
@@ -176,7 +178,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		}
 	}
 
-	update, err := NewLightClientFinalityUpdateFromBeaconState(
+	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -191,7 +193,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	// Return the result
 	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    CreateLightClientFinalityUpdate(update),
+		Data:    lightclient.CreateLightClientFinalityUpdate(update),
 	}
 
 	// Send event
@@ -211,7 +213,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 		return 0, errors.Wrap(err, "could not get attested state")
 	}
 
-	update, err := NewLightClientOptimisticUpdateFromBeaconState(
+	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -225,7 +227,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	// Return the result
 	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    CreateLightClientOptimisticUpdate(update),
+		Data:    lightclient.CreateLightClientOptimisticUpdate(update),
 	}
 
 	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{

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

@@ -0,0 +1,31 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["lightclient.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/state:go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
+        "//time/slots:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["lightclient_test.go"],
+    deps = [
+        ":go_default_library",
+        "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//proto/eth/v1:go_default_library",
+        "//testing/require:go_default_library",
+        "//testing/util:go_default_library",
+    ],
+)

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

@@ -1,18 +1,20 @@
-package blockchain
+package light_client
 
 import (
 	"bytes"
-	"context"
 	"fmt"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	"github.com/prysmaticlabs/prysm/v5/proto/migration"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+
+	"context"
+
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 )
 
 const (

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

@@ -0,0 +1,54 @@
+package light_client_test
+
+import (
+	"testing"
+
+	lightClient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+	"github.com/prysmaticlabs/prysm/v5/testing/util"
+
+	v1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
+)
+
+func TestLightClient_NewLightClientOptimisticUpdateFromBeaconState(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTest()
+
+	update, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState)
+	require.NoError(t, err)
+	require.NotNil(t, update, "update is nil")
+
+	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
+
+	l.CheckSyncAggregate(update)
+	l.CheckAttestedHeader(update)
+
+	require.Equal(t, (*v1.BeaconBlockHeader)(nil), update.FinalizedHeader, "Finalized header is not nil")
+	require.DeepSSZEqual(t, ([][]byte)(nil), update.FinalityBranch, "Finality branch is not nil")
+}
+
+func TestLightClient_NewLightClientFinalityUpdateFromBeaconState(t *testing.T) {
+	l := util.NewTestLightClient(t).SetupTest()
+
+	update, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, nil)
+	require.NoError(t, err)
+	require.NotNil(t, update, "update is nil")
+
+	require.Equal(t, l.Block.Block().Slot(), update.SignatureSlot, "Signature slot is not equal")
+
+	l.CheckSyncAggregate(update)
+	l.CheckAttestedHeader(update)
+
+	zeroHash := params.BeaconConfig().ZeroHash[:]
+	require.NotNil(t, update.FinalizedHeader, "Finalized header is nil")
+	require.Equal(t, primitives.Slot(0), update.FinalizedHeader.Slot, "Finalized header slot is not zero")
+	require.Equal(t, primitives.ValidatorIndex(0), update.FinalizedHeader.ProposerIndex, "Finalized header proposer index is not zero")
+	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.ParentRoot, "Finalized header parent root is not zero")
+	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.StateRoot, "Finalized header state root is not zero")
+	require.DeepSSZEqual(t, zeroHash, update.FinalizedHeader.BodyRoot, "Finalized header body root is not zero")
+	require.Equal(t, lightClient.FinalityBranchNumOfLeaves, len(update.FinalityBranch), "Invalid finality branch leaves")
+	for _, leaf := range update.FinalityBranch {
+		require.DeepSSZEqual(t, zeroHash, leaf, "Leaf is not zero")
+	}
+}

beacon-chain/db/iface/BUILD.bazel

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

beacon-chain/db/iface/interface.go

@@ -7,6 +7,8 @@ import (
 	"context"
 	"io"
 
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filters"
 	slashertypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
@@ -56,6 +58,9 @@ type ReadOnlyDatabase interface {
 	// Fee recipients operations.
 	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)
 
 	// origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
@@ -92,6 +97,8 @@ type NoHeadAccessDatabase interface {
 	// Fee recipients operations.
 	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
 
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
 }

beacon-chain/db/kv/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "genesis.go",
         "key.go",
         "kv.go",
+        "lightclient.go",
         "log.go",
         "migration.go",
         "migration_archived_index.go",
@@ -51,6 +52,7 @@ go_library(
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing: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",
@@ -87,6 +89,7 @@ go_test(
         "genesis_test.go",
         "init_test.go",
         "kv_test.go",
+        "lightclient_test.go",
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
@@ -113,6 +116,7 @@ go_test(
         "//encoding/bytesutil:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/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",

beacon-chain/db/kv/kv.go

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

beacon-chain/db/kv/lightclient.go

@@ -0,0 +1,79 @@
+package kv
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
+)
+
+func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update *ethpbv2.LightClientUpdateWithVersion) error {
+	ctx, 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)
+		if err != nil {
+			return err
+		}
+		return bkt.Put(bytesutil.Uint64ToBytesBigEndian(period), updateMarshalled)
+	})
+}
+
+func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]*ethpbv2.LightClientUpdateWithVersion, error) {
+	ctx, 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)
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(lightClientUpdatesBucket)
+		c := bkt.Cursor()
+
+		firstPeriodInDb, _ := c.First()
+		if firstPeriodInDb == nil {
+			return nil
+		}
+
+		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 {
+				return err
+			}
+			updates[currentPeriod] = &update
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	return updates, err
+}
+
+func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (*ethpbv2.LightClientUpdateWithVersion, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.LightClientUpdate")
+	defer span.End()
+
+	var update ethpbv2.LightClientUpdateWithVersion
+	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)
+	})
+	return &update, err
+}

beacon-chain/db/kv/lightclient_test.go

@@ -0,0 +1,648 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+func TestStore_LightclientUpdate_CanSaveRetrieve(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	update := &ethpbv2.LightClientUpdate{
+		AttestedHeader:          nil,
+		NextSyncCommittee:       nil,
+		NextSyncCommitteeBranch: nil,
+		FinalizedHeader:         nil,
+		FinalityBranch:          nil,
+		SyncAggregate:           nil,
+		SignatureSlot:           7,
+	}
+
+	period := uint64(1)
+	err := db.SaveLightClientUpdate(ctx, period, &ethpbv2.LightClientUpdateWithVersion{
+		Version: 1,
+		Data:    update,
+	})
+	require.NoError(t, err)
+
+	// Retrieve the update
+	retrievedUpdate, err := db.LightClientUpdate(ctx, period)
+	require.NoError(t, err)
+	require.Equal(t, update.SignatureSlot, retrievedUpdate.Data.SignatureSlot, "retrieved update does not match saved update")
+
+}
+
+func TestStore_LightclientUpdates_canRetrieveRange(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdatesMap, err := db.LightClientUpdates(ctx, 1, 3)
+	require.NoError(t, err)
+	require.Equal(t, len(updates), len(retrievedUpdatesMap), "retrieved updates do not match saved updates")
+	for i, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdatesMap[uint64(i+1)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+
+}
+
+func TestStore_LightClientUpdate_EndPeriodSmallerThanStartPeriod(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 3, 1)
+	require.NotNil(t, err)
+	require.Equal(t, err.Error(), "start period 3 is greater than end period 1")
+	require.IsNil(t, retrievedUpdates)
+
+}
+
+func TestStore_LightClientUpdate_EndPeriodEqualToStartPeriod(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 2, 2)
+	require.NoError(t, err)
+	require.Equal(t, 1, len(retrievedUpdates))
+	require.Equal(t, updates[1].Data.SignatureSlot, retrievedUpdates[2].Data.SignatureSlot, "retrieved update does not match saved update")
+}
+
+func TestStore_LightClientUpdate_StartPeriodBeforeFirstUpdate(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+2), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 0, 4)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	for i, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(i+2)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_EndPeriodAfterLastUpdate(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 6)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	for i, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(i+1)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_PartialUpdates(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           9,
+			},
+		},
+	}
+
+	for i, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(i+1), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 2)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(retrievedUpdates))
+	for i, update := range updates[:2] {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(i+1)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriods_SimpleData(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+	updates := []*ethpbv2.LightClientUpdateWithVersion{
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           7,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           8,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           11,
+			},
+		},
+		{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           12,
+			},
+		},
+	}
+
+	for _, update := range updates {
+		err := db.SaveLightClientUpdate(ctx, uint64(update.Data.SignatureSlot), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 7, 12)
+	require.NoError(t, err)
+	require.Equal(t, 4, len(retrievedUpdates))
+	for _, update := range updates {
+		require.Equal(t, update.Data.SignatureSlot, retrievedUpdates[uint64(update.Data.SignatureSlot)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+
+	// Retrieve the updates from the middle
+	retrievedUpdates, err = db.LightClientUpdates(ctx, 8, 12)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	require.Equal(t, updates[1].Data.SignatureSlot, retrievedUpdates[8].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[2].Data.SignatureSlot, retrievedUpdates[11].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[3].Data.SignatureSlot, retrievedUpdates[12].Data.SignatureSlot, "retrieved update does not match saved update")
+
+	// Retrieve the updates from after the missing period
+	retrievedUpdates, err = db.LightClientUpdates(ctx, 11, 12)
+	require.NoError(t, err)
+	require.Equal(t, 2, len(retrievedUpdates))
+	require.Equal(t, updates[2].Data.SignatureSlot, retrievedUpdates[11].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[3].Data.SignatureSlot, retrievedUpdates[12].Data.SignatureSlot, "retrieved update does not match saved update")
+
+	//retrieve the updates from before the missing period to after the missing period
+	retrievedUpdates, err = db.LightClientUpdates(ctx, 3, 15)
+	require.NoError(t, err)
+	require.Equal(t, 4, len(retrievedUpdates))
+	require.Equal(t, updates[0].Data.SignatureSlot, retrievedUpdates[7].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[1].Data.SignatureSlot, retrievedUpdates[8].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[2].Data.SignatureSlot, retrievedUpdates[11].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, updates[3].Data.SignatureSlot, retrievedUpdates[12].Data.SignatureSlot, "retrieved update does not match saved update")
+}
+
+func TestStore_LightClientUpdate_EmptyDB(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	// Retrieve the updates
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 3)
+	require.IsNil(t, err)
+	require.Equal(t, 0, len(retrievedUpdates))
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsAtTheEnd_SimpleData(t *testing.T) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	for i := 1; i < 4; i++ {
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+	for i := 7; i < 10; i++ {
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+
+	// Retrieve the updates from 1 to 5
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 5)
+	require.NoError(t, err)
+	require.Equal(t, 3, len(retrievedUpdates))
+	require.Equal(t, primitives.Slot(1), retrievedUpdates[1].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, primitives.Slot(2), retrievedUpdates[2].Data.SignatureSlot, "retrieved update does not match saved update")
+	require.Equal(t, primitives.Slot(3), retrievedUpdates[3].Data.SignatureSlot, "retrieved update does not match saved update")
+
+}
+
+func setupLightClientTestDB(t *testing.T) (*Store, context.Context) {
+	db := setupDB(t)
+	ctx := context.Background()
+
+	for i := 10; i < 101; i++ { // 10 to 100
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+
+	for i := 110; i < 201; i++ { // 110 to 200
+		update := &ethpbv2.LightClientUpdateWithVersion{
+			Version: 1,
+			Data: &ethpbv2.LightClientUpdate{
+				AttestedHeader:          nil,
+				NextSyncCommittee:       nil,
+				NextSyncCommitteeBranch: nil,
+				FinalizedHeader:         nil,
+				FinalityBranch:          nil,
+				SyncAggregate:           nil,
+				SignatureSlot:           primitives.Slot(uint64(i)),
+			},
+		}
+		err := db.SaveLightClientUpdate(ctx, uint64(i), update)
+		require.NoError(t, err)
+	}
+
+	return db, ctx
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsInTheMiddleDistributed(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// Retrieve the updates - should fail because of missing periods in the middle
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 300)
+	require.NoError(t, err)
+	require.Equal(t, 91*2, len(retrievedUpdates))
+	for i := 10; i < 101; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+
+}
+
+func TestStore_LightClientUpdate_RetrieveValidRangeFromStart(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 1 to 100 - should work because all periods are present after the firstPeriodInDB > startPeriod
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 1, 100)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 10; i < 101; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_RetrieveValidRangeInTheMiddle(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 110 to 200 - should work because all periods are present
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 110, 200)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriodInTheMiddleConcentrated(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 100 to 200
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 100, 200)
+	require.NoError(t, err)
+	require.Equal(t, 92, len(retrievedUpdates))
+	require.Equal(t, primitives.Slot(100), retrievedUpdates[100].Data.SignatureSlot, "retrieved update does not match saved update")
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsAtTheEnd(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 10 to 109
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 10, 109)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 10; i < 101; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_MissingPeriodsAtTheBeginning(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 105 to 200
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 105, 200)
+	require.NoError(t, err)
+	require.Equal(t, 91, len(retrievedUpdates))
+	for i := 110; i < 201; i++ {
+		require.Equal(t, primitives.Slot(uint64(i)), retrievedUpdates[uint64(i)].Data.SignatureSlot, "retrieved update does not match saved update")
+	}
+}
+
+func TestStore_LightClientUpdate_StartPeriodGreaterThanLastPeriod(t *testing.T) {
+	db, ctx := setupLightClientTestDB(t)
+
+	// retrieve 300 to 400
+	retrievedUpdates, err := db.LightClientUpdates(ctx, 300, 400)
+	require.NoError(t, err)
+	require.Equal(t, 0, len(retrievedUpdates))
+
+}

beacon-chain/db/kv/schema.go

@@ -17,6 +17,9 @@ var (
 	feeRecipientBucket    = []byte("fee-recipient")
 	registrationBucket    = []byte("registration")
 
+	// Light Client Updates Bucket
+	lightClientUpdatesBucket = []byte("light-client-updates")
+
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.
 	slotsHasObjectBucket = []byte("slots-has-objects")
 	// Deprecated: This bucket was migrated in PR 6461. Do not use, except for migrations.

beacon-chain/node/config.go

@@ -132,7 +132,7 @@ func configureEth1Config(cliCtx *cli.Context) error {
 }
 
 func configureNetwork(cliCtx *cli.Context) {
-	if len(cliCtx.StringSlice(cmd.BootstrapNode.Name)) > 0 {
+	if cliCtx.IsSet(cmd.BootstrapNode.Name) {
 		c := params.BeaconNetworkConfig()
 		c.BootstrapNodes = cliCtx.StringSlice(cmd.BootstrapNode.Name)
 		params.OverrideBeaconNetworkConfig(c)

beacon-chain/rpc/endpoints.go

@@ -815,6 +815,7 @@ func (s *Service) lightClientEndpoints(blocker lookup.Blocker, stater lookup.Sta
 		Blocker:     blocker,
 		Stater:      stater,
 		HeadFetcher: s.cfg.HeadFetcher,
+		BeaconDB:    s.cfg.BeaconDB,
 	}
 
 	const namespace = "lightclient"

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

@@ -286,7 +286,7 @@ func (s *Server) PublishBlindedBlockV2(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body: "+err.Error(), http.StatusInternalServerError)
@@ -297,6 +297,29 @@ func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWrit
 		httputil.HandleError(w, api.VersionHeader+" header is required", http.StatusBadRequest)
 	}
 
+	electraBlock := &eth.SignedBlindedBeaconBlockElectra{}
+	if err = electraBlock.UnmarshalSSZ(body); err == nil {
+		genericBlock := &eth.GenericSignedBeaconBlock{
+			Block: &eth.GenericSignedBeaconBlock_BlindedElectra{
+				BlindedElectra: electraBlock,
+			},
+		}
+		if err = s.validateBroadcast(ctx, r, genericBlock); err != nil {
+			httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		s.proposeBlock(ctx, w, genericBlock)
+		return
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	denebBlock := &eth.SignedBlindedBeaconBlockDeneb{}
 	if err = denebBlock.UnmarshalSSZ(body); err == nil {
 		genericBlock := &eth.GenericSignedBeaconBlock{
@@ -415,7 +438,7 @@ func (s *Server) publishBlindedBlockSSZ(ctx context.Context, w http.ResponseWrit
 	httputil.HandleError(w, "Body does not represent a valid block type", http.StatusBadRequest)
 }
 
-func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body", http.StatusInternalServerError)
@@ -428,6 +451,27 @@ func (s *Server) publishBlindedBlock(ctx context.Context, w http.ResponseWriter,
 
 	var consensusBlock *eth.GenericSignedBeaconBlock
 
+	var electraBlock *structs.SignedBlindedBeaconBlockElectra
+	if err = unmarshalStrict(body, &electraBlock); err == nil {
+		consensusBlock, err = electraBlock.ToGeneric()
+		if err == nil {
+			if err = s.validateBroadcast(ctx, r, consensusBlock); err != nil {
+				httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.proposeBlock(ctx, w, consensusBlock)
+			return
+		}
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	var denebBlock *structs.SignedBlindedBeaconBlockDeneb
 	if err = unmarshalStrict(body, &denebBlock); err == nil {
 		consensusBlock, err = denebBlock.ToGeneric()
@@ -579,7 +623,7 @@ func (s *Server) PublishBlockV2(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body", http.StatusInternalServerError)
@@ -591,6 +635,39 @@ func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *
 		return
 	}
 
+	electraBlock := &eth.SignedBeaconBlockContentsElectra{}
+	if err = electraBlock.UnmarshalSSZ(body); err == nil {
+		genericBlock := &eth.GenericSignedBeaconBlock{
+			Block: &eth.GenericSignedBeaconBlock_Electra{
+				Electra: electraBlock,
+			},
+		}
+		if err = s.validateBroadcast(ctx, r, genericBlock); err != nil {
+			if errors.Is(err, errEquivocatedBlock) {
+				b, err := blocks.NewSignedBeaconBlock(genericBlock)
+				if err != nil {
+					httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+					return
+				}
+				if err := s.broadcastSeenBlockSidecars(ctx, b, genericBlock.GetElectra().Blobs, genericBlock.GetElectra().KzgProofs); err != nil {
+					log.WithError(err).Error("Failed to broadcast blob sidecars")
+				}
+			}
+			httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		s.proposeBlock(ctx, w, genericBlock)
+		return
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	denebBlock := &eth.SignedBeaconBlockContentsDeneb{}
 	if err = denebBlock.UnmarshalSSZ(body); err == nil {
 		genericBlock := &eth.GenericSignedBeaconBlock{
@@ -719,7 +796,7 @@ func (s *Server) publishBlockSSZ(ctx context.Context, w http.ResponseWriter, r *
 	httputil.HandleError(w, "Body does not represent a valid block type", http.StatusBadRequest)
 }
 
-func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) {
+func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *http.Request, versionRequired bool) { // nolint:gocognit
 	body, err := io.ReadAll(r.Body)
 	if err != nil {
 		httputil.HandleError(w, "Could not read request body", http.StatusInternalServerError)
@@ -733,6 +810,37 @@ func (s *Server) publishBlock(ctx context.Context, w http.ResponseWriter, r *htt
 
 	var consensusBlock *eth.GenericSignedBeaconBlock
 
+	var electraBlockContents *structs.SignedBeaconBlockContentsElectra
+	if err = unmarshalStrict(body, &electraBlockContents); err == nil {
+		consensusBlock, err = electraBlockContents.ToGeneric()
+		if err == nil {
+			if err = s.validateBroadcast(ctx, r, consensusBlock); err != nil {
+				if errors.Is(err, errEquivocatedBlock) {
+					b, err := blocks.NewSignedBeaconBlock(consensusBlock)
+					if err != nil {
+						httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+						return
+					}
+					if err := s.broadcastSeenBlockSidecars(ctx, b, consensusBlock.GetElectra().Blobs, consensusBlock.GetElectra().KzgProofs); err != nil {
+						log.WithError(err).Error("Failed to broadcast blob sidecars")
+					}
+				}
+				httputil.HandleError(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+			s.proposeBlock(ctx, w, consensusBlock)
+			return
+		}
+	}
+	if versionHeader == version.String(version.Electra) {
+		httputil.HandleError(
+			w,
+			fmt.Sprintf("Could not decode request body into %s consensus block: %v", version.String(version.Electra), err.Error()),
+			http.StatusBadRequest,
+		)
+		return
+	}
+
 	var denebBlockContents *structs.SignedBeaconBlockContentsDeneb
 	if err = unmarshalStrict(body, &denebBlockContents); err == nil {
 		consensusBlock, err = denebBlockContents.ToGeneric()

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

@@ -1071,6 +1071,29 @@ func TestPublishBlock(t *testing.T) {
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			converted, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBeaconBlockContentsElectra
+			err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.ElectraBlockContents)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1254,6 +1277,32 @@ func TestPublishBlockSSZ(t *testing.T) {
 		server.PublishBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1433,6 +1482,30 @@ func TestPublishBlindedBlock(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock.Message)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1617,6 +1690,32 @@ func TestPublishBlindedBlockSSZ(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1788,6 +1887,30 @@ func TestPublishBlockV2(t *testing.T) {
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			converted, err := structs.SignedBeaconBlockContentsElectraFromConsensus(block.Electra)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBeaconBlockContentsElectra
+			err = json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.ElectraBlockContents)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -1984,6 +2107,32 @@ func TestPublishBlockV2SSZ(t *testing.T) {
 		server.PublishBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_Electra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBeaconBlockContentsElectra
+		err := json.Unmarshal([]byte(rpctesting.ElectraBlockContents), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -2176,6 +2325,30 @@ func TestPublishBlindedBlockV2(t *testing.T) {
 		server.PublishBlindedBlockV2(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Blinded Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			block, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			converted, err := structs.BlindedBeaconBlockElectraFromConsensus(block.BlindedElectra.Message)
+			require.NoError(t, err)
+			var signedblock *structs.SignedBlindedBeaconBlockElectra
+			err = json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &signedblock)
+			require.NoError(t, err)
+			require.DeepEqual(t, converted, signedblock.Message)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader([]byte(rpctesting.BlindedElectraBlock)))
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlockV2(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},
@@ -2372,6 +2545,32 @@ func TestPublishBlindedBlockV2SSZ(t *testing.T) {
 		server.PublishBlindedBlock(writer, request)
 		assert.Equal(t, http.StatusOK, writer.Code)
 	})
+	t.Run("Electra", func(t *testing.T) {
+		v1alpha1Server := mock2.NewMockBeaconNodeValidatorServer(ctrl)
+		v1alpha1Server.EXPECT().ProposeBeaconBlock(gomock.Any(), mock.MatchedBy(func(req *eth.GenericSignedBeaconBlock) bool {
+			_, ok := req.Block.(*eth.GenericSignedBeaconBlock_BlindedElectra)
+			return ok
+		}))
+		server := &Server{
+			V1Alpha1ValidatorServer: v1alpha1Server,
+			SyncChecker:             &mockSync.Sync{IsSyncing: false},
+		}
+
+		var blk structs.SignedBlindedBeaconBlockElectra
+		err := json.Unmarshal([]byte(rpctesting.BlindedElectraBlock), &blk)
+		require.NoError(t, err)
+		genericBlock, err := blk.ToGeneric()
+		require.NoError(t, err)
+		ssz, err := genericBlock.GetBlindedElectra().MarshalSSZ()
+		require.NoError(t, err)
+		request := httptest.NewRequest(http.MethodPost, "http://foo.example", bytes.NewReader(ssz))
+		request.Header.Set("Content-Type", api.OctetStreamMediaType)
+		request.Header.Set(api.VersionHeader, version.String(version.Electra))
+		writer := httptest.NewRecorder()
+		writer.Body = &bytes.Buffer{}
+		server.PublishBlindedBlock(writer, request)
+		assert.Equal(t, http.StatusOK, writer.Code)
+	})
 	t.Run("invalid block", func(t *testing.T) {
 		server := &Server{
 			SyncChecker: &mockSync.Sync{IsSyncing: false},

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

@@ -488,7 +488,7 @@ func TestGetSpec(t *testing.T) {
 			case "MAX_PER_EPOCH_ACTIVATION_EXIT_CHURN_LIMIT":
 				assert.Equal(t, "256000000000", v)
 			case "DATA_COLUMN_SIDECAR_SUBNET_COUNT":
-				assert.Equal(t, "32", v)
+				assert.Equal(t, "128", v)
 			case "MAX_REQUEST_DATA_COLUMN_SIDECARS":
 				assert.Equal(t, "16384", v)
 			case "MIN_SLASHING_PENALTY_QUOTIENT_ELECTRA":

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

@@ -12,6 +12,8 @@ go_library(
     deps = [
         "//api/server/structs:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/db:go_default_library",
         "//beacon-chain/rpc/eth/shared:go_default_library",
         "//beacon-chain/rpc/lookup:go_default_library",
         "//beacon-chain/state:go_default_library",
@@ -41,9 +43,9 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//api/server/structs:go_default_library",
-        "//beacon-chain/blockchain:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/rpc/testutil:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",

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

@@ -73,7 +73,7 @@ func TestLightClientHandler_GetLightClientBootstrap(t *testing.T) {
 	resp := &structs.LightClientBootstrapResponse{}
 	require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
 	require.Equal(t, "capella", resp.Version)
-	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.BodyRoot)
+	require.Equal(t, hexutil.Encode(header.Header.BodyRoot), resp.Data.Header.Beacon.BodyRoot)
 	require.NotNil(t, resp.Data)
 }
 

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

@@ -6,9 +6,10 @@ import (
 	"reflect"
 	"strconv"
 
+	lightclient "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/light-client"
+
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/prysmaticlabs/prysm/v5/api/server/structs"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -66,17 +67,20 @@ func createLightClientBootstrap(ctx context.Context, state state.BeaconState) (*
 		branch[i] = hexutil.Encode(proof)
 	}
 
-	header := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
-	if header == nil {
+	beacon := structs.BeaconBlockHeaderFromConsensus(latestBlockHeader)
+	if beacon == nil {
 		return nil, fmt.Errorf("could not get beacon block header")
 	}
+	header := &structs.LightClientHeader{
+		Beacon: beacon,
+	}
 
 	// Above shared util function won't calculate state root, so we need to do it manually
 	stateRoot, err := state.HashTreeRoot(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("could not get state root: %s", err.Error())
 	}
-	header.StateRoot = hexutil.Encode(stateRoot[:])
+	header.Beacon.StateRoot = hexutil.Encode(stateRoot[:])
 
 	// Return result
 	result := &structs.LightClientBootstrap{
@@ -152,7 +156,7 @@ func createLightClientUpdate(
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientUpdate, error) {
-	result, err := blockchain.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -210,7 +214,7 @@ func newLightClientFinalityUpdateFromBeaconState(
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState,
 	finalizedBlock interfaces.ReadOnlySignedBeaconBlock) (*structs.LightClientUpdate, error) {
-	result, err := blockchain.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
+	result, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, finalizedBlock)
 	if err != nil {
 		return nil, err
 	}
@@ -223,7 +227,7 @@ func newLightClientOptimisticUpdateFromBeaconState(
 	state state.BeaconState,
 	block interfaces.ReadOnlySignedBeaconBlock,
 	attestedState state.BeaconState) (*structs.LightClientUpdate, error) {
-	result, err := blockchain.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState)
+	result, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState)
 	if err != nil {
 		return nil, err
 	}
@@ -236,7 +240,7 @@ func NewLightClientBootstrapFromJSON(bootstrapJSON *structs.LightClientBootstrap
 
 	var err error
 
-	v1Alpha1Header, err := bootstrapJSON.Header.ToConsensus()
+	v1Alpha1Header, err := bootstrapJSON.Header.Beacon.ToConsensus()
 	if err != nil {
 		return nil, err
 	}
@@ -319,7 +323,7 @@ func IsSyncCommitteeUpdate(update *v2.LightClientUpdate) bool {
 }
 
 func IsFinalityUpdate(update *v2.LightClientUpdate) bool {
-	finalityBranch := make([][]byte, blockchain.FinalityBranchNumOfLeaves)
+	finalityBranch := make([][]byte, lightclient.FinalityBranchNumOfLeaves)
 	return !reflect.DeepEqual(update.FinalityBranch, finalityBranch)
 }
 

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

@@ -3,7 +3,8 @@ package lightclient
 import (
 	"testing"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
+	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"
@@ -19,7 +20,7 @@ func createNonEmptySyncCommitteeBranch() [][]byte {
 
 // When the update has finality
 func createNonEmptyFinalityBranch() [][]byte {
-	res := make([][]byte, blockchain.FinalityBranchNumOfLeaves)
+	res := make([][]byte, lightclient.FinalityBranchNumOfLeaves)
 	res[0] = []byte("xyz")
 	return res
 }
@@ -146,7 +147,7 @@ func TestIsBetterUpdate(t *testing.T) {
 				},
 				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
 				SignatureSlot:           9999,
-				FinalityBranch:          make([][]byte, blockchain.FinalityBranchNumOfLeaves),
+				FinalityBranch:          make([][]byte, lightclient.FinalityBranchNumOfLeaves),
 			},
 			newUpdate: &ethpbv2.LightClientUpdate{
 				SyncAggregate: &ethpbv1.SyncAggregate{
@@ -183,7 +184,7 @@ func TestIsBetterUpdate(t *testing.T) {
 				},
 				NextSyncCommitteeBranch: createNonEmptySyncCommitteeBranch(),
 				SignatureSlot:           9999,
-				FinalityBranch:          make([][]byte, blockchain.FinalityBranchNumOfLeaves),
+				FinalityBranch:          make([][]byte, lightclient.FinalityBranchNumOfLeaves),
 			},
 			expectedResult: false,
 		},

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

@@ -2,6 +2,7 @@ package lightclient
 
 import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/lookup"
 )
 
@@ -9,4 +10,5 @@ type Server struct {
 	Blocker     lookup.Blocker
 	Stater      lookup.Stater
 	HeadFetcher blockchain.HeadFetcher
+	BeaconDB    db.HeadAccessDatabase
 }

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

@@ -3,7 +3,11 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     testonly = True,
-    srcs = ["json.go"],
+    srcs = [
+        "json.go",
+        "json_mainnet.go",
+        "json_minimal.go",  # keep
+    ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/shared/testing",
     visibility = ["//visibility:public"],
 )

beacon-chain/rpc/eth/shared/testing/json_mainnet.go

@@ -0,0 +1,5 @@
+//go:build !minimal
+
+package testing
+
+const attestationCommitteeBits = "0x0100000000000000"

beacon-chain/rpc/eth/shared/testing/json_minimal.go

@@ -0,0 +1,5 @@
+//go:build minimal
+
+package testing
+
+const attestationCommitteeBits = "0x01"

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

@@ -23,49 +23,10 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("slot", int64(req.Slot)))
 
-	if vs.SyncChecker.Syncing() {
-		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
-	}
-
-	// An optimistic validator MUST NOT participate in attestation
-	// (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
-	if err := vs.optimisticStatus(ctx); err != nil {
-		return nil, err
-	}
-
-	st, err := vs.HeadFetcher.HeadStateReadOnly(ctx)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
-	}
-
-	validatorIndex, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
-	if !exists {
-		return nil, status.Error(codes.Internal, "Could not locate validator index in DB")
-	}
-
-	epoch := slots.ToEpoch(req.Slot)
-	activeValidatorIndices, err := helpers.ActiveValidatorIndices(ctx, st, epoch)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get validators: %v", err)
-	}
-	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get seed: %v", err)
-	}
-	committee, err := helpers.BeaconCommittee(ctx, activeValidatorIndices, seed, req.Slot, req.CommitteeIndex)
+	indexInCommittee, validatorIndex, err := vs.processAggregateSelection(ctx, req)
 	if err != nil {
 		return nil, err
 	}
-
-	// Check if the validator is an aggregator
-	isAggregator, err := helpers.IsAggregator(uint64(len(committee)), req.SlotSignature)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get aggregator status: %v", err)
-	}
-	if !isAggregator {
-		return nil, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
-	}
-
 	atts := vs.AttPool.AggregatedAttestationsBySlotIndex(ctx, req.Slot, req.CommitteeIndex)
 	// Filter out the best aggregated attestation (ie. the one with the most aggregated bits).
 	if len(atts) == 0 {
@@ -74,14 +35,6 @@ func (vs *Server) SubmitAggregateSelectionProof(ctx context.Context, req *ethpb.
 			return nil, status.Errorf(codes.NotFound, "Could not find attestation for slot and committee in pool")
 		}
 	}
-
-	var indexInCommittee uint64
-	for i, idx := range committee {
-		if idx == validatorIndex {
-			indexInCommittee = uint64(i)
-		}
-	}
-
 	best := bestAggregate(atts, req.CommitteeIndex, indexInCommittee)
 	attAndProof := &ethpb.AggregateAttestationAndProof{
 		Aggregate:       best,
@@ -102,49 +55,10 @@ func (vs *Server) SubmitAggregateSelectionProofElectra(
 	defer span.End()
 	span.AddAttributes(trace.Int64Attribute("slot", int64(req.Slot)))
 
-	if vs.SyncChecker.Syncing() {
-		return nil, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
-	}
-
-	// An optimistic validator MUST NOT participate in attestation
-	// (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
-	if err := vs.optimisticStatus(ctx); err != nil {
-		return nil, err
-	}
-
-	st, err := vs.HeadFetcher.HeadStateReadOnly(ctx)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
-	}
-
-	validatorIndex, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
-	if !exists {
-		return nil, status.Error(codes.Internal, "Could not locate validator index in DB")
-	}
-
-	epoch := slots.ToEpoch(req.Slot)
-	activeValidatorIndices, err := helpers.ActiveValidatorIndices(ctx, st, epoch)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get validators: %v", err)
-	}
-	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get seed: %v", err)
-	}
-	committee, err := helpers.BeaconCommittee(ctx, activeValidatorIndices, seed, req.Slot, req.CommitteeIndex)
+	indexInCommittee, validatorIndex, err := vs.processAggregateSelection(ctx, req)
 	if err != nil {
 		return nil, err
 	}
-
-	// Check if the validator is an aggregator
-	isAggregator, err := helpers.IsAggregator(uint64(len(committee)), req.SlotSignature)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "Could not get aggregator status: %v", err)
-	}
-	if !isAggregator {
-		return nil, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
-	}
-
 	atts := vs.AttPool.AggregatedAttestationsBySlotIndexElectra(ctx, req.Slot, req.CommitteeIndex)
 	if len(atts) == 0 {
 		atts = vs.AttPool.UnaggregatedAttestationsBySlotIndexElectra(ctx, req.Slot, req.CommitteeIndex)
@@ -152,6 +66,58 @@ func (vs *Server) SubmitAggregateSelectionProofElectra(
 			return nil, status.Errorf(codes.NotFound, "No attestations found in pool")
 		}
 	}
+	best := bestAggregate(atts, req.CommitteeIndex, indexInCommittee)
+	attAndProof := &ethpb.AggregateAttestationAndProofElectra{
+		Aggregate:       best,
+		SelectionProof:  req.SlotSignature,
+		AggregatorIndex: validatorIndex,
+	}
+	return &ethpb.AggregateSelectionElectraResponse{AggregateAndProof: attAndProof}, nil
+}
+
+func (vs *Server) processAggregateSelection(ctx context.Context, req *ethpb.AggregateSelectionRequest) (uint64, primitives.ValidatorIndex, error) {
+	if vs.SyncChecker.Syncing() {
+		return 0, 0, status.Errorf(codes.Unavailable, "Syncing to latest head, not ready to respond")
+	}
+
+	// An optimistic validator MUST NOT participate in attestation
+	// (i.e., sign across the DOMAIN_BEACON_ATTESTER, DOMAIN_SELECTION_PROOF or DOMAIN_AGGREGATE_AND_PROOF domains).
+	if err := vs.optimisticStatus(ctx); err != nil {
+		return 0, 0, err
+	}
+
+	st, err := vs.HeadFetcher.HeadStateReadOnly(ctx)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
+	}
+
+	validatorIndex, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
+	if !exists {
+		return 0, 0, status.Error(codes.Internal, "Could not locate validator index in DB")
+	}
+
+	epoch := slots.ToEpoch(req.Slot)
+	activeValidatorIndices, err := helpers.ActiveValidatorIndices(ctx, st, epoch)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not get validators: %v", err)
+	}
+	seed, err := helpers.Seed(st, epoch, params.BeaconConfig().DomainBeaconAttester)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not get seed: %v", err)
+	}
+	committee, err := helpers.BeaconCommittee(ctx, activeValidatorIndices, seed, req.Slot, req.CommitteeIndex)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	// Check if the validator is an aggregator
+	isAggregator, err := helpers.IsAggregator(uint64(len(committee)), req.SlotSignature)
+	if err != nil {
+		return 0, 0, status.Errorf(codes.Internal, "Could not get aggregator status: %v", err)
+	}
+	if !isAggregator {
+		return 0, 0, status.Errorf(codes.InvalidArgument, "Validator is not an aggregator")
+	}
 
 	var indexInCommittee uint64
 	for i, idx := range committee {
@@ -159,14 +125,7 @@ func (vs *Server) SubmitAggregateSelectionProofElectra(
 			indexInCommittee = uint64(i)
 		}
 	}
-
-	best := bestAggregate(atts, req.CommitteeIndex, indexInCommittee)
-	attAndProof := &ethpb.AggregateAttestationAndProofElectra{
-		Aggregate:       best,
-		SelectionProof:  req.SlotSignature,
-		AggregatorIndex: validatorIndex,
-	}
-	return &ethpb.AggregateSelectionElectraResponse{AggregateAndProof: attAndProof}, nil
+	return indexInCommittee, validatorIndex, nil
 }
 
 // SubmitSignedAggregateSelectionProof is called by a validator to broadcast a signed

beacon-chain/state/fieldtrie/field_trie_helpers.go

@@ -14,21 +14,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
-// ProofFromMerkleLayers creates a proof starting at the leaf index of the state Merkle layers.
-func ProofFromMerkleLayers(layers [][][]byte, startingLeafIndex int) [][]byte {
-	// The merkle tree structure looks as follows:
-	// [[r1, r2, r3, r4], [parent1, parent2], [root]]
-	proof := make([][]byte, 0)
-	currentIndex := startingLeafIndex
-	for i := 0; i < len(layers)-1; i++ {
-		neighborIdx := currentIndex ^ 1
-		neighbor := layers[i][neighborIdx]
-		proof = append(proof, neighbor)
-		currentIndex = currentIndex / 2
-	}
-	return proof
-}
-
 func (f *FieldTrie) validateIndices(idxs []uint64) error {
 	length := f.length
 	if f.dataType == types.CompressedArray {

beacon-chain/state/genesis/BUILD.bazel

@@ -8,7 +8,10 @@ go_library(
     ],
     embedsrcs = ["mainnet.ssz.snappy"],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/state/genesis",
-    visibility = ["//beacon-chain/db:__subpackages__"],
+    visibility = [
+        "//beacon-chain/db:__subpackages__",
+        "//config/params:go_default_test",
+    ],
     deps = [
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",

beacon-chain/state/state-native/BUILD.bazel

@@ -67,6 +67,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//container/multi-value-slice:go_default_library",
         "//container/slice:go_default_library",
+        "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/state/state-native/proofs.go

@@ -4,8 +4,8 @@ import (
 	"context"
 	"encoding/binary"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/fieldtrie"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native/types"
+	"github.com/prysmaticlabs/prysm/v5/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
@@ -56,7 +56,7 @@ func (b *BeaconState) CurrentSyncCommitteeProof(ctx context.Context) ([][]byte,
 	if err := b.recomputeDirtyFields(ctx); err != nil {
 		return nil, err
 	}
-	return fieldtrie.ProofFromMerkleLayers(b.merkleLayers, types.CurrentSyncCommittee.RealPosition()), nil
+	return trie.ProofFromMerkleLayers(b.merkleLayers, types.CurrentSyncCommittee.RealPosition()), nil
 }
 
 // NextSyncCommitteeProof from the state's Merkle trie representation.
@@ -74,7 +74,7 @@ func (b *BeaconState) NextSyncCommitteeProof(ctx context.Context) ([][]byte, err
 	if err := b.recomputeDirtyFields(ctx); err != nil {
 		return nil, err
 	}
-	return fieldtrie.ProofFromMerkleLayers(b.merkleLayers, types.NextSyncCommittee.RealPosition()), nil
+	return trie.ProofFromMerkleLayers(b.merkleLayers, types.NextSyncCommittee.RealPosition()), nil
 }
 
 // FinalizedRootProof crafts a Merkle proof for the finalized root
@@ -102,7 +102,7 @@ func (b *BeaconState) FinalizedRootProof(ctx context.Context) ([][]byte, error)
 	epochRoot := bytesutil.ToBytes32(epochBuf)
 	proof := make([][]byte, 0)
 	proof = append(proof, epochRoot[:])
-	branch := fieldtrie.ProofFromMerkleLayers(b.merkleLayers, types.FinalizedCheckpoint.RealPosition())
+	branch := trie.ProofFromMerkleLayers(b.merkleLayers, types.FinalizedCheckpoint.RealPosition())
 	proof = append(proof, branch...)
 	return proof, nil
 }

config/params/BUILD.bazel

@@ -62,6 +62,7 @@ go_test(
     gotags = ["develop"],
     tags = ["CI_race_detection"],
     deps = [
+        "//beacon-chain/state/genesis:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//io/file:go_default_library",

config/params/config.go

@@ -128,6 +128,7 @@ type BeaconChainConfig struct {
 	DomainConsolidation               [4]byte `yaml:"DOMAIN_CONSOLIDATION" spec:"true"`
 
 	// Prysm constants.
+	GenesisValidatorsRoot          [32]byte        // GenesisValidatorsRoot is the root hash of the genesis validators.
 	GweiPerEth                     uint64          // GweiPerEth is the amount of gwei corresponding to 1 eth.
 	BLSSecretKeyLength             int             // BLSSecretKeyLength defines the expected length of BLS secret keys in bytes.
 	BLSPubkeyLength                int             // BLSPubkeyLength defines the expected length of BLS public keys in bytes.

config/params/config_test.go

@@ -1,9 +1,11 @@
 package params_test
 
 import (
+	"bytes"
 	"sync"
 	"testing"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/genesis"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -92,3 +94,14 @@ func TestConfig_WithinDAPeriod(t *testing.T) {
 		})
 	}
 }
+
+func TestConfigGenesisValidatorRoot(t *testing.T) {
+	g, err := genesis.State(params.MainnetName)
+	require.NoError(t, err)
+
+	gvr := g.GenesisValidatorsRoot()
+
+	if !bytes.Equal(gvr, params.BeaconConfig().GenesisValidatorsRoot[:]) {
+		t.Fatal("mainnet params genesis validator root does not match the mainnet genesis state value")
+	}
+}

config/params/mainnet_config.go

@@ -174,6 +174,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	DomainConsolidation:               bytesutil.Uint32ToBytes4(0x0B000000),
 
 	// Prysm constants.
+	GenesisValidatorsRoot:          [32]byte{75, 54, 61, 185, 78, 40, 97, 32, 215, 110, 185, 5, 52, 15, 221, 78, 84, 191, 233, 240, 107, 243, 63, 246, 207, 90, 210, 127, 81, 27, 254, 149},
 	GweiPerEth:                     1000000000,
 	BLSSecretKeyLength:             32,
 	BLSPubkeyLength:                48,
@@ -276,7 +277,7 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 
 	// Values related to electra
 	MaxRequestDataColumnSidecars:          16384,
-	DataColumnSidecarSubnetCount:          32,
+	DataColumnSidecarSubnetCount:          128,
 	MinPerEpochChurnLimitElectra:          128_000_000_000,
 	MaxPerEpochActivationExitChurnLimit:   256_000_000_000,
 	MaxEffectiveBalanceElectra:            2048_000_000_000,
@@ -293,6 +294,10 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	MaxDepositRequestsPerPayload:          8192, // 2**13 (= 8192)
 	UnsetDepositRequestsStartIndex:        math.MaxUint64,
 
+	// PeerDAS
+	NumberOfColumns:          128,
+	MaxCellsInExtendedMatrix: 768,
+
 	// Values related to networking parameters.
 	GossipMaxSize:                   10 * 1 << 20, // 10 MiB
 	MaxChunkSize:                    10 * 1 << 20, // 10 MiB
@@ -310,10 +315,6 @@ var mainnetBeaconConfig = &BeaconChainConfig{
 	AttestationSubnetPrefixBits:     6,
 	SubnetsPerNode:                  2,
 	NodeIdBits:                      256,
-
-	// PeerDAS
-	NumberOfColumns:          128,
-	MaxCellsInExtendedMatrix: 768,
 }
 
 // MainnetTestConfig provides a version of the mainnet config that has a different name

config/params/testnet_holesky_config.go

@@ -26,6 +26,7 @@ func HoleskyConfig() *BeaconChainConfig {
 	cfg.MinGenesisTime = 1695902100
 	cfg.GenesisDelay = 300
 	cfg.ConfigName = HoleskyName
+	cfg.GenesisValidatorsRoot = [32]byte{145, 67, 170, 124, 97, 90, 127, 113, 21, 226, 182, 170, 195, 25, 192, 53, 41, 223, 130, 66, 174, 112, 95, 186, 157, 243, 155, 121, 197, 159, 168, 177}
 	cfg.GenesisForkVersion = []byte{0x01, 0x01, 0x70, 0x00}
 	cfg.SecondsPerETH1Block = 14
 	cfg.DepositChainID = 17000

config/params/testnet_sepolia_config.go

@@ -26,6 +26,7 @@ func SepoliaConfig() *BeaconChainConfig {
 	cfg.MinGenesisTime = 1655647200
 	cfg.GenesisDelay = 86400
 	cfg.MinGenesisActiveValidatorCount = 1300
+	cfg.GenesisValidatorsRoot = [32]byte{216, 234, 23, 31, 60, 148, 174, 162, 30, 188, 66, 161, 237, 97, 5, 42, 207, 63, 146, 9, 192, 14, 78, 251, 170, 221, 172, 9, 237, 155, 128, 120}
 	cfg.ConfigName = SepoliaName
 	cfg.GenesisForkVersion = []byte{0x90, 0x00, 0x00, 0x69}
 	cfg.SecondsPerETH1Block = 14

consensus-types/blocks/BUILD.bazel

@@ -18,6 +18,7 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/state/stateutil:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",

consensus-types/blocks/proofs.go

@@ -3,15 +3,23 @@ package blocks
 import (
 	"context"
 	"encoding/binary"
+	"errors"
 	"fmt"
 
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stateutil"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/container/trie"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash/htr"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"go.opencensus.io/trace"
 )
 
+const (
+	payloadFieldIndex = 9
+	bodyFieldIndex    = 4
+)
+
 func ComputeBlockBodyFieldRoots(ctx context.Context, blockBody *BeaconBlockBody) ([][]byte, error) {
 	_, span := trace.StartSpan(ctx, "blocks.ComputeBlockBodyFieldRoots")
 	defer span.End()
@@ -172,3 +180,68 @@ func ComputeBlockBodyFieldRoots(ctx context.Context, blockBody *BeaconBlockBody)
 
 	return fieldRoots, nil
 }
+
+func ComputeBlockFieldRoots(ctx context.Context, block *BeaconBlock) ([][]byte, error) {
+	_, span := trace.StartSpan(ctx, "blocks.ComputeBlockFieldRoots")
+	defer span.End()
+
+	if block == nil {
+		return nil, errNilBlock
+	}
+
+	fieldRoots := make([][]byte, 5)
+	for i := range fieldRoots {
+		fieldRoots[i] = make([]byte, 32)
+	}
+
+	// Slot
+	slotRoot := ssz.Uint64Root(uint64(block.slot))
+	copy(fieldRoots[0], slotRoot[:])
+
+	// Proposer Index
+	proposerRoot := ssz.Uint64Root(uint64(block.proposerIndex))
+	copy(fieldRoots[1], proposerRoot[:])
+
+	// Parent Root
+	copy(fieldRoots[2], block.parentRoot[:])
+
+	// State Root
+	copy(fieldRoots[3], block.stateRoot[:])
+
+	// block body Root
+	blockBodyRoot, err := block.body.HashTreeRoot()
+	if err != nil {
+		return nil, err
+	}
+	copy(fieldRoots[4], blockBodyRoot[:])
+
+	return fieldRoots, nil
+}
+
+func PayloadProof(ctx context.Context, block *BeaconBlock) ([][]byte, error) {
+	i := block.Body()
+	blockBody, ok := i.(*BeaconBlockBody)
+	if !ok {
+		return nil, errors.New("failed to cast block body")
+	}
+
+	blockBodyFieldRoots, err := ComputeBlockBodyFieldRoots(ctx, blockBody)
+	if err != nil {
+		return nil, err
+	}
+
+	blockBodyFieldRootsTrie := stateutil.Merkleize(blockBodyFieldRoots)
+	blockBodyProof := trie.ProofFromMerkleLayers(blockBodyFieldRootsTrie, payloadFieldIndex)
+
+	beaconBlockFieldRoots, err := ComputeBlockFieldRoots(ctx, block)
+	if err != nil {
+		return nil, err
+	}
+
+	beaconBlockFieldRootsTrie := stateutil.Merkleize(beaconBlockFieldRoots)
+	beaconBlockProof := trie.ProofFromMerkleLayers(beaconBlockFieldRootsTrie, bodyFieldIndex)
+
+	finalProof := append(blockBodyProof, beaconBlockProof...)
+
+	return finalProof, nil
+}

container/trie/sparse_merkle.go

@@ -259,3 +259,18 @@ func (m *SparseMerkleTrie) NumOfItems() int {
 	}
 	return len(m.originalItems)
 }
+
+// ProofFromMerkleLayers creates a proof starting at the leaf index of the merkle layers.
+func ProofFromMerkleLayers(layers [][][]byte, startingLeafIndex int) [][]byte {
+	// The merkle tree structure looks as follows:
+	// [[r1, r2, r3, r4], [parent1, parent2], [root]]
+	proof := make([][]byte, 0)
+	currentIndex := startingLeafIndex
+	for i := 0; i < len(layers)-1; i++ {
+		neighborIdx := currentIndex ^ 1
+		neighbor := layers[i][neighborIdx]
+		proof = append(proof, neighbor)
+		currentIndex = currentIndex / 2
+	}
+	return proof
+}

proto/eth/v2/beacon_lightclient.pb.go

@@ -434,6 +434,61 @@ func (x *LightClientOptimisticUpdate) GetSignatureSlot() github_com_prysmaticlab
 	return github_com_prysmaticlabs_prysm_v5_consensus_types_primitives.Slot(0)
 }
 
+type LightClientUpdateWithVersion struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Version Version            `protobuf:"varint,1,opt,name=version,proto3,enum=ethereum.eth.v2.Version" json:"version,omitempty"`
+	Data    *LightClientUpdate `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
+}
+
+func (x *LightClientUpdateWithVersion) Reset() {
+	*x = LightClientUpdateWithVersion{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[6]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *LightClientUpdateWithVersion) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*LightClientUpdateWithVersion) ProtoMessage() {}
+
+func (x *LightClientUpdateWithVersion) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_eth_v2_beacon_lightclient_proto_msgTypes[6]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use LightClientUpdateWithVersion.ProtoReflect.Descriptor instead.
+func (*LightClientUpdateWithVersion) Descriptor() ([]byte, []int) {
+	return file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP(), []int{6}
+}
+
+func (x *LightClientUpdateWithVersion) GetVersion() Version {
+	if x != nil {
+		return x.Version
+	}
+	return Version_PHASE0
+}
+
+func (x *LightClientUpdateWithVersion) GetData() *LightClientUpdate {
+	if x != nil {
+		return x.Data
+	}
+	return nil
+}
+
 var File_proto_eth_v2_beacon_lightclient_proto protoreflect.FileDescriptor
 
 var file_proto_eth_v2_beacon_lightclient_proto_rawDesc = []byte{
@@ -560,16 +615,25 @@ var file_proto_eth_v2_beacon_lightclient_proto_rawDesc = []byte{
 	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x63, 0x6f, 0x6e, 0x73, 0x65, 0x6e,
 	0x73, 0x75, 0x73, 0x2d, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x70, 0x72, 0x69, 0x6d, 0x69, 0x74,
 	0x69, 0x76, 0x65, 0x73, 0x2e, 0x53, 0x6c, 0x6f, 0x74, 0x52, 0x0d, 0x73, 0x69, 0x67, 0x6e, 0x61,
-	0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x42, 0x83, 0x01, 0x0a, 0x13, 0x6f, 0x72, 0x67,
-	0x2e, 0x65, 0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32,
-	0x42, 0x12, 0x53, 0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x50,
-	0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63,
-	0x6f, 0x6d, 0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73,
-	0x2f, 0x70, 0x72, 0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f,
-	0x65, 0x74, 0x68, 0x2f, 0x76, 0x32, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x0f, 0x45, 0x74, 0x68,
-	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x32, 0xca, 0x02, 0x0f, 0x45,
-	0x74, 0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x32, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x74, 0x75, 0x72, 0x65, 0x53, 0x6c, 0x6f, 0x74, 0x22, 0x8a, 0x01, 0x0a, 0x1c, 0x4c, 0x69, 0x67,
+	0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x57, 0x69,
+	0x74, 0x68, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x07, 0x76, 0x65, 0x72,
+	0x73, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x18, 0x2e, 0x65, 0x74, 0x68,
+	0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x56, 0x65, 0x72,
+	0x73, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x36, 0x0a,
+	0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x65, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x2e, 0x4c, 0x69,
+	0x67, 0x68, 0x74, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52,
+	0x04, 0x64, 0x61, 0x74, 0x61, 0x42, 0x83, 0x01, 0x0a, 0x13, 0x6f, 0x72, 0x67, 0x2e, 0x65, 0x74,
+	0x68, 0x65, 0x72, 0x65, 0x75, 0x6d, 0x2e, 0x65, 0x74, 0x68, 0x2e, 0x76, 0x32, 0x42, 0x12, 0x53,
+	0x79, 0x6e, 0x63, 0x43, 0x6f, 0x6d, 0x6d, 0x69, 0x74, 0x74, 0x65, 0x65, 0x50, 0x72, 0x6f, 0x74,
+	0x6f, 0x50, 0x01, 0x5a, 0x32, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f,
+	0x70, 0x72, 0x79, 0x73, 0x6d, 0x61, 0x74, 0x69, 0x63, 0x6c, 0x61, 0x62, 0x73, 0x2f, 0x70, 0x72,
+	0x79, 0x73, 0x6d, 0x2f, 0x76, 0x35, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x65, 0x74, 0x68,
+	0x2f, 0x76, 0x32, 0x3b, 0x65, 0x74, 0x68, 0xaa, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65, 0x72, 0x65,
+	0x75, 0x6d, 0x2e, 0x45, 0x74, 0x68, 0x2e, 0x56, 0x32, 0xca, 0x02, 0x0f, 0x45, 0x74, 0x68, 0x65,
+	0x72, 0x65, 0x75, 0x6d, 0x5c, 0x45, 0x74, 0x68, 0x5c, 0x76, 0x32, 0x62, 0x06, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x33,
 }
 
 var (
@@ -584,7 +648,7 @@ func file_proto_eth_v2_beacon_lightclient_proto_rawDescGZIP() []byte {
 	return file_proto_eth_v2_beacon_lightclient_proto_rawDescData
 }
 
-var file_proto_eth_v2_beacon_lightclient_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
+var file_proto_eth_v2_beacon_lightclient_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
 var file_proto_eth_v2_beacon_lightclient_proto_goTypes = []interface{}{
 	(*LightClientBootstrap)(nil),                   // 0: ethereum.eth.v2.LightClientBootstrap
 	(*LightClientUpdate)(nil),                      // 1: ethereum.eth.v2.LightClientUpdate
@@ -592,32 +656,35 @@ var file_proto_eth_v2_beacon_lightclient_proto_goTypes = []interface{}{
 	(*LightClientFinalityUpdate)(nil),              // 3: ethereum.eth.v2.LightClientFinalityUpdate
 	(*LightClientOptimisticUpdateWithVersion)(nil), // 4: ethereum.eth.v2.LightClientOptimisticUpdateWithVersion
 	(*LightClientOptimisticUpdate)(nil),            // 5: ethereum.eth.v2.LightClientOptimisticUpdate
-	(*v1.BeaconBlockHeader)(nil),                   // 6: ethereum.eth.v1.BeaconBlockHeader
-	(*SyncCommittee)(nil),                          // 7: ethereum.eth.v2.SyncCommittee
-	(*v1.SyncAggregate)(nil),                       // 8: ethereum.eth.v1.SyncAggregate
-	(Version)(0),                                   // 9: ethereum.eth.v2.Version
+	(*LightClientUpdateWithVersion)(nil),           // 6: ethereum.eth.v2.LightClientUpdateWithVersion
+	(*v1.BeaconBlockHeader)(nil),                   // 7: ethereum.eth.v1.BeaconBlockHeader
+	(*SyncCommittee)(nil),                          // 8: ethereum.eth.v2.SyncCommittee
+	(*v1.SyncAggregate)(nil),                       // 9: ethereum.eth.v1.SyncAggregate
+	(Version)(0),                                   // 10: ethereum.eth.v2.Version
 }
 var file_proto_eth_v2_beacon_lightclient_proto_depIdxs = []int32{
-	6,  // 0: ethereum.eth.v2.LightClientBootstrap.header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	7,  // 1: ethereum.eth.v2.LightClientBootstrap.current_sync_committee:type_name -> ethereum.eth.v2.SyncCommittee
-	6,  // 2: ethereum.eth.v2.LightClientUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	7,  // 3: ethereum.eth.v2.LightClientUpdate.next_sync_committee:type_name -> ethereum.eth.v2.SyncCommittee
-	6,  // 4: ethereum.eth.v2.LightClientUpdate.finalized_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	8,  // 5: ethereum.eth.v2.LightClientUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate
-	9,  // 6: ethereum.eth.v2.LightClientFinalityUpdateWithVersion.version:type_name -> ethereum.eth.v2.Version
+	7,  // 0: ethereum.eth.v2.LightClientBootstrap.header:type_name -> ethereum.eth.v1.BeaconBlockHeader
+	8,  // 1: ethereum.eth.v2.LightClientBootstrap.current_sync_committee:type_name -> ethereum.eth.v2.SyncCommittee
+	7,  // 2: ethereum.eth.v2.LightClientUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
+	8,  // 3: ethereum.eth.v2.LightClientUpdate.next_sync_committee:type_name -> ethereum.eth.v2.SyncCommittee
+	7,  // 4: ethereum.eth.v2.LightClientUpdate.finalized_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
+	9,  // 5: ethereum.eth.v2.LightClientUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate
+	10, // 6: ethereum.eth.v2.LightClientFinalityUpdateWithVersion.version:type_name -> ethereum.eth.v2.Version
 	3,  // 7: ethereum.eth.v2.LightClientFinalityUpdateWithVersion.data:type_name -> ethereum.eth.v2.LightClientFinalityUpdate
-	6,  // 8: ethereum.eth.v2.LightClientFinalityUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	6,  // 9: ethereum.eth.v2.LightClientFinalityUpdate.finalized_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	8,  // 10: ethereum.eth.v2.LightClientFinalityUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate
-	9,  // 11: ethereum.eth.v2.LightClientOptimisticUpdateWithVersion.version:type_name -> ethereum.eth.v2.Version
+	7,  // 8: ethereum.eth.v2.LightClientFinalityUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
+	7,  // 9: ethereum.eth.v2.LightClientFinalityUpdate.finalized_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
+	9,  // 10: ethereum.eth.v2.LightClientFinalityUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate
+	10, // 11: ethereum.eth.v2.LightClientOptimisticUpdateWithVersion.version:type_name -> ethereum.eth.v2.Version
 	5,  // 12: ethereum.eth.v2.LightClientOptimisticUpdateWithVersion.data:type_name -> ethereum.eth.v2.LightClientOptimisticUpdate
-	6,  // 13: ethereum.eth.v2.LightClientOptimisticUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
-	8,  // 14: ethereum.eth.v2.LightClientOptimisticUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate
-	15, // [15:15] is the sub-list for method output_type
-	15, // [15:15] is the sub-list for method input_type
-	15, // [15:15] is the sub-list for extension type_name
-	15, // [15:15] is the sub-list for extension extendee
-	0,  // [0:15] is the sub-list for field type_name
+	7,  // 13: ethereum.eth.v2.LightClientOptimisticUpdate.attested_header:type_name -> ethereum.eth.v1.BeaconBlockHeader
+	9,  // 14: ethereum.eth.v2.LightClientOptimisticUpdate.sync_aggregate:type_name -> ethereum.eth.v1.SyncAggregate
+	10, // 15: ethereum.eth.v2.LightClientUpdateWithVersion.version:type_name -> ethereum.eth.v2.Version
+	1,  // 16: ethereum.eth.v2.LightClientUpdateWithVersion.data:type_name -> ethereum.eth.v2.LightClientUpdate
+	17, // [17:17] is the sub-list for method output_type
+	17, // [17:17] is the sub-list for method input_type
+	17, // [17:17] is the sub-list for extension type_name
+	17, // [17:17] is the sub-list for extension extendee
+	0,  // [0:17] is the sub-list for field type_name
 }
 
 func init() { file_proto_eth_v2_beacon_lightclient_proto_init() }
@@ -700,6 +767,18 @@ func file_proto_eth_v2_beacon_lightclient_proto_init() {
 				return nil
 			}
 		}
+		file_proto_eth_v2_beacon_lightclient_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*LightClientUpdateWithVersion); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
 	}
 	type x struct{}
 	out := protoimpl.TypeBuilder{
@@ -707,7 +786,7 @@ func file_proto_eth_v2_beacon_lightclient_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_eth_v2_beacon_lightclient_proto_rawDesc,
 			NumEnums:      0,
-			NumMessages:   6,
+			NumMessages:   7,
 			NumExtensions: 0,
 			NumServices:   0,
 		},

proto/eth/v2/beacon_lightclient.proto

@@ -30,41 +30,46 @@ option php_namespace = "Ethereum\\Eth\\v2";
 // Beacon LightClient API related messages.
 
 message LightClientBootstrap {
-    v1.BeaconBlockHeader header = 1;
-    SyncCommittee current_sync_committee = 2;
-    repeated bytes current_sync_committee_branch = 3;
+  v1.BeaconBlockHeader header = 1;
+  SyncCommittee current_sync_committee = 2;
+  repeated bytes current_sync_committee_branch = 3;
 }
 
 message LightClientUpdate {
-    v1.BeaconBlockHeader attested_header = 1;
-    SyncCommittee next_sync_committee = 2;
-    repeated bytes next_sync_committee_branch = 3;
-    v1.BeaconBlockHeader finalized_header = 4;
-    repeated bytes finality_branch = 5;
-    v1.SyncAggregate sync_aggregate = 6;
-    uint64 signature_slot = 7 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
+  v1.BeaconBlockHeader attested_header = 1;
+  SyncCommittee next_sync_committee = 2;
+  repeated bytes next_sync_committee_branch = 3;
+  v1.BeaconBlockHeader finalized_header = 4;
+  repeated bytes finality_branch = 5;
+  v1.SyncAggregate sync_aggregate = 6;
+  uint64 signature_slot = 7 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
 }
 
 message LightClientFinalityUpdateWithVersion {
-    v2.Version version = 1;
-    LightClientFinalityUpdate data = 2;
+  v2.Version version = 1;
+  LightClientFinalityUpdate data = 2;
 }
 
 message LightClientFinalityUpdate {
-    v1.BeaconBlockHeader attested_header = 1;
-    v1.BeaconBlockHeader finalized_header = 2;
-    repeated bytes finality_branch = 3;
-    v1.SyncAggregate sync_aggregate = 4;
-    uint64 signature_slot = 5 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
+  v1.BeaconBlockHeader attested_header = 1;
+  v1.BeaconBlockHeader finalized_header = 2;
+  repeated bytes finality_branch = 3;
+  v1.SyncAggregate sync_aggregate = 4;
+  uint64 signature_slot = 5 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
 }
 
 message LightClientOptimisticUpdateWithVersion {
-    v2.Version version = 1;
-    LightClientOptimisticUpdate data = 2;
+  v2.Version version = 1;
+  LightClientOptimisticUpdate data = 2;
 }
 
 message LightClientOptimisticUpdate {
-    v1.BeaconBlockHeader attested_header = 1;
-    v1.SyncAggregate sync_aggregate = 2;
-    uint64 signature_slot = 3 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
+  v1.BeaconBlockHeader attested_header = 1;
+  v1.SyncAggregate sync_aggregate = 2;
+  uint64 signature_slot = 3 [(ethereum.eth.ext.cast_type) = "github.com/prysmaticlabs/prysm/v5/consensus-types/primitives.Slot"];
 }
+
+message LightClientUpdateWithVersion {
+  v2.Version version = 1;
+  LightClientUpdate data = 2;
+}

proto/prysm/v1alpha1/BUILD.bazel

@@ -149,6 +149,7 @@ ssz_electra_objs = [
     "PendingConsolidation",
     "PendingPartialWithdrawal",
     "SignedAggregateAttestationAndProofElectra",
+    "SignedBeaconBlockContentsElectra",
     "SignedBeaconBlockElectra",
     "SignedBlindedBeaconBlockElectra",
     "SignedConsolidation",
@@ -156,90 +157,89 @@ ssz_electra_objs = [
 
 ssz_gen_marshal(
     name = "ssz_generated_phase0",
-    go_proto = ":go_proto",
     out = "phase0.ssz.go",
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = ssz_phase0_objs,
 )
 
 ssz_gen_marshal(
     name = "ssz_generated_altair",
-    go_proto = ":go_proto",
     out = "altair.ssz.go",
+    exclude_objs = ssz_phase0_objs,
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = ssz_altair_objs,
-    exclude_objs = ssz_phase0_objs,
 )
 
 ssz_gen_marshal(
     name = "ssz_generated_bellatrix",
-    go_proto = ":go_proto",
     out = "bellatrix.ssz.go",
+    exclude_objs = ssz_phase0_objs + ssz_altair_objs,
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = ssz_bellatrix_objs,
-    exclude_objs = ssz_phase0_objs + ssz_altair_objs,
 )
 
 ssz_gen_marshal(
     name = "ssz_generated_capella",
-    go_proto = ":go_proto",
     out = "capella.ssz.go",
+    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs,
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = ssz_capella_objs,
-    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs,
 )
 
 ssz_gen_marshal(
     name = "ssz_generated_deneb",
-    go_proto = ":go_proto",
     out = "deneb.ssz.go",
+    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs + ssz_capella_objs,
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = ssz_deneb_objs,
-    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs  + ssz_capella_objs,
 )
 
 ssz_gen_marshal(
     name = "ssz_generated_electra",
-    go_proto = ":go_proto",
     out = "electra.ssz.go",
+    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs + ssz_capella_objs + ssz_deneb_objs,
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = ssz_electra_objs,
-    exclude_objs = ssz_phase0_objs + ssz_altair_objs + ssz_bellatrix_objs  + ssz_capella_objs + ssz_deneb_objs,
 )
 
-
 ssz_gen_marshal(
     name = "ssz_generated_non_core",
-    go_proto = ":go_proto",
     out = "non-core.ssz.go",
+    go_proto = ":go_proto",
     includes = [
         "//consensus-types/primitives:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//math:go_default_library",
+        "//proto/engine/v1:go_default_library",
     ],
     objs = [
         "BeaconBlocksByRangeRequest",
@@ -313,13 +313,13 @@ go_library(
         "eip_7521.go",
         "sync_committee_mainnet.go",
         "sync_committee_minimal.go",  # keep
-        ":ssz_generated_non_core",  # keep
-        ":ssz_generated_phase0",  # keep
         ":ssz_generated_altair",  # keep
         ":ssz_generated_bellatrix",  # keep
         ":ssz_generated_capella",  # keep
         ":ssz_generated_deneb",  # keep
         ":ssz_generated_electra",  # keep
+        ":ssz_generated_non_core",  # keep
+        ":ssz_generated_phase0",  # keep
     ],
     embed = [
         ":go_grpc_gateway_library",

proto/prysm/v1alpha1/electra.ssz.go

@@ -1,5 +1,5 @@
 // Code generated by fastssz. DO NOT EDIT.
-// Hash: 84572d8fa233c45a41477bced891ee355cc1745ae0fad290f110b7f6b5ed12e1
+// Hash: 502599304fd370b8602d212eaf1956fe5bf034fe59c75d1a3a6e3db8bcde291a
 package eth
 
 import (
@@ -30,20 +30,20 @@ func (a *AttestationElectra) MarshalSSZTo(buf []byte) (dst []byte, err error) {
 		return
 	}
 
-	// Field (2) 'CommitteeBits'
-	if size := len(a.CommitteeBits); size != 8 {
-		err = ssz.ErrBytesLengthFn("--.CommitteeBits", size, 8)
-		return
-	}
-	dst = append(dst, a.CommitteeBits...)
-
-	// Field (3) 'Signature'
+	// Field (2) 'Signature'
 	if size := len(a.Signature); size != 96 {
 		err = ssz.ErrBytesLengthFn("--.Signature", size, 96)
 		return
 	}
 	dst = append(dst, a.Signature...)
 
+	// Field (3) 'CommitteeBits'
+	if size := len(a.CommitteeBits); size != 8 {
+		err = ssz.ErrBytesLengthFn("--.CommitteeBits", size, 8)
+		return
+	}
+	dst = append(dst, a.CommitteeBits...)
+
 	// Field (0) 'AggregationBits'
 	if size := len(a.AggregationBits); size > 131072 {
 		err = ssz.ErrBytesLengthFn("--.AggregationBits", size, 131072)
@@ -82,17 +82,17 @@ func (a *AttestationElectra) UnmarshalSSZ(buf []byte) error {
 		return err
 	}
 
-	// Field (2) 'CommitteeBits'
-	if cap(a.CommitteeBits) == 0 {
-		a.CommitteeBits = make([]byte, 0, len(buf[132:140]))
-	}
-	a.CommitteeBits = append(a.CommitteeBits, buf[132:140]...)
-
-	// Field (3) 'Signature'
+	// Field (2) 'Signature'
 	if cap(a.Signature) == 0 {
-		a.Signature = make([]byte, 0, len(buf[140:236]))
+		a.Signature = make([]byte, 0, len(buf[132:228]))
 	}
-	a.Signature = append(a.Signature, buf[140:236]...)
+	a.Signature = append(a.Signature, buf[132:228]...)
+
+	// Field (3) 'CommitteeBits'
+	if cap(a.CommitteeBits) == 0 {
+		a.CommitteeBits = make([]byte, 0, len(buf[228:236]))
+	}
+	a.CommitteeBits = append(a.CommitteeBits, buf[228:236]...)
 
 	// Field (0) 'AggregationBits'
 	{
@@ -139,20 +139,20 @@ func (a *AttestationElectra) HashTreeRootWith(hh *ssz.Hasher) (err error) {
 		return
 	}
 
-	// Field (2) 'CommitteeBits'
-	if size := len(a.CommitteeBits); size != 8 {
-		err = ssz.ErrBytesLengthFn("--.CommitteeBits", size, 8)
-		return
-	}
-	hh.PutBytes(a.CommitteeBits)
-
-	// Field (3) 'Signature'
+	// Field (2) 'Signature'
 	if size := len(a.Signature); size != 96 {
 		err = ssz.ErrBytesLengthFn("--.Signature", size, 96)
 		return
 	}
 	hh.PutBytes(a.Signature)
 
+	// Field (3) 'CommitteeBits'
+	if size := len(a.CommitteeBits); size != 8 {
+		err = ssz.ErrBytesLengthFn("--.CommitteeBits", size, 8)
+		return
+	}
+	hh.PutBytes(a.CommitteeBits)
+
 	hh.Merkleize(indx)
 	return
 }
@@ -653,6 +653,215 @@ func (i *IndexedAttestationElectra) HashTreeRootWith(hh *ssz.Hasher) (err error)
 	return
 }
 
+// MarshalSSZ ssz marshals the SignedBeaconBlockContentsElectra object
+func (s *SignedBeaconBlockContentsElectra) MarshalSSZ() ([]byte, error) {
+	return ssz.MarshalSSZ(s)
+}
+
+// MarshalSSZTo ssz marshals the SignedBeaconBlockContentsElectra object to a target array
+func (s *SignedBeaconBlockContentsElectra) MarshalSSZTo(buf []byte) (dst []byte, err error) {
+	dst = buf
+	offset := int(12)
+
+	// Offset (0) 'Block'
+	dst = ssz.WriteOffset(dst, offset)
+	if s.Block == nil {
+		s.Block = new(SignedBeaconBlockElectra)
+	}
+	offset += s.Block.SizeSSZ()
+
+	// Offset (1) 'KzgProofs'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(s.KzgProofs) * 48
+
+	// Offset (2) 'Blobs'
+	dst = ssz.WriteOffset(dst, offset)
+	offset += len(s.Blobs) * 131072
+
+	// Field (0) 'Block'
+	if dst, err = s.Block.MarshalSSZTo(dst); err != nil {
+		return
+	}
+
+	// Field (1) 'KzgProofs'
+	if size := len(s.KzgProofs); size > 4096 {
+		err = ssz.ErrListTooBigFn("--.KzgProofs", size, 4096)
+		return
+	}
+	for ii := 0; ii < len(s.KzgProofs); ii++ {
+		if size := len(s.KzgProofs[ii]); size != 48 {
+			err = ssz.ErrBytesLengthFn("--.KzgProofs[ii]", size, 48)
+			return
+		}
+		dst = append(dst, s.KzgProofs[ii]...)
+	}
+
+	// Field (2) 'Blobs'
+	if size := len(s.Blobs); size > 4096 {
+		err = ssz.ErrListTooBigFn("--.Blobs", size, 4096)
+		return
+	}
+	for ii := 0; ii < len(s.Blobs); ii++ {
+		if size := len(s.Blobs[ii]); size != 131072 {
+			err = ssz.ErrBytesLengthFn("--.Blobs[ii]", size, 131072)
+			return
+		}
+		dst = append(dst, s.Blobs[ii]...)
+	}
+
+	return
+}
+
+// UnmarshalSSZ ssz unmarshals the SignedBeaconBlockContentsElectra object
+func (s *SignedBeaconBlockContentsElectra) UnmarshalSSZ(buf []byte) error {
+	var err error
+	size := uint64(len(buf))
+	if size < 12 {
+		return ssz.ErrSize
+	}
+
+	tail := buf
+	var o0, o1, o2 uint64
+
+	// Offset (0) 'Block'
+	if o0 = ssz.ReadOffset(buf[0:4]); o0 > size {
+		return ssz.ErrOffset
+	}
+
+	if o0 != 12 {
+		return ssz.ErrInvalidVariableOffset
+	}
+
+	// Offset (1) 'KzgProofs'
+	if o1 = ssz.ReadOffset(buf[4:8]); o1 > size || o0 > o1 {
+		return ssz.ErrOffset
+	}
+
+	// Offset (2) 'Blobs'
+	if o2 = ssz.ReadOffset(buf[8:12]); o2 > size || o1 > o2 {
+		return ssz.ErrOffset
+	}
+
+	// Field (0) 'Block'
+	{
+		buf = tail[o0:o1]
+		if s.Block == nil {
+			s.Block = new(SignedBeaconBlockElectra)
+		}
+		if err = s.Block.UnmarshalSSZ(buf); err != nil {
+			return err
+		}
+	}
+
+	// Field (1) 'KzgProofs'
+	{
+		buf = tail[o1:o2]
+		num, err := ssz.DivideInt2(len(buf), 48, 4096)
+		if err != nil {
+			return err
+		}
+		s.KzgProofs = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(s.KzgProofs[ii]) == 0 {
+				s.KzgProofs[ii] = make([]byte, 0, len(buf[ii*48:(ii+1)*48]))
+			}
+			s.KzgProofs[ii] = append(s.KzgProofs[ii], buf[ii*48:(ii+1)*48]...)
+		}
+	}
+
+	// Field (2) 'Blobs'
+	{
+		buf = tail[o2:]
+		num, err := ssz.DivideInt2(len(buf), 131072, 4096)
+		if err != nil {
+			return err
+		}
+		s.Blobs = make([][]byte, num)
+		for ii := 0; ii < num; ii++ {
+			if cap(s.Blobs[ii]) == 0 {
+				s.Blobs[ii] = make([]byte, 0, len(buf[ii*131072:(ii+1)*131072]))
+			}
+			s.Blobs[ii] = append(s.Blobs[ii], buf[ii*131072:(ii+1)*131072]...)
+		}
+	}
+	return err
+}
+
+// SizeSSZ returns the ssz encoded size in bytes for the SignedBeaconBlockContentsElectra object
+func (s *SignedBeaconBlockContentsElectra) SizeSSZ() (size int) {
+	size = 12
+
+	// Field (0) 'Block'
+	if s.Block == nil {
+		s.Block = new(SignedBeaconBlockElectra)
+	}
+	size += s.Block.SizeSSZ()
+
+	// Field (1) 'KzgProofs'
+	size += len(s.KzgProofs) * 48
+
+	// Field (2) 'Blobs'
+	size += len(s.Blobs) * 131072
+
+	return
+}
+
+// HashTreeRoot ssz hashes the SignedBeaconBlockContentsElectra object
+func (s *SignedBeaconBlockContentsElectra) HashTreeRoot() ([32]byte, error) {
+	return ssz.HashWithDefaultHasher(s)
+}
+
+// HashTreeRootWith ssz hashes the SignedBeaconBlockContentsElectra object with a hasher
+func (s *SignedBeaconBlockContentsElectra) HashTreeRootWith(hh *ssz.Hasher) (err error) {
+	indx := hh.Index()
+
+	// Field (0) 'Block'
+	if err = s.Block.HashTreeRootWith(hh); err != nil {
+		return
+	}
+
+	// Field (1) 'KzgProofs'
+	{
+		if size := len(s.KzgProofs); size > 4096 {
+			err = ssz.ErrListTooBigFn("--.KzgProofs", size, 4096)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range s.KzgProofs {
+			if len(i) != 48 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.PutBytes(i)
+		}
+
+		numItems := uint64(len(s.KzgProofs))
+		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	}
+
+	// Field (2) 'Blobs'
+	{
+		if size := len(s.Blobs); size > 4096 {
+			err = ssz.ErrListTooBigFn("--.Blobs", size, 4096)
+			return
+		}
+		subIndx := hh.Index()
+		for _, i := range s.Blobs {
+			if len(i) != 131072 {
+				err = ssz.ErrBytesLength
+				return
+			}
+			hh.PutBytes(i)
+		}
+
+		numItems := uint64(len(s.Blobs))
+		hh.MerkleizeWithMixin(subIndx, numItems, 4096)
+	}
+
+	hh.Merkleize(indx)
+	return
+}
+
 // MarshalSSZ ssz marshals the SignedBeaconBlockElectra object
 func (s *SignedBeaconBlockElectra) MarshalSSZ() ([]byte, error) {
 	return ssz.MarshalSSZ(s)

testing/util/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "electra_block.go",
         "electra_state.go",
         "helpers.go",
+        "lightclient.go",
         "merge.go",
         "state.go",
         "sync_aggregate.go",

testing/util/lightclient.go

@@ -0,0 +1,117 @@
+package util
+
+import (
+	"context"
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
+	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
+	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
+)
+
+type TestLightClient struct {
+	T              *testing.T
+	Ctx            context.Context
+	State          state.BeaconState
+	Block          interfaces.ReadOnlySignedBeaconBlock
+	AttestedState  state.BeaconState
+	AttestedHeader *ethpb.BeaconBlockHeader
+}
+
+func NewTestLightClient(t *testing.T) *TestLightClient {
+	return &TestLightClient{T: t}
+}
+
+func (l *TestLightClient) SetupTest() *TestLightClient {
+	ctx := context.Background()
+
+	slot := primitives.Slot(params.BeaconConfig().AltairForkEpoch * primitives.Epoch(params.BeaconConfig().SlotsPerEpoch)).Add(1)
+
+	attestedState, err := NewBeaconStateCapella()
+	require.NoError(l.T, err)
+	err = attestedState.SetSlot(slot)
+	require.NoError(l.T, err)
+
+	parent := NewBeaconBlockCapella()
+	parent.Block.Slot = slot
+
+	signedParent, err := blocks.NewSignedBeaconBlock(parent)
+	require.NoError(l.T, err)
+
+	parentHeader, err := signedParent.Header()
+	require.NoError(l.T, err)
+	attestedHeader := parentHeader.Header
+
+	err = attestedState.SetLatestBlockHeader(attestedHeader)
+	require.NoError(l.T, err)
+	attestedStateRoot, err := attestedState.HashTreeRoot(ctx)
+	require.NoError(l.T, err)
+
+	// get a new signed block so the root is updated with the new state root
+	parent.Block.StateRoot = attestedStateRoot[:]
+	signedParent, err = blocks.NewSignedBeaconBlock(parent)
+	require.NoError(l.T, err)
+
+	state, err := NewBeaconStateCapella()
+	require.NoError(l.T, err)
+	err = state.SetSlot(slot)
+	require.NoError(l.T, err)
+
+	parentRoot, err := signedParent.Block().HashTreeRoot()
+	require.NoError(l.T, err)
+
+	block := NewBeaconBlockCapella()
+	block.Block.Slot = slot
+	block.Block.ParentRoot = parentRoot[:]
+
+	for i := uint64(0); i < params.BeaconConfig().MinSyncCommitteeParticipants; i++ {
+		block.Block.Body.SyncAggregate.SyncCommitteeBits.SetBitAt(i, true)
+	}
+
+	signedBlock, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(l.T, err)
+
+	h, err := signedBlock.Header()
+	require.NoError(l.T, err)
+
+	err = state.SetLatestBlockHeader(h.Header)
+	require.NoError(l.T, err)
+	stateRoot, err := state.HashTreeRoot(ctx)
+	require.NoError(l.T, err)
+
+	// get a new signed block so the root is updated with the new state root
+	block.Block.StateRoot = stateRoot[:]
+	signedBlock, err = blocks.NewSignedBeaconBlock(block)
+	require.NoError(l.T, err)
+
+	l.State = state
+	l.AttestedState = attestedState
+	l.AttestedHeader = attestedHeader
+	l.Block = signedBlock
+	l.Ctx = ctx
+
+	return l
+}
+
+func (l *TestLightClient) CheckAttestedHeader(update *ethpbv2.LightClientUpdate) {
+	require.Equal(l.T, l.AttestedHeader.Slot, update.AttestedHeader.Slot, "Attested header slot is not equal")
+	require.Equal(l.T, l.AttestedHeader.ProposerIndex, update.AttestedHeader.ProposerIndex, "Attested header proposer index is not equal")
+	require.DeepSSZEqual(l.T, l.AttestedHeader.ParentRoot, update.AttestedHeader.ParentRoot, "Attested header parent root is not equal")
+	require.DeepSSZEqual(l.T, l.AttestedHeader.BodyRoot, update.AttestedHeader.BodyRoot, "Attested header body root is not equal")
+
+	attestedStateRoot, err := l.AttestedState.HashTreeRoot(l.Ctx)
+	require.NoError(l.T, err)
+	require.DeepSSZEqual(l.T, attestedStateRoot[:], update.AttestedHeader.StateRoot, "Attested header state root is not equal")
+}
+
+func (l *TestLightClient) CheckSyncAggregate(update *ethpbv2.LightClientUpdate) {
+	syncAggregate, err := l.Block.Block().Body().SyncAggregate()
+	require.NoError(l.T, err)
+	require.DeepSSZEqual(l.T, syncAggregate.SyncCommitteeBits, update.SyncAggregate.SyncCommitteeBits, "SyncAggregate bits is not equal")
+	require.DeepSSZEqual(l.T, syncAggregate.SyncCommitteeSignature, update.SyncAggregate.SyncCommitteeSignature, "SyncAggregate signature is not equal")
+}

validator/client/registration.go

@@ -52,7 +52,7 @@ func SubmitValidatorRegistrations(
 	}
 
 	if lastErr == nil {
-		log.Infoln("Submitted builder validator registration settings for custom builders")
+		log.Debugln("Submitted builder validator registration settings for custom builders")
 	} else {
 		log.WithError(lastErr).Warn("Could not submit all signed registrations to beacon node")
 	}

validator/node/node.go

@@ -560,8 +560,8 @@ func Web3SignerConfig(cliCtx *cli.Context) (*remoteweb3signer.SetupConfig, error
 		if cliCtx.IsSet(flags.WalletPasswordFileFlag.Name) {
 			log.Warnf("%s was provided while using web3signer and will be ignored", flags.WalletPasswordFileFlag.Name)
 		}
-
-		if publicKeysSlice := cliCtx.StringSlice(flags.Web3SignerPublicValidatorKeysFlag.Name); len(publicKeysSlice) > 0 {
+		if cliCtx.IsSet(flags.Web3SignerPublicValidatorKeysFlag.Name) {
+			publicKeysSlice := cliCtx.StringSlice(flags.Web3SignerPublicValidatorKeysFlag.Name)
 			if len(publicKeysSlice) == 1 {
 				pURL, err := url.ParseRequestURI(publicKeysSlice[0])
 				if err == nil && pURL.Scheme != "" && pURL.Host != "" {