Add Capella-Bellatrix bid compatibility to proposer version check

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,6 +1,6 @@
 name: 🐞 Bug report
 description: Report a bug or problem with running Prysm
-type: "Bug"
+labels: ["Bug"]
 body:
   - type: markdown
     attributes:

.github/workflows/check-specrefs.yml

@@ -1,43 +0,0 @@
-name: Check Spec References
-on: [push, pull_request]
-
-jobs:
-  check-specrefs:
-    runs-on: ubuntu-latest
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-
-    - name: Check version consistency
-      run: |
-        WORKSPACE_VERSION=$(grep 'consensus_spec_version = ' WORKSPACE | sed 's/.*"\(.*\)"/\1/')
-        ETHSPECIFY_VERSION=$(grep '^version:' specrefs/.ethspecify.yml | sed 's/version: //')
-        if [ "$WORKSPACE_VERSION" != "$ETHSPECIFY_VERSION" ]; then
-          echo "Version mismatch between WORKSPACE and ethspecify"
-          echo "  WORKSPACE: $WORKSPACE_VERSION"
-          echo "  specrefs/.ethspecify.yml: $ETHSPECIFY_VERSION"
-          exit 1
-        else
-          echo "Versions match: $WORKSPACE_VERSION"
-        fi
-
-    - name: Install ethspecify
-      run: python3 -mpip install ethspecify
-
-    - name: Update spec references
-      run: ethspecify process --path=specrefs
-
-    - name: Check for differences
-      run: |
-        if ! git diff --exit-code specrefs >/dev/null; then
-          echo "Spec references are out-of-date!"
-          echo ""
-          git --no-pager diff specrefs
-          exit 1
-        else
-          echo "Spec references are up-to-date!"
-        fi
-
-    - name: Check spec references
-      run: ethspecify check --path=specrefs

CHANGELOG.md

@@ -2993,7 +2993,7 @@ There are two known issues with this release:
 
 ### Added
 
-- Web3Signer support. See the [documentation](https://prysm.offchainlabs.com/docs/manage-wallet/web3signer/) for more
+- Web3Signer support. See the [documentation](https://docs.prylabs.network/docs/next/wallet/web3signer) for more
   details.
 - Bellatrix support. See [kiln testnet instructions](https://hackmd.io/OqIoTiQvS9KOIataIFksBQ?view)
 - Weak subjectivity sync / checkpoint sync. This is an experimental feature and may have unintended side effects for

DEPENDENCIES.md

@@ -2,7 +2,7 @@
 
 Prysm is go project with many complicated dependencies, including some c++ based libraries. There
 are two parts to Prysm's dependency management. Go modules and bazel managed dependencies. Be sure 
-to read [Why Bazel?](https://prysm.offchainlabs.com/docs/install-prysm/install-with-bazel/#why-bazel) to fully
+to read [Why Bazel?](https://github.com/OffchainLabs/documentation/issues/138) to fully
 understand the reasoning behind an additional layer of build tooling via Bazel rather than a pure
 "go build" project.
 

WORKSPACE

@@ -253,16 +253,16 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.6.0-alpha.6"
+consensus_spec_version = "v1.6.0-alpha.1"
 
 load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
 consensus_spec_tests(
     name = "consensus_spec_tests",
     flavors = {
-        "general": "sha256-7wkWuahuCO37uVYnxq8Badvi+jY907pBj68ixL8XDOI=",
-        "minimal": "sha256-Qy/f27N0LffS/ej7VhIubwDejD6LMK0VdenKkqtZVt4=",
-        "mainnet": "sha256-3H7mu5yE+FGz2Wr/nc8Nd9aEu93YoEpsYtn0zBSoeDE=",
+        "general": "sha256-o4t9p3R+fQHF4KOykGmwlG3zDw5wUdVWprkzId8aIsk=",
+        "minimal": "sha256-sU7ToI8t3MR8x0vVjC8ERmAHZDWpEmnAC9FWIpHi5x4=",
+        "mainnet": "sha256-YKS4wngg0LgI9Upp4MYJ77aG+8+e/G4YeqEIlp06LZw=",
     },
     version = consensus_spec_version,
 )
@@ -278,7 +278,7 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-uvz3XfMTGfy3/BtQQoEp5XQOgrWgcH/5Zo/gR0iiP+k=",
+    integrity = "sha256-Nv4TEuEJPQIM4E6T9J0FOITsmappmXZjGtlhe1HEXnU=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )

api/client/beacon/BUILD.bazel

@@ -16,6 +16,7 @@ go_library(
         "//api/server/structs:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",

api/client/beacon/client.go

@@ -9,6 +9,7 @@ import (
 	"net/url"
 	"path"
 	"regexp"
+	"sort"
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v6/api/client"
@@ -16,6 +17,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
@@ -135,6 +137,24 @@ func (c *Client) GetFork(ctx context.Context, stateId StateOrBlockId) (*ethpb.Fo
 	return fr.ToConsensus()
 }
 
+// GetForkSchedule retrieve all forks, past present and future, of which this node is aware.
+func (c *Client) GetForkSchedule(ctx context.Context) (forks.OrderedSchedule, error) {
+	body, err := c.Get(ctx, getForkSchedulePath)
+	if err != nil {
+		return nil, errors.Wrap(err, "error requesting fork schedule")
+	}
+	fsr := &forkScheduleResponse{}
+	err = json.Unmarshal(body, fsr)
+	if err != nil {
+		return nil, err
+	}
+	ofs, err := fsr.OrderedForkSchedule()
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf("problem unmarshaling %s response", getForkSchedulePath))
+	}
+	return ofs, nil
+}
+
 // GetConfigSpec retrieve the current configs of the network used by the beacon node.
 func (c *Client) GetConfigSpec(ctx context.Context) (*structs.GetSpecResponse, error) {
 	body, err := c.Get(ctx, getConfigSpecPath)
@@ -314,3 +334,31 @@ func (c *Client) GetBLStoExecutionChanges(ctx context.Context) (*structs.BLSToEx
 	}
 	return poolResponse, nil
 }
+
+type forkScheduleResponse struct {
+	Data []structs.Fork
+}
+
+func (fsr *forkScheduleResponse) OrderedForkSchedule() (forks.OrderedSchedule, error) {
+	ofs := make(forks.OrderedSchedule, 0)
+	for _, d := range fsr.Data {
+		epoch, err := strconv.ParseUint(d.Epoch, 10, 64)
+		if err != nil {
+			return nil, errors.Wrapf(err, "error parsing epoch %s", d.Epoch)
+		}
+		vSlice, err := hexutil.Decode(d.CurrentVersion)
+		if err != nil {
+			return nil, err
+		}
+		if len(vSlice) != 4 {
+			return nil, fmt.Errorf("got %d byte version, expected 4 bytes. version hex=%s", len(vSlice), d.CurrentVersion)
+		}
+		version := bytesutil.ToBytes4(vSlice)
+		ofs = append(ofs, forks.ForkScheduleEntry{
+			Version: version,
+			Epoch:   primitives.Epoch(epoch),
+		})
+	}
+	sort.Sort(ofs)
+	return ofs, nil
+}

api/client/builder/client.go

@@ -102,7 +102,6 @@ type BuilderClient interface {
 	GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubkey [48]byte) (SignedBid, error)
 	RegisterValidator(ctx context.Context, svr []*ethpb.SignedValidatorRegistrationV1) error
 	SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, v1.BlobsBundler, error)
-	SubmitBlindedBlockPostFulu(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) error
 	Status(ctx context.Context) error
 }
 
@@ -153,8 +152,7 @@ func (c *Client) NodeURL() string {
 type reqOption func(*http.Request)
 
 // do is a generic, opinionated request function to reduce boilerplate amongst the methods in this package api/client/builder.
-// It validates that the HTTP response status matches the expectedStatus parameter.
-func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, expectedStatus int, opts ...reqOption) (res []byte, header http.Header, err error) {
+func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) (res []byte, header http.Header, err error) {
 	ctx, span := trace.StartSpan(ctx, "builder.client.do")
 	defer func() {
 		tracing.AnnotateError(span, err)
@@ -189,8 +187,8 @@ func (c *Client) do(ctx context.Context, method string, path string, body io.Rea
 			log.WithError(closeErr).Error("Failed to close response body")
 		}
 	}()
-	if r.StatusCode != expectedStatus {
-		err = unexpectedStatusErr(r, expectedStatus)
+	if r.StatusCode != http.StatusOK {
+		err = non200Err(r)
 		return
 	}
 	res, err = io.ReadAll(io.LimitReader(r.Body, client.MaxBodySize))
@@ -238,7 +236,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 			r.Header.Set("Accept", api.JsonMediaType)
 		}
 	}
-	data, header, err := c.do(ctx, http.MethodGet, path, nil, http.StatusOK, getOpts)
+	data, header, err := c.do(ctx, http.MethodGet, path, nil, getOpts)
 	if err != nil {
 		return nil, errors.Wrap(err, "error getting header from builder server")
 	}
@@ -411,7 +409,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 		}
 	}
 
-	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), http.StatusOK, postOpts); err != nil {
+	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), postOpts); err != nil {
 		return errors.Wrap(err, "do")
 	}
 	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
@@ -473,7 +471,7 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 
 	// post the blinded block - the execution payload response should contain the unblinded payload, along with the
 	// blobs bundle if it is post deneb.
-	data, header, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), http.StatusOK, postOpts)
+	data, header, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), postOpts)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
 	}
@@ -503,24 +501,6 @@ func (c *Client) SubmitBlindedBlock(ctx context.Context, sb interfaces.ReadOnlyS
 	return ed, blobs, nil
 }
 
