Validator: Remove early context cancellation. (#15369)

This is causing issues where submitting validator registrations and proposer settings were failing about 50% of the time in testing.

.github/workflows/changelog.yml

@@ -18,7 +18,7 @@ jobs:
         uses: dsaltares/fetch-gh-release-asset@aa2ab1243d6e0d5b405b973c89fa4d06a2d0fff7 # 1.1.2
         with:
           repo: OffchainLabs/unclog
-          version: "tags/v0.1.3"
+          version: "tags/v0.1.5"
           file: "unclog"
 
       - name: Get new changelog files

CHANGELOG.md

@@ -4,6 +4,108 @@ All notable changes to this project will be documented in this file.
 
 The format is based on Keep a Changelog, and this project adheres to Semantic Versioning.
 
+## [v6.0.3](https://github.com/prysmaticlabs/prysm/compare/v6.0.2...v6.0.3) - 2025-05-21
+
+This release has important bugfixes for users of the [Beacon API](https://ethereum.github.io/beacon-APIs/). These fixes include:
+- Fixed pending consolidations endpoint to return the correct response.
+- Fixed incorrect field name from pending partial withdrawals response.
+- Fixed attester slashing to return an empty array instead of nil/null. 
+- Fixed validator participation and active set changes endpoints to accept a `{state_id}` parameter. 
+
+Other improvements include:
+- Disabled deposit log processing routine for Electra and beyond.
+
+Operators are encouraged to update at their own convenience.
+
+### Added
+
+- ssz static spec tests for fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15279)
+- finality and merkle proof spec tests for fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15286)
+- sanity and rewards spec tests for fulu. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15285)
+
+### Changed
+
+- Added more tracing spans to various helpers related to GetDuties. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15271)
+- Disable log processing after deposit requests are activated. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15274)
+
+### Fixed
+
+- fixed wrong handler for get pending consolidations endpoint. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15290)
+- Fixed /eth/v2/beacon/pool/attester_slashings no slashings returns empty array instead of nil. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15291)
+- Fix Prysm endpoints `/prysm/v1/validators/{state_id}/participation` and `/prysm/v1/validators/{state_id}/active_set_changes` to properly handle `{state_id}`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15245)
+
+## [v6.0.2](https://github.com/prysmaticlabs/prysm/compare/v6.0.1...v6.0.2) - 2025-05-12
+
+This is a patch release to fix a few important bugs. Most importantly, we have adjusted the index limit for field tries in the beacon state to better support Pectra states. This should alleviate memory issues that clients are seeing since Pectra mainnet fork.
+
+### Added
+
+- Enable light client gossip for optimistic and finality updates. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15220)
+- Implement peerDAS core functions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15192)
+- Force duties start on received blocks. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15251)
+- Added additional tracing spans for the GetDuties routine. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15258)
+
+### Changed
+
+- Use otelgrpc for tracing grpc server and client. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15237)
+- Upgraded ristretto to v2.2.0, for RISC-V support. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15170)
+- Update spec to v1.5.0 compliance which changes minimal execution requests size. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15256)
+- Increase indices limit in field trie rebuilding. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15252)
+- Increase sepolia gas limit to 60M. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15253)
+
+### Fixed
+
+- Fixed wrong field name in pending partial withdrawals was returned on state json representation, described in https://github.com/ethereum/consensus-specs/blob/dev/specs/electra/beacon-chain.md#pendingpartialwithdrawal. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15254)
+- Fixed gocognit on propose block rest path. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15147)
+
+## [v6.0.1](https://github.com/prysmaticlabs/prysm/compare/v6.0.0...v6.0.1) - 2025-05-02
+
+This release fixes two bugs related to the `payload_attributes` [event stream](https://ethereum.github.io/beacon-APIs/#/Events/eventstream). If you are using or planning to use this endpoint, upgrading to version 6.0.1 is mandatory.  
+Also, a reminder: like other Beacon API endpoints, when a node is syncing, it may return historical data as `finalized` or `head`. Until the node is fully synced to the head of the chain, you should avoid using this data, depending on your application's needs.
+
+We currently recommend against using the `--enable-beacon-rest-api` flag on Mainnet. As you may have noticed, we put a deprecation notice on our gRPC code, in particular on gRPC-related flags. The reason for this is that we want to eventually remove gRPC and have REST HTTP as the standard way of communication between the validator client and the beacon node. That being said, the REST option is still unstable and thus marked as experimental in the flag's description (the flag is `--enable-beacon-rest-api`). Therefore we encourage everyone to keep using gRPC, which is currently the default. It is fine to test the REST option on testnets, but doing it on Mainnet can lead to missing attestations and even missing blocks.
+
+**Updating to v6.0.0 or later is required for Pectra Mainnet!**
+
+This patch release has a few important fixes from v6.0.0. Updating to this release is encouraged.
+
+### Added
+
+- `UpgradeToFulu` spectests. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15190)
+- PeerDAS related KZG wrappers. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15186)
+- Add light client p2p broadcaster functions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15175)
+- Added immediate broadcasting of proposer slashings when equivocating blocks are detected during block processing. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14693)
+- Added 2 new errors: `HeadStateErr` and `ErrCouldNotVerifyBlockHeader`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/14693)
+- Implement pending consolidations Beacon API endpoint. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15219)
+- PeerDAS: Add needed proto files and corresponding generated code. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15187)
+- Add light client p2p validator and subscriber functions. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15214)
+
+### Changed
+
+- Refactored internal function `reValidateSubscriptions` to `pruneSubscriptions` in `beacon-chain/sync/subscriber.go` for improved clarity, addressing a TODO comment. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15160)
+- Updated geth to v1.15.9. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15216)
+- Removed the slot from `UpdateDuties`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15223)
+- Update hoodie bootnodes. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15240)
+
+### Fixed
+
+- avoid nondeterministic default fork value when generate genesis. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15151)
+- `UpgradeToFulu`. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15190)
+- fixed underflow with balances in leaking edge case with expected withdrawals. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15191)
+- Fixes our generated ssz files to have the correct package name. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15199)
+- Fixes our blob sidecar by root request lists for electra. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15209)
+- Ensure that the `payload_attributes` event has a consistent view of the head state by passing the head block in the event and using stategen to retrieve the corresponding state. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15213)
+- Pass parent context to update duties when dependent roots change. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15221)
+- Process slots across epoch for payload attribute event. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15228)
+- extend the payload attribute computation deadline to the beginning of the proposal slot. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15230)
+
+### Security
+
+- Fix CVE-2025-22869. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15204)
+- Fix CVE-2025-22870. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15204)
+- Fix CVE-2025-22872. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15204)
+- Fix CVE-2025-30204. [[PR]](https://github.com/prysmaticlabs/prysm/pull/15204)
+
 ## [v6.0.0](https://github.com/prysmaticlabs/prysm/compare/v5.3.2...v6.0.0) - 2025-04-21
 
 This release introduces Mainnet support for the upcoming Electra + Prague (Pectra) fork. The fork is scheduled for mainnet epoch 364032 (May 7, 2025, 10:05:11 UTC). You MUST update Prysm Beacon Node, Prysm Validator Client, and your execution layer client to the Pectra ready release prior to the fork to stay on the correct chain.

CONTRIBUTING.md

@@ -4,7 +4,7 @@ Note: The latest and most up-to-date documentation can be found on our [docs por
 
 Excited by our work and want to get involved in building out our sharding releases? Or maybe you haven't learned as much about the Ethereum protocol but are a savvy developer? 
 
-You can explore our [Open Issues](https://github.com/OffchainLabs/prysm/issues) in-the works for our different releases. Feel free to fork our repo and start creating PR’s after assigning yourself to an issue of interest. We are always chatting on [Discord](https://discord.gg/CTYGPUJ) drop us a line there if you want to get more involved or have any questions on our implementation!
+You can explore our [Open Issues](https://github.com/OffchainLabs/prysm/issues) in-the works for our different releases. Feel free to fork our repo and start creating PR’s after assigning yourself to an issue of interest. We are always chatting on [Discord](https://discord.gg/prysm) drop us a line there if you want to get more involved or have any questions on our implementation!
 
 > [!IMPORTANT] 
 > Please, **do not send pull requests for trivial changes**, such as typos, these will be rejected. These types of pull requests incur a cost to reviewers and do not provide much value to the project. If you are unsure, please open an issue first to discuss the change.

README.md

@@ -6,7 +6,7 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/OffchainLabs/prysm)](https://goreportcard.com/report/github.com/OffchainLabs/prysm)
 [![Consensus_Spec_Version 1.4.0](https://img.shields.io/badge/Consensus%20Spec%20Version-v1.4.0-blue.svg)](https://github.com/ethereum/consensus-specs/tree/v1.4.0)
 [![Execution_API_Version 1.0.0-beta.2](https://img.shields.io/badge/Execution%20API%20Version-v1.0.0.beta.2-blue.svg)](https://github.com/ethereum/execution-apis/tree/v1.0.0-beta.2/src/engine)
-[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/OffchainLabs)
+[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/prysm)
 [![GitPOAP Badge](https://public-api.gitpoap.io/v1/repo/OffchainLabs/prysm/badge)](https://www.gitpoap.io/gh/OffchainLabs/prysm)
 
 </div>
@@ -25,7 +25,7 @@ See the [Changelog](https://github.com/OffchainLabs/prysm/releases) for details
 
 A detailed set of installation and usage instructions as well as breakdowns of each individual component are available in the **[official documentation portal](https://docs.prylabs.network)**.
 
-💬 **Need help?** Join our **[Discord Community](https://discord.gg/OffchainLabs)** for support.
+💬 **Need help?** Join our **[Discord Community](https://discord.gg/prysm)** for support.
 
 ---
 

WORKSPACE

@@ -255,56 +255,18 @@ filegroup(
     url = "https://github.com/ethereum/EIPs/archive/5480440fe51742ed23342b68cf106cefd427e39d.tar.gz",
 )
 
-consensus_spec_version = "v1.5.0"
+consensus_spec_version = "v1.6.0-alpha.0"
 
-bls_test_version = "v0.1.1"
+load("@prysm//tools:download_spectests.bzl", "consensus_spec_tests")
 
-http_archive(
-    name = "consensus_spec_tests_general",
-    build_file_content = """
-filegroup(
-    name = "test_data",
-    srcs = glob([
-        "**/*.ssz_snappy",
-        "**/*.yaml",
-    ]),
-    visibility = ["//visibility:public"],
-)
-    """,
-    integrity = "sha256-JljxS/if/t0qvGWcf5CgsX+72fj90yGTg/uEgC56y7U=",
-    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/general.tar.gz" % consensus_spec_version,
-)
-
-http_archive(
-    name = "consensus_spec_tests_minimal",
-    build_file_content = """
-filegroup(
-    name = "test_data",
-    srcs = glob([
-        "**/*.ssz_snappy",
-        "**/*.yaml",
-    ]),
-    visibility = ["//visibility:public"],
-)
-    """,
-    integrity = "sha256-NRba2h4zqb2LAXyDPglHTtkT4gVyuwpY708XmwXKXV8=",
-    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/minimal.tar.gz" % consensus_spec_version,
-)
-
-http_archive(
-    name = "consensus_spec_tests_mainnet",
-    build_file_content = """
-filegroup(
-    name = "test_data",
-    srcs = glob([
-        "**/*.ssz_snappy",
-        "**/*.yaml",
-    ]),
-    visibility = ["//visibility:public"],
-)
-    """,
-    integrity = "sha256-hpbtKUbc3NHtVcUPk/Zm+Hn57G2ijI9qvXJwl9hc/tM=",
-    url = "https://github.com/ethereum/consensus-spec-tests/releases/download/%s/mainnet.tar.gz" % consensus_spec_version,
+consensus_spec_tests(
+    name = "consensus_spec_tests",
+    flavors = {
+        "general": "sha256-W7oKvoM0nAkyitykRxAw6kmCvjYC01IqiNJy0AmCnMM=",
+        "minimal": "sha256-ig7/zxomjv6buBWMom4IxAJh3lFJ9+JnY44E7c8ZNP8=",
+        "mainnet": "sha256-mjx+MkXtPhCNv4c4knLYLIkvIdpF7WTjx/ElvGPQzSo=",
+    },
+    version = consensus_spec_version,
 )
 
 http_archive(
@@ -318,11 +280,13 @@ filegroup(
     visibility = ["//visibility:public"],
 )
     """,
-    integrity = "sha256-Wy3YcJxoXiKQwrGgJecrtjtdokc4X/VUNBmyQXJf0Oc=",
+    integrity = "sha256-u0RkIZIeGttb3sInR31mO64aBSwxALqO5SYIPlqEvPo=",
     strip_prefix = "consensus-specs-" + consensus_spec_version[1:],
     url = "https://github.com/ethereum/consensus-specs/archive/refs/tags/%s.tar.gz" % consensus_spec_version,
 )
 
+bls_test_version = "v0.1.1"
+
 http_archive(
     name = "bls_spec_tests",
     build_file_content = """

api/client/builder/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
     deps = [
         "//api:go_default_library",
         "//api/client:go_default_library",
-        "//api/server:go_default_library",
         "//api/server/structs:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
@@ -28,7 +27,6 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
-        "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",

api/client/builder/client.go

@@ -241,7 +241,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 		return nil, errors.Wrap(err, "error getting header from builder server")
 	}
 
-	bid, err := c.parseHeaderResponse(data, header)
+	bid, err := c.parseHeaderResponse(data, header, slot)
 	if err != nil {
 		return nil, errors.Wrapf(
 			err,
@@ -254,7 +254,7 @@ func (c *Client) GetHeader(ctx context.Context, slot primitives.Slot, parentHash
 	return bid, nil
 }
 
-func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid, error) {
+func (c *Client) parseHeaderResponse(data []byte, header http.Header, slot primitives.Slot) (SignedBid, error) {
 	var versionHeader string
 	if c.sszEnabled || header.Get(api.VersionHeader) != "" {
 		versionHeader = header.Get(api.VersionHeader)
@@ -276,7 +276,7 @@ func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid
 	}
 
 	if ver >= version.Electra {
-		return c.parseHeaderElectra(data)
+		return c.parseHeaderElectra(data, slot)
 	}
 	if ver >= version.Deneb {
 		return c.parseHeaderDeneb(data)
@@ -291,7 +291,7 @@ func (c *Client) parseHeaderResponse(data []byte, header http.Header) (SignedBid
 	return nil, fmt.Errorf("unsupported header version %s", versionHeader)
 }
 
-func (c *Client) parseHeaderElectra(data []byte) (SignedBid, error) {
+func (c *Client) parseHeaderElectra(data []byte, slot primitives.Slot) (SignedBid, error) {
 	if c.sszEnabled {
 		sb := &ethpb.SignedBuilderBidElectra{}
 		if err := sb.UnmarshalSSZ(data); err != nil {
@@ -303,7 +303,7 @@ func (c *Client) parseHeaderElectra(data []byte) (SignedBid, error) {
 	if err := json.Unmarshal(data, hr); err != nil {
 		return nil, errors.Wrap(err, "could not unmarshal ExecHeaderResponseElectra JSON")
 	}
-	p, err := hr.ToProto()
+	p, err := hr.ToProto(slot)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert ExecHeaderResponseElectra to proto")
 	}

api/client/builder/client_test.go

@@ -532,7 +532,7 @@ func TestClient_GetHeader(t *testing.T) {
 				require.Equal(t, expectedPath, r.URL.Path)
 				epr := &ExecHeaderResponseElectra{}
 				require.NoError(t, json.Unmarshal([]byte(testExampleHeaderResponseElectra), epr))
-				pro, err := epr.ToProto()
+				pro, err := epr.ToProto(100)
 				require.NoError(t, err)
 				ssz, err := pro.MarshalSSZ()
 				require.NoError(t, err)
@@ -640,9 +640,9 @@ func TestSubmitBlindedBlock(t *testing.T) {
 				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
 				epr := &ExecutionPayloadResponse{}
 				require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), epr))
-				ep := &ExecutionPayload{}
+				ep := &structs.ExecutionPayload{}
 				require.NoError(t, json.Unmarshal(epr.Data, ep))
-				pro, err := ep.ToProto()
+				pro, err := ep.ToConsensus()
 				require.NoError(t, err)
 				ssz, err := pro.MarshalSSZ()
 				require.NoError(t, err)
@@ -710,9 +710,9 @@ func TestSubmitBlindedBlock(t *testing.T) {
 				require.Equal(t, api.OctetStreamMediaType, r.Header.Get("Accept"))
 				epr := &ExecutionPayloadResponse{}
 				require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadCapella), epr))
-				ep := &ExecutionPayloadCapella{}
+				ep := &structs.ExecutionPayloadCapella{}
 				require.NoError(t, json.Unmarshal(epr.Data, ep))
-				pro, err := ep.ToProto()
+				pro, err := ep.ToConsensus()
 				require.NoError(t, err)
 				ssz, err := pro.MarshalSSZ()
 				require.NoError(t, err)

api/client/builder/types_test.go

@@ -328,72 +328,72 @@ func TestExecutionHeaderResponseUnmarshal(t *testing.T) {
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ParentHash),
+			actual:   hr.Data.Message.Header.ParentHash,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ParentHash",
 		},
 		{
 			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(hr.Data.Message.Header.FeeRecipient),
+			actual:   hr.Data.Message.Header.FeeRecipient,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.FeeRecipient",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.StateRoot),
+			actual:   hr.Data.Message.Header.StateRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.StateRoot",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ReceiptsRoot),
+			actual:   hr.Data.Message.Header.ReceiptsRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ReceiptsRoot",
 		},
 		{
 			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(hr.Data.Message.Header.LogsBloom),
+			actual:   hr.Data.Message.Header.LogsBloom,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.LogsBloom",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.PrevRandao),
+			actual:   hr.Data.Message.Header.PrevRandao,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.PrevRandao",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BlockNumber),
+			actual:   hr.Data.Message.Header.BlockNumber,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockNumber",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasLimit),
+			actual:   hr.Data.Message.Header.GasLimit,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasLimit",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasUsed),
+			actual:   hr.Data.Message.Header.GasUsed,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasUsed",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.Timestamp),
+			actual:   hr.Data.Message.Header.Timestamp,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.Timestamp",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ExtraData),
+			actual:   hr.Data.Message.Header.ExtraData,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ExtraData",
 		},
 		{
 			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BaseFeePerGas),
+			actual:   hr.Data.Message.Header.BaseFeePerGas,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BaseFeePerGas",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.BlockHash),
+			actual:   hr.Data.Message.Header.BlockHash,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockHash",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.TransactionsRoot),
+			actual:   hr.Data.Message.Header.TransactionsRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.TransactionsRoot",
 		},
 	}
@@ -427,77 +427,77 @@ func TestExecutionHeaderResponseCapellaUnmarshal(t *testing.T) {
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ParentHash),
+			actual:   hr.Data.Message.Header.ParentHash,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ParentHash",
 		},
 		{
 			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(hr.Data.Message.Header.FeeRecipient),
+			actual:   hr.Data.Message.Header.FeeRecipient,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.FeeRecipient",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.StateRoot),
+			actual:   hr.Data.Message.Header.StateRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.StateRoot",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ReceiptsRoot),
+			actual:   hr.Data.Message.Header.ReceiptsRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ReceiptsRoot",
 		},
 		{
 			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(hr.Data.Message.Header.LogsBloom),
+			actual:   hr.Data.Message.Header.LogsBloom,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.LogsBloom",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.PrevRandao),
+			actual:   hr.Data.Message.Header.PrevRandao,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.PrevRandao",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BlockNumber),
+			actual:   hr.Data.Message.Header.BlockNumber,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockNumber",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasLimit),
+			actual:   hr.Data.Message.Header.GasLimit,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasLimit",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.GasUsed),
+			actual:   hr.Data.Message.Header.GasUsed,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.GasUsed",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.Timestamp),
+			actual:   hr.Data.Message.Header.Timestamp,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.Timestamp",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.ExtraData),
+			actual:   hr.Data.Message.Header.ExtraData,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.ExtraData",
 		},
 		{
 			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", hr.Data.Message.Header.BaseFeePerGas),
+			actual:   hr.Data.Message.Header.BaseFeePerGas,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BaseFeePerGas",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.BlockHash),
+			actual:   hr.Data.Message.Header.BlockHash,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.BlockHash",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.TransactionsRoot),
+			actual:   hr.Data.Message.Header.TransactionsRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.TransactionsRoot",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(hr.Data.Message.Header.WithdrawalsRoot),
+			actual:   hr.Data.Message.Header.WithdrawalsRoot,
 			name:     "ExecHeaderResponse.ExecutionPayloadHeader.WithdrawalsRoot",
 		},
 	}
@@ -867,88 +867,6 @@ var testExampleExecutionPayloadDenebDifferentProofCount = fmt.Sprintf(`{
   }
 }`, hexutil.Encode(make([]byte, fieldparams.BlobLength)))
 
-func TestExecutionPayloadResponseUnmarshal(t *testing.T) {
-	epr := &ExecPayloadResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), epr))
-	cases := []struct {
-		expected string
-		actual   string
-		name     string
-	}{
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ParentHash),
-			name:     "ExecPayloadResponse.ExecutionPayload.ParentHash",
-		},
-		{
-			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(epr.Data.FeeRecipient),
-			name:     "ExecPayloadResponse.ExecutionPayload.FeeRecipient",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.StateRoot),
-			name:     "ExecPayloadResponse.ExecutionPayload.StateRoot",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ReceiptsRoot),
-			name:     "ExecPayloadResponse.ExecutionPayload.ReceiptsRoot",
-		},
-		{
-			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(epr.Data.LogsBloom),
-			name:     "ExecPayloadResponse.ExecutionPayload.LogsBloom",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.PrevRandao),
-			name:     "ExecPayloadResponse.ExecutionPayload.PrevRandao",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.BlockNumber),
-			name:     "ExecPayloadResponse.ExecutionPayload.BlockNumber",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.GasLimit),
-			name:     "ExecPayloadResponse.ExecutionPayload.GasLimit",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.GasUsed),
-			name:     "ExecPayloadResponse.ExecutionPayload.GasUsed",
-		},
-		{
-			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.Timestamp),
-			name:     "ExecPayloadResponse.ExecutionPayload.Timestamp",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExtraData),
-			name:     "ExecPayloadResponse.ExecutionPayload.ExtraData",
-		},
-		{
-			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", epr.Data.BaseFeePerGas),
-			name:     "ExecPayloadResponse.ExecutionPayload.BaseFeePerGas",
-		},
-		{
-			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.BlockHash),
-			name:     "ExecPayloadResponse.ExecutionPayload.BlockHash",
-		},
-	}
-	for _, c := range cases {
-		require.Equal(t, c.expected, c.actual, fmt.Sprintf("unexpected value for field %s", c.name))
-	}
-	require.Equal(t, 1, len(epr.Data.Transactions))
-	txHash := "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
-	require.Equal(t, txHash, hexutil.Encode(epr.Data.Transactions[0]))
-}
-
 func TestExecutionPayloadResponseCapellaUnmarshal(t *testing.T) {
 	epr := &ExecPayloadResponseCapella{}
 	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayloadCapella), epr))
@@ -959,67 +877,67 @@ func TestExecutionPayloadResponseCapellaUnmarshal(t *testing.T) {
 	}{
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ParentHash),
+			actual:   epr.Data.ParentHash,
 			name:     "ExecPayloadResponse.ExecutionPayload.ParentHash",
 		},
 		{
 			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(epr.Data.FeeRecipient),
+			actual:   epr.Data.FeeRecipient,
 			name:     "ExecPayloadResponse.ExecutionPayload.FeeRecipient",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.StateRoot),
+			actual:   epr.Data.StateRoot,
 			name:     "ExecPayloadResponse.ExecutionPayload.StateRoot",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ReceiptsRoot),
+			actual:   epr.Data.ReceiptsRoot,
 			name:     "ExecPayloadResponse.ExecutionPayload.ReceiptsRoot",
 		},
 		{
 			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(epr.Data.LogsBloom),
+			actual:   epr.Data.LogsBloom,
 			name:     "ExecPayloadResponse.ExecutionPayload.LogsBloom",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.PrevRandao),
+			actual:   epr.Data.PrevRandao,
 			name:     "ExecPayloadResponse.ExecutionPayload.PrevRandao",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.BlockNumber),
+			actual:   epr.Data.BlockNumber,
 			name:     "ExecPayloadResponse.ExecutionPayload.BlockNumber",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.GasLimit),
+			actual:   epr.Data.GasLimit,
 			name:     "ExecPayloadResponse.ExecutionPayload.GasLimit",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.GasUsed),
+			actual:   epr.Data.GasUsed,
 			name:     "ExecPayloadResponse.ExecutionPayload.GasUsed",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.Timestamp),
+			actual:   epr.Data.Timestamp,
 			name:     "ExecPayloadResponse.ExecutionPayload.Timestamp",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExtraData),
+			actual:   epr.Data.ExtraData,
 			name:     "ExecPayloadResponse.ExecutionPayload.ExtraData",
 		},
 		{
 			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", epr.Data.BaseFeePerGas),
+			actual:   epr.Data.BaseFeePerGas,
 			name:     "ExecPayloadResponse.ExecutionPayload.BaseFeePerGas",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.BlockHash),
+			actual:   epr.Data.BlockHash,
 			name:     "ExecPayloadResponse.ExecutionPayload.BlockHash",
 		},
 	}
@@ -1028,14 +946,14 @@ func TestExecutionPayloadResponseCapellaUnmarshal(t *testing.T) {
 	}
 	require.Equal(t, 1, len(epr.Data.Transactions))
 	txHash := "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
-	require.Equal(t, txHash, hexutil.Encode(epr.Data.Transactions[0]))
+	require.Equal(t, txHash, epr.Data.Transactions[0])
 
 	require.Equal(t, 1, len(epr.Data.Withdrawals))
 	w := epr.Data.Withdrawals[0]
-	assert.Equal(t, uint64(1), w.Index.Uint64())
-	assert.Equal(t, uint64(1), w.ValidatorIndex.Uint64())
-	assert.DeepEqual(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943", w.Address.String())
-	assert.Equal(t, uint64(1), w.Amount.Uint64())
+	assert.Equal(t, "1", w.WithdrawalIndex)
+	assert.Equal(t, "1", w.ValidatorIndex)
+	assert.DeepEqual(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943", w.ExecutionAddress)
+	assert.Equal(t, "1", w.Amount)
 }
 
 func TestExecutionPayloadResponseDenebUnmarshal(t *testing.T) {
@@ -1048,77 +966,77 @@ func TestExecutionPayloadResponseDenebUnmarshal(t *testing.T) {
 	}{
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.ParentHash),
+			actual:   epr.Data.ExecutionPayload.ParentHash,
 			name:     "ExecPayloadResponse.ExecutionPayload.ParentHash",
 		},
 		{
 			expected: "0xabcf8e0d4e9587369b2301d0790347320302cc09",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.FeeRecipient),
+			actual:   epr.Data.ExecutionPayload.FeeRecipient,
 			name:     "ExecPayloadResponse.ExecutionPayload.FeeRecipient",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.StateRoot),
+			actual:   epr.Data.ExecutionPayload.StateRoot,
 			name:     "ExecPayloadResponse.ExecutionPayload.StateRoot",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.ReceiptsRoot),
+			actual:   epr.Data.ExecutionPayload.ReceiptsRoot,
 			name:     "ExecPayloadResponse.ExecutionPayload.ReceiptsRoot",
 		},
 		{
 			expected: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.LogsBloom),
+			actual:   epr.Data.ExecutionPayload.LogsBloom,
 			name:     "ExecPayloadResponse.ExecutionPayload.LogsBloom",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.PrevRandao),
+			actual:   epr.Data.ExecutionPayload.PrevRandao,
 			name:     "ExecPayloadResponse.ExecutionPayload.PrevRandao",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.BlockNumber),
+			actual:   epr.Data.ExecutionPayload.BlockNumber,
 			name:     "ExecPayloadResponse.ExecutionPayload.BlockNumber",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.GasLimit),
+			actual:   epr.Data.ExecutionPayload.GasLimit,
 			name:     "ExecPayloadResponse.ExecutionPayload.GasLimit",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.GasUsed),
+			actual:   epr.Data.ExecutionPayload.GasUsed,
 			name:     "ExecPayloadResponse.ExecutionPayload.GasUsed",
 		},
 		{
 			expected: "1",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.Timestamp),
+			actual:   epr.Data.ExecutionPayload.Timestamp,
 			name:     "ExecPayloadResponse.ExecutionPayload.Timestamp",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.ExtraData),
+			actual:   epr.Data.ExecutionPayload.ExtraData,
 			name:     "ExecPayloadResponse.ExecutionPayload.ExtraData",
 		},
 		{
 			expected: "452312848583266388373324160190187140051835877600158453279131187530910662656",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.BaseFeePerGas),
+			actual:   epr.Data.ExecutionPayload.BaseFeePerGas,
 			name:     "ExecPayloadResponse.ExecutionPayload.BaseFeePerGas",
 		},
 		{
 			expected: "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2",
-			actual:   hexutil.Encode(epr.Data.ExecutionPayload.BlockHash),
+			actual:   epr.Data.ExecutionPayload.BlockHash,
 			name:     "ExecPayloadResponse.ExecutionPayload.BlockHash",
 		},
 		{
 			expected: "2",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.BlobGasUsed),
+			actual:   epr.Data.ExecutionPayload.BlobGasUsed,
 			name:     "ExecPayloadResponse.ExecutionPayload.BlobGasUsed",
 		},
 		{
 			expected: "3",
-			actual:   fmt.Sprintf("%d", epr.Data.ExecutionPayload.ExcessBlobGas),
+			actual:   epr.Data.ExecutionPayload.ExcessBlobGas,
 			name:     "ExecPayloadResponse.ExecutionPayload.ExcessBlobGas",
 		},
 	}
@@ -1127,64 +1045,16 @@ func TestExecutionPayloadResponseDenebUnmarshal(t *testing.T) {
 	}
 	require.Equal(t, 1, len(epr.Data.ExecutionPayload.Transactions))
 	txHash := "0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86"
-	require.Equal(t, txHash, hexutil.Encode(epr.Data.ExecutionPayload.Transactions[0]))
+	require.Equal(t, txHash, epr.Data.ExecutionPayload.Transactions[0])
 
 	require.Equal(t, 1, len(epr.Data.ExecutionPayload.Withdrawals))
 	w := epr.Data.ExecutionPayload.Withdrawals[0]
