Resolve more conflics

* Rename various variables/functions to be more clear

* Add changelog fragment

---------

Co-authored-by: Bastin <43618253+Inspector-Butters@users.noreply.github.com>

WORKSPACE

@@ -190,7 +190,7 @@ load("@rules_oci//oci:pull.bzl", "oci_pull")
 # A multi-arch base image
 oci_pull(
     name = "linux_debian11_multiarch_base",  # Debian bullseye
-    digest = "sha256:b82f113425c5b5c714151aaacd8039bc141821cdcd3c65202d42bdf9c43ae60b",  # 2023-12-12
+    digest = "sha256:55a5e011b2c4246b4c51e01fcc2b452d151e03df052e357465f0392fcd59fddf",
     image = "gcr.io/prysmaticlabs/distroless/cc-debian11",
     platforms = [
         "linux/amd64",
@@ -208,7 +208,7 @@ load("@io_bazel_rules_go//go:deps.bzl", "go_register_toolchains", "go_rules_depe
 go_rules_dependencies()
 
 go_register_toolchains(
-    go_version = "1.24.0",
+    go_version = "1.24.6",
     nogo = "@//:nogo",
 )
 

api/client/beacon/BUILD.bazel

@@ -16,7 +16,6 @@ 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,7 +9,6 @@ import (
 	"net/url"
 	"path"
 	"regexp"
-	"sort"
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v6/api/client"
@@ -17,7 +16,6 @@ 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"
@@ -137,24 +135,6 @@ 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)
@@ -334,31 +314,3 @@ 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,6 +102,7 @@ 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
 }
 
@@ -152,7 +153,8 @@ 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.
-func (c *Client) do(ctx context.Context, method string, path string, body io.Reader, opts ...reqOption) (res []byte, header http.Header, err error) {
+// 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) {
 	ctx, span := trace.StartSpan(ctx, "builder.client.do")
 	defer func() {
 		tracing.AnnotateError(span, err)
@@ -187,8 +189,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 != http.StatusOK {
-		err = non200Err(r)
+	if r.StatusCode != expectedStatus {
+		err = unexpectedStatusErr(r, expectedStatus)
 		return
 	}
 	res, err = io.ReadAll(io.LimitReader(r.Body, client.MaxBodySize))
@@ -236,7 +238,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, getOpts)
+	data, header, err := c.do(ctx, http.MethodGet, path, nil, http.StatusOK, getOpts)
 	if err != nil {
 		return nil, errors.Wrap(err, "error getting header from builder server")
 	}
@@ -409,7 +411,7 @@ func (c *Client) RegisterValidator(ctx context.Context, svr []*ethpb.SignedValid
 		}
 	}
 
-	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), postOpts); err != nil {
+	if _, _, err = c.do(ctx, http.MethodPost, postRegisterValidatorPath, bytes.NewBuffer(body), http.StatusOK, postOpts); err != nil {
 		return errors.Wrap(err, "do")
 	}
 	log.WithField("registrationCount", len(svr)).Debug("Successfully registered validator(s) on builder")
@@ -471,7 +473,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), postOpts)
+	data, header, err := c.do(ctx, http.MethodPost, postBlindedBeaconBlockPath, bytes.NewBuffer(body), http.StatusOK, postOpts)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "error posting the blinded block to the builder api")
 	}
@@ -501,6 +503,24 @@ 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 {
@@ -657,11 +677,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, getOpts)
+	_, _, err := c.do(ctx, http.MethodGet, getStatus, nil, http.StatusOK, getOpts)
 	return err
 }
 