-// SubmitBlindedBlockPostFulu calls the builder API endpoint post-Fulu where relays only return status codes.
-// This method is used after the Fulu fork when MEV-boost relays no longer return execution payloads.
-func (c *Client) SubmitBlindedBlockPostFulu(ctx context.Context, sb interfaces.ReadOnlySignedBeaconBlock) error {
-	body, postOpts, err := c.buildBlindedBlockRequest(sb)
-	if err != nil {
-		return err
-	}
-
-	// Post the blinded block - the response should only contain a status code (no payload)
-	_, _, 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")
-	}
-
-	// Success is indicated by no error (status 202)
-	return nil
-}
-
 func (c *Client) checkBlockVersion(respBytes []byte, header http.Header) (int, error) {
 	var versionHeader string
 	if c.sszEnabled {
@@ -677,11 +657,11 @@ func (c *Client) Status(ctx context.Context) error {
 	getOpts := func(r *http.Request) {
 		r.Header.Set("Accept", api.JsonMediaType)
 	}
-	_, _, err := c.do(ctx, http.MethodGet, getStatus, nil, http.StatusOK, getOpts)
+	_, _, err := c.do(ctx, http.MethodGet, getStatus, nil, getOpts)
 	return err
 }
 
-func unexpectedStatusErr(response *http.Response, expected int) error {
+func non200Err(response *http.Response) error {
 	bodyBytes, err := io.ReadAll(io.LimitReader(response.Body, client.MaxErrBodySize))
 	var errMessage ErrorMessage
 	var body string
@@ -690,7 +670,7 @@ func unexpectedStatusErr(response *http.Response, expected int) error {
 	} else {
 		body = "response body:\n" + string(bodyBytes)
 	}
-	msg := fmt.Sprintf("expected=%d, got=%d, url=%s, body=%s", expected, response.StatusCode, response.Request.URL, body)
+	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
 	switch response.StatusCode {
 	case http.StatusUnsupportedMediaType:
 		log.WithError(ErrUnsupportedMediaType).Debug(msg)

api/client/builder/client_test.go

@@ -1555,89 +1555,6 @@ func testSignedBlindedBeaconBlockElectra(t *testing.T) *eth.SignedBlindedBeaconB
 	}
 }
 
-func TestSubmitBlindedBlockPostFulu(t *testing.T) {
-	ctx := t.Context()
-
-	t.Run("success", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				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"))
-				// Post-Fulu: only return status code, no payload
-				return &http.Response{
-					StatusCode: http.StatusAccepted,
-					Body:       io.NopCloser(bytes.NewBufferString("")),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:      hc,
-			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		err = c.SubmitBlindedBlockPostFulu(ctx, sbbb)
-		require.NoError(t, err)
-	})
-
-	t.Run("success_ssz", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				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"))
-				// Post-Fulu: only return status code, no payload
-				return &http.Response{
-					StatusCode: http.StatusAccepted,
-					Body:       io.NopCloser(bytes.NewBufferString("")),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:         hc,
-			baseURL:    &url.URL{Host: "localhost:3500", Scheme: "http"},
-			sszEnabled: true,
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		err = c.SubmitBlindedBlockPostFulu(ctx, sbbb)
-		require.NoError(t, err)
-	})
-
-	t.Run("error_response", func(t *testing.T) {
-		hc := &http.Client{
-			Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-				require.Equal(t, postBlindedBeaconBlockPath, r.URL.Path)
-				require.Equal(t, "bellatrix", r.Header.Get("Eth-Consensus-Version"))
-				message := ErrorMessage{
-					Code:    400,
-					Message: "Bad Request",
-				}
-				resp, err := json.Marshal(message)
-				require.NoError(t, err)
-				return &http.Response{
-					StatusCode: http.StatusBadRequest,
-					Body:       io.NopCloser(bytes.NewBuffer(resp)),
-					Request:    r.Clone(ctx),
-				}, nil
-			}),
-		}
-		c := &Client{
-			hc:      hc,
-			baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-		}
-		sbbb, err := blocks.NewSignedBeaconBlock(testSignedBlindedBeaconBlockBellatrix(t))
-		require.NoError(t, err)
-		err = c.SubmitBlindedBlockPostFulu(ctx, sbbb)
-		require.ErrorIs(t, err, ErrNotOK)
-	})
-}
-
 func TestRequestLogger(t *testing.T) {
 	wo := WithObserver(&requestLogger{})
 	c, err := NewClient("localhost:3500", wo)
@@ -1810,7 +1727,7 @@ func TestSubmitBlindedBlock_BlobsBundlerInterface(t *testing.T) {
 	t.Run("Interface signature verification", func(t *testing.T) {
 		// This test verifies that the SubmitBlindedBlock method signature
 		// has been updated to return BlobsBundler interface
-
+		
 		client := &Client{}
 
 		// Verify the method exists with the correct signature

api/client/builder/testing/mock.go

@@ -45,11 +45,6 @@ func (MockClient) SubmitBlindedBlock(_ context.Context, _ interfaces.ReadOnlySig
 	return nil, nil, nil
 }
 
-// SubmitBlindedBlockPostFulu --
-func (MockClient) SubmitBlindedBlockPostFulu(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock) error {
-	return nil
-}
-
 // Status --
 func (MockClient) Status(_ context.Context) error {
 	return nil

api/client/builder/types_test.go

@@ -1699,7 +1699,7 @@ func TestExecutionPayloadHeaderCapellaRoundtrip(t *testing.T) {
 	require.DeepEqual(t, string(expected[0:len(expected)-1]), string(m))
 }
 
-func TestErrorMessage_unexpectedStatusErr(t *testing.T) {
+func TestErrorMessage_non200Err(t *testing.T) {
 	mockRequest := &http.Request{
 		URL: &url.URL{Path: "example.com"},
 	}
@@ -1779,7 +1779,7 @@ func TestErrorMessage_unexpectedStatusErr(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := unexpectedStatusErr(tt.args, http.StatusOK)
+			err := non200Err(tt.args)
 			if err != nil && tt.wantMessage != "" {
 				require.ErrorContains(t, tt.wantMessage, err)
 			}

api/server/httprest/options.go

@@ -1,9 +1,10 @@
 package httprest
 
 import (
-	"net/http"
 	"time"
 
+	"net/http"
+
 	"github.com/OffchainLabs/prysm/v6/api/server/middleware"
 )
 

beacon-chain/blockchain/BUILD.bazel

@@ -182,7 +182,6 @@ go_test(
         "//container/trie:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/blockchain/chain_info_test.go

@@ -14,7 +14,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -625,7 +624,6 @@ func Test_hashForGenesisRoot(t *testing.T) {
 	ctx := t.Context()
 	c := setupBeaconChain(t, beaconDB)
 	st, _ := util.DeterministicGenesisStateElectra(t, 10)
-	genesis.StoreDuringTest(t, genesis.GenesisData{State: st})
 	require.NoError(t, c.cfg.BeaconDB.SaveGenesisData(ctx, st))
 	root, err := beaconDB.GenesisBlockRoot(ctx)
 	require.NoError(t, err)

beacon-chain/blockchain/execution_engine_test.go

@@ -19,7 +19,6 @@ 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/genesis"
 	v1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -310,7 +309,6 @@ func Test_NotifyForkchoiceUpdate_NIlLVH(t *testing.T) {
 		block: wba,
 	}
 
-	genesis.StoreStateDuringTest(t, st)
 	require.NoError(t, beaconDB.SaveState(ctx, st, bra))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, bra))
 	a := &fcuConfig{
@@ -405,7 +403,6 @@ func Test_NotifyForkchoiceUpdateRecursive_DoublyLinkedTree(t *testing.T) {
 	require.NoError(t, err)
 
 	bState, _ := util.DeterministicGenesisState(t, 10)
-	genesis.StoreStateDuringTest(t, bState)
 	require.NoError(t, beaconDB.SaveState(ctx, bState, bra))
 	require.NoError(t, fcs.InsertNode(ctx, state, blkRoot))
 	state, blkRoot, err = prepareForkchoiceState(ctx, 2, brb, bra, [32]byte{'B'}, ojc, ofc)

beacon-chain/blockchain/kzg/kzg.go

@@ -102,6 +102,7 @@ func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, cellIndices []uint64, c
 	for i := range cells {
 		ckzgCells[i] = ckzg4844.Cell(cells[i])
 	}
+
 	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, cellIndices, ckzgCells, proofsBytes)
 }
 

beacon-chain/blockchain/kzg/validation.go

@@ -1,14 +1,32 @@
 package kzg
 
 import (
-	"fmt"
-
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	ckzg4844 "github.com/ethereum/c-kzg-4844/v2/bindings/go"
-	"github.com/pkg/errors"
 )
 
+// Verify performs single or batch verification of commitments depending on the number of given BlobSidecars.
+func Verify(sidecars ...blocks.ROBlob) error {
+	if len(sidecars) == 0 {
+		return nil
+	}
+	if len(sidecars) == 1 {
+		return kzgContext.VerifyBlobKZGProof(
+			bytesToBlob(sidecars[0].Blob),
+			bytesToCommitment(sidecars[0].KzgCommitment),
+			bytesToKZGProof(sidecars[0].KzgProof))
+	}
+	blobs := make([]GoKZG.Blob, len(sidecars))
+	cmts := make([]GoKZG.KZGCommitment, len(sidecars))
+	proofs := make([]GoKZG.KZGProof, len(sidecars))
+	for i, sidecar := range sidecars {
+		blobs[i] = *bytesToBlob(sidecar.Blob)
+		cmts[i] = bytesToCommitment(sidecar.KzgCommitment)
+		proofs[i] = bytesToKZGProof(sidecar.KzgProof)
+	}
+	return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs)
+}
+
 func bytesToBlob(blob []byte) *GoKZG.Blob {
 	var ret GoKZG.Blob
 	copy(ret[:], blob)
@@ -24,144 +42,3 @@ func bytesToKZGProof(proof []byte) (ret GoKZG.KZGProof) {
 	copy(ret[:], proof)
 	return
 }
-
-// Verify performs single or batch verification of commitments depending on the number of given BlobSidecars.
-func Verify(blobSidecars ...blocks.ROBlob) error {
-	if len(blobSidecars) == 0 {
-		return nil
-	}
-	if len(blobSidecars) == 1 {
-		return kzgContext.VerifyBlobKZGProof(
-			bytesToBlob(blobSidecars[0].Blob),
-			bytesToCommitment(blobSidecars[0].KzgCommitment),
-			bytesToKZGProof(blobSidecars[0].KzgProof))
-	}
-	blobs := make([]GoKZG.Blob, len(blobSidecars))
-	cmts := make([]GoKZG.KZGCommitment, len(blobSidecars))
-	proofs := make([]GoKZG.KZGProof, len(blobSidecars))
-	for i, sidecar := range blobSidecars {
-		blobs[i] = *bytesToBlob(sidecar.Blob)
-		cmts[i] = bytesToCommitment(sidecar.KzgCommitment)
-		proofs[i] = bytesToKZGProof(sidecar.KzgProof)
-	}
-	return kzgContext.VerifyBlobKZGProofBatch(blobs, cmts, proofs)
-}
-
-// VerifyBlobKZGProofBatch verifies KZG proofs for multiple blobs using batch verification.
-// This is more efficient than verifying each blob individually when len(blobs) > 1.
-// For single blob verification, it uses the optimized single verification path.
-func VerifyBlobKZGProofBatch(blobs [][]byte, commitments [][]byte, proofs [][]byte) error {
-	if len(blobs) != len(commitments) || len(blobs) != len(proofs) {
-		return errors.Errorf("number of blobs (%d), commitments (%d), and proofs (%d) must match", len(blobs), len(commitments), len(proofs))
-	}
-
-	if len(blobs) == 0 {
-		return nil
-	}
-
-	// Optimize for single blob case - use single verification to avoid batch overhead
-	if len(blobs) == 1 {
-		return kzgContext.VerifyBlobKZGProof(
-			bytesToBlob(blobs[0]),
-			bytesToCommitment(commitments[0]),
-			bytesToKZGProof(proofs[0]))
-	}
-
-	// Use batch verification for multiple blobs
-	ckzgBlobs := make([]ckzg4844.Blob, len(blobs))
-	ckzgCommitments := make([]ckzg4844.Bytes48, len(commitments))
-	ckzgProofs := make([]ckzg4844.Bytes48, len(proofs))
-
-	for i := range blobs {
-		if len(blobs[i]) != len(ckzg4844.Blob{}) {
-			return fmt.Errorf("blobs len (%d) differs from expected (%d)", len(blobs[i]), len(ckzg4844.Blob{}))
-		}
-		if len(commitments[i]) != len(ckzg4844.Bytes48{}) {
-			return fmt.Errorf("commitments len (%d) differs from expected (%d)", len(commitments[i]), len(ckzg4844.Blob{}))
-		}
-		if len(proofs[i]) != len(ckzg4844.Bytes48{}) {
-			return fmt.Errorf("proofs len (%d) differs from expected (%d)", len(proofs[i]), len(ckzg4844.Blob{}))
-		}
-		ckzgBlobs[i] = ckzg4844.Blob(blobs[i])
-		ckzgCommitments[i] = ckzg4844.Bytes48(commitments[i])
-		ckzgProofs[i] = ckzg4844.Bytes48(proofs[i])
-	}
-
-	valid, err := ckzg4844.VerifyBlobKZGProofBatch(ckzgBlobs, ckzgCommitments, ckzgProofs)
-	if err != nil {
-		return errors.Wrap(err, "batch verification")
-	}
-	if !valid {
-		return errors.New("batch KZG proof verification failed")
-	}
-
-	return nil
-}
-
-// VerifyCellKZGProofBatchFromBlobData verifies cell KZG proofs in batch format directly from blob data.
-// This is more efficient than reconstructing data column sidecars when you have the raw blob data and cell proofs.
-// For PeerDAS/Fulu, the execution client provides cell proofs in flattened format via BlobsBundleV2.
-// For single blob verification, it optimizes by computing cells once and verifying efficiently.
-func VerifyCellKZGProofBatchFromBlobData(blobs [][]byte, commitments [][]byte, cellProofs [][]byte, numberOfColumns uint64) error {
-	blobCount := uint64(len(blobs))
-	expectedCellProofs := blobCount * numberOfColumns
-
-	if uint64(len(cellProofs)) != expectedCellProofs {
-		return errors.Errorf("expected %d cell proofs, got %d", expectedCellProofs, len(cellProofs))
-	}
-
-	if len(commitments) != len(blobs) {
-		return errors.Errorf("number of commitments (%d) must match number of blobs (%d)", len(commitments), len(blobs))
-	}
-
-	if blobCount == 0 {
-		return nil
-	}
-
-	// Handle multiple blobs - compute cells for all blobs
-	allCells := make([]Cell, 0, expectedCellProofs)
-	allCommitments := make([]Bytes48, 0, expectedCellProofs)
-	allIndices := make([]uint64, 0, expectedCellProofs)
-	allProofs := make([]Bytes48, 0, expectedCellProofs)
-
-	for blobIndex := range blobs {
-		if len(blobs[blobIndex]) != len(Blob{}) {
-			return fmt.Errorf("blobs len (%d) differs from expected (%d)", len(blobs[blobIndex]), len(Blob{}))
-		}
-		// Convert blob to kzg.Blob type
-		blob := Blob(blobs[blobIndex])
-
-		// Compute cells for this blob
-		cells, err := ComputeCells(&blob)
-		if err != nil {
-			return errors.Wrapf(err, "failed to compute cells for blob %d", blobIndex)
-		}
-
-		// Add cells and corresponding data for each column
-		for columnIndex := range numberOfColumns {
-			cellProofIndex := uint64(blobIndex)*numberOfColumns + columnIndex
-			if len(commitments[blobIndex]) != len(Bytes48{}) {
-				return fmt.Errorf("commitments len (%d) differs from expected (%d)", len(commitments[blobIndex]), len(Bytes48{}))
-			}
-			if len(cellProofs[cellProofIndex]) != len(Bytes48{}) {
-				return fmt.Errorf("proofs len (%d) differs from expected (%d)", len(cellProofs[cellProofIndex]), len(Bytes48{}))
-			}
-			allCells = append(allCells, cells[columnIndex])
-			allCommitments = append(allCommitments, Bytes48(commitments[blobIndex]))
-			allIndices = append(allIndices, columnIndex)
-
-			allProofs = append(allProofs, Bytes48(cellProofs[cellProofIndex]))
-		}
-	}
-
-	// Batch verify all cells
-	valid, err := VerifyCellKZGProofBatch(allCommitments, allIndices, allCells, allProofs)
-	if err != nil {
-		return errors.Wrap(err, "cell batch verification")
-	}
-	if !valid {
-		return errors.New("cell KZG proof batch verification failed")
-	}
-
-	return nil
-}

beacon-chain/blockchain/kzg/validation_test.go

@@ -22,8 +22,8 @@ func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZG
 }
 
 func TestVerify(t *testing.T) {
-	blobSidecars := make([]blocks.ROBlob, 0)
-	require.NoError(t, Verify(blobSidecars...))
+	sidecars := make([]blocks.ROBlob, 0)
+	require.NoError(t, Verify(sidecars...))
 }
 
 func TestBytesToAny(t *testing.T) {
@@ -37,7 +37,6 @@ func TestBytesToAny(t *testing.T) {
 }
 
 func TestGenerateCommitmentAndProof(t *testing.T) {
-	require.NoError(t, Start())
 	blob := random.GetRandBlob(123)
 	commitment, proof, err := GenerateCommitmentAndProof(blob)
 	require.NoError(t, err)
@@ -46,432 +45,3 @@ func TestGenerateCommitmentAndProof(t *testing.T) {
 	require.Equal(t, expectedCommitment, commitment)
 	require.Equal(t, expectedProof, proof)
 }
-
-func TestVerifyBlobKZGProofBatch(t *testing.T) {
-	// Initialize KZG for testing
-	require.NoError(t, Start())
-
-	t.Run("valid single blob batch", func(t *testing.T) {
-		blob := random.GetRandBlob(123)
-		commitment, proof, err := GenerateCommitmentAndProof(blob)
-		require.NoError(t, err)
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{commitment[:]}
-		proofs := [][]byte{proof[:]}
-
-		err = VerifyBlobKZGProofBatch(blobs, commitments, proofs)
-		require.NoError(t, err)
-	})
-
-	t.Run("valid multiple blob batch", func(t *testing.T) {
-		blobCount := 3
-		blobs := make([][]byte, blobCount)
-		commitments := make([][]byte, blobCount)
-		proofs := make([][]byte, blobCount)
-
-		for i := 0; i < blobCount; i++ {
-			blob := random.GetRandBlob(int64(i))
-			commitment, proof, err := GenerateCommitmentAndProof(blob)
-			require.NoError(t, err)
-
-			blobs[i] = blob[:]
-			commitments[i] = commitment[:]
-			proofs[i] = proof[:]
-		}
-
-		err := VerifyBlobKZGProofBatch(blobs, commitments, proofs)
-		require.NoError(t, err)
-	})
-
-	t.Run("empty inputs should pass", func(t *testing.T) {
-		err := VerifyBlobKZGProofBatch([][]byte{}, [][]byte{}, [][]byte{})
-		require.NoError(t, err)
-	})
-
-	t.Run("mismatched input lengths", func(t *testing.T) {
-		blob := random.GetRandBlob(123)
-		commitment, proof, err := GenerateCommitmentAndProof(blob)
-		require.NoError(t, err)
-
-		// Test different mismatch scenarios
-		err = VerifyBlobKZGProofBatch(
-			[][]byte{blob[:]},
-			[][]byte{},
-			[][]byte{proof[:]},
-		)
-		require.ErrorContains(t, "number of blobs (1), commitments (0), and proofs (1) must match", err)
-
-		err = VerifyBlobKZGProofBatch(
-			[][]byte{blob[:], blob[:]},
-			[][]byte{commitment[:]},
-			[][]byte{proof[:], proof[:]},
-		)
-		require.ErrorContains(t, "number of blobs (2), commitments (1), and proofs (2) must match", err)
-	})
-
-	t.Run("invalid commitment should fail", func(t *testing.T) {
-		blob := random.GetRandBlob(123)
-		_, proof, err := GenerateCommitmentAndProof(blob)
-		require.NoError(t, err)
-
-		// Use a different blob's commitment (mismatch)
-		differentBlob := random.GetRandBlob(456)
-		wrongCommitment, _, err := GenerateCommitmentAndProof(differentBlob)
-		require.NoError(t, err)
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{wrongCommitment[:]}
-		proofs := [][]byte{proof[:]}
-
-		err = VerifyBlobKZGProofBatch(blobs, commitments, proofs)
-		// Single blob optimization uses different error message
-		require.ErrorContains(t, "can't verify opening proof", err)
-	})
-
-	t.Run("invalid proof should fail", func(t *testing.T) {
-		blob := random.GetRandBlob(123)
-		commitment, _, err := GenerateCommitmentAndProof(blob)
-		require.NoError(t, err)
-
-		// Use wrong proof
-		invalidProof := make([]byte, 48) // All zeros
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{commitment[:]}
-		proofs := [][]byte{invalidProof}
-
-		err = VerifyBlobKZGProofBatch(blobs, commitments, proofs)
-		require.ErrorContains(t, "short buffer", err)
-	})
-
-	t.Run("mixed valid and invalid proofs should fail", func(t *testing.T) {
-		// First blob - valid
-		blob1 := random.GetRandBlob(123)
-		commitment1, proof1, err := GenerateCommitmentAndProof(blob1)
-		require.NoError(t, err)
-
-		// Second blob - invalid proof
-		blob2 := random.GetRandBlob(456)
-		commitment2, _, err := GenerateCommitmentAndProof(blob2)
-		require.NoError(t, err)
-		invalidProof := make([]byte, 48) // All zeros
-
-		blobs := [][]byte{blob1[:], blob2[:]}
-		commitments := [][]byte{commitment1[:], commitment2[:]}
-		proofs := [][]byte{proof1[:], invalidProof}
-
-		err = VerifyBlobKZGProofBatch(blobs, commitments, proofs)
-		require.ErrorContains(t, "batch verification", err)
-	})
-
-	t.Run("batch KZG proof verification failed", func(t *testing.T) {
-		// Create multiple blobs with mismatched commitments and proofs to trigger batch verification failure
-		blob1 := random.GetRandBlob(123)
-		blob2 := random.GetRandBlob(456)
-
-		// Generate valid proof for blob1
-		commitment1, proof1, err := GenerateCommitmentAndProof(blob1)
-		require.NoError(t, err)
-
-		// Generate valid proof for blob2 but use wrong commitment (from blob1)
-		_, proof2, err := GenerateCommitmentAndProof(blob2)
-		require.NoError(t, err)
-
-		// Use blob2 data with blob1's commitment and blob2's proof - this should cause batch verification to fail
-		blobs := [][]byte{blob1[:], blob2[:]}
-		commitments := [][]byte{commitment1[:], commitment1[:]} // Wrong commitment for blob2
-		proofs := [][]byte{proof1[:], proof2[:]}
-
-		err = VerifyBlobKZGProofBatch(blobs, commitments, proofs)
-		require.ErrorContains(t, "batch KZG proof verification failed", err)
-	})
-}
-
-func TestVerifyCellKZGProofBatchFromBlobData(t *testing.T) {
-	// Initialize KZG for testing
-	require.NoError(t, Start())
-
-	t.Run("valid single blob cell verification", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		// Generate blob and commitment
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		// Compute cells and proofs
-		cellsAndProofs, err := ComputeCellsAndKZGProofs(&blob)
-		require.NoError(t, err)
-
-		// Create flattened cell proofs (like execution client format)
-		cellProofs := make([][]byte, numberOfColumns)
-		for i := range numberOfColumns {
-			cellProofs[i] = cellsAndProofs.Proofs[i][:]
-		}
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{commitment[:]}
-
-		err = VerifyCellKZGProofBatchFromBlobData(blobs, commitments, cellProofs, numberOfColumns)
-		require.NoError(t, err)
-	})
-
-	t.Run("valid multiple blob cell verification", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-		blobCount := 2
-
-		blobs := make([][]byte, blobCount)
-		commitments := make([][]byte, blobCount)
-		var allCellProofs [][]byte
-
-		for i := range blobCount {
-			// Generate blob and commitment
-			randBlob := random.GetRandBlob(int64(i))
-			var blob Blob
-			copy(blob[:], randBlob[:])
-			commitment, err := BlobToKZGCommitment(&blob)
-			require.NoError(t, err)
-
-			// Compute cells and proofs
-			cellsAndProofs, err := ComputeCellsAndKZGProofs(&blob)
-			require.NoError(t, err)
-
-			blobs[i] = blob[:]
-			commitments[i] = commitment[:]
-
-			// Add cell proofs for this blob
-			for j := range numberOfColumns {
-				allCellProofs = append(allCellProofs, cellsAndProofs.Proofs[j][:])
-			}
-		}
-
-		err := VerifyCellKZGProofBatchFromBlobData(blobs, commitments, allCellProofs, numberOfColumns)
-		require.NoError(t, err)
-	})
-
-	t.Run("empty inputs should pass", func(t *testing.T) {
-		err := VerifyCellKZGProofBatchFromBlobData([][]byte{}, [][]byte{}, [][]byte{}, 128)
-		require.NoError(t, err)
-	})
-
-	t.Run("mismatched blob and commitment count", func(t *testing.T) {
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		err := VerifyCellKZGProofBatchFromBlobData(
-			[][]byte{blob[:]},
-			[][]byte{}, // Empty commitments
-			[][]byte{},
-			128,
-		)
-		require.ErrorContains(t, "expected 128 cell proofs", err)
-	})
-
-	t.Run("wrong cell proof count", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{commitment[:]}
-
-		// Wrong number of cell proofs - should be 128 for 1 blob, but provide 10
-		wrongCellProofs := make([][]byte, 10)
-
-		err = VerifyCellKZGProofBatchFromBlobData(blobs, commitments, wrongCellProofs, numberOfColumns)
-		require.ErrorContains(t, "expected 128 cell proofs, got 10", err)
-	})
-
-	t.Run("invalid cell proofs should fail", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{commitment[:]}
-
-		// Create invalid cell proofs (all zeros)
-		invalidCellProofs := make([][]byte, numberOfColumns)
-		for i := range numberOfColumns {
-			invalidCellProofs[i] = make([]byte, 48) // All zeros
-		}
-
-		err = VerifyCellKZGProofBatchFromBlobData(blobs, commitments, invalidCellProofs, numberOfColumns)
-		require.ErrorContains(t, "cell batch verification", err)
-	})
-
-	t.Run("mismatched commitment should fail", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		// Generate blob and correct cell proofs
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-		cellsAndProofs, err := ComputeCellsAndKZGProofs(&blob)
-		require.NoError(t, err)
-
-		// Generate wrong commitment from different blob
-		randBlob2 := random.GetRandBlob(456)
-		var differentBlob Blob
-		copy(differentBlob[:], randBlob2[:])
-		wrongCommitment, err := BlobToKZGCommitment(&differentBlob)
-		require.NoError(t, err)
-
-		cellProofs := make([][]byte, numberOfColumns)
-		for i := range numberOfColumns {
-			cellProofs[i] = cellsAndProofs.Proofs[i][:]
-		}
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{wrongCommitment[:]}
-
-		err = VerifyCellKZGProofBatchFromBlobData(blobs, commitments, cellProofs, numberOfColumns)
-		require.ErrorContains(t, "cell KZG proof batch verification failed", err)
-	})
-
-	t.Run("invalid blob data that should cause ComputeCells to fail", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		// Create invalid blob (not properly formatted)
-		invalidBlobData := make([]byte, 10) // Too short
-		commitment := make([]byte, 48)      // Dummy commitment
-		cellProofs := make([][]byte, numberOfColumns)
-		for i := range numberOfColumns {
-			cellProofs[i] = make([]byte, 48)
-		}
-
-		blobs := [][]byte{invalidBlobData}
-		commitments := [][]byte{commitment}
-
-		err := VerifyCellKZGProofBatchFromBlobData(blobs, commitments, cellProofs, numberOfColumns)
-		require.NotNil(t, err)
-		require.ErrorContains(t, "blobs len (10) differs from expected (131072)", err)
-	})
-
-	t.Run("invalid commitment size should fail", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-
-		// Create invalid commitment (wrong size)
-		invalidCommitment := make([]byte, 32) // Should be 48 bytes
-		cellProofs := make([][]byte, numberOfColumns)
-		for i := range numberOfColumns {
-			cellProofs[i] = make([]byte, 48)
-		}
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{invalidCommitment}
-
-		err := VerifyCellKZGProofBatchFromBlobData(blobs, commitments, cellProofs, numberOfColumns)
-		require.ErrorContains(t, "commitments len (32) differs from expected (48)", err)
-	})
-
-	t.Run("invalid cell proof size should fail", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-
-		randBlob := random.GetRandBlob(123)
-		var blob Blob
-		copy(blob[:], randBlob[:])
-		commitment, err := BlobToKZGCommitment(&blob)
-		require.NoError(t, err)
-
-		// Create invalid cell proofs (wrong size)
-		invalidCellProofs := make([][]byte, numberOfColumns)
-		for i := range numberOfColumns {
-			if i == 0 {
-				invalidCellProofs[i] = make([]byte, 32) // Wrong size - should be 48
-			} else {
-				invalidCellProofs[i] = make([]byte, 48)
-			}
-		}
-
-		blobs := [][]byte{blob[:]}
-		commitments := [][]byte{commitment[:]}
-
-		err = VerifyCellKZGProofBatchFromBlobData(blobs, commitments, invalidCellProofs, numberOfColumns)
-		require.ErrorContains(t, "proofs len (32) differs from expected (48)", err)
-	})
-
-	t.Run("multiple blobs with mixed invalid commitments", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-		blobCount := 2
-
-		blobs := make([][]byte, blobCount)
-		commitments := make([][]byte, blobCount)
-		var allCellProofs [][]byte
-
-		// First blob - valid
-		randBlob1 := random.GetRandBlob(123)
-		var blob1 Blob
-		copy(blob1[:], randBlob1[:])
-		commitment1, err := BlobToKZGCommitment(&blob1)
-		require.NoError(t, err)
-		blobs[0] = blob1[:]
-		commitments[0] = commitment1[:]
-
-		// Second blob - use invalid commitment size
-		randBlob2 := random.GetRandBlob(456)
-		var blob2 Blob
-		copy(blob2[:], randBlob2[:])
-		blobs[1] = blob2[:]
-		commitments[1] = make([]byte, 32) // Wrong size
-
-		// Add cell proofs for both blobs
-		for i := 0; i < blobCount; i++ {
-			for j := uint64(0); j < numberOfColumns; j++ {
-				allCellProofs = append(allCellProofs, make([]byte, 48))
-			}
-		}
-
-		err = VerifyCellKZGProofBatchFromBlobData(blobs, commitments, allCellProofs, numberOfColumns)
-		require.ErrorContains(t, "commitments len (32) differs from expected (48)", err)
-	})
-
-	t.Run("multiple blobs with mixed invalid cell proof sizes", func(t *testing.T) {
-		numberOfColumns := uint64(128)
-		blobCount := 2
-
-		blobs := make([][]byte, blobCount)
-		commitments := make([][]byte, blobCount)
-		var allCellProofs [][]byte
-
-		for i := 0; i < blobCount; i++ {
-			randBlob := random.GetRandBlob(int64(i))
-			var blob Blob
-			copy(blob[:], randBlob[:])
-			commitment, err := BlobToKZGCommitment(&blob)
-			require.NoError(t, err)
-
-			blobs[i] = blob[:]
-			commitments[i] = commitment[:]
-
-			// Add cell proofs - make some invalid in the second blob
-			for j := uint64(0); j < numberOfColumns; j++ {
-				if i == 1 && j == 64 {
-					// Invalid proof size in middle of second blob's proofs
-					allCellProofs = append(allCellProofs, make([]byte, 20))
-				} else {
-					allCellProofs = append(allCellProofs, make([]byte, 48))
-				}
-			}
-		}
-
-		err := VerifyCellKZGProofBatchFromBlobData(blobs, commitments, allCellProofs, numberOfColumns)
-		require.ErrorContains(t, "proofs len (20) differs from expected (48)", err)
-	})
-}

beacon-chain/blockchain/process_block.go

@@ -159,7 +159,7 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	}
 
 	// Fill in missing blocks
-	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0], preState.FinalizedCheckpoint(), preState.CurrentJustifiedCheckpoint()); err != nil {
+	if err := s.fillInForkChoiceMissingBlocks(ctx, blks[0], preState.CurrentJustifiedCheckpoint(), preState.FinalizedCheckpoint()); err != nil {
 		return errors.Wrap(err, "could not fill in missing blocks to forkchoice")
 	}
 
@@ -240,10 +240,9 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			}
 		}
 
-		if err := s.areSidecarsAvailable(ctx, avs, b); err != nil {
-			return errors.Wrapf(err, "could not validate sidecar availability for block %#x at slot %d", b.Root(), b.Block().Slot())
+		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), b); err != nil {
+			return errors.Wrapf(err, "could not validate sidecar availability at slot %d", b.Block().Slot())
 		}
-
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
@@ -309,30 +308,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 	return s.saveHeadNoDB(ctx, lastB, lastBR, preState, !isValidPayload)
 }
 
