implement eip-7928 as a gloas fork without eip-7732

.bazelrc

@@ -34,7 +34,6 @@ build:minimal --@io_bazel_rules_go//go/config:tags=minimal
 build:release --compilation_mode=opt
 build:release --stamp
 build:release --define pgo_enabled=1
-build:release --strip=always
 
 # Build binary with cgo symbolizer for debugging / profiling.
 build:cgo_symbolizer --copt=-g

.github/actions/gomodtidy/Dockerfile

@@ -1,4 +1,4 @@
-FROM golang:1.25.1-alpine
+FROM golang:1.24-alpine
 
 COPY entrypoint.sh /entrypoint.sh
 

.github/workflows/changelog.yml

@@ -9,7 +9,7 @@ on:
 
 jobs:
   run-changelog-check:
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout source code
         uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0

.github/workflows/check-specrefs.yml

@@ -3,7 +3,7 @@ on: [push, pull_request]
 
 jobs:
   check-specrefs:
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
 
     steps:
     - name: Checkout repository

.github/workflows/clang-format.yml

@@ -10,7 +10,7 @@ on:
 
 jobs:
   clang-format-checking:
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       # Is this step failing for you? 

.github/workflows/fuzz.yml

@@ -10,13 +10,13 @@ permissions:
 
 jobs:
   list:
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     timeout-minutes: 180
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.25.1'
+          go-version: '1.23.5'
       - id: list
         uses: shogo82148/actions-go-fuzz/list@v0
         with:
@@ -25,7 +25,7 @@ jobs:
       fuzz-tests: ${{steps.list.outputs.fuzz-tests}}
 
   fuzz:
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     timeout-minutes: 360
     needs: list
     strategy:
@@ -36,7 +36,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-go@v4
         with:
-          go-version: '1.25.1'
+          go-version: '1.23.5'
       - uses: shogo82148/actions-go-fuzz/run@v0
         with:
           packages: ${{ matrix.package }}

.github/workflows/go.yml

@@ -11,7 +11,7 @@ on:
 jobs:
   formatting:
     name: Formatting
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -22,7 +22,7 @@ jobs:
 
   gosec:
     name: Gosec scan
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     env:
       GO111MODULE: on
     steps:
@@ -31,7 +31,7 @@ jobs:
       - name: Set up Go 1.24
         uses: actions/setup-go@v4
         with:
-          go-version: '1.25.1'
+          go-version: '1.24.0'
       - name: Run Gosec Security Scanner
         run: | # https://github.com/securego/gosec/issues/469
           export PATH=$PATH:$(go env GOPATH)/bin
@@ -40,31 +40,31 @@ jobs:
 
   lint:
     name: Lint
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
 
-      - name: Set up Go 1.25.1
-        uses: actions/setup-go@v5
+      - name: Set up Go 1.24
+        uses: actions/setup-go@v4
         with:
-          go-version: '1.25.1'
+          go-version: '1.24.0'
+          id: go
 
       - name: Golangci-lint
-        uses: golangci/golangci-lint-action@v8
+        uses: golangci/golangci-lint-action@v5
         with:
-          version: v2.4
+          version: v1.64.5
+          args: --config=.golangci.yml --out-${NO_FUTURE}format colored-line-number
 
   build:
     name: Build
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     steps:
-      - name: Set up Go 1.25.1
+      - name: Set up Go 1.x
         uses: actions/setup-go@v4
         with:
-          go-version: '1.25.1'
+          go-version: '1.24.0'
         id: go
 
       - name: Check out code into the Go module directory

.github/workflows/horusec.yaml

@@ -8,7 +8,7 @@ on:
 jobs:
   Horusec_Scan:
     name: horusec-Scan
-    runs-on: ubuntu-4
+    runs-on: ubuntu-latest
     if: github.ref == 'refs/heads/develop'
     steps:
     - name: Check out code
@@ -19,4 +19,4 @@ jobs:
     - name: Running Security Scan
       run: |
         curl -fsSL https://raw.githubusercontent.com/ZupIT/horusec/main/deployments/scripts/install.sh | bash -s latest
-        horusec start -t="10000" -p="./" -e="true" -i="**/crypto/bls/herumi/**, **/**/*_test.go, **/third_party/afl/**, **/crypto/keystore/key.go"
+        horusec start -t="10000" -p="./" -e="true" -i="**/crypto/bls/herumi/**, **/**/*_test.go, **/third_party/afl/**, **/crypto/keystore/key.go"

.golangci.yml

@@ -1,41 +1,90 @@
-version: "2"
 run:
-  go: 1.23.5
-linters:
-  enable:
-    - errcheck
-    - ineffassign
-    - govet
-  disable:
-    - staticcheck
-    - unused
-  exclusions:
-    generated: lax
-    presets:
-      - comments
-      - common-false-positives
-      - legacy
-      - std-error-handling
-    paths:
-      - validator/web/site_data.go
-      - .*_test.go
-      - proto
-      - tools/analyzers
-      - third_party$
-      - builtin$
-      - examples$
+  timeout: 10m
+  go: '1.23.5'
 
-formatters:
-  enable:
-    - gofmt
-    - goimports
-  exclusions:
-    generated: lax
-    paths:
-      - validator/web/site_data.go
-      - .*_test.go
-      - proto
-      - tools/analyzers
-      - third_party$
-      - builtin$
-      - examples$
+issues:
+  exclude-files:
+    - validator/web/site_data.go
+    - .*_test.go
+  exclude-dirs:
+    - proto
+    - tools/analyzers
+
+linters:
+  enable-all: true
+  disable:
+    # Deprecated linters:
+    - govet
+
+    # Disabled for now:
+    - asasalint
+    - bodyclose
+    - containedctx
+    - contextcheck
+    - cyclop
+    - depguard
+    - dogsled
+    - dupl
+    - durationcheck
+    - errname
+    - err113
+    - exhaustive
+    - exhaustruct
+    - forbidigo
+    - forcetypeassert
+    - funlen
+    - gci
+    - gochecknoglobals
+    - gochecknoinits
+    - goconst
+    - gocritic
+    - gocyclo
+    - godot
+    - godox
+    - gofumpt
+    - gomoddirectives
+    - gosec
+    - inamedparam
+    - interfacebloat
+    - intrange
+    - ireturn
+    - lll
+    - maintidx
+    - makezero
+    - mnd
+    - musttag
+    - nakedret
+    - nestif
+    - nilnil
+    - nlreturn
+    - noctx
+    - nolintlint
+    - nonamedreturns
+    - nosprintfhostport
+    - perfsprint
+    - prealloc
+    - predeclared
+    - promlinter
+    - protogetter
+    - recvcheck
+    - revive
+    - spancheck
+    - staticcheck
+    - stylecheck
+    - tagalign
+    - tagliatelle
+    - thelper
+    - unparam
+    - usetesting
+    - varnamelen
+    - wrapcheck
+    - wsl
+
+linters-settings:
+  gocognit:
+    # TODO: We should target for < 50
+    min-complexity: 65
+
+output:
+  print-issued-lines: true
+  sort-results: true

WORKSPACE

@@ -158,15 +158,15 @@ oci_register_toolchains(
 
 http_archive(
     name = "io_bazel_rules_go",
+    integrity = "sha256-JD8o94crTb2DFiJJR8nMAGdBAW95zIENB4cbI+JnrI4=",
     patch_args = ["-p1"],
     patches = [
         # Expose internals of go_test for custom build transitions.
         "//third_party:io_bazel_rules_go_test.patch",
     ],
-    sha256 = "a729c8ed2447c90fe140077689079ca0acfb7580ec41637f312d650ce9d93d96",
+    strip_prefix = "rules_go-cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9",
     urls = [
-        "https://mirror.bazel.build/github.com/bazel-contrib/rules_go/releases/download/v0.57.0/rules_go-v0.57.0.zip",
-        "https://github.com/bazel-contrib/rules_go/releases/download/v0.57.0/rules_go-v0.57.0.zip",
+        "https://github.com/bazel-contrib/rules_go/archive/cf3c3af34bd869b864f5f2b98e2f41c2b220d6c9.tar.gz",
     ],
 )
 
@@ -208,7 +208,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.25.1",
+    go_version = "1.24.6",
     nogo = "@//:nogo",
 )
 
@@ -253,16 +253,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.6.0-beta.0"
+consensus_spec_version = "v1.6.0-alpha.6"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-rT3jQp2+ZaDiO66gIQggetzqr+kGeexaLqEhbx4HDMY=",
-        "minimal": "sha256-wowwwyvd0KJLsE+oDOtPkrhZyJndJpJ0lbXYsLH6XBw=",
-        "mainnet": "sha256-4ZLrLNeO7NihZ4TuWH5V5fUhvW9Y3mAPBQDCqrfShps=",
+        "general": "sha256-7wkWuahuCO37uVYnxq8Badvi+jY907pBj68ixL8XDOI=",
+        "minimal": "sha256-Qy/f27N0LffS/ej7VhIubwDejD6LMK0VdenKkqtZVt4=",
+        "mainnet": "sha256-3H7mu5yE+FGz2Wr/nc8Nd9aEu93YoEpsYtn0zBSoeDE=",
     },
     version = consensus_spec_version,
 )
@@ -278,7 +278,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-sBe3Rx8zGq9IrvfgIhZQpYidGjy3mE1SiCb6/+pjLdY=",
+    integrity = "sha256-uvz3XfMTGfy3/BtQQoEp5XQOgrWgcH/5Zo/gR0iiP+k=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
@@ -300,6 +300,22 @@ filegroup(
     url = "https://github.com/ethereum/bls12-381-tests/releases/download/%s/bls_tests_yaml.tar.gz" % bls_test_version,
 )
 
+http_archive(
+    name = "eth2_networks",
+    build_file_content = """
+filegroup(
+    name = "configs",
+    srcs = glob([
+        "shared/**/config.yaml",
+    ]),
+    visibility = ["//visibility:public"],
+)
+    """,
+    sha256 = "77e7e3ed65e33b7bb19d30131f4c2bb39e4dfeb188ab9ae84651c3cc7600131d",
+    strip_prefix = "eth2-networks-934c948e69205dcf2deb87e4ae6cc140c335f94d",
+    url = "https://github.com/eth-clients/eth2-networks/archive/934c948e69205dcf2deb87e4ae6cc140c335f94d.tar.gz",
+)
+
 http_archive(
     name = "holesky_testnet",
     build_file_content = """
@@ -311,9 +327,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    integrity = "sha256-htyxg8Ln2o8eCiifFN7/hcHGZg8Ir9CPzCEx+FUnnCs=",
-    strip_prefix = "holesky-8aec65f11f0c986d6b76b2eb902420635eb9b815",
-    url = "https://github.com/eth-clients/holesky/archive/8aec65f11f0c986d6b76b2eb902420635eb9b815.tar.gz",
+    integrity = "sha256-YVFFrCmjoGZ3fXMWpsCpSsYbANy1grnqYwOLKIg2SsA=",
+    strip_prefix = "holesky-32a72e21c6e53c262f27d50dd540cb654517d03a",
+    url = "https://github.com/eth-clients/holesky/archive/32a72e21c6e53c262f27d50dd540cb654517d03a.tar.gz",  # 2025-03-17
 )
 
 http_archive(
@@ -343,9 +359,9 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    integrity = "sha256-+UZgfvBcea0K0sbvAJZOz5ZNmxdWZYbohP38heUuc6w=",
-    strip_prefix = "sepolia-f9158732adb1a2a6440613ad2232eb50e7384c4f",
-    url = "https://github.com/eth-clients/sepolia/archive/f9158732adb1a2a6440613ad2232eb50e7384c4f.tar.gz",
+    integrity = "sha256-b5F7Wg9LLMqGRIpP2uqb/YsSFVn2ynzlV7g/Nb1EFLk=",
+    strip_prefix = "sepolia-562d9938f08675e9ba490a1dfba21fb05843f39f",
+    url = "https://github.com/eth-clients/sepolia/archive/562d9938f08675e9ba490a1dfba21fb05843f39f.tar.gz",  # 2025-03-17
 )
 
 http_archive(
@@ -359,17 +375,17 @@ filegroup(
     visibility = ["//visibility:public"],
 )
 """,
-    integrity = "sha256-G+4c9c/vci1OyPrQJnQCI+ZCv/E0cWN4hrHDY3i7ns0=",
-    strip_prefix = "hoodi-b6ee51b2045a5e7fe3efac52534f75b080b049c6",
-    url = "https://github.com/eth-clients/hoodi/archive/b6ee51b2045a5e7fe3efac52534f75b080b049c6.tar.gz",
+    integrity = "sha256-dPiEWUd8QvbYGwGtIm0QtCekitVLOLsW5rpQIGzz8PU=",
+    strip_prefix = "hoodi-828c2c940e1141092bd4bb979cef547ea926d272",
+    url = "https://github.com/eth-clients/hoodi/archive/828c2c940e1141092bd4bb979cef547ea926d272.tar.gz",
 )
 
 http_archive(
     name = "com_google_protobuf",
-    sha256 = "7c3ebd7aaedd86fa5dc479a0fda803f602caaf78d8aff7ce83b89e1b8ae7442a",
-    strip_prefix = "protobuf-28.3",
+    sha256 = "9bd87b8280ef720d3240514f884e56a712f2218f0d693b48050c836028940a42",
+    strip_prefix = "protobuf-25.1",
     urls = [
-        "https://github.com/protocolbuffers/protobuf/archive/v28.3.tar.gz",
+        "https://github.com/protocolbuffers/protobuf/archive/v25.1.tar.gz",
     ],
 )
 

api/client/builder/BUILD.bazel

@@ -59,7 +59,6 @@ go_test(
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",

api/client/builder/client.go

@@ -30,11 +30,10 @@ import (
 )
 
 const (
-	getExecHeaderPath            = "/eth/v1/builder/header/{{.Slot}}/{{.ParentHash}}/{{.Pubkey}}"
-	getStatus                    = "/eth/v1/builder/status"
-	postBlindedBeaconBlockPath   = "/eth/v1/builder/blinded_blocks"
-	postBlindedBeaconBlockV2Path = "/eth/v2/builder/blinded_blocks"
-	postRegisterValidatorPath    = "/eth/v1/builder/validators"
+	getExecHeaderPath          = "/eth/v1/builder/header/{{.Slot}}/{{.ParentHash}}/{{.Pubkey}}"
+	getStatus                  = "/eth/v1/builder/status"
+	postBlindedBeaconBlockPath = "/eth/v1/builder/blinded_blocks"
+	postRegisterValidatorPath  = "/eth/v1/builder/validators"
 )
 
 var (
@@ -513,7 +512,7 @@ func (c *Client) SubmitBlindedBlockPostFulu(ctx context.Context, sb interfaces.R
 	}
 
 	// Post the blinded block - the response should only contain a status code (no payload)
-	_, _, err = c.do(ctx, http.MethodPost, postBlindedBeaconBlockV2Path, bytes.NewBuffer(body), http.StatusAccepted, postOpts)
+	_, _, err = c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), http.StatusAccepted, postOpts)
 	if err != nil {
 		return errors.Wrap(err, "error posting the blinded block to the builder api post-Fulu")
 	}