-func non200Err(response *http.Response) error {
+func unexpectedStatusErr(response *http.Response, expected int) error {
 	bodyBytes, err := io.ReadAll(io.LimitReader(response.Body, client.MaxErrBodySize))
 	var errMessage ErrorMessage
 	var body string
@@ -670,7 +690,7 @@ func non200Err(response *http.Response) error {
 	} else {
 		body = "response body:\n" + string(bodyBytes)
 	}
-	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
+	msg := fmt.Sprintf("expected=%d, got=%d, url=%s, body=%s", expected, response.StatusCode, response.Request.URL, body)
 	switch response.StatusCode {
 	case http.StatusUnsupportedMediaType:
 		log.WithError(ErrUnsupportedMediaType).Debug(msg)

api/client/builder/client_test.go

@@ -1555,6 +1555,89 @@ 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)
@@ -1727,7 +1810,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,6 +45,11 @@ 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_non200Err(t *testing.T) {
+func TestErrorMessage_unexpectedStatusErr(t *testing.T) {
 	mockRequest := &http.Request{
 		URL: &url.URL{Path: "example.com"},
 	}
@@ -1779,7 +1779,7 @@ func TestErrorMessage_non200Err(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := non200Err(tt.args)
+			err := unexpectedStatusErr(tt.args, http.StatusOK)
 			if err != nil && tt.wantMessage != "" {
 				require.ErrorContains(t, tt.wantMessage, err)
 			}

beacon-chain/blockchain/BUILD.bazel

@@ -73,6 +73,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//cmd/beacon-chain/flags:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -181,6 +182,7 @@ 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",
@@ -194,6 +196,7 @@ go_test(
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_holiman_uint256//:go_default_library",
+        "@com_github_libp2p_go_libp2p//core/peer: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",

beacon-chain/blockchain/chain_info_test.go

@@ -14,6 +14,7 @@ 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"
@@ -624,6 +625,7 @@ 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/currently_syncing_block.go

@@ -7,10 +7,15 @@ type currentlySyncingBlock struct {
 	roots map[[32]byte]struct{}
 }
 
-func (b *currentlySyncingBlock) set(root [32]byte) {
+func (b *currentlySyncingBlock) set(root [32]byte) error {
 	b.Lock()
 	defer b.Unlock()
+	_, ok := b.roots[root]
+	if ok {
+		return errBlockBeingSynced
+	}
 	b.roots[root] = struct{}{}
+	return nil
 }
 
 func (b *currentlySyncingBlock) unset(root [32]byte) {

beacon-chain/blockchain/error.go

@@ -44,6 +44,8 @@ var (
 	errMaxBlobsExceeded = verification.AsVerificationFailure(errors.New("expected commitments in block exceeds MAX_BLOBS_PER_BLOCK"))
 	// errMaxDataColumnsExceeded is returned when the number of data columns exceeds the maximum allowed.
 	errMaxDataColumnsExceeded = verification.AsVerificationFailure(errors.New("expected data columns for node exceeds NUMBER_OF_COLUMNS"))
+	// errBlockBeingSynced is returned when a block is being synced.
+	errBlockBeingSynced = errors.New("block is being synced")
 )
 
 // An invalid block is the block that fails state transition based on the core protocol rules.

beacon-chain/blockchain/execution_engine_test.go

@@ -19,6 +19,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/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"
@@ -309,6 +310,7 @@ 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{
@@ -403,6 +405,7 @@ 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/validation.go

@@ -6,20 +6,20 @@ import (
 )
 
 // 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 {
+func Verify(blobSidecars ...blocks.ROBlob) error {
+	if len(blobSidecars) == 0 {
 		return nil
 	}
-	if len(sidecars) == 1 {
+	if len(blobSidecars) == 1 {
 		return kzgContext.VerifyBlobKZGProof(
-			bytesToBlob(sidecars[0].Blob),
-			bytesToCommitment(sidecars[0].KzgCommitment),
-			bytesToKZGProof(sidecars[0].KzgProof))
+			bytesToBlob(blobSidecars[0].Blob),
+			bytesToCommitment(blobSidecars[0].KzgCommitment),
+			bytesToKZGProof(blobSidecars[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 := 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)

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) {
-	sidecars := make([]blocks.ROBlob, 0)
-	require.NoError(t, Verify(sidecars...))
+	blobSidecars := make([]blocks.ROBlob, 0)
+	require.NoError(t, Verify(blobSidecars...))
 }
 
 func TestBytesToAny(t *testing.T) {

beacon-chain/blockchain/options.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution"
@@ -235,14 +234,6 @@ func WithSyncChecker(checker Checker) Option {
 	}
 }
 
-// WithCustodyInfo sets the custody info for the blockchain service.
-func WithCustodyInfo(custodyInfo *peerdas.CustodyInfo) Option {
-	return func(s *Service) error {
-		s.cfg.CustodyInfo = custodyInfo
-		return nil
-	}
-}
-
 // WithSlasherEnabled sets whether the slasher is enabled or not.
 func WithSlasherEnabled(enabled bool) Option {
 	return func(s *Service) error {

beacon-chain/blockchain/process_block.go

@@ -240,9 +240,10 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 			}
 		}
 
-		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())
+		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())
 		}
+
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
 			JustifiedCheckpoint: jCheckpoints[i],
 			FinalizedCheckpoint: fCheckpoints[i]}
@@ -308,6 +309,30 @@ 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 {
@@ -584,7 +609,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(bs *filesystem.BlobStorage, root [fieldparams.RootLength]byte, expected [][]byte, slot primitives.Slot) (map[uint64]bool, error) {
+func missingBlobIndices(store *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
@@ -592,7 +617,7 @@ func missingBlobIndices(bs *filesystem.BlobStorage, root [fieldparams.RootLength
 	if len(expected) > maxBlobsPerBlock {
 		return nil, errMaxBlobsExceeded
 	}
-	indices := bs.Summary(root)
+	indices := store.Summary(root)
 	missing := make(map[uint64]bool, len(expected))
 	for i := range expected {
 		if len(expected[i]) > 0 && !indices.HasIndex(uint64(i)) {
@@ -607,7 +632,7 @@ func missingBlobIndices(bs *filesystem.BlobStorage, root [fieldparams.RootLength
 // 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(bs *filesystem.DataColumnStorage, root [fieldparams.RootLength]byte, expected map[uint64]bool) (map[uint64]bool, error) {
+func missingDataColumnIndices(store *filesystem.DataColumnStorage, root [fieldparams.RootLength]byte, expected map[uint64]bool) (map[uint64]bool, error) {
 	if len(expected) == 0 {
 		return nil, nil
 	}
@@ -619,7 +644,7 @@ func missingDataColumnIndices(bs *filesystem.DataColumnStorage, root [fieldparam
 	}
 
 	// Get a summary of the data columns stored in the database.
-	summary := bs.Summary(root)
+	summary := store.Summary(root)
 
 	// Check all expected data columns against the summary.
 	missing := make(map[uint64]bool)
@@ -666,7 +691,9 @@ func (s *Service) areDataColumnsAvailable(
 	root [fieldparams.RootLength]byte,
 	block interfaces.ReadOnlyBeaconBlock,
 ) error {
-	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS.
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+
+	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
 	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
 	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
 	if !params.WithinDAPeriod(blockEpoch, currentEpoch) {
@@ -689,16 +716,20 @@ func (s *Service) areDataColumnsAvailable(
 	}
 
 	// All columns to sample need to be available for the block to be considered available.
-	// https://github.com/ethereum/consensus-specs/blob/v1.5.0-alpha.10/specs/fulu/das-core.md#custody-sampling
 	nodeID := s.cfg.P2P.NodeID()
 
-	// Prevent custody group count to change during the rest of the function.
-	s.cfg.CustodyInfo.Mut.RLock()
-	defer s.cfg.CustodyInfo.Mut.RUnlock()
-
 	// Get the custody group sampling size for the node.
-	custodyGroupSamplingSize := s.cfg.CustodyInfo.CustodyGroupSamplingSize(peerdas.Actual)
-	peerInfo, _, err := peerdas.Info(nodeID, custodyGroupSamplingSize)
+	custodyGroupCount, err := s.cfg.P2P.CustodyGroupCount()
+	if err != nil {
+		return errors.Wrap(err, "custody group count")
+	}
+
+	// Compute the sampling size.
+	// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#custody-sampling
+	samplingSize := max(samplesPerSlot, custodyGroupCount)
+
+	// Get the peer info for the node.
+	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
 	if err != nil {
 		return errors.Wrap(err, "peer info")
 	}
@@ -711,7 +742,7 @@ func (s *Service) areDataColumnsAvailable(
 	summary := s.dataColumnStorage.Summary(root)
 	storedDataColumnsCount := summary.Count()
 
-	minimumColumnCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
+	minimumColumnCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
 
 	// 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.
@@ -814,7 +845,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)
 		}
 	}
 }
@@ -895,6 +926,118 @@ func (s *Service) areBlobsAvailable(ctx context.Context, root [fieldparams.RootL
 	}
 }
 
+// areDataColumnsImmediatelyAvailable checks if all required data columns are currently
+// available in the database without waiting for missing ones.
+func (s *Service) areDataColumnsImmediatelyAvailable(
+	ctx context.Context,
+	root [fieldparams.RootLength]byte,
+	block interfaces.ReadOnlyBeaconBlock,
+) error {
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
+	blockSlot, currentSlot := block.Slot(), s.CurrentSlot()
+	blockEpoch, currentEpoch := slots.ToEpoch(blockSlot), slots.ToEpoch(currentSlot)
+	if !params.WithinDAPeriod(blockEpoch, currentEpoch) {
+		return nil
+	}
+
+	body := block.Body()
+	if body == nil {
+		return errors.New("invalid nil beacon block body")
+	}
+
+	kzgCommitments, err := body.BlobKzgCommitments()
+	if err != nil {
+		return errors.Wrap(err, "blob KZG commitments")
+	}
+
+	// If block has no commitments there is nothing to check.
+	if len(kzgCommitments) == 0 {
+		return nil
+	}
+
+	// All columns to sample need to be available for the block to be considered available.
+	nodeID := s.cfg.P2P.NodeID()
+
+	// Get the custody group sampling size for the node.
+	custodyGroupCount, err := s.cfg.P2P.CustodyGroupCount()
+	if err != nil {
+		return errors.Wrap(err, "custody group count error")
+	}
+
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+	// Compute the sampling size.
+	samplingSize := max(samplesPerSlot, custodyGroupCount)
+
+	// Get the peer info for the node.
+	peerInfo, _, err := peerdas.Info(nodeID, samplingSize)
+	if err != nil {
+		return errors.Wrap(err, "peer info")
+	}
+
+	// Get the count of data columns we already have in the store.
+	summary := s.dataColumnStorage.Summary(root)
+	storedDataColumnsCount := summary.Count()
+
+	minimumColumnCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
+
+	// 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.
+	if storedDataColumnsCount >= minimumColumnCountToReconstruct {
+		return nil
+	}
+
+	// Get a map of data column indices that are not currently available.
+	missingMap, err := missingDataColumnIndices(s.dataColumnStorage, root, peerInfo.CustodyColumns)
+	if err != nil {
+		return errors.Wrap(err, "missing data columns")
+	}
+
+	// If there are no missing indices, all data column sidecars are available.
+	if len(missingMap) == 0 {
+		return nil
+	}
+
+	// If any data is missing, return error immediately (don't wait)
+	missingIndices := uint64MapToSortedSlice(missingMap)
+	return fmt.Errorf("data columns not immediately available, missing %v", missingIndices)
+}
+
+// areBlobsImmediatelyAvailable checks if all required blobs are currently
+// available in the database without waiting for missing ones.
+func (s *Service) areBlobsImmediatelyAvailable(ctx context.Context, root [fieldparams.RootLength]byte, block interfaces.ReadOnlyBeaconBlock) error {
+	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
+	if !params.WithinDAPeriod(slots.ToEpoch(block.Slot()), slots.ToEpoch(s.CurrentSlot())) {
+		return nil
+	}
+
+	body := block.Body()
+	if body == nil {
+		return errors.New("invalid nil beacon block body")
+	}
+	kzgCommitments, err := body.BlobKzgCommitments()
+	if err != nil {
+		return errors.Wrap(err, "could not get KZG commitments")
+	}
+	// expected is the number of kzg commitments observed in the block.
+	expected := len(kzgCommitments)
+	if expected == 0 {
+		return nil
+	}
+	// get a map of BlobSidecar indices that are not currently available.
+	missing, err := missingBlobIndices(s.blobStorage, root, kzgCommitments, block.Slot())
+	if err != nil {
+		return errors.Wrap(err, "missing indices")
+	}
+	// If there are no missing indices, all BlobSidecars are available.
+	if len(missing) == 0 {
+		return nil
+	}
+
+	// If any blobs are missing, return error immediately (don't wait)
+	missingIndices := uint64MapToSortedSlice(missing)
+	return fmt.Errorf("blobs not immediately available, missing %v", missingIndices)
+}
+
 // uint64MapToSortedSlice produces a sorted uint64 slice from a map.
 func uint64MapToSortedSlice(input map[uint64]bool) []uint64 {
 	output := make([]uint64, 0, len(input))

beacon-chain/blockchain/process_block_test.go

@@ -35,6 +35,7 @@ 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"
@@ -1980,14 +1981,15 @@ 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")
-	genesis := blocks.NewGenesisBlock(stateRoot[:])
-	wsb, err := consensusblocks.NewSignedBeaconBlock(genesis)
+	gb := blocks.NewGenesisBlock(stateRoot[:])
+	wsb, err := consensusblocks.NewSignedBeaconBlock(gb)
 	require.NoError(t, err)
-	genesisRoot, err := genesis.Block.HashTreeRoot()
+	genesisRoot, err := gb.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")
@@ -2887,14 +2889,13 @@ func TestIsDataAvailable(t *testing.T) {
 	})
 
 	t.Run("Fulu - more than half of the columns in custody", func(t *testing.T) {
-		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct)
 		for i := range minimumColumnsCountToReconstruct {
 			indices = append(indices, i)
 		}
 
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
@@ -2907,7 +2908,6 @@ func TestIsDataAvailable(t *testing.T) {
 
 	t.Run("Fulu - no missing data columns", func(t *testing.T) {
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
 			columnsToSave:           []uint64{1, 17, 19, 42, 75, 87, 102, 117, 119}, // 119 is not needed
 			blobKzgCommitmentsCount: 3,
 		}
@@ -2922,7 +2922,7 @@ func TestIsDataAvailable(t *testing.T) {
 		startWaiting := make(chan bool)
 
 		testParams := testIsAvailableParams{
-			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:       []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
 
 			blobKzgCommitmentsCount: 3,
@@ -2959,6 +2959,9 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
+		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
+		defer cancel()
+
 		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
@@ -2971,11 +2974,7 @@ func TestIsDataAvailable(t *testing.T) {
 
 		startWaiting := make(chan bool)
 
-		var custodyInfo peerdas.CustodyInfo
-		custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(cgc)
-		custodyInfo.ToAdvertiseGroupCount.Set(cgc)
-
-		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnCountToReconstruct()
 		indices := make([]uint64, 0, minimumColumnsCountToReconstruct-missingColumns)
 
 		for i := range minimumColumnsCountToReconstruct - missingColumns {
@@ -2983,12 +2982,14 @@ func TestIsDataAvailable(t *testing.T) {
 		}
 
 		testParams := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&custodyInfo), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
 			columnsToSave:           indices,
 			blobKzgCommitmentsCount: 3,
 		}
 
 		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
+		_, _, err := service.cfg.P2P.UpdateCustodyInfo(0, cgc)
+		require.NoError(t, err)
 		block := signed.Block()
 		slot := block.Slot()
 		proposerIndex := block.ProposerIndex()
@@ -3020,6 +3021,9 @@ func TestIsDataAvailable(t *testing.T) {
 			require.NoError(t, err)
 		}()
 
+		ctx, cancel := context.WithTimeout(ctx, time.Second*2)
+		defer cancel()
+
 		err = service.isDataAvailable(ctx, root, signed)
 		require.NoError(t, err)
 	})
@@ -3028,7 +3032,7 @@ func TestIsDataAvailable(t *testing.T) {
 		startWaiting := make(chan bool)
 
 		params := testIsAvailableParams{
-			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{}), WithStartWaitingDataColumnSidecars(startWaiting)},
+			options:                 []Option{WithStartWaitingDataColumnSidecars(startWaiting)},
 			blobKzgCommitmentsCount: 3,
 		}
 

beacon-chain/blockchain/receive_block.go

@@ -84,7 +84,11 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	}
 
 	receivedTime := time.Now()
-	s.blockBeingSynced.set(blockRoot)
+	err := s.blockBeingSynced.set(blockRoot)
+	if errors.Is(err, errBlockBeingSynced) {
+		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring block currently being synced")
+		return nil
+	}
 	defer s.blockBeingSynced.unset(blockRoot)
 
 	blockCopy, err := block.Copy()

beacon-chain/blockchain/receive_block_test.go

@@ -311,7 +311,10 @@ func TestService_HasBlock(t *testing.T) {
 	r, err = b.Block.HashTreeRoot()
 	require.NoError(t, err)
 	require.Equal(t, true, s.HasBlock(t.Context(), r))
-	s.blockBeingSynced.set(r)
+	err = s.blockBeingSynced.set(r)
+	require.NoError(t, err)
+	err = s.blockBeingSynced.set(r)
+	require.ErrorIs(t, err, errBlockBeingSynced)
 	require.Equal(t, false, s.HasBlock(t.Context(), r))
 }
 

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 sidecars")
+		return errors.Wrap(err, "save data column sidecar")
 	}
 
 	return nil

beacon-chain/blockchain/service.go

@@ -12,11 +12,9 @@ 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"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	coreTime "github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
@@ -31,6 +29,8 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
+	"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/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -38,12 +38,22 @@ import (
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	prysmTime "github.com/OffchainLabs/prysm/v6/time"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
+// DataAvailabilityChecker defines an interface for checking if data is available
+// for a given block root. This interface is implemented by the blockchain service
+// which has knowledge of the beacon chain's data availability requirements.
+// Returns nil if data is available, ErrDataNotAvailable if data is not available,
+// or another error for other failures.
+type DataAvailabilityChecker interface {
+	IsDataAvailable(ctx context.Context, blockRoot [32]byte, signedBlock interfaces.ReadOnlySignedBeaconBlock) error
+}
+
 // Service represents a service that handles the internal
 // logic of managing the full PoS beacon chain.
 type Service struct {
@@ -97,7 +107,6 @@ type config struct {
 	FinalizedStateAtStartUp state.BeaconState
 	ExecutionEngineCaller   execution.EngineCaller
 	SyncChecker             Checker
-	CustodyInfo             *peerdas.CustodyInfo
 }
 
 // Checker is an interface used to determine if a node is in initial sync
@@ -108,25 +117,32 @@ type Checker interface {
 
 var ErrMissingClockSetter = errors.New("blockchain Service initialized without a startup.ClockSetter")
 
+// ErrDataNotAvailable is returned when block data is not immediately available for processing.
+var ErrDataNotAvailable = errors.New("block data is not available")
+
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][]bool
+	// TODO: Separate blobs from data columns
+	// seenIndex map[[32]byte][]bool
+	seenIndex map[[32]byte][fieldparams.NumberOfColumns]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
 func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitives.Slot) {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
-	if idx >= uint64(maxBlobsPerBlock) {
-		return
-	}
+	// TODO: Separate blobs from data columns
+	// maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	// if idx >= uint64(maxBlobsPerBlock) {
+	// 	return
+	// }
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
-	if seen == nil {
-		seen = make([]bool, maxBlobsPerBlock)
-	}
+	// TODO: Separate blobs from data columns
+	// if seen == nil {
+	// seen = make([]bool, maxBlobsPerBlock)
+	// }
 	if seen[idx] {
 		bn.Unlock()
 		return
@@ -137,7 +153,9 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, maxBlobsPerBlock)
+		// TODO: Separate blobs from data columns
+		// c = make(chan uint64, maxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.NumberOfColumns)
 		bn.notifiers[root] = c
 	}
 
@@ -147,12 +165,15 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 }
 
 func (bn *blobNotifierMap) forRoot(root [32]byte, slot primitives.Slot) chan uint64 {
-	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	// TODO: Separate blobs from data columns
+	// maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	bn.Lock()
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, maxBlobsPerBlock)
+		// TODO: Separate blobs from data columns
+		// c = make(chan uint64, maxBlobsPerBlock)
+		c = make(chan uint64, fieldparams.NumberOfColumns)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -178,7 +199,9 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][]bool),
+		// TODO: Separate blobs from data columns
+		// seenIndex: make(map[[32]byte][]bool),
+		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
 	}
 	srv := &Service{
 		ctx:                    ctx,
@@ -208,17 +231,9 @@ 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 saved != nil && !saved.IsNil() {
-		if err := s.StartFromSavedState(saved); err != nil {
-			log.Fatal(err)
-		}
-	} else {
-		if err := s.startFromExecutionChain(); err != nil {
-			log.Fatal(err)
-		}
+	if err := s.StartFromSavedState(s.cfg.FinalizedStateAtStartUp); err != nil {
+		log.Fatal(err)
 	}
 	s.spawnProcessAttestationsRoutine()
 	go s.runLateBlockTasks()
@@ -267,6 +282,9 @@ 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())
@@ -296,6 +314,20 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	if err := s.clockSetter.SetClock(startup.NewClock(s.genesisTime, vr)); err != nil {
 		return errors.Wrap(err, "failed to initialize blockchain service")
 	}
+
+	if !params.FuluEnabled() {
+		return nil
+	}
+
+	earliestAvailableSlot, custodySubnetCount, err := s.updateCustodyInfoInDB(saved.Slot())
+	if err != nil {
+		return errors.Wrap(err, "could not get and save custody group count")
+	}
+
+	if _, _, err := s.cfg.P2P.UpdateCustodyInfo(earliestAvailableSlot, custodySubnetCount); err != nil {
+		return errors.Wrap(err, "update custody info")
+	}
+
 	return nil
 }
 
@@ -358,62 +390,6 @@ 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.
@@ -516,6 +492,83 @@ func (s *Service) removeStartupState() {
 	s.cfg.FinalizedStateAtStartUp = nil
 }
 
+// UpdateCustodyInfoInDB updates the custody information in the database.
+// It returns the (potentially updated) custody group count and the earliest available slot.
+func (s *Service) updateCustodyInfoInDB(slot primitives.Slot) (primitives.Slot, uint64, error) {
+	isSubscribedToAllDataSubnets := flags.Get().SubscribeAllDataSubnets
+
+	beaconConfig := params.BeaconConfig()
+	custodyRequirement := beaconConfig.CustodyRequirement
+
+	// Check if the node was previously subscribed to all data subnets, and if so,
+	// store the new status accordingly.
+	wasSubscribedToAllDataSubnets, err := s.cfg.BeaconDB.UpdateSubscribedToAllDataSubnets(s.ctx, isSubscribedToAllDataSubnets)
+	if err != nil {
+		log.WithError(err).Error("Could not update subscription status to all data subnets")
+	}
+
+	// Warn the user if the node was previously subscribed to all data subnets and is not any more.
+	if wasSubscribedToAllDataSubnets && !isSubscribedToAllDataSubnets {
+		log.Warnf(
+			"Because the flag `--%s` was previously used, the node will still subscribe to all data subnets.",
+			flags.SubscribeAllDataSubnets.Name,
+		)
+	}
+
+	// Compute the custody group count.
+	custodyGroupCount := custodyRequirement
+	if isSubscribedToAllDataSubnets {
+		custodyGroupCount = beaconConfig.NumberOfColumns
+	}
+
+	// Safely compute the fulu fork slot.
+	fuluForkSlot, err := fuluForkSlot()
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "fulu fork slot")
+	}
+
+	// If slot is before the fulu fork slot, then use the earliest stored slot as the reference slot.
+	if slot < fuluForkSlot {
+		slot, err = s.cfg.BeaconDB.EarliestSlot(s.ctx)
+		if err != nil {
+			return 0, 0, errors.Wrap(err, "earliest slot")
+		}
+	}
+
+	earliestAvailableSlot, custodyGroupCount, err := s.cfg.BeaconDB.UpdateCustodyInfo(s.ctx, slot, custodyGroupCount)
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "update custody info")
+	}
+
+	return earliestAvailableSlot, custodyGroupCount, nil
+}
+
+// IsDataAvailable implements the DataAvailabilityChecker interface for use by the execution service.
+// It checks if all required blob and data column data is immediately available in the database without waiting.
+func (s *Service) IsDataAvailable(ctx context.Context, blockRoot [fieldparams.RootLength]byte, signedBlock interfaces.ReadOnlySignedBeaconBlock) error {
+	block := signedBlock.Block()
+	if block == nil {
+		return errors.New("invalid nil beacon block")
+	}
+
+	blockVersion := block.Version()
+
+	if blockVersion >= version.Fulu {
+		if err := s.areDataColumnsImmediatelyAvailable(ctx, blockRoot, block); err != nil {
+			return errors.Wrap(ErrDataNotAvailable, err.Error())
+		}
+		return nil
+	}
+
+	if blockVersion >= version.Deneb {
+		if err := s.areBlobsImmediatelyAvailable(ctx, blockRoot, block); err != nil {
+			return errors.Wrap(ErrDataNotAvailable, err.Error())
+		}
+	}
+
+	return nil
+}
+
 func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db db.HeadAccessDatabase) {
 	currentTime := prysmTime.Now()
 	if currentTime.After(genesisTime) {
@@ -532,3 +585,19 @@ func spawnCountdownIfPreGenesis(ctx context.Context, genesisTime time.Time, db d
 	}
 	go slots.CountdownToGenesis(ctx, genesisTime, uint64(gState.NumValidators()), gRoot)
 }
+
+func fuluForkSlot() (primitives.Slot, error) {
+	beaconConfig := params.BeaconConfig()
+
+	fuluForkEpoch := beaconConfig.FuluForkEpoch
+	if fuluForkEpoch == beaconConfig.FarFutureEpoch {
+		return beaconConfig.FarFutureSlot, nil
+	}
+
+	forkFuluSlot, err := slots.EpochStart(fuluForkEpoch)
+	if err != nil {
+		return 0, errors.Wrap(err, "epoch start")
+	}
+
+	return forkFuluSlot, nil
+}

beacon-chain/blockchain/service_test.go

@@ -31,6 +31,7 @@ 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"
@@ -51,6 +52,7 @@ 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)
@@ -71,20 +73,22 @@ 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.
@@ -396,24 +400,6 @@ 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)
@@ -568,7 +554,9 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][]bool),
+		// TODO: Separate blobs from data columns
+		// seenIndex: make(map[[32]byte][]bool),
+		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 

beacon-chain/blockchain/setup_test.go

@@ -30,6 +30,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/libp2p/go-libp2p/core/peer"
 	"google.golang.org/protobuf/proto"
 )
 
@@ -54,6 +55,7 @@ type mockBroadcaster struct {
 
 type mockAccessor struct {
 	mockBroadcaster
+	mockCustodyManager
 	p2pTesting.MockPeerManager
 }
 
@@ -87,7 +89,7 @@ func (mb *mockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumn(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
+func (mb *mockBroadcaster) BroadcastDataColumnSidecar(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar) error {
 	mb.broadcastCalled = true
 	return nil
 }
@@ -97,6 +99,43 @@ func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.Sig
 
 var _ p2p.Broadcaster = (*mockBroadcaster)(nil)
 
+// mockCustodyManager is a mock implementation of p2p.CustodyManager
+type mockCustodyManager struct {
+	mut                   sync.RWMutex
+	earliestAvailableSlot primitives.Slot
+	custodyGroupCount     uint64
+}
+
+func (dch *mockCustodyManager) EarliestAvailableSlot() (primitives.Slot, error) {
+	dch.mut.RLock()
+	defer dch.mut.RUnlock()
+
+	return dch.earliestAvailableSlot, nil
+}
+
+func (dch *mockCustodyManager) CustodyGroupCount() (uint64, error) {
+	dch.mut.RLock()
+	defer dch.mut.RUnlock()
+
+	return dch.custodyGroupCount, nil
+}
+
+func (dch *mockCustodyManager) UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error) {
+	dch.mut.Lock()
+	defer dch.mut.Unlock()
+
+	dch.earliestAvailableSlot = earliestAvailableSlot
+	dch.custodyGroupCount = custodyGroupCount
+
+	return earliestAvailableSlot, custodyGroupCount, nil
+}
+
+func (dch *mockCustodyManager) CustodyGroupCountFromPeer(peer.ID) uint64 {
+	return 0
+}
+
+var _ p2p.CustodyManager = (*mockCustodyManager)(nil)
+
 type testServiceRequirements struct {
 	ctx     context.Context
 	db      db.Database

beacon-chain/blockchain/testing/mock.go

@@ -732,6 +732,11 @@ func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]b
 	return c.TargetRoot, nil
 }
 
+// IsDataAvailable implements the data availability checker interface for testing
+func (c *ChainService) IsDataAvailable(_ context.Context, _ [32]byte, _ interfaces.ReadOnlySignedBeaconBlock) error {
+	return nil
+}
+
 // MockSyncChecker is a mock implementation of blockchain.Checker.
 // We can't make an assertion here that this is true because that would create a circular dependency.
 type MockSyncChecker struct {

beacon-chain/builder/service.go

@@ -25,6 +25,7 @@ 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)
@@ -101,6 +102,22 @@ 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,21 +24,22 @@ 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
-	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
+	ErrSubmitBlindedBlockPostFulu 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.
@@ -115,3 +116,8 @@ 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/core/blocks/BUILD.bazel

@@ -41,7 +41,6 @@ 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/signature.go

@@ -11,7 +11,6 @@ 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"
@@ -101,7 +100,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 := forks.Fork(currentEpoch)
+	fork, err := params.Fork(currentEpoch)
 	if err != nil {
 		return err
 	}

beacon-chain/core/electra/withdrawals.go

@@ -102,13 +102,13 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 			return nil, err
 		} else if n == params.BeaconConfig().PendingPartialWithdrawalsLimit && !isFullExitRequest {
 			// if the PendingPartialWithdrawalsLimit is met, the user would have paid for a partial withdrawal that's not included
-			log.Debugln("Skipping execution layer withdrawal request, PendingPartialWithdrawalsLimit reached")
+			log.Debug("Skipping execution layer withdrawal request, PendingPartialWithdrawalsLimit reached")
 			continue
 		}
 
 		vIdx, exists := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(wr.ValidatorPubkey))
 		if !exists {
-			log.Debugf("Skipping execution layer withdrawal request, validator index for %s not found\n", hexutil.Encode(wr.ValidatorPubkey))
+			log.WithField("validator", hexutil.Encode(wr.ValidatorPubkey)).Debug("Skipping execution layer withdrawal request, validator index not found")
 			continue
 		}
 		validator, err := st.ValidatorAtIndexReadOnly(vIdx)
@@ -120,23 +120,23 @@ func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []
 		wc := validator.GetWithdrawalCredentials()
 		isCorrectSourceAddress := bytes.Equal(wc[12:], wr.SourceAddress)
 		if !hasCorrectCredential || !isCorrectSourceAddress {
-			log.Debugln("Skipping execution layer withdrawal request, wrong withdrawal credentials")
+			log.Debug("Skipping execution layer withdrawal request, wrong withdrawal credentials")
 			continue
 		}
 
 		// Verify the validator is active.
 		if !helpers.IsActiveValidatorUsingTrie(validator, currentEpoch) {
-			log.Debugln("Skipping execution layer withdrawal request, validator not active")
+			log.Debug("Skipping execution layer withdrawal request, validator not active")
 			continue
 		}
 		// Verify the validator has not yet submitted an exit.
 		if validator.ExitEpoch() != params.BeaconConfig().FarFutureEpoch {
-			log.Debugln("Skipping execution layer withdrawal request, validator has submitted an exit already")
+			log.Debug("Skipping execution layer withdrawal request, validator has submitted an exit already")
 			continue
 		}
 		// Verify the validator has been active long enough.
 		if currentEpoch < validator.ActivationEpoch().AddEpoch(params.BeaconConfig().ShardCommitteePeriod) {
-			log.Debugln("Skipping execution layer withdrawal request, validator has not been active long enough")
+			log.Debug("Skipping execution layer withdrawal request, validator has not been active long enough")
 			continue
 		}
 

beacon-chain/core/fulu/upgrade.go

@@ -15,7 +15,7 @@ import (
 )
 
 // UpgradeToFulu updates inputs a generic state to return the version Fulu state.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/fork.md#upgrading-the-state
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/fork.md#upgrading-the-state
 func UpgradeToFulu(ctx context.Context, beaconState state.BeaconState) (state.BeaconState, error) {
 	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
 	if err != nil {

beacon-chain/core/helpers/sync_committee_test.go

@@ -78,6 +78,7 @@ 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{
@@ -264,6 +265,7 @@ 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/peerdas/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
     deps = [
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/state:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -53,7 +52,6 @@ go_test(
         ":go_default_library",
         "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

beacon-chain/core/peerdas/das_core.go

@@ -31,15 +31,8 @@ var (
 	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
 )
 
-type CustodyType int
-
-const (
-	Target CustodyType = iota
-	Actual
-)
-
 // CustodyGroups computes the custody groups the node should participate in for custody.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/das-core.md#get_custody_groups
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#get_custody_groups
 func CustodyGroups(nodeId enode.ID, custodyGroupCount uint64) ([]uint64, error) {
 	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
 
@@ -102,7 +95,7 @@ func CustodyGroups(nodeId enode.ID, custodyGroupCount uint64) ([]uint64, error)
 }
 
 // ComputeColumnsForCustodyGroup computes the columns for a given custody group.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/das-core.md#compute_columns_for_custody_group
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/das-core.md#compute_columns_for_custody_group
 func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 	beaconConfig := params.BeaconConfig()
 	numberOfCustodyGroups := beaconConfig.NumberOfCustodyGroups
@@ -127,7 +120,7 @@ func ComputeColumnsForCustodyGroup(custodyGroup uint64) ([]uint64, error) {
 // DataColumnSidecars computes the data column sidecars from the signed block, cells and cell proofs.
 // The returned value contains pointers to function parameters.
 // (If the caller alterates `cellsAndProofs` afterwards, the returned value will be modified as well.)
-// https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.3/specs/fulu/validator.md#get_data_column_sidecars_from_block
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars_from_block
 func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsAndProofs []kzg.CellsAndProofs) ([]*ethpb.DataColumnSidecar, error) {
 	if signedBlock == nil || signedBlock.IsNil() || len(cellsAndProofs) == 0 {
 		return nil, nil
@@ -176,19 +169,6 @@ func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
 	return columnIndex % numberOfCustodyGroups, nil
 }
 
-// CustodyGroupSamplingSize returns the number of custody groups the node should sample from.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/das-core.md#custody-sampling
-func (custodyInfo *CustodyInfo) CustodyGroupSamplingSize(ct CustodyType) uint64 {
-	custodyGroupCount := custodyInfo.TargetGroupCount.Get()
-
-	if ct == Actual {
-		custodyGroupCount = custodyInfo.ActualGroupCount()
-	}
-
-	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
-	return max(samplesPerSlot, custodyGroupCount)
-}
-
 // CustodyColumns computes the custody columns from the custody groups.
 func CustodyColumns(custodyGroups []uint64) (map[uint64]bool, error) {
 	numberOfCustodyGroups := params.BeaconConfig().NumberOfCustodyGroups
@@ -219,7 +199,7 @@ func CustodyColumns(custodyGroups []uint64) (map[uint64]bool, error) {
 // the KZG commitment includion proofs and cells and cell proofs.
 // The returned value contains pointers to function parameters.
 // (If the caller alterates input parameters afterwards, the returned value will be modified as well.)
-// https://github.com/ethereum/consensus-specs/blob/v1.6.0-alpha.3/specs/fulu/validator.md#get_data_column_sidecars
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#get_data_column_sidecars
 func dataColumnsSidecars(
 	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
 	blobKzgCommitments [][]byte,
@@ -243,6 +223,14 @@ 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,6 +67,55 @@ 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) {
@@ -104,62 +153,6 @@ func TestComputeCustodyGroupForColumn(t *testing.T) {
 	})
 }
 
-func TestCustodyGroupSamplingSize(t *testing.T) {
-	testCases := []struct {
-		name                         string
-		custodyType                  peerdas.CustodyType
-		validatorsCustodyRequirement uint64
-		toAdvertiseCustodyGroupCount uint64
-		expected                     uint64
-	}{
-		{
-			name:                         "target, lower than samples per slot",
-			custodyType:                  peerdas.Target,
-			validatorsCustodyRequirement: 2,
-			expected:                     8,
-		},
-		{
-			name:                         "target, higher than samples per slot",
-			custodyType:                  peerdas.Target,
-			validatorsCustodyRequirement: 100,
-			expected:                     100,
-		},
-		{
-			name:                         "actual, lower than samples per slot",
-			custodyType:                  peerdas.Actual,
-			validatorsCustodyRequirement: 3,
-			toAdvertiseCustodyGroupCount: 4,
-			expected:                     8,
-		},
-		{
-			name:                         "actual, higher than samples per slot",
-			custodyType:                  peerdas.Actual,
-			validatorsCustodyRequirement: 100,
-			toAdvertiseCustodyGroupCount: 101,
-			expected:                     100,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Create a custody info.
-			custodyInfo := peerdas.CustodyInfo{}
-
-			// Set the validators custody requirement for target custody group count.
-			custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(tc.validatorsCustodyRequirement)
-
-			// Set the to advertise custody group count.
-			custodyInfo.ToAdvertiseGroupCount.Set(tc.toAdvertiseCustodyGroupCount)
-
-			// Compute the custody group sampling size.
-			actual := custodyInfo.CustodyGroupSamplingSize(tc.custodyType)
-
-			// Check the result.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}
-
 func TestCustodyColumns(t *testing.T) {
 	t.Run("group too large", func(t *testing.T) {
 		_, err := peerdas.CustodyColumns([]uint64{1_000_000})

beacon-chain/core/peerdas/info.go

@@ -4,45 +4,17 @@ import (
 	"encoding/binary"
 	"sync"
 
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/pkg/errors"
 )
 
 // info contains all useful peerDAS related information regarding a peer.
-type (
-	info struct {
-		CustodyGroups      map[uint64]bool
-		CustodyColumns     map[uint64]bool
-		DataColumnsSubnets map[uint64]bool
-	}
-
-	targetCustodyGroupCount struct {
-		mut                          sync.RWMutex
-		validatorsCustodyRequirement uint64
-	}
-
-	toAdverstiseCustodyGroupCount struct {
-		mut   sync.RWMutex
-		value uint64
-	}
-
-	CustodyInfo struct {
-		// Mut is a mutex to be used by caller to ensure neither
-		// TargetCustodyGroupCount nor ToAdvertiseCustodyGroupCount are being modified.
-		// (This is not necessary to use this mutex for any data protection.)
-		Mut sync.RWMutex
-
-		// TargetGroupCount represents the target number of custody groups we should custody
-		// regarding the validators we are tracking.
-		TargetGroupCount targetCustodyGroupCount
-
-		// ToAdvertiseGroupCount represents the number of custody groups to advertise to the network.
-		ToAdvertiseGroupCount toAdverstiseCustodyGroupCount
-	}
-)
+type info struct {
+	CustodyGroups      map[uint64]bool
+	CustodyColumns     map[uint64]bool
+	DataColumnsSubnets map[uint64]bool
+}
 
 const (
 	nodeInfoCacheSize   = 200
@@ -109,61 +81,6 @@ func Info(nodeID enode.ID, custodyGroupCount uint64) (*info, bool, error) {
 	return result, false, nil
 }
 
-// ActualGroupCount returns the actual custody group count.
-func (custodyInfo *CustodyInfo) ActualGroupCount() uint64 {
-	return min(custodyInfo.TargetGroupCount.Get(), custodyInfo.ToAdvertiseGroupCount.Get())
-}
-
-// CustodyGroupCount returns the number of groups we should participate in for custody.
-func (tcgc *targetCustodyGroupCount) Get() uint64 {
-	// If subscribed to all subnets, return the number of custody groups.
-	if flags.Get().SubscribeAllDataSubnets {
-		return params.BeaconConfig().NumberOfCustodyGroups
-	}
-
-	tcgc.mut.RLock()
-	defer tcgc.mut.RUnlock()
-
-	// If no validators are tracked, return the default custody requirement.
-	if tcgc.validatorsCustodyRequirement == 0 {
-		return params.BeaconConfig().CustodyRequirement
-	}
-
-	// Return the validators custody requirement.
-	return tcgc.validatorsCustodyRequirement
-}
-
-// setValidatorsCustodyRequirement sets the validators custody requirement.
-func (tcgc *targetCustodyGroupCount) SetValidatorsCustodyRequirement(value uint64) {
-	tcgc.mut.Lock()
-	defer tcgc.mut.Unlock()
-
-	tcgc.validatorsCustodyRequirement = value
-}
-
-// Get returns the to advertise custody group count.
-func (tacgc *toAdverstiseCustodyGroupCount) Get() uint64 {
-	// If subscribed to all subnets, return the number of custody groups.
-	if flags.Get().SubscribeAllDataSubnets {
-		return params.BeaconConfig().NumberOfCustodyGroups
-	}
-
-	custodyRequirement := params.BeaconConfig().CustodyRequirement
-
-	tacgc.mut.RLock()
-	defer tacgc.mut.RUnlock()
-
-	return max(tacgc.value, custodyRequirement)
-}
-
-// Set sets the to advertise custody group count.
-func (tacgc *toAdverstiseCustodyGroupCount) Set(value uint64) {
-	tacgc.mut.Lock()
-	defer tacgc.mut.Unlock()
-
-	tacgc.value = value
-}
-
 // createInfoCacheIfNeeded creates a new cache if it doesn't exist.
 func createInfoCacheIfNeeded() error {
 	nodeInfoCacheMut.Lock()

beacon-chain/core/peerdas/info_test.go

@@ -4,7 +4,6 @@ import (
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 )
@@ -26,108 +25,3 @@ func TestInfo(t *testing.T) {
 		require.DeepEqual(t, expectedDataColumnsSubnets, actual.DataColumnsSubnets)
 	}
 }
-
-func TestTargetCustodyGroupCount(t *testing.T) {
-	testCases := []struct {
-		name                         string
-		subscribeToAllColumns        bool
-		validatorsCustodyRequirement uint64
-		expected                     uint64
-	}{
-		{
-			name:                         "subscribed to all data subnets",
-			subscribeToAllColumns:        true,
-			validatorsCustodyRequirement: 100,
-			expected:                     128,
-		},
-		{
-			name:                         "no validators attached",
-			subscribeToAllColumns:        false,
-			validatorsCustodyRequirement: 0,
-			expected:                     4,
-		},
-		{
-			name:                         "some validators attached",
-			subscribeToAllColumns:        false,
-			validatorsCustodyRequirement: 100,
-			expected:                     100,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Subscribe to all subnets if needed.
-			if tc.subscribeToAllColumns {
-				resetFlags := flags.Get()
-				gFlags := new(flags.GlobalFlags)
-				gFlags.SubscribeAllDataSubnets = true
-				flags.Init(gFlags)
-				defer flags.Init(resetFlags)
-			}
-
-			var custodyInfo peerdas.CustodyInfo
-
-			// Set the validators custody requirement.
-			custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(tc.validatorsCustodyRequirement)
-
-			// Get the target custody group count.
-			actual := custodyInfo.TargetGroupCount.Get()
-
-			// Compare the expected and actual values.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}
-
-func TestToAdvertiseCustodyGroupCount(t *testing.T) {
-	testCases := []struct {
-		name                         string
-		subscribeToAllColumns        bool
-		toAdvertiseCustodyGroupCount uint64
-		expected                     uint64
-	}{
-		{
-			name:                         "subscribed to all subnets",
-			subscribeToAllColumns:        true,
-			toAdvertiseCustodyGroupCount: 100,
-			expected:                     128,
-		},
-		{
-			name:                         "higher than custody requirement",
-			subscribeToAllColumns:        false,
-			toAdvertiseCustodyGroupCount: 100,
-			expected:                     100,
-		},
-		{
-			name:                         "lower than custody requirement",
-			subscribeToAllColumns:        false,
-			toAdvertiseCustodyGroupCount: 1,
-			expected:                     4,
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			// Subscribe to all subnets if needed.
-			if tc.subscribeToAllColumns {
-				resetFlags := flags.Get()
-				gFlags := new(flags.GlobalFlags)
-				gFlags.SubscribeAllDataSubnets = true
-				flags.Init(gFlags)
-				defer flags.Init(resetFlags)
-			}
-
-			// Create a custody info.
-			var custodyInfo peerdas.CustodyInfo
-
-			// Set the to advertise custody group count.
-			custodyInfo.ToAdvertiseGroupCount.Set(tc.toAdvertiseCustodyGroupCount)
-
-			// Get the to advertise custody group count.
-			actual := custodyInfo.ToAdvertiseGroupCount.Get()
-
-			// Compare the expected and actual values.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-}

beacon-chain/core/peerdas/p2p_interface.go

@@ -10,10 +10,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-const (
-	CustodyGroupCountEnrKey = "cgc"
-	kzgPosition             = 11 // The index of the KZG commitment list in the Body
-)
+const kzgPosition = 11 // The index of the KZG commitment list in the Body
 
 var (
 	ErrIndexTooLarge               = errors.New("column index is larger than the specified columns count")
@@ -27,13 +24,13 @@ var (
 	ErrCannotLoadCustodyGroupCount = errors.New("cannot load the custody group count from peer")
 )
 
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#custody-group-count
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#custody-group-count
 type Cgc uint64
 
-func (Cgc) ENRKey() string { return CustodyGroupCountEnrKey }
+func (Cgc) ENRKey() string { return params.BeaconNetworkConfig().CustodyGroupCountKey }
 
 // VerifyDataColumnSidecar verifies if the data column sidecar is valid.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#verify_data_column_sidecar
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar
 func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 	// The sidecar index must be within the valid range.
 	numberOfColumns := params.BeaconConfig().NumberOfColumns
@@ -60,7 +57,7 @@ func VerifyDataColumnSidecar(sidecar blocks.RODataColumn) error {
 // while we are verifying all the KZG proofs from multiple sidecars in a batch.
 // This is done to improve performance since the internal KZG library is way more
 // efficient when verifying in batch.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_kzg_proofs
 func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
 	// Compute the total count.
 	count := 0
@@ -96,7 +93,7 @@ func VerifyDataColumnsSidecarKZGProofs(sidecars []blocks.RODataColumn) error {
 }
 
 // VerifyDataColumnSidecarInclusionProof verifies if the given KZG commitments included in the given beacon block.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#verify_data_column_sidecar_inclusion_proof
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#verify_data_column_sidecar_inclusion_proof
 func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
 	if sidecar.SignedBlockHeader == nil || sidecar.SignedBlockHeader.Header == nil {
 		return ErrNilBlockHeader
@@ -128,7 +125,7 @@ func VerifyDataColumnSidecarInclusionProof(sidecar blocks.RODataColumn) error {
 }
 
 // ComputeSubnetForDataColumnSidecar computes the subnet for a data column sidecar.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#compute_subnet_for_data_column_sidecar
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/p2p-interface.md#compute_subnet_for_data_column_sidecar
 func ComputeSubnetForDataColumnSidecar(columnIndex uint64) uint64 {
 	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
 	return columnIndex % dataColumnSidecarSubnetCount

beacon-chain/core/peerdas/reconstruction.go

@@ -18,8 +18,8 @@ var (
 	ErrBlobsCellsProofsMismatch = errors.New("blobs and cells proofs mismatch")
 )
 
-// MinimumColumnsCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
-func MinimumColumnsCountToReconstruct() uint64 {
+// MinimumColumnCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
+func MinimumColumnCountToReconstruct() 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) < MinimumColumnsCountToReconstruct() {
+	if uint64(sidecarCount) < MinimumColumnCountToReconstruct() {
 		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.MinimumColumnsCountToReconstruct()
+			actual := peerdas.MinimumColumnCountToReconstruct()
 			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.MinimumColumnsCountToReconstruct()
+		minimum := peerdas.MinimumColumnCountToReconstruct()
 		_, err := peerdas.ReconstructDataColumnSidecars(verifiedRoSidecars[:minimum-1])
 		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
 	})

beacon-chain/core/peerdas/validator.go

@@ -8,7 +8,7 @@ import (
 )
 
 // ValidatorsCustodyRequirement returns the number of custody groups regarding the validator indices attached to the beacon node.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/validator.md#validator-custody
+// https://github.com/ethereum/consensus-specs/blob/master/specs/fulu/validator.md#validator-custody
 func ValidatorsCustodyRequirement(state beaconState.ReadOnlyBeaconState, validatorsIndex map[primitives.ValidatorIndex]bool) (uint64, error) {
 	totalNodeBalance := uint64(0)
 	for index := range validatorsIndex {

beacon-chain/core/signing/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "domain.go",
-        "signature.go",
         "signing_root.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing",
@@ -25,7 +24,6 @@ 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

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

@@ -1,42 +0,0 @@
-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/das/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "availability_blobs.go",
-        "availability_columns.go",
         "blob_cache.go",
         "data_column_cache.go",
         "iface.go",
@@ -13,7 +12,6 @@ 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",
@@ -23,7 +21,6 @@ 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",
     ],
@@ -33,16 +30,13 @@ go_test(
     name = "go_default_test",
     srcs = [
         "availability_blobs_test.go",
-        "availability_columns_test.go",
         "blob_cache_test.go",
         "data_column_cache_test.go",
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/verification:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -51,7 +45,6 @@ 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,30 +53,25 @@ 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.ROSidecar) error {
+func (s *LazilyPersistentStoreBlob) Persist(current primitives.Slot, sidecars ...blocks.ROBlob) error {
 	if len(sidecars) == 0 {
 		return nil
 	}
 
-	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 len(sidecars) > 1 {
+		firstRoot := sidecars[0].BlockRoot()
+		for _, sidecar := range sidecars[1:] {
 			if sidecar.BlockRoot() != firstRoot {
 				return errMixedRoots
 			}
 		}
 	}
-	if !params.WithinDAPeriod(slots.ToEpoch(blobSidecars[0].Slot()), slots.ToEpoch(current)) {
+	if !params.WithinDAPeriod(slots.ToEpoch(sidecars[0].Slot()), slots.ToEpoch(current)) {
 		return nil
 	}
-	key := keyFromSidecar(blobSidecars[0])
+	key := keyFromSidecar(sidecars[0])
 	entry := s.cache.ensure(key)
-	for _, blobSidecar := range blobSidecars {
+	for _, blobSidecar := range sidecars {
 		if err := entry.stash(&blobSidecar); err != nil {
 			return err
 		}

beacon-chain/das/availability_blobs_test.go

@@ -118,23 +118,21 @@ 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, scs[2]))
+	require.NoError(t, as.Persist(1, blobSidecars[2]))
 	err := as.IsDataAvailable(ctx, 1, blk)
 	require.ErrorIs(t, err, errMissingSidecar)
 
 	// All but one persisted, return missing idx
-	require.NoError(t, as.Persist(1, scs[0]))
+	require.NoError(t, as.Persist(1, blobSidecars[0]))
 	err = as.IsDataAvailable(ctx, 1, blk)
 	require.ErrorIs(t, err, errMissingSidecar)
 
 	// All persisted, return nil
-	require.NoError(t, as.Persist(1, scs...))
+	require.NoError(t, as.Persist(1, blobSidecars...))
 
 	require.NoError(t, as.IsDataAvailable(ctx, 1, blk))
 }
@@ -149,10 +147,8 @@ 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, scs[0]))
+	require.NoError(t, as.Persist(1, blobSidecars[0]))
 	err := as.IsDataAvailable(ctx, 1, blk)
 	require.NotNil(t, err)
 	require.ErrorIs(t, err, errCommitmentMismatch)
@@ -161,29 +157,25 @@ 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, scs...))
+	require.NoError(t, as.Persist(1, blobSidecars...))
 	// ignores duplicates
-	require.ErrorIs(t, as.Persist(1, scs...), ErrDuplicateSidecar)
+	require.ErrorIs(t, as.Persist(1, blobSidecars...), ErrDuplicateSidecar)
 
 	// ignores index out of bound
 	blobSidecars[0].Index = 6
-	require.ErrorIs(t, as.Persist(1, blocks.NewSidecarFromBlobSidecar(blobSidecars[0])), errIndexOutOfBounds)
+	require.ErrorIs(t, as.Persist(1, 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, more[0]))
+	require.NoError(t, as.Persist(32+slotOOB, moreBlobSidecars[0]))
 
 	// doesn't ignore new sidecars with a different block root
-	require.NoError(t, as.Persist(1, more...))
+	require.NoError(t, as.Persist(1, moreBlobSidecars...))
 }
 
 type mockBlobBatchVerifier struct {

beacon-chain/das/availability_columns.go

@@ -1,208 +0,0 @@
-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
-	custodyInfo            *peerdas.CustodyInfo
-	newDataColumnsVerifier verification.NewDataColumnsVerifier
-}
-
-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, custodyInfo *peerdas.CustodyInfo) *LazilyPersistentStoreColumn {
-	return &LazilyPersistentStoreColumn{
-		store:                  store,
-		nodeID:                 nodeID,
-		cache:                  newDataColumnCache(),
-		custodyInfo:            custodyInfo,
-		newDataColumnsVerifier: newDataColumnsVerifier,
-	}
-}
-
-// 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) {
-	// 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 the groups count.
-	custodyGroupCount := s.custodyInfo.ActualGroupCount()
-
-	// Retrieve peer info.
-	peerInfo, _, err := peerdas.Info(nodeID, custodyGroupCount)
-	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

@@ -1,319 +0,0 @@
-package das
-
-import (
-	"context"
-	"testing"
-
-	"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/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/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, &peerdas.CustodyInfo{})
-		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, &peerdas.CustodyInfo{})
-
-		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, &peerdas.CustodyInfo{})
-
-		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, &peerdas.CustodyInfo{})
-
-		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, &peerdas.CustodyInfo{})
-
-		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, &peerdas.CustodyInfo{})
-
-		indices := [...]uint64{1, 17, 87, 102}
-		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) {
-			resetFlags := flags.Get()
-			gFlags := new(flags.GlobalFlags)
-			gFlags.SubscribeAllDataSubnets = true
-			flags.Init(gFlags)
-			defer flags.Init(resetFlags)
-
-			b := tc.block(t)
-			s := NewLazilyPersistentStoreColumn(nil, enode.ID{}, nil, &peerdas.CustodyInfo{})
-
-			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,20 +99,26 @@ 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 e.scs[i] != nil {
-				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, e.scs[i].KzgCommitment)
+			if sidecar != nil {
+				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, sidecar.KzgCommitment)
 			}
 			continue
 		}
 
-		if e.scs[i] == nil {
+		if sidecar == nil {
 			return nil, errors.Wrapf(errMissingSidecar, "root=%#x, index=%#x", root, 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])
+		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])
 		}
-		scs = append(scs, *e.scs[i])
+		scs = append(scs, *sidecar)
 	}
 
 	return scs, nil

beacon-chain/das/blob_cache_test.go

@@ -155,6 +155,41 @@ 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, sc ...blocks.ROSidecar) error
+	Persist(current primitives.Slot, blobSidecar ...blocks.ROBlob) error
 }

beacon-chain/das/mock.go

@@ -5,13 +5,12 @@ 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, sc ...blocks.ROBlob) error
+	PersistBlobsCallback       func(current primitives.Slot, blobSidecar ...blocks.ROBlob) error
 }
 
 var _ AvailabilityStore = &MockAvailabilityStore{}
@@ -25,13 +24,9 @@ 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, sc ...blocks.ROSidecar) error {
-	blobSidecars, err := blocks.BlobSidecarsFromSidecars(sc)
-	if err != nil {
-		return errors.Wrap(err, "blob sidecars from sidecars")
-	}
+func (m *MockAvailabilityStore) Persist(current primitives.Slot, blobSidecar ...blocks.ROBlob) error {
 	if m.PersistBlobsCallback != nil {
-		return m.PersistBlobsCallback(current, blobSidecars...)
+		return m.PersistBlobsCallback(current, blobSidecar...)
 	}
 	return nil
 }

beacon-chain/db/BUILD.bazel

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

beacon-chain/db/alias.go

@@ -10,6 +10,11 @@ type ReadOnlyDatabase = iface.ReadOnlyDatabase
 // about head info. For head info, use github.com/prysmaticlabs/prysm/blockchain.HeadFetcher.
 type NoHeadAccessDatabase = iface.NoHeadAccessDatabase
 
+// ReadOnlyDatabaseWithSeqNum exposes Prysm's Ethereum data backend for read access only, no information about
+// head info, but with read/write access to the p2p metadata sequence number.
+// This is used for the p2p service.
+type ReadOnlyDatabaseWithSeqNum = iface.ReadOnlyDatabaseWithSeqNum
+
 // HeadAccessDatabase exposes Prysm's Ethereum backend for read/write access with information about
 // chain head information. This interface should be used sparingly as the HeadFetcher is the source
 // of truth around chain head information while this interface serves as persistent storage for the

beacon-chain/db/filesystem/data_column.go

@@ -100,6 +100,14 @@ 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,12 +84,6 @@ 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
@@ -98,8 +92,6 @@ 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/mock.go

@@ -144,14 +144,3 @@ 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/iface/interface.go

@@ -33,6 +33,7 @@ type ReadOnlyDatabase interface {
 	IsFinalizedBlock(ctx context.Context, blockRoot [32]byte) bool
 	FinalizedChildBlock(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error)
 	HighestRootsBelowSlot(ctx context.Context, slot primitives.Slot) (primitives.Slot, [][32]byte, error)
+	EarliestSlot(ctx context.Context) (primitives.Slot, error)
 	// State related methods.
 	State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
 	StateOrError(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error)
@@ -56,14 +57,25 @@ type ReadOnlyDatabase interface {
 	// Fee recipients operations.
 	FeeRecipientByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (common.Address, error)
 	RegistrationByValidatorID(ctx context.Context, id primitives.ValidatorIndex) (*ethpb.ValidatorRegistrationV1, error)
-	// light client operations
+	// Light client operations
 	LightClientUpdates(ctx context.Context, startPeriod, endPeriod uint64) (map[uint64]interfaces.LightClientUpdate, error)
 	LightClientUpdate(ctx context.Context, period uint64) (interfaces.LightClientUpdate, error)
 	LightClientBootstrap(ctx context.Context, blockRoot []byte) (interfaces.LightClientBootstrap, error)
-
-	// origin checkpoint sync support
+	// Origin checkpoint sync support
 	OriginCheckpointBlockRoot(ctx context.Context) ([32]byte, error)
 	BackfillStatus(context.Context) (*dbval.BackfillStatus, error)
+
+	// P2P Metadata operations.
+	MetadataSeqNum(ctx context.Context) (uint64, error)
+}
+
+// ReadOnlyDatabaseWithSeqNum defines a struct which has read access to database methods
+// and also has read/write access to the p2p metadata sequence number.
+// Only used for the p2p service.
+type ReadOnlyDatabaseWithSeqNum interface {
+	ReadOnlyDatabase
+
+	SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error
 }
 
 // NoHeadAccessDatabase defines a struct without access to chain head data.
@@ -102,6 +114,24 @@ 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)
+
+	// P2P Metadata operations.
+	SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error
 }
 
 // HeadAccessDatabase defines a struct with access to reading chain head data.
@@ -112,16 +142,6 @@ 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

@@ -8,6 +8,7 @@ go_library(
         "backup.go",
         "blocks.go",
         "checkpoint.go",
+        "custody.go",
         "deposit_contract.go",
         "encoding.go",
         "error.go",
@@ -23,6 +24,7 @@ go_library(
         "migration_block_slot_index.go",
         "migration_finalized_parent.go",
         "migration_state_validators.go",
+        "p2p.go",
         "schema.go",
         "state.go",
         "state_summary.go",
@@ -38,7 +40,6 @@ 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",
@@ -50,6 +51,7 @@ 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",
@@ -83,6 +85,7 @@ go_test(
         "backup_test.go",
         "blocks_test.go",
         "checkpoint_test.go",
+        "custody_test.go",
         "deposit_contract_test.go",
         "encoding_test.go",
         "execution_chain_test.go",
@@ -94,6 +97,7 @@ go_test(
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
+        "p2p_test.go",
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",
@@ -106,7 +110,6 @@ 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",
@@ -116,6 +119,7 @@ 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/blocks.go

@@ -860,6 +860,47 @@ func (s *Store) SaveRegistrationsByValidatorIDs(ctx context.Context, ids []primi
 	})
 }
 
+// EarliestStoredSlot returns the earliest slot in the database.
+func (s *Store) EarliestSlot(ctx context.Context) (primitives.Slot, error) {
+	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+	_, span := trace.StartSpan(ctx, "BeaconDB.EarliestSlot")
+	defer span.End()
+
+	earliestAvailableSlot := primitives.Slot(0)
+	err := s.db.View(func(tx *bolt.Tx) error {
+		// Retrieve the root corresponding to the earliest available block.
+		c := tx.Bucket(blockSlotIndicesBucket).Cursor()
+		k, v := c.First()
+		if k == nil || v == nil {
+			return ErrNotFound
+		}
+		slot := bytesutil.BytesToSlotBigEndian(k)
+
+		// The genesis block may be indexed in this bucket, even if we started from a checkpoint.
+		// Because of this, we check the next block. If the next block is still in the genesis epoch,
+		// then we consider we have the whole chain.
+		if slot != 0 {
+			earliestAvailableSlot = slot
+		}
+
+		k, v = c.Next()
+		if k == nil || v == nil {
+			// Only the genesis block is available.
+			return nil
+		}
+		slot = bytesutil.BytesToSlotBigEndian(k)
+		if slot < slotsPerEpoch {
+			// We are still in the genesis epoch, so we consider we have the whole chain.
+			return nil
+		}
+
+		earliestAvailableSlot = slot
+		return nil
+	})
+
+	return earliestAvailableSlot, err
+}
+
 type slotRoot struct {
 	slot primitives.Slot
 	root [32]byte
@@ -883,7 +924,7 @@ func (s *Store) slotRootsInRange(ctx context.Context, start, end primitives.Slot
 		c := bkt.Cursor()
 		for k, v := c.Seek(key); ; /* rely on internal checks to exit */ k, v = c.Prev() {
 			if len(k) == 0 && len(v) == 0 {
-				// The `edge`` variable and this `if` deal with 2 edge cases:
+				// The `edge` variable and this `if` deal with 2 edge cases:
 				// - Seeking past the end of the bucket (the `end` param is higher than the highest slot).
 				// - Seeking before the beginning of the bucket (the `start` param is lower than the lowest slot).
 				// In both of these cases k,v will be nil and we can handle the same way using `edge` to

beacon-chain/db/kv/blocks_test.go

@@ -1,6 +1,7 @@
 package kv
 
 import (
+	"context"
 	"fmt"
 	"testing"
 	"time"
@@ -1327,3 +1328,86 @@ func TestStore_RegistrationsByValidatorID(t *testing.T) {
 	want := errors.Wrap(ErrNotFoundFeeRecipient, "validator id 3")
 	require.Equal(t, want.Error(), err.Error())
 }
+
+// Block creates a phase0 beacon block at the specified slot and saves it to the database.
+func createAndSaveBlock(t *testing.T, ctx context.Context, db *Store, slot primitives.Slot) {
+	block := util.NewBeaconBlock()
+	block.Block.Slot = slot
+
+	wrappedBlock, err := blocks.NewSignedBeaconBlock(block)
+	require.NoError(t, err)
+	require.NoError(t, db.SaveBlock(ctx, wrappedBlock))
+}
+
+func TestStore_EarliestSlot(t *testing.T) {
+	ctx := t.Context()
+
+	t.Run("empty database returns ErrNotFound", func(t *testing.T) {
+		db := setupDB(t)
+
+		slot, err := db.EarliestSlot(ctx)
+		require.ErrorIs(t, err, ErrNotFound)
+		assert.Equal(t, primitives.Slot(0), slot)
+	})
+
+	t.Run("database with only genesis block", func(t *testing.T) {
+		db := setupDB(t)
+
+		// Create and save genesis block (slot 0)
+		createAndSaveBlock(t, ctx, db, 0)
+
+		slot, err := db.EarliestSlot(ctx)
+		require.NoError(t, err)
+		assert.Equal(t, primitives.Slot(0), slot)
+	})
+
+	t.Run("database with genesis and blocks in genesis epoch", func(t *testing.T) {
+		db := setupDB(t)
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+
+		// Create and save genesis block (slot 0)
+		createAndSaveBlock(t, ctx, db, 0)
+
+		// Create and save a block in the genesis epoch
+		createAndSaveBlock(t, ctx, db, primitives.Slot(slotsPerEpoch-1))
+
+		slot, err := db.EarliestSlot(ctx)
+		require.NoError(t, err)
+		assert.Equal(t, primitives.Slot(0), slot)
+	})
+
+	t.Run("database with genesis and blocks beyond genesis epoch", func(t *testing.T) {
+		db := setupDB(t)
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+
+		// Create and save genesis block (slot 0)
+		createAndSaveBlock(t, ctx, db, 0)
+
+		// Create and save a block beyond the genesis epoch
+		nextEpochSlot := primitives.Slot(slotsPerEpoch)
+		createAndSaveBlock(t, ctx, db, nextEpochSlot)
+
+		slot, err := db.EarliestSlot(ctx)
+		require.NoError(t, err)
+		assert.Equal(t, nextEpochSlot, slot)
+	})
+
+	t.Run("database starting from checkpoint (non-zero earliest slot)", func(t *testing.T) {
+		db := setupDB(t)
+		slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
+
+		// Simulate starting from a checkpoint by creating blocks starting from a later slot
+		checkpointSlot := primitives.Slot(slotsPerEpoch * 10) // 10 epochs later
+		nextEpochSlot := checkpointSlot + slotsPerEpoch
+
+		// Create and save first block at checkpoint slot
+		createAndSaveBlock(t, ctx, db, checkpointSlot)
+
+		// Create and save another block in the next epoch
+		createAndSaveBlock(t, ctx, db, nextEpochSlot)
+
+		slot, err := db.EarliestSlot(ctx)
+		require.NoError(t, err)
+		assert.Equal(t, nextEpochSlot, slot)
+	})
+}

beacon-chain/db/kv/custody.go

@@ -0,0 +1,129 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
+	bolt "go.etcd.io/bbolt"
+)
+
+// UpdateCustodyInfo atomically updates the custody group count only it is greater than the stored one.
+// In this case, it also updates the earliest available slot with the provided value.
+// It returns the (potentially updated) custody group count and earliest available slot.
+func (s *Store) UpdateCustodyInfo(ctx context.Context, earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.UpdateCustodyInfo")
+	defer span.End()
+
+	storedGroupCount, storedEarliestAvailableSlot := uint64(0), primitives.Slot(0)
+	if err := s.db.Update(func(tx *bolt.Tx) error {
+		// Retrieve the custody bucket.
+		bucket, err := tx.CreateBucketIfNotExists(custodyBucket)
+		if err != nil {
+			return errors.Wrap(err, "create custody bucket")
+		}
+
+		// Retrieve the stored custody group count.
+		storedGroupCountBytes := bucket.Get(groupCountKey)
+		if len(storedGroupCountBytes) != 0 {
+			storedGroupCount = bytesutil.BytesToUint64BigEndian(storedGroupCountBytes)
+		}
+
+		// Retrieve the stored earliest available slot.
+		storedEarliestAvailableSlotBytes := bucket.Get(earliestAvailableSlotKey)
+		if len(storedEarliestAvailableSlotBytes) != 0 {
+			storedEarliestAvailableSlot = primitives.Slot(bytesutil.BytesToUint64BigEndian(storedEarliestAvailableSlotBytes))
+		}
+
+		// Exit early if the new custody group count is lower than or equal to the stored one.
+		if custodyGroupCount <= storedGroupCount {
+			return nil
+		}
+
+		storedGroupCount, storedEarliestAvailableSlot = custodyGroupCount, earliestAvailableSlot
+
+		// Store the earliest available slot.
+		bytes := bytesutil.Uint64ToBytesBigEndian(uint64(earliestAvailableSlot))
+		if err := bucket.Put(earliestAvailableSlotKey, bytes); err != nil {
+			return errors.Wrap(err, "put earliest available slot")
+		}
+
+		// Store the custody group count.
+		bytes = bytesutil.Uint64ToBytesBigEndian(custodyGroupCount)
+		if err := bucket.Put(groupCountKey, bytes); err != nil {
+			return errors.Wrap(err, "put custody group count")
+		}
+
+		return nil
+	}); err != nil {
+		return 0, 0, err
+	}
+
+	log.WithFields(logrus.Fields{
+		"earliestAvailableSlot": storedEarliestAvailableSlot,
+		"groupCount":            storedGroupCount,
+	}).Debug("Custody info")
+
+	return storedEarliestAvailableSlot, storedGroupCount, nil
+}
+
+// UpdateSubscribedToAllDataSubnets updates the "subscribed to all data subnets" status in the database
+// only if `subscribed` is `true`.
+// It returns the previous subscription status.
+func (s *Store) UpdateSubscribedToAllDataSubnets(ctx context.Context, subscribed bool) (bool, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.UpdateSubscribedToAllDataSubnets")
+	defer span.End()
+
+	result := false
+	if !subscribed {
+		if err := s.db.View(func(tx *bolt.Tx) error {
+			// Retrieve the custody bucket.
+			bucket := tx.Bucket(custodyBucket)
+			if bucket == nil {
+				return nil
+			}
+
+			// Retrieve the subscribe all data subnets flag.
+			bytes := bucket.Get(subscribeAllDataSubnetsKey)
+			if len(bytes) == 0 {
+				return nil
+			}
+
+			if bytes[0] == 1 {
+				result = true
+			}
+
+			return nil
+		}); err != nil {
+			return false, err
+		}
+
+		return result, nil
+	}
+
+	if err := s.db.Update(func(tx *bolt.Tx) error {
+		// Retrieve the custody bucket.
+		bucket, err := tx.CreateBucketIfNotExists(custodyBucket)
+		if err != nil {
+			return errors.Wrap(err, "create custody bucket")
+		}
+
+		bytes := bucket.Get(subscribeAllDataSubnetsKey)
+		if len(bytes) != 0 && bytes[0] == 1 {
+			result = true
+		}
+
+		if err := bucket.Put(subscribeAllDataSubnetsKey, []byte{1}); err != nil {
+			return errors.Wrap(err, "put subscribe all data subnets")
+		}
+
+		return nil
+	}); err != nil {
+		return false, err
+	}
+
+	return result, nil
+}

beacon-chain/db/kv/custody_test.go

@@ -0,0 +1,176 @@
+package kv
+
+import (
+	"context"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	bolt "go.etcd.io/bbolt"
+)
+
+// getCustodyInfoFromDB reads the custody info directly from the database for testing purposes.
+func getCustodyInfoFromDB(t *testing.T, db *Store) (primitives.Slot, uint64) {
+	t.Helper()
+	var earliestSlot primitives.Slot
+	var groupCount uint64
+
+	err := db.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(custodyBucket)
+		if bucket == nil {
+			return nil
+		}
+
+		// Read group count
+		groupCountBytes := bucket.Get(groupCountKey)
+		if len(groupCountBytes) != 0 {
+			groupCount = bytesutil.BytesToUint64BigEndian(groupCountBytes)
+		}
+
+		// Read earliest available slot
+		earliestSlotBytes := bucket.Get(earliestAvailableSlotKey)
+		if len(earliestSlotBytes) != 0 {
+			earliestSlot = primitives.Slot(bytesutil.BytesToUint64BigEndian(earliestSlotBytes))
+		}
+
+		return nil
+	})
+	require.NoError(t, err)
+
+	return earliestSlot, groupCount
+}
+
+// getSubscriptionStatusFromDB reads the subscription status directly from the database for testing purposes.
+func getSubscriptionStatusFromDB(t *testing.T, db *Store) bool {
+	t.Helper()
+	var subscribed bool
+
+	err := db.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(custodyBucket)
+		if bucket == nil {
+			return nil
+		}
+
+		bytes := bucket.Get(subscribeAllDataSubnetsKey)
+		if len(bytes) != 0 && bytes[0] == 1 {
+			subscribed = true
+		}
+
+		return nil
+	})
+	require.NoError(t, err)
+
+	return subscribed
+}
+
+func TestUpdateCustodyInfo(t *testing.T) {
+	ctx := t.Context()
+
+	t.Run("initial update with empty database", func(t *testing.T) {
+		const (
+			earliestSlot = primitives.Slot(100)
+			groupCount   = uint64(5)
+		)
+
+		db := setupDB(t)
+
+		slot, count, err := db.UpdateCustodyInfo(ctx, earliestSlot, groupCount)
+		require.NoError(t, err)
+		require.Equal(t, earliestSlot, slot)
+		require.Equal(t, groupCount, count)
+
+		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
+		require.Equal(t, earliestSlot, storedSlot)
+		require.Equal(t, groupCount, storedCount)
+	})
+
+	t.Run("update with higher group count", func(t *testing.T) {
+		const (
+			initialSlot  = primitives.Slot(100)
+			initialCount = uint64(5)
+			earliestSlot = primitives.Slot(200)
+			groupCount   = uint64(10)
+		)
+
+		db := setupDB(t)
+
+		_, _, err := db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
+		require.NoError(t, err)
+
+		slot, count, err := db.UpdateCustodyInfo(ctx, earliestSlot, groupCount)
+		require.NoError(t, err)
+		require.Equal(t, earliestSlot, slot)
+		require.Equal(t, groupCount, count)
+
+		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
+		require.Equal(t, earliestSlot, storedSlot)
+		require.Equal(t, groupCount, storedCount)
+	})
+
+	t.Run("update with lower group count should not update", func(t *testing.T) {
+		const (
+			initialSlot  = primitives.Slot(200)
+			initialCount = uint64(10)
+			earliestSlot = primitives.Slot(300)
+			groupCount   = uint64(8)
+		)
+
+		db := setupDB(t)
+
+		_, _, err := db.UpdateCustodyInfo(ctx, initialSlot, initialCount)
+		require.NoError(t, err)
+
+		slot, count, err := db.UpdateCustodyInfo(ctx, earliestSlot, groupCount)
+		require.NoError(t, err)
+		require.Equal(t, initialSlot, slot)
+		require.Equal(t, initialCount, count)
+
+		storedSlot, storedCount := getCustodyInfoFromDB(t, db)
+		require.Equal(t, initialSlot, storedSlot)
+		require.Equal(t, initialCount, storedCount)
+	})
+}
+
+func TestUpdateSubscribedToAllDataSubnets(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("initial update with empty database - set to false", func(t *testing.T) {
+		db := setupDB(t)
+
+		prev, err := db.UpdateSubscribedToAllDataSubnets(ctx, false)
+		require.NoError(t, err)
+		require.Equal(t, false, prev)
+
+		stored := getSubscriptionStatusFromDB(t, db)
+		require.Equal(t, false, stored)
+	})
+
+	t.Run("attempt to update from true to false (should not change)", func(t *testing.T) {
+		db := setupDB(t)
+
+		_, err := db.UpdateSubscribedToAllDataSubnets(ctx, true)
+		require.NoError(t, err)
+
+		prev, err := db.UpdateSubscribedToAllDataSubnets(ctx, false)
+		require.NoError(t, err)
+		require.Equal(t, true, prev)
+
+		stored := getSubscriptionStatusFromDB(t, db)
+		require.Equal(t, true, stored)
+	})
+
+	t.Run("attempt to update from true to false (should not change)", func(t *testing.T) {
+		db := setupDB(t)
+
+		_, err := db.UpdateSubscribedToAllDataSubnets(ctx, true)
+		require.NoError(t, err)
+
+		prev, err := db.UpdateSubscribedToAllDataSubnets(ctx, true)
+		require.NoError(t, err)
+		require.Equal(t, true, prev)
+
+		stored := getSubscriptionStatusFromDB(t, db)
+		require.Equal(t, true, stored)
+	})
+}

beacon-chain/db/kv/error.go

@@ -19,6 +19,9 @@ var ErrNotFoundGenesisBlockRoot = errors.Wrap(ErrNotFound, "OriginGenesisRoot")
 // ErrNotFoundFeeRecipient is a not found error specifically for the fee recipient getter
 var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
 
+// ErrNotFoundMetadataSeqNum is a not found error specifically for the metadata sequence number getter
+var ErrNotFoundMetadataSeqNum = errors.Wrap(ErrNotFound, "metadata sequence number")
+
 var errEmptyBlockSlice = errors.New("[]blocks.ROBlock is empty")
 var errIncorrectBlockParent = errors.New("unexpected missing or forked blocks in a []ROBlock")
 var errFinalizedChildNotFound = errors.New("unable to find finalized root descending from backfill batch")

beacon-chain/db/kv/genesis.go

@@ -8,6 +8,7 @@ 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"
 )
@@ -97,8 +98,22 @@ func (s *Store) EnsureEmbeddedGenesis(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
-	if gs != nil && !gs.IsNil() {
+	if !state.IsNil(gs) {
 		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,6 +8,7 @@ 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"
@@ -152,6 +153,7 @@ 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/kv.go

@@ -123,6 +123,7 @@ var Buckets = [][]byte{
 
 	feeRecipientBucket,
 	registrationBucket,
+	custodyBucket,
 }
 
 // KVStoreOption is a functional option that modifies a kv.Store.

beacon-chain/db/kv/p2p.go

@@ -0,0 +1,42 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	bolt "go.etcd.io/bbolt"
+)
+
+// MetadataSeqNum retrieves the p2p metadata sequence number from the database.
+// It returns 0 and ErrNotFoundMetadataSeqNum if the key does not exist.
+func (s *Store) MetadataSeqNum(ctx context.Context) (uint64, error) {
+	_, span := trace.StartSpan(ctx, "BeaconDB.MetadataSeqNum")
+	defer span.End()
+
+	var seqNum uint64
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(chainMetadataBucket)
+		val := bkt.Get(metadataSequenceNumberKey)
+		if val == nil {
+			return ErrNotFoundMetadataSeqNum
+		}
+
+		seqNum = bytesutil.BytesToUint64BigEndian(val)
+		return nil
+	})
+
+	return seqNum, err
+}
+
+// SaveMetadataSeqNum saves the p2p metadata sequence number to the database.
+func (s *Store) SaveMetadataSeqNum(ctx context.Context, seqNum uint64) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.SaveMetadataSeqNum")
+	defer span.End()
+
+	return s.db.Update(func(tx *bolt.Tx) error {
+		bkt := tx.Bucket(chainMetadataBucket)
+		val := bytesutil.Uint64ToBytesBigEndian(seqNum)
+		return bkt.Put(metadataSequenceNumberKey, val)
+	})
+}

beacon-chain/db/kv/p2p_test.go

@@ -0,0 +1,33 @@
+package kv
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/testing/assert"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestStore_MetadataSeqNum(t *testing.T) {
+	ctx := t.Context()
+	db := setupDB(t)
+
+	seqNum, err := db.MetadataSeqNum(ctx)
+	require.ErrorIs(t, err, ErrNotFoundMetadataSeqNum)
+	assert.Equal(t, uint64(0), seqNum)
+
+	initialSeqNum := uint64(42)
+	err = db.SaveMetadataSeqNum(ctx, initialSeqNum)
+	require.NoError(t, err)
+
+	retrievedSeqNum, err := db.MetadataSeqNum(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, initialSeqNum, retrievedSeqNum)
+
+	updatedSeqNum := uint64(43)
+	err = db.SaveMetadataSeqNum(ctx, updatedSeqNum)
+	require.NoError(t, err)
+
+	retrievedSeqNum, err = db.MetadataSeqNum(ctx)
+	require.NoError(t, err)
+	assert.Equal(t, updatedSeqNum, retrievedSeqNum)
+}

beacon-chain/db/kv/schema.go

@@ -42,6 +42,7 @@ var (
 	finalizedCheckpointKey     = []byte("finalized-checkpoint")
 	powchainDataKey            = []byte("powchain-data")
 	lastValidatedCheckpointKey = []byte("last-validated-checkpoint")
+	metadataSequenceNumberKey  = []byte("metadata-seq-number")
 
 	// Below keys are used to identify objects are to be fork compatible.
 	// Objects that are only compatible with specific forks should be prefixed with such keys.
@@ -70,4 +71,10 @@ var (
 
 	// Migrations
 	migrationsBucket = []byte("migrations")
+
+	// Custody
+	custodyBucket              = []byte("custody")
+	groupCountKey              = []byte("group-count")
+	earliestAvailableSlotKey   = []byte("earliest-available-slot")
+	subscribeAllDataSubnetsKey = []byte("subscribe-all-data-subnets")
 )

beacon-chain/db/kv/state.go

@@ -6,14 +6,12 @@ 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/monitoring/tracing"
+	"github.com/OffchainLabs/prysm/v6/genesis"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -65,21 +63,21 @@ func (s *Store) StateOrError(ctx context.Context, blockRoot [32]byte) (state.Bea
 	return st, nil
 }
 
-// GenesisState returns the genesis state in beacon chain.
 func (s *Store) GenesisState(ctx context.Context) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.GenesisState")
+	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")
 	defer span.End()
 
-	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 err error
 	var st state.BeaconState
 	err = s.db.View(func(tx *bolt.Tx) error {
 		// Retrieve genesis block's signing root from blocks bucket,
@@ -253,6 +251,10 @@ func (s *Store) saveStatesEfficientInternal(ctx context.Context, tx *bolt.Tx, bl
 			if err := s.processElectra(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
 				return err
 			}
+		case *ethpb.BeaconStateFulu:
+			if err := s.processFulu(ctx, rawType, rt[:], bucket, valIdxBkt, validatorKeys[i]); err != nil {
+				return err
+			}
 		default:
 			return errors.New("invalid state type")
 		}
@@ -368,6 +370,24 @@ func (s *Store) processElectra(ctx context.Context, pbState *ethpb.BeaconStateEl
 	return nil
 }
 
+func (s *Store) processFulu(ctx context.Context, pbState *ethpb.BeaconStateFulu, rootHash []byte, bucket, valIdxBkt *bolt.Bucket, validatorKey []byte) error {
+	valEntries := pbState.Validators
+	pbState.Validators = make([]*ethpb.Validator, 0)
+	rawObj, err := pbState.MarshalSSZ()
+	if err != nil {
+		return err
+	}
+	encodedState := snappy.Encode(nil, append(fuluKey, rawObj...))
+	if err := bucket.Put(rootHash, encodedState); err != nil {
+		return err
+	}
+	pbState.Validators = valEntries
+	if err := valIdxBkt.Put(rootHash, validatorKey); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (s *Store) storeValidatorEntriesSeparately(ctx context.Context, tx *bolt.Tx, validatorsEntries map[string]*ethpb.Validator) error {
 	valBkt := tx.Bucket(stateValidatorsBucket)
 	for hashStr, validatorEntry := range validatorsEntries {

beacon-chain/db/kv/state_test.go

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

beacon-chain/db/kv/wss.go

@@ -43,6 +43,7 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		return errors.Wrap(err, "failed to initialize origin block w/ bytes + config+fork")
 	}
 	blk := wblk.Block()
+	slot := blk.Slot()
 
 	blockRoot, err := blk.HashTreeRoot()
 	if err != nil {
@@ -51,43 +52,43 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 
 	pr := blk.ParentRoot()
 	bf := &dbval.BackfillStatus{
-		LowSlot:       uint64(wblk.Block().Slot()),
+		LowSlot:       uint64(slot),
 		LowRoot:       blockRoot[:],
 		LowParentRoot: pr[:],
 		OriginRoot:    blockRoot[:],
-		OriginSlot:    uint64(wblk.Block().Slot()),
+		OriginSlot:    uint64(slot),
 	}
 
 	if err = s.SaveBackfillStatus(ctx, bf); err != nil {
 		return errors.Wrap(err, "unable to save backfill status data to db for checkpoint sync")
 	}
 
-	log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Info("Saving checkpoint block to db")
+	log.WithField("root", fmt.Sprintf("%#x", blockRoot)).Info("Saving checkpoint data into database")
 	if err := s.SaveBlock(ctx, wblk); err != nil {
-		return errors.Wrap(err, "could not save checkpoint block")
+		return errors.Wrap(err, "save block")
 	}
 
 	// save state
-	log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Info("Calling SaveState")
 	if err = s.SaveState(ctx, state, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save state")
+		return errors.Wrap(err, "save state")
 	}
+
 	if err = s.SaveStateSummary(ctx, &ethpb.StateSummary{
 		Slot: state.Slot(),
 		Root: blockRoot[:],
 	}); err != nil {
-		return errors.Wrap(err, "could not save state summary")
+		return errors.Wrap(err, "save state summary")
 	}
 
 	// mark block as head of chain, so that processing will pick up from this point
 	if err = s.SaveHeadBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save head block root")
+		return errors.Wrap(err, "save head block root")
 	}
 
 	// save origin block root in a special key, to be used when the canonical
 	// origin (start of chain, ie alternative to genesis) block or state is needed
 	if err = s.SaveOriginCheckpointBlockRoot(ctx, blockRoot); err != nil {
-		return errors.Wrap(err, "could not save origin block root")
+		return errors.Wrap(err, "save origin checkpoint block root")
 	}
 
 	// rebuild the checkpoint from the block
@@ -96,15 +97,18 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 	if err != nil {
 		return err
 	}
+
 	chkpt := &ethpb.Checkpoint{
 		Epoch: primitives.Epoch(slotEpoch),
 		Root:  blockRoot[:],
 	}
+
 	if err = s.SaveJustifiedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "could not mark checkpoint sync block as justified")
+		return errors.Wrap(err, "save justified checkpoint")
 	}
+
 	if err = s.SaveFinalizedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "could not mark checkpoint sync block as finalized")
+		return errors.Wrap(err, "save finalized checkpoint")
 	}
 
 	return nil

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,7 +18,11 @@ func TestSaveOrigin(t *testing.T) {
 	ctx := t.Context()
 	db := setupDB(t)
 
-	st, err := genesis.State(params.MainnetName)
+	// 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()
 	require.NoError(t, err)
 
 	sb, err := st.MarshalSSZ()

beacon-chain/execution/BUILD.bazel

@@ -74,6 +74,7 @@ go_library(
         "@com_github_sirupsen_logrus//:go_default_library",
         "@io_k8s_client_go//tools/cache:go_default_library",
         "@org_golang_google_protobuf//proto:go_default_library",
+        "@org_golang_x_sync//singleflight:go_default_library",
     ],
 )
 
@@ -84,6 +85,7 @@ go_test(
         "block_cache_test.go",
         "block_reader_test.go",
         "deposit_test.go",
+        "engine_client_broadcast_test.go",
         "engine_client_fuzz_test.go",
         "engine_client_test.go",
         "execution_chain_test.go",
@@ -125,6 +127,7 @@ 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

@@ -99,6 +99,8 @@ const (
 	GetBlobsV2 = "engine_getBlobsV2"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
 	defaultEngineTimeout = time.Second
+	// defaultGetBlobsRetryInterval is the default retry interval for getBlobsV2 calls.
+	defaultGetBlobsRetryInterval = 200 * time.Millisecond
 )
 
 var (
@@ -652,9 +654,94 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 }
 
 // ReconstructDataColumnSidecars reconstructs the verified data column sidecars for a given beacon block.
-// It retrieves the KZG commitments from the block body, fetches the associated blobs and cell proofs from the EL,
-// and constructs the corresponding verified read-only data column sidecars.
+// It uses singleflight to ensure only one reconstruction per blockRoot.
 func (s *Service) ReconstructDataColumnSidecars(ctx context.Context, signedROBlock interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
+	// Use singleflight to ensure only one reconstruction per blockRoot
+	v, err, _ := s.reconstructSingleflight.Do(fmt.Sprintf("%x", blockRoot), func() (interface{}, error) {
+		// Try reconstruction once
+		result, err := s.reconstructDataColumnSidecarsOnce(ctx, signedROBlock, blockRoot)
+		if err != nil {
+			return nil, errors.Wrap(err, "failed to reconstruct data column sidecars")
+		}
+		if len(result) > 0 {
+			return result, nil // Success - return data
+		}
+
+		// Empty result - initiate retry mechanism
+
+		// Create a new context with a timeout for the retry goroutine.
+		retryCtx, cancel := context.WithTimeout(s.ctx, time.Duration(params.BeaconConfig().SecondsPerSlot)*time.Second)
+
+		// LoadOrStore atomically checks for an existing retry and stores
+		// a new one if none exists. This prevents a race condition.
+		// The stored value is the cancel function for the new context.
+		_, loaded := s.activeRetries.LoadOrStore(blockRoot, cancel)
+
+		if loaded {
+			// Another goroutine already started the retry process. The current one can exit.
+			cancel() // Cancel the context we just created as it won't be used.
+			return []blocks.VerifiedRODataColumn{}, nil
+		}
+
+		// This goroutine is now responsible for starting the retry.
+		// Perform periodic retry attempts for data column reconstruction inline.
+		go func() {
+			startTime := time.Now()
+			// Defer the cancellation of the context and the removal of the active retry tracker.
+			defer func() {
+				cancel()
+				s.activeRetries.Delete(blockRoot)
+			}()
+
+			ticker := time.NewTicker(defaultGetBlobsRetryInterval)
+			defer ticker.Stop()
+
+			attemptCount := 0
+			retryLog := log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot))
+
+			for {
+				select {
+				case <-ticker.C:
+					attemptCount++
+					getBlobsRetryAttempts.WithLabelValues("attempt").Inc()
+
+					// Retry reconstruction
+					retryLog.WithField("attempt", attemptCount).Debug("Retrying data column reconstruction")
+					result, err := s.reconstructDataColumnSidecarsOnce(retryCtx, signedROBlock, blockRoot)
+					if err != nil {
+						retryLog.WithError(err).Debug("Reconstruction attempt failed, will retry")
+						continue
+					}
+					if len(result) > 0 {
+						retryLog.WithField("attempts", attemptCount).Debug("Retry succeeded")
+						getBlobsRetryAttempts.WithLabelValues("success_reconstructed").Inc()
+						getBlobsRetryDuration.WithLabelValues("success").Observe(time.Since(startTime).Seconds())
+						// Clean up active retry tracker immediately on success
+						s.activeRetries.Delete(blockRoot)
+						return
+					}
+
+				case <-retryCtx.Done():
+					retryLog.WithField("attempts", attemptCount).Debug("Retry timeout")
+					getBlobsRetryAttempts.WithLabelValues("timeout").Inc()
+					getBlobsRetryDuration.WithLabelValues("timeout").Observe(time.Since(startTime).Seconds())
+					return
+				}
+			}
+		}()
+
+		// Return empty result for now; the background retry will handle it.
+		return []blocks.VerifiedRODataColumn{}, nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+	return v.([]blocks.VerifiedRODataColumn), nil
+}
+
+// reconstructDataColumnSidecarsOnce performs a single attempt to reconstruct data column sidecars.
+func (s *Service) reconstructDataColumnSidecarsOnce(ctx context.Context, signedROBlock interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
 	block := signedROBlock.Block()
 
 	log := log.WithFields(logrus.Fields{
@@ -1008,6 +1095,12 @@ func toBlockNumArg(number *big.Int) string {
 	return hexutil.EncodeBig(number)
 }
 
+// hasActiveRetry checks if there's an active retry for the given block root.
+func (s *Service) hasActiveRetry(blockRoot [fieldparams.RootLength]byte) bool {
+	_, exists := s.activeRetries.Load(blockRoot)
+	return exists
+}
+
 // wrapWithBlockRoot returns a new error with the given block root.
 func wrapWithBlockRoot(err error, blockRoot [32]byte, message string) error {
 	return errors.Wrap(err, fmt.Sprintf("%s for block %#x", message, blockRoot))

beacon-chain/execution/engine_client_broadcast_test.go

@@ -0,0 +1,92 @@
+package execution
+
+import (
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+// TestStartRetryIfNeeded_AtomicBehavior tests that the atomic retry start behavior
+// prevents race conditions by ensuring only one retry can be active per blockRoot.
+func TestStartRetryIfNeeded_AtomicBehavior(t *testing.T) {
+	t.Run("prevents multiple concurrent retry claims", func(t *testing.T) {
+		service := &Service{
+			activeRetries: sync.Map{},
+		}
+		
+		blockRoot := [32]byte{1, 2, 3}
+		claimCount := int64(0)
+		
+		numConcurrentCalls := 20
+		var wg sync.WaitGroup
+		startSignal := make(chan struct{})
+		
+		// Launch multiple goroutines that try to claim retry slot simultaneously
+		for i := 0; i < numConcurrentCalls; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				<-startSignal // Wait for signal to maximize race contention
+				
+				// Simulate the atomic claim logic from startRetryIfNeeded
+				cancelFunc := func() {}
+				if _, loaded := service.activeRetries.LoadOrStore(blockRoot, cancelFunc); !loaded {
+					// We won the race - count successful claims
+					atomic.AddInt64(&claimCount, 1)
+					
+					// Simulate some work before cleaning up
+					time.Sleep(1 * time.Millisecond)
+					service.activeRetries.Delete(blockRoot)
+				}
+			}()
+		}
+		
+		// Start all goroutines simultaneously to maximize race condition
+		close(startSignal)
+		wg.Wait()
+		
+		// Verify only one goroutine successfully claimed the retry slot
+		actualClaimCount := atomic.LoadInt64(&claimCount)
+		require.Equal(t, int64(1), actualClaimCount, "Only one goroutine should successfully claim retry slot despite %d concurrent attempts", numConcurrentCalls)
+		
+		t.Logf("Success: %d concurrent attempts resulted in only 1 successful claim (atomic behavior verified)", numConcurrentCalls)
+	})
+	
+	t.Run("hasActiveRetry correctly detects active retries", func(t *testing.T) {
+		service := &Service{
+			activeRetries: sync.Map{},
+		}
+		
+		blockRoot1 := [32]byte{1, 2, 3}
+		blockRoot2 := [32]byte{4, 5, 6}
+		
+		// Initially no active retries
+		if service.hasActiveRetry(blockRoot1) {
+			t.Error("Should not have active retry initially")
+		}
+		
+		// Add active retry for blockRoot1
+		service.activeRetries.Store(blockRoot1, func() {})
+		
+		// Verify detection
+		if !service.hasActiveRetry(blockRoot1) {
+			t.Error("Should detect active retry for blockRoot1")
+		}
+		if service.hasActiveRetry(blockRoot2) {
+			t.Error("Should not detect active retry for blockRoot2")
+		}
+		
+		// Remove active retry
+		service.activeRetries.Delete(blockRoot1)
+		
+		// Verify removal
+		if service.hasActiveRetry(blockRoot1) {
+			t.Error("Should not detect active retry after deletion")
+		}
+		
+		t.Logf("Success: hasActiveRetry correctly tracks retry state")
+	})
+}

beacon-chain/execution/engine_client_test.go

@@ -11,7 +11,10 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"testing"
+	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
@@ -2723,3 +2726,412 @@ func testNewBlobVerifier() verification.NewBlobVerifier {
 		}
 	}
 }
+
+// Test retry helper methods
+func TestRetryHelperMethods(t *testing.T) {
+	client := &Service{}
+	blockRoot := [32]byte{1, 2, 3}
+
+	t.Run("hasActiveRetry returns false initially", func(t *testing.T) {
+		hasActive := client.hasActiveRetry(blockRoot)
+		require.Equal(t, false, hasActive)
+	})
+
+	t.Run("hasActiveRetry returns true after storing cancel function", func(t *testing.T) {
+		_, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		client.activeRetries.Store(blockRoot, cancel)
+
+		hasActive := client.hasActiveRetry(blockRoot)
+		require.Equal(t, true, hasActive)
+
+		// Clean up
+		client.activeRetries.Delete(blockRoot)
+	})
+}
+
+// Test ReconstructDataColumnSidecars with retry logic
+func TestReconstructDataColumnSidecars_WithRetry(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Setup test config
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.CapellaForkEpoch = 1
+	cfg.DenebForkEpoch = 2
+	cfg.ElectraForkEpoch = 3
+	cfg.FuluForkEpoch = 4
+	params.OverrideBeaconConfig(cfg)
+
+	// Create test block
+	kzgCommitments := createRandomKzgCommitments(t, 3)
+	sb := util.NewBeaconBlockFulu()
+	sb.Block.Body.BlobKzgCommitments = kzgCommitments
+	signedB, err := blocks.NewSignedBeaconBlock(sb)
+	require.NoError(t, err)
+	r := [32]byte{1, 2, 3}
+
+	t.Run("successful initial call does not trigger retry", func(t *testing.T) {
+		ctx := context.Background()
+		// Setup server that returns all blobs
+		blobMasks := []bool{true, true, true}
+		srv := createBlobServerV2(t, 3, blobMasks)
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err)
+		require.Equal(t, 128, len(dataColumns))
+
+		// Should not have any active retries since initial call succeeded
+		require.Equal(t, false, client.hasActiveRetry(r))
+	})
+
+	t.Run("failed initial call triggers retry", func(t *testing.T) {
+		ctx := context.Background()
+		// Setup server that returns no blobs
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataColumns))
+
+		// Wait a bit for the goroutine to start
+		time.Sleep(10 * time.Millisecond)
+
+		// Should have active retry since initial call returned empty
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Clean up
+		if cancel, ok := client.activeRetries.Load(r); ok {
+			cancel.(context.CancelFunc)()
+		}
+	})
+
+
+	t.Run("does not start duplicate retry", func(t *testing.T) {
+		ctx := context.Background()
+		// Setup server that returns no blobs
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		// First call should start retry
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataColumns))
+
+		// Wait a bit for the goroutine to start
+		time.Sleep(10 * time.Millisecond)
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Second call should not start another retry
+		dataColumns, err = client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataColumns))
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Clean up
+		if cancel, ok := client.activeRetries.Load(r); ok {
+			cancel.(context.CancelFunc)()
+		}
+	})
+}
+
+// Test timeout and cleanup behavior
+func TestRetryTimeout(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Setup test config
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.CapellaForkEpoch = 1
+	cfg.DenebForkEpoch = 2
+	cfg.ElectraForkEpoch = 3
+	cfg.FuluForkEpoch = 4
+	params.OverrideBeaconConfig(cfg)
+
+	// Create test block
+	kzgCommitments := createRandomKzgCommitments(t, 1)
+	sb := util.NewBeaconBlockFulu()
+	sb.Block.Body.BlobKzgCommitments = kzgCommitments
+	signedB, err := blocks.NewSignedBeaconBlock(sb)
+	require.NoError(t, err)
+	r := [32]byte{1, 2, 3}
+
+	t.Run("retry cleans up after timeout", func(t *testing.T) {
+		// Setup server that always returns no blobs
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		// Modify config to have very short slot time for testing
+		originalConfig := params.BeaconConfig()
+		cfg := originalConfig.Copy()
+		cfg.SecondsPerSlot = 1 // 1 second timeout for retry
+		params.OverrideBeaconConfig(cfg)
+		defer params.OverrideBeaconConfig(originalConfig)
+
+		// Call ReconstructDataColumnSidecars which will start retry internally
+		ctx := context.Background()
+		_, err := client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err) // Should not error, just return empty result
+
+		// Wait a bit for the retry goroutine to start
+		time.Sleep(10 * time.Millisecond)
+
+		// Should have active retry initially
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Wait for timeout (longer than the 1 second timeout we set)
+		time.Sleep(1200 * time.Millisecond)
+
+		// Should be cleaned up after timeout
+		require.Equal(t, false, client.hasActiveRetry(r))
+	})
+}
+
+// Test concurrent retry scenarios
+func TestConcurrentRetries(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Setup test config
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.CapellaForkEpoch = 1
+	cfg.DenebForkEpoch = 2
+	cfg.ElectraForkEpoch = 3
+	cfg.FuluForkEpoch = 4
+	params.OverrideBeaconConfig(cfg)
+
+	t.Run("multiple blocks can have concurrent retries", func(t *testing.T) {
+		// Setup server that returns no blobs
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		// Create multiple test blocks
+		testBlocks := make([]interfaces.ReadOnlySignedBeaconBlock, 3)
+		roots := make([][32]byte, 3)
+
+		for i := 0; i < 3; i++ {
+			kzgCommitments := createRandomKzgCommitments(t, 1)
+			sb := util.NewBeaconBlockFulu()
+			sb.Block.Body.BlobKzgCommitments = kzgCommitments
+			signedB, err := blocks.NewSignedBeaconBlock(sb)
+			require.NoError(t, err)
+			testBlocks[i] = signedB
+			roots[i] = [32]byte{byte(i), byte(i), byte(i)}
+		}
+
+		ctx := context.Background()
+
+		// Start retries for all blocks
+		for i := 0; i < 3; i++ {
+			_, err := client.ReconstructDataColumnSidecars(ctx, testBlocks[i], roots[i])
+			require.NoError(t, err)
+		}
+
+		// Wait a bit for the goroutines to start
+		time.Sleep(10 * time.Millisecond)
+
+		// All should have active retries
+		for i := 0; i < 3; i++ {
+			require.Equal(t, true, client.hasActiveRetry(roots[i]))
+		}
+
+		// Clean up
+		for i := 0; i < 3; i++ {
+			if cancel, ok := client.activeRetries.Load(roots[i]); ok {
+				cancel.(context.CancelFunc)()
+			}
+		}
+	})
+}
+
+// Test end-to-end retry behavior with data availability changes
+func TestRetryBehaviorWithDataAvailability(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	// Setup test config
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.CapellaForkEpoch = 1
+	cfg.DenebForkEpoch = 2
+	cfg.ElectraForkEpoch = 3
+	cfg.FuluForkEpoch = 4
+	params.OverrideBeaconConfig(cfg)
+
+	// Create test block
+	kzgCommitments := createRandomKzgCommitments(t, 1)
+	sb := util.NewBeaconBlockFulu()
+	sb.Block.Body.BlobKzgCommitments = kzgCommitments
+	signedB, err := blocks.NewSignedBeaconBlock(sb)
+	require.NoError(t, err)
+	r := [32]byte{1, 2, 3}
+
+	t.Run("retry stops when data becomes available", func(t *testing.T) {
+		// Setup server that returns no blobs initially
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		// Start the initial reconstruction which should trigger retry
+		ctx := context.Background()
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataColumns))
+
+		// Wait a bit for the goroutine to start
+		time.Sleep(10 * time.Millisecond)
+
+		// Verify retry started
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Wait for retry timeout (the retry will continue since there's no way to stop it now)
+		time.Sleep(300 * time.Millisecond)
+
+		// Retry should still be active since there's no availability check to stop it
+		require.Equal(t, true, client.hasActiveRetry(r))
+	})
+
+	t.Run("retry continues when data is not available", func(t *testing.T) {
+		// Setup server that returns no blobs
+		srv := createBlobServerV2(t, 0, []bool{})
+		defer srv.Close()
+
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		// Start the initial reconstruction which should trigger retry
+		ctx := context.Background()
+		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, signedB, r)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(dataColumns))
+
+		// Wait a bit for the goroutine to start
+		time.Sleep(10 * time.Millisecond)
+
+		// Verify retry started
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Wait a bit - retry should still be active
+		time.Sleep(100 * time.Millisecond)
+		require.Equal(t, true, client.hasActiveRetry(r))
+
+		// Clean up
+		if cancel, ok := client.activeRetries.Load(r); ok {
+			cancel.(context.CancelFunc)()
+		}
+
+		// Wait for cleanup
+		time.Sleep(50 * time.Millisecond)
+		require.Equal(t, false, client.hasActiveRetry(r))
+	})
+}
+
+
+// TestConcurrentReconstructDataColumnSidecars tests that concurrent calls to ReconstructDataColumnSidecars
+// don't result in multiple getBlobsV2 calls for the same block root
+func TestConcurrentReconstructDataColumnSidecars(t *testing.T) {
+	t.Run("concurrent calls share result", func(t *testing.T) {
+		// Setup server that tracks call count
+		callCount := int32(0)
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			atomic.AddInt32(&callCount, 1)
+			w.Header().Set("Content-Type", "application/json")
+			// Simulate some processing time
+			time.Sleep(10 * time.Millisecond)
+
+			if strings.Contains(r.URL.RequestURI(), GetBlobsV2) {
+				// Return empty result - simulating EL doesn't have the data yet
+				resp := []interface{}{nil}
+				respJSON, _ := json.Marshal(map[string]interface{}{
+					"jsonrpc": "2.0",
+					"id":      1,
+					"result":  resp,
+				})
+				_, _ = w.Write(respJSON)
+				return
+			}
+		}))
+		defer srv.Close()
+
+		// Setup client
+		client := &Service{}
+		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
+		defer rpcClient.Close()
+
+		// Create test block with KZG commitments
+		slot := primitives.Slot(100)
+		block := util.NewBeaconBlockDeneb()
+		block.Block.Slot = slot
+		commitment := [48]byte{1, 2, 3}
+		block.Block.Body.BlobKzgCommitments = [][]byte{commitment[:]}
+
+		signedBlock, err := blocks.NewSignedBeaconBlock(block)
+		require.NoError(t, err)
+
+		blockRoot, err := signedBlock.Block().HashTreeRoot()
+		require.NoError(t, err)
+
+		ctx := context.Background()
+
+		// Start multiple concurrent calls
+		numCalls := 5
+		var wg sync.WaitGroup
+		results := make([][]blocks.VerifiedRODataColumn, numCalls)
+		errors := make([]error, numCalls)
+
+		for i := 0; i < numCalls; i++ {
+			wg.Add(1)
+			go func(index int) {
+				defer wg.Done()
+				result, err := client.ReconstructDataColumnSidecars(ctx, signedBlock, blockRoot)
+				results[index] = result
+				errors[index] = err
+			}(i)
+		}
+
+		// Wait for all calls to complete
+		wg.Wait()
+
+		// Verify that GetBlobsV2 was called only once, not numCalls times
+		finalCallCount := atomic.LoadInt32(&callCount)
+		require.Equal(t, int32(1), finalCallCount, "Expected GetBlobsV2 to be called only once, but was called %d times", finalCallCount)
+
+		// Verify all calls got the same result length
+		for i := 1; i < numCalls; i++ {
+			require.Equal(t, len(results[0]), len(results[i]), "All concurrent calls should return same result length")
+		}
+	})
+}