-func (s *Service) areSidecarsAvailable(ctx context.Context, avs das.AvailabilityStore, roBlock consensusblocks.ROBlock) error {
-	blockVersion := roBlock.Version()
-	block := roBlock.Block()
-	slot := block.Slot()
-
-	if blockVersion >= version.Fulu {
-		if err := s.areDataColumnsAvailable(ctx, roBlock.Root(), block); err != nil {
-			return errors.Wrapf(err, "are data columns available for block %#x with slot %d", roBlock.Root(), slot)
-		}
-
-		return nil
-	}
-
-	if blockVersion >= version.Deneb {
-		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), roBlock); err != nil {
-			return errors.Wrapf(err, "could not validate sidecar availability at slot %d", slot)
-		}
-
-		return nil
-	}
-
-	return nil
-}
-
 func (s *Service) updateEpochBoundaryCaches(ctx context.Context, st state.BeaconState) error {
 	e := coreTime.CurrentEpoch(st)
 	if err := helpers.UpdateCommitteeCache(ctx, st, e); err != nil {
@@ -609,7 +584,7 @@ func (s *Service) runLateBlockTasks() {
 // It returns a map where each key represents a missing BlobSidecar index.
 // An empty map means we have all indices; a non-empty map can be used to compare incoming
 // BlobSidecars against the set of known missing sidecars.
-func missingBlobIndices(store *filesystem.BlobStorage, root [fieldparams.RootLength]byte, expected [][]byte, slot primitives.Slot) (map[uint64]bool, error) {
+func missingBlobIndices(bs *filesystem.BlobStorage, root [fieldparams.RootLength]byte, expected [][]byte, slot primitives.Slot) (map[uint64]bool, error) {
 	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	if len(expected) == 0 {
 		return nil, nil
@@ -617,7 +592,7 @@ func missingBlobIndices(store *filesystem.BlobStorage, root [fieldparams.RootLen
 	if len(expected) > maxBlobsPerBlock {
 		return nil, errMaxBlobsExceeded
 	}
-	indices := store.Summary(root)
+	indices := bs.Summary(root)
 	missing := make(map[uint64]bool, len(expected))
 	for i := range expected {
 		if len(expected[i]) > 0 && !indices.HasIndex(uint64(i)) {
@@ -632,7 +607,7 @@ func missingBlobIndices(store *filesystem.BlobStorage, root [fieldparams.RootLen
 // It returns a map where each key represents a missing DataColumnSidecar index.
 // An empty map means we have all indices; a non-empty map can be used to compare incoming
 // DataColumns against the set of known missing sidecars.
-func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldparams.RootLength]byte, expected map[uint64]bool) (map[uint64]bool, error) {
+func missingDataColumnIndices(bs *filesystem.DataColumnStorage, root [fieldparams.RootLength]byte, expected map[uint64]bool) (map[uint64]bool, error) {
 	if len(expected) == 0 {
 		return nil, nil
 	}
@@ -644,7 +619,7 @@ func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldpa
 	}
 
 	// Get a summary of the data columns stored in the database.
-	summary := store.Summary(root)
+	summary := bs.Summary(root)
 
 	// Check all expected data columns against the summary.
 	missing := make(map[uint64]bool)
@@ -742,7 +717,7 @@ func (s *Service) areDataColumnsAvailable(
 	summary := s.dataColumnStorage.Summary(root)
 	storedDataColumnsCount := summary.Count()
 
-	minimumColumnCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+	minimumColumnCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 
 	// As soon as we have enough data column sidecars, we can reconstruct the missing ones.
 	// We don't need to wait for the rest of the data columns to declare the block as available.
@@ -845,7 +820,7 @@ func (s *Service) areDataColumnsAvailable(
 				missingIndices = uint64MapToSortedSlice(missingMap)
 			}
 
-			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing: %v", block.Slot(), root, missingIndices)
+			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndices)
 		}
 	}
 }

beacon-chain/blockchain/process_block_helpers.go

@@ -30,10 +30,6 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
-// ErrInvalidCheckpointArgs may be returned when the finalized checkpoint has an epoch greater than the justified checkpoint epoch.
-// If you are seeing this error, make sure you haven't mixed up the order of the arguments in the method you are calling.
-var ErrInvalidCheckpointArgs = errors.New("finalized checkpoint cannot be greater than justified checkpoint")
-
 // CurrentSlot returns the current slot based on time.
 func (s *Service) CurrentSlot() primitives.Slot {
 	return slots.CurrentSlot(s.genesisTime)
@@ -458,9 +454,6 @@ func (s *Service) ancestorByDB(ctx context.Context, r [32]byte, slot primitives.
 // This is useful for block tree visualizer and additional vote accounting.
 func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, signed interfaces.ReadOnlySignedBeaconBlock,
 	fCheckpoint, jCheckpoint *ethpb.Checkpoint) error {
-	if fCheckpoint.Epoch > jCheckpoint.Epoch {
-		return ErrInvalidCheckpointArgs
-	}
 	pendingNodes := make([]*forkchoicetypes.BlockAndCheckpoints, 0)
 
 	// Fork choice only matters from last finalized slot.

beacon-chain/blockchain/process_block_test.go

@@ -35,7 +35,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	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"
@@ -375,81 +374,6 @@ func TestFillForkChoiceMissingBlocks_FinalizedSibling(t *testing.T) {
 	require.Equal(t, ErrNotDescendantOfFinalized.Error(), err.Error())
 }
 
-func TestFillForkChoiceMissingBlocks_ErrorCases(t *testing.T) {
-	tests := []struct {
-		name           string
-		finalizedEpoch primitives.Epoch
-		justifiedEpoch primitives.Epoch
-		expectedError  error
-	}{
-		{
-			name:           "finalized epoch greater than justified epoch",
-			finalizedEpoch: 5,
-			justifiedEpoch: 3,
-			expectedError:  ErrInvalidCheckpointArgs,
-		},
-		{
-			name:           "valid case - finalized equal to justified",
-			finalizedEpoch: 3,
-			justifiedEpoch: 3,
-			expectedError:  nil,
-		},
-		{
-			name:           "valid case - finalized less than justified",
-			finalizedEpoch: 2,
-			justifiedEpoch: 3,
-			expectedError:  nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			service, tr := minimalTestService(t)
-			ctx, beaconDB := tr.ctx, tr.db
-
-			st, _ := util.DeterministicGenesisState(t, 64)
-			require.NoError(t, service.saveGenesisData(ctx, st))
-
-			// Create a simple block for testing
-			blk := util.NewBeaconBlock()
-			blk.Block.Slot = 10
-			blk.Block.ParentRoot = service.originBlockRoot[:]
-			wsb, err := consensusblocks.NewSignedBeaconBlock(blk)
-			require.NoError(t, err)
-			util.SaveBlock(t, ctx, beaconDB, blk)
-
-			// Create checkpoints with test case epochs
-			finalizedCheckpoint := &ethpb.Checkpoint{
-				Epoch: tt.finalizedEpoch,
-				Root:  service.originBlockRoot[:],
-			}
-			justifiedCheckpoint := &ethpb.Checkpoint{
-				Epoch: tt.justifiedEpoch,
-				Root:  service.originBlockRoot[:],
-			}
-
-			// Set up forkchoice store to avoid other errors
-			fcp := &ethpb.Checkpoint{Epoch: 0, Root: service.originBlockRoot[:]}
-			state, blkRoot, err := prepareForkchoiceState(ctx, 0, service.originBlockRoot, service.originBlockRoot, [32]byte{}, fcp, fcp)
-			require.NoError(t, err)
-			require.NoError(t, service.cfg.ForkChoiceStore.InsertNode(ctx, state, blkRoot))
-
-			err = service.fillInForkChoiceMissingBlocks(
-				t.Context(), wsb, finalizedCheckpoint, justifiedCheckpoint)
-
-			if tt.expectedError != nil {
-				require.ErrorIs(t, err, tt.expectedError)
-			} else {
-				// For valid cases, we might get other errors (like block not being descendant of finalized)
-				// but we shouldn't get the checkpoint validation error
-				if err != nil && errors.Is(err, tt.expectedError) {
-					t.Errorf("Unexpected checkpoint validation error: %v", err)
-				}
-			}
-		})
-	}
-}
-
 // blockTree1 constructs the following tree:
 //
 //	/- B1
@@ -2056,15 +1980,14 @@ func TestNoViableHead_Reboot(t *testing.T) {
 	genesisState, keys := util.DeterministicGenesisState(t, 64)
 	stateRoot, err := genesisState.HashTreeRoot(ctx)
 	require.NoError(t, err, "Could not hash genesis state")
-	gb := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(gb)
+	genesis := blocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
 	require.NoError(t, err)
-	genesisRoot, err := gb.Block.HashTreeRoot()
+	genesisRoot, err := genesis.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not get signing root")
 	require.NoError(t, service.cfg.BeaconDB.SaveBlock(ctx, wsb), "Could not save genesis block")
 	require.NoError(t, service.saveGenesisData(ctx, genesisState))
 
-	genesis.StoreStateDuringTest(t, genesisState)
 	require.NoError(t, service.cfg.BeaconDB.SaveState(ctx, genesisState, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveHeadBlockRoot(ctx, genesisRoot), "Could not save genesis state")
 	require.NoError(t, service.cfg.BeaconDB.SaveGenesisBlockRoot(ctx, genesisRoot), "Could not save genesis state")
@@ -2207,13 +2130,13 @@ func TestNoViableHead_Reboot(t *testing.T) {
 
 	// Forkchoice has the genesisRoot loaded at startup
 	require.Equal(t, genesisRoot, service.ensureRootNotZeros(service.cfg.ForkChoiceStore.CachedHeadRoot()))
-	// Service's store has the justified checkpoint root as headRoot (verified below through justified checkpoint comparison)
+	// Service's store has the finalized state as headRoot
 	headRoot, err := service.HeadRoot(ctx)
 	require.NoError(t, err)
-	require.NotEqual(t, bytesutil.ToBytes32(params.BeaconConfig().ZeroHash[:]), bytesutil.ToBytes32(headRoot)) // Ensure head is not zero
+	require.Equal(t, genesisRoot, bytesutil.ToBytes32(headRoot))
 	optimistic, err := service.IsOptimistic(ctx)
 	require.NoError(t, err)
-	require.Equal(t, true, optimistic) // Head is now optimistic when starting from justified checkpoint
+	require.Equal(t, false, optimistic)
 
 	// Check that the node's justified checkpoint does not agree with the
 	// last valid state's justified checkpoint
@@ -2964,7 +2887,7 @@ func TestIsDataAvailable(t *testing.T) {
 	})
 
 	t.Run("Fulu - more than half of the columns in custody", func(t *testing.T) {
-		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct)
 		for i := range minimumColumnsCountToReconstruct {
 			indices = append(indices, i)
@@ -3049,7 +2972,7 @@ func TestIsDataAvailable(t *testing.T) {
 
 		startWaiting := make(chan bool)
 
-		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct-missingColumns)
 
 		for i := range minimumColumnsCountToReconstruct - missingColumns {

beacon-chain/blockchain/receive_data_column.go

@@ -17,7 +17,7 @@ func (s *Service) ReceiveDataColumns(dataColumnSidecars []blocks.VerifiedRODataC
 // ReceiveDataColumn receives a single data column.
 func (s *Service) ReceiveDataColumn(dataColumnSidecar blocks.VerifiedRODataColumn) error {
 	if err := s.dataColumnStorage.Save([]blocks.VerifiedRODataColumn{dataColumnSidecar}); err != nil {
-		return errors.Wrap(err, "save data column sidecar")
+		return errors.Wrap(err, "save data column sidecars")
 	}
 
 	return nil

beacon-chain/blockchain/service.go

@@ -12,6 +12,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
+	"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"
 	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
@@ -206,9 +207,17 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 
 // Start a blockchain service's main event loop.
 func (s *Service) Start() {
+	saved := s.cfg.FinalizedStateAtStartUp
 	defer s.removeStartupState()
-	if err := s.StartFromSavedState(s.cfg.FinalizedStateAtStartUp); err != nil {
-		log.Fatal(err)
+
+	if saved != nil && !saved.IsNil() {
+		if err := s.StartFromSavedState(saved); err != nil {
+			log.Fatal(err)
+		}
+	} else {
+		if err := s.startFromExecutionChain(); err != nil {
+			log.Fatal(err)
+		}
 	}
 	s.spawnProcessAttestationsRoutine()
 	go s.runLateBlockTasks()
@@ -257,9 +266,6 @@ func (s *Service) Status() error {
 
 // StartFromSavedState initializes the blockchain using a previously saved finalized checkpoint.
 func (s *Service) StartFromSavedState(saved state.BeaconState) error {
-	if state.IsNil(saved) {
-		return errors.New("Last finalized state at startup is nil")
-	}
 	log.Info("Blockchain data already exists in DB, initializing...")
 	s.genesisTime = saved.GenesisTime()
 	s.cfg.AttService.SetGenesisTime(saved.GenesisTime())
@@ -365,6 +371,62 @@ func (s *Service) initializeHead(ctx context.Context, st state.BeaconState) erro
 	return nil
 }
 
+func (s *Service) startFromExecutionChain() error {
+	log.Info("Waiting to reach the validator deposit threshold to start the beacon chain...")
+	if s.cfg.ChainStartFetcher == nil {
+		return errors.New("not configured execution chain")
+	}
+	go func() {
+		stateChannel := make(chan *feed.Event, 1)
+		stateSub := s.cfg.StateNotifier.StateFeed().Subscribe(stateChannel)
+		defer stateSub.Unsubscribe()
+		for {
+			select {
+			case e := <-stateChannel:
+				if e.Type == statefeed.ChainStarted {
+					data, ok := e.Data.(*statefeed.ChainStartedData)
+					if !ok {
+						log.Error("Event data is not type *statefeed.ChainStartedData")
+						return
+					}
+					log.WithField("startTime", data.StartTime).Debug("Received chain start event")
+					s.onExecutionChainStart(s.ctx, data.StartTime)
+					return
+				}
+			case <-s.ctx.Done():
+				log.Debug("Context closed, exiting goroutine")
+				return
+			case err := <-stateSub.Err():
+				log.WithError(err).Error("Subscription to state forRoot failed")
+				return
+			}
+		}
+	}()
+
+	return nil
+}
+
+// onExecutionChainStart initializes a series of deposits from the ChainStart deposits in the eth1
+// deposit contract, initializes the beacon chain's state, and kicks off the beacon chain.
+func (s *Service) onExecutionChainStart(ctx context.Context, genesisTime time.Time) {
+	preGenesisState := s.cfg.ChainStartFetcher.PreGenesisState()
+	initializedState, err := s.initializeBeaconChain(ctx, genesisTime, preGenesisState, s.cfg.ChainStartFetcher.ChainStartEth1Data())
+	if err != nil {
+		log.WithError(err).Fatal("Could not initialize beacon chain")
+	}
+	// We start a counter to genesis, if needed.
+	gRoot, err := initializedState.HashTreeRoot(s.ctx)
+	if err != nil {
+		log.WithError(err).Fatal("Could not hash tree root genesis state")
+	}
+	go slots.CountdownToGenesis(ctx, genesisTime, uint64(initializedState.NumValidators()), gRoot)
+
+	vr := bytesutil.ToBytes32(initializedState.GenesisValidatorsRoot())
+	if err := s.clockSetter.SetClock(startup.NewClock(genesisTime, vr)); err != nil {
+		log.WithError(err).Fatal("Failed to initialize blockchain service from execution start event")
+	}
+}
+
 // initializes the state and genesis block of the beacon chain to persistent storage
 // based on a genesis timestamp value obtained from the ChainStart event emitted
 // by the ETH1.0 Deposit Contract and the POWChain service of the node.

beacon-chain/blockchain/service_test.go

@@ -31,7 +31,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/container/trie"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -52,7 +51,6 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		srv.Stop()
 	})
 	bState, _ := util.DeterministicGenesisState(t, 10)
-	genesis.StoreStateDuringTest(t, bState)
 	pbState, err := state_native.ProtobufBeaconStatePhase0(bState.ToProtoUnsafe())
 	require.NoError(t, err)
 	mockTrie, err := trie.NewTrie(0)
@@ -73,22 +71,20 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		DepositContainers: []*ethpb.DepositContainer{},
 	})
 	require.NoError(t, err)
-
-	depositCache, err := depositsnapshot.New()
-	require.NoError(t, err)
-
 	web3Service, err = execution.NewService(
 		ctx,
 		execution.WithDatabase(beaconDB),
 		execution.WithHttpEndpoint(endpoint),
 		execution.WithDepositContractAddress(common.Address{}),
-		execution.WithDepositCache(depositCache),
 	)
 	require.NoError(t, err, "Unable to set up web3 service")
 
 	attService, err := attestations.NewService(ctx, &attestations.Config{Pool: attestations.NewPool()})
 	require.NoError(t, err)
 
+	depositCache, err := depositsnapshot.New()
+	require.NoError(t, err)
+
 	fc := doublylinkedtree.New()
 	stateGen := stategen.New(beaconDB, fc)
 	// Safe a state in stategen to purposes of testing a service stop / shutdown.
@@ -400,6 +396,24 @@ func TestServiceStop_SaveCachedBlocks(t *testing.T) {
 	require.Equal(t, true, s.cfg.BeaconDB.HasBlock(s.ctx, r))
 }
 
+func TestProcessChainStartTime_ReceivedFeed(t *testing.T) {
+	ctx := t.Context()
+	beaconDB := testDB.SetupDB(t)
+	service := setupBeaconChain(t, beaconDB)
+	mgs := &MockClockSetter{}
+	service.clockSetter = mgs
+	gt := time.Now()
+	service.onExecutionChainStart(t.Context(), gt)
+	gs, err := beaconDB.GenesisState(ctx)
+	require.NoError(t, err)
+	require.NotEqual(t, nil, gs)
+	require.Equal(t, 32, len(gs.GenesisValidatorsRoot()))
+	var zero [32]byte
+	require.DeepNotEqual(t, gs.GenesisValidatorsRoot(), zero[:])
+	require.Equal(t, gt, mgs.G.GenesisTime())
+	require.Equal(t, bytesutil.ToBytes32(gs.GenesisValidatorsRoot()), mgs.G.GenesisValidatorsRoot())
+}
+
 func BenchmarkHasBlockDB(b *testing.B) {
 	ctx := b.Context()
 	s := testServiceWithDB(b)

beacon-chain/blockchain/setup_forchoice.go

@@ -20,7 +20,7 @@ func (s *Service) setupForkchoice(st state.BeaconState) error {
 		return errors.Wrap(err, "could not set up forkchoice checkpoints")
 	}
 	if err := s.setupForkchoiceTree(st); err != nil {
-		return errors.Wrap(err, "could not set up forkchoice tree")
+		return errors.Wrap(err, "could not set up forkchoice root")
 	}
 	if err := s.initializeHead(s.ctx, st); err != nil {
 		return errors.Wrap(err, "could not initialize head from db")
@@ -30,24 +30,24 @@ func (s *Service) setupForkchoice(st state.BeaconState) error {
 
 func (s *Service) startupHeadRoot() [32]byte {
 	headStr := features.Get().ForceHead
-	jp := s.CurrentJustifiedCheckpt()
-	jRoot := s.ensureRootNotZeros([32]byte(jp.Root))
+	cp := s.FinalizedCheckpt()
+	fRoot := s.ensureRootNotZeros([32]byte(cp.Root))
 	if headStr == "" {
-		return jRoot
+		return fRoot
 	}
 	if headStr == "head" {
 		root, err := s.cfg.BeaconDB.HeadBlockRoot()
 		if err != nil {
-			log.WithError(err).Error("Could not get head block root, starting with justified block as head")
-			return jRoot
+			log.WithError(err).Error("Could not get head block root, starting with finalized block as head")
+			return fRoot
 		}
 		log.Infof("Using Head root of %#x", root)
 		return root
 	}
 	root, err := bytesutil.DecodeHexWithLength(headStr, 32)
 	if err != nil {
-		log.WithError(err).Error("Could not parse head root, starting with justified block as head")
-		return jRoot
+		log.WithError(err).Error("Could not parse head root, starting with finalized block as head")
+		return fRoot
 	}
 	return [32]byte(root)
 }

beacon-chain/blockchain/setup_forkchoice_test.go

@@ -32,7 +32,7 @@ func Test_startupHeadRoot(t *testing.T) {
 		})
 		defer resetCfg()
 		require.Equal(t, service.startupHeadRoot(), gr)
-		require.LogsContain(t, hook, "Could not get head block root, starting with justified block as head")
+		require.LogsContain(t, hook, "Could not get head block root, starting with finalized block as head")
 	})
 
 	st, _ := util.DeterministicGenesisState(t, 64)

beacon-chain/blockchain/setup_test.go

@@ -89,7 +89,7 @@ func (mb *mockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumnSidecar(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
+func (mb *mockBroadcaster) BroadcastDataColumn(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
 	mb.broadcastCalled = true
 	return nil
 }

beacon-chain/builder/service.go

@@ -25,7 +25,6 @@ var ErrNoBuilder = errors.New("builder endpoint not configured")
 // BlockBuilder defines the interface for interacting with the block builder
 type BlockBuilder interface {
 	SubmitBlindedBlock(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) (interfaces.ExecutionData, v1.BlobsBundler, error)
-	SubmitBlindedBlockPostFulu(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock) error
 	GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubKey [48]byte) (builder.SignedBid, error)
 	RegisterValidator(ctx context.Context, reg []*ethpb.SignedValidatorRegistrationV1) error
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
@@ -102,22 +101,6 @@ func (s *Service) SubmitBlindedBlock(ctx context.Context, b interfaces.ReadOnlyS
 	return s.c.SubmitBlindedBlock(ctx, b)
 }
 
-// SubmitBlindedBlockPostFulu submits a blinded block to the builder relay network post-Fulu.
-// After Fulu, relays only return status codes (no payload).
-func (s *Service) SubmitBlindedBlockPostFulu(ctx context.Context, b interfaces.ReadOnlySignedBeaconBlock) error {
-	ctx, span := trace.StartSpan(ctx, "builder.SubmitBlindedBlockPostFulu")
-	defer span.End()
-	start := time.Now()
-	defer func() {
-		submitBlindedBlockLatency.Observe(float64(time.Since(start).Milliseconds()))
-	}()
-	if s.c == nil {
-		return ErrNoBuilder
-	}
-
-	return s.c.SubmitBlindedBlockPostFulu(ctx, b)
-}
-
 // GetHeader retrieves the header for a given slot and parent hash from the builder relay network.
 func (s *Service) GetHeader(ctx context.Context, slot primitives.Slot, parentHash [32]byte, pubKey [48]byte) (builder.SignedBid, error) {
 	ctx, span := trace.StartSpan(ctx, "builder.GetHeader")

beacon-chain/builder/testing/mock.go

@@ -24,22 +24,21 @@ type Config struct {
 
 // MockBuilderService to mock builder.
 type MockBuilderService struct {
-	HasConfigured                 bool
-	Payload                       *v1.ExecutionPayload
-	PayloadCapella                *v1.ExecutionPayloadCapella
-	PayloadDeneb                  *v1.ExecutionPayloadDeneb
-	BlobBundle                    *v1.BlobsBundle
-	BlobBundleV2                  *v1.BlobsBundleV2
-	ErrSubmitBlindedBlock         error
-	ErrSubmitBlindedBlockPostFulu error
-	Bid                           *ethpb.SignedBuilderBid
-	BidCapella                    *ethpb.SignedBuilderBidCapella
-	BidDeneb                      *ethpb.SignedBuilderBidDeneb
-	BidElectra                    *ethpb.SignedBuilderBidElectra
-	RegistrationCache             *cache.RegistrationCache
-	ErrGetHeader                  error
-	ErrRegisterValidator          error
-	Cfg                           *Config
+	HasConfigured         bool
+	Payload               *v1.ExecutionPayload
+	PayloadCapella        *v1.ExecutionPayloadCapella
+	PayloadDeneb          *v1.ExecutionPayloadDeneb
+	BlobBundle            *v1.BlobsBundle
+	BlobBundleV2          *v1.BlobsBundleV2
+	ErrSubmitBlindedBlock error
+	Bid                   *ethpb.SignedBuilderBid
+	BidCapella            *ethpb.SignedBuilderBidCapella
+	BidDeneb              *ethpb.SignedBuilderBidDeneb
+	BidElectra            *ethpb.SignedBuilderBidElectra
+	RegistrationCache     *cache.RegistrationCache
+	ErrGetHeader          error
+	ErrRegisterValidator  error
+	Cfg                   *Config
 }
 
 // Configured for mocking.
@@ -116,8 +115,3 @@ func (s *MockBuilderService) RegistrationByValidatorID(ctx context.Context, id p
 func (s *MockBuilderService) RegisterValidator(context.Context, []*ethpb.SignedValidatorRegistrationV1) error {
 	return s.ErrRegisterValidator
 }
-
-// SubmitBlindedBlockPostFulu for mocking.
-func (s *MockBuilderService) SubmitBlindedBlockPostFulu(_ context.Context, _ interfaces.ReadOnlySignedBeaconBlock) error {
-	return s.ErrSubmitBlindedBlockPostFulu
-}

beacon-chain/cache/sync_committee.go

@@ -67,30 +67,6 @@ func (s *SyncCommitteeCache) Clear() {
 	s.cache = cache.NewFIFO(keyFn)
 }
 
-// CurrentPeriodPositions returns current period positions of validator indices with respect with
-// sync committee. If any input validator index has no assignment, an empty list will be returned
-// for that validator. If the input root does not exist in cache, `ErrNonExistingSyncCommitteeKey` is returned.
-// Manual checking of state for index position in state is recommended when `ErrNonExistingSyncCommitteeKey` is returned.
-func (s *SyncCommitteeCache) CurrentPeriodPositions(root [32]byte, indices []primitives.ValidatorIndex) ([][]primitives.CommitteeIndex, error) {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	pos, err := s.positionsInCommittee(root, indices)
-	if err != nil {
-		return nil, err
-	}
-	result := make([][]primitives.CommitteeIndex, len(pos))
-	for i, p := range pos {
-		if p == nil {
-			result[i] = []primitives.CommitteeIndex{}
-		} else {
-			result[i] = p.currentPeriod
-		}
-	}
-
-	return result, nil
-}
-
 // CurrentPeriodIndexPosition returns current period index position of a validator index with respect with
 // sync committee. If the input validator index has no assignment, an empty list will be returned.
 // If the input root does not exist in cache, `ErrNonExistingSyncCommitteeKey` is returned.
@@ -128,7 +104,11 @@ func (s *SyncCommitteeCache) NextPeriodIndexPosition(root [32]byte, valIdx primi
 	return pos.nextPeriod, nil
 }
 
-func (s *SyncCommitteeCache) positionsInCommittee(root [32]byte, indices []primitives.ValidatorIndex) ([]*positionInCommittee, error) {
+// Helper function for `CurrentPeriodIndexPosition` and `NextPeriodIndexPosition` to return a mapping
+// of validator index to its index(s) position in the sync committee.
+func (s *SyncCommitteeCache) idxPositionInCommittee(
+	root [32]byte, valIdx primitives.ValidatorIndex,
+) (*positionInCommittee, error) {
 	obj, exists, err := s.cache.GetByKey(key(root))
 	if err != nil {
 		return nil, err
@@ -141,33 +121,13 @@ func (s *SyncCommitteeCache) positionsInCommittee(root [32]byte, indices []primi
 	if !ok {
 		return nil, errNotSyncCommitteeIndexPosition
 	}
-	result := make([]*positionInCommittee, len(indices))
-	for i, idx := range indices {
-		idxInCommittee, ok := item.vIndexToPositionMap[idx]
-		if ok {
-			SyncCommitteeCacheHit.Inc()
-			result[i] = idxInCommittee
-		} else {
-			SyncCommitteeCacheMiss.Inc()
-			result[i] = nil
-		}
-	}
-	return result, nil
-}
-
-// Helper function for `CurrentPeriodIndexPosition` and `NextPeriodIndexPosition` to return a mapping
-// of validator index to its index(s) position in the sync committee.
-func (s *SyncCommitteeCache) idxPositionInCommittee(
-	root [32]byte, valIdx primitives.ValidatorIndex,
-) (*positionInCommittee, error) {
-	positions, err := s.positionsInCommittee(root, []primitives.ValidatorIndex{valIdx})
-	if err != nil {
-		return nil, err
-	}
-	if len(positions) == 0 {
+	idxInCommittee, ok := item.vIndexToPositionMap[valIdx]
+	if !ok {
+		SyncCommitteeCacheMiss.Inc()
 		return nil, nil
 	}
-	return positions[0], nil
+	SyncCommitteeCacheHit.Inc()
+	return idxInCommittee, nil
 }
 
 // UpdatePositionsInCommittee updates caching of validators position in sync committee in respect to

beacon-chain/cache/sync_committee_disabled.go

@@ -16,11 +16,6 @@ func NewSyncCommittee() *FakeSyncCommitteeCache {
 	return &FakeSyncCommitteeCache{}
 }
 
-// CurrentPeriodPositions -- fake
-func (s *FakeSyncCommitteeCache) CurrentPeriodPositions(root [32]byte, indices []primitives.ValidatorIndex) ([][]primitives.CommitteeIndex, error) {
-	return nil, nil
-}
-
 // CurrentEpochIndexPosition -- fake.
 func (s *FakeSyncCommitteeCache) CurrentPeriodIndexPosition(root [32]byte, valIdx primitives.ValidatorIndex) ([]primitives.CommitteeIndex, error) {
 	return nil, nil

beacon-chain/core/blocks/BUILD.bazel

@@ -41,6 +41,7 @@ go_library(
         "//encoding/ssz:go_default_library",
         "//math:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",

beacon-chain/core/blocks/attester_slashing.go

@@ -5,7 +5,6 @@ import (
 	"sort"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/container/slice"
@@ -40,11 +39,11 @@ func ProcessAttesterSlashings(
 	ctx context.Context,
 	beaconState state.BeaconState,
 	slashings []ethpb.AttSlashing,
-	exitInfo *validators.ExitInfo,
+	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	var err error
 	for _, slashing := range slashings {
-		beaconState, err = ProcessAttesterSlashing(ctx, beaconState, slashing, exitInfo)
+		beaconState, err = ProcessAttesterSlashing(ctx, beaconState, slashing, slashFunc)
 		if err != nil {
 			return nil, err
 		}
@@ -57,7 +56,7 @@ func ProcessAttesterSlashing(
 	ctx context.Context,
 	beaconState state.BeaconState,
 	slashing ethpb.AttSlashing,
-	exitInfo *validators.ExitInfo,
+	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	if err := VerifyAttesterSlashing(ctx, beaconState, slashing); err != nil {
 		return nil, errors.Wrap(err, "could not verify attester slashing")
@@ -76,9 +75,10 @@ func ProcessAttesterSlashing(
 			return nil, err
 		}
 		if helpers.IsSlashableValidator(val.ActivationEpoch(), val.WithdrawableEpoch(), val.Slashed(), currentEpoch) {
-			beaconState, err = validators.SlashValidator(ctx, beaconState, primitives.ValidatorIndex(validatorIndex), exitInfo)
+			beaconState, err = slashFunc(ctx, beaconState, primitives.ValidatorIndex(validatorIndex))
 			if err != nil {
-				return nil, errors.Wrapf(err, "could not slash validator index %d", validatorIndex)
+				return nil, errors.Wrapf(err, "could not slash validator index %d",
+					validatorIndex)
 			}
 			slashedAny = true
 		}

beacon-chain/core/blocks/attester_slashing_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
@@ -45,10 +44,11 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 				Target: &ethpb.Checkpoint{Epoch: 1}},
 		})}}
 
+	var registry []*ethpb.Validator
 	currentSlot := primitives.Slot(0)
 
 	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: []*ethpb.Validator{{}},
+		Validators: registry,
 		Slot:       currentSlot,
 	})
 	require.NoError(t, err)
@@ -62,15 +62,16 @@ func TestProcessAttesterSlashings_DataNotSlashable(t *testing.T) {
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
-	_, err = blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.ExitInformation(beaconState))
+	_, err = blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.SlashValidator)
 	assert.ErrorContains(t, "attestations are not slashable", err)
 }
 
 func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T) {
+	var registry []*ethpb.Validator
 	currentSlot := primitives.Slot(0)
 
 	beaconState, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: []*ethpb.Validator{{}},
+		Validators: registry,
 		Slot:       currentSlot,
 	})
 	require.NoError(t, err)
@@ -100,7 +101,7 @@ func TestProcessAttesterSlashings_IndexedAttestationFailedToVerify(t *testing.T)
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
-	_, err = blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.ExitInformation(beaconState))
+	_, err = blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.SlashValidator)
 	assert.ErrorContains(t, "validator indices count exceeds MAX_VALIDATORS_PER_COMMITTEE", err)
 }
 
@@ -242,7 +243,7 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 			currentSlot := 2 * params.BeaconConfig().SlotsPerEpoch
 			require.NoError(t, tc.st.SetSlot(currentSlot))
 
-			newState, err := blocks.ProcessAttesterSlashings(t.Context(), tc.st, []ethpb.AttSlashing{tc.slashing}, v.ExitInformation(tc.st))
+			newState, err := blocks.ProcessAttesterSlashings(t.Context(), tc.st, []ethpb.AttSlashing{tc.slashing}, v.SlashValidator)
 			require.NoError(t, err)
 			newRegistry := newState.Validators()
 
@@ -264,83 +265,3 @@ func TestProcessAttesterSlashings_AppliesCorrectStatus(t *testing.T) {
 		})
 	}
 }
-
-func TestProcessAttesterSlashing_ExitEpochGetsUpdated(t *testing.T) {
-	st, keys := util.DeterministicGenesisStateElectra(t, 8)
-	bal, err := helpers.TotalActiveBalance(st)
-	require.NoError(t, err)
-	perEpochChurn := helpers.ActivationExitChurnLimit(primitives.Gwei(bal))
-	vals := st.Validators()
-
-	// We set the total effective balance of slashed validators
-	// higher than the churn limit for a single epoch.
-	vals[0].EffectiveBalance = uint64(perEpochChurn / 3)
-	vals[1].EffectiveBalance = uint64(perEpochChurn / 3)
-	vals[2].EffectiveBalance = uint64(perEpochChurn / 3)
-	vals[3].EffectiveBalance = uint64(perEpochChurn / 3)
-	require.NoError(t, st.SetValidators(vals))
-
-	sl1att1 := util.HydrateIndexedAttestationElectra(&ethpb.IndexedAttestationElectra{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 1},
-		},
-		AttestingIndices: []uint64{0, 1},
-	})
-	sl1att2 := util.HydrateIndexedAttestationElectra(&ethpb.IndexedAttestationElectra{
-		AttestingIndices: []uint64{0, 1},
-	})
-	slashing1 := &ethpb.AttesterSlashingElectra{
-		Attestation_1: sl1att1,
-		Attestation_2: sl1att2,
-	}
-	sl2att1 := util.HydrateIndexedAttestationElectra(&ethpb.IndexedAttestationElectra{
-		Data: &ethpb.AttestationData{
-			Source: &ethpb.Checkpoint{Epoch: 1},
-		},
-		AttestingIndices: []uint64{2, 3},
-	})
-	sl2att2 := util.HydrateIndexedAttestationElectra(&ethpb.IndexedAttestationElectra{
-		AttestingIndices: []uint64{2, 3},
-	})
-	slashing2 := &ethpb.AttesterSlashingElectra{
-		Attestation_1: sl2att1,
-		Attestation_2: sl2att2,
-	}
-
-	domain, err := signing.Domain(st.Fork(), 0, params.BeaconConfig().DomainBeaconAttester, st.GenesisValidatorsRoot())
-	require.NoError(t, err)
-
-	signingRoot, err := signing.ComputeSigningRoot(sl1att1.GetData(), domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	sig0 := keys[0].Sign(signingRoot[:])
-	sig1 := keys[1].Sign(signingRoot[:])
-	aggregateSig := bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	sl1att1.Signature = aggregateSig.Marshal()
-
-	signingRoot, err = signing.ComputeSigningRoot(sl1att2.GetData(), domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	sig0 = keys[0].Sign(signingRoot[:])
-	sig1 = keys[1].Sign(signingRoot[:])
-	aggregateSig = bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	sl1att2.Signature = aggregateSig.Marshal()
-
-	signingRoot, err = signing.ComputeSigningRoot(sl2att1.GetData(), domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	sig0 = keys[2].Sign(signingRoot[:])
-	sig1 = keys[3].Sign(signingRoot[:])
-	aggregateSig = bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	sl2att1.Signature = aggregateSig.Marshal()
-
-	signingRoot, err = signing.ComputeSigningRoot(sl2att2.GetData(), domain)
-	assert.NoError(t, err, "Could not get signing root of beacon block header")
-	sig0 = keys[2].Sign(signingRoot[:])
-	sig1 = keys[3].Sign(signingRoot[:])
-	aggregateSig = bls.AggregateSignatures([]bls.Signature{sig0, sig1})
-	sl2att2.Signature = aggregateSig.Marshal()
-
-	exitInfo := v.ExitInformation(st)
-	assert.Equal(t, primitives.Epoch(0), exitInfo.HighestExitEpoch)
-	_, err = blocks.ProcessAttesterSlashings(t.Context(), st, []ethpb.AttSlashing{slashing1, slashing2}, exitInfo)
-	require.NoError(t, err)
-	assert.Equal(t, primitives.Epoch(6), exitInfo.HighestExitEpoch)
-}

beacon-chain/core/blocks/block_operations_fuzz_test.go

@@ -191,7 +191,7 @@ func TestFuzzProcessProposerSlashings_10000(t *testing.T) {
 		fuzzer.Fuzz(p)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		r, err := ProcessProposerSlashings(ctx, s, []*ethpb.ProposerSlashing{p}, v.ExitInformation(s))
+		r, err := ProcessProposerSlashings(ctx, s, []*ethpb.ProposerSlashing{p}, v.SlashValidator)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, p)
 		}
@@ -224,7 +224,7 @@ func TestFuzzProcessAttesterSlashings_10000(t *testing.T) {
 		fuzzer.Fuzz(a)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		r, err := ProcessAttesterSlashings(ctx, s, []ethpb.AttSlashing{a}, v.ExitInformation(s))
+		r, err := ProcessAttesterSlashings(ctx, s, []ethpb.AttSlashing{a}, v.SlashValidator)
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and slashing: %v", r, err, state, a)
 		}
@@ -334,7 +334,7 @@ func TestFuzzProcessVoluntaryExits_10000(t *testing.T) {
 		fuzzer.Fuzz(e)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		r, err := ProcessVoluntaryExits(ctx, s, []*ethpb.SignedVoluntaryExit{e}, v.ExitInformation(s))
+		r, err := ProcessVoluntaryExits(ctx, s, []*ethpb.SignedVoluntaryExit{e})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and exit: %v", r, err, state, e)
 		}
@@ -351,7 +351,7 @@ func TestFuzzProcessVoluntaryExitsNoVerify_10000(t *testing.T) {
 		fuzzer.Fuzz(e)
 		s, err := state_native.InitializeFromProtoUnsafePhase0(state)
 		require.NoError(t, err)
-		r, err := ProcessVoluntaryExits(t.Context(), s, []*ethpb.SignedVoluntaryExit{e}, v.ExitInformation(s))
+		r, err := ProcessVoluntaryExits(t.Context(), s, []*ethpb.SignedVoluntaryExit{e})
 		if err != nil && r != nil {
 			t.Fatalf("return value should be nil on err. found: %v on error: %v for state: %v and block: %v", r, err, state, e)
 		}

beacon-chain/core/blocks/block_regression_test.go

@@ -94,7 +94,7 @@ func TestProcessAttesterSlashings_RegressionSlashableIndices(t *testing.T) {
 	for i, s := range b.Block.Body.AttesterSlashings {
 		ss[i] = s
 	}
-	newState, err := blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.ExitInformation(beaconState))
+	newState, err := blocks.ProcessAttesterSlashings(t.Context(), beaconState, ss, v.SlashValidator)
 	require.NoError(t, err)
 	newRegistry := newState.Validators()
 	if !newRegistry[expectedSlashedVal].Slashed {

beacon-chain/core/blocks/exit.go

@@ -9,6 +9,7 @@ import (
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"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/time/slots"
@@ -49,12 +50,13 @@ func ProcessVoluntaryExits(
 	ctx context.Context,
 	beaconState state.BeaconState,
 	exits []*ethpb.SignedVoluntaryExit,
-	exitInfo *v.ExitInfo,
 ) (state.BeaconState, error) {
 	// Avoid calculating the epoch churn if no exits exist.
 	if len(exits) == 0 {
 		return beaconState, nil
 	}
+	maxExitEpoch, churn := v.MaxExitEpochAndChurn(beaconState)
+	var exitEpoch primitives.Epoch
 	for idx, exit := range exits {
 		if exit == nil || exit.Exit == nil {
 			return nil, errors.New("nil voluntary exit in block body")
@@ -66,8 +68,15 @@ func ProcessVoluntaryExits(
 		if err := VerifyExitAndSignature(val, beaconState, exit); err != nil {
 			return nil, errors.Wrapf(err, "could not verify exit %d", idx)
 		}
-		beaconState, err = v.InitiateValidatorExit(ctx, beaconState, exit.Exit.ValidatorIndex, exitInfo)
-		if err != nil && !errors.Is(err, v.ErrValidatorAlreadyExited) {
+		beaconState, exitEpoch, err = v.InitiateValidatorExit(ctx, beaconState, exit.Exit.ValidatorIndex, maxExitEpoch, churn)
+		if err == nil {
+			if exitEpoch > maxExitEpoch {
+				maxExitEpoch = exitEpoch
+				churn = 1
+			} else if exitEpoch == maxExitEpoch {
+				churn++
+			}
+		} else if !errors.Is(err, v.ErrValidatorAlreadyExited) {
 			return nil, err
 		}
 	}

beacon-chain/core/blocks/exit_test.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"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"
@@ -47,7 +46,7 @@ func TestProcessVoluntaryExits_NotActiveLongEnoughToExit(t *testing.T) {
 	}
 
 	want := "validator has not been active long enough to exit"
-	_, err = blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits, validators.ExitInformation(state))
+	_, err = blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -77,7 +76,7 @@ func TestProcessVoluntaryExits_ExitAlreadySubmitted(t *testing.T) {
 	}
 
 	want := "validator with index 0 has already submitted an exit, which will take place at epoch: 10"
-	_, err = blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits, validators.ExitInformation(state))
+	_, err = blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -125,7 +124,7 @@ func TestProcessVoluntaryExits_AppliesCorrectStatus(t *testing.T) {
 		},
 	}
 
-	newState, err := blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits, validators.ExitInformation(state))
+	newState, err := blocks.ProcessVoluntaryExits(t.Context(), state, b.Block.Body.VoluntaryExits)
 	require.NoError(t, err, "Could not process exits")
 	newRegistry := newState.Validators()
 	if newRegistry[0].ExitEpoch != helpers.ActivationExitEpoch(primitives.Epoch(state.Slot()/params.BeaconConfig().SlotsPerEpoch)) {

beacon-chain/core/blocks/proposer_slashing.go

@@ -7,9 +7,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
@@ -19,6 +19,11 @@ import (
 // ErrCouldNotVerifyBlockHeader is returned when a block header's signature cannot be verified.
 var ErrCouldNotVerifyBlockHeader = errors.New("could not verify beacon block header")
 
+type slashValidatorFunc func(
+	ctx context.Context,
+	st state.BeaconState,
+	vid primitives.ValidatorIndex) (state.BeaconState, error)
+
 // ProcessProposerSlashings is one of the operations performed
 // on each processed beacon block to slash proposers based on
 // slashing conditions if any slashable events occurred.
@@ -49,11 +54,11 @@ func ProcessProposerSlashings(
 	ctx context.Context,
 	beaconState state.BeaconState,
 	slashings []*ethpb.ProposerSlashing,
-	exitInfo *validators.ExitInfo,
+	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	var err error
 	for _, slashing := range slashings {
-		beaconState, err = ProcessProposerSlashing(ctx, beaconState, slashing, exitInfo)
+		beaconState, err = ProcessProposerSlashing(ctx, beaconState, slashing, slashFunc)
 		if err != nil {
 			return nil, err
 		}
@@ -66,7 +71,7 @@ func ProcessProposerSlashing(
 	ctx context.Context,
 	beaconState state.BeaconState,
 	slashing *ethpb.ProposerSlashing,
-	exitInfo *validators.ExitInfo,
+	slashFunc slashValidatorFunc,
 ) (state.BeaconState, error) {
 	var err error
 	if slashing == nil {
@@ -75,7 +80,7 @@ func ProcessProposerSlashing(
 	if err = VerifyProposerSlashing(beaconState, slashing); err != nil {
 		return nil, errors.Wrap(err, "could not verify proposer slashing")
 	}
-	beaconState, err = validators.SlashValidator(ctx, beaconState, slashing.Header_1.Header.ProposerIndex, exitInfo)
+	beaconState, err = slashFunc(ctx, beaconState, slashing.Header_1.Header.ProposerIndex)
 	if err != nil {
 		return nil, errors.Wrapf(err, "could not slash proposer index %d", slashing.Header_1.Header.ProposerIndex)
 	}

beacon-chain/core/blocks/proposer_slashing_test.go

@@ -50,7 +50,7 @@ func TestProcessProposerSlashings_UnmatchedHeaderSlots(t *testing.T) {
 		},
 	}
 	want := "mismatched header slots"
-	_, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	_, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -83,7 +83,7 @@ func TestProcessProposerSlashings_SameHeaders(t *testing.T) {
 		},
 	}
 	want := "expected slashing headers to differ"
-	_, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	_, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -133,7 +133,7 @@ func TestProcessProposerSlashings_ValidatorNotSlashable(t *testing.T) {
 		"validator with key %#x is not slashable",
 		bytesutil.ToBytes48(beaconState.Validators()[0].PublicKey),
 	)
-	_, err = blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	_, err = blocks.ProcessProposerSlashings(t.Context(), beaconState, b.Block.Body.ProposerSlashings, v.SlashValidator)
 	assert.ErrorContains(t, want, err)
 }
 
@@ -172,7 +172,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatus(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -220,7 +220,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusAltair(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -268,7 +268,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusBellatrix(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()
@@ -316,7 +316,7 @@ func TestProcessProposerSlashings_AppliesCorrectStatusCapella(t *testing.T) {
 	block := util.NewBeaconBlock()
 	block.Block.Body.ProposerSlashings = slashings
 
-	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.ExitInformation(beaconState))
+	newState, err := blocks.ProcessProposerSlashings(t.Context(), beaconState, block.Block.Body.ProposerSlashings, v.SlashValidator)
 	require.NoError(t, err)
 
 	newStateVals := newState.Validators()

beacon-chain/core/blocks/signature.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/attestation"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -100,7 +101,7 @@ func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.Sig
 // via the respective epoch.
 func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState, blk interfaces.ReadOnlySignedBeaconBlock, blkRoot [32]byte) error {
 	currentEpoch := slots.ToEpoch(blk.Block().Slot())
-	fork, err := params.Fork(currentEpoch)
+	fork, err := forks.Fork(currentEpoch)
 	if err != nil {
 		return err
 	}

beacon-chain/core/electra/registry_updates.go

@@ -84,8 +84,8 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) error {
 	// Handle validator ejections.
 	for _, idx := range eligibleForEjection {
 		var err error
-		// exit info is not used in electra
-		st, err = validators.InitiateValidatorExit(ctx, st, idx, &validators.ExitInfo{})
+		// exitQueueEpoch and churn arguments are not used in electra.
+		st, _, err = validators.InitiateValidatorExit(ctx, st, idx, 0 /*exitQueueEpoch*/, 0 /*churn*/)
 		if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
 			return fmt.Errorf("failed to initiate validator exit at index %d: %w", idx, err)
 		}

beacon-chain/core/electra/transition_no_verify_sig.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	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/interfaces"
@@ -47,21 +46,18 @@ var (
 //      # [New in Electra:EIP7251]
 //      for_ops(body.execution_payload.consolidation_requests, process_consolidation_request)
 
-func ProcessOperations(ctx context.Context, st state.BeaconState, block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
-	var err error
-
+func ProcessOperations(
+	ctx context.Context,
+	st state.BeaconState,
+	block interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
 	// 6110 validations are in VerifyOperationLengths
 	bb := block.Body()
 	// Electra extends the altair operations.
-	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)
+	st, err := ProcessProposerSlashings(ctx, st, bb.ProposerSlashings(), v.SlashValidator)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair proposer slashing")
 	}
-	st, err = ProcessAttesterSlashings(ctx, st, bb.AttesterSlashings(), exitInfo)
+	st, err = ProcessAttesterSlashings(ctx, st, bb.AttesterSlashings(), v.SlashValidator)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair attester slashing")
 	}
@@ -72,7 +68,7 @@ func ProcessOperations(ctx context.Context, st state.BeaconState, block interfac
 	if _, err := ProcessDeposits(ctx, st, bb.Deposits()); err != nil { // new in electra
 		return nil, errors.Wrap(err, "could not process altair deposit")
 	}
-	st, err = ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits(), exitInfo)
+	st, err = ProcessVoluntaryExits(ctx, st, bb.VoluntaryExits())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process voluntary exits")
 	}

beacon-chain/core/electra/withdrawals.go

@@ -147,8 +147,9 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 		if isFullExitRequest {
 			// Only exit validator if it has no pending withdrawals in the queue
 			if pendingBalanceToWithdraw == 0 {
+				maxExitEpoch, churn := validators.MaxExitEpochAndChurn(st)
 				var err error
-				st, err = validators.InitiateValidatorExit(ctx, st, vIdx, validators.ExitInformation(st))
+				st, _, err = validators.InitiateValidatorExit(ctx, st, vIdx, maxExitEpoch, churn)
 				if err != nil {
 					return nil, err
 				}

beacon-chain/core/epoch/epoch_processing.go

@@ -99,7 +99,8 @@ func ProcessRegistryUpdates(ctx context.Context, st state.BeaconState) (state.Be
 	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))
+		maxExitEpoch, churn := validators.MaxExitEpochAndChurn(st)
+		st, _, err = validators.InitiateValidatorExit(ctx, st, idx, maxExitEpoch, churn)
 		if err != nil && !errors.Is(err, validators.ErrValidatorAlreadyExited) {
 			return nil, errors.Wrapf(err, "could not initiate exit for validator %d", idx)
 		}

beacon-chain/core/fulu/transition.go

@@ -16,10 +16,10 @@ func ProcessEpoch(ctx context.Context, state state.BeaconState) error {
 	if err := electra.ProcessEpoch(ctx, state); err != nil {
 		return errors.Wrap(err, "could not process epoch in fulu transition")
 	}
-	return ProcessProposerLookahead(ctx, state)
+	return processProposerLookahead(ctx, state)
 }
 
-func ProcessProposerLookahead(ctx context.Context, state state.BeaconState) error {
+func processProposerLookahead(ctx context.Context, state state.BeaconState) error {
 	_, span := trace.StartSpan(ctx, "fulu.processProposerLookahead")
 	defer span.End()
 

beacon-chain/core/gloas/BUILD.bazel

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

@@ -1,189 +0,0 @@
-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/beacon_committee.go

@@ -317,15 +317,23 @@ func ProposerAssignments(ctx context.Context, state state.BeaconState, epoch pri
 	}
 
 	proposerAssignments := make(map[primitives.ValidatorIndex][]primitives.Slot)
+
+	originalStateSlot := state.Slot()
+
 	for slot := startSlot; slot < startSlot+params.BeaconConfig().SlotsPerEpoch; slot++ {
 		// Skip proposer assignment for genesis slot.
 		if slot == 0 {
 			continue
 		}
+		// Set the state's current slot.
+		if err := state.SetSlot(slot); err != nil {
+			return nil, err
+		}
+
 		// Determine the proposer index for the current slot.
-		i, err := BeaconProposerIndexAtSlot(ctx, state, slot)
+		i, err := BeaconProposerIndex(ctx, state)
 		if err != nil {
-			return nil, errors.Wrapf(err, "could not check proposer at slot %d", slot)
+			return nil, errors.Wrapf(err, "could not check proposer at slot %d", state.Slot())
 		}
 
 		// Append the slot to the proposer's assignments.
@@ -334,6 +342,12 @@ func ProposerAssignments(ctx context.Context, state state.BeaconState, epoch pri
 		}
 		proposerAssignments[i] = append(proposerAssignments[i], slot)
 	}
+
+	// Reset state back to its original slot.
+	if err := state.SetSlot(originalStateSlot); err != nil {
+		return nil, err
+	}
+
 	return proposerAssignments, nil
 }
 

beacon-chain/core/helpers/rewards_penalties.go

@@ -87,11 +87,6 @@ func TotalActiveBalance(s state.ReadOnlyBeaconState) (uint64, error) {
 	return total, nil
 }
 
-// UpdateTotalActiveBalanceCache updates the cache with the given total active balance.
-func UpdateTotalActiveBalanceCache(s state.BeaconState, total uint64) error {
-	return balanceCache.AddTotalEffectiveBalance(s, total)
-}
-
 // IncreaseBalance increases validator with the given 'index' balance by 'delta' in Gwei.
 //
 // Spec pseudocode definition:

beacon-chain/core/helpers/rewards_penalties_test.go

@@ -297,30 +297,3 @@ func TestIncreaseBadBalance_NotOK(t *testing.T) {
 		require.ErrorContains(t, "addition overflows", helpers.IncreaseBalance(state, test.i, test.nb))
 	}
 }
-
-func TestUpdateTotalActiveBalanceCache(t *testing.T) {
-	helpers.ClearCache()
-
-	// Create a test state with some validators
-	validators := []*ethpb.Validator{
-		{EffectiveBalance: 32 * 1e9, ExitEpoch: params.BeaconConfig().FarFutureEpoch, ActivationEpoch: 0},
-		{EffectiveBalance: 32 * 1e9, ExitEpoch: params.BeaconConfig().FarFutureEpoch, ActivationEpoch: 0},
-		{EffectiveBalance: 31 * 1e9, ExitEpoch: params.BeaconConfig().FarFutureEpoch, ActivationEpoch: 0},
-	}
-	state, err := state_native.InitializeFromProtoPhase0(&ethpb.BeaconState{
-		Validators: validators,
-		Slot:       0,
-	})
-	require.NoError(t, err)
-
-	// Test updating cache with a specific total
-	testTotal := uint64(95 * 1e9) // 32 + 32 + 31 = 95
-	err = helpers.UpdateTotalActiveBalanceCache(state, testTotal)
-	require.NoError(t, err)
-
-	// Verify the cache was updated by retrieving the total active balance
-	// which should now return the cached value
-	cachedTotal, err := helpers.TotalActiveBalance(state)
-	require.NoError(t, err)
-	assert.Equal(t, testTotal, cachedTotal, "Cache should return the updated total")
-}

beacon-chain/core/helpers/sync_committee.go

@@ -21,39 +21,6 @@ var (
 	syncCommitteeCache = cache.NewSyncCommittee()
 )
 
-// CurrentPeriodPositions returns committee indices of the current period sync committee for input validators.
-func CurrentPeriodPositions(st state.BeaconState, indices []primitives.ValidatorIndex) ([][]primitives.CommitteeIndex, error) {
-	root, err := SyncPeriodBoundaryRoot(st)
-	if err != nil {
-		return nil, err
-	}
-	pos, err := syncCommitteeCache.CurrentPeriodPositions(root, indices)
-	if errors.Is(err, cache.ErrNonExistingSyncCommitteeKey) {
-		committee, err := st.CurrentSyncCommittee()
-		if err != nil {
-			return nil, err
-		}
-
-		// Fill in the cache on miss.
-		go func() {
-			if err := syncCommitteeCache.UpdatePositionsInCommittee(root, st); err != nil {
-				log.WithError(err).Error("Could not fill sync committee cache on miss")
-			}
-		}()
-
-		pos = make([][]primitives.CommitteeIndex, len(indices))
-		for i, idx := range indices {
-			pubkey := st.PubkeyAtIndex(idx)
-			pos[i] = findSubCommitteeIndices(pubkey[:], committee.Pubkeys)
-		}
-		return pos, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	return pos, nil
-}
-
 // IsCurrentPeriodSyncCommittee returns true if the input validator index belongs in the current period sync committee
 // along with the sync committee root.
 // 1. Checks if the public key exists in the sync committee cache

beacon-chain/core/helpers/sync_committee_test.go

@@ -17,38 +17,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 )
 
-func TestCurrentPeriodPositions(t *testing.T) {
-	helpers.ClearCache()
-
-	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)
-	syncCommittee := &ethpb.SyncCommittee{
-		Pubkeys: make([][]byte, params.BeaconConfig().SyncCommitteeSize),
-	}
-	for i := 0; i < len(validators); i++ {
-		k := make([]byte, 48)
-		copy(k, strconv.Itoa(i))
-		validators[i] = &ethpb.Validator{
-			PublicKey: k,
-		}
-		syncCommittee.Pubkeys[i] = bytesutil.PadTo(k, 48)
-	}
-	state, err := state_native.InitializeFromProtoAltair(&ethpb.BeaconStateAltair{
-		Validators: validators,
-	})
-	require.NoError(t, err)
-	require.NoError(t, state.SetCurrentSyncCommittee(syncCommittee))
-	require.NoError(t, state.SetNextSyncCommittee(syncCommittee))
-	require.NoError(t, err, helpers.SyncCommitteeCache().UpdatePositionsInCommittee([32]byte{}, state))
-
-	positions, err := helpers.CurrentPeriodPositions(state, []primitives.ValidatorIndex{0, 1})
-	require.NoError(t, err)
-	require.Equal(t, 2, len(positions))
-	require.Equal(t, 1, len(positions[0]))
-	assert.Equal(t, primitives.CommitteeIndex(0), positions[0][0])
-	require.Equal(t, 1, len(positions[1]))
-	assert.Equal(t, primitives.CommitteeIndex(1), positions[1][0])
-}
-
 func TestIsCurrentEpochSyncCommittee_UsingCache(t *testing.T) {
 	helpers.ClearCache()
 
@@ -110,7 +78,6 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) {
 
 func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	helpers.ClearCache()
-	params.SetupTestConfigCleanup(t)
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)
 	syncCommittee := &ethpb.SyncCommittee{
@@ -297,7 +264,6 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 }
 
 func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)

beacon-chain/core/helpers/validators.go

@@ -309,29 +309,23 @@ func beaconProposerIndexAtSlotFulu(state state.ReadOnlyBeaconState, slot primiti
 	if err != nil {
 		return 0, errors.Wrap(err, "could not get proposer lookahead")
 	}
-	spe := params.BeaconConfig().SlotsPerEpoch
 	if e == stateEpoch {
-		return lookAhead[slot%spe], nil
+		return lookAhead[slot%params.BeaconConfig().SlotsPerEpoch], nil
 	}
 	// The caller is requesting the proposer for the next epoch
-	return lookAhead[spe+slot%spe], nil
+	return lookAhead[slot%params.BeaconConfig().SlotsPerEpoch+params.BeaconConfig().SlotsPerEpoch], nil
 }
 
 // BeaconProposerIndexAtSlot returns proposer index at the given slot from the
 // point of view of the given state as head state
 func BeaconProposerIndexAtSlot(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) (primitives.ValidatorIndex, error) {
-	e := slots.ToEpoch(slot)
-	stateEpoch := slots.ToEpoch(state.Slot())
-	// Even if the state is post Fulu, we may request a past proposer index.
-	if state.Version() >= version.Fulu && e >= params.BeaconConfig().FuluForkEpoch {
-		// We can use the cached lookahead only for the current and the next epoch.
-		if e == stateEpoch || e == stateEpoch+1 {
-			return beaconProposerIndexAtSlotFulu(state, slot)
-		}
+	if state.Version() >= version.Fulu {
+		return beaconProposerIndexAtSlotFulu(state, slot)
 	}
+	e := slots.ToEpoch(slot)
 	// The cache uses the state root of the previous epoch - minimum_seed_lookahead last slot as key. (e.g. Starting epoch 1, slot 32, the key would be block root at slot 31)
-	// For simplicity, the node will skip caching of genesis epoch. If the passed state has not yet reached this slot then we do not check the cache.
-	if e <= stateEpoch && e > params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
+	// For simplicity, the node will skip caching of genesis epoch.
+	if e > params.BeaconConfig().GenesisEpoch+params.BeaconConfig().MinSeedLookahead {
 		s, err := slots.EpochEnd(e - 1)
 		if err != nil {
 			return 0, err

beacon-chain/core/helpers/validators_test.go

@@ -1161,10 +1161,6 @@ func TestValidatorMaxEffectiveBalance(t *testing.T) {
 }
 
 func TestBeaconProposerIndexAtSlotFulu(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.FuluForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
 	lookahead := make([]uint64, 64)
 	lookahead[0] = 15
 	lookahead[1] = 16
@@ -1184,4 +1180,8 @@ func TestBeaconProposerIndexAtSlotFulu(t *testing.T) {
 	idx, err = helpers.BeaconProposerIndexAtSlot(t.Context(), st, 130)
 	require.NoError(t, err)
 	require.Equal(t, primitives.ValidatorIndex(42), idx)
+	_, err = helpers.BeaconProposerIndexAtSlot(t.Context(), st, 95)
+	require.ErrorContains(t, "slot 95 is not in the current epoch 3 or the next epoch", err)
+	_, err = helpers.BeaconProposerIndexAtSlot(t.Context(), st, 160)
+	require.ErrorContains(t, "slot 160 is not in the current epoch 3 or the next epoch", err)
 }

beacon-chain/core/peerdas/das_core.go

@@ -223,14 +223,6 @@ func dataColumnsSidecars(
 			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)
 

beacon-chain/core/peerdas/das_core_test.go

@@ -67,55 +67,6 @@ func TestDataColumnSidecars(t *testing.T) {
 		_, 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) {

beacon-chain/core/peerdas/reconstruction.go

@@ -18,8 +18,8 @@ var (
 	ErrBlobsCellsProofsMismatch = errors.New("blobs and cells proofs mismatch")
 )
 
-// MinimumColumnCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
-func MinimumColumnCountToReconstruct() uint64 {
+// MinimumColumnsCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
+func MinimumColumnsCountToReconstruct() uint64 {
 	// If the number of columns is odd, then we need total / 2 + 1 columns to reconstruct.
 	// If the number of columns is even, then we need total / 2 columns to reconstruct.
 	return (params.BeaconConfig().NumberOfColumns + 1) / 2
@@ -58,7 +58,7 @@ func ReconstructDataColumnSidecars(inVerifiedRoSidecars []blocks.VerifiedRODataC
 
 	// Check if there is enough sidecars to reconstruct the missing columns.
 	sidecarCount := len(sidecarByIndex)
-	if uint64(sidecarCount) < MinimumColumnCountToReconstruct() {
+	if uint64(sidecarCount) < MinimumColumnsCountToReconstruct() {
 		return nil, ErrNotEnoughDataColumnSidecars
 	}
 

beacon-chain/core/peerdas/reconstruction_test.go

@@ -48,7 +48,7 @@ func TestMinimumColumnsCountToReconstruct(t *testing.T) {
 			params.OverrideBeaconConfig(cfg)
 
 			// Compute the minimum number of columns needed to reconstruct.
-			actual := peerdas.MinimumColumnCountToReconstruct()
+			actual := peerdas.MinimumColumnsCountToReconstruct()
 			require.Equal(t, tc.expected, actual)
 		})
 	}
@@ -100,7 +100,7 @@ func TestReconstructDataColumnSidecars(t *testing.T) {
 	t.Run("not enough columns to enable reconstruction", func(t *testing.T) {
 		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
 
-		minimum := peerdas.MinimumColumnCountToReconstruct()
+		minimum := peerdas.MinimumColumnsCountToReconstruct()
 		_, err := peerdas.ReconstructDataColumnSidecars(verifiedRoSidecars[:minimum-1])
 		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
 	})

beacon-chain/core/signing/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "domain.go",
+        "signature.go",
         "signing_root.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing",
@@ -24,6 +25,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "domain_test.go",
+        "signature_test.go",
         "signing_root_test.go",
     ],
     embed = [":go_default_library"],

beacon-chain/core/signing/signature.go

@@ -0,0 +1,34 @@
+package signing
+
+import (
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/pkg/errors"
+)
+
+var ErrNilRegistration = errors.New("nil signed registration")
+
+// VerifyRegistrationSignature verifies the signature of a validator's registration.
+func VerifyRegistrationSignature(
+	sr *ethpb.SignedValidatorRegistrationV1,
+) error {
+	if sr == nil || sr.Message == nil {
+		return ErrNilRegistration
+	}
+
+	d := params.BeaconConfig().DomainApplicationBuilder
+	// Per spec, we want the fork version and genesis validator to be nil.
+	// Which is genesis value and zero by default.
+	sd, err := ComputeDomain(
+		d,
+		nil, /* fork version */
+		nil /* genesis val root */)
+	if err != nil {
+		return err
+	}
+
+	if err := VerifySigningRoot(sr.Message, sr.Message.Pubkey, sr.Signature, sd); err != nil {
+		return ErrSigFailedToVerify
+	}
+	return nil
+}

beacon-chain/core/signing/signature_test.go

@@ -0,0 +1,42 @@
+package signing_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/crypto/bls"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestVerifyRegistrationSignature(t *testing.T) {
+	sk, err := bls.RandKey()
+	require.NoError(t, err)
+	reg := &ethpb.ValidatorRegistrationV1{
+		FeeRecipient: bytesutil.PadTo([]byte("fee"), 20),
+		GasLimit:     123456,
+		Timestamp:    uint64(time.Now().Unix()),
+		Pubkey:       sk.PublicKey().Marshal(),
+	}
+	d := params.BeaconConfig().DomainApplicationBuilder
+	domain, err := signing.ComputeDomain(d, nil, nil)
+	require.NoError(t, err)
+	sr, err := signing.ComputeSigningRoot(reg, domain)
+	require.NoError(t, err)
+	sk.Sign(sr[:]).Marshal()
+
+	sReg := &ethpb.SignedValidatorRegistrationV1{
+		Message:   reg,
+		Signature: sk.Sign(sr[:]).Marshal(),
+	}
+	require.NoError(t, signing.VerifyRegistrationSignature(sReg))
+
+	sReg.Signature = []byte("bad")
+	require.ErrorIs(t, signing.VerifyRegistrationSignature(sReg), signing.ErrSigFailedToVerify)
+
+	sReg.Message = nil
+	require.ErrorIs(t, signing.VerifyRegistrationSignature(sReg), signing.ErrNilRegistration)
+}

beacon-chain/core/time/slot_epoch.go

@@ -108,12 +108,6 @@ 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,7 +24,6 @@ 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,7 +17,6 @@ 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"
@@ -390,15 +389,6 @@ 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

@@ -8,7 +8,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
 	b "github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
 	"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"
 	v "github.com/OffchainLabs/prysm/v6/beacon-chain/core/validators"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
@@ -375,18 +374,15 @@ func ProcessBlockForStateRoot(
 }
 
 // This calls altair block operations.
-func altairOperations(ctx context.Context, st state.BeaconState, beaconBlock interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
-	var err error
-
-	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)
+func altairOperations(
+	ctx context.Context,
+	st state.BeaconState,
+	beaconBlock interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
+	st, err := b.ProcessProposerSlashings(ctx, st, beaconBlock.Body().ProposerSlashings(), v.SlashValidator)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair proposer slashing")
 	}
-	st, err = b.ProcessAttesterSlashings(ctx, st, beaconBlock.Body().AttesterSlashings(), exitInfo)
+	st, err = b.ProcessAttesterSlashings(ctx, st, beaconBlock.Body().AttesterSlashings(), v.SlashValidator)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process altair attester slashing")
 	}
@@ -397,7 +393,7 @@ func altairOperations(ctx context.Context, st state.BeaconState, beaconBlock int
 	if _, err := altair.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
 		return nil, errors.Wrap(err, "could not process altair deposit")
 	}
-	st, err = b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits(), exitInfo)
+	st, err = b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process voluntary exits")
 	}
@@ -405,18 +401,15 @@ 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
-
-	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)
+func phase0Operations(
+	ctx context.Context,
+	st state.BeaconState,
+	beaconBlock interfaces.ReadOnlyBeaconBlock) (state.BeaconState, error) {
+	st, err := b.ProcessProposerSlashings(ctx, st, beaconBlock.Body().ProposerSlashings(), v.SlashValidator)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process block proposer slashings")
 	}
-	st, err = b.ProcessAttesterSlashings(ctx, st, beaconBlock.Body().AttesterSlashings(), exitInfo)
+	st, err = b.ProcessAttesterSlashings(ctx, st, beaconBlock.Body().AttesterSlashings(), v.SlashValidator)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process block attester slashings")
 	}
@@ -427,9 +420,5 @@ func phase0Operations(ctx context.Context, st state.BeaconState, beaconBlock int
 	if _, err := altair.ProcessDeposits(ctx, st, beaconBlock.Body().Deposits()); err != nil {
 		return nil, errors.Wrap(err, "could not process deposits")
 	}
-	st, err = b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits(), exitInfo)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not process voluntary exits")
-	}
-	return st, nil
+	return b.ProcessVoluntaryExits(ctx, st, beaconBlock.Body().VoluntaryExits())
 }

beacon-chain/core/validators/validator.go

@@ -13,55 +13,34 @@ 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"
 	"github.com/pkg/errors"
 )
 
-// ExitInfo provides information about validator exits in the state.
-type ExitInfo struct {
-	HighestExitEpoch   primitives.Epoch
-	Churn              uint64
-	TotalActiveBalance uint64
-}
-
 // ErrValidatorAlreadyExited is an error raised when trying to process an exit of
 // an already exited validator
 var ErrValidatorAlreadyExited = errors.New("validator already exited")
 
-// ExitInformation returns information about validator exits.
-func ExitInformation(s state.BeaconState) *ExitInfo {
-	exitInfo := &ExitInfo{}
-
+// MaxExitEpochAndChurn returns the maximum non-FAR_FUTURE_EPOCH exit
+// epoch and the number of them
+func MaxExitEpochAndChurn(s state.BeaconState) (maxExitEpoch primitives.Epoch, churn uint64) {
 	farFutureEpoch := params.BeaconConfig().FarFutureEpoch
-	currentEpoch := slots.ToEpoch(s.Slot())
-	totalActiveBalance := uint64(0)
-
 	err := s.ReadFromEveryValidator(func(idx int, val state.ReadOnlyValidator) error {
 		e := val.ExitEpoch()
 		if e != farFutureEpoch {
-			if e > exitInfo.HighestExitEpoch {
-				exitInfo.HighestExitEpoch = e
-				exitInfo.Churn = 1
-			} else if e == exitInfo.HighestExitEpoch {
-				exitInfo.Churn++
+			if e > maxExitEpoch {
+				maxExitEpoch = e
+				churn = 1
+			} else if e == maxExitEpoch {
+				churn++
 			}
 		}
-
-		// Calculate total active balance in the same loop
-		if helpers.IsActiveValidatorUsingTrie(val, currentEpoch) {
-			totalActiveBalance += val.EffectiveBalance()
-		}
-
 		return nil
 	})
 	_ = err
-
-	// Apply minimum balance as per spec
-	exitInfo.TotalActiveBalance = mathutil.Max(params.BeaconConfig().EffectiveBalanceIncrement, totalActiveBalance)
-	return exitInfo
+	return
 }
 
 // InitiateValidatorExit takes in validator index and updates
@@ -85,117 +64,59 @@ func ExitInformation(s state.BeaconState) *ExitInfo {
 //	    # Set validator exit epoch and withdrawable epoch
 //	    validator.exit_epoch = exit_queue_epoch
 //	    validator.withdrawable_epoch = Epoch(validator.exit_epoch + MIN_VALIDATOR_WITHDRAWABILITY_DELAY)
-func InitiateValidatorExit(
-	ctx context.Context,
-	s state.BeaconState,
-	idx primitives.ValidatorIndex,
-	exitInfo *ExitInfo,
-) (state.BeaconState, error) {
+func InitiateValidatorExit(ctx context.Context, s state.BeaconState, idx primitives.ValidatorIndex, exitQueueEpoch primitives.Epoch, churn uint64) (state.BeaconState, primitives.Epoch, error) {
 	validator, err := s.ValidatorAtIndex(idx)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 	if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
-		return s, ErrValidatorAlreadyExited
+		return s, validator.ExitEpoch, ErrValidatorAlreadyExited
 	}
 
 	// Compute exit queue epoch.
 	if s.Version() < version.Electra {
-		if err = initiateValidatorExitPreElectra(ctx, s, exitInfo); err != nil {
-			return nil, err
+		// Relevant spec code from phase0:
+		//
+		//	exit_epochs = [v.exit_epoch for v in state.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
+		//	exit_queue_epoch = max(exit_epochs + [compute_activation_exit_epoch(get_current_epoch(state))])
+		//	exit_queue_churn = len([v for v in state.validators if v.exit_epoch == exit_queue_epoch])
+		//	if exit_queue_churn >= get_validator_churn_limit(state):
+		//	    exit_queue_epoch += Epoch(1)
+		exitableEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(s))
+		if exitableEpoch > exitQueueEpoch {
+			exitQueueEpoch = exitableEpoch
+			churn = 0
+		}
+		activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, s, time.CurrentEpoch(s))
+		if err != nil {
+			return nil, 0, errors.Wrap(err, "could not get active validator count")
+		}
+		currentChurn := helpers.ValidatorExitChurnLimit(activeValidatorCount)
+
+		if churn >= currentChurn {
+			exitQueueEpoch, err = exitQueueEpoch.SafeAdd(1)
+			if err != nil {
+				return nil, 0, err
+			}
 		}
 	} else {
 		// [Modified in Electra:EIP7251]
 		// exit_queue_epoch = compute_exit_epoch_and_update_churn(state, validator.effective_balance)
 		var err error
-		exitInfo.HighestExitEpoch, err = s.ExitEpochAndUpdateChurn(primitives.Gwei(validator.EffectiveBalance))
+		exitQueueEpoch, err = s.ExitEpochAndUpdateChurn(primitives.Gwei(validator.EffectiveBalance))
 		if err != nil {
-			return nil, err
+			return nil, 0, err
 		}
 	}
-	validator.ExitEpoch = exitInfo.HighestExitEpoch
-	validator.WithdrawableEpoch, err = exitInfo.HighestExitEpoch.SafeAddEpoch(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
+	validator.ExitEpoch = exitQueueEpoch
+	validator.WithdrawableEpoch, err = exitQueueEpoch.SafeAddEpoch(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
 	if err != nil {
-		return nil, err
+		return nil, 0, err
 	}
 	if err := s.UpdateValidatorAtIndex(idx, validator); err != nil {
-		return nil, err
+		return nil, 0, err
 	}
-	return s, nil
-}
-
-// InitiateValidatorExitForTotalBal has the same functionality as InitiateValidatorExit,
-// the only difference being how total active balance is obtained. In InitiateValidatorExit
-// it is calculated inside the function and in InitiateValidatorExitForTotalBal it's a
-// function argument.
-func InitiateValidatorExitForTotalBal(
-	ctx context.Context,
-	s state.BeaconState,
-	idx primitives.ValidatorIndex,
-	exitInfo *ExitInfo,
-	totalActiveBalance primitives.Gwei,
-) (state.BeaconState, error) {
-	validator, err := s.ValidatorAtIndex(idx)
-	if err != nil {
-		return nil, err
-	}
-	if validator.ExitEpoch != params.BeaconConfig().FarFutureEpoch {
-		return s, ErrValidatorAlreadyExited
-	}
-
-	// Compute exit queue epoch.
-	if s.Version() < version.Electra {
-		if err = initiateValidatorExitPreElectra(ctx, s, exitInfo); err != nil {
-			return nil, err
-		}
-	} else {
-		// [Modified in Electra:EIP7251]
-		// exit_queue_epoch = compute_exit_epoch_and_update_churn(state, validator.effective_balance)
-		var err error
-		exitInfo.HighestExitEpoch, err = s.ExitEpochAndUpdateChurnForTotalBal(totalActiveBalance, primitives.Gwei(validator.EffectiveBalance))
-		if err != nil {
-			return nil, err
-		}
-	}
-	validator.ExitEpoch = exitInfo.HighestExitEpoch
-	validator.WithdrawableEpoch, err = exitInfo.HighestExitEpoch.SafeAddEpoch(params.BeaconConfig().MinValidatorWithdrawabilityDelay)
-	if err != nil {
-		return nil, err
-	}
-	if err := s.UpdateValidatorAtIndex(idx, validator); err != nil {
-		return nil, err
-	}
-	return s, nil
-}
-
-func initiateValidatorExitPreElectra(ctx context.Context, s state.BeaconState, exitInfo *ExitInfo) error {
-	// Relevant spec code from phase0:
-	//
-	//	exit_epochs = [v.exit_epoch for v in state.validators if v.exit_epoch != FAR_FUTURE_EPOCH]
-	//	exit_queue_epoch = max(exit_epochs + [compute_activation_exit_epoch(get_current_epoch(state))])
-	//	exit_queue_churn = len([v for v in state.validators if v.exit_epoch == exit_queue_epoch])
-	//	if exit_queue_churn >= get_validator_churn_limit(state):
-	//	    exit_queue_epoch += Epoch(1)
-	exitableEpoch := helpers.ActivationExitEpoch(time.CurrentEpoch(s))
-	if exitableEpoch > exitInfo.HighestExitEpoch {
-		exitInfo.HighestExitEpoch = exitableEpoch
-		exitInfo.Churn = 0
-	}
-	activeValidatorCount, err := helpers.ActiveValidatorCount(ctx, s, time.CurrentEpoch(s))
-	if err != nil {
-		return errors.Wrap(err, "could not get active validator count")
-	}
-	currentChurn := helpers.ValidatorExitChurnLimit(activeValidatorCount)
-	if exitInfo.Churn >= currentChurn {
-		exitInfo.HighestExitEpoch, err = exitInfo.HighestExitEpoch.SafeAdd(1)
-		if err != nil {
-			return err
-		}
-		exitInfo.Churn = 1
-	} else {
-		exitInfo.Churn = exitInfo.Churn + 1
-	}
-	return nil
+	return s, exitQueueEpoch, nil
 }
 
 // SlashValidator slashes the malicious validator's balance and awards
@@ -231,12 +152,9 @@ func initiateValidatorExitPreElectra(ctx context.Context, s state.BeaconState, e
 func SlashValidator(
 	ctx context.Context,
 	s state.BeaconState,
-	slashedIdx primitives.ValidatorIndex,
-	exitInfo *ExitInfo,
-) (state.BeaconState, error) {
-	var err error
-
-	s, err = InitiateValidatorExitForTotalBal(ctx, s, slashedIdx, exitInfo, primitives.Gwei(exitInfo.TotalActiveBalance))
+	slashedIdx primitives.ValidatorIndex) (state.BeaconState, error) {
+	maxExitEpoch, churn := MaxExitEpochAndChurn(s)
+	s, _, err := InitiateValidatorExit(ctx, s, slashedIdx, maxExitEpoch, churn)
 	if err != nil && !errors.Is(err, ErrValidatorAlreadyExited) {
 		return nil, errors.Wrapf(err, "could not initiate validator %d exit", slashedIdx)
 	}

beacon-chain/core/validators/validator_test.go

@@ -49,11 +49,9 @@ func TestInitiateValidatorExit_AlreadyExited(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	exitInfo := &validators.ExitInfo{HighestExitEpoch: 199, Churn: 1}
-	newState, err := validators.InitiateValidatorExit(t.Context(), state, 0, exitInfo)
+	newState, epoch, err := validators.InitiateValidatorExit(t.Context(), state, 0, 199, 1)
 	require.ErrorIs(t, err, validators.ErrValidatorAlreadyExited)
-	assert.Equal(t, primitives.Epoch(199), exitInfo.HighestExitEpoch)
-	assert.Equal(t, uint64(1), exitInfo.Churn)
+	require.Equal(t, exitEpoch, epoch)
 	v, err := newState.ValidatorAtIndex(0)
 	require.NoError(t, err)
 	assert.Equal(t, exitEpoch, v.ExitEpoch, "Already exited")
@@ -70,11 +68,9 @@ func TestInitiateValidatorExit_ProperExit(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	exitInfo := &validators.ExitInfo{HighestExitEpoch: exitedEpoch + 2, Churn: 1}
-	newState, err := validators.InitiateValidatorExit(t.Context(), state, idx, exitInfo)
+	newState, epoch, err := validators.InitiateValidatorExit(t.Context(), state, idx, exitedEpoch+2, 1)
 	require.NoError(t, err)
-	assert.Equal(t, exitedEpoch+2, exitInfo.HighestExitEpoch)
-	assert.Equal(t, uint64(2), exitInfo.Churn)
+	require.Equal(t, exitedEpoch+2, epoch)
 	v, err := newState.ValidatorAtIndex(idx)
 	require.NoError(t, err)
 	assert.Equal(t, exitedEpoch+2, v.ExitEpoch, "Exit epoch was not the highest")
@@ -92,11 +88,9 @@ func TestInitiateValidatorExit_ChurnOverflow(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	exitInfo := &validators.ExitInfo{HighestExitEpoch: exitedEpoch + 2, Churn: 4}
-	newState, err := validators.InitiateValidatorExit(t.Context(), state, idx, exitInfo)
+	newState, epoch, err := validators.InitiateValidatorExit(t.Context(), state, idx, exitedEpoch+2, 4)
 	require.NoError(t, err)
-	assert.Equal(t, exitedEpoch+3, exitInfo.HighestExitEpoch)
-	assert.Equal(t, uint64(1), exitInfo.Churn)
+	require.Equal(t, exitedEpoch+3, epoch)
 
 	// Because of exit queue overflow,
 	// validator who init exited has to wait one more epoch.
@@ -116,8 +110,7 @@ func TestInitiateValidatorExit_WithdrawalOverflows(t *testing.T) {
 	}}
 	state, err := state_native.InitializeFromProtoPhase0(base)
 	require.NoError(t, err)
-	exitInfo := &validators.ExitInfo{HighestExitEpoch: params.BeaconConfig().FarFutureEpoch - 1, Churn: 1}
-	_, err = validators.InitiateValidatorExit(t.Context(), state, 1, exitInfo)
+	_, _, err = validators.InitiateValidatorExit(t.Context(), state, 1, params.BeaconConfig().FarFutureEpoch-1, 1)
 	require.ErrorContains(t, "addition overflows", err)
 }
 
@@ -153,11 +146,12 @@ func TestInitiateValidatorExit_ProperExit_Electra(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, primitives.Gwei(0), ebtc)
 
-	newState, err := validators.InitiateValidatorExit(t.Context(), state, idx, &validators.ExitInfo{}) // exit info is not used in electra
+	newState, epoch, err := validators.InitiateValidatorExit(t.Context(), state, idx, 0, 0) // exitQueueEpoch and churn are not used in electra
 	require.NoError(t, err)
 
 	// Expect that the exit epoch is the next available epoch with max seed lookahead.
 	want := helpers.ActivationExitEpoch(exitedEpoch + 1)
+	require.Equal(t, want, epoch)
 	v, err := newState.ValidatorAtIndex(idx)
 	require.NoError(t, err)
 	assert.Equal(t, want, v.ExitEpoch, "Exit epoch was not the highest")
@@ -196,7 +190,7 @@ func TestSlashValidator_OK(t *testing.T) {
 	require.NoError(t, err, "Could not get proposer")
 	proposerBal, err := state.BalanceAtIndex(proposer)
 	require.NoError(t, err)
-	slashedState, err := validators.SlashValidator(t.Context(), state, slashedIdx, validators.ExitInformation(state))
+	slashedState, err := validators.SlashValidator(t.Context(), state, slashedIdx)
 	require.NoError(t, err, "Could not slash validator")
 	require.Equal(t, true, slashedState.Version() == version.Phase0)
 
@@ -250,7 +244,7 @@ func TestSlashValidator_Electra(t *testing.T) {
 	require.NoError(t, err, "Could not get proposer")
 	proposerBal, err := state.BalanceAtIndex(proposer)
 	require.NoError(t, err)
-	slashedState, err := validators.SlashValidator(t.Context(), state, slashedIdx, validators.ExitInformation(state))
+	slashedState, err := validators.SlashValidator(t.Context(), state, slashedIdx)
 	require.NoError(t, err, "Could not slash validator")
 	require.Equal(t, true, slashedState.Version() == version.Electra)
 
@@ -511,8 +505,8 @@ func TestValidatorMaxExitEpochAndChurn(t *testing.T) {
 	for _, tt := range tests {
 		s, err := state_native.InitializeFromProtoPhase0(tt.state)
 		require.NoError(t, err)
-		exitInfo := validators.ExitInformation(s)
-		require.Equal(t, tt.wantedEpoch, exitInfo.HighestExitEpoch)
-		require.Equal(t, tt.wantedChurn, exitInfo.Churn)
+		epoch, churn := validators.MaxExitEpochAndChurn(s)
+		require.Equal(t, tt.wantedEpoch, epoch)
+		require.Equal(t, tt.wantedChurn, churn)
 	}
 }

beacon-chain/das/BUILD.bazel

@@ -4,6 +4,7 @@ go_library(
     name = "go_default_library",
     srcs = [
         "availability_blobs.go",
+        "availability_columns.go",
         "blob_cache.go",
         "data_column_cache.go",
         "iface.go",
@@ -12,6 +13,7 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/das",
     visibility = ["//visibility:public"],
     deps = [
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -21,6 +23,7 @@ go_library(
         "//runtime/logging:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],
@@ -30,6 +33,7 @@ go_test(
     name = "go_default_test",
     srcs = [
         "availability_blobs_test.go",
+        "availability_columns_test.go",
         "blob_cache_test.go",
         "data_column_cache_test.go",
     ],
@@ -45,6 +49,7 @@ go_test(
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time/slots:go_default_library",
+        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )

beacon-chain/das/availability_blobs.go

@@ -53,25 +53,30 @@ func NewLazilyPersistentStore(store *filesystem.BlobStorage, verifier BlobBatchV
 // Persist adds blobs to the working blob cache. Blobs stored in this cache will be persisted
 // for at least as long as the node is running. Once IsDataAvailable succeeds, all blobs referenced
 // by the given block are guaranteed to be persisted for the remainder of the retention period.
-func (s *LazilyPersistentStoreBlob) Persist(current primitives.Slot, sidecars ...blocks.ROBlob) error {
+func (s *LazilyPersistentStoreBlob) Persist(current primitives.Slot, sidecars ...blocks.ROSidecar) error {
 	if len(sidecars) == 0 {
 		return nil
 	}
 
-	if len(sidecars) > 1 {
-		firstRoot := sidecars[0].BlockRoot()
-		for _, sidecar := range sidecars[1:] {
+	blobSidecars, err := blocks.BlobSidecarsFromSidecars(sidecars)
+	if err != nil {
+		return errors.Wrap(err, "blob sidecars from sidecars")
+	}
+
+	if len(blobSidecars) > 1 {
+		firstRoot := blobSidecars[0].BlockRoot()
+		for _, sidecar := range blobSidecars[1:] {
 			if sidecar.BlockRoot() != firstRoot {
 				return errMixedRoots
 			}
 		}
 	}
-	if !params.WithinDAPeriod(slots.ToEpoch(sidecars[0].Slot()), slots.ToEpoch(current)) {
+	if !params.WithinDAPeriod(slots.ToEpoch(blobSidecars[0].Slot()), slots.ToEpoch(current)) {
 		return nil
 	}
-	key := keyFromSidecar(sidecars[0])
+	key := keyFromSidecar(blobSidecars[0])
 	entry := s.cache.ensure(key)
-	for _, blobSidecar := range sidecars {
+	for _, blobSidecar := range blobSidecars {
 		if err := entry.stash(&blobSidecar); err != nil {
 			return err
 		}

beacon-chain/das/availability_blobs_test.go

@@ -118,21 +118,23 @@ func TestLazilyPersistent_Missing(t *testing.T) {
 
 	blk, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 3)
 
+	scs := blocks.NewSidecarsFromBlobSidecars(blobSidecars)
+
 	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(1, blobSidecars[2]))
+	require.NoError(t, as.Persist(1, scs[2]))
 	err := as.IsDataAvailable(ctx, 1, blk)
 	require.ErrorIs(t, err, errMissingSidecar)
 
 	// All but one persisted, return missing idx
-	require.NoError(t, as.Persist(1, blobSidecars[0]))
+	require.NoError(t, as.Persist(1, scs[0]))
 	err = as.IsDataAvailable(ctx, 1, blk)
 	require.ErrorIs(t, err, errMissingSidecar)
 
 	// All persisted, return nil
-	require.NoError(t, as.Persist(1, blobSidecars...))
+	require.NoError(t, as.Persist(1, scs...))
 
 	require.NoError(t, as.IsDataAvailable(ctx, 1, blk))
 }
@@ -147,8 +149,10 @@ func TestLazilyPersistent_Mismatch(t *testing.T) {
 	blobSidecars[0].KzgCommitment = bytesutil.PadTo([]byte("nope"), 48)
 	as := NewLazilyPersistentStore(store, mbv)
 
+	scs := blocks.NewSidecarsFromBlobSidecars(blobSidecars)
+
 	// Only one commitment persisted, should return error with other indices
-	require.NoError(t, as.Persist(1, blobSidecars[0]))
+	require.NoError(t, as.Persist(1, scs[0]))
 	err := as.IsDataAvailable(ctx, 1, blk)
 	require.NotNil(t, err)
 	require.ErrorIs(t, err, errCommitmentMismatch)
@@ -157,25 +161,29 @@ func TestLazilyPersistent_Mismatch(t *testing.T) {
 func TestLazyPersistOnceCommitted(t *testing.T) {
 	_, blobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 6)
 
+	scs := blocks.NewSidecarsFromBlobSidecars(blobSidecars)
+
 	as := NewLazilyPersistentStore(filesystem.NewEphemeralBlobStorage(t), &mockBlobBatchVerifier{})
 	// stashes as expected
-	require.NoError(t, as.Persist(1, blobSidecars...))
+	require.NoError(t, as.Persist(1, scs...))
 	// ignores duplicates
-	require.ErrorIs(t, as.Persist(1, blobSidecars...), ErrDuplicateSidecar)
+	require.ErrorIs(t, as.Persist(1, scs...), ErrDuplicateSidecar)
 
 	// ignores index out of bound
 	blobSidecars[0].Index = 6
-	require.ErrorIs(t, as.Persist(1, blobSidecars[0]), errIndexOutOfBounds)
+	require.ErrorIs(t, as.Persist(1, blocks.NewSidecarFromBlobSidecar(blobSidecars[0])), errIndexOutOfBounds)
 
 	_, moreBlobSidecars := util.GenerateTestDenebBlockWithSidecar(t, [32]byte{}, 1, 4)
 
+	more := blocks.NewSidecarsFromBlobSidecars(moreBlobSidecars)
+
 	// ignores sidecars before the retention period
 	slotOOB, err := slots.EpochStart(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest)
 	require.NoError(t, err)
-	require.NoError(t, as.Persist(32+slotOOB, moreBlobSidecars[0]))
+	require.NoError(t, as.Persist(32+slotOOB, more[0]))
 
 	// doesn't ignore new sidecars with a different block root
-	require.NoError(t, as.Persist(1, moreBlobSidecars...))
+	require.NoError(t, as.Persist(1, more...))
 }
 
 type mockBlobBatchVerifier struct {

beacon-chain/das/availability_columns.go

@@ -0,0 +1,213 @@
+package das
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/ethereum/go-ethereum/p2p/enode"
+	errors "github.com/pkg/errors"
+)
+
+// LazilyPersistentStoreColumn is an implementation of AvailabilityStore to be used when batch syncing data columns.
+// This implementation will hold any data columns passed to Persist until the IsDataAvailable is called for their
+// block, at which time they will undergo full verification and be saved to the disk.
+type LazilyPersistentStoreColumn struct {
+	store                  *filesystem.DataColumnStorage
+	nodeID                 enode.ID
+	cache                  *dataColumnCache
+	newDataColumnsVerifier verification.NewDataColumnsVerifier
+	custodyGroupCount      uint64
+}
+
+var _ AvailabilityStore = &LazilyPersistentStoreColumn{}
+
+// DataColumnsVerifier enables LazilyPersistentStoreColumn to manage the verification process
+// going from RODataColumn->VerifiedRODataColumn, while avoiding the decision of which individual verifications
+// to run and in what order. Since LazilyPersistentStoreColumn always tries to verify and save data columns only when
+// they are all available, the interface takes a slice of data column sidecars.
+type DataColumnsVerifier interface {
+	VerifiedRODataColumns(ctx context.Context, blk blocks.ROBlock, scs []blocks.RODataColumn) ([]blocks.VerifiedRODataColumn, error)
+}
+
+// NewLazilyPersistentStoreColumn creates a new LazilyPersistentStoreColumn.
+// WARNING: The resulting LazilyPersistentStoreColumn is NOT thread-safe.
+func NewLazilyPersistentStoreColumn(
+	store *filesystem.DataColumnStorage,
+	nodeID enode.ID,
+	newDataColumnsVerifier verification.NewDataColumnsVerifier,
+	custodyGroupCount uint64,
+) *LazilyPersistentStoreColumn {
+	return &LazilyPersistentStoreColumn{
+		store:                  store,
+		nodeID:                 nodeID,
+		cache:                  newDataColumnCache(),
+		newDataColumnsVerifier: newDataColumnsVerifier,
+		custodyGroupCount:      custodyGroupCount,
+	}
+}
+
+// PersistColumns adds columns to the working column cache. Columns stored in this cache will be persisted
+// for at least as long as the node is running. Once IsDataAvailable succeeds, all columns referenced
+// by the given block are guaranteed to be persisted for the remainder of the retention period.
+func (s *LazilyPersistentStoreColumn) Persist(current primitives.Slot, sidecars ...blocks.ROSidecar) error {
+	if len(sidecars) == 0 {
+		return nil
+	}
+
+	dataColumnSidecars, err := blocks.DataColumnSidecarsFromSidecars(sidecars)
+	if err != nil {
+		return errors.Wrap(err, "blob sidecars from sidecars")
+	}
+
+	// It is safe to retrieve the first sidecar.
+	firstSidecar := dataColumnSidecars[0]
+
+	if len(sidecars) > 1 {
+		firstRoot := firstSidecar.BlockRoot()
+		for _, sidecar := range dataColumnSidecars[1:] {
+			if sidecar.BlockRoot() != firstRoot {
+				return errMixedRoots
+			}
+		}
+	}
+
+	firstSidecarEpoch, currentEpoch := slots.ToEpoch(firstSidecar.Slot()), slots.ToEpoch(current)
+	if !params.WithinDAPeriod(firstSidecarEpoch, currentEpoch) {
+		return nil
+	}
+
+	key := cacheKey{slot: firstSidecar.Slot(), root: firstSidecar.BlockRoot()}
+	entry := s.cache.ensure(key)
+
+	for _, sidecar := range dataColumnSidecars {
+		if err := entry.stash(&sidecar); err != nil {
+			return errors.Wrap(err, "stash DataColumnSidecar")
+		}
+	}
+
+	return nil
+}
+
+// IsDataAvailable returns nil if all the commitments in the given block are persisted to the db and have been verified.
+// DataColumnsSidecars already in the db are assumed to have been previously verified against the block.
+func (s *LazilyPersistentStoreColumn) IsDataAvailable(ctx context.Context, currentSlot primitives.Slot, block blocks.ROBlock) error {
+	blockCommitments, err := s.fullCommitmentsToCheck(s.nodeID, block, currentSlot)
+	if err != nil {
+		return errors.Wrapf(err, "full commitments to check with block root `%#x` and current slot `%d`", block.Root(), currentSlot)
+	}
+
+	// Return early for blocks that do not have any commitments.
+	if blockCommitments.count() == 0 {
+		return nil
+	}
+
+	// Get the root of the block.
+	blockRoot := block.Root()
+
+	// Build the cache key for the block.
+	key := cacheKey{slot: block.Block().Slot(), root: blockRoot}
+
+	// Retrieve the cache entry for the block, or create an empty one if it doesn't exist.
+	entry := s.cache.ensure(key)
+
+	// Delete the cache entry for the block at the end.
+	defer s.cache.delete(key)
+
+	// Set the disk summary for the block in the cache entry.
+	entry.setDiskSummary(s.store.Summary(blockRoot))
+
+	// Verify we have all the expected sidecars, and fail fast if any are missing or inconsistent.
+	// We don't try to salvage problematic batches because this indicates a misbehaving peer and we'd rather
+	// ignore their response and decrease their peer score.
+	roDataColumns, err := entry.filter(blockRoot, blockCommitments)
+	if err != nil {
+		return errors.Wrap(err, "entry filter")
+	}
+
+	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#datacolumnsidecarsbyrange-v1
+	verifier := s.newDataColumnsVerifier(roDataColumns, verification.ByRangeRequestDataColumnSidecarRequirements)
+
+	if err := verifier.ValidFields(); err != nil {
+		return errors.Wrap(err, "valid fields")
+	}
+
+	if err := verifier.SidecarInclusionProven(); err != nil {
+		return errors.Wrap(err, "sidecar inclusion proven")
+	}
+
+	if err := verifier.SidecarKzgProofVerified(); err != nil {
+		return errors.Wrap(err, "sidecar KZG proof verified")
+	}
+
+	verifiedRoDataColumns, err := verifier.VerifiedRODataColumns()
+	if err != nil {
+		return errors.Wrap(err, "verified RO data columns - should never happen")
+	}
+
+	if err := s.store.Save(verifiedRoDataColumns); err != nil {
+		return errors.Wrap(err, "save data column sidecars")
+	}
+
+	return nil
+}
+
+// fullCommitmentsToCheck returns the commitments to check for a given block.
+func (s *LazilyPersistentStoreColumn) fullCommitmentsToCheck(nodeID enode.ID, block blocks.ROBlock, currentSlot primitives.Slot) (*safeCommitmentsArray, error) {
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+
+	// Return early for blocks that are pre-Fulu.
+	if block.Version() < version.Fulu {
+		return &safeCommitmentsArray{}, nil
+	}
+
+	// Compute the block epoch.
+	blockSlot := block.Block().Slot()
+	blockEpoch := slots.ToEpoch(blockSlot)
+
+	// Compute the current epoch.
+	currentEpoch := slots.ToEpoch(currentSlot)
+
+	// Return early if the request is out of the MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS window.
+	if !params.WithinDAPeriod(blockEpoch, currentEpoch) {
+		return &safeCommitmentsArray{}, nil
+	}
+
+	// Retrieve the KZG commitments for the block.
+	kzgCommitments, err := block.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return nil, errors.Wrap(err, "blob KZG commitments")
+	}
+
+	// Return early if there are no commitments in the block.
+	if len(kzgCommitments) == 0 {
+		return &safeCommitmentsArray{}, nil
+	}
+
+	// Retrieve peer info.
+	samplingSize := max(s.custodyGroupCount, samplesPerSlot)
+	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
+	if err != nil {
+		return nil, errors.Wrap(err, "peer info")
+	}
+
+	// Create a safe commitments array for the custody columns.
+	commitmentsArray := &safeCommitmentsArray{}
+	commitmentsArraySize := uint64(len(commitmentsArray))
+
+	for column := range peerInfo.CustodyColumns {
+		if column >= commitmentsArraySize {
+			return nil, errors.Errorf("custody column index %d too high (max allowed %d) - should never happen", column, commitmentsArraySize)
+		}
+
+		commitmentsArray[column] = kzgCommitments
+	}
+
+	return commitmentsArray, nil
+}

beacon-chain/das/availability_columns_test.go

@@ -0,0 +1,313 @@
+package das
+
+import (
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
+	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"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/ethereum/go-ethereum/p2p/enode"
+)
+
+var commitments = [][]byte{
+	bytesutil.PadTo([]byte("a"), 48),
+	bytesutil.PadTo([]byte("b"), 48),
+	bytesutil.PadTo([]byte("c"), 48),
+	bytesutil.PadTo([]byte("d"), 48),
+}
+
+func TestPersist(t *testing.T) {
+	t.Run("no sidecars", func(t *testing.T) {
+		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+		err := lazilyPersistentStoreColumns.Persist(0)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(lazilyPersistentStoreColumns.cache.entries))
+	})
+
+	t.Run("mixed roots", func(t *testing.T) {
+		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+
+		dataColumnParamsByBlockRoot := []util.DataColumnParam{
+			{Slot: 1, Index: 1},
+			{Slot: 2, Index: 2},
+		}
+
+		roSidecars, _ := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+
+		err := lazilyPersistentStoreColumns.Persist(0, roSidecars...)
+		require.ErrorIs(t, err, errMixedRoots)
+		require.Equal(t, 0, len(lazilyPersistentStoreColumns.cache.entries))
+	})
+
+	t.Run("outside DA period", func(t *testing.T) {
+		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+
+		dataColumnParamsByBlockRoot := []util.DataColumnParam{
+			{Slot: 1, Index: 1},
+		}
+
+		roSidecars, _ := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+
+		err := lazilyPersistentStoreColumns.Persist(1_000_000, roSidecars...)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(lazilyPersistentStoreColumns.cache.entries))
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		const slot = 42
+		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+
+		dataColumnParamsByBlockRoot := []util.DataColumnParam{
+			{Slot: slot, Index: 1},
+			{Slot: slot, Index: 5},
+		}
+
+		roSidecars, roDataColumns := roSidecarsFromDataColumnParamsByBlockRoot(t, dataColumnParamsByBlockRoot)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, nil, 0)
+
+		err := lazilyPersistentStoreColumns.Persist(slot, roSidecars...)
+		require.NoError(t, err)
+		require.Equal(t, 1, len(lazilyPersistentStoreColumns.cache.entries))
+
+		key := cacheKey{slot: slot, root: roDataColumns[0].BlockRoot()}
+		entry, ok := lazilyPersistentStoreColumns.cache.entries[key]
+		require.Equal(t, true, ok)
+
+		// A call to Persist does NOT save the sidecars to disk.
+		require.Equal(t, uint64(0), entry.diskSummary.Count())
+
+		require.DeepSSZEqual(t, roDataColumns[0], *entry.scs[1])
+		require.DeepSSZEqual(t, roDataColumns[1], *entry.scs[5])
+
+		for i, roDataColumn := range entry.scs {
+			if map[int]bool{1: true, 5: true}[i] {
+				continue
+			}
+
+			require.IsNil(t, roDataColumn)
+		}
+	})
+}
+
+func TestIsDataAvailable(t *testing.T) {
+	newDataColumnsVerifier := func(dataColumnSidecars []blocks.RODataColumn, _ []verification.Requirement) verification.DataColumnsVerifier {
+		return &mockDataColumnsVerifier{t: t, dataColumnSidecars: dataColumnSidecars}
+	}
+
+	ctx := t.Context()
+
+	t.Run("without commitments", func(t *testing.T) {
+		signedBeaconBlockFulu := util.NewBeaconBlockFulu()
+		signedRoBlock := newSignedRoBlock(t, signedBeaconBlockFulu)
+
+		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, 0)
+
+		err := lazilyPersistentStoreColumns.IsDataAvailable(ctx, 0 /*current slot*/, signedRoBlock)
+		require.NoError(t, err)
+	})
+
+	t.Run("with commitments", func(t *testing.T) {
+		signedBeaconBlockFulu := util.NewBeaconBlockFulu()
+		signedBeaconBlockFulu.Block.Body.BlobKzgCommitments = commitments
+		signedRoBlock := newSignedRoBlock(t, signedBeaconBlockFulu)
+		block := signedRoBlock.Block()
+		slot := block.Slot()
+		proposerIndex := block.ProposerIndex()
+		parentRoot := block.ParentRoot()
+		stateRoot := block.StateRoot()
+		bodyRoot, err := block.Body().HashTreeRoot()
+		require.NoError(t, err)
+
+		root := signedRoBlock.Root()
+
+		dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+		lazilyPersistentStoreColumns := NewLazilyPersistentStoreColumn(dataColumnStorage, enode.ID{}, newDataColumnsVerifier, 0)
+
+		indices := [...]uint64{1, 17, 19, 42, 75, 87, 102, 117}
+		dataColumnsParams := make([]util.DataColumnParam, 0, len(indices))
+		for _, index := range indices {
+			dataColumnParams := util.DataColumnParam{
+				Index:          index,
+				KzgCommitments: commitments,
+
+				Slot:          slot,
+				ProposerIndex: proposerIndex,
+				ParentRoot:    parentRoot[:],
+				StateRoot:     stateRoot[:],
+				BodyRoot:      bodyRoot[:],
+			}
+
+			dataColumnsParams = append(dataColumnsParams, dataColumnParams)
+		}
+
+		_, verifiedRoDataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnsParams)
+
+		key := cacheKey{root: root}
+		entry := lazilyPersistentStoreColumns.cache.ensure(key)
+		defer lazilyPersistentStoreColumns.cache.delete(key)
+
+		for _, verifiedRoDataColumn := range verifiedRoDataColumns {
+			err := entry.stash(&verifiedRoDataColumn.RODataColumn)
+			require.NoError(t, err)
+		}
+
+		err = lazilyPersistentStoreColumns.IsDataAvailable(ctx, slot, signedRoBlock)
+		require.NoError(t, err)
+
+		actual, err := dataColumnStorage.Get(root, indices[:])
+		require.NoError(t, err)
+
+		summary := dataColumnStorage.Summary(root)
+		require.Equal(t, uint64(len(indices)), summary.Count())
+		require.DeepSSZEqual(t, verifiedRoDataColumns, actual)
+	})
+}
+
+func TestFullCommitmentsToCheck(t *testing.T) {
+	windowSlots, err := slots.EpochEnd(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
+	require.NoError(t, err)
+
+	testCases := []struct {
+		name        string
+		commitments [][]byte
+		block       func(*testing.T) blocks.ROBlock
+		slot        primitives.Slot
+	}{
+		{
+			name: "Pre-Fulu block",
+			block: func(t *testing.T) blocks.ROBlock {
+				return newSignedRoBlock(t, util.NewBeaconBlockElectra())
+			},
+		},
+		{
+			name: "Commitments outside data availability window",
+			block: func(t *testing.T) blocks.ROBlock {
+				beaconBlockElectra := util.NewBeaconBlockElectra()
+
+				// Block is from slot 0, "current slot" is window size +1 (so outside the window)
+				beaconBlockElectra.Block.Body.BlobKzgCommitments = commitments
+
+				return newSignedRoBlock(t, beaconBlockElectra)
+			},
+			slot: windowSlots + 1,
+		},
+		{
+			name: "Commitments within data availability window",
+			block: func(t *testing.T) blocks.ROBlock {
+				signedBeaconBlockFulu := util.NewBeaconBlockFulu()
+				signedBeaconBlockFulu.Block.Body.BlobKzgCommitments = commitments
+				signedBeaconBlockFulu.Block.Slot = 100
+
+				return newSignedRoBlock(t, signedBeaconBlockFulu)
+			},
+			commitments: commitments,
+			slot:        100,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+			b := tc.block(t)
+			s := NewLazilyPersistentStoreColumn(nil, enode.ID{}, nil, numberOfColumns)
+
+			commitmentsArray, err := s.fullCommitmentsToCheck(enode.ID{}, b, tc.slot)
+			require.NoError(t, err)
+
+			for _, commitments := range commitmentsArray {
+				require.DeepEqual(t, tc.commitments, commitments)
+			}
+		})
+	}
+}
+
+func roSidecarsFromDataColumnParamsByBlockRoot(t *testing.T, parameters []util.DataColumnParam) ([]blocks.ROSidecar, []blocks.RODataColumn) {
+	roDataColumns, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, parameters)
+
+	roSidecars := make([]blocks.ROSidecar, 0, len(roDataColumns))
+	for _, roDataColumn := range roDataColumns {
+		roSidecars = append(roSidecars, blocks.NewSidecarFromDataColumnSidecar(roDataColumn))
+	}
+
+	return roSidecars, roDataColumns
+}
+
+func newSignedRoBlock(t *testing.T, signedBeaconBlock interface{}) blocks.ROBlock {
+	sb, err := blocks.NewSignedBeaconBlock(signedBeaconBlock)
+	require.NoError(t, err)
+
+	rb, err := blocks.NewROBlock(sb)
+	require.NoError(t, err)
+
+	return rb
+}
+
+type mockDataColumnsVerifier struct {
+	t                                                                        *testing.T
+	dataColumnSidecars                                                       []blocks.RODataColumn
+	validCalled, SidecarInclusionProvenCalled, SidecarKzgProofVerifiedCalled bool
+}
+
+var _ verification.DataColumnsVerifier = &mockDataColumnsVerifier{}
+
+func (m *mockDataColumnsVerifier) VerifiedRODataColumns() ([]blocks.VerifiedRODataColumn, error) {
+	require.Equal(m.t, true, m.validCalled && m.SidecarInclusionProvenCalled && m.SidecarKzgProofVerifiedCalled)
+
+	verifiedDataColumnSidecars := make([]blocks.VerifiedRODataColumn, 0, len(m.dataColumnSidecars))
+	for _, dataColumnSidecar := range m.dataColumnSidecars {
+		verifiedDataColumnSidecar := blocks.NewVerifiedRODataColumn(dataColumnSidecar)
+		verifiedDataColumnSidecars = append(verifiedDataColumnSidecars, verifiedDataColumnSidecar)
+	}
+
+	return verifiedDataColumnSidecars, nil
+}
+
+func (m *mockDataColumnsVerifier) SatisfyRequirement(verification.Requirement) {}
+
+func (m *mockDataColumnsVerifier) ValidFields() error {
+	m.validCalled = true
+	return nil
+}
+
+func (m *mockDataColumnsVerifier) CorrectSubnet(dataColumnSidecarSubTopic string, expectedTopics []string) error {
+	return nil
+}
+func (m *mockDataColumnsVerifier) NotFromFutureSlot() error                         { return nil }
+func (m *mockDataColumnsVerifier) SlotAboveFinalized() error                        { return nil }
+func (m *mockDataColumnsVerifier) ValidProposerSignature(ctx context.Context) error { return nil }
+
+func (m *mockDataColumnsVerifier) SidecarParentSeen(parentSeen func([fieldparams.RootLength]byte) bool) error {
+	return nil
+}
+
+func (m *mockDataColumnsVerifier) SidecarParentValid(badParent func([fieldparams.RootLength]byte) bool) error {
+	return nil
+}
+
+func (m *mockDataColumnsVerifier) SidecarParentSlotLower() error       { return nil }
+func (m *mockDataColumnsVerifier) SidecarDescendsFromFinalized() error { return nil }
+
+func (m *mockDataColumnsVerifier) SidecarInclusionProven() error {
+	m.SidecarInclusionProvenCalled = true
+	return nil
+}
+
+func (m *mockDataColumnsVerifier) SidecarKzgProofVerified() error {
+	m.SidecarKzgProofVerifiedCalled = true
+	return nil
+}
+
+func (m *mockDataColumnsVerifier) SidecarProposerExpected(ctx context.Context) error { return nil }

beacon-chain/das/blob_cache.go

@@ -99,26 +99,20 @@ func (e *blobCacheEntry) filter(root [32]byte, kc [][]byte, slot primitives.Slot
 		if e.diskSummary.HasIndex(i) {
 			continue
 		}
-		// Check if e.scs has this index before accessing
-		var sidecar *blocks.ROBlob
-		if i < uint64(len(e.scs)) {
-			sidecar = e.scs[i]
-		}
-
 		if kc[i] == nil {
-			if sidecar != nil {
-				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, sidecar.KzgCommitment)
+			if e.scs[i] != nil {
+				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, e.scs[i].KzgCommitment)
 			}
 			continue
 		}
 
-		if sidecar == nil {
+		if e.scs[i] == nil {
 			return nil, errors.Wrapf(errMissingSidecar, "root=%#x, index=%#x", root, i)
 		}
-		if !bytes.Equal(kc[i], sidecar.KzgCommitment) {
-			return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, block commitment=%#x", root, i, sidecar.KzgCommitment, kc[i])
+		if !bytes.Equal(kc[i], e.scs[i].KzgCommitment) {
+			return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, block commitment=%#x", root, i, e.scs[i].KzgCommitment, kc[i])
 		}
-		scs = append(scs, *sidecar)
+		scs = append(scs, *e.scs[i])
 	}
 
 	return scs, nil

beacon-chain/das/blob_cache_test.go

@@ -155,41 +155,6 @@ func TestFilter(t *testing.T) {
 			},
 			err: errCommitmentMismatch,
 		},
-		{
-			name: "empty scs array with commitments",
-			setup: func(t *testing.T) (*blobCacheEntry, [][]byte, []blocks.ROBlob) {
-				// This reproduces the panic condition where entry.scs is empty or nil
-				// but we have commitments to check
-				entry := &blobCacheEntry{
-					scs: nil, // Empty/nil array that caused the panic
-				}
-				// Create a commitment that would trigger the check at index 0
-				commits := [][]byte{
-					bytesutil.PadTo([]byte("commitment1"), 48),
-				}
-				return entry, commits, nil
-			},
-			err: errMissingSidecar,
-		},
-		{
-			name: "scs array shorter than commitments",
-			setup: func(t *testing.T) (*blobCacheEntry, [][]byte, []blocks.ROBlob) {
-				// This reproduces the condition where entry.scs exists but is shorter
-				// than the number of commitments we're checking
-				entry := &blobCacheEntry{
-					scs: make([]*blocks.ROBlob, 2), // Only 2 slots
-				}
-				// Create 4 commitments, accessing index 2 and 3 would have panicked
-				commits := [][]byte{
-					nil,
-					nil,
-					bytesutil.PadTo([]byte("commitment3"), 48),
-					bytesutil.PadTo([]byte("commitment4"), 48),
-				}
-				return entry, commits, nil
-			},
-			err: errMissingSidecar,
-		},
 	}
 	for _, c := range cases {
 		t.Run(c.name, func(t *testing.T) {

beacon-chain/das/iface.go

@@ -15,5 +15,5 @@ import (
 // durably persisted before returning a non-error value.
 type AvailabilityStore interface {
 	IsDataAvailable(ctx context.Context, current primitives.Slot, b blocks.ROBlock) error
-	Persist(current primitives.Slot, blobSidecar ...blocks.ROBlob) error
+	Persist(current primitives.Slot, sc ...blocks.ROSidecar) error
 }

beacon-chain/das/mock.go

@@ -5,12 +5,13 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	errors "github.com/pkg/errors"
 )
 
 // MockAvailabilityStore is an implementation of AvailabilityStore that can be used by other packages in tests.
 type MockAvailabilityStore struct {
 	VerifyAvailabilityCallback func(ctx context.Context, current primitives.Slot, b blocks.ROBlock) error
-	PersistBlobsCallback       func(current primitives.Slot, blobSidecar ...blocks.ROBlob) error
+	PersistBlobsCallback       func(current primitives.Slot, sc ...blocks.ROBlob) error
 }
 
 var _ AvailabilityStore = &MockAvailabilityStore{}
@@ -24,9 +25,13 @@ func (m *MockAvailabilityStore) IsDataAvailable(ctx context.Context, current pri
 }
 
 // Persist satisfies the corresponding method of the AvailabilityStore interface in a way that is useful for tests.
-func (m *MockAvailabilityStore) Persist(current primitives.Slot, blobSidecar ...blocks.ROBlob) error {
+func (m *MockAvailabilityStore) Persist(current primitives.Slot, sc ...blocks.ROSidecar) error {
+	blobSidecars, err := blocks.BlobSidecarsFromSidecars(sc)
+	if err != nil {
+		return errors.Wrap(err, "blob sidecars from sidecars")
+	}
 	if m.PersistBlobsCallback != nil {
-		return m.PersistBlobsCallback(current, blobSidecar...)
+		return m.PersistBlobsCallback(current, blobSidecars...)
 	}
 	return nil
 }

beacon-chain/db/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//cmd/beacon-chain:__subpackages__",
-        "//genesis:__subpackages__",
         "//testing/slasher/simulator:__pkg__",
         "//tools:__subpackages__",
     ],

beacon-chain/db/filesystem/data_column.go

@@ -100,14 +100,6 @@ type (
 	}
 )
 
-// DataColumnStorageReader is an interface to read data column sidecars from the filesystem.
-type DataColumnStorageReader interface {
-	Summary(root [fieldparams.RootLength]byte) DataColumnStorageSummary
-	Get(root [fieldparams.RootLength]byte, indices []uint64) ([]blocks.VerifiedRODataColumn, error)
-}
-
-var _ DataColumnStorageReader = &DataColumnStorage{}
-
 // WithDataColumnBasePath is a required option that sets the base path of data column storage.
 func WithDataColumnBasePath(base string) DataColumnStorageOption {
 	return func(b *DataColumnStorage) error {

beacon-chain/db/filesystem/data_column_cache.go

@@ -84,6 +84,12 @@ func (s DataColumnStorageSummary) Stored() map[uint64]bool {
 	return stored
 }
 
+// DataColumnStorageSummarizer can be used to receive a summary of metadata about data columns on disk for a given root.
+// The DataColumnStorageSummary can be used to check which indices (if any) are available for a given block by root.
+type DataColumnStorageSummarizer interface {
+	Summary(root [fieldparams.RootLength]byte) DataColumnStorageSummary
+}
+
 type dataColumnStorageSummaryCache struct {
 	mu                 sync.RWMutex
 	dataColumnCount    float64
@@ -92,6 +98,8 @@ type dataColumnStorageSummaryCache struct {
 	cache              map[[fieldparams.RootLength]byte]DataColumnStorageSummary
 }
 
+var _ DataColumnStorageSummarizer = &dataColumnStorageSummaryCache{}
+
 func newDataColumnStorageSummaryCache() *dataColumnStorageSummaryCache {
 	return &dataColumnStorageSummaryCache{
 		cache:             make(map[[fieldparams.RootLength]byte]DataColumnStorageSummary),

beacon-chain/db/filesystem/layout_by_epoch.go

@@ -116,43 +116,19 @@ func (l *periodicEpochLayout) pruneBefore(before primitives.Epoch) (*pruneSummar
 	}
 	// Roll up summaries and clean up per-epoch directories.
 	rollup := &pruneSummary{}
-
-	// Track which period directories might be empty after epoch removal
-	periodsToCheck := make(map[string]struct{})
-
 	for epoch, sum := range sums {
 		rollup.blobsPruned += sum.blobsPruned
 		rollup.failedRemovals = append(rollup.failedRemovals, sum.failedRemovals...)
 		rmdir := l.epochDir(epoch)
-		periodDir := l.periodDir(epoch)
-
 		if len(sum.failedRemovals) == 0 {
 			if err := l.fs.Remove(rmdir); err != nil {
 				log.WithField("dir", rmdir).WithError(err).Error("Failed to remove epoch directory while pruning")
-			} else {
-				periodsToCheck[periodDir] = struct{}{}
 			}
 		} else {
 			log.WithField("dir", rmdir).WithField("numFailed", len(sum.failedRemovals)).WithError(err).Error("Unable to remove epoch directory due to pruning failures")
 		}
 	}
 
-	//Clean up empty period directories
-	for periodDir := range periodsToCheck {
-		entries, err := afero.ReadDir(l.fs, periodDir)
-		if err != nil {
-			log.WithField("dir", periodDir).WithError(err).Debug("Failed to read period directory contents")
-			continue
-		}
-
-		// Only attempt to remove if directory is empty
-		if len(entries) == 0 {
-			if err := l.fs.Remove(periodDir); err != nil {
-				log.WithField("dir", periodDir).WithError(err).Error("Failed to remove empty period directory")
-			}
-		}
-	}
-
 	return rollup, nil
 }
 

beacon-chain/db/filesystem/mock.go

@@ -144,3 +144,14 @@ func NewEphemeralDataColumnStorageWithMocker(t testing.TB) (*DataColumnMocker, *
 	fs, dcs := NewEphemeralDataColumnStorageAndFs(t)
 	return &DataColumnMocker{fs: fs, dcs: dcs}, dcs
 }
+
+func NewMockDataColumnStorageSummarizer(t *testing.T, set map[[fieldparams.RootLength]byte][]uint64) DataColumnStorageSummarizer {
+	c := newDataColumnStorageSummaryCache()
+	for root, indices := range set {
+		if err := c.set(DataColumnsIdent{Root: root, Epoch: 0, Indices: indices}); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	return c
+}

beacon-chain/db/filesystem/pruner_test.go

@@ -4,7 +4,6 @@ import (
 	"encoding/binary"
 	"os"
 	"testing"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -196,48 +195,3 @@ func TestLayoutPruneBefore(t *testing.T) {
 		})
 	}
 }
-
-func TestLayoutByEpochPruneBefore(t *testing.T) {
-	roots := testRoots(10)
-	cases := []struct {
-		name   string
-		pruned []testIdent
-		remain []testIdent
-		err    error
-		sum    pruneSummary
-	}{
-		{
-			name: "single epoch period cleanup",
-			pruned: []testIdent{
-				{offset: 0, blobIdent: blobIdent{root: roots[0], epoch: 367076, index: 0}},
-			},
-			remain: []testIdent{
-				{offset: 0, blobIdent: blobIdent{root: roots[1], epoch: 371176, index: 0}}, // Different period
-			},
-			sum: pruneSummary{blobsPruned: 1},
-		},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			fs, bs := NewEphemeralBlobStorageAndFs(t, WithLayout(LayoutNameByEpoch))
-			pruned := testSetupBlobIdentPaths(t, fs, bs, c.pruned)
-			remain := testSetupBlobIdentPaths(t, fs, bs, c.remain)
-
-			time.Sleep(1 * time.Second)
-			for _, id := range pruned {
-				_, err := fs.Stat(bs.layout.sszPath(id))
-				require.Equal(t, true, os.IsNotExist(err))
-
-				dirs := bs.layout.blockParentDirs(id)
-				for i := len(dirs) - 1; i > 0; i-- {
-					_, err = fs.Stat(dirs[i])
-					require.Equal(t, true, os.IsNotExist(err))
-				}
-			}
-			for _, id := range remain {
-				_, err := fs.Stat(bs.layout.sszPath(id))
-				require.NoError(t, err)
-			}
-		})
-	}
-}

beacon-chain/db/iface/interface.go

@@ -115,17 +115,6 @@ type NoHeadAccessDatabase interface {
 	CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint primitives.Slot) error
 	DeleteHistoricalDataBeforeSlot(ctx context.Context, slot primitives.Slot, batchSize int) (int, error)
 
-	// Genesis operations.
-	LoadGenesis(ctx context.Context, stateBytes []byte) error
-	SaveGenesisData(ctx context.Context, state state.BeaconState) error
-	EnsureEmbeddedGenesis(ctx context.Context) error
-
-	// Support for checkpoint sync and backfill.
-	SaveOriginCheckpointBlockRoot(ctx context.Context, blockRoot [32]byte) error
-	SaveOrigin(ctx context.Context, serState, serBlock []byte) error
-	SaveBackfillStatus(context.Context, *dbval.BackfillStatus) error
-	BackfillFinalizedIndex(ctx context.Context, blocks []blocks.ROBlock, finalizedChildRoot [32]byte) error
-
 	// Custody operations.
 	UpdateSubscribedToAllDataSubnets(ctx context.Context, subscribed bool) (bool, error)
 	UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error)
@@ -142,6 +131,16 @@ type HeadAccessDatabase interface {
 	HeadBlock(ctx context.Context) (interfaces.ReadOnlySignedBeaconBlock, error)
 	HeadBlockRoot() ([32]byte, error)
 	SaveHeadBlockRoot(ctx context.Context, blockRoot [32]byte) error
+
+	// Genesis operations.
+	LoadGenesis(ctx context.Context, stateBytes []byte) error
+	SaveGenesisData(ctx context.Context, state state.BeaconState) error
+	EnsureEmbeddedGenesis(ctx context.Context) error
+
+	// Support for checkpoint sync and backfill.
+	SaveOrigin(ctx context.Context, serState, serBlock []byte) error
+	SaveBackfillStatus(context.Context, *dbval.BackfillStatus) error
+	BackfillFinalizedIndex(ctx context.Context, blocks []blocks.ROBlock, finalizedChildRoot [32]byte) error
 }
 
 // SlasherDatabase interface for persisting data related to detecting slashable offenses on Ethereum.

beacon-chain/db/kv/BUILD.bazel

@@ -40,6 +40,7 @@ go_library(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -51,7 +52,6 @@ go_library(
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/detect:go_default_library",
-        "//genesis:go_default_library",
         "//io/file:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
@@ -110,6 +110,7 @@ go_test(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -119,7 +120,6 @@ go_test(
         "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/db/kv/genesis.go

@@ -8,7 +8,6 @@ import (
 	dbIface "github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/encoding/ssz/detect"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
@@ -98,22 +97,8 @@ func (s *Store) EnsureEmbeddedGenesis(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	if !state.IsNil(gs) {
+	if gs != nil && !gs.IsNil() {
 		return s.SaveGenesisData(ctx, gs)
 	}
 	return nil
 }
-
-type LegacyGenesisProvider struct {
-	store *Store
-}
-
-func NewLegacyGenesisProvider(store *Store) *LegacyGenesisProvider {
-	return &LegacyGenesisProvider{store: store}
-}
-
-var _ genesis.Provider = &LegacyGenesisProvider{}
-
-func (p *LegacyGenesisProvider) Genesis(ctx context.Context) (state.BeaconState, error) {
-	return p.store.LegacyGenesisState(ctx)
-}

beacon-chain/db/kv/genesis_test.go

@@ -8,7 +8,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/iface"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
@@ -153,7 +152,6 @@ func TestEnsureEmbeddedGenesis(t *testing.T) {
 		require.NoError(t, undo())
 	}()
 
-	genesis.StoreEmbeddedDuringTest(t, params.BeaconConfig().ConfigName)
 	ctx := t.Context()
 	db := setupDB(t)
 

beacon-chain/db/kv/state.go

@@ -6,12 +6,14 @@ import (
 	"fmt"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis"
 	statenative "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
 	"github.com/OffchainLabs/prysm/v6/config/features"
+	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -63,21 +65,21 @@ func (s *Store) StateOrError(ctx context.Context, blockRoot [32]byte) (state.Bea
 	return st, nil
 }
 
-func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
-	st, err := genesis.State()
-	if errors.Is(err, genesis.ErrGenesisStateNotInitialized) {
-		log.WithError(err).Error("genesis state not initialized, returning nil state. this should only happen in tests")
-		return nil, nil
-	}
-	return st, err
-}
-
 // GenesisState returns the genesis state in beacon chain.
-func (s *Store) LegacyGenesisState(ctx context.Context) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.LegacyGenesisState")
+func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "BeaconDB.GenesisState")
 	defer span.End()
 
-	var err error
+	cached, err := genesis.State(params.BeaconConfig().ConfigName)
+	if err != nil {
+		tracing.AnnotateError(span, err)
+		return nil, err
+	}
+	span.SetAttributes(trace.BoolAttribute("cache_hit", cached != nil))
+	if cached != nil {
+		return cached, nil
+	}
+
 	var st state.BeaconState
 	err = s.db.View(func(tx *bolt.Tx) error {
 		// Retrieve genesis block's signing root from blocks bucket,

beacon-chain/db/kv/state_test.go

@@ -15,7 +15,6 @@ 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/genesis"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -489,7 +488,7 @@ func TestGenesisState_CanSaveRetrieve(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, st.SetSlot(1))
 	require.NoError(t, db.SaveGenesisBlockRoot(t.Context(), headRoot))
-	genesis.StoreStateDuringTest(t, st)
+	require.NoError(t, db.SaveState(t.Context(), st, headRoot))
 
 	savedGenesisS, err := db.GenesisState(t.Context())
 	require.NoError(t, err)
@@ -662,7 +661,7 @@ func TestStore_GenesisState_CanGetHighestBelow(t *testing.T) {
 	require.NoError(t, err)
 	genesisRoot := [32]byte{'a'}
 	require.NoError(t, db.SaveGenesisBlockRoot(t.Context(), genesisRoot))
-	genesis.StoreStateDuringTest(t, genesisState)
+	require.NoError(t, db.SaveState(t.Context(), genesisState, genesisRoot))
 
 	b := util.NewBeaconBlock()
 	b.Block.Slot = 1

beacon-chain/db/kv/wss_test.go

@@ -3,9 +3,9 @@ package kv
 import (
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 )
@@ -18,11 +18,7 @@ func TestSaveOrigin(t *testing.T) {
 	ctx := t.Context()
 	db := setupDB(t)
 
-	// Initialize genesis with mainnet config - this will load the embedded mainnet state
-	require.NoError(t, genesis.Initialize(ctx, t.TempDir()))
-
-	// Get the initialized genesis state
-	st, err := genesis.State()
+	st, err := genesis.State(params.MainnetName)
 	require.NoError(t, err)
 
 	sb, err := st.MarshalSSZ()

beacon-chain/execution/BUILD.bazel

@@ -125,7 +125,6 @@ go_test(
         "//contracts/deposit/mock:go_default_library",
         "//crypto/bls:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//monitoring/clientstats:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/execution/engine_client.go

@@ -57,11 +57,6 @@ var (
 		GetPayloadMethodV5,
 		GetBlobsV2,
 	}
-
-	gloasEngineEndpoints = []string{
-		NewPayloadMethodV5,
-		GetPayloadMethodV6,
-	}
 )
 
 const (
@@ -72,8 +67,6 @@ 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.
@@ -90,8 +83,6 @@ 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.
@@ -190,18 +181,6 @@ 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")
 	}
@@ -294,9 +273,6 @@ 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{}
 	}
@@ -349,10 +325,6 @@ 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)

beacon-chain/execution/service_test.go

@@ -22,7 +22,6 @@ import (
 	contracts "github.com/OffchainLabs/prysm/v6/contracts/deposit"
 	"github.com/OffchainLabs/prysm/v6/contracts/deposit/mock"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/monitoring/clientstats"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -382,7 +381,6 @@ func TestInitDepositCache_OK(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, s.cfg.beaconDB.SaveGenesisBlockRoot(t.Context(), blockRootA))
 	require.NoError(t, s.cfg.beaconDB.SaveState(t.Context(), emptyState, blockRootA))
-	genesis.StoreStateDuringTest(t, emptyState)
 	s.chainStartData.Chainstarted = true
 	require.NoError(t, s.initDepositCaches(t.Context(), ctrs))
 	require.Equal(t, 3, len(s.cfg.depositCache.PendingContainers(t.Context(), nil)))
@@ -448,7 +446,6 @@ func TestInitDepositCacheWithFinalization_OK(t *testing.T) {
 	require.NoError(t, s.cfg.beaconDB.SaveGenesisBlockRoot(t.Context(), headRoot))
 	require.NoError(t, s.cfg.beaconDB.SaveState(t.Context(), emptyState, headRoot))
 	require.NoError(t, stateGen.SaveState(t.Context(), headRoot, emptyState))
-	genesis.StoreStateDuringTest(t, emptyState)
 	s.cfg.stateGen = stateGen
 	require.NoError(t, emptyState.SetEth1DepositIndex(3))
 
@@ -597,7 +594,6 @@ func TestService_EnsureConsistentPowchainData(t *testing.T) {
 	require.NoError(t, err)
 	assert.NoError(t, genState.SetSlot(1000))
 
-	genesis.StoreStateDuringTest(t, genState)
 	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(t.Context(), genState))
 	_, err = s1.validPowchainData(t.Context())
 	require.NoError(t, err)
@@ -659,7 +655,6 @@ func TestService_EnsureValidPowchainData(t *testing.T) {
 	require.NoError(t, err)
 	assert.NoError(t, genState.SetSlot(1000))
 
-	genesis.StoreStateDuringTest(t, genState)
 	require.NoError(t, s1.cfg.beaconDB.SaveGenesisData(t.Context(), genState))
 
 	err = s1.cfg.beaconDB.SaveExecutionChainData(t.Context(), &ethpb.ETH1ChainData{

beacon-chain/node/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "clear_db.go",
         "config.go",
         "log.go",
         "node.go",
@@ -50,6 +49,7 @@ go_library(
         "//beacon-chain/sync/backfill:go_default_library",
         "//beacon-chain/sync/backfill/coverage:go_default_library",
         "//beacon-chain/sync/checkpoint:go_default_library",
+        "//beacon-chain/sync/genesis:go_default_library",
         "//beacon-chain/sync/initial-sync:go_default_library",
         "//beacon-chain/verification:go_default_library",
         "//cmd:go_default_library",
@@ -59,7 +59,6 @@ go_library(
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis:go_default_library",
         "//monitoring/prometheus:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//runtime:go_default_library",

beacon-chain/node/clear_db.go

@@ -1,101 +0,0 @@
-package node
-
-import (
-	"context"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/kv"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/slasherkv"
-	"github.com/OffchainLabs/prysm/v6/cmd"
-	"github.com/pkg/errors"
-	"github.com/urfave/cli/v2"
-)
-
-type dbClearer struct {
-	shouldClear bool
-	force       bool
-	confirmed   bool
-}
-
-const (
-	clearConfirmation = "This will delete your beacon chain database stored in your data directory. " +
-		"Your database backups will not be removed - do you want to proceed? (Y/N)"
-
-	clearDeclined = "Database will not be deleted. No changes have been made."
-)
-
-func (c *dbClearer) clearKV(ctx context.Context, db *kv.Store) (*kv.Store, error) {
-	if !c.shouldProceed() {
-		return db, nil
-	}
-
-	log.Warning("Removing database")
-	if err := db.ClearDB(); err != nil {
-		return nil, errors.Wrap(err, "could not clear database")
-	}
-	return kv.NewKVStore(ctx, db.DatabasePath())
-}
-
-func (c *dbClearer) clearBlobs(bs *filesystem.BlobStorage) error {
-	if !c.shouldProceed() {
-		return nil
-	}
-
-	log.Warning("Removing blob storage")
-	if err := bs.Clear(); err != nil {
-		return errors.Wrap(err, "could not clear blob storage")
-	}
-
-	return nil
-}
-
-func (c *dbClearer) clearColumns(cs *filesystem.DataColumnStorage) error {
-	if !c.shouldProceed() {
-		return nil
-	}
-
-	log.Warning("Removing data columns storage")
-	if err := cs.Clear(); err != nil {
-		return errors.Wrap(err, "could not clear data columns storage")
-	}
-
-	return nil
-}
-
-func (c *dbClearer) clearSlasher(ctx context.Context, db *slasherkv.Store) (*slasherkv.Store, error) {
-	if !c.shouldProceed() {
-		return db, nil
-	}
-
-	log.Warning("Removing slasher database")
-	if err := db.ClearDB(); err != nil {
-		return nil, errors.Wrap(err, "could not clear slasher database")
-	}
-	return slasherkv.NewKVStore(ctx, db.DatabasePath())
-}
-
-func (c *dbClearer) shouldProceed() bool {
-	if !c.shouldClear {
-		return false
-	}
-	if c.force {
-		return true
-	}
-	if !c.confirmed {
-		confirmed, err := cmd.ConfirmAction(clearConfirmation, clearDeclined)
-		if err != nil {
-			log.WithError(err).Error("Not clearing db due to confirmation error")
-			return false
-		}
-		c.confirmed = confirmed
-	}
-	return c.confirmed
-}
-
-func newDbClearer(cliCtx *cli.Context) *dbClearer {
-	force := cliCtx.Bool(cmd.ForceClearDB.Name)
-	return &dbClearer{
-		shouldClear: cliCtx.Bool(cmd.ClearDB.Name) || force,
-		force:       force,
-	}
-}

beacon-chain/node/node.go

@@ -52,6 +52,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync/backfill"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync/backfill/coverage"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync/checkpoint"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync/genesis"
 	initialsync "github.com/OffchainLabs/prysm/v6/beacon-chain/sync/initial-sync"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	"github.com/OffchainLabs/prysm/v6/cmd"
@@ -61,7 +62,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/container/slice"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/monitoring/prometheus"
 	"github.com/OffchainLabs/prysm/v6/runtime"
 	"github.com/OffchainLabs/prysm/v6/runtime/prereqs"
@@ -113,7 +113,7 @@ type BeaconNode struct {
 	slasherAttestationsFeed  *event.Feed
 	finalizedStateAtStartUp  state.BeaconState
 	serviceFlagOpts          *serviceFlagOpts
-	GenesisProviders         []genesis.Provider
+	GenesisInitializer       genesis.Initializer
 	CheckpointInitializer    checkpoint.Initializer
 	forkChoicer              forkchoice.ForkChoicer
 	clockWaiter              startup.ClockWaiter
@@ -127,7 +127,6 @@ type BeaconNode struct {
 	syncChecker              *initialsync.SyncChecker
 	slasherEnabled           bool
 	lcStore                  *lightclient.Store
-	ConfigOptions            []params.Option
 }
 
 // New creates a new node instance, sets up configuration options, and registers
@@ -136,13 +135,18 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 	if err := configureBeacon(cliCtx); err != nil {
 		return nil, errors.Wrap(err, "could not set beacon configuration options")
 	}
+
+	// Initializes any forks here.
+	params.BeaconConfig().InitializeForkSchedule()
+
+	registry := runtime.NewServiceRegistry()
 	ctx := cliCtx.Context
 
 	beacon := &BeaconNode{
 		cliCtx:                  cliCtx,
 		ctx:                     ctx,
 		cancel:                  cancel,
-		services:                runtime.NewServiceRegistry(),
+		services:                registry,
 		stop:                    make(chan struct{}),
 		stateFeed:               new(event.Feed),
 		blockFeed:               new(event.Feed),
@@ -169,25 +173,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		}
 	}
 
-	dbClearer := newDbClearer(cliCtx)
-	dataDir := cliCtx.String(cmd.DataDirFlag.Name)
-	boltFname := filepath.Join(dataDir, kv.BeaconNodeDbDirName)
-	kvdb, err := openDB(ctx, boltFname, dbClearer)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not open database")
-	}
-	beacon.db = kvdb
-
-	providers := append(beacon.GenesisProviders, kv.NewLegacyGenesisProvider(kvdb))
-	if err := genesis.Initialize(ctx, dataDir, providers...); err != nil {
-		return nil, errors.Wrap(err, "could not initialize genesis state")
-	}
-
-	beacon.ConfigOptions = append([]params.Option{params.WithGenesisValidatorsRoot(genesis.ValidatorsRoot())}, beacon.ConfigOptions...)
-	params.BeaconConfig().ApplyOptions(beacon.ConfigOptions...)
-	params.BeaconConfig().InitializeForkSchedule()
-	params.LogDigests(params.BeaconConfig())
-
 	synchronizer := startup.NewClockSynchronizer()
 	beacon.clockWaiter = synchronizer
 	beacon.forkChoicer = doublylinkedtree.New()
@@ -206,9 +191,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		}
 		beacon.BlobStorage = blobs
 	}
-	if err := dbClearer.clearBlobs(beacon.BlobStorage); err != nil {
-		return nil, errors.Wrap(err, "could not clear blob storage")
-	}
 
 	if beacon.DataColumnStorage == nil {
 		dataColumnStorage, err := filesystem.NewDataColumnStorage(cliCtx.Context, beacon.DataColumnStorageOptions...)
@@ -218,11 +200,8 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 
 		beacon.DataColumnStorage = dataColumnStorage
 	}
-	if err := dbClearer.clearColumns(beacon.DataColumnStorage); err != nil {
-		return nil, errors.Wrap(err, "could not clear data column storage")
-	}
 
-	bfs, err := startBaseServices(cliCtx, beacon, depositAddress, dbClearer)
+	bfs, err := startBaseServices(cliCtx, beacon, depositAddress)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not start modules")
 	}
@@ -310,7 +289,7 @@ func configureBeacon(cliCtx *cli.Context) error {
 	return nil
 }
 
-func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress string, clearer *dbClearer) (*backfill.Store, error) {
+func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress string) (*backfill.Store, error) {
 	ctx := cliCtx.Context
 	log.Debugln("Starting DB")
 	if err := beacon.startDB(cliCtx, depositAddress); err != nil {
@@ -318,10 +297,9 @@ func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress s
 	}
 
 	beacon.BlobStorage.WarmCache()
-	beacon.DataColumnStorage.WarmCache()
 
 	log.Debugln("Starting Slashing DB")
-	if err := beacon.startSlasherDB(cliCtx, clearer); err != nil {
+	if err := beacon.startSlasherDB(cliCtx); err != nil {
 		return nil, errors.Wrap(err, "could not start slashing DB")
 	}
 
@@ -501,6 +479,43 @@ func (b *BeaconNode) Close() {
 	close(b.stop)
 }
 
+func (b *BeaconNode) clearDB(clearDB, forceClearDB bool, d *kv.Store, dbPath string) (*kv.Store, error) {
+	var err error
+	clearDBConfirmed := false
+
+	if clearDB && !forceClearDB {
+		const (
+			actionText = "This will delete your beacon chain database stored in your data directory. " +
+				"Your database backups will not be removed - do you want to proceed? (Y/N)"
+
+			deniedText = "Database will not be deleted. No changes have been made."
+		)
+
+		clearDBConfirmed, err = cmd.ConfirmAction(actionText, deniedText)
+		if err != nil {
+			return nil, errors.Wrapf(err, "could not confirm action")
+		}
+	}
+
+	if clearDBConfirmed || forceClearDB {
+		log.Warning("Removing database")
+		if err := d.ClearDB(); err != nil {
+			return nil, errors.Wrap(err, "could not clear database")
+		}
+
+		if err := b.BlobStorage.Clear(); err != nil {
+			return nil, errors.Wrap(err, "could not clear blob storage")
+		}
+
+		d, err = kv.NewKVStore(b.ctx, dbPath)
+		if err != nil {
+			return nil, errors.Wrap(err, "could not create new database")
+		}
+	}
+
+	return d, nil
+}
+
 func (b *BeaconNode) checkAndSaveDepositContract(depositAddress string) error {
 	knownContract, err := b.db.DepositContractAddress(b.ctx)
 	if err != nil {
@@ -524,36 +539,60 @@ func (b *BeaconNode) checkAndSaveDepositContract(depositAddress string) error {
 	return nil
 }
 
-func openDB(ctx context.Context, dbPath string, clearer *dbClearer) (*kv.Store, error) {
+func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
+	var depositCache cache.DepositCache
+
+	baseDir := cliCtx.String(cmd.DataDirFlag.Name)
+	dbPath := filepath.Join(baseDir, kv.BeaconNodeDbDirName)
+	clearDBRequired := cliCtx.Bool(cmd.ClearDB.Name)
+	forceClearDBRequired := cliCtx.Bool(cmd.ForceClearDB.Name)
+
 	log.WithField("databasePath", dbPath).Info("Checking DB")
 
-	d, err := kv.NewKVStore(ctx, dbPath)
+	d, err := kv.NewKVStore(b.ctx, dbPath)
 	if err != nil {
-		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
+		return errors.Wrapf(err, "could not create database at %s", dbPath)
 	}
 
-	d, err = clearer.clearKV(ctx, d)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not clear database")
+	if clearDBRequired || forceClearDBRequired {
+		d, err = b.clearDB(clearDBRequired, forceClearDBRequired, d, dbPath)
+		if err != nil {
+			return errors.Wrap(err, "could not clear database")
+		}
 	}
 
-	return d, d.RunMigrations(ctx)
-}
+	if err := d.RunMigrations(b.ctx); err != nil {
+		return err
+	}
 
-func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
-	depositCache, err := depositsnapshot.New()
+	b.db = d
+
+	depositCache, err = depositsnapshot.New()
 	if err != nil {
 		return errors.Wrap(err, "could not create deposit cache")
 	}
+
 	b.depositCache = depositCache
 
+	if b.GenesisInitializer != nil {
+		if err := b.GenesisInitializer.Initialize(b.ctx, d); err != nil {
+			if errors.Is(err, db.ErrExistingGenesisState) {
+				return errors.Errorf("Genesis state flag specified but a genesis state "+
+					"exists already. Run again with --%s and/or ensure you are using the "+
+					"appropriate testnet flag to load the given genesis state.", cmd.ClearDB.Name)
+			}
+
+			return errors.Wrap(err, "could not load genesis from file")
+		}
+	}
+
 	if err := b.db.EnsureEmbeddedGenesis(b.ctx); err != nil {
 		return errors.Wrap(err, "could not ensure embedded genesis")
 	}
 
 	if b.CheckpointInitializer != nil {
 		log.Info("Checkpoint sync - Downloading origin state and block")
-		if err := b.CheckpointInitializer.Initialize(b.ctx, b.db); err != nil {
+		if err := b.CheckpointInitializer.Initialize(b.ctx, d); err != nil {
 			return err
 		}
 	}
@@ -565,25 +604,49 @@ func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
 	log.WithField("address", depositAddress).Info("Deposit contract")
 	return nil
 }
-func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context, clearer *dbClearer) error {
+
+func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context) error {
 	if !b.slasherEnabled {
 		return nil
 	}
 	baseDir := cliCtx.String(cmd.DataDirFlag.Name)
+
 	if cliCtx.IsSet(flags.SlasherDirFlag.Name) {
 		baseDir = cliCtx.String(flags.SlasherDirFlag.Name)
 	}
 
 	dbPath := filepath.Join(baseDir, kv.BeaconNodeDbDirName)
+	clearDB := cliCtx.Bool(cmd.ClearDB.Name)
+	forceClearDB := cliCtx.Bool(cmd.ForceClearDB.Name)
+
 	log.WithField("databasePath", dbPath).Info("Checking DB")
+
 	d, err := slasherkv.NewKVStore(b.ctx, dbPath)
 	if err != nil {
 		return err
 	}
-	d, err = clearer.clearSlasher(b.ctx, d)
-	if err != nil {
-		return errors.Wrap(err, "could not clear slasher database")
+	clearDBConfirmed := false
+	if clearDB && !forceClearDB {
+		actionText := "This will delete your beacon chain database stored in your data directory. " +
+			"Your database backups will not be removed - do you want to proceed? (Y/N)"
+		deniedText := "Database will not be deleted. No changes have been made."
+		clearDBConfirmed, err = cmd.ConfirmAction(actionText, deniedText)
+		if err != nil {
+			return err
+		}
 	}
+	if clearDBConfirmed || forceClearDB {
+		log.Warning("Removing database")
+		if err := d.ClearDB(); err != nil {
+			return errors.Wrap(err, "could not clear database")
+		}
+
+		d, err = slasherkv.NewKVStore(b.ctx, dbPath)
+		if err != nil {
+			return errors.Wrap(err, "could not create new database")
+		}
+	}
+
 	b.slasherDB = d
 	return nil
 }
@@ -846,7 +909,6 @@ func (b *BeaconNode) registerInitialSyncService(complete chan struct{}) error {
 		ClockWaiter:         b.clockWaiter,
 		InitialSyncComplete: complete,
 		BlobStorage:         b.BlobStorage,
-		DataColumnStorage:   b.DataColumnStorage,
 	}, opts...)
 	return b.services.RegisterService(is)
 }
@@ -941,7 +1003,6 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 		FinalizationFetcher:       chainService,
 		BlockReceiver:             chainService,
 		BlobReceiver:              chainService,
-		DataColumnReceiver:        chainService,
 		AttestationReceiver:       chainService,
 		GenesisTimeFetcher:        chainService,
 		GenesisFetcher:            chainService,
@@ -969,7 +1030,6 @@ func (b *BeaconNode) registerRPCService(router *http.ServeMux) error {
 		Router:                    router,
 		ClockWaiter:               b.clockWaiter,
 		BlobStorage:               b.BlobStorage,
-		DataColumnStorage:         b.DataColumnStorage,
 		TrackedValidatorsCache:    b.trackedValidatorsCache,
 		PayloadIDCache:            b.payloadIDCache,
 		LCStore:                   b.lcStore,

beacon-chain/node/options.go

@@ -5,7 +5,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/builder"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 )
 
 // Option for beacon node configuration.
@@ -52,13 +51,6 @@ func WithBlobStorageOptions(opt ...filesystem.BlobStorageOption) Option {
 	}
 }
 
-func WithConfigOptions(opt ...params.Option) Option {
-	return func(bn *BeaconNode) error {
-		bn.ConfigOptions = append(bn.ConfigOptions, opt...)
-		return nil
-	}
-}
-
 // WithDataColumnStorage sets the DataColumnStorage backend for the BeaconNode
 func WithDataColumnStorage(bs *filesystem.DataColumnStorage) Option {
 	return func(bn *BeaconNode) error {

beacon-chain/p2p/BUILD.bazel

@@ -72,6 +72,7 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
         "//runtime:go_default_library",
@@ -168,6 +169,7 @@ go_test(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//network:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
@@ -177,7 +179,6 @@ go_test(
         "//testing/util:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
@@ -195,6 +196,7 @@ go_test(
         "@com_github_multiformats_go_multiaddr//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+        "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_sirupsen_logrus//hooks/test:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
     ],

beacon-chain/p2p/broadcaster.go

@@ -15,6 +15,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
@@ -273,8 +274,14 @@ func (s *Service) BroadcastLightClientOptimisticUpdate(ctx context.Context, upda
 		return errors.New("attempted to broadcast nil light client optimistic update")
 	}
 
-	digest := params.ForkDigest(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
-	if err := s.broadcastObject(ctx, update, lcOptimisticToTopic(digest)); err != nil {
+	forkDigest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(update.AttestedHeader().Beacon().Slot), s.genesisValidatorsRoot)
+	if err != nil {
+		err := errors.Wrap(err, "could not retrieve fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	if err := s.broadcastObject(ctx, update, lcOptimisticToTopic(forkDigest)); err != nil {
 		log.WithError(err).Debug("Failed to broadcast light client optimistic update")
 		err := errors.Wrap(err, "could not publish message")
 		tracing.AnnotateError(span, err)
@@ -293,7 +300,13 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 		return errors.New("attempted to broadcast nil light client finality update")
 	}
 
-	forkDigest := params.ForkDigest(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
+	forkDigest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(update.AttestedHeader().Beacon().Slot), s.genesisValidatorsRoot)
+	if err != nil {
+		err := errors.Wrap(err, "could not retrieve fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
 	if err := s.broadcastObject(ctx, update, lcFinalityToTopic(forkDigest)); err != nil {
 		log.WithError(err).Debug("Failed to broadcast light client finality update")
 		err := errors.Wrap(err, "could not publish message")
@@ -305,15 +318,15 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 	return nil
 }
 
-// BroadcastDataColumnSidecar broadcasts a data column to the p2p network, the message is assumed to be
+// BroadcastDataColumn broadcasts a data column to the p2p network, the message is assumed to be
 // broadcasted to the current fork and to the input column subnet.
-func (s *Service) BroadcastDataColumnSidecar(
+func (s *Service) BroadcastDataColumn(
 	root [fieldparams.RootLength]byte,
 	dataColumnSubnet uint64,
 	dataColumnSidecar *ethpb.DataColumnSidecar,
 ) error {
 	// Add tracing to the function.
-	ctx, span := trace.StartSpan(s.ctx, "p2p.BroadcastDataColumnSidecar")
+	ctx, span := trace.StartSpan(s.ctx, "p2p.BroadcastDataColumn")
 	defer span.End()
 
 	// Ensure the data column sidecar is not nil.
@@ -330,12 +343,12 @@ func (s *Service) BroadcastDataColumnSidecar(
 	}
 
 	// Non-blocking broadcast, with attempts to discover a column subnet peer if none available.
-	go s.internalBroadcastDataColumnSidecar(ctx, root, dataColumnSubnet, dataColumnSidecar, forkDigest)
+	go s.internalBroadcastDataColumn(ctx, root, dataColumnSubnet, dataColumnSidecar, forkDigest)
 
 	return nil
 }
 
-func (s *Service) internalBroadcastDataColumnSidecar(
+func (s *Service) internalBroadcastDataColumn(
 	ctx context.Context,
 	root [fieldparams.RootLength]byte,
 	columnSubnet uint64,
@@ -343,7 +356,7 @@ func (s *Service) internalBroadcastDataColumnSidecar(
 	forkDigest [fieldparams.VersionLength]byte,
 ) {
 	// Add tracing to the function.
-	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastDataColumnSidecar")
+	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastDataColumn")
 	defer span.End()
 
 	// Increase the number of broadcast attempts.

beacon-chain/p2p/broadcaster_test.go

@@ -15,13 +15,12 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/wrapper"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	testpb "github.com/OffchainLabs/prysm/v6/proto/testing"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
@@ -60,7 +59,6 @@ func TestService_Broadcast(t *testing.T) {
 	topic := "/eth2/%x/testing"
 	// Set a test gossip mapping for testpb.TestSimpleMessage.
 	GossipTypeMapping[reflect.TypeOf(msg)] = topic
-	p.clock = startup.NewClock(p.genesisTime, bytesutil.ToBytes32(p.genesisValidatorsRoot))
 	digest, err := p.currentForkDigest()
 	require.NoError(t, err)
 	topic = fmt.Sprintf(topic, digest)
@@ -553,7 +551,9 @@ func TestService_BroadcastLightClientOptimisticUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientOptimisticUpdateTopicFormat
-	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, params.ForkDigest(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot)))
+	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
+	require.NoError(t, err)
+	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, digest)
 
 	// External peer subscribes to the topic.
 	topic += p.Encoding().ProtocolSuffix()
@@ -617,7 +617,9 @@ func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientFinalityUpdateTopicFormat
-	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, params.ForkDigest(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot)))
+	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
+	require.NoError(t, err)
+	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, digest)
 
 	// External peer subscribes to the topic.
 	topic += p.Encoding().ProtocolSuffix()
@@ -716,7 +718,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 
 	// Attempt to broadcast nil object should fail.
 	var emptyRoot [fieldparams.RootLength]byte
-	err = service.BroadcastDataColumnSidecar(emptyRoot, subnet, nil)
+	err = service.BroadcastDataColumn(emptyRoot, subnet, nil)
 	require.ErrorContains(t, "attempted to broadcast nil", err)
 
 	// Subscribe to the topic.
@@ -727,7 +729,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	time.Sleep(50 * time.Millisecond)
 
 	// Broadcast to peers and wait.
-	err = service.BroadcastDataColumnSidecar(emptyRoot, subnet, sidecar)
+	err = service.BroadcastDataColumn(emptyRoot, subnet, sidecar)
 	require.NoError(t, err)
 
 	// Receive the message.