Fixing Proto Generation

* Update ckzg4844 to latest version

* Run go mod tidy

* Remove unnecessary tests & run goimports

* Remove fieldparams from blockchain/kzg

* Add back blank line

* Avoid large copies

* Run gazelle

* Use trusted setup from the specs & fix issue with struct

* Run goimports

* Fix mistake in makeCellsAndProofs

---------

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

.github/PULL_REQUEST_TEMPLATE.md

@@ -10,7 +10,6 @@
    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?**
@@ -29,9 +28,3 @@
 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

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

.github/workflows/go.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Go mod tidy checker
         id: gomodtidy
@@ -27,11 +27,11 @@ jobs:
       GO111MODULE: on
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
       - name: Set up Go 1.22
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v3
         with:
-          go-version: '1.22.6'
+          go-version: '1.22.3'
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
@@ -43,18 +43,18 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Set up Go 1.22
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v3
         with:
-          go-version: '1.22.6'
+          go-version: '1.22.3'
           id: go
 
       - name: Golangci-lint
-        uses: golangci/golangci-lint-action@v5
+        uses: golangci/golangci-lint-action@v3
         with:
-          version: v1.56.1
+          version: v1.55.2
           args: --config=.golangci.yml --out-${NO_FUTURE}format colored-line-number
 
   build:
@@ -62,13 +62,13 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Set up Go 1.x
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v2
         with:
-          go-version: '1.22.6'
+          go-version: '1.22.3'
         id: go
 
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
 
       - name: Get dependencies
         run: |

.golangci.yml

@@ -6,7 +6,7 @@ run:
     - proto
     - tools/analyzers
   timeout: 10m
-  go: '1.22.6'
+  go: '1.22.3'
 
 linters:
   enable-all: true
@@ -73,7 +73,6 @@ linters:
     - promlinter
     - protogetter
     - revive
-    - spancheck
     - staticcheck
     - stylecheck
     - tagalign

CONTRIBUTING.md

@@ -6,9 +6,6 @@ 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!
 
-> [!IMPORTANT] 
-> 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.**
@@ -123,19 +120,15 @@ $ 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. Add an entry to CHANGELOG.md.**
+**16. Create a pull request.**
 