beacon-chain/execution/metrics.go

@@ -71,4 +71,19 @@ var (
 		Name: "execution_payload_bodies_count",
 		Help: "The number of requested payload bodies is too large",
 	})
+	getBlobsRetryAttempts = promauto.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "getblobs_retry_attempts_total",
+			Help: "Total number of getBlobsV2 retry attempts",
+		},
+		[]string{"result"},
+	)
+	getBlobsRetryDuration = promauto.NewHistogramVec(
+		prometheus.HistogramOpts{
+			Name:    "getblobs_retry_duration_seconds",
+			Help:    "Duration of getBlobsV2 retry cycles",
+			Buckets: []float64{0.1, 0.5, 1.0, 2.0, 5.0, 10.0, 15.0},
+		},
+		[]string{"result"},
+	)
 )

beacon-chain/execution/service.go

@@ -13,6 +13,8 @@ import (
 	"sync"
 	"time"
 
+	"golang.org/x/sync/singleflight"
+
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
@@ -162,6 +164,8 @@ type Service struct {
 	verifierWaiter          *verification.InitializerWaiter
 	blobVerifier            verification.NewBlobVerifier
 	capabilityCache         *capabilityCache
+	activeRetries           sync.Map // map[blockRoot]context.CancelFunc for tracking active retries
+	reconstructSingleflight singleflight.Group
 }
 
 // NewService sets up a new instance with an ethclient when given a web3 endpoint as a string in the config.

beacon-chain/execution/service_test.go

@@ -22,6 +22,7 @@ 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"
@@ -381,6 +382,7 @@ 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)))
@@ -446,6 +448,7 @@ 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))
 