api/client/builder/client_test.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/api"
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -171,11 +170,8 @@ func TestClient_RegisterValidator(t *testing.T) {
 
 func TestClient_GetHeader(t *testing.T) {
 	ctx := t.Context()
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
-	es := util.SlotAtEpoch(t, params.BeaconConfig().ElectraForkEpoch)
-	expectedPath := "/eth/v1/builder/header/%d/0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2/0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
-	expectedPath = fmt.Sprintf(expectedPath, ds)
-	var slot primitives.Slot = ds
+	expectedPath := "/eth/v1/builder/header/23/0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2/0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a"
+	var slot primitives.Slot = 23
 	parentHash := ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
 	pubkey := ezDecode(t, "0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a")
 	t.Run("server error", func(t *testing.T) {
@@ -537,7 +533,7 @@ func TestClient_GetHeader(t *testing.T) {
 				require.Equal(t, expectedPath, r.URL.Path)
 				epr := &ExecHeaderResponseElectra{}
 				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponseElectra), epr))
-				pro, err := epr.ToProto(es)
+				pro, err := epr.ToProto(100)
 				require.NoError(t, err)
 				ssz, err := pro.MarshalSSZ()
 				require.NoError(t, err)
@@ -1565,7 +1561,7 @@ func TestSubmitBlindedBlockPostFulu(t *testing.T) {
 	t.Run("success", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockV2Path, r.URL.Path)
+				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Content-Type"))
 				require.Equal(t, api.JsonMediaType, r.Header.Get("Accept"))
@@ -1590,7 +1586,7 @@ func TestSubmitBlindedBlockPostFulu(t *testing.T) {
 	t.Run("success_ssz", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockV2Path, r.URL.Path)
+				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get(api.VersionHeader))
 				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Content-Type"))
 				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
@@ -1616,7 +1612,7 @@ func TestSubmitBlindedBlockPostFulu(t *testing.T) {
 	t.Run("error_response", func(t *testing.T) {
 		hc := &http.Client{
 			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockV2Path, r.URL.Path)
+				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
 				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
 				message := ErrorMessage{
 					Code:    400,

api/server/structs/endpoints_beacon.go

@@ -290,9 +290,3 @@ type GetProposerLookaheadResponse struct {
 	Finalized           bool     `json:"finalized"`
 	Data                []string `json:"data"` // validator indexes
 }
-
-type GetBlobsResponse struct {
-	ExecutionOptimistic bool     `json:"execution_optimistic"`
-	Finalized           bool     `json:"finalized"`
-	Data                []string `json:"data"` //blobs
-}

api/server/structs/endpoints_debug.go

@@ -56,19 +56,3 @@ type ForkChoiceNodeExtraData struct {
 	TimeStamp                string `json:"timestamp"`
 	Target                   string `json:"target"`
 }
-
-type GetDebugDataColumnSidecarsResponse struct {
-	Version             string               `json:"version"`
-	ExecutionOptimistic bool                 `json:"execution_optimistic"`
-	Finalized           bool                 `json:"finalized"`
-	Data                []*DataColumnSidecar `json:"data"`
-}
-
-type DataColumnSidecar struct {
-	Index                        string                   `json:"index"`
-	Column                       []string                 `json:"column"`
-	KzgCommitments               []string                 `json:"kzg_commitments"`
-	KzgProofs                    []string                 `json:"kzg_proofs"`
-	SignedBeaconBlockHeader      *SignedBeaconBlockHeader `json:"signed_block_header"`
-	KzgCommitmentsInclusionProof []string                 `json:"kzg_commitments_inclusion_proof"`
-}

beacon-chain/blockchain/BUILD.bazel

@@ -27,7 +27,7 @@ go_library(
         "receive_block.go",
         "receive_data_column.go",
         "service.go",
-        "setup_forkchoice.go",
+        "setup_forchoice.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
     ],
@@ -50,6 +50,7 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
@@ -62,7 +63,6 @@ go_library(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
-        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",
         "//beacon-chain/operations/slashings:go_default_library",
@@ -148,6 +148,7 @@ go_test(
         "//beacon-chain/core/blocks:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -160,7 +161,6 @@ go_test(
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
         "//beacon-chain/forkchoice/types:go_default_library",
-        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",
         "//beacon-chain/operations/attestations/kv:go_default_library",
         "//beacon-chain/operations/blstoexec:go_default_library",

beacon-chain/blockchain/execution_engine.go

@@ -16,7 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	blocktypes "github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	consensusblocks "github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	payloadattribute "github.com/OffchainLabs/prysm/v6/consensus-types/payload-attribute"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -218,18 +218,24 @@ func (s *Service) getPayloadHash(ctx context.Context, root []byte) ([32]byte, er
 
 // notifyNewPayload signals execution engine on a new payload.
 // It returns true if the EL has returned VALID for the block
-// stVersion should represent the version of the pre-state; header should also be from the pre-state.
-func (s *Service) notifyNewPayload(ctx context.Context, stVersion int, header interfaces.ExecutionData, blk blocktypes.ROBlock) (bool, error) {
+func (s *Service) notifyNewPayload(ctx context.Context, preStateVersion int,
+	preStateHeader interfaces.ExecutionData, blk interfaces.ReadOnlySignedBeaconBlock) (bool, error) {
 	ctx, span := trace.StartSpan(ctx, "blockChain.notifyNewPayload")
 	defer span.End()
 
 	// Execution payload is only supported in Bellatrix and beyond. Pre
 	// merge blocks are never optimistic
-	if stVersion < version.Bellatrix {
+	if blk == nil {
+		return false, errors.New("signed beacon block can't be nil")
+	}
+	if preStateVersion < version.Bellatrix {
 		return true, nil
 	}
+	if err := consensusblocks.BeaconBlockIsNil(blk); err != nil {
+		return false, err
+	}
 	body := blk.Block().Body()
-	enabled, err := blocks.IsExecutionEnabledUsingHeader(header, body)
+	enabled, err := blocks.IsExecutionEnabledUsingHeader(preStateHeader, body)
 	if err != nil {
 		return false, errors.Wrap(invalidBlock{error: err}, "could not determine if execution is enabled")
 	}
@@ -262,32 +268,28 @@ func (s *Service) notifyNewPayload(ctx context.Context, stVersion int, header in
 			return false, errors.New("nil execution requests")
 		}
 	}
-
 	lastValidHash, err = s.cfg.ExecutionEngineCaller.NewPayload(ctx, payload, versionedHashes, parentRoot, requests)
-	if err == nil {
+
+	switch {
+	case err == nil:
 		newPayloadValidNodeCount.Inc()
 		return true, nil
-	}
-	logFields := logrus.Fields{
-		"slot":             blk.Block().Slot(),
-		"parentRoot":       fmt.Sprintf("%#x", parentRoot),
-		"root":             fmt.Sprintf("%#x", blk.Root()),
-		"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
-	}
-	if errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus) {
+	case errors.Is(err, execution.ErrAcceptedSyncingPayloadStatus):
 		newPayloadOptimisticNodeCount.Inc()
-		log.WithFields(logFields).Info("Called new payload with optimistic block")
+		log.WithFields(logrus.Fields{
+			"slot":             blk.Block().Slot(),
+			"payloadBlockHash": fmt.Sprintf("%#x", bytesutil.Trunc(payload.BlockHash())),
+		}).Info("Called new payload with optimistic block")
 		return false, nil
-	}
-	if errors.Is(err, execution.ErrInvalidPayloadStatus) {
-		log.WithFields(logFields).WithError(err).Error("Invalid payload status")
+	case errors.Is(err, execution.ErrInvalidPayloadStatus):
+		lvh := bytesutil.ToBytes32(lastValidHash)
 		return false, invalidBlock{
 			error:         ErrInvalidPayload,
-			lastValidHash: bytesutil.ToBytes32(lastValidHash),
+			lastValidHash: lvh,
 		}
+	default:
+		return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 	}
-	log.WithFields(logFields).WithError(err).Error("Unexpected execution engine error")
-	return false, errors.WithMessage(ErrUndefinedExecutionEngineError, err.Error())
 }
 
 // reportInvalidBlock deals with the event that an invalid block was detected by the execution layer

beacon-chain/blockchain/execution_engine_test.go

@@ -481,12 +481,33 @@ func Test_NotifyNewPayload(t *testing.T) {
 	phase0State, _ := util.DeterministicGenesisState(t, 1)
 	altairState, _ := util.DeterministicGenesisStateAltair(t, 1)
 	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)
-	a := util.NewBeaconBlockAltair()
+	a := &ethpb.SignedBeaconBlockAltair{
+		Block: &ethpb.BeaconBlockAltair{
+			Body: &ethpb.BeaconBlockBodyAltair{},
+		},
+	}
 	altairBlk, err := consensusblocks.NewSignedBeaconBlock(a)
 	require.NoError(t, err)
-	blk := util.NewBeaconBlockBellatrix()
-	blk.Block.Slot = 1
-	blk.Block.Body.ExecutionPayload.BlockNumber = 1
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Slot: 1,
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				ExecutionPayload: &v1.ExecutionPayload{
+					BlockNumber:   1,
+					ParentHash:    make([]byte, fieldparams.RootLength),
+					FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+					StateRoot:     make([]byte, fieldparams.RootLength),
+					ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+					LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+					PrevRandao:    make([]byte, fieldparams.RootLength),
+					ExtraData:     make([]byte, 0),
+					BaseFeePerGas: make([]byte, fieldparams.RootLength),
+					BlockHash:     make([]byte, fieldparams.RootLength),
+					Transactions:  make([][]byte, 0),
+				},
+			},
+		},
+	}
 	bellatrixBlk, err := consensusblocks.NewSignedBeaconBlock(util.HydrateSignedBeaconBlockBellatrix(blk))
 	require.NoError(t, err)
 	st := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(epochsSinceFinalitySaveHotStateDB))
@@ -523,6 +544,12 @@ func Test_NotifyNewPayload(t *testing.T) {
 			blk:            altairBlk,
 			isValidPayload: true,
 		},
+		{
+			name:           "nil beacon block",
+			postState:      bellatrixState,
+			errString:      "signed beacon block can't be nil",
+			isValidPayload: false,
+		},
 		{
 			name:           "new payload with optimistic block",
 			postState:      bellatrixState,
@@ -549,8 +576,15 @@ func Test_NotifyNewPayload(t *testing.T) {
 			name:      "altair pre state, happy case",
 			postState: bellatrixState,
 			blk: func() interfaces.ReadOnlySignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Body.ExecutionPayload.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk := &ethpb.SignedBeaconBlockBellatrix{
+					Block: &ethpb.BeaconBlockBellatrix{
+						Body: &ethpb.BeaconBlockBodyBellatrix{
+							ExecutionPayload: &v1.ExecutionPayload{
+								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
+							},
+						},
+					},
+				}
 				b, err := consensusblocks.NewSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
@@ -561,7 +595,24 @@ func Test_NotifyNewPayload(t *testing.T) {
 			name:      "not at merge transition",
 			postState: bellatrixState,
 			blk: func() interfaces.ReadOnlySignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
+				blk := &ethpb.SignedBeaconBlockBellatrix{
+					Block: &ethpb.BeaconBlockBellatrix{
+						Body: &ethpb.BeaconBlockBodyBellatrix{
+							ExecutionPayload: &v1.ExecutionPayload{
+								ParentHash:    make([]byte, fieldparams.RootLength),
+								FeeRecipient:  make([]byte, fieldparams.FeeRecipientLength),
+								StateRoot:     make([]byte, fieldparams.RootLength),
+								ReceiptsRoot:  make([]byte, fieldparams.RootLength),
+								LogsBloom:     make([]byte, fieldparams.LogsBloomLength),
+								PrevRandao:    make([]byte, fieldparams.RootLength),
+								ExtraData:     make([]byte, 0),
+								BaseFeePerGas: make([]byte, fieldparams.RootLength),
+								BlockHash:     make([]byte, fieldparams.RootLength),
+								Transactions:  make([][]byte, 0),
+							},
+						},
+					},
+				}
 				b, err := consensusblocks.NewSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
@@ -572,8 +623,15 @@ func Test_NotifyNewPayload(t *testing.T) {
 			name:      "happy case",
 			postState: bellatrixState,
 			blk: func() interfaces.ReadOnlySignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Body.ExecutionPayload.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk := &ethpb.SignedBeaconBlockBellatrix{
+					Block: &ethpb.BeaconBlockBellatrix{
+						Body: &ethpb.BeaconBlockBodyBellatrix{
+							ExecutionPayload: &v1.ExecutionPayload{
+								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
+							},
+						},
+					},
+				}
 				b, err := consensusblocks.NewSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
@@ -584,8 +642,15 @@ func Test_NotifyNewPayload(t *testing.T) {
 			name:      "undefined error from ee",
 			postState: bellatrixState,
 			blk: func() interfaces.ReadOnlySignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Body.ExecutionPayload.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk := &ethpb.SignedBeaconBlockBellatrix{
+					Block: &ethpb.BeaconBlockBellatrix{
+						Body: &ethpb.BeaconBlockBodyBellatrix{
+							ExecutionPayload: &v1.ExecutionPayload{
+								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
+							},
+						},
+					},
+				}
 				b, err := consensusblocks.NewSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
@@ -597,8 +662,15 @@ func Test_NotifyNewPayload(t *testing.T) {
 			name:      "invalid block hash error from ee",
 			postState: bellatrixState,
 			blk: func() interfaces.ReadOnlySignedBeaconBlock {
-				blk := util.NewBeaconBlockBellatrix()
-				blk.Block.Body.ExecutionPayload.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+				blk := &ethpb.SignedBeaconBlockBellatrix{
+					Block: &ethpb.BeaconBlockBellatrix{
+						Body: &ethpb.BeaconBlockBodyBellatrix{
+							ExecutionPayload: &v1.ExecutionPayload{
+								ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
+							},
+						},
+					},
+				}
 				b, err := consensusblocks.NewSignedBeaconBlock(blk)
 				require.NoError(t, err)
 				return b
@@ -629,9 +701,7 @@ func Test_NotifyNewPayload(t *testing.T) {
 			require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
 			postVersion, postHeader, err := getStateVersionAndPayload(tt.postState)
 			require.NoError(t, err)
-			rob, err := consensusblocks.NewROBlock(tt.blk)
-			require.NoError(t, err)
-			isValidPayload, err := service.notifyNewPayload(ctx, postVersion, postHeader, rob)
+			isValidPayload, err := service.notifyNewPayload(ctx, postVersion, postHeader, tt.blk)
 			if tt.errString != "" {
 				require.ErrorContains(t, tt.errString, err)
 				if tt.invalidBlock {
@@ -655,12 +725,17 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	ctx := tr.ctx
 
 	bellatrixState, _ := util.DeterministicGenesisStateBellatrix(t, 2)
-	blk := util.NewBeaconBlockBellatrix()
-	blk.Block.Body.ExecutionPayload.ParentHash = bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength)
+	blk := &ethpb.SignedBeaconBlockBellatrix{
+		Block: &ethpb.BeaconBlockBellatrix{
+			Body: &ethpb.BeaconBlockBodyBellatrix{
+				ExecutionPayload: &v1.ExecutionPayload{
+					ParentHash: bytesutil.PadTo([]byte{'a'}, fieldparams.RootLength),
+				},
+			},
+		},
+	}
 	bellatrixBlk, err := consensusblocks.NewSignedBeaconBlock(blk)
 	require.NoError(t, err)
-	rob, err := consensusblocks.NewROBlock(bellatrixBlk)
-	require.NoError(t, err)
 	e := &mockExecution.EngineClient{BlockByHashMap: map[[32]byte]*v1.ExecutionBlock{}}
 	e.BlockByHashMap[[32]byte{'a'}] = &v1.ExecutionBlock{
 		Header: gethtypes.Header{
@@ -677,7 +752,7 @@ func Test_NotifyNewPayload_SetOptimisticToValid(t *testing.T) {
 	service.cfg.ExecutionEngineCaller = e
 	postVersion, postHeader, err := getStateVersionAndPayload(bellatrixState)
 	require.NoError(t, err)
-	validated, err := service.notifyNewPayload(ctx, postVersion, postHeader, rob)
+	validated, err := service.notifyNewPayload(ctx, postVersion, postHeader, bellatrixBlk)
 	require.NoError(t, err)
 	require.Equal(t, true, validated)
 }

beacon-chain/blockchain/head.go

@@ -16,6 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/math"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	ethpbv1 "github.com/OffchainLabs/prysm/v6/proto/eth/v1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -107,7 +108,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 			commonRoot = params.BeaconConfig().ZeroHash
 		}
 		dis := headSlot + newHeadSlot - 2*forkSlot
-		dep := max(uint64(headSlot-forkSlot), uint64(newHeadSlot-forkSlot))
+		dep := math.Max(uint64(headSlot-forkSlot), uint64(newHeadSlot-forkSlot))
 		oldWeight, err := s.cfg.ForkChoiceStore.Weight(oldHeadRoot)
 		if err != nil {
 			log.WithField("root", fmt.Sprintf("%#x", oldHeadRoot)).Warn("Could not determine node weight")
@@ -134,7 +135,7 @@ func (s *Service) saveHead(ctx context.Context, newHeadRoot [32]byte, headBlock
 			Type: statefeed.Reorg,
 			Data: &ethpbv1.EventChainReorg{
 				Slot:                newHeadSlot,
-				Depth:               max(uint64(headSlot-forkSlot), uint64(newHeadSlot-forkSlot)),
+				Depth:               math.Max(uint64(headSlot-forkSlot), uint64(newHeadSlot-forkSlot)),
 				OldHeadBlock:        oldHeadRoot[:],
 				NewHeadBlock:        newHeadRoot[:],
 				OldHeadState:        oldStateRoot[:],

beacon-chain/blockchain/kzg/kzg.go

@@ -14,10 +14,7 @@ const BytesPerBlob = ckzg4844.BytesPerBlob
 type Blob [BytesPerBlob]byte
 
 // BytesPerCell is the number of bytes in a single cell.
-const (
-	BytesPerCell  = ckzg4844.BytesPerCell
-	BytesPerProof = ckzg4844.BytesPerProof
-)
+const BytesPerCell = ckzg4844.BytesPerCell
 
 // Cell represents a chunk of an encoded Blob.
 type Cell [BytesPerCell]byte
@@ -26,7 +23,7 @@ type Cell [BytesPerCell]byte
 type Commitment [48]byte
 
 // Proof represents a KZG proof that attests to the validity of a Blob or parts of it.
-type Proof [BytesPerProof]byte
+type Proof [48]byte
 
 // Bytes48 is a 48-byte array.
 type Bytes48 = ckzg4844.Bytes48
@@ -109,7 +106,6 @@ func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, c
 }
 
 // RecoverCellsAndKZGProofs recovers the complete cells and KZG proofs from a given set of cell indices and partial cells.
-// Note: `len(cellIndices)` must be equal to `len(partialCells)` and `cellIndices` must be sorted in ascending order.
 func RecoverCellsAndKZGProofs(cellIndices []uint64, partialCells []Cell) (CellsAndProofs, error) {
 	// Convert `Cell` type to `ckzg4844.Cell`
 	ckzgPartialCells := make([]ckzg4844.Cell, len(partialCells))

beacon-chain/blockchain/options.go

@@ -6,11 +6,11 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"
@@ -35,7 +35,7 @@ func WithMaxGoroutines(x int) Option {
 // WithLCStore for light client store access.
 func WithLCStore() Option {
 	return func(s *Service) error {
-		s.lcStore = lightclient.NewLightClientStore(s.cfg.P2P, s.cfg.StateNotifier.StateFeed(), s.cfg.BeaconDB)
+		s.lcStore = lightclient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
 		return nil
 	}
 }

beacon-chain/blockchain/process_block.go

@@ -3,6 +3,7 @@ package blockchain
 import (
 	"context"
 	"fmt"
+	"slices"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
@@ -246,7 +247,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
-		pendingNodes[i] = args
+		pendingNodes[len(blks)-i-1] = args
 		if err := s.saveInitSyncBlock(ctx, root, b); err != nil {
 			tracing.AnnotateError(span, err)
 			return err
@@ -283,10 +284,14 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	if err := s.cfg.StateGen.SaveState(ctx, lastBR, preState); err != nil {
 		return err
 	}
-	// Insert all nodes to forkchoice
+	// Insert all nodes but the last one to forkchoice
 	if err := s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes); err != nil {
 		return errors.Wrap(err, "could not insert batch to forkchoice")
 	}
+	// Insert the last block to forkchoice
+	if err := s.cfg.ForkChoiceStore.InsertNode(ctx, preState, lastB); err != nil {
+		return errors.Wrap(err, "could not insert last block in batch to forkchoice")
+	}
 	// Set their optimistic status
 	if isValidPayload {
 		if err := s.cfg.ForkChoiceStore.SetOptimisticToValid(ctx, lastBR); err != nil {
@@ -659,14 +664,14 @@ func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldpa
 // closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
 func (s *Service) isDataAvailable(
 	ctx context.Context,
-	roBlock consensusblocks.ROBlock,
+	root [fieldparams.RootLength]byte,
+	signedBlock interfaces.ReadOnlySignedBeaconBlock,
 ) error {
-	block := roBlock.Block()
+	block := signedBlock.Block()
 	if block == nil {
 		return errors.New("invalid nil beacon block")
 	}
 
-	root := roBlock.Root()
 	blockVersion := block.Version()
 	if blockVersion >= version.Fulu {
 		return s.areDataColumnsAvailable(ctx, root, block)
@@ -686,6 +691,8 @@ func (s *Service) areDataColumnsAvailable(
 	root [fieldparams.RootLength]byte,
 	block interfaces.ReadOnlyBeaconBlock,
 ) error {
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+
 	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
 	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
@@ -712,14 +719,13 @@ func (s *Service) areDataColumnsAvailable(
 	nodeID := s.cfg.P2P.NodeID()
 
 	// Get the custody group sampling size for the node.
-	custodyGroupCount, err := s.cfg.P2P.CustodyGroupCount(ctx)
+	custodyGroupCount, err := s.cfg.P2P.CustodyGroupCount()
 	if err != nil {
 		return errors.Wrap(err, "custody group count")
 	}
 
 	// Compute the sampling size.
 	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#custody-sampling
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
 	samplingSize := max(samplesPerSlot, custodyGroupCount)
 
 	// Get the peer info for the node.
@@ -745,14 +751,14 @@ func (s *Service) areDataColumnsAvailable(
 	}
 
 	// Get a map of data column indices that are not currently available.
-	missing, err := missingDataColumnIndices(s.dataColumnStorage, root, peerInfo.CustodyColumns)
+	missingMap, err := missingDataColumnIndices(s.dataColumnStorage, root, peerInfo.CustodyColumns)
 	if err != nil {
 		return errors.Wrap(err, "missing data columns")
 	}
 
 	// If there are no missing indices, all data column sidecars are available.
 	// This is the happy path.
-	if len(missing) == 0 {
+	if len(missingMap) == 0 {
 		return nil
 	}
 
@@ -769,17 +775,33 @@ func (s *Service) areDataColumnsAvailable(
 	// Avoid logging if DA check is called after next slot start.
 	if nextSlot.After(time.Now()) {
 		timer := time.AfterFunc(time.Until(nextSlot), func() {
-			missingCount := uint64(len(missing))
+			missingMapCount := uint64(len(missingMap))
 
-			if missingCount == 0 {
+			if missingMapCount == 0 {
 				return
 			}
 
+			var (
+				expected interface{} = "all"
+				missing  interface{} = "all"
+			)
+
+			numberOfColumns := params.BeaconConfig().NumberOfColumns
+			colMapCount := uint64(len(peerInfo.CustodyColumns))
+
+			if colMapCount < numberOfColumns {
+				expected = uint64MapToSortedSlice(peerInfo.CustodyColumns)
+			}
+
+			if missingMapCount < numberOfColumns {
+				missing = uint64MapToSortedSlice(missingMap)
+			}
+
 			log.WithFields(logrus.Fields{
 				"slot":            block.Slot(),
 				"root":            fmt.Sprintf("%#x", root),
-				"columnsExpected": helpers.SortedPrettySliceFromMap(peerInfo.CustodyColumns),
-				"columnsWaiting":  helpers.SortedPrettySliceFromMap(missing),
+				"columnsExpected": expected,
+				"columnsWaiting":  missing,
 			}).Warning("Data columns still missing at slot end")
 		})
 		defer timer.Stop()
@@ -795,7 +817,7 @@ func (s *Service) areDataColumnsAvailable(
 
 			for _, index := range idents.Indices {
 				// This is a data column we are expecting.
-				if _, ok := missing[index]; ok {
+				if _, ok := missingMap[index]; ok {
 					storedDataColumnsCount++
 				}
 
@@ -806,10 +828,10 @@ func (s *Service) areDataColumnsAvailable(
 				}
 
 				// Remove the index from the missing map.
-				delete(missing, index)
+				delete(missingMap, index)
 
 				// Return if there is no more missing data columns.
-				if len(missing) == 0 {
+				if len(missingMap) == 0 {
 					return nil
 				}
 			}
@@ -817,10 +839,10 @@ func (s *Service) areDataColumnsAvailable(
 		case <-ctx.Done():
 			var missingIndices interface{} = "all"
 			numberOfColumns := params.BeaconConfig().NumberOfColumns
-			missingIndicesCount := uint64(len(missing))
+			missingIndicesCount := uint64(len(missingMap))
 
 			if missingIndicesCount < numberOfColumns {
-				missingIndices = helpers.SortedPrettySliceFromMap(missing)
+				missingIndices = uint64MapToSortedSlice(missingMap)
 			}
 
 			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, missingIndices)
@@ -904,6 +926,16 @@ func (s *Service) areBlobsAvailable(ctx context.Context, root [fieldparams.RootL
 	}
 }
 
+// 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
+}
+
 // lateBlockTasks  is called 4 seconds into the slot and performs tasks
 // related to late blocks. It emits a MissedSlot state feed event.
 // It calls FCU and sets the right attributes if we are proposing next slot

beacon-chain/blockchain/process_block_helpers.go

@@ -3,12 +3,14 @@ package blockchain
 import (
 	"context"
 	"fmt"
-	"slices"
+	"strings"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
@@ -131,26 +133,35 @@ func (s *Service) sendStateFeedOnBlock(cfg *postBlockProcessConfig) {
 	})
 }
 
-// processLightClientUpdates saves the light client data in lcStore, when feature flag is enabled.
 func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
+	if err := s.processLightClientUpdate(cfg); err != nil {
+		log.WithError(err).Error("Failed to process light client update")
+	}
+	if err := s.processLightClientOptimisticUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
+		log.WithError(err).Error("Failed to process light client optimistic update")
+	}
+	if err := s.processLightClientFinalityUpdate(cfg.ctx, cfg.roblock, cfg.postState); err != nil {
+		log.WithError(err).Error("Failed to process light client finality update")
+	}
+}
+
+// processLightClientUpdate saves the light client update for this block
+// if it's better than the already saved one, when feature flag is enabled.
+func (s *Service) processLightClientUpdate(cfg *postBlockProcessConfig) error {
 	attestedRoot := cfg.roblock.Block().ParentRoot()
 	attestedBlock, err := s.getBlock(cfg.ctx, attestedRoot)
 	if err != nil {
-		log.WithError(err).Error("processLightClientUpdates: Could not get attested block")
-		return
+		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
 	}
 	if attestedBlock == nil || attestedBlock.IsNil() {
-		log.Error("processLightClientUpdates: Could not get attested block")
-		return
+		return errors.New("attested block is nil")
 	}
 	attestedState, err := s.cfg.StateGen.StateByRoot(cfg.ctx, attestedRoot)
 	if err != nil {
-		log.WithError(err).Error("processLightClientUpdates: Could not get attested state")
-		return
+		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
 	}
 	if attestedState == nil || attestedState.IsNil() {
-		log.Error("processLightClientUpdates: Could not get attested state")
-		return
+		return errors.New("attested state is nil")
 	}
 
 	finalizedRoot := attestedState.FinalizedCheckpoint().Root
@@ -158,17 +169,98 @@ func (s *Service) processLightClientUpdates(cfg *postBlockProcessConfig) {
 	if err != nil {
 		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
 			log.Debugf("Skipping saving light client update because finalized block is nil for root %#x", finalizedRoot)
-			return
+			return nil
 		}
-		log.WithError(err).Error("processLightClientUpdates: Could not get finalized block")
-		return
+		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
 	}
 
-	err = s.lcStore.SaveLCData(cfg.ctx, cfg.postState, cfg.roblock, attestedState, attestedBlock, finalizedBlock, s.headRoot())
+	update, err := lightclient.NewLightClientUpdateFromBeaconState(cfg.ctx, cfg.postState, cfg.roblock, attestedState, attestedBlock, finalizedBlock)
 	if err != nil {
-		log.WithError(err).Error("processLightClientUpdates: Could not save light client data")
+		return errors.Wrapf(err, "could not create light client update")
 	}
-	log.Debug("Processed light client updates")
+
+	period := slots.SyncCommitteePeriod(slots.ToEpoch(attestedState.Slot()))
+
+	return s.lcStore.SaveLightClientUpdate(cfg.ctx, period, update)
+}
+
+func (s *Service) processLightClientFinalityUpdate(
+	ctx context.Context,
+	signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState,
+) error {
+	attestedRoot := signed.Block().ParentRoot()
+	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
+	if err != nil {
+		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
+	}
+	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
+	if err != nil {
+		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
+	}
+
+	finalizedCheckpoint := attestedState.FinalizedCheckpoint()
+
+	if finalizedCheckpoint == nil {
+		return nil
+	}
+
+	finalizedRoot := bytesutil.ToBytes32(finalizedCheckpoint.Root)
+	finalizedBlock, err := s.cfg.BeaconDB.Block(ctx, finalizedRoot)
+	if err != nil {
+		if errors.Is(err, errBlockNotFoundInCacheOrDB) {
+			log.Debugf("Skipping processing light client finality update: Finalized block is nil for root %#x", finalizedRoot)
+			return nil
+		}
+		return errors.Wrapf(err, "could not get finalized block for root %#x", finalizedRoot)
+	}
+
+	newUpdate, err := lightclient.NewLightClientFinalityUpdateFromBeaconState(ctx, postState, signed, attestedState, attestedBlock, finalizedBlock)
+
+	if err != nil {
+		return errors.Wrap(err, "could not create light client finality update")
+	}
+
+	if !lightclient.IsBetterFinalityUpdate(newUpdate, s.lcStore.LastFinalityUpdate()) {
+		log.Debug("Skip saving light client finality update: current update is better")
+		return nil
+	}
+
+	s.lcStore.SetLastFinalityUpdate(newUpdate, true)
+
+	return nil
+}
+
+func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
+	postState state.BeaconState) error {
+	attestedRoot := signed.Block().ParentRoot()
+	attestedBlock, err := s.cfg.BeaconDB.Block(ctx, attestedRoot)
+	if err != nil {
+		return errors.Wrapf(err, "could not get attested block for root %#x", attestedRoot)
+	}
+	attestedState, err := s.cfg.StateGen.StateByRoot(ctx, attestedRoot)
+	if err != nil {
+		return errors.Wrapf(err, "could not get attested state for root %#x", attestedRoot)
+	}
+
+	newUpdate, err := lightclient.NewLightClientOptimisticUpdateFromBeaconState(ctx, postState, signed, attestedState, attestedBlock)
+
+	if err != nil {
+		if strings.Contains(err.Error(), lightclient.ErrNotEnoughSyncCommitteeBits) {
+			log.WithError(err).Debug("Skipping processing light client optimistic update")
+			return nil
+		}
+		return errors.Wrap(err, "could not create light client optimistic update")
+	}
+
+	if !lightclient.IsBetterOptimisticUpdate(newUpdate, s.lcStore.LastOptimisticUpdate()) {
+		log.Debug("Skip saving light client optimistic update: current update is better")
+		return nil
+	}
+
+	s.lcStore.SetLastOptimisticUpdate(newUpdate, true)
+
+	return nil
 }
 
 // updateCachesPostBlockProcessing updates the next slot cache and handles the epoch
@@ -377,8 +469,15 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 	if err != nil {
 		return err
 	}
-	root := signed.Block().ParentRoot()
+	// The first block can have a bogus root since the block is not inserted in forkchoice
+	roblock, err := consensus_blocks.NewROBlockWithRoot(signed, [32]byte{})
+	if err != nil {
+		return err
+	}
+	pendingNodes = append(pendingNodes, &forkchoicetypes.BlockAndCheckpoints{Block: roblock,
+		JustifiedCheckpoint: jCheckpoint, FinalizedCheckpoint: fCheckpoint})
 	// As long as parent node is not in fork choice store, and parent node is in DB.
+	root := roblock.Block().ParentRoot()
 	for !s.cfg.ForkChoiceStore.HasNode(root) && s.cfg.BeaconDB.HasBlock(ctx, root) {
 		b, err := s.getBlock(ctx, root)
 		if err != nil {
@@ -397,13 +496,12 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed inte
 			FinalizedCheckpoint: fCheckpoint}
 		pendingNodes = append(pendingNodes, args)
 	}
-	if len(pendingNodes) == 0 {
+	if len(pendingNodes) == 1 {
 		return nil
 	}
 	if root != s.ensureRootNotZeros(finalized.Root) && !s.cfg.ForkChoiceStore.HasNode(root) {
 		return ErrNotDescendantOfFinalized
 	}
-	slices.Reverse(pendingNodes)
 	return s.cfg.ForkChoiceStore.InsertChain(ctx, pendingNodes)
 }
 

beacon-chain/blockchain/process_block_test.go

@@ -12,6 +12,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
@@ -23,7 +24,6 @@ import (
 	mockExecution "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations/kv"
 	mockp2p "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
@@ -2413,8 +2413,6 @@ func driftGenesisTime(s *Service, slot primitives.Slot, delay time.Duration) {
 }
 
 func TestMissingBlobIndices(t *testing.T) {
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
-	maxBlobs := params.BeaconConfig().MaxBlobsPerBlock(ds)
 	cases := []struct {
 		name     string
 		expected [][]byte
@@ -2428,23 +2426,23 @@ func TestMissingBlobIndices(t *testing.T) {
 		},
 		{
 			name:     "expected exceeds max",
-			expected: fakeCommitments(maxBlobs + 1),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0) + 1),
 			err:      errMaxBlobsExceeded,
 		},
 		{
 			name:     "first missing",
-			expected: fakeCommitments(maxBlobs),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			present:  []uint64{1, 2, 3, 4, 5},
 			result:   fakeResult([]uint64{0}),
 		},
 		{
 			name:     "all missing",
-			expected: fakeCommitments(maxBlobs),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			result:   fakeResult([]uint64{0, 1, 2, 3, 4, 5}),
 		},
 		{
 			name:     "none missing",
-			expected: fakeCommitments(maxBlobs),
+			expected: fakeCommitments(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			present:  []uint64{0, 1, 2, 3, 4, 5},
 			result:   fakeResult([]uint64{}),
 		},
@@ -2477,8 +2475,8 @@ func TestMissingBlobIndices(t *testing.T) {
 	for _, c := range cases {
 		bm, bs := filesystem.NewEphemeralBlobStorageWithMocker(t)
 		t.Run(c.name, func(t *testing.T) {
-			require.NoError(t, bm.CreateFakeIndices(c.root, ds, c.present...))
-			missing, err := missingBlobIndices(bs, c.root, c.expected, ds)
+			require.NoError(t, bm.CreateFakeIndices(c.root, 0, c.present...))
+			missing, err := missingBlobIndices(bs, c.root, c.expected, 0)
 			if c.err != nil {
 				require.ErrorIs(t, err, c.err)
 				return
@@ -2797,11 +2795,6 @@ func TestProcessLightClientUpdate(t *testing.T) {
 	s, tr := minimalTestService(t, WithLCStore())
 	ctx := tr.ctx
 
-	headState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, s.cfg.BeaconDB.SaveState(ctx, headState, [32]byte{1, 2}))
-	require.NoError(t, s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, [32]byte{1, 2}))
-
 	for testVersion := version.Altair; testVersion <= version.Electra; testVersion++ {
 		t.Run(version.String(testVersion), func(t *testing.T) {
 			l := util.NewTestLightClient(t, testVersion)
@@ -2824,8 +2817,6 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			require.NoError(t, err)
 			err = s.cfg.BeaconDB.SaveState(ctx, l.State, currentBlockRoot)
 			require.NoError(t, err)
-			err = s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, currentBlockRoot)
-			require.NoError(t, err)
 
 			err = s.cfg.BeaconDB.SaveBlock(ctx, l.FinalizedBlock)
 			require.NoError(t, err)
@@ -2840,9 +2831,10 @@ func TestProcessLightClientUpdate(t *testing.T) {
 			period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedState.Slot()))
 
 			t.Run("no old update", func(t *testing.T) {
-				s.processLightClientUpdates(cfg)
+				require.NoError(t, s.processLightClientUpdate(cfg))
+
 				// Check that the light client update is saved
-				u, err := s.lcStore.LightClientUpdate(ctx, period, l.Block)
+				u, err := s.lcStore.LightClientUpdate(ctx, period)
 				require.NoError(t, err)
 				require.NotNil(t, u)
 				attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
@@ -2856,12 +2848,12 @@ func TestProcessLightClientUpdate(t *testing.T) {
 				oldUpdate, err := lightClient.CreateDefaultLightClientUpdate(l.AttestedBlock)
 				require.NoError(t, err)
 
-				err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+				err = s.lcStore.SaveLightClientUpdate(ctx, period, oldUpdate)
 				require.NoError(t, err)
 
-				s.processLightClientUpdates(cfg)
+				require.NoError(t, s.processLightClientUpdate(cfg))
 
-				u, err := s.lcStore.LightClientUpdate(ctx, period, l.Block)
+				u, err := s.lcStore.LightClientUpdate(ctx, period)
 				require.NoError(t, err)
 				require.NotNil(t, u)
 				attestedStateRoot, err := l.AttestedState.HashTreeRoot(ctx)
@@ -2885,12 +2877,12 @@ func TestProcessLightClientUpdate(t *testing.T) {
 					SyncCommitteeSignature: make([]byte, 96),
 				})
 
-				err = s.cfg.BeaconDB.SaveLightClientUpdate(ctx, period, oldUpdate)
+				err = s.lcStore.SaveLightClientUpdate(ctx, period, oldUpdate)
 				require.NoError(t, err)
 
-				s.processLightClientUpdates(cfg)
+				require.NoError(t, s.processLightClientUpdate(cfg))
 
-				u, err := s.lcStore.LightClientUpdate(ctx, period, l.Block)
+				u, err := s.lcStore.LightClientUpdate(ctx, period)
 				require.NoError(t, err)
 				require.NotNil(t, u)
 				require.DeepEqual(t, oldUpdate, u)
@@ -2906,21 +2898,22 @@ type testIsAvailableParams struct {
 	columnsToSave           []uint64
 }
 
-func testIsAvailableSetup(t *testing.T, p testIsAvailableParams) (context.Context, context.CancelFunc, *Service, [fieldparams.RootLength]byte, interfaces.SignedBeaconBlock) {
+func testIsAvailableSetup(t *testing.T, params testIsAvailableParams) (context.Context, context.CancelFunc, *Service, [fieldparams.RootLength]byte, interfaces.SignedBeaconBlock) {
 	ctx, cancel := context.WithCancel(t.Context())
 	dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
 
-	options := append(p.options, WithDataColumnStorage(dataColumnStorage))
+	options := append(params.options, WithDataColumnStorage(dataColumnStorage))
 	service, _ := minimalTestService(t, options...)
-	fs := util.SlotAtEpoch(t, params.BeaconConfig().FuluForkEpoch)
 
-	genesisState, secretKeys := util.DeterministicGenesisStateElectra(t, 32, util.WithElectraStateSlot(fs))
-	require.NoError(t, service.saveGenesisData(ctx, genesisState))
+	genesisState, secretKeys := util.DeterministicGenesisStateElectra(t, 32 /*validator count*/)
+
+	err := service.saveGenesisData(ctx, genesisState)
+	require.NoError(t, err)
 
 	conf := util.DefaultBlockGenConfig()
-	conf.NumBlobKzgCommitments = p.blobKzgCommitmentsCount
+	conf.NumBlobKzgCommitments = params.blobKzgCommitmentsCount
 
-	signedBeaconBlock, err := util.GenerateFullBlockFulu(genesisState, secretKeys, conf, fs+1)
+	signedBeaconBlock, err := util.GenerateFullBlockFulu(genesisState, secretKeys, conf, 10 /*block slot*/)
 	require.NoError(t, err)
 
 	block := signedBeaconBlock.Block
@@ -2930,8 +2923,8 @@ func testIsAvailableSetup(t *testing.T, p testIsAvailableParams) (context.Contex
 	root, err := block.HashTreeRoot()
 	require.NoError(t, err)
 
-	dataColumnsParams := make([]util.DataColumnParam, 0, len(p.columnsToSave))
-	for _, i := range p.columnsToSave {
+	dataColumnsParams := make([]util.DataColumnParam, 0, len(params.columnsToSave))
+	for _, i := range params.columnsToSave {
 		dataColumnParam := util.DataColumnParam{
 			Index:         i,
 			Slot:          block.Slot,
@@ -2955,28 +2948,21 @@ func testIsAvailableSetup(t *testing.T, p testIsAvailableParams) (context.Contex
 }
 
 func TestIsDataAvailable(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch, cfg.BellatrixForkEpoch, cfg.CapellaForkEpoch, cfg.DenebForkEpoch, cfg.ElectraForkEpoch, cfg.FuluForkEpoch = 0, 0, 0, 0, 0, 0
-	params.OverrideBeaconConfig(cfg)
 	t.Run("Fulu - out of retention window", func(t *testing.T) {
-		params := testIsAvailableParams{}
+		params := testIsAvailableParams{options: []Option{WithGenesisTime(time.Unix(0, 0))}}
 		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err := service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
 	t.Run("Fulu - no commitment in blocks", func(t *testing.T) {
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testIsAvailableParams{})
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err := service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
+
 	t.Run("Fulu - more than half of the columns in custody", func(t *testing.T) {
 		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct)
@@ -2991,9 +2977,7 @@ func TestIsDataAvailable(t *testing.T) {
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err := service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
@@ -3005,9 +2989,7 @@ func TestIsDataAvailable(t *testing.T) {
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err := service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
@@ -3055,9 +3037,7 @@ func TestIsDataAvailable(t *testing.T) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
 		defer cancel()
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
@@ -3119,9 +3099,7 @@ func TestIsDataAvailable(t *testing.T) {
 		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
 		defer cancel()
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
 
@@ -3140,9 +3118,7 @@ func TestIsDataAvailable(t *testing.T) {
 			cancel()
 		}()
 
-		roBlock, err := consensusblocks.NewROBlockWithRoot(signed, root)
-		require.NoError(t, err)
-		err = service.isDataAvailable(ctx, roBlock)
+		err := service.isDataAvailable(ctx, root, signed)
 		require.NotNil(t, err)
 	})
 }
@@ -3214,11 +3190,6 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 	s.cfg.P2P = &mockp2p.FakeP2P{}
 	ctx := tr.ctx
 
-	headState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, s.cfg.BeaconDB.SaveState(ctx, headState, [32]byte{1, 2}))
-	require.NoError(t, s.cfg.BeaconDB.SaveHeadBlockRoot(ctx, [32]byte{1, 2}))
-
 	testCases := []struct {
 		name          string
 		oldOptions    []util.LightClientOption
@@ -3234,7 +3205,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 		{
 			name:          "Same age",
 			oldOptions:    []util.LightClientOption{},
-			newOptions:    []util.LightClientOption{util.WithSupermajority(0)}, // supermajority does not matter here and is only added to result in two different updates
+			newOptions:    []util.LightClientOption{util.WithSupermajority()}, // supermajority does not matter here and is only added to result in two different updates
 			expectReplace: false,
 		},
 		{
@@ -3278,14 +3249,14 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = lightClient.NewLightClientStore(s.cfg.P2P, s.cfg.StateNotifier.StateFeed(), s.cfg.BeaconDB)
+				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
 
 				var oldActualUpdate interfaces.LightClientOptimisticUpdate
 				var err error
 				if tc.oldOptions != nil {
 					// config for old update
 					lOld, cfgOld := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.oldOptions...)
-					s.processLightClientUpdates(cfgOld)
+					require.NoError(t, s.processLightClientOptimisticUpdate(cfgOld.ctx, cfgOld.roblock, cfgOld.postState))
 
 					oldActualUpdate, err = lightClient.NewLightClientOptimisticUpdateFromBeaconState(lOld.Ctx, lOld.State, lOld.Block, lOld.AttestedState, lOld.AttestedBlock)
 					require.NoError(t, err)
@@ -3299,7 +3270,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 
 				// config for new update
 				lNew, cfgNew := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.newOptions...)
-				s.processLightClientUpdates(cfgNew)
+				require.NoError(t, s.processLightClientOptimisticUpdate(cfgNew.ctx, cfgNew.roblock, cfgNew.postState))
 
 				newActualUpdate, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lNew.Ctx, lNew.State, lNew.Block, lNew.AttestedState, lNew.AttestedBlock)
 				require.NoError(t, err)
@@ -3340,7 +3311,6 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 	s, tr := minimalTestService(t)
 	s.cfg.P2P = &mockp2p.FakeP2P{}
 	ctx := tr.ctx
-	s.head = &head{}
 
 	testCases := []struct {
 		name          string
@@ -3419,18 +3389,15 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 
 			t.Run(version.String(testVersion)+"_"+tc.name, func(t *testing.T) {
 				s.genesisTime = time.Unix(time.Now().Unix()-(int64(forkEpoch)*int64(params.BeaconConfig().SlotsPerEpoch)*int64(params.BeaconConfig().SecondsPerSlot)), 0)
-				s.lcStore = lightClient.NewLightClientStore(s.cfg.P2P, s.cfg.StateNotifier.StateFeed(), s.cfg.BeaconDB)
+				s.lcStore = lightClient.NewLightClientStore(s.cfg.BeaconDB, s.cfg.P2P, s.cfg.StateNotifier.StateFeed())
 
 				var actualOldUpdate, actualNewUpdate interfaces.LightClientFinalityUpdate
+				var err error
 
 				if tc.oldOptions != nil {
 					// config for old update
 					lOld, cfgOld := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.oldOptions...)
-					blkRoot, err := lOld.Block.Block().HashTreeRoot()
-					require.NoError(t, err)
-					s.head.block = lOld.Block
-					s.head.root = blkRoot
-					s.processLightClientUpdates(cfgOld)
+					require.NoError(t, s.processLightClientFinalityUpdate(cfgOld.ctx, cfgOld.roblock, cfgOld.postState))
 
 					// check that the old update is saved
 					actualOldUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(ctx, cfgOld.postState, cfgOld.roblock, lOld.AttestedState, lOld.AttestedBlock, lOld.FinalizedBlock)
@@ -3441,11 +3408,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 
 				// config for new update
 				lNew, cfgNew := setupLightClientTestRequirements(ctx, t, s, testVersion, tc.newOptions...)
-				blkRoot, err := lNew.Block.Block().HashTreeRoot()
-				require.NoError(t, err)
-				s.head.block = lNew.Block
-				s.head.root = blkRoot
-				s.processLightClientUpdates(cfgNew)
+				require.NoError(t, s.processLightClientFinalityUpdate(cfgNew.ctx, cfgNew.roblock, cfgNew.postState))
 
 				// check that the actual old update and the actual new update are different
 				actualNewUpdate, err = lightClient.NewLightClientFinalityUpdateFromBeaconState(ctx, cfgNew.postState, cfgNew.roblock, lNew.AttestedState, lNew.AttestedBlock, lNew.FinalizedBlock)

beacon-chain/blockchain/receive_block.go

@@ -16,6 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/slasher/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -92,7 +93,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 
 	blockCopy, err := block.Copy()
 	if err != nil {
-		return errors.Wrap(err, "block copy")
+		return err
 	}
 
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
@@ -103,17 +104,17 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	currentCheckpoints := s.saveCurrentCheckpoints(preState)
 	roblock, err := blocks.NewROBlockWithRoot(blockCopy, blockRoot)
 	if err != nil {
-		return errors.Wrap(err, "new ro block with root")
+		return err
 	}
 
 	postState, isValidPayload, err := s.validateExecutionAndConsensus(ctx, preState, roblock)
 	if err != nil {
-		return errors.Wrap(err, "validator execution and consensus")
+		return err
 	}
 
-	daWaitedTime, err := s.handleDA(ctx, avs, roblock)
+	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
 	if err != nil {
-		return errors.Wrap(err, "handle da")
+		return err
 	}
 
 	// Defragment the state before continuing block processing.
@@ -134,10 +135,10 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err := s.postBlockProcess(args); err != nil {
 		err := errors.Wrap(err, "could not process block")
 		tracing.AnnotateError(span, err)
-		return errors.Wrap(err, "post block process")
+		return err
 	}
 	if err := s.updateCheckpoints(ctx, currentCheckpoints, preState, postState, blockRoot); err != nil {
-		return errors.Wrap(err, "update checkpoints")
+		return err
 	}
 	// If slasher is configured, forward the attestations in the block via an event feed for processing.
 	if s.slasherEnabled {
@@ -151,12 +152,12 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 
 	// Have we been finalizing? Should we start saving hot states to db?
 	if err := s.checkSaveHotStateDB(ctx); err != nil {
-		return errors.Wrap(err, "check save hot state db")
+		return err
 	}
 
 	// We apply the same heuristic to some of our more important caches.
 	if err := s.handleCaches(); err != nil {
-		return errors.Wrap(err, "handle caches")
+		return err
 	}
 	s.reportPostBlockProcessing(blockCopy, blockRoot, receivedTime, daWaitedTime)
 	return nil
@@ -239,19 +240,37 @@ func (s *Service) validateExecutionAndConsensus(
 	return postState, isValidPayload, nil
 }
 
-func (s *Service) handleDA(ctx context.Context, avs das.AvailabilityStore, block blocks.ROBlock) (time.Duration, error) {
-	var err error
-	start := time.Now()
-	if avs != nil {
-		err = avs.IsDataAvailable(ctx, s.CurrentSlot(), block)
-	} else {
-		err = s.isDataAvailable(ctx, block)
+func (s *Service) handleDA(
+	ctx context.Context,
+	block interfaces.SignedBeaconBlock,
+	blockRoot [fieldparams.RootLength]byte,
+	avs das.AvailabilityStore,
+) (elapsed time.Duration, err error) {
+	defer func(start time.Time) {
+		elapsed = time.Since(start)
+
+		if err == nil {
+			dataAvailWaitedTime.Observe(float64(elapsed.Milliseconds()))
+		}
+	}(time.Now())
+
+	if avs == nil {
+		if err = s.isDataAvailable(ctx, blockRoot, block); err != nil {
+			return
+		}
+
+		return
 	}
-	elapsed := time.Since(start)
-	if err == nil {
-		dataAvailWaitedTime.Observe(float64(elapsed.Milliseconds()))
+
+	var rob blocks.ROBlock
+	rob, err = blocks.NewROBlockWithRoot(block, blockRoot)
+	if err != nil {
+		return
 	}
-	return elapsed, err
+
+	err = avs.IsDataAvailable(ctx, s.CurrentSlot(), rob)
+
+	return
 }
 
 func (s *Service) reportPostBlockProcessing(
@@ -301,28 +320,13 @@ func (s *Service) executePostFinalizationTasks(ctx context.Context, finalizedSta
 	if features.Get().EnableLightClient {
 		// Save a light client bootstrap for the finalized checkpoint
 		go func() {
-			st, err := s.cfg.StateGen.StateByRoot(ctx, finalized.Root)
-			if err != nil {
-				log.WithError(err).Error("Could not retrieve state for finalized root to save light client bootstrap")
-				return
-			}
-			err = s.lcStore.SaveLightClientBootstrap(s.ctx, finalized.Root, st)
+			err := s.lcStore.SaveLightClientBootstrap(s.ctx, finalized.Root)
 			if err != nil {
 				log.WithError(err).Error("Could not save light client bootstrap by block root")
 			} else {
 				log.Debugf("Saved light client bootstrap for finalized root %#x", finalized.Root)
 			}
 		}()
-
-		// Clean up the light client store caches
-		go func() {
-			err := s.lcStore.MigrateToCold(s.ctx, finalized.Root)
-			if err != nil {
-				log.WithError(err).Error("Could not migrate light client store to cold storage")
-			} else {
-				log.Debugf("Migrated light client store to cold storage for finalized root %#x", finalized.Root)
-			}
-		}()
 	}
 }
 

beacon-chain/blockchain/receive_block_test.go

@@ -9,9 +9,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/das"
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/voluntaryexits"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -192,9 +192,7 @@ func TestHandleDA(t *testing.T) {
 	require.NoError(t, err)
 
 	s, _ := minimalTestService(t)
-	block, err := blocks.NewROBlockWithRoot(signedBeaconBlock, [32]byte{})
-	require.NoError(t, err)
-	elapsed, err := s.handleDA(t.Context(), nil, block)
+	elapsed, err := s.handleDA(t.Context(), signedBeaconBlock, [fieldparams.RootLength]byte{}, nil)
 	require.NoError(t, err)
 	require.Equal(t, true, elapsed > 0, "Elapsed time should be greater than 0")
 }
@@ -596,7 +594,11 @@ func TestProcessLightClientBootstrap(t *testing.T) {
 
 			require.NoError(t, s.cfg.ForkChoiceStore.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: cp.Epoch, Root: [32]byte(cp.Root)}))
 
-			s.executePostFinalizationTasks(s.ctx, l.AttestedState)
+			sss, err := s.cfg.BeaconDB.State(ctx, finalizedBlockRoot)
+			require.NoError(t, err)
+			require.NotNil(t, sss)
+
+			s.executePostFinalizationTasks(s.ctx, l.FinalizedState)
 
 			// wait for the goroutine to finish processing
 			time.Sleep(1 * time.Second)

beacon-chain/blockchain/service.go

@@ -14,13 +14,13 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	coreTime "github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	f "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/slashings"

beacon-chain/blockchain/service_test.go

@@ -562,9 +562,8 @@ func TestNotifyIndex(t *testing.T) {
 	var root [32]byte
 	copy(root[:], "exampleRoot")
 
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
 	// Test notifying a new index
-	bn.notifyIndex(root, 1, ds)
+	bn.notifyIndex(root, 1, 1)
 	if !bn.seenIndex[root][1] {
 		t.Errorf("Index was not marked as seen")
 	}
@@ -581,7 +580,7 @@ func TestNotifyIndex(t *testing.T) {
 	}
 
 	// Test notifying a new index again
-	bn.notifyIndex(root, 2, ds)
+	bn.notifyIndex(root, 2, 1)
 	if !bn.seenIndex[root][2] {
 		t.Errorf("Index was not marked as seen")
 	}

beacon-chain/blockchain/setup_forchoice.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"context"
 	"fmt"
-	"slices"
 
 	forkchoicetypes "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
@@ -113,7 +112,6 @@ func (s *Service) buildForkchoiceChain(ctx context.Context, head interfaces.Read
 			return nil, errors.New("head block is not a descendant of the finalized checkpoint")
 		}
 	}
-	slices.Reverse(chain)
 	return chain, nil
 }
 

beacon-chain/blockchain/setup_forkchoice_test.go

@@ -124,5 +124,5 @@ func Test_setupForkchoiceTree_Head(t *testing.T) {
 	require.NotEqual(t, fRoot, root)
 	require.Equal(t, root, service.startupHeadRoot())
 	require.NoError(t, service.setupForkchoiceTree(st))
-	require.Equal(t, 3, service.cfg.ForkChoiceStore.NodeCount())
+	require.Equal(t, 2, service.cfg.ForkChoiceStore.NodeCount())
 }

beacon-chain/blockchain/setup_test.go

@@ -11,21 +11,21 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	mockExecution "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
 	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
@@ -89,7 +89,7 @@ func (mb *mockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumnSidecars(_ context.Context, _ []blocks.VerifiedRODataColumn) error {
+func (mb *mockBroadcaster) BroadcastDataColumnSidecar(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
 	mb.broadcastCalled = true
 	return nil
 }
@@ -106,14 +106,14 @@ type mockCustodyManager struct {
 	custodyGroupCount     uint64
 }
 
-func (dch *mockCustodyManager) EarliestAvailableSlot(context.Context) (primitives.Slot, error) {
+func (dch *mockCustodyManager) EarliestAvailableSlot() (primitives.Slot, error) {
 	dch.mut.RLock()
 	defer dch.mut.RUnlock()
 
 	return dch.earliestAvailableSlot, nil
 }
 
-func (dch *mockCustodyManager) CustodyGroupCount(context.Context) (uint64, error) {
+func (dch *mockCustodyManager) CustodyGroupCount() (uint64, error) {
 	dch.mut.RLock()
 	defer dch.mut.RUnlock()
 

beacon-chain/blockchain/testing/mock.go

@@ -723,8 +723,7 @@ func (c *ChainService) ReceiveDataColumn(dc blocks.VerifiedRODataColumn) error {
 }
 
 // ReceiveDataColumns implements the same method in chain service
-func (c *ChainService) ReceiveDataColumns(dcs []blocks.VerifiedRODataColumn) error {
-	c.DataColumns = append(c.DataColumns, dcs...)
+func (*ChainService) ReceiveDataColumns(_ []blocks.VerifiedRODataColumn) error {
 	return nil
 }
 

beacon-chain/cache/committee.go

@@ -5,6 +5,7 @@ package cache
 import (
 	"context"
 	"errors"
+	"math"
 	"sync"
 	"time"
 
@@ -271,7 +272,7 @@ func (c *CommitteeCache) checkInProgress(ctx context.Context, seed [32]byte) err
 		// for the in progress boolean to flip to false.
 		time.Sleep(time.Duration(delay) * time.Nanosecond)
 		delay *= delayFactor
-		delay = min(delay, maxDelay)
+		delay = math.Min(delay, maxDelay)
 	}
 	return nil
 }

beacon-chain/cache/depositsnapshot/merkle_tree.go

@@ -52,7 +52,7 @@ func create(leaves [][32]byte, depth uint64) MerkleTreeNode {
 	if depth == 0 {
 		return &LeafNode{hash: leaves[0]}
 	}
-	split := min(math.PowerOf2(depth-1), length)
+	split := math.Min(math.PowerOf2(depth-1), length)
 	left := create(leaves[0:split], depth-1)
 	right := create(leaves[split:], depth-1)
 	return &InnerNode{left: left, right: right}

beacon-chain/cache/skip_slot_cache.go

@@ -2,6 +2,7 @@ package cache
 
 import (
 	"context"
+	"math"
 	"sync"
 	"time"
 
@@ -89,7 +90,7 @@ func (c *SkipSlotCache) Get(ctx context.Context, r [32]byte) (state.BeaconState,
 		// for the in progress boolean to flip to false.
 		time.Sleep(time.Duration(delay) * time.Nanosecond)
 		delay *= delayFactor
-		delay = min(delay, maxDelay)
+		delay = math.Min(delay, maxDelay)
 	}
 	span.SetAttributes(trace.BoolAttribute("inProgress", inProgress))
 

beacon-chain/core/altair/sync_committee.go

@@ -16,6 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/math"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -208,7 +209,7 @@ func IsSyncCommitteeAggregator(sig []byte) (bool, error) {
 	}
 
 	cfg := params.BeaconConfig()
-	modulo := max(1, cfg.SyncCommitteeSize/cfg.SyncCommitteeSubnetCount/cfg.TargetAggregatorsPerSyncSubcommittee)
+	modulo := math.Max(1, cfg.SyncCommitteeSize/cfg.SyncCommitteeSubnetCount/cfg.TargetAggregatorsPerSyncSubcommittee)
 	hashedSig := hash.Hash(sig)
 	return bytesutil.FromBytes8(hashedSig[:8])%modulo == 0, nil
 }

beacon-chain/core/blocks/BUILD.bazel

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

beacon-chain/core/blocks/attester_slashing.go

@@ -42,9 +42,6 @@ func ProcessAttesterSlashings(
 	slashings []ethpb.AttSlashing,
 	exitInfo *validators.ExitInfo,
 ) (state.BeaconState, error) {
-	if exitInfo == nil && len(slashings) > 0 {
-		return nil, errors.New("exit info required to process attester slashings")
-	}
 	var err error
 	for _, slashing := range slashings {
 		beaconState, err = ProcessAttesterSlashing(ctx, beaconState, slashing, exitInfo)
@@ -62,9 +59,6 @@ func ProcessAttesterSlashing(
 	slashing ethpb.AttSlashing,
 	exitInfo *validators.ExitInfo,
 ) (state.BeaconState, error) {
-	if exitInfo == nil {
-		return nil, errors.New("exit info is required to process attester slashing")
-	}
 	if err := VerifyAttesterSlashing(ctx, beaconState, slashing); err != nil {
 		return nil, errors.Wrap(err, "could not verify attester slashing")
 	}

beacon-chain/core/blocks/deposit.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/contracts/deposit"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/math"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
@@ -33,7 +34,7 @@ func ActivateValidatorWithEffectiveBalance(beaconState state.BeaconState, deposi
 		if err != nil {
 			return nil, err
 		}
-		validator.EffectiveBalance = min(balance-balance%params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance)
+		validator.EffectiveBalance = math.Min(balance-balance%params.BeaconConfig().EffectiveBalanceIncrement, params.BeaconConfig().MaxEffectiveBalance)
 		if validator.EffectiveBalance ==
 			params.BeaconConfig().MaxEffectiveBalance {
 			validator.ActivationEligibilityEpoch = 0

beacon-chain/core/blocks/exit.go

@@ -55,9 +55,6 @@ func ProcessVoluntaryExits(
 	if len(exits) == 0 {
 		return beaconState, nil
 	}
-	if exitInfo == nil {
-		return nil, errors.New("exit info required to process voluntary exits")
-	}
 	for idx, exit := range exits {
 		if exit == nil || exit.Exit == nil {
 			return nil, errors.New("nil voluntary exit in block body")

beacon-chain/core/blocks/genesis.go

@@ -184,54 +184,45 @@ func NewGenesisBlockForState(ctx context.Context, st state.BeaconState) (interfa
 		})
 	case *ethpb.BeaconStateElectra:
 		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{
-			Block:     electraGenesisBlock(root),
-			Signature: params.BeaconConfig().EmptySignature[:],
-		})
-	case *ethpb.BeaconStateFulu:
-		return blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockFulu{
-			Block:     electraGenesisBlock(root),
+			Block: &ethpb.BeaconBlockElectra{
+				ParentRoot: params.BeaconConfig().ZeroHash[:],
+				StateRoot:  root[:],
+				Body: &ethpb.BeaconBlockBodyElectra{
+					RandaoReveal: make([]byte, 96),
+					Eth1Data: &ethpb.Eth1Data{
+						DepositRoot: make([]byte, 32),
+						BlockHash:   make([]byte, 32),
+					},
+					Graffiti: make([]byte, 32),
+					SyncAggregate: &ethpb.SyncAggregate{
+						SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
+						SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
+					},
+					ExecutionPayload: &enginev1.ExecutionPayloadDeneb{
+						ParentHash:    make([]byte, 32),
+						FeeRecipient:  make([]byte, 20),
+						StateRoot:     make([]byte, 32),
+						ReceiptsRoot:  make([]byte, 32),
+						LogsBloom:     make([]byte, 256),
+						PrevRandao:    make([]byte, 32),
+						ExtraData:     make([]byte, 0),
+						BaseFeePerGas: make([]byte, 32),
+						BlockHash:     make([]byte, 32),
+						Transactions:  make([][]byte, 0),
+						Withdrawals:   make([]*enginev1.Withdrawal, 0),
+					},
+					BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
+					BlobKzgCommitments:    make([][]byte, 0),
+					ExecutionRequests: &enginev1.ExecutionRequests{
+						Withdrawals:    make([]*enginev1.WithdrawalRequest, 0),
+						Deposits:       make([]*enginev1.DepositRequest, 0),
+						Consolidations: make([]*enginev1.ConsolidationRequest, 0),
+					},
+				},
+			},
 			Signature: params.BeaconConfig().EmptySignature[:],
 		})
 	default:
 		return nil, ErrUnrecognizedState
 	}
 }
-
-func electraGenesisBlock(root [fieldparams.RootLength]byte) *ethpb.BeaconBlockElectra {
-	return &ethpb.BeaconBlockElectra{
-		ParentRoot: params.BeaconConfig().ZeroHash[:],
-		StateRoot:  root[:],
-		Body: &ethpb.BeaconBlockBodyElectra{
-			RandaoReveal: make([]byte, 96),
-			Eth1Data: &ethpb.Eth1Data{
-				DepositRoot: make([]byte, 32),
-				BlockHash:   make([]byte, 32),
-			},
-			Graffiti: make([]byte, 32),
-			SyncAggregate: &ethpb.SyncAggregate{
-				SyncCommitteeBits:      make([]byte, fieldparams.SyncCommitteeLength/8),
-				SyncCommitteeSignature: make([]byte, fieldparams.BLSSignatureLength),
-			},
-			ExecutionPayload: &enginev1.ExecutionPayloadDeneb{
-				ParentHash:    make([]byte, 32),
-				FeeRecipient:  make([]byte, 20),
-				StateRoot:     make([]byte, 32),
-				ReceiptsRoot:  make([]byte, 32),
-				LogsBloom:     make([]byte, 256),
-				PrevRandao:    make([]byte, 32),
-				ExtraData:     make([]byte, 0),
-				BaseFeePerGas: make([]byte, 32),
-				BlockHash:     make([]byte, 32),
-				Transactions:  make([][]byte, 0),
-				Withdrawals:   make([]*enginev1.Withdrawal, 0),
-			},
-			BlsToExecutionChanges: make([]*ethpb.SignedBLSToExecutionChange, 0),
-			BlobKzgCommitments:    make([][]byte, 0),
-			ExecutionRequests: &enginev1.ExecutionRequests{
-				Withdrawals:    make([]*enginev1.WithdrawalRequest, 0),
-				Deposits:       make([]*enginev1.DepositRequest, 0),
-				Consolidations: make([]*enginev1.ConsolidationRequest, 0),
-			},
-		},
-	}
-}

beacon-chain/core/blocks/proposer_slashing.go

@@ -51,9 +51,6 @@ func ProcessProposerSlashings(
 	slashings []*ethpb.ProposerSlashing,
 	exitInfo *validators.ExitInfo,
 ) (state.BeaconState, error) {
-	if exitInfo == nil && len(slashings) > 0 {
-		return nil, errors.New("exit info required to process proposer slashings")
-	}
 	var err error
 	for _, slashing := range slashings {
 		beaconState, err = ProcessProposerSlashing(ctx, beaconState, slashing, exitInfo)
@@ -78,9 +75,6 @@ func ProcessProposerSlashing(
 	if err = VerifyProposerSlashing(beaconState, slashing); err != nil {
 		return nil, errors.Wrap(err, "could not verify proposer slashing")
 	}
-	if exitInfo == nil {
-		return nil, errors.New("exit info is required to process proposer slashing")
-	}
 	beaconState, err = validators.SlashValidator(ctx, beaconState, slashing.Header_1.Header.ProposerIndex, exitInfo)
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not slash proposer index %d", slashing.Header_1.Header.ProposerIndex)

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -53,15 +53,9 @@ func ProcessOperations(ctx context.Context, st state.BeaconState, block interfac
 	// 6110 validations are in VerifyOperationLengths
 	bb := block.Body()
 	// Electra extends the altair operations.
-	var exitInfo *v.ExitInfo
-	hasSlashings := len(bb.ProposerSlashings()) > 0 || len(bb.AttesterSlashings()) > 0
-	hasExits := len(bb.VoluntaryExits()) > 0
-	if hasSlashings || hasExits {
-		// ExitInformation is expensive to compute, only do it if we need it.
-		exitInfo = v.ExitInformation(st)
-		if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
-			return nil, errors.Wrap(err, "could not update total active balance cache")
-		}
+	exitInfo := v.ExitInformation(st)
+	if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
+		return nil, errors.Wrap(err, "could not update total active balance cache")
 	}
 	st, err = ProcessProposerSlashings(ctx, st, bb.ProposerSlashings(), exitInfo)
 	if err != nil {

beacon-chain/core/electra/withdrawals.go

@@ -13,7 +13,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
@@ -92,18 +91,6 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 	ctx, span := trace.StartSpan(ctx, "electra.ProcessWithdrawalRequests")
 	defer span.End()
 	currentEpoch := slots.ToEpoch(st.Slot())
-	if len(wrs) == 0 {
-		return st, nil
-	}
-	// It is correct to compute exitInfo once for all withdrawals in the block, as the ExitInfo pointer is
-	// updated within InitiateValidatorExit which is the only function that uses it.
-	var exitInfo *validators.ExitInfo
-	if st.Version() < version.Electra {
-		exitInfo = validators.ExitInformation(st)
-	} else {
-		// After Electra, the function InitiateValidatorExit ignores the exitInfo passed to it and recomputes it anyway.
-		exitInfo = &validators.ExitInfo{}
-	}
 	for _, wr := range wrs {
 		if wr == nil {
 			return nil, errors.New("nil execution layer withdrawal request")
@@ -161,8 +148,7 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 			// Only exit validator if it has no pending withdrawals in the queue
 			if pendingBalanceToWithdraw == 0 {
 				var err error
-				// exitInfo is updated within InitiateValidatorExit
-				st, err = validators.InitiateValidatorExit(ctx, st, vIdx, exitInfo)
+				st, err = validators.InitiateValidatorExit(ctx, st, vIdx, validators.ExitInformation(st))
 				if err != nil {
 					return nil, err
 				}

beacon-chain/core/epoch/epoch_processing.go

@@ -96,17 +96,12 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 	}
 
 	// Process validators eligible for ejection.
-	if len(eligibleForEjection) > 0 {
-		// It is safe to compute exitInfo once for all ejections in the epoch, as the ExitInfo pointer is
-		// updated within InitiateValidatorExit which is the only function that uses it.
-		exitInfo := validators.ExitInformation(st)
-		for _, idx := range eligibleForEjection {
-			// Here is fine to do a quadratic loop since this should
-			// barely happen
-			st, err = validators.InitiateValidatorExit(ctx, st, idx, exitInfo)
-			if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
-				return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
-			}
+	for _, idx := range eligibleForEjection {
+		// Here is fine to do a quadratic loop since this should
+		// barely happen
+		st, err = validators.InitiateValidatorExit(ctx, st, idx, validators.ExitInformation(st))
+		if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
+			return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
 		}
 	}
 
@@ -233,7 +228,7 @@ func ProcessSlashings(st state.BeaconState) error {
 	// a callback is used here to apply the following actions to all validators
 	// below equally.
 	increment := params.BeaconConfig().EffectiveBalanceIncrement
-	minSlashing := min(totalSlashing*slashingMultiplier, totalBalance)
+	minSlashing := math.Min(totalSlashing*slashingMultiplier, totalBalance)
 
 	// Modified in Electra:EIP7251
 	var penaltyPerEffectiveBalanceIncrement uint64

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

@@ -5,6 +5,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/math"
 )
 
 // ProcessSlashingsPrecompute processes the slashed validators during epoch processing.
@@ -20,7 +21,7 @@ func ProcessSlashingsPrecompute(s state.BeaconState, pBal *Balance) error {
 		totalSlashing += slashing
 	}
 
-	minSlashing := min(totalSlashing*params.BeaconConfig().ProportionalSlashingMultiplier, pBal.ActiveCurrentEpoch)
+	minSlashing := math.Min(totalSlashing*params.BeaconConfig().ProportionalSlashingMultiplier, pBal.ActiveCurrentEpoch)
 	epochToWithdraw := currentEpoch + exitLength/2
 
 	var hasSlashing bool

beacon-chain/core/gloas/BUILD.bazel

@@ -0,0 +1,19 @@
+load("@prysm//tools/go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["upgrade.go"],
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/gloas",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/time:go_default_library",
+        "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/state-native:go_default_library",
+        "//config/params:go_default_library",
+        "//proto/engine/v1:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//time/slots:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)

beacon-chain/core/gloas/upgrade.go

@@ -0,0 +1,189 @@
+package gloas
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/pkg/errors"
+)
+
+// UpgradeToGloas updates inputs a generic state to return the version Gloas state.
+// This implements the upgrade_to_eip7928 function from the specification.
+func UpgradeToGloas(ctx context.Context, beaconState state.BeaconState) (state.BeaconState, error) {
+	epoch := time.CurrentEpoch(beaconState)
+
+	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := beaconState.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := beaconState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := payloadHeader.TransactionsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wdRoot, err := payloadHeader.WithdrawalsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := beaconState.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := beaconState.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := beaconState.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	excessBlobGas, err := payloadHeader.ExcessBlobGas()
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payloadHeader.BlobGasUsed()
+	if err != nil {
+		return nil, err
+	}
+	depositRequestsStartIndex, err := beaconState.DepositRequestsStartIndex()
+	if err != nil {
+		return nil, err
+	}
+	depositBalanceToConsume, err := beaconState.DepositBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	exitBalanceToConsume, err := beaconState.ExitBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	earliestExitEpoch, err := beaconState.EarliestExitEpoch()
+	if err != nil {
+		return nil, err
+	}
+	consolidationBalanceToConsume, err := beaconState.ConsolidationBalanceToConsume()
+	if err != nil {
+		return nil, err
+	}
+	earliestConsolidationEpoch, err := beaconState.EarliestConsolidationEpoch()
+	if err != nil {
+		return nil, err
+	}
+	pendingDeposits, err := beaconState.PendingDeposits()
+	if err != nil {
+		return nil, err
+	}
+	pendingPartialWithdrawals, err := beaconState.PendingPartialWithdrawals()
+	if err != nil {
+		return nil, err
+	}
+	pendingConsolidations, err := beaconState.PendingConsolidations()
+	if err != nil {
+		return nil, err
+	}
+	proposerLookahead, err := helpers.InitializeProposerLookahead(ctx, beaconState, slots.ToEpoch(beaconState.Slot()))
+	if err != nil {
+		return nil, err
+	}
+
+	// Create the new Gloas execution payload header with block_access_list_root
+	// as specified in the EIP7928 upgrade function
+	latestExecutionPayloadHeader := &enginev1.ExecutionPayloadHeaderGloas{
+		ParentHash:          payloadHeader.ParentHash(),
+		FeeRecipient:        payloadHeader.FeeRecipient(),
+		StateRoot:           payloadHeader.StateRoot(),
+		ReceiptsRoot:        payloadHeader.ReceiptsRoot(),
+		LogsBloom:           payloadHeader.LogsBloom(),
+		PrevRandao:          payloadHeader.PrevRandao(),
+		BlockNumber:         payloadHeader.BlockNumber(),
+		GasLimit:            payloadHeader.GasLimit(),
+		GasUsed:             payloadHeader.GasUsed(),
+		Timestamp:           payloadHeader.Timestamp(),
+		ExtraData:           payloadHeader.ExtraData(),
+		BaseFeePerGas:       payloadHeader.BaseFeePerGas(),
+		BlockHash:           payloadHeader.BlockHash(),
+		TransactionsRoot:    txRoot,
+		WithdrawalsRoot:     wdRoot,
+		BlobGasUsed:         blobGasUsed,
+		ExcessBlobGas:       excessBlobGas,
+		BlockAccessListRoot: make([]byte, 32), // New in EIP7928 - empty Root()
+	}
+
+	s := &ethpb.BeaconStateGloas{
+		GenesisTime:           uint64(beaconState.GenesisTime().Unix()),
+		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
+		Slot:                  beaconState.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: beaconState.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().GloasForkVersion, // Modified in EIP7928
+			Epoch:           epoch,
+		},
+		LatestBlockHeader:             beaconState.LatestBlockHeader(),
+		BlockRoots:                    beaconState.BlockRoots(),
+		StateRoots:                    beaconState.StateRoots(),
+		HistoricalRoots:               beaconState.HistoricalRoots(),
+		Eth1Data:                      beaconState.Eth1Data(),
+		Eth1DataVotes:                 beaconState.Eth1DataVotes(),
+		Eth1DepositIndex:              beaconState.Eth1DepositIndex(),
+		Validators:                    beaconState.Validators(),
+		Balances:                      beaconState.Balances(),
+		RandaoMixes:                   beaconState.RandaoMixes(),
+		Slashings:                     beaconState.Slashings(),
+		PreviousEpochParticipation:    prevEpochParticipation,
+		CurrentEpochParticipation:     currentEpochParticipation,
+		JustificationBits:             beaconState.JustificationBits(),
+		PreviousJustifiedCheckpoint:   beaconState.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:    beaconState.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:           beaconState.FinalizedCheckpoint(),
+		InactivityScores:              inactivityScores,
+		CurrentSyncCommittee:          currentSyncCommittee,
+		NextSyncCommittee:             nextSyncCommittee,
+		LatestExecutionPayloadHeader:  latestExecutionPayloadHeader,
+		NextWithdrawalIndex:           wi,
+		NextWithdrawalValidatorIndex:  vi,
+		HistoricalSummaries:           summaries,
+		DepositRequestsStartIndex:     depositRequestsStartIndex,
+		DepositBalanceToConsume:       depositBalanceToConsume,
+		ExitBalanceToConsume:          exitBalanceToConsume,
+		EarliestExitEpoch:             earliestExitEpoch,
+		ConsolidationBalanceToConsume: consolidationBalanceToConsume,
+		EarliestConsolidationEpoch:    earliestConsolidationEpoch,
+		PendingDeposits:               pendingDeposits,
+		PendingPartialWithdrawals:     pendingPartialWithdrawals,
+		PendingConsolidations:         pendingConsolidations,
+		ProposerLookahead:             proposerLookahead,
+	}
+
+	post, err := state_native.InitializeFromProtoUnsafeGloas(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post gloas beaconState")
+	}
+
+	return post, nil
+}

beacon-chain/core/helpers/BUILD.bazel

@@ -10,7 +10,6 @@ go_library(
         "legacy.go",
         "metrics.go",
         "randao.go",
-        "ranges.go",
         "rewards_penalties.go",
         "shuffle.go",
         "sync_committee.go",
@@ -57,7 +56,6 @@ go_test(
         "private_access_fuzz_noop_test.go",  # keep
         "private_access_test.go",
         "randao_test.go",
-        "ranges_test.go",
         "rewards_penalties_test.go",
         "shuffle_test.go",
         "sync_committee_test.go",

beacon-chain/core/helpers/beacon_committee.go

@@ -399,6 +399,7 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	ctx, span := trace.StartSpan(ctx, "helpers.CommitteeAssignments")
 	defer span.End()
 
+	// Verify if the epoch is valid for assignment based on the provided state.
 	if err := VerifyAssignmentEpoch(epoch, state); err != nil {
 		return nil, err
 	}
@@ -406,15 +407,12 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 	if err != nil {
 		return nil, err
 	}
-
-	// Deduplicate and make set for O(1) membership checks.
-	vals := make(map[primitives.ValidatorIndex]struct{}, len(validators))
+	vals := make(map[primitives.ValidatorIndex]struct{})
 	for _, v := range validators {
 		vals[v] = struct{}{}
 	}
-	remaining := len(vals)
-
-	assignments := make(map[primitives.ValidatorIndex]*CommitteeAssignment, len(vals))
+	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 {
@@ -422,7 +420,7 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 		}
 		for j, committee := range committees {
 			for _, vIndex := range committee {
-				if _, ok := vals[vIndex]; !ok {
+				if _, ok := vals[vIndex]; !ok { // Skip if the validator is not in the provided validators slice.
 					continue
 				}
 				if _, ok := assignments[vIndex]; !ok {
@@ -431,11 +429,6 @@ func CommitteeAssignments(ctx context.Context, state state.BeaconState, epoch pr
 				assignments[vIndex].Committee = committee
 				assignments[vIndex].AttesterSlot = slot
 				assignments[vIndex].CommitteeIndex = primitives.CommitteeIndex(j)
-				delete(vals, vIndex)
-				remaining--
-				if remaining == 0 {
-					return assignments, nil // early exit
-				}
 			}
 		}
 	}

beacon-chain/core/helpers/ranges.go

@@ -1,62 +0,0 @@
-package helpers
-
-import (
-	"fmt"
-	"slices"
-)
-
-// SortedSliceFromMap takes a map with uint64 keys and returns a sorted slice of the keys.
-func SortedSliceFromMap(toSort map[uint64]bool) []uint64 {
-	slice := make([]uint64, 0, len(toSort))
-	for key := range toSort {
-		slice = append(slice, key)
-	}
-
-	slices.Sort(slice)
-	return slice
-}
-
-// PrettySlice returns a pretty string representation of a sorted slice of uint64.
-// `sortedSlice` must be sorted in ascending order.
-// Example: [1,2,3,5,6,7,8,10] -> "1-3,5-8,10"
-func PrettySlice(sortedSlice []uint64) string {
-	if len(sortedSlice) == 0 {
-		return ""
-	}
-
-	var result string
-	start := sortedSlice[0]
-	end := sortedSlice[0]
-
-	for i := 1; i < len(sortedSlice); i++ {
-		if sortedSlice[i] == end+1 {
-			end = sortedSlice[i]
-			continue
-		}
-
-		if start == end {
-			result += fmt.Sprintf("%d,", start)
-			start = sortedSlice[i]
-			end = sortedSlice[i]
-			continue
-		}
-
-		result += fmt.Sprintf("%d-%d,", start, end)
-		start = sortedSlice[i]
-		end = sortedSlice[i]
-	}
-
-	if start == end {
-		result += fmt.Sprintf("%d", start)
-		return result
-	}
-
-	result += fmt.Sprintf("%d-%d", start, end)
-	return result
-}
-
-// SortedPrettySliceFromMap combines SortedSliceFromMap and PrettySlice to return a pretty string representation of the keys in a map.
-func SortedPrettySliceFromMap(toSort map[uint64]bool) string {
-	sorted := SortedSliceFromMap(toSort)
-	return PrettySlice(sorted)
-}

beacon-chain/core/helpers/ranges_test.go

@@ -1,64 +0,0 @@
-package helpers_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestSortedSliceFromMap(t *testing.T) {
-	input := map[uint64]bool{5: true, 3: true, 8: true, 1: true}
-	expected := []uint64{1, 3, 5, 8}
-
-	actual := helpers.SortedSliceFromMap(input)
-	require.Equal(t, len(expected), len(actual))
-
-	for i := range expected {
-		require.Equal(t, expected[i], actual[i])
-	}
-}
-
-func TestPrettySlice(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    []uint64
-		expected string
-	}{
-		{
-			name:     "empty slice",
-			input:    []uint64{},
-			expected: "",
-		},
-		{
-			name:     "only distinct elements",
-			input:    []uint64{1, 3, 5, 7, 9},
-			expected: "1,3,5,7,9",
-		},
-		{
-			name:     "single range",
-			input:    []uint64{1, 2, 3, 4, 5},
-			expected: "1-5",
-		},
-		{
-			name:     "multiple ranges and distinct elements",
-			input:    []uint64{1, 2, 3, 5, 6, 7, 8, 10, 12, 13, 14},
-			expected: "1-3,5-8,10,12-14",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			actual := helpers.PrettySlice(tt.input)
-			require.Equal(t, tt.expected, actual)
-		})
-	}
-}
-
-func TestSortedPrettySliceFromMap(t *testing.T) {
-	input := map[uint64]bool{5: true, 7: true, 8: true, 10: true}
-	expected := "5,7-8,10"
-
-	actual := helpers.SortedPrettySliceFromMap(input)
-	require.Equal(t, expected, actual)
-}

beacon-chain/core/helpers/rewards_penalties.go

@@ -79,7 +79,7 @@ func TotalActiveBalance(s state.ReadOnlyBeaconState) (uint64, error) {
 	}
 
 	// Spec defines `EffectiveBalanceIncrement` as min to avoid divisions by zero.
-	total = max(params.BeaconConfig().EffectiveBalanceIncrement, total)
+	total = mathutil.Max(params.BeaconConfig().EffectiveBalanceIncrement, total)
 	if err := balanceCache.AddTotalEffectiveBalance(s, total); err != nil {
 		return 0, err
 	}

beacon-chain/core/helpers/weak_subjectivity.go

@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/math"
 	v1alpha1 "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 )
@@ -94,7 +95,7 @@ func ComputeWeakSubjectivityPeriod(ctx context.Context, st state.ReadOnlyBeaconS
 	if T*(200+3*D) < t*(200+12*D) {
 		epochsForValidatorSetChurn := N * (t*(200+12*D) - T*(200+3*D)) / (600 * delta * (2*t + T))
 		epochsForBalanceTopUps := N * (200 + 3*D) / (600 * Delta)
-		wsp += max(epochsForValidatorSetChurn, epochsForBalanceTopUps)
+		wsp += math.Max(epochsForValidatorSetChurn, epochsForBalanceTopUps)
 	} else {
 		wsp += 3 * N * D * t / (200 * Delta * (T - t))
 	}

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

@@ -3,12 +3,11 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "cache.go",
         "helpers.go",
         "lightclient.go",
         "store.go",
     ],
-    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client",
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client",
     visibility = ["//visibility:public"],
     deps = [
         "//async/event:go_default_library",
@@ -39,30 +38,25 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "cache_test.go",
         "lightclient_test.go",
         "store_test.go",
     ],
-    embed = [":go_default_library"],
     deps = [
+        ":go_default_library",
         "//async/event:go_default_library",
-        "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p/testing:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/light-client:go_default_library",
-        "//consensus-types/primitives:go_default_library",
         "//encoding/ssz:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
-        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )

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

@@ -592,10 +592,6 @@ func HasFinality(update interfaces.LightClientUpdate) (bool, error) {
 }
 
 func IsBetterUpdate(newUpdate, oldUpdate interfaces.LightClientUpdate) (bool, error) {
-	if oldUpdate == nil || oldUpdate.IsNil() {
-		return true, nil
-	}
-
 	maxActiveParticipants := newUpdate.SyncAggregate().SyncCommitteeBits.Len()
 	newNumActiveParticipants := newUpdate.SyncAggregate().SyncCommitteeBits.Count()
 	oldNumActiveParticipants := oldUpdate.SyncAggregate().SyncCommitteeBits.Count()
@@ -782,7 +778,7 @@ func IsFinalityUpdateValidForBroadcast(newUpdate, oldUpdate interfaces.LightClie
 // This does not concern broadcasting, but rather the decision of whether to save the new update.
 // For broadcasting checks, use IsFinalityUpdateValidForBroadcast.
 func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityUpdate) bool {
-	if oldUpdate == nil || oldUpdate.IsNil() {
+	if oldUpdate == nil {
 		return true
 	}
 
@@ -808,7 +804,7 @@ func IsBetterFinalityUpdate(newUpdate, oldUpdate interfaces.LightClientFinalityU
 }
 
 func IsBetterOptimisticUpdate(newUpdate, oldUpdate interfaces.LightClientOptimisticUpdate) bool {
-	if oldUpdate == nil || oldUpdate.IsNil() {
+	if oldUpdate == nil {
 		return true
 	}
 	// The attested_header.beacon.slot is greater than that of all previously forwarded optimistic updates

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

@@ -9,7 +9,7 @@ import (
 	light_client "github.com/OffchainLabs/prysm/v6/consensus-types/light-client"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 
-	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	consensustypes "github.com/OffchainLabs/prysm/v6/consensus-types"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"

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

@@ -0,0 +1,202 @@
+package light_client
+
+import (
+	"context"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v6/async/event"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
+	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/pkg/errors"
+	log "github.com/sirupsen/logrus"
+)
+
+var ErrLightClientBootstrapNotFound = errors.New("light client bootstrap not found")
+
+type Store struct {
+	mu sync.RWMutex
+
+	beaconDB             iface.HeadAccessDatabase
+	lastFinalityUpdate   interfaces.LightClientFinalityUpdate   // tracks the best finality update seen so far
+	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate // tracks the best optimistic update seen so far
+	p2p                  p2p.Accessor
+	stateFeed            event.SubscriberSender
+}
+
+func NewLightClientStore(db iface.HeadAccessDatabase, p p2p.Accessor, e event.SubscriberSender) *Store {
+	return &Store{
+		beaconDB:  db,
+		p2p:       p,
+		stateFeed: e,
+	}
+}
+
+func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot [32]byte) (interfaces.LightClientBootstrap, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	// Fetch the light client bootstrap from the database
+	bootstrap, err := s.beaconDB.LightClientBootstrap(ctx, blockRoot[:])
+	if err != nil {
+		return nil, err
+	}
+	if bootstrap == nil { // not found
+		return nil, ErrLightClientBootstrapNotFound
+	}
+
+	return bootstrap, nil
+}
+
+func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot [32]byte) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	blk, err := s.beaconDB.Block(ctx, blockRoot)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fetch block for root %x", blockRoot)
+	}
+	if blk == nil {
+		return errors.Errorf("failed to fetch block for root %x", blockRoot)
+	}
+
+	state, err := s.beaconDB.State(ctx, blockRoot)
+	if err != nil {
+		return errors.Wrapf(err, "failed to fetch state for block root %x", blockRoot)
+	}
+	if state == nil {
+		return errors.Errorf("failed to fetch state for block root %x", blockRoot)
+	}
+
+	bootstrap, err := NewLightClientBootstrapFromBeaconState(ctx, state.Slot(), state, blk)
+	if err != nil {
+		return errors.Wrapf(err, "failed to create light client bootstrap for block root %x", blockRoot)
+	}
+
+	// Save the light client bootstrap to the database
+	if err := s.beaconDB.SaveLightClientBootstrap(ctx, blockRoot[:], bootstrap); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) ([]interfaces.LightClientUpdate, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	// Fetch the light client updatesMap from the database
+	updatesMap, err := s.beaconDB.LightClientUpdates(ctx, startPeriod, endPeriod)
+	if err != nil {
+		return nil, err
+	}
+
+	var updates []interfaces.LightClientUpdate
+	for i := startPeriod; i <= endPeriod; i++ {
+		update, ok := updatesMap[i]
+		if !ok {
+			// Only return the first contiguous range of updates
+			break
+		}
+		updates = append(updates, update)
+	}
+
+	return updates, nil
+}
+
+func (s *Store) LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	// Fetch the light client update for the given period from the database
+	update, err := s.beaconDB.LightClientUpdate(ctx, period)
+	if err != nil {
+		return nil, err
+	}
+
+	return update, nil
+}
+
+func (s *Store) SaveLightClientUpdate(ctx context.Context, period uint64, update interfaces.LightClientUpdate) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	oldUpdate, err := s.beaconDB.LightClientUpdate(ctx, period)
+	if err != nil {
+		return errors.Wrapf(err, "could not get current light client update")
+	}
+
+	if oldUpdate == nil {
+		if err := s.beaconDB.SaveLightClientUpdate(ctx, period, update); err != nil {
+			return errors.Wrapf(err, "could not save light client update")
+		}
+		log.WithField("period", period).Debug("Saved new light client update")
+		return nil
+	}
+
+	isNewUpdateBetter, err := IsBetterUpdate(update, oldUpdate)
+	if err != nil {
+		return errors.Wrapf(err, "could not compare light client updates")
+	}
+
+	if isNewUpdateBetter {
+		if err := s.beaconDB.SaveLightClientUpdate(ctx, period, update); err != nil {
+			return errors.Wrapf(err, "could not save light client update")
+		}
+		log.WithField("period", period).Debug("Saved new light client update")
+		return nil
+	}
+	log.WithField("period", period).Debug("New light client update is not better than the current one, skipping save")
+	return nil
+}
+
+func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if broadcast && IsFinalityUpdateValidForBroadcast(update, s.lastFinalityUpdate) {
+		if err := s.p2p.BroadcastLightClientFinalityUpdate(context.Background(), update); err != nil {
+			log.WithError(err).Error("Could not broadcast light client finality update")
+		}
+	}
+
+	s.lastFinalityUpdate = update
+	log.Debug("Saved new light client finality update")
+
+	s.stateFeed.Send(&feed.Event{
+		Type: statefeed.LightClientFinalityUpdate,
+		Data: update,
+	})
+}
+
+func (s *Store) LastFinalityUpdate() interfaces.LightClientFinalityUpdate {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.lastFinalityUpdate
+}
+
+func (s *Store) SetLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	if broadcast {
+		if err := s.p2p.BroadcastLightClientOptimisticUpdate(context.Background(), update); err != nil {
+			log.WithError(err).Error("Could not broadcast light client optimistic update")
+		}
+	}
+
+	s.lastOptimisticUpdate = update
+	log.Debug("Saved new light client optimistic update")
+
+	s.stateFeed.Send(&feed.Event{
+		Type: statefeed.LightClientOptimisticUpdate,
+		Data: update,
+	})
+}
+
+func (s *Store) LastOptimisticUpdate() interfaces.LightClientOptimisticUpdate {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.lastOptimisticUpdate
+}

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

@@ -0,0 +1,165 @@
+package light_client_test
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/async/event"
+	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
+	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+)
+
+func TestLightClientStore(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig()
+	cfg.AltairForkEpoch = 1
+	cfg.BellatrixForkEpoch = 2
+	cfg.CapellaForkEpoch = 3
+	cfg.DenebForkEpoch = 4
+	cfg.ElectraForkEpoch = 5
+	params.OverrideBeaconConfig(cfg)
+
+	// Initialize the light client store
+	lcStore := lightClient.NewLightClientStore(testDB.SetupDB(t), &p2pTesting.FakeP2P{}, new(event.Feed))
+
+	// Create test light client updates for Capella and Deneb
+	lCapella := util.NewTestLightClient(t, version.Capella)
+	opUpdateCapella, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, opUpdateCapella, "OptimisticUpdateCapella is nil")
+	finUpdateCapella, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock, lCapella.FinalizedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, finUpdateCapella, "FinalityUpdateCapella is nil")
+
+	lDeneb := util.NewTestLightClient(t, version.Deneb)
+	opUpdateDeneb, err := lightClient.NewLightClientOptimisticUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, opUpdateDeneb, "OptimisticUpdateDeneb is nil")
+	finUpdateDeneb, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock, lDeneb.FinalizedBlock)
+	require.NoError(t, err)
+	require.NotNil(t, finUpdateDeneb, "FinalityUpdateDeneb is nil")
+
+	// Initially the store should have nil values for both updates
+	require.IsNil(t, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should be nil")
+	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
+
+	// Set and get finality with Capella update. Optimistic update should be nil
+	lcStore.SetLastFinalityUpdate(finUpdateCapella, false)
+	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
+	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
+
+	// Set and get optimistic with Capella update. Finality update should be Capella
+	lcStore.SetLastOptimisticUpdate(opUpdateCapella, false)
+	require.Equal(t, opUpdateCapella, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
+	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
+
+	// Set and get finality and optimistic with Deneb update
+	lcStore.SetLastFinalityUpdate(finUpdateDeneb, false)
+	lcStore.SetLastOptimisticUpdate(opUpdateDeneb, false)
+	require.Equal(t, finUpdateDeneb, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
+	require.Equal(t, opUpdateDeneb, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
+}
+
+func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
+	p2p := p2pTesting.NewTestP2P(t)
+	lcStore := lightClient.NewLightClientStore(testDB.SetupDB(t), p2p, new(event.Feed))
+
+	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
+	l0 := util.NewTestLightClient(t, version.Altair)
+	update0, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update0, lcStore.LastFinalityUpdate()), "update0 should be better than nil")
+	// update0 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update0, lcStore.LastFinalityUpdate()), "update0 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update0, true)
+	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
+	l1 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
+	update1, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update1, update0), "update1 should be better than update0")
+	// update1 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update1, lcStore.LastFinalityUpdate()), "update1 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update1, true)
+	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 2 with same finality slot, increased attested slot, and supermajority - should save and broadcast
+	l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(2), util.WithSupermajority())
+	update2, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update2, update1), "update2 should be better than update1")
+	// update2 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update2, lcStore.LastFinalityUpdate()), "update2 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update2, true)
+	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
+	l3 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(3), util.WithSupermajority())
+	update3, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l3.Ctx, l3.State, l3.Block, l3.AttestedState, l3.AttestedBlock, l3.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update3, update2), "update3 should be better than update2")
+	// update3 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update3, lcStore.LastFinalityUpdate()), "update3 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update3, true)
+	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
+
+	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
+	l4 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(1), util.WithSupermajority())
+	update4, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l4.Ctx, l4.State, l4.Block, l4.AttestedState, l4.AttestedBlock, l4.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update4, update3), "update4 should be better than update3")
+	// update4 should be valid for broadcast - meaning it should be broadcasted
+	require.Equal(t, true, lightClient.IsFinalityUpdateValidForBroadcast(update4, lcStore.LastFinalityUpdate()), "update4 should be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update4, true)
+	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
+	p2p.BroadcastCalled.Store(false) // Reset for next test
+
+	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
+	l5 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(2), util.WithSupermajority())
+	update5, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l5.Ctx, l5.State, l5.Block, l5.AttestedState, l5.AttestedBlock, l5.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update5, update4), "update5 should be better than update4")
+	// update5 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update5, lcStore.LastFinalityUpdate()), "update5 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update5, true)
+	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
+
+	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
+	l6 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(3))
+	update6, err := lightClient.NewLightClientFinalityUpdateFromBeaconState(l6.Ctx, l6.State, l6.Block, l6.AttestedState, l6.AttestedBlock, l6.FinalizedBlock)
+	require.NoError(t, err, "Failed to create light client finality update")
+
+	require.Equal(t, true, lightClient.IsBetterFinalityUpdate(update6, update5), "update6 should be better than update5")
+	// update6 should not be valid for broadcast - meaning it should not be broadcasted
+	require.Equal(t, false, lightClient.IsFinalityUpdateValidForBroadcast(update6, lcStore.LastFinalityUpdate()), "update6 should not be valid for broadcast")
+
+	lcStore.SetLastFinalityUpdate(update6, true)
+	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
+	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
+}

beacon-chain/core/peerdas/BUILD.bazel

@@ -19,11 +19,11 @@ go_library(
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/trie:go_default_library",
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",

beacon-chain/core/peerdas/das_core.go

@@ -4,10 +4,15 @@ import (
 	"encoding/binary"
 	"math"
 	"slices"
+	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
@@ -15,9 +20,12 @@ import (
 
 var (
 	// Custom errors
-	ErrCustodyGroupTooLarge           = errors.New("custody group too large")
-	ErrCustodyGroupCountTooLarge      = errors.New("custody group count too large")
-	errWrongComputedCustodyGroupCount = errors.New("wrong computed custody group count, should never happen")
+	ErrCustodyGroupTooLarge               = errors.New("custody group too large")
+	ErrCustodyGroupCountTooLarge          = errors.New("custody group count too large")
+	ErrSizeMismatch                       = errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
+	ErrNotEnoughDataColumnSidecars        = errors.New("not enough columns")
+	ErrDataColumnSidecarsNotSortedByIndex = errors.New("data column sidecars are not sorted by index")
+	errWrongComputedCustodyGroupCount     = errors.New("wrong computed custody group count, should never happen")
 
 	// maxUint256 is the maximum value of an uint256.
 	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
@@ -109,6 +117,44 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 	return columns, nil
 }
 
+// DataColumnSidecars computes the data column sidecars from the signed block, cells and cell proofs.
+// The returned value contains pointers to function parameters.
+// (If the caller alterates `cellsAndProofs` afterwards, the returned value will be modified as well.)
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block
+func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsAndProofs []kzg.CellsAndProofs) ([]*ethpb.DataColumnSidecar, error) {
+	if signedBlock == nil || signedBlock.IsNil() || len(cellsAndProofs) == 0 {
+		return nil, nil
+	}
+
+	block := signedBlock.Block()
+	blockBody := block.Body()
+	blobKzgCommitments, err := blockBody.BlobKzgCommitments()
+	if err != nil {
+		return nil, errors.Wrap(err, "blob KZG commitments")
+	}
+
+	if len(blobKzgCommitments) != len(cellsAndProofs) {
+		return nil, ErrSizeMismatch
+	}
+
+	signedBlockHeader, err := signedBlock.Header()
+	if err != nil {
+		return nil, errors.Wrap(err, "signed block header")
+	}
+
+	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
+	if err != nil {
+		return nil, errors.Wrap(err, "merkle proof KZG commitments")
+	}
+
+	dataColumnSidecars, err := dataColumnsSidecars(signedBlockHeader, blobKzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
+	if err != nil {
+		return nil, errors.Wrap(err, "data column sidecars")
+	}
+
+	return dataColumnSidecars, nil
+}
+
 // ComputeCustodyGroupForColumn computes the custody group for a given column.
 // It is the reciprocal function of ComputeColumnsForCustodyGroup.
 func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
@@ -148,3 +194,72 @@ func CustodyColumns(custodyGroups []uint64) (map[uint64]bool, error) {
 
 	return columns, nil
 }
+
+// dataColumnsSidecars computes the data column sidecars from the signed block header, the blob KZG commiments,
+// the KZG commitment includion proofs and cells and cell proofs.
+// The returned value contains pointers to function parameters.
+// (If the caller alterates input parameters afterwards, the returned value will be modified as well.)
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars
+func dataColumnsSidecars(
+	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
+	blobKzgCommitments [][]byte,
+	kzgCommitmentsInclusionProof [][]byte,
+	cellsAndProofs []kzg.CellsAndProofs,
+) ([]*ethpb.DataColumnSidecar, error) {
+	start := time.Now()
+	if len(blobKzgCommitments) != len(cellsAndProofs) {
+		return nil, ErrSizeMismatch
+	}
+
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	blobsCount := len(cellsAndProofs)
+	sidecars := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns)
+	for columnIndex := range numberOfColumns {
+		column := make([]kzg.Cell, 0, blobsCount)
+		kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount)
+
+		for rowIndex := range blobsCount {
+			cellsForRow := cellsAndProofs[rowIndex].Cells
+			proofsForRow := cellsAndProofs[rowIndex].Proofs
+
+			// Validate that we have enough cells and proofs for this column index
+			if columnIndex >= uint64(len(cellsForRow)) {
+				return nil, errors.Errorf("column index %d exceeds cells length %d for blob %d", columnIndex, len(cellsForRow), rowIndex)
+			}
+			if columnIndex >= uint64(len(proofsForRow)) {
+				return nil, errors.Errorf("column index %d exceeds proofs length %d for blob %d", columnIndex, len(proofsForRow), rowIndex)
+			}
+
+			cell := cellsForRow[columnIndex]
+			column = append(column, cell)
+
+			kzgProof := proofsForRow[columnIndex]
+			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
+		}
+
+		columnBytes := make([][]byte, 0, blobsCount)
+		for i := range column {
+			columnBytes = append(columnBytes, column[i][:])
+		}
+
+		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
+		for _, kzgProof := range kzgProofOfColumn {
+			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, kzgProof[:])
+		}
+
+		sidecar := &ethpb.DataColumnSidecar{
+			Index:                        columnIndex,
+			Column:                       columnBytes,
+			KzgCommitments:               blobKzgCommitments,
+			KzgProofs:                    kzgProofOfColumnBytes,
+			SignedBlockHeader:            signedBlockHeader,
+			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
+		}
+
+		sidecars = append(sidecars, sidecar)
+	}
+
+	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
+	return sidecars, nil
+}

beacon-chain/core/peerdas/das_core_test.go

@@ -3,9 +3,13 @@ package peerdas_test
 import (
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
 
@@ -27,6 +31,93 @@ func TestComputeColumnsForCustodyGroup(t *testing.T) {
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupTooLarge)
 }
 
+func TestDataColumnSidecars(t *testing.T) {
+	t.Run("nil signed block", func(t *testing.T) {
+		var expected []*ethpb.DataColumnSidecar = nil
+		actual, err := peerdas.DataColumnSidecars(nil, []kzg.CellsAndProofs{})
+		require.NoError(t, err)
+
+		require.DeepSSZEqual(t, expected, actual)
+	})
+
+	t.Run("empty cells and proofs", func(t *testing.T) {
+		// Create a protobuf signed beacon block.
+		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		actual, err := peerdas.DataColumnSidecars(signedBeaconBlock, []kzg.CellsAndProofs{})
+		require.NoError(t, err)
+		require.IsNil(t, actual)
+	})
+
+	t.Run("sizes mismatch", func(t *testing.T) {
+		// Create a protobuf signed beacon block.
+		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs.
+		cellsAndProofs := make([]kzg.CellsAndProofs, 1)
+
+		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
+		require.ErrorIs(t, err, peerdas.ErrSizeMismatch)
+	})
+
+	t.Run("cells array too short for column index", func(t *testing.T) {
+		// Create a Fulu block with a blob commitment.
+		signedBeaconBlockPb := util.NewBeaconBlockFulu()
+		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs with insufficient cells for the number of columns.
+		// This simulates a scenario where cellsAndProofs has fewer cells than expected columns.
+		cellsAndProofs := []kzg.CellsAndProofs{
+			{
+				Cells:  make([]kzg.Cell, 10),  // Only 10 cells
+				Proofs: make([]kzg.Proof, 10), // Only 10 proofs
+			},
+		}
+
+		// This should fail because the function will try to access columns up to NumberOfColumns
+		// but we only have 10 cells/proofs.
+		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
+		require.ErrorContains(t, "column index", err)
+		require.ErrorContains(t, "exceeds cells length", err)
+	})
+
+	t.Run("proofs array too short for column index", func(t *testing.T) {
+		// Create a Fulu block with a blob commitment.
+		signedBeaconBlockPb := util.NewBeaconBlockFulu()
+		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
+
+		// Create a signed beacon block from the protobuf.
+		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
+		require.NoError(t, err)
+
+		// Create cells and proofs with sufficient cells but insufficient proofs.
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+		cellsAndProofs := []kzg.CellsAndProofs{
+			{
+				Cells:  make([]kzg.Cell, numberOfColumns),
+				Proofs: make([]kzg.Proof, 5), // Only 5 proofs, less than columns
+			},
+		}
+
+		// This should fail when trying to access proof beyond index 4.
+		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
+		require.ErrorContains(t, "column index", err)
+		require.ErrorContains(t, "exceeds proofs length", err)
+	})
+}
+
 func TestComputeCustodyGroupForColumn(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	config := params.BeaconConfig()

beacon-chain/core/peerdas/p2p_interface_test.go

@@ -63,14 +63,17 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	t.Run("invalid proof", func(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
 		sidecars[0].Column[0][0]++ // It is OK to overflow
+		roDataColumnSidecars := generateRODataColumnSidecars(t, sidecars)
 
-		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
 		require.ErrorIs(t, err, peerdas.ErrInvalidKZGProof)
 	})
 
 	t.Run("nominal", func(t *testing.T) {
 		sidecars := generateRandomSidecars(t, seed, blobCount)
-		err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
+		roDataColumnSidecars := generateRODataColumnSidecars(t, sidecars)
+
+		err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
 		require.NoError(t, err)
 	})
 }
@@ -253,8 +256,9 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_SameCommitments_NoBatch(b *testin
 	for i := range int64(b.N) {
 		// Generate new random sidecars to ensure the KZG backend does not cache anything.
 		sidecars := generateRandomSidecars(b, i, blobCount)
+		roDataColumnSidecars := generateRODataColumnSidecars(b, sidecars)
 
-		for _, sidecar := range sidecars {
+		for _, sidecar := range roDataColumnSidecars {
 			sidecars := []blocks.RODataColumn{sidecar}
 			b.StartTimer()
 			err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
@@ -278,7 +282,7 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.
 			b.ResetTimer()
 
 			for j := range int64(b.N) {
-				allSidecars := make([]blocks.RODataColumn, 0, numberOfColumns)
+				allSidecars := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns)
 				for k := int64(0); k < numberOfColumns; k += columnsCount {
 					// Use different seeds to generate different blobs/commitments
 					seed := int64(b.N*i) + numberOfColumns*j + blobCount*k
@@ -288,8 +292,10 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.
 					allSidecars = append(allSidecars, sidecars[k:k+columnsCount]...)
 				}
 
+				roDataColumnSidecars := generateRODataColumnSidecars(b, allSidecars)
+
 				b.StartTimer()
-				err := peerdas.VerifyDataColumnsSidecarKZGProofs(allSidecars)
+				err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
 				b.StopTimer()
 				require.NoError(b, err)
 			}
@@ -317,7 +323,8 @@ func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch4(b *testing
 		for j := range int64(batchCount) {
 			// Use different seeds to generate different blobs/commitments
 			sidecars := generateRandomSidecars(b, int64(batchCount)*i+j*blobCount, blobCount)
-			allSidecars = append(allSidecars, sidecars)
+			roDataColumnSidecars := generateRODataColumnSidecars(b, sidecars[:columnsCount])
+			allSidecars = append(allSidecars, roDataColumnSidecars)
 		}
 
 		for _, sidecars := range allSidecars {
@@ -351,7 +358,7 @@ func createTestSidecar(t *testing.T, index uint64, column, kzgCommitments, kzgPr
 	return roSidecar
 }
 
-func generateRandomSidecars(t testing.TB, seed, blobCount int64) []blocks.RODataColumn {
+func generateRandomSidecars(t testing.TB, seed, blobCount int64) []*ethpb.DataColumnSidecar {
 	dbBlock := util.NewBeaconBlockDeneb()
 
 	commitments := make([][]byte, 0, blobCount)
@@ -372,10 +379,20 @@ func generateRandomSidecars(t testing.TB, seed, blobCount int64) []blocks.ROData
 	require.NoError(t, err)
 
 	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
-	rob, err := blocks.NewROBlock(sBlock)
-	require.NoError(t, err)
-	sidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
+	sidecars, err := peerdas.DataColumnSidecars(sBlock, cellsAndProofs)
 	require.NoError(t, err)
 
 	return sidecars
 }
+
+func generateRODataColumnSidecars(t testing.TB, sidecars []*ethpb.DataColumnSidecar) []blocks.RODataColumn {
+	roDataColumnSidecars := make([]blocks.RODataColumn, 0, len(sidecars))
+	for _, sidecar := range sidecars {
+		roCol, err := blocks.NewRODataColumn(sidecar)
+		require.NoError(t, err)
+
+		roDataColumnSidecars = append(roDataColumnSidecars, roCol)
+	}
+
+	return roDataColumnSidecars
+}

beacon-chain/core/peerdas/reconstruction.go

@@ -1,13 +1,11 @@
 package peerdas
 
 import (
-	"sort"
-
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	pb "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
@@ -18,7 +16,6 @@ var (
 	ErrBlobIndexTooHigh         = errors.New("blob index is too high")
 	ErrBlockRootMismatch        = errors.New("block root mismatch")
 	ErrBlobsCellsProofsMismatch = errors.New("blobs and cells proofs mismatch")
-	ErrNilBlobAndProof          = errors.New("nil blob and proof")
 )
 
 // MinimumColumnCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
@@ -30,21 +27,20 @@ func MinimumColumnCountToReconstruct() uint64 {
 
 // ReconstructDataColumnSidecars reconstructs all the data column sidecars from the given input data column sidecars.
 // All input sidecars must be committed to the same block.
-// `inVerifiedRoSidecars` should contain enough sidecars to reconstruct the missing columns, and should not contain any duplicate.
-// WARNING: This function sorts inplace `verifiedRoSidecars` by index.
-func ReconstructDataColumnSidecars(verifiedRoSidecars []blocks.VerifiedRODataColumn) ([]blocks.VerifiedRODataColumn, error) {
+// `inVerifiedRoSidecars` should contain enough (unique) sidecars to reconstruct the missing columns.
+func ReconstructDataColumnSidecars(inVerifiedRoSidecars []blocks.VerifiedRODataColumn) ([]blocks.VerifiedRODataColumn, error) {
 	// Check if there is at least one input sidecar.
-	if len(verifiedRoSidecars) == 0 {
+	if len(inVerifiedRoSidecars) == 0 {
 		return nil, ErrNotEnoughDataColumnSidecars
 	}
 
 	// Safely retrieve the first sidecar as a reference.
-	referenceSidecar := verifiedRoSidecars[0]
+	referenceSidecar := inVerifiedRoSidecars[0]
 
 	// Check if all columns have the same length and are commmitted to the same block.
 	blobCount := len(referenceSidecar.Column)
 	blockRoot := referenceSidecar.BlockRoot()
-	for _, sidecar := range verifiedRoSidecars[1:] {
+	for _, sidecar := range inVerifiedRoSidecars[1:] {
 		if len(sidecar.Column) != blobCount {
 			return nil, ErrColumnLengthsDiffer
 		}
@@ -54,16 +50,23 @@ func ReconstructDataColumnSidecars(verifiedRoSidecars []blocks.VerifiedRODataCol
 		}
 	}
 
+	// Deduplicate sidecars.
+	sidecarByIndex := make(map[uint64]blocks.VerifiedRODataColumn, len(inVerifiedRoSidecars))
+	for _, inVerifiedRoSidecar := range inVerifiedRoSidecars {
+		sidecarByIndex[inVerifiedRoSidecar.Index] = inVerifiedRoSidecar
+	}
+
 	// Check if there is enough sidecars to reconstruct the missing columns.
-	sidecarCount := len(verifiedRoSidecars)
+	sidecarCount := len(sidecarByIndex)
 	if uint64(sidecarCount) < MinimumColumnCountToReconstruct() {
 		return nil, ErrNotEnoughDataColumnSidecars
 	}
 
-	// Sort the input sidecars by index.
-	sort.Slice(verifiedRoSidecars, func(i, j int) bool {
-		return verifiedRoSidecars[i].Index < verifiedRoSidecars[j].Index
-	})
+	// Sidecars are verified and are committed to the same block.
+	// All signed block headers, KZG commitments, and inclusion proofs are the same.
+	signedBlockHeader := referenceSidecar.SignedBlockHeader
+	kzgCommitments := referenceSidecar.KzgCommitments
+	kzgCommitmentsInclusionProof := referenceSidecar.KzgCommitmentsInclusionProof
 
 	// Recover cells and compute proofs in parallel.
 	var wg errgroup.Group
@@ -73,10 +76,10 @@ func ReconstructDataColumnSidecars(verifiedRoSidecars []blocks.VerifiedRODataCol
 			cellsIndices := make([]uint64, 0, sidecarCount)
 			cells := make([]kzg.Cell, 0, sidecarCount)
 
-			for _, sidecar := range verifiedRoSidecars {
+			for columnIndex, sidecar := range sidecarByIndex {
 				cell := sidecar.Column[blobIndex]
 				cells = append(cells, kzg.Cell(cell))
-				cellsIndices = append(cellsIndices, sidecar.Index)
+				cellsIndices = append(cellsIndices, columnIndex)
 			}
 
 			// Recover the cells and proofs for the corresponding blob
@@ -97,20 +100,78 @@ func ReconstructDataColumnSidecars(verifiedRoSidecars []blocks.VerifiedRODataCol
 		return nil, errors.Wrap(err, "wait for RecoverCellsAndKZGProofs")
 	}
 
-	outSidecars, err := DataColumnSidecars(cellsAndProofs, PopulateFromSidecar(referenceSidecar))
+	outSidecars, err := dataColumnsSidecars(signedBlockHeader, kzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
 	if err != nil {
 		return nil, errors.Wrap(err, "data column sidecars from items")
 	}
 
 	// Input sidecars are verified, and we reconstructed ourselves the missing sidecars.
 	// As a consequence, reconstructed sidecars are also verified.
-	reconstructedVerifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(outSidecars))
+	outVerifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(outSidecars))
 	for _, sidecar := range outSidecars {
-		verifiedRoSidecar := blocks.NewVerifiedRODataColumn(sidecar)
-		reconstructedVerifiedRoSidecars = append(reconstructedVerifiedRoSidecars, verifiedRoSidecar)
+		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, blockRoot)
+		if err != nil {
+			return nil, errors.Wrap(err, "new RO data column with root")
+		}
+
+		verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
+		outVerifiedRoSidecars = append(outVerifiedRoSidecars, verifiedRoSidecar)
 	}
 
-	return reconstructedVerifiedRoSidecars, nil
+	return outVerifiedRoSidecars, nil
+}
+
+// ConstructDataColumnSidecars constructs data column sidecars from a block, (un-extended) blobs and
+// cell proofs corresponding the extended blobs. The main purpose of this function is to
+// construct data column sidecars from data obtained from the execution client via:
+// - `engine_getBlobsV2` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getblobsv2, or
+// - `engine_getPayloadV5` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getpayloadv5
+// Note: In this function, to stick with the `BlobsBundleV2` format returned by the execution client in `engine_getPayloadV5`,
+// cell proofs are "flattened".
+func ConstructDataColumnSidecars(block interfaces.ReadOnlySignedBeaconBlock, blobs [][]byte, cellProofs [][]byte) ([]*ethpb.DataColumnSidecar, error) {
+	// Check if the cells count is equal to the cell proofs count.
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+	blobCount := uint64(len(blobs))
+	cellProofsCount := uint64(len(cellProofs))
+
+	cellsCount := blobCount * numberOfColumns
+	if cellsCount != cellProofsCount {
+		return nil, ErrBlobsCellsProofsMismatch
+	}
+
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobCount)
+	for i, blob := range blobs {
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blob) != len(kzgBlob) {
+			return nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute cells")
+		}
+
+		var proofs []kzg.Proof
+		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
+				return nil, errors.New("wrong KZG proof size - should never happen")
+			}
+
+			proofs = append(proofs, kzgProof)
+		}
+
+		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: proofs}
+		cellsAndProofs = append(cellsAndProofs, cellsProofs)
+	}
+
+	dataColumnSidecars, err := DataColumnSidecars(block, cellsAndProofs)
+	if err != nil {
+		return nil, errors.Wrap(err, "data column sidcars")
+	}
+
+	return dataColumnSidecars, nil
 }
 
 // ReconstructBlobs constructs verified read only blobs sidecars from verified read only blob sidecars.
@@ -195,89 +256,6 @@ func ReconstructBlobs(block blocks.ROBlock, verifiedDataColumnSidecars []blocks.
 	return blobSidecars, nil
 }
 
-// ComputeCellsAndProofsFromFlat computes the cells and proofs from blobs and cell flat proofs.
-func ComputeCellsAndProofsFromFlat(blobs [][]byte, cellProofs [][]byte) ([]kzg.CellsAndProofs, error) {
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-	blobCount := uint64(len(blobs))
-	cellProofsCount := uint64(len(cellProofs))
-
-	cellsCount := blobCount * numberOfColumns
-	if cellsCount != cellProofsCount {
-		return nil, ErrBlobsCellsProofsMismatch
-	}
-
-	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobCount)
-	for i, blob := range blobs {
-		var kzgBlob kzg.Blob
-		if copy(kzgBlob[:], blob) != len(kzgBlob) {
-			return nil, errors.New("wrong blob size - should never happen")
-		}
-
-		// Compute the extended cells from the (non-extended) blob.
-		cells, err := kzg.ComputeCells(&kzgBlob)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute cells")
-		}
-
-		var proofs []kzg.Proof
-		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
-			var kzgProof kzg.Proof
-			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
-				return nil, errors.New("wrong KZG proof size - should never happen")
-			}
-
-			proofs = append(proofs, kzgProof)
-		}
-
-		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: proofs}
-		cellsAndProofs = append(cellsAndProofs, cellsProofs)
-	}
-
-	return cellsAndProofs, nil
-}
-
-// ComputeCellsAndProofs computes the cells and proofs from blobs and cell proofs.
-func ComputeCellsAndProofsFromStructured(blobsAndProofs []*pb.BlobAndProofV2) ([]kzg.CellsAndProofs, error) {
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	cellsAndProofs := make([]kzg.CellsAndProofs, 0, len(blobsAndProofs))
-	for _, blobAndProof := range blobsAndProofs {
-		if blobAndProof == nil {
-			return nil, ErrNilBlobAndProof
-		}
-
-		var kzgBlob kzg.Blob
-		if copy(kzgBlob[:], blobAndProof.Blob) != len(kzgBlob) {
-			return nil, errors.New("wrong blob size - should never happen")
-		}
-
-		// Compute the extended cells from the (non-extended) blob.
-		cells, err := kzg.ComputeCells(&kzgBlob)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute cells")
-		}
-
-		kzgProofs := make([]kzg.Proof, 0, numberOfColumns*kzg.BytesPerProof)
-		for _, kzgProofBytes := range blobAndProof.KzgProofs {
-			if len(kzgProofBytes) != kzg.BytesPerProof {
-				return nil, errors.New("wrong KZG proof size - should never happen")
-			}
-
-			var kzgProof kzg.Proof
-			if copy(kzgProof[:], kzgProofBytes) != len(kzgProof) {
-				return nil, errors.New("wrong copied KZG proof size - should never happen")
-			}
-
-			kzgProofs = append(kzgProofs, kzgProof)
-		}
-
-		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: kzgProofs}
-		cellsAndProofs = append(cellsAndProofs, cellsProofs)
-	}
-
-	return cellsAndProofs, nil
-}
-
 // blobSidecarsFromDataColumnSidecars converts verified data column sidecars to verified blob sidecars.
 func blobSidecarsFromDataColumnSidecars(roBlock blocks.ROBlock, dataColumnSidecars []blocks.VerifiedRODataColumn, indices []int) ([]*blocks.VerifiedROBlob, error) {
 	referenceSidecar := dataColumnSidecars[0]

beacon-chain/core/peerdas/reconstruction_test.go

@@ -9,7 +9,7 @@ import (
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	pb "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 	"github.com/pkg/errors"
@@ -124,13 +124,56 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 	})
 }
 
-func TestReconstructBlobs(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.BeaconConfig().FuluForkEpoch = params.BeaconConfig().ElectraForkEpoch + 4096*2
+func TestConstructDataColumnSidecars(t *testing.T) {
+	const (
+		blobCount    = 3
+		cellsPerBlob = fieldparams.CellsPerBlob
+	)
+
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	roBlock, _, baseVerifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, blobCount)
+
+	// Extract blobs and proofs from the sidecars.
+	blobs := make([][]byte, 0, blobCount)
+	cellProofs := make([][]byte, 0, cellsPerBlob)
+	for blobIndex := range blobCount {
+		blob := make([]byte, 0, cellsPerBlob)
+		for columnIndex := range cellsPerBlob {
+			cell := baseVerifiedRoSidecars[columnIndex].Column[blobIndex]
+			blob = append(blob, cell...)
+		}
+
+		blobs = append(blobs, blob)
+
+		for columnIndex := range numberOfColumns {
+			cellProof := baseVerifiedRoSidecars[columnIndex].KzgProofs[blobIndex]
+			cellProofs = append(cellProofs, cellProof)
+		}
+	}
+
+	actual, err := peerdas.ConstructDataColumnSidecars(roBlock, blobs, cellProofs)
+	require.NoError(t, err)
+
+	// Extract the base verified ro sidecars into sidecars.
+	expected := make([]*ethpb.DataColumnSidecar, 0, len(baseVerifiedRoSidecars))
+	for _, verifiedRoSidecar := range baseVerifiedRoSidecars {
+		expected = append(expected, verifiedRoSidecar.DataColumnSidecar)
+	}
+
+	require.DeepSSZEqual(t, expected, actual)
+}
+
+func TestReconstructBlobs(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
 
-	require.NoError(t, kzg.Start())
 	var emptyBlock blocks.ROBlock
-	fs := util.SlotAtEpoch(t, params.BeaconConfig().FuluForkEpoch)
 
 	t.Run("no index", func(t *testing.T) {
 		actual, err := peerdas.ReconstructBlobs(emptyBlock, nil, nil)
@@ -191,10 +234,10 @@ func TestReconstructBlobs(t *testing.T) {
 	})
 
 	t.Run("not committed to the same block", func(t *testing.T) {
-		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{1}), util.WithSlot(fs))
-		roBlock, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{2}), util.WithSlot(fs))
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{1}))
+		roBlock, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{2}))
 
-		_, err := peerdas.ReconstructBlobs(roBlock, verifiedRoSidecars, []int{0})
+		_, err = peerdas.ReconstructBlobs(roBlock, verifiedRoSidecars, []int{0})
 		require.ErrorContains(t, peerdas.ErrRootMismatch.Error(), err)
 	})
 
@@ -207,7 +250,7 @@ func TestReconstructBlobs(t *testing.T) {
 		// Compute cells and proofs from blob sidecars.
 		var wg errgroup.Group
 		blobs := make([][]byte, blobCount)
-		inputCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
+		cellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
 		for i := range blobCount {
 			blob := roBlobSidecars[i].Blob
 			blobs[i] = blob
@@ -224,7 +267,7 @@ func TestReconstructBlobs(t *testing.T) {
 
 				// It is safe for multiple goroutines to concurrently write to the same slice,
 				// as long as they are writing to different indices, which is the case here.
-				inputCellsAndProofs[i] = cp
+				cellsAndProofs[i] = cp
 
 				return nil
 			})
@@ -235,24 +278,25 @@ func TestReconstructBlobs(t *testing.T) {
 
 		// Flatten proofs.
 		cellProofs := make([][]byte, 0, blobCount*numberOfColumns)
-		for _, cp := range inputCellsAndProofs {
+		for _, cp := range cellsAndProofs {
 			for _, proof := range cp.Proofs {
 				cellProofs = append(cellProofs, proof[:])
 			}
 		}
 
-		// Compute celles and proofs from the blobs and cell proofs.
-		cellsAndProofs, err := peerdas.ComputeCellsAndProofsFromFlat(blobs, cellProofs)
-		require.NoError(t, err)
-
-		// Construct data column sidears from the signed block and cells and proofs.
-		roDataColumnSidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(roBlock))
+		// Construct data column sidecars.
+		// It is OK to use the public function `ConstructDataColumnSidecars`, as long as
+		// `TestConstructDataColumnSidecars` tests pass.
+		dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(roBlock, blobs, cellProofs)
 		require.NoError(t, err)
 
 		// Convert to verified data column sidecars.
-		verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(roDataColumnSidecars))
-		for _, roDataColumnSidecar := range roDataColumnSidecars {
-			verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roDataColumnSidecar)
+		verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
+		for _, dataColumnSidecar := range dataColumnSidecars {
+			roSidecar, err := blocks.NewRODataColumn(dataColumnSidecar)
+			require.NoError(t, err)
+
+			verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
 			verifiedRoSidecars = append(verifiedRoSidecars, verifiedRoSidecar)
 		}
 
@@ -295,162 +339,3 @@ func TestReconstructBlobs(t *testing.T) {
 	})
 
 }
-
-func TestComputeCellsAndProofsFromFlat(t *testing.T) {
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	t.Run("mismatched blob and proof counts", func(t *testing.T) {
-		numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-		// Create one blob but proofs for two blobs
-		blobs := [][]byte{{}}
-
-		// Create proofs for 2 blobs worth of columns
-		cellProofs := make([][]byte, 2*numberOfColumns)
-
-		_, err := peerdas.ComputeCellsAndProofsFromFlat(blobs, cellProofs)
-		require.ErrorIs(t, err, peerdas.ErrBlobsCellsProofsMismatch)
-	})
-
-	t.Run("nominal", func(t *testing.T) {
-		const blobCount = 2
-		numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-		// Generate test blobs
-		_, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)
-
-		// Extract blobs and compute expected cells and proofs
-		blobs := make([][]byte, blobCount)
-		expectedCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
-		var wg errgroup.Group
-
-		for i := range blobCount {
-			blob := roBlobSidecars[i].Blob
-			blobs[i] = blob
-
-			wg.Go(func() error {
-				var kzgBlob kzg.Blob
-				count := copy(kzgBlob[:], blob)
-				require.Equal(t, len(kzgBlob), count)
-
-				cp, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
-				if err != nil {
-					return errors.Wrapf(err, "compute cells and kzg proofs for blob %d", i)
-				}
-
-				expectedCellsAndProofs[i] = cp
-				return nil
-			})
-		}
-
-		err := wg.Wait()
-		require.NoError(t, err)
-
-		// Flatten proofs
-		cellProofs := make([][]byte, 0, blobCount*numberOfColumns)
-		for _, cp := range expectedCellsAndProofs {
-			for _, proof := range cp.Proofs {
-				cellProofs = append(cellProofs, proof[:])
-			}
-		}
-
-		// Test ComputeCellsAndProofs
-		actualCellsAndProofs, err := peerdas.ComputeCellsAndProofsFromFlat(blobs, cellProofs)
-		require.NoError(t, err)
-		require.Equal(t, blobCount, len(actualCellsAndProofs))
-
-		// Verify the results match expected
-		for i := range blobCount {
-			require.Equal(t, len(expectedCellsAndProofs[i].Cells), len(actualCellsAndProofs[i].Cells))
-			require.Equal(t, len(expectedCellsAndProofs[i].Proofs), len(actualCellsAndProofs[i].Proofs))
-
-			// Compare cells
-			for j, expectedCell := range expectedCellsAndProofs[i].Cells {
-				require.Equal(t, expectedCell, actualCellsAndProofs[i].Cells[j])
-			}
-
-			// Compare proofs
-			for j, expectedProof := range expectedCellsAndProofs[i].Proofs {
-				require.Equal(t, expectedProof, actualCellsAndProofs[i].Proofs[j])
-			}
-		}
-	})
-}
-
-func TestComputeCellsAndProofsFromStructured(t *testing.T) {
-	t.Run("nil blob and proof", func(t *testing.T) {
-		_, err := peerdas.ComputeCellsAndProofsFromStructured([]*pb.BlobAndProofV2{nil})
-		require.ErrorIs(t, err, peerdas.ErrNilBlobAndProof)
-	})
-
-	t.Run("nominal", func(t *testing.T) {
-		// Start the trusted setup.
-		err := kzg.Start()
-		require.NoError(t, err)
-
-		const blobCount = 2
-
-		// Generate test blobs
-		_, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)
-
-		// Extract blobs and compute expected cells and proofs
-		blobsAndProofs := make([]*pb.BlobAndProofV2, blobCount)
-		expectedCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
-
-		var wg errgroup.Group
-		for i := range blobCount {
-			blob := roBlobSidecars[i].Blob
-
-			wg.Go(func() error {
-				var kzgBlob kzg.Blob
-				count := copy(kzgBlob[:], blob)
-				require.Equal(t, len(kzgBlob), count)
-
-				cellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
-				if err != nil {
-					return errors.Wrapf(err, "compute cells and kzg proofs for blob %d", i)
-				}
-				expectedCellsAndProofs[i] = cellsAndProofs
-
-				kzgProofs := make([][]byte, 0, len(cellsAndProofs.Proofs))
-				for _, proof := range cellsAndProofs.Proofs {
-					kzgProofs = append(kzgProofs, proof[:])
-				}
-
-				blobAndProof := &pb.BlobAndProofV2{
-					Blob:      blob,
-					KzgProofs: kzgProofs,
-				}
-				blobsAndProofs[i] = blobAndProof
-
-				return nil
-			})
-		}
-
-		err = wg.Wait()
-		require.NoError(t, err)
-
-		// Test ComputeCellsAndProofs
-		actualCellsAndProofs, err := peerdas.ComputeCellsAndProofsFromStructured(blobsAndProofs)
-		require.NoError(t, err)
-		require.Equal(t, blobCount, len(actualCellsAndProofs))
-
-		// Verify the results match expected
-		for i := range blobCount {
-			require.Equal(t, len(expectedCellsAndProofs[i].Cells), len(actualCellsAndProofs[i].Cells))
-			require.Equal(t, len(expectedCellsAndProofs[i].Proofs), len(actualCellsAndProofs[i].Proofs))
-
-			// Compare cells
-			for j, expectedCell := range expectedCellsAndProofs[i].Cells {
-				require.Equal(t, expectedCell, actualCellsAndProofs[i].Cells[j])
-			}
-
-			// Compare proofs
-			for j, expectedProof := range expectedCellsAndProofs[i].Proofs {
-				require.Equal(t, expectedProof, actualCellsAndProofs[i].Proofs[j])
-			}
-		}
-	})
-}

beacon-chain/core/peerdas/validator.go

@@ -1,76 +1,12 @@
 package peerdas
 
 import (
-	"time"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	beaconState "github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
 
-var (
-	ErrNilSignedBlockOrEmptyCellsAndProofs = errors.New("nil signed block or empty cells and proofs")
-	ErrSizeMismatch                        = errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
-	ErrNotEnoughDataColumnSidecars         = errors.New("not enough columns")
-	ErrDataColumnSidecarsNotSortedByIndex  = errors.New("data column sidecars are not sorted by index")
-)
-
-var (
-	_ ConstructionPopulator = (*BlockReconstructionSource)(nil)
-	_ ConstructionPopulator = (*SidecarReconstructionSource)(nil)
-)
-
-const (
-	BlockType   = "BeaconBlock"
-	SidecarType = "DataColumnSidecar"
-)
-
-type (
-	// ConstructionPopulator is an interface that can be satisfied by a type that can use data from a struct
-	// like a DataColumnSidecar or a BeaconBlock to set the fields in a data column sidecar that cannot
-	// be obtained from the engine api.
-	ConstructionPopulator interface {
-		Slot() primitives.Slot
-		Root() [fieldparams.RootLength]byte
-		ProposerIndex() primitives.ValidatorIndex
-		Commitments() ([][]byte, error)
-		Type() string
-
-		extract() (*blockInfo, error)
-	}
-
-	// BlockReconstructionSource is a ConstructionPopulator that uses a beacon block as the source of data
-	BlockReconstructionSource struct {
-		blocks.ROBlock
-	}
-
-	// DataColumnSidecar is a ConstructionPopulator that uses a data column sidecar as the source of data
-	SidecarReconstructionSource struct {
-		blocks.VerifiedRODataColumn
-	}
-
-	blockInfo struct {
-		signedBlockHeader *ethpb.SignedBeaconBlockHeader
-		kzgCommitments    [][]byte
-		kzgInclusionProof [][]byte
-	}
-)
-
-// PopulateFromBlock creates a BlockReconstructionSource from a beacon block
-func PopulateFromBlock(block blocks.ROBlock) *BlockReconstructionSource {
-	return &BlockReconstructionSource{ROBlock: block}
-}
-
-// PopulateFromSidecar creates a SidecarReconstructionSource from a data column sidecar
-func PopulateFromSidecar(sidecar blocks.VerifiedRODataColumn) *SidecarReconstructionSource {
-	return &SidecarReconstructionSource{VerifiedRODataColumn: sidecar}
-}
-
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
 // https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
 func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
@@ -92,158 +28,3 @@ func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validat
 	count := totalNodeBalance / balancePerAdditionalCustodyGroup
 	return min(max(count, validatorCustodyRequirement), numberOfCustodyGroups), nil
 }
-
-// DataColumnSidecars, given ConstructionPopulator and the cells/proofs associated with each blob in the
-// block, assembles sidecars which can be distributed to peers.
-// This is an adapted version of
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars,
-// which is designed to be used both when constructing sidecars from a block and from a sidecar, replacing
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block and
-// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_column_sidecar
-func DataColumnSidecars(rows []kzg.CellsAndProofs, src ConstructionPopulator) ([]blocks.RODataColumn, error) {
-	if len(rows) == 0 {
-		return nil, nil
-	}
-	start := time.Now()
-	cells, proofs, err := rotateRowsToCols(rows, params.BeaconConfig().NumberOfColumns)
-	if err != nil {
-		return nil, errors.Wrap(err, "rotate cells and proofs")
-	}
-	info, err := src.extract()
-	if err != nil {
-		return nil, errors.Wrap(err, "extract block info")
-	}
-
-	maxIdx := params.BeaconConfig().NumberOfColumns
-	roSidecars := make([]blocks.RODataColumn, 0, maxIdx)
-	for idx := range maxIdx {
-		sidecar := &ethpb.DataColumnSidecar{
-			Index:                        idx,
-			Column:                       cells[idx],
-			KzgCommitments:               info.kzgCommitments,
-			KzgProofs:                    proofs[idx],
-			SignedBlockHeader:            info.signedBlockHeader,
-			KzgCommitmentsInclusionProof: info.kzgInclusionProof,
-		}
-
-		if len(sidecar.KzgCommitments) != len(sidecar.Column) || len(sidecar.KzgCommitments) != len(sidecar.KzgProofs) {
-			return nil, ErrSizeMismatch
-		}
-
-		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, src.Root())
-		if err != nil {
-			return nil, errors.Wrap(err, "new ro data column")
-		}
-		roSidecars = append(roSidecars, roSidecar)
-	}
-
-	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
-	return roSidecars, nil
-}
-
-// Slot returns the slot of the source
-func (s *BlockReconstructionSource) Slot() primitives.Slot {
-	return s.Block().Slot()
-}
-
-// ProposerIndex returns the proposer index of the source
-func (s *BlockReconstructionSource) ProposerIndex() primitives.ValidatorIndex {
-	return s.Block().ProposerIndex()
-}
-
-// Commitments returns the blob KZG commitments of the source
-func (s *BlockReconstructionSource) Commitments() ([][]byte, error) {
-	c, err := s.Block().Body().BlobKzgCommitments()
-
-	if err != nil {
-		return nil, errors.Wrap(err, "blob KZG commitments")
-	}
-
-	return c, nil
-}
-
-// Type returns the type of the source
-func (s *BlockReconstructionSource) Type() string {
-	return BlockType
-}
-
-// extract extracts the block information from the source
-func (b *BlockReconstructionSource) extract() (*blockInfo, error) {
-	block := b.Block()
-
-	header, err := b.Header()
-	if err != nil {
-		return nil, errors.Wrap(err, "header")
-	}
-
-	commitments, err := block.Body().BlobKzgCommitments()
-	if err != nil {
-		return nil, errors.Wrap(err, "commitments")
-	}
-
-	inclusionProof, err := blocks.MerkleProofKZGCommitments(block.Body())
-	if err != nil {
-		return nil, errors.Wrap(err, "merkle proof kzg commitments")
-	}
-
-	info := &blockInfo{
-		signedBlockHeader: header,
-		kzgCommitments:    commitments,
-		kzgInclusionProof: inclusionProof,
-	}
-
-	return info, nil
-}
-
-// rotateRowsToCols takes a 2D slice of cells and proofs, where the x is rows (blobs) and y is columns,
-// and returns a 2D slice where x is columns and y is rows.
-func rotateRowsToCols(rows []kzg.CellsAndProofs, numCols uint64) ([][][]byte, [][][]byte, error) {
-	if len(rows) == 0 {
-		return nil, nil, nil
-	}
-	cellCols := make([][][]byte, numCols)
-	proofCols := make([][][]byte, numCols)
-	for i, cp := range rows {
-		if uint64(len(cp.Cells)) != numCols {
-			return nil, nil, errors.Wrap(ErrNotEnoughDataColumnSidecars, "not enough cells")
-		}
-		if len(cp.Cells) != len(cp.Proofs) {
-			return nil, nil, errors.Wrap(ErrNotEnoughDataColumnSidecars, "not enough proofs")
-		}
-		for j := uint64(0); j < numCols; j++ {
-			if i == 0 {
-				cellCols[j] = make([][]byte, len(rows))
-				proofCols[j] = make([][]byte, len(rows))
-			}
-			cellCols[j][i] = cp.Cells[j][:]
-			proofCols[j][i] = cp.Proofs[j][:]
-		}
-	}
-	return cellCols, proofCols, nil
-}
-
-// Root returns the block root of the source
-func (s *SidecarReconstructionSource) Root() [fieldparams.RootLength]byte {
-	return s.BlockRoot()
-}
-
-// Commmitments returns the blob KZG commitments of the source
-func (s *SidecarReconstructionSource) Commitments() ([][]byte, error) {
-	return s.KzgCommitments, nil
-}
-
-// Type returns the type of the source
-func (s *SidecarReconstructionSource) Type() string {
-	return SidecarType
-}
-
-// extract extracts the block information from the source
-func (s *SidecarReconstructionSource) extract() (*blockInfo, error) {
-	info := &blockInfo{
-		signedBlockHeader: s.SignedBlockHeader,
-		kzgCommitments:    s.KzgCommitments,
-		kzgInclusionProof: s.KzgCommitmentsInclusionProof,
-	}
-
-	return info, nil
-}

beacon-chain/core/peerdas/validator_test.go

@@ -3,15 +3,11 @@ package peerdas_test
 import (
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
 
 func TestValidatorsCustodyRequirement(t *testing.T) {
@@ -57,218 +53,3 @@ func TestValidatorsCustodyRequirement(t *testing.T) {
 		})
 	}
 }
-
-func TestDataColumnSidecars(t *testing.T) {
-	t.Run("sizes mismatch", func(t *testing.T) {
-		// Create a protobuf signed beacon block.
-		signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs.
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, params.BeaconConfig().NumberOfColumns),
-				Proofs: make([]kzg.Proof, params.BeaconConfig().NumberOfColumns),
-			},
-		}
-
-		rob, err := blocks.NewROBlock(signedBeaconBlock)
-		require.NoError(t, err)
-		_, err = peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
-		require.ErrorIs(t, err, peerdas.ErrSizeMismatch)
-	})
-
-	t.Run("cells array too short for column index", func(t *testing.T) {
-		// Create a Fulu block with a blob commitment.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with insufficient cells for the number of columns.
-		// This simulates a scenario where cellsAndProofs has fewer cells than expected columns.
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, 10),  // Only 10 cells
-				Proofs: make([]kzg.Proof, 10), // Only 10 proofs
-			},
-		}
-
-		// This should fail because the function will try to access columns up to NumberOfColumns
-		// but we only have 10 cells/proofs.
-		rob, err := blocks.NewROBlock(signedBeaconBlock)
-		require.NoError(t, err)
-		_, err = peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
-		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
-	})
-
-	t.Run("proofs array too short for column index", func(t *testing.T) {
-		// Create a Fulu block with a blob commitment.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{make([]byte, 48)}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with sufficient cells but insufficient proofs.
-		numberOfColumns := params.BeaconConfig().NumberOfColumns
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, numberOfColumns),
-				Proofs: make([]kzg.Proof, 5), // Only 5 proofs, less than columns
-			},
-		}
-
-		// This should fail when trying to access proof beyond index 4.
-		rob, err := blocks.NewROBlock(signedBeaconBlock)
-		require.NoError(t, err)
-		_, err = peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
-		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
-		require.ErrorContains(t, "not enough proofs", err)
-	})
-
-	t.Run("nominal", func(t *testing.T) {
-		// Create a Fulu block with blob commitments.
-		signedBeaconBlockPb := util.NewBeaconBlockFulu()
-		commitment1 := make([]byte, 48)
-		commitment2 := make([]byte, 48)
-
-		// Set different values to distinguish commitments
-		commitment1[0] = 0x01
-		commitment2[0] = 0x02
-		signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{commitment1, commitment2}
-
-		// Create a signed beacon block from the protobuf.
-		signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-		require.NoError(t, err)
-
-		// Create cells and proofs with correct dimensions.
-		numberOfColumns := params.BeaconConfig().NumberOfColumns
-		cellsAndProofs := []kzg.CellsAndProofs{
-			{
-				Cells:  make([]kzg.Cell, numberOfColumns),
-				Proofs: make([]kzg.Proof, numberOfColumns),
-			},
-			{
-				Cells:  make([]kzg.Cell, numberOfColumns),
-				Proofs: make([]kzg.Proof, numberOfColumns),
-			},
-		}
-
-		// Set distinct values in cells and proofs for testing
-		for i := range numberOfColumns {
-			cellsAndProofs[0].Cells[i][0] = byte(i)
-			cellsAndProofs[0].Proofs[i][0] = byte(i)
-			cellsAndProofs[1].Cells[i][0] = byte(i + 128)
-			cellsAndProofs[1].Proofs[i][0] = byte(i + 128)
-		}
-
-		rob, err := blocks.NewROBlock(signedBeaconBlock)
-		require.NoError(t, err)
-		sidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
-		require.NoError(t, err)
-		require.NotNil(t, sidecars)
-		require.Equal(t, int(numberOfColumns), len(sidecars))
-
-		// Verify each sidecar has the expected structure
-		for i, sidecar := range sidecars {
-			require.Equal(t, uint64(i), sidecar.Index)
-			require.Equal(t, 2, len(sidecar.Column))
-			require.Equal(t, 2, len(sidecar.KzgCommitments))
-			require.Equal(t, 2, len(sidecar.KzgProofs))
-
-			// Verify commitments match what we set
-			require.DeepEqual(t, commitment1, sidecar.KzgCommitments[0])
-			require.DeepEqual(t, commitment2, sidecar.KzgCommitments[1])
-
-			// Verify column data comes from the correct cells
-			require.Equal(t, byte(i), sidecar.Column[0][0])
-			require.Equal(t, byte(i+128), sidecar.Column[1][0])
-
-			// Verify proofs come from the correct proofs
-			require.Equal(t, byte(i), sidecar.KzgProofs[0][0])
-			require.Equal(t, byte(i+128), sidecar.KzgProofs[1][0])
-		}
-	})
-}
-
-func TestReconstructionSource(t *testing.T) {
-	// Create a Fulu block with blob commitments.
-	signedBeaconBlockPb := util.NewBeaconBlockFulu()
-	commitment1 := make([]byte, 48)
-	commitment2 := make([]byte, 48)
-
-	// Set different values to distinguish commitments
-	commitment1[0] = 0x01
-	commitment2[0] = 0x02
-	signedBeaconBlockPb.Block.Body.BlobKzgCommitments = [][]byte{commitment1, commitment2}
-
-	// Create a signed beacon block from the protobuf.
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-	require.NoError(t, err)
-
-	// Create cells and proofs with correct dimensions.
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-	cellsAndProofs := []kzg.CellsAndProofs{
-		{
-			Cells:  make([]kzg.Cell, numberOfColumns),
-			Proofs: make([]kzg.Proof, numberOfColumns),
-		},
-		{
-			Cells:  make([]kzg.Cell, numberOfColumns),
-			Proofs: make([]kzg.Proof, numberOfColumns),
-		},
-	}
-
-	// Set distinct values in cells and proofs for testing
-	for i := range numberOfColumns {
-		cellsAndProofs[0].Cells[i][0] = byte(i)
-		cellsAndProofs[0].Proofs[i][0] = byte(i)
-		cellsAndProofs[1].Cells[i][0] = byte(i + 128)
-		cellsAndProofs[1].Proofs[i][0] = byte(i + 128)
-	}
-
-	rob, err := blocks.NewROBlock(signedBeaconBlock)
-	require.NoError(t, err)
-	sidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, peerdas.PopulateFromBlock(rob))
-	require.NoError(t, err)
-	require.NotNil(t, sidecars)
-	require.Equal(t, int(numberOfColumns), len(sidecars))
-
-	t.Run("from block", func(t *testing.T) {
-		src := peerdas.PopulateFromBlock(rob)
-		require.Equal(t, rob.Block().Slot(), src.Slot())
-		require.Equal(t, rob.Root(), src.Root())
-		require.Equal(t, rob.Block().ProposerIndex(), src.ProposerIndex())
-
-		commitments, err := src.Commitments()
-		require.NoError(t, err)
-		require.Equal(t, 2, len(commitments))
-		require.DeepEqual(t, commitment1, commitments[0])
-		require.DeepEqual(t, commitment2, commitments[1])
-
-		require.Equal(t, peerdas.BlockType, src.Type())
-	})
-
-	t.Run("from sidecar", func(t *testing.T) {
-		referenceSidecar := blocks.NewVerifiedRODataColumn(sidecars[0])
-		src := peerdas.PopulateFromSidecar(referenceSidecar)
-		require.Equal(t, referenceSidecar.Slot(), src.Slot())
-		require.Equal(t, referenceSidecar.BlockRoot(), src.Root())
-		require.Equal(t, referenceSidecar.ProposerIndex(), src.ProposerIndex())
-
-		commitments, err := src.Commitments()
-		require.NoError(t, err)
-		require.Equal(t, 2, len(commitments))
-		require.DeepEqual(t, commitment1, commitments[0])
-		require.DeepEqual(t, commitment2, commitments[1])
-
-		require.Equal(t, peerdas.SidecarType, src.Type())
-	})
-}

beacon-chain/core/peerdas/verification_test.go

@@ -16,60 +16,61 @@ func TestDataColumnsAlignWithBlock(t *testing.T) {
 	err := kzg.Start()
 	require.NoError(t, err)
 
-	params.BeaconConfig().FuluForkEpoch = params.BeaconConfig().ElectraForkEpoch + 4096*2
-	fs := util.SlotAtEpoch(t, params.BeaconConfig().ElectraForkEpoch)
-	require.NoError(t, err)
-	fuluMax := params.BeaconConfig().MaxBlobsPerBlock(fs)
 	t.Run("pre fulu", func(t *testing.T) {
-		block, _ := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, fs, 0)
+		block, _ := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 0, 0)
 		err := peerdas.DataColumnsAlignWithBlock(block, nil)
 		require.NoError(t, err)
 	})
 
-	t.Run("too many commitments", func(t *testing.T) {
-		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, fuluMax+1, util.WithSlot(fs))
+	t.Run("too many commitmnets", func(t *testing.T) {
+		params.SetupTestConfigCleanup(t)
+		config := params.BeaconConfig()
+		config.BlobSchedule = []params.BlobScheduleEntry{{}}
+		params.OverrideBeaconConfig(config)
+
+		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 3)
 		err := peerdas.DataColumnsAlignWithBlock(block, nil)
 		require.ErrorIs(t, err, peerdas.ErrTooManyCommitments)
 	})
 
 	t.Run("root mismatch", func(t *testing.T) {
-		_, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
-		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 0, util.WithSlot(fs))
+		_, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 0)
 		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
 		require.ErrorIs(t, err, peerdas.ErrRootMismatch)
 	})
 
 	t.Run("column size mismatch", func(t *testing.T) {
-		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
 		sidecars[0].Column = [][]byte{}
 		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
 		require.ErrorIs(t, err, peerdas.ErrBlockColumnSizeMismatch)
 	})
 
 	t.Run("KZG commitments size mismatch", func(t *testing.T) {
-		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
 		sidecars[0].KzgCommitments = [][]byte{}
 		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
 		require.ErrorIs(t, err, peerdas.ErrBlockColumnSizeMismatch)
 	})
 
 	t.Run("KZG proofs mismatch", func(t *testing.T) {
-		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
 		sidecars[0].KzgProofs = [][]byte{}
 		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
 		require.ErrorIs(t, err, peerdas.ErrBlockColumnSizeMismatch)
 	})
 
 	t.Run("commitment mismatch", func(t *testing.T) {
-		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
-		_, alteredSidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
+		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		_, alteredSidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
 		alteredSidecars[1].KzgCommitments[0][0]++ // Overflow is OK
 		err := peerdas.DataColumnsAlignWithBlock(block, alteredSidecars)
 		require.ErrorIs(t, err, peerdas.ErrCommitmentMismatch)
 	})
 
 	t.Run("nominal", func(t *testing.T) {
-		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2, util.WithSlot(fs))
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
 		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
 		require.NoError(t, err)
 	})

beacon-chain/core/time/slot_epoch.go

@@ -108,6 +108,12 @@ func CanUpgradeToFulu(slot primitives.Slot) bool {
 	return epochStart && fuluEpoch
 }
 
+func CanUpgradeToGloas(slot primitives.Slot) bool {
+	epochStart := slots.IsEpochStart(slot)
+	gloasEpoch := slots.ToEpoch(slot) == params.BeaconConfig().GloasForkEpoch
+	return epochStart && gloasEpoch
+}
+
 // CanProcessEpoch checks the eligibility to process epoch.
 // The epoch can be processed at the end of the last slot of every epoch.
 //

beacon-chain/core/transition/BUILD.bazel

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

beacon-chain/core/transition/transition.go

@@ -17,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/epoch/precompute"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/fulu"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/gloas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
@@ -389,6 +390,15 @@ func UpgradeState(ctx context.Context, state state.BeaconState) (state.BeaconSta
 		upgraded = true
 	}
 
+	if time.CanUpgradeToGloas(slot) {
+		state, err = gloas.UpgradeToGloas(ctx, state)
+		if err != nil {
+			tracing.AnnotateError(span, err)
+			return nil, err
+		}
+		upgraded = true
+	}
+
 	if upgraded {
 		log.WithField("version", version.String(state.Version())).Info("Upgraded state to")
 	}

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -10,7 +10,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/electra"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition/interop"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -379,16 +378,9 @@ func ProcessBlockForStateRoot(
 func altairOperations(ctx context.Context, st state.BeaconState, beaconBlock interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
 	var err error
 
-	hasSlashings := len(beaconBlock.Body().ProposerSlashings()) > 0 || len(beaconBlock.Body().AttesterSlashings()) > 0
-	// exitInfo is only needed for voluntary exits pre Electra.
-	hasExits := st.Version() < version.Electra && len(beaconBlock.Body().VoluntaryExits()) > 0
-	exitInfo := &validators.ExitInfo{}
-	if hasSlashings || hasExits {
-		// ExitInformation is expensive to compute, only do it if we need it.
-		exitInfo = v.ExitInformation(st)
-		if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
-			return nil, errors.Wrap(err, "could not update total active balance cache")
-		}
+	exitInfo := v.ExitInformation(st)
+	if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
+		return nil, errors.Wrap(err, "could not update total active balance cache")
 	}
 	st, err = b.ProcessProposerSlashings(ctx, st, beaconBlock.Body().ProposerSlashings(), exitInfo)
 	if err != nil {
@@ -415,15 +407,10 @@ func altairOperations(ctx context.Context, st state.BeaconState, beaconBlock int
 // This calls phase 0 block operations.
 func phase0Operations(ctx context.Context, st state.BeaconState, beaconBlock interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
 	var err error
-	hasSlashings := len(beaconBlock.Body().ProposerSlashings()) > 0 || len(beaconBlock.Body().AttesterSlashings()) > 0
-	hasExits := len(beaconBlock.Body().VoluntaryExits()) > 0
-	var exitInfo *v.ExitInfo
-	if hasSlashings || hasExits {
-		// ExitInformation is expensive to compute, only do it if we need it.
-		exitInfo = v.ExitInformation(st)
-		if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
-			return nil, errors.Wrap(err, "could not update total active balance cache")
-		}
+
+	exitInfo := v.ExitInformation(st)
+	if err := helpers.UpdateTotalActiveBalanceCache(st, exitInfo.TotalActiveBalance); err != nil {
+		return nil, errors.Wrap(err, "could not update total active balance cache")
 	}
 	st, err = b.ProcessProposerSlashings(ctx, st, beaconBlock.Body().ProposerSlashings(), exitInfo)
 	if err != nil {

beacon-chain/core/validators/validator.go

@@ -13,6 +13,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/math"
+	mathutil "github.com/OffchainLabs/prysm/v6/math"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -59,7 +60,7 @@ func ExitInformation(s state.BeaconState) *ExitInfo {
 	_ = err
 
 	// Apply minimum balance as per spec
-	exitInfo.TotalActiveBalance = max(params.BeaconConfig().EffectiveBalanceIncrement, totalActiveBalance)
+	exitInfo.TotalActiveBalance = mathutil.Max(params.BeaconConfig().EffectiveBalanceIncrement, totalActiveBalance)
 	return exitInfo
 }
 
@@ -97,9 +98,7 @@ func InitiateValidatorExit(
 	if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
 		return s, ErrValidatorAlreadyExited
 	}
-	if exitInfo == nil {
-		return nil, errors.New("exit info is required to process validator exit")
-	}
+
 	// Compute exit queue epoch.
 	if s.Version() < version.Electra {
 		if err = initiateValidatorExitPreElectra(ctx, s, exitInfo); err != nil {
@@ -178,9 +177,6 @@ func initiateValidatorExitPreElectra(ctx context.Context, s state.BeaconState, e
 	//	if exit_queue_churn >= get_validator_churn_limit(state):
 	//	    exit_queue_epoch += Epoch(1)
 	exitableEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(s))
-	if exitInfo == nil {
-		return errors.New("exit info is required to process validator exit")
-	}
 	if exitableEpoch > exitInfo.HighestExitEpoch {
 		exitInfo.HighestExitEpoch = exitableEpoch
 		exitInfo.Churn = 0
@@ -239,9 +235,7 @@ func SlashValidator(
 	exitInfo *ExitInfo,
 ) (state.BeaconState, error) {
 	var err error
-	if exitInfo == nil {
-		return nil, errors.New("exit info is required to slash validator")
-	}
+
 	s, err = InitiateValidatorExitForTotalBal(ctx, s, slashedIdx, exitInfo, primitives.Gwei(exitInfo.TotalActiveBalance))
 	if err != nil && !errors.Is(err, ErrValidatorAlreadyExited) {
 		return nil, errors.Wrapf(err, "could not initiate validator %d exit", slashedIdx)

beacon-chain/das/availability_blobs_test.go

@@ -18,16 +18,13 @@ import (
 )
 
 func Test_commitmentsToCheck(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	params.BeaconConfig().FuluForkEpoch = params.BeaconConfig().ElectraForkEpoch + 4096*2
-	fulu := primitives.Slot(params.BeaconConfig().FuluForkEpoch) * params.BeaconConfig().SlotsPerEpoch
 	windowSlots, err := slots.EpochEnd(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest)
 	require.NoError(t, err)
-	windowSlots = windowSlots + primitives.Slot(params.BeaconConfig().FuluForkEpoch)
-	maxBlobs := params.LastNetworkScheduleEntry().MaxBlobsPerBlock
-	commits := make([][]byte, maxBlobs+1)
-	for i := 0; i < len(commits); i++ {
-		commits[i] = bytesutil.PadTo([]byte{byte(i)}, 48)
+	commits := [][]byte{
+		bytesutil.PadTo([]byte("a"), 48),
+		bytesutil.PadTo([]byte("b"), 48),
+		bytesutil.PadTo([]byte("c"), 48),
+		bytesutil.PadTo([]byte("d"), 48),
 	}
 	cases := []struct {
 		name    string
@@ -50,40 +47,41 @@ func Test_commitmentsToCheck(t *testing.T) {
 		{
 			name: "commitments within da",
 			block: func(t *testing.T) blocks.ROBlock {
-				d := util.NewBeaconBlockFulu()
-				d.Block.Body.BlobKzgCommitments = commits[:maxBlobs]
-				d.Block.Slot = fulu + 100
+				d := util.NewBeaconBlockDeneb()
+				d.Block.Body.BlobKzgCommitments = commits
+				d.Block.Slot = 100
 				sb, err := blocks.NewSignedBeaconBlock(d)
 				require.NoError(t, err)
 				rb, err := blocks.NewROBlock(sb)
 				require.NoError(t, err)
 				return rb
 			},
-			commits: commits[:maxBlobs],
-			slot:    fulu + 100,
+			commits: commits,
+			slot:    100,
 		},
 		{
 			name: "commitments outside da",
 			block: func(t *testing.T) blocks.ROBlock {
-				d := util.NewBeaconBlockFulu()
-				d.Block.Slot = fulu
+				d := util.NewBeaconBlockDeneb()
 				// block is from slot 0, "current slot" is window size +1 (so outside the window)
-				d.Block.Body.BlobKzgCommitments = commits[:maxBlobs]
+				d.Block.Body.BlobKzgCommitments = commits
 				sb, err := blocks.NewSignedBeaconBlock(d)
 				require.NoError(t, err)
 				rb, err := blocks.NewROBlock(sb)
 				require.NoError(t, err)
 				return rb
 			},
-			slot: fulu + windowSlots + 1,
+			slot: windowSlots + 1,
 		},
 		{
 			name: "excessive commitments",
 			block: func(t *testing.T) blocks.ROBlock {
-				d := util.NewBeaconBlockFulu()
-				d.Block.Slot = fulu + 100
+				d := util.NewBeaconBlockDeneb()
+				d.Block.Slot = 100
 				// block is from slot 0, "current slot" is window size +1 (so outside the window)
 				d.Block.Body.BlobKzgCommitments = commits
+				// Double the number of commitments, assert that this is over the limit
+				d.Block.Body.BlobKzgCommitments = append(commits, d.Block.Body.BlobKzgCommitments...)
 				sb, err := blocks.NewSignedBeaconBlock(d)
 				require.NoError(t, err)
 				rb, err := blocks.NewROBlock(sb)
@@ -117,69 +115,67 @@ func Test_commitmentsToCheck(t *testing.T) {
 func TestLazilyPersistent_Missing(t *testing.T) {
 	ctx := t.Context()
 	store := filesystem.NewEphemeralBlobStorage(t)
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
 
-	blk, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, ds, 3)
+	blk, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 3)
 
 	mbv := &mockBlobBatchVerifier{t: t, scs: blobSidecars}
 	as := NewLazilyPersistentStore(store, mbv)
 
 	// Only one commitment persisted, should return error with other indices
-	require.NoError(t, as.Persist(ds, blobSidecars[2]))
-	err := as.IsDataAvailable(ctx, ds, blk)
+	require.NoError(t, as.Persist(1, blobSidecars[2]))
+	err := as.IsDataAvailable(ctx, 1, blk)
 	require.ErrorIs(t, err, errMissingSidecar)
 
 	// All but one persisted, return missing idx
-	require.NoError(t, as.Persist(ds, blobSidecars[0]))
-	err = as.IsDataAvailable(ctx, ds, blk)
+	require.NoError(t, as.Persist(1, blobSidecars[0]))
+	err = as.IsDataAvailable(ctx, 1, blk)
 	require.ErrorIs(t, err, errMissingSidecar)
 
 	// All persisted, return nil
-	require.NoError(t, as.Persist(ds, blobSidecars...))
+	require.NoError(t, as.Persist(1, blobSidecars...))
 
-	require.NoError(t, as.IsDataAvailable(ctx, ds, blk))
+	require.NoError(t, as.IsDataAvailable(ctx, 1, blk))
 }
 
 func TestLazilyPersistent_Mismatch(t *testing.T) {
 	ctx := t.Context()
 	store := filesystem.NewEphemeralBlobStorage(t)
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
 
-	blk, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, ds, 3)
+	blk, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 3)
 
 	mbv := &mockBlobBatchVerifier{t: t, err: errors.New("kzg check should not run")}
 	blobSidecars[0].KzgCommitment = bytesutil.PadTo([]byte("nope"), 48)
 	as := NewLazilyPersistentStore(store, mbv)
 
 	// Only one commitment persisted, should return error with other indices
-	require.NoError(t, as.Persist(ds, blobSidecars[0]))
-	err := as.IsDataAvailable(ctx, ds, blk)
+	require.NoError(t, as.Persist(1, blobSidecars[0]))
+	err := as.IsDataAvailable(ctx, 1, blk)
 	require.NotNil(t, err)
 	require.ErrorIs(t, err, errCommitmentMismatch)
 }
 
 func TestLazyPersistOnceCommitted(t *testing.T) {
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
-	_, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, ds, 6)
+	_, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 6)
 
 	as := NewLazilyPersistentStore(filesystem.NewEphemeralBlobStorage(t), &mockBlobBatchVerifier{})
 	// stashes as expected
-	require.NoError(t, as.Persist(ds, blobSidecars...))
+	require.NoError(t, as.Persist(1, blobSidecars...))
 	// ignores duplicates
-	require.ErrorIs(t, as.Persist(ds, blobSidecars...), ErrDuplicateSidecar)
+	require.ErrorIs(t, as.Persist(1, blobSidecars...), ErrDuplicateSidecar)
 
 	// ignores index out of bound
 	blobSidecars[0].Index = 6
-	require.ErrorIs(t, as.Persist(ds, blobSidecars[0]), errIndexOutOfBounds)
-	_, moreBlobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, ds, 4)
+	require.ErrorIs(t, as.Persist(1, blobSidecars[0]), errIndexOutOfBounds)
+
+	_, moreBlobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 4)
 
 	// ignores sidecars before the retention period
-	slotOOB := util.SlotAtEpoch(t, params.BeaconConfig().MinEpochsForBlobsSidecarsRequest)
-	slotOOB += ds + 32
-	require.NoError(t, as.Persist(slotOOB, moreBlobSidecars[0]))
+	slotOOB, err := slots.EpochStart(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest)
+	require.NoError(t, err)
+	require.NoError(t, as.Persist(32+slotOOB, moreBlobSidecars[0]))
 
 	// doesn't ignore new sidecars with a different block root
-	require.NoError(t, as.Persist(ds, moreBlobSidecars...))
+	require.NoError(t, as.Persist(1, moreBlobSidecars...))
 }
 
 type mockBlobBatchVerifier struct {

beacon-chain/das/blob_cache_test.go

@@ -39,7 +39,7 @@ func filterTestCaseSetup(slot primitives.Slot, nBlobs int, onDisk []int, numExpe
 		entry := &blobCacheEntry{}
 		if len(onDisk) > 0 {
 			od := map[[32]byte][]int{blk.Root(): onDisk}
-			sumz := filesystem.NewMockBlobStorageSummarizer(t, slots.ToEpoch(slot), od)
+			sumz := filesystem.NewMockBlobStorageSummarizer(t, od)
 			sum := sumz.Summary(blk.Root())
 			entry.setDiskSummary(sum)
 		}

beacon-chain/db/filesystem/blob.go

@@ -122,18 +122,18 @@ type BlobStorage struct {
 func (bs *BlobStorage) WarmCache() {
 	start := time.Now()
 	if bs.layoutName == LayoutNameFlat {
-		log.Info("Blob filesystem cache warm-up started. This may take a few minutes")
+		log.Info("Blob filesystem cache warm-up started. This may take a few minutes.")
 	} else {
-		log.Info("Blob filesystem cache warm-up started")
+		log.Info("Blob filesystem cache warm-up started.")
 	}
 
 	if err := warmCache(bs.layout, bs.cache); err != nil {
-		log.WithError(err).Error("Error encountered while warming up blob filesystem cache")
+		log.WithError(err).Error("Error encountered while warming up blob filesystem cache.")
 	}
 	if err := bs.migrateLayouts(); err != nil {
-		log.WithError(err).Error("Error encountered while migrating blob storage")
+		log.WithError(err).Error("Error encountered while migrating blob storage.")
 	}
-	log.WithField("elapsed", time.Since(start)).Info("Blob filesystem cache warm-up complete")
+	log.WithField("elapsed", time.Since(start)).Info("Blob filesystem cache warm-up complete.")
 }
 
 // If any blob storage directories are found for layouts besides the configured layout, migrate them.

beacon-chain/db/filesystem/blob_test.go

@@ -21,8 +21,7 @@ import (
 )
 
 func TestBlobStorage_SaveBlobData(t *testing.T) {
-	ds := util.SlotAtEpoch(t, params.BeaconConfig().DenebForkEpoch)
-	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, ds, params.BeaconConfig().MaxBlobsPerBlock(ds))
+	_, sidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, params.BeaconConfig().MaxBlobsPerBlock(1))
 	testSidecars := verification.FakeVerifySliceForTest(t, sidecars)
 
 	t.Run("no error for duplicate", func(t *testing.T) {
@@ -128,22 +127,21 @@ func TestBlobStorage_SaveBlobData(t *testing.T) {
 }
 
 func TestBlobIndicesBounds(t *testing.T) {
-	es := util.SlotAtEpoch(t, params.BeaconConfig().ElectraForkEpoch)
 	fs := afero.NewMemMapFs()
 	root := [32]byte{}
 
-	okIdx := uint64(params.BeaconConfig().MaxBlobsPerBlock(es)) - 1
-	writeFakeSSZ(t, fs, root, es, okIdx)
+	okIdx := uint64(params.BeaconConfig().MaxBlobsPerBlock(0)) - 1
+	writeFakeSSZ(t, fs, root, 0, okIdx)
 	bs := NewWarmedEphemeralBlobStorageUsingFs(t, fs, WithLayout(LayoutNameByEpoch))
 	indices := bs.Summary(root).mask
-	expected := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
+	expected := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
 	expected[okIdx] = true
 	for i := range expected {
 		require.Equal(t, expected[i], indices[i])
 	}
 
-	oobIdx := uint64(params.BeaconConfig().MaxBlobsPerBlock(es))
-	writeFakeSSZ(t, fs, root, es, oobIdx)
+	oobIdx := uint64(params.BeaconConfig().MaxBlobsPerBlock(0))
+	writeFakeSSZ(t, fs, root, 0, oobIdx)
 	// This now fails at cache warmup time.
 	require.ErrorIs(t, warmCache(bs.layout, bs.cache), errIndexOutOfBounds)
 }

beacon-chain/db/filesystem/cache_test.go

@@ -6,17 +6,14 @@ import (
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
 
 func TestSlotByRoot_Summary(t *testing.T) {
-	ee := params.BeaconConfig().ElectraForkEpoch
-	es := util.SlotAtEpoch(t, ee)
-	noneSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
-	allSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
-	firstSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
-	lastSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
-	oneSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
+	noneSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+	allSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+	firstSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+	lastSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
+	oneSet := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
 	firstSet[0] = true
 	lastSet[len(lastSet)-1] = true
 	oneSet[1] = true
@@ -56,7 +53,7 @@ func TestSlotByRoot_Summary(t *testing.T) {
 	for _, c := range cases {
 		if c.expected != nil {
 			key := bytesutil.ToBytes32([]byte(c.name))
-			sc.cache[key] = BlobStorageSummary{epoch: ee, mask: c.expected}
+			sc.cache[key] = BlobStorageSummary{epoch: 0, mask: c.expected}
 		}
 	}
 	for _, c := range cases {
@@ -76,7 +73,6 @@ func TestSlotByRoot_Summary(t *testing.T) {
 }
 
 func TestAllAvailable(t *testing.T) {
-	es := util.SlotAtEpoch(t, params.BeaconConfig().ElectraForkEpoch)
 	idxUpTo := func(u int) []int {
 		r := make([]int, u)
 		for i := range r {
@@ -129,13 +125,13 @@ func TestAllAvailable(t *testing.T) {
 		},
 		{
 			name:  "out of bound is safe",
-			count: params.BeaconConfig().MaxBlobsPerBlock(es) + 1,
+			count: params.BeaconConfig().MaxBlobsPerBlock(0) + 1,
 			aa:    false,
 		},
 		{
 			name:   "max present",
-			count:  params.BeaconConfig().MaxBlobsPerBlock(es),
-			idxSet: idxUpTo(params.BeaconConfig().MaxBlobsPerBlock(es)),
+			count:  params.BeaconConfig().MaxBlobsPerBlock(0),
+			idxSet: idxUpTo(params.BeaconConfig().MaxBlobsPerBlock(0)),
 			aa:     true,
 		},
 		{
@@ -147,7 +143,7 @@ func TestAllAvailable(t *testing.T) {
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {
-			mask := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(es))
+			mask := make([]bool, params.BeaconConfig().MaxBlobsPerBlock(0))
 			for _, idx := range c.idxSet {
 				mask[idx] = true
 			}

beacon-chain/db/filesystem/data_column.go

@@ -259,6 +259,7 @@ func (dcs *DataColumnStorage) Summary(root [fieldparams.RootLength]byte) DataCol
 }
 
 // Save saves data column sidecars into the database and asynchronously performs pruning.
+// The returned channel is closed when the pruning is complete.
 func (dcs *DataColumnStorage) Save(dataColumnSidecars []blocks.VerifiedRODataColumn) error {
 	startTime := time.Now()
 

beacon-chain/db/filesystem/iteration_test.go

@@ -11,7 +11,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -61,13 +60,12 @@ func TestRootFromDir(t *testing.T) {
 }
 
 func TestSlotFromFile(t *testing.T) {
-	es := util.SlotAtEpoch(t, params.BeaconConfig().ElectraForkEpoch)
 	cases := []struct {
 		slot primitives.Slot
 	}{
-		{slot: es + 0},
-		{slot: es + 2},
-		{slot: es + 1123581321},
+		{slot: 0},
+		{slot: 2},
+		{slot: 1123581321},
 		{slot: math.MaxUint64},
 	}
 	for _, c := range cases {
@@ -245,40 +243,39 @@ func TestSlotFromBlob(t *testing.T) {
 }
 
 func TestIterationComplete(t *testing.T) {
-	de := params.BeaconConfig().DenebForkEpoch
 	targets := []migrationTestTarget{
 		{
-			ident: ezIdent(t, "0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b", de+1234, 0),
-			path:  "by-epoch/%d/%d/0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b/0.ssz",
+			ident: ezIdent(t, "0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b", 1234, 0),
+			path:  "by-epoch/0/1234/0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b/0.ssz",
 		},
 		{
-			ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", de+5330, 0),
+			ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", 5330, 0),
 			slotOffset: 31,
-			path:       "by-epoch/%d/%d/0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86/0.ssz",
+			path:       "by-epoch/1/5330/0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86/0.ssz",
 		},
 		{
-			ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", de+5330, 1),
+			ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", 5330, 1),
 			slotOffset: 31,
-			path:       "by-epoch/%d/%d/0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86/1.ssz",
+			path:       "by-epoch/1/5330/0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86/1.ssz",
 		},
 		{
-			ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", -1+math.MaxUint64/32, 0),
+			ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", 16777216, 0),
 			slotOffset: 16,
-			path:       "by-epoch/%d/%d/0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c/0.ssz",
+			path:       "by-epoch/4096/16777216/0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c/0.ssz",
 		},
 		{
-			ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", -1+math.MaxUint64/32, 1),
+			ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", 16777216, 1),
 			slotOffset: 16,
-			path:       "by-epoch/%d/%d/0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c/1.ssz",
+			path:       "by-epoch/4096/16777216/0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c/1.ssz",
 		},
 		{
-			ident:      ezIdent(t, "0x42eabe3d2c125410cd226de6f2825fb7575ab896c3f52e43de1fa29e4c809aba", -1+math.MaxUint64/32, 0),
+			ident:      ezIdent(t, "0x42eabe3d2c125410cd226de6f2825fb7575ab896c3f52e43de1fa29e4c809aba", 16777217, 0),
 			slotOffset: 16,
-			path:       "by-epoch/%d/%d/0x42eabe3d2c125410cd226de6f2825fb7575ab896c3f52e43de1fa29e4c809aba/0.ssz",
+			path:       "by-epoch/4096/16777217/0x42eabe3d2c125410cd226de6f2825fb7575ab896c3f52e43de1fa29e4c809aba/0.ssz",
 		},
 		{
-			ident: ezIdent(t, "0x666cea5034e22bd3b849cb33914cad59afd88ee08e4d5bc0e997411c945fbc1d", de+11235, 1),
-			path:  "by-epoch/%d/%d/0x666cea5034e22bd3b849cb33914cad59afd88ee08e4d5bc0e997411c945fbc1d/1.ssz",
+			ident: ezIdent(t, "0x666cea5034e22bd3b849cb33914cad59afd88ee08e4d5bc0e997411c945fbc1d", 11235, 1),
+			path:  "by-epoch/2/11235/0x666cea5034e22bd3b849cb33914cad59afd88ee08e4d5bc0e997411c945fbc1d/1.ssz",
 		},
 	}
 	fs := afero.NewMemMapFs()
@@ -302,7 +299,6 @@ func TestIterationComplete(t *testing.T) {
 		require.Equal(t, true, ok)
 		require.Equal(t, tar.ident.epoch, entry.epoch)
 		require.Equal(t, true, entry.HasIndex(tar.ident.index))
-		path := fmt.Sprintf(tar.path, periodForEpoch(tar.ident.epoch), tar.ident.epoch)
-		require.Equal(t, path, byEpoch.sszPath(tar.ident))
+		require.Equal(t, tar.path, byEpoch.sszPath(tar.ident))
 	}
 }

beacon-chain/db/filesystem/migration_test.go

@@ -4,10 +4,10 @@ import (
 	"os"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/spf13/afero"
 )
 
@@ -18,7 +18,9 @@ func ezIdent(t *testing.T, rootStr string, epoch primitives.Epoch, index uint64)
 }
 
 func setupTestBlobFile(t *testing.T, ident blobIdent, offset primitives.Slot, fs afero.Fs, l fsLayout) {
-	slot := util.SlotAtEpoch(t, ident.epoch) + offset
+	slot, err := slots.EpochStart(ident.epoch)
+	require.NoError(t, err)
+	slot += offset
 	_, sc := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, slot, 1)
 	scb, err := sc[0].MarshalSSZ()
 	require.NoError(t, err)
@@ -51,7 +53,6 @@ func testAssertFsMigrated(t *testing.T, fs afero.Fs, ident blobIdent, before, af
 }
 
 func TestMigrations(t *testing.T) {
-	de := params.BeaconConfig().DenebForkEpoch
 	cases := []struct {
 		name           string
 		forwardLayout  string
@@ -64,18 +65,18 @@ func TestMigrations(t *testing.T) {
 			forwardLayout:  LayoutNameByEpoch,
 			targets: []migrationTestTarget{
 				{
-					ident: ezIdent(t, "0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b", de+1234, 0),
+					ident: ezIdent(t, "0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b", 1234, 0),
 				},
 				{
-					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", de+5330, 0),
+					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", 5330, 0),
 					slotOffset: 31,
 				},
 				{
-					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", de+5330, 1),
+					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", 5330, 1),
 					slotOffset: 31,
 				},
 				{
-					ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", de+16777216, 0),
+					ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", 16777216, 0),
 					slotOffset: 16,
 				},
 			},
@@ -86,33 +87,33 @@ func TestMigrations(t *testing.T) {
 			forwardLayout:  LayoutNameByEpoch,
 			targets: []migrationTestTarget{
 				{
-					ident: ezIdent(t, "0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b", de+1234, 0),
+					ident: ezIdent(t, "0x0125e54c64c925018c9296965a5b622d9f5ab626c10917860dcfb6aa09a0a00b", 1234, 0),
 				},
 				{
-					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", de+5330, 0),
+					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", 5330, 0),
 					slotOffset: 31,
 				},
 				{
-					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", de+5330, 1),
+					ident:      ezIdent(t, "0x0127dba6fd30fdbb47e73e861d5c6e602b38ac3ddc945bb6a2fc4e10761e9a86", 5330, 1),
 					slotOffset: 31,
 				},
 				{
-					ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", de+16777216, 0),
+					ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", 16777216, 0),
 					slotOffset: 16,
 					migrated:   true,
 				},
 				{
-					ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", de+16777216, 1),
+					ident:      ezIdent(t, "0x0232521756a0b965eab2c2245d7ad85feaeaf5f427cd14d1a7531f9d555b415c", 16777216, 1),
 					slotOffset: 16,
 					migrated:   true,
 				},
 				{
-					ident:      ezIdent(t, "0x42eabe3d2c125410cd226de6f2825fb7575ab896c3f52e43de1fa29e4c809aba", de+16777217, 0),
+					ident:      ezIdent(t, "0x42eabe3d2c125410cd226de6f2825fb7575ab896c3f52e43de1fa29e4c809aba", 16777217, 0),
 					slotOffset: 16,
 					migrated:   true,
 				},
 				{
-					ident:    ezIdent(t, "0x666cea5034e22bd3b849cb33914cad59afd88ee08e4d5bc0e997411c945fbc1d", de+11235, 1),
+					ident:    ezIdent(t, "0x666cea5034e22bd3b849cb33914cad59afd88ee08e4d5bc0e997411c945fbc1d", 11235, 1),
 					migrated: true,
 				},
 			},

beacon-chain/db/filesystem/mock.go

@@ -88,11 +88,11 @@ func NewEphemeralBlobStorageWithMocker(t testing.TB) (*BlobMocker, *BlobStorage)
 	return &BlobMocker{fs: fs, bs: bs}, bs
 }
 
-func NewMockBlobStorageSummarizer(t *testing.T, epoch primitives.Epoch, set map[[32]byte][]int) BlobStorageSummarizer {
+func NewMockBlobStorageSummarizer(t *testing.T, set map[[32]byte][]int) BlobStorageSummarizer {
 	c := newBlobStorageCache()
 	for k, v := range set {
 		for i := range v {
-			if err := c.ensure(blobIdent{root: k, epoch: epoch, index: uint64(v[i])}); err != nil {
+			if err := c.ensure(blobIdent{root: k, epoch: 0, index: uint64(v[i])}); err != nil {
 				t.Fatal(err)
 			}
 		}

beacon-chain/db/filesystem/pruner_test.go

@@ -142,7 +142,6 @@ func testRoots(n int) [][32]byte {
 }
 
 func TestLayoutPruneBefore(t *testing.T) {
-	electra := params.BeaconConfig().ElectraForkEpoch
 	roots := testRoots(10)
 	cases := []struct {
 		name        string
@@ -154,27 +153,27 @@ func TestLayoutPruneBefore(t *testing.T) {
 	}{
 		{
 			name:        "none pruned",
-			pruneBefore: electra + 1,
+			pruneBefore: 1,
 			pruned:      []testIdent{},
 			remain: []testIdent{
-				{offset: 1, blobIdent: blobIdent{root: roots[0], epoch: electra + 1, index: 0}},
-				{offset: 1, blobIdent: blobIdent{root: roots[1], epoch: electra + 1, index: 0}},
+				{offset: 1, blobIdent: blobIdent{root: roots[0], epoch: 1, index: 0}},
+				{offset: 1, blobIdent: blobIdent{root: roots[1], epoch: 1, index: 0}},
 			},
 		},
 		{
 			name:        "expected pruned before epoch",
-			pruneBefore: electra + 3,
+			pruneBefore: 3,
 			pruned: []testIdent{
-				{offset: 0, blobIdent: blobIdent{root: roots[0], epoch: electra + 1, index: 0}},
-				{offset: 31, blobIdent: blobIdent{root: roots[1], epoch: electra + 1, index: 5}},
-				{offset: 0, blobIdent: blobIdent{root: roots[2], epoch: electra + 2, index: 0}},
-				{offset: 31, blobIdent: blobIdent{root: roots[3], epoch: electra + 2, index: 3}},
+				{offset: 0, blobIdent: blobIdent{root: roots[0], epoch: 1, index: 0}},
+				{offset: 31, blobIdent: blobIdent{root: roots[1], epoch: 1, index: 5}},
+				{offset: 0, blobIdent: blobIdent{root: roots[2], epoch: 2, index: 0}},
+				{offset: 31, blobIdent: blobIdent{root: roots[3], epoch: 2, index: 3}},
 			},
 			remain: []testIdent{
-				{offset: 0, blobIdent: blobIdent{root: roots[4], epoch: electra + 3, index: 2}},  // boundary
-				{offset: 31, blobIdent: blobIdent{root: roots[5], epoch: electra + 3, index: 0}}, // boundary
-				{offset: 0, blobIdent: blobIdent{root: roots[6], epoch: electra + 4, index: 1}},
-				{offset: 31, blobIdent: blobIdent{root: roots[7], epoch: electra + 4, index: 5}},
+				{offset: 0, blobIdent: blobIdent{root: roots[4], epoch: 3, index: 2}},  // boundary
+				{offset: 31, blobIdent: blobIdent{root: roots[5], epoch: 3, index: 0}}, // boundary
+				{offset: 0, blobIdent: blobIdent{root: roots[6], epoch: 4, index: 1}},
+				{offset: 31, blobIdent: blobIdent{root: roots[7], epoch: 4, index: 5}},
 			},
 			sum: pruneSummary{blobsPruned: 4},
 		},

beacon-chain/db/kv/state.go

@@ -954,9 +954,7 @@ func (s *Store) CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint pr
 	deletedRoots := make([][32]byte, 0)
 
 	oRoot, err := s.OriginCheckpointBlockRoot(ctx)
-	if err != nil && !errors.Is(err, ErrNotFoundOriginBlockRoot) {
-		// If the node did not use checkpoint sync, there will be no origin block root.
-		// Use zero hash which will never match any actual state root
+	if err != nil {
 		return err
 	}
 

beacon-chain/db/kv/state_test.go

@@ -10,7 +10,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -1284,50 +1283,3 @@ func BenchmarkState_CheckStateSaveTime_10(b *testing.B) { checkStateSaveTime(b,
 
 func BenchmarkState_CheckStateReadTime_1(b *testing.B)  { checkStateReadTime(b, 1) }
 func BenchmarkState_CheckStateReadTime_10(b *testing.B) { checkStateReadTime(b, 10) }
-
-func TestStore_CleanUpDirtyStates_NoOriginRoot(t *testing.T) {
-	// This test verifies that CleanUpDirtyStates does not fail when the origin block root is not set,
-	// which can happen when starting from genesis or in certain fork scenarios like Fulu.
-	db := setupDB(t)
-	genesisState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	genesisRoot := [fieldparams.RootLength]byte{'a'}
-	require.NoError(t, db.SaveGenesisBlockRoot(t.Context(), genesisRoot))
-	require.NoError(t, db.SaveState(t.Context(), genesisState, genesisRoot))
-	// Note: We intentionally do NOT call SaveOriginCheckpointBlockRoot here
-	// to simulate the scenario where origin block root is not set
-	slotsPerArchivedPoint := primitives.Slot(128)
-	bRoots := make([][fieldparams.RootLength]byte, 0)
-	prevRoot := genesisRoot
-	for i := primitives.Slot(1); i <= slotsPerArchivedPoint; i++ { // skip slot 0
-		b := util.NewBeaconBlock()
-		b.Block.Slot = i
-		b.Block.ParentRoot = prevRoot[:]
-		r, err := b.Block.HashTreeRoot()
-		require.NoError(t, err)
-		wsb, err := blocks.NewSignedBeaconBlock(b)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveBlock(t.Context(), wsb))
-		bRoots = append(bRoots, r)
-		prevRoot = r
-		st, err := util.NewBeaconState()
-		require.NoError(t, err)
-		require.NoError(t, st.SetSlot(i))
-		require.NoError(t, db.SaveState(t.Context(), st, r))
-	}
-	require.NoError(t, db.SaveFinalizedCheckpoint(t.Context(), &ethpb.Checkpoint{
-		Root:  bRoots[len(bRoots)-1][:],
-		Epoch: primitives.Epoch(slotsPerArchivedPoint / params.BeaconConfig().SlotsPerEpoch),
-	}))
-	// This should not fail even though origin block root is not set
-	err = db.CleanUpDirtyStates(t.Context(), slotsPerArchivedPoint)
-	require.NoError(t, err)
-	// Verify that cleanup still works correctly
-	for i, root := range bRoots {
-		if primitives.Slot(i) >= slotsPerArchivedPoint.SubSlot(slotsPerArchivedPoint.Div(3)) {
-			require.Equal(t, true, db.HasState(t.Context(), root))
-		} else {
-			require.Equal(t, false, db.HasState(t.Context(), root))
-		}
-	}
-}

beacon-chain/db/slasherkv/pruning.go

@@ -4,26 +4,17 @@ import (
 	"bytes"
 	"context"
 	"encoding/binary"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/pkg/errors"
 	bolt "go.etcd.io/bbolt"
 )
 
-var errTimeOut = errors.New("operation timed out")
-
 // PruneAttestationsAtEpoch deletes all attestations from the slasher DB with target epoch
 // less than or equal to the specified epoch.
 func (s *Store) PruneAttestationsAtEpoch(
-	ctx context.Context, maxEpoch primitives.Epoch,
+	_ context.Context, maxEpoch primitives.Epoch,
 ) (numPruned uint, err error) {
-	// In some cases, pruning may take a very long time and consume significant memory in the
-	// open Update transaction. Therefore, we impose a 1 minute timeout on this operation.
-	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
-	defer cancel()
-
 	// We can prune everything less than the current epoch - history length.
 	encodedEndPruneEpoch := make([]byte, 8)
 	binary.BigEndian.PutUint64(encodedEndPruneEpoch, uint64(maxEpoch))
@@ -57,18 +48,13 @@ func (s *Store) PruneAttestationsAtEpoch(
 		return
 	}
 
-	err = s.db.Update(func(tx *bolt.Tx) error {
+	if err = s.db.Update(func(tx *bolt.Tx) error {
 		signingRootsBkt := tx.Bucket(attestationDataRootsBucket)
 		attRecordsBkt := tx.Bucket(attestationRecordsBucket)
 		c := signingRootsBkt.Cursor()
 
 		// We begin a pruning iteration starting from the first item in the bucket.
 		for k, v := c.First(); k != nil; k, v = c.Next() {
-			if ctx.Err() != nil {
-				// Exit the routine if the context has expired.
-				return errTimeOut
-			}
-
 			// We check the epoch from the current key in the database.
 			// If we have hit an epoch that is greater than the end epoch of the pruning process,
 			// we then completely exit the process as we are done.
@@ -81,27 +67,18 @@ func (s *Store) PruneAttestationsAtEpoch(
 			// so it is possible we have a few adjacent objects that have the same slot, such as
 			//  (target_epoch = 3 ++ _) => encode(attestation)
 			if err := signingRootsBkt.Delete(k); err != nil {
-				return errors.Wrap(err, "delete attestation signing root")
+				return err
 			}
 			if err := attRecordsBkt.Delete(v); err != nil {
-				return errors.Wrap(err, "delete attestation record")
+				return err
 			}
 			slasherAttestationsPrunedTotal.Inc()
 			numPruned++
 		}
 		return nil
-	})
-
-	if errors.Is(err, errTimeOut) {
-		log.Warning("Aborting pruning routine")
+	}); err != nil {
 		return
 	}
-
-	if err != nil {
-		log.WithError(err).Error("Failed to prune attestations")
-		return
-	}
-
 	return
 }
 

beacon-chain/execution/BUILD.bazel

@@ -25,7 +25,6 @@ go_library(
         "//testing/spectest:__subpackages__",
     ],
     deps = [
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
@@ -104,7 +103,6 @@ go_test(
         "//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/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",

beacon-chain/execution/engine_client.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
@@ -58,6 +57,11 @@ var (
 		GetPayloadMethodV5,
 		GetBlobsV2,
 	}
+
+	gloasEngineEndpoints = []string{
+		NewPayloadMethodV5,
+		GetPayloadMethodV6,
+	}
 )
 
 const (
@@ -68,6 +72,8 @@ const (
 	NewPayloadMethodV3 = "engine_newPayloadV3"
 	// NewPayloadMethodV4 is the engine_newPayloadVX method added at Electra.
 	NewPayloadMethodV4 = "engine_newPayloadV4"
+	// NewPayloadMethodV5 is the engine_newPayloadVX method added at Gloas.
+	NewPayloadMethodV5 = "engine_newPayloadV5"
 	// ForkchoiceUpdatedMethod v1 request string for JSON-RPC.
 	ForkchoiceUpdatedMethod = "engine_forkchoiceUpdatedV1"
 	// ForkchoiceUpdatedMethodV2 v2 request string for JSON-RPC.
@@ -84,6 +90,8 @@ const (
 	GetPayloadMethodV4 = "engine_getPayloadV4"
 	// GetPayloadMethodV5 is the get payload method added for fulu
 	GetPayloadMethodV5 = "engine_getPayloadV5"
+	// GetPayloadMethodV6 is the get payload method added for gloas
+	GetPayloadMethodV6 = "engine_getPayloadV6"
 	// BlockByHashMethod request string for JSON-RPC.
 	BlockByHashMethod = "eth_getBlockByHash"
 	// BlockByNumberMethod request string for JSON-RPC.
@@ -102,7 +110,10 @@ const (
 	defaultEngineTimeout = time.Second
 )
 
-var errInvalidPayloadBodyResponse = errors.New("engine api payload body response is invalid")
+var (
+	errInvalidPayloadBodyResponse  = errors.New("engine api payload body response is invalid")
+	errMissingBlobsAndProofsFromEL = errors.New("engine api payload body response is missing blobs and proofs")
+)
 
 // ForkchoiceUpdatedResponse is the response kind received by the
 // engine_forkchoiceUpdatedV1 endpoint.
@@ -121,7 +132,7 @@ type Reconstructor interface {
 		ctx context.Context, blindedBlocks []interfaces.ReadOnlySignedBeaconBlock,
 	) ([]interfaces.SignedBeaconBlock, error)
 	ReconstructBlobSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte, hi func(uint64) bool) ([]blocks.VerifiedROBlob, error)
-	ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error)
+	ReconstructDataColumnSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error)
 }
 
 // EngineCaller defines a client that can interact with an Ethereum
@@ -142,9 +153,10 @@ var ErrEmptyBlockHash = errors.New("Block hash is empty 0x0000...")
 func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionData, versionedHashes []common.Hash, parentBlockRoot *common.Hash, executionRequests *pb.ExecutionRequests) ([]byte, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.NewPayload")
 	defer span.End()
-	defer func(start time.Time) {
+	start := time.Now()
+	defer func() {
 		newPayloadLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}(time.Now())
+	}()
 
 	d := time.Now().Add(time.Duration(params.BeaconConfig().ExecutionEngineTimeoutValue) * time.Second)
 	ctx, cancel := context.WithDeadline(ctx, d)
@@ -178,14 +190,23 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 				return nil, handleRPCError(err)
 			}
 		}
+	case *pb.ExecutionPayloadGloas:
+		if executionRequests == nil {
+			return nil, errors.New("execution requests are required for gloas execution payload")
+		}
+		flattenedRequests, err := pb.EncodeExecutionRequests(executionRequests)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to encode execution requests")
+		}
+		err = s.rpcClient.CallContext(ctx, result, NewPayloadMethodV5, payloadPb, versionedHashes, parentBlockRoot, flattenedRequests)
+		if err != nil {
+			return nil, handleRPCError(err)
+		}
 	default:
 		return nil, errors.New("unknown execution data type")
 	}
 	if result.ValidationError != "" {
-		log.WithField("status", result.Status.String()).
-			WithField("parentRoot", fmt.Sprintf("%#x", parentBlockRoot)).
-			WithError(errors.New(result.ValidationError)).
-			Error("Got a validation error in newPayload")
+		log.WithError(errors.New(result.ValidationError)).Error("Got a validation error in newPayload")
 	}
 	switch result.Status {
 	case pb.PayloadStatus_INVALID_BLOCK_HASH:
@@ -197,7 +218,7 @@ func (s *Service) NewPayload(ctx context.Context, payload interfaces.ExecutionDa
 	case pb.PayloadStatus_VALID:
 		return result.LatestValidHash, nil
 	default:
-		return nil, errors.Wrapf(ErrUnknownPayloadStatus, "unknown payload status: %s", result.Status.String())
+		return nil, ErrUnknownPayloadStatus
 	}
 }
 
@@ -273,6 +294,9 @@ func (s *Service) ForkchoiceUpdated(
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
 	epoch := slots.ToEpoch(slot)
+	if epoch >= params.BeaconConfig().GloasForkEpoch {
+		return GetPayloadMethodV6, &pb.ExecutionBundleGloas{}
+	}
 	if epoch >= params.BeaconConfig().FuluForkEpoch {
 		return GetPayloadMethodV5, &pb.ExecutionBundleFulu{}
 	}
@@ -325,6 +349,10 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 		supportedEngineEndpoints = append(supportedEngineEndpoints, fuluEngineEndpoints...)
 	}
 
+	if params.GloasEnabled() {
+		supportedEngineEndpoints = append(supportedEngineEndpoints, gloasEngineEndpoints...)
+	}
+
 	elSupportedEndpointsSlice := make([]string, len(supportedEngineEndpoints))
 	if err := s.rpcClient.CallContext(ctx, &elSupportedEndpointsSlice, ExchangeCapabilities, supportedEngineEndpoints); err != nil {
 		return nil, handleRPCError(err)
@@ -651,40 +679,22 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	return verifiedBlobs, nil
 }
 
-func (s *Service) ConstructDataColumnSidecars(ctx context.Context, populator peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
-	root := populator.Root()
+// ReconstructDataColumnSidecars reconstructs the verified data column sidecars for a given beacon block.
+// It retrieves the KZG commitments from the block body, fetches the associated blobs and cell proofs from the EL,
+// and constructs the corresponding verified read-only data column sidecars.
+func (s *Service) ReconstructDataColumnSidecars(ctx context.Context, signedROBlock interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
+	block := signedROBlock.Block()
 
-	// Fetch cells and proofs from the execution client using the KZG commitments from the sidecar.
-	commitments, err := populator.Commitments()
+	log := log.WithFields(logrus.Fields{
+		"root": fmt.Sprintf("%#x", blockRoot),
+		"slot": block.Slot(),
+	})
+
+	kzgCommitments, err := block.Body().BlobKzgCommitments()
 	if err != nil {
-		return nil, wrapWithBlockRoot(err, root, "commitments")
+		return nil, wrapWithBlockRoot(err, blockRoot, "blob KZG commitments")
 	}
 
-	cellsAndProofs, err := s.fetchCellsAndProofsFromExecution(ctx, commitments)
-	if err != nil {
-		return nil, wrapWithBlockRoot(err, root, "fetch cells and proofs from execution client")
-	}
-
-	// Return early if nothing is returned from the EL.
-	if len(cellsAndProofs) == 0 {
-		return nil, nil
-	}
-
-	// Construct data column sidears from the signed block and cells and proofs.
-	roSidecars, err := peerdas.DataColumnSidecars(cellsAndProofs, populator)
-	if err != nil {
-		return nil, wrapWithBlockRoot(err, populator.Root(), "data column sidcars from column sidecar")
-	}
-
-	// Upgrade the sidecars to verified sidecars.
-	// We trust the execution layer we are connected to, so we can upgrade the sidecar into a verified one.
-	verifiedROSidecars := upgradeSidecarsToVerifiedSidecars(roSidecars)
-
-	return verifiedROSidecars, nil
-}
-
-// fetchCellsAndProofsFromExecution fetches cells and proofs from the execution client (using engine_getBlobsV2 execution API method)
-func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommitments [][]byte) ([]kzg.CellsAndProofs, error) {
 	// Collect KZG hashes for all blobs.
 	versionedHashes := make([]common.Hash, 0, len(kzgCommitments))
 	for _, commitment := range kzgCommitments {
@@ -695,32 +705,47 @@ func (s *Service) fetchCellsAndProofsFromExecution(ctx context.Context, kzgCommi
 	// Fetch all blobsAndCellsProofs from the execution client.
 	blobAndProofV2s, err := s.GetBlobsV2(ctx, versionedHashes)
 	if err != nil {
-		return nil, errors.Wrapf(err, "get blobs V2")
+		return nil, wrapWithBlockRoot(err, blockRoot, "get blobs V2")
 	}
 
 	// Return early if nothing is returned from the EL.
 	if len(blobAndProofV2s) == 0 {
+		log.Debug("No blobs returned from execution client")
 		return nil, nil
 	}
 
-	// Compute cells and proofs from the blobs and cell proofs.
-	cellsAndProofs, err := peerdas.ComputeCellsAndProofsFromStructured(blobAndProofV2s)
-	if err != nil {
-		return nil, errors.Wrap(err, "compute cells and proofs")
+	// Extract the blobs and proofs from the blobAndProofV2s.
+	blobs, cellProofs := make([][]byte, 0, len(blobAndProofV2s)), make([][]byte, 0, len(blobAndProofV2s))
+	for _, blobsAndProofs := range blobAndProofV2s {
+		if blobsAndProofs == nil {
+			return nil, wrapWithBlockRoot(errMissingBlobsAndProofsFromEL, blockRoot, "")
+		}
+
+		blobs, cellProofs = append(blobs, blobsAndProofs.Blob), append(cellProofs, blobsAndProofs.KzgProofs...)
 	}
 
-	return cellsAndProofs, nil
-}
+	// Construct the data column sidcars from the blobs and cell proofs provided by the execution client.
+	dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(signedROBlock, blobs, cellProofs)
+	if err != nil {
+		return nil, wrapWithBlockRoot(err, blockRoot, "construct data column sidecars")
+	}
 
-// upgradeSidecarsToVerifiedSidecars upgrades a list of data column sidecars into verified data column sidecars.
-func upgradeSidecarsToVerifiedSidecars(roSidecars []blocks.RODataColumn) []blocks.VerifiedRODataColumn {
-	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(roSidecars))
-	for _, roSidecar := range roSidecars {
-		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roSidecar)
+	// Finally, construct verified RO data column sidecars.
+	// We trust the execution layer we are connected to, so we can upgrade the read only data column sidecar into a verified one.
+	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
+	for _, dataColumnSidecar := range dataColumnSidecars {
+		roDataColumn, err := blocks.NewRODataColumnWithRoot(dataColumnSidecar, blockRoot)
+		if err != nil {
+			return nil, wrapWithBlockRoot(err, blockRoot, "new read-only data column with root")
+		}
+
+		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
 		verifiedRODataColumns = append(verifiedRODataColumns, verifiedRODataColumn)
 	}
 
-	return verifiedRODataColumns
+	log.Debug("Data columns successfully reconstructed from the execution client")
+
+	return verifiedRODataColumns, nil
 }
 
 func fullPayloadFromPayloadBody(
@@ -1012,6 +1037,6 @@ func toBlockNumArg(number *big.Int) string {
 }
 
 // wrapWithBlockRoot returns a new error with the given block root.
-func wrapWithBlockRoot(err error, blockRoot [fieldparams.RootLength]byte, message string) error {
+func wrapWithBlockRoot(err error, blockRoot [32]byte, message string) error {
 	return errors.Wrap(err, fmt.Sprintf("%s for block %#x", message, blockRoot))
 }

beacon-chain/execution/engine_client_test.go

@@ -14,7 +14,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	mocks "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
@@ -928,7 +927,7 @@ func TestClient_HTTP(t *testing.T) {
 		wrappedPayload, err := blocks.WrappedExecutionPayload(execPayload)
 		require.NoError(t, err)
 		resp, err := client.NewPayload(ctx, wrappedPayload, []common.Hash{}, &common.Hash{}, nil)
-		require.ErrorIs(t, err, ErrUnknownPayloadStatus)
+		require.ErrorIs(t, ErrUnknownPayloadStatus, err)
 		require.DeepEqual(t, []uint8(nil), resp)
 	})
 	t.Run(BlockByNumberMethod, func(t *testing.T) {
@@ -2557,7 +2556,7 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	})
 }
 
-func TestConstructDataColumnSidecars(t *testing.T) {
+func TestReconstructDataColumnSidecars(t *testing.T) {
 	// Start the trusted setup.
 	err := kzg.Start()
 	require.NoError(t, err)
@@ -2581,14 +2580,11 @@ func TestConstructDataColumnSidecars(t *testing.T) {
 	sb, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
 
-	roBlock, err := blocks.NewROBlockWithRoot(sb, r)
-	require.NoError(t, err)
-
 	ctx := context.Background()
 
 	t.Run("GetBlobsV2 is not supported", func(t *testing.T) {
-		_, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
-		require.ErrorContains(t, "engine_getBlobsV2 is not supported", err)
+		_, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		require.ErrorContains(t, "get blobs V2 for block", err)
 	})
 
 	t.Run("nothing received", func(t *testing.T) {
@@ -2598,7 +2594,7 @@ func TestConstructDataColumnSidecars(t *testing.T) {
 		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
 		defer rpcClient.Close()
 
-		dataColumns, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
 		require.NoError(t, err)
 		require.Equal(t, 0, len(dataColumns))
 	})
@@ -2611,22 +2607,23 @@ func TestConstructDataColumnSidecars(t *testing.T) {
 		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
 		defer rpcClient.Close()
 
-		dataColumns, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
 		require.NoError(t, err)
 		require.Equal(t, 128, len(dataColumns))
 	})
 
-	// t.Run("missing some blobs", func(t *testing.T) {
-	// 	blobMasks := []bool{false, true, true, true, true, true}
-	// 	srv := createBlobServerV2(t, 6, blobMasks)
-	// 	defer srv.Close()
+	t.Run("missing some blobs", func(t *testing.T) {
+		blobMasks := []bool{false, true, true, true, true, true}
+		srv := createBlobServerV2(t, 6, blobMasks)
+		defer srv.Close()
 
-	// 	rpcClient, client := setupRpcClientV2(t, srv.URL, client)
-	// 	defer rpcClient.Close()
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
 
-	// 	_, err := client.ConstructDataColumnSidecars(ctx, peerdas.PopulateFromBlock(roBlock))
-	// 	require.ErrorContains(t, "fetch cells and proofs from execution client", err)
-	// })
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
+		require.ErrorContains(t, errMissingBlobsAndProofsFromEL.Error(), err)
+		require.Equal(t, 0, len(dataColumns))
+	})
 }
 
 func createRandomKzgCommitments(t *testing.T, num int) [][]byte {

beacon-chain/execution/testing/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
     ],
     deps = [
         "//async/event:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/execution/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",

beacon-chain/execution/testing/mock_engine_client.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"math/big"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -117,8 +116,7 @@ func (e *EngineClient) ReconstructBlobSidecars(context.Context, interfaces.ReadO
 	return e.BlobSidecars, e.ErrorBlobSidecars
 }
 
-// ConstructDataColumnSidecars is a mock implementation of the ConstructDataColumnSidecars method.
-func (e *EngineClient) ConstructDataColumnSidecars(context.Context, peerdas.ConstructionPopulator) ([]blocks.VerifiedRODataColumn, error) {
+func (e *EngineClient) ReconstructDataColumnSidecars(context.Context, interfaces.ReadOnlySignedBeaconBlock, [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
 	return e.DataColumnSidecars, e.ErrorDataColumnSidecars
 }
 

beacon-chain/forkchoice/doubly-linked-tree/forkchoice.go

@@ -463,20 +463,22 @@ func (f *ForkChoice) CommonAncestor(ctx context.Context, r1 [32]byte, r2 [32]byt
 }
 
 // InsertChain inserts all nodes corresponding to blocks in the slice
-// `blocks`. This slice must be ordered in increasing slot order and
-// each consecutive entry must be a child of the previous one.
-// The parent of the first block in this list must already be present in forkchoice.
+// `blocks`. This slice must be ordered from child to parent. It includes all
+// blocks **except** the first one (that is the one with the highest slot
+// number). All blocks are assumed to be a strict chain
+// where blocks[i].Parent = blocks[i+1]. Also, we assume that the parent of the
+// last block in this list is already included in forkchoice store.
 func (f *ForkChoice) InsertChain(ctx context.Context, chain []*forkchoicetypes.BlockAndCheckpoints) error {
 	if len(chain) == 0 {
 		return nil
 	}
-	for _, bcp := range chain {
+	for i := len(chain) - 1; i > 0; i-- {
 		if _, err := f.store.insert(ctx,
-			bcp.Block,
-			bcp.JustifiedCheckpoint.Epoch, bcp.FinalizedCheckpoint.Epoch); err != nil {
+			chain[i].Block,
+			chain[i].JustifiedCheckpoint.Epoch, chain[i].FinalizedCheckpoint.Epoch); err != nil {
 			return err
 		}
-		if err := f.updateCheckpoints(ctx, bcp.JustifiedCheckpoint, bcp.FinalizedCheckpoint); err != nil {
+		if err := f.updateCheckpoints(ctx, chain[i].JustifiedCheckpoint, chain[i].FinalizedCheckpoint); err != nil {
 			return err
 		}
 	}

beacon-chain/forkchoice/doubly-linked-tree/forkchoice_test.go

@@ -630,15 +630,14 @@ func TestStore_InsertChain(t *testing.T) {
 			FinalizedCheckpoint: &ethpb.Checkpoint{Epoch: 1, Root: params.BeaconConfig().ZeroHash[:]},
 		})
 	}
-	// InsertChain now expects blocks in increasing slot order
-	require.NoError(t, f.InsertChain(t.Context(), blks))
+	args := make([]*forkchoicetypes.BlockAndCheckpoints, 10)
+	for i := 0; i < len(blks); i++ {
+		args[i] = blks[10-i-1]
+	}
+	require.NoError(t, f.InsertChain(t.Context(), args))
 
-	// Test partial insertion: first insert the foundation blocks, then a subset
 	f = setup(1, 1)
-	// Insert first 2 blocks to establish a chain from genesis
-	require.NoError(t, f.InsertChain(t.Context(), blks[:2]))
-	// Then insert the remaining blocks
-	require.NoError(t, f.InsertChain(t.Context(), blks[2:]))
+	require.NoError(t, f.InsertChain(t.Context(), args[2:]))
 }
 
 func TestForkChoice_UpdateCheckpoints(t *testing.T) {

beacon-chain/light-client/cache.go

@@ -1,26 +0,0 @@
-package light_client
-
-import (
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-)
-
-// cache tracks LC data over the non finalized chain for different branches.
-type cache struct {
-	items map[[32]byte]*cacheItem
-}
-
-// cacheItem represents the LC data for a block. It tracks the best update and finality update seen in that branch.
-type cacheItem struct {
-	parent             *cacheItem      // parent item in the cache, can be nil
-	period             uint64          // sync committee period
-	slot               primitives.Slot // slot of the signature block
-	bestUpdate         interfaces.LightClientUpdate
-	bestFinalityUpdate interfaces.LightClientFinalityUpdate
-}
-
-func newLightClientCache() *cache {
-	return &cache{
-		items: make(map[[32]byte]*cacheItem),
-	}
-}

beacon-chain/light-client/cache_test.go

@@ -1,24 +0,0 @@
-package light_client
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-func TestLCCache(t *testing.T) {
-	lcCache := newLightClientCache()
-	require.NotNil(t, lcCache)
-
-	item := &cacheItem{
-		period:             5,
-		bestUpdate:         nil,
-		bestFinalityUpdate: nil,
-	}
-
-	blkRoot := [32]byte{4, 5, 6}
-
-	lcCache.items[blkRoot] = item
-
-	require.Equal(t, item, lcCache.items[blkRoot], "Expected to find the item in the cache")
-}

beacon-chain/light-client/store.go

@@ -1,389 +0,0 @@
-package light_client
-
-import (
-	"context"
-	"sync"
-
-	"github.com/OffchainLabs/prysm/v6/async/event"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed"
-	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-	"github.com/pkg/errors"
-	log "github.com/sirupsen/logrus"
-)
-
-var ErrLightClientBootstrapNotFound = errors.New("light client bootstrap not found")
-
-type Store struct {
-	mu sync.RWMutex
-
-	beaconDB             iface.HeadAccessDatabase
-	lastFinalityUpdate   interfaces.LightClientFinalityUpdate   // tracks the best finality update seen so far
-	lastOptimisticUpdate interfaces.LightClientOptimisticUpdate // tracks the best optimistic update seen so far
-	p2p                  p2p.Accessor
-	stateFeed            event.SubscriberSender
-	cache                *cache // non finality cache
-}
-
-func NewLightClientStore(p p2p.Accessor, e event.SubscriberSender, db iface.HeadAccessDatabase) *Store {
-	return &Store{
-		beaconDB:  db,
-		p2p:       p,
-		stateFeed: e,
-		cache:     newLightClientCache(),
-	}
-}
-
-func (s *Store) SaveLCData(ctx context.Context,
-	state state.BeaconState,
-	block interfaces.ReadOnlySignedBeaconBlock,
-	attestedState state.BeaconState,
-	attestedBlock interfaces.ReadOnlySignedBeaconBlock,
-	finalizedBlock interfaces.ReadOnlySignedBeaconBlock,
-	headBlockRoot [32]byte) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	// compute required data
-	update, err := NewLightClientUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
-	if err != nil {
-		return errors.Wrapf(err, "failed to create light client update")
-	}
-	finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock, finalizedBlock)
-	if err != nil {
-		return errors.Wrapf(err, "failed to create light client finality update")
-	}
-	optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(ctx, state, block, attestedState, attestedBlock)
-	if err != nil {
-		return errors.Wrapf(err, "failed to create light client optimistic update")
-	}
-	period := slots.SyncCommitteePeriod(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
-	blockRoot, err := attestedBlock.Block().HashTreeRoot()
-	if err != nil {
-		return errors.Wrapf(err, "failed to compute attested block root")
-	}
-	parentRoot := [32]byte(update.AttestedHeader().Beacon().ParentRoot)
-	signatureBlockRoot, err := block.Block().HashTreeRoot()
-	if err != nil {
-		return errors.Wrapf(err, "failed to compute signature block root")
-	}
-
-	newBlockIsHead := signatureBlockRoot == headBlockRoot
-
-	// create the new cache item
-	newCacheItem := &cacheItem{
-		period: period,
-		slot:   attestedBlock.Block().Slot(),
-	}
-
-	// check if parent exists in cache
-	parentItem, ok := s.cache.items[parentRoot]
-	if ok {
-		newCacheItem.parent = parentItem
-	} else {
-		// if not, create an item for the parent, but don't need to save it since it's the accumulated best update and is just used for comparison
-		bestUpdateSoFar, err := s.beaconDB.LightClientUpdate(ctx, period)
-		if err != nil {
-			return errors.Wrapf(err, "could not get best light client update for period %d", period)
-		}
-		parentItem = &cacheItem{
-			period:             period,
-			bestUpdate:         bestUpdateSoFar,
-			bestFinalityUpdate: s.lastFinalityUpdate,
-		}
-	}
-
-	// if at a period boundary, no need to compare data, just save new ones
-	if parentItem.period != period {
-		newCacheItem.bestUpdate = update
-		newCacheItem.bestFinalityUpdate = finalityUpdate
-		s.cache.items[blockRoot] = newCacheItem
-
-		s.setLastOptimisticUpdate(optimisticUpdate, true)
-
-		// if the new block is not head, we don't want to change our lastFinalityUpdate
-		if newBlockIsHead {
-			s.setLastFinalityUpdate(finalityUpdate, true)
-		}
-
-		return nil
-	}
-
-	// if in the same period, compare updates
-	isUpdateBetter, err := IsBetterUpdate(update, parentItem.bestUpdate)
-	if err != nil {
-		return errors.Wrapf(err, "could not compare light client updates")
-	}
-	if isUpdateBetter {
-		newCacheItem.bestUpdate = update
-	} else {
-		newCacheItem.bestUpdate = parentItem.bestUpdate
-	}
-
-	isBetterFinalityUpdate := IsBetterFinalityUpdate(finalityUpdate, parentItem.bestFinalityUpdate)
-	if isBetterFinalityUpdate {
-		newCacheItem.bestFinalityUpdate = finalityUpdate
-	} else {
-		newCacheItem.bestFinalityUpdate = parentItem.bestFinalityUpdate
-	}
-
-	// save new item in cache
-	s.cache.items[blockRoot] = newCacheItem
-
-	// save lastOptimisticUpdate if better
-	if isBetterOptimisticUpdate := IsBetterOptimisticUpdate(optimisticUpdate, s.lastOptimisticUpdate); isBetterOptimisticUpdate {
-		s.setLastOptimisticUpdate(optimisticUpdate, true)
-	}
-
-	// if the new block is considered the head, set the last finality update
-	if newBlockIsHead {
-		s.setLastFinalityUpdate(newCacheItem.bestFinalityUpdate, isBetterFinalityUpdate)
-	}
-
-	return nil
-}
-
-func (s *Store) LightClientBootstrap(ctx context.Context, blockRoot [32]byte) (interfaces.LightClientBootstrap, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Fetch the light client bootstrap from the database
-	bootstrap, err := s.beaconDB.LightClientBootstrap(ctx, blockRoot[:])
-	if err != nil {
-		return nil, err
-	}
-	if bootstrap == nil { // not found
-		return nil, ErrLightClientBootstrapNotFound
-	}
-
-	return bootstrap, nil
-}
-
-func (s *Store) SaveLightClientBootstrap(ctx context.Context, blockRoot [32]byte, state state.BeaconState) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	blk, err := s.beaconDB.Block(ctx, blockRoot)
-	if err != nil {
-		return errors.Wrapf(err, "failed to fetch block for root %x", blockRoot)
-	}
-	if blk == nil {
-		return errors.Errorf("nil block for root %x", blockRoot)
-	}
-
-	bootstrap, err := NewLightClientBootstrapFromBeaconState(ctx, state.Slot(), state, blk)
-	if err != nil {
-		return errors.Wrapf(err, "failed to create light client bootstrap for block root %x", blockRoot)
-	}
-
-	// Save the light client bootstrap to the database
-	if err := s.beaconDB.SaveLightClientBootstrap(ctx, blockRoot[:], bootstrap); err != nil {
-		return err
-	}
-	return nil
-}
-
-func (s *Store) LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64, headBlock interfaces.ReadOnlySignedBeaconBlock) ([]interfaces.LightClientUpdate, error) {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-
-	// Fetch the light client updatesMap from the database
-	updatesMap, err := s.beaconDB.LightClientUpdates(ctx, startPeriod, endPeriod)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to get updates from the database")
-	}
-
-	cacheUpdatesByPeriod, err := s.getCacheUpdatesByPeriod(headBlock)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to get updates from cache")
-	}
-
-	for period, update := range cacheUpdatesByPeriod {
-		updatesMap[period] = update
-	}
-
-	var updates []interfaces.LightClientUpdate
-
-	for i := startPeriod; i <= endPeriod; i++ {
-		update, ok := updatesMap[i]
-		if !ok {
-			// Only return the first contiguous range of updates
-			break
-		}
-		updates = append(updates, update)
-	}
-
-	return updates, nil
-}
-
-func (s *Store) LightClientUpdate(ctx context.Context, period uint64, headBlock interfaces.ReadOnlySignedBeaconBlock) (interfaces.LightClientUpdate, error) {
-	// we don't need to lock here because the LightClientUpdates method locks the store
-	updates, err := s.LightClientUpdates(ctx, period, period, headBlock)
-	if err != nil {
-		return nil, errors.Wrapf(err, "failed to get light client update for period %d", period)
-	}
-	if len(updates) == 0 {
-		return nil, nil
-	}
-	return updates[0], nil
-}
-
-func (s *Store) getCacheUpdatesByPeriod(headBlock interfaces.ReadOnlySignedBeaconBlock) (map[uint64]interfaces.LightClientUpdate, error) {
-	updatesByPeriod := make(map[uint64]interfaces.LightClientUpdate)
-
-	cacheHeadRoot := headBlock.Block().ParentRoot()
-
-	cacheHeadItem, ok := s.cache.items[cacheHeadRoot]
-	if !ok {
-		log.Debugf("Head root %x not found in light client cache. Returning empty updates map for non finality cache.", cacheHeadRoot)
-		return updatesByPeriod, nil
-	}
-
-	for cacheHeadItem != nil {
-		if _, exists := updatesByPeriod[cacheHeadItem.period]; !exists {
-			updatesByPeriod[cacheHeadItem.period] = cacheHeadItem.bestUpdate
-		}
-		cacheHeadItem = cacheHeadItem.parent
-	}
-
-	return updatesByPeriod, nil
-}
-
-// SetLastFinalityUpdate should be used only for testing.
-func (s *Store) SetLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	s.setLastFinalityUpdate(update, broadcast)
-}
-
-func (s *Store) setLastFinalityUpdate(update interfaces.LightClientFinalityUpdate, broadcast bool) {
-	if broadcast && IsFinalityUpdateValidForBroadcast(update, s.lastFinalityUpdate) {
-		go func() {
-			if err := s.p2p.BroadcastLightClientFinalityUpdate(context.Background(), update); err != nil {
-				log.WithError(err).Error("Could not broadcast light client finality update")
-			}
-		}()
-	}
-
-	s.lastFinalityUpdate = update
-	log.Debug("Saved new light client finality update")
-
-	s.stateFeed.Send(&feed.Event{
-		Type: statefeed.LightClientFinalityUpdate,
-		Data: update,
-	})
-}
-
-func (s *Store) LastFinalityUpdate() interfaces.LightClientFinalityUpdate {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.lastFinalityUpdate
-}
-
-// SetLastOptimisticUpdate should be used only for testing.
-func (s *Store) SetLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	s.setLastOptimisticUpdate(update, broadcast)
-}
-
-func (s *Store) setLastOptimisticUpdate(update interfaces.LightClientOptimisticUpdate, broadcast bool) {
-	if broadcast {
-		go func() {
-			if err := s.p2p.BroadcastLightClientOptimisticUpdate(context.Background(), update); err != nil {
-				log.WithError(err).Error("Could not broadcast light client optimistic update")
-			}
-		}()
-	}
-
-	s.lastOptimisticUpdate = update
-	log.Debug("Saved new light client optimistic update")
-
-	s.stateFeed.Send(&feed.Event{
-		Type: statefeed.LightClientOptimisticUpdate,
-		Data: update,
-	})
-}
-
-func (s *Store) LastOptimisticUpdate() interfaces.LightClientOptimisticUpdate {
-	s.mu.RLock()
-	defer s.mu.RUnlock()
-	return s.lastOptimisticUpdate
-}
-
-func (s *Store) MigrateToCold(ctx context.Context, finalizedRoot [32]byte) error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	// If there cache is empty (some problem in processing data), we can skip migration.
-	// This is a safety check and should not happen in normal operation.
-	if len(s.cache.items) == 0 {
-		log.Debug("Non-finality cache is empty. Skipping migration.")
-		return nil
-	}
-
-	blk, err := s.beaconDB.Block(ctx, finalizedRoot)
-	if err != nil {
-		return errors.Wrapf(err, "failed to fetch block for finalized root %x", finalizedRoot)
-	}
-	if blk == nil {
-		return errors.Errorf("nil block for finalized root %x", finalizedRoot)
-	}
-	finalizedSlot := blk.Block().Slot()
-	finalizedCacheHeadRoot := blk.Block().ParentRoot()
-
-	var finalizedCacheHead *cacheItem
-	var ok bool
-
-	finalizedCacheHead, ok = s.cache.items[finalizedCacheHeadRoot]
-	if !ok {
-		log.Debugf("Finalized block's parent root %x not found in light client cache. Cleaning the broken part of the cache.", finalizedCacheHeadRoot)
-
-		// delete non-finality cache items older than finalized slot
-		s.cleanCache(finalizedSlot)
-
-		return nil
-	}
-
-	updateByPeriod := make(map[uint64]interfaces.LightClientUpdate)
-	// Traverse the cache from the head item to the tail, collecting updates
-	for item := finalizedCacheHead; item != nil; item = item.parent {
-		if _, seen := updateByPeriod[item.period]; seen {
-			// We already have an update for this period, skip this item
-			continue
-		}
-		updateByPeriod[item.period] = item.bestUpdate
-	}
-
-	// save updates to db
-	for period, update := range updateByPeriod {
-		err = s.beaconDB.SaveLightClientUpdate(ctx, period, update)
-		if err != nil {
-			log.WithError(err).Errorf("failed to save light client update for period %d. Skipping this period.", period)
-		}
-	}
-
-	// delete non-finality cache items older than finalized slot
-	s.cleanCache(finalizedSlot)
-
-	return nil
-}
-
-func (s *Store) cleanCache(finalizedSlot primitives.Slot) {
-	// delete non-finality cache items older than finalized slot
-	for k, v := range s.cache.items {
-		if v.slot < finalizedSlot {
-			delete(s.cache.items, k)
-		}
-		if v.parent != nil && v.parent.slot < finalizedSlot {
-			v.parent = nil // remove parent reference
-		}
-	}
-}

beacon-chain/light-client/store_test.go

@@ -1,968 +0,0 @@
-package light_client
-
-import (
-	"context"
-	"testing"
-	"time"
-
-	"github.com/OffchainLabs/prysm/v6/async/event"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
-	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
-	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/OffchainLabs/prysm/v6/time/slots"
-)
-
-func TestLightClientStore(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.AltairForkEpoch = 1
-	cfg.BellatrixForkEpoch = 2
-	cfg.CapellaForkEpoch = 3
-	cfg.DenebForkEpoch = 4
-	cfg.ElectraForkEpoch = 5
-	params.OverrideBeaconConfig(cfg)
-
-	// Initialize the light client store
-	lcStore := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), testDB.SetupDB(t))
-
-	// Create test light client updates for Capella and Deneb
-	lCapella := util.NewTestLightClient(t, version.Capella)
-	opUpdateCapella, err := NewLightClientOptimisticUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, opUpdateCapella, "OptimisticUpdateCapella is nil")
-	finUpdateCapella, err := NewLightClientFinalityUpdateFromBeaconState(lCapella.Ctx, lCapella.State, lCapella.Block, lCapella.AttestedState, lCapella.AttestedBlock, lCapella.FinalizedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, finUpdateCapella, "FinalityUpdateCapella is nil")
-
-	lDeneb := util.NewTestLightClient(t, version.Deneb)
-	opUpdateDeneb, err := NewLightClientOptimisticUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, opUpdateDeneb, "OptimisticUpdateDeneb is nil")
-	finUpdateDeneb, err := NewLightClientFinalityUpdateFromBeaconState(lDeneb.Ctx, lDeneb.State, lDeneb.Block, lDeneb.AttestedState, lDeneb.AttestedBlock, lDeneb.FinalizedBlock)
-	require.NoError(t, err)
-	require.NotNil(t, finUpdateDeneb, "FinalityUpdateDeneb is nil")
-
-	// Initially the store should have nil values for both updates
-	require.IsNil(t, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should be nil")
-	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
-
-	// Set and get finality with Capella update. Optimistic update should be nil
-	lcStore.SetLastFinalityUpdate(finUpdateCapella, false)
-	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
-	require.IsNil(t, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate should be nil")
-
-	// Set and get optimistic with Capella update. Finality update should be Capella
-	lcStore.SetLastOptimisticUpdate(opUpdateCapella, false)
-	require.Equal(t, opUpdateCapella, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
-	require.Equal(t, finUpdateCapella, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
-
-	// Set and get finality and optimistic with Deneb update
-	lcStore.SetLastFinalityUpdate(finUpdateDeneb, false)
-	lcStore.SetLastOptimisticUpdate(opUpdateDeneb, false)
-	require.Equal(t, finUpdateDeneb, lcStore.LastFinalityUpdate(), "lastFinalityUpdate is wrong")
-	require.Equal(t, opUpdateDeneb, lcStore.LastOptimisticUpdate(), "lastOptimisticUpdate is wrong")
-}
-
-func TestLightClientStore_SetLastFinalityUpdate(t *testing.T) {
-	p2p := p2pTesting.NewTestP2P(t)
-	lcStore := NewLightClientStore(p2p, new(event.Feed), testDB.SetupDB(t))
-
-	timeForGoroutinesToFinish := 20 * time.Microsecond
-	// update 0 with basic data and no supermajority following an empty lastFinalityUpdate - should save and broadcast
-	l0 := util.NewTestLightClient(t, version.Altair)
-	update0, err := NewLightClientFinalityUpdateFromBeaconState(l0.Ctx, l0.State, l0.Block, l0.AttestedState, l0.AttestedBlock, l0.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update0, lcStore.LastFinalityUpdate()), "update0 should be better than nil")
-	// update0 should be valid for broadcast - meaning it should be broadcasted
-	require.Equal(t, true, IsFinalityUpdateValidForBroadcast(update0, lcStore.LastFinalityUpdate()), "update0 should be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update0, true)
-	require.Equal(t, update0, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update when previous is nil")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 1 with same finality slot, increased attested slot, and no supermajority - should save but not broadcast
-	l1 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
-	update1, err := NewLightClientFinalityUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update1, update0), "update1 should be better than update0")
-	// update1 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update1, lcStore.LastFinalityUpdate()), "update1 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update1, true)
-	require.Equal(t, update1, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called after setting a new last finality update without supermajority")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 2 with same finality slot, increased attested slot, and supermajority - should save and broadcast
-	l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(2), util.WithSupermajority(0))
-	update2, err := NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update2, update1), "update2 should be better than update1")
-	// update2 should be valid for broadcast - meaning it should be broadcasted
-	require.Equal(t, true, IsFinalityUpdateValidForBroadcast(update2, lcStore.LastFinalityUpdate()), "update2 should be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update2, true)
-	require.Equal(t, update2, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after setting a new last finality update with supermajority")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 3 with same finality slot, increased attested slot, and supermajority - should save but not broadcast
-	l3 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(3), util.WithSupermajority(0))
-	update3, err := NewLightClientFinalityUpdateFromBeaconState(l3.Ctx, l3.State, l3.Block, l3.AttestedState, l3.AttestedBlock, l3.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update3, update2), "update3 should be better than update2")
-	// update3 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update3, lcStore.LastFinalityUpdate()), "update3 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update3, true)
-	require.Equal(t, update3, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been when previous was already broadcast")
-
-	// update 4 with increased finality slot, increased attested slot, and supermajority - should save and broadcast
-	l4 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0))
-	update4, err := NewLightClientFinalityUpdateFromBeaconState(l4.Ctx, l4.State, l4.Block, l4.AttestedState, l4.AttestedBlock, l4.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update4, update3), "update4 should be better than update3")
-	// update4 should be valid for broadcast - meaning it should be broadcasted
-	require.Equal(t, true, IsFinalityUpdateValidForBroadcast(update4, lcStore.LastFinalityUpdate()), "update4 should be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update4, true)
-	require.Equal(t, update4, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, true, p2p.BroadcastCalled.Load(), "Broadcast should have been called after a new finality update with increased finality slot")
-	p2p.BroadcastCalled.Store(false) // Reset for next test
-
-	// update 5 with the same new finality slot, increased attested slot, and supermajority - should save but not broadcast
-	l5 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(2), util.WithSupermajority(0))
-	update5, err := NewLightClientFinalityUpdateFromBeaconState(l5.Ctx, l5.State, l5.Block, l5.AttestedState, l5.AttestedBlock, l5.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update5, update4), "update5 should be better than update4")
-	// update5 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update5, lcStore.LastFinalityUpdate()), "update5 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update5, true)
-	require.Equal(t, update5, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
-
-	// update 6 with the same new finality slot, increased attested slot, and no supermajority - should save but not broadcast
-	l6 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedFinalizedSlot(1), util.WithIncreasedAttestedSlot(3))
-	update6, err := NewLightClientFinalityUpdateFromBeaconState(l6.Ctx, l6.State, l6.Block, l6.AttestedState, l6.AttestedBlock, l6.FinalizedBlock)
-	require.NoError(t, err, "Failed to create light client finality update")
-
-	require.Equal(t, true, IsBetterFinalityUpdate(update6, update5), "update6 should be better than update5")
-	// update6 should not be valid for broadcast - meaning it should not be broadcasted
-	require.Equal(t, false, IsFinalityUpdateValidForBroadcast(update6, lcStore.LastFinalityUpdate()), "update6 should not be valid for broadcast")
-
-	lcStore.SetLastFinalityUpdate(update6, true)
-	require.Equal(t, update6, lcStore.LastFinalityUpdate(), "lastFinalityUpdate should match the set value")
-	time.Sleep(timeForGoroutinesToFinish) // give some time for the broadcast goroutine to finish
-	require.Equal(t, false, p2p.BroadcastCalled.Load(), "Broadcast should not have been called when previous was already broadcast with supermajority")
-}
-
-func TestLightClientStore_SaveLCData(t *testing.T) {
-	t.Run("no parent in cache or db - new is head", func(t *testing.T) {
-		db := testDB.SetupDB(t)
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-
-		blkRoot, err := l.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.NoError(t, s.SaveLCData(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, blkRoot), "Failed to save light client data")
-
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
-		require.NoError(t, err)
-		attstedBlkRoot, err := l.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
-		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
-		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
-		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
-	})
-
-	t.Run("no parent in cache or db - new not head", func(t *testing.T) {
-		db := testDB.SetupDB(t)
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-
-		blkRoot, err := l.FinalizedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.NoError(t, s.SaveLCData(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, blkRoot), "Failed to save light client data")
-
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock)
-		require.NoError(t, err)
-		attstedBlkRoot, err := l.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.IsNil(t, s.lastFinalityUpdate, "Expected to not find the last finality update in the store since the block is not head")
-		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
-		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
-		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
-	})
-
-	t.Run("parent in db", func(t *testing.T) {
-		db := testDB.SetupDB(t)
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-
-		// save an update for this period in db
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		require.NoError(t, db.SaveLightClientUpdate(l.Ctx, period, update), "Failed to save light client update in db")
-
-		l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0)) // updates from this setup should be all better
-
-		blkRoot, err := l2.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.NoError(t, s.SaveLCData(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock, blkRoot), "Failed to save light client data")
-
-		update, err = NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock)
-		require.NoError(t, err)
-		attstedBlkRoot, err := l2.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
-		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
-		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
-		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
-	})
-
-	t.Run("parent in cache", func(t *testing.T) {
-		db := testDB.SetupDB(t)
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0)) // updates from this setup should be all better
-
-		// save the cache item for this period in cache
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		item := &cacheItem{
-			period:             period,
-			bestUpdate:         update,
-			bestFinalityUpdate: finalityUpdate,
-		}
-		attestedBlockRoot := l2.AttestedBlock.Block().ParentRoot() // we want this item to be the parent of the new block
-		s.cache.items[attestedBlockRoot] = item
-
-		blkRoot, err := l2.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.NoError(t, s.SaveLCData(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock, blkRoot), "Failed to save light client data")
-
-		update, err = NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err = NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock)
-		require.NoError(t, err)
-		attstedBlkRoot, err := l2.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
-		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
-		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
-		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
-	})
-
-	t.Run("parent in the previous period", func(t *testing.T) {
-		db := testDB.SetupDB(t)
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), db)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		l2 := util.NewTestLightClient(t, version.Bellatrix, util.WithIncreasedAttestedSlot(1), util.WithSupermajority(0)) // updates from this setup should be all better
-
-		// save the cache item for this period1 in cache
-		period1 := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err := NewLightClientFinalityUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		item := &cacheItem{
-			period:             period1,
-			bestUpdate:         update,
-			bestFinalityUpdate: finalityUpdate,
-		}
-		attestedBlockRoot := l2.AttestedBlock.Block().ParentRoot() // we want this item to be the parent of the new block
-		s.cache.items[attestedBlockRoot] = item
-
-		blkRoot, err := l2.Block.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.NoError(t, s.SaveLCData(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock, blkRoot), "Failed to save light client data")
-
-		update, err = NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-		finalityUpdate, err = NewLightClientFinalityUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-		optimisticUpdate, err := NewLightClientOptimisticUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock)
-		require.NoError(t, err)
-		attstedBlkRoot, err := l2.AttestedBlock.Block().HashTreeRoot()
-		require.NoError(t, err)
-
-		require.DeepEqual(t, finalityUpdate, s.lastFinalityUpdate, "Expected to find the last finality update in the store")
-		require.DeepEqual(t, optimisticUpdate, s.lastOptimisticUpdate, "Expected to find the last optimistic update in the store")
-		require.DeepEqual(t, update, s.cache.items[attstedBlkRoot].bestUpdate, "Expected to find the update in the non-finality cache")
-		require.DeepEqual(t, finalityUpdate, s.cache.items[attstedBlkRoot].bestFinalityUpdate, "Expected to find the finality update in the non-finality cache")
-	})
-}
-
-func TestLightClientStore_MigrateToCold(t *testing.T) {
-	// This tests the scenario where chain advances but the cache is empty.
-	// It should see that there is nothing in the cache to migrate and just update the tail to the new finalized root.
-	t.Run("empty cache", func(t *testing.T) {
-		beaconDB := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
-		require.NotNil(t, s)
-
-		for i := 0; i < 3; i++ {
-			newBlock := util.NewBeaconBlock()
-			newBlock.Block.Slot = primitives.Slot(32 + uint64(i))
-			newBlock.Block.ParentRoot = finalizedBlockRoot[:]
-			signedNewBlock, err := blocks.NewSignedBeaconBlock(newBlock)
-			require.NoError(t, err)
-			blockRoot, err := signedNewBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-			require.NoError(t, beaconDB.SaveBlock(ctx, signedNewBlock))
-			finalizedBlockRoot = blockRoot
-		}
-
-		err := s.MigrateToCold(ctx, finalizedBlockRoot)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(s.cache.items))
-	})
-
-	// This tests the scenario where chain advances but the CANONICAL cache is empty.
-	// It should see that there is nothing in the canonical cache to migrate and just update the tail to the new finalized root AND delete anything non-canonical.
-	t.Run("non canonical cache", func(t *testing.T) {
-		beaconDB := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
-		require.NotNil(t, s)
-
-		for i := 0; i < 3; i++ {
-			newBlock := util.NewBeaconBlock()
-			newBlock.Block.Slot = primitives.Slot(32 + uint64(i))
-			newBlock.Block.ParentRoot = finalizedBlockRoot[:]
-			signedNewBlock, err := blocks.NewSignedBeaconBlock(newBlock)
-			require.NoError(t, err)
-			blockRoot, err := signedNewBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-			require.NoError(t, beaconDB.SaveBlock(ctx, signedNewBlock))
-			finalizedBlockRoot = blockRoot
-		}
-
-		// Add a non-canonical item to the cache
-		cacheItem := &cacheItem{
-			period: 0,
-			slot:   33,
-		}
-		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
-		s.cache.items[nonCanonicalBlockRoot] = cacheItem
-
-		require.Equal(t, 1, len(s.cache.items))
-
-		err := s.MigrateToCold(ctx, finalizedBlockRoot)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
-	})
-
-	// db has update - cache has both canonical and non-canonical items.
-	// should update the update in db and delete cache.
-	t.Run("mixed cache - finality immediately after cache", func(t *testing.T) {
-		beaconDB := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
-		require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, finalizedBlockRoot))
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
-		require.NotNil(t, s)
-
-		// Save an update for this period in db
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		require.NoError(t, beaconDB.SaveLightClientUpdate(ctx, period, update))
-
-		lastBlockRoot := finalizedBlockRoot
-		lastAttestedRoot := finalizedBlockRoot
-		lastUpdate := update
-		for i := 1; i < 4; i++ {
-			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
-			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
-			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
-			lastBlockRoot, err = l.Block.Block().HashTreeRoot()
-			require.NoError(t, err)
-			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-			update, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-			require.NoError(t, err)
-			lastUpdate = update
-		}
-
-		require.Equal(t, 3, len(s.cache.items))
-
-		// Add a non-canonical item to the cache
-		cacheItem := &cacheItem{
-			period: 0,
-			slot:   33,
-		}
-		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
-		s.cache.items[nonCanonicalBlockRoot] = cacheItem
-
-		require.Equal(t, 4, len(s.cache.items))
-
-		err = s.MigrateToCold(ctx, lastBlockRoot)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
-		u, err := beaconDB.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		require.DeepEqual(t, lastUpdate, u)
-	})
-
-	// db has update - cache has both canonical and non-canonical items. finalized height is in the middle.
-	// should update the update in db and delete items in cache before finalized slot.
-	t.Run("mixed cache - finality middle of cache", func(t *testing.T) {
-		beaconDB := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
-		require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, finalizedBlockRoot))
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
-		require.NotNil(t, s)
-
-		// Save an update for this period in db
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		period := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		require.NoError(t, beaconDB.SaveLightClientUpdate(ctx, period, update))
-
-		lastBlockRoot := finalizedBlockRoot
-		lastUpdate := update
-		lastAttestedRoot := [32]byte{}
-		for i := 1; i < 4; i++ {
-			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
-			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
-			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
-			root, err := l.Block.Block().HashTreeRoot()
-			require.NoError(t, err)
-			lastBlockRoot = root
-			update, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-			require.NoError(t, err)
-			lastUpdate = update
-			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-		}
-
-		require.Equal(t, 3, len(s.cache.items))
-
-		// Add a non-canonical item to the cache
-		cacheItem := &cacheItem{
-			period: 0,
-			slot:   33,
-		}
-		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
-		s.cache.items[nonCanonicalBlockRoot] = cacheItem
-
-		require.Equal(t, 4, len(s.cache.items))
-
-		for i := 4; i < 7; i++ {
-			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(0), util.WithAttestedParentRoot(lastAttestedRoot))
-			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
-			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
-			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-		}
-
-		require.Equal(t, 7, len(s.cache.items))
-
-		err = s.MigrateToCold(ctx, lastBlockRoot)
-		require.NoError(t, err)
-		require.Equal(t, 3, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
-		u, err := beaconDB.LightClientUpdate(ctx, period)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		require.DeepEqual(t, lastUpdate, u)
-	})
-
-	// we have multiple periods in the cache before finalization happens. we expect all of them to be saved in db.
-	t.Run("finality after multiple periods in cache", func(t *testing.T) {
-		beaconDB := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		cfg := params.BeaconConfig().Copy()
-		cfg.EpochsPerSyncCommitteePeriod = 1
-		params.OverrideBeaconConfig(cfg)
-
-		finalizedBlockRoot, _ := saveInitialFinalizedCheckpointData(t, ctx, beaconDB)
-		require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, finalizedBlockRoot))
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), beaconDB)
-		require.NotNil(t, s)
-
-		// Save an update for this period1 in db
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-		period1 := slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		require.NoError(t, beaconDB.SaveLightClientUpdate(ctx, period1, update))
-
-		lastBlockRoot := finalizedBlockRoot
-		lastUpdatePeriod1 := update
-		lastAttestedRoot := [32]byte{}
-		for i := 1; i < 4; i++ {
-			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
-			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
-			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
-			root, err := l.Block.Block().HashTreeRoot()
-			require.NoError(t, err)
-			lastBlockRoot = root
-			lastUpdatePeriod1, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-			require.NoError(t, err)
-			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-		}
-
-		period2 := period1
-		var lastUpdatePeriod2 interfaces.LightClientUpdate
-		for i := 1; i < 4; i++ {
-			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)+33), util.WithSupermajority(uint64(i)), util.WithAttestedParentRoot(lastAttestedRoot))
-			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
-			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
-			root, err := l.Block.Block().HashTreeRoot()
-			require.NoError(t, err)
-			lastBlockRoot = root
-			lastUpdatePeriod2, err = NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-			require.NoError(t, err)
-			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-			period2 = slots.SyncCommitteePeriod(slots.ToEpoch(l.AttestedBlock.Block().Slot()))
-		}
-
-		require.Equal(t, 6, len(s.cache.items))
-
-		// Add a non-canonical item to the cache
-		cacheItem := &cacheItem{
-			period: 0,
-			slot:   33,
-		}
-		nonCanonicalBlockRoot := [32]byte{1, 2, 3, 4}
-		s.cache.items[nonCanonicalBlockRoot] = cacheItem
-
-		require.Equal(t, 7, len(s.cache.items))
-
-		for i := 4; i < 7; i++ {
-			l = util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(uint64(i)+33), util.WithSupermajority(0), util.WithAttestedParentRoot(lastAttestedRoot))
-			require.NoError(t, beaconDB.SaveBlock(ctx, l.Block))
-			require.NoError(t, s.SaveLCData(ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock, [32]byte{1}))
-			lastAttestedRoot, err = l.AttestedBlock.Block().HashTreeRoot()
-			require.NoError(t, err)
-		}
-
-		require.Equal(t, 10, len(s.cache.items))
-
-		err = s.MigrateToCold(ctx, lastBlockRoot)
-		require.NoError(t, err)
-		require.Equal(t, 3, len(s.cache.items), "Expected the non-canonical item in the cache to be deleted")
-		u, err := beaconDB.LightClientUpdate(ctx, period2)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		require.DeepEqual(t, lastUpdatePeriod2, u)
-		u, err = beaconDB.LightClientUpdate(ctx, period1)
-		require.NoError(t, err)
-		require.NotNil(t, u)
-		require.DeepEqual(t, lastUpdatePeriod1, u)
-	})
-}
-
-func saveInitialFinalizedCheckpointData(t *testing.T, ctx context.Context, beaconDB db.Database) ([32]byte, interfaces.SignedBeaconBlock) {
-	genesis := util.NewBeaconBlock()
-	genesisRoot, err := genesis.Block.HashTreeRoot()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, genesisRoot))
-	util.SaveBlock(t, ctx, beaconDB, genesis)
-	genesisState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, beaconDB.SaveState(ctx, genesisState, genesisRoot))
-
-	finalizedState, err := util.NewBeaconState()
-	require.NoError(t, err)
-	finalizedBlock := util.NewBeaconBlock()
-	finalizedBlock.Block.Slot = 32
-	finalizedBlock.Block.ParentRoot = genesisRoot[:]
-	signedFinalizedBlock, err := blocks.NewSignedBeaconBlock(finalizedBlock)
-	require.NoError(t, err)
-	finalizedBlockHeader, err := signedFinalizedBlock.Header()
-	require.NoError(t, err)
-	require.NoError(t, finalizedState.SetLatestBlockHeader(finalizedBlockHeader.Header))
-	finalizedStateRoot, err := finalizedState.HashTreeRoot(ctx)
-	require.NoError(t, err)
-	finalizedBlock.Block.StateRoot = finalizedStateRoot[:]
-	signedFinalizedBlock, err = blocks.NewSignedBeaconBlock(finalizedBlock)
-	require.NoError(t, err)
-	finalizedBlockRoot, err := signedFinalizedBlock.Block().HashTreeRoot()
-	require.NoError(t, err)
-	cp := ethpb.Checkpoint{
-		Epoch: 1,
-		Root:  finalizedBlockRoot[:],
-	}
-	require.NoError(t, beaconDB.SaveBlock(ctx, signedFinalizedBlock))
-	require.NoError(t, beaconDB.SaveState(ctx, finalizedState, finalizedBlockRoot))
-	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &cp))
-
-	return finalizedBlockRoot, signedFinalizedBlock
-}
-
-func TestLightClientStore_LightClientUpdatesByRange(t *testing.T) {
-	t.Run("no updates", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, finalizedBlock := saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		updates, err := s.LightClientUpdates(ctx, 2, 5, finalizedBlock)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(updates))
-	})
-
-	t.Run("single update from db", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, finalizedBlock := saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 3, update))
-
-		updates, err := s.LightClientUpdates(ctx, 3, 3, finalizedBlock)
-		require.NoError(t, err)
-		require.Equal(t, 1, len(updates))
-		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
-	})
-
-	t.Run("multiple updates from db", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, finalizedBlock := saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 3, update))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 4, update))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 5, update))
-
-		updates, err := s.LightClientUpdates(ctx, 3, 5, finalizedBlock)
-		require.NoError(t, err)
-		require.Equal(t, 3, len(updates))
-		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
-		require.DeepEqual(t, update, updates[1], "Expected to find the update in the store")
-		require.DeepEqual(t, update, updates[2], "Expected to find the update in the store")
-	})
-
-	t.Run("single update from cache", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-
-		cacheItem := &cacheItem{
-			period:     3,
-			bestUpdate: update,
-		}
-		s.cache.items[[32]byte{3}] = cacheItem
-
-		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{3})
-
-		updates, err := s.LightClientUpdates(ctx, 3, 3, headBlock)
-		require.NoError(t, err)
-		require.Equal(t, 1, len(updates))
-		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
-	})
-
-	t.Run("multiple updates from cache", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-
-		cacheItemP3 := &cacheItem{
-			period:     3,
-			bestUpdate: update,
-		}
-		s.cache.items[[32]byte{3}] = cacheItemP3
-
-		cacheItemP4 := &cacheItem{
-			period:     4,
-			bestUpdate: update,
-			parent:     cacheItemP3,
-		}
-		s.cache.items[[32]byte{4}] = cacheItemP4
-
-		cacheItemP5 := &cacheItem{
-			period:     5,
-			bestUpdate: update,
-			parent:     cacheItemP4,
-		}
-		s.cache.items[[32]byte{5}] = cacheItemP5
-
-		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
-
-		updates, err := s.LightClientUpdates(ctx, 3, 5, headBlock)
-		require.NoError(t, err)
-		require.Equal(t, 3, len(updates))
-		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
-		require.DeepEqual(t, update, updates[1], "Expected to find the update in the store")
-		require.DeepEqual(t, update, updates[2], "Expected to find the update in the store")
-	})
-
-	t.Run("multiple updates from both db and cache - no overlap", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l.Ctx, l.State, l.Block, l.AttestedState, l.AttestedBlock, l.FinalizedBlock)
-		require.NoError(t, err)
-
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 1, update))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 2, update))
-
-		cacheItemP3 := &cacheItem{
-			period:     3,
-			bestUpdate: update,
-		}
-		s.cache.items[[32]byte{3}] = cacheItemP3
-
-		cacheItemP4 := &cacheItem{
-			period:     4,
-			bestUpdate: update,
-			parent:     cacheItemP3,
-		}
-		s.cache.items[[32]byte{4}] = cacheItemP4
-
-		cacheItemP5 := &cacheItem{
-			period:     5,
-			bestUpdate: update,
-			parent:     cacheItemP4,
-		}
-		s.cache.items[[32]byte{5}] = cacheItemP5
-
-		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
-
-		updates, err := s.LightClientUpdates(ctx, 1, 5, headBlock)
-		require.NoError(t, err)
-		require.Equal(t, 5, len(updates))
-		for i := 0; i < 5; i++ {
-			require.DeepEqual(t, update, updates[i], "Expected to find the update in the store")
-		}
-	})
-
-	t.Run("multiple updates from both db and cache - overlap", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l1 := util.NewTestLightClient(t, version.Altair)
-		update1, err := NewLightClientUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
-		require.NoError(t, err)
-
-		l2 := util.NewTestLightClient(t, version.Altair, util.WithIncreasedAttestedSlot(1))
-		update2, err := NewLightClientUpdateFromBeaconState(l2.Ctx, l2.State, l2.Block, l2.AttestedState, l2.AttestedBlock, l2.FinalizedBlock)
-		require.NoError(t, err)
-
-		require.DeepNotEqual(t, update1, update2)
-
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 1, update1))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 2, update1))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 3, update1))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 4, update1))
-
-		cacheItemP3 := &cacheItem{
-			period:     3,
-			bestUpdate: update2,
-		}
-		s.cache.items[[32]byte{3}] = cacheItemP3
-
-		cacheItemP4 := &cacheItem{
-			period:     4,
-			bestUpdate: update2,
-			parent:     cacheItemP3,
-		}
-		s.cache.items[[32]byte{4}] = cacheItemP4
-
-		cacheItemP5 := &cacheItem{
-			period:     5,
-			bestUpdate: update2,
-			parent:     cacheItemP4,
-		}
-		s.cache.items[[32]byte{5}] = cacheItemP5
-
-		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
-
-		updates, err := s.LightClientUpdates(ctx, 1, 5, headBlock)
-		require.NoError(t, err)
-		require.Equal(t, 5, len(updates))
-		// first two updates should be update1
-		for i := 0; i < 2; i++ {
-			require.DeepEqual(t, update1, updates[i], "Expected to find the update in the store")
-		}
-		// next three updates should be update2 - as cache overrides db
-		for i := 2; i < 5; i++ {
-			require.DeepEqual(t, update2, updates[i], "Expected to find the update in the store")
-		}
-	})
-
-	t.Run("first continuous range", func(t *testing.T) {
-		d := testDB.SetupDB(t)
-		ctx := context.Background()
-
-		_, _ = saveInitialFinalizedCheckpointData(t, ctx, d)
-
-		s := NewLightClientStore(&p2pTesting.FakeP2P{}, new(event.Feed), d)
-		require.NotNil(t, s)
-
-		l1 := util.NewTestLightClient(t, version.Altair)
-		update, err := NewLightClientUpdateFromBeaconState(l1.Ctx, l1.State, l1.Block, l1.AttestedState, l1.AttestedBlock, l1.FinalizedBlock)
-		require.NoError(t, err)
-
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 1, update))
-		require.NoError(t, d.SaveLightClientUpdate(ctx, 2, update))
-
-		cacheItemP4 := &cacheItem{
-			period:     4,
-			bestUpdate: update,
-		}
-		s.cache.items[[32]byte{4}] = cacheItemP4
-
-		cacheItemP5 := &cacheItem{
-			period:     5,
-			bestUpdate: update,
-			parent:     cacheItemP4,
-		}
-		s.cache.items[[32]byte{5}] = cacheItemP5
-
-		_, headBlock := saveStateAndBlockWithParentRoot(t, ctx, d, [32]byte{5})
-
-		updates, err := s.LightClientUpdates(ctx, 1, 5, headBlock)
-		require.NoError(t, err)
-		require.Equal(t, 2, len(updates))
-		require.DeepEqual(t, update, updates[0], "Expected to find the update in the store")
-		require.DeepEqual(t, update, updates[1], "Expected to find the update in the store")
-	})
-
-}
-
-func saveStateAndBlockWithParentRoot(t *testing.T, ctx context.Context, d db.Database, parentRoot [32]byte) ([32]byte, interfaces.SignedBeaconBlock) {
-	blk := util.NewBeaconBlock()
-	blk.Block.ParentRoot = parentRoot[:]
-
-	blkRoot, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-
-	util.SaveBlock(t, ctx, d, blk)
-
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, d.SaveState(ctx, st, blkRoot))
-
-	signedFinalizedBlock, err := blocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-
-	return blkRoot, signedFinalizedBlock
-}