-If your change is user facing, you must include a CHANGELOG.md entry. See the [Maintaining CHANGELOG.md](#maintaining-changelogmd) section for more information.
+Navigate your browser to https://github.com/prysmaticlabs/prysm and click on the new pull request button. In the “base” box on the left, leave the default selection “base master”, the branch that you want your changes to be applied to. In the “compare” box on the right, select feature-in-progress-branch, the branch containing the changes you want to apply. You will then be asked to answer a few questions about your pull request. After you complete the questionnaire, the pull request will appear in the list of pull requests at https://github.com/prysmaticlabs/prysm/pulls.
 
-**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.**
+**17. 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.
 
-**19. If the number of commits becomes excessive, you may be asked to squash your commits.**
+**18. 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...
 
@@ -143,7 +136,7 @@ Core Contributors may ask questions and request that you make edits. If you set
 $ git merge-base feature-in-progress-branch prysm/master
 ```
 
-**20. The previous command will return a commit-hash that you should use in the following command.**
+**19. The previous command will return a commit-hash that you should use in the following command.**
 
 ```
 $ git rebase -i commit-hash
@@ -167,30 +160,13 @@ 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.
 
-**21. Update your pull request with the following command.**
+**20. Update your pull request with the following command.**
 
 ```
 $ git push myrepo feature-in-progress-branch -f
 ```
 
-**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.
+**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.**
 
 ## 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.5"
+consensus_spec_version = "v1.5.0-alpha.3"
 
 bls_test_version = "v0.1.1"
 
@@ -243,7 +243,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-R9vG5HEL5eGMOAmbkKfJ2jfelNqL5V0xBUPiXOiGM6U=",
+    integrity = "sha256-+byv+GUOQytex5GgtjBGVoNDseJZbiBdAjEtlgCbjEo=",
     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-AEIiEOlf1XuxoRMCsN+kgJMo4LrS05+biTA1p/7Ro00=",
+    integrity = "sha256-JJUy/jT1h3kGQkinTuzL7gMOA1+qgmPgJXVrYuH63Cg=",
     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-LH/Xr20yrJRYnbpjRGupMWTIOWt3cpxZJWXgThwVDsk=",
+    integrity = "sha256-T2VM4Qd0SwgGnTjWxjOX297DqEsovO9Ueij1UEJy48Y=",
     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-mlytz4MPjKh0DwV7FMiAtnRbJw9B6o78/x66/vmnYc8=",
+    integrity = "sha256-OP9BCBcQ7i+93bwj7ktY8pZ5uWsGjgTe4XTp7BDhX+I=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/builder/BUILD.bazel

@@ -21,7 +21,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
@@ -29,6 +28,7 @@ go_library(
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

api/client/builder/client.go

@@ -19,11 +19,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 const (

api/client/event/BUILD.bazel

@@ -2,10 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "event_stream.go",
-        "utils.go",
-    ],
+    srcs = ["event_stream.go"],
     importpath = "github.com/prysmaticlabs/prysm/v5/api/client/event",
     visibility = ["//visibility:public"],
     deps = [
@@ -18,10 +15,7 @@ go_library(
 
 go_test(
     name = "go_default_test",
-    srcs = [
-        "event_stream_test.go",
-        "utils_test.go",
-    ],
+    srcs = ["event_stream_test.go"],
     embed = [":go_default_library"],
     deps = [
         "//testing/require:go_default_library",

api/client/event/event_stream.go

@@ -102,8 +102,6 @@ func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
 	}()
 	// Create a new scanner to read lines from the response body
 	scanner := bufio.NewScanner(resp.Body)
-	// Set the split function for the scanning operation
-	scanner.Split(scanLinesWithCarriage)
 
 	var eventType, data string // Variables to store event type and data
 
@@ -115,7 +113,7 @@ func (h *EventStream) Subscribe(eventsChannel chan<- *Event) {
 			close(eventsChannel)
 			return
 		default:
-			line := scanner.Text()
+			line := scanner.Text() // TODO(13730): scanner does not handle /r and does not fully adhere to https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
 			// Handle the event based on your specific format
 			if line == "" {
 				// Empty line indicates the end of an event

api/client/event/event_stream_test.go

@@ -43,9 +43,8 @@ func TestEventStream(t *testing.T) {
 	mux.HandleFunc("/eth/v1/events", func(w http.ResponseWriter, r *http.Request) {
 		flusher, ok := w.(http.Flusher)
 		require.Equal(t, true, ok)
-		for i := 1; i <= 3; i++ {
-			events := [3]string{"event: head\ndata: data%d\n\n", "event: head\rdata: data%d\r\r", "event: head\r\ndata: data%d\r\n\r\n"}
-			_, err := fmt.Fprintf(w, events[i-1], i)
+		for i := 1; i <= 2; i++ {
+			_, err := fmt.Fprintf(w, "event: head\ndata: data%d\n\n", i)
 			require.NoError(t, err)
 			flusher.Flush()                    // Trigger flush to simulate streaming data
 			time.Sleep(100 * time.Millisecond) // Simulate delay between events
@@ -63,7 +62,7 @@ func TestEventStream(t *testing.T) {
 	// Collect events
 	var events []*Event
 
-	for len(events) != 3 {
+	for len(events) != 2 {
 		select {
 		case event := <-eventsChannel:
 			log.Info(event)
@@ -72,7 +71,7 @@ func TestEventStream(t *testing.T) {
 	}
 
 	// Assertions to verify the events content
-	expectedData := []string{"data1", "data2", "data3"}
+	expectedData := []string{"data1", "data2"}
 	for i, event := range events {
 		if string(event.Data) != expectedData[i] {
 			t.Errorf("Expected event data %q, got %q", expectedData[i], string(event.Data))

api/client/event/utils.go

@@ -1,36 +0,0 @@
-package event
-
-import (
-	"bytes"
-)
-
-// adapted from ScanLines in scan.go to handle carriage return characters as separators
-func scanLinesWithCarriage(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	if atEOF && len(data) == 0 {
-		return 0, nil, nil
-	}
-	if i, j := bytes.IndexByte(data, '\n'), bytes.IndexByte(data, '\r'); i >= 0 || j >= 0 {
-		in := i
-		// Select the first index of \n or \r or the second index of \r if it is followed by \n
-		if i < 0 || (i > j && i != j+1 && j >= 0) {
-			in = j
-		}
-
-		// We have a full newline-terminated line.
-		return in + 1, dropCR(data[0:in]), nil
-	}
-	// If we're at EOF, we have a final, non-terminated line. Return it.
-	if atEOF {
-		return len(data), dropCR(data), nil
-	}
-	// Request more data.
-	return 0, nil, nil
-}
-
-// dropCR drops a terminal \r from the data.
-func dropCR(data []byte) []byte {
-	if len(data) > 0 && data[len(data)-1] == '\r' {
-		return data[0 : len(data)-1]
-	}
-	return data
-}

api/client/event/utils_test.go

@@ -1,97 +0,0 @@
-package event
-
-import (
-	"bufio"
-	"bytes"
-	"testing"
-
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-)
-
-func TestScanLinesWithCarriage(t *testing.T) {
-	testCases := []struct {
-		name     string
-		input    string
-		expected []string
-	}{
-		{
-			name:     "LF line endings",
-			input:    "line1\nline2\nline3",
-			expected: []string{"line1", "line2", "line3"},
-		},
-		{
-			name:     "CR line endings",
-			input:    "line1\rline2\rline3",
-			expected: []string{"line1", "line2", "line3"},
-		},
-		{
-			name:     "CRLF line endings",
-			input:    "line1\r\nline2\r\nline3",
-			expected: []string{"line1", "line2", "line3"},
-		},
-		{
-			name:     "Mixed line endings",
-			input:    "line1\nline2\rline3\r\nline4",
-			expected: []string{"line1", "line2", "line3", "line4"},
-		},
-		{
-			name:     "Empty lines",
-			input:    "line1\n\nline2\r\rline3",
-			expected: []string{"line1", "", "line2", "", "line3"},
-		},
-		{
-			name:     "Empty lines 2",
-			input:    "line1\n\rline2\n\rline3",
-			expected: []string{"line1", "", "line2", "", "line3"},
-		},
-		{
-			name:     "No line endings",
-			input:    "single line without ending",
-			expected: []string{"single line without ending"},
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			scanner := bufio.NewScanner(bytes.NewReader([]byte(tc.input)))
-			scanner.Split(scanLinesWithCarriage)
-
-			var lines []string
-			for scanner.Scan() {
-				lines = append(lines, scanner.Text())
-			}
-
-			require.NoError(t, scanner.Err())
-			require.Equal(t, len(tc.expected), len(lines), "Number of lines does not match")
-			for i, line := range lines {
-				require.Equal(t, tc.expected[i], line, "Line %d does not match", i)
-			}
-		})
-	}
-}
-
-// TestScanLinesWithCarriageEdgeCases tests edge cases and potential error scenarios
-func TestScanLinesWithCarriageEdgeCases(t *testing.T) {
-	t.Run("Empty input", func(t *testing.T) {
-		scanner := bufio.NewScanner(bytes.NewReader([]byte("")))
-		scanner.Split(scanLinesWithCarriage)
-		require.Equal(t, scanner.Scan(), false)
-		require.NoError(t, scanner.Err())
-	})
-
-	t.Run("Very long line", func(t *testing.T) {
-		longLine := bytes.Repeat([]byte("a"), bufio.MaxScanTokenSize+1)
-		scanner := bufio.NewScanner(bytes.NewReader(longLine))
-		scanner.Split(scanLinesWithCarriage)
-		require.Equal(t, scanner.Scan(), false)
-		require.NotNil(t, scanner.Err())
-	})
-
-	t.Run("Line ending at max token size", func(t *testing.T) {
-		input := append(bytes.Repeat([]byte("a"), bufio.MaxScanTokenSize-1), '\n')
-		scanner := bufio.NewScanner(bytes.NewReader(input))
-		scanner.Split(scanLinesWithCarriage)
-		require.Equal(t, scanner.Scan(), true)
-		require.Equal(t, string(bytes.Repeat([]byte("a"), bufio.MaxScanTokenSize-1)), scanner.Text())
-	})
-}

api/server/structs/block.go

@@ -317,94 +317,6 @@ type BlindedBeaconBlockBodyDeneb struct {
 	BlobKzgCommitments     []string                      `json:"blob_kzg_commitments"`
 }
 
-type SignedBeaconBlockContentsElectra struct {
-	SignedBlock *SignedBeaconBlockElectra `json:"signed_block"`
-	KzgProofs   []string                  `json:"kzg_proofs"`
-	Blobs       []string                  `json:"blobs"`
-}
-
-type BeaconBlockContentsElectra struct {
-	Block     *BeaconBlockElectra `json:"block"`
-	KzgProofs []string            `json:"kzg_proofs"`
-	Blobs     []string            `json:"blobs"`
-}
-
-type SignedBeaconBlockElectra struct {
-	Message   *BeaconBlockElectra `json:"message"`
-	Signature string              `json:"signature"`
-}
-
-var _ SignedMessageJsoner = &SignedBeaconBlockElectra{}
-
-func (s *SignedBeaconBlockElectra) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
-}
-
-func (s *SignedBeaconBlockElectra) SigString() string {
-	return s.Signature
-}
-
-type BeaconBlockElectra struct {
-	Slot          string                  `json:"slot"`
-	ProposerIndex string                  `json:"proposer_index"`
-	ParentRoot    string                  `json:"parent_root"`
-	StateRoot     string                  `json:"state_root"`
-	Body          *BeaconBlockBodyElectra `json:"body"`
-}
-
-type BeaconBlockBodyElectra struct {
-	RandaoReveal          string                        `json:"randao_reveal"`
-	Eth1Data              *Eth1Data                     `json:"eth1_data"`
-	Graffiti              string                        `json:"graffiti"`
-	ProposerSlashings     []*ProposerSlashing           `json:"proposer_slashings"`
-	AttesterSlashings     []*AttesterSlashingElectra    `json:"attester_slashings"`
-	Attestations          []*AttestationElectra         `json:"attestations"`
-	Deposits              []*Deposit                    `json:"deposits"`
-	VoluntaryExits        []*SignedVoluntaryExit        `json:"voluntary_exits"`
-	SyncAggregate         *SyncAggregate                `json:"sync_aggregate"`
-	ExecutionPayload      *ExecutionPayloadElectra      `json:"execution_payload"`
-	BLSToExecutionChanges []*SignedBLSToExecutionChange `json:"bls_to_execution_changes"`
-	BlobKzgCommitments    []string                      `json:"blob_kzg_commitments"`
-}
-
-type BlindedBeaconBlockElectra struct {
-	Slot          string                         `json:"slot"`
-	ProposerIndex string                         `json:"proposer_index"`
-	ParentRoot    string                         `json:"parent_root"`
-	StateRoot     string                         `json:"state_root"`
-	Body          *BlindedBeaconBlockBodyElectra `json:"body"`
-}
-
-type SignedBlindedBeaconBlockElectra struct {
-	Message   *BlindedBeaconBlockElectra `json:"message"`
-	Signature string                     `json:"signature"`
-}
-
-var _ SignedMessageJsoner = &SignedBlindedBeaconBlockElectra{}
-
-func (s *SignedBlindedBeaconBlockElectra) MessageRawJson() ([]byte, error) {
-	return json.Marshal(s.Message)
-}
-
-func (s *SignedBlindedBeaconBlockElectra) SigString() string {
-	return s.Signature
-}
-
-type BlindedBeaconBlockBodyElectra struct {
-	RandaoReveal           string                         `json:"randao_reveal"`
-	Eth1Data               *Eth1Data                      `json:"eth1_data"`
-	Graffiti               string                         `json:"graffiti"`
-	ProposerSlashings      []*ProposerSlashing            `json:"proposer_slashings"`
-	AttesterSlashings      []*AttesterSlashingElectra     `json:"attester_slashings"`
-	Attestations           []*AttestationElectra          `json:"attestations"`
-	Deposits               []*Deposit                     `json:"deposits"`
-	VoluntaryExits         []*SignedVoluntaryExit         `json:"voluntary_exits"`
-	SyncAggregate          *SyncAggregate                 `json:"sync_aggregate"`
-	ExecutionPayloadHeader *ExecutionPayloadHeaderElectra `json:"execution_payload_header"`
-	BLSToExecutionChanges  []*SignedBLSToExecutionChange  `json:"bls_to_execution_changes"`
-	BlobKzgCommitments     []string                       `json:"blob_kzg_commitments"`
-}
-
 type SignedBeaconBlockHeaderContainer struct {
 	Header    *SignedBeaconBlockHeader `json:"header"`
 	Root      string                   `json:"root"`
@@ -533,49 +445,3 @@ type ExecutionPayloadHeaderDeneb struct {
 	BlobGasUsed      string `json:"blob_gas_used"`
 	ExcessBlobGas    string `json:"excess_blob_gas"`
 }
-
-type ExecutionPayloadElectra struct {
-	ParentHash            string                  `json:"parent_hash"`
-	FeeRecipient          string                  `json:"fee_recipient"`
-	StateRoot             string                  `json:"state_root"`
-	ReceiptsRoot          string                  `json:"receipts_root"`
-	LogsBloom             string                  `json:"logs_bloom"`
-	PrevRandao            string                  `json:"prev_randao"`
-	BlockNumber           string                  `json:"block_number"`
-	GasLimit              string                  `json:"gas_limit"`
-	GasUsed               string                  `json:"gas_used"`
-	Timestamp             string                  `json:"timestamp"`
-	ExtraData             string                  `json:"extra_data"`
-	BaseFeePerGas         string                  `json:"base_fee_per_gas"`
-	BlockHash             string                  `json:"block_hash"`
-	Transactions          []string                `json:"transactions"`
-	Withdrawals           []*Withdrawal           `json:"withdrawals"`
-	BlobGasUsed           string                  `json:"blob_gas_used"`
-	ExcessBlobGas         string                  `json:"excess_blob_gas"`
-	DepositRequests       []*DepositRequest       `json:"deposit_requests"`
-	WithdrawalRequests    []*WithdrawalRequest    `json:"withdrawal_requests"`
-	ConsolidationRequests []*ConsolidationRequest `json:"consolidation_requests"`
-}
-
-type ExecutionPayloadHeaderElectra struct {
-	ParentHash                string `json:"parent_hash"`
-	FeeRecipient              string `json:"fee_recipient"`
-	StateRoot                 string `json:"state_root"`
-	ReceiptsRoot              string `json:"receipts_root"`
-	LogsBloom                 string `json:"logs_bloom"`
-	PrevRandao                string `json:"prev_randao"`
-	BlockNumber               string `json:"block_number"`
-	GasLimit                  string `json:"gas_limit"`
-	GasUsed                   string `json:"gas_used"`
-	Timestamp                 string `json:"timestamp"`
-	ExtraData                 string `json:"extra_data"`
-	BaseFeePerGas             string `json:"base_fee_per_gas"`
-	BlockHash                 string `json:"block_hash"`
-	TransactionsRoot          string `json:"transactions_root"`
-	WithdrawalsRoot           string `json:"withdrawals_root"`
-	BlobGasUsed               string `json:"blob_gas_used"`
-	ExcessBlobGas             string `json:"excess_blob_gas"`
-	DepositRequestsRoot       string `json:"deposit_requests_root"`
-	WithdrawalRequestsRoot    string `json:"withdrawal_requests_root"`
-	ConsolidationRequestsRoot string `json:"consolidation_requests_root"`
-}

api/server/structs/conversions.go

@@ -340,42 +340,6 @@ func (a *AggregateAttestationAndProof) ToConsensus() (*eth.AggregateAttestationA
 	}, nil
 }
 
-func (s *SignedAggregateAttestationAndProofElectra) ToConsensus() (*eth.SignedAggregateAttestationAndProofElectra, error) {
-	msg, err := s.Message.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Message")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(s.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-
-	return &eth.SignedAggregateAttestationAndProofElectra{
-		Message:   msg,
-		Signature: sig,
-	}, nil
-}
-
-func (a *AggregateAttestationAndProofElectra) ToConsensus() (*eth.AggregateAttestationAndProofElectra, error) {
-	aggIndex, err := strconv.ParseUint(a.AggregatorIndex, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AggregatorIndex")
-	}
-	agg, err := a.Aggregate.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Aggregate")
-	}
-	proof, err := bytesutil.DecodeHexWithLength(a.SelectionProof, 96)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SelectionProof")
-	}
-	return &eth.AggregateAttestationAndProofElectra{
-		AggregatorIndex: primitives.ValidatorIndex(aggIndex),
-		Aggregate:       agg,
-		SelectionProof:  proof,
-	}, nil
-}
-
 func (a *Attestation) ToConsensus() (*eth.Attestation, error) {
 	aggBits, err := hexutil.Decode(a.AggregationBits)
 	if err != nil {
@@ -405,41 +369,6 @@ func AttFromConsensus(a *eth.Attestation) *Attestation {
 	}
 }
 
-func (a *AttestationElectra) ToConsensus() (*eth.AttestationElectra, error) {
-	aggBits, err := hexutil.Decode(a.AggregationBits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "AggregationBits")
-	}
-	data, err := a.Data.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Data")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(a.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	committeeBits, err := hexutil.Decode(a.CommitteeBits)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "CommitteeBits")
-	}
-
-	return &eth.AttestationElectra{
-		AggregationBits: aggBits,
-		Data:            data,
-		Signature:       sig,
-		CommitteeBits:   committeeBits,
-	}, nil
-}
-
-func AttElectraFromConsensus(a *eth.AttestationElectra) *AttestationElectra {
-	return &AttestationElectra{
-		AggregationBits: hexutil.Encode(a.AggregationBits),
-		Data:            AttDataFromConsensus(a.Data),
-		Signature:       hexutil.Encode(a.Signature),
-		CommitteeBits:   hexutil.Encode(a.CommitteeBits),
-	}
-}
-
 func (a *AttestationData) ToConsensus() (*eth.AttestationData, error) {
 	slot, err := strconv.ParseUint(a.Slot, 10, 64)
 	if err != nil {
@@ -694,18 +623,6 @@ func (s *AttesterSlashing) ToConsensus() (*eth.AttesterSlashing, error) {
 	return &eth.AttesterSlashing{Attestation_1: att1, Attestation_2: att2}, nil
 }
 
-func (s *AttesterSlashingElectra) ToConsensus() (*eth.AttesterSlashingElectra, error) {
-	att1, err := s.Attestation1.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Attestation1")
-	}
-	att2, err := s.Attestation2.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Attestation2")
-	}
-	return &eth.AttesterSlashingElectra{Attestation_1: att1, Attestation_2: att2}, nil
-}
-
 func (a *IndexedAttestation) ToConsensus() (*eth.IndexedAttestation, error) {
 	indices := make([]uint64, len(a.AttestingIndices))
 	var err error
@@ -731,31 +648,6 @@ func (a *IndexedAttestation) ToConsensus() (*eth.IndexedAttestation, error) {
 	}, nil
 }
 
-func (a *IndexedAttestationElectra) ToConsensus() (*eth.IndexedAttestationElectra, error) {
-	indices := make([]uint64, len(a.AttestingIndices))
-	var err error
-	for i, ix := range a.AttestingIndices {
-		indices[i], err = strconv.ParseUint(ix, 10, 64)
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("AttestingIndices[%d]", i))
-		}
-	}
-	data, err := a.Data.ToConsensus()
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Data")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(a.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-
-	return &eth.IndexedAttestationElectra{
-		AttestingIndices: indices,
-		Data:             data,
-		Signature:        sig,
-	}, nil
-}
-
 func WithdrawalsFromConsensus(ws []*enginev1.Withdrawal) []*Withdrawal {
 	result := make([]*Withdrawal, len(ws))
 	for i, w := range ws {
@@ -773,126 +665,6 @@ func WithdrawalFromConsensus(w *enginev1.Withdrawal) *Withdrawal {
 	}
 }
 
-func WithdrawalRequestsFromConsensus(ws []*enginev1.WithdrawalRequest) []*WithdrawalRequest {
-	result := make([]*WithdrawalRequest, len(ws))
-	for i, w := range ws {
-		result[i] = WithdrawalRequestFromConsensus(w)
-	}
-	return result
-}
-
-func WithdrawalRequestFromConsensus(w *enginev1.WithdrawalRequest) *WithdrawalRequest {
-	return &WithdrawalRequest{
-		SourceAddress:   hexutil.Encode(w.SourceAddress),
-		ValidatorPubkey: hexutil.Encode(w.ValidatorPubkey),
-		Amount:          fmt.Sprintf("%d", w.Amount),
-	}
-}
-
-func (w *WithdrawalRequest) ToConsensus() (*enginev1.WithdrawalRequest, error) {
-	src, err := bytesutil.DecodeHexWithLength(w.SourceAddress, common.AddressLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SourceAddress")
-	}
-	pubkey, err := bytesutil.DecodeHexWithLength(w.ValidatorPubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "ValidatorPubkey")
-	}
-	amount, err := strconv.ParseUint(w.Amount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Amount")
-	}
-	return &enginev1.WithdrawalRequest{
-		SourceAddress:   src,
-		ValidatorPubkey: pubkey,
-		Amount:          amount,
-	}, nil
-}
-
-func ConsolidationRequestsFromConsensus(cs []*enginev1.ConsolidationRequest) []*ConsolidationRequest {
-	result := make([]*ConsolidationRequest, len(cs))
-	for i, c := range cs {
-		result[i] = ConsolidationRequestFromConsensus(c)
-	}
-	return result
-}
-
-func ConsolidationRequestFromConsensus(c *enginev1.ConsolidationRequest) *ConsolidationRequest {
-	return &ConsolidationRequest{
-		SourceAddress: hexutil.Encode(c.SourceAddress),
-		SourcePubkey:  hexutil.Encode(c.SourcePubkey),
-		TargetPubkey:  hexutil.Encode(c.TargetPubkey),
-	}
-}
-
-func (c *ConsolidationRequest) ToConsensus() (*enginev1.ConsolidationRequest, error) {
-	srcAddress, err := bytesutil.DecodeHexWithLength(c.SourceAddress, common.AddressLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SourceAddress")
-	}
-	srcPubkey, err := bytesutil.DecodeHexWithLength(c.SourcePubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "SourcePubkey")
-	}
-	targetPubkey, err := bytesutil.DecodeHexWithLength(c.TargetPubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "TargetPubkey")
-	}
-	return &enginev1.ConsolidationRequest{
-		SourceAddress: srcAddress,
-		SourcePubkey:  srcPubkey,
-		TargetPubkey:  targetPubkey,
-	}, nil
-}
-
-func DepositRequestsFromConsensus(ds []*enginev1.DepositRequest) []*DepositRequest {
-	result := make([]*DepositRequest, len(ds))
-	for i, d := range ds {
-		result[i] = DepositRequestFromConsensus(d)
-	}
-	return result
-}
-
-func DepositRequestFromConsensus(d *enginev1.DepositRequest) *DepositRequest {
-	return &DepositRequest{
-		Pubkey:                hexutil.Encode(d.Pubkey),
-		WithdrawalCredentials: hexutil.Encode(d.WithdrawalCredentials),
-		Amount:                fmt.Sprintf("%d", d.Amount),
-		Signature:             hexutil.Encode(d.Signature),
-		Index:                 fmt.Sprintf("%d", d.Index),
-	}
-}
-
-func (d *DepositRequest) ToConsensus() (*enginev1.DepositRequest, error) {
-	pubkey, err := bytesutil.DecodeHexWithLength(d.Pubkey, fieldparams.BLSPubkeyLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Pubkey")
-	}
-	withdrawalCredentials, err := bytesutil.DecodeHexWithLength(d.WithdrawalCredentials, fieldparams.RootLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "WithdrawalCredentials")
-	}
-	amount, err := strconv.ParseUint(d.Amount, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Amount")
-	}
-	sig, err := bytesutil.DecodeHexWithLength(d.Signature, fieldparams.BLSSignatureLength)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Signature")
-	}
-	index, err := strconv.ParseUint(d.Index, 10, 64)
-	if err != nil {
-		return nil, server.NewDecodeError(err, "Index")
-	}
-	return &enginev1.DepositRequest{
-		Pubkey:                pubkey,
-		WithdrawalCredentials: withdrawalCredentials,
-		Amount:                amount,
-		Signature:             sig,
-		Index:                 index,
-	}, nil
-}
-
 func ProposerSlashingsToConsensus(src []*ProposerSlashing) ([]*eth.ProposerSlashing, error) {
 	if src == nil {
 		return nil, errNilValue
@@ -1158,138 +930,6 @@ func AttesterSlashingFromConsensus(src *eth.AttesterSlashing) *AttesterSlashing
 	}
 }
 
-func AttesterSlashingsElectraToConsensus(src []*AttesterSlashingElectra) ([]*eth.AttesterSlashingElectra, error) {
-	if src == nil {
-		return nil, errNilValue
-	}
-	err := slice.VerifyMaxLength(src, 2)
-	if err != nil {
-		return nil, err
-	}
-
-	attesterSlashings := make([]*eth.AttesterSlashingElectra, len(src))
-	for i, s := range src {
-		if s == nil {
-			return nil, server.NewDecodeError(errNilValue, fmt.Sprintf("[%d]", i))
-		}
-		if s.Attestation1 == nil {
-			return nil, server.NewDecodeError(errNilValue, fmt.Sprintf("[%d].Attestation1", i))
-		}
-		if s.Attestation2 == nil {
-			return nil, server.NewDecodeError(errNilValue, fmt.Sprintf("[%d].Attestation2", i))
-		}
-
-		a1Sig, err := bytesutil.DecodeHexWithLength(s.Attestation1.Signature, fieldparams.BLSSignatureLength)
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.Signature", i))
-		}
-		err = slice.VerifyMaxLength(s.Attestation1.AttestingIndices, 2048)
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.AttestingIndices", i))
-		}
-		a1AttestingIndices := make([]uint64, len(s.Attestation1.AttestingIndices))
-		for j, ix := range s.Attestation1.AttestingIndices {
-			attestingIndex, err := strconv.ParseUint(ix, 10, 64)
-			if err != nil {
-				return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.AttestingIndices[%d]", i, j))
-			}
-			a1AttestingIndices[j] = attestingIndex
-		}
-		a1Data, err := s.Attestation1.Data.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation1.Data", i))
-		}
-		a2Sig, err := bytesutil.DecodeHexWithLength(s.Attestation2.Signature, fieldparams.BLSSignatureLength)
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.Signature", i))
-		}
-		err = slice.VerifyMaxLength(s.Attestation2.AttestingIndices, 2048)
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.AttestingIndices", i))
-		}
-		a2AttestingIndices := make([]uint64, len(s.Attestation2.AttestingIndices))
-		for j, ix := range s.Attestation2.AttestingIndices {
-			attestingIndex, err := strconv.ParseUint(ix, 10, 64)
-			if err != nil {
-				return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.AttestingIndices[%d]", i, j))
-			}
-			a2AttestingIndices[j] = attestingIndex
-		}
-		a2Data, err := s.Attestation2.Data.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d].Attestation2.Data", i))
-		}
-		attesterSlashings[i] = &eth.AttesterSlashingElectra{
-			Attestation_1: &eth.IndexedAttestationElectra{
-				AttestingIndices: a1AttestingIndices,
-				Data:             a1Data,
-				Signature:        a1Sig,
-			},
-			Attestation_2: &eth.IndexedAttestationElectra{
-				AttestingIndices: a2AttestingIndices,
-				Data:             a2Data,
-				Signature:        a2Sig,
-			},
-		}
-	}
-	return attesterSlashings, nil
-}
-
-func AttesterSlashingsElectraFromConsensus(src []*eth.AttesterSlashingElectra) []*AttesterSlashingElectra {
-	attesterSlashings := make([]*AttesterSlashingElectra, len(src))
-	for i, s := range src {
-		attesterSlashings[i] = AttesterSlashingElectraFromConsensus(s)
-	}
-	return attesterSlashings
-}
-
-func AttesterSlashingElectraFromConsensus(src *eth.AttesterSlashingElectra) *AttesterSlashingElectra {
-	a1AttestingIndices := make([]string, len(src.Attestation_1.AttestingIndices))
-	for j, ix := range src.Attestation_1.AttestingIndices {
-		a1AttestingIndices[j] = fmt.Sprintf("%d", ix)
-	}
-	a2AttestingIndices := make([]string, len(src.Attestation_2.AttestingIndices))
-	for j, ix := range src.Attestation_2.AttestingIndices {
-		a2AttestingIndices[j] = fmt.Sprintf("%d", ix)
-	}
-	return &AttesterSlashingElectra{
-		Attestation1: &IndexedAttestationElectra{
-			AttestingIndices: a1AttestingIndices,
-			Data: &AttestationData{
-				Slot:            fmt.Sprintf("%d", src.Attestation_1.Data.Slot),
-				CommitteeIndex:  fmt.Sprintf("%d", src.Attestation_1.Data.CommitteeIndex),
-				BeaconBlockRoot: hexutil.Encode(src.Attestation_1.Data.BeaconBlockRoot),
-				Source: &Checkpoint{
-					Epoch: fmt.Sprintf("%d", src.Attestation_1.Data.Source.Epoch),
-					Root:  hexutil.Encode(src.Attestation_1.Data.Source.Root),
-				},
-				Target: &Checkpoint{
-					Epoch: fmt.Sprintf("%d", src.Attestation_1.Data.Target.Epoch),
-					Root:  hexutil.Encode(src.Attestation_1.Data.Target.Root),
-				},
-			},
-			Signature: hexutil.Encode(src.Attestation_1.Signature),
-		},
-		Attestation2: &IndexedAttestationElectra{
-			AttestingIndices: a2AttestingIndices,
-			Data: &AttestationData{
-				Slot:            fmt.Sprintf("%d", src.Attestation_2.Data.Slot),
-				CommitteeIndex:  fmt.Sprintf("%d", src.Attestation_2.Data.CommitteeIndex),
-				BeaconBlockRoot: hexutil.Encode(src.Attestation_2.Data.BeaconBlockRoot),
-				Source: &Checkpoint{
-					Epoch: fmt.Sprintf("%d", src.Attestation_2.Data.Source.Epoch),
-					Root:  hexutil.Encode(src.Attestation_2.Data.Source.Root),
-				},
-				Target: &Checkpoint{
-					Epoch: fmt.Sprintf("%d", src.Attestation_2.Data.Target.Epoch),
-					Root:  hexutil.Encode(src.Attestation_2.Data.Target.Root),
-				},
-			},
-			Signature: hexutil.Encode(src.Attestation_2.Signature),
-		},
-	}
-}
-
 func AttsToConsensus(src []*Attestation) ([]*eth.Attestation, error) {
 	if src == nil {
 		return nil, errNilValue
@@ -1317,33 +957,6 @@ func AttsFromConsensus(src []*eth.Attestation) []*Attestation {
 	return atts
 }
 
-func AttsElectraToConsensus(src []*AttestationElectra) ([]*eth.AttestationElectra, error) {
-	if src == nil {
-		return nil, errNilValue
-	}
-	err := slice.VerifyMaxLength(src, 8)
-	if err != nil {
-		return nil, err
-	}
-
-	atts := make([]*eth.AttestationElectra, len(src))
-	for i, a := range src {
-		atts[i], err = a.ToConsensus()
-		if err != nil {
-			return nil, server.NewDecodeError(err, fmt.Sprintf("[%d]", i))
-		}
-	}
-	return atts, nil
-}
-
-func AttsElectraFromConsensus(src []*eth.AttestationElectra) []*AttestationElectra {
-	atts := make([]*AttestationElectra, len(src))
-	for i, a := range src {
-		atts[i] = AttElectraFromConsensus(a)
-	}
-	return atts
-}
-
 func DepositsToConsensus(src []*Deposit) ([]*eth.Deposit, error) {
 	if src == nil {
 		return nil, errNilValue
@@ -1474,37 +1087,3 @@ func DepositSnapshotFromConsensus(ds *eth.DepositSnapshot) *DepositSnapshot {
 		ExecutionBlockHeight: fmt.Sprintf("%d", ds.ExecutionDepth),
 	}
 }
-
-func PendingBalanceDepositsFromConsensus(ds []*eth.PendingBalanceDeposit) []*PendingBalanceDeposit {
-	deposits := make([]*PendingBalanceDeposit, len(ds))
-	for i, d := range ds {
-		deposits[i] = &PendingBalanceDeposit{
-			Index:  fmt.Sprintf("%d", d.Index),
-			Amount: fmt.Sprintf("%d", d.Amount),
-		}
-	}
-	return deposits
-}
-
-func PendingPartialWithdrawalsFromConsensus(ws []*eth.PendingPartialWithdrawal) []*PendingPartialWithdrawal {
-	withdrawals := make([]*PendingPartialWithdrawal, len(ws))
-	for i, w := range ws {
-		withdrawals[i] = &PendingPartialWithdrawal{
-			Index:             fmt.Sprintf("%d", w.Index),
-			Amount:            fmt.Sprintf("%d", w.Amount),
-			WithdrawableEpoch: fmt.Sprintf("%d", w.WithdrawableEpoch),
-		}
-	}
-	return withdrawals
-}
-
-func PendingConsolidationsFromConsensus(cs []*eth.PendingConsolidation) []*PendingConsolidation {
-	consolidations := make([]*PendingConsolidation, len(cs))
-	for i, c := range cs {
-		consolidations[i] = &PendingConsolidation{
-			SourceIndex: fmt.Sprintf("%d", c.SourceIndex),
-			TargetIndex: fmt.Sprintf("%d", c.TargetIndex),
-		}
-	}
-	return consolidations
-}

api/server/structs/conversions_state.go

@@ -593,185 +593,3 @@ func BeaconStateDenebFromConsensus(st beaconState.BeaconState) (*BeaconStateDene
 		HistoricalSummaries:          hs,
 	}, nil
 }
-
-func BeaconStateElectraFromConsensus(st beaconState.BeaconState) (*BeaconStateElectra, error) {
-	srcBr := st.BlockRoots()
-	br := make([]string, len(srcBr))
-	for i, r := range srcBr {
-		br[i] = hexutil.Encode(r)
-	}
-	srcSr := st.StateRoots()
-	sr := make([]string, len(srcSr))
-	for i, r := range srcSr {
-		sr[i] = hexutil.Encode(r)
-	}
-	srcHr, err := st.HistoricalRoots()
-	if err != nil {
-		return nil, err
-	}
-	hr := make([]string, len(srcHr))
-	for i, r := range srcHr {
-		hr[i] = hexutil.Encode(r)
-	}
-	srcVotes := st.Eth1DataVotes()
-	votes := make([]*Eth1Data, len(srcVotes))
-	for i, e := range srcVotes {
-		votes[i] = Eth1DataFromConsensus(e)
-	}
-	srcVals := st.Validators()
-	vals := make([]*Validator, len(srcVals))
-	for i, v := range srcVals {
-		vals[i] = ValidatorFromConsensus(v)
-	}
-	srcBals := st.Balances()
-	bals := make([]string, len(srcBals))
-	for i, b := range srcBals {
-		bals[i] = fmt.Sprintf("%d", b)
-	}
-	srcRm := st.RandaoMixes()
-	rm := make([]string, len(srcRm))
-	for i, m := range srcRm {
-		rm[i] = hexutil.Encode(m)
-	}
-	srcSlashings := st.Slashings()
-	slashings := make([]string, len(srcSlashings))
-	for i, s := range srcSlashings {
-		slashings[i] = fmt.Sprintf("%d", s)
-	}
-	srcPrevPart, err := st.PreviousEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	prevPart := make([]string, len(srcPrevPart))
-	for i, p := range srcPrevPart {
-		prevPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcCurrPart, err := st.CurrentEpochParticipation()
-	if err != nil {
-		return nil, err
-	}
-	currPart := make([]string, len(srcCurrPart))
-	for i, p := range srcCurrPart {
-		currPart[i] = fmt.Sprintf("%d", p)
-	}
-	srcIs, err := st.InactivityScores()
-	if err != nil {
-		return nil, err
-	}
-	is := make([]string, len(srcIs))
-	for i, s := range srcIs {
-		is[i] = fmt.Sprintf("%d", s)
-	}
-	currSc, err := st.CurrentSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	nextSc, err := st.NextSyncCommittee()
-	if err != nil {
-		return nil, err
-	}
-	execData, err := st.LatestExecutionPayloadHeader()
-	if err != nil {
-		return nil, err
-	}
-	srcPayload, ok := execData.Proto().(*enginev1.ExecutionPayloadHeaderElectra)
-	if !ok {
-		return nil, errPayloadHeaderNotFound
-	}
-	payload, err := ExecutionPayloadHeaderElectraFromConsensus(srcPayload)
-	if err != nil {
-		return nil, err
-	}
-	srcHs, err := st.HistoricalSummaries()
-	if err != nil {
-		return nil, err
-	}
-	hs := make([]*HistoricalSummary, len(srcHs))
-	for i, s := range srcHs {
-		hs[i] = HistoricalSummaryFromConsensus(s)
-	}
-	nwi, err := st.NextWithdrawalIndex()
-	if err != nil {
-		return nil, err
-	}
-	nwvi, err := st.NextWithdrawalValidatorIndex()
-	if err != nil {
-		return nil, err
-	}
-	drsi, err := st.DepositRequestsStartIndex()
-	if err != nil {
-		return nil, err
-	}
-	dbtc, err := st.DepositBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ebtc, err := st.ExitBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	eee, err := st.EarliestExitEpoch()
-	if err != nil {
-		return nil, err
-	}
-	cbtc, err := st.ConsolidationBalanceToConsume()
-	if err != nil {
-		return nil, err
-	}
-	ece, err := st.EarliestConsolidationEpoch()
-	if err != nil {
-		return nil, err
-	}
-	pbd, err := st.PendingBalanceDeposits()
-	if err != nil {
-		return nil, err
-	}
-	ppw, err := st.PendingPartialWithdrawals()
-	if err != nil {
-		return nil, err
-	}
-	pc, err := st.PendingConsolidations()
-	if err != nil {
-		return nil, err
-	}
-
-	return &BeaconStateElectra{
-		GenesisTime:                   fmt.Sprintf("%d", st.GenesisTime()),
-		GenesisValidatorsRoot:         hexutil.Encode(st.GenesisValidatorsRoot()),
-		Slot:                          fmt.Sprintf("%d", st.Slot()),
-		Fork:                          ForkFromConsensus(st.Fork()),
-		LatestBlockHeader:             BeaconBlockHeaderFromConsensus(st.LatestBlockHeader()),
-		BlockRoots:                    br,
-		StateRoots:                    sr,
-		HistoricalRoots:               hr,
-		Eth1Data:                      Eth1DataFromConsensus(st.Eth1Data()),
-		Eth1DataVotes:                 votes,
-		Eth1DepositIndex:              fmt.Sprintf("%d", st.Eth1DepositIndex()),
-		Validators:                    vals,
-		Balances:                      bals,
-		RandaoMixes:                   rm,
-		Slashings:                     slashings,
-		PreviousEpochParticipation:    prevPart,
-		CurrentEpochParticipation:     currPart,
-		JustificationBits:             hexutil.Encode(st.JustificationBits()),
-		PreviousJustifiedCheckpoint:   CheckpointFromConsensus(st.PreviousJustifiedCheckpoint()),
-		CurrentJustifiedCheckpoint:    CheckpointFromConsensus(st.CurrentJustifiedCheckpoint()),
-		FinalizedCheckpoint:           CheckpointFromConsensus(st.FinalizedCheckpoint()),
-		InactivityScores:              is,
-		CurrentSyncCommittee:          SyncCommitteeFromConsensus(currSc),
-		NextSyncCommittee:             SyncCommitteeFromConsensus(nextSc),
-		LatestExecutionPayloadHeader:  payload,
-		NextWithdrawalIndex:           fmt.Sprintf("%d", nwi),
-		NextWithdrawalValidatorIndex:  fmt.Sprintf("%d", nwvi),
-		HistoricalSummaries:           hs,
-		DepositRequestsStartIndex:     fmt.Sprintf("%d", drsi),
-		DepositBalanceToConsume:       fmt.Sprintf("%d", dbtc),
-		ExitBalanceToConsume:          fmt.Sprintf("%d", ebtc),
-		EarliestExitEpoch:             fmt.Sprintf("%d", eee),
-		ConsolidationBalanceToConsume: fmt.Sprintf("%d", cbtc),
-		EarliestConsolidationEpoch:    fmt.Sprintf("%d", ece),
-		PendingBalanceDeposits:        PendingBalanceDepositsFromConsensus(pbd),
-		PendingPartialWithdrawals:     PendingPartialWithdrawalsFromConsensus(ppw),
-		PendingConsolidations:         PendingConsolidationsFromConsensus(pc),
-	}, nil
-}

api/server/structs/endpoints_beacon.go

@@ -196,48 +196,3 @@ type DepositSnapshot struct {
 	ExecutionBlockHash   string   `json:"execution_block_hash"`
 	ExecutionBlockHeight string   `json:"execution_block_height"`
 }
-
-type GetIndividualVotesRequest struct {
-	Epoch      string   `json:"epoch"`
-	PublicKeys []string `json:"public_keys,omitempty"`
-	Indices    []string `json:"indices,omitempty"`
-}
-
-type GetIndividualVotesResponse struct {
-	IndividualVotes []*IndividualVote `json:"individual_votes"`
-}
-
-type IndividualVote struct {
-	Epoch                            string `json:"epoch"`
-	PublicKey                        string `json:"public_keys,omitempty"`
-	ValidatorIndex                   string `json:"validator_index"`
-	IsSlashed                        bool   `json:"is_slashed"`
-	IsWithdrawableInCurrentEpoch     bool   `json:"is_withdrawable_in_current_epoch"`
-	IsActiveInCurrentEpoch           bool   `json:"is_active_in_current_epoch"`
-	IsActiveInPreviousEpoch          bool   `json:"is_active_in_previous_epoch"`
-	IsCurrentEpochAttester           bool   `json:"is_current_epoch_attester"`
-	IsCurrentEpochTargetAttester     bool   `json:"is_current_epoch_target_attester"`
-	IsPreviousEpochAttester          bool   `json:"is_previous_epoch_attester"`
-	IsPreviousEpochTargetAttester    bool   `json:"is_previous_epoch_target_attester"`
-	IsPreviousEpochHeadAttester      bool   `json:"is_previous_epoch_head_attester"`
-	CurrentEpochEffectiveBalanceGwei string `json:"current_epoch_effective_balance_gwei"`
-	InclusionSlot                    string `json:"inclusion_slot"`
-	InclusionDistance                string `json:"inclusion_distance"`
-	InactivityScore                  string `json:"inactivity_score"`
-}
-
-type ChainHead struct {
-	HeadSlot                   string `json:"head_slot"`
-	HeadEpoch                  string `json:"head_epoch"`
-	HeadBlockRoot              string `json:"head_block_root"`
-	FinalizedSlot              string `json:"finalized_slot"`
-	FinalizedEpoch             string `json:"finalized_epoch"`
-	FinalizedBlockRoot         string `json:"finalized_block_root"`
-	JustifiedSlot              string `json:"justified_slot"`
-	JustifiedEpoch             string `json:"justified_epoch"`
-	JustifiedBlockRoot         string `json:"justified_block_root"`
-	PreviousJustifiedSlot      string `json:"previous_justified_slot"`
-	PreviousJustifiedEpoch     string `json:"previous_justified_epoch"`
-	PreviousJustifiedBlockRoot string `json:"previous_justified_block_root"`
-	OptimisticStatus           bool   `json:"optimistic_status"`
-}

api/server/structs/endpoints_lightclient.go

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

api/server/structs/endpoints_validator.go

@@ -118,34 +118,3 @@ type GetValidatorPerformanceResponse struct {
 	MissingValidators             [][]byte `json:"missing_validators,omitempty"`
 	InactivityScores              []uint64 `json:"inactivity_scores,omitempty"`
 }
-
-type GetValidatorParticipationResponse struct {
-	Epoch         string                  `json:"epoch"`
-	Finalized     bool                    `json:"finalized"`
-	Participation *ValidatorParticipation `json:"participation"`
-}
-
-type ValidatorParticipation struct {
-	GlobalParticipationRate          string `json:"global_participation_rate" deprecated:"true"`
-	VotedEther                       string `json:"voted_ether" deprecated:"true"`
-	EligibleEther                    string `json:"eligible_ether" deprecated:"true"`
-	CurrentEpochActiveGwei           string `json:"current_epoch_active_gwei"`
-	CurrentEpochAttestingGwei        string `json:"current_epoch_attesting_gwei"`
-	CurrentEpochTargetAttestingGwei  string `json:"current_epoch_target_attesting_gwei"`
-	PreviousEpochActiveGwei          string `json:"previous_epoch_active_gwei"`
-	PreviousEpochAttestingGwei       string `json:"previous_epoch_attesting_gwei"`
-	PreviousEpochTargetAttestingGwei string `json:"previous_epoch_target_attesting_gwei"`
-	PreviousEpochHeadAttestingGwei   string `json:"previous_epoch_head_attesting_gwei"`
-}
-
-type ActiveSetChanges struct {
-	Epoch               string   `json:"epoch"`
-	ActivatedPublicKeys []string `json:"activated_public_keys"`
-	ActivatedIndices    []string `json:"activated_indices"`
-	ExitedPublicKeys    []string `json:"exited_public_keys"`
-	ExitedIndices       []string `json:"exited_indices"`
-	SlashedPublicKeys   []string `json:"slashed_public_keys"`
-	SlashedIndices      []string `json:"slashed_indices"`
-	EjectedPublicKeys   []string `json:"ejected_public_keys"`
-	EjectedIndices      []string `json:"ejected_indices"`
-}

api/server/structs/other.go

@@ -29,13 +29,6 @@ type Attestation struct {
 	Signature       string           `json:"signature"`
 }
 
-type AttestationElectra struct {
-	AggregationBits string           `json:"aggregation_bits"`
-	Data            *AttestationData `json:"data"`
-	Signature       string           `json:"signature"`
-	CommitteeBits   string           `json:"committee_bits"`
-}
-
 type AttestationData struct {
 	Slot            string      `json:"slot"`
 	CommitteeIndex  string      `json:"index"`
@@ -85,17 +78,6 @@ type AggregateAttestationAndProof struct {
 	SelectionProof  string       `json:"selection_proof"`
 }
 
-type SignedAggregateAttestationAndProofElectra struct {
-	Message   *AggregateAttestationAndProofElectra `json:"message"`
-	Signature string                               `json:"signature"`
-}
-
-type AggregateAttestationAndProofElectra struct {
-	AggregatorIndex string              `json:"aggregator_index"`
-	Aggregate       *AttestationElectra `json:"aggregate"`
-	SelectionProof  string              `json:"selection_proof"`
-}
-
 type SyncCommitteeSubscription struct {
 	ValidatorIndex       string   `json:"validator_index"`
 	SyncCommitteeIndices []string `json:"sync_committee_indices"`
@@ -196,11 +178,6 @@ type AttesterSlashing struct {
 	Attestation2 *IndexedAttestation `json:"attestation_2"`
 }
 
-type AttesterSlashingElectra struct {
-	Attestation1 *IndexedAttestationElectra `json:"attestation_1"`
-	Attestation2 *IndexedAttestationElectra `json:"attestation_2"`
-}
-
 type Deposit struct {
 	Proof []string     `json:"proof"`
 	Data  *DepositData `json:"data"`
@@ -219,12 +196,6 @@ type IndexedAttestation struct {
 	Signature        string           `json:"signature"`
 }
 
-type IndexedAttestationElectra struct {
-	AttestingIndices []string         `json:"attesting_indices"`
-	Data             *AttestationData `json:"data"`
-	Signature        string           `json:"signature"`
-}
-
 type SyncAggregate struct {
 	SyncCommitteeBits      string `json:"sync_committee_bits"`
 	SyncCommitteeSignature string `json:"sync_committee_signature"`
@@ -236,39 +207,3 @@ type Withdrawal struct {
 	ExecutionAddress string `json:"address"`
 	Amount           string `json:"amount"`
 }
-
-type DepositRequest struct {
-	Pubkey                string `json:"pubkey"`
-	WithdrawalCredentials string `json:"withdrawal_credentials"`
-	Amount                string `json:"amount"`
-	Signature             string `json:"signature"`
-	Index                 string `json:"index"`
-}
-
-type WithdrawalRequest struct {
-	SourceAddress   string `json:"source_address"`
-	ValidatorPubkey string `json:"validator_pubkey"`
-	Amount          string `json:"amount"`
-}
-
-type ConsolidationRequest struct {
-	SourceAddress string `json:"source_address"`
-	SourcePubkey  string `json:"source_pubkey"`
-	TargetPubkey  string `json:"target_pubkey"`
-}
-
-type PendingBalanceDeposit struct {
-	Index  string `json:"index"`
-	Amount string `json:"amount"`
-}
-
-type PendingPartialWithdrawal struct {
-	Index             string `json:"index"`
-	Amount            string `json:"amount"`
-	WithdrawableEpoch string `json:"withdrawable_epoch"`
-}
-
-type PendingConsolidation struct {
-	SourceIndex string `json:"source_index"`
-	TargetIndex string `json:"target_index"`
-}

api/server/structs/state.go

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

beacon-chain/blockchain/BUILD.bazel

@@ -13,6 +13,7 @@ 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,7 +49,6 @@ 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/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
@@ -83,10 +83,10 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/eth/v2:go_default_library",
+        "//proto/migration:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -119,6 +119,7 @@ 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",
@@ -176,6 +177,7 @@ 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/chain_info.go

@@ -16,9 +16,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // ChainInfoFetcher defines a common interface for methods in blockchain service which
@@ -48,8 +48,6 @@ type ForkchoiceFetcher interface {
 	ForkChoiceDump(context.Context) (*forkchoice.Dump, error)
 	NewSlot(context.Context, primitives.Slot) error
 	ProposerBoost() [32]byte
-	RecentBlockSlot(root [32]byte) (primitives.Slot, error)
-	IsCanonical(ctx context.Context, blockRoot [32]byte) (bool, error)
 }
 
 // TimeFetcher retrieves the Ethereum consensus data that's related to time.

beacon-chain/blockchain/chain_info_forkchoice.go

@@ -22,6 +22,13 @@ func (s *Service) GetProposerHead() [32]byte {
 	return s.cfg.ForkChoiceStore.GetProposerHead()
 }
 
+// ShouldOverrideFCU returns the corresponding value from forkchoice
+func (s *Service) ShouldOverrideFCU() bool {
+	s.cfg.ForkChoiceStore.RLock()
+	defer s.cfg.ForkChoiceStore.RUnlock()
+	return s.cfg.ForkChoiceStore.ShouldOverrideFCU()
+}
+
 // SetForkChoiceGenesisTime sets the genesis time in Forkchoice
 func (s *Service) SetForkChoiceGenesisTime(timestamp uint64) {
 	s.cfg.ForkChoiceStore.Lock()
@@ -92,10 +99,3 @@ func (s *Service) FinalizedBlockHash() [32]byte {
 	defer s.cfg.ForkChoiceStore.RUnlock()
 	return s.cfg.ForkChoiceStore.FinalizedPayloadBlockHash()
 }
-
-// ParentRoot wraps a call to the corresponding method in forkchoice
-func (s *Service) ParentRoot(root [32]byte) ([32]byte, error) {
-	s.cfg.ForkChoiceStore.RLock()
-	defer s.cfg.ForkChoiceStore.RUnlock()
-	return s.cfg.ForkChoiceStore.ParentRoot(root)
-}

beacon-chain/blockchain/execution_engine.go

@@ -21,11 +21,11 @@ import (
 	payloadattribute "github.com/prysmaticlabs/prysm/v5/consensus-types/payload-attribute"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 const blobCommitmentVersionKZG uint8 = 0x01

beacon-chain/blockchain/head.go

@@ -18,11 +18,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // UpdateAndSaveHeadWithBalances updates the beacon state head after getting justified balanced from cache.

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -53,7 +53,7 @@ func Start() error {
 	}
 	if !kzgLoaded {
 		// TODO: Provide a configuration option for this.
-		var precompute uint = 8
+		var precompute uint = 0
 
 		// Free the current trusted setup before running this method. CKZG
 		// panics if the same setup is run multiple times.

beacon-chain/blockchain/lightclient.go

@@ -1,24 +1,22 @@
-package light_client
+package blockchain
 
 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 (
-	FinalityBranchNumOfLeaves = 6
+	finalityBranchNumOfLeaves = 6
 )
 
 // CreateLightClientFinalityUpdate - implements https://github.com/ethereum/consensus-specs/blob/3d235740e5f1e641d3b160c8688f26e7dc5a1894/specs/altair/light-client/full-node.md#create_light_client_finality_update
@@ -217,8 +215,8 @@ func NewLightClientFinalityUpdateFromBeaconState(
 			BodyRoot:      make([]byte, 32),
 		}
 
-		finalityBranch = make([][]byte, FinalityBranchNumOfLeaves)
-		for i := 0; i < FinalityBranchNumOfLeaves; i++ {
+		finalityBranch = make([][]byte, finalityBranchNumOfLeaves)
+		for i := 0; i < finalityBranchNumOfLeaves; i++ {
 			finalityBranch[i] = make([]byte, 32)
 		}
 	}

beacon-chain/blockchain/lightclient_test.go

@@ -0,0 +1,160 @@
+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_attestation.go

@@ -46,7 +46,7 @@ func (s *Service) OnAttestation(ctx context.Context, a ethpb.Att, disparity time
 	if err := helpers.ValidateSlotTargetEpoch(a.GetData()); err != nil {
 		return err
 	}
-	tgt := a.GetData().Target.Copy()
+	tgt := ethpb.CopyCheckpoint(a.GetData().Target)
 
 	// Note that target root check is ignored here because it was performed in sync's validation pipeline:
 	// validate_aggregate_proof.go and validate_beacon_attestation.go

beacon-chain/blockchain/process_block.go

@@ -3,10 +3,12 @@ package blockchain
 import (
 	"context"
 	"fmt"
-	"slices"
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
@@ -27,12 +29,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // A custom slot deadline for processing state slots in our cache.
@@ -144,7 +146,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	b := blks[0].Block()
 
 	// Retrieve incoming block's pre state.
-	if err := s.verifyBlkPreState(ctx, b.ParentRoot()); err != nil {
+	if err := s.verifyBlkPreState(ctx, b); err != nil {
 		return err
 	}
 	preState, err := s.cfg.StateGen.StateByRootInitialSync(ctx, b.ParentRoot())
@@ -519,23 +521,19 @@ func missingDataColumns(bs *filesystem.BlobStorage, root [32]byte, expected map[
 	if len(expected) == 0 {
 		return nil, nil
 	}
-
 	if len(expected) > int(params.BeaconConfig().NumberOfColumns) {
 		return nil, errMaxDataColumnsExceeded
 	}
-
 	indices, err := bs.ColumnIndices(root)
 	if err != nil {
 		return nil, err
 	}
-
 	missing := make(map[uint64]bool, len(expected))
 	for col := range expected {
 		if !indices[col] {
 			missing[col] = true
 		}
 	}
-
 	return missing, nil
 }
 
@@ -546,9 +544,8 @@ func missingDataColumns(bs *filesystem.BlobStorage, root [32]byte, expected map[
 // closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
 func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
 	if coreTime.PeerDASIsActive(signed.Block().Slot()) {
-		return s.areDataColumnsAvailable(ctx, root, signed)
+		return s.isDataAvailableDataColumns(ctx, root, signed)
 	}
-
 	if signed.Version() < version.Deneb {
 		return nil
 	}
@@ -625,17 +622,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	}
 }
 
-// uint64MapToSortedSlice produces a sorted uint64 slice from a map.
-func uint64MapToSortedSlice(input map[uint64]bool) []uint64 {
-	output := make([]uint64, 0, len(input))
-	for idx := range input {
-		output = append(output, idx)
-	}
-	slices.Sort[[]uint64](output)
-	return output
-}
-
-func (s *Service) areDataColumnsAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
+func (s *Service) isDataAvailableDataColumns(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
 	if signed.Version() < version.Deneb {
 		return nil
 	}
@@ -648,34 +635,26 @@ func (s *Service) areDataColumnsAvailable(ctx context.Context, root [32]byte, si
 	if !params.WithinDAPeriod(slots.ToEpoch(block.Slot()), slots.ToEpoch(s.CurrentSlot())) {
 		return nil
 	}
-
 	body := block.Body()
 	if body == nil {
 		return errors.New("invalid nil beacon block body")
 	}
-
 	kzgCommitments, err := body.BlobKzgCommitments()
 	if err != nil {
-		return errors.Wrap(err, "blob KZG commitments")
+		return errors.Wrap(err, "could not get KZG commitments")
 	}
-
 	// If block has not commitments there is nothing to wait for.
 	if len(kzgCommitments) == 0 {
 		return nil
 	}
 
-	// All columns to sample need to be available for the block to be considered available.
-	// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#subnet-sampling
-	nodeID := s.cfg.P2P.NodeID()
-	subnetSamplingSize := peerdas.SubnetSamplingSize()
-
-	colMap, err := peerdas.CustodyColumns(nodeID, subnetSamplingSize)
+	colMap, err := peerdas.CustodyColumns(s.cfg.P2P.NodeID(), peerdas.CustodySubnetCount())
 	if err != nil {
-		return errors.Wrap(err, "custody columns")
+		return err
 	}
-
-	// colMap represents the data columnns a node is expected to custody.
-	if len(colMap) == 0 {
+	// Expected is the number of custodied data columnns a node is expected to have.
+	expected := len(colMap)
+	if expected == 0 {
 		return nil
 	}
 
@@ -684,29 +663,15 @@ func (s *Service) areDataColumnsAvailable(ctx context.Context, root [32]byte, si
 	subscription := s.blobStorage.DataColumnFeed.Subscribe(rootIndexChan)
 	defer subscription.Unsubscribe()
 
-	// Get the count of data columns we already have in the store.
-	retrievedDataColumns, err := s.blobStorage.ColumnIndices(root)
-	if err != nil {
-		return errors.Wrap(err, "column indices")
-	}
-
-	retrievedDataColumnsCount := uint64(len(retrievedDataColumns))
-
-	// As soon as we have more than half of the data columns, we can reconstruct the missing ones.
-	// We don't need to wait for the rest of the data columns to declare the block as available.
-	if peerdas.CanSelfReconstruct(retrievedDataColumnsCount) {
-		return nil
-	}
-
 	// Get a map of data column indices that are not currently available.
-	missingMap, err := missingDataColumns(s.blobStorage, root, colMap)
+	missing, err := missingDataColumns(s.blobStorage, root, colMap)
 	if err != nil {
 		return err
 	}
 
 	// If there are no missing indices, all data column sidecars are available.
 	// This is the happy path.
-	if len(missingMap) == 0 {
+	if len(missing) == 0 {
 		return nil
 	}
 
@@ -715,39 +680,19 @@ func (s *Service) areDataColumnsAvailable(ctx context.Context, root [32]byte, si
 	// Avoid logging if DA check is called after next slot start.
 	if nextSlot.After(time.Now()) {
 		nst := time.AfterFunc(time.Until(nextSlot), func() {
-			missingMapCount := uint64(len(missingMap))
-
-			if missingMapCount == 0 {
+			if len(missing) == 0 {
 				return
 			}
 
-			var (
-				expected interface{} = "all"
-				missing  interface{} = "all"
-			)
-
-			numberOfColumns := params.BeaconConfig().NumberOfColumns
-			colMapCount := uint64(len(colMap))
-
-			if colMapCount < numberOfColumns {
-				expected = uint64MapToSortedSlice(colMap)
-			}
-
-			if missingMapCount < numberOfColumns {
-				missing = uint64MapToSortedSlice(missingMap)
-			}
-
 			log.WithFields(logrus.Fields{
 				"slot":            signed.Block().Slot(),
 				"root":            fmt.Sprintf("%#x", root),
 				"columnsExpected": expected,
-				"columnsWaiting":  missing,
-			}).Error("Some data columns are still unavailable at slot end")
+				"columnsWaiting":  len(missing),
+			}).Error("Still waiting for data columns DA check at slot end.")
 		})
-
 		defer nst.Stop()
 	}
-
 	for {
 		select {
 		case rootIndex := <-rootIndexChan:
@@ -756,34 +701,20 @@ func (s *Service) areDataColumnsAvailable(ctx context.Context, root [32]byte, si
 				continue
 			}
 
-			// This is a data column we are expecting.
-			if _, ok := missingMap[rootIndex.Index]; ok {
-				retrievedDataColumnsCount++
-			}
-
-			// As soon as we have more than half of the data columns, we can reconstruct the missing ones.
-			// We don't need to wait for the rest of the data columns to declare the block as available.
-			if peerdas.CanSelfReconstruct(retrievedDataColumnsCount) {
-				return nil
-			}
-
 			// Remove the index from the missing map.
-			delete(missingMap, rootIndex.Index)
+			delete(missing, rootIndex.Index)
 
 			// Exit if there is no more missing data columns.
-			if len(missingMap) == 0 {
+			if len(missing) == 0 {
 				return nil
 			}
 		case <-ctx.Done():
-			var missingIndices interface{} = "all"
-			numberOfColumns := params.BeaconConfig().NumberOfColumns
-			missingIndicesCount := uint64(len(missingMap))
-
-			if missingIndicesCount < numberOfColumns {
-				missingIndices = uint64MapToSortedSlice(missingMap)
+			missingIndexes := make([]uint64, 0, len(missing))
+			for val := range missing {
+				copiedVal := val
+				missingIndexes = append(missingIndexes, copiedVal)
 			}
-
-			return errors.Wrapf(ctx.Err(), "context deadline waiting for data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndices)
+			return errors.Wrapf(ctx.Err(), "context deadline waiting for data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndexes)
 		}
 	}
 }
@@ -867,7 +798,7 @@ func (s *Service) waitForSync() error {
 	}
 }
 
-func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot, parentRoot [32]byte) error {
+func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot [32]byte, parentRoot [32]byte) error {
 	if IsInvalidBlock(err) && InvalidBlockLVH(err) != [32]byte{} {
 		return s.pruneInvalidBlock(ctx, blockRoot, parentRoot, InvalidBlockLVH(err))
 	}

beacon-chain/blockchain/process_block_helpers.go

@@ -5,8 +5,6 @@ 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"
@@ -16,17 +14,16 @@ import (
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/forkchoice/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // CurrentSlot returns the current slot based on time.
@@ -178,7 +175,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 		}
 	}
 
-	update, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(
+	update, err := NewLightClientFinalityUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -193,7 +190,7 @@ func (s *Service) sendLightClientFinalityUpdate(ctx context.Context, signed inte
 	// Return the result
 	result := &ethpbv2.LightClientFinalityUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    lightclient.CreateLightClientFinalityUpdate(update),
+		Data:    CreateLightClientFinalityUpdate(update),
 	}
 
 	// Send event
@@ -213,7 +210,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 		return 0, errors.Wrap(err, "could not get attested state")
 	}
 
-	update, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(
+	update, err := NewLightClientOptimisticUpdateFromBeaconState(
 		ctx,
 		postState,
 		signed,
@@ -227,7 +224,7 @@ func (s *Service) sendLightClientOptimisticUpdate(ctx context.Context, signed in
 	// Return the result
 	result := &ethpbv2.LightClientOptimisticUpdateWithVersion{
 		Version: ethpbv2.Version(signed.Version()),
-		Data:    lightclient.CreateLightClientOptimisticUpdate(update),
+		Data:    CreateLightClientOptimisticUpdate(update),
 	}
 
 	return s.cfg.StateNotifier.StateFeed().Send(&feed.Event{
@@ -288,7 +285,7 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 	defer span.End()
 
 	// Verify incoming block has a valid pre state.
-	if err := s.verifyBlkPreState(ctx, b.ParentRoot()); err != nil {
+	if err := s.verifyBlkPreState(ctx, b); err != nil {
 		return nil, err
 	}
 
@@ -314,10 +311,11 @@ func (s *Service) getBlockPreState(ctx context.Context, b interfaces.ReadOnlyBea
 }
 
 // verifyBlkPreState validates input block has a valid pre-state.
-func (s *Service) verifyBlkPreState(ctx context.Context, parentRoot [field_params.RootLength]byte) error {
+func (s *Service) verifyBlkPreState(ctx context.Context, b interfaces.ReadOnlyBeaconBlock) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.verifyBlkPreState")
 	defer span.End()
 
+	parentRoot := b.ParentRoot()
 	// Loosen the check to HasBlock because state summary gets saved in batches
 	// during initial syncing. There's no risk given a state summary object is just a
 	// subset of the block object.

beacon-chain/blockchain/process_block_test.go

@@ -117,7 +117,7 @@ func TestCachedPreState_CanGetFromStateSummary(t *testing.T) {
 
 	require.NoError(t, service.cfg.BeaconDB.SaveStateSummary(ctx, &ethpb.StateSummary{Slot: 1, Root: root[:]}))
 	require.NoError(t, service.cfg.StateGen.SaveState(ctx, root, st))
-	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block().ParentRoot()))
+	require.NoError(t, service.verifyBlkPreState(ctx, wsb.Block()))
 }
 
 func TestFillForkChoiceMissingBlocks_CanSave(t *testing.T) {
@@ -2044,11 +2044,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
-		defaultConfig := util.DefaultBlockGenConfig()
-		defaultConfig.NumWithdrawalRequests = 1
-		defaultConfig.NumDepositRequests = 2
-		defaultConfig.NumConsolidationRequests = 1
-		b, err := util.GenerateFullBlockElectra(st, keys, defaultConfig, 1)
+		b, err := util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 1)
 		require.NoError(t, err)
 		wsb, err := consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
@@ -2063,7 +2059,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 
 		st, err = service.HeadState(ctx)
 		require.NoError(t, err)
-		b, err = util.GenerateFullBlockElectra(st, keys, defaultConfig, 2)
+		b, err = util.GenerateFullBlockElectra(st, keys, util.DefaultBlockGenConfig(), 2)
 		require.NoError(t, err)
 		wsb, err = consensusblocks.NewSignedBeaconBlock(b)
 		require.NoError(t, err)
@@ -2071,7 +2067,7 @@ func TestOnBlock_HandleBlockAttestations(t *testing.T) {
 		// prepare another block that is not inserted
 		st3, err := transition.ExecuteStateTransition(ctx, st, wsb)
 		require.NoError(t, err)
-		b3, err := util.GenerateFullBlockElectra(st3, keys, defaultConfig, 3)
+		b3, err := util.GenerateFullBlockElectra(st3, keys, util.DefaultBlockGenConfig(), 3)
 		require.NoError(t, err)
 		wsb3, err := consensusblocks.NewSignedBeaconBlock(b3)
 		require.NoError(t, err)

beacon-chain/blockchain/receive_attestation.go

@@ -12,11 +12,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 // reorgLateBlockCountAttestations is the time until the end of the slot in which we count
@@ -191,26 +190,13 @@ func (s *Service) processAttestations(ctx context.Context, disparity time.Durati
 		}
 
 		if err := s.receiveAttestationNoPubsub(ctx, a, disparity); err != nil {
-			var fields logrus.Fields
-			if a.Version() >= version.Electra {
-				fields = logrus.Fields{
-					"slot":             a.GetData().Slot,
-					"committeeCount":   a.CommitteeBitsVal().Count(),
-					"committeeIndices": a.CommitteeBitsVal().BitIndices(),
-					"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
-					"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
-					"aggregatedCount":  a.GetAggregationBits().Count(),
-				}
-			} else {
-				fields = logrus.Fields{
-					"slot":            a.GetData().Slot,
-					"committeeIndex":  a.GetData().CommitteeIndex,
-					"beaconBlockRoot": fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
-					"targetRoot":      fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
-					"aggregatedCount": a.GetAggregationBits().Count(),
-				}
-			}
-			log.WithFields(fields).WithError(err).Warn("Could not process attestation for fork choice")
+			log.WithFields(logrus.Fields{
+				"slot":             a.GetData().Slot,
+				"committeeIndex":   a.GetData().CommitteeIndex,
+				"beaconBlockRoot":  fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().BeaconBlockRoot)),
+				"targetRoot":       fmt.Sprintf("%#x", bytesutil.Trunc(a.GetData().Target.Root)),
+				"aggregationCount": a.GetAggregationBits().Count(),
+			}).WithError(err).Warn("Could not process attestation for fork choice")
 		}
 	}
 }

beacon-chain/blockchain/receive_block.go

@@ -21,12 +21,12 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpbv1 "github.com/prysmaticlabs/prysm/v5/proto/eth/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 	"golang.org/x/sync/errgroup"
 )
 
@@ -54,7 +54,7 @@ type BlobReceiver interface {
 // DataColumnReceiver interface defines the methods of chain service for receiving new
 // data columns
 type DataColumnReceiver interface {
-	ReceiveDataColumn(blocks.VerifiedRODataColumn) error
+	ReceiveDataColumn(context.Context, blocks.VerifiedRODataColumn) error
 }
 
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
@@ -83,20 +83,59 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
+	rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
+	if err != nil {
+		return err
+	}
+
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
 	if err != nil {
 		return errors.Wrap(err, "could not get block's prestate")
 	}
+	// Save current justified and finalized epochs for future use.
+	currStoreJustifiedEpoch := s.CurrentJustifiedCheckpt().Epoch
+	currStoreFinalizedEpoch := s.FinalizedCheckpt().Epoch
+	currentEpoch := coreTime.CurrentEpoch(preState)
 
-	currentCheckpoints := s.saveCurrentCheckpoints(preState)
-	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, blockCopy, blockRoot)
+	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
 	if err != nil {
 		return err
 	}
-	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
-	if err != nil {
+	eg, _ := errgroup.WithContext(ctx)
+	var postState state.BeaconState
+	eg.Go(func() error {
+		var err error
+		postState, err = s.validateStateTransition(ctx, preState, blockCopy)
+		if err != nil {
+			return errors.Wrap(err, "failed to validate consensus state transition function")
+		}
+		return nil
+	})
+	var isValidPayload bool
+	eg.Go(func() error {
+		var err error
+		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, blockCopy, blockRoot)
+		if err != nil {
+			return errors.Wrap(err, "could not notify the engine of the new payload")
+		}
+		return nil
+	})
+	if err := eg.Wait(); err != nil {
 		return err
 	}
+	daStartTime := time.Now()
+	if avs != nil {
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
+			return errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
+		}
+	} else {
+		if err := s.isDataAvailable(ctx, blockRoot, blockCopy); err != nil {
+			return errors.Wrap(err, "could not validate blob data availability")
+		}
+	}
+	daWaitedTime := time.Since(daStartTime)
+	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
+
 	// Defragment the state before continuing block processing.
 	s.defragmentState(postState)
 
@@ -118,9 +157,29 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		tracing.AnnotateError(span, err)
 		return err
 	}
-	if err := s.updateCheckpoints(ctx, currentCheckpoints, preState, postState, blockRoot); err != nil {
-		return err
+	if coreTime.CurrentEpoch(postState) > currentEpoch && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
+		headSt, err := s.HeadState(ctx)
+		if err != nil {
+			return errors.Wrap(err, "could not get head state")
+		}
+		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
+			log.WithError(err).Error("could not report epoch metrics")
+		}
 	}
+	if err := s.updateJustificationOnBlock(ctx, preState, postState, currStoreJustifiedEpoch); err != nil {
+		return errors.Wrap(err, "could not update justified checkpoint")
+	}
+
+	newFinalized, err := s.updateFinalizationOnBlock(ctx, preState, postState, currStoreFinalizedEpoch)
+	if err != nil {
+		return errors.Wrap(err, "could not update finalized checkpoint")
+	}
+	// Send finalized events and finalized deposits in the background
+	if newFinalized {
+		// hook to process all post state finalization tasks
+		s.executePostFinalizationTasks(ctx, postState)
+	}
+
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
 	if features.Get().EnableSlasher {
 		go s.sendBlockAttestationsToSlasher(blockCopy, preState)
@@ -140,140 +199,31 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err := s.handleCaches(); err != nil {
 		return err
 	}
-	s.reportPostBlockProcessing(blockCopy, blockRoot, receivedTime, daWaitedTime)
-	return nil
-}
 
-type ffgCheckpoints struct {
-	j, f, c primitives.Epoch
-}
-
-func (s *Service) saveCurrentCheckpoints(state state.BeaconState) (cp ffgCheckpoints) {
-	// Save current justified and finalized epochs for future use.
-	cp.j = s.CurrentJustifiedCheckpt().Epoch
-	cp.f = s.FinalizedCheckpt().Epoch
-	cp.c = coreTime.CurrentEpoch(state)
-	return
-}
-
-func (s *Service) updateCheckpoints(
-	ctx context.Context,
-	cp ffgCheckpoints,
-	preState, postState state.BeaconState,
-	blockRoot [32]byte,
-) error {
-	if coreTime.CurrentEpoch(postState) > cp.c && s.cfg.ForkChoiceStore.IsCanonical(blockRoot) {
-		headSt, err := s.HeadState(ctx)
-		if err != nil {
-			return errors.Wrap(err, "could not get head state")
-		}
-		if err := reportEpochMetrics(ctx, postState, headSt); err != nil {
-			log.WithError(err).Error("could not report epoch metrics")
-		}
-	}
-	if err := s.updateJustificationOnBlock(ctx, preState, postState, cp.j); err != nil {
-		return errors.Wrap(err, "could not update justified checkpoint")
-	}
-
-	newFinalized, err := s.updateFinalizationOnBlock(ctx, preState, postState, cp.f)
-	if err != nil {
-		return errors.Wrap(err, "could not update finalized checkpoint")
-	}
-	// Send finalized events and finalized deposits in the background
-	if newFinalized {
-		// hook to process all post state finalization tasks
-		s.executePostFinalizationTasks(ctx, postState)
-	}
-	return nil
-}
-
-func (s *Service) validateExecutionAndConsensus(
-	ctx context.Context,
-	preState state.BeaconState,
-	block interfaces.SignedBeaconBlock,
-	blockRoot [32]byte,
-) (state.BeaconState, bool, error) {
-	preStateVersion, preStateHeader, err := getStateVersionAndPayload(preState)
-	if err != nil {
-		return nil, false, err
-	}
-	eg, _ := errgroup.WithContext(ctx)
-	var postState state.BeaconState
-	eg.Go(func() error {
-		var err error
-		postState, err = s.validateStateTransition(ctx, preState, block)
-		if err != nil {
-			return errors.Wrap(err, "failed to validate consensus state transition function")
-		}
-		return nil
-	})
-	var isValidPayload bool
-	eg.Go(func() error {
-		var err error
-		isValidPayload, err = s.validateExecutionOnBlock(ctx, preStateVersion, preStateHeader, block, blockRoot)
-		if err != nil {
-			return errors.Wrap(err, "could not notify the engine of the new payload")
-		}
-		return nil
-	})
-	if err := eg.Wait(); err != nil {
-		return nil, false, err
-	}
-	return postState, isValidPayload, nil
-}
-
-func (s *Service) handleDA(
-	ctx context.Context,
-	block interfaces.SignedBeaconBlock,
-	blockRoot [32]byte,
-	avs das.AvailabilityStore,
-) (time.Duration, error) {
-	daStartTime := time.Now()
-	if avs != nil {
-		rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
-		if err != nil {
-			return 0, err
-		}
-		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
-			return 0, errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
-		}
-	} else {
-		if err := s.isDataAvailable(ctx, blockRoot, block); err != nil {
-			return 0, errors.Wrap(err, "could not validate blob data availability")
-		}
-	}
-	daWaitedTime := time.Since(daStartTime)
-	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
-	return daWaitedTime, nil
-}
-
-func (s *Service) reportPostBlockProcessing(
-	block interfaces.SignedBeaconBlock,
-	blockRoot [32]byte,
-	receivedTime time.Time,
-	daWaitedTime time.Duration,
-) {
 	// Reports on block and fork choice metrics.
 	cp := s.cfg.ForkChoiceStore.FinalizedCheckpoint()
 	finalized := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	reportSlotMetrics(block.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
+	reportSlotMetrics(blockCopy.Block().Slot(), s.HeadSlot(), s.CurrentSlot(), finalized)
 
 	// Log block sync status.
 	cp = s.cfg.ForkChoiceStore.JustifiedCheckpoint()
 	justified := &ethpb.Checkpoint{Epoch: cp.Epoch, Root: bytesutil.SafeCopyBytes(cp.Root[:])}
-	if err := logBlockSyncStatus(block.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix()), daWaitedTime); err != nil {
+	if err := logBlockSyncStatus(blockCopy.Block(), blockRoot, justified, finalized, receivedTime, uint64(s.genesisTime.Unix()), daWaitedTime); err != nil {
 		log.WithError(err).Error("Unable to log block sync status")
 	}
 	// Log payload data
-	if err := logPayload(block.Block()); err != nil {
+	if err := logPayload(blockCopy.Block()); err != nil {
 		log.WithError(err).Error("Unable to log debug block payload data")
 	}
 	// Log state transition data.
-	if err := logStateTransitionData(block.Block()); err != nil {
+	if err := logStateTransitionData(blockCopy.Block()); err != nil {
 		log.WithError(err).Error("Unable to log state transition data")
 	}
+
 	timeWithoutDaWait := time.Since(receivedTime) - daWaitedTime
 	chainServiceProcessingTime.Observe(float64(timeWithoutDaWait.Milliseconds()))
+
+	return nil
 }
 
 func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedState state.BeaconState) {

beacon-chain/blockchain/receive_block_test.go

@@ -12,6 +12,7 @@ import (
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/voluntaryexits"
+	"github.com/prysmaticlabs/prysm/v5/config/features"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -420,9 +421,14 @@ func Test_sendNewFinalizedEvent(t *testing.T) {
 }
 
 func Test_executePostFinalizationTasks(t *testing.T) {
+	resetFn := features.InitWithReset(&features.Flags{
+		EIP6110ValidatorIndexCache: true,
+	})
+	defer resetFn()
+
 	logHook := logTest.NewGlobal()
 
-	headState, err := util.NewBeaconStateElectra()
+	headState, err := util.NewBeaconState()
 	require.NoError(t, err)
 	finalizedStRoot, err := headState.HashTreeRoot(context.Background())
 	require.NoError(t, err)

beacon-chain/blockchain/receive_data_column.go

@@ -1,11 +1,13 @@
 package blockchain
 
 import (
+	"context"
+
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 )
 
-func (s *Service) ReceiveDataColumn(ds blocks.VerifiedRODataColumn) error {
+func (s *Service) ReceiveDataColumn(ctx context.Context, ds blocks.VerifiedRODataColumn) error {
 	if err := s.blobStorage.SaveDataColumn(ds); err != nil {
 		return errors.Wrap(err, "save data column")
 	}

beacon-chain/blockchain/service.go

@@ -39,10 +39,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"go.opencensus.io/trace"
 )
 
 // Service represents a service that handles the internal

beacon-chain/blockchain/service_test.go

@@ -503,15 +503,16 @@ func TestChainService_EverythingOptimistic(t *testing.T) {
 
 func TestStartFromSavedState_ValidatorIndexCacheUpdated(t *testing.T) {
 	resetFn := features.InitWithReset(&features.Flags{
-		EnableStartOptimistic: true,
+		EnableStartOptimistic:      true,
+		EIP6110ValidatorIndexCache: true,
 	})
 	defer resetFn()
 
-	genesis := util.NewBeaconBlockElectra()
+	genesis := util.NewBeaconBlock()
 	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err)
 	finalizedSlot := params.BeaconConfig().SlotsPerEpoch*2 + 1
-	headBlock := util.NewBeaconBlockElectra()
+	headBlock := util.NewBeaconBlock()
 	headBlock.Block.Slot = finalizedSlot
 	headBlock.Block.ParentRoot = bytesutil.PadTo(genesisRoot[:], 32)
 	headState, err := util.NewBeaconState()

beacon-chain/blockchain/testing/mock.go

@@ -629,7 +629,7 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 }
 
 // ReceiveDataColumn implements the same method in chain service
-func (*ChainService) ReceiveDataColumn(_ blocks.VerifiedRODataColumn) error {
+func (c *ChainService) ReceiveDataColumn(_ context.Context, _ blocks.VerifiedRODataColumn) error {
 	return nil
 }
 

beacon-chain/cache/column_subnet_ids.go

@@ -19,14 +19,9 @@ var ColumnSubnetIDs = newColumnSubnetIDs()
 const columnKey = "columns"
 
 func newColumnSubnetIDs() *columnSubnetIDs {
-	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	epochDuration := time.Duration(slotsPerEpoch.Mul(secondsPerSlot))
-
+	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
 	// Set the default duration of a column subnet subscription as the column expiry period.
-	minEpochsForDataColumnSidecarsRequest := time.Duration(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
-	subLength := epochDuration * minEpochsForDataColumnSidecarsRequest
-
+	subLength := epochDuration * time.Duration(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
 	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
 	return &columnSubnetIDs{colSubCache: persistentCache}
 }

beacon-chain/core/altair/BUILD.bazel

@@ -34,13 +34,13 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/core/altair/attestation.go

@@ -14,9 +14,9 @@ import (
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
+	"go.opencensus.io/trace"
 )
 
 // ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation

beacon-chain/core/altair/epoch_precompute.go

@@ -10,7 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/math"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	"go.opencensus.io/trace"
 )
 
 // AttDelta contains rewards and penalties for a single attestation.

beacon-chain/core/altair/transition.go

@@ -7,7 +7,7 @@ import (
 	e "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch/precompute"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
+	"go.opencensus.io/trace"
 )
 
 // ProcessEpoch describes the per epoch operations that are performed on the beacon state.

beacon-chain/core/blocks/BUILD.bazel

@@ -40,7 +40,6 @@ go_library(
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -50,6 +49,7 @@ go_library(
         "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/blocks/attestation.go

@@ -14,10 +14,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"go.opencensus.io/trace"
 )
 
 // ProcessAttestationsNoVerifySignature applies processing operations to a block's inner attestation
@@ -110,7 +110,25 @@ func VerifyAttestationNoVerifySignature(
 
 	var indexedAtt ethpb.IndexedAtt
 
-	if att.Version() >= version.Electra {
+	if att.Version() < version.Electra {
+		if uint64(att.GetData().CommitteeIndex) >= c {
+			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
+		}
+
+		if err = helpers.VerifyAttestationBitfieldLengths(ctx, beaconState, att); err != nil {
+			return errors.Wrap(err, "could not verify attestation bitfields")
+		}
+
+		// Verify attesting indices are correct.
+		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
+		if err != nil {
+			return err
+		}
+		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
+		if err != nil {
+			return err
+		}
+	} else {
 		if att.GetData().CommitteeIndex != 0 {
 			return errors.New("committee index must be 0 post-Electra")
 		}
@@ -136,29 +154,6 @@ func VerifyAttestationNoVerifySignature(
 		if err != nil {
 			return err
 		}
-	} else {
-		if uint64(att.GetData().CommitteeIndex) >= c {
-			return fmt.Errorf("committee index %d >= committee count %d", att.GetData().CommitteeIndex, c)
-		}
-
-		// Verify attesting indices are correct.
-		committee, err := helpers.BeaconCommitteeFromState(ctx, beaconState, att.GetData().Slot, att.GetData().CommitteeIndex)
-		if err != nil {
-			return err
-		}
-
-		if committee == nil {
-			return errors.New("no committee exist for this attestation")
-		}
-
-		if err := helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
-			return errors.Wrap(err, "failed to verify aggregation bitfield")
-		}
-
-		indexedAtt, err = attestation.ConvertToIndexed(ctx, att, committee)
-		if err != nil {
-			return err
-		}
 	}
 
 	return attestation.IsValidAttestationIndices(ctx, indexedAtt)

beacon-chain/core/blocks/eth1_data.go

@@ -58,9 +58,10 @@ func AreEth1DataEqual(a, b *ethpb.Eth1Data) bool {
 // votes to see if they match the eth1data.
 func Eth1DataHasEnoughSupport(beaconState state.ReadOnlyBeaconState, data *ethpb.Eth1Data) (bool, error) {
 	voteCount := uint64(0)
+	data = ethpb.CopyETH1Data(data)
 
 	for _, vote := range beaconState.Eth1DataVotes() {
-		if AreEth1DataEqual(vote, data.Copy()) {
+		if AreEth1DataEqual(vote, data) {
 			voteCount++
 		}
 	}

beacon-chain/core/blocks/eth1_data_test.go

@@ -186,7 +186,7 @@ func TestProcessEth1Data_SetsCorrectly(t *testing.T) {
 	if len(newETH1DataVotes) <= 1 {
 		t.Error("Expected new ETH1 data votes to have length > 1")
 	}
-	if !proto.Equal(beaconState.Eth1Data(), b.Block.Body.Eth1Data.Copy()) {
+	if !proto.Equal(beaconState.Eth1Data(), ethpb.CopyETH1Data(b.Block.Body.Eth1Data)) {
 		t.Errorf(
 			"Expected latest eth1 data to have been set to %v, received %v",
 			b.Block.Body.Eth1Data,

beacon-chain/core/blocks/exports_test.go

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

beacon-chain/core/blocks/payload.go

@@ -2,13 +2,11 @@ package blocks
 
 import (
 	"bytes"
-	"fmt"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	consensus_types "github.com/prysmaticlabs/prysm/v5/consensus-types"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -202,13 +200,13 @@ func ValidatePayload(st state.BeaconState, payload interfaces.ExecutionData) err
 //	    block_hash=payload.block_hash,
 //	    transactions_root=hash_tree_root(payload.transactions),
 //	)
-func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBody) (state.BeaconState, error) {
-	payload, err := body.Execution()
-	if err != nil {
-		return nil, err
-	}
-	if err := verifyBlobCommitmentCount(body); err != nil {
-		return nil, err
+func ProcessPayload(st state.BeaconState, payload interfaces.ExecutionData) (state.BeaconState, error) {
+	var err error
+	if st.Version() >= version.Capella {
+		st, err = ProcessWithdrawals(st, payload)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not process withdrawals")
+		}
 	}
 	if err := ValidatePayloadWhenMergeCompletes(st, payload); err != nil {
 		return nil, err
@@ -222,20 +220,70 @@ func ProcessPayload(st state.BeaconState, body interfaces.ReadOnlyBeaconBlockBod
 	return st, nil
 }
 
-func verifyBlobCommitmentCount(body interfaces.ReadOnlyBeaconBlockBody) error {
-	if body.Version() < version.Deneb {
-		return nil
-	}
-	kzgs, err := body.BlobKzgCommitments()
+// ValidatePayloadHeaderWhenMergeCompletes validates the payload header when the merge completes.
+func ValidatePayloadHeaderWhenMergeCompletes(st state.BeaconState, header interfaces.ExecutionData) error {
+	// Skip validation if the state is not merge compatible.
+	complete, err := IsMergeTransitionComplete(st)
 	if err != nil {
 		return err
 	}
-	if len(kzgs) > field_params.MaxBlobsPerBlock {
-		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
+	if !complete {
+		return nil
+	}
+	// Validate current header's parent hash matches state header's block hash.
+	h, err := st.LatestExecutionPayloadHeader()
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(header.ParentHash(), h.BlockHash()) {
+		return ErrInvalidPayloadBlockHash
 	}
 	return nil
 }
 
+// ValidatePayloadHeader validates the payload header.
+func ValidatePayloadHeader(st state.BeaconState, header interfaces.ExecutionData) error {
+	// Validate header's random mix matches with state in current epoch
+	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(header.PrevRandao(), random) {
+		return ErrInvalidPayloadPrevRandao
+	}
+
+	// Validate header's timestamp matches with state in current slot.
+	t, err := slots.ToTime(st.GenesisTime(), st.Slot())
+	if err != nil {
+		return err
+	}
+	if header.Timestamp() != uint64(t.Unix()) {
+		return ErrInvalidPayloadTimeStamp
+	}
+	return nil
+}
+
+// ProcessPayloadHeader processes the payload header.
+func ProcessPayloadHeader(st state.BeaconState, header interfaces.ExecutionData) (state.BeaconState, error) {
+	var err error
+	if st.Version() >= version.Capella {
+		st, err = ProcessWithdrawals(st, header)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not process withdrawals")
+		}
+	}
+	if err := ValidatePayloadHeaderWhenMergeCompletes(st, header); err != nil {
+		return nil, err
+	}
+	if err := ValidatePayloadHeader(st, header); err != nil {
+		return nil, err
+	}
+	if err := st.SetLatestExecutionPayloadHeader(header); err != nil {
+		return nil, err
+	}
+	return st, nil
+}
+
 // GetBlockPayloadHash returns the hash of the execution payload of the block
 func GetBlockPayloadHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
 	var payloadHash [32]byte

beacon-chain/core/blocks/payload_test.go

@@ -1,7 +1,6 @@
 package blocks_test
 
 import (
-	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/blocks"
@@ -14,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
@@ -583,18 +581,14 @@ func Test_ProcessPayload(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BeaconBlockBodyBellatrix{
-				ExecutionPayload: tt.payload,
-			})
+			wrappedPayload, err := consensusblocks.WrappedExecutionPayload(tt.payload)
 			require.NoError(t, err)
-			st, err := blocks.ProcessPayload(st, body)
+			st, err := blocks.ProcessPayload(st, wrappedPayload)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
 				require.Equal(t, tt.err, err)
-				payload, err := body.Execution()
-				require.NoError(t, err)
-				want, err := consensusblocks.PayloadToHeader(payload)
+				want, err := consensusblocks.PayloadToHeader(wrappedPayload)
 				require.Equal(t, tt.err, err)
 				h, err := st.LatestExecutionPayloadHeader()
 				require.NoError(t, err)
@@ -615,15 +609,13 @@ func Test_ProcessPayloadCapella(t *testing.T) {
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
 	payload.PrevRandao = random
-	body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BeaconBlockBodyCapella{
-		ExecutionPayload: payload,
-	})
+	wrapped, err := consensusblocks.WrappedExecutionPayloadCapella(payload)
 	require.NoError(t, err)
-	_, err = blocks.ProcessPayload(st, body)
+	_, err = blocks.ProcessPayload(st, wrapped)
 	require.NoError(t, err)
 }
 
-func Test_ProcessPayload_Blinded(t *testing.T) {
+func Test_ProcessPayloadHeader(t *testing.T) {
 	st, _ := util.DeterministicGenesisStateBellatrix(t, 1)
 	random, err := helpers.RandaoMix(st, time.CurrentEpoch(st))
 	require.NoError(t, err)
@@ -671,13 +663,7 @@ func Test_ProcessPayload_Blinded(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			p, ok := tt.header.Proto().(*enginev1.ExecutionPayloadHeader)
-			require.Equal(t, true, ok)
-			body, err := consensusblocks.NewBeaconBlockBody(&ethpb.BlindedBeaconBlockBodyBellatrix{
-				ExecutionPayloadHeader: p,
-			})
-			require.NoError(t, err)
-			st, err := blocks.ProcessPayload(st, body)
+			st, err := blocks.ProcessPayloadHeader(st, tt.header)
 			if err != nil {
 				require.Equal(t, tt.err.Error(), err.Error())
 			} else {
@@ -742,7 +728,7 @@ func Test_ValidatePayloadHeader(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err = blocks.ValidatePayload(st, tt.header)
+			err = blocks.ValidatePayloadHeader(st, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -799,7 +785,7 @@ func Test_ValidatePayloadHeaderWhenMergeCompletes(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err = blocks.ValidatePayloadWhenMergeCompletes(tt.state, tt.header)
+			err = blocks.ValidatePayloadHeaderWhenMergeCompletes(tt.state, tt.header)
 			require.Equal(t, tt.err, err)
 		})
 	}
@@ -920,15 +906,3 @@ func emptyPayloadCapella() *enginev1.ExecutionPayloadCapella {
 		Withdrawals:   make([]*enginev1.Withdrawal, 0),
 	}
 }
-
-func TestVerifyBlobCommitmentCount(t *testing.T) {
-	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
-	rb, err := consensusblocks.NewBeaconBlock(b)
-	require.NoError(t, err)
-	require.NoError(t, blocks.VerifyBlobCommitmentCount(rb.Body()))
-
-	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, fieldparams.MaxBlobsPerBlock+1)}}
-	rb, err = consensusblocks.NewBeaconBlock(b)
-	require.NoError(t, err)
-	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", fieldparams.MaxBlobsPerBlock+1), blocks.VerifyBlobCommitmentCount(rb.Body()))
-}

beacon-chain/core/electra/consolidations.go

@@ -49,7 +49,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 		return errors.New("nil state")
 	}
 
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
+	currentEpoch := slots.ToEpoch(st.Slot())
 
 	var nextPendingConsolidation uint64
 	pendingConsolidations, err := st.PendingConsolidations()
@@ -66,7 +66,7 @@ func ProcessPendingConsolidations(ctx context.Context, st state.BeaconState) err
 			nextPendingConsolidation++
 			continue
 		}
-		if sourceValidator.WithdrawableEpoch > nextEpoch {
+		if sourceValidator.WithdrawableEpoch > currentEpoch {
 			break
 		}
 

beacon-chain/core/electra/deposits.go

@@ -248,7 +248,7 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 
 	// constants
 	ffe := params.BeaconConfig().FarFutureEpoch
-	nextEpoch := slots.ToEpoch(st.Slot()) + 1
+	curEpoch := slots.ToEpoch(st.Slot())
 
 	for _, balanceDeposit := range deposits {
 		v, err := st.ValidatorAtIndexReadOnly(balanceDeposit.Index)
@@ -259,7 +259,7 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 		// If the validator is currently exiting, postpone the deposit until after the withdrawable
 		// epoch.
 		if v.ExitEpoch() < ffe {
-			if nextEpoch <= v.WithdrawableEpoch() {
+			if curEpoch <= v.WithdrawableEpoch() {
 				depositsToPostpone = append(depositsToPostpone, balanceDeposit)
 			} else {
 				// The deposited balance will never become active. Therefore, we increase the balance but do
@@ -308,6 +308,7 @@ func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState,
 	defer span.End()
 
 	if len(requests) == 0 {
+		log.Debug("ProcessDepositRequests: no deposit requests found")
 		return beaconState, nil
 	}
 

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -22,31 +22,29 @@ var (
 //
 // Spec definition:
 //
-//  def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
-//      # [Modified in Electra:EIP6110]
-//      # Disable former deposit mechanism once all prior deposits are processed
-//      eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
-//      if state.eth1_deposit_index < eth1_deposit_index_limit:
-//          assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
-//      else:
-//          assert len(body.deposits) == 0
+//	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
+//	    # [Modified in Electra:EIP6110]
+//	    # Disable former deposit mechanism once all prior deposits are processed
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
+//	    if state.eth1_deposit_index < eth1_deposit_index_limit:
+//	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
+//	    else:
+//	        assert len(body.deposits) == 0
 //
-//      def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
-//          for operation in operations:
-//              fn(state, operation)
+//	    def for_ops(operations: Sequence[Any], fn: Callable[[BeaconState, Any], None]) -> None:
+//	        for operation in operations:
+//	            fn(state, operation)
 //
-//      for_ops(body.proposer_slashings, process_proposer_slashing)
-//      for_ops(body.attester_slashings, process_attester_slashing)
-//      for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
-//      for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
-//      for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
-//      for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
-//      for_ops(body.execution_payload.deposit_requests, process_deposit_request)  # [New in Electra:EIP6110]
-//      # [New in Electra:EIP7002:EIP7251]
-//      for_ops(body.execution_payload.withdrawal_requests, process_withdrawal_request)
-//      # [New in Electra:EIP7251]
-//      for_ops(body.execution_payload.consolidation_requests, process_consolidation_request)
-
+//	    for_ops(body.proposer_slashings, process_proposer_slashing)
+//	    for_ops(body.attester_slashings, process_attester_slashing)
+//	    for_ops(body.attestations, process_attestation)  # [Modified in Electra:EIP7549]
+//	    for_ops(body.deposits, process_deposit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.voluntary_exits, process_voluntary_exit)  # [Modified in Electra:EIP7251]
+//	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
+//	    # [New in Electra:EIP7002:EIP7251]
+//	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
+//	    for_ops(body.execution_payload.deposit_requests, process_deposit_requests)  # [New in Electra:EIP6110]
+//	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
 func ProcessOperations(
 	ctx context.Context,
 	st state.BeaconState,
@@ -86,14 +84,16 @@ func ProcessOperations(
 	if !ok {
 		return nil, errors.New("could not cast execution data to electra execution data")
 	}
-	st, err = ProcessDepositRequests(ctx, st, exe.DepositRequests())
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process deposit receipts")
-	}
 	st, err = ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
 	}
+
+	st, err = ProcessDepositRequests(ctx, st, exe.DepositRequests()) // TODO: EIP-6110 deposit changes.
+	if err != nil {
+		return nil, errors.Wrap(err, "could not process deposit receipts")
+	}
+
 	if err := ProcessConsolidationRequests(ctx, st, exe.ConsolidationRequests()); err != nil {
 		return nil, fmt.Errorf("could not process consolidation requests: %w", err)
 	}

beacon-chain/core/electra/transition_test.go

@@ -1,15 +1,11 @@
 package electra_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/electra"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
@@ -51,68 +47,3 @@ func TestVerifyOperationLengths_Electra(t *testing.T) {
 		require.ErrorContains(t, "incorrect outstanding deposits in block body", err)
 	})
 }
-
-func TestProcessEpoch_CanProcessElectra(t *testing.T) {
-	st, _ := util.DeterministicGenesisStateElectra(t, params.BeaconConfig().MaxValidatorsPerCommittee)
-	require.NoError(t, st.SetSlot(10*params.BeaconConfig().SlotsPerEpoch))
-	require.NoError(t, st.SetDepositBalanceToConsume(100))
-	amountAvailForProcessing := helpers.ActivationExitChurnLimit(1_000 * 1e9)
-	deps := make([]*ethpb.PendingBalanceDeposit, 20)
-	for i := 0; i < len(deps); i += 1 {
-		deps[i] = &ethpb.PendingBalanceDeposit{
-			Amount: uint64(amountAvailForProcessing) / 10,
-			Index:  primitives.ValidatorIndex(i),
-		}
-	}
-	require.NoError(t, st.SetPendingBalanceDeposits(deps))
-	require.NoError(t, st.SetPendingConsolidations([]*ethpb.PendingConsolidation{
-		{
-			SourceIndex: 2,
-			TargetIndex: 3,
-		},
-		{
-			SourceIndex: 0,
-			TargetIndex: 1,
-		},
-	}))
-	err := electra.ProcessEpoch(context.Background(), st)
-	require.NoError(t, err)
-	require.Equal(t, uint64(0), st.Slashings()[2], "Unexpected slashed balance")
-
-	b := st.Balances()
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(b)))
-	require.Equal(t, uint64(44799839993), b[0])
-
-	s, err := st.InactivityScores()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(s)))
-
-	p, err := st.PreviousEpochParticipation()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
-
-	p, err = st.CurrentEpochParticipation()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().MaxValidatorsPerCommittee, uint64(len(p)))
-
-	sc, err := st.CurrentSyncCommittee()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
-
-	sc, err = st.NextSyncCommittee()
-	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().SyncCommitteeSize, uint64(len(sc.Pubkeys)))
-
-	res, err := st.DepositBalanceToConsume()
-	require.NoError(t, err)
-	require.Equal(t, primitives.Gwei(100), res)
-
-	// Half of the balance deposits should have been processed.
-	remaining, err := st.PendingBalanceDeposits()
-	require.NoError(t, err)
-	require.Equal(t, 10, len(remaining))
-
-	num, err := st.NumPendingConsolidations()
-	require.NoError(t, err)
-	require.Equal(t, uint64(2), num)
-}

beacon-chain/core/electra/upgrade.go

@@ -40,7 +40,6 @@ import (
 //	    excess_blob_gas=pre.latest_execution_payload_header.excess_blob_gas,
 //	    deposit_requests_root=Root(),  # [New in Electra:EIP6110]
 //	    withdrawal_requests_root=Root(),  # [New in Electra:EIP7002],
-//	    consolidation_requests_root=Root(),  # [New in Electra:EIP7251]
 //	)
 //
 //	exit_epochs = [v.exit_epoch for v in pre.validators if v.exit_epoch != FAR_FUTURE_EPOCH]

beacon-chain/core/epoch/BUILD.bazel

@@ -22,6 +22,7 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//math:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
@@ -52,6 +53,7 @@ go_test(
         "//testing/util:go_default_library",
         "@com_github_google_go_cmp//cmp:go_default_library",
         "@com_github_google_gofuzz//:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )

beacon-chain/core/epoch/epoch_processing.go

@@ -20,9 +20,32 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/math"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 )
 
+// AttestingBalance returns the total balance from all the attesting indices.
+//
+// WARNING: This method allocates a new copy of the attesting validator indices set and is
+// considered to be very memory expensive. Avoid using this unless you really
+// need to get attesting balance from attestations.
+//
+// Spec pseudocode definition:
+//
+//	def get_attesting_balance(state: BeaconState, attestations: Sequence[PendingAttestation]) -> Gwei:
+//	  """
+//	  Return the combined effective balance of the set of unslashed validators participating in ``attestations``.
+//	  Note: ``get_total_balance`` returns ``EFFECTIVE_BALANCE_INCREMENT`` Gwei minimum to avoid divisions by zero.
+//	  """
+//	  return get_total_balance(state, get_unslashed_attesting_indices(state, attestations))
+func AttestingBalance(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) (uint64, error) {
+	indices, err := UnslashedAttestingIndices(ctx, state, atts)
+	if err != nil {
+		return 0, errors.Wrap(err, "could not get attesting indices")
+	}
+	return helpers.TotalBalance(state, indices), nil
+}
+
 // ProcessRegistryUpdates rotates validators in and out of active pool.
 // the amount to rotate is determined churn limit.
 //
@@ -432,3 +455,51 @@ func ProcessFinalUpdates(state state.BeaconState) (state.BeaconState, error) {
 
 	return state, nil
 }
+
+// UnslashedAttestingIndices returns all the attesting indices from a list of attestations,
+// it sorts the indices and filters out the slashed ones.
+//
+// Spec pseudocode definition:
+//
+//	def get_unslashed_attesting_indices(state: BeaconState,
+//	                                  attestations: Sequence[PendingAttestation]) -> Set[ValidatorIndex]:
+//	  output = set()  # type: Set[ValidatorIndex]
+//	  for a in attestations:
+//	      output = output.union(get_attesting_indices(state, a.data, a.aggregation_bits))
+//	  return set(filter(lambda index: not state.validators[index].slashed, output))
+func UnslashedAttestingIndices(ctx context.Context, state state.ReadOnlyBeaconState, atts []*ethpb.PendingAttestation) ([]primitives.ValidatorIndex, error) {
+	var setIndices []primitives.ValidatorIndex
+	seen := make(map[uint64]bool)
+
+	for _, att := range atts {
+		committee, err := helpers.BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
+		if err != nil {
+			return nil, err
+		}
+		attestingIndices, err := attestation.AttestingIndices(att, committee)
+		if err != nil {
+			return nil, err
+		}
+		// Create a set for attesting indices
+		for _, index := range attestingIndices {
+			if !seen[index] {
+				setIndices = append(setIndices, primitives.ValidatorIndex(index))
+			}
+			seen[index] = true
+		}
+	}
+	// Sort the attesting set indices by increasing order.
+	sort.Slice(setIndices, func(i, j int) bool { return setIndices[i] < setIndices[j] })
+	// Remove the slashed validator indices.
+	for i := 0; i < len(setIndices); i++ {
+		v, err := state.ValidatorAtIndexReadOnly(setIndices[i])
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to look up validator")
+		}
+		if !v.IsNil() && v.Slashed() {
+			setIndices = append(setIndices[:i], setIndices[i+1:]...)
+		}
+	}
+
+	return setIndices, nil
+}

beacon-chain/core/epoch/epoch_processing_test.go

@@ -6,6 +6,7 @@ import (
 	"math"
 	"testing"
 
+	"github.com/prysmaticlabs/go-bitfield"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
@@ -23,6 +24,131 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
+func TestUnslashedAttestingIndices_CanSortAndFilter(t *testing.T) {
+	// Generate 2 attestations.
+	atts := make([]*ethpb.PendingAttestation, 2)
+	for i := 0; i < len(atts); i++ {
+		atts[i] = &ethpb.PendingAttestation{
+			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
+				Target: &ethpb.Checkpoint{Epoch: 0, Root: make([]byte, fieldparams.RootLength)},
+			},
+			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
+		}
+	}
+
+	// Generate validators and state for the 2 attestations.
+	validatorCount := 1000
+	validators := make([]*ethpb.Validator, validatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+	base := &ethpb.BeaconState{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	}
+	beaconState, err := state_native.InitializeFromProtoPhase0(base)
+	require.NoError(t, err)
+
+	indices, err := epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
+	require.NoError(t, err)
+	for i := 0; i < len(indices)-1; i++ {
+		if indices[i] >= indices[i+1] {
+			t.Error("sorted indices not sorted or duplicated")
+		}
+	}
+
+	// Verify the slashed validator is filtered.
+	slashedValidator := indices[0]
+	validators = beaconState.Validators()
+	validators[slashedValidator].Slashed = true
+	require.NoError(t, beaconState.SetValidators(validators))
+	indices, err = epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
+	require.NoError(t, err)
+	for i := 0; i < len(indices); i++ {
+		assert.NotEqual(t, slashedValidator, indices[i], "Slashed validator %d is not filtered", slashedValidator)
+	}
+}
+
+func TestUnslashedAttestingIndices_DuplicatedAttestations(t *testing.T) {
+	// Generate 5 of the same attestations.
+	atts := make([]*ethpb.PendingAttestation, 5)
+	for i := 0; i < len(atts); i++ {
+		atts[i] = &ethpb.PendingAttestation{
+			Data: &ethpb.AttestationData{Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
+				Target: &ethpb.Checkpoint{Epoch: 0}},
+			AggregationBits: bitfield.Bitlist{0x00, 0xFF, 0xFF, 0xFF},
+		}
+	}
+
+	// Generate validators and state for the 5 attestations.
+	validatorCount := 1000
+	validators := make([]*ethpb.Validator, validatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch: params.BeaconConfig().FarFutureEpoch,
+		}
+	}
+	base := &ethpb.BeaconState{
+		Validators:  validators,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+	}
+	beaconState, err := state_native.InitializeFromProtoPhase0(base)
+	require.NoError(t, err)
+
+	indices, err := epoch.UnslashedAttestingIndices(context.Background(), beaconState, atts)
+	require.NoError(t, err)
+
+	for i := 0; i < len(indices)-1; i++ {
+		if indices[i] >= indices[i+1] {
+			t.Error("sorted indices not sorted or duplicated")
+		}
+	}
+}
+
+func TestAttestingBalance_CorrectBalance(t *testing.T) {
+	helpers.ClearCache()
+	// Generate 2 attestations.
+	atts := make([]*ethpb.PendingAttestation, 2)
+	for i := 0; i < len(atts); i++ {
+		atts[i] = &ethpb.PendingAttestation{
+			Data: &ethpb.AttestationData{
+				Target: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
+				Source: &ethpb.Checkpoint{Root: make([]byte, fieldparams.RootLength)},
+				Slot:   primitives.Slot(i),
+			},
+			AggregationBits: bitfield.Bitlist{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+				0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x01},
+		}
+	}
+
+	// Generate validators with balances and state for the 2 attestations.
+	validators := make([]*ethpb.Validator, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	balances := make([]uint64, params.BeaconConfig().MinGenesisActiveValidatorCount)
+	for i := 0; i < len(validators); i++ {
+		validators[i] = &ethpb.Validator{
+			ExitEpoch:        params.BeaconConfig().FarFutureEpoch,
+			EffectiveBalance: params.BeaconConfig().MaxEffectiveBalance,
+		}
+		balances[i] = params.BeaconConfig().MaxEffectiveBalance
+	}
+	base := &ethpb.BeaconState{
+		Slot:        2,
+		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
+
+		Validators: validators,
+		Balances:   balances,
+	}
+	beaconState, err := state_native.InitializeFromProtoPhase0(base)
+	require.NoError(t, err)
+
+	balance, err := epoch.AttestingBalance(context.Background(), beaconState, atts)
+	require.NoError(t, err)
+	wanted := 256 * params.BeaconConfig().MaxEffectiveBalance
+	assert.Equal(t, wanted, balance)
+}
+
 func TestProcessSlashings_NotSlashed(t *testing.T) {
 	base := &ethpb.BeaconState{
 		Slot:       0,

beacon-chain/core/epoch/precompute/BUILD.bazel

@@ -24,7 +24,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//runtime/version:go_default_library",
@@ -48,6 +47,7 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//beacon-chain/core/altair:go_default_library",
+        "//beacon-chain/core/epoch:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/state:go_default_library",

beacon-chain/core/epoch/precompute/attestation.go

@@ -11,10 +11,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/attestation"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"go.opencensus.io/trace"
 )
 
 // ProcessAttestations process the attestations in state and update individual validator's pre computes,

beacon-chain/core/epoch/precompute/reward_penalty_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/epoch"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
@@ -58,6 +59,90 @@ func TestProcessRewardsAndPenaltiesPrecompute(t *testing.T) {
 	assert.Equal(t, wanted, beaconState.Balances()[0], "Unexpected balance")
 }
 
+func TestAttestationDeltaPrecompute(t *testing.T) {
+	e := params.BeaconConfig().SlotsPerEpoch
+	validatorCount := uint64(2048)
+	base := buildState(e+2, validatorCount)
+	atts := make([]*ethpb.PendingAttestation, 3)
+	var emptyRoot [32]byte
+	for i := 0; i < len(atts); i++ {
+		atts[i] = &ethpb.PendingAttestation{
+			Data: &ethpb.AttestationData{
+				Target: &ethpb.Checkpoint{
+					Root: emptyRoot[:],
+				},
+				Source: &ethpb.Checkpoint{
+					Root: emptyRoot[:],
+				},
+				BeaconBlockRoot: emptyRoot[:],
+			},
+			AggregationBits: bitfield.Bitlist{0xC0, 0xC0, 0xC0, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x01},
+			InclusionDelay:  1,
+		}
+	}
+	base.PreviousEpochAttestations = atts
+	beaconState, err := state_native.InitializeFromProtoPhase0(base)
+	require.NoError(t, err)
+	slashedAttestedIndices := []primitives.ValidatorIndex{1413}
+	for _, i := range slashedAttestedIndices {
+		vs := beaconState.Validators()
+		vs[i].Slashed = true
+		require.Equal(t, nil, beaconState.SetValidators(vs))
+	}
+
+	vp, bp, err := New(context.Background(), beaconState)
+	require.NoError(t, err)
+	vp, bp, err = ProcessAttestations(context.Background(), beaconState, vp, bp)
+	require.NoError(t, err)
+
+	// Add some variances to target and head balances.
+	// See: https://github.com/prysmaticlabs/prysm/issues/5593
+	bp.PrevEpochTargetAttested /= 2
+	bp.PrevEpochHeadAttested = bp.PrevEpochHeadAttested * 2 / 3
+	rewards, penalties, err := AttestationsDelta(beaconState, bp, vp)
+	require.NoError(t, err)
+	attestedBalance, err := epoch.AttestingBalance(context.Background(), beaconState, atts)
+	require.NoError(t, err)
+	totalBalance, err := helpers.TotalActiveBalance(beaconState)
+	require.NoError(t, err)
+
+	attestedIndices := []primitives.ValidatorIndex{55, 1339, 1746, 1811, 1569}
+	for _, i := range attestedIndices {
+		base, err := baseReward(beaconState, i)
+		require.NoError(t, err, "Could not get base reward")
+
+		// Base rewards for getting source right
+		wanted := attestedBalance*base/totalBalance +
+			bp.PrevEpochTargetAttested*base/totalBalance +
+			bp.PrevEpochHeadAttested*base/totalBalance
+		// Base rewards for proposer and attesters working together getting attestation
+		// on chain in the fatest manner
+		proposerReward := base / params.BeaconConfig().ProposerRewardQuotient
+		wanted += (base-proposerReward)*uint64(params.BeaconConfig().MinAttestationInclusionDelay) - 1
+		assert.Equal(t, wanted, rewards[i], "Unexpected reward balance for validator with index %d", i)
+		// Since all these validators attested, they shouldn't get penalized.
+		assert.Equal(t, uint64(0), penalties[i], "Unexpected penalty balance")
+	}
+
+	for _, i := range slashedAttestedIndices {
+		base, err := baseReward(beaconState, i)
+		assert.NoError(t, err, "Could not get base reward")
+		assert.Equal(t, uint64(0), rewards[i], "Unexpected slashed indices reward balance")
+		assert.Equal(t, 3*base, penalties[i], "Unexpected slashed indices penalty balance")
+	}
+
+	nonAttestedIndices := []primitives.ValidatorIndex{434, 677, 872, 791}
+	for _, i := range nonAttestedIndices {
+		base, err := baseReward(beaconState, i)
+		assert.NoError(t, err, "Could not get base reward")
+		wanted := 3 * base
+		// Since all these validators did not attest, they shouldn't get rewarded.
+		assert.Equal(t, uint64(0), rewards[i], "Unexpected reward balance")
+		// Base penalties for not attesting.
+		assert.Equal(t, wanted, penalties[i], "Unexpected penalty balance")
+	}
+}
+
 func TestAttestationDeltas_ZeroEpoch(t *testing.T) {
 	e := params.BeaconConfig().SlotsPerEpoch
 	validatorCount := uint64(2048)

beacon-chain/core/epoch/precompute/type.go

@@ -24,7 +24,7 @@ type Validator struct {
 	IsPrevEpochSourceAttester bool
 	// IsPrevEpochTargetAttester is true if the validator attested previous epoch target.
 	IsPrevEpochTargetAttester bool
-	// IsPrevEpochHeadAttester is true if the validator attested the previous epoch head.
+	// IsHeadAttester is true if the validator attested head.
 	IsPrevEpochHeadAttester bool
 
 	// CurrentEpochEffectiveBalance is how much effective balance this validator has current epoch.

beacon-chain/core/helpers/BUILD.bazel

@@ -33,7 +33,6 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//math:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
@@ -43,6 +42,7 @@ go_library(
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@io_opencensus_go//trace:go_default_library",
     ],
 )
 

beacon-chain/core/helpers/beacon_committee.go

@@ -82,47 +82,6 @@ func AttestationCommittees(ctx context.Context, st state.ReadOnlyBeaconState, at
 	return committees, nil
 }
 
-// BeaconCommittees returns the list of all beacon committees for a given state at a given slot.
-func BeaconCommittees(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) ([][]primitives.ValidatorIndex, error) {
-	epoch := slots.ToEpoch(slot)
-	activeCount, err := ActiveValidatorCount(ctx, state, epoch)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not compute active validator count")
-	}
-	committeesPerSlot := SlotCommitteeCount(activeCount)
-	seed, err := Seed(state, epoch, params.BeaconConfig().DomainBeaconAttester)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get seed")
-	}
-
-	committees := make([][]primitives.ValidatorIndex, committeesPerSlot)
-	var activeIndices []primitives.ValidatorIndex
-
-	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
-		committee, err := committeeCache.Committee(ctx, slot, seed, idx)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not interface with committee cache")
-		}
-		if committee != nil {
-			committees[idx] = committee
-			continue
-		}
-
-		if len(activeIndices) == 0 {
-			activeIndices, err = ActiveValidatorIndices(ctx, state, epoch)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not get active indices")
-			}
-		}
-		committee, err = BeaconCommittee(ctx, activeIndices, seed, slot, idx)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute beacon committee")
-		}
-		committees[idx] = committee
-	}
-	return committees, nil
-}
-
 // BeaconCommitteeFromState returns the crosslink committee of a given slot and committee index. This
 // is a spec implementation where state is used as an argument. In case of state retrieval
 // becomes expensive, consider using BeaconCommittee below.
@@ -294,22 +253,36 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	if err := verifyAssignmentEpoch(epoch, state); err != nil {
 		return nil, err
 	}
+
+	// Retrieve active validator count for the specified epoch.
+	activeValidatorCount, err := ActiveValidatorCount(ctx, state, epoch)
+	if err != nil {
+		return nil, err
+	}
+
+	// Determine the number of committees per slot based on the number of active validator indices.
+	numCommitteesPerSlot := SlotCommitteeCount(activeValidatorCount)
+
 	startSlot, err := slots.EpochStart(epoch)
 	if err != nil {
 		return nil, err
 	}
+
+	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
 	vals := make(map[primitives.ValidatorIndex]struct{})
 	for _, v := range validators {
 		vals[v] = struct{}{}
 	}
-	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment)
+
 	// Compute committee assignments for each slot in the epoch.
 	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
-		committees, err := BeaconCommittees(ctx, state, slot)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not compute beacon committees")
-		}
-		for j, committee := range committees {
+		// Compute committees for the current slot.
+		for j := uint64(0); j < numCommitteesPerSlot; j++ {
+			committee, err := BeaconCommitteeFromState(ctx, state, slot, primitives.CommitteeIndex(j))
+			if err != nil {
+				return nil, err
+			}
+
 			for _, vIndex := range committee {
 				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
 					continue
@@ -323,6 +296,7 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 			}
 		}
 	}
+
 	return assignments, nil
 }
 
@@ -337,6 +311,24 @@ func VerifyBitfieldLength(bf bitfield.Bitfield, committeeSize uint64) error {
 	return nil
 }
 
+// VerifyAttestationBitfieldLengths verifies that an attestations aggregation bitfields is
+// a valid length matching the size of the committee.
+func VerifyAttestationBitfieldLengths(ctx context.Context, state state.ReadOnlyBeaconState, att ethpb.Att) error {
+	committee, err := BeaconCommitteeFromState(ctx, state, att.GetData().Slot, att.GetData().CommitteeIndex)
+	if err != nil {
+		return errors.Wrap(err, "could not retrieve beacon committees")
+	}
+
+	if committee == nil {
+		return errors.New("no committee exist for this attestation")
+	}
+
+	if err := VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee))); err != nil {
+		return errors.Wrap(err, "failed to verify aggregation bitfield")
+	}
+	return nil
+}
+
 // ShuffledIndices uses input beacon state and returns the shuffled indices of the input epoch,
 // the shuffled indices then can be used to break up into committees.
 func ShuffledIndices(s state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]primitives.ValidatorIndex, error) {

beacon-chain/core/helpers/beacon_committee_test.go

@@ -18,7 +18,6 @@ import (
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
 
@@ -403,12 +402,7 @@ func TestVerifyAttestationBitfieldLengths_OK(t *testing.T) {
 		helpers.ClearCache()
 
 		require.NoError(t, state.SetSlot(tt.stateSlot))
-		att := tt.attestation
-		// Verify attesting indices are correct.
-		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, att.GetData().Slot, att.GetData().CommitteeIndex)
-		require.NoError(t, err)
-		require.NotNil(t, committee)
-		err = helpers.VerifyBitfieldLength(att.GetAggregationBits(), uint64(len(committee)))
+		err := helpers.VerifyAttestationBitfieldLengths(context.Background(), state, tt.attestation)
 		if tt.verificationFailure {
 			assert.NotNil(t, err, "Verification succeeded when it was supposed to fail")
 		} else {
@@ -755,27 +749,3 @@ func TestAttestationCommittees(t *testing.T) {
 		assert.Equal(t, params.BeaconConfig().TargetCommitteeSize, uint64(len(committees[1])))
 	})
 }
-
-func TestBeaconCommittees(t *testing.T) {
-	prevConfig := params.BeaconConfig().Copy()
-	defer params.OverrideBeaconConfig(prevConfig)
-	c := params.BeaconConfig().Copy()
-	c.MinGenesisActiveValidatorCount = 128
-	c.SlotsPerEpoch = 4
-	c.TargetCommitteeSize = 16
-	params.OverrideBeaconConfig(c)
-
-	state, _ := util.DeterministicGenesisState(t, 256)
-
-	activeCount, err := helpers.ActiveValidatorCount(context.Background(), state, 0)
-	require.NoError(t, err)
-	committeesPerSlot := helpers.SlotCommitteeCount(activeCount)
-	committees, err := helpers.BeaconCommittees(context.Background(), state, 0)
-	require.NoError(t, err)
-	require.Equal(t, committeesPerSlot, uint64(len(committees)))
-	for idx := primitives.CommitteeIndex(0); idx < primitives.CommitteeIndex(len(committees)); idx++ {
-		committee, err := helpers.BeaconCommitteeFromState(context.Background(), state, 0, idx)
-		require.NoError(t, err)
-		require.DeepEqual(t, committees[idx], committee)
-	}
-}

beacon-chain/core/helpers/sync_committee_test.go

@@ -78,7 +78,6 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) {
 
 func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	helpers.ClearCache()
-	params.SetupTestConfigCleanup(t)
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)
 	syncCommittee := &ethpb.SyncCommittee{
@@ -265,7 +264,6 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 }
 
 func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)

beacon-chain/core/helpers/validators.go

@@ -16,11 +16,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	log "github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
 )
 
 var (

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

@@ -1,31 +0,0 @@
-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_test.go

@@ -1,54 +0,0 @@
-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/core/peerdas/BUILD.bazel

@@ -2,11 +2,7 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
     name = "go_default_library",
-    srcs = [
-        "helpers.go",
-        "log.go",
-        "metrics.go",
-    ],
+    srcs = ["helpers.go"],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas",
     visibility = ["//visibility:public"],
     deps = [
@@ -23,10 +19,6 @@ go_library(
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus:go_default_library",
-        "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-        "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )
 
@@ -36,16 +28,11 @@ go_test(
     deps = [
         ":go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
-        "//config/fieldparams:go_default_library",
-        "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/core/peerdas/helpers.go

@@ -1,24 +1,18 @@
 package peerdas
 
 import (
-	"context"
 	"encoding/binary"
-	"fmt"
 	"math"
 	"math/big"
-	"slices"
-	"time"
 
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/sync/errgroup"
 
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/holiman/uint256"
 	errors "github.com/pkg/errors"
 
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
+	kzg "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
 
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -118,7 +112,6 @@ func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool
 // DataColumnSidecars computes the data column sidecars from the signed block and blobs.
 // https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix
 func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs []kzg.Blob) ([]*ethpb.DataColumnSidecar, error) {
-	startTime := time.Now()
 	blobsCount := len(blobs)
 	if blobsCount == 0 {
 		return nil, nil
@@ -147,24 +140,16 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs
 	}
 
 	// Compute cells and proofs.
-	cellsAndProofs := make([]kzg.CellsAndProofs, blobsCount)
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobsCount)
 
-	eg, _ := errgroup.WithContext(context.Background())
 	for i := range blobs {
-		blobIndex := i
-		eg.Go(func() error {
-			blob := &blobs[blobIndex]
-			blobCellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(blob)
-			if err != nil {
-				return errors.Wrap(err, "compute cells and KZG proofs")
-			}
+		blob := &blobs[i]
+		blobCellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(blob)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute cells and KZG proofs")
+		}
 
-			cellsAndProofs[blobIndex] = blobCellsAndProofs
-			return nil
-		})
-	}
-	if err := eg.Wait(); err != nil {
-		return nil, err
+		cellsAndProofs = append(cellsAndProofs, blobCellsAndProofs)
 	}
 
 	// Get the column sidecars.
@@ -206,147 +191,10 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs
 
 		sidecars = append(sidecars, sidecar)
 	}
-	dataColumnComputationTime.Observe(float64(time.Since(startTime).Milliseconds()))
+
 	return sidecars, nil
 }
 
-// populateAndFilterIndices returns a sorted slices of indices, setting all indices if none are provided,
-// and filtering out indices higher than the blob count.
-func populateAndFilterIndices(indices map[uint64]bool, blobCount uint64) []uint64 {
-	// If no indices are provided, provide all blobs.
-	if len(indices) == 0 {
-		for i := range blobCount {
-			indices[i] = true
-		}
-	}
-
-	// Filter blobs index higher than the blob count.
-	filteredIndices := make(map[uint64]bool, len(indices))
-	for i := range indices {
-		if i < blobCount {
-			filteredIndices[i] = true
-		}
-	}
-
-	// Transform set to slice.
-	indicesSlice := make([]uint64, 0, len(filteredIndices))
-	for i := range filteredIndices {
-		indicesSlice = append(indicesSlice, i)
-	}
-
-	// Sort the indices.
-	slices.Sort[[]uint64](indicesSlice)
-
-	return indicesSlice
-}
-
-// Blobs extract blobs from `dataColumnsSidecar`.
-// This can be seen as the reciprocal function of DataColumnSidecars.
-// `dataColumnsSidecar` needs to contain the datacolumns corresponding to the non-extended matrix,
-// else an error will be returned.
-// (`dataColumnsSidecar` can contain extra columns, but they will be ignored.)
-func Blobs(indices map[uint64]bool, dataColumnsSidecar []*ethpb.DataColumnSidecar) ([]*blocks.VerifiedROBlob, error) {
-	columnCount := fieldparams.NumberOfColumns
-
-	neededColumnCount := columnCount / 2
-
-	// Check if all needed columns are present.
-	sliceIndexFromColumnIndex := make(map[uint64]int, len(dataColumnsSidecar))
-	for i := range dataColumnsSidecar {
-		dataColumnSideCar := dataColumnsSidecar[i]
-		columnIndex := dataColumnSideCar.ColumnIndex
-
-		if columnIndex < uint64(neededColumnCount) {
-			sliceIndexFromColumnIndex[columnIndex] = i
-		}
-	}
-
-	actualColumnCount := len(sliceIndexFromColumnIndex)
-
-	// Get missing columns.
-	if actualColumnCount < neededColumnCount {
-		missingColumns := make(map[int]bool, neededColumnCount-actualColumnCount)
-		for i := range neededColumnCount {
-			if _, ok := sliceIndexFromColumnIndex[uint64(i)]; !ok {
-				missingColumns[i] = true
-			}
-		}
-
-		missingColumnsSlice := make([]int, 0, len(missingColumns))
-		for i := range missingColumns {
-			missingColumnsSlice = append(missingColumnsSlice, i)
-		}
-
-		slices.Sort[[]int](missingColumnsSlice)
-		return nil, errors.Errorf("some columns are missing: %v", missingColumnsSlice)
-	}
-
-	// It is safe to retrieve the first column since we already checked that `dataColumnsSidecar` is not empty.
-	firstDataColumnSidecar := dataColumnsSidecar[0]
-
-	blobCount := uint64(len(firstDataColumnSidecar.DataColumn))
-
-	// Check all colums have te same length.
-	for i := range dataColumnsSidecar {
-		if uint64(len(dataColumnsSidecar[i].DataColumn)) != blobCount {
-			return nil, errors.Errorf("mismatch in the length of the data columns, expected %d, got %d", blobCount, len(dataColumnsSidecar[i].DataColumn))
-		}
-	}
-
-	// Reconstruct verified RO blobs from columns.
-	verifiedROBlobs := make([]*blocks.VerifiedROBlob, 0, blobCount)
-
-	// Populate and filter indices.
-	indicesSlice := populateAndFilterIndices(indices, blobCount)
-
-	for _, blobIndex := range indicesSlice {
-		var blob kzg.Blob
-
-		// Compute the content of the blob.
-		for columnIndex := range neededColumnCount {
-			sliceIndex, ok := sliceIndexFromColumnIndex[uint64(columnIndex)]
-			if !ok {
-				return nil, errors.Errorf("missing column %d, this should never happen", columnIndex)
-			}
-
-			dataColumnSideCar := dataColumnsSidecar[sliceIndex]
-			cell := dataColumnSideCar.DataColumn[blobIndex]
-
-			for i := 0; i < len(cell); i++ {
-				blob[columnIndex*kzg.BytesPerCell+i] = cell[i]
-			}
-		}
-
-		// Retrieve the blob KZG commitment.
-		blobKZGCommitment := kzg.Commitment(firstDataColumnSidecar.KzgCommitments[blobIndex])
-
-		// Compute the blob KZG proof.
-		blobKzgProof, err := kzg.ComputeBlobKZGProof(&blob, blobKZGCommitment)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute blob KZG proof")
-		}
-
-		blobSidecar := &ethpb.BlobSidecar{
-			Index:                    blobIndex,
-			Blob:                     blob[:],
-			KzgCommitment:            blobKZGCommitment[:],
-			KzgProof:                 blobKzgProof[:],
-			SignedBlockHeader:        firstDataColumnSidecar.SignedBlockHeader,
-			CommitmentInclusionProof: firstDataColumnSidecar.KzgCommitmentsInclusionProof,
-		}
-
-		roBlob, err := blocks.NewROBlob(blobSidecar)
-		if err != nil {
-			return nil, errors.Wrap(err, "new RO blob")
-		}
-
-		verifiedROBlob := blocks.NewVerifiedROBlob(roBlob)
-		verifiedROBlobs = append(verifiedROBlobs, &verifiedROBlob)
-	}
-
-	return verifiedROBlobs, nil
-}
-
 // DataColumnSidecarsForReconstruct is a TEMPORARY function until there is an official specification for it.
 // It is scheduled for deletion.
 func DataColumnSidecarsForReconstruct(
@@ -407,7 +255,7 @@ func DataColumnSidecarsForReconstruct(
 
 // VerifyDataColumnSidecarKZGProofs verifies the provided KZG Proofs for the particular
 // data column.
-func VerifyDataColumnSidecarKZGProofs(sc blocks.RODataColumn) (bool, error) {
+func VerifyDataColumnSidecarKZGProofs(sc *ethpb.DataColumnSidecar) (bool, error) {
 	if sc.ColumnIndex >= params.BeaconConfig().NumberOfColumns {
 		return false, errIndexTooLarge
 	}
@@ -431,37 +279,11 @@ func VerifyDataColumnSidecarKZGProofs(sc blocks.RODataColumn) (bool, error) {
 
 // CustodySubnetCount returns the number of subnets the node should participate in for custody.
 func CustodySubnetCount() uint64 {
+	count := params.BeaconConfig().CustodyRequirement
 	if flags.Get().SubscribeToAllSubnets {
-		return params.BeaconConfig().DataColumnSidecarSubnetCount
+		count = params.BeaconConfig().DataColumnSidecarSubnetCount
 	}
-
-	return params.BeaconConfig().CustodyRequirement
-}
-
-// SubnetSamplingSize returns the number of subnets the node should sample from.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#subnet-sampling
-func SubnetSamplingSize() uint64 {
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
-	custodySubnetCount := CustodySubnetCount()
-
-	return max(samplesPerSlot, custodySubnetCount)
-}
-
-// CustodyColumnCount returns the number of columns the node should custody.
-func CustodyColumnCount() uint64 {
-	// Get the number of subnets.
-	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
-
-	// Compute the number of columns per subnet.
-	columnsPerSubnet := fieldparams.NumberOfColumns / dataColumnSidecarSubnetCount
-
-	// Get the number of subnets we custody
-	custodySubnetCount := CustodySubnetCount()
-
-	// Finally, compute the number of columns we should custody.
-	custodyColumnCount := custodySubnetCount * columnsPerSubnet
-
-	return custodyColumnCount
+	return count
 }
 
 // HypergeomCDF computes the hypergeometric cumulative distribution function.
@@ -535,72 +357,3 @@ func CanSelfReconstruct(numCol uint64) bool {
 	columnsNeeded := total/2 + total%2
 	return numCol >= columnsNeeded
 }
-
-// RecoverCellsAndProofs recovers the cells and proofs from the data column sidecars.
-func RecoverCellsAndProofs(
-	dataColumnSideCars []*ethpb.DataColumnSidecar,
-	blockRoot [fieldparams.RootLength]byte,
-) ([]kzg.CellsAndProofs, error) {
-	var wg errgroup.Group
-
-	dataColumnSideCarsCount := len(dataColumnSideCars)
-
-	if dataColumnSideCarsCount == 0 {
-		return nil, errors.New("no data column sidecars")
-	}
-
-	// Check if all columns have the same length.
-	blobCount := len(dataColumnSideCars[0].DataColumn)
-	for _, sidecar := range dataColumnSideCars {
-		length := len(sidecar.DataColumn)
-
-		if length != blobCount {
-			return nil, errors.New("columns do not have the same length")
-		}
-	}
-
-	// Recover cells and compute proofs in parallel.
-	recoveredCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
-
-	for blobIndex := 0; blobIndex < blobCount; blobIndex++ {
-		bIndex := blobIndex
-		wg.Go(func() error {
-			start := time.Now()
-
-			cellsIndices := make([]uint64, 0, dataColumnSideCarsCount)
-			cells := make([]kzg.Cell, 0, dataColumnSideCarsCount)
-
-			for _, sidecar := range dataColumnSideCars {
-				// Build the cell indices.
-				cellsIndices = append(cellsIndices, sidecar.ColumnIndex)
-
-				// Get the cell.
-				column := sidecar.DataColumn
-				cell := column[bIndex]
-
-				cells = append(cells, kzg.Cell(cell))
-			}
-
-			// Recover the cells and proofs for the corresponding blob
-			cellsAndProofs, err := kzg.RecoverCellsAndKZGProofs(cellsIndices, cells)
-
-			if err != nil {
-				return errors.Wrapf(err, "recover cells and KZG proofs for blob %d", bIndex)
-			}
-
-			recoveredCellsAndProofs[bIndex] = cellsAndProofs
-			log.WithFields(logrus.Fields{
-				"elapsed": time.Since(start),
-				"index":   bIndex,
-				"root":    fmt.Sprintf("%x", blockRoot),
-			}).Debug("Recovered cells and proofs")
-			return nil
-		})
-	}
-
-	if err := wg.Wait(); err != nil {
-		return nil, err
-	}
-
-	return recoveredCellsAndProofs, nil
-}

beacon-chain/core/peerdas/helpers_test.go

@@ -4,20 +4,14 @@ import (
 	"bytes"
 	"crypto/sha256"
 	"encoding/binary"
-	"errors"
 	"fmt"
 	"testing"
 
 	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 	"github.com/sirupsen/logrus"
@@ -56,12 +50,12 @@ func GetRandBlob(seed int64) kzg.Blob {
 	return blob
 }
 
-func GenerateCommitmentAndProof(blob *kzg.Blob) (*kzg.Commitment, *kzg.Proof, error) {
-	commitment, err := kzg.BlobToKZGCommitment(blob)
+func GenerateCommitmentAndProof(blob kzg.Blob) (*kzg.Commitment, *kzg.Proof, error) {
+	commitment, err := kzg.BlobToKZGCommitment(&blob)
 	if err != nil {
 		return nil, nil, err
 	}
-	proof, err := kzg.ComputeBlobKZGProof(blob, commitment)
+	proof, err := kzg.ComputeBlobKZGProof(&blob, commitment)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -78,7 +72,7 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	)
 	for i := int64(0); i < 6; i++ {
 		blob := GetRandBlob(i)
-		commitment, _, err := GenerateCommitmentAndProof(&blob)
+		commitment, _, err := GenerateCommitmentAndProof(blob)
 		require.NoError(t, err)
 		comms = append(comms, commitment[:])
 		blobs = append(blobs, blob)
@@ -91,200 +85,12 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	require.NoError(t, err)
 
 	for i, sidecar := range sCars {
-		roCol, err := blocks.NewRODataColumn(sidecar)
-		require.NoError(t, err)
-		verified, err := peerdas.VerifyDataColumnSidecarKZGProofs(roCol)
+		verified, err := peerdas.VerifyDataColumnSidecarKZGProofs(sidecar)
 		require.NoError(t, err)
 		require.Equal(t, true, verified, fmt.Sprintf("sidecar %d failed", i))
 	}
 }
 
-func TestDataColumnSidecars(t *testing.T) {
-	var expected []*ethpb.DataColumnSidecar = nil
-	actual, err := peerdas.DataColumnSidecars(nil, []kzg.Blob{})
-	require.NoError(t, err)
-
-	require.DeepSSZEqual(t, expected, actual)
-}
-
-func TestBlobs(t *testing.T) {
-	blobsIndice := map[uint64]bool{}
-
-	almostAllColumns := make([]*ethpb.DataColumnSidecar, 0, fieldparams.NumberOfColumns/2)
-	for i := 2; i < fieldparams.NumberOfColumns/2+2; i++ {
-		almostAllColumns = append(almostAllColumns, &ethpb.DataColumnSidecar{
-			ColumnIndex: uint64(i),
-		})
-	}
-
-	testCases := []struct {
-		name     string
-		input    []*ethpb.DataColumnSidecar
-		expected []*blocks.VerifiedROBlob
-		err      error
-	}{
-		{
-			name:     "empty input",
-			input:    []*ethpb.DataColumnSidecar{},
-			expected: nil,
-			err:      errors.New("some columns are missing: [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63]"),
-		},
-		{
-			name:     "missing columns",
-			input:    almostAllColumns,
-			expected: nil,
-			err:      errors.New("some columns are missing: [0 1]"),
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			actual, err := peerdas.Blobs(blobsIndice, tc.input)
-			if tc.err != nil {
-				require.Equal(t, tc.err.Error(), err.Error())
-			} else {
-				require.NoError(t, err)
-			}
-			require.DeepSSZEqual(t, tc.expected, actual)
-		})
-	}
-}
-
-func TestDataColumnsSidecarsBlobsRoundtrip(t *testing.T) {
-	const blobCount = 5
-	blobsIndex := map[uint64]bool{}
-
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	// Create a protobuf signed beacon block.
-	signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-
-	// Generate random blobs and their corresponding commitments and proofs.
-	blobs := make([]kzg.Blob, 0, blobCount)
-	blobKzgCommitments := make([]*kzg.Commitment, 0, blobCount)
-	blobKzgProofs := make([]*kzg.Proof, 0, blobCount)
-
-	for blobIndex := range blobCount {
-		// Create a random blob.
-		blob := GetRandBlob(int64(blobIndex))
-		blobs = append(blobs, blob)
-
-		// Generate a blobKZGCommitment for the blob.
-		blobKZGCommitment, proof, err := GenerateCommitmentAndProof(&blob)
-		require.NoError(t, err)
-
-		blobKzgCommitments = append(blobKzgCommitments, blobKZGCommitment)
-		blobKzgProofs = append(blobKzgProofs, proof)
-	}
-
-	// Set the commitments into the block.
-	blobZkgCommitmentsBytes := make([][]byte, 0, blobCount)
-	for _, blobKZGCommitment := range blobKzgCommitments {
-		blobZkgCommitmentsBytes = append(blobZkgCommitmentsBytes, blobKZGCommitment[:])
-	}
-
-	signedBeaconBlockPb.Block.Body.BlobKzgCommitments = blobZkgCommitmentsBytes
-
-	// Generate verified RO blobs.
-	verifiedROBlobs := make([]*blocks.VerifiedROBlob, 0, blobCount)
-
-	// Create a signed beacon block from the protobuf.
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-	require.NoError(t, err)
-
-	commitmentInclusionProof, err := blocks.MerkleProofKZGCommitments(signedBeaconBlock.Block().Body())
-	require.NoError(t, err)
-
-	for blobIndex := range blobCount {
-		blob := blobs[blobIndex]
-		blobKZGCommitment := blobKzgCommitments[blobIndex]
-		blobKzgProof := blobKzgProofs[blobIndex]
-
-		// Get the signed beacon block header.
-		signedBeaconBlockHeader, err := signedBeaconBlock.Header()
-		require.NoError(t, err)
-
-		blobSidecar := &ethpb.BlobSidecar{
-			Index:                    uint64(blobIndex),
-			Blob:                     blob[:],
-			KzgCommitment:            blobKZGCommitment[:],
-			KzgProof:                 blobKzgProof[:],
-			SignedBlockHeader:        signedBeaconBlockHeader,
-			CommitmentInclusionProof: commitmentInclusionProof,
-		}
-
-		roBlob, err := blocks.NewROBlob(blobSidecar)
-		require.NoError(t, err)
-
-		verifiedROBlob := blocks.NewVerifiedROBlob(roBlob)
-		verifiedROBlobs = append(verifiedROBlobs, &verifiedROBlob)
-	}
-
-	// Compute data columns sidecars from the signed beacon block and from the blobs.
-	dataColumnsSidecar, err := peerdas.DataColumnSidecars(signedBeaconBlock, blobs)
-	require.NoError(t, err)
-
-	// Compute the blobs from the data columns sidecar.
-	roundtripBlobs, err := peerdas.Blobs(blobsIndex, dataColumnsSidecar)
-	require.NoError(t, err)
-
-	// Check that the blobs are the same.
-	require.DeepSSZEqual(t, verifiedROBlobs, roundtripBlobs)
-}
-
-func TestCustodySubnetCount(t *testing.T) {
-	testCases := []struct {
-		name                  string
-		subscribeToAllSubnets bool
-		expected              uint64
-	}{
-		{
-			name:                  "subscribeToAllSubnets=false",
-			subscribeToAllSubnets: false,
-			expected:              params.BeaconConfig().CustodyRequirement,
-		},
-		{
-			name:                  "subscribeToAllSubnets=true",
-			subscribeToAllSubnets: true,
-			expected:              params.BeaconConfig().DataColumnSidecarSubnetCount,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Set flags.
-			resetFlags := flags.Get()
-			defer func() {
-				flags.Init(resetFlags)
-			}()
-
-			params.SetupTestConfigCleanup(t)
-			gFlags := new(flags.GlobalFlags)
-			gFlags.SubscribeToAllSubnets = tc.subscribeToAllSubnets
-			flags.Init(gFlags)
-
-			// Get the custody subnet count.
-			actual := peerdas.CustodySubnetCount()
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}
-
-func TestCustodyColumnCount(t *testing.T) {
-	const expected uint64 = 8
-
-	params.SetupTestConfigCleanup(t)
-	config := params.BeaconConfig().Copy()
-	config.DataColumnSidecarSubnetCount = 32
-	config.CustodyRequirement = 2
-	params.OverrideBeaconConfig(config)
-
-	actual := peerdas.CustodyColumnCount()
-	require.Equal(t, expected, actual)
-}
-
 func TestHypergeomCDF(t *testing.T) {
 	// Test case from https://en.wikipedia.org/wiki/Hypergeometric_distribution
 	// Population size: 1000, number of successes in population: 500, sample size: 10, number of successes in sample: 5
@@ -336,209 +142,3 @@ func TestExtendedSampleCount(t *testing.T) {
 		})
 	}
 }
-
-func TestCustodyCountFromRecord(t *testing.T) {
-	const expected uint64 = 7
-
-	// Create an Ethereum record.
-	record := &enr.Record{}
-	record.Set(peerdas.Csc(expected))
-
-	actual, err := peerdas.CustodyCountFromRecord(record)
-	require.NoError(t, err)
-	require.Equal(t, expected, actual)
-}
-
-func TestCanSelfReconstruct(t *testing.T) {
-	testCases := []struct {
-		name                   string
-		totalNumberOfColumns   uint64
-		custodyNumberOfColumns uint64
-		expected               bool
-	}{
-		{
-			name:                   "totalNumberOfColumns=64, custodyNumberOfColumns=31",
-			totalNumberOfColumns:   64,
-			custodyNumberOfColumns: 31,
-			expected:               false,
-		},
-		{
-			name:                   "totalNumberOfColumns=64, custodyNumberOfColumns=32",
-			totalNumberOfColumns:   64,
-			custodyNumberOfColumns: 32,
-			expected:               true,
-		},
-		{
-			name:                   "totalNumberOfColumns=65, custodyNumberOfColumns=32",
-			totalNumberOfColumns:   65,
-			custodyNumberOfColumns: 32,
-			expected:               false,
-		},
-		{
-			name:                   "totalNumberOfColumns=63, custodyNumberOfColumns=33",
-			totalNumberOfColumns:   65,
-			custodyNumberOfColumns: 33,
-			expected:               true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Set the total number of columns.
-			params.SetupTestConfigCleanup(t)
-			cfg := params.BeaconConfig().Copy()
-			cfg.NumberOfColumns = tc.totalNumberOfColumns
-			params.OverrideBeaconConfig(cfg)
-
-			// Check if reconstuction is possible.
-			actual := peerdas.CanSelfReconstruct(tc.custodyNumberOfColumns)
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}
-
-func TestReconstructionRoundTrip(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-
-	const blobCount = 5
-
-	var blockRoot [fieldparams.RootLength]byte
-
-	signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-	require.NoError(t, kzg.Start())
-
-	// Generate random blobs and their corresponding commitments.
-	var (
-		blobsKzgCommitments [][]byte
-		blobs               []kzg.Blob
-	)
-	for i := range blobCount {
-		blob := GetRandBlob(int64(i))
-		commitment, _, err := GenerateCommitmentAndProof(&blob)
-		require.NoError(t, err)
-
-		blobsKzgCommitments = append(blobsKzgCommitments, commitment[:])
-		blobs = append(blobs, blob)
-	}
-
-	// Generate a signed beacon block.
-	signedBeaconBlockPb.Block.Body.BlobKzgCommitments = blobsKzgCommitments
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-	require.NoError(t, err)
-
-	// Get the signed beacon block header.
-	signedBeaconBlockHeader, err := signedBeaconBlock.Header()
-	require.NoError(t, err)
-
-	// Convert data columns sidecars from signed block and blobs.
-	dataColumnSidecars, err := peerdas.DataColumnSidecars(signedBeaconBlock, blobs)
-	require.NoError(t, err)
-
-	// Create verified RO data columns.
-	verifiedRoDataColumns := make([]*blocks.VerifiedRODataColumn, 0, blobCount)
-	for _, dataColumnSidecar := range dataColumnSidecars {
-		roDataColumn, err := blocks.NewRODataColumn(dataColumnSidecar)
-		require.NoError(t, err)
-
-		verifiedRoDataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
-		verifiedRoDataColumns = append(verifiedRoDataColumns, &verifiedRoDataColumn)
-	}
-
-	verifiedRoDataColumn := verifiedRoDataColumns[0]
-
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	var noDataColumns []*ethpb.DataColumnSidecar
-	dataColumnsWithDifferentLengths := []*ethpb.DataColumnSidecar{
-		{DataColumn: [][]byte{{}, {}}},
-		{DataColumn: [][]byte{{}}},
-	}
-	notEnoughDataColumns := dataColumnSidecars[:numberOfColumns/2-1]
-	originalDataColumns := dataColumnSidecars[:numberOfColumns/2]
-	extendedDataColumns := dataColumnSidecars[numberOfColumns/2:]
-	evenDataColumns := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns/2)
-	oddDataColumns := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns/2)
-	allDataColumns := dataColumnSidecars
-
-	for i, dataColumn := range dataColumnSidecars {
-		if i%2 == 0 {
-			evenDataColumns = append(evenDataColumns, dataColumn)
-		} else {
-			oddDataColumns = append(oddDataColumns, dataColumn)
-		}
-	}
-
-	testCases := []struct {
-		name               string
-		dataColumnsSidecar []*ethpb.DataColumnSidecar
-		isError            bool
-	}{
-		{
-			name:               "No data columns sidecars",
-			dataColumnsSidecar: noDataColumns,
-			isError:            true,
-		},
-		{
-			name:               "Data columns sidecar with different lengths",
-			dataColumnsSidecar: dataColumnsWithDifferentLengths,
-			isError:            true,
-		},
-		{
-			name:               "All columns are present (no actual need to reconstruct)",
-			dataColumnsSidecar: allDataColumns,
-			isError:            false,
-		},
-		{
-			name:               "Only original columns are present",
-			dataColumnsSidecar: originalDataColumns,
-			isError:            false,
-		},
-		{
-			name:               "Only extended columns are present",
-			dataColumnsSidecar: extendedDataColumns,
-			isError:            false,
-		},
-		{
-			name:               "Only even columns are present",
-			dataColumnsSidecar: evenDataColumns,
-			isError:            false,
-		},
-		{
-			name:               "Only odd columns are present",
-			dataColumnsSidecar: oddDataColumns,
-			isError:            false,
-		},
-		{
-			name:               "Not enough columns to reconstruct",
-			dataColumnsSidecar: notEnoughDataColumns,
-			isError:            true,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Recover cells and proofs from available data columns sidecars.
-			cellsAndProofs, err := peerdas.RecoverCellsAndProofs(tc.dataColumnsSidecar, blockRoot)
-			isError := (err != nil)
-			require.Equal(t, tc.isError, isError)
-
-			if isError {
-				return
-			}
-
-			// Recover all data columns sidecars from cells and proofs.
-			reconstructedDataColumnsSideCars, err := peerdas.DataColumnSidecarsForReconstruct(
-				blobsKzgCommitments,
-				signedBeaconBlockHeader,
-				verifiedRoDataColumn.KzgCommitmentsInclusionProof,
-				cellsAndProofs,
-			)
-
-			require.NoError(t, err)
-
-			expected := dataColumnSidecars
-			actual := reconstructedDataColumnsSideCars
-			require.DeepSSZEqual(t, expected, actual)
-		})
-	}
-}

beacon-chain/core/peerdas/log.go

@@ -1,5 +0,0 @@
-package peerdas
-
-import "github.com/sirupsen/logrus"
-
-var log = logrus.WithField("prefix", "peerdas")

beacon-chain/core/peerdas/metrics.go

@@ -1,14 +0,0 @@
-package peerdas
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var dataColumnComputationTime = promauto.NewHistogram(
-	prometheus.HistogramOpts{
-		Name:    "data_column_sidecar_computation_milliseconds",
-		Help:    "Captures the time taken to compute data column sidecars from blobs.",
-		Buckets: []float64{100, 250, 500, 750, 1000, 1500, 2000, 4000, 8000, 12000, 16000},
-	},
-)

beacon-chain/core/transition/BUILD.bazel

@@ -41,7 +41,6 @@ go_library(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",

beacon-chain/core/transition/altair_transition_no_verify_sig_test.go

@@ -70,7 +70,7 @@ func TestExecuteAltairStateTransitionNoVerify_FullProcess(t *testing.T) {
 	}
 	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
-	h := beaconState.LatestBlockHeader().Copy()
+	h := ethpb.CopyBeaconBlockHeader(beaconState.LatestBlockHeader())
 	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]
@@ -157,7 +157,7 @@ func TestExecuteAltairStateTransitionNoVerifySignature_CouldNotVerifyStateRoot(t
 	}
 	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
-	h := beaconState.LatestBlockHeader().Copy()
+	h := ethpb.CopyBeaconBlockHeader(beaconState.LatestBlockHeader())
 	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]

beacon-chain/core/transition/bellatrix_transition_no_verify_sig_test.go

@@ -72,7 +72,7 @@ func TestExecuteBellatrixStateTransitionNoVerify_FullProcess(t *testing.T) {
 	}
 	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
-	h := beaconState.LatestBlockHeader().Copy()
+	h := ethpb.CopyBeaconBlockHeader(beaconState.LatestBlockHeader())
 	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]
@@ -159,7 +159,7 @@ func TestExecuteBellatrixStateTransitionNoVerifySignature_CouldNotVerifyStateRoo
 	}
 	indices, err := altair.NextSyncCommitteeIndices(context.Background(), beaconState)
 	require.NoError(t, err)
-	h := beaconState.LatestBlockHeader().Copy()
+	h := ethpb.CopyBeaconBlockHeader(beaconState.LatestBlockHeader())
 	prevStateRoot, err := beaconState.HashTreeRoot(context.Background())
 	require.NoError(t, err)
 	h.StateRoot = prevStateRoot[:]

beacon-chain/core/transition/transition.go

@@ -25,13 +25,10 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	goTrace "go.opencensus.io/trace"
+	"go.opencensus.io/trace"
 )
 
-type customProcessingFn func(context.Context, state.BeaconState) error
-
 // ExecuteStateTransition defines the procedure for a state transition function.
 //
 // Note: This method differs from the spec pseudocode as it uses a batch signature verification.
@@ -176,7 +173,18 @@ func ProcessSlotsIfPossible(ctx context.Context, state state.BeaconState, target
 	return state, nil
 }
 
-// ProcessSlots includes core slot processing as well as a cache
+// ProcessSlots process through skip slots and apply epoch transition when it's needed
+//
+// Spec pseudocode definition:
+//
+//	def process_slots(state: BeaconState, slot: Slot) -> None:
+//	  assert state.slot < slot
+//	  while state.slot < slot:
+//	      process_slot(state)
+//	      # Process epoch on the start slot of the next epoch
+//	      if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
+//	          process_epoch(state)
+//	      state.slot = Slot(state.slot + 1)
 func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.Slot) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.ProcessSlots")
 	defer span.End()
@@ -223,63 +231,42 @@ func ProcessSlots(ctx context.Context, state state.BeaconState, slot primitives.
 	defer func() {
 		SkipSlotCache.MarkNotInProgress(key)
 	}()
-	state, err = ProcessSlotsCore(ctx, span, state, slot, cacheBestBeaconStateOnErrFn(highestSlot, key))
-	if err != nil {
-		return nil, err
-	}
-	if highestSlot < state.Slot() {
-		SkipSlotCache.Put(ctx, key, state)
-	}
 
-	return state, nil
-}
-
-func cacheBestBeaconStateOnErrFn(highestSlot primitives.Slot, key [32]byte) customProcessingFn {
-	return func(ctx context.Context, state state.BeaconState) error {
+	for state.Slot() < slot {
 		if ctx.Err() != nil {
+			tracing.AnnotateError(span, ctx.Err())
 			// Cache last best value.
 			if highestSlot < state.Slot() {
-				SkipSlotCache.Put(ctx, key, state)
-			}
-			return ctx.Err()
-		}
-		return nil
-	}
-}
-
-// ProcessSlotsCore process through skip slots and apply epoch transition when it's needed
-//
-// Spec pseudocode definition:
-//
-//	def process_slots(state: BeaconState, slot: Slot) -> None:
-//	  assert state.slot < slot
-//	  while state.slot < slot:
-//	      process_slot(state)
-//	      # Process epoch on the start slot of the next epoch
-//	      if (state.slot + 1) % SLOTS_PER_EPOCH == 0:
-//	          process_epoch(state)
-//	      state.slot = Slot(state.slot + 1)
-func ProcessSlotsCore(ctx context.Context, span *goTrace.Span, state state.BeaconState, slot primitives.Slot, fn customProcessingFn) (state.BeaconState, error) {
-	var err error
-	for state.Slot() < slot {
-		if fn != nil {
-			if err = fn(ctx, state); err != nil {
-				tracing.AnnotateError(span, err)
-				return nil, err
+				if SkipSlotCache.Put(ctx, key, state); err != nil {
+					log.WithError(err).Error("Failed to put skip slot cache value")
+				}
 			}
+			return nil, ctx.Err()
 		}
 		state, err = ProcessSlot(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, errors.Wrap(err, "could not process slot")
 		}
-
-		state, err = ProcessEpoch(ctx, state)
-		if err != nil {
-			tracing.AnnotateError(span, err)
-			return nil, err
+		if time.CanProcessEpoch(state) {
+			if state.Version() == version.Phase0 {
+				state, err = ProcessEpochPrecompute(ctx, state)
+				if err != nil {
+					tracing.AnnotateError(span, err)
+					return nil, errors.Wrap(err, "could not process epoch with optimizations")
+				}
+			} else if state.Version() <= version.Deneb {
+				if err = altair.ProcessEpoch(ctx, state); err != nil {
+					tracing.AnnotateError(span, err)
+					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
+				}
+			} else {
+				if err = electra.ProcessEpoch(ctx, state); err != nil {
+					tracing.AnnotateError(span, err)
+					return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
+				}
+			}
 		}
-
 		if err := state.SetSlot(state.Slot() + 1); err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, errors.Wrap(err, "failed to increment state slot")
@@ -291,46 +278,25 @@ func ProcessSlotsCore(ctx context.Context, span *goTrace.Span, state state.Beaco
 			return nil, errors.Wrap(err, "failed to upgrade state")
 		}
 	}
-	return state, nil
-}
 
-// ProcessEpoch is a wrapper on fork specific epoch processing
-func ProcessEpoch(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	var err error
-	if time.CanProcessEpoch(state) {
-		if state.Version() == version.Electra {
-			if err = electra.ProcessEpoch(ctx, state); err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
-			}
-		} else if state.Version() >= version.Altair {
-			if err = altair.ProcessEpoch(ctx, state); err != nil {
-				return nil, errors.Wrap(err, fmt.Sprintf("could not process %s epoch", version.String(state.Version())))
-			}
-		} else {
-			state, err = ProcessEpochPrecompute(ctx, state)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not process epoch with optimizations")
-			}
-		}
+	if highestSlot < state.Slot() {
+		SkipSlotCache.Put(ctx, key, state)
 	}
-	return state, err
+
+	return state, nil
 }
 
 // UpgradeState upgrades the state to the next version if possible.
 func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "core.state.UpgradeState")
 	defer span.End()
-
 	var err error
-	upgraded := false
-
 	if time.CanUpgradeToAltair(state.Slot()) {
 		state, err = altair.UpgradeToAltair(ctx, state)
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
-		upgraded = true
 	}
 
 	if time.CanUpgradeToBellatrix(state.Slot()) {
@@ -339,7 +305,6 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
-		upgraded = true
 	}
 
 	if time.CanUpgradeToCapella(state.Slot()) {
@@ -348,7 +313,6 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
-		upgraded = true
 	}
 
 	if time.CanUpgradeToDeneb(state.Slot()) {
@@ -357,7 +321,6 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
-		upgraded = true
 	}
 
 	if time.CanUpgradeToElectra(state.Slot()) {
@@ -366,13 +329,7 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 			tracing.AnnotateError(span, err)
 			return nil, err
 		}
-		upgraded = true
 	}
-
-	if upgraded {
-		log.Debugf("upgraded state to %s", version.String(state.Version()))
-	}
-
 	return state, nil
 }
 

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -12,12 +12,13 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition/interop"
 	v "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/validators"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/crypto/bls"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+	"go.opencensus.io/trace"
 )
 
 // ExecuteStateTransitionNoVerifyAnySig defines the procedure for a state transition function.
@@ -327,18 +328,20 @@ func ProcessBlockForStateRoot(
 		if err != nil {
 			return nil, err
 		}
-		if state.Version() >= version.Capella {
-			state, err = b.ProcessWithdrawals(state, executionData)
-			if err != nil {
-				return nil, errors.Wrap(err, "could not process withdrawals")
-			}
+		if blk.IsBlinded() {
+			state, err = b.ProcessPayloadHeader(state, executionData)
+		} else {
+			state, err = b.ProcessPayload(state, executionData)
 		}
-		state, err = b.ProcessPayload(state, blk.Body())
 		if err != nil {
 			return nil, errors.Wrap(err, "could not process execution data")
 		}
 	}
 
+	if err := VerifyBlobCommitmentCount(blk); err != nil {
+		return nil, err
+	}
+
 	randaoReveal := signed.Block().Body().RandaoReveal()
 	state, err = b.ProcessRandaoNoVerify(state, randaoReveal[:])
 	if err != nil {
@@ -374,6 +377,20 @@ func ProcessBlockForStateRoot(
 	return state, nil
 }
 
+func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
+	if blk.Version() < version.Deneb {
+		return nil
+	}
+	kzgs, err := blk.Body().BlobKzgCommitments()
+	if err != nil {
+		return err
+	}
+	if len(kzgs) > field_params.MaxBlobsPerBlock {
+		return fmt.Errorf("too many kzg commitments in block: %d", len(kzgs))
+	}
+	return nil
+}
+
 // This calls altair block operations.
 func altairOperations(
 	ctx context.Context,

beacon-chain/core/transition/transition_no_verify_sig_test.go

@@ -2,11 +2,13 @@ package transition_test
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
+	field_params "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -210,3 +212,15 @@ func TestProcessBlockDifferentVersion(t *testing.T) {
 	_, _, err = transition.ProcessBlockNoVerifyAnySig(context.Background(), beaconState, wsb)
 	require.ErrorContains(t, "state and block are different version. 0 != 1", err)
 }
+
+func TestVerifyBlobCommitmentCount(t *testing.T) {
+	b := &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{}}
+	rb, err := blocks.NewBeaconBlock(b)
+	require.NoError(t, err)
+	require.NoError(t, transition.VerifyBlobCommitmentCount(rb))
+
+	b = &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{BlobKzgCommitments: make([][]byte, field_params.MaxBlobsPerBlock+1)}}
+	rb, err = blocks.NewBeaconBlock(b)
+	require.NoError(t, err)
+	require.ErrorContains(t, fmt.Sprintf("too many kzg commitments in block: %d", field_params.MaxBlobsPerBlock+1), transition.VerifyBlobCommitmentCount(rb))
+}

beacon-chain/das/availability_columns.go

@@ -39,9 +39,8 @@ func NewLazilyPersistentStoreColumn(store *filesystem.BlobStorage, verifier Colu
 	}
 }
 
-// Persist do nothing at the moment.
 // TODO: Very Ugly, change interface to allow for columns and blobs
-func (*LazilyPersistentStoreColumn) Persist(_ primitives.Slot, _ ...blocks.ROBlob) error {
+func (s *LazilyPersistentStoreColumn) Persist(current primitives.Slot, sc ...blocks.ROBlob) error {
 	return nil
 }
 
@@ -101,7 +100,7 @@ func (s *LazilyPersistentStoreColumn) IsDataAvailable(ctx context.Context, curre
 	// Verify we have all the expected sidecars, and fail fast if any are missing or inconsistent.
 	// We don't try to salvage problematic batches because this indicates a misbehaving peer and we'd rather
 	// ignore their response and decrease their peer score.
-	sidecars, err := entry.filterColumns(root, &blockCommitments)
+	sidecars, err := entry.filterColumns(root, blockCommitments)
 	if err != nil {
 		return errors.Wrap(err, "incomplete BlobSidecar batch")
 	}

beacon-chain/das/cache.go

@@ -134,7 +134,7 @@ func (e *cacheEntry) filter(root [32]byte, kc safeCommitmentArray) ([]blocks.ROB
 	return scs, nil
 }
 
-func (e *cacheEntry) filterColumns(root [32]byte, kc *safeCommitmentsArray) ([]blocks.RODataColumn, error) {
+func (e *cacheEntry) filterColumns(root [32]byte, kc safeCommitmentsArray) ([]blocks.RODataColumn, error) {
 	if e.diskSummary.AllAvailable(kc.count()) {
 		return nil, nil
 	}
@@ -178,7 +178,7 @@ func (s safeCommitmentArray) count() int {
 
 type safeCommitmentsArray [fieldparams.NumberOfColumns][][]byte
 
-func (s *safeCommitmentsArray) count() int {
+func (s safeCommitmentsArray) count() int {
 	for i := range s {
 		if s[i] == nil {
 			return i

beacon-chain/db/filesystem/blob.go

@@ -326,12 +326,10 @@ func (bs *BlobStorage) SaveDataColumn(column blocks.VerifiedRODataColumn) error
 	partialMoved = true
 
 	// Notify the data column notifier that a new data column has been saved.
-	if bs.DataColumnFeed != nil {
-		bs.DataColumnFeed.Send(RootIndexPair{
-			Root:  column.BlockRoot(),
-			Index: column.ColumnIndex,
-		})
-	}
+	bs.DataColumnFeed.Send(RootIndexPair{
+		Root:  column.BlockRoot(),
+		Index: column.ColumnIndex,
+	})
 
 	// TODO: Use new metrics for data columns
 	blobsWrittenCounter.Inc()

beacon-chain/db/filesystem/cache.go

@@ -26,15 +26,6 @@ func (s BlobStorageSummary) HasIndex(idx uint64) bool {
 	return s.mask[idx]
 }
 
-// HasDataColumnIndex true if the DataColumnSidecar at the given index is available in the filesystem.
-func (s BlobStorageSummary) HasDataColumnIndex(idx uint64) bool {
-	// Protect from panic, but assume callers are sophisticated enough to not need an error telling them they have an invalid idx.
-	if idx >= fieldparams.NumberOfColumns {
-		return false
-	}
-	return s.mask[idx]
-}
-
 // AllAvailable returns true if we have all blobs for all indices from 0 to count-1.
 func (s BlobStorageSummary) AllAvailable(count int) bool {
 	if count > fieldparams.MaxBlobsPerBlock {
@@ -48,21 +39,6 @@ func (s BlobStorageSummary) AllAvailable(count int) bool {
 	return true
 }
 
-// AllDataColumnsAvailable returns true if we have all datacolumns for corresponding indices.
-func (s BlobStorageSummary) AllDataColumnsAvailable(indices map[uint64]bool) bool {
-	if uint64(len(indices)) > fieldparams.NumberOfColumns {
-		return false
-	}
-
-	for indice := range indices {
-		if !s.mask[indice] {
-			return false
-		}
-	}
-
-	return true
-}
-
 // BlobStorageSummarizer can be used to receive a summary of metadata about blobs on disk for a given root.
 // The BlobStorageSummary can be used to check which indices (if any) are available for a given block by root.
 type BlobStorageSummarizer interface {

beacon-chain/db/filesystem/cache_test.go

@@ -149,108 +149,3 @@ func TestAllAvailable(t *testing.T) {
 		})
 	}
 }
-
-func TestHasDataColumnIndex(t *testing.T) {
-	storedIndices := map[uint64]bool{
-		1: true,
-		3: true,
-		5: true,
-	}
-
-	cases := []struct {
-		name     string
-		idx      uint64
-		expected bool
-	}{
-		{
-			name:     "index is too high",
-			idx:      fieldparams.NumberOfColumns,
-			expected: false,
-		},
-		{
-			name:     "non existing index",
-			idx:      2,
-			expected: false,
-		},
-		{
-			name:     "existing index",
-			idx:      3,
-			expected: true,
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			var mask blobIndexMask
-
-			for idx := range storedIndices {
-				mask[idx] = true
-			}
-
-			sum := BlobStorageSummary{mask: mask}
-			require.Equal(t, c.expected, sum.HasDataColumnIndex(c.idx))
-		})
-	}
-}
-
-func TestAllDataColumnAvailable(t *testing.T) {
-	tooManyColumns := make(map[uint64]bool, fieldparams.NumberOfColumns+1)
-	for i := uint64(0); i < fieldparams.NumberOfColumns+1; i++ {
-		tooManyColumns[i] = true
-	}
-
-	columns346 := map[uint64]bool{
-		3: true,
-		4: true,
-		6: true,
-	}
-
-	columns36 := map[uint64]bool{
-		3: true,
-		6: true,
-	}
-
-	cases := []struct {
-		name          string
-		storedIndices map[uint64]bool
-		testedIndices map[uint64]bool
-		expected      bool
-	}{
-		{
-			name:          "no tested indices",
-			storedIndices: columns346,
-			testedIndices: map[uint64]bool{},
-			expected:      true,
-		},
-		{
-			name:          "too many tested indices",
-			storedIndices: columns346,
-			testedIndices: tooManyColumns,
-			expected:      false,
-		},
-		{
-			name:          "not all tested indices are stored",
-			storedIndices: columns36,
-			testedIndices: columns346,
-			expected:      false,
-		},
-		{
-			name:          "all tested indices are stored",
-			storedIndices: columns346,
-			testedIndices: columns36,
-			expected:      true,
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			var mask blobIndexMask
-
-			for idx := range c.storedIndices {
-				mask[idx] = true
-			}
-
-			sum := BlobStorageSummary{mask: mask}
-			require.Equal(t, c.expected, sum.AllDataColumnsAvailable(c.testedIndices))
-		})
-	}
-}

beacon-chain/db/iface/BUILD.bazel

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

beacon-chain/db/iface/interface.go

@@ -7,8 +7,6 @@ import (
 	"context"
 	"io"
 
-	ethpbv2 "github.com/prysmaticlabs/prysm/v5/proto/eth/v2"
-
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filters"
 	slashertypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/slasher/types"
@@ -58,9 +56,6 @@ 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)
@@ -97,8 +92,6 @@ 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,7 +16,6 @@ go_library(
         "genesis.go",
         "key.go",
         "kv.go",
-        "lightclient.go",
         "log.go",
         "migration.go",
         "migration_archived_index.go",
@@ -51,9 +50,7 @@ go_library(
         "//io/file:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
-        "//monitoring/tracing/trace:go_default_library",
         "//proto/dbval:go_default_library",
-        "//proto/eth/v2:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//time:go_default_library",
@@ -90,7 +87,6 @@ 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",
@@ -117,7 +113,6 @@ 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/backup.go

@@ -8,8 +8,8 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 const backupsDirectoryName = "backups"

beacon-chain/db/kv/blocks.go

@@ -16,11 +16,11 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/container/slice"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 // Used to represent errors for inconsistent slot ranges.

beacon-chain/db/kv/checkpoint.go

@@ -8,9 +8,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 var errMissingStateForCheckpoint = errors.New("missing state summary for checkpoint root")

beacon-chain/db/kv/execution_chain.go

@@ -5,9 +5,9 @@ import (
 	"errors"
 
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	v2 "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 	"google.golang.org/protobuf/proto"
 )
 

beacon-chain/db/kv/finalized_block_roots.go

@@ -10,9 +10,9 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
-	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing/trace"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	bolt "go.etcd.io/bbolt"
+	"go.opencensus.io/trace"
 )
 
 var previousFinalizedCheckpointKey = []byte("previous-finalized-checkpoint")

beacon-chain/db/kv/kv.go

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

beacon-chain/db/kv/lightclient.go

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

@@ -1,648 +0,0 @@
-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))
-
-}