@@ -594,6 +597,7 @@ 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)
@@ -655,6 +659,7 @@ 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,6 +3,7 @@ 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",
@@ -23,7 +24,6 @@ go_library(
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/kv:go_default_library",
@@ -50,7 +50,6 @@ 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",
@@ -60,6 +59,7 @@ 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

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

@@ -26,7 +26,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
 	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/kv"
@@ -53,7 +52,6 @@ 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"
@@ -63,6 +61,7 @@ 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"
@@ -114,7 +113,7 @@ type BeaconNode struct {
 	slasherAttestationsFeed  *event.Feed
 	finalizedStateAtStartUp  state.BeaconState
 	serviceFlagOpts          *serviceFlagOpts
-	GenesisInitializer       genesis.Initializer
+	GenesisProviders         []genesis.Provider
 	CheckpointInitializer    checkpoint.Initializer
 	forkChoicer              forkchoice.ForkChoicer
 	clockWaiter              startup.ClockWaiter
@@ -124,11 +123,11 @@ type BeaconNode struct {
 	BlobStorageOptions       []filesystem.BlobStorageOption
 	DataColumnStorage        *filesystem.DataColumnStorage
 	DataColumnStorageOptions []filesystem.DataColumnStorageOption
-	custodyInfo              *peerdas.CustodyInfo
 	verifyInitWaiter         *verification.InitializerWaiter
 	syncChecker              *initialsync.SyncChecker
 	slasherEnabled           bool
 	lcStore                  *lightclient.Store
+	ConfigOptions            []params.Option
 }
 
 // New creates a new node instance, sets up configuration options, and registers
@@ -137,18 +136,13 @@ 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:                registry,
+		services:                runtime.NewServiceRegistry(),
 		stop:                    make(chan struct{}),
 		stateFeed:               new(event.Feed),
 		blockFeed:               new(event.Feed),
@@ -166,7 +160,6 @@ func New(cliCtx *cli.Context, cancel context.CancelFunc, opts ...Option) (*Beaco
 		serviceFlagOpts:         &serviceFlagOpts{},
 		initialSyncComplete:     make(chan struct{}),
 		syncChecker:             &initialsync.SyncChecker{},
-		custodyInfo:             &peerdas.CustodyInfo{},
 		slasherEnabled:          cliCtx.Bool(flags.SlasherFlag.Name),
 	}
 
@@ -176,6 +169,25 @@ 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()
@@ -194,6 +206,9 @@ 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...)
@@ -203,8 +218,11 @@ 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)
+	bfs, err := startBaseServices(cliCtx, beacon, depositAddress, dbClearer)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not start modules")
 	}
@@ -292,7 +310,7 @@ func configureBeacon(cliCtx *cli.Context) error {
 	return nil
 }
 
-func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress string) (*backfill.Store, error) {
+func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress string, clearer *dbClearer) (*backfill.Store, error) {
 	ctx := cliCtx.Context
 	log.Debugln("Starting DB")
 	if err := beacon.startDB(cliCtx, depositAddress); err != nil {
@@ -302,7 +320,7 @@ func startBaseServices(cliCtx *cli.Context, beacon *BeaconNode, depositAddress s
 	beacon.BlobStorage.WarmCache()
 
 	log.Debugln("Starting Slashing DB")
-	if err := beacon.startSlasherDB(cliCtx); err != nil {
+	if err := beacon.startSlasherDB(cliCtx, clearer); err != nil {
 		return nil, errors.Wrap(err, "could not start slashing DB")
 	}
 
@@ -482,43 +500,6 @@ 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 {
@@ -542,60 +523,36 @@ func (b *BeaconNode) checkAndSaveDepositContract(depositAddress string) error {
 	return nil
 }
 
-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)
-
+func openDB(ctx context.Context, dbPath string, clearer *dbClearer) (*kv.Store, error) {
 	log.WithField("databasePath", dbPath).Info("Checking DB")
 
-	d, err := kv.NewKVStore(b.ctx, dbPath)
+	d, err := kv.NewKVStore(ctx, dbPath)
 	if err != nil {
-		return errors.Wrapf(err, "could not create database at %s", dbPath)
+		return nil, errors.Wrapf(err, "could not create database at %s", dbPath)
 	}
 
-	if clearDBRequired || forceClearDBRequired {
-		d, err = b.clearDB(clearDBRequired, forceClearDBRequired, d, dbPath)
-		if err != nil {
-			return errors.Wrap(err, "could not clear database")
-		}
+	d, err = clearer.clearKV(ctx, d)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not clear database")
 	}
 
-	if err := d.RunMigrations(b.ctx); err != nil {
-		return err
-	}
+	return d, d.RunMigrations(ctx)
+}
 
-	b.db = d
-
-	depositCache, err = depositsnapshot.New()
+func (b *BeaconNode) startDB(cliCtx *cli.Context, depositAddress string) error {
+	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, d); err != nil {
+		if err := b.CheckpointInitializer.Initialize(b.ctx, b.db); err != nil {
 			return err
 		}
 	}
@@ -607,49 +564,25 @@ 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) error {
+func (b *BeaconNode) startSlasherDB(cliCtx *cli.Context, clearer *dbClearer) 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
 	}
-	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
-		}
+	d, err = clearer.clearSlasher(b.ctx, d)
+	if err != nil {
+		return errors.Wrap(err, "could not clear slasher database")
 	}
-	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
 }
@@ -705,7 +638,6 @@ func (b *BeaconNode) registerP2P(cliCtx *cli.Context) error {
 		HostDNS:              cliCtx.String(cmd.P2PHostDNS.Name),
 		PrivateKey:           cliCtx.String(cmd.P2PPrivKey.Name),
 		StaticPeerID:         cliCtx.Bool(cmd.P2PStaticID.Name),
-		MetaDataDir:          cliCtx.String(cmd.P2PMetadata.Name),
 		QUICPort:             cliCtx.Uint(cmd.P2PQUICPort.Name),
 		TCPPort:              cliCtx.Uint(cmd.P2PTCPPort.Name),
 		UDPPort:              cliCtx.Uint(cmd.P2PUDPPort.Name),
@@ -717,7 +649,6 @@ func (b *BeaconNode) registerP2P(cliCtx *cli.Context) error {
 		StateNotifier:        b,
 		DB:                   b.db,
 		ClockWaiter:          b.clockWaiter,
-		CustodyInfo:          b.custodyInfo,
 	})
 	if err != nil {
 		return err
@@ -800,7 +731,6 @@ func (b *BeaconNode) registerBlockchainService(fc forkchoice.ForkChoicer, gs *st
 		blockchain.WithTrackedValidatorsCache(b.trackedValidatorsCache),
 		blockchain.WithPayloadIDCache(b.payloadIDCache),
 		blockchain.WithSyncChecker(b.syncChecker),
-		blockchain.WithCustodyInfo(b.custodyInfo),
 		blockchain.WithSlasherEnabled(b.slasherEnabled),
 		blockchain.WithLightClientStore(b.lcStore),
 	)
@@ -888,7 +818,7 @@ func (b *BeaconNode) registerSyncService(initialSyncComplete chan struct{}, bFil
 		regularsync.WithDataColumnStorage(b.DataColumnStorage),
 		regularsync.WithVerifierWaiter(b.verifyInitWaiter),
 		regularsync.WithAvailableBlocker(bFillStore),
-		regularsync.WithCustodyInfo(b.custodyInfo),
+		regularsync.WithTrackedValidatorsCache(b.trackedValidatorsCache),
 		regularsync.WithSlasherEnabled(b.slasherEnabled),
 		regularsync.WithLightClientStore(b.lcStore),
 		regularsync.WithBatchVerifierLimit(b.cliCtx.Int(flags.BatchVerifierLimit.Name)),
@@ -915,6 +845,7 @@ 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)
 }
@@ -1194,4 +1125,4 @@ func hasNetworkFlag(cliCtx *cli.Context) bool {
 		}
 	}
 	return false