beacon-chain/node/BUILD.bazel

@@ -23,6 +23,7 @@ go_library(
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
+        "//beacon-chain/core/light-client:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
@@ -31,7 +32,6 @@ go_library(
         "//beacon-chain/execution:go_default_library",
         "//beacon-chain/forkchoice:go_default_library",
         "//beacon-chain/forkchoice/doubly-linked-tree:go_default_library",
-        "//beacon-chain/light-client:go_default_library",
         "//beacon-chain/monitor:go_default_library",
         "//beacon-chain/node/registration:go_default_library",
         "//beacon-chain/operations/attestations:go_default_library",

beacon-chain/node/node.go

@@ -25,6 +25,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/builder"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
+	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/kv"
@@ -33,7 +34,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice"
 	doublylinkedtree "github.com/OffchainLabs/prysm/v6/beacon-chain/forkchoice/doubly-linked-tree"
-	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/light-client"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/monitor"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/node/registration"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
@@ -253,6 +253,10 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	// their initialization.
 	beacon.finalizedStateAtStartUp = nil
 
+	if features.Get().EnableLightClient {
+		beacon.lcStore = lightclient.NewLightClientStore(beacon.db, beacon.fetchP2P(), beacon.StateFeed())
+	}
+
 	return beacon, nil
 }
 
@@ -345,11 +349,6 @@ func registerServices(cliCtx *cli.Context, beacon *BeaconNode, synchronizer *sta
 		return errors.Wrap(err, "could not register P2P service")
 	}
 
-	if features.Get().EnableLightClient {
-		log.Debugln("Registering Light Client Store")
-		beacon.registerLightClientStore()
-	}
-
 	log.Debugln("Registering Backfill Service")
 	if err := beacon.RegisterBackfillService(cliCtx, bfs); err != nil {
 		return errors.Wrap(err, "could not register Back Fill service")
@@ -622,55 +621,35 @@ func (b *BeaconNode) startStateGen(ctx context.Context, bfs coverage.AvailableBl
 	return nil
 }
 
-func parseIPNetStrings(ipWhitelist []string) ([]*net.IPNet, error) {
-	ipNets := make([]*net.IPNet, 0, len(ipWhitelist))
-	for _, cidr := range ipWhitelist {
-		_, ipNet, err := net.ParseCIDR(cidr)
-		if err != nil {
-			log.WithError(err).WithField("cidr", cidr).Error("Invalid CIDR in IP colocation whitelist")
-			return nil, err
-		}
-		ipNets = append(ipNets, ipNet)
-		log.WithField("cidr", cidr).Info("Added IP to colocation whitelist")
-	}
-	return ipNets, nil
-}
-
 func (b *BeaconNode) registerP2P(cliCtx *cli.Context) error {
 	bootstrapNodeAddrs, dataDir, err := registration.P2PPreregistration(cliCtx)
 	if err != nil {
 		return errors.Wrapf(err, "could not register p2p service")
 	}
 
-	colocationWhitelist, err := parseIPNetStrings(slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.P2PColocationWhitelist.Name)))
-	if err != nil {
-		return fmt.Errorf("failed to register p2p service: %w", err)
-	}
-
 	svc, err := p2p.NewService(b.ctx, &p2p.Config{
-		NoDiscovery:           cliCtx.Bool(cmd.NoDiscovery.Name),
-		StaticPeers:           slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.StaticPeers.Name)),
-		Discv5BootStrapAddrs:  p2p.ParseBootStrapAddrs(bootstrapNodeAddrs),
-		RelayNodeAddr:         cliCtx.String(cmd.RelayNode.Name),
-		DataDir:               dataDir,
-		DiscoveryDir:          filepath.Join(dataDir, "discovery"),
-		LocalIP:               cliCtx.String(cmd.P2PIP.Name),
-		HostAddress:           cliCtx.String(cmd.P2PHost.Name),
-		HostDNS:               cliCtx.String(cmd.P2PHostDNS.Name),
-		PrivateKey:            cliCtx.String(cmd.P2PPrivKey.Name),
-		StaticPeerID:          cliCtx.Bool(cmd.P2PStaticID.Name),
-		QUICPort:              cliCtx.Uint(cmd.P2PQUICPort.Name),
-		TCPPort:               cliCtx.Uint(cmd.P2PTCPPort.Name),
-		UDPPort:               cliCtx.Uint(cmd.P2PUDPPort.Name),
-		MaxPeers:              cliCtx.Uint(cmd.P2PMaxPeers.Name),
-		QueueSize:             cliCtx.Uint(cmd.PubsubQueueSize.Name),
-		AllowListCIDR:         cliCtx.String(cmd.P2PAllowList.Name),
-		DenyListCIDR:          slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.P2PDenyList.Name)),
-		IPColocationWhitelist: colocationWhitelist,
-		EnableUPnP:            cliCtx.Bool(cmd.EnableUPnPFlag.Name),
-		StateNotifier:         b,
-		DB:                    b.db,
-		ClockWaiter:           b.clockWaiter,
+		NoDiscovery:          cliCtx.Bool(cmd.NoDiscovery.Name),
+		StaticPeers:          slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.StaticPeers.Name)),
+		Discv5BootStrapAddrs: p2p.ParseBootStrapAddrs(bootstrapNodeAddrs),
+		RelayNodeAddr:        cliCtx.String(cmd.RelayNode.Name),
+		DataDir:              dataDir,
+		DiscoveryDir:         filepath.Join(dataDir, "discovery"),
+		LocalIP:              cliCtx.String(cmd.P2PIP.Name),
+		HostAddress:          cliCtx.String(cmd.P2PHost.Name),
+		HostDNS:              cliCtx.String(cmd.P2PHostDNS.Name),
+		PrivateKey:           cliCtx.String(cmd.P2PPrivKey.Name),
+		StaticPeerID:         cliCtx.Bool(cmd.P2PStaticID.Name),
+		QUICPort:             cliCtx.Uint(cmd.P2PQUICPort.Name),
+		TCPPort:              cliCtx.Uint(cmd.P2PTCPPort.Name),
+		UDPPort:              cliCtx.Uint(cmd.P2PUDPPort.Name),
+		MaxPeers:             cliCtx.Uint(cmd.P2PMaxPeers.Name),
+		QueueSize:            cliCtx.Uint(cmd.PubsubQueueSize.Name),
+		AllowListCIDR:        cliCtx.String(cmd.P2PAllowList.Name),
+		DenyListCIDR:         slice.SplitCommaSeparated(cliCtx.StringSlice(cmd.P2PDenyList.Name)),
+		EnableUPnP:           cliCtx.Bool(cmd.EnableUPnPFlag.Name),
+		StateNotifier:        b,
+		DB:                   b.db,
+		ClockWaiter:          b.clockWaiter,
 	})
 	if err != nil {
 		return err
@@ -1140,11 +1119,6 @@ func (b *BeaconNode) RegisterBackfillService(cliCtx *cli.Context, bfs *backfill.
 	return b.services.RegisterService(bf)
 }
 
-func (b *BeaconNode) registerLightClientStore() {
-	lcs := lightclient.NewLightClientStore(b.fetchP2P(), b.StateFeed(), b.db)
-	b.lcStore = lcs
-}
-
 func hasNetworkFlag(cliCtx *cli.Context) bool {
 	for _, flag := range features.NetworkFlags {
 		for _, name := range flag.Names() {