-	assert.Equal(t, uint64(1), w.Index.Uint64())
-	assert.Equal(t, uint64(1), w.ValidatorIndex.Uint64())
-	assert.DeepEqual(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943", w.Address.String())
-	assert.Equal(t, uint64(1), w.Amount.Uint64())
-	assert.Equal(t, uint64(2), uint64(epr.Data.ExecutionPayload.BlobGasUsed))
-	assert.Equal(t, uint64(3), uint64(epr.Data.ExecutionPayload.ExcessBlobGas))
-}
-
-func TestExecutionPayloadResponseToProto(t *testing.T) {
-	hr := &ExecPayloadResponse{}
-	require.NoError(t, json.Unmarshal([]byte(testExampleExecutionPayload), hr))
-	p, err := hr.ToProto()
-	require.NoError(t, err)
-
-	parentHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	feeRecipient, err := hexutil.Decode("0xabcf8e0d4e9587369b2301d0790347320302cc09")
-	require.NoError(t, err)
-	stateRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	receiptsRoot, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	logsBloom, err := hexutil.Decode("0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
-	require.NoError(t, err)
-	prevRandao, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	extraData, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-	blockHash, err := hexutil.Decode("0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")
-	require.NoError(t, err)
-
-	tx, err := hexutil.Decode("0x02f878831469668303f51d843b9ac9f9843b9aca0082520894c93269b73096998db66be0441e836d873535cb9c8894a19041886f000080c001a031cc29234036afbf9a1fb9476b463367cb1f957ac0b919b69bbc798436e604aaa018c4e9c3914eb27aadd0b91e10b18655739fcf8c1fc398763a9f1beecb8ddc86")
-	require.NoError(t, err)
-	txList := [][]byte{tx}
-
-	bfpg, err := stringToUint256("452312848583266388373324160190187140051835877600158453279131187530910662656")
-	require.NoError(t, err)
-	expected := &v1.ExecutionPayload{
-		ParentHash:    parentHash,
-		FeeRecipient:  feeRecipient,
-		StateRoot:     stateRoot,
-		ReceiptsRoot:  receiptsRoot,
-		LogsBloom:     logsBloom,
-		PrevRandao:    prevRandao,
-		BlockNumber:   1,
-		GasLimit:      1,
-		GasUsed:       1,
-		Timestamp:     1,
-		ExtraData:     extraData,
-		BaseFeePerGas: bfpg.SSZBytes(),
-		BlockHash:     blockHash,
-		Transactions:  txList,
-	}
-	require.DeepEqual(t, expected, p)
+	assert.Equal(t, "1", w.WithdrawalIndex)
+	assert.Equal(t, "1", w.ValidatorIndex)
+	assert.DeepEqual(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943", w.ExecutionAddress)
+	assert.Equal(t, "1", w.Amount)
+	assert.Equal(t, "2", epr.Data.ExecutionPayload.BlobGasUsed)
+	assert.Equal(t, "3", epr.Data.ExecutionPayload.ExcessBlobGas)
 }
 
 func TestExecutionPayloadResponseCapellaToProto(t *testing.T) {
@@ -1352,16 +1222,6 @@ func pbEth1Data() *eth.Eth1Data {
 	}
 }
 
-func TestEth1DataMarshal(t *testing.T) {
-	ed := &Eth1Data{
-		Eth1Data: pbEth1Data(),
-	}
-	b, err := json.Marshal(ed)
-	require.NoError(t, err)
-	expected := `{"deposit_root":"0x0000000000000000000000000000000000000000000000000000000000000000","deposit_count":"23","block_hash":"0x0000000000000000000000000000000000000000000000000000000000000000"}`
-	require.Equal(t, expected, string(b))
-}
-
 func pbSyncAggregate() *eth.SyncAggregate {
 	return &eth.SyncAggregate{
 		SyncCommitteeSignature: make([]byte, 48),
@@ -1369,14 +1229,6 @@ func pbSyncAggregate() *eth.SyncAggregate {
 	}
 }
 
-func TestSyncAggregate_MarshalJSON(t *testing.T) {
-	sa := &SyncAggregate{pbSyncAggregate()}
-	b, err := json.Marshal(sa)
-	require.NoError(t, err)
-	expected := `{"sync_committee_bits":"0x01","sync_committee_signature":"0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"}`
-	require.Equal(t, expected, string(b))
-}
-
 func pbDeposit(t *testing.T) *eth.Deposit {
 	return &eth.Deposit{
 		Proof: [][]byte{ezDecode(t, "0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2")},
@@ -1389,16 +1241,6 @@ func pbDeposit(t *testing.T) *eth.Deposit {
 	}
 }
 
-func TestDeposit_MarshalJSON(t *testing.T) {
-	d := &Deposit{
-		Deposit: pbDeposit(t),
-	}
-	b, err := json.Marshal(d)
-	require.NoError(t, err)
-	expected := `{"proof":["0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"],"data":{"pubkey":"0x93247f2209abcacf57b75a51dafae777f9dd38bc7053d1af526f220a7489a6d3a2753e5f3e8b1cfe39b56f43611df74a","withdrawal_credentials":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","amount":"1","signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
-	require.Equal(t, expected, string(b))
-}
-
 func pbSignedVoluntaryExit(t *testing.T) *eth.SignedVoluntaryExit {
 	return &eth.SignedVoluntaryExit{
 		Exit: &eth.VoluntaryExit{
@@ -1409,16 +1251,6 @@ func pbSignedVoluntaryExit(t *testing.T) *eth.SignedVoluntaryExit {
 	}
 }
 
-func TestVoluntaryExit(t *testing.T) {
-	ve := &SignedVoluntaryExit{
-		SignedVoluntaryExit: pbSignedVoluntaryExit(t),
-	}
-	b, err := json.Marshal(ve)
-	require.NoError(t, err)
-	expected := `{"message":{"epoch":"1","validator_index":"1"},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}`
-	require.Equal(t, expected, string(b))
-}
-
 func pbAttestation(t *testing.T) *eth.Attestation {
 	return &eth.Attestation{
 		AggregationBits: bitfield.Bitlist{0x01},
@@ -1439,16 +1271,6 @@ func pbAttestation(t *testing.T) *eth.Attestation {
 	}
 }
 
-func TestAttestationMarshal(t *testing.T) {
-	a := &Attestation{
-		Attestation: pbAttestation(t),
-	}
-	b, err := json.Marshal(a)
-	require.NoError(t, err)
-	expected := `{"aggregation_bits":"0x01","data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}`
-	require.Equal(t, expected, string(b))
-}
-
 func pbAttesterSlashing(t *testing.T) *eth.AttesterSlashing {
 	return &eth.AttesterSlashing{
 		Attestation_1: &eth.IndexedAttestation{
@@ -1489,9 +1311,7 @@ func pbAttesterSlashing(t *testing.T) *eth.AttesterSlashing {
 }
 
 func TestAttesterSlashing_MarshalJSON(t *testing.T) {
-	as := &AttesterSlashing{
-		AttesterSlashing: pbAttesterSlashing(t),
-	}
+	as := structs.AttesterSlashingFromConsensus(pbAttesterSlashing(t))
 	b, err := json.Marshal(as)
 	require.NoError(t, err)
 	expected := `{"attestation_1":{"attesting_indices":["1"],"data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"},"attestation_2":{"attesting_indices":["1"],"data":{"slot":"1","index":"1","beacon_block_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","source":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"},"target":{"epoch":"1","root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}},"signature":"0x1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505cc411d61252fb6cb3fa0017b679f8bb2305b26a285fa2737f175668d0dff91cc1b66ac1fb663c9bc59509846d6ec05345bd908eda73e670af888da41af171505"}}`
@@ -1599,9 +1419,8 @@ func pbExecutionPayloadHeaderDeneb(t *testing.T) *v1.ExecutionPayloadHeaderDeneb
 }
 
 func TestExecutionPayloadHeader_MarshalJSON(t *testing.T) {
-	h := &ExecutionPayloadHeader{
-		ExecutionPayloadHeader: pbExecutionPayloadHeader(t),
-	}
+	h, err := structs.ExecutionPayloadHeaderFromConsensus(pbExecutionPayloadHeader(t))
+	require.NoError(t, err)
 	b, err := json.Marshal(h)
 	require.NoError(t, err)
 	expected := `{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"452312848583266388373324160190187140051835877600158453279131187530910662656","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}`
@@ -1609,9 +1428,9 @@ func TestExecutionPayloadHeader_MarshalJSON(t *testing.T) {
 }
 
 func TestExecutionPayloadHeaderCapella_MarshalJSON(t *testing.T) {
-	h := &ExecutionPayloadHeaderCapella{
-		ExecutionPayloadHeaderCapella: pbExecutionPayloadHeaderCapella(t),
-	}
+	h, err := structs.ExecutionPayloadHeaderCapellaFromConsensus(pbExecutionPayloadHeaderCapella(t))
+	require.NoError(t, err)
+	require.NoError(t, err)
 	b, err := json.Marshal(h)
 	require.NoError(t, err)
 	expected := `{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"452312848583266388373324160190187140051835877600158453279131187530910662656","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","withdrawals_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2"}`
@@ -1619,9 +1438,8 @@ func TestExecutionPayloadHeaderCapella_MarshalJSON(t *testing.T) {
 }
 
 func TestExecutionPayloadHeaderDeneb_MarshalJSON(t *testing.T) {
-	h := &ExecutionPayloadHeaderDeneb{
-		ExecutionPayloadHeaderDeneb: pbExecutionPayloadHeaderDeneb(t),
-	}
+	h, err := structs.ExecutionPayloadHeaderDenebFromConsensus(pbExecutionPayloadHeaderDeneb(t))
+	require.NoError(t, err)
 	b, err := json.Marshal(h)
 	require.NoError(t, err)
 	expected := `{"parent_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","fee_recipient":"0xabcf8e0d4e9587369b2301d0790347320302cc09","state_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","receipts_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","logs_bloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000","prev_randao":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","block_number":"1","gas_limit":"1","gas_used":"1","timestamp":"1","extra_data":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","base_fee_per_gas":"452312848583266388373324160190187140051835877600158453279131187530910662656","block_hash":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","transactions_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","withdrawals_root":"0xcf8e0d4e9587369b2301d0790347320302cc0943d5a1884560367e8208d920f2","blob_gas_used":"1","excess_blob_gas":"2"}`
@@ -1850,12 +1668,13 @@ func TestRoundTripUint256(t *testing.T) {
 func TestRoundTripProtoUint256(t *testing.T) {
 	h := pbExecutionPayloadHeader(t)
 	h.BaseFeePerGas = []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31}
-	hm := &ExecutionPayloadHeader{ExecutionPayloadHeader: h}
+	hm, err := structs.ExecutionPayloadHeaderFromConsensus(h)
+	require.NoError(t, err)
 	m, err := json.Marshal(hm)
 	require.NoError(t, err)
-	hu := &ExecutionPayloadHeader{}
+	hu := &structs.ExecutionPayloadHeader{}
 	require.NoError(t, json.Unmarshal(m, hu))
-	hp, err := hu.ToProto()
+	hp, err := hu.ToConsensus()
 	require.NoError(t, err)
 	require.DeepEqual(t, h.BaseFeePerGas, hp.BaseFeePerGas)
 }
@@ -1863,7 +1682,7 @@ func TestRoundTripProtoUint256(t *testing.T) {
 func TestExecutionPayloadHeaderRoundtrip(t *testing.T) {
 	expected, err := os.ReadFile("testdata/execution-payload.json")
 	require.NoError(t, err)
-	hu := &ExecutionPayloadHeader{}
+	hu := &structs.ExecutionPayloadHeader{}
 	require.NoError(t, json.Unmarshal(expected, hu))
 	m, err := json.Marshal(hu)
 	require.NoError(t, err)
@@ -1873,7 +1692,7 @@ func TestExecutionPayloadHeaderRoundtrip(t *testing.T) {
 func TestExecutionPayloadHeaderCapellaRoundtrip(t *testing.T) {
 	expected, err := os.ReadFile("testdata/execution-payload-capella.json")
 	require.NoError(t, err)
-	hu := &ExecutionPayloadHeaderCapella{}
+	hu := &structs.ExecutionPayloadHeaderCapella{}
 	require.NoError(t, json.Unmarshal(expected, hu))
 	m, err := json.Marshal(hu)
 	require.NoError(t, err)
@@ -1994,11 +1813,9 @@ func TestEmptyResponseBody(t *testing.T) {
 			epr := &ExecutionPayloadResponse{}
 			require.NoError(t, json.Unmarshal(encoded, epr))
 			pp, err := epr.ParsePayload()
-			require.NoError(t, err)
-			pb, err := pp.PayloadProto()
 			if err == nil {
 				require.NoError(t, err)
-				require.Equal(t, false, pb == nil)
+				require.Equal(t, false, pp == nil)
 			} else {
 				require.ErrorIs(t, err, consensusblocks.ErrNilObject)
 			}

api/client/event/event_stream.go

@@ -14,22 +14,10 @@ import (
 )
 
 const (
-	EventHead                        = "head"
-	EventBlock                       = "block"
-	EventAttestation                 = "attestation"
-	EventVoluntaryExit               = "voluntary_exit"
-	EventBlsToExecutionChange        = "bls_to_execution_change"
-	EventProposerSlashing            = "proposer_slashing"
-	EventAttesterSlashing            = "attester_slashing"
-	EventFinalizedCheckpoint         = "finalized_checkpoint"
-	EventChainReorg                  = "chain_reorg"
-	EventContributionAndProof        = "contribution_and_proof"
-	EventLightClientFinalityUpdate   = "light_client_finality_update"
-	EventLightClientOptimisticUpdate = "light_client_optimistic_update"
-	EventPayloadAttributes           = "payload_attributes"
-	EventBlobSidecar                 = "blob_sidecar"
-	EventError                       = "error"
-	EventConnectionError             = "connection_error"
+	EventHead = "head"
+
+	EventError           = "error"
+	EventConnectionError = "connection_error"
 )
 
 var (

api/client/event/event_stream_test.go

@@ -83,8 +83,7 @@ func TestEventStream(t *testing.T) {
 func TestEventStreamRequestError(t *testing.T) {
 	topics := []string{"head"}
 	eventsChannel := make(chan *Event, 1)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	// use valid url that will result in failed request with nil body
 	stream, err := NewEventStream(ctx, http.DefaultClient, "http://badhost:1234", topics)

api/server/structs/BUILD.bazel

@@ -31,6 +31,7 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/blocks:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/validator:go_default_library",
@@ -44,6 +45,7 @@ go_library(
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
+        "@org_golang_google_protobuf//proto:go_default_library",
     ],
 )
 

api/server/structs/conversions_block_execution.go

@@ -7,12 +7,15 @@ import (
 	"github.com/OffchainLabs/prysm/v6/api/server"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	consensusblocks "github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/container/slice"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/pkg/errors"
+	"google.golang.org/protobuf/proto"
 )
 
 // ----------------------------------------------------------------------------
@@ -132,6 +135,13 @@ func (e *ExecutionPayload) ToConsensus() (*enginev1.ExecutionPayload, error) {
 	}, nil
 }
 
+func (r *ExecutionPayload) PayloadProto() (proto.Message, error) {
+	if r == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil execution payload")
+	}
+	return r.ToConsensus()
+}
+
 func ExecutionPayloadHeaderFromConsensus(payload *enginev1.ExecutionPayloadHeader) (*ExecutionPayloadHeader, error) {
 	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
 	if err != nil {
@@ -383,6 +393,13 @@ func (e *ExecutionPayloadCapella) ToConsensus() (*enginev1.ExecutionPayloadCapel
 	}, nil
 }
 
+func (p *ExecutionPayloadCapella) PayloadProto() (proto.Message, error) {
+	if p == nil {
+		return nil, errors.Wrap(consensusblocks.ErrNilObject, "nil capella execution payload")
+	}
+	return p.ToConsensus()
+}
+
 func ExecutionPayloadHeaderCapellaFromConsensus(payload *enginev1.ExecutionPayloadHeaderCapella) (*ExecutionPayloadHeaderCapella, error) {
 	baseFeePerGas, err := sszBytesToUint256String(payload.BaseFeePerGas)
 	if err != nil {

beacon-chain/README.md

@@ -4,6 +4,6 @@ This is the main project folder for the beacon chain implementation of Ethereum
 
 You can also read our main [README](https://github.com/prysmaticlabs/prysm/blob/master/README.md) and join our active chat room on Discord.
 
-[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/CTYGPUJ)
+[![Discord](https://user-images.githubusercontent.com/7288322/34471967-1df7808a-efbb-11e7-9088-ed0b04151291.png)](https://discord.gg/prysm)
 
 Also, read the official beacon chain [specification](https://github.com/ethereum/consensus-specs/blob/master/specs/phase0/beacon-chain.md), this design spec serves as a source of truth for the beacon chain implementation we follow at Prysmatic Labs.

beacon-chain/blockchain/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
+        "receive_data_column.go",
         "service.go",
         "setup_forchoice.go",
         "tracked_proposer.go",
@@ -50,6 +51,7 @@ go_library(
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -146,6 +148,7 @@ go_test(
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/das:go_default_library",

beacon-chain/blockchain/error.go

@@ -40,10 +40,12 @@ var (
 	errNotGenesisRoot = errors.New("root is not the genesis block root")
 	// errBlacklistedBlock is returned when a block is blacklisted as invalid.
 	errBlacklistedRoot = verification.AsVerificationFailure(errors.New("block root is blacklisted"))
+	// errMaxBlobsExceeded is returned when the number of blobs in a block exceeds the maximum allowed.
+	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"))
 )
 
-var errMaxBlobsExceeded = verification.AsVerificationFailure(errors.New("Expected commitments in block exceeds MAX_BLOBS_PER_BLOCK"))
-
 // An invalid block is the block that fails state transition based on the core protocol rules.
 // The beacon node shall not be accepting nor building blocks that branch off from an invalid block.
 // Some examples of invalid blocks are:

beacon-chain/blockchain/execution_engine.go

@@ -439,6 +439,9 @@ func (s *Service) removeInvalidBlockAndState(ctx context.Context, blkRoots [][32
 			// Blobs may not exist for some blocks, leading to deletion failures. Log such errors at debug level.
 			log.WithError(err).Debug("Could not remove blob from blob storage")
 		}
+		if err := s.dataColumnStorage.Remove(root); err != nil {
+			log.WithError(err).Errorf("Could not remove data columns from data column storage for root %#x", root)
+		}
 	}
 	return nil
 }

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -29,9 +29,8 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//consensus-types/blocks:go_default_library",
+        "//crypto/random:go_default_library",
         "//testing/require:go_default_library",
-        "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/blockchain/kzg/validation_test.go

@@ -1,16 +1,12 @@
 package kzg
 
 import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/binary"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/crypto/random"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
-	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	"github.com/sirupsen/logrus"
 )
 
 func GenerateCommitmentAndProof(blob GoKZG.Blob) (GoKZG.KZGCommitment, GoKZG.KZGProof, error) {
@@ -41,7 +37,7 @@ func TestBytesToAny(t *testing.T) {
 }
 
 func TestGenerateCommitmentAndProof(t *testing.T) {
-	blob := getRandBlob(123)
+	blob := random.GetRandBlob(123)
 	commitment, proof, err := GenerateCommitmentAndProof(blob)
 	require.NoError(t, err)
 	expectedCommitment := GoKZG.KZGCommitment{180, 218, 156, 194, 59, 20, 10, 189, 186, 254, 132, 93, 7, 127, 104, 172, 238, 240, 237, 70, 83, 89, 1, 152, 99, 0, 165, 65, 143, 62, 20, 215, 230, 14, 205, 95, 28, 245, 54, 25, 160, 16, 178, 31, 232, 207, 38, 85}
@@ -49,36 +45,3 @@ func TestGenerateCommitmentAndProof(t *testing.T) {
 	require.Equal(t, expectedCommitment, commitment)
 	require.Equal(t, expectedProof, proof)
 }
-
-func deterministicRandomness(seed int64) [32]byte {
-	// Converts an int64 to a byte slice
-	buf := new(bytes.Buffer)
-	err := binary.Write(buf, binary.BigEndian, seed)
-	if err != nil {
-		logrus.WithError(err).Error("Failed to write int64 to bytes buffer")
-		return [32]byte{}
-	}
-	bytes := buf.Bytes()
-
-	return sha256.Sum256(bytes)
-}
-
-// Returns a serialized random field element in big-endian
-func getRandFieldElement(seed int64) [32]byte {
-	bytes := deterministicRandomness(seed)
-	var r fr.Element
-	r.SetBytes(bytes[:])
-
-	return GoKZG.SerializeScalar(r)
-}
-
-// Returns a random blob using the passed seed as entropy
-func getRandBlob(seed int64) GoKZG.Blob {
-	var blob GoKZG.Blob
-	bytesPerBlob := GoKZG.ScalarsPerBlob * GoKZG.SerializedScalarSize
-	for i := 0; i < bytesPerBlob; i += GoKZG.SerializedScalarSize {
-		fieldElementBytes := getRandFieldElement(seed + int64(i))
-		copy(blob[i:i+GoKZG.SerializedScalarSize], fieldElementBytes[:])
-	}
-	return blob
-}

beacon-chain/blockchain/options.go

@@ -1,10 +1,13 @@
 package blockchain
 
 import (
+	"time"
+
 	"github.com/OffchainLabs/prysm/v6/async/event"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
 	lightclient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/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"
@@ -127,9 +130,9 @@ func WithBLSToExecPool(p blstoexec.PoolManager) Option {
 }
 
 // WithP2PBroadcaster to broadcast messages after appropriate processing.
-func WithP2PBroadcaster(p p2p.Broadcaster) Option {
+func WithP2PBroadcaster(p p2p.Accessor) Option {
 	return func(s *Service) error {
-		s.cfg.P2p = p
+		s.cfg.P2P = p
 		return nil
 	}
 }
@@ -208,6 +211,15 @@ func WithBlobStorage(b *filesystem.BlobStorage) Option {
 	}
 }
 
+// WithDataColumnStorage sets the data column storage backend for the blockchain service.
+func WithDataColumnStorage(b *filesystem.DataColumnStorage) Option {
+	return func(s *Service) error {
+		s.dataColumnStorage = b
+		return nil
+	}
+}
+
+// WithSyncChecker sets the sync checker for the blockchain service.
 func WithSyncChecker(checker Checker) Option {
 	return func(s *Service) error {
 		s.cfg.SyncChecker = checker
@@ -215,6 +227,15 @@ 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 {
 		s.slasherEnabled = enabled
@@ -222,6 +243,15 @@ func WithSlasherEnabled(enabled bool) Option {
 	}
 }
 
+// WithGenesisTime sets the genesis time for the blockchain service.
+func WithGenesisTime(genesisTime time.Time) Option {
+	return func(s *Service) error {
+		s.genesisTime = genesisTime
+		return nil
+	}
+}
+
+// WithLightClientStore sets the light client store for the blockchain service.
 func WithLightClientStore(lcs *lightclient.Store) Option {
 	return func(s *Service) error {
 		s.lcStore = lcs

beacon-chain/blockchain/process_block.go

@@ -3,10 +3,12 @@ package blockchain
 import (
 	"context"
 	"fmt"
+	"slices"
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/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/das"
@@ -239,8 +241,9 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []consensusblocks.ROBlo
 				return err
 			}
 		}
+
 		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), b); err != nil {
-			return errors.Wrapf(err, "could not validate blob data availability at slot %d", b.Block().Slot())
+			return errors.Wrapf(err, "could not validate sidecar availability at slot %d", b.Block().Slot())
 		}
 		args := &forkchoicetypes.BlockAndCheckpoints{Block: b,
 			JustifiedCheckpoint: jCheckpoints[i],
@@ -578,12 +581,12 @@ func (s *Service) runLateBlockTasks() {
 	}
 }
 
-// missingIndices uses the expected commitments from the block to determine
+// missingBlobIndices uses the expected commitments from the block to determine
 // which BlobSidecar indices would need to be in the database for DA success.
 // 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 missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte, slot primitives.Slot) (map[uint64]struct{}, error) {
+func missingBlobIndices(bs *filesystem.BlobStorage, root [fieldparams.RootLength]byte, expected [][]byte, slot primitives.Slot) (map[uint64]bool, error) {
 	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	if len(expected) == 0 {
 		return nil, nil
@@ -592,29 +595,223 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 		return nil, errMaxBlobsExceeded
 	}
 	indices := bs.Summary(root)
-	missing := make(map[uint64]struct{}, len(expected))
+	missing := make(map[uint64]bool, len(expected))
 	for i := range expected {
 		if len(expected[i]) > 0 && !indices.HasIndex(uint64(i)) {
-			missing[uint64(i)] = struct{}{}
+			missing[uint64(i)] = true
 		}
 	}
 	return missing, nil
 }
 
-// isDataAvailable blocks until all BlobSidecars committed to in the block are available,
-// or an error or context cancellation occurs. A nil result means that the data availability check is successful.
-// The function will first check the database to see if all sidecars have been persisted. If any
-// sidecars are missing, it will then read from the blobNotifier channel for the given root until the channel is
-// closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
-func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
-	if signed.Version() < version.Deneb {
-		return nil
+// missingDataColumnIndices uses the expected data columns from the block to determine
+// which DataColumnSidecar indices would need to be in the database for DA success.
+// 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) {
+	if len(expected) == 0 {
+		return nil, nil
 	}
 
-	block := signed.Block()
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	if uint64(len(expected)) > numberOfColumns {
+		return nil, errMaxDataColumnsExceeded
+	}
+
+	// Get a summary of the data columns stored in the database.
+	summary := bs.Summary(root)
+
+	// Check all expected data columns against the summary.
+	missing := make(map[uint64]bool)
+	for column := range expected {
+		if !summary.HasIndex(column) {
+			missing[column] = true
+		}
+	}
+
+	return missing, nil
+}
+
+// isDataAvailable blocks until all sidecars committed to in the block are available,
+// or an error or context cancellation occurs. A nil result means that the data availability check is successful.
+// The function will first check the database to see if all sidecars have been persisted. If any
+// sidecars are missing, it will then read from the sidecar notifier channel for the given root until the channel is
+// closed, the context hits cancellation/timeout, or notifications have been received for all the missing sidecars.
+func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signedBlock interfaces.ReadOnlySignedBeaconBlock) error {
+	block := signedBlock.Block()
 	if block == nil {
 		return errors.New("invalid nil beacon block")
 	}
+
+	blockVersion := block.Version()
+	if blockVersion >= version.Fulu {
+		return s.areDataColumnsAvailable(ctx, root, block)
+	}
+
+	if blockVersion >= version.Deneb {
+		return s.areBlobsAvailable(ctx, root, block)
+	}
+
+	return nil
+}
+
+// areDataColumnsAvailable blocks until all data columns committed to in the block are available,
+// or an error or context cancellation occurs. A nil result means that the data availability check is successful.
+func (s *Service) areDataColumnsAvailable(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 not commitments there is nothing to wait for.
+	if len(kzgCommitments) == 0 {
+		return nil
+	}
+
+	// All columns to sample need to be available for the block to be considered available.
+	// https://github.com/ethereum/consensus-specs/blob/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)
+	if err != nil {
+		return errors.Wrap(err, "peer info")
+	}
+
+	// Subscribe to newly data columns stored in the database.
+	subscription, identsChan := s.dataColumnStorage.Subscribe()
+	defer subscription.Unsubscribe()
+
+	// Get the count of data columns we already have in the store.
+	summary := s.dataColumnStorage.Summary(root)
+	storedDataColumnsCount := summary.Count()
+
+	minimumColumnCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
+
+	// As soon as we have enough data column sidecars, we can reconstruct the missing ones.
+	// We don't need to wait for the rest of the data columns to declare the block as available.
+	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.
+	// This is the happy path.
+	if len(missingMap) == 0 {
+		return nil
+	}
+
+	// Log for DA checks that cross over into the next slot; helpful for debugging.
+	nextSlot := slots.BeginsAt(block.Slot()+1, s.genesisTime)
+
+	// Avoid logging if DA check is called after next slot start.
+	if nextSlot.After(time.Now()) {
+		timer := time.AfterFunc(time.Until(nextSlot), func() {
+			missingMapCount := uint64(len(missingMap))
+
+			if missingMapCount == 0 {
+				return
+			}
+
+			var (
+				expected interface{} = "all"
+				missing  interface{} = "all"
+			)
+
+			numberOfColumns := params.BeaconConfig().NumberOfColumns
+			colMapCount := uint64(len(peerInfo.CustodyColumns))
+
+			if colMapCount < numberOfColumns {
+				expected = uint64MapToSortedSlice(peerInfo.CustodyColumns)
+			}
+
+			if missingMapCount < numberOfColumns {
+				missing = uint64MapToSortedSlice(missingMap)
+			}
+
+			log.WithFields(logrus.Fields{
+				"slot":            block.Slot(),
+				"root":            fmt.Sprintf("%#x", root),
+				"columnsExpected": expected,
+				"columnsWaiting":  missing,
+			}).Warning("Data columns still missing at slot end")
+		})
+		defer timer.Stop()
+	}
+
+	for {
+		select {
+		case idents := <-identsChan:
+			if idents.Root != root {
+				// This is not the root we are looking for.
+				continue
+			}
+
+			for _, index := range idents.Indices {
+				// This is a data column we are expecting.
+				if _, ok := missingMap[index]; ok {
+					storedDataColumnsCount++
+				}
+
+				// As soon as we have more than half of the data columns, we can reconstruct the missing ones.
+				// We don't need to wait for the rest of the data columns to declare the block as available.
+				if storedDataColumnsCount >= minimumColumnCountToReconstruct {
+					return nil
+				}
+
+				// Remove the index from the missing map.
+				delete(missingMap, index)
+
+				// Return if there is no more missing data columns.
+				if len(missingMap) == 0 {
+					return nil
+				}
+			}
+
+		case <-ctx.Done():
+			var missingIndices interface{} = "all"
+			numberOfColumns := params.BeaconConfig().NumberOfColumns
+			missingIndicesCount := uint64(len(missingMap))
+
+			if missingIndicesCount < numberOfColumns {
+				missingIndices = uint64MapToSortedSlice(missingMap)
+			}
+
+			return errors.Wrapf(ctx.Err(), "data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndices)
+		}
+	}
+}
+
+// areBlobsAvailable blocks until all BlobSidecars committed to in the block are available,
+// or an error or context cancellation occurs. A nil result means that the data availability check is successful.
+func (s *Service) areBlobsAvailable(ctx context.Context, root [fieldparams.RootLength]byte, block interfaces.ReadOnlyBeaconBlock) error {
+	blockSlot := block.Slot()
+
 	// 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
@@ -634,9 +831,9 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 		return nil
 	}
 	// get a map of BlobSidecar indices that are not currently available.
-	missing, err := missingIndices(s.blobStorage, root, kzgCommitments, block.Slot())
+	missing, err := missingBlobIndices(s.blobStorage, root, kzgCommitments, block.Slot())
 	if err != nil {
-		return err
+		return errors.Wrap(err, "missing indices")
 	}
 	// If there are no missing indices, all BlobSidecars are available.
 	if len(missing) == 0 {
@@ -648,15 +845,20 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	nc := s.blobNotifiers.forRoot(root, block.Slot())
 
 	// Log for DA checks that cross over into the next slot; helpful for debugging.
-	nextSlot := slots.BeginsAt(signed.Block().Slot()+1, s.genesisTime)
+	nextSlot := slots.BeginsAt(block.Slot()+1, s.genesisTime)
 	// Avoid logging if DA check is called after next slot start.
 	if nextSlot.After(time.Now()) {
 		nst := time.AfterFunc(time.Until(nextSlot), func() {
 			if len(missing) == 0 {
 				return
 			}
-			log.WithFields(daCheckLogFields(root, signed.Block().Slot(), expected, len(missing))).
-				Error("Still waiting for DA check at slot end.")
+
+			log.WithFields(logrus.Fields{
+				"slot":          blockSlot,
+				"root":          fmt.Sprintf("%#x", root),
+				"blobsExpected": expected,
+				"blobsWaiting":  len(missing),
+			}).Error("Still waiting for blobs DA check at slot end.")
 		})
 		defer nst.Stop()
 	}
@@ -678,13 +880,14 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	}
 }
 
-func daCheckLogFields(root [32]byte, slot primitives.Slot, expected, missing int) logrus.Fields {
-	return logrus.Fields{
-		"slot":          slot,
-		"root":          fmt.Sprintf("%#x", root),
-		"blobsExpected": expected,
-		"blobsWaiting":  missing,
+// uint64MapToSortedSlice produces a sorted uint64 slice from a map.
+func uint64MapToSortedSlice(input map[uint64]bool) []uint64 {
+	output := make([]uint64, 0, len(input))
+	for idx := range input {
+		output = append(output, idx)
 	}
+	slices.Sort[[]uint64](output)
+	return output
 }
 
 // lateBlockTasks  is called 4 seconds into the slot and performs tasks
@@ -770,7 +973,7 @@ func (s *Service) waitForSync() error {
 	}
 }
 
-func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot [32]byte, parentRoot [32]byte) error {
+func (s *Service) handleInvalidExecutionError(ctx context.Context, err error, blockRoot, parentRoot [fieldparams.RootLength]byte) error {
 	if IsInvalidBlock(err) && InvalidBlockLVH(err) != [32]byte{} {
 		return s.pruneInvalidBlock(ctx, blockRoot, parentRoot, InvalidBlockLVH(err))
 	}

beacon-chain/blockchain/process_block_helpers.go

@@ -310,7 +310,7 @@ func (s *Service) processLightClientFinalityUpdate(
 		Data: newUpdate,
 	})
 
-	if err = s.cfg.P2p.BroadcastLightClientFinalityUpdate(ctx, newUpdate); err != nil {
+	if err = s.cfg.P2P.BroadcastLightClientFinalityUpdate(ctx, newUpdate); err != nil {
 		return errors.Wrap(err, "could not broadcast light client finality update")
 	}
 
@@ -363,7 +363,7 @@ func (s *Service) processLightClientOptimisticUpdate(ctx context.Context, signed
 		Data: newUpdate,
 	})
 
-	if err = s.cfg.P2p.BroadcastLightClientOptimisticUpdate(ctx, newUpdate); err != nil {
+	if err = s.cfg.P2P.BroadcastLightClientOptimisticUpdate(ctx, newUpdate); err != nil {
 		return errors.Wrap(err, "could not broadcast light client optimistic update")
 	}
 

beacon-chain/blockchain/process_block_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/blocks"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/das"
@@ -2331,13 +2332,13 @@ func driftGenesisTime(s *Service, slot, delay int64) {
 	s.cfg.ForkChoiceStore.SetGenesisTime(uint64(newTime.Unix()))
 }
 
-func TestMissingIndices(t *testing.T) {
+func TestMissingBlobIndices(t *testing.T) {
 	cases := []struct {
 		name     string
 		expected [][]byte
 		present  []uint64
 		result   map[uint64]struct{}
-		root     [32]byte
+		root     [fieldparams.RootLength]byte
 		err      error
 	}{
 		{
@@ -2395,7 +2396,7 @@ func TestMissingIndices(t *testing.T) {
 		bm, bs := filesystem.NewEphemeralBlobStorageWithMocker(t)
 		t.Run(c.name, func(t *testing.T) {
 			require.NoError(t, bm.CreateFakeIndices(c.root, 0, c.present...))
-			missing, err := missingIndices(bs, c.root, c.expected, 0)
+			missing, err := missingBlobIndices(bs, c.root, c.expected, 0)
 			if c.err != nil {
 				require.ErrorIs(t, err, c.err)
 				return
@@ -2403,9 +2404,70 @@ func TestMissingIndices(t *testing.T) {
 			require.NoError(t, err)
 			require.Equal(t, len(c.result), len(missing))
 			for key := range c.result {
-				m, ok := missing[key]
-				require.Equal(t, true, ok)
-				require.Equal(t, c.result[key], m)
+				require.Equal(t, true, missing[key])
+			}
+		})
+	}
+}
+
+func TestMissingDataColumnIndices(t *testing.T) {
+	countPlusOne := params.BeaconConfig().NumberOfColumns + 1
+	tooManyColumns := make(map[uint64]bool, countPlusOne)
+	for i := range countPlusOne {
+		tooManyColumns[uint64(i)] = true
+	}
+
+	testCases := []struct {
+		name          string
+		storedIndices []uint64
+		input         map[uint64]bool
+		expected      map[uint64]bool
+		err           error
+	}{
+		{
+			name:  "zero len expected",
+			input: map[uint64]bool{},
+		},
+		{
+			name:  "expected exceeds max",
+			input: tooManyColumns,
+			err:   errMaxDataColumnsExceeded,
+		},
+		{
+			name:          "all missing",
+			storedIndices: []uint64{},
+			input:         map[uint64]bool{0: true, 1: true, 2: true},
+			expected:      map[uint64]bool{0: true, 1: true, 2: true},
+		},
+		{
+			name:          "none missing",
+			input:         map[uint64]bool{0: true, 1: true, 2: true},
+			expected:      map[uint64]bool{},
+			storedIndices: []uint64{0, 1, 2, 3, 4}, // Extra columns stored but not expected
+		},
+		{
+			name:          "some missing",
+			storedIndices: []uint64{0, 20},
+			input:         map[uint64]bool{0: true, 10: true, 20: true, 30: true},
+			expected:      map[uint64]bool{10: true, 30: true},
+		},
+	}
+
+	var emptyRoot [fieldparams.RootLength]byte
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			dcm, dcs := filesystem.NewEphemeralDataColumnStorageWithMocker(t)
+			err := dcm.CreateFakeIndices(emptyRoot, 0, tc.storedIndices...)
+			require.NoError(t, err)
+
+			// Test the function
+			actual, err := missingDataColumnIndices(dcs, emptyRoot, tc.input)
+			require.ErrorIs(t, err, tc.err)
+
+			require.Equal(t, len(tc.expected), len(actual))
+			for key := range tc.expected {
+				require.Equal(t, true, actual[key])
 			}
 		})
 	}
@@ -3246,6 +3308,193 @@ func TestSaveLightClientBootstrap(t *testing.T) {
 	reset()
 }
 
+type testIsAvailableParams struct {
+	options                 []Option
+	blobKzgCommitmentsCount uint64
+	columnsToSave           []uint64
+}
+
+func testIsAvailableSetup(t *testing.T, params testIsAvailableParams) (context.Context, context.CancelFunc, *Service, [fieldparams.RootLength]byte, interfaces.SignedBeaconBlock) {
+	ctx, cancel := context.WithCancel(context.Background())
+	dataColumnStorage := filesystem.NewEphemeralDataColumnStorage(t)
+
+	options := append(params.options, WithDataColumnStorage(dataColumnStorage))
+	service, _ := minimalTestService(t, options...)
+
+	genesisState, secretKeys := util.DeterministicGenesisStateElectra(t, 32 /*validator count*/)
+
+	err := service.saveGenesisData(ctx, genesisState)
+	require.NoError(t, err)
+
+	conf := util.DefaultBlockGenConfig()
+	conf.NumBlobKzgCommitments = params.blobKzgCommitmentsCount
+
+	signedBeaconBlock, err := util.GenerateFullBlockFulu(genesisState, secretKeys, conf, 10 /*block slot*/)
+	require.NoError(t, err)
+
+	root, err := signedBeaconBlock.Block.HashTreeRoot()
+	require.NoError(t, err)
+
+	dataColumnsParams := make([]util.DataColumnParams, 0, len(params.columnsToSave))
+	for _, i := range params.columnsToSave {
+		dataColumnParam := util.DataColumnParams{ColumnIndex: i}
+		dataColumnsParams = append(dataColumnsParams, dataColumnParam)
+	}
+
+	dataColumnParamsByBlockRoot := util.DataColumnsParamsByRoot{root: dataColumnsParams}
+	_, verifiedRODataColumns := util.CreateTestVerifiedRoDataColumnSidecars(t, dataColumnParamsByBlockRoot)
+
+	err = dataColumnStorage.Save(verifiedRODataColumns)
+	require.NoError(t, err)
+
+	signed, err := consensusblocks.NewSignedBeaconBlock(signedBeaconBlock)
+	require.NoError(t, err)
+
+	return ctx, cancel, service, root, signed
+}
+
+func TestIsDataAvailable(t *testing.T) {
+	t.Run("Fulu - out of retention window", func(t *testing.T) {
+		params := testIsAvailableParams{options: []Option{WithGenesisTime(time.Unix(0, 0))}}
+		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NoError(t, err)
+	})
+
+	t.Run("Fulu - no commitment in blocks", func(t *testing.T) {
+		ctx, _, service, root, signed := testIsAvailableSetup(t, testIsAvailableParams{})
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NoError(t, err)
+	})
+
+	t.Run("Fulu - more than half of the columns in custody", func(t *testing.T) {
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
+		indices := make([]uint64, 0, minimumColumnsCountToReconstruct)
+		for i := range minimumColumnsCountToReconstruct {
+			indices = append(indices, i)
+		}
+
+		params := testIsAvailableParams{
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			columnsToSave:           indices,
+			blobKzgCommitmentsCount: 3,
+		}
+
+		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NoError(t, err)
+	})
+
+	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,
+		}
+
+		ctx, _, service, root, signed := testIsAvailableSetup(t, params)
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NoError(t, err)
+	})
+
+	t.Run("Fulu - some initially missing data columns (no reconstruction)", func(t *testing.T) {
+		testParams := testIsAvailableParams{
+			options:       []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			columnsToSave: []uint64{1, 17, 19, 75, 102, 117, 119}, // 119 is not needed, 42 and 87 are missing
+
+			blobKzgCommitmentsCount: 3,
+		}
+
+		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
+
+		var wrongRoot [fieldparams.RootLength]byte
+		copy(wrongRoot[:], root[:])
+		wrongRoot[0]++ // change the root to simulate a wrong root
+
+		_, verifiedSidecarsWrongRoot := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{wrongRoot: {
+			{ColumnIndex: 42}, // needed
+		}})
+
+		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{root: {
+			{ColumnIndex: 87}, // needed
+			{ColumnIndex: 1},  // not needed
+			{ColumnIndex: 42}, // needed
+		}})
+
+		time.AfterFunc(10*time.Millisecond, func() {
+			err := service.dataColumnStorage.Save(verifiedSidecarsWrongRoot)
+			require.NoError(t, err)
+
+			err = service.dataColumnStorage.Save(verifiedSidecars)
+			require.NoError(t, err)
+		})
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NoError(t, err)
+	})
+
+	t.Run("Fulu - some initially missing data columns (reconstruction)", func(t *testing.T) {
+		const (
+			missingColumns = uint64(2)
+			cgc            = 128
+		)
+		var custodyInfo peerdas.CustodyInfo
+		custodyInfo.TargetGroupCount.SetValidatorsCustodyRequirement(cgc)
+		custodyInfo.ToAdvertiseGroupCount.Set(cgc)
+
+		minimumColumnsCountToReconstruct := peerdas.MinimumColumnsCountToReconstruct()
+		indices := make([]uint64, 0, minimumColumnsCountToReconstruct-missingColumns)
+
+		for i := range minimumColumnsCountToReconstruct - missingColumns {
+			indices = append(indices, i)
+		}
+
+		testParams := testIsAvailableParams{
+			options:                 []Option{WithCustodyInfo(&custodyInfo)},
+			columnsToSave:           indices,
+			blobKzgCommitmentsCount: 3,
+		}
+
+		ctx, _, service, root, signed := testIsAvailableSetup(t, testParams)
+
+		dataColumnParams := make([]util.DataColumnParams, 0, missingColumns)
+		for i := minimumColumnsCountToReconstruct - missingColumns; i < minimumColumnsCountToReconstruct; i++ {
+			dataColumnParam := util.DataColumnParams{ColumnIndex: i}
+			dataColumnParams = append(dataColumnParams, dataColumnParam)
+		}
+
+		_, verifiedSidecars := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{root: dataColumnParams})
+
+		time.AfterFunc(10*time.Millisecond, func() {
+			err := service.dataColumnStorage.Save(verifiedSidecars)
+			require.NoError(t, err)
+		})
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NoError(t, err)
+	})
+
+	t.Run("Fulu - some columns are definitively missing", func(t *testing.T) {
+		params := testIsAvailableParams{
+			options:                 []Option{WithCustodyInfo(&peerdas.CustodyInfo{})},
+			blobKzgCommitmentsCount: 3,
+		}
+
+		ctx, cancel, service, root, signed := testIsAvailableSetup(t, params)
+
+		time.AfterFunc(10*time.Millisecond, func() {
+			cancel()
+		})
+
+		err := service.isDataAvailable(ctx, root, signed)
+		require.NotNil(t, err)
+	})
+}
+
 func setupLightClientTestRequirements(ctx context.Context, t *testing.T, s *Service, v int, options ...util.LightClientOption) (*util.TestLightClient, *postBlockProcessConfig) {
 	var l *util.TestLightClient
 	switch v {
@@ -3310,7 +3559,7 @@ func TestProcessLightClientOptimisticUpdate(t *testing.T) {
 	params.OverrideBeaconConfig(beaconCfg)
 
 	s, tr := minimalTestService(t)
-	s.cfg.P2p = &mockp2p.FakeP2P{}
+	s.cfg.P2P = &mockp2p.FakeP2P{}
 	ctx := tr.ctx
 
 	testCases := []struct {
@@ -3446,7 +3695,7 @@ func TestProcessLightClientFinalityUpdate(t *testing.T) {
 	params.OverrideBeaconConfig(beaconCfg)
 
 	s, tr := minimalTestService(t)
-	s.cfg.P2p = &mockp2p.FakeP2P{}
+	s.cfg.P2P = &mockp2p.FakeP2P{}
 	ctx := tr.ctx
 
 	testCases := []struct {

beacon-chain/blockchain/receive_block.go

@@ -16,6 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/slasher/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/config/features"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -52,6 +53,13 @@ type BlobReceiver interface {
 	ReceiveBlob(context.Context, blocks.VerifiedROBlob) error
 }
 
+// DataColumnReceiver interface defines the methods of chain service for receiving new
+// data columns
+type DataColumnReceiver interface {
+	ReceiveDataColumn(blocks.VerifiedRODataColumn) error
+	ReceiveDataColumns([]blocks.VerifiedRODataColumn) error
+}
+
 // SlashingReceiver interface defines the methods of chain service for receiving validated slashing over the wire.
 type SlashingReceiver interface {
 	ReceiveAttesterSlashing(ctx context.Context, slashing ethpb.AttSlashing)
@@ -74,6 +82,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 		log.WithField("blockRoot", fmt.Sprintf("%#x", blockRoot)).Debug("Ignoring already synced block")
 		return nil
 	}
+
 	receivedTime := time.Now()
 	s.blockBeingSynced.set(blockRoot)
 	defer s.blockBeingSynced.unset(blockRoot)
@@ -82,6 +91,7 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
+
 	preState, err := s.getBlockPreState(ctx, blockCopy.Block())
 	if err != nil {
 		return errors.Wrap(err, "could not get block's prestate")
@@ -97,10 +107,12 @@ func (s *Service) ReceiveBlock(ctx context.Context, block interfaces.ReadOnlySig
 	if err != nil {
 		return err
 	}
+
 	daWaitedTime, err := s.handleDA(ctx, blockCopy, blockRoot, avs)
 	if err != nil {
 		return err
 	}
+
 	// Defragment the state before continuing block processing.
 	s.defragmentState(postState)
 
@@ -227,26 +239,34 @@ func (s *Service) validateExecutionAndConsensus(
 func (s *Service) handleDA(
 	ctx context.Context,
 	block interfaces.SignedBeaconBlock,
-	blockRoot [32]byte,
+	blockRoot [fieldparams.RootLength]byte,
 	avs das.AvailabilityStore,
-) (time.Duration, error) {
-	daStartTime := time.Now()
-	if avs != nil {
-		rob, err := blocks.NewROBlockWithRoot(block, blockRoot)
-		if err != nil {
-			return 0, err
+) (elapsed time.Duration, err error) {
+	defer func(start time.Time) {
+		elapsed = time.Since(start)
+
+		if err == nil {
+			dataAvailWaitedTime.Observe(float64(elapsed.Milliseconds()))
 		}
-		if err := avs.IsDataAvailable(ctx, s.CurrentSlot(), rob); err != nil {
-			return 0, errors.Wrap(err, "could not validate blob data availability (AvailabilityStore.IsDataAvailable)")
-		}
-	} else {
-		if err := s.isDataAvailable(ctx, blockRoot, block); err != nil {
-			return 0, errors.Wrap(err, "could not validate blob data availability")
+	}(time.Now())
+
+	if avs == nil {
+		if err = s.isDataAvailable(ctx, blockRoot, block); err != nil {
+			return
 		}
+
+		return
 	}
-	daWaitedTime := time.Since(daStartTime)
-	dataAvailWaitedTime.Observe(float64(daWaitedTime.Milliseconds()))
-	return daWaitedTime, nil
+
+	var rob blocks.ROBlock
+	rob, err = blocks.NewROBlockWithRoot(block, blockRoot)
+	if err != nil {
+		return
+	}
+
+	err = avs.IsDataAvailable(ctx, s.CurrentSlot(), rob)
+
+	return
 }
 
 func (s *Service) reportPostBlockProcessing(

beacon-chain/blockchain/receive_block_test.go

@@ -180,6 +180,19 @@ func TestService_ReceiveBlock(t *testing.T) {
 	}
 	wg.Wait()
 }
+func TestHandleDA(t *testing.T) {
+	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{
+		Block: &ethpb.BeaconBlock{
+			Body: &ethpb.BeaconBlockBody{},
+		},
+	})
+	require.NoError(t, err)
+
+	s, _ := minimalTestService(t)
+	elapsed, err := s.handleDA(context.Background(), signedBeaconBlock, [fieldparams.RootLength]byte{}, nil)
+	require.NoError(t, err)
+	require.Equal(t, true, elapsed > 0, "Elapsed time should be greater than 0")
+}
 
 func TestService_ReceiveBlockUpdateHead(t *testing.T) {
 	s, tr := minimalTestService(t,

beacon-chain/blockchain/receive_data_column.go

@@ -0,0 +1,25 @@
+package blockchain
+
+import (
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/pkg/errors"
+)
+
+// ReceiveDataColumns receives a batch of data columns.
+func (s *Service) ReceiveDataColumns(dataColumnSidecars []blocks.VerifiedRODataColumn) error {
+	if err := s.dataColumnStorage.Save(dataColumnSidecars); err != nil {
+		return errors.Wrap(err, "save data column sidecars")
+	}
+
+	return nil
+}
+
+// ReceiveDataColumn receives a single data column.
+// (It is only a wrapper around ReceiveDataColumns.)
+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 nil
+}

beacon-chain/blockchain/service.go

@@ -16,6 +16,7 @@ import (
 	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"
@@ -64,6 +65,7 @@ type Service struct {
 	blobNotifiers        *blobNotifierMap
 	blockBeingSynced     *currentlySyncingBlock
 	blobStorage          *filesystem.BlobStorage
+	dataColumnStorage    *filesystem.DataColumnStorage
 	slasherEnabled       bool
 	lcStore              *lightClient.Store
 }
@@ -81,7 +83,7 @@ type config struct {
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
 	BLSToExecPool           blstoexec.PoolManager
-	P2p                     p2p.Broadcaster
+	P2P                     p2p.Accessor
 	MaxRoutines             int
 	StateNotifier           statefeed.Notifier
 	ForkChoiceStore         f.ForkChoicer
@@ -93,6 +95,7 @@ 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

beacon-chain/blockchain/service_test.go

@@ -97,7 +97,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		WithAttestationPool(attestations.NewPool()),
 		WithSlashingPool(slashings.NewPool()),
 		WithExitPool(voluntaryexits.NewPool()),
-		WithP2PBroadcaster(&mockBroadcaster{}),
+		WithP2PBroadcaster(&mockAccessor{}),
 		WithStateNotifier(&mockBeaconNode{}),
 		WithForkChoiceStore(fc),
 		WithAttestationService(attService),

beacon-chain/blockchain/setup_test.go

@@ -20,8 +20,10 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/attestations"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/operations/blstoexec"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p"
+	p2pTesting "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -47,6 +49,11 @@ type mockBroadcaster struct {
 	broadcastCalled bool
 }
 
+type mockAccessor struct {
+	mockBroadcaster
+	p2pTesting.MockPeerManager
+}
+
 func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	mb.broadcastCalled = true
 	return nil
@@ -77,6 +84,11 @@ func (mb *mockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
+func (mb *mockBroadcaster) BroadcastDataColumn(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar, _ ...chan<- bool) error {
+	mb.broadcastCalled = true
+	return nil
+}
+
 func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.SignedBLSToExecutionChange) {
 }
 
@@ -132,8 +144,10 @@ func minimalTestService(t *testing.T, opts ...Option) (*Service, *testServiceReq
 		WithDepositCache(dc),
 		WithTrackedValidatorsCache(cache.NewTrackedValidatorsCache()),
 		WithBlobStorage(filesystem.NewEphemeralBlobStorage(t)),
+		WithDataColumnStorage(filesystem.NewEphemeralDataColumnStorage(t)),
 		WithSyncChecker(mock.MockChecker{}),
 		WithExecutionEngineCaller(&mockExecution.EngineClient{}),
+		WithP2PBroadcaster(&mockAccessor{}),
 		WithLightClientStore(&lightclient.Store{}),
 	}
 	// append the variadic opts so they override the defaults by being processed afterwards

beacon-chain/blockchain/testing/mock.go

@@ -75,6 +75,7 @@ type ChainService struct {
 	BlockSlot                   primitives.Slot
 	SyncingRoot                 [32]byte
 	Blobs                       []blocks.VerifiedROBlob
+	DataColumns                 []blocks.VerifiedRODataColumn
 	TargetRoot                  [32]byte
 	MockHeadSlot                *primitives.Slot
 }
@@ -715,6 +716,17 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 	return nil
 }
 
+// ReceiveDataColumn implements the same method in chain service
+func (c *ChainService) ReceiveDataColumn(dc blocks.VerifiedRODataColumn) error {
+	c.DataColumns = append(c.DataColumns, dc)
+	return nil
+}
+
+// ReceiveDataColumns implements the same method in chain service
+func (*ChainService) ReceiveDataColumns(_ []blocks.VerifiedRODataColumn) error {
+	return nil
+}
+
 // TargetRootForEpoch mocks the same method in the chain service
 func (c *ChainService) TargetRootForEpoch(_ [32]byte, _ primitives.Epoch) ([32]byte, error) {
 	return c.TargetRoot, nil

beacon-chain/cache/committee.go

@@ -14,6 +14,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/container/slice"
 	mathutil "github.com/OffchainLabs/prysm/v6/math"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
@@ -104,11 +105,16 @@ func (c *CommitteeCache) CompressCommitteeCache() {
 // Committee fetches the shuffled indices by slot and committee index. Every list of indices
 // represent one committee. Returns true if the list exists with slot and committee index. Otherwise returns false, nil.
 func (c *CommitteeCache) Committee(ctx context.Context, slot primitives.Slot, seed [32]byte, index primitives.CommitteeIndex) ([]primitives.ValidatorIndex, error) {
+	ctx, span := trace.StartSpan(ctx, "committeeCache.Committee")
+	defer span.End()
+	span.SetAttributes(trace.Int64Attribute("slot", int64(slot)), trace.Int64Attribute("index", int64(index))) // lint:ignore uintcast -- OK for tracing.
+
 	if err := c.checkInProgress(ctx, seed); err != nil {
 		return nil, err
 	}
 
 	obj, exists := c.CommitteeCache.Get(key(seed))
+	span.SetAttributes(trace.BoolAttribute("cache_hit", exists))
 	if exists {
 		CommitteeCacheHit.Inc()
 	} else {
@@ -157,11 +163,14 @@ func (c *CommitteeCache) AddCommitteeShuffledList(ctx context.Context, committee
 
 // ActiveIndices returns the active indices of a given seed stored in cache.
 func (c *CommitteeCache) ActiveIndices(ctx context.Context, seed [32]byte) ([]primitives.ValidatorIndex, error) {
+	ctx, span := trace.StartSpan(ctx, "committeeCache.ActiveIndices")
+	defer span.End()
+
 	if err := c.checkInProgress(ctx, seed); err != nil {
 		return nil, err
 	}
 	obj, exists := c.CommitteeCache.Get(key(seed))
-
+	span.SetAttributes(trace.BoolAttribute("cache_hit", exists))
 	if exists {
 		CommitteeCacheHit.Inc()
 	} else {

beacon-chain/core/blocks/payload.go

@@ -12,7 +12,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"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/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
@@ -240,16 +239,3 @@ func verifyBlobCommitmentCount(slot primitives.Slot, body interfaces.ReadOnlyBea
 	}
 	return nil
 }
-
-// GetBlockPayloadHash returns the hash of the execution payload of the block
-func GetBlockPayloadHash(blk interfaces.ReadOnlyBeaconBlock) ([32]byte, error) {
-	var payloadHash [32]byte
-	if IsPreBellatrixVersion(blk.Version()) {
-		return payloadHash, nil
-	}
-	payload, err := blk.Body().Execution()
-	if err != nil {
-		return payloadHash, err
-	}
-	return bytesutil.ToBytes32(payload.BlockHash()), nil
-}

beacon-chain/core/helpers/attestation.go

@@ -187,9 +187,7 @@ func ValidateAttestationTime(attSlot primitives.Slot, genesisTime time.Time, clo
 // VerifyCheckpointEpoch is within current epoch and previous epoch
 // with respect to current time. Returns true if it's within, false if it's not.
 func VerifyCheckpointEpoch(c *ethpb.Checkpoint, genesis time.Time) bool {
-	now := uint64(prysmTime.Now().Unix())
-	genesisTime := uint64(genesis.Unix())
-	currentSlot := primitives.Slot((now - genesisTime) / params.BeaconConfig().SecondsPerSlot)
+	currentSlot := slots.CurrentSlot(uint64(genesis.Unix()))
 	currentEpoch := slots.ToEpoch(currentSlot)
 
 	var prevEpoch primitives.Epoch

beacon-chain/core/helpers/beacon_committee.go

@@ -119,6 +119,9 @@ func attestationCommittees(
 
 // BeaconCommittees returns the list of all beacon committees for a given state at a given slot.
 func BeaconCommittees(ctx context.Context, state state.ReadOnlyBeaconState, slot primitives.Slot) ([][]primitives.ValidatorIndex, error) {
+	ctx, span := trace.StartSpan(ctx, "helpers.BeaconCommittees")
+	defer span.End()
+
 	epoch := slots.ToEpoch(slot)
 	activeCount, err := ActiveValidatorCount(ctx, state, epoch)
 	if err != nil {
@@ -245,6 +248,9 @@ func BeaconCommittee(
 	slot primitives.Slot,
 	committeeIndex primitives.CommitteeIndex,
 ) ([]primitives.ValidatorIndex, error) {
+	ctx, span := trace.StartSpan(ctx, "helpers.BeaconCommittee")
+	defer span.End()
+
 	committee, err := committeeCache.Committee(ctx, slot, seed, committeeIndex)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not interface with committee cache")
@@ -439,6 +445,9 @@ func CommitteeIndices(committeeBits bitfield.Bitfield) []primitives.CommitteeInd
 // UpdateCommitteeCache gets called at the beginning of every epoch to cache the committee shuffled indices
 // list with committee index and epoch number. It caches the shuffled indices for the input epoch.
 func UpdateCommitteeCache(ctx context.Context, state state.ReadOnlyBeaconState, e primitives.Epoch) error {
+	ctx, span := trace.StartSpan(ctx, "committeeCache.UpdateCommitteeCache")
+	defer span.End()
+
 	seed, err := Seed(state, e, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {
 		return err

beacon-chain/core/helpers/validators.go

@@ -102,6 +102,9 @@ func checkValidatorSlashable(activationEpoch, withdrawableEpoch primitives.Epoch
 //	  """
 //	  return [ValidatorIndex(i) for i, v in enumerate(state.validators) if is_active_validator(v, epoch)]
 func ActiveValidatorIndices(ctx context.Context, s state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]primitives.ValidatorIndex, error) {
+	ctx, span := trace.StartSpan(ctx, "helpers.ActiveValidatorIndices")
+	defer span.End()
+
 	seed, err := Seed(s, epoch, params.BeaconConfig().DomainBeaconAttester)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get seed")

beacon-chain/core/peerdas/BUILD.bazel

@@ -8,8 +8,8 @@ go_library(
         "metrics.go",
         "p2p_interface.go",
         "reconstruction.go",
-        "util.go",
         "validator.go",
+        "verification.go",
     ],
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas",
     visibility = ["//visibility:public"],
@@ -47,6 +47,7 @@ go_test(
         "reconstruction_test.go",
         "utils_test.go",
         "validator_test.go",
+        "verification_test.go",
     ],
     deps = [
         ":go_default_library",
@@ -67,5 +68,6 @@ go_test(
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
+        "@org_golang_x_sync//errgroup:go_default_library",
     ],
 )

beacon-chain/core/peerdas/das_core.go

@@ -20,10 +20,12 @@ import (
 
 var (
 	// Custom errors
-	ErrCustodyGroupTooLarge           = errors.New("custody group too large")
-	ErrCustodyGroupCountTooLarge      = errors.New("custody group count too large")
-	ErrMismatchSize                   = errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
-	errWrongComputedCustodyGroupCount = errors.New("wrong computed custody group count, should never happen")
+	ErrCustodyGroupTooLarge               = errors.New("custody group too large")
+	ErrCustodyGroupCountTooLarge          = errors.New("custody group count too large")
+	ErrSizeMismatch                       = errors.New("mismatch in the number of blob KZG commitments and cellsAndProofs")
+	ErrNotEnoughDataColumnSidecars        = errors.New("not enough columns")
+	ErrDataColumnSidecarsNotSortedByIndex = errors.New("data column sidecars are not sorted by index")
+	errWrongComputedCustodyGroupCount     = errors.New("wrong computed custody group count, should never happen")
 
 	// maxUint256 is the maximum value of an uint256.
 	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
@@ -139,7 +141,7 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsA
 	}
 
 	if len(blobKzgCommitments) != len(cellsAndProofs) {
-		return nil, ErrMismatchSize
+		return nil, ErrSizeMismatch
 	}
 
 	signedBlockHeader, err := signedBlock.Header()
@@ -152,19 +154,72 @@ func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, cellsA
 		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
 	}
 
-	dataColumnSidecars, err := DataColumnsSidecarsFromItems(signedBlockHeader, blobKzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
+	dataColumnSidecars, err := dataColumnsSidecars(signedBlockHeader, blobKzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
 	if err != nil {
-		return nil, errors.Wrap(err, "data column sidecars from items")
+		return nil, errors.Wrap(err, "data column sidecars")
 	}
 
 	return dataColumnSidecars, nil
 }
 
-// DataColumnsSidecarsFromItems computes the data column sidecars from the signed block header, the blob KZG commiments,
+// ComputeCustodyGroupForColumn computes the custody group for a given column.
+// It is the reciprocal function of ComputeColumnsForCustodyGroup.
+func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
+	beaconConfig := params.BeaconConfig()
+	numberOfColumns := beaconConfig.NumberOfColumns
+	numberOfCustodyGroups := beaconConfig.NumberOfCustodyGroups
+
+	if columnIndex >= numberOfColumns {
+		return 0, ErrIndexTooLarge
+	}
+
+	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
+
+	custodyGroupCount := len(custodyGroups)
+
+	// Compute the columns for each custody group.
+	columns := make(map[uint64]bool, custodyGroupCount)
+	for _, group := range custodyGroups {
+		if group >= numberOfCustodyGroups {
+			return nil, ErrCustodyGroupTooLarge
+		}
+
+		groupColumns, err := ComputeColumnsForCustodyGroup(group)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute columns for custody group")
+		}
+
+		for _, column := range groupColumns {
+			columns[column] = true
+		}
+	}
+
+	return columns, nil
+}
+
+// dataColumnsSidecars computes the data column sidecars from the signed block header, the blob KZG commiments,
 // the KZG commitment includion proofs and cells and cell proofs.
 // The returned value contains pointers to function parameters.
 // (If the caller alterates input parameters afterwards, the returned value will be modified as well.)
-func DataColumnsSidecarsFromItems(
+func dataColumnsSidecars(
 	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
 	blobKzgCommitments [][]byte,
 	kzgCommitmentsInclusionProof [][]byte,
@@ -172,7 +227,7 @@ func DataColumnsSidecarsFromItems(
 ) ([]*ethpb.DataColumnSidecar, error) {
 	start := time.Now()
 	if len(blobKzgCommitments) != len(cellsAndProofs) {
-		return nil, ErrMismatchSize
+		return nil, ErrSizeMismatch
 	}
 
 	numberOfColumns := params.BeaconConfig().NumberOfColumns
@@ -219,184 +274,3 @@ func DataColumnsSidecarsFromItems(
 	dataColumnComputationTime.Observe(float64(time.Since(start).Milliseconds()))
 	return sidecars, nil
 }
-
-// ComputeCustodyGroupForColumn computes the custody group for a given column.
-// It is the reciprocal function of ComputeColumnsForCustodyGroup.
-func ComputeCustodyGroupForColumn(columnIndex uint64) (uint64, error) {
-	beaconConfig := params.BeaconConfig()
-	numberOfColumns := beaconConfig.NumberOfColumns
-	numberOfCustodyGroups := beaconConfig.NumberOfCustodyGroups
-
-	if columnIndex >= numberOfColumns {
-		return 0, ErrIndexTooLarge
-	}
-
-	return columnIndex % numberOfCustodyGroups, nil
-}
-
-// Blobs extract blobs from `dataColumnsSidecar`.
-// This can be seen as the reciprocal function of DataColumnSidecars.
-// `dataColumnsSidecar` needs to contain the datacolumns corresponding to the non-extended matrix,
-// else an error will be returned.
-// (`dataColumnsSidecar` can contain extra columns, but they will be ignored.)
-func Blobs(indices map[uint64]bool, dataColumnsSidecar []*ethpb.DataColumnSidecar) ([]*blocks.VerifiedROBlob, error) {
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	// Compute the number of needed columns, including the number of columns is odd case.
-	neededColumnCount := (numberOfColumns + 1) / 2
-
-	// Check if all needed columns are present.
-	sliceIndexFromColumnIndex := make(map[uint64]int, len(dataColumnsSidecar))
-	for i := range dataColumnsSidecar {
-		dataColumnSideCar := dataColumnsSidecar[i]
-		index := dataColumnSideCar.Index
-
-		if index < neededColumnCount {
-			sliceIndexFromColumnIndex[index] = i
-		}
-	}
-
-	actualColumnCount := uint64(len(sliceIndexFromColumnIndex))
-
-	// Get missing columns.
-	if actualColumnCount < neededColumnCount {
-		var missingColumnsSlice []uint64
-
-		for i := range neededColumnCount {
-			if _, ok := sliceIndexFromColumnIndex[i]; !ok {
-				missingColumnsSlice = append(missingColumnsSlice, i)
-			}
-		}
-
-		slices.Sort[[]uint64](missingColumnsSlice)
-		return nil, errors.Errorf("some columns are missing: %v", missingColumnsSlice)
-	}
-
-	// It is safe to retrieve the first column since we already checked that `dataColumnsSidecar` is not empty.
-	firstDataColumnSidecar := dataColumnsSidecar[0]
-
-	blobCount := uint64(len(firstDataColumnSidecar.Column))
-
-	// Check all colums have te same length.
-	for i := range dataColumnsSidecar {
-		if uint64(len(dataColumnsSidecar[i].Column)) != blobCount {
-			return nil, errors.Errorf("mismatch in the length of the data columns, expected %d, got %d", blobCount, len(dataColumnsSidecar[i].Column))
-		}
-	}
-
-	// Reconstruct verified RO blobs from columns.
-	verifiedROBlobs := make([]*blocks.VerifiedROBlob, 0, blobCount)
-
-	// Populate and filter indices.
-	indicesSlice := populateAndFilterIndices(indices, blobCount)
-
-	for _, blobIndex := range indicesSlice {
-		var blob kzg.Blob
-
-		// Compute the content of the blob.
-		for columnIndex := range neededColumnCount {
-			sliceIndex, ok := sliceIndexFromColumnIndex[columnIndex]
-			if !ok {
-				return nil, errors.Errorf("missing column %d, this should never happen", columnIndex)
-			}
-
-			dataColumnSideCar := dataColumnsSidecar[sliceIndex]
-			cell := dataColumnSideCar.Column[blobIndex]
-
-			for i := range cell {
-				blob[columnIndex*kzg.BytesPerCell+uint64(i)] = cell[i]
-			}
-		}
-
-		// Retrieve the blob KZG commitment.
-		blobKZGCommitment := kzg.Commitment(firstDataColumnSidecar.KzgCommitments[blobIndex])
-
-		// Compute the blob KZG proof.
-		blobKzgProof, err := kzg.ComputeBlobKZGProof(&blob, blobKZGCommitment)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute blob KZG proof")
-		}
-
-		blobSidecar := &ethpb.BlobSidecar{
-			Index:                    blobIndex,
-			Blob:                     blob[:],
-			KzgCommitment:            blobKZGCommitment[:],
-			KzgProof:                 blobKzgProof[:],
-			SignedBlockHeader:        firstDataColumnSidecar.SignedBlockHeader,
-			CommitmentInclusionProof: firstDataColumnSidecar.KzgCommitmentsInclusionProof,
-		}
-
-		roBlob, err := blocks.NewROBlob(blobSidecar)
-		if err != nil {
-			return nil, errors.Wrap(err, "new RO blob")
-		}
-
-		verifiedROBlob := blocks.NewVerifiedROBlob(roBlob)
-		verifiedROBlobs = append(verifiedROBlobs, &verifiedROBlob)
-	}
-
-	return verifiedROBlobs, nil
-}
-
-// 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
-
-	custodyGroupCount := len(custodyGroups)
-
-	// Compute the columns for each custody group.
-	columns := make(map[uint64]bool, custodyGroupCount)
-	for _, group := range custodyGroups {
-		if group >= numberOfCustodyGroups {
-			return nil, ErrCustodyGroupTooLarge
-		}
-
-		groupColumns, err := ComputeColumnsForCustodyGroup(group)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute columns for custody group")
-		}
-
-		for _, column := range groupColumns {
-			columns[column] = true
-		}
-	}
-
-	return columns, nil
-}
-
-// populateAndFilterIndices returns a sorted slices of indices, setting all indices if none are provided,
-// and filtering out indices higher than the blob count.
-func populateAndFilterIndices(indices map[uint64]bool, blobCount uint64) []uint64 {
-	// If no indices are provided, provide all blobs.
-	if len(indices) == 0 {
-		for i := range blobCount {
-			indices[i] = true
-		}
-	}
-
-	// Filter blobs index higher than the blob count.
-	indicesSlice := make([]uint64, 0, len(indices))
-	for i := range indices {
-		if i < blobCount {
-			indicesSlice = append(indicesSlice, i)
-		}
-	}
-
-	// Sort the indices.
-	slices.Sort[[]uint64](indicesSlice)
-
-	return indicesSlice
-}

beacon-chain/core/peerdas/das_core_test.go

@@ -11,18 +11,21 @@ import (
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
 	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/pkg/errors"
 )
 
 func TestCustodyGroups(t *testing.T) {
+	// --------------------------------------------
 	// The happy path is unit tested in spec tests.
+	// --------------------------------------------
 	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
 	_, err := peerdas.CustodyGroups(enode.ID{}, numberOfCustodyGroup+1)
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupCountTooLarge)
 }
 
 func TestComputeColumnsForCustodyGroup(t *testing.T) {
+	// --------------------------------------------
 	// The happy path is unit tested in spec tests.
+	// --------------------------------------------
 	numberOfCustodyGroup := params.BeaconConfig().NumberOfCustodyGroups
 	_, err := peerdas.ComputeColumnsForCustodyGroup(numberOfCustodyGroup)
 	require.ErrorIs(t, err, peerdas.ErrCustodyGroupTooLarge)
@@ -62,14 +65,10 @@ func TestDataColumnSidecars(t *testing.T) {
 		cellsAndProofs := make([]kzg.CellsAndProofs, 1)
 
 		_, err = peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-		require.ErrorIs(t, err, peerdas.ErrMismatchSize)
+		require.ErrorIs(t, err, peerdas.ErrSizeMismatch)
 	})
 }
 
-// --------------------------------------------------------------------------------------------------------------------------------------
-// DataColumnsSidecarsFromItems is tested as part of the DataColumnSidecars tests, in the TestDataColumnsSidecarsBlobsRoundtrip function.
-// --------------------------------------------------------------------------------------------------------------------------------------
-
 func TestComputeCustodyGroupForColumn(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	config := params.BeaconConfig()
@@ -105,136 +104,6 @@ func TestComputeCustodyGroupForColumn(t *testing.T) {
 	})
 }
 
-func TestBlobs(t *testing.T) {
-	blobsIndice := map[uint64]bool{}
-
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	almostAllColumns := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns/2)
-	for i := uint64(2); i < numberOfColumns/2+2; i++ {
-		almostAllColumns = append(almostAllColumns, &ethpb.DataColumnSidecar{
-			Index: i,
-		})
-	}
-
-	testCases := []struct {
-		name     string
-		input    []*ethpb.DataColumnSidecar
-		expected []*blocks.VerifiedROBlob
-		err      error
-	}{
-		{
-			name:     "empty input",
-			input:    []*ethpb.DataColumnSidecar{},
-			expected: nil,
-			err:      errors.New("some columns are missing: [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63]"),
-		},
-		{
-			name:     "missing columns",
-			input:    almostAllColumns,
-			expected: nil,
-			err:      errors.New("some columns are missing: [0 1]"),
-		},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			actual, err := peerdas.Blobs(blobsIndice, tc.input)
-			if tc.err != nil {
-				require.Equal(t, tc.err.Error(), err.Error())
-			} else {
-				require.NoError(t, err)
-			}
-			require.DeepSSZEqual(t, tc.expected, actual)
-		})
-	}
-}
-
-func TestDataColumnsSidecarsBlobsRoundtrip(t *testing.T) {
-	const blobCount = 5
-	blobsIndex := map[uint64]bool{}
-
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	// Create a protobuf signed beacon block.
-	signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-
-	// Generate random blobs and their corresponding commitments and proofs.
-	blobs := make([]kzg.Blob, 0, blobCount)
-	blobKzgCommitments := make([]*kzg.Commitment, 0, blobCount)
-	blobKzgProofs := make([]*kzg.Proof, 0, blobCount)
-
-	for blobIndex := range blobCount {
-		// Create a random blob.
-		blob := getRandBlob(int64(blobIndex))
-		blobs = append(blobs, blob)
-
-		// Generate a blobKZGCommitment for the blob.
-		blobKZGCommitment, proof, err := generateCommitmentAndProof(&blob)
-		require.NoError(t, err)
-
-		blobKzgCommitments = append(blobKzgCommitments, blobKZGCommitment)
-		blobKzgProofs = append(blobKzgProofs, proof)
-	}
-
-	// Set the commitments into the block.
-	blobZkgCommitmentsBytes := make([][]byte, 0, blobCount)
-	for _, blobKZGCommitment := range blobKzgCommitments {
-		blobZkgCommitmentsBytes = append(blobZkgCommitmentsBytes, blobKZGCommitment[:])
-	}
-
-	signedBeaconBlockPb.Block.Body.BlobKzgCommitments = blobZkgCommitmentsBytes
-
-	// Generate verified RO blobs.
-	verifiedROBlobs := make([]*blocks.VerifiedROBlob, 0, blobCount)
-
-	// Create a signed beacon block from the protobuf.
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-	require.NoError(t, err)
-
-	commitmentInclusionProof, err := blocks.MerkleProofKZGCommitments(signedBeaconBlock.Block().Body())
-	require.NoError(t, err)
-
-	for blobIndex := range blobCount {
-		blob := blobs[blobIndex]
-		blobKZGCommitment := blobKzgCommitments[blobIndex]
-		blobKzgProof := blobKzgProofs[blobIndex]
-
-		// Get the signed beacon block header.
-		signedBeaconBlockHeader, err := signedBeaconBlock.Header()
-		require.NoError(t, err)
-
-		blobSidecar := &ethpb.BlobSidecar{
-			Index:                    uint64(blobIndex),
-			Blob:                     blob[:],
-			KzgCommitment:            blobKZGCommitment[:],
-			KzgProof:                 blobKzgProof[:],
-			SignedBlockHeader:        signedBeaconBlockHeader,
-			CommitmentInclusionProof: commitmentInclusionProof,
-		}
-
-		roBlob, err := blocks.NewROBlob(blobSidecar)
-		require.NoError(t, err)
-
-		verifiedROBlob := blocks.NewVerifiedROBlob(roBlob)
-		verifiedROBlobs = append(verifiedROBlobs, &verifiedROBlob)
-	}
-
-	// Compute data columns sidecars from the signed beacon block and from the blobs.
-	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
-	dataColumnsSidecar, err := peerdas.DataColumnSidecars(signedBeaconBlock, cellsAndProofs)
-	require.NoError(t, err)
-
-	// Compute the blobs from the data columns sidecar.
-	roundtripBlobs, err := peerdas.Blobs(blobsIndex, dataColumnsSidecar)
-	require.NoError(t, err)
-
-	// Check that the blobs are the same.
-	require.DeepSSZEqual(t, verifiedROBlobs, roundtripBlobs)
-}
-
 func TestCustodyGroupSamplingSize(t *testing.T) {
 	testCases := []struct {
 		name                         string

beacon-chain/core/peerdas/info.go

@@ -117,7 +117,7 @@ func (custodyInfo *CustodyInfo) ActualGroupCount() uint64 {
 // 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().SubscribeToAllSubnets {
+	if flags.Get().SubscribeAllDataSubnets {
 		return params.BeaconConfig().NumberOfCustodyGroups
 	}
 
@@ -144,7 +144,7 @@ func (tcgc *targetCustodyGroupCount) SetValidatorsCustodyRequirement(value uint6
 // 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().SubscribeToAllSubnets {
+	if flags.Get().SubscribeAllDataSubnets {
 		return params.BeaconConfig().NumberOfCustodyGroups
 	}
 

beacon-chain/core/peerdas/info_test.go

@@ -30,25 +30,25 @@ func TestInfo(t *testing.T) {
 func TestTargetCustodyGroupCount(t *testing.T) {
 	testCases := []struct {
 		name                         string
-		subscribeToAllSubnets        bool
+		subscribeToAllColumns        bool
 		validatorsCustodyRequirement uint64
 		expected                     uint64
 	}{
 		{
-			name:                         "subscribed to all subnets",
-			subscribeToAllSubnets:        true,
+			name:                         "subscribed to all data subnets",
+			subscribeToAllColumns:        true,
 			validatorsCustodyRequirement: 100,
 			expected:                     128,
 		},
 		{
 			name:                         "no validators attached",
-			subscribeToAllSubnets:        false,
+			subscribeToAllColumns:        false,
 			validatorsCustodyRequirement: 0,
 			expected:                     4,
 		},
 		{
 			name:                         "some validators attached",
-			subscribeToAllSubnets:        false,
+			subscribeToAllColumns:        false,
 			validatorsCustodyRequirement: 100,
 			expected:                     100,
 		},
@@ -57,10 +57,10 @@ func TestTargetCustodyGroupCount(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			// Subscribe to all subnets if needed.
-			if tc.subscribeToAllSubnets {
+			if tc.subscribeToAllColumns {
 				resetFlags := flags.Get()
 				gFlags := new(flags.GlobalFlags)
-				gFlags.SubscribeToAllSubnets = true
+				gFlags.SubscribeAllDataSubnets = true
 				flags.Init(gFlags)
 				defer flags.Init(resetFlags)
 			}
@@ -82,25 +82,25 @@ func TestTargetCustodyGroupCount(t *testing.T) {
 func TestToAdvertiseCustodyGroupCount(t *testing.T) {
 	testCases := []struct {
 		name                         string
-		subscribeToAllSubnets        bool
+		subscribeToAllColumns        bool
 		toAdvertiseCustodyGroupCount uint64
 		expected                     uint64
 	}{
 		{
 			name:                         "subscribed to all subnets",
-			subscribeToAllSubnets:        true,
+			subscribeToAllColumns:        true,
 			toAdvertiseCustodyGroupCount: 100,
 			expected:                     128,
 		},
 		{
 			name:                         "higher than custody requirement",
-			subscribeToAllSubnets:        false,
+			subscribeToAllColumns:        false,
 			toAdvertiseCustodyGroupCount: 100,
 			expected:                     100,
 		},
 		{
 			name:                         "lower than custody requirement",
-			subscribeToAllSubnets:        false,
+			subscribeToAllColumns:        false,
 			toAdvertiseCustodyGroupCount: 1,
 			expected:                     4,
 		},
@@ -109,10 +109,10 @@ func TestToAdvertiseCustodyGroupCount(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			// Subscribe to all subnets if needed.
-			if tc.subscribeToAllSubnets {
+			if tc.subscribeToAllColumns {
 				resetFlags := flags.Get()
 				gFlags := new(flags.GlobalFlags)
-				gFlags.SubscribeToAllSubnets = true
+				gFlags.SubscribeAllDataSubnets = true
 				flags.Init(gFlags)
 				defer flags.Init(resetFlags)
 			}

beacon-chain/core/peerdas/metrics.go

@@ -9,6 +9,6 @@ var dataColumnComputationTime = promauto.NewHistogram(
 	prometheus.HistogramOpts{
 		Name:    "beacon_data_column_sidecar_computation_milliseconds",
 		Help:    "Captures the time taken to compute data column sidecars from blobs.",
-		Buckets: []float64{100, 250, 500, 750, 1000, 1500, 2000, 4000, 8000, 12000, 16000},
+		Buckets: []float64{25, 50, 100, 250, 500, 750, 1000},
 	},
 )

beacon-chain/core/peerdas/p2p_interface_test.go

@@ -2,6 +2,7 @@ package peerdas_test
 
 import (
 	"crypto/rand"
+	"fmt"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
@@ -52,51 +53,15 @@ func TestVerifyDataColumnSidecar(t *testing.T) {
 }
 
 func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
+	const (
+		blobCount = 6
+		seed      = 0
+	)
 	err := kzg.Start()
 	require.NoError(t, err)
 
-	generateSidecars := func(t *testing.T) []*ethpb.DataColumnSidecar {
-		const blobCount = int64(6)
-
-		dbBlock := util.NewBeaconBlockDeneb()
-
-		commitments := make([][]byte, 0, blobCount)
-		blobs := make([]kzg.Blob, 0, blobCount)
-
-		for i := range blobCount {
-			blob := getRandBlob(i)
-			commitment, _, err := generateCommitmentAndProof(&blob)
-			require.NoError(t, err)
-
-			commitments = append(commitments, commitment[:])
-			blobs = append(blobs, blob)
-		}
-
-		dbBlock.Block.Body.BlobKzgCommitments = commitments
-		sBlock, err := blocks.NewSignedBeaconBlock(dbBlock)
-		require.NoError(t, err)
-
-		cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
-		sidecars, err := peerdas.DataColumnSidecars(sBlock, cellsAndProofs)
-		require.NoError(t, err)
-
-		return sidecars
-	}
-
-	generateRODataColumnSidecars := func(t *testing.T, sidecars []*ethpb.DataColumnSidecar) []blocks.RODataColumn {
-		roDataColumnSidecars := make([]blocks.RODataColumn, 0, len(sidecars))
-		for _, sidecar := range sidecars {
-			roCol, err := blocks.NewRODataColumn(sidecar)
-			require.NoError(t, err)
-
-			roDataColumnSidecars = append(roDataColumnSidecars, roCol)
-		}
-
-		return roDataColumnSidecars
-	}
-
 	t.Run("invalid proof", func(t *testing.T) {
-		sidecars := generateSidecars(t)
+		sidecars := generateRandomSidecars(t, seed, blobCount)
 		sidecars[0].Column[0][0]++ // It is OK to overflow
 		roDataColumnSidecars := generateRODataColumnSidecars(t, sidecars)
 
@@ -105,7 +70,7 @@ func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
 	})
 
 	t.Run("nominal", func(t *testing.T) {
-		sidecars := generateSidecars(t)
+		sidecars := generateRandomSidecars(t, seed, blobCount)
 		roDataColumnSidecars := generateRODataColumnSidecars(t, sidecars)
 
 		err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
@@ -281,6 +246,96 @@ func TestCustodyGroupCountFromRecord(t *testing.T) {
 	})
 }
 
+func BenchmarkVerifyDataColumnSidecarKZGProofs_SameCommitments_NoBatch(b *testing.B) {
+	const blobCount = 12
+	err := kzg.Start()
+	require.NoError(b, err)
+
+	b.StopTimer()
+	b.ResetTimer()
+	for i := range int64(b.N) {
+		// Generate new random sidecars to ensure the KZG backend does not cache anything.
+		sidecars := generateRandomSidecars(b, i, blobCount)
+		roDataColumnSidecars := generateRODataColumnSidecars(b, sidecars)
+
+		for _, sidecar := range roDataColumnSidecars {
+			sidecars := []blocks.RODataColumn{sidecar}
+			b.StartTimer()
+			err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
+			b.StopTimer()
+			require.NoError(b, err)
+		}
+	}
+}
+
+func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch(b *testing.B) {
+	const blobCount = 12
+	numberOfColumns := int64(params.BeaconConfig().NumberOfColumns)
+	err := kzg.Start()
+	require.NoError(b, err)
+
+	columnsCounts := []int64{1, 2, 4, 8, 16, 32, 64, 128}
+
+	for i, columnsCount := range columnsCounts {
+		b.Run(fmt.Sprintf("columnsCount_%d", columnsCount), func(b *testing.B) {
+			b.StopTimer()
+			b.ResetTimer()
+
+			for j := range int64(b.N) {
+				allSidecars := make([]*ethpb.DataColumnSidecar, 0, numberOfColumns)
+				for k := int64(0); k < numberOfColumns; k += columnsCount {
+					// Use different seeds to generate different blobs/commitments
+					seed := int64(b.N*i) + numberOfColumns*j + blobCount*k
+					sidecars := generateRandomSidecars(b, seed, blobCount)
+
+					// Pick sidecars.
+					allSidecars = append(allSidecars, sidecars[k:k+columnsCount]...)
+				}
+
+				roDataColumnSidecars := generateRODataColumnSidecars(b, allSidecars)
+
+				b.StartTimer()
+				err := peerdas.VerifyDataColumnsSidecarKZGProofs(roDataColumnSidecars)
+				b.StopTimer()
+				require.NoError(b, err)
+			}
+		})
+	}
+}
+
+func BenchmarkVerifyDataColumnSidecarKZGProofs_DiffCommitments_Batch4(b *testing.B) {
+	const (
+		blobCount = 12
+
+		// columnsCount*batchCount = 128
+		columnsCount = 4
+		batchCount   = 32
+	)
+
+	err := kzg.Start()
+	require.NoError(b, err)
+
+	b.StopTimer()
+	b.ResetTimer()
+
+	for i := range int64(b.N) {
+		allSidecars := make([][]blocks.RODataColumn, 0, batchCount)
+		for j := range int64(batchCount) {
+			// Use different seeds to generate different blobs/commitments
+			sidecars := generateRandomSidecars(b, int64(batchCount)*i+j*blobCount, blobCount)
+			roDataColumnSidecars := generateRODataColumnSidecars(b, sidecars[:columnsCount])
+			allSidecars = append(allSidecars, roDataColumnSidecars)
+		}
+
+		for _, sidecars := range allSidecars {
+			b.StartTimer()
+			err := peerdas.VerifyDataColumnsSidecarKZGProofs(sidecars)
+			b.StopTimer()
+			require.NoError(b, err)
+		}
+	}
+}
+
 func createTestSidecar(t *testing.T, index uint64, column, kzgCommitments, kzgProofs [][]byte) blocks.RODataColumn {
 	pbSignedBeaconBlock := util.NewBeaconBlockDeneb()
 	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(pbSignedBeaconBlock)
@@ -302,3 +357,42 @@ func createTestSidecar(t *testing.T, index uint64, column, kzgCommitments, kzgPr
 
 	return roSidecar
 }
+
+func generateRandomSidecars(t testing.TB, seed, blobCount int64) []*ethpb.DataColumnSidecar {
+	dbBlock := util.NewBeaconBlockDeneb()
+
+	commitments := make([][]byte, 0, blobCount)
+	blobs := make([]kzg.Blob, 0, blobCount)
+
+	for i := range blobCount {
+		subSeed := seed + i
+		blob := getRandBlob(subSeed)
+		commitment, err := generateCommitment(&blob)
+		require.NoError(t, err)
+
+		commitments = append(commitments, commitment[:])
+		blobs = append(blobs, blob)
+	}
+
+	dbBlock.Block.Body.BlobKzgCommitments = commitments
+	sBlock, err := blocks.NewSignedBeaconBlock(dbBlock)
+	require.NoError(t, err)
+
+	cellsAndProofs := util.GenerateCellsAndProofs(t, blobs)
+	sidecars, err := peerdas.DataColumnSidecars(sBlock, cellsAndProofs)
+	require.NoError(t, err)
+
+	return sidecars
+}
+
+func generateRODataColumnSidecars(t testing.TB, sidecars []*ethpb.DataColumnSidecar) []blocks.RODataColumn {
+	roDataColumnSidecars := make([]blocks.RODataColumn, 0, len(sidecars))
+	for _, sidecar := range sidecars {
+		roCol, err := blocks.NewRODataColumn(sidecar)
+		require.NoError(t, err)
+
+		roDataColumnSidecars = append(roDataColumnSidecars, roCol)
+	}
+
+	return roDataColumnSidecars
+}

beacon-chain/core/peerdas/reconstruction.go

@@ -2,75 +2,321 @@ package peerdas
 
 import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 	"golang.org/x/sync/errgroup"
 )
 
-// CanSelfReconstruct returns true if the node can self-reconstruct all the data columns from its custody group count.
-func CanSelfReconstruct(custodyGroupCount uint64) bool {
-	total := params.BeaconConfig().NumberOfCustodyGroups
-	// If total is odd, then we need total / 2 + 1 columns to reconstruct.
-	// If total is even, then we need total / 2 columns to reconstruct.
-	return custodyGroupCount >= (total+1)/2
+var (
+	ErrColumnLengthsDiffer      = errors.New("columns do not have the same length")
+	ErrBlobIndexTooHigh         = errors.New("blob index is too high")
+	ErrBlockRootMismatch        = errors.New("block root mismatch")
+	ErrBlobsCellsProofsMismatch = errors.New("blobs and cells proofs mismatch")
+)
+
+// MinimumColumnsCountToReconstruct return the minimum number of columns needed to proceed to a reconstruction.
+func MinimumColumnsCountToReconstruct() uint64 {
+	// If the number of columns is odd, then we need total / 2 + 1 columns to reconstruct.
+	// If the number of columns is even, then we need total / 2 columns to reconstruct.
+	return (params.BeaconConfig().NumberOfColumns + 1) / 2
 }
 
-// RecoverCellsAndProofs recovers the cells and proofs from the data column sidecars.
-func RecoverCellsAndProofs(dataColumnSideCars []*ethpb.DataColumnSidecar) ([]kzg.CellsAndProofs, error) {
-	var wg errgroup.Group
-
-	dataColumnSideCarsCount := len(dataColumnSideCars)
-
-	if dataColumnSideCarsCount == 0 {
-		return nil, errors.New("no data column sidecars")
+// ReconstructDataColumnSidecars reconstructs all the data column sidecars from the given input data column sidecars.
+// All input sidecars must be committed to the same block.
+// `inVerifiedRoSidecars` should contain enough (unique) sidecars to reconstruct the missing columns.
+func ReconstructDataColumnSidecars(inVerifiedRoSidecars []blocks.VerifiedRODataColumn) ([]blocks.VerifiedRODataColumn, error) {
+	// Check if there is at least one input sidecar.
+	if len(inVerifiedRoSidecars) == 0 {
+		return nil, ErrNotEnoughDataColumnSidecars
 	}
 
-	// Check if all columns have the same length.
-	blobCount := len(dataColumnSideCars[0].Column)
-	for _, sidecar := range dataColumnSideCars {
-		length := len(sidecar.Column)
+	// Safely retrieve the first sidecar as a reference.
+	referenceSidecar := inVerifiedRoSidecars[0]
 
-		if length != blobCount {
-			return nil, errors.New("columns do not have the same length")
+	// Check if all columns have the same length and are commmitted to the same block.
+	blobCount := len(referenceSidecar.Column)
+	blockRoot := referenceSidecar.BlockRoot()
+	for _, sidecar := range inVerifiedRoSidecars[1:] {
+		if len(sidecar.Column) != blobCount {
+			return nil, ErrColumnLengthsDiffer
+		}
+
+		if sidecar.BlockRoot() != blockRoot {
+			return nil, ErrBlockRootMismatch
 		}
 	}
 
+	// Deduplicate sidecars.
+	sidecarByIndex := make(map[uint64]blocks.VerifiedRODataColumn, len(inVerifiedRoSidecars))
+	for _, inVerifiedRoSidecar := range inVerifiedRoSidecars {
+		sidecarByIndex[inVerifiedRoSidecar.Index] = inVerifiedRoSidecar
+	}
+
+	// Check if there is enough sidecars to reconstruct the missing columns.
+	sidecarCount := len(sidecarByIndex)
+	if uint64(sidecarCount) < MinimumColumnsCountToReconstruct() {
+		return nil, ErrNotEnoughDataColumnSidecars
+	}
+
+	// Sidecars are verified and are committed to the same block.
+	// All signed block headers, KZG commitments, and inclusion proofs are the same.
+	signedBlockHeader := referenceSidecar.SignedBlockHeader
+	kzgCommitments := referenceSidecar.KzgCommitments
+	kzgCommitmentsInclusionProof := referenceSidecar.KzgCommitmentsInclusionProof
+
 	// Recover cells and compute proofs in parallel.
-	recoveredCellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
-
-	for blobIndex := 0; blobIndex < blobCount; blobIndex++ {
-		bIndex := blobIndex
+	var wg errgroup.Group
+	cellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
+	for blobIndex := range uint64(blobCount) {
 		wg.Go(func() error {
-			cellsIndices := make([]uint64, 0, dataColumnSideCarsCount)
-			cells := make([]kzg.Cell, 0, dataColumnSideCarsCount)
-
-			for _, sidecar := range dataColumnSideCars {
-				// Build the cell indices.
-				cellsIndices = append(cellsIndices, sidecar.Index)
-
-				// Get the cell.
-				column := sidecar.Column
-				cell := column[bIndex]
+			cellsIndices := make([]uint64, 0, sidecarCount)
+			cells := make([]kzg.Cell, 0, sidecarCount)
 
+			for columnIndex, sidecar := range sidecarByIndex {
+				cell := sidecar.Column[blobIndex]
 				cells = append(cells, kzg.Cell(cell))
+				cellsIndices = append(cellsIndices, columnIndex)
 			}
 
 			// Recover the cells and proofs for the corresponding blob
-			cellsAndProofs, err := kzg.RecoverCellsAndKZGProofs(cellsIndices, cells)
+			cellsAndProofsForBlob, err := kzg.RecoverCellsAndKZGProofs(cellsIndices, cells)
 
 			if err != nil {
-				return errors.Wrapf(err, "recover cells and KZG proofs for blob %d", bIndex)
+				return errors.Wrapf(err, "recover cells and KZG proofs for blob %d", blobIndex)
 			}
 
-			recoveredCellsAndProofs[bIndex] = cellsAndProofs
+			// It is safe for multiple goroutines to concurrently write to the same slice,
+			// as long as they are writing to different indices, which is the case here.
+			cellsAndProofs[blobIndex] = cellsAndProofsForBlob
 			return nil
 		})
 	}
 
 	if err := wg.Wait(); err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "wait for RecoverCellsAndKZGProofs")
 	}
 
-	return recoveredCellsAndProofs, nil
+	outSidecars, err := dataColumnsSidecars(signedBlockHeader, kzgCommitments, kzgCommitmentsInclusionProof, cellsAndProofs)
+	if err != nil {
+		return nil, errors.Wrap(err, "data column sidecars from items")
+	}
+
+	// Input sidecars are verified, and we reconstructed ourselves the missing sidecars.
+	// As a consequence, reconstructed sidecars are also verified.
+	outVerifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(outSidecars))
+	for _, sidecar := range outSidecars {
+		roSidecar, err := blocks.NewRODataColumnWithRoot(sidecar, blockRoot)
+		if err != nil {
+			return nil, errors.Wrap(err, "new RO data column with root")
+		}
+
+		verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
+		outVerifiedRoSidecars = append(outVerifiedRoSidecars, verifiedRoSidecar)
+	}
+
+	return outVerifiedRoSidecars, nil
+}
+
+// ConstructDataColumnSidecars constructs data column sidecars from a block, (un-extended) blobs and
+// cell proofs corresponding the extended blobs. The main purpose of this function is to
+// construct data columns sidecars from data obtained from the execution client via:
+// - `engine_getBlobsV2` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getblobsv2, or
+// - `engine_getPayloadV5` - https://github.com/ethereum/execution-apis/blob/main/src/engine/osaka.md#engine_getpayloadv5
+// Note: In this function, to stick with the `BlobsBundleV2` format returned by the execution client in `engine_getPayloadV5`,
+// cell proofs are "flattened".
+func ConstructDataColumnSidecars(block interfaces.ReadOnlySignedBeaconBlock, blobs [][]byte, cellProofs [][]byte) ([]*ethpb.DataColumnSidecar, error) {
+	// Check if the cells count is equal to the cell proofs count.
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+	blobCount := uint64(len(blobs))
+	cellProofsCount := uint64(len(cellProofs))
+
+	cellsCount := blobCount * numberOfColumns
+	if cellsCount != cellProofsCount {
+		return nil, ErrBlobsCellsProofsMismatch
+	}
+
+	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobCount)
+	for i, blob := range blobs {
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blob) != len(kzgBlob) {
+			return nil, errors.New("wrong blob size - should never happen")
+		}
+
+		// Compute the extended cells from the (non-extended) blob.
+		cells, err := kzg.ComputeCells(&kzgBlob)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute cells")
+		}
+
+		var proofs []kzg.Proof
+		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
+			var kzgProof kzg.Proof
+			if copy(kzgProof[:], cellProofs[idx]) != len(kzgProof) {
+				return nil, errors.New("wrong KZG proof size - should never happen")
+			}
+
+			proofs = append(proofs, kzgProof)
+		}
+
+		cellsProofs := kzg.CellsAndProofs{Cells: cells, Proofs: proofs}
+		cellsAndProofs = append(cellsAndProofs, cellsProofs)
+	}
+
+	dataColumnSidecars, err := DataColumnSidecars(block, cellsAndProofs)
+	if err != nil {
+		return nil, errors.Wrap(err, "data column sidcars")
+	}
+
+	return dataColumnSidecars, nil
+}
+
+// ReconstructBlobs constructs verified read only blobs sidecars from verified read only blob sidecars.
+// The following constraints must be satisfied:
+//   - All `dataColumnSidecars` has to be committed to the same block, and
+//   - `dataColumnSidecars` must be sorted by index and should not contain duplicates.
+//   - `dataColumnSidecars` must contain either all sidecars corresponding to (non-extended) blobs,
+//     or either enough sidecars to reconstruct the blobs.
+func ReconstructBlobs(block blocks.ROBlock, verifiedDataColumnSidecars []blocks.VerifiedRODataColumn, indices []int) ([]*blocks.VerifiedROBlob, error) {
+	// Return early if no blobs are requested.
+	if len(indices) == 0 {
+		return nil, nil
+	}
+
+	if len(verifiedDataColumnSidecars) == 0 {
+		return nil, ErrNotEnoughDataColumnSidecars
+	}
+
+	// Check if the sidecars are sorted by index and do not contain duplicates.
+	previousColumnIndex := verifiedDataColumnSidecars[0].Index
+	for _, dataColumnSidecar := range verifiedDataColumnSidecars[1:] {
+		columnIndex := dataColumnSidecar.Index
+		if columnIndex <= previousColumnIndex {
+			return nil, ErrDataColumnSidecarsNotSortedByIndex
+		}
+
+		previousColumnIndex = columnIndex
+	}
+
+	// Check if we have enough columns.
+	cellsPerBlob := fieldparams.CellsPerBlob
+	if len(verifiedDataColumnSidecars) < cellsPerBlob {
+		return nil, ErrNotEnoughDataColumnSidecars
+	}
+
+	// Check if the blob index is too high.
+	commitments, err := block.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return nil, errors.Wrap(err, "blob KZG commitments")
+	}
+
+	for _, blobIndex := range indices {
+		if blobIndex >= len(commitments) {
+			return nil, ErrBlobIndexTooHigh
+		}
+	}
+
+	// Check if the data column sidecars are aligned with the block.
+	dataColumnSidecars := make([]blocks.RODataColumn, 0, len(verifiedDataColumnSidecars))
+	for _, verifiedDataColumnSidecar := range verifiedDataColumnSidecars {
+		dataColumnSicecar := verifiedDataColumnSidecar.RODataColumn
+		dataColumnSidecars = append(dataColumnSidecars, dataColumnSicecar)
+	}
+
+	if err := DataColumnsAlignWithBlock(block, dataColumnSidecars); err != nil {
+		return nil, errors.Wrap(err, "data columns align with block")
+	}
+
+	// If all column sidecars corresponding to (non-extended) blobs are present, no need to reconstruct.
+	if verifiedDataColumnSidecars[cellsPerBlob-1].Index == uint64(cellsPerBlob-1) {
+		// Convert verified data column sidecars to verified blob sidecars.
+		blobSidecars, err := blobSidecarsFromDataColumnSidecars(block, verifiedDataColumnSidecars, indices)
+		if err != nil {
+			return nil, errors.Wrap(err, "blob sidecars from data column sidecars")
+		}
+
+		return blobSidecars, nil
+	}
+
+	// We need to reconstruct the blobs.
+	reconstructedDataColumnSidecars, err := ReconstructDataColumnSidecars(verifiedDataColumnSidecars)
+	if err != nil {
+		return nil, errors.Wrap(err, "reconstruct data column sidecars")
+	}
+
+	// Convert verified data column sidecars to verified blob sidecars.
+	blobSidecars, err := blobSidecarsFromDataColumnSidecars(block, reconstructedDataColumnSidecars, indices)
+	if err != nil {
+		return nil, errors.Wrap(err, "blob sidecars from data column sidecars")
+	}
+
+	return blobSidecars, nil
+}
+
+// blobSidecarsFromDataColumnSidecars converts verified data column sidecars to verified blob sidecars.
+func blobSidecarsFromDataColumnSidecars(roBlock blocks.ROBlock, dataColumnSidecars []blocks.VerifiedRODataColumn, indices []int) ([]*blocks.VerifiedROBlob, error) {
+	referenceSidecar := dataColumnSidecars[0]
+
+	kzgCommitments := referenceSidecar.KzgCommitments
+	signedBlockHeader := referenceSidecar.SignedBlockHeader
+
+	verifiedROBlobs := make([]*blocks.VerifiedROBlob, 0, len(indices))
+	for _, blobIndex := range indices {
+		var blob kzg.Blob
+
+		// Compute the content of the blob.
+		for columnIndex := range fieldparams.CellsPerBlob {
+			dataColumnSidecar := dataColumnSidecars[columnIndex]
+			cell := dataColumnSidecar.Column[blobIndex]
+			if copy(blob[kzg.BytesPerCell*columnIndex:], cell) != kzg.BytesPerCell {
+				return nil, errors.New("wrong cell size - should never happen")
+			}
+		}
+
+		// Extract the KZG commitment.
+		var kzgCommitment kzg.Commitment
+		if copy(kzgCommitment[:], kzgCommitments[blobIndex]) != len(kzgCommitment) {
+			return nil, errors.New("wrong KZG commitment size - should never happen")
+		}
+
+		// Compute the blob KZG proof.
+		blobKzgProof, err := kzg.ComputeBlobKZGProof(&blob, kzgCommitment)
+		if err != nil {
+			return nil, errors.Wrap(err, "compute blob KZG proof")
+		}
+
+		// Build the inclusion proof for the blob.
+		var kzgBlob kzg.Blob
+		if copy(kzgBlob[:], blob[:]) != len(kzgBlob) {
+			return nil, errors.New("wrong blob size - should never happen")
+		}
+
+		commitmentInclusionProof, err := blocks.MerkleProofKZGCommitment(roBlock.Block().Body(), blobIndex)
+		if err != nil {
+			return nil, errors.Wrap(err, "merkle proof KZG commitment")
+		}
+
+		// Build the blob sidecar.
+		blobSidecar := &ethpb.BlobSidecar{
+			Index:                    uint64(blobIndex),
+			Blob:                     blob[:],
+			KzgCommitment:            kzgCommitment[:],
+			KzgProof:                 blobKzgProof[:],
+			SignedBlockHeader:        signedBlockHeader,
+			CommitmentInclusionProof: commitmentInclusionProof,
+		}
+
+		roBlob, err := blocks.NewROBlob(blobSidecar)
+		if err != nil {
+			return nil, errors.Wrap(err, "new RO blob")
+		}
+
+		verifiedROBlob := blocks.NewVerifiedROBlob(roBlob)
+		verifiedROBlobs = append(verifiedROBlobs, &verifiedROBlob)
+	}
+
+	return verifiedROBlobs, nil
 }

beacon-chain/core/peerdas/reconstruction_test.go

@@ -1,43 +1,41 @@
 package peerdas_test
 
 import (
+	"encoding/binary"
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/pkg/errors"
+	"golang.org/x/sync/errgroup"
 )
 
-func TestCanSelfReconstruct(t *testing.T) {
+func TestMinimumColumnsCountToReconstruct(t *testing.T) {
 	testCases := []struct {
-		name                       string
-		totalNumberOfCustodyGroups uint64
-		custodyNumberOfGroups      uint64
-		expected                   bool
+		name            string
+		numberOfColumns uint64
+		expected        uint64
 	}{
 		{
-			name:                       "totalNumberOfCustodyGroups=64, custodyNumberOfGroups=31",
-			totalNumberOfCustodyGroups: 64,
-			custodyNumberOfGroups:      31,
-			expected:                   false,
+			name:            "numberOfColumns=128",
+			numberOfColumns: 128,
+			expected:        64,
 		},
 		{
-			name:                       "totalNumberOfCustodyGroups=64, custodyNumberOfGroups=32",
-			totalNumberOfCustodyGroups: 64,
-			custodyNumberOfGroups:      32,
-			expected:                   true,
+			name:            "numberOfColumns=129",
+			numberOfColumns: 129,
+			expected:        65,
 		},
 		{
-			name:                       "totalNumberOfCustodyGroups=65, custodyNumberOfGroups=32",
-			totalNumberOfCustodyGroups: 65,
-			custodyNumberOfGroups:      32,
-			expected:                   false,
-		},
-		{
-			name:                       "totalNumberOfCustodyGroups=63, custodyNumberOfGroups=33",
-			totalNumberOfCustodyGroups: 65,
-			custodyNumberOfGroups:      33,
-			expected:                   true,
+			name:            "numberOfColumns=130",
+			numberOfColumns: 130,
+			expected:        65,
 		},
 	}
 
@@ -46,12 +44,278 @@ func TestCanSelfReconstruct(t *testing.T) {
 			// Set the total number of columns.
 			params.SetupTestConfigCleanup(t)
 			cfg := params.BeaconConfig().Copy()
-			cfg.NumberOfCustodyGroups = tc.totalNumberOfCustodyGroups
+			cfg.NumberOfColumns = tc.numberOfColumns
 			params.OverrideBeaconConfig(cfg)
 
-			// Check if reconstuction is possible.
-			actual := peerdas.CanSelfReconstruct(tc.custodyNumberOfGroups)
+			// Compute the minimum number of columns needed to reconstruct.
+			actual := peerdas.MinimumColumnsCountToReconstruct()
 			require.Equal(t, tc.expected, actual)
 		})
 	}
 }
+
+func TestReconstructDataColumnSidecars(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	t.Run("empty input", func(t *testing.T) {
+		_, err := peerdas.ReconstructDataColumnSidecars(nil)
+		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
+	})
+
+	t.Run("columns lengths differ", func(t *testing.T) {
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
+
+		// Arbitrarily alter the column with index 3
+		verifiedRoSidecars[3].Column = verifiedRoSidecars[3].Column[1:]
+
+		_, err := peerdas.ReconstructDataColumnSidecars(verifiedRoSidecars)
+		require.ErrorIs(t, err, peerdas.ErrColumnLengthsDiffer)
+	})
+
+	t.Run("roots differ", func(t *testing.T) {
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{1}))
+		_, _, verifiedRoSidecarsAlter := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{2}))
+
+		// Arbitrarily alter the column with index 3
+		verifiedRoSidecars[3] = verifiedRoSidecarsAlter[3]
+		_, err := peerdas.ReconstructDataColumnSidecars(verifiedRoSidecars)
+		require.ErrorIs(t, err, peerdas.ErrBlockRootMismatch)
+	})
+
+	const blobCount = 6
+	signedBeaconBlockPb := util.NewBeaconBlockFulu()
+	block := signedBeaconBlockPb.Block
+
+	commitments := make([][]byte, 0, blobCount)
+	for i := range uint64(blobCount) {
+		var commitment [fieldparams.KzgCommitmentSize]byte
+		binary.BigEndian.PutUint64(commitment[:], i)
+		commitments = append(commitments, commitment[:])
+	}
+
+	block.Body.BlobKzgCommitments = commitments
+
+	t.Run("not enough columns to enable reconstruction", func(t *testing.T) {
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
+
+		minimum := peerdas.MinimumColumnsCountToReconstruct()
+		_, err := peerdas.ReconstructDataColumnSidecars(verifiedRoSidecars[:minimum-1])
+		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		// Build a full set of verified data column sidecars.
+		_, _, inputVerifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
+
+		// Arbitrarily keep only the even sicars.
+		filteredVerifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(inputVerifiedRoSidecars)/2)
+		for i := 0; i < len(inputVerifiedRoSidecars); i += 2 {
+			filteredVerifiedRoSidecars = append(filteredVerifiedRoSidecars, inputVerifiedRoSidecars[i])
+		}
+
+		// Reconstruct the data column sidecars.
+		reconstructedVerifiedRoSidecars, err := peerdas.ReconstructDataColumnSidecars(filteredVerifiedRoSidecars)
+		require.NoError(t, err)
+
+		// Verify that the reconstructed sidecars are equal to the original ones.
+		require.DeepSSZEqual(t, inputVerifiedRoSidecars, reconstructedVerifiedRoSidecars)
+	})
+}
+
+func TestConstructDataColumnSidecars(t *testing.T) {
+	const (
+		blobCount    = 3
+		cellsPerBlob = fieldparams.CellsPerBlob
+	)
+
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	roBlock, _, baseVerifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, blobCount)
+
+	// Extract blobs and proofs from the sidecars.
+	blobs := make([][]byte, 0, blobCount)
+	cellProofs := make([][]byte, 0, cellsPerBlob)
+	for blobIndex := range blobCount {
+		blob := make([]byte, 0, cellsPerBlob)
+		for columnIndex := range cellsPerBlob {
+			cell := baseVerifiedRoSidecars[columnIndex].Column[blobIndex]
+			blob = append(blob, cell...)
+		}
+
+		blobs = append(blobs, blob)
+
+		for columnIndex := range numberOfColumns {
+			cellProof := baseVerifiedRoSidecars[columnIndex].KzgProofs[blobIndex]
+			cellProofs = append(cellProofs, cellProof)
+		}
+	}
+
+	actual, err := peerdas.ConstructDataColumnSidecars(roBlock, blobs, cellProofs)
+	require.NoError(t, err)
+
+	// Extract the base verified ro sidecars into sidecars.
+	expected := make([]*ethpb.DataColumnSidecar, 0, len(baseVerifiedRoSidecars))
+	for _, verifiedRoSidecar := range baseVerifiedRoSidecars {
+		expected = append(expected, verifiedRoSidecar.DataColumnSidecar)
+	}
+
+	require.DeepSSZEqual(t, expected, actual)
+}
+
+func TestReconstructBlobs(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	var emptyBlock blocks.ROBlock
+
+	t.Run("no index", func(t *testing.T) {
+		actual, err := peerdas.ReconstructBlobs(emptyBlock, nil, nil)
+		require.NoError(t, err)
+		require.IsNil(t, actual)
+	})
+
+	t.Run("empty input", func(t *testing.T) {
+		_, err := peerdas.ReconstructBlobs(emptyBlock, nil, []int{0})
+		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
+	})
+
+	t.Run("not sorted", func(t *testing.T) {
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
+
+		// Arbitrarily change the order of the sidecars.
+		verifiedRoSidecars[3], verifiedRoSidecars[2] = verifiedRoSidecars[2], verifiedRoSidecars[3]
+
+		_, err := peerdas.ReconstructBlobs(emptyBlock, verifiedRoSidecars, []int{0})
+		require.ErrorIs(t, err, peerdas.ErrDataColumnSidecarsNotSortedByIndex)
+	})
+
+	t.Run("not enough columns", func(t *testing.T) {
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3)
+
+		inputSidecars := verifiedRoSidecars[:fieldparams.CellsPerBlob-1]
+		_, err := peerdas.ReconstructBlobs(emptyBlock, inputSidecars, []int{0})
+		require.ErrorIs(t, err, peerdas.ErrNotEnoughDataColumnSidecars)
+	})
+
+	t.Run("index too high", func(t *testing.T) {
+		const blobCount = 3
+
+		roBlock, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, blobCount)
+
+		_, err := peerdas.ReconstructBlobs(roBlock, verifiedRoSidecars, []int{1, blobCount})
+		require.ErrorIs(t, err, peerdas.ErrBlobIndexTooHigh)
+	})
+
+	t.Run("not committed to the same block", func(t *testing.T) {
+		_, _, verifiedRoSidecars := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{1}))
+		roBlock, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 3, util.WithParentRoot([fieldparams.RootLength]byte{2}))
+
+		_, err = peerdas.ReconstructBlobs(roBlock, verifiedRoSidecars, []int{0})
+		require.ErrorContains(t, peerdas.ErrRootMismatch.Error(), err)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		const blobCount = 3
+		numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+		roBlock, roBlobSidecars := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 42, blobCount)
+
+		// Compute cells and proofs from blob sidecars.
+		var wg errgroup.Group
+		blobs := make([][]byte, blobCount)
+		cellsAndProofs := make([]kzg.CellsAndProofs, blobCount)
+		for i := range blobCount {
+			blob := roBlobSidecars[i].Blob
+			blobs[i] = blob
+
+			wg.Go(func() error {
+				var kzgBlob kzg.Blob
+				count := copy(kzgBlob[:], blob)
+				require.Equal(t, len(kzgBlob), count)
+
+				cp, err := kzg.ComputeCellsAndKZGProofs(&kzgBlob)
+				if err != nil {
+					return errors.Wrapf(err, "compute cells and kzg proofs for blob %d", i)
+				}
+
+				// It is safe for multiple goroutines to concurrently write to the same slice,
+				// as long as they are writing to different indices, which is the case here.
+				cellsAndProofs[i] = cp
+
+				return nil
+			})
+		}
+
+		err := wg.Wait()
+		require.NoError(t, err)
+
+		// Flatten proofs.
+		cellProofs := make([][]byte, 0, blobCount*numberOfColumns)
+		for _, cp := range cellsAndProofs {
+			for _, proof := range cp.Proofs {
+				cellProofs = append(cellProofs, proof[:])
+			}
+		}
+
+		// Construct data column sidecars.
+		// It is OK to use the public function `ConstructDataColumnSidecars`, as long as
+		// `TestConstructDataColumnSidecars` tests pass.
+		dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(roBlock, blobs, cellProofs)
+		require.NoError(t, err)
+
+		// Convert to verified data column sidecars.
+		verifiedRoSidecars := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
+		for _, dataColumnSidecar := range dataColumnSidecars {
+			roSidecar, err := blocks.NewRODataColumn(dataColumnSidecar)
+			require.NoError(t, err)
+
+			verifiedRoSidecar := blocks.NewVerifiedRODataColumn(roSidecar)
+			verifiedRoSidecars = append(verifiedRoSidecars, verifiedRoSidecar)
+		}
+
+		indices := []int{2, 0}
+
+		t.Run("no reconstruction needed", func(t *testing.T) {
+			// Reconstruct blobs.
+			reconstructedVerifiedRoBlobSidecars, err := peerdas.ReconstructBlobs(roBlock, verifiedRoSidecars, indices)
+			require.NoError(t, err)
+
+			// Compare blobs.
+			for i, blobIndex := range indices {
+				expected := roBlobSidecars[blobIndex]
+				actual := reconstructedVerifiedRoBlobSidecars[i].ROBlob
+
+				require.DeepSSZEqual(t, expected, actual)
+			}
+		})
+
+		t.Run("reconstruction needed", func(t *testing.T) {
+			// Arbitrarily keep only the even sidecars.
+			filteredSidecars := make([]blocks.VerifiedRODataColumn, 0, len(verifiedRoSidecars)/2)
+			for i := 0; i < len(verifiedRoSidecars); i += 2 {
+				filteredSidecars = append(filteredSidecars, verifiedRoSidecars[i])
+			}
+
+			// Reconstruct blobs.
+			reconstructedVerifiedRoBlobSidecars, err := peerdas.ReconstructBlobs(roBlock, filteredSidecars, indices)
+			require.NoError(t, err)
+
+			// Compare blobs.
+			for i, blobIndex := range indices {
+				expected := roBlobSidecars[blobIndex]
+				actual := reconstructedVerifiedRoBlobSidecars[i].ROBlob
+
+				require.DeepSSZEqual(t, expected, actual)
+			}
+		})
+
+	})
+
+}

beacon-chain/core/peerdas/util.go

@@ -1,54 +0,0 @@
-package peerdas
-
-import (
-	"fmt"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
-	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
-	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
-	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/pkg/errors"
-)
-
-// ConstructDataColumnSidecars constructs data column sidecars from a block, blobs and their cell proofs.
-// This is a convenience method as blob and cell proofs are common inputs.
-func ConstructDataColumnSidecars(block interfaces.SignedBeaconBlock, blobs [][]byte, cellProofs [][]byte) ([]*ethpb.DataColumnSidecar, error) {
-	// Check if the block is at least a Fulu block.
-	if block.Version() < version.Fulu {
-		return nil, nil
-	}
-
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-	if uint64(len(blobs))*numberOfColumns != uint64(len(cellProofs)) {
-		return nil, fmt.Errorf("number of blobs and cell proofs do not match: %d * %d != %d", len(blobs), numberOfColumns, len(cellProofs))
-	}
-
-	cellsAndProofs := make([]kzg.CellsAndProofs, 0, len(blobs))
-
-	for i, blob := range blobs {
-		var b kzg.Blob
-		copy(b[:], blob)
-		cells, err := kzg.ComputeCells(&b)
-		if err != nil {
-			return nil, err
-		}
-
-		var proofs []kzg.Proof
-		for idx := uint64(i) * numberOfColumns; idx < (uint64(i)+1)*numberOfColumns; idx++ {
-			proofs = append(proofs, kzg.Proof(cellProofs[idx]))
-		}
-
-		cellsAndProofs = append(cellsAndProofs, kzg.CellsAndProofs{
-			Cells:  cells,
-			Proofs: proofs,
-		})
-	}
-
-	dataColumnSidecars, err := DataColumnSidecars(block, cellsAndProofs)
-	if err != nil {
-		return nil, errors.Wrap(err, "data column sidcars")
-	}
-
-	return dataColumnSidecars, nil
-}

beacon-chain/core/peerdas/utils_test.go

@@ -8,18 +8,30 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
+	"github.com/pkg/errors"
 	"github.com/sirupsen/logrus"
 )
 
+func generateCommitment(blob *kzg.Blob) (*kzg.Commitment, error) {
+	commitment, err := kzg.BlobToKZGCommitment(blob)
+	if err != nil {
+		return nil, errors.Wrap(err, "blob to kzg commitment")
+	}
+
+	return &commitment, nil
+}
+
 func generateCommitmentAndProof(blob *kzg.Blob) (*kzg.Commitment, *kzg.Proof, error) {
 	commitment, err := kzg.BlobToKZGCommitment(blob)
 	if err != nil {
 		return nil, nil, err
 	}
+
 	proof, err := kzg.ComputeBlobKZGProof(blob, commitment)
 	if err != nil {
 		return nil, nil, err
 	}
+
 	return &commitment, &proof, err
 }
 

beacon-chain/core/peerdas/verification.go

@@ -0,0 +1,65 @@
+package peerdas
+
+import (
+	"bytes"
+
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/pkg/errors"
+)
+
+var (
+	ErrBlockColumnSizeMismatch = errors.New("size mismatch between data column and block")
+	ErrTooManyCommitments      = errors.New("too many commitments")
+	ErrRootMismatch            = errors.New("root mismatch between data column and block")
+	ErrCommitmentMismatch      = errors.New("commitment mismatch between data column and block")
+)
+
+// DataColumnsAlignWithBlock checks if the data columns align with the block.
+func DataColumnsAlignWithBlock(block blocks.ROBlock, dataColumns []blocks.RODataColumn) error {
+	// No data columns before Fulu.
+	if block.Version() < version.Fulu {
+		return nil
+	}
+
+	// Compute the maximum number of blobs per block.
+	blockSlot := block.Block().Slot()
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(blockSlot)
+
+	// Check if the block has not too many commitments.
+	blockCommitments, err := block.Block().Body().BlobKzgCommitments()
+	if err != nil {
+		return errors.Wrap(err, "blob KZG commitments")
+	}
+
+	blockCommitmentCount := len(blockCommitments)
+	if blockCommitmentCount > maxBlobsPerBlock {
+		return ErrTooManyCommitments
+	}
+
+	blockRoot := block.Root()
+
+	for _, dataColumn := range dataColumns {
+		// Check if the root of the data column sidecar matches the block root.
+		if dataColumn.BlockRoot() != blockRoot {
+			return ErrRootMismatch
+		}
+
+		// Check if the content length of the data column sidecar matches the block.
+		if len(dataColumn.Column) != blockCommitmentCount ||
+			len(dataColumn.KzgCommitments) != blockCommitmentCount ||
+			len(dataColumn.KzgProofs) != blockCommitmentCount {
+			return ErrBlockColumnSizeMismatch
+		}
+
+		// Check if the commitments of the data column sidecar match the block.
+		for i := range blockCommitments {
+			if !bytes.Equal(blockCommitments[i], dataColumn.KzgCommitments[i]) {
+				return ErrCommitmentMismatch
+			}
+		}
+	}
+
+	return nil
+}

beacon-chain/core/peerdas/verification_test.go

@@ -0,0 +1,77 @@
+package peerdas_test
+
+import (
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+)
+
+func TestDataColumnsAlignWithBlock(t *testing.T) {
+	// Start the trusted setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	t.Run("pre fulu", func(t *testing.T) {
+		block, _ := util.GenerateTestElectraBlockWithSidecar(t, [fieldparams.RootLength]byte{}, 0, 0)
+		err := peerdas.DataColumnsAlignWithBlock(block, nil)
+		require.NoError(t, err)
+	})
+
+	t.Run("too many commitmnets", func(t *testing.T) {
+		params.SetupTestConfigCleanup(t)
+		config := params.BeaconConfig()
+		config.BlobSchedule = []params.BlobScheduleEntry{{}}
+		params.OverrideBeaconConfig(config)
+
+		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 3)
+		err := peerdas.DataColumnsAlignWithBlock(block, nil)
+		require.ErrorIs(t, err, peerdas.ErrTooManyCommitments)
+	})
+
+	t.Run("root mismatch", func(t *testing.T) {
+		_, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 0)
+		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
+		require.ErrorIs(t, err, peerdas.ErrRootMismatch)
+	})
+
+	t.Run("column size mismatch", func(t *testing.T) {
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		sidecars[0].Column = [][]byte{}
+		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
+		require.ErrorIs(t, err, peerdas.ErrBlockColumnSizeMismatch)
+	})
+
+	t.Run("KZG commitments size mismatch", func(t *testing.T) {
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		sidecars[0].KzgCommitments = [][]byte{}
+		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
+		require.ErrorIs(t, err, peerdas.ErrBlockColumnSizeMismatch)
+	})
+
+	t.Run("KZG proofs mismatch", func(t *testing.T) {
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		sidecars[0].KzgProofs = [][]byte{}
+		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
+		require.ErrorIs(t, err, peerdas.ErrBlockColumnSizeMismatch)
+	})
+
+	t.Run("commitment mismatch", func(t *testing.T) {
+		block, _, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		_, alteredSidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		alteredSidecars[1].KzgCommitments[0][0]++ // Overflow is OK
+		err := peerdas.DataColumnsAlignWithBlock(block, alteredSidecars)
+		require.ErrorIs(t, err, peerdas.ErrCommitmentMismatch)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		block, sidecars, _ := util.GenerateTestFuluBlockWithSidecars(t, 2)
+		err := peerdas.DataColumnsAlignWithBlock(block, sidecars)
+		require.NoError(t, err)
+	})
+}

beacon-chain/core/transition/BUILD.bazel

@@ -46,6 +46,7 @@ go_library(
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
+        "//time/slots:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
         "@com_github_prometheus_client_golang//prometheus/promauto:go_default_library",

beacon-chain/core/transition/transition.go

@@ -27,7 +27,9 @@ import (
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	prysmTrace "github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
+	"github.com/sirupsen/logrus"
 	"go.opentelemetry.io/otel/trace"
 )
 
@@ -291,6 +293,8 @@ func ProcessSlotsCore(ctx context.Context, span trace.Span, state state.BeaconSt
 			tracing.AnnotateError(span, err)
 			return nil, errors.Wrap(err, "failed to upgrade state")
 		}
+
+		logBlobLimitIncrease(state.Slot())
 	}
 	return state, nil
 }
@@ -507,3 +511,19 @@ func ProcessEpochPrecompute(ctx context.Context, state state.BeaconState) (state
 	}
 	return state, nil
 }
+
+func logBlobLimitIncrease(slot primitives.Slot) {
+	if !slots.IsEpochStart(slot) {
+		return
+	}
+
+	epoch := slots.ToEpoch(slot)
+	for _, entry := range params.BeaconConfig().BlobSchedule {
+		if entry.Epoch == epoch {
+			log.WithFields(logrus.Fields{
+				"epoch":     epoch,
+				"blobLimit": entry.MaxBlobsPerBlock,
+			}).Info("Blob limit updated")
+		}
+	}
+}

beacon-chain/db/filesystem/BUILD.bazel

@@ -5,6 +5,9 @@ go_library(
     srcs = [
         "blob.go",
         "cache.go",
+        "data_column.go",
+        "data_column_cache.go",
+        "doc.go",
         "iteration.go",
         "layout.go",
         "layout_by_epoch.go",
@@ -17,6 +20,8 @@ go_library(
     importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem",
     visibility = ["//visibility:public"],
     deps = [
+        "//async:go_default_library",
+        "//async/event:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -41,6 +46,8 @@ go_test(
     srcs = [
         "blob_test.go",
         "cache_test.go",
+        "data_column_cache_test.go",
+        "data_column_test.go",
         "iteration_test.go",
         "layout_test.go",
         "migration_test.go",
@@ -50,6 +57,7 @@ go_test(
     deps = [
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/verification:go_default_library",
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/db/filesystem/data_column_cache.go

@@ -0,0 +1,243 @@
+package filesystem
+
+import (
+	"sync"
+
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/pkg/errors"
+)
+
+var errDataColumnIndexOutOfBounds = errors.New("data column index too high")
+
+// DataColumnStorageSummary represents cached information about the DataColumnSidecars on disk for each root the cache knows about.
+type DataColumnStorageSummary struct {
+	epoch primitives.Epoch
+	mask  [fieldparams.NumberOfColumns]bool
+}
+
+// NewDataColumnStorageSummary creates a new DataColumnStorageSummary for a given epoch and mask.
+func NewDataColumnStorageSummary(epoch primitives.Epoch, mask [fieldparams.NumberOfColumns]bool) DataColumnStorageSummary {
+	return DataColumnStorageSummary{
+		epoch: epoch,
+		mask:  mask,
+	}
+}
+
+// HasIndex returns true if the DataColumnSidecar at the given index is available in the filesystem.
+func (s DataColumnStorageSummary) HasIndex(index uint64) bool {
+	if index >= uint64(fieldparams.NumberOfColumns) {
+		return false
+	}
+	return s.mask[index]
+}
+
+// HasAtLeastOneIndex returns true if at least one of the DataColumnSidecars at the given indices is available in the filesystem.
+func (s DataColumnStorageSummary) HasAtLeastOneIndex(indices []uint64) bool {
+	for _, index := range indices {
+		if s.mask[index] {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Count returns the number of available data columns.
+func (s DataColumnStorageSummary) Count() uint64 {
+	count := uint64(0)
+
+	for _, available := range s.mask {
+		if available {
+			count++
+		}
+	}
+
+	return count
+}
+
+// AllAvailable returns true if we have all data columns for corresponding indices.
+func (s DataColumnStorageSummary) AllAvailable(indices map[uint64]bool) bool {
+	if len(indices) > len(s.mask) {
+		return false
+	}
+
+	for index := range indices {
+		if !s.mask[index] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Stored returns a map of all stored data columns.
+func (s DataColumnStorageSummary) Stored() map[uint64]bool {
+	stored := make(map[uint64]bool, fieldparams.NumberOfColumns)
+	for index, exists := range s.mask {
+		if exists {
+			stored[uint64(index)] = true
+		}
+	}
+
+	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
+	lowestCachedEpoch  primitives.Epoch
+	highestCachedEpoch primitives.Epoch
+	cache              map[[fieldparams.RootLength]byte]DataColumnStorageSummary
+}
+
+var _ DataColumnStorageSummarizer = &dataColumnStorageSummaryCache{}
+
+func newDataColumnStorageSummaryCache() *dataColumnStorageSummaryCache {
+	return &dataColumnStorageSummaryCache{
+		cache:             make(map[[fieldparams.RootLength]byte]DataColumnStorageSummary),
+		lowestCachedEpoch: params.BeaconConfig().FarFutureEpoch,
+	}
+}
+
+// Summary returns the DataColumnStorageSummary for `root`.
+// The DataColumnStorageSummary can be used to check for the presence of DataColumnSidecars based on Index.
+func (sc *dataColumnStorageSummaryCache) Summary(root [fieldparams.RootLength]byte) DataColumnStorageSummary {
+	sc.mu.RLock()
+	defer sc.mu.RUnlock()
+
+	return sc.cache[root]
+}
+
+func (sc *dataColumnStorageSummaryCache) HighestEpoch() primitives.Epoch {
+	sc.mu.RLock()
+	defer sc.mu.RUnlock()
+	return sc.highestCachedEpoch
+}
+
+// set updates the cache.
+func (sc *dataColumnStorageSummaryCache) set(dataColumnsIdent DataColumnsIdent) error {
+	numberOfColumns := params.BeaconConfig().NumberOfColumns
+
+	sc.mu.Lock()
+	defer sc.mu.Unlock()
+
+	summary := sc.cache[dataColumnsIdent.Root]
+	summary.epoch = dataColumnsIdent.Epoch
+
+	count := uint64(0)
+	for _, index := range dataColumnsIdent.Indices {
+		if index >= numberOfColumns {
+			return errDataColumnIndexOutOfBounds
+		}
+
+		if summary.mask[index] {
+			continue
+		}
+
+		count++
+
+		summary.mask[index] = true
+		sc.lowestCachedEpoch = min(sc.lowestCachedEpoch, dataColumnsIdent.Epoch)
+		sc.highestCachedEpoch = max(sc.highestCachedEpoch, dataColumnsIdent.Epoch)
+	}
+
+	sc.cache[dataColumnsIdent.Root] = summary
+
+	countFloat := float64(count)
+	sc.dataColumnCount += countFloat
+	dataColumnDiskCount.Set(sc.dataColumnCount)
+	dataColumnWrittenCounter.Add(countFloat)
+
+	return nil
+}
+
+// get returns the DataColumnStorageSummary for the given block root.
+// If the root is not in the cache, the second return value will be false.
+func (sc *dataColumnStorageSummaryCache) get(blockRoot [fieldparams.RootLength]byte) (DataColumnStorageSummary, bool) {
+	sc.mu.RLock()
+	defer sc.mu.RUnlock()
+
+	v, ok := sc.cache[blockRoot]
+	return v, ok
+}
+
+// evict removes the DataColumnStorageSummary for the given block root from the cache.
+func (s *dataColumnStorageSummaryCache) evict(blockRoot [fieldparams.RootLength]byte) int {
+	deleted := 0
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	summary, ok := s.cache[blockRoot]
+	if !ok {
+		return 0
+	}
+
+	for i := range summary.mask {
+		if summary.mask[i] {
+			deleted += 1
+		}
+	}
+
+	delete(s.cache, blockRoot)
+	if deleted > 0 {
+		s.dataColumnCount -= float64(deleted)
+		dataColumnDiskCount.Set(s.dataColumnCount)
+	}
+
+	// The lowest and highest cached epoch may no longer be valid here,
+	// but is not worth the effort to recalculate.
+
+	return deleted
+}
+
+// pruneUpTo removes all entries from the cache up to the given target epoch included.
+func (sc *dataColumnStorageSummaryCache) pruneUpTo(targetEpoch primitives.Epoch) uint64 {
+	sc.mu.Lock()
+	defer sc.mu.Unlock()
+
+	prunedCount := uint64(0)
+	newLowestCachedEpoch := params.BeaconConfig().FarFutureEpoch
+	newHighestCachedEpoch := primitives.Epoch(0)
+
+	for blockRoot, summary := range sc.cache {
+		epoch := summary.epoch
+
+		if epoch > targetEpoch {
+			newLowestCachedEpoch = min(newLowestCachedEpoch, epoch)
+			newHighestCachedEpoch = max(newHighestCachedEpoch, epoch)
+		}
+
+		if epoch <= targetEpoch {
+			for i := range summary.mask {
+				if summary.mask[i] {
+					prunedCount += 1
+				}
+			}
+
+			delete(sc.cache, blockRoot)
+		}
+	}
+
+	if prunedCount > 0 {
+		sc.lowestCachedEpoch = newLowestCachedEpoch
+		sc.highestCachedEpoch = newHighestCachedEpoch
+		sc.dataColumnCount -= float64(prunedCount)
+		dataColumnDiskCount.Set(sc.dataColumnCount)
+	}
+
+	return prunedCount
+}
+
+// clear removes all entries from the cache.
+func (sc *dataColumnStorageSummaryCache) clear() uint64 {
+	return sc.pruneUpTo(params.BeaconConfig().FarFutureEpoch)
+}

beacon-chain/db/filesystem/data_column_cache_test.go

@@ -0,0 +1,257 @@
+package filesystem
+
+import (
+	"testing"
+
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+)
+
+func TestHasIndex(t *testing.T) {
+	summary := NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{false, true})
+
+	hasIndex := summary.HasIndex(1_000_000)
+	require.Equal(t, false, hasIndex)
+
+	hasIndex = summary.HasIndex(0)
+	require.Equal(t, false, hasIndex)
+
+	hasIndex = summary.HasIndex(1)
+	require.Equal(t, true, hasIndex)
+}
+
+func TestHasAtLeastOneIndex(t *testing.T) {
+	summary := NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{false, true})
+
+	hasAtLeastOneIndex := summary.HasAtLeastOneIndex([]uint64{3, 1, 2})
+	require.Equal(t, true, hasAtLeastOneIndex)
+
+	hasAtLeastOneIndex = summary.HasAtLeastOneIndex([]uint64{3, 4, 2})
+	require.Equal(t, false, hasAtLeastOneIndex)
+}
+
+func TestCount(t *testing.T) {
+	summary := NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{false, true, false, true})
+
+	count := summary.Count()
+	require.Equal(t, uint64(2), count)
+}
+
+func TestAllAvailableDataColumns(t *testing.T) {
+	const count = uint64(1_000)
+
+	summary := NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{false, true, false, true})
+
+	indices := make(map[uint64]bool, count)
+	for i := range count {
+		indices[i] = true
+	}
+
+	allAvailable := summary.AllAvailable(indices)
+	require.Equal(t, false, allAvailable)
+
+	indices = map[uint64]bool{1: true, 2: true}
+	allAvailable = summary.AllAvailable(indices)
+	require.Equal(t, false, allAvailable)
+
+	indices = map[uint64]bool{1: true, 3: true}
+	allAvailable = summary.AllAvailable(indices)
+	require.Equal(t, true, allAvailable)
+}
+
+func TestStored(t *testing.T) {
+	summary := NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{false, true, true, false})
+
+	expected := map[uint64]bool{1: true, 2: true}
+	actual := summary.Stored()
+
+	require.Equal(t, len(expected), len(actual))
+	for k, v := range expected {
+		require.Equal(t, v, actual[k])
+	}
+}
+
+func TestSummary(t *testing.T) {
+	root := [fieldparams.RootLength]byte{}
+
+	summaryCache := newDataColumnStorageSummaryCache()
+	expected := NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{})
+	actual := summaryCache.Summary(root)
+	require.DeepEqual(t, expected, actual)
+
+	summaryCache = newDataColumnStorageSummaryCache()
+	expected = NewDataColumnStorageSummary(0, [fieldparams.NumberOfColumns]bool{true, false, true, false})
+	summaryCache.cache[root] = expected
+	actual = summaryCache.Summary(root)
+	require.DeepEqual(t, expected, actual)
+}
+
+func TestHighestEpoch(t *testing.T) {
+	root1 := [fieldparams.RootLength]byte{1}
+	root2 := [fieldparams.RootLength]byte{2}
+	root3 := [fieldparams.RootLength]byte{3}
+
+	summaryCache := newDataColumnStorageSummaryCache()
+	actual := summaryCache.HighestEpoch()
+	require.Equal(t, primitives.Epoch(0), actual)
+
+	err := summaryCache.set(DataColumnsIdent{Root: root1, Epoch: 42, Indices: []uint64{1, 3}})
+	require.NoError(t, err)
+	require.Equal(t, primitives.Epoch(42), summaryCache.HighestEpoch())
+
+	err = summaryCache.set(DataColumnsIdent{Root: root2, Epoch: 43, Indices: []uint64{1, 3}})
+	require.NoError(t, err)
+	require.Equal(t, primitives.Epoch(43), summaryCache.HighestEpoch())
+
+	err = summaryCache.set(DataColumnsIdent{Root: root3, Epoch: 40, Indices: []uint64{1, 3}})
+	require.NoError(t, err)
+	require.Equal(t, primitives.Epoch(43), summaryCache.HighestEpoch())
+}
+
+func TestSet(t *testing.T) {
+	t.Run("Index out of bounds", func(t *testing.T) {
+		summaryCache := newDataColumnStorageSummaryCache()
+		err := summaryCache.set(DataColumnsIdent{Indices: []uint64{1_000_000}})
+		require.ErrorIs(t, err, errDataColumnIndexOutOfBounds)
+		require.Equal(t, params.BeaconConfig().FarFutureEpoch, summaryCache.lowestCachedEpoch)
+		require.Equal(t, 0, len(summaryCache.cache))
+	})
+
+	t.Run("Nominal", func(t *testing.T) {
+		root1 := [fieldparams.RootLength]byte{1}
+		root2 := [fieldparams.RootLength]byte{2}
+
+		summaryCache := newDataColumnStorageSummaryCache()
+
+		err := summaryCache.set(DataColumnsIdent{Root: root1, Epoch: 42, Indices: []uint64{1, 3}})
+		require.NoError(t, err)
+		require.Equal(t, primitives.Epoch(42), summaryCache.lowestCachedEpoch)
+		require.Equal(t, 1, len(summaryCache.cache))
+		expected := DataColumnStorageSummary{epoch: 42, mask: [fieldparams.NumberOfColumns]bool{false, true, false, true}}
+		actual := summaryCache.cache[root1]
+		require.DeepEqual(t, expected, actual)
+
+		err = summaryCache.set(DataColumnsIdent{Root: root1, Epoch: 42, Indices: []uint64{0, 1}})
+		require.NoError(t, err)
+		require.Equal(t, primitives.Epoch(42), summaryCache.lowestCachedEpoch)
+		require.Equal(t, 1, len(summaryCache.cache))
+		expected = DataColumnStorageSummary{epoch: 42, mask: [fieldparams.NumberOfColumns]bool{true, true, false, true}}
+		actual = summaryCache.cache[root1]
+		require.DeepEqual(t, expected, actual)
+
+		err = summaryCache.set(DataColumnsIdent{Root: root2, Epoch: 43, Indices: []uint64{1}})
+		require.NoError(t, err)
+		require.Equal(t, primitives.Epoch(42), summaryCache.lowestCachedEpoch) // Epoch 42 is still the lowest
+		require.Equal(t, 2, len(summaryCache.cache))
+		expected = DataColumnStorageSummary{epoch: 43, mask: [fieldparams.NumberOfColumns]bool{false, true}}
+		actual = summaryCache.cache[root2]
+		require.DeepEqual(t, expected, actual)
+	})
+}
+
+func TestGet(t *testing.T) {
+	t.Run("Not in cache", func(t *testing.T) {
+		summaryCache := newDataColumnStorageSummaryCache()
+		root := [fieldparams.RootLength]byte{}
+		_, ok := summaryCache.get(root)
+		require.Equal(t, false, ok)
+	})
+
+	t.Run("In cache", func(t *testing.T) {
+		root := [fieldparams.RootLength]byte{}
+		summaryCache := newDataColumnStorageSummaryCache()
+		summaryCache.cache[root] = NewDataColumnStorageSummary(42, [fieldparams.NumberOfColumns]bool{true, false, true, false})
+		actual, ok := summaryCache.get(root)
+		require.Equal(t, true, ok)
+		expected := NewDataColumnStorageSummary(42, [fieldparams.NumberOfColumns]bool{true, false, true, false})
+		require.DeepEqual(t, expected, actual)
+	})
+}
+
+func TestEvict(t *testing.T) {
+	t.Run("No eviction", func(t *testing.T) {
+		root := [fieldparams.RootLength]byte{}
+		summaryCache := newDataColumnStorageSummaryCache()
+
+		evicted := summaryCache.evict(root)
+		require.Equal(t, 0, evicted)
+	})
+
+	t.Run("Eviction", func(t *testing.T) {
+		root1 := [fieldparams.RootLength]byte{1}
+		root2 := [fieldparams.RootLength]byte{2}
+		summaryCache := newDataColumnStorageSummaryCache()
+		summaryCache.cache[root1] = NewDataColumnStorageSummary(42, [fieldparams.NumberOfColumns]bool{true, false, true, false})
+		summaryCache.cache[root2] = NewDataColumnStorageSummary(43, [fieldparams.NumberOfColumns]bool{false, true, false, true})
+
+		evicted := summaryCache.evict(root1)
+		require.Equal(t, 2, evicted)
+		require.Equal(t, 1, len(summaryCache.cache))
+
+		_, ok := summaryCache.cache[root1]
+		require.Equal(t, false, ok)
+
+		_, ok = summaryCache.cache[root2]
+		require.Equal(t, true, ok)
+	})
+}
+
+func TestPruneUpTo(t *testing.T) {
+	t.Run("No pruning", func(t *testing.T) {
+		summaryCache := newDataColumnStorageSummaryCache()
+		err := summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{1}, Epoch: 42, Indices: []uint64{1}})
+		require.NoError(t, err)
+
+		err = summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{2}, Epoch: 43, Indices: []uint64{2, 4}})
+		require.NoError(t, err)
+
+		count := summaryCache.pruneUpTo(41)
+		require.Equal(t, uint64(0), count)
+		require.Equal(t, 2, len(summaryCache.cache))
+		require.Equal(t, primitives.Epoch(42), summaryCache.lowestCachedEpoch)
+	})
+
+	t.Run("Pruning", func(t *testing.T) {
+		summaryCache := newDataColumnStorageSummaryCache()
+		err := summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{1}, Epoch: 42, Indices: []uint64{1}})
+		require.NoError(t, err)
+
+		err = summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{2}, Epoch: 44, Indices: []uint64{2, 4}})
+		require.NoError(t, err)
+
+		err = summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{3}, Epoch: 45, Indices: []uint64{2, 4}})
+		require.NoError(t, err)
+
+		count := summaryCache.pruneUpTo(42)
+		require.Equal(t, uint64(1), count)
+		require.Equal(t, 2, len(summaryCache.cache))
+		require.Equal(t, primitives.Epoch(44), summaryCache.lowestCachedEpoch)
+
+		count = summaryCache.pruneUpTo(45)
+		require.Equal(t, uint64(4), count)
+		require.Equal(t, 0, len(summaryCache.cache))
+		require.Equal(t, params.BeaconConfig().FarFutureEpoch, summaryCache.lowestCachedEpoch)
+		require.Equal(t, primitives.Epoch(0), summaryCache.highestCachedEpoch)
+
+	})
+
+	t.Run("Clear", func(t *testing.T) {
+		summaryCache := newDataColumnStorageSummaryCache()
+		err := summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{1}, Epoch: 42, Indices: []uint64{1}})
+		require.NoError(t, err)
+
+		err = summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{2}, Epoch: 44, Indices: []uint64{2, 4}})
+		require.NoError(t, err)
+
+		err = summaryCache.set(DataColumnsIdent{Root: [fieldparams.RootLength]byte{3}, Epoch: 45, Indices: []uint64{2, 4}})
+		require.NoError(t, err)
+
+		count := summaryCache.clear()
+		require.Equal(t, uint64(5), count)
+		require.Equal(t, 0, len(summaryCache.cache))
+		require.Equal(t, params.BeaconConfig().FarFutureEpoch, summaryCache.lowestCachedEpoch)
+		require.Equal(t, primitives.Epoch(0), summaryCache.highestCachedEpoch)
+	})
+}

beacon-chain/db/filesystem/data_column_test.go

@@ -0,0 +1,762 @@
+package filesystem
+
+import (
+	"context"
+	"encoding/binary"
+	"os"
+	"testing"
+
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"github.com/spf13/afero"
+)
+
+func TestNewDataColumnStorage(t *testing.T) {
+	ctx := context.Background()
+
+	t.Run("No base path", func(t *testing.T) {
+		_, err := NewDataColumnStorage(ctx)
+		require.ErrorIs(t, err, errNoBasePath)
+	})
+
+	t.Run("Nominal", func(t *testing.T) {
+		dir := t.TempDir()
+
+		storage, err := NewDataColumnStorage(ctx, WithDataColumnBasePath(dir))
+		require.NoError(t, err)
+		require.Equal(t, dir, storage.base)
+	})
+}
+
+func TestWarmCache(t *testing.T) {
+	storage, err := NewDataColumnStorage(
+		context.Background(),
+		WithDataColumnBasePath(t.TempDir()),
+		WithDataColumnRetentionEpochs(10_000),
+	)
+	require.NoError(t, err)
+
+	_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+		t,
+		util.DataColumnsParamsByRoot{
+			{0}: {
+				{Slot: 33, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 1
+				{Slot: 33, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 1
+			},
+			{1}: {
+				{Slot: 128_002, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
+				{Slot: 128_002, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
+			},
+			{2}: {
+				{Slot: 128_003, ColumnIndex: 1, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
+				{Slot: 128_003, ColumnIndex: 3, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
+			},
+			{3}: {
+				{Slot: 128_034, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4001
+				{Slot: 128_034, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4001
+			},
+			{4}: {
+				{Slot: 131_138, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
+			},
+			{5}: {
+				{Slot: 131_138, ColumnIndex: 1, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
+			},
+			{6}: {
+				{Slot: 131_168, ColumnIndex: 0, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4099
+			},
+		},
+	)
+
+	err = storage.Save(verifiedRoDataColumnSidecars)
+	require.NoError(t, err)
+
+	storage.retentionEpochs = 4_096
+
+	storage.WarmCache()
+	require.Equal(t, primitives.Epoch(4_000), storage.cache.lowestCachedEpoch)
+	require.Equal(t, 6, len(storage.cache.cache))
+
+	summary, ok := storage.cache.get([fieldparams.RootLength]byte{1})
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_000, mask: [fieldparams.NumberOfColumns]bool{false, false, true, false, true}}, summary)
+
+	summary, ok = storage.cache.get([fieldparams.RootLength]byte{2})
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_000, mask: [fieldparams.NumberOfColumns]bool{false, true, false, true}}, summary)
+
+	summary, ok = storage.cache.get([fieldparams.RootLength]byte{3})
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_001, mask: [fieldparams.NumberOfColumns]bool{false, false, true, false, true}}, summary)
+
+	summary, ok = storage.cache.get([fieldparams.RootLength]byte{4})
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_098, mask: [fieldparams.NumberOfColumns]bool{false, false, true}}, summary)
+
+	summary, ok = storage.cache.get([fieldparams.RootLength]byte{5})
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_098, mask: [fieldparams.NumberOfColumns]bool{false, true}}, summary)
+
+	summary, ok = storage.cache.get([fieldparams.RootLength]byte{6})
+	require.Equal(t, true, ok)
+	require.DeepEqual(t, DataColumnStorageSummary{epoch: 4_099, mask: [fieldparams.NumberOfColumns]bool{true}}, summary)
+}
+
+func TestSaveDataColumnsSidecars(t *testing.T) {
+	t.Run("wrong numbers of columns", func(t *testing.T) {
+		cfg := params.BeaconConfig().Copy()
+		cfg.NumberOfColumns = 0
+		params.OverrideBeaconConfig(cfg)
+		params.SetupTestConfigCleanup(t)
+
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{}: {{ColumnIndex: 12}, {ColumnIndex: 1_000_000}, {ColumnIndex: 48}},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.ErrorIs(t, err, errWrongNumberOfColumns)
+	})
+
+	t.Run("one of the column index is too large", func(t *testing.T) {
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{{}: {{ColumnIndex: 12}, {ColumnIndex: 1_000_000}, {ColumnIndex: 48}}},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.ErrorIs(t, err, errDataColumnIndexTooLarge)
+	})
+
+	t.Run("different slots", func(t *testing.T) {
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{}: {
+					{Slot: 1, ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+					{Slot: 2, ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+				},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.ErrorIs(t, err, errDataColumnSidecarsFromDifferentSlots)
+	})
+
+	t.Run("new file - no data columns to save", func(t *testing.T) {
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{{}: {}},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+	})
+
+	t.Run("new file - different data column size", func(t *testing.T) {
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{}: {
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+					{ColumnIndex: 11, DataColumn: []byte{1, 2, 3, 4}},
+				},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.ErrorIs(t, err, errWrongSszEncodedDataColumnSidecarSize)
+	})
+
+	t.Run("existing file - wrong incoming SSZ encoded size", func(t *testing.T) {
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{{1}: {{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}}},
+		)
+
+		// Save data columns into a file.
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		// Build a data column sidecar for the same block but with a different
+		// column index and an different SSZ encoded size.
+		_, verifiedRoDataColumnSidecars = util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{{1}: {{ColumnIndex: 13, DataColumn: []byte{1, 2, 3, 4}}}},
+		)
+
+		// Try to rewrite the file.
+		err = dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.ErrorIs(t, err, errWrongSszEncodedDataColumnSidecarSize)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		_, inputVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{1}: {
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+					{ColumnIndex: 11, DataColumn: []byte{3, 4, 5}},
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}, // OK if duplicate
+					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
+				},
+				{2}: {
+					{ColumnIndex: 12, DataColumn: []byte{3, 4, 5}},
+					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
+				},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(inputVerifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		_, inputVerifiedRoDataColumnSidecars = util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{1}: {
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}, // OK if duplicate
+					{ColumnIndex: 15, DataColumn: []byte{2, 3, 4}},
+					{ColumnIndex: 1, DataColumn: []byte{2, 3, 4}},
+				},
+				{3}: {
+					{ColumnIndex: 6, DataColumn: []byte{3, 4, 5}},
+					{ColumnIndex: 2, DataColumn: []byte{6, 7, 8}},
+				},
+			},
+		)
+
+		err = dataColumnStorage.Save(inputVerifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		type fixture struct {
+			fileName         string
+			blockRoot        [fieldparams.RootLength]byte
+			expectedIndices  [mandatoryNumberOfColumns]byte
+			dataColumnParams []util.DataColumnParams
+		}
+
+		fixtures := []fixture{
+			{
+				fileName:  "0/0/0x0100000000000000000000000000000000000000000000000000000000000000.sszs",
+				blockRoot: [fieldparams.RootLength]byte{1},
+				expectedIndices: [mandatoryNumberOfColumns]byte{
+					0, nonZeroOffset + 4, 0, 0, 0, 0, 0, 0,
+					0, 0, 0, nonZeroOffset + 1, nonZeroOffset, nonZeroOffset + 2, 0, nonZeroOffset + 3,
+					// The rest is filled with zeroes.
+				},
+				dataColumnParams: []util.DataColumnParams{
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+					{ColumnIndex: 11, DataColumn: []byte{3, 4, 5}},
+					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
+					{ColumnIndex: 15, DataColumn: []byte{2, 3, 4}},
+					{ColumnIndex: 1, DataColumn: []byte{2, 3, 4}},
+				},
+			},
+			{
+				fileName:  "0/0/0x0200000000000000000000000000000000000000000000000000000000000000.sszs",
+				blockRoot: [fieldparams.RootLength]byte{2},
+				expectedIndices: [mandatoryNumberOfColumns]byte{
+					0, 0, 0, 0, 0, 0, 0, 0,
+					0, 0, 0, 0, nonZeroOffset, nonZeroOffset + 1, 0, 0,
+					// The rest is filled with zeroes.
+				},
+				dataColumnParams: []util.DataColumnParams{
+					{ColumnIndex: 12, DataColumn: []byte{3, 4, 5}},
+					{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}},
+				},
+			},
+			{
+				fileName:  "0/0/0x0300000000000000000000000000000000000000000000000000000000000000.sszs",
+				blockRoot: [fieldparams.RootLength]byte{3},
+				expectedIndices: [mandatoryNumberOfColumns]byte{
+					0, 0, nonZeroOffset + 1, 0, 0, 0, nonZeroOffset, 0,
+					// The rest is filled with zeroes.
+				},
+				dataColumnParams: []util.DataColumnParams{
+					{ColumnIndex: 6, DataColumn: []byte{3, 4, 5}},
+					{ColumnIndex: 2, DataColumn: []byte{6, 7, 8}},
+				},
+			},
+		}
+
+		for _, fixture := range fixtures {
+			// Build expected data column sidecars.
+			_, expectedDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+				t,
+				util.DataColumnsParamsByRoot{fixture.blockRoot: fixture.dataColumnParams},
+			)
+
+			// Build expected bytes.
+			firstSszEncodedDataColumnSidecar, err := expectedDataColumnSidecars[0].MarshalSSZ()
+			require.NoError(t, err)
+
+			dataColumnSidecarsCount := len(expectedDataColumnSidecars)
+			sszEncodedDataColumnSidecarSize := len(firstSszEncodedDataColumnSidecar)
+
+			sszEncodedDataColumnSidecars := make([]byte, 0, dataColumnSidecarsCount*sszEncodedDataColumnSidecarSize)
+			sszEncodedDataColumnSidecars = append(sszEncodedDataColumnSidecars, firstSszEncodedDataColumnSidecar...)
+			for _, dataColumnSidecar := range expectedDataColumnSidecars[1:] {
+				sszEncodedDataColumnSidecar, err := dataColumnSidecar.MarshalSSZ()
+				require.NoError(t, err)
+				sszEncodedDataColumnSidecars = append(sszEncodedDataColumnSidecars, sszEncodedDataColumnSidecar...)
+			}
+
+			var encodedSszEncodedDataColumnSidecarSize [sidecarByteLenSize]byte
+			binary.BigEndian.PutUint32(encodedSszEncodedDataColumnSidecarSize[:], uint32(sszEncodedDataColumnSidecarSize))
+
+			expectedBytes := make([]byte, 0, headerSize+dataColumnSidecarsCount*sszEncodedDataColumnSidecarSize)
+			expectedBytes = append(expectedBytes, []byte{0x01}...)
+			expectedBytes = append(expectedBytes, encodedSszEncodedDataColumnSidecarSize[:]...)
+			expectedBytes = append(expectedBytes, fixture.expectedIndices[:]...)
+			expectedBytes = append(expectedBytes, sszEncodedDataColumnSidecars...)
+
+			// Check the actual content of the file.
+			actualBytes, err := afero.ReadFile(dataColumnStorage.fs, fixture.fileName)
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, expectedBytes, actualBytes)
+
+			// Check the summary.
+			indices := map[uint64]bool{}
+			for _, dataColumnParam := range fixture.dataColumnParams {
+				indices[dataColumnParam.ColumnIndex] = true
+			}
+
+			summary := dataColumnStorage.Summary(fixture.blockRoot)
+			for index := range uint64(mandatoryNumberOfColumns) {
+				require.Equal(t, indices[index], summary.HasIndex(index))
+			}
+
+			err = dataColumnStorage.Remove(fixture.blockRoot)
+			require.NoError(t, err)
+
+			summary = dataColumnStorage.Summary(fixture.blockRoot)
+			for index := range uint64(mandatoryNumberOfColumns) {
+				require.Equal(t, false, summary.HasIndex(index))
+			}
+
+			_, err = afero.ReadFile(dataColumnStorage.fs, fixture.fileName)
+			require.ErrorIs(t, err, os.ErrNotExist)
+		}
+	})
+}
+
+func TestGetDataColumnSidecars(t *testing.T) {
+	t.Run("root not found", func(t *testing.T) {
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+
+		verifiedRODataColumnSidecars, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, []uint64{12, 13, 14})
+		require.NoError(t, err)
+		require.Equal(t, 0, len(verifiedRODataColumnSidecars))
+	})
+
+	t.Run("indices not found", func(t *testing.T) {
+		_, savedVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{1}: {
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+					{ColumnIndex: 14, DataColumn: []byte{2, 3, 4}},
+				},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(savedVerifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		verifiedRODataColumnSidecars, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, []uint64{3, 1, 2})
+		require.NoError(t, err)
+		require.Equal(t, 0, len(verifiedRODataColumnSidecars))
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		_, expectedVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{1}: {
+					{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}},
+					{ColumnIndex: 14, DataColumn: []byte{2, 3, 4}},
+				},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(expectedVerifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		verifiedRODataColumnSidecars, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, nil)
+		require.NoError(t, err)
+		require.DeepSSZEqual(t, expectedVerifiedRoDataColumnSidecars, verifiedRODataColumnSidecars)
+
+		verifiedRODataColumnSidecars, err = dataColumnStorage.Get([fieldparams.RootLength]byte{1}, []uint64{12, 13, 14})
+		require.NoError(t, err)
+		require.DeepSSZEqual(t, expectedVerifiedRoDataColumnSidecars, verifiedRODataColumnSidecars)
+	})
+}
+
+func TestRemove(t *testing.T) {
+	t.Run("not found", func(t *testing.T) {
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Remove([fieldparams.RootLength]byte{1})
+		require.NoError(t, err)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		_, inputVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{1}: {
+					{Slot: 32, ColumnIndex: 10, DataColumn: []byte{1, 2, 3}},
+					{Slot: 32, ColumnIndex: 11, DataColumn: []byte{2, 3, 4}},
+				},
+				{2}: {
+					{Slot: 33, ColumnIndex: 10, DataColumn: []byte{1, 2, 3}},
+					{Slot: 33, ColumnIndex: 11, DataColumn: []byte{2, 3, 4}},
+				},
+			},
+		)
+
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(inputVerifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		err = dataColumnStorage.Remove([fieldparams.RootLength]byte{1})
+		require.NoError(t, err)
+
+		summary := dataColumnStorage.Summary([fieldparams.RootLength]byte{1})
+		require.Equal(t, primitives.Epoch(0), summary.epoch)
+		require.Equal(t, uint64(0), summary.Count())
+
+		summary = dataColumnStorage.Summary([fieldparams.RootLength]byte{2})
+		require.Equal(t, primitives.Epoch(1), summary.epoch)
+		require.Equal(t, uint64(2), summary.Count())
+
+		actual, err := dataColumnStorage.Get([fieldparams.RootLength]byte{1}, nil)
+		require.NoError(t, err)
+		require.Equal(t, 0, len(actual))
+
+		actual, err = dataColumnStorage.Get([fieldparams.RootLength]byte{2}, nil)
+		require.NoError(t, err)
+		require.Equal(t, 2, len(actual))
+	})
+}
+
+func TestClear(t *testing.T) {
+	_, inputVerifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+		t,
+		util.DataColumnsParamsByRoot{
+			{1}: {{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}},
+			{2}: {{ColumnIndex: 13, DataColumn: []byte{6, 7, 8}}},
+		},
+	)
+
+	_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+	err := dataColumnStorage.Save(inputVerifiedRoDataColumnSidecars)
+	require.NoError(t, err)
+
+	filePaths := []string{
+		"0/0/0x0100000000000000000000000000000000000000000000000000000000000000.sszs",
+		"0/0/0x0200000000000000000000000000000000000000000000000000000000000000.sszs",
+	}
+
+	for _, filePath := range filePaths {
+		_, err = afero.ReadFile(dataColumnStorage.fs, filePath)
+		require.NoError(t, err)
+	}
+
+	err = dataColumnStorage.Clear()
+	require.NoError(t, err)
+
+	summary := dataColumnStorage.Summary([fieldparams.RootLength]byte{1})
+	for index := range uint64(mandatoryNumberOfColumns) {
+		require.Equal(t, false, summary.HasIndex(index))
+	}
+
+	for _, filePath := range filePaths {
+		_, err = afero.ReadFile(dataColumnStorage.fs, filePath)
+		require.ErrorIs(t, err, os.ErrNotExist)
+	}
+}
+
+func TestMetadata(t *testing.T) {
+	t.Run("wrong version", func(t *testing.T) {
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{1}: {{ColumnIndex: 12, DataColumn: []byte{1, 2, 3}}},
+			},
+		)
+
+		// Save data columns into a file.
+		_, dataColumnStorage := NewEphemeralDataColumnStorageAndFs(t)
+		err := dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		// Alter the version.
+		const filePath = "0/0/0x0100000000000000000000000000000000000000000000000000000000000000.sszs"
+		file, err := dataColumnStorage.fs.OpenFile(filePath, os.O_WRONLY, os.FileMode(0600))
+		require.NoError(t, err)
+
+		count, err := file.Write([]byte{42})
+		require.NoError(t, err)
+		require.Equal(t, 1, count)
+
+		// Try to read the metadata.
+		_, err = dataColumnStorage.metadata(file)
+		require.ErrorIs(t, err, errWrongVersion)
+
+		err = file.Close()
+		require.NoError(t, err)
+	})
+}
+
+func TestNewStorageIndices(t *testing.T) {
+	t.Run("wrong number of columns", func(t *testing.T) {
+		_, err := newStorageIndices(nil)
+		require.ErrorIs(t, err, errWrongNumberOfColumns)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		var indices [mandatoryNumberOfColumns]byte
+		indices[0] = 1
+
+		storageIndices, err := newStorageIndices(indices[:])
+		require.NoError(t, err)
+		require.Equal(t, indices, storageIndices.indices)
+	})
+}
+
+func TestStorageIndicesGet(t *testing.T) {
+	t.Run("index too large", func(t *testing.T) {
+		var indices storageIndices
+		_, _, err := indices.get(1_000_000)
+		require.ErrorIs(t, errDataColumnIndexTooLarge, err)
+	})
+
+	t.Run("index not set", func(t *testing.T) {
+		const expected = false
+		var indices storageIndices
+		actual, _, err := indices.get(0)
+		require.NoError(t, err)
+		require.Equal(t, expected, actual)
+	})
+
+	t.Run("index set", func(t *testing.T) {
+		const (
+			expectedOk       = true
+			expectedPosition = int64(3)
+		)
+
+		indices := storageIndices{indices: [mandatoryNumberOfColumns]byte{0, 131}}
+		actualOk, actualPosition, err := indices.get(1)
+		require.NoError(t, err)
+		require.Equal(t, expectedOk, actualOk)
+		require.Equal(t, expectedPosition, actualPosition)
+	})
+}
+
+func TestStorageIndicesLen(t *testing.T) {
+	const expected = int64(2)
+	indices := storageIndices{count: 2}
+	actual := indices.len()
+	require.Equal(t, expected, actual)
+}
+
+func TestStorageIndicesAll(t *testing.T) {
+	expectedIndices := []uint64{1, 3}
+	indices := storageIndices{indices: [mandatoryNumberOfColumns]byte{0, 131, 0, 128}}
+	actualIndices := indices.all()
+	require.DeepEqual(t, expectedIndices, actualIndices)
+}
+
+func TestStorageIndicesSet(t *testing.T) {
+	t.Run("data column index too large", func(t *testing.T) {
+		var indices storageIndices
+		err := indices.set(1_000_000, 0)
+		require.ErrorIs(t, errDataColumnIndexTooLarge, err)
+	})
+
+	t.Run("position too large", func(t *testing.T) {
+		var indices storageIndices
+		err := indices.set(0, 255)
+		require.ErrorIs(t, errDataColumnIndexTooLarge, err)
+	})
+
+	t.Run("nominal", func(t *testing.T) {
+		expected := [mandatoryNumberOfColumns]byte{0, 0, 128, 0, 131}
+		var storageIndices storageIndices
+		require.Equal(t, int64(0), storageIndices.len())
+
+		err := storageIndices.set(2, 1)
+		require.NoError(t, err)
+		require.Equal(t, int64(1), storageIndices.len())
+
+		err = storageIndices.set(4, 3)
+		require.NoError(t, err)
+		require.Equal(t, int64(2), storageIndices.len())
+
+		err = storageIndices.set(2, 0)
+		require.NoError(t, err)
+		require.Equal(t, int64(2), storageIndices.len())
+
+		actual := storageIndices.indices
+		require.Equal(t, expected, actual)
+	})
+}
+
+func TestPrune(t *testing.T) {
+	t.Run(("nothing to prune"), func(t *testing.T) {
+		dir := t.TempDir()
+		dataColumnStorage, err := NewDataColumnStorage(context.Background(), WithDataColumnBasePath(dir))
+		require.NoError(t, err)
+
+		dataColumnStorage.prune()
+	})
+	t.Run("nominal", func(t *testing.T) {
+		var compareSlices = func(left, right []string) bool {
+			if len(left) != len(right) {
+				return false
+			}
+
+			leftMap := make(map[string]bool, len(left))
+			for _, leftItem := range left {
+				leftMap[leftItem] = true
+			}
+
+			for _, rightItem := range right {
+				if _, ok := leftMap[rightItem]; !ok {
+					return false
+				}
+			}
+
+			return true
+		}
+		_, verifiedRoDataColumnSidecars := util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{0}: {
+					{Slot: 33, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 1
+					{Slot: 33, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 1
+				},
+				{1}: {
+					{Slot: 128_002, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
+					{Slot: 128_002, ColumnIndex: 4, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
+				},
+				{2}: {
+					{Slot: 128_003, ColumnIndex: 1, DataColumn: []byte{1, 2, 3}}, // Period 0 - Epoch 4000
+					{Slot: 128_003, ColumnIndex: 3, DataColumn: []byte{2, 3, 4}}, // Period 0 - Epoch 4000
+				},
+				{3}: {
+					{Slot: 131_138, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
+					{Slot: 131_138, ColumnIndex: 3, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4098
+				},
+				{4}: {
+					{Slot: 131_169, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4099
+					{Slot: 131_169, ColumnIndex: 3, DataColumn: []byte{1, 2, 3}}, // Period 1 - Epoch 4099
+				},
+				{5}: {
+					{Slot: 262_144, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}, // Period 2 - Epoch 8192
+					{Slot: 262_144, ColumnIndex: 3, DataColumn: []byte{1, 2, 3}}, // Period 2 - Epoch 8292
+				},
+			},
+		)
+
+		dir := t.TempDir()
+		dataColumnStorage, err := NewDataColumnStorage(context.Background(), WithDataColumnBasePath(dir), WithDataColumnRetentionEpochs(10_000))
+		require.NoError(t, err)
+
+		err = dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		dirs, err := listDir(dataColumnStorage.fs, ".")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0", "1", "2"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "0")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"1", "4000"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "1")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"4099", "4098"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "2")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"8192"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "0/1")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0000000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "0/4000")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{
+			"0x0200000000000000000000000000000000000000000000000000000000000000.sszs",
+			"0x0100000000000000000000000000000000000000000000000000000000000000.sszs",
+		}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "1/4098")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0300000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "1/4099")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0400000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "2/8192")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0500000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+
+		_, verifiedRoDataColumnSidecars = util.CreateTestVerifiedRoDataColumnSidecars(
+			t,
+			util.DataColumnsParamsByRoot{
+				{6}: {{Slot: 451_141, ColumnIndex: 2, DataColumn: []byte{1, 2, 3}}}, // Period 3 - Epoch 14_098
+			},
+		)
+
+		err = dataColumnStorage.Save(verifiedRoDataColumnSidecars)
+		require.NoError(t, err)
+
+		// dataColumnStorage.prune(14_098)
+		dataColumnStorage.prune()
+
+		dirs, err = listDir(dataColumnStorage.fs, ".")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"1", "2", "3"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "1")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"4099"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "2")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"8192"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "3")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"14098"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "1/4099")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0400000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "2/8192")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0500000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+
+		dirs, err = listDir(dataColumnStorage.fs, "3/14098")
+		require.NoError(t, err)
+		require.Equal(t, true, compareSlices([]string{"0x0600000000000000000000000000000000000000000000000000000000000000.sszs"}, dirs))
+	})
+}

beacon-chain/db/filesystem/doc.go

@@ -0,0 +1,104 @@
+package filesystem
+
+// nolint:dupword
+/*
+Data column sidecars storage documentation
+==========================================
+
+File organisation
+-----------------
+- The first byte represents the version of the file structure (up to 0xff = 255).
+  We set it to 0x01.
+  Note: This is not strictly needed, but it will help a lot if, in the future,
+        we want to modify the file structure.
+- The next 4 bytes represents the size of a SSZ encoded data column sidecar.
+  (See the `Computation of the maximum size of a DataColumnSidecar` section to a description
+  of how this value is computed).
+- The next 128 bytes represent the index in the file of a given column.
+  The first bit of each byte in the index is set to 0 if there is no data column,
+  and set to 1 if there is a data column.
+  The remaining 7 bits (from 0 to 127) represent the index of the data column.
+  This sentinel bit is needed to distinguish between the column with index 0 and no column.
+  Example: If the column with index 5 is in the 3th position in the file, then indices[5] = 0x80 + 0x03 = 0x83.
+- The rest of the file is a repeat of the SSZ encoded data columns sidecars.
+
+
+|------------------------------------------|------------------------------------------------------------------------------------|
+|                Byte offset               |                                     Description                                    |
+|------------------------------------------|------------------------------------------------------------------------------------|
+|                                        0 | version (1 byte) | sszEncodedDataColumnSidecarSize (4 bytes) | indices (128 bytes) |
+|133 +   0*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|133 +   1*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|133 +   2*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|                  ...                     |                                 ...                                                |
+|133 + 127*sszEncodedDataColumnSidecarSize | sszEncodedDataColumnSidecar (sszEncodedDataColumnSidecarSize bytes)                |
+|------------------------------------------|------------------------------------------------------------------------------------|
+
+Each file is named after the block root where the data columns were data columns are committed to.
+Example: `0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs`
+
+Database organisation
+---------------------
+SSZ encoded data column sidecars are stored following the `by-epoch` layout.
+- The first layer is a directory corresponding to the `period`, which corresponds to the epoch divided by the 4096.
+- The second layer is a directory corresponding to the epoch.
+- Then all files are stored in the epoch directory.
+
+Example:
+data-columns
+├── 0
+│   ├── 3638
+│   │   ├── 0x259c6d2f6a0bb75e2405cea7cb248e5663dc26b9404fd3bcd777afc20de91c1e.sszs
+│   │   ├── 0x2a855b1f6e9a2f04f8383e336325bf7d5ba02d1eab3ef90ef183736f8c768533.sszs
+│   │   ├── ...
+│   │   ├── 0xeb78e2b2350a71c640f1e96fea9e42f38e65705ab7e6e100c8bc9c589f2c5f2b.sszs
+│   │   └── 0xeb7ee68da988fd20d773d45aad01dd62527734367a146e2b048715bd68a4e370.sszs
+│   └── 3639
+│       ├── 0x0fd231fe95e57936fa44f6c712c490b9e337a481b661dfd46768901e90444330.sszs
+│       ├── 0x1bf5edff6b6ba2b65b1db325ff3312bbb57da461ef2ae651bd741af851aada3a.sszs
+│       ├── ...
+│       ├── 0xa156a527e631f858fee79fab7ef1fde3f6117a2e1201d47c09fbab0c6780c937.sszs
+│       └── 0xcd80bc535ddc467dea1d19e0c39c1160875ccd1989061bcd8ce206e3c1261c87.sszs
+└── 1
+    ├── 4096
+    │   ├── 0x0d244009093e2bedb72eb265280290199e8c7bf1d90d7583c41af40d9f662269.sszs
+    │   ├── 0x11f420928d8de41c50e735caab0369996824a5299c5f054e097965855925697d.sszs
+    │   ├── ...
+    │   ├── 0xbe91fc782877ed400d95c02c61aebfdd592635d11f8e64c94b46abd84f45c967.sszs
+    │   └── 0xf246189f078f02d30173ff74605cf31c9e65b5e463275ebdbeb40476638135ff.sszs
+    └── 4097
+        ├── 0x454d000674793c479e90504c0fe9827b50bb176ae022dab4e37d6a21471ab570.sszs
+        ├── 0xac5eb7437d7190c48cfa863e3c45f96a7f8af371d47ac12ccda07129a06af763.sszs
+        ├── ...
+        ├── 0xb7df30561d9d92ab5fafdd96bca8b44526497c8debf0fc425c7a0770b2abeb83.sszs
+        └── 0xc1dd0b1ae847b6ec62303a36d08c6a4a2e9e3ec4be3ff70551972a0ee3de9c14.sszs
+
+Computation of the maximum size of a DataColumnSidecar
+------------------------------------------------------
+https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/das-core.md#datacolumnsidecar
+
+
+class DataColumnSidecar(Container):
+    index: ColumnIndex  # Index of column in extended matrix
+    column: List[Cell, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    kzg_commitments: List[KZGCommitment, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    kzg_proofs: List[KZGProof, MAX_BLOB_COMMITMENTS_PER_BLOCK]
+    signed_block_header: SignedBeaconBlockHeader
+    kzg_commitments_inclusion_proof: Vector[Bytes32, KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH]
+
+
+- index: 2 bytes (ColumnIndex)
+- `column`: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 64 (FIELD_ELEMENTS_PER_CELL) * 32 bytes (BYTES_PER_FIELD_ELEMENT) = 8,388,608 bytes
+- kzg_commitments: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 48 bytes (KZGCommitment) = 196,608 bytes
+- kzg_proofs: 4,096 (MAX_BLOB_COMMITMENTS_PER_BLOCK) * 48 bytes (KZGProof) = 196,608 bytes
+- signed_block_header: 2 bytes (Slot) + 2 bytes (ValidatorIndex) + 3 * 2 bytes (Root) + 96 bytes (BLSSignature) = 106 bytes
+- kzg_commitments_inclusion_proof: 4 (KZG_COMMITMENTS_INCLUSION_PROOF_DEPTH) * 32 bytes = 128 bytes
+
+TOTAL: 8,782,060 bytes = 70,256,480 bits
+log(70,256,480) / log(2) ~= 26.07
+
+==> 32 bits (4 bytes) are enough to store the maximum size of a data column sidecar.
+
+The maximum size of an SSZ encoded data column can be 2**32 bits = 536,879,912 bytes,
+which left a room of 536,879,912 bytes - 8,782,060 bytes ~= 503 mega bytes to store the extra data needed by SSZ encoding (which is more than enough.)
+*/

beacon-chain/db/filesystem/metrics.go

@@ -6,6 +6,7 @@ import (
 )
 
 var (
+	// Blobs
 	blobBuckets     = []float64{3, 5, 7, 9, 11, 13}
 	blobSaveLatency = promauto.NewHistogram(prometheus.HistogramOpts{
 		Name:    "blob_storage_save_latency",
@@ -33,4 +34,29 @@ var (
 		Name: "blob_disk_bytes",
 		Help: "Approximate number of bytes occupied by blobs in storage",
 	})
+
+	// Data columns
+	dataColumnBuckets     = []float64{3, 5, 7, 9, 11, 13}
+	dataColumnSaveLatency = promauto.NewHistogram(prometheus.HistogramOpts{
+		Name:    "data_column_storage_save_latency",
+		Help:    "Latency of DataColumnSidecar storage save operations in milliseconds",
+		Buckets: dataColumnBuckets,
+	})
+	dataColumnFetchLatency = promauto.NewHistogram(prometheus.HistogramOpts{
+		Name:    "data_column_storage_get_latency",
+		Help:    "Latency of DataColumnSidecar storage get operations in milliseconds",
+		Buckets: dataColumnBuckets,
+	})
+	dataColumnPrunedCounter = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "data_column_pruned",
+		Help: "Number of DataColumnSidecar pruned.",
+	})
+	dataColumnWrittenCounter = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "data_column_written",
+		Help: "Number of DataColumnSidecar written",
+	})
+	dataColumnDiskCount = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "data_column_disk_count",
+		Help: "Approximate number of data columns in storage",
+	})
 )

beacon-chain/db/filesystem/mock.go

@@ -1,14 +1,20 @@
 package filesystem
 
 import (
+	"context"
 	"testing"
 
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
+	"github.com/pkg/errors"
 	"github.com/spf13/afero"
 )
 
+// Blobs
+// -----
+
 // NewEphemeralBlobStorage should only be used for tests.
 // The instance of BlobStorage returned is backed by an in-memory virtual filesystem,
 // improving test performance and simplifying cleanup.
@@ -41,14 +47,21 @@ func NewWarmedEphemeralBlobStorageUsingFs(t testing.TB, fs afero.Fs, opts ...Blo
 	return bs
 }
 
-type BlobMocker struct {
-	fs afero.Fs
-	bs *BlobStorage
-}
+type (
+	BlobMocker struct {
+		fs afero.Fs
+		bs *BlobStorage
+	}
+
+	DataColumnMocker struct {
+		fs  afero.Fs
+		dcs *DataColumnStorage
+	}
+)
 
 // CreateFakeIndices creates empty blob sidecar files at the expected path for the given
 // root and indices to influence the result of Indices().
-func (bm *BlobMocker) CreateFakeIndices(root [32]byte, slot primitives.Slot, indices ...uint64) error {
+func (bm *BlobMocker) CreateFakeIndices(root [fieldparams.RootLength]byte, slot primitives.Slot, indices ...uint64) error {
 	for i := range indices {
 		if err := bm.bs.layout.notify(newBlobIdent(root, slots.ToEpoch(slot), indices[i])); err != nil {
 			return err
@@ -57,6 +70,17 @@ func (bm *BlobMocker) CreateFakeIndices(root [32]byte, slot primitives.Slot, ind
 	return nil
 }
 
+// CreateFakeIndices creates empty blob sidecar files at the expected path for the given
+// root and indices to influence the result of Indices().
+func (bm *DataColumnMocker) CreateFakeIndices(root [fieldparams.RootLength]byte, slot primitives.Slot, indices ...uint64) error {
+	err := bm.dcs.cache.set(DataColumnsIdent{Root: root, Epoch: slots.ToEpoch(slot), Indices: indices})
+	if err != nil {
+		return errors.Wrap(err, "cache set")
+	}
+
+	return nil
+}
+
 // NewEphemeralBlobStorageWithMocker returns a *BlobMocker value in addition to the BlobStorage value.
 // BlockMocker encapsulates things blob path construction to avoid leaking implementation details.
 func NewEphemeralBlobStorageWithMocker(t testing.TB) (*BlobMocker, *BlobStorage) {
@@ -75,3 +99,59 @@ func NewMockBlobStorageSummarizer(t *testing.T, set map[[32]byte][]int) BlobStor
 	}
 	return c
 }
+
+// Data columns
+// ------------
+
+// NewEphemeralDataColumnStorage should only be used for tests.
+// The instance of DataColumnStorage returned is backed by an in-memory virtual filesystem,
+// improving test performance and simplifying cleanup.
+func NewEphemeralDataColumnStorage(t testing.TB, opts ...DataColumnStorageOption) *DataColumnStorage {
+	return NewWarmedEphemeralDataColumnStorageUsingFs(t, afero.NewMemMapFs(), opts...)
+}
+
+// NewEphemeralDataColumnStorageAndFs can be used by tests that want access to the virtual filesystem
+// in order to interact with it outside the parameters of the DataColumnStorage API.
+func NewEphemeralDataColumnStorageAndFs(t testing.TB, opts ...DataColumnStorageOption) (afero.Fs, *DataColumnStorage) {
+	fs := afero.NewMemMapFs()
+	dcs := NewWarmedEphemeralDataColumnStorageUsingFs(t, fs, opts...)
+	return fs, dcs
+}
+
+func NewWarmedEphemeralDataColumnStorageUsingFs(t testing.TB, fs afero.Fs, opts ...DataColumnStorageOption) *DataColumnStorage {
+	bs := NewEphemeralDataColumnStorageUsingFs(t, fs, opts...)
+	bs.WarmCache()
+	return bs
+}
+
+func NewEphemeralDataColumnStorageUsingFs(t testing.TB, fs afero.Fs, opts ...DataColumnStorageOption) *DataColumnStorage {
+	opts = append(opts,
+		WithDataColumnRetentionEpochs(params.BeaconConfig().MinEpochsForBlobsSidecarsRequest),
+		WithDataColumnFs(fs),
+	)
+
+	bs, err := NewDataColumnStorage(context.Background(), opts...)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	return bs
+}
+
+// NewEphemeralDataColumnStorageWithMocker returns a *BlobMocker value in addition to the BlobStorage value.
+// BlockMocker encapsulates things blob path construction to avoid leaking implementation details.
+func NewEphemeralDataColumnStorageWithMocker(t testing.TB) (*DataColumnMocker, *DataColumnStorage) {
+	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/kv/error.go

@@ -16,9 +16,6 @@ var ErrNotFoundOriginBlockRoot = errors.Wrap(ErrNotFound, "OriginBlockRoot")
 // ErrNotFoundGenesisBlockRoot means no genesis block root was found, indicating the db was not initialized with genesis
 var ErrNotFoundGenesisBlockRoot = errors.Wrap(ErrNotFound, "OriginGenesisRoot")
 
-// ErrNotFoundBackfillBlockRoot is an error specifically for the origin block root getter
-var ErrNotFoundBackfillBlockRoot = errors.Wrap(ErrNotFound, "BackfillBlockRoot")
-
 // ErrNotFoundFeeRecipient is a not found error specifically for the fee recipient getter
 var ErrNotFoundFeeRecipient = errors.Wrap(ErrNotFound, "fee recipient")
 

beacon-chain/execution/log_processing_test.go

@@ -479,6 +479,93 @@ func TestProcessETH2GenesisLog_CorrectNumOfDeposits(t *testing.T) {
 	hook.Reset()
 }
 
+func TestProcessLogs_DepositRequestsStarted(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	hook := logTest.NewGlobal()
+	testAcc, err := mock.Setup()
+	require.NoError(t, err, "Unable to set up simulated backend")
+	kvStore := testDB.SetupDB(t)
+	depositCache, err := depositsnapshot.New()
+	require.NoError(t, err)
+	server, endpoint, err := mockExecution.SetupRPCServer()
+	require.NoError(t, err)
+	t.Cleanup(func() {
+		server.Stop()
+	})
+
+	web3Service, err := NewService(context.Background(),
+		WithHttpEndpoint(endpoint),
+		WithDepositContractAddress(testAcc.ContractAddr),
+		WithDatabase(kvStore),
+		WithDepositCache(depositCache),
+	)
+	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
+	web3Service = setDefaultMocks(web3Service)
+	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend.Client())
+	require.NoError(t, err)
+	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
+	web3Service.httpLogger = testAcc.Backend.Client()
+	web3Service.latestEth1Data.LastRequestedBlock = 0
+	block, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = block.NumberU64()
+	web3Service.latestEth1Data.BlockTime = block.Time()
+	bConfig := params.MinimalSpecConfig().Copy()
+	bConfig.MinGenesisTime = 0
+	bConfig.SecondsPerETH1Block = 1
+	params.OverrideBeaconConfig(bConfig)
+	nConfig := params.BeaconNetworkConfig()
+	nConfig.ContractDeploymentBlock = 0
+	params.OverrideBeaconNetworkConfig(nConfig)
+
+	testAcc.Backend.Commit()
+
+	totalNumOfDeposits := depositsReqForChainStart + 30
+
+	deposits, _, err := util.DeterministicDepositsAndKeys(uint64(totalNumOfDeposits))
+	require.NoError(t, err)
+	_, depositRoots, err := util.DeterministicDepositTrie(len(deposits))
+	require.NoError(t, err)
+	depositOffset := 5
+
+	// 64 Validators are used as size required for beacon-chain to start. This number
+	// is defined in the deposit contract as the number required for the testnet. The actual number
+	// is 2**14
+	for i := 0; i < totalNumOfDeposits; i++ {
+		data := deposits[i].Data
+		testAcc.TxOpts.Value = mock.Amount32Eth()
+		testAcc.TxOpts.GasLimit = 1000000
+		_, err = testAcc.Contract.Deposit(testAcc.TxOpts, data.PublicKey, data.WithdrawalCredentials, data.Signature, depositRoots[i])
+		require.NoError(t, err, "Could not deposit to deposit contract")
+		// pack 8 deposits into a block with an offset of
+		// 5
+		if (i+1)%8 == depositOffset {
+			testAcc.Backend.Commit()
+		}
+	}
+	// Forward the chain to account for the follow distance
+	for i := uint64(0); i < params.BeaconConfig().Eth1FollowDistance; i++ {
+		testAcc.Backend.Commit()
+	}
+	b, err := testAcc.Backend.Client().BlockByNumber(context.Background(), nil)
+	require.NoError(t, err)
+	web3Service.latestEth1Data.BlockHeight = b.NumberU64()
+	web3Service.latestEth1Data.BlockTime = b.Time()
+
+	// Set up our subscriber now to listen for the chain started event.
+	stateChannel := make(chan *feed.Event, 1)
+	stateSub := web3Service.cfg.stateNotifier.StateFeed().Subscribe(stateChannel)
+	defer stateSub.Unsubscribe()
+
+	web3Service.depositRequestsStarted = true
+	web3Service.initPOWService()
+	require.NoError(t, err)
+
+	require.Equal(t, int64(-1), web3Service.lastReceivedMerkleIndex, "Processed deposit logs even when requests are active")
+
+	hook.Reset()
+}
+
 func TestProcessETH2GenesisLog_LargePeriodOfNoLogs(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	hook := logTest.NewGlobal()

beacon-chain/execution/service.go

@@ -16,6 +16,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache/depositsnapshot"
 	statefeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/state"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution/types"
@@ -141,6 +142,7 @@ type config struct {
 type Service struct {
 	connectedETH1           bool
 	isRunning               bool
+	depositRequestsStarted  bool
 	processingLock          sync.RWMutex
 	latestEth1DataLock      sync.RWMutex
 	cfg                     *config
@@ -205,7 +207,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 			return nil, err
 		}
 	}
-
+	s.initDepositRequests()
 	eth1Data, err := s.validPowchainData(ctx)
 	if err != nil {
 		return nil, errors.Wrap(err, "unable to validate powchain data")
@@ -463,7 +465,9 @@ func safelyHandlePanic() {
 func (s *Service) handleETH1FollowDistance() {
 	defer safelyHandlePanic()
 	ctx := s.ctx
-
+	if s.depositRequestsStarted {
+		return
+	}
 	// use a 5 minutes timeout for block time, because the max mining time is 278 sec (block 7208027)
 	// (analyzed the time of the block from 2018-09-01 to 2019-02-13)
 	fiveMinutesTimeout := prysmTime.Now().Add(-5 * time.Minute)
@@ -530,25 +534,27 @@ func (s *Service) initPOWService() {
 			s.latestEth1Data.BlockTime = header.Time
 			s.latestEth1DataLock.Unlock()
 
-			if err := s.processPastLogs(ctx); err != nil {
-				err = errors.Wrap(err, "processPastLogs")
-				s.retryExecutionClientConnection(ctx, err)
-				errorLogger(
-					err,
-					"Unable to process past deposit contract logs, perhaps your execution client is not fully synced",
-				)
-				continue
-			}
-			// Cache eth1 headers from our voting period.
-			if err := s.cacheHeadersForEth1DataVote(ctx); err != nil {
-				err = errors.Wrap(err, "cacheHeadersForEth1DataVote")
-				s.retryExecutionClientConnection(ctx, err)
-				if errors.Is(err, errBlockTimeTooLate) {
-					log.WithError(err).Debug("Unable to cache headers for execution client votes")
-				} else {
-					errorLogger(err, "Unable to cache headers for execution client votes")
+			if !s.depositRequestsStarted {
+				if err := s.processPastLogs(ctx); err != nil {
+					err = errors.Wrap(err, "processPastLogs")
+					s.retryExecutionClientConnection(ctx, err)
+					errorLogger(
+						err,
+						"Unable to process past deposit contract logs, perhaps your execution client is not fully synced",
+					)
+					continue
+				}
+				// Cache eth1 headers from our voting period.
+				if err := s.cacheHeadersForEth1DataVote(ctx); err != nil {
+					err = errors.Wrap(err, "cacheHeadersForEth1DataVote")
+					s.retryExecutionClientConnection(ctx, err)
+					if errors.Is(err, errBlockTimeTooLate) {
+						log.WithError(err).Debug("Unable to cache headers for execution client votes")
+					} else {
+						errorLogger(err, "Unable to cache headers for execution client votes")
+					}
+					continue
 				}
-				continue
 			}
 			// Handle edge case with embedded genesis state by fetching genesis header to determine
 			// its height.
@@ -824,7 +830,7 @@ func (s *Service) validPowchainData(ctx context.Context) (*ethpb.ETH1ChainData,
 	if genState == nil || genState.IsNil() {
 		return eth1Data, nil
 	}
-	if eth1Data == nil || !eth1Data.ChainstartData.Chainstarted || !validateDepositContainers(eth1Data.DepositContainers) {
+	if s.depositRequestsStarted || eth1Data == nil || !eth1Data.ChainstartData.Chainstarted || !validateDepositContainers(eth1Data.DepositContainers) {
 		pbState, err := native.ProtobufBeaconStatePhase0(s.preGenesisState.ToProtoUnsafe())
 		if err != nil {
 			return nil, err
@@ -900,6 +906,15 @@ func (s *Service) removeStartupState() {
 	s.cfg.finalizedStateAtStartup = nil
 }
 
+func (s *Service) initDepositRequests() {
+	fState := s.cfg.finalizedStateAtStartup
+	isNil := fState == nil || fState.IsNil()
+	if isNil {
+		return
+	}
+	s.depositRequestsStarted = helpers.DepositRequestsStarted(fState)
+}
+
 func newBlobVerifierFromInitializer(ini *verification.Initializer) verification.NewBlobVerifier {
 	return func(b blocks.ROBlob, reqs []verification.Requirement) verification.BlobVerifier {
 		return ini.NewBlobVerifier(b, reqs)

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

@@ -267,7 +267,7 @@ func (f *ForkChoice) HighestReceivedBlockSlot() primitives.Slot {
 	return f.store.highestReceivedNode.slot
 }
 
-// HighestReceivedBlockSlotDelay returns the number of slots that the highest
+// HighestReceivedBlockDelay returns the number of slots that the highest
 // received block was late when receiving it
 func (f *ForkChoice) HighestReceivedBlockDelay() primitives.Slot {
 	n := f.store.highestReceivedNode

beacon-chain/p2p/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
         "broadcaster.go",
         "config.go",
         "connection_gater.go",
+        "custody.go",
         "dial_relay_node.go",
         "discovery.go",
         "doc.go",
@@ -45,6 +46,7 @@ go_library(
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
@@ -55,6 +57,7 @@ go_library(
         "//beacon-chain/startup: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",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
@@ -117,6 +120,7 @@ go_test(
         "addr_factory_test.go",
         "broadcaster_test.go",
         "connection_gater_test.go",
+        "custody_test.go",
         "dial_relay_node_test.go",
         "discovery_test.go",
         "fork_test.go",
@@ -138,10 +142,12 @@ go_test(
     flaky = True,
     tags = ["requires-network"],
     deps = [
+        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
         "//beacon-chain/core/light-client:go_default_library",
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
@@ -165,6 +171,7 @@ go_test(
         "//network/forks:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//proto/prysm/v1alpha1/metadata:go_default_library",
         "//proto/testing:go_default_library",
         "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",

beacon-chain/p2p/broadcaster.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/altair"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	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/crypto/hash"
@@ -98,7 +99,7 @@ func (s *Service) BroadcastSyncCommitteeMessage(ctx context.Context, subnet uint
 	return nil
 }
 
-func (s *Service) internalBroadcastAttestation(ctx context.Context, subnet uint64, att ethpb.Att, forkDigest [4]byte) {
+func (s *Service) internalBroadcastAttestation(ctx context.Context, subnet uint64, att ethpb.Att, forkDigest [fieldparams.VersionLength]byte) {
 	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastAttestation")
 	defer span.End()
 	ctx = trace.NewContext(context.Background(), span) // clear parent context / deadline.
@@ -154,7 +155,7 @@ func (s *Service) internalBroadcastAttestation(ctx context.Context, subnet uint6
 	}
 }
 
-func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMsg *ethpb.SyncCommitteeMessage, forkDigest [4]byte) {
+func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMsg *ethpb.SyncCommitteeMessage, forkDigest [fieldparams.VersionLength]byte) {
 	_, span := trace.StartSpan(ctx, "p2p.broadcastSyncCommittee")
 	defer span.End()
 	ctx = trace.NewContext(context.Background(), span) // clear parent context / deadline.
@@ -230,7 +231,7 @@ func (s *Service) BroadcastBlob(ctx context.Context, subnet uint64, blob *ethpb.
 	return nil
 }
 
-func (s *Service) internalBroadcastBlob(ctx context.Context, subnet uint64, blobSidecar *ethpb.BlobSidecar, forkDigest [4]byte) {
+func (s *Service) internalBroadcastBlob(ctx context.Context, subnet uint64, blobSidecar *ethpb.BlobSidecar, forkDigest [fieldparams.VersionLength]byte) {
 	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastBlob")
 	defer span.End()
 	ctx = trace.NewContext(context.Background(), span) // clear parent context / deadline.
@@ -245,7 +246,7 @@ func (s *Service) internalBroadcastBlob(ctx context.Context, subnet uint64, blob
 	s.subnetLocker(wrappedSubIdx).RUnlock()
 
 	if !hasPeer {
-		blobSidecarCommitteeBroadcastAttempts.Inc()
+		blobSidecarBroadcastAttempts.Inc()
 		if err := func() error {
 			s.subnetLocker(wrappedSubIdx).Lock()
 			defer s.subnetLocker(wrappedSubIdx).Unlock()
@@ -254,7 +255,7 @@ func (s *Service) internalBroadcastBlob(ctx context.Context, subnet uint64, blob
 				return err
 			}
 			if ok {
-				blobSidecarCommitteeBroadcasts.Inc()
+				blobSidecarBroadcasts.Inc()
 				return nil
 			}
 			return errors.New("failed to find peers for subnet")
@@ -322,6 +323,132 @@ 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
+// broadcasted to the current fork and to the input column subnet.
+func (s *Service) BroadcastDataColumn(
+	root [fieldparams.RootLength]byte,
+	dataColumnSubnet uint64,
+	dataColumnSidecar *ethpb.DataColumnSidecar,
+	peersCheckedChans ...chan<- bool, // Used for testing purposes to signal when peers are checked.
+) error {
+	// Add tracing to the function.
+	ctx, span := trace.StartSpan(s.ctx, "p2p.BroadcastDataColumn")
+	defer span.End()
+
+	// Ensure the data column sidecar is not nil.
+	if dataColumnSidecar == nil {
+		return errors.Errorf("attempted to broadcast nil data column sidecar at subnet %d", dataColumnSubnet)
+	}
+
+	// Retrieve the current fork digest.
+	forkDigest, err := s.currentForkDigest()
+	if err != nil {
+		err := errors.Wrap(err, "current fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	// Non-blocking broadcast, with attempts to discover a column subnet peer if none available.
+	go s.internalBroadcastDataColumn(ctx, root, dataColumnSubnet, dataColumnSidecar, forkDigest, peersCheckedChans)
+
+	return nil
+}
+
+func (s *Service) internalBroadcastDataColumn(
+	ctx context.Context,
+	root [fieldparams.RootLength]byte,
+	columnSubnet uint64,
+	dataColumnSidecar *ethpb.DataColumnSidecar,
+	forkDigest [fieldparams.VersionLength]byte,
+	peersCheckedChans []chan<- bool, // Used for testing purposes to signal when peers are checked.
+) {
+	// Add tracing to the function.
+	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastDataColumn")
+	defer span.End()
+
+	// Increase the number of broadcast attempts.
+	dataColumnSidecarBroadcastAttempts.Inc()
+
+	// Define a one-slot length context timeout.
+	secondsPerSlot := params.BeaconConfig().SecondsPerSlot
+	oneSlot := time.Duration(secondsPerSlot) * time.Second
+	ctx, cancel := context.WithTimeout(ctx, oneSlot)
+	defer cancel()
+
+	// Build the topic corresponding to this column subnet and this fork digest.
+	topic := dataColumnSubnetToTopic(columnSubnet, forkDigest)
+
+	// Compute the wrapped subnet index.
+	wrappedSubIdx := columnSubnet + dataColumnSubnetVal
+
+	// Find peers if needed.
+	if err := s.findPeersIfNeeded(ctx, wrappedSubIdx, topic, columnSubnet, peersCheckedChans); err != nil {
+		log.WithError(err).Error("Failed to find peers for data column subnet")
+		tracing.AnnotateError(span, err)
+	}
+
+	// Broadcast the data column sidecar to the network.
+	if err := s.broadcastObject(ctx, dataColumnSidecar, topic); err != nil {
+		log.WithError(err).Error("Failed to broadcast data column sidecar")
+		tracing.AnnotateError(span, err)
+		return
+	}
+
+	header := dataColumnSidecar.SignedBlockHeader.GetHeader()
+	slot := header.GetSlot()
+
+	slotStartTime, err := slots.ToTime(uint64(s.genesisTime.Unix()), slot)
+	if err != nil {
+		log.WithError(err).Error("Failed to convert slot to time")
+	}
+
+	log.WithFields(logrus.Fields{
+		"slot":               slot,
+		"timeSinceSlotStart": time.Since(slotStartTime),
+		"root":               fmt.Sprintf("%#x", root),
+		"columnSubnet":       columnSubnet,
+	}).Debug("Broadcasted data column sidecar")
+
+	// Increase the number of successful broadcasts.
+	dataColumnSidecarBroadcasts.Inc()
+}
+
+func (s *Service) findPeersIfNeeded(
+	ctx context.Context,
+	wrappedSubIdx uint64,
+	topic string,
+	subnet uint64,
+	peersCheckedChans []chan<- bool, // Used for testing purposes to signal when peers are checked.
+) error {
+	s.subnetLocker(wrappedSubIdx).Lock()
+	defer s.subnetLocker(wrappedSubIdx).Unlock()
+
+	// Sending a data column sidecar to only one peer is not ideal,
+	// but it ensures at least one peer receives it.
+	const peerCount = 1
+
+	if s.hasPeerWithSubnet(topic) {
+		// Exit early if we already have peers with this subnet.
+		return nil
+	}
+
+	// Used for testing purposes.
+	if len(peersCheckedChans) > 0 {
+		peersCheckedChans[0] <- true
+	}
+
+	// No peers found, attempt to find peers with this subnet.
+	ok, err := s.FindPeersWithSubnet(ctx, topic, subnet, peerCount)
+	if err != nil {
+		return errors.Wrap(err, "find peers with subnet")
+	}
+	if !ok {
+		return errors.Errorf("failed to find peers for topic %s with subnet %d", topic, subnet)
+	}
+
+	return nil
+}
+
 // method to broadcast messages to other peers in our gossip mesh.
 func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic string) error {
 	ctx, span := trace.StartSpan(ctx, "p2p.broadcastObject")
@@ -351,15 +478,15 @@ func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic
 	return nil
 }
 
-func attestationToTopic(subnet uint64, forkDigest [4]byte) string {
+func attestationToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
 	return fmt.Sprintf(AttestationSubnetTopicFormat, forkDigest, subnet)
 }
 
-func syncCommitteeToTopic(subnet uint64, forkDigest [4]byte) string {
+func syncCommitteeToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
 	return fmt.Sprintf(SyncCommitteeSubnetTopicFormat, forkDigest, subnet)
 }
 
-func blobSubnetToTopic(subnet uint64, forkDigest [4]byte) string {
+func blobSubnetToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
 	return fmt.Sprintf(BlobSubnetTopicFormat, forkDigest, subnet)
 }
 
@@ -370,3 +497,7 @@ func lcOptimisticToTopic(forkDigest [4]byte) string {
 func lcFinalityToTopic(forkDigest [4]byte) string {
 	return fmt.Sprintf(LightClientFinalityUpdateTopicFormat, forkDigest)
 }
+
+func dataColumnSubnetToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
+	return fmt.Sprintf(DataColumnSubnetTopicFormat, forkDigest, subnet)
+}

beacon-chain/p2p/broadcaster_test.go

@@ -9,11 +9,14 @@ import (
 	"testing"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
 	lightClient "github.com/OffchainLabs/prysm/v6/beacon-chain/core/light-client"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/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/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/wrapper"
@@ -655,3 +658,99 @@ func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
 		t.Error("Failed to receive pubsub within 1s")
 	}
 }
+
+func TestService_BroadcastDataColumn(t *testing.T) {
+	const (
+		port        = 2000
+		columnIndex = 12
+		topicFormat = DataColumnSubnetTopicFormat
+	)
+
+	// Load the KZG trust setup.
+	err := kzg.Start()
+	require.NoError(t, err)
+
+	gFlags := new(flags.GlobalFlags)
+	gFlags.MinimumPeersPerSubnet = 1
+	flags.Init(gFlags)
+
+	// Reset config.
+	defer flags.Init(new(flags.GlobalFlags))
+
+	// Create two peers and connect them.
+	p1, p2 := p2ptest.NewTestP2P(t), p2ptest.NewTestP2P(t)
+	p1.Connect(p2)
+
+	// Test the peers are connected.
+	require.NotEqual(t, 0, len(p1.BHost.Network().Peers()), "No peers")
+
+	// Create a host.
+	_, pkey, ipAddr := createHost(t, port)
+
+	p := &Service{
+		ctx:                   context.Background(),
+		host:                  p1.BHost,
+		pubsub:                p1.PubSub(),
+		joinedTopics:          map[string]*pubsub.Topic{},
+		cfg:                   &Config{},
+		genesisTime:           time.Now(),
+		genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),
+		subnetsLock:           make(map[uint64]*sync.RWMutex),
+		subnetsLockLock:       sync.Mutex{},
+		peers:                 peers.NewStatus(context.Background(), &peers.StatusConfig{ScorerParams: &scorers.Config{}}),
+	}
+
+	// Create a listener.
+	listener, err := p.startDiscoveryV5(ipAddr, pkey)
+	require.NoError(t, err)
+
+	p.dv5Listener = listener
+
+	digest, err := p.currentForkDigest()
+	require.NoError(t, err)
+
+	subnet := peerdas.ComputeSubnetForDataColumnSidecar(columnIndex)
+	topic := fmt.Sprintf(topicFormat, digest, subnet)
+
+	roSidecars, _ := util.CreateTestVerifiedRoDataColumnSidecars(t, util.DataColumnsParamsByRoot{{}: {{ColumnIndex: columnIndex}}})
+	sidecar := roSidecars[0].DataColumnSidecar
+
+	// Async listen for the pubsub, must be before the broadcast.
+	var wg sync.WaitGroup
+	wg.Add(1)
+
+	peersChecked := make(chan bool, 0)
+
+	go func(tt *testing.T) {
+		defer wg.Done()
+
+		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+
+		// Wait for the peers to be checked.
+		<-peersChecked
+
+		// External peer subscribes to the topic.
+		topic += p.Encoding().ProtocolSuffix()
+		sub, err := p2.SubscribeToTopic(topic)
+		require.NoError(tt, err)
+
+		msg, err := sub.Next(ctx)
+		require.NoError(tt, err)
+
+		var result ethpb.DataColumnSidecar
+		require.NoError(tt, p.Encoding().DecodeGossip(msg.Data, &result))
+		require.DeepEqual(tt, &result, sidecar)
+	}(t)
+
+	var emptyRoot [fieldparams.RootLength]byte
+
+	// Attempt to broadcast nil object should fail.
+	err = p.BroadcastDataColumn(emptyRoot, subnet, nil)
+	require.ErrorContains(t, "attempted to broadcast nil", err)
+
+	// Broadcast to peers and wait.
+	err = p.BroadcastDataColumn(emptyRoot, subnet, sidecar, peersChecked)
+	require.NoError(t, err)
+	require.Equal(t, false, util.WaitTimeout(&wg, 1*time.Minute), "Failed to receive pubsub within 1s")
+}

beacon-chain/p2p/config.go

@@ -4,6 +4,7 @@ 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"
 )
@@ -38,6 +39,7 @@ type Config struct {
 	StateNotifier        statefeed.Notifier
 	DB                   db.ReadOnlyDatabase
 	ClockWaiter          startup.ClockWaiter
+	CustodyInfo          *peerdas.CustodyInfo
 }
 
 // validateConfig validates whether the values provided are accurate and will set

beacon-chain/p2p/custody.go

@@ -0,0 +1,74 @@
+package p2p
+
+import (
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/sirupsen/logrus"
+)
+
+var _ DataColumnsHandler = (*Service)(nil)
+
+// CustodyGroupCountFromPeer retrieves custody group count from a peer.
+// It first tries to get the custody group count from the peer's metadata,
+// then falls back to the ENR value if the metadata is not available, then
+// falls back to the minimum number of custody groups an honest node should custodiy
+// and serve samples from if ENR is not available.
+func (s *Service) CustodyGroupCountFromPeer(pid peer.ID) uint64 {
+	log := log.WithField("peerID", pid)
+	// Try to get the custody group count from the peer's metadata.
+	metadata, err := s.peers.Metadata(pid)
+	if err != nil {
+		// On error, default to the ENR value.
+		log.WithError(err).Debug("Failed to retrieve metadata for peer, defaulting to the ENR value")
+		return s.custodyGroupCountFromPeerENR(pid)
+	}
+
+	// If the metadata is nil, default to the ENR value.
+	if metadata == nil {
+		log.Debug("Metadata is nil, defaulting to the ENR value")
+		return s.custodyGroupCountFromPeerENR(pid)
+	}
+
+	// Get the custody subnets count from the metadata.
+	custodyCount := metadata.CustodyGroupCount()
+
+	// If the custody count is null, default to the ENR value.
+	if custodyCount == 0 {
+		log.Debug("The custody count extracted from the metadata equals to 0, defaulting to the ENR value")
+		return s.custodyGroupCountFromPeerENR(pid)
+	}
+
+	return custodyCount
+}
+
+// custodyGroupCountFromPeerENR retrieves the custody count from the peer's ENR.
+// If the ENR is not available, it defaults to the minimum number of custody groups
+// an honest node custodies and serves samples from.
+func (s *Service) custodyGroupCountFromPeerENR(pid peer.ID) uint64 {
+	// By default, we assume the peer custodies the minimum number of groups.
+	custodyRequirement := params.BeaconConfig().CustodyRequirement
+
+	log := log.WithFields(logrus.Fields{
+		"peerID":       pid,
+		"defaultValue": custodyRequirement,
+	})
+
+	// Retrieve the ENR of the peer.
+	record, err := s.peers.ENR(pid)
+	if err != nil {
+		log.WithError(err).Debug("Failed to retrieve ENR for peer, defaulting to the default value")
+
+		return custodyRequirement
+	}
+
+	// Retrieve the custody group count from the ENR.
+	custodyGroupCount, err := peerdas.CustodyGroupCountFromRecord(record)
+	if err != nil {
+		log.WithError(err).Debug("Failed to retrieve custody group count from ENR for peer, defaulting to the default value")
+
+		return custodyRequirement
+	}
+
+	return custodyGroupCount
+}

beacon-chain/p2p/custody_test.go

@@ -0,0 +1,112 @@
+package p2p
+
+import (
+	"context"
+	"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/wrapper"
+	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/metadata"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/ethereum/go-ethereum/p2p/enr"
+	"github.com/libp2p/go-libp2p/core/network"
+)
+
+func TestCustodyGroupCountFromPeer(t *testing.T) {
+	const (
+		expectedENR      uint64 = 7
+		expectedMetadata uint64 = 8
+		pid                     = "test-id"
+	)
+
+	cgc := peerdas.Cgc(expectedENR)
+
+	// Define a nil record
+	var nilRecord *enr.Record = nil
+
+	// Define an empty record (record with non `cgc` entry)
+	emptyRecord := &enr.Record{}
+
+	// Define a nominal record
+	nominalRecord := &enr.Record{}
+	nominalRecord.Set(cgc)
+
+	// Define a metadata with zero custody.
+	zeroMetadata := wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+		CustodyGroupCount: 0,
+	})
+
+	// Define a nominal metadata.
+	nominalMetadata := wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+		CustodyGroupCount: expectedMetadata,
+	})
+
+	testCases := []struct {
+		name     string
+		record   *enr.Record
+		metadata metadata.Metadata
+		expected uint64
+	}{
+		{
+			name:     "No metadata - No ENR",
+			record:   nilRecord,
+			expected: params.BeaconConfig().CustodyRequirement,
+		},
+		{
+			name:     "No metadata - Empty ENR",
+			record:   emptyRecord,
+			expected: params.BeaconConfig().CustodyRequirement,
+		},
+		{
+			name:     "No Metadata - ENR",
+			record:   nominalRecord,
+			expected: expectedENR,
+		},
+		{
+			name:     "Metadata with 0 value - ENR",
+			record:   nominalRecord,
+			metadata: zeroMetadata,
+			expected: expectedENR,
+		},
+		{
+			name:     "Metadata - ENR",
+			record:   nominalRecord,
+			metadata: nominalMetadata,
+			expected: expectedMetadata,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Create peers status.
+			peers := peers.NewStatus(context.Background(), &peers.StatusConfig{
+				ScorerParams: &scorers.Config{},
+			})
+
+			// Set the metadata.
+			if tc.metadata != nil {
+				peers.SetMetadata(pid, tc.metadata)
+			}
+
+			// Add a new peer with the record.
+			peers.Add(tc.record, pid, nil, network.DirOutbound)
+
+			// Create a new service.
+			service := &Service{
+				peers:    peers,
+				metaData: tc.metadata,
+			}
+
+			// Retrieve the custody count from the remote peer.
+			actual := service.CustodyGroupCountFromPeer(pid)
+
+			// Verify the result.
+			require.Equal(t, tc.expected, actual)
+		})
+	}
+
+}

beacon-chain/p2p/discovery.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -187,7 +188,8 @@ func (s *Service) RefreshPersistentSubnets() {
 	// Compare current epoch with Altair fork epoch
 	altairForkEpoch := params.BeaconConfig().AltairForkEpoch
 
-	if currentEpoch < altairForkEpoch {
+	// We add `1` to the current epoch because we want to prepare one epoch before the Altair fork.
+	if currentEpoch+1 < altairForkEpoch {
 		// Phase 0 behaviour.
 		if isBitVUpToDate {
 			// Return early if bitfield hasn't changed.
@@ -223,15 +225,51 @@ func (s *Service) RefreshPersistentSubnets() {
 	// Is our sync bitvector record up to date?
 	isBitSUpToDate := bytes.Equal(bitS, inRecordBitS) && bytes.Equal(bitS, currentBitSInMetadata)
 
-	if metadataVersion == version.Altair && isBitVUpToDate && isBitSUpToDate {
+	// Compare current epoch with the Fulu fork epoch.
+	fuluForkEpoch := params.BeaconConfig().FuluForkEpoch
+
+	// We add `1` to the current epoch because we want to prepare one epoch before the Fulu fork.
+	if currentEpoch+1 < fuluForkEpoch {
+		// Altair behaviour.
+		if metadataVersion == version.Altair && isBitVUpToDate && isBitSUpToDate {
+			// Nothing to do, return early.
+			return
+		}
+
+		// Some data have changed, update our record and metadata.
+		s.updateSubnetRecordWithMetadataV2(bitV, bitS)
+
+		// Ping all peers to inform them of new metadata
+		s.pingPeersAndLogEnr()
+
+		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()
+
+	// Is our custody group count record up to date?
+	isCustodyGroupCountUpToDate := (custodyGroupCount == inRecordCustodyGroupCount && custodyGroupCount == inMetadataCustodyGroupCount)
+
+	if isBitVUpToDate && isBitSUpToDate && isCustodyGroupCountUpToDate {
 		// Nothing to do, return early.
 		return
 	}
 
-	// Some data have changed, update our record and metadata.
-	s.updateSubnetRecordWithMetadataV2(bitV, bitS)
+	// Some data changed. Update the record and the metadata.
+	s.updateSubnetRecordWithMetadataV3(bitV, bitS, custodyGroupCount)
 
-	// Ping all peers to inform them of new metadata
+	// Ping all peers.
 	s.pingPeersAndLogEnr()
 }
 
@@ -458,6 +496,11 @@ 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)
 

beacon-chain/p2p/discovery_test.go

@@ -16,6 +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"
 	"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"
@@ -140,6 +141,15 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 
 func TestCreateLocalNode(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
+
+	// Set the fulu fork epoch to something other than the far future epoch.
+	initFuluForkEpoch := params.BeaconConfig().FuluForkEpoch
+	params.BeaconConfig().FuluForkEpoch = 42
+
+	defer func() {
+		params.BeaconConfig().FuluForkEpoch = initFuluForkEpoch
+	}()
+
 	testCases := []struct {
 		name          string
 		cfg           *Config
@@ -147,30 +157,31 @@ func TestCreateLocalNode(t *testing.T) {
 	}{
 		{
 			name:          "valid config",
-			cfg:           nil,
+			cfg:           &Config{CustodyInfo: &peerdas.CustodyInfo{}},
 			expectedError: false,
 		},
 		{
 			name:          "invalid host address",
-			cfg:           &Config{HostAddress: "invalid"},
+			cfg:           &Config{HostAddress: "invalid", CustodyInfo: &peerdas.CustodyInfo{}},
 			expectedError: true,
 		},
 		{
 			name:          "valid host address",
-			cfg:           &Config{HostAddress: "192.168.0.1"},
+			cfg:           &Config{HostAddress: "192.168.0.1", CustodyInfo: &peerdas.CustodyInfo{}},
 			expectedError: false,
 		},
 		{
 			name:          "invalid host DNS",
-			cfg:           &Config{HostDNS: "invalid"},
+			cfg:           &Config{HostDNS: "invalid", CustodyInfo: &peerdas.CustodyInfo{}},
 			expectedError: true,
 		},
 		{
 			name:          "valid host DNS",
-			cfg:           &Config{HostDNS: "www.google.com"},
+			cfg:           &Config{HostDNS: "www.google.com", CustodyInfo: &peerdas.CustodyInfo{}},
 			expectedError: false,
 		},
 	}
+
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
 			// Define ports.
@@ -199,7 +210,7 @@ func TestCreateLocalNode(t *testing.T) {
 			require.NoError(t, err)
 
 			expectedAddress := address
-			if tt.cfg != nil && tt.cfg.HostAddress != "" {
+			if tt.cfg.HostAddress != "" {
 				expectedAddress = net.ParseIP(tt.cfg.HostAddress)
 			}
 
@@ -236,6 +247,11 @@ func TestCreateLocalNode(t *testing.T) {
 			syncSubnets := new([]byte)
 			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(syncCommsSubnetEnrKey, syncSubnets)))
 			require.DeepSSZEqual(t, []byte{0}, *syncSubnets)
+
+			// 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)
 		})
 	}
 }
@@ -535,7 +551,7 @@ type check struct {
 	metadataSequenceNumber uint64
 	attestationSubnets     []uint64
 	syncSubnets            []uint64
-	custodySubnetCount     *uint64
+	custodyGroupCount      *uint64
 }
 
 func checkPingCountCacheMetadataRecord(
@@ -601,6 +617,18 @@ func checkPingCountCacheMetadataRecord(
 		actualBitSMetadata := service.metaData.SyncnetsBitfield()
 		require.DeepSSZEqual(t, expectedBitS, actualBitSMetadata)
 	}
+
+	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))
+		require.NoError(t, err)
+		require.Equal(t, *expected.custodyGroupCount, actualCustodyGroupCount)
+
+		// Check custody subnet count in metadata.
+		actualGroupCountMetadata := service.metaData.CustodyGroupCount()
+		require.Equal(t, *expected.custodyGroupCount, actualGroupCountMetadata)
+	}
 }
 
 func TestRefreshPersistentSubnets(t *testing.T) {
@@ -610,12 +638,18 @@ func TestRefreshPersistentSubnets(t *testing.T) {
 	defer cache.SubnetIDs.EmptyAllCaches()
 	defer cache.SyncSubnetIDs.EmptyAllCaches()
 
-	const altairForkEpoch = 5
+	const (
+		altairForkEpoch = 5
+		fuluForkEpoch   = 10
+	)
+
+	custodyGroupCount := params.BeaconConfig().CustodyRequirement
 
 	// Set up epochs.
 	defaultCfg := params.BeaconConfig()
 	cfg := defaultCfg.Copy()
 	cfg.AltairForkEpoch = altairForkEpoch
+	cfg.FuluForkEpoch = fuluForkEpoch
 	params.OverrideBeaconConfig(cfg)
 
 	// Compute the number of seconds per epoch.
@@ -684,6 +718,39 @@ func TestRefreshPersistentSubnets(t *testing.T) {
 				},
 			},
 		},
+		{
+			name:              "Fulu",
+			epochSinceGenesis: fuluForkEpoch,
+			checks: []check{
+				{
+					pingCount:              0,
+					metadataSequenceNumber: 0,
+					attestationSubnets:     []uint64{},
+					syncSubnets:            nil,
+				},
+				{
+					pingCount:              1,
+					metadataSequenceNumber: 1,
+					attestationSubnets:     []uint64{40, 41},
+					syncSubnets:            nil,
+					custodyGroupCount:      &custodyGroupCount,
+				},
+				{
+					pingCount:              2,
+					metadataSequenceNumber: 2,
+					attestationSubnets:     []uint64{40, 41},
+					syncSubnets:            []uint64{1, 2},
+					custodyGroupCount:      &custodyGroupCount,
+				},
+				{
+					pingCount:              2,
+					metadataSequenceNumber: 2,
+					attestationSubnets:     []uint64{40, 41},
+					syncSubnets:            []uint64{1, 2},
+					custodyGroupCount:      &custodyGroupCount,
+				},
+			},
+		},
 	}
 
 	for _, tc := range testCases {
@@ -717,7 +784,7 @@ func TestRefreshPersistentSubnets(t *testing.T) {
 					actualPingCount++
 					return nil
 				},
-				cfg:                   &Config{UDPPort: 2000},
+				cfg:                   &Config{UDPPort: 2000, CustodyInfo: &peerdas.CustodyInfo{}},
 				peers:                 p2p.Peers(),
 				genesisTime:           time.Now().Add(-time.Duration(tc.epochSinceGenesis*secondsPerEpoch) * time.Second),
 				genesisValidatorsRoot: bytesutil.PadTo([]byte{'A'}, 32),

beacon-chain/p2p/gossip_scoring_params.go

@@ -127,7 +127,7 @@ func (s *Service) topicScoreParams(topic string) (*pubsub.TopicScoreParams, erro
 		return defaultAttesterSlashingTopicParams(), nil
 	case strings.Contains(topic, GossipBlsToExecutionChangeMessage):
 		return defaultBlsToExecutionChangeTopicParams(), nil
-	case strings.Contains(topic, GossipBlobSidecarMessage):
+	case strings.Contains(topic, GossipBlobSidecarMessage), strings.Contains(topic, GossipDataColumnSidecarMessage):
 		// TODO(Deneb): Using the default block scoring. But this should be updated.
 		return defaultBlockTopicParams(), nil
 	case strings.Contains(topic, GossipLightClientOptimisticUpdateMessage):

beacon-chain/p2p/gossip_topic_mappings.go

@@ -24,6 +24,7 @@ var gossipTopicMappings = map[string]func() proto.Message{
 	BlobSubnetTopicFormat:                     func() proto.Message { return &ethpb.BlobSidecar{} },
 	LightClientOptimisticUpdateTopicFormat:    func() proto.Message { return &ethpb.LightClientOptimisticUpdateAltair{} },
 	LightClientFinalityUpdateTopicFormat:      func() proto.Message { return &ethpb.LightClientFinalityUpdateAltair{} },
+	DataColumnSubnetTopicFormat:               func() proto.Message { return &ethpb.DataColumnSidecar{} },
 }
 
 // GossipTopicMappings is a function to return the assigned data type

beacon-chain/p2p/handshake.go

@@ -22,7 +22,9 @@ const (
 )
 
 func peerMultiaddrString(conn network.Conn) string {
-	return fmt.Sprintf("%s/p2p/%s", conn.RemoteMultiaddr().String(), conn.RemotePeer().String())
+	remoteMultiaddr := conn.RemoteMultiaddr().String()
+	remotePeerID := conn.RemotePeer().String()
+	return fmt.Sprintf("%s/p2p/%s", remoteMultiaddr, remotePeerID)
 }
 
 func (s *Service) connectToPeer(conn network.Conn) {

beacon-chain/p2p/interfaces.go

@@ -5,9 +5,11 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	"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"
 	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"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/connmgr"
@@ -18,90 +20,106 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-// P2P represents the full p2p interface composed of all of the sub-interfaces.
-type P2P interface {
-	Broadcaster
-	SetStreamHandler
-	PubSubProvider
-	PubSubTopicUser
-	SenderEncoder
-	PeerManager
-	ConnectionHandler
-	PeersProvider
-	MetadataProvider
-}
+type (
+	// P2P represents the full p2p interface composed of all of the sub-interfaces.
+	P2P interface {
+		Broadcaster
+		SetStreamHandler
+		PubSubProvider
+		PubSubTopicUser
+		SenderEncoder
+		PeerManager
+		ConnectionHandler
+		PeersProvider
+		MetadataProvider
+		DataColumnsHandler
+	}
 
-// Broadcaster broadcasts messages to peers over the p2p pubsub protocol.
-type Broadcaster interface {
-	Broadcast(context.Context, proto.Message) error
-	BroadcastAttestation(ctx context.Context, subnet uint64, att ethpb.Att) error
-	BroadcastSyncCommitteeMessage(ctx context.Context, subnet uint64, sMsg *ethpb.SyncCommitteeMessage) error
-	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
-}
+	// Accessor provides access to the Broadcaster and PeerManager interfaces.
+	Accessor interface {
+		Broadcaster
+		PeerManager
+	}
 
-// SetStreamHandler configures p2p to handle streams of a certain topic ID.
-type SetStreamHandler interface {
-	SetStreamHandler(topic string, handler network.StreamHandler)
-}
+	// Broadcaster broadcasts messages to peers over the p2p pubsub protocol.
+	Broadcaster interface {
+		Broadcast(context.Context, proto.Message) error
+		BroadcastAttestation(ctx context.Context, subnet uint64, att ethpb.Att) error
+		BroadcastSyncCommitteeMessage(ctx context.Context, subnet uint64, sMsg *ethpb.SyncCommitteeMessage) error
+		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, peersChecked ...chan<- bool) error
+	}
 
-// PubSubTopicUser provides way to join, use and leave PubSub topics.
-type PubSubTopicUser interface {
-	JoinTopic(topic string, opts ...pubsub.TopicOpt) (*pubsub.Topic, error)
-	LeaveTopic(topic string) error
-	PublishToTopic(ctx context.Context, topic string, data []byte, opts ...pubsub.PubOpt) error
-	SubscribeToTopic(topic string, opts ...pubsub.SubOpt) (*pubsub.Subscription, error)
-}
+	// SetStreamHandler configures p2p to handle streams of a certain topic ID.
+	SetStreamHandler interface {
+		SetStreamHandler(topic string, handler network.StreamHandler)
+	}
 
-// ConnectionHandler configures p2p to handle connections with a peer.
-type ConnectionHandler interface {
-	AddConnectionHandler(f func(ctx context.Context, id peer.ID) error,
-		j func(ctx context.Context, id peer.ID) error)
-	AddDisconnectionHandler(f func(ctx context.Context, id peer.ID) error)
-	connmgr.ConnectionGater
-}
+	// PubSubTopicUser provides way to join, use and leave PubSub topics.
+	PubSubTopicUser interface {
+		JoinTopic(topic string, opts ...pubsub.TopicOpt) (*pubsub.Topic, error)
+		LeaveTopic(topic string) error
+		PublishToTopic(ctx context.Context, topic string, data []byte, opts ...pubsub.PubOpt) error
+		SubscribeToTopic(topic string, opts ...pubsub.SubOpt) (*pubsub.Subscription, error)
+	}
 
-// SenderEncoder allows sending functionality from libp2p as well as encoding for requests and responses.
-type SenderEncoder interface {
-	EncodingProvider
-	Sender
-}
+	// ConnectionHandler configures p2p to handle connections with a peer.
+	ConnectionHandler interface {
+		AddConnectionHandler(f func(ctx context.Context, id peer.ID) error,
+			j func(ctx context.Context, id peer.ID) error)
+		AddDisconnectionHandler(f func(ctx context.Context, id peer.ID) error)
+		connmgr.ConnectionGater
+	}
 
-// EncodingProvider provides p2p network encoding.
-type EncodingProvider interface {
-	Encoding() encoder.NetworkEncoding
-}
+	// SenderEncoder allows sending functionality from libp2p as well as encoding for requests and responses.
+	SenderEncoder interface {
+		EncodingProvider
+		Sender
+	}
 
-// PubSubProvider provides the p2p pubsub protocol.
-type PubSubProvider interface {
-	PubSub() *pubsub.PubSub
-}
+	// EncodingProvider provides p2p network encoding.
+	EncodingProvider interface {
+		Encoding() encoder.NetworkEncoding
+	}
 
-// PeerManager abstracts some peer management methods from libp2p.
-type PeerManager interface {
-	Disconnect(peer.ID) error
-	PeerID() peer.ID
-	Host() host.Host
-	ENR() *enr.Record
-	DiscoveryAddresses() ([]multiaddr.Multiaddr, error)
-	RefreshPersistentSubnets()
-	FindPeersWithSubnet(ctx context.Context, topic string, subIndex uint64, threshold int) (bool, error)
-	AddPingMethod(reqFunc func(ctx context.Context, id peer.ID) error)
-}
+	// PubSubProvider provides the p2p pubsub protocol.
+	PubSubProvider interface {
+		PubSub() *pubsub.PubSub
+	}
 
-// Sender abstracts the sending functionality from libp2p.
-type Sender interface {
-	Send(context.Context, interface{}, string, peer.ID) (network.Stream, error)
-}
+	// PeerManager abstracts some peer management methods from libp2p.
+	PeerManager interface {
+		Disconnect(peer.ID) error
+		PeerID() peer.ID
+		Host() host.Host
+		ENR() *enr.Record
+		NodeID() enode.ID
+		DiscoveryAddresses() ([]multiaddr.Multiaddr, error)
+		RefreshPersistentSubnets()
+		FindPeersWithSubnet(ctx context.Context, topic string, subIndex uint64, threshold int) (bool, error)
+		AddPingMethod(reqFunc func(ctx context.Context, id peer.ID) error)
+	}
 
-// PeersProvider abstracts obtaining our current list of known peers status.
-type PeersProvider interface {
-	Peers() *peers.Status
-}
+	// Sender abstracts the sending functionality from libp2p.
+	Sender interface {
+		Send(context.Context, interface{}, string, peer.ID) (network.Stream, error)
+	}
 
-// MetadataProvider returns the metadata related information for the local peer.
-type MetadataProvider interface {
-	Metadata() metadata.Metadata
-	MetadataSeq() uint64
-}
+	// PeersProvider abstracts obtaining our current list of known peers status.
+	PeersProvider interface {
+		Peers() *peers.Status
+	}
+
+	// MetadataProvider returns the metadata related information for the local peer.
+	MetadataProvider interface {
+		Metadata() metadata.Metadata
+		MetadataSeq() uint64
+	}
+
+	// DataColumnsHandler abstracts some data columns related methods.
+	DataColumnsHandler interface {
+		CustodyGroupCountFromPeer(peer.ID) uint64
+	}
+)

beacon-chain/p2p/monitoring.go

@@ -46,31 +46,39 @@ var (
 	})
 	savedAttestationBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_attestation_subnet_recovered_broadcasts",
-		Help: "The number of attestations that were attempted to be broadcast with no peers on " +
+		Help: "The number of attestations message broadcast attempts with no peers on " +
 			"the subnet. The beacon node increments this counter when the broadcast is blocked " +
 			"until a subnet peer can be found.",
 	})
 	attestationBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_attestation_subnet_attempted_broadcasts",
-		Help: "The number of attestations that were attempted to be broadcast.",
+		Help: "The number of attestations message broadcast attempts.",
 	})
 	savedSyncCommitteeBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_sync_committee_subnet_recovered_broadcasts",
-		Help: "The number of sync committee messages that were attempted to be broadcast with no peers on " +
+		Help: "The number of sync committee messages broadcast attempts with no peers on " +
 			"the subnet. The beacon node increments this counter when the broadcast is blocked " +
 			"until a subnet peer can be found.",
 	})
-	blobSidecarCommitteeBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
+	blobSidecarBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_blob_sidecar_committee_broadcasts",
-		Help: "The number of blob sidecar committee messages that were broadcast with no peer on.",
+		Help: "The number of blob sidecar messages that were broadcast with no peer on.",
 	})
 	syncCommitteeBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_sync_committee_subnet_attempted_broadcasts",
-		Help: "The number of sync committee that were attempted to be broadcast.",
+		Help: "The number of sync committee message broadcast attempts.",
 	})
-	blobSidecarCommitteeBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
+	blobSidecarBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_blob_sidecar_committee_attempted_broadcasts",
-		Help: "The number of blob sidecar committee messages that were attempted to be broadcast.",
+		Help: "The number of blob sidecar message broadcast attempts.",
+	})
+	dataColumnSidecarBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "p2p_data_column_sidecar_broadcasts",
+		Help: "The number of data column sidecar messages that were broadcasted.",
+	})
+	dataColumnSidecarBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
+		Name: "p2p_data_column_sidecar_attempted_broadcasts",
+		Help: "The number of data column sidecar message broadcast attempts.",
 	})
 
 	// Gossip Tracer Metrics

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

@@ -11,8 +11,7 @@ import (
 )
 
 func TestStore_GetSetDelete(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	store := peerdata.NewStore(ctx, &peerdata.StoreConfig{
 		MaxPeers: 12,
@@ -52,8 +51,7 @@ func TestStore_GetSetDelete(t *testing.T) {
 }
 
 func TestStore_PeerDataGetOrCreate(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	store := peerdata.NewStore(ctx, &peerdata.StoreConfig{
 		MaxPeers: 12,

beacon-chain/p2p/peers/scorers/bad_responses_test.go

@@ -1,7 +1,6 @@
 package scorers_test
 
 import (
-	"context"
 	"sort"
 	"testing"
 
@@ -17,8 +16,7 @@ import (
 func TestScorers_BadResponses_Score(t *testing.T) {
 	const pid = "peer1"
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		PeerLimit: 30,
@@ -50,8 +48,7 @@ func TestScorers_BadResponses_Score(t *testing.T) {
 }
 
 func TestScorers_BadResponses_ParamsThreshold(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	maxBadResponses := 2
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
@@ -67,8 +64,7 @@ func TestScorers_BadResponses_ParamsThreshold(t *testing.T) {
 }
 
 func TestScorers_BadResponses_Count(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		PeerLimit:    30,
@@ -87,8 +83,7 @@ func TestScorers_BadResponses_Count(t *testing.T) {
 }
 
 func TestScorers_BadResponses_Decay(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	maxBadResponses := 2
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
@@ -143,8 +138,7 @@ func TestScorers_BadResponses_Decay(t *testing.T) {
 }
 
 func TestScorers_BadResponses_IsBadPeer(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		PeerLimit:    30,
@@ -168,8 +162,7 @@ func TestScorers_BadResponses_IsBadPeer(t *testing.T) {
 }
 
 func TestScorers_BadResponses_BadPeers(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		PeerLimit:    30,

beacon-chain/p2p/peers/scorers/block_providers_test.go

@@ -1,7 +1,6 @@
 package scorers_test
 
 import (
-	"context"
 	"fmt"
 	"sort"
 	"strconv"
@@ -18,8 +17,7 @@ import (
 )
 
 func TestScorers_BlockProvider_Score(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	batchSize := uint64(flags.Get().BlockBatchLimit)
 	tests := []struct {
@@ -136,8 +134,7 @@ func TestScorers_BlockProvider_Score(t *testing.T) {
 }
 
 func TestScorers_BlockProvider_GettersSetters(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		ScorerParams: &scorers.Config{},
@@ -150,8 +147,7 @@ func TestScorers_BlockProvider_GettersSetters(t *testing.T) {
 }
 
 func TestScorers_BlockProvider_WeightSorted(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		ScorerParams: &scorers.Config{
 			BlockProviderScorerConfig: &scorers.BlockProviderScorerConfig{
@@ -290,8 +286,7 @@ func TestScorers_BlockProvider_Sorted(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
+			ctx := t.Context()
 			peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 				ScorerParams: &scorers.Config{
 					BlockProviderScorerConfig: &scorers.BlockProviderScorerConfig{
@@ -307,8 +302,7 @@ func TestScorers_BlockProvider_Sorted(t *testing.T) {
 }
 
 func TestScorers_BlockProvider_MaxScore(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 	batchSize := uint64(flags.Get().BlockBatchLimit)
 
 	tests := []struct {
@@ -345,8 +339,7 @@ func TestScorers_BlockProvider_MaxScore(t *testing.T) {
 }
 
 func TestScorers_BlockProvider_FormatScorePretty(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 	batchSize := uint64(flags.Get().BlockBatchLimit)
 	format := "[%0.1f%%, raw: %0.2f,  blocks: %d/1280]"
 
@@ -473,8 +466,7 @@ func TestScorers_BlockProvider_FormatScorePretty(t *testing.T) {
 }
 
 func TestScorers_BlockProvider_BadPeerMarking(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
 		ScorerParams: &scorers.Config{},

beacon-chain/p2p/peers/scorers/gossip_scorer_test.go

@@ -1,7 +1,6 @@
 package scorers_test
 
 import (
-	"context"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
@@ -11,8 +10,7 @@ import (
 )
 
 func TestScorers_Gossip_Score(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	tests := []struct {
 		name   string

beacon-chain/p2p/peers/scorers/peer_status_test.go

@@ -16,8 +16,7 @@ import (
 )
 
 func TestScorers_PeerStatus_Score(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	tests := []struct {
 		name   string

beacon-chain/p2p/peers/scorers/service_test.go

@@ -14,8 +14,7 @@ import (
 )
 
 func TestScorers_Service_Init(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	ctx := t.Context()
 
 	batchSize := uint64(flags.Get().BlockBatchLimit)
 

beacon-chain/p2p/pubsub_filter.go

@@ -26,10 +26,11 @@ var _ pubsub.SubscriptionFilter = (*Service)(nil)
 // -> SyncContributionAndProof * 2 = 2
 // -> 4 SyncCommitteeSubnets   * 2 = 8
 // -> BlsToExecutionChange     * 2 = 2
-// -> 6 BlobSidecar            * 2 = 12
+// -> 128 DataColumnSidecar    * 2 = 256
 // -------------------------------------
-// TOTAL                           = 162
-const pubsubSubscriptionRequestLimit = 200
+// TOTAL                           = 406
+// (Note: BlobSidecar is not included in this list since it is superseded by DataColumnSidecar)
+const pubsubSubscriptionRequestLimit = 500
 
 // CanSubscribe returns true if the topic is of interest and we could subscribe to it.
 func (s *Service) CanSubscribe(topic string) bool {

beacon-chain/p2p/pubsub_filter_test.go

@@ -90,7 +90,14 @@ func TestService_CanSubscribe(t *testing.T) {
 		formatting := []interface{}{digest}
 
 		// Special case for attestation subnets which have a second formatting placeholder.
-		if topic == AttestationSubnetTopicFormat || topic == SyncCommitteeSubnetTopicFormat || topic == BlobSubnetTopicFormat {
+		topics := map[string]bool{
+			AttestationSubnetTopicFormat:   true,
+			SyncCommitteeSubnetTopicFormat: true,
+			BlobSubnetTopicFormat:          true,
+			DataColumnSubnetTopicFormat:    true,
+		}
+
+		if topics[topic] {
 			formatting = append(formatting, 0 /* some subnet ID */)
 		}
 

beacon-chain/p2p/rpc_topic_mappings.go

@@ -4,17 +4,23 @@ import (
 	"reflect"
 
 	p2ptypes "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/pkg/errors"
 )
 
-// SchemaVersionV1 specifies the schema version for our rpc protocol ID.
-const SchemaVersionV1 = "/1"
+const (
+	// SchemaVersionV1 specifies the schema version for our rpc protocol ID.
+	SchemaVersionV1 = "/1"
 
-// SchemaVersionV2 specifies the next schema version for our rpc protocol ID.
-const SchemaVersionV2 = "/2"
+	// SchemaVersionV2 specifies the next schema version for our rpc protocol ID.
+	SchemaVersionV2 = "/2"
+
+	// SchemaVersionV3 specifies the next schema version for our rpc protocol ID.
+	SchemaVersionV3 = "/3"
+)
 
 // Specifies the protocol prefix for all our Req/Resp topics.
 const protocolPrefix = "/eth2/beacon_chain/req"
@@ -43,6 +49,18 @@ const BlobSidecarsByRangeName = "/blob_sidecars_by_range"
 // BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
 const BlobSidecarsByRootName = "/blob_sidecars_by_root"
 
+// LightClientBootstrapName is the name for the LightClientBootstrap message topic,
+const LightClientBootstrapName = "/light_client_bootstrap"
+
+// LightClientUpdatesByRangeName is the name for the LightClientUpdatesByRange topic.
+const LightClientUpdatesByRangeName = "/light_client_updates_by_range"
+
+// LightClientFinalityUpdateName is the name for the LightClientFinalityUpdate topic.
+const LightClientFinalityUpdateName = "/light_client_finality_update"
+
+// LightClientOptimisticUpdateName is the name for the LightClientOptimisticUpdate topic.
+const LightClientOptimisticUpdateName = "/light_client_optimistic_update"
+
 const (
 	// V1 RPC Topics
 	// RPCStatusTopicV1 defines the v1 topic for the status rpc method.
@@ -60,12 +78,21 @@ const (
 
 	// RPCBlobSidecarsByRangeTopicV1 is a topic for requesting blob sidecars
 	// in the slot range [start_slot, start_slot + count), leading up to the current head block as selected by fork choice.
-	// Protocol ID: /eth2/beacon_chain/req/blob_sidecars_by_range/1/ - New in deneb.
+	// /eth2/beacon_chain/req/blob_sidecars_by_range/1/ - New in deneb.
 	RPCBlobSidecarsByRangeTopicV1 = protocolPrefix + BlobSidecarsByRangeName + SchemaVersionV1
-	// RPCBlobSidecarsByRootTopicV1 is a topic for requesting blob sidecars by their block root. New in deneb.
-	// /eth2/beacon_chain/req/blob_sidecars_by_root/1/
+	// RPCBlobSidecarsByRootTopicV1 is a topic for requesting blob sidecars by their block root.
+	// /eth2/beacon_chain/req/blob_sidecars_by_root/1/ - New in deneb.
 	RPCBlobSidecarsByRootTopicV1 = protocolPrefix + BlobSidecarsByRootName + SchemaVersionV1
 
+	// RPCLightClientBootstrapTopicV1 is a topic for requesting a light client bootstrap.
+	RPCLightClientBootstrapTopicV1 = protocolPrefix + LightClientBootstrapName + SchemaVersionV1
+	// RPCLightClientUpdatesByRangeTopicV1 is a topic for requesting light client updates by range.
+	RPCLightClientUpdatesByRangeTopicV1 = protocolPrefix + LightClientUpdatesByRangeName + SchemaVersionV1
+	// RPCLightClientFinalityUpdateTopicV1 is a topic for requesting a light client finality update.
+	RPCLightClientFinalityUpdateTopicV1 = protocolPrefix + LightClientFinalityUpdateName + SchemaVersionV1
+	// RPCLightClientOptimisticUpdateTopicV1 is a topic for requesting a light client Optimistic update.
+	RPCLightClientOptimisticUpdateTopicV1 = protocolPrefix + LightClientOptimisticUpdateName + SchemaVersionV1
+
 	// V2 RPC Topics
 	// RPCBlocksByRangeTopicV2 defines v2 the topic for the blocks by range rpc method.
 	RPCBlocksByRangeTopicV2 = protocolPrefix + BeaconBlocksByRangeMessageName + SchemaVersionV2
@@ -73,6 +100,10 @@ const (
 	RPCBlocksByRootTopicV2 = protocolPrefix + BeaconBlocksByRootsMessageName + SchemaVersionV2
 	// RPCMetaDataTopicV2 defines the v2 topic for the metadata rpc method.
 	RPCMetaDataTopicV2 = protocolPrefix + MetadataMessageName + SchemaVersionV2
+
+	// V3 RPC Topics
+	// RPCMetaDataTopicV3 defines the v3 topic for the metadata rpc method.
+	RPCMetaDataTopicV3 = protocolPrefix + MetadataMessageName + SchemaVersionV3
 )
 
 // RPC errors for topic parsing.
@@ -97,10 +128,17 @@ var RPCTopicMappings = map[string]interface{}{
 	// RPC Metadata Message
 	RPCMetaDataTopicV1: new(interface{}),
 	RPCMetaDataTopicV2: new(interface{}),
+	RPCMetaDataTopicV3: new(interface{}),
 	// BlobSidecarsByRange v1 Message
 	RPCBlobSidecarsByRangeTopicV1: new(pb.BlobSidecarsByRangeRequest),
 	// BlobSidecarsByRoot v1 Message
 	RPCBlobSidecarsByRootTopicV1: new(p2ptypes.BlobSidecarsByRootReq),
+
+	// Light client
+	RPCLightClientBootstrapTopicV1:        new([fieldparams.RootLength]byte),
+	RPCLightClientUpdatesByRangeTopicV1:   new(pb.LightClientUpdatesByRangeRequest),
+	RPCLightClientFinalityUpdateTopicV1:   new(interface{}),
+	RPCLightClientOptimisticUpdateTopicV1: new(interface{}),
 }
 
 // Maps all registered protocol prefixes.
@@ -111,14 +149,18 @@ var protocolMapping = map[string]bool{
 // Maps all the protocol message names for the different rpc
 // topics.
 var messageMapping = map[string]bool{
-	StatusMessageName:              true,
-	GoodbyeMessageName:             true,
-	BeaconBlocksByRangeMessageName: true,
-	BeaconBlocksByRootsMessageName: true,
-	PingMessageName:                true,
-	MetadataMessageName:            true,
-	BlobSidecarsByRangeName:        true,
-	BlobSidecarsByRootName:         true,
+	StatusMessageName:               true,
+	GoodbyeMessageName:              true,
+	BeaconBlocksByRangeMessageName:  true,
+	BeaconBlocksByRootsMessageName:  true,
+	PingMessageName:                 true,
+	MetadataMessageName:             true,
+	BlobSidecarsByRangeName:         true,
+	BlobSidecarsByRootName:          true,
+	LightClientBootstrapName:        true,
+	LightClientUpdatesByRangeName:   true,
+	LightClientFinalityUpdateName:   true,
+	LightClientOptimisticUpdateName: true,
 }
 
 // Maps all the RPC messages which are to updated in altair.
@@ -128,9 +170,15 @@ var altairMapping = map[string]bool{
 	MetadataMessageName:            true,
 }
 
+// Maps all the RPC messages which are to updated in fulu.
+var fuluMapping = map[string]bool{
+	MetadataMessageName: true,
+}
+
 var versionMapping = map[string]bool{
 	SchemaVersionV1: true,
 	SchemaVersionV2: true,
+	SchemaVersionV3: true,
 }
 
 // OmitContextBytesV1 keeps track of which RPC methods do not write context bytes in their v1 incarnations.
@@ -258,13 +306,22 @@ func (r RPCTopic) Version() string {
 // TopicFromMessage constructs the rpc topic from the provided message
 // type and epoch.
 func TopicFromMessage(msg string, epoch primitives.Epoch) (string, error) {
+	// Check if the topic is known.
 	if !messageMapping[msg] {
 		return "", errors.Errorf("%s: %s", invalidRPCMessageType, msg)
 	}
-	version := SchemaVersionV1
-	isAltair := epoch >= params.BeaconConfig().AltairForkEpoch
-	if isAltair && altairMapping[msg] {
-		version = SchemaVersionV2
+
+	beaconConfig := params.BeaconConfig()
+
+	// Check if the message is to be updated in fulu.
+	if epoch >= beaconConfig.FuluForkEpoch && fuluMapping[msg] {
+		return protocolPrefix + msg + SchemaVersionV3, nil
 	}
-	return protocolPrefix + msg + version, nil
+
+	// Check if the message is to be updated in altair.
+	if epoch >= beaconConfig.AltairForkEpoch && altairMapping[msg] {
+		return protocolPrefix + msg + SchemaVersionV2, nil
+	}
+
+	return protocolPrefix + msg + SchemaVersionV1, nil
 }

beacon-chain/p2p/rpc_topic_mappings_test.go

@@ -82,43 +82,87 @@ func TestTopicDeconstructor(t *testing.T) {
 }
 
 func TestTopicFromMessage_CorrectType(t *testing.T) {
+	const (
+		genesisEpoch    = primitives.Epoch(0)
+		altairForkEpoch = primitives.Epoch(100)
+		fuluForkEpoch   = primitives.Epoch(200)
+	)
+
 	params.SetupTestConfigCleanup(t)
 	bCfg := params.BeaconConfig().Copy()
-	forkEpoch := primitives.Epoch(100)
-	bCfg.AltairForkEpoch = forkEpoch
-	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.AltairForkVersion)] = primitives.Epoch(100)
+
+	bCfg.AltairForkEpoch = altairForkEpoch
+	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.AltairForkVersion)] = altairForkEpoch
+
+	bCfg.FuluForkEpoch = fuluForkEpoch
+	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.FuluForkVersion)] = fuluForkEpoch
+
 	params.OverrideBeaconConfig(bCfg)
 
-	// Garbage Message
-	badMsg := "wljdjska"
-	_, err := TopicFromMessage(badMsg, 0)
-	assert.ErrorContains(t, fmt.Sprintf("%s: %s", invalidRPCMessageType, badMsg), err)
-	// Before Fork
-	for m := range messageMapping {
-		topic, err := TopicFromMessage(m, 0)
-		assert.NoError(t, err)
+	t.Run("garbage message", func(t *testing.T) {
+		// Garbage Message
+		const badMsg = "wljdjska"
+		_, err := TopicFromMessage(badMsg, genesisEpoch)
+		require.ErrorContains(t, fmt.Sprintf("%s: %s", invalidRPCMessageType, badMsg), err)
+	})
 
-		assert.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
-		_, _, version, err := TopicDeconstructor(topic)
-		assert.NoError(t, err)
-		assert.Equal(t, SchemaVersionV1, version)
-	}
+	t.Run("before altair fork", func(t *testing.T) {
+		for m := range messageMapping {
+			topic, err := TopicFromMessage(m, genesisEpoch)
+			require.NoError(t, err)
 
-	// Altair Fork
-	for m := range messageMapping {
-		topic, err := TopicFromMessage(m, forkEpoch)
-		assert.NoError(t, err)
-
-		if altairMapping[m] {
-			assert.Equal(t, true, strings.Contains(topic, SchemaVersionV2))
+			require.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
 			_, _, version, err := TopicDeconstructor(topic)
-			assert.NoError(t, err)
-			assert.Equal(t, SchemaVersionV2, version)
-		} else {
-			assert.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
-			_, _, version, err := TopicDeconstructor(topic)
-			assert.NoError(t, err)
-			assert.Equal(t, SchemaVersionV1, version)
+			require.NoError(t, err)
+			require.Equal(t, SchemaVersionV1, version)
 		}
-	}
+	})
+
+	t.Run("after altair fork but before fulu fork", func(t *testing.T) {
+		for m := range messageMapping {
+			topic, err := TopicFromMessage(m, altairForkEpoch)
+			require.NoError(t, err)
+
+			if altairMapping[m] {
+				require.Equal(t, true, strings.Contains(topic, SchemaVersionV2))
+				_, _, version, err := TopicDeconstructor(topic)
+				require.NoError(t, err)
+				require.Equal(t, SchemaVersionV2, version)
+				continue
+			}
+
+			require.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
+			_, _, version, err := TopicDeconstructor(topic)
+			require.NoError(t, err)
+			require.Equal(t, SchemaVersionV1, version)
+		}
+	})
+
+	t.Run("after fulu fork", func(t *testing.T) {
+		for m := range messageMapping {
+			topic, err := TopicFromMessage(m, fuluForkEpoch)
+			require.NoError(t, err)
+
+			if fuluMapping[m] {
+				require.Equal(t, true, strings.Contains(topic, SchemaVersionV3))
+				_, _, version, err := TopicDeconstructor(topic)
+				require.NoError(t, err)
+				require.Equal(t, SchemaVersionV3, version)
+				continue
+			}
+
+			if altairMapping[m] {
+				require.Equal(t, true, strings.Contains(topic, SchemaVersionV2))
+				_, _, version, err := TopicDeconstructor(topic)
+				require.NoError(t, err)
+				require.Equal(t, SchemaVersionV2, version)
+				continue
+			}
+
+			require.Equal(t, true, strings.Contains(topic, SchemaVersionV1))
+			_, _, version, err := TopicDeconstructor(topic)
+			require.NoError(t, err)
+			require.Equal(t, SchemaVersionV1, version)
+		}
+	})
 }

beacon-chain/p2p/sender.go

@@ -22,8 +22,9 @@ func (s *Service) Send(ctx context.Context, message interface{}, baseTopic strin
 	ctx, span := trace.StartSpan(ctx, "p2p.Send")
 	defer span.End()
 	if err := VerifyTopicMapping(baseTopic, message); err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "verify topic mapping")
 	}
+
 	topic := baseTopic + s.Encoding().ProtocolSuffix()
 	span.SetAttributes(trace.StringAttribute("topic", topic))
 
@@ -39,19 +40,21 @@ func (s *Service) Send(ctx context.Context, message interface{}, baseTopic strin
 	stream, err := s.host.NewStream(ctx, pid, protocol.ID(topic))
 	if err != nil {
 		tracing.AnnotateError(span, err)
-		return nil, err
+		return nil, errors.Wrap(err, "new stream")
 	}
-	// do not encode anything if we are sending a metadata request
-	if baseTopic != RPCMetaDataTopicV1 && baseTopic != RPCMetaDataTopicV2 {
+
+	// Do not encode anything if we are sending a metadata request
+	if baseTopic != RPCMetaDataTopicV1 && baseTopic != RPCMetaDataTopicV2 && baseTopic != RPCMetaDataTopicV3 {
 		castedMsg, ok := message.(ssz.Marshaler)
 		if !ok {
 			return nil, errors.Errorf("%T does not support the ssz marshaller interface", message)
 		}
+
 		if _, err := s.Encoding().EncodeWithMaxLength(stream, castedMsg); err != nil {
 			tracing.AnnotateError(span, err)
 			_err := stream.Reset()
 			_ = _err
-			return nil, err
+			return nil, errors.Wrap(err, "encode with max length")
 		}
 	}
 
@@ -60,7 +63,7 @@ func (s *Service) Send(ctx context.Context, message interface{}, baseTopic strin
 		tracing.AnnotateError(span, err)
 		_err := stream.Reset()
 		_ = _err
-		return nil, err
+		return nil, errors.Wrap(err, "close write")
 	}
 
 	return stream, nil

beacon-chain/p2p/service.go

@@ -363,6 +363,15 @@ func (s *Service) ENR() *enr.Record {
 	return s.dv5Listener.Self().Record()
 }
 
+// NodeID returns the local node's node ID for discovery.
+func (s *Service) NodeID() enode.ID {
+	if s.dv5Listener == nil {
+		return enode.ID{}
+	}
+
+	return s.dv5Listener.Self().ID()
+}
+
 // DiscoveryAddresses represents our enr addresses as multiaddresses.
 func (s *Service) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	if s.dv5Listener == nil {

beacon-chain/p2p/subnets.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
@@ -29,8 +30,9 @@ var (
 	attestationSubnetCount = params.BeaconConfig().AttestationSubnetCount
 	syncCommsSubnetCount   = params.BeaconConfig().SyncCommitteeSubnetCount
 
-	attSubnetEnrKey       = params.BeaconNetworkConfig().AttSubnetKey
-	syncCommsSubnetEnrKey = params.BeaconNetworkConfig().SyncCommsSubnetKey
+	attSubnetEnrKey         = params.BeaconNetworkConfig().AttSubnetKey
+	syncCommsSubnetEnrKey   = params.BeaconNetworkConfig().SyncCommsSubnetKey
+	custodyGroupCountEnrKey = params.BeaconNetworkConfig().CustodyGroupCountKey
 )
 
 // The value used with the subnet, in order
@@ -47,7 +49,14 @@ const syncLockerVal = 100
 // chosen more than sync and attestation subnet combined.
 const blobSubnetLockerVal = 110
 
-// nodeFilter return a function that filters nodes based on the subnet topic and subnet index.
+// The value used with the data column sidecar subnet, in order
+// to create an appropriate key to retrieve
+// the relevant lock. This is used to differentiate
+// data column subnets from others. This is deliberately
+// chosen more than sync, attestation and blob subnet (6) combined.
+const dataColumnSubnetVal = 150
+
+// nodeFilter returns a function that filters nodes based on the subnet topic and subnet index.
 func (s *Service) nodeFilter(topic string, index uint64) (func(node *enode.Node) bool, error) {
 	switch {
 	case strings.Contains(topic, GossipAttestationMessage):
@@ -56,6 +65,8 @@ func (s *Service) nodeFilter(topic string, index uint64) (func(node *enode.Node)
 		return s.filterPeerForSyncSubnet(index), nil
 	case strings.Contains(topic, GossipBlobSidecarMessage):
 		return s.filterPeerForBlobSubnet(), nil
+	case strings.Contains(topic, GossipDataColumnSidecarMessage):
+		return s.filterPeerForDataColumnsSubnet(index), nil
 	default:
 		return nil, errors.Errorf("no subnet exists for provided topic: %s", topic)
 	}
@@ -276,6 +287,22 @@ func (s *Service) filterPeerForBlobSubnet() func(_ *enode.Node) bool {
 	}
 }
 
+// returns a method with filters peers specifically for a particular data column subnet.
+func (s *Service) filterPeerForDataColumnsSubnet(index uint64) func(node *enode.Node) bool {
+	return func(node *enode.Node) bool {
+		if !s.filterPeer(node) {
+			return false
+		}
+
+		subnets, err := dataColumnSubnets(node.ID(), node.Record())
+		if err != nil {
+			return false
+		}
+
+		return subnets[index]
+	}
+}
+
 // lower threshold to broadcast object compared to searching
 // for a subnet. So that even in the event of poor peer
 // connectivity, we can still broadcast an attestation.
@@ -321,6 +348,35 @@ func (s *Service) updateSubnetRecordWithMetadataV2(bitVAtt bitfield.Bitvector64,
 	})
 }
 
+// updateSubnetRecordWithMetadataV3 updates:
+// - attestation subnet tracked,
+// - sync subnets tracked, and
+// - custody subnet count
+// both in the node's record and in the node's metadata.
+func (s *Service) updateSubnetRecordWithMetadataV3(
+	bitVAtt bitfield.Bitvector64,
+	bitVSync bitfield.Bitvector4,
+	custodyGroupCount uint64,
+) {
+	attSubnetsEntry := enr.WithEntry(attSubnetEnrKey, &bitVAtt)
+	syncSubnetsEntry := enr.WithEntry(syncCommsSubnetEnrKey, &bitVSync)
+	custodyGroupCountEntry := enr.WithEntry(custodyGroupCountEnrKey, custodyGroupCount)
+
+	localNode := s.dv5Listener.LocalNode()
+	localNode.Set(attSubnetsEntry)
+	localNode.Set(syncSubnetsEntry)
+	localNode.Set(custodyGroupCountEntry)
+
+	newSeqNumber := s.metaData.SequenceNumber() + 1
+
+	s.metaData = wrapper.WrappedMetadataV2(&pb.MetaDataV2{
+		SeqNumber:         newSeqNumber,
+		Attnets:           bitVAtt,
+		Syncnets:          bitVSync,
+		CustodyGroupCount: custodyGroupCount,
+	})
+}
+
 func initializePersistentSubnets(id enode.ID, epoch primitives.Epoch) error {
 	_, ok, expTime := cache.SubnetIDs.GetPersistentSubnets()
 	if ok && expTime.After(time.Now()) {
@@ -458,6 +514,24 @@ func syncSubnets(record *enr.Record) ([]uint64, error) {
 	return committeeIdxs, nil
 }
 
+// Retrieve the data columns subnets from a node's ENR and node ID.
+func dataColumnSubnets(nodeID enode.ID, record *enr.Record) (map[uint64]bool, error) {
+	// Retrieve the custody count from the ENR.
+	custodyGroupCount, err := peerdas.CustodyGroupCountFromRecord(record)
+	if err != nil {
+		return nil, errors.Wrap(err, "custody group count from record")
+	}
+
+	// Retrieve the peer info.
+	peerInfo, _, err := peerdas.Info(nodeID, custodyGroupCount)
+	if err != nil {
+		return nil, errors.Wrap(err, "peer info")
+	}
+
+	// Get custody columns subnets from the columns.
+	return peerInfo.DataColumnsSubnets, nil
+}
+
 // Parses the attestation subnets ENR entry in a node and extracts its value
 // as a bitvector for further manipulation.
 func attBitvector(record *enr.Record) (bitfield.Bitvector64, error) {
@@ -484,14 +558,16 @@ func syncBitvector(record *enr.Record) (bitfield.Bitvector4, error) {
 
 // The subnet locker is a map which keeps track of all
 // mutexes stored per subnet. This locker is reused
-// between both the attestation, sync and blob subnets.
+// between both the attestation, sync blob and data column subnets.
 // Sync subnets are stored by (subnet+syncLockerVal).
 // Blob subnets are stored by (subnet+blobSubnetLockerVal).
+// Data column subnets are stored by (subnet+dataColumnSubnetVal).
 // This is to prevent conflicts while allowing subnets
 // to use a single locker.
 func (s *Service) subnetLocker(i uint64) *sync.RWMutex {
 	s.subnetsLockLock.Lock()
 	defer s.subnetsLockLock.Unlock()
+
 	l, ok := s.subnetsLock[i]
 	if !ok {
 		l = &sync.RWMutex{}

beacon-chain/p2p/subnets_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	ecdsaprysm "github.com/OffchainLabs/prysm/v6/crypto/ecdsa"
@@ -503,6 +504,26 @@ func Test_SyncSubnets(t *testing.T) {
 	}
 }
 
+func TestDataColumnSubnets(t *testing.T) {
+	const cgc = 3
+
+	var (
+		nodeID enode.ID
+		record enr.Record
+	)
+
+	record.Set(peerdas.Cgc(cgc))
+
+	expected := map[uint64]bool{1: true, 87: true, 102: true}
+	actual, err := dataColumnSubnets(nodeID, &record)
+	assert.NoError(t, err)
+
+	require.Equal(t, len(expected), len(actual))
+	for subnet := range expected {
+		require.Equal(t, true, actual[subnet])
+	}
+}
+
 func TestSubnetComputation(t *testing.T) {
 	db, err := enode.OpenDB("")
 	assert.NoError(t, err)

beacon-chain/p2p/testing/BUILD.bazel

@@ -17,9 +17,12 @@ go_library(
         "//beacon-chain:__subpackages__",
     ],
     deps = [
+        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/p2p/encoder:go_default_library",
         "//beacon-chain/p2p/peers:go_default_library",
         "//beacon-chain/p2p/peers/scorers:go_default_library",
+        "//config/fieldparams:go_default_library",
+        "//config/params:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -5,9 +5,11 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	"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"
 	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"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/control"
@@ -56,6 +58,11 @@ func (*FakeP2P) ENR() *enr.Record {
 	return new(enr.Record)
 }
 
+// NodeID returns the node id of the local peer.
+func (*FakeP2P) NodeID() enode.ID {
+	return enode.ID{}
+}
+
 // DiscoveryAddresses -- fake
 func (*FakeP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return nil, nil
@@ -159,6 +166,11 @@ func (*FakeP2P) BroadcastLightClientFinalityUpdate(_ context.Context, _ interfac
 	return nil
 }
 
+// BroadcastDataColumn -- fake.
+func (*FakeP2P) BroadcastDataColumn(_ [fieldparams.RootLength]byte, _ uint64, _ *ethpb.DataColumnSidecar, _ ...chan<- bool) error {
+	return nil
+}
+
 // InterceptPeerDial -- fake.
 func (*FakeP2P) InterceptPeerDial(peer.ID) (allow bool) {
 	return true
@@ -183,3 +195,7 @@ func (*FakeP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiad
 func (*FakeP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
 	return true, 0
 }
+
+func (*FakeP2P) CustodyGroupCountFromPeer(peer.ID) uint64 {
+	return 0
+}

beacon-chain/p2p/testing/mock_broadcaster.go

@@ -5,6 +5,7 @@ import (
 	"sync"
 	"sync/atomic"
 
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"google.golang.org/protobuf/proto"
@@ -61,6 +62,12 @@ func (m *MockBroadcaster) BroadcastLightClientFinalityUpdate(_ context.Context,
 	return nil
 }
 
+// BroadcastDataColumn broadcasts a data column for mock.
+func (m *MockBroadcaster) BroadcastDataColumn([fieldparams.RootLength]byte, uint64, *ethpb.DataColumnSidecar, ...chan<- bool) error {
+	m.BroadcastCalled.Store(true)
+	return nil
+}
+
 // NumMessages returns the number of messages broadcasted.
 func (m *MockBroadcaster) NumMessages() int {
 	m.msgLock.Lock()

beacon-chain/p2p/testing/mock_peermanager.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 
+	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -39,6 +40,11 @@ func (m *MockPeerManager) ENR() *enr.Record {
 	return m.Enr
 }
 
+// NodeID .
+func (m MockPeerManager) NodeID() enode.ID {
+	return enode.ID{}
+}
+
 // DiscoveryAddresses .
 func (m *MockPeerManager) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	if m.FailDiscoveryAddr {

beacon-chain/p2p/testing/p2p.go

@@ -10,9 +10,12 @@ import (
 	"testing"
 	"time"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
+	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
+	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/metadata"
@@ -220,6 +223,12 @@ func (p *TestP2P) BroadcastLightClientFinalityUpdate(_ context.Context, _ interf
 	return nil
 }
 
+// BroadcastDataColumn broadcasts a data column for mock.
+func (p *TestP2P) BroadcastDataColumn([fieldparams.RootLength]byte, uint64, *ethpb.DataColumnSidecar, ...chan<- bool) error {
+	p.BroadcastCalled.Store(true)
+	return nil
+}
+
 // SetStreamHandler for RPC.
 func (p *TestP2P) SetStreamHandler(topic string, handler network.StreamHandler) {
 	p.BHost.SetStreamHandler(protocol.ID(topic), handler)
@@ -451,3 +460,22 @@ func (*TestP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiad
 func (*TestP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
 	return true, 0
 }
+
+func (s *TestP2P) CustodyGroupCountFromPeer(pid peer.ID) uint64 {
+	// By default, we assume the peer custodies the minimum number of groups.
+	custodyRequirement := params.BeaconConfig().CustodyRequirement
+
+	// Retrieve the ENR of the peer.
+	record, err := s.peers.ENR(pid)
+	if err != nil {
+		return custodyRequirement
+	}
+
+	// Retrieve the custody subnets count from the ENR.
+	custodyGroupCount, err := peerdas.CustodyGroupCountFromRecord(record)
+	if err != nil {
+		return custodyRequirement
+	}
+
+	return custodyGroupCount
+}

beacon-chain/p2p/topics.go

@@ -34,6 +34,9 @@ const (
 	GossipLightClientFinalityUpdateMessage = "light_client_finality_update"
 	// GossipLightClientOptimisticUpdateMessage is the name for the light client optimistic update message type.
 	GossipLightClientOptimisticUpdateMessage = "light_client_optimistic_update"
+	// GossipDataColumnSidecarMessage is the name for the data column sidecar message type.
+	GossipDataColumnSidecarMessage = "data_column_sidecar"
+
 	// Topic Formats
 	//
 	// AttestationSubnetTopicFormat is the topic format for the attestation subnet.
@@ -60,4 +63,6 @@ const (
 	LightClientFinalityUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientFinalityUpdateMessage
 	// LightClientOptimisticUpdateTopicFormat is the topic format for the light client optimistic update subnet.
 	LightClientOptimisticUpdateTopicFormat = GossipProtocolAndDigest + GossipLightClientOptimisticUpdateMessage
+	// DataColumnSubnetTopicFormat is the topic format for the data column subnet.
+	DataColumnSubnetTopicFormat = GossipProtocolAndDigest + GossipDataColumnSidecarMessage + "_%d"
 )

beacon-chain/p2p/types/BUILD.bazel

@@ -41,6 +41,7 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
+        "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",

beacon-chain/p2p/types/object_mapping.go

@@ -108,7 +108,7 @@ func InitializeDataMaps() {
 			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
 		},
 		bytesutil.ToBytes4(params.BeaconConfig().FuluForkVersion): func() (metadata.Metadata, error) {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+			return wrapper.WrappedMetadataV2(&ethpb.MetaDataV2{}), nil
 		},
 	}
 

beacon-chain/p2p/types/rpc_errors.go

@@ -12,7 +12,7 @@ var (
 	ErrRateLimited         = errors.New("rate limited")
 	ErrIODeadline          = errors.New("i/o deadline exceeded")
 	ErrInvalidRequest      = errors.New("invalid range, step or count")
-	ErrBlobLTMinRequest    = errors.New("blob slot < minimum_request_epoch")
+	ErrBlobLTMinRequest    = errors.New("blob epoch < minimum_request_epoch")
 	ErrMaxBlobReqExceeded  = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
 	ErrResourceUnavailable = errors.New("resource requested unavailable")
 )

beacon-chain/p2p/types/types.go

@@ -5,6 +5,7 @@ package types
 
 import (
 	"bytes"
+	"encoding/binary"
 	"sort"
 
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -14,7 +15,10 @@ import (
 	ssz "github.com/prysmaticlabs/fastssz"
 )
 
-const maxErrorLength = 256
+const (
+	maxErrorLength       = 256
+	bytesPerLengthOffset = 4
+)
 
 // SSZBytes is a bytes slice that satisfies the fast-ssz interface.
 type SSZBytes []byte
@@ -182,23 +186,23 @@ func (b *BlobSidecarsByRootReq) UnmarshalSSZ(buf []byte) error {
 	return nil
 }
 
-var _ sort.Interface = BlobSidecarsByRootReq{}
+var _ sort.Interface = (*BlobSidecarsByRootReq)(nil)
 
 // Less reports whether the element with index i must sort before the element with index j.
 // BlobIdentifier will be sorted in lexicographic order by root, with Blob Index as tiebreaker for a given root.
 func (s BlobSidecarsByRootReq) Less(i, j int) bool {
-	rootCmp := bytes.Compare(s[i].BlockRoot, s[j].BlockRoot)
+	rootCmp := bytes.Compare((s)[i].BlockRoot, (s)[j].BlockRoot)
 	if rootCmp != 0 {
 		// They aren't equal; return true if i < j, false if i > j.
 		return rootCmp < 0
 	}
 	// They are equal; blob index is the tie breaker.
-	return s[i].Index < s[j].Index
+	return (s)[i].Index < (s)[j].Index
 }
 
 // Swap swaps the elements with indexes i and j.
 func (s BlobSidecarsByRootReq) Swap(i, j int) {
-	s[i], s[j] = s[j], s[i]
+	(s)[i], (s)[j] = (s)[j], (s)[i]
 }
 
 // Len is the number of elements in the collection.
@@ -206,7 +210,130 @@ func (s BlobSidecarsByRootReq) Len() int {
 	return len(s)
 }
 
-func init() {
-	sizer := &eth.BlobIdentifier{}
-	blobIdSize = sizer.SizeSSZ()
+// ====================================
+// DataColumnsByRootIdentifiers section
+// ====================================
+var _ ssz.Marshaler = (*DataColumnsByRootIdentifiers)(nil)
+var _ ssz.Unmarshaler = (*DataColumnsByRootIdentifiers)(nil)
+
+// DataColumnsByRootIdentifiers is used to specify a list of data column targets (root+index) in a DataColumnSidecarsByRoot RPC request.
+type DataColumnsByRootIdentifiers []*eth.DataColumnsByRootIdentifier
+
+// DataColumnIdentifier is a fixed size value, so we can compute its fixed size at start time (see init below)
+var dataColumnIdSize int
+
+// UnmarshalSSZ implements ssz.Unmarshaler. It unmarshals the provided bytes buffer into the DataColumnSidecarsByRootReq value.
+func (d *DataColumnsByRootIdentifiers) UnmarshalSSZ(buf []byte) error {
+	// Exit early if the buffer is too small.
+	if len(buf) < bytesPerLengthOffset {
+		return nil
+	}
+
+	// Get the size of the offsets.
+	offsetEnd := binary.LittleEndian.Uint32(buf[:bytesPerLengthOffset])
+	if offsetEnd%bytesPerLengthOffset != 0 {
+		return errors.Errorf("expected offsets size to be a multiple of %d but got %d", bytesPerLengthOffset, offsetEnd)
+	}
+
+	count := offsetEnd / bytesPerLengthOffset
+	if count < 1 {
+		return nil
+	}
+
+	maxSize := params.BeaconConfig().MaxRequestBlocksDeneb
+	if uint64(count) > maxSize {
+		return errors.Errorf("data column identifiers list exceeds max size: %d > %d", count, maxSize)
+	}
+
+	if offsetEnd > uint32(len(buf)) {
+		return errors.Errorf("offsets value %d larger than buffer %d", offsetEnd, len(buf))
+	}
+	valueStart := offsetEnd
+
+	// Decode the identifers.
+	*d = make([]*eth.DataColumnsByRootIdentifier, count)
+	var start uint32
+	end := uint32(len(buf))
+	for i := count; i > 0; i-- {
+		offsetEnd -= bytesPerLengthOffset
+		start = binary.LittleEndian.Uint32(buf[offsetEnd : offsetEnd+bytesPerLengthOffset])
+		if start > end {
+			return errors.Errorf("expected offset[%d] %d to be less than %d", i-1, start, end)
+		}
+		if start < valueStart {
+			return errors.Errorf("offset[%d] %d indexes before value section %d", i-1, start, valueStart)
+		}
+		// Decode the identifier.
+		ident := &eth.DataColumnsByRootIdentifier{}
+		if err := ident.UnmarshalSSZ(buf[start:end]); err != nil {
+			return err
+		}
+		(*d)[i-1] = ident
+		end = start
+	}
+
+	return nil
+}
+
+func (d *DataColumnsByRootIdentifiers) MarshalSSZ() ([]byte, error) {
+	var err error
+	count := len(*d)
+	maxSize := params.BeaconConfig().MaxRequestBlocksDeneb
+	if uint64(count) > maxSize {
+		return nil, errors.Errorf("data column identifiers list exceeds max size: %d > %d", count, maxSize)
+	}
+
+	if len(*d) == 0 {
+		return []byte{}, nil
+	}
+	sizes := make([]uint32, count)
+	valTotal := uint32(0)
+	for i, elem := range *d {
+		if elem == nil {
+			return nil, errors.New("nil item in DataColumnsByRootIdentifiers list")
+		}
+		sizes[i] = uint32(elem.SizeSSZ())
+		valTotal += sizes[i]
+	}
+	offSize := uint32(4 * len(*d))
+	out := make([]byte, offSize, offSize+valTotal)
+	for i := range sizes {
+		binary.LittleEndian.PutUint32(out[i*4:i*4+4], offSize)
+		offSize += sizes[i]
+	}
+	for _, elem := range *d {
+		out, err = elem.MarshalSSZTo(out)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return out, nil
+}
+
+// MarshalSSZTo implements ssz.Marshaler. It appends the serialized DataColumnSidecarsByRootReq value to the provided byte slice.
+func (d *DataColumnsByRootIdentifiers) MarshalSSZTo(dst []byte) ([]byte, error) {
+	obj, err := d.MarshalSSZ()
+	if err != nil {
+		return nil, err
+	}
+	return append(dst, obj...), nil
+}
+
+// SizeSSZ implements ssz.Marshaler. It returns the size of the serialized representation.
+func (d *DataColumnsByRootIdentifiers) SizeSSZ() int {
+	size := 0
+	for i := 0; i < len(*d); i++ {
+		size += 4
+		size += (*d)[i].SizeSSZ()
+	}
+	return size
+}
+
+func init() {
+	blobSizer := &eth.BlobIdentifier{}
+	blobIdSize = blobSizer.SizeSSZ()
+
+	dataColumnSizer := &eth.DataColumnSidecarsByRangeRequest{}
+	dataColumnIdSize = dataColumnSizer.SizeSSZ()
 }