-}
+}

beacon-chain/node/options.go

@@ -5,6 +5,7 @@ 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.
@@ -51,6 +52,13 @@ 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

@@ -49,6 +49,7 @@ go_library(
         "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/db:go_default_library",
+        "//beacon-chain/db/kv:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/peers/peerdata:go_default_library",
@@ -71,7 +72,6 @@ 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,7 +168,6 @@ 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",
@@ -178,6 +177,7 @@ 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",

beacon-chain/p2p/broadcaster.go

@@ -15,7 +15,6 @@ 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"
@@ -274,14 +273,8 @@ func (s *Service) BroadcastLightClientOptimisticUpdate(ctx context.Context, upda
 		return errors.New("attempted to broadcast nil light client optimistic update")
 	}
 
-	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 {
+	digest := params.ForkDigest(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
+	if err := s.broadcastObject(ctx, update, lcOptimisticToTopic(digest)); 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)
@@ -300,13 +293,7 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 		return errors.New("attempted to broadcast nil light client finality update")
 	}
 
-	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
-	}
-
+	forkDigest := params.ForkDigest(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
 	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")
@@ -318,15 +305,15 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 	return nil
 }
 
-// BroadcastDataColumn broadcasts a data column to the p2p network, the message is assumed to be
+// BroadcastDataColumnSidecar 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) BroadcastDataColumn(
+func (s *Service) BroadcastDataColumnSidecar(
 	root [fieldparams.RootLength]byte,
 	dataColumnSubnet uint64,
 	dataColumnSidecar *ethpb.DataColumnSidecar,
 ) error {
 	// Add tracing to the function.
-	ctx, span := trace.StartSpan(s.ctx, "p2p.BroadcastDataColumn")
+	ctx, span := trace.StartSpan(s.ctx, "p2p.BroadcastDataColumnSidecar")
 	defer span.End()
 
 	// Ensure the data column sidecar is not nil.
@@ -343,12 +330,12 @@ func (s *Service) BroadcastDataColumn(
 	}
 
 	// Non-blocking broadcast, with attempts to discover a column subnet peer if none available.
-	go s.internalBroadcastDataColumn(ctx, root, dataColumnSubnet, dataColumnSidecar, forkDigest)
+	go s.internalBroadcastDataColumnSidecar(ctx, root, dataColumnSubnet, dataColumnSidecar, forkDigest)
 
 	return nil
 }
 
-func (s *Service) internalBroadcastDataColumn(
+func (s *Service) internalBroadcastDataColumnSidecar(
 	ctx context.Context,
 	root [fieldparams.RootLength]byte,
 	columnSubnet uint64,
@@ -356,7 +343,7 @@ func (s *Service) internalBroadcastDataColumn(
 	forkDigest [fieldparams.VersionLength]byte,
 ) {
 	// Add tracing to the function.
-	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastDataColumn")
+	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastDataColumnSidecar")
 	defer span.End()
 
 	// Increase the number of broadcast attempts.

beacon-chain/p2p/broadcaster_test.go

@@ -15,12 +15,13 @@ 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"
@@ -59,6 +60,7 @@ 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)
@@ -227,6 +229,7 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 		cfg:                   cfg,
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
+		custodyInfo:           &custodyInfo{},
 	}
 	bootListener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
@@ -255,6 +258,7 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 			cfg:                   cfg,
 			genesisTime:           genesisTime,
 			genesisValidatorsRoot: genesisValidatorsRoot,
+			custodyInfo:           &custodyInfo{},
 		}
 		listener, err := s.startDiscoveryV5(ipAddr, pkey)
 		// Set for 2nd peer
@@ -263,7 +267,8 @@ func TestService_BroadcastAttestationWithDiscoveryAttempts(t *testing.T) {
 			s.metaData = wrapper.WrappedMetadataV0(new(ethpb.MetaDataV0))
 			bitV := bitfield.NewBitvector64()
 			bitV.SetBitAt(subnet, true)
-			s.updateSubnetRecordWithMetadata(bitV)
+			err := s.updateSubnetRecordWithMetadata(bitV)
+			require.NoError(t, err)
 		}
 		assert.NoError(t, err, "Could not start discovery for node")
 		listeners = append(listeners, listener)
@@ -548,9 +553,7 @@ func TestService_BroadcastLightClientOptimisticUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientOptimisticUpdateTopicFormat
-	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
-	require.NoError(t, err)
-	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, digest)
+	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, params.ForkDigest(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot)))
 
 	// External peer subscribes to the topic.
 	topic += p.Encoding().ProtocolSuffix()
@@ -614,9 +617,7 @@ func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientFinalityUpdateTopicFormat
-	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
-	require.NoError(t, err)
-	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, digest)
+	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, params.ForkDigest(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot)))
 
 	// External peer subscribes to the topic.
 	topic += p.Encoding().ProtocolSuffix()
@@ -695,6 +696,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 		subnetsLock:           make(map[uint64]*sync.RWMutex),
 		subnetsLockLock:       sync.Mutex{},
 		peers:                 peers.NewStatus(t.Context(), &peers.StatusConfig{ScorerParams: &scorers.Config{}}),
+		custodyInfo:           &custodyInfo{},
 	}
 
 	// Create a listener.
@@ -714,7 +716,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 
 	// Attempt to broadcast nil object should fail.
 	var emptyRoot [fieldparams.RootLength]byte
-	err = service.BroadcastDataColumn(emptyRoot, subnet, nil)
+	err = service.BroadcastDataColumnSidecar(emptyRoot, subnet, nil)
 	require.ErrorContains(t, "attempted to broadcast nil", err)
 
 	// Subscribe to the topic.
@@ -725,7 +727,7 @@ func TestService_BroadcastDataColumn(t *testing.T) {
 	time.Sleep(50 * time.Millisecond)
 
 	// Broadcast to peers and wait.
-	err = service.BroadcastDataColumn(emptyRoot, subnet, sidecar)
+	err = service.BroadcastDataColumnSidecar(emptyRoot, subnet, sidecar)
 	require.NoError(t, err)
 
 	// Receive the message.

beacon-chain/p2p/config.go

@@ -4,7 +4,6 @@ import (
 	"time"
 
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 )
@@ -28,7 +27,6 @@ type Config struct {
 	PrivateKey           string
 	DataDir              string
 	DiscoveryDir         string
-	MetaDataDir          string
 	QUICPort             uint
 	TCPPort              uint
 	UDPPort              uint
@@ -38,9 +36,8 @@ type Config struct {
 	AllowListCIDR        string
 	DenyListCIDR         []string
 	StateNotifier        statefeed.Notifier
-	DB                   db.ReadOnlyDatabase
+	DB                   db.ReadOnlyDatabaseWithSeqNum
 	ClockWaiter          startup.ClockWaiter
-	CustodyInfo          *peerdas.CustodyInfo
 }
 
 // validateConfig validates whether the values provided are accurate and will set

beacon-chain/p2p/custody.go

@@ -3,11 +3,114 @@ package p2p
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
-var _ DataColumnsHandler = (*Service)(nil)
+var _ CustodyManager = (*Service)(nil)
+
+// EarliestAvailableSlot returns the earliest available slot.
+func (s *Service) EarliestAvailableSlot() (primitives.Slot, error) {
+	s.custodyInfoLock.RLock()
+	defer s.custodyInfoLock.RUnlock()
+
+	if s.custodyInfo == nil {
+		return 0, errors.New("no custody info available")
+	}
+
+	return s.custodyInfo.earliestAvailableSlot, nil
+}
+
+// CustodyGroupCount returns the custody group count.
+func (s *Service) CustodyGroupCount() (uint64, error) {
+	s.custodyInfoLock.Lock()
+	defer s.custodyInfoLock.Unlock()
+
+	if s.custodyInfo == nil {
+		return 0, errors.New("no custody info available")
+	}
+
+	return s.custodyInfo.groupCount, nil
+}
+
+// UpdateCustodyInfo updates the stored custody group count to the incoming one
+// if the incoming one is greater than the stored one. In this case, the
+// incoming earliest available slot should be greater than or equal to the
+// stored one or an error is returned.
+//
+//   - If there is no stored custody info, or
+//   - If the incoming earliest available slot is greater than or equal to the
+//     fulu fork slot and the incoming custody group count is greater than the
+//     number of samples per slot
+//
+// then the stored earliest available slot is updated to the incoming one.
+//
+// This function returns a boolean indicating whether the custody info was
+// updated and the (possibly updated) custody info itself.
+//
+// Rationale:
+//   - The custody group count can only be increased (specification)
+//   - If the custody group count is increased before Fulu, we can still serve
+//     all the data, since there is no sharding before Fulu. As a consequence
+//     we do not need to update the earliest available slot in this case.
+//   - If the custody group count is increased after Fulu, but to a value less
+//     than or equal to the number of samples per slot, we can still serve all
+//     the data, since we store all sampled data column sidecars in all cases.
+//     As a consequence, we do not need to update the earliest available slot
+//   - If the custody group count is increased after Fulu to a value higher than
+//     the number of samples per slot, then, until the backfill is complete, we
+//     are unable to serve the data column sidecars corresponding to the new
+//     custody groups. As a consequence, we need to update the earliest
+//     available slot to inform the peers that we are not able to serve data
+//     column sidecars before this point.
+func (s *Service) UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error) {
+	samplesPerSlot := params.BeaconConfig().SamplesPerSlot
+
+	s.custodyInfoLock.Lock()
+	defer s.custodyInfoLock.Unlock()
+
+	if s.custodyInfo == nil {
+		s.custodyInfo = &custodyInfo{
+			earliestAvailableSlot: earliestAvailableSlot,
+			groupCount:            custodyGroupCount,
+		}
+		return earliestAvailableSlot, custodyGroupCount, nil
+	}
+
+	inMemory := s.custodyInfo
+	if custodyGroupCount <= inMemory.groupCount {
+		return inMemory.earliestAvailableSlot, inMemory.groupCount, nil
+	}
+
+	if earliestAvailableSlot < inMemory.earliestAvailableSlot {
+		return 0, 0, errors.Errorf(
+			"earliest available slot %d is less than the current one %d. (custody group count: %d, current one: %d)",
+			earliestAvailableSlot, inMemory.earliestAvailableSlot, custodyGroupCount, inMemory.groupCount,
+		)
+	}
+
+	if custodyGroupCount <= samplesPerSlot {
+		inMemory.groupCount = custodyGroupCount
+		return inMemory.earliestAvailableSlot, custodyGroupCount, nil
+	}
+
+	fuluForkSlot, err := fuluForkSlot()
+	if err != nil {
+		return 0, 0, errors.Wrap(err, "fulu fork slot")
+	}
+
+	if earliestAvailableSlot < fuluForkSlot {
+		inMemory.groupCount = custodyGroupCount
+		return inMemory.earliestAvailableSlot, custodyGroupCount, nil
+	}
+
+	inMemory.earliestAvailableSlot = earliestAvailableSlot
+	inMemory.groupCount = custodyGroupCount
+	return earliestAvailableSlot, custodyGroupCount, nil
+}
 
 // CustodyGroupCountFromPeer retrieves custody group count from a peer.
 // It first tries to get the custody group count from the peer's metadata,
@@ -72,3 +175,19 @@ func (s *Service) custodyGroupCountFromPeerENR(pid peer.ID) uint64 {
 
 	return custodyGroupCount
 }
+
+func fuluForkSlot() (primitives.Slot, error) {
+	beaconConfig := params.BeaconConfig()
+
+	fuluForkEpoch := beaconConfig.FuluForkEpoch
+	if fuluForkEpoch == beaconConfig.FarFutureEpoch {
+		return beaconConfig.FarFutureSlot, nil
+	}
+
+	forkFuluSlot, err := slots.EpochStart(fuluForkEpoch)
+	if err != nil {
+		return 0, errors.Wrap(err, "epoch start")
+	}
+
+	return forkFuluSlot, nil
+}

beacon-chain/p2p/custody_test.go

@@ -1,12 +1,15 @@
 package p2p
 
 import (
+	"context"
+	"strings"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/wrapper"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/metadata"
@@ -15,6 +18,174 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 )
 
+func TestEarliestAvailableSlot(t *testing.T) {
+	t.Run("No custody info available", func(t *testing.T) {
+		service := &Service{
+			custodyInfo: nil,
+		}
+
+		_, err := service.EarliestAvailableSlot()
+
+		require.NotNil(t, err)
+	})
+
+	t.Run("Valid custody info", func(t *testing.T) {
+		const expected primitives.Slot = 100
+
+		service := &Service{
+			custodyInfo: &custodyInfo{
+				earliestAvailableSlot: expected,
+			},
+		}
+
+		slot, err := service.EarliestAvailableSlot()
+
+		require.NoError(t, err)
+		require.Equal(t, expected, slot)
+	})
+}
+
+func TestCustodyGroupCount(t *testing.T) {
+	t.Run("No custody info available", func(t *testing.T) {
+		service := &Service{
+			custodyInfo: nil,
+		}
+
+		_, err := service.CustodyGroupCount()
+
+		require.NotNil(t, err)
+		require.Equal(t, true, strings.Contains(err.Error(), "no custody info available"))
+	})
+
+	t.Run("Valid custody info", func(t *testing.T) {
+		const expected uint64 = 5
+
+		service := &Service{
+			custodyInfo: &custodyInfo{
+				groupCount: expected,
+			},
+		}
+
+		count, err := service.CustodyGroupCount()
+
+		require.NoError(t, err)
+		require.Equal(t, expected, count)
+	})
+}
+
+func TestUpdateCustodyInfo(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	config := params.BeaconConfig()
+	config.SamplesPerSlot = 8
+	config.FuluForkEpoch = 10
+	params.OverrideBeaconConfig(config)
+
+	testCases := []struct {
+		name               string
+		initialCustodyInfo *custodyInfo
+		inputSlot          primitives.Slot
+		inputGroupCount    uint64
+		expectedUpdated    bool
+		expectedSlot       primitives.Slot
+		expectedGroupCount uint64
+		expectedErr        string
+	}{
+		{
+			name:               "First time setting custody info",
+			initialCustodyInfo: nil,
+			inputSlot:          100,
+			inputGroupCount:    5,
+			expectedUpdated:    true,
+			expectedSlot:       100,
+			expectedGroupCount: 5,
+		},
+		{
+			name: "Group count decrease - no update",
+			initialCustodyInfo: &custodyInfo{
+				earliestAvailableSlot: 50,
+				groupCount:            10,
+			},
+			inputSlot:          60,
+			inputGroupCount:    8,
+			expectedUpdated:    false,
+			expectedSlot:       50,
+			expectedGroupCount: 10,
+		},
+		{
+			name: "Earliest slot decrease - error",
+			initialCustodyInfo: &custodyInfo{
+				earliestAvailableSlot: 100,
+				groupCount:            5,
+			},
+			inputSlot:       50,
+			inputGroupCount: 10,
+			expectedErr:     "earliest available slot 50 is less than the current one 100",
+		},
+		{
+			name: "Group count increase but <= samples per slot",
+			initialCustodyInfo: &custodyInfo{
+				earliestAvailableSlot: 50,
+				groupCount:            5,
+			},
+			inputSlot:          60,
+			inputGroupCount:    8,
+			expectedUpdated:    true,
+			expectedSlot:       50,
+			expectedGroupCount: 8,
+		},
+		{
+			name: "Group count increase > samples per slot, before Fulu fork",
+			initialCustodyInfo: &custodyInfo{
+				earliestAvailableSlot: 50,
+				groupCount:            5,
+			},
+			inputSlot:          60,
+			inputGroupCount:    15,
+			expectedUpdated:    true,
+			expectedSlot:       50,
+			expectedGroupCount: 15,
+		},
+		{
+			name: "Group count increase > samples per slot, after Fulu fork",
+			initialCustodyInfo: &custodyInfo{
+				earliestAvailableSlot: 50,
+				groupCount:            5,
+			},
+			inputSlot:          500,
+			inputGroupCount:    15,
+			expectedUpdated:    true,
+			expectedSlot:       500,
+			expectedGroupCount: 15,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			service := &Service{
+				custodyInfo: tc.initialCustodyInfo,
+			}
+
+			slot, groupCount, err := service.UpdateCustodyInfo(tc.inputSlot, tc.inputGroupCount)
+
+			if tc.expectedErr != "" {
+				require.NotNil(t, err)
+				require.Equal(t, true, strings.Contains(err.Error(), tc.expectedErr))
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tc.expectedSlot, slot)
+			require.Equal(t, tc.expectedGroupCount, groupCount)
+
+			if tc.expectedUpdated {
+				require.NotNil(t, service.custodyInfo)
+				require.Equal(t, tc.expectedSlot, service.custodyInfo.earliestAvailableSlot)
+				require.Equal(t, tc.expectedGroupCount, service.custodyInfo.groupCount)
+			}
+		})
+	}
+}
+
 func TestCustodyGroupCountFromPeer(t *testing.T) {
 	const (
 		expectedENR      uint64 = 7
@@ -109,3 +280,59 @@ func TestCustodyGroupCountFromPeer(t *testing.T) {
 	}
 
 }
+
+func TestCustodyGroupCountFromPeerENR(t *testing.T) {
+	const (
+		expectedENR uint64 = 7
+		pid                = "test-id"
+	)
+
+	cgc := peerdas.Cgc(expectedENR)
+	custodyRequirement := params.BeaconConfig().CustodyRequirement
+
+	testCases := []struct {
+		name     string
+		record   *enr.Record
+		expected uint64
+		wantErr  bool
+	}{
+		{
+			name:     "No ENR record",
+			record:   nil,
+			expected: custodyRequirement,
+		},
+		{
+			name:     "Empty ENR record",
+			record:   &enr.Record{},
+			expected: custodyRequirement,
+		},
+		{
+			name: "Valid ENR with custody group count",
+			record: func() *enr.Record {
+				record := &enr.Record{}
+				record.Set(cgc)
+				return record
+			}(),
+			expected: expectedENR,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			peers := peers.NewStatus(context.Background(), &peers.StatusConfig{
+				ScorerParams: &scorers.Config{},
+			})
+
+			if tc.record != nil {
+				peers.Add(tc.record, pid, nil, network.DirOutbound)
+			}
+
+			service := &Service{
+				peers: peers,
+			}
+
+			actual := service.custodyGroupCountFromPeerENR(pid)
+			require.Equal(t, tc.expected, actual)
+		})
+	}
+}

beacon-chain/p2p/discovery.go

@@ -211,7 +211,10 @@ func (s *Service) RefreshPersistentSubnets() {
 		}
 
 		// Some data changed. Update the record and the metadata.
-		s.updateSubnetRecordWithMetadata(bitV)
+		// Not returning early here because the error comes from saving the metadata sequence number.
+		if err := s.updateSubnetRecordWithMetadata(bitV); err != nil {
+			log.WithError(err).Error("Failed to update subnet record with metadata")
+		}
 
 		// Ping all peers.
 		s.pingPeersAndLogEnr()
@@ -236,22 +239,43 @@ func (s *Service) RefreshPersistentSubnets() {
 	// Get the sync subnet bitfield in our metadata.
 	currentBitSInMetadata := s.Metadata().SyncnetsBitfield()
 
-	// Is our sync bitvector record up to date?
 	isBitSUpToDate := bytes.Equal(bitS, inRecordBitS) && bytes.Equal(bitS, currentBitSInMetadata)
 
 	// Compare current epoch with the Fulu fork epoch.
 	fuluForkEpoch := params.BeaconConfig().FuluForkEpoch
 
+	custodyGroupCount, inRecordCustodyGroupCount := uint64(0), uint64(0)
+	if params.FuluEnabled() {
+		// Get the custody group count we store in our record.
+		inRecordCustodyGroupCount, err = peerdas.CustodyGroupCountFromRecord(record)
+		if err != nil {
+			log.WithError(err).Error("Could not retrieve custody group count")
+			return
+		}
+
+		custodyGroupCount, err = s.CustodyGroupCount()
+		if err != nil {
+			log.WithError(err).Error("Could not retrieve custody group count")
+			return
+		}
+	}
+
 	// We add `1` to the current epoch because we want to prepare one epoch before the Fulu fork.
 	if currentEpoch+1 < fuluForkEpoch {
+		// Is our custody group count record up to date?
+		isCustodyGroupCountUpToDate := custodyGroupCount == inRecordCustodyGroupCount
+
 		// Altair behaviour.
-		if metadataVersion == version.Altair && isBitVUpToDate && isBitSUpToDate {
+		if metadataVersion == version.Altair && isBitVUpToDate && isBitSUpToDate && (!params.FuluEnabled() || isCustodyGroupCountUpToDate) {
 			// Nothing to do, return early.
 			return
 		}
 
 		// Some data have changed, update our record and metadata.
-		s.updateSubnetRecordWithMetadataV2(bitV, bitS)
+		// Not returning early here because the error comes from saving the metadata sequence number.
+		if err := s.updateSubnetRecordWithMetadataV2(bitV, bitS, custodyGroupCount); err != nil {
+			log.WithError(err).Error("Failed to update subnet record with metadata")
+		}
 
 		// Ping all peers to inform them of new metadata
 		s.pingPeersAndLogEnr()
@@ -259,16 +283,6 @@ func (s *Service) RefreshPersistentSubnets() {
 		return
 	}
 
-	// Get the current custody group count.
-	custodyGroupCount := s.cfg.CustodyInfo.ActualGroupCount()
-
-	// Get the custody group count we store in our record.
-	inRecordCustodyGroupCount, err := peerdas.CustodyGroupCountFromRecord(record)
-	if err != nil {
-		log.WithError(err).Error("Could not retrieve custody subnet count")
-		return
-	}
-
 	// Get the custody group count in our metadata.
 	inMetadataCustodyGroupCount := s.Metadata().CustodyGroupCount()
 
@@ -281,7 +295,10 @@ func (s *Service) RefreshPersistentSubnets() {
 	}
 
 	// Some data changed. Update the record and the metadata.
-	s.updateSubnetRecordWithMetadataV3(bitV, bitS, custodyGroupCount)
+	// Not returning early here because the error comes from saving the metadata sequence number.
+	if err := s.updateSubnetRecordWithMetadataV3(bitV, bitS, custodyGroupCount); err != nil {
+		log.WithError(err).Error("Failed to update subnet record with metadata")
+	}
 
 	// Ping all peers.
 	s.pingPeersAndLogEnr()
@@ -565,22 +582,30 @@ func (s *Service) createLocalNode(
 		localNode.Set(quicEntry)
 	}
 
-	if params.FuluEnabled() {
-		custodyGroupCount := s.cfg.CustodyInfo.ActualGroupCount()
-		localNode.Set(peerdas.Cgc(custodyGroupCount))
-	}
-
 	localNode.SetFallbackIP(ipAddr)
 	localNode.SetFallbackUDP(udpPort)
 
-	localNode, err = addForkEntry(localNode, s.genesisTime, s.genesisValidatorsRoot)
-	if err != nil {
+	currentSlot := slots.CurrentSlot(s.genesisTime)
+	currentEpoch := slots.ToEpoch(currentSlot)
+	current := params.GetNetworkScheduleEntry(currentEpoch)
+	next := params.NextNetworkScheduleEntry(currentEpoch)
+	if err := updateENR(localNode, current, next); err != nil {
 		return nil, errors.Wrap(err, "could not add eth2 fork version entry to enr")
 	}
 
 	localNode = initializeAttSubnets(localNode)
 	localNode = initializeSyncCommSubnets(localNode)
 
+	if params.FuluEnabled() {
+		custodyGroupCount, err := s.CustodyGroupCount()
+		if err != nil {
+			return nil, errors.Wrap(err, "could not retrieve custody group count")
+		}
+
+		custodyGroupCountEntry := peerdas.Cgc(custodyGroupCount)
+		localNode.Set(custodyGroupCountEntry)
+	}
+
 	if s.cfg != nil && s.cfg.HostAddress != "" {
 		hostIP := net.ParseIP(s.cfg.HostAddress)
 		if hostIP.To4() == nil && hostIP.To16() == nil {
@@ -685,7 +710,7 @@ func (s *Service) filterPeer(node *enode.Node) bool {
 	// Ignore nodes that don't match our fork digest.
 	nodeENR := node.Record()
 	if s.genesisValidatorsRoot != nil {
-		if err := s.compareForkENR(nodeENR); err != nil {
+		if err := compareForkENR(s.dv5Listener.LocalNode().Node().Record(), nodeENR); err != nil {
 			log.WithError(err).Trace("Fork ENR mismatches between peer and local node")
 			return false
 		}

beacon-chain/p2p/discovery_test.go

@@ -16,7 +16,7 @@ import (
 
 	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/peerdata"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
@@ -65,6 +65,7 @@ func TestCreateListener(t *testing.T) {
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		cfg:                   &Config{UDPPort: uint(port)},
+		custodyInfo:           &custodyInfo{},
 	}
 	listener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
@@ -91,6 +92,7 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 		cfg:                   &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
+		custodyInfo:           &custodyInfo{},
 	}
 	bootListener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
@@ -116,6 +118,7 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 			cfg:                   cfg,
 			genesisTime:           genesisTime,
 			genesisValidatorsRoot: genesisValidatorsRoot,
+			custodyInfo:           &custodyInfo{},
 		}
 		listener, err := s.startDiscoveryV5(ipAddr, pkey)
 		assert.NoError(t, err, "Could not start discovery for node")
@@ -157,27 +160,27 @@ func TestCreateLocalNode(t *testing.T) {
 	}{
 		{
 			name:          "valid config",
-			cfg:           &Config{CustodyInfo: &peerdas.CustodyInfo{}},
+			cfg:           &Config{},
 			expectedError: false,
 		},
 		{
 			name:          "invalid host address",
-			cfg:           &Config{HostAddress: "invalid", CustodyInfo: &peerdas.CustodyInfo{}},
+			cfg:           &Config{HostAddress: "invalid"},
 			expectedError: true,
 		},
 		{
 			name:          "valid host address",
-			cfg:           &Config{HostAddress: "192.168.0.1", CustodyInfo: &peerdas.CustodyInfo{}},
+			cfg:           &Config{HostAddress: "192.168.0.1"},
 			expectedError: false,
 		},
 		{
 			name:          "invalid host DNS",
-			cfg:           &Config{HostDNS: "invalid", CustodyInfo: &peerdas.CustodyInfo{}},
+			cfg:           &Config{HostDNS: "invalid"},
 			expectedError: true,
 		},
 		{
 			name:          "valid host DNS",
-			cfg:           &Config{HostDNS: "www.google.com", CustodyInfo: &peerdas.CustodyInfo{}},
+			cfg:           &Config{HostDNS: "www.google.com"},
 			expectedError: false,
 		},
 	}
@@ -191,6 +194,8 @@ func TestCreateLocalNode(t *testing.T) {
 				quicPort = 3000
 			)
 
+			custodyRequirement := params.BeaconConfig().CustodyRequirement
+
 			// Create a private key.
 			address, privKey := createAddrAndPrivKey(t)
 
@@ -199,6 +204,7 @@ func TestCreateLocalNode(t *testing.T) {
 				genesisTime:           time.Now(),
 				genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 				cfg:                   tt.cfg,
+				custodyInfo:           &custodyInfo{groupCount: custodyRequirement},
 			}
 
 			localNode, err := service.createLocalNode(privKey, address, udpPort, tcpPort, quicPort)
@@ -210,7 +216,7 @@ func TestCreateLocalNode(t *testing.T) {
 			require.NoError(t, err)
 
 			expectedAddress := address
-			if tt.cfg.HostAddress != "" {
+			if tt.cfg != nil && tt.cfg.HostAddress != "" {
 				expectedAddress = net.ParseIP(tt.cfg.HostAddress)
 			}
 
@@ -250,8 +256,8 @@ func TestCreateLocalNode(t *testing.T) {
 
 			// Check cgc config.
 			custodyGroupCount := new(uint64)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(peerdas.CustodyGroupCountEnrKey, custodyGroupCount)))
-			require.Equal(t, params.BeaconConfig().CustodyRequirement, *custodyGroupCount)
+			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(params.BeaconNetworkConfig().CustodyGroupCountKey, custodyGroupCount)))
+			require.Equal(t, custodyRequirement, *custodyGroupCount)
 		})
 	}
 }
@@ -263,6 +269,7 @@ func TestRebootDiscoveryListener(t *testing.T) {
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		cfg:                   &Config{UDPPort: uint(port)},
+		custodyInfo:           &custodyInfo{},
 	}
 
 	createListener := func() (*discover.UDPv5, error) {
@@ -295,6 +302,7 @@ func TestMultiAddrsConversion_InvalidIPAddr(t *testing.T) {
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
 		cfg:                   &Config{},
+		custodyInfo:           &custodyInfo{},
 	}
 	node, err := s.createLocalNode(pkey, addr, 0, 0, 0)
 	require.NoError(t, err)
@@ -313,6 +321,7 @@ func TestMultiAddrConversion_OK(t *testing.T) {
 		},
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
+		custodyInfo:           &custodyInfo{},
 	}
 	listener, err := s.createListener(ipAddr, pkey)
 	require.NoError(t, err)
@@ -353,6 +362,8 @@ func TestStaticPeering_PeersAreAdded(t *testing.T) {
 	cfg.StaticPeers = staticPeers
 	cfg.StateNotifier = &mock.MockStateNotifier{}
 	cfg.NoDiscovery = true
+	cfg.DB = testDB.SetupDB(t)
+
 	s, err := NewService(t.Context(), cfg)
 	require.NoError(t, err)
 
@@ -386,6 +397,7 @@ func TestHostIsResolved(t *testing.T) {
 		},
 		genesisTime:           time.Now(),
 		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
+		custodyInfo:           &custodyInfo{},
 	}
 	ip, key := createAddrAndPrivKey(t)
 	list, err := s.createListener(ip, key)
@@ -455,6 +467,7 @@ func TestUDPMultiAddress(t *testing.T) {
 		cfg:                   &Config{UDPPort: uint(port)},
 		genesisTime:           genesisTime,
 		genesisValidatorsRoot: genesisValidatorsRoot,
+		custodyInfo:           &custodyInfo{},
 	}
 
 	createListener := func() (*discover.UDPv5, error) {
@@ -655,7 +668,7 @@ func checkPingCountCacheMetadataRecord(
 	if expected.custodyGroupCount != nil {
 		// Check custody subnet count in ENR.
 		var actualCustodyGroupCount uint64
-		err := service.dv5Listener.LocalNode().Node().Record().Load(enr.WithEntry(peerdas.CustodyGroupCountEnrKey, &actualCustodyGroupCount))
+		err := service.dv5Listener.LocalNode().Node().Record().Load(enr.WithEntry(params.BeaconNetworkConfig().CustodyGroupCountKey, &actualCustodyGroupCount))
 		require.NoError(t, err)
 		require.Equal(t, *expected.custodyGroupCount, actualCustodyGroupCount)
 
@@ -818,10 +831,11 @@ func TestRefreshPersistentSubnets(t *testing.T) {
 					actualPingCount++
 					return nil
 				},
-				cfg:                   &Config{UDPPort: 2000, CustodyInfo: &peerdas.CustodyInfo{}},
+				cfg:                   &Config{UDPPort: 2000, DB: testDB.SetupDB(t)},
 				peers:                 p2p.Peers(),
 				genesisTime:           time.Now().Add(-time.Duration(tc.epochSinceGenesis*secondsPerEpoch) * time.Second),
 				genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
+				custodyInfo:           &custodyInfo{groupCount: custodyGroupCount},
 			}
 
 			// Set the listener and the metadata.

beacon-chain/p2p/fork.go

@@ -3,12 +3,9 @@ package p2p
 import (
 	"bytes"
 	"fmt"
-	"time"
 
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	prysmTime "github.com/OffchainLabs/prysm/v6/time"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
@@ -16,6 +13,8 @@ import (
 	"github.com/sirupsen/logrus"
 )
 
+var errEth2ENRDigestMismatch = errors.New("fork digest of peer does not match local value")
+
 // ENR key used for Ethereum consensus-related fork data.
 var eth2ENRKey = params.BeaconNetworkConfig().ETH2Key
 
@@ -25,29 +24,31 @@ func (s *Service) currentForkDigest() ([4]byte, error) {
 	if !s.isInitialized() {
 		return [4]byte{}, errors.New("state is not initialized")
 	}
-	return forks.CreateForkDigest(s.genesisTime, s.genesisValidatorsRoot)
+
+	currentSlot := slots.CurrentSlot(s.genesisTime)
+	currentEpoch := slots.ToEpoch(currentSlot)
+	return params.ForkDigest(currentEpoch), nil
 }
 
 // Compares fork ENRs between an incoming peer's record and our node's
 // local record values for current and next fork version/epoch.
-func (s *Service) compareForkENR(record *enr.Record) error {
-	currentRecord := s.dv5Listener.LocalNode().Node().Record()
-	peerForkENR, err := forkEntry(record)
+func compareForkENR(self, peer *enr.Record) error {
+	peerForkENR, err := forkEntry(peer)
 	if err != nil {
 		return err
 	}
-	currentForkENR, err := forkEntry(currentRecord)
+	currentForkENR, err := forkEntry(self)
 	if err != nil {
 		return err
 	}
-	enrString, err := SerializeENR(record)
+	enrString, err := SerializeENR(peer)
 	if err != nil {
 		return err
 	}
 	// Clients SHOULD connect to peers with current_fork_digest, next_fork_version,
 	// and next_fork_epoch that match local values.
 	if !bytes.Equal(peerForkENR.CurrentForkDigest, currentForkENR.CurrentForkDigest) {
-		return fmt.Errorf(
+		return errors.Wrapf(errEth2ENRDigestMismatch,
 			"fork digest of peer with ENR %s: %v, does not match local value: %v",
 			enrString,
 			peerForkENR.CurrentForkDigest,
@@ -74,41 +75,36 @@ func (s *Service) compareForkENR(record *enr.Record) error {
 	return nil
 }
 
-// Adds a fork entry as an ENR record under the Ethereum consensus EnrKey for
-// the local node. The fork entry is an ssz-encoded enrForkID type
-// which takes into account the current fork version from the current
-// epoch to create a fork digest, the next fork version,
-// and the next fork epoch.
-func addForkEntry(
-	node *enode.LocalNode,
-	genesisTime time.Time,
-	genesisValidatorsRoot []byte,
-) (*enode.LocalNode, error) {
-	digest, err := forks.CreateForkDigest(genesisTime, genesisValidatorsRoot)
-	if err != nil {
-		return nil, err
-	}
-	currentSlot := slots.CurrentSlot(genesisTime)
-	currentEpoch := slots.ToEpoch(currentSlot)
-	if prysmTime.Now().Before(genesisTime) {
-		currentEpoch = 0
-	}
-	nextForkVersion, nextForkEpoch, err := forks.NextForkData(currentEpoch)
-	if err != nil {
-		return nil, err
-	}
+func updateENR(node *enode.LocalNode, entry, next params.NetworkScheduleEntry) error {
 	enrForkID := &pb.ENRForkID{
-		CurrentForkDigest: digest[:],
-		NextForkVersion:   nextForkVersion[:],
-		NextForkEpoch:     nextForkEpoch,
+		CurrentForkDigest: entry.ForkDigest[:],
+		NextForkVersion:   next.ForkVersion[:],
+		NextForkEpoch:     next.Epoch,
 	}
+	if entry.Epoch == next.Epoch {
+		enrForkID.NextForkEpoch = params.BeaconConfig().FarFutureEpoch
+	}
+	logFields := logrus.Fields{
+		"CurrentForkDigest": fmt.Sprintf("%#x", enrForkID.CurrentForkDigest),
+		"NextForkVersion":   fmt.Sprintf("%#x", enrForkID.NextForkVersion),
+		"NextForkEpoch":     fmt.Sprintf("%d", enrForkID.NextForkEpoch),
+	}
+	if params.BeaconConfig().FuluForkEpoch != params.BeaconConfig().FarFutureEpoch {
+		if entry.ForkDigest == next.ForkDigest {
+			node.Set(enr.WithEntry(nfdEnrKey, make([]byte, len(next.ForkDigest))))
+		} else {
+			node.Set(enr.WithEntry(nfdEnrKey, next.ForkDigest[:]))
+		}
+		logFields["NextForkDigest"] = fmt.Sprintf("%#x", next.ForkDigest)
+	}
+	log.WithFields(logFields).Info("Updating ENR Fork ID")
 	enc, err := enrForkID.MarshalSSZ()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	forkEntry := enr.WithEntry(eth2ENRKey, enc)
 	node.Set(forkEntry)
-	return node, nil
+	return nil
 }
 
 // Retrieves an enrForkID from an ENR record by key lookup

beacon-chain/p2p/fork_test.go

@@ -8,242 +8,121 @@ import (
 	"testing"
 	"time"
 
-	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
-	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
-	ma "github.com/multiformats/go-multiaddr"
 	"github.com/sirupsen/logrus"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
-func TestStartDiscv5_DifferentForkDigests(t *testing.T) {
-	const port = 2000
-
-	ipAddr, pkey := createAddrAndPrivKey(t)
-	genesisTime := time.Now()
-	genesisValidatorsRoot := make([]byte, fieldparams.RootLength)
-	s := &Service{
-		cfg: &Config{
-			UDPPort:              uint(port),
-			StateNotifier:        &mock.MockStateNotifier{},
-			PingInterval:         testPingInterval,
-			DisableLivenessCheck: true,
-		},
-		genesisTime:           genesisTime,
-		genesisValidatorsRoot: genesisValidatorsRoot,
-	}
-	bootListener, err := s.createListener(ipAddr, pkey)
-	require.NoError(t, err)
-	defer bootListener.Close()
-
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
-
-	bootNode := bootListener.Self()
-	cfg := &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		UDPPort:              uint(port),
-		StateNotifier:        &mock.MockStateNotifier{},
-		PingInterval:         testPingInterval,
-		DisableLivenessCheck: true,
-	}
-
-	var listeners []*listenerWrapper
-	for i := 1; i <= 5; i++ {
-		port := 3000 + i
-		cfg.UDPPort = uint(port)
-		ipAddr, pkey := createAddrAndPrivKey(t)
-
-		// We give every peer a different genesis validators root, which
-		// will cause each peer to have a different ForkDigest, preventing
-		// them from connecting according to our discovery rules for Ethereum consensus.
-		root := make([]byte, 32)
-		copy(root, strconv.Itoa(port))
-		s = &Service{
-			cfg:                   cfg,
-			genesisTime:           genesisTime,
-			genesisValidatorsRoot: root,
-		}
-		listener, err := s.startDiscoveryV5(ipAddr, pkey)
-		assert.NoError(t, err, "Could not start discovery for node")
-		listeners = append(listeners, listener)
-	}
-	defer func() {
-		// Close down all peers.
-		for _, listener := range listeners {
-			listener.Close()
-		}
-	}()
-
-	// Wait for the nodes to have their local routing tables to be populated with the other nodes
-	time.Sleep(discoveryWaitTime)
-
-	lastListener := listeners[len(listeners)-1]
-	nodes := lastListener.Lookup(bootNode.ID())
-	if len(nodes) < 4 {
-		t.Errorf("The node's local table doesn't have the expected number of nodes. "+
-			"Expected more than or equal to %d but got %d", 4, len(nodes))
-	}
-
-	// Now, we start a new p2p service. It should have no peers aside from the
-	// bootnode given all nodes provided by discv5 will have different fork digests.
-	cfg.UDPPort = 14000
-	cfg.TCPPort = 14001
-	cfg.MaxPeers = 30
-	s, err = NewService(t.Context(), cfg)
-	require.NoError(t, err)
-	s.genesisTime = genesisTime
-	s.genesisValidatorsRoot = make([]byte, 32)
-	s.dv5Listener = lastListener
-
-	addrs := make([]ma.Multiaddr, 0)
-
-	for _, node := range nodes {
-		if s.filterPeer(node) {
-			nodeAddrs, err := retrieveMultiAddrsFromNode(node)
-			require.NoError(t, err)
-			addrs = append(addrs, nodeAddrs...)
-		}
-	}
-
-	// We should not have valid peers if the fork digest mismatched.
-	assert.Equal(t, 0, len(addrs), "Expected 0 valid peers")
-	require.NoError(t, s.Stop())
-}
-
-func TestStartDiscv5_SameForkDigests_DifferentNextForkData(t *testing.T) {
-	const port = 2000
-
+func TestCompareForkENR(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-	hook := logTest.NewGlobal()
+	params.BeaconConfig().InitializeForkSchedule()
 	logrus.SetLevel(logrus.TraceLevel)
-	ipAddr, pkey := createAddrAndPrivKey(t)
-	genesisTime := time.Now()
-	genesisValidatorsRoot := make([]byte, 32)
-	s := &Service{
-		cfg:                   &Config{UDPPort: uint(port), PingInterval: testPingInterval, DisableLivenessCheck: true},
-		genesisTime:           genesisTime,
-		genesisValidatorsRoot: genesisValidatorsRoot,
-	}
-	bootListener, err := s.createListener(ipAddr, pkey)
-	require.NoError(t, err)
-	defer bootListener.Close()
 
-	// Allow bootnode's table to have its initial refresh. This allows
-	// inbound nodes to be added in.
-	time.Sleep(5 * time.Second)
+	db, err := enode.OpenDB("")
+	assert.NoError(t, err)
+	_, k := createAddrAndPrivKey(t)
+	clock := startup.NewClock(time.Now(), params.BeaconConfig().GenesisValidatorsRoot)
+	current := params.GetNetworkScheduleEntry(clock.CurrentEpoch())
+	next := params.NextNetworkScheduleEntry(clock.CurrentEpoch())
+	self := enode.NewLocalNode(db, k)
+	require.NoError(t, updateENR(self, current, next))
 
-	bootNode := bootListener.Self()
-	cfg := &Config{
-		Discv5BootStrapAddrs: []string{bootNode.String()},
-		UDPPort:              uint(port),
-		PingInterval:         testPingInterval,
-		DisableLivenessCheck: true,
+	cases := []struct {
+		name      string
+		expectErr error
+		expectLog string
+		node      func(t *testing.T) *enode.Node
+	}{
+		{
+			name: "match",
+			node: func(t *testing.T) *enode.Node {
+				// Create a peer with the same current fork digest and next fork version/epoch.
+				peer := enode.NewLocalNode(db, k)
+				require.NoError(t, updateENR(peer, current, next))
+				return peer.Node()
+			},
+		},
+		{
+			name: "current digest mismatch",
+			node: func(t *testing.T) *enode.Node {
+				// Create a peer with the same current fork digest and next fork version/epoch.
+				peer := enode.NewLocalNode(db, k)
+				testDigest := [4]byte{0xFF, 0xFF, 0xFF, 0xFF}
+				require.NotEqual(t, current.ForkDigest, testDigest, "ensure test fork digest is unique")
+				currentCopy := current
+				currentCopy.ForkDigest = testDigest
+				require.NoError(t, updateENR(peer, currentCopy, next))
+				return peer.Node()
+			},
+			expectErr: errEth2ENRDigestMismatch,
+		},
+		{
+			name: "next fork version mismatch",
+			node: func(t *testing.T) *enode.Node {
+				// Create a peer with the same current fork digest and next fork version/epoch.
+				peer := enode.NewLocalNode(db, k)
+				testVersion := [4]byte{0xFF, 0xFF, 0xFF, 0xFF}
+				require.NotEqual(t, next.ForkVersion, testVersion, "ensure test fork version is unique")
+				nextCopy := next
+				nextCopy.ForkVersion = testVersion
+				require.NoError(t, updateENR(peer, current, nextCopy))
+				return peer.Node()
+			},
+			expectLog: "Peer matches fork digest but has different next fork version",
+		},
+		{
+			name: "next fork epoch mismatch",
+			node: func(t *testing.T) *enode.Node {
+				// Create a peer with the same current fork digest and next fork version/epoch.
+				peer := enode.NewLocalNode(db, k)
+				nextCopy := next
+				nextCopy.Epoch = nextCopy.Epoch + 1
+				require.NoError(t, updateENR(peer, current, nextCopy))
+				return peer.Node()
+			},
+			expectLog: "Peer matches fork digest but has different next fork epoch",
+		},
 	}
 
-	var listeners []*listenerWrapper
-	for i := 1; i <= 5; i++ {
-		port := 3000 + i
-		cfg.UDPPort = uint(port)
-		ipAddr, pkey := createAddrAndPrivKey(t)
-		c := params.BeaconConfig().Copy()
-		nextForkEpoch := primitives.Epoch(i)
-		c.ForkVersionSchedule[[4]byte{'A', 'B', 'C', 'D'}] = nextForkEpoch
-		params.OverrideBeaconConfig(c)
-
-		// We give every peer a different genesis validators root, which
-		// will cause each peer to have a different ForkDigest, preventing
-		// them from connecting according to our discovery rules for Ethereum consensus.
-		s = &Service{
-			cfg:                   cfg,
-			genesisTime:           genesisTime,
-			genesisValidatorsRoot: genesisValidatorsRoot,
-		}
-		listener, err := s.startDiscoveryV5(ipAddr, pkey)
-		assert.NoError(t, err, "Could not start discovery for node")
-		listeners = append(listeners, listener)
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			hook := logTest.NewGlobal()
+			peer := c.node(t)
+			err := compareForkENR(self.Node().Record(), peer.Record())
+			if c.expectErr != nil {
+				require.ErrorIs(t, err, c.expectErr, "Expected error to match")
+			} else {
+				require.NoError(t, err, "Expected no error comparing fork ENRs")
+			}
+			if c.expectLog != "" {
+				require.LogsContain(t, hook, c.expectLog, "Expected log message not found")
+			}
+		})
 	}
-	defer func() {
-		// Close down all peers.
-		for _, listener := range listeners {
-			listener.Close()
-		}
-	}()
-
-	// Wait for the nodes to have their local routing tables to be populated with the other nodes
-	time.Sleep(discoveryWaitTime)
-
-	lastListener := listeners[len(listeners)-1]
-	nodes := lastListener.Lookup(bootNode.ID())
-	if len(nodes) < 4 {
-		t.Errorf("The node's local table doesn't have the expected number of nodes. "+
-			"Expected more than or equal to %d but got %d", 4, len(nodes))
-	}
-
-	// Now, we start a new p2p service. It should have no peers aside from the
-	// bootnode given all nodes provided by discv5 will have different fork digests.
-	cfg.UDPPort = 14000
-	cfg.TCPPort = 14001
-	cfg.MaxPeers = 30
-	cfg.StateNotifier = &mock.MockStateNotifier{}
-	s, err = NewService(t.Context(), cfg)
-	require.NoError(t, err)
-
-	s.genesisTime = genesisTime
-	s.genesisValidatorsRoot = make([]byte, 32)
-	s.dv5Listener = lastListener
-	addrs := make([]ma.Multiaddr, 0, len(nodes))
-
-	for _, node := range nodes {
-		if s.filterPeer(node) {
-			nodeAddrs, err := retrieveMultiAddrsFromNode(node)
-			require.NoError(t, err)
-			addrs = append(addrs, nodeAddrs...)
-		}
-	}
-	if len(addrs) == 0 {
-		t.Error("Expected to have valid peers, got 0")
-	}
-
-	require.LogsContain(t, hook, "Peer matches fork digest but has different next fork epoch")
-	require.NoError(t, s.Stop())
 }
 
 func TestDiscv5_AddRetrieveForkEntryENR(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-	c := params.BeaconConfig().Copy()
-	c.ForkVersionSchedule = map[[4]byte]primitives.Epoch{
-		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): 0,
-		{0, 0, 0, 1}: 1,
-	}
-	nextForkEpoch := primitives.Epoch(1)
-	nextForkVersion := []byte{0, 0, 0, 1}
-	params.OverrideBeaconConfig(c)
+	params.BeaconConfig().InitializeForkSchedule()
 
-	genesisTime := time.Now()
-	genesisValidatorsRoot := make([]byte, 32)
-	digest, err := forks.CreateForkDigest(genesisTime, make([]byte, 32))
-	require.NoError(t, err)
+	clock := startup.NewClock(time.Now(), params.BeaconConfig().GenesisValidatorsRoot)
+	current := params.GetNetworkScheduleEntry(clock.CurrentEpoch())
+	next := params.NextNetworkScheduleEntry(clock.CurrentEpoch())
 	enrForkID := &pb.ENRForkID{
-		CurrentForkDigest: digest[:],
-		NextForkVersion:   nextForkVersion,
-		NextForkEpoch:     nextForkEpoch,
+		CurrentForkDigest: current.ForkDigest[:],
+		NextForkVersion:   next.ForkVersion[:],
+		NextForkEpoch:     next.Epoch,
 	}
 	enc, err := enrForkID.MarshalSSZ()
 	require.NoError(t, err)
 	entry := enr.WithEntry(eth2ENRKey, enc)
-	// In epoch 1 of current time, the fork version should be
-	// {0, 0, 0, 1} according to the configuration override above.
 	temp := t.TempDir()
 	randNum := rand.Int()
 	tempPath := path.Join(temp, strconv.Itoa(randNum))
@@ -255,18 +134,16 @@ func TestDiscv5_AddRetrieveForkEntryENR(t *testing.T) {
 	localNode := enode.NewLocalNode(db, pkey)
 	localNode.Set(entry)
 
-	want, err := signing.ComputeForkDigest([]byte{0, 0, 0, 0}, genesisValidatorsRoot)
-	require.NoError(t, err)
-
 	resp, err := forkEntry(localNode.Node().Record())
 	require.NoError(t, err)
-	assert.DeepEqual(t, want[:], resp.CurrentForkDigest)
-	assert.DeepEqual(t, nextForkVersion, resp.NextForkVersion)
-	assert.Equal(t, nextForkEpoch, resp.NextForkEpoch, "Unexpected next fork epoch")
+	assert.Equal(t, hexutil.Encode(current.ForkDigest[:]), hexutil.Encode(resp.CurrentForkDigest))
+	assert.Equal(t, hexutil.Encode(next.ForkVersion[:]), hexutil.Encode(resp.NextForkVersion))
+	assert.Equal(t, next.Epoch, resp.NextForkEpoch, "Unexpected next fork epoch")
 }
 
-func TestAddForkEntry_Genesis(t *testing.T) {
+func TestAddForkEntry_NextForkVersion(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
+	params.BeaconConfig().InitializeForkSchedule()
 	temp := t.TempDir()
 	randNum := rand.Int()
 	tempPath := path.Join(temp, strconv.Itoa(randNum))
@@ -276,17 +153,135 @@ func TestAddForkEntry_Genesis(t *testing.T) {
 	db, err := enode.OpenDB("")
 	require.NoError(t, err)
 
-	bCfg := params.MainnetConfig()
-	bCfg.ForkVersionSchedule = map[[4]byte]primitives.Epoch{}
-	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)] = bCfg.GenesisEpoch
-	params.OverrideBeaconConfig(bCfg)
-
 	localNode := enode.NewLocalNode(db, pkey)
-	localNode, err = addForkEntry(localNode, time.Now().Add(10*time.Second), bytesutil.PadTo([]byte{'A', 'B', 'C', 'D'}, 32))
+	clock := startup.NewClock(time.Now(), params.BeaconConfig().GenesisValidatorsRoot)
+	current := params.GetNetworkScheduleEntry(clock.CurrentEpoch())
+	next := params.NextNetworkScheduleEntry(clock.CurrentEpoch())
+	// Add the fork entry to the local node's ENR.
+	require.NoError(t, updateENR(localNode, current, next))
+	fe, err := forkEntry(localNode.Node().Record())
 	require.NoError(t, err)
-	forkEntry, err := forkEntry(localNode.Node().Record())
-	require.NoError(t, err)
-	assert.DeepEqual(t,
-		params.BeaconConfig().GenesisForkVersion, forkEntry.NextForkVersion,
+	assert.Equal(t,
+		hexutil.Encode(params.BeaconConfig().AltairForkVersion), hexutil.Encode(fe.NextForkVersion),
 		"Wanted Next Fork Version to be equal to genesis fork version")
+
+	last := params.LastForkEpoch()
+	current = params.GetNetworkScheduleEntry(last)
+	next = params.NextNetworkScheduleEntry(last)
+	require.NoError(t, updateENR(localNode, current, next))
+	entry := params.NextNetworkScheduleEntry(last)
+	fe, err = forkEntry(localNode.Node().Record())
+	require.NoError(t, err)
+	assert.Equal(t,
+		hexutil.Encode(entry.ForkVersion[:]), hexutil.Encode(fe.NextForkVersion),
+		"Wanted Next Fork Version to be equal to last entry in schedule")
+
+}
+
+func TestUpdateENR_FuluForkDigest(t *testing.T) {
+	setupTest := func(t *testing.T, fuluEnabled bool) (*enode.LocalNode, func()) {
+		params.SetupTestConfigCleanup(t)
+
+		cfg := params.BeaconConfig().Copy()
+		if fuluEnabled {
+			cfg.FuluForkEpoch = 100
+		} else {
+			cfg.FuluForkEpoch = cfg.FarFutureEpoch
+		}
+		cfg.FuluForkVersion = []byte{5, 0, 0, 0}
+		params.OverrideBeaconConfig(cfg)
+		cfg.InitializeForkSchedule()
+
+		pkey, err := privKey(&Config{DataDir: t.TempDir()})
+		require.NoError(t, err, "Could not get private key")
+		db, err := enode.OpenDB("")
+		require.NoError(t, err)
+
+		localNode := enode.NewLocalNode(db, pkey)
+		cleanup := func() {
+			db.Close()
+		}
+
+		return localNode, cleanup
+	}
+
+	tests := []struct {
+		name         string
+		fuluEnabled  bool
+		currentEntry params.NetworkScheduleEntry
+		nextEntry    params.NetworkScheduleEntry
+		validateNFD  func(t *testing.T, localNode *enode.LocalNode, nextEntry params.NetworkScheduleEntry)
+	}{
+		{
+			name:        "different digests sets nfd to next digest",
+			fuluEnabled: true,
+			currentEntry: params.NetworkScheduleEntry{
+				Epoch:       50,
+				ForkDigest:  [4]byte{1, 2, 3, 4},
+				ForkVersion: [4]byte{1, 0, 0, 0},
+			},
+			nextEntry: params.NetworkScheduleEntry{
+				Epoch:       100,
+				ForkDigest:  [4]byte{5, 6, 7, 8}, // Different from current
+				ForkVersion: [4]byte{2, 0, 0, 0},
+			},
+			validateNFD: func(t *testing.T, localNode *enode.LocalNode, nextEntry params.NetworkScheduleEntry) {
+				var nfdValue []byte
+				err := localNode.Node().Record().Load(enr.WithEntry(nfdEnrKey, &nfdValue))
+				require.NoError(t, err)
+				assert.DeepEqual(t, nextEntry.ForkDigest[:], nfdValue, "nfd entry should equal next fork digest")
+			},
+		},
+		{
+			name:        "same digests sets nfd to empty",
+			fuluEnabled: true,
+			currentEntry: params.NetworkScheduleEntry{
+				Epoch:       50,
+				ForkDigest:  [4]byte{1, 2, 3, 4},
+				ForkVersion: [4]byte{1, 0, 0, 0},
+			},
+			nextEntry: params.NetworkScheduleEntry{
+				Epoch:       100,
+				ForkDigest:  [4]byte{1, 2, 3, 4}, // Same as current
+				ForkVersion: [4]byte{2, 0, 0, 0},
+			},
+			validateNFD: func(t *testing.T, localNode *enode.LocalNode, nextEntry params.NetworkScheduleEntry) {
+				var nfdValue []byte
+				err := localNode.Node().Record().Load(enr.WithEntry(nfdEnrKey, &nfdValue))
+				require.NoError(t, err)
+				assert.DeepEqual(t, make([]byte, len(nextEntry.ForkDigest)), nfdValue, "nfd entry should be empty bytes when digests are same")
+			},
+		},
+		{
+			name:        "fulu disabled does not add nfd field",
+			fuluEnabled: false,
+			currentEntry: params.NetworkScheduleEntry{
+				Epoch:       50,
+				ForkDigest:  [4]byte{1, 2, 3, 4},
+				ForkVersion: [4]byte{1, 0, 0, 0},
+			},
+			nextEntry: params.NetworkScheduleEntry{
+				Epoch:       100,
+				ForkDigest:  [4]byte{5, 6, 7, 8}, // Different from current
+				ForkVersion: [4]byte{2, 0, 0, 0},
+			},
+			validateNFD: func(t *testing.T, localNode *enode.LocalNode, nextEntry params.NetworkScheduleEntry) {
+				var nfdValue []byte
+				err := localNode.Node().Record().Load(enr.WithEntry(nfdEnrKey, &nfdValue))
+				require.ErrorContains(t, "missing ENR key", err, "nfd field should not be present when Fulu fork is disabled")
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			localNode, cleanup := setupTest(t, tt.fuluEnabled)
+			defer cleanup()
+
+			currentEntry := tt.currentEntry
+			nextEntry := tt.nextEntry
+			require.NoError(t, updateENR(localNode, currentEntry, nextEntry))
+			tt.validateNFD(t, localNode, nextEntry)
+		})
+	}
 }

beacon-chain/p2p/fork_watcher.go

@@ -9,27 +9,26 @@ import (
 // updates the node's discovery service to reflect any new fork version
 // changes.
 func (s *Service) forkWatcher() {
+	// Exit early if discovery is disabled - there's no ENR to update
+	if s.dv5Listener == nil {
+		log.Debug("Discovery disabled, exiting fork watcher")
+		return
+	}
+
 	slotTicker := slots.NewSlotTicker(s.genesisTime, params.BeaconConfig().SecondsPerSlot)
+	var scheduleEntry params.NetworkScheduleEntry
 	for {
 		select {
 		case currSlot := <-slotTicker.C():
-			currEpoch := slots.ToEpoch(currSlot)
-			if currEpoch == params.BeaconConfig().AltairForkEpoch ||
-				currEpoch == params.BeaconConfig().BellatrixForkEpoch ||
-				currEpoch == params.BeaconConfig().CapellaForkEpoch ||
-				currEpoch == params.BeaconConfig().DenebForkEpoch ||
-				currEpoch == params.BeaconConfig().ElectraForkEpoch ||
-				currEpoch == params.BeaconConfig().FuluForkEpoch {
-				// If we are in the fork epoch, we update our enr with
-				// the updated fork digest. These repeatedly does
-				// this over the epoch, which might be slightly wasteful
-				// but is fine nonetheless.
-				if s.dv5Listener != nil { // make sure it's not a local network
-					_, err := addForkEntry(s.dv5Listener.LocalNode(), s.genesisTime, s.genesisValidatorsRoot)
-					if err != nil {
-						log.WithError(err).Error("Could not add fork entry")
-					}
+			currentEpoch := slots.ToEpoch(currSlot)
+			newEntry := params.GetNetworkScheduleEntry(currentEpoch)
+			if newEntry.ForkDigest != scheduleEntry.ForkDigest {
+				nextEntry := params.NextNetworkScheduleEntry(currentEpoch)
+				if err := updateENR(s.dv5Listener.LocalNode(), newEntry, nextEntry); err != nil {
+					log.WithFields(newEntry.LogFields()).WithError(err).Error("Could not add fork entry")
+					continue // don't replace scheduleEntry until this succeeds
 				}
+				scheduleEntry = newEntry
 			}
 		case <-s.ctx.Done():
 			log.Debug("Context closed, exiting goroutine")

beacon-chain/p2p/interfaces.go

@@ -7,6 +7,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/metadata"
 	"github.com/ethereum/go-ethereum/p2p/enode"
@@ -32,13 +33,14 @@ type (
 		ConnectionHandler
 		PeersProvider
 		MetadataProvider
-		DataColumnsHandler
+		CustodyManager
 	}
 
-	// Accessor provides access to the Broadcaster and PeerManager interfaces.
+	// Accessor provides access to the Broadcaster, PeerManager and CustodyManager interfaces.
 	Accessor interface {
 		Broadcaster
 		PeerManager
+		CustodyManager
 	}
 
 	// Broadcaster broadcasts messages to peers over the p2p pubsub protocol.
@@ -49,7 +51,7 @@ type (
 		BroadcastBlob(ctx context.Context, subnet uint64, blob *ethpb.BlobSidecar) error
 		BroadcastLightClientOptimisticUpdate(ctx context.Context, update interfaces.LightClientOptimisticUpdate) error
 		BroadcastLightClientFinalityUpdate(ctx context.Context, update interfaces.LightClientFinalityUpdate) error
-		BroadcastDataColumn(root [fieldparams.RootLength]byte, columnSubnet uint64, dataColumnSidecar *ethpb.DataColumnSidecar) error
+		BroadcastDataColumnSidecar(root [fieldparams.RootLength]byte, columnSubnet uint64, dataColumnSidecar *ethpb.DataColumnSidecar) error
 	}
 
 	// SetStreamHandler configures p2p to handle streams of a certain topic ID.
@@ -118,8 +120,11 @@ type (
 		MetadataSeq() uint64
 	}
 
-	// DataColumnsHandler abstracts some data columns related methods.
-	DataColumnsHandler interface {
+	// CustodyManager abstracts some data columns related methods.
+	CustodyManager interface {
+		EarliestAvailableSlot() (primitives.Slot, error)
+		CustodyGroupCount() (uint64, error)
+		UpdateCustodyInfo(earliestAvailableSlot primitives.Slot, custodyGroupCount uint64) (primitives.Slot, uint64, error)
 		CustodyGroupCountFromPeer(peer.ID) uint64
 	}
 )

beacon-chain/p2p/message_id.go

@@ -7,7 +7,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/math"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
 )
 
@@ -39,7 +38,7 @@ func MsgID(genesisValidatorsRoot []byte, pmsg *pubsubpb.Message) string {
 		copy(msg, "invalid")
 		return bytesutil.UnsafeCastToString(msg)
 	}
-	_, fEpoch, err := forks.RetrieveForkDataFromDigest(digest, genesisValidatorsRoot)
+	_, fEpoch, err := params.ForkDataFromDigest(digest)
 	if err != nil {
 		// Impossible condition that should
 		// never be hit.

beacon-chain/p2p/message_id_test.go

@@ -7,10 +7,10 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
-	"github.com/OffchainLabs/prysm/v6/network/forks"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/golang/snappy"
 	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
@@ -18,28 +18,27 @@ import (
 
 func TestMsgID_HashesCorrectly(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-	genesisValidatorsRoot := bytesutil.PadTo([]byte{'A'}, 32)
-	d, err := forks.CreateForkDigest(time.Now(), genesisValidatorsRoot)
-	assert.NoError(t, err)
+	clock := startup.NewClock(time.Now(), bytesutil.ToBytes32([]byte{'A'}))
+	valRoot := clock.GenesisValidatorsRoot()
+	d := params.ForkDigest(clock.CurrentEpoch())
 	tpc := fmt.Sprintf(p2p.BlockSubnetTopicFormat, d)
 	invalidSnappy := [32]byte{'J', 'U', 'N', 'K'}
 	pMsg := &pubsubpb.Message{Data: invalidSnappy[:], Topic: &tpc}
 	hashedData := hash.Hash(append(params.BeaconConfig().MessageDomainInvalidSnappy[:], pMsg.Data...))
 	msgID := string(hashedData[:20])
-	assert.Equal(t, msgID, p2p.MsgID(genesisValidatorsRoot, pMsg), "Got incorrect msg id")
+	assert.Equal(t, msgID, p2p.MsgID(valRoot[:], pMsg), "Got incorrect msg id")
 
 	validObj := [32]byte{'v', 'a', 'l', 'i', 'd'}
 	enc := snappy.Encode(nil, validObj[:])
 	nMsg := &pubsubpb.Message{Data: enc, Topic: &tpc}
 	hashedData = hash.Hash(append(params.BeaconConfig().MessageDomainValidSnappy[:], validObj[:]...))
 	msgID = string(hashedData[:20])
-	assert.Equal(t, msgID, p2p.MsgID(genesisValidatorsRoot, nMsg), "Got incorrect msg id")
+	assert.Equal(t, msgID, p2p.MsgID(valRoot[:], nMsg), "Got incorrect msg id")
 }
 
 func TestMessageIDFunction_HashesCorrectlyAltair(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-	genesisValidatorsRoot := bytesutil.PadTo([]byte{'A'}, 32)
-	d, err := signing.ComputeForkDigest(params.BeaconConfig().AltairForkVersion, genesisValidatorsRoot)
+	d, err := signing.ComputeForkDigest(params.BeaconConfig().AltairForkVersion, params.BeaconConfig().GenesisValidatorsRoot[:])
 	assert.NoError(t, err)
 	tpc := fmt.Sprintf(p2p.BlockSubnetTopicFormat, d)
 	topicLen := uint64(len(tpc))
@@ -52,7 +51,7 @@ func TestMessageIDFunction_HashesCorrectlyAltair(t *testing.T) {
 	combinedObj = append(combinedObj, pMsg.Data...)
 	hashedData := hash.Hash(combinedObj)
 	msgID := string(hashedData[:20])
-	assert.Equal(t, msgID, p2p.MsgID(genesisValidatorsRoot, pMsg), "Got incorrect msg id")
+	assert.Equal(t, msgID, p2p.MsgID(params.BeaconConfig().GenesisValidatorsRoot[:], pMsg), "Got incorrect msg id")
 
 	validObj := [32]byte{'v', 'a', 'l', 'i', 'd'}
 	enc := snappy.Encode(nil, validObj[:])
@@ -63,13 +62,12 @@ func TestMessageIDFunction_HashesCorrectlyAltair(t *testing.T) {
 	combinedObj = append(combinedObj, validObj[:]...)
 	hashedData = hash.Hash(combinedObj)
 	msgID = string(hashedData[:20])
-	assert.Equal(t, msgID, p2p.MsgID(genesisValidatorsRoot, nMsg), "Got incorrect msg id")
+	assert.Equal(t, msgID, p2p.MsgID(params.BeaconConfig().GenesisValidatorsRoot[:], nMsg), "Got incorrect msg id")
 }
 
 func TestMessageIDFunction_HashesCorrectlyBellatrix(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
-	genesisValidatorsRoot := bytesutil.PadTo([]byte{'A'}, 32)
-	d, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, genesisValidatorsRoot)
+	d, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, params.BeaconConfig().GenesisValidatorsRoot[:])
 	assert.NoError(t, err)
 	tpc := fmt.Sprintf(p2p.BlockSubnetTopicFormat, d)
 	topicLen := uint64(len(tpc))
@@ -82,7 +80,7 @@ func TestMessageIDFunction_HashesCorrectlyBellatrix(t *testing.T) {
 	combinedObj = append(combinedObj, pMsg.Data...)
 	hashedData := hash.Hash(combinedObj)
 	msgID := string(hashedData[:20])
-	assert.Equal(t, msgID, p2p.MsgID(genesisValidatorsRoot, pMsg), "Got incorrect msg id")
+	assert.Equal(t, msgID, p2p.MsgID(params.BeaconConfig().GenesisValidatorsRoot[:], pMsg), "Got incorrect msg id")
 
 	validObj := [32]byte{'v', 'a', 'l', 'i', 'd'}
 	enc := snappy.Encode(nil, validObj[:])
@@ -93,7 +91,7 @@ func TestMessageIDFunction_HashesCorrectlyBellatrix(t *testing.T) {
 	combinedObj = append(combinedObj, validObj[:]...)
 	hashedData = hash.Hash(combinedObj)
 	msgID = string(hashedData[:20])
-	assert.Equal(t, msgID, p2p.MsgID(genesisValidatorsRoot, nMsg), "Got incorrect msg id")
+	assert.Equal(t, msgID, p2p.MsgID(params.BeaconConfig().GenesisValidatorsRoot[:], nMsg), "Got incorrect msg id")
 }
 
 func TestMsgID_WithNilTopic(t *testing.T) {

beacon-chain/p2p/peers/peerdata/store.go

@@ -54,7 +54,7 @@ type PeerData struct {
 	NextValidTime time.Time
 	// Chain related data.
 	MetaData                  metadata.Metadata
-	ChainState                *ethpb.Status
+	ChainState                *ethpb.StatusV2
 	ChainStateLastUpdated     time.Time
 	ChainStateValidationError error
 	// Scorers internal data.