adding generated code

* EIP-7549: p2p and sync

* small cleanup

* fuzz fix

* deepsource

* review

* fix ineffectual assignment

* fix pubsub

* update ComputeSubnetForAttestation

* review

* review

.bazelrc

@@ -22,7 +22,6 @@ coverage --define=coverage_enabled=1
 build --workspace_status_command=./hack/workspace_status.sh
 
 build --define blst_disabled=false
-build --compilation_mode=opt
 run --define blst_disabled=false
 
 build:blst_disabled --define blst_disabled=true

BUILD.bazel

@@ -1,3 +1,4 @@
+load("@prysm//tools/go:def.bzl", "go_library")
 load("@bazel_gazelle//:def.bzl", "gazelle")
 load("@com_github_atlassian_bazel_tools//gometalinter:def.bzl", "gometalinter")
 load("@com_github_atlassian_bazel_tools//goimports:def.bzl", "goimports")
@@ -286,3 +287,14 @@ sh_binary(
     srcs = ["prysm.sh"],
     visibility = ["//visibility:public"],
 )
+
+go_library(
+    name = "go_default_library",
+    srcs = ["derp.go"],
+    importpath = "github.com/prysmaticlabs/prysm/v5",
+    visibility = ["//visibility:public"],
+    deps = [
+        "@com_github_prysmaticlabs_fastssz//:go_default_library",
+        "@com_github_prysmaticlabs_go_bitfield//:go_default_library",
+    ],
+)

api/server/middleware/middleware_test.go

@@ -31,7 +31,7 @@ func TestNormalizeQueryValuesHandler(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			req, err := http.NewRequest("GET", "/test?"+test.inputQuery, nil)
+			req, err := http.NewRequest("GET", "/test?"+test.inputQuery, http.NoBody)
 			if err != nil {
 				t.Fatal(err)
 			}

beacon-chain/blockchain/BUILD.bazel

@@ -26,7 +26,6 @@ go_library(
         "receive_attestation.go",
         "receive_blob.go",
         "receive_block.go",
-        "receive_data_column.go",
         "service.go",
         "tracked_proposer.go",
         "weak_subjectivity_checks.go",
@@ -49,7 +48,6 @@ go_library(
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/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",
@@ -159,7 +157,6 @@ go_test(
         "//beacon-chain/operations/slashings:go_default_library",
         "//beacon-chain/operations/voluntaryexits:go_default_library",
         "//beacon-chain/p2p:go_default_library",
-        "//beacon-chain/p2p/testing:go_default_library",
         "//beacon-chain/startup:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",

beacon-chain/blockchain/error.go

@@ -33,7 +33,6 @@ var (
 )
 
 var errMaxBlobsExceeded = errors.New("Expected commitments in block exceeds MAX_BLOBS_PER_BLOCK")
-var errMaxDataColumnsExceeded = errors.New("Expected data columns for node exceeds NUMBER_OF_COLUMNS")
 
 // 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.

beacon-chain/blockchain/kzg/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "kzg.go",
         "trusted_setup.go",
         "validation.go",
     ],
@@ -13,9 +12,6 @@ go_library(
     deps = [
         "//consensus-types/blocks:go_default_library",
         "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
-        "@com_github_ethereum_c_kzg_4844//bindings/go:go_default_library",
-        "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_ethereum_go_ethereum//crypto/kzg4844:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
     ],
 )
@@ -23,7 +19,6 @@ go_library(
 go_test(
     name = "go_default_test",
     srcs = [
-        "kzg_test.go",
         "trusted_setup_test.go",
         "validation_test.go",
     ],

beacon-chain/blockchain/kzg/kzg.go

@@ -1,178 +0,0 @@
-package kzg
-
-import (
-	"errors"
-
-	ckzg4844 "github.com/ethereum/c-kzg-4844/bindings/go"
-	"github.com/ethereum/go-ethereum/crypto/kzg4844"
-)
-
-// Blob represents a serialized chunk of data.
-type Blob [BytesPerBlob]byte
-
-// Commitment represent a KZG commitment to a Blob.
-type Commitment [48]byte
-
-// Proof represents a KZG proof that attests to the validity of a Blob or parts of it.
-type Proof [48]byte
-
-// Bytes48 is a 48-byte array.
-type Bytes48 = ckzg4844.Bytes48
-
-// Bytes32 is a 32-byte array.
-type Bytes32 = ckzg4844.Bytes32
-
-// BytesPerCell is the number of bytes in a single cell.
-const BytesPerCell = ckzg4844.FieldElementsPerCell * ckzg4844.BytesPerFieldElement
-
-// BytesPerBlob is the number of bytes in a single blob.
-const BytesPerBlob = ckzg4844.BytesPerBlob
-
-// fieldElementsPerCell is the number of field elements in a single cell.
-const fieldElementsPerCell = ckzg4844.FieldElementsPerCell
-
-// CellsPerExtBlob is the number of cells that we generate for a single blob.
-// This is equivalent to the number of columns in the data matrix.
-const CellsPerExtBlob = ckzg4844.CellsPerExtBlob
-
-// Cell represents a chunk of an encoded Blob.
-type Cell [BytesPerCell]byte
-
-// CellsAndProofs represents the Cells and Proofs corresponding to
-// a single blob.
-type CellsAndProofs struct {
-	Cells  [ckzg4844.CellsPerExtBlob]Cell
-	Proofs [ckzg4844.CellsPerExtBlob]Proof
-}
-
-func BlobToKZGCommitment(blob *Blob) (Commitment, error) {
-	comm, err := kzg4844.BlobToCommitment(kzg4844.Blob(*blob))
-	if err != nil {
-		return Commitment{}, err
-	}
-	return Commitment(comm), nil
-}
-
-func ComputeBlobKZGProof(blob *Blob, commitment Commitment) (Proof, error) {
-	proof, err := kzg4844.ComputeBlobProof(kzg4844.Blob(*blob), kzg4844.Commitment(commitment))
-	if err != nil {
-		return [48]byte{}, err
-	}
-	return Proof(proof), nil
-}
-
-func ComputeCellsAndKZGProofs(blob *Blob) (CellsAndProofs, error) {
-	ckzgBlob := ckzg4844.Blob(*blob)
-	_cells, _proofs, err := ckzg4844.ComputeCellsAndKZGProofs(&ckzgBlob)
-	if err != nil {
-		return CellsAndProofs{}, err
-	}
-
-	// Convert Cells and Proofs to types defined in this package
-	var cells [ckzg4844.CellsPerExtBlob]Cell
-	for i := range _cells {
-		cells[i] = ckzgCellToCell(&_cells[i])
-	}
-
-	var proofs [ckzg4844.CellsPerExtBlob]Proof
-	for i := range _proofs {
-		proofs[i] = Proof(_proofs[i])
-	}
-
-	return CellsAndProofs{
-		Cells:  cells,
-		Proofs: proofs,
-	}, nil
-}
-
-// VerifyCellKZGProof is unused. TODO: We can check when the batch size for `VerifyCellKZGProofBatch` is 1
-// and call this, though I think its better if the cryptography library handles this.
-func VerifyCellKZGProof(commitmentBytes Bytes48, cellId uint64, cell *Cell, proofBytes Bytes48) (bool, error) {
-	return ckzg4844.VerifyCellKZGProof(commitmentBytes, cellId, cellToCKZGCell(cell), proofBytes)
-}
-
-func VerifyCellKZGProofBatch(commitmentsBytes []Bytes48, rowIndices, columnIndices []uint64, _cells []Cell, proofsBytes []Bytes48) (bool, error) {
-	// Convert `Cell` type to `ckzg4844.Cell`
-	ckzgCells := make([]ckzg4844.Cell, len(_cells))
-	for i := range _cells {
-		ckzgCells[i] = cellToCKZGCell(&_cells[i])
-	}
-
-	return ckzg4844.VerifyCellKZGProofBatch(commitmentsBytes, rowIndices, columnIndices, ckzgCells, proofsBytes)
-}
-
-func recoverAllCells(cellIds []uint64, _cells []Cell) ([ckzg4844.CellsPerExtBlob]Cell, error) {
-	// Convert `Cell` type to `ckzg4844.Cell`
-	ckzgCells := make([]ckzg4844.Cell, len(_cells))
-	for i := range _cells {
-		ckzgCells[i] = cellToCKZGCell(&_cells[i])
-	}
-
-	recoveredCells, err := ckzg4844.RecoverAllCells(cellIds, ckzgCells)
-	if err != nil {
-		return [ckzg4844.CellsPerExtBlob]Cell{}, err
-	}
-
-	// This should never happen, we return an error instead of panicking.
-	if len(recoveredCells) != ckzg4844.CellsPerExtBlob {
-		return [ckzg4844.CellsPerExtBlob]Cell{}, errors.New("recovered cells length is not equal to CellsPerExtBlob")
-	}
-
-	// Convert `ckzg4844.Cell` type to `Cell`
-	var ret [ckzg4844.CellsPerExtBlob]Cell
-	for i := range recoveredCells {
-		ret[i] = ckzgCellToCell(&recoveredCells[i])
-	}
-	return ret, nil
-}
-
-// RecoverCellsAndKZGProofs recovers the cells and compute the KZG Proofs associated with the cells.
-func RecoverCellsAndKZGProofs(cellIds []uint64, _cells []Cell) (CellsAndProofs, error) {
-	// First recover all of the cells
-	recoveredCells, err := recoverAllCells(cellIds, _cells)
-	if err != nil {
-		return CellsAndProofs{}, err
-	}
-
-	// Extract the Blob from all of the Cells
-	blob, err := cellsToBlob(&recoveredCells)
-	if err != nil {
-		return CellsAndProofs{}, err
-	}
-
-	// Compute all of the cells and KZG proofs
-	return ComputeCellsAndKZGProofs(&blob)
-}
-
-func cellsToBlob(_cells *[ckzg4844.CellsPerExtBlob]Cell) (Blob, error) {
-	// Convert `Cell` type to `ckzg4844.Cell`
-	var ckzgCells [ckzg4844.CellsPerExtBlob]ckzg4844.Cell
-	for i := range _cells {
-		ckzgCells[i] = cellToCKZGCell(&_cells[i])
-	}
-
-	blob, err := ckzg4844.CellsToBlob(ckzgCells)
-	if err != nil {
-		return Blob{}, err
-	}
-
-	return Blob(blob), nil
-}
-
-// The correct type for Cell is [BytesPerCell]byte
-// c-kzg currently uses [BytesPerFieldElement]Bytes32
-// so we have these helper methods to convert between the two.
-func cellToCKZGCell(flattened *Cell) ckzg4844.Cell {
-	var cell ckzg4844.Cell
-	for i := 0; i < fieldElementsPerCell; i++ {
-		copy(cell[i][:], flattened[i*32:(i+1)*32])
-	}
-	return cell
-}
-func ckzgCellToCell(cell *ckzg4844.Cell) Cell {
-	var flattened Cell
-	for i, fieldElement := range cell {
-		copy(flattened[i*32:(i+1)*32], fieldElement[:])
-	}
-	return flattened
-}

beacon-chain/blockchain/kzg/kzg_test.go

@@ -1,21 +0,0 @@
-package kzg
-
-import "testing"
-
-func TestCellFlattenedChunked(t *testing.T) {
-	cell := makeCell()
-	chunkedCell := cellToCKZGCell(&cell)
-	flattenedCell := ckzgCellToCell(&chunkedCell)
-	if cell != flattenedCell {
-		t.Errorf("cell != flattenedCell")
-	}
-}
-
-func makeCell() Cell {
-	var cell Cell
-	for i := 0; i < fieldElementsPerCell; i++ {
-		rand32 := deterministicRandomness(int64(i))
-		copy(cell[i*32:], rand32[:])
-	}
-	return cell
-}

beacon-chain/blockchain/kzg/trusted_setup.go

@@ -5,8 +5,6 @@ import (
 	"encoding/json"
 
 	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	CKZG "github.com/ethereum/c-kzg-4844/bindings/go"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
 )
 
@@ -14,38 +12,17 @@ var (
 	//go:embed trusted_setup.json
 	embeddedTrustedSetup []byte // 1.2Mb
 	kzgContext           *GoKZG.Context
-	kzgLoaded            bool
 )
 
 func Start() error {
-	parsedSetup := &GoKZG.JSONTrustedSetup{}
-	err := json.Unmarshal(embeddedTrustedSetup, parsedSetup)
+	parsedSetup := GoKZG.JSONTrustedSetup{}
+	err := json.Unmarshal(embeddedTrustedSetup, &parsedSetup)
 	if err != nil {
 		return errors.Wrap(err, "could not parse trusted setup JSON")
 	}
-	kzgContext, err = GoKZG.NewContext4096(parsedSetup)
+	kzgContext, err = GoKZG.NewContext4096(&parsedSetup)
 	if err != nil {
 		return errors.Wrap(err, "could not initialize go-kzg context")
 	}
-	g1Lagrange := &parsedSetup.SetupG1Lagrange
-
-	// Length of a G1 point, converted from hex to binary.
-	g1s := make([]byte, len(g1Lagrange)*(len(g1Lagrange[0])-2)/2)
-	for i, g1 := range g1Lagrange {
-		copy(g1s[i*(len(g1)-2)/2:], hexutil.MustDecode(g1))
-	}
-	// Length of a G2 point, converted from hex to binary.
-	g2s := make([]byte, len(parsedSetup.SetupG2)*(len(parsedSetup.SetupG2[0])-2)/2)
-	for i, g2 := range parsedSetup.SetupG2 {
-		copy(g2s[i*(len(g2)-2)/2:], hexutil.MustDecode(g2))
-	}
-	if !kzgLoaded {
-		// Free the current trusted setup before running this method. CKZG
-		// panics if the same setup is run multiple times.
-		if err = CKZG.LoadTrustedSetup(g1s, g2s); err != nil {
-			panic(err)
-		}
-	}
-	kzgLoaded = true
 	return nil
 }

beacon-chain/blockchain/options.go

@@ -118,9 +118,9 @@ func WithBLSToExecPool(p blstoexec.PoolManager) Option {
 }
 
 // WithP2PBroadcaster to broadcast messages after appropriate processing.
-func WithP2PBroadcaster(p p2p.Acceser) Option {
+func WithP2PBroadcaster(p p2p.Broadcaster) Option {
 	return func(s *Service) error {
-		s.cfg.P2P = p
+		s.cfg.P2p = p
 		return nil
 	}
 }

beacon-chain/blockchain/process_block.go

@@ -13,7 +13,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/das"
@@ -501,7 +500,7 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 	}
 	indices, err := bs.Indices(root)
 	if err != nil {
-		return nil, errors.Wrap(err, "indices")
+		return nil, err
 	}
 	missing := make(map[uint64]struct{}, len(expected))
 	for i := range expected {
@@ -515,35 +514,12 @@ func missingIndices(bs *filesystem.BlobStorage, root [32]byte, expected [][]byte
 	return missing, nil
 }
 
-func missingDataColumns(bs *filesystem.BlobStorage, root [32]byte, expected map[uint64]bool) (map[uint64]bool, error) {
-	if len(expected) == 0 {
-		return nil, nil
-	}
-	if len(expected) > int(params.BeaconConfig().NumberOfColumns) {
-		return nil, errMaxDataColumnsExceeded
-	}
-	indices, err := bs.ColumnIndices(root)
-	if err != nil {
-		return nil, err
-	}
-	missing := make(map[uint64]bool, len(expected))
-	for col := range expected {
-		if !indices[col] {
-			missing[col] = true
-		}
-	}
-	return missing, nil
-}
-
 // 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 coreTime.PeerDASIsActive(signed.Block().Slot()) {
-		return s.isDataAvailableDataColumns(ctx, root, signed)
-	}
 	if signed.Version() < version.Deneb {
 		return nil
 	}
@@ -573,7 +549,7 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	// get a map of BlobSidecar indices that are not currently available.
 	missing, err := missingIndices(s.blobStorage, root, kzgCommitments)
 	if err != nil {
-		return errors.Wrap(err, "missing indices")
+		return err
 	}
 	// If there are no missing indices, all BlobSidecars are available.
 	if len(missing) == 0 {
@@ -592,13 +568,8 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 			if len(missing) == 0 {
 				return
 			}
-
-			log.WithFields(logrus.Fields{
-				"slot":          signed.Block().Slot(),
-				"root":          fmt.Sprintf("%#x", root),
-				"blobsExpected": expected,
-				"blobsWaiting":  len(missing),
-			}).Error("Still waiting for blobs DA check at slot end.")
+			log.WithFields(daCheckLogFields(root, signed.Block().Slot(), expected, len(missing))).
+				Error("Still waiting for DA check at slot end.")
 		})
 		defer nst.Stop()
 	}
@@ -620,100 +591,12 @@ func (s *Service) isDataAvailable(ctx context.Context, root [32]byte, signed int
 	}
 }
 
-func (s *Service) isDataAvailableDataColumns(ctx context.Context, root [32]byte, signed interfaces.ReadOnlySignedBeaconBlock) error {
-	if signed.Version() < version.Deneb {
-		return nil
-	}
-
-	block := signed.Block()
-	if block == nil {
-		return errors.New("invalid nil beacon block")
-	}
-	// We are only required to check within MIN_EPOCHS_FOR_BLOB_SIDECARS_REQUESTS
-	if !params.WithinDAPeriod(slots.ToEpoch(block.Slot()), slots.ToEpoch(s.CurrentSlot())) {
-		return nil
-	}
-	body := block.Body()
-	if body == nil {
-		return errors.New("invalid nil beacon block body")
-	}
-	kzgCommitments, err := body.BlobKzgCommitments()
-	if err != nil {
-		return errors.Wrap(err, "could not get KZG commitments")
-	}
-	// If block has not commitments there is nothing to wait for.
-	if len(kzgCommitments) == 0 {
-		return nil
-	}
-
-	colMap, err := peerdas.CustodyColumns(s.cfg.P2P.NodeID(), peerdas.CustodySubnetCount())
-	if err != nil {
-		return err
-	}
-	// Expected is the number of custodied data columnns a node is expected to have.
-	expected := len(colMap)
-	if expected == 0 {
-		return nil
-	}
-
-	// Subscribe to newsly data columns stored in the database.
-	rootIndexChan := make(chan filesystem.RootIndexPair)
-	subscription := s.blobStorage.DataColumnFeed.Subscribe(rootIndexChan)
-	defer subscription.Unsubscribe()
-
-	// Get a map of data column indices that are not currently available.
-	missing, err := missingDataColumns(s.blobStorage, root, colMap)
-	if err != nil {
-		return err
-	}
-
-	// If there are no missing indices, all data column sidecars are available.
-	// This is the happy path.
-	if len(missing) == 0 {
-		return nil
-	}
-
-	// Log for DA checks that cross over into the next slot; helpful for debugging.
-	nextSlot := slots.BeginsAt(signed.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(logrus.Fields{
-				"slot":            signed.Block().Slot(),
-				"root":            fmt.Sprintf("%#x", root),
-				"columnsExpected": expected,
-				"columnsWaiting":  len(missing),
-			}).Error("Still waiting for data columns DA check at slot end.")
-		})
-		defer nst.Stop()
-	}
-	for {
-		select {
-		case rootIndex := <-rootIndexChan:
-			if rootIndex.Root != root {
-				// This is not the root we are looking for.
-				continue
-			}
-
-			// Remove the index from the missing map.
-			delete(missing, rootIndex.Index)
-
-			// Exit if there is no more missing data columns.
-			if len(missing) == 0 {
-				return nil
-			}
-		case <-ctx.Done():
-			missingIndexes := make([]uint64, 0, len(missing))
-			for val := range missing {
-				copiedVal := val
-				missingIndexes = append(missingIndexes, copiedVal)
-			}
-			return errors.Wrapf(ctx.Err(), "context deadline waiting for data column sidecars slot: %d, BlockRoot: %#x, missing %v", block.Slot(), root, missingIndexes)
-		}
+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,
 	}
 }
 

beacon-chain/blockchain/receive_block.go

@@ -50,12 +50,6 @@ 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(context.Context, 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)

beacon-chain/blockchain/receive_data_column.go

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

beacon-chain/blockchain/service.go

@@ -82,7 +82,7 @@ type config struct {
 	ExitPool                voluntaryexits.PoolManager
 	SlashingPool            slashings.PoolManager
 	BLSToExecPool           blstoexec.PoolManager
-	P2P                     p2p.Acceser
+	P2p                     p2p.Broadcaster
 	MaxRoutines             int
 	StateNotifier           statefeed.Notifier
 	ForkChoiceStore         f.ForkChoicer
@@ -107,17 +107,15 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	seenIndex map[[32]byte][fieldparams.NumberOfColumns]bool
+	seenIndex map[[32]byte][fieldparams.MaxBlobsPerBlock]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
 func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
-	// TODO: Separate Data Columns from blobs
-	/*
-		if idx >= fieldparams.MaxBlobsPerBlock {
-			return
-		}*/
+	if idx >= fieldparams.MaxBlobsPerBlock {
+		return
+	}
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
@@ -131,7 +129,7 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64) {
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.NumberOfColumns)
+		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 
@@ -145,7 +143,7 @@ func (bn *blobNotifierMap) forRoot(root [32]byte) chan uint64 {
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		c = make(chan uint64, fieldparams.NumberOfColumns)
+		c = make(chan uint64, fieldparams.MaxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -171,7 +169,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
+		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,

beacon-chain/blockchain/service_test.go

@@ -95,7 +95,7 @@ func setupBeaconChain(t *testing.T, beaconDB db.Database) *Service {
 		WithAttestationPool(attestations.NewPool()),
 		WithSlashingPool(slashings.NewPool()),
 		WithExitPool(voluntaryexits.NewPool()),
-		WithP2PBroadcaster(&mockAccesser{}),
+		WithP2PBroadcaster(&mockBroadcaster{}),
 		WithStateNotifier(&mockBeaconNode{}),
 		WithForkChoiceStore(fc),
 		WithAttestationService(attService),
@@ -518,7 +518,7 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
+		seenIndex: make(map[[32]byte][fieldparams.MaxBlobsPerBlock]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 

beacon-chain/blockchain/setup_test.go

@@ -19,7 +19,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/attestations"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/operations/blstoexec"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
-	p2pTesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/stategen"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -46,11 +45,6 @@ type mockBroadcaster struct {
 	broadcastCalled bool
 }
 
-type mockAccesser struct {
-	mockBroadcaster
-	p2pTesting.MockPeerManager
-}
-
 func (mb *mockBroadcaster) Broadcast(_ context.Context, _ proto.Message) error {
 	mb.broadcastCalled = true
 	return nil
@@ -71,11 +65,6 @@ func (mb *mockBroadcaster) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.B
 	return nil
 }
 
-func (mb *mockBroadcaster) BroadcastDataColumn(_ context.Context, _ uint64, _ *ethpb.DataColumnSidecar) error {
-	mb.broadcastCalled = true
-	return nil
-}
-
 func (mb *mockBroadcaster) BroadcastBLSChanges(_ context.Context, _ []*ethpb.SignedBLSToExecutionChange) {
 }
 

beacon-chain/blockchain/testing/mock.go

@@ -628,11 +628,6 @@ func (c *ChainService) ReceiveBlob(_ context.Context, b blocks.VerifiedROBlob) e
 	return nil
 }
 
-// ReceiveDataColumn implements the same method in chain service
-func (c *ChainService) ReceiveDataColumn(_ context.Context, _ 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/BUILD.bazel

@@ -8,7 +8,6 @@ go_library(
         "attestation_data.go",
         "balance_cache_key.go",
         "checkpoint_state.go",
-        "column_subnet_ids.go",
         "committee.go",
         "committee_disabled.go",  # keep
         "committees.go",

beacon-chain/cache/column_subnet_ids.go

@@ -1,65 +0,0 @@
-package cache
-
-import (
-	"sync"
-	"time"
-
-	"github.com/patrickmn/go-cache"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-)
-
-type columnSubnetIDs struct {
-	colSubCache *cache.Cache
-	colSubLock  sync.RWMutex
-}
-
-// ColumnSubnetIDs for column subnet participants
-var ColumnSubnetIDs = newColumnSubnetIDs()
-
-const columnKey = "columns"
-
-func newColumnSubnetIDs() *columnSubnetIDs {
-	epochDuration := time.Duration(params.BeaconConfig().SlotsPerEpoch.Mul(params.BeaconConfig().SecondsPerSlot))
-	// Set the default duration of a column subnet subscription as the column expiry period.
-	subLength := epochDuration * time.Duration(params.BeaconConfig().MinEpochsForDataColumnSidecarsRequest)
-	persistentCache := cache.New(subLength*time.Second, epochDuration*time.Second)
-	return &columnSubnetIDs{colSubCache: persistentCache}
-}
-
-// GetColumnSubnets retrieves the data column subnets.
-func (s *columnSubnetIDs) GetColumnSubnets() ([]uint64, bool, time.Time) {
-	s.colSubLock.RLock()
-	defer s.colSubLock.RUnlock()
-
-	id, duration, ok := s.colSubCache.GetWithExpiration(columnKey)
-	if !ok {
-		return nil, false, time.Time{}
-	}
-	// Retrieve indices from the cache.
-	idxs, ok := id.([]uint64)
-	if !ok {
-		return nil, false, time.Time{}
-	}
-
-	return idxs, ok, duration
-}
-
-// AddColumnSubnets adds the relevant data column subnets.
-func (s *columnSubnetIDs) AddColumnSubnets(colIdx []uint64) {
-	s.colSubLock.Lock()
-	defer s.colSubLock.Unlock()
-
-	s.colSubCache.Set(columnKey, colIdx, 0)
-}
-
-// EmptyAllCaches empties out all the related caches and flushes any stored
-// entries on them. This should only ever be used for testing, in normal
-// production, handling of the relevant subnets for each role is done
-// separately.
-func (s *columnSubnetIDs) EmptyAllCaches() {
-	// Clear the cache.
-	s.colSubLock.Lock()
-	defer s.colSubLock.Unlock()
-
-	s.colSubCache.Flush()
-}

beacon-chain/core/blocks/signature.go

@@ -96,24 +96,6 @@ func VerifyBlockHeaderSignature(beaconState state.BeaconState, header *ethpb.Sig
 	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
 }
 
-func VerifyBlockHeaderSignatureUsingCurrentFork(beaconState state.BeaconState, header *ethpb.SignedBeaconBlockHeader) error {
-	currentEpoch := slots.ToEpoch(header.Header.Slot)
-	fork, err := forks.Fork(currentEpoch)
-	if err != nil {
-		return err
-	}
-	domain, err := signing.Domain(fork, currentEpoch, params.BeaconConfig().DomainBeaconProposer, beaconState.GenesisValidatorsRoot())
-	if err != nil {
-		return err
-	}
-	proposer, err := beaconState.ValidatorAtIndex(header.Header.ProposerIndex)
-	if err != nil {
-		return err
-	}
-	proposerPubKey := proposer.PublicKey
-	return signing.VerifyBlockHeaderSigningRoot(header.Header, proposerPubKey, header.Signature, domain)
-}
-
 // VerifyBlockSignatureUsingCurrentFork verifies the proposer signature of a beacon block. This differs
 // from the above method by not using fork data from the state and instead retrieving it
 // via the respective epoch.

beacon-chain/core/feed/operation/events.go

@@ -32,9 +32,6 @@ const (
 
 	// AttesterSlashingReceived is sent after an attester slashing is received from gossip or rpc
 	AttesterSlashingReceived = 8
-
-	// DataColumnSidecarReceived is sent after a data column sidecar is received from gossip or rpc.
-	DataColumnSidecarReceived = 9
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -80,7 +77,3 @@ type ProposerSlashingReceivedData struct {
 type AttesterSlashingReceivedData struct {
 	AttesterSlashing ethpb.AttSlashing
 }
-
-type DataColumnSidecarReceivedData struct {
-	DataColumn *blocks.VerifiedRODataColumn
-}

beacon-chain/core/helpers/attestation.go

@@ -10,6 +10,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	prysmTime "github.com/prysmaticlabs/prysm/v5/time"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
 )
@@ -91,6 +92,14 @@ func IsAggregated(attestation ethpb.Att) bool {
 //
 //	return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
 func ComputeSubnetForAttestation(activeValCount uint64, att ethpb.Att) uint64 {
+	if att.Version() >= version.Electra {
+		committeeIndex := 0
+		committeeIndices := att.CommitteeBitsVal().BitIndices()
+		if len(committeeIndices) > 0 {
+			committeeIndex = committeeIndices[0]
+		}
+		return ComputeSubnetFromCommitteeAndSlot(activeValCount, primitives.CommitteeIndex(committeeIndex), att.GetData().Slot)
+	}
 	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.GetData().CommitteeIndex, att.GetData().Slot)
 }
 

beacon-chain/core/helpers/attestation_test.go

@@ -73,21 +73,37 @@ func TestAttestation_ComputeSubnetForAttestation(t *testing.T) {
 		RandaoMixes: make([][]byte, params.BeaconConfig().EpochsPerHistoricalVector),
 	})
 	require.NoError(t, err)
-	att := &ethpb.Attestation{
-		AggregationBits: []byte{'A'},
-		Data: &ethpb.AttestationData{
-			Slot:            34,
-			CommitteeIndex:  4,
-			BeaconBlockRoot: []byte{'C'},
-			Source:          nil,
-			Target:          nil,
-		},
-		Signature: []byte{'B'},
-	}
-	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(att.Data.Slot))
+	valCount, err := helpers.ActiveValidatorCount(context.Background(), state, slots.ToEpoch(34))
 	require.NoError(t, err)
-	sub := helpers.ComputeSubnetForAttestation(valCount, att)
-	assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
+
+	t.Run("Phase 0", func(t *testing.T) {
+		att := &ethpb.Attestation{
+			AggregationBits: []byte{'A'},
+			Data: &ethpb.AttestationData{
+				Slot:            34,
+				CommitteeIndex:  4,
+				BeaconBlockRoot: []byte{'C'},
+			},
+			Signature: []byte{'B'},
+		}
+		sub := helpers.ComputeSubnetForAttestation(valCount, att)
+		assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
+	})
+	t.Run("Electra", func(t *testing.T) {
+		cb := primitives.NewAttestationCommitteeBits()
+		cb.SetBitAt(4, true)
+		att := &ethpb.AttestationElectra{
+			AggregationBits: []byte{'A'},
+			CommitteeBits:   cb,
+			Data: &ethpb.AttestationData{
+				Slot:            34,
+				BeaconBlockRoot: []byte{'C'},
+			},
+			Signature: []byte{'B'},
+		}
+		sub := helpers.ComputeSubnetForAttestation(valCount, att)
+		assert.Equal(t, uint64(6), sub, "Did not get correct subnet for attestation")
+	})
 }
 
 func Test_ValidateAttestationTime(t *testing.T) {

beacon-chain/core/peerdas/BUILD.bazel

@@ -1,37 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library", "go_test")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["helpers.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//beacon-chain/blockchain/kzg:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
-        "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
-        "//crypto/hash:go_default_library",
-        "//encoding/bytesutil:go_default_library",
-        "//proto/prysm/v1alpha1:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
-        "@com_github_holiman_uint256//:go_default_library",
-        "@com_github_pkg_errors//:go_default_library",
-    ],
-)
-
-go_test(
-    name = "go_default_test",
-    srcs = ["helpers_test.go"],
-    deps = [
-        ":go_default_library",
-        "//beacon-chain/blockchain/kzg:go_default_library",
-        "//consensus-types/blocks:go_default_library",
-        "//testing/require:go_default_library",
-        "//testing/util:go_default_library",
-        "@com_github_consensys_gnark_crypto//ecc/bls12-381/fr:go_default_library",
-        "@com_github_crate_crypto_go_kzg_4844//:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
-    ],
-)

beacon-chain/core/peerdas/helpers.go

@@ -1,359 +0,0 @@
-package peerdas
-
-import (
-	"encoding/binary"
-	"math"
-	"math/big"
-
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/enr"
-	"github.com/holiman/uint256"
-	errors "github.com/pkg/errors"
-
-	kzg "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
-
-	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
-	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
-	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-)
-
-const (
-	CustodySubnetCountEnrKey = "csc"
-)
-
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/p2p-interface.md#the-discovery-domain-discv5
-type Csc uint64
-
-func (Csc) ENRKey() string { return CustodySubnetCountEnrKey }
-
-var (
-	// Custom errors
-	errCustodySubnetCountTooLarge   = errors.New("custody subnet count larger than data column sidecar subnet count")
-	errIndexTooLarge                = errors.New("column index is larger than the specified columns count")
-	errMismatchLength               = errors.New("mismatch in the length of the commitments and proofs")
-	errRecordNil                    = errors.New("record is nil")
-	errCannotLoadCustodySubnetCount = errors.New("cannot load the custody subnet count from peer")
-
-	// maxUint256 is the maximum value of a uint256.
-	maxUint256 = &uint256.Int{math.MaxUint64, math.MaxUint64, math.MaxUint64, math.MaxUint64}
-)
-
-// CustodyColumnSubnets computes the subnets the node should participate in for custody.
-func CustodyColumnSubnets(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) {
-	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
-
-	// Check if the custody subnet count is larger than the data column sidecar subnet count.
-	if custodySubnetCount > dataColumnSidecarSubnetCount {
-		return nil, errCustodySubnetCountTooLarge
-	}
-
-	// First, compute the subnet IDs that the node should participate in.
-	subnetIds := make(map[uint64]bool, custodySubnetCount)
-
-	one := uint256.NewInt(1)
-
-	for currentId := new(uint256.Int).SetBytes(nodeId.Bytes()); uint64(len(subnetIds)) < custodySubnetCount; currentId.Add(currentId, one) {
-		// Convert to big endian bytes.
-		currentIdBytesBigEndian := currentId.Bytes32()
-
-		// Convert to little endian.
-		currentIdBytesLittleEndian := bytesutil.ReverseByteOrder(currentIdBytesBigEndian[:])
-
-		// Hash the result.
-		hashedCurrentId := hash.Hash(currentIdBytesLittleEndian)
-
-		// Get the subnet ID.
-		subnetId := binary.LittleEndian.Uint64(hashedCurrentId[:8]) % dataColumnSidecarSubnetCount
-
-		// Add the subnet to the map.
-		subnetIds[subnetId] = true
-
-		// Overflow prevention.
-		if currentId.Cmp(maxUint256) == 0 {
-			currentId = uint256.NewInt(0)
-		}
-	}
-
-	return subnetIds, nil
-}
-
-// CustodyColumns computes the columns the node should custody.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#helper-functions
-func CustodyColumns(nodeId enode.ID, custodySubnetCount uint64) (map[uint64]bool, error) {
-	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
-
-	// Compute the custodied subnets.
-	subnetIds, err := CustodyColumnSubnets(nodeId, custodySubnetCount)
-	if err != nil {
-		return nil, errors.Wrap(err, "custody subnets")
-	}
-
-	columnsPerSubnet := kzg.CellsPerExtBlob / dataColumnSidecarSubnetCount
-
-	// Knowing the subnet ID and the number of columns per subnet, select all the columns the node should custody.
-	// Columns belonging to the same subnet are contiguous.
-	columnIndices := make(map[uint64]bool, custodySubnetCount*columnsPerSubnet)
-	for i := uint64(0); i < columnsPerSubnet; i++ {
-		for subnetId := range subnetIds {
-			columnIndex := dataColumnSidecarSubnetCount*i + subnetId
-			columnIndices[columnIndex] = true
-		}
-	}
-
-	return columnIndices, nil
-}
-
-// DataColumnSidecars computes the data column sidecars from the signed block and blobs.
-// https://github.com/ethereum/consensus-specs/blob/dev/specs/_features/eip7594/das-core.md#recover_matrix
-func DataColumnSidecars(signedBlock interfaces.ReadOnlySignedBeaconBlock, blobs []kzg.Blob) ([]*ethpb.DataColumnSidecar, error) {
-	blobsCount := len(blobs)
-	if blobsCount == 0 {
-		return nil, nil
-	}
-
-	// Get the signed block header.
-	signedBlockHeader, err := signedBlock.Header()
-	if err != nil {
-		return nil, errors.Wrap(err, "signed block header")
-	}
-
-	// Get the block body.
-	block := signedBlock.Block()
-	blockBody := block.Body()
-
-	// Get the blob KZG commitments.
-	blobKzgCommitments, err := blockBody.BlobKzgCommitments()
-	if err != nil {
-		return nil, errors.Wrap(err, "blob KZG commitments")
-	}
-
-	// Compute the KZG commitments inclusion proof.
-	kzgCommitmentsInclusionProof, err := blocks.MerkleProofKZGCommitments(blockBody)
-	if err != nil {
-		return nil, errors.Wrap(err, "merkle proof ZKG commitments")
-	}
-
-	// Compute cells and proofs.
-	cellsAndProofs := make([]kzg.CellsAndProofs, 0, blobsCount)
-
-	for i := range blobs {
-		blob := &blobs[i]
-		blobCellsAndProofs, err := kzg.ComputeCellsAndKZGProofs(blob)
-		if err != nil {
-			return nil, errors.Wrap(err, "compute cells and KZG proofs")
-		}
-
-		cellsAndProofs = append(cellsAndProofs, blobCellsAndProofs)
-	}
-
-	// Get the column sidecars.
-	sidecars := make([]*ethpb.DataColumnSidecar, 0, kzg.CellsPerExtBlob)
-	for columnIndex := uint64(0); columnIndex < kzg.CellsPerExtBlob; columnIndex++ {
-		column := make([]kzg.Cell, 0, blobsCount)
-		kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount)
-
-		for rowIndex := 0; rowIndex < blobsCount; rowIndex++ {
-			cellsForRow := cellsAndProofs[rowIndex].Cells
-			proofsForRow := cellsAndProofs[rowIndex].Proofs
-
-			cell := cellsForRow[columnIndex]
-			column = append(column, cell)
-
-			kzgProof := proofsForRow[columnIndex]
-			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
-		}
-
-		columnBytes := make([][]byte, 0, blobsCount)
-		for i := range column {
-			columnBytes = append(columnBytes, column[i][:])
-		}
-
-		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
-		for _, kzgProof := range kzgProofOfColumn {
-			copiedProof := kzgProof
-			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, copiedProof[:])
-		}
-
-		sidecar := &ethpb.DataColumnSidecar{
-			ColumnIndex:                  columnIndex,
-			DataColumn:                   columnBytes,
-			KzgCommitments:               blobKzgCommitments,
-			KzgProof:                     kzgProofOfColumnBytes,
-			SignedBlockHeader:            signedBlockHeader,
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		}
-
-		sidecars = append(sidecars, sidecar)
-	}
-
-	return sidecars, nil
-}
-
-// DataColumnSidecarsForReconstruct is a TEMPORARY function until there is an official specification for it.
-// It is scheduled for deletion.
-func DataColumnSidecarsForReconstruct(
-	blobKzgCommitments [][]byte,
-	signedBlockHeader *ethpb.SignedBeaconBlockHeader,
-	kzgCommitmentsInclusionProof [][]byte,
-	cellsAndProofs []kzg.CellsAndProofs,
-) ([]*ethpb.DataColumnSidecar, error) {
-	// Each CellsAndProofs corresponds to a Blob
-	// So we can get the BlobCount by checking the length of CellsAndProofs
-	blobsCount := len(cellsAndProofs)
-	if blobsCount == 0 {
-		return nil, nil
-	}
-
-	// Get the column sidecars.
-	sidecars := make([]*ethpb.DataColumnSidecar, 0, kzg.CellsPerExtBlob)
-	for columnIndex := uint64(0); columnIndex < kzg.CellsPerExtBlob; columnIndex++ {
-		column := make([]kzg.Cell, 0, blobsCount)
-		kzgProofOfColumn := make([]kzg.Proof, 0, blobsCount)
-
-		for rowIndex := 0; rowIndex < blobsCount; rowIndex++ {
-			cellsForRow := cellsAndProofs[rowIndex].Cells
-			proofsForRow := cellsAndProofs[rowIndex].Proofs
-
-			cell := cellsForRow[columnIndex]
-			column = append(column, cell)
-
-			kzgProof := proofsForRow[columnIndex]
-			kzgProofOfColumn = append(kzgProofOfColumn, kzgProof)
-		}
-
-		columnBytes := make([][]byte, 0, blobsCount)
-		for i := range column {
-			columnBytes = append(columnBytes, column[i][:])
-		}
-
-		kzgProofOfColumnBytes := make([][]byte, 0, blobsCount)
-		for _, kzgProof := range kzgProofOfColumn {
-			copiedProof := kzgProof
-			kzgProofOfColumnBytes = append(kzgProofOfColumnBytes, copiedProof[:])
-		}
-
-		sidecar := &ethpb.DataColumnSidecar{
-			ColumnIndex:                  columnIndex,
-			DataColumn:                   columnBytes,
-			KzgCommitments:               blobKzgCommitments,
-			KzgProof:                     kzgProofOfColumnBytes,
-			SignedBlockHeader:            signedBlockHeader,
-			KzgCommitmentsInclusionProof: kzgCommitmentsInclusionProof,
-		}
-
-		sidecars = append(sidecars, sidecar)
-	}
-
-	return sidecars, nil
-}
-
-// VerifyDataColumnSidecarKZGProofs verifies the provided KZG Proofs for the particular
-// data column.
-func VerifyDataColumnSidecarKZGProofs(sc *ethpb.DataColumnSidecar) (bool, error) {
-	if sc.ColumnIndex >= params.BeaconConfig().NumberOfColumns {
-		return false, errIndexTooLarge
-	}
-	if len(sc.DataColumn) != len(sc.KzgCommitments) || len(sc.KzgCommitments) != len(sc.KzgProof) {
-		return false, errMismatchLength
-	}
-	blobsCount := len(sc.DataColumn)
-
-	rowIdx := make([]uint64, 0, blobsCount)
-	colIdx := make([]uint64, 0, blobsCount)
-	for i := 0; i < len(sc.DataColumn); i++ {
-		copiedI := uint64(i)
-		rowIdx = append(rowIdx, copiedI)
-		colI := sc.ColumnIndex
-		colIdx = append(colIdx, colI)
-	}
-	ckzgComms := make([]kzg.Bytes48, 0, len(sc.KzgCommitments))
-	for _, com := range sc.KzgCommitments {
-		ckzgComms = append(ckzgComms, kzg.Bytes48(com))
-	}
-	var cells []kzg.Cell
-	for _, cell := range sc.DataColumn {
-		cells = append(cells, kzg.Cell(cell))
-	}
-	var proofs []kzg.Bytes48
-	for _, p := range sc.KzgProof {
-		proofs = append(proofs, kzg.Bytes48(p))
-	}
-	return kzg.VerifyCellKZGProofBatch(ckzgComms, rowIdx, colIdx, cells, proofs)
-}
-
-// CustodySubnetCount returns the number of subnets the node should participate in for custody.
-func CustodySubnetCount() uint64 {
-	count := params.BeaconConfig().CustodyRequirement
-	if flags.Get().SubscribeToAllSubnets {
-		count = params.BeaconConfig().DataColumnSidecarSubnetCount
-	}
-	return count
-}
-
-// HypergeomCDF computes the hypergeometric cumulative distribution function.
-// https://en.wikipedia.org/wiki/Hypergeometric_distribution
-func HypergeomCDF(k, M, n, N uint64) float64 {
-	denominatorInt := new(big.Int).Binomial(int64(M), int64(N)) // lint:ignore uintcast
-	denominator := new(big.Float).SetInt(denominatorInt)
-
-	rBig := big.NewFloat(0)
-
-	for i := uint64(0); i < k+1; i++ {
-		a := new(big.Int).Binomial(int64(n), int64(i)) // lint:ignore uintcast
-		b := new(big.Int).Binomial(int64(M-n), int64(N-i))
-		numeratorInt := new(big.Int).Mul(a, b)
-		numerator := new(big.Float).SetInt(numeratorInt)
-		item := new(big.Float).Quo(numerator, denominator)
-		rBig.Add(rBig, item)
-	}
-
-	r, _ := rBig.Float64()
-
-	return r
-}
-
-// ExtendedSampleCount computes, for a given number of samples per slot and allowed failures the
-// number of samples we should actually query from peers.
-// TODO: Add link to the specification once it is available.
-func ExtendedSampleCount(samplesPerSlot, allowedFailures uint64) uint64 {
-	// Retrieve the columns count
-	columnsCount := params.BeaconConfig().NumberOfColumns
-
-	// If half of the columns are missing, we are able to reconstruct the data.
-	// If half of the columns + 1 are missing, we are not able to reconstruct the data.
-	// This is the smallest worst case.
-	worstCaseMissing := columnsCount/2 + 1
-
-	// Compute the false positive threshold.
-	falsePositiveThreshold := HypergeomCDF(0, columnsCount, worstCaseMissing, samplesPerSlot)
-
-	var sampleCount uint64
-
-	// Finally, compute the extended sample count.
-	for sampleCount = samplesPerSlot; sampleCount < columnsCount+1; sampleCount++ {
-		if HypergeomCDF(allowedFailures, columnsCount, worstCaseMissing, sampleCount) <= falsePositiveThreshold {
-			break
-		}
-	}
-
-	return sampleCount
-}
-
-func CustodyCountFromRecord(record *enr.Record) (uint64, error) {
-	// By default, we assume the peer custodies the minimum number of subnets.
-	if record == nil {
-		return 0, errRecordNil
-	}
-
-	// Load the `custody_subnet_count`
-	var csc Csc
-	if err := record.Load(&csc); err != nil {
-		return 0, errCannotLoadCustodySubnetCount
-	}
-
-	return uint64(csc), nil
-}

beacon-chain/core/peerdas/helpers_test.go

@@ -1,144 +0,0 @@
-package peerdas_test
-
-import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/binary"
-	"fmt"
-	"testing"
-
-	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
-	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"github.com/sirupsen/logrus"
-)
-
-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) kzg.Blob {
-	var blob kzg.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
-}
-
-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
-}
-
-func TestVerifyDataColumnSidecarKZGProofs(t *testing.T) {
-	dbBlock := util.NewBeaconBlockDeneb()
-	require.NoError(t, kzg.Start())
-
-	var (
-		comms [][]byte
-		blobs []kzg.Blob
-	)
-	for i := int64(0); i < 6; i++ {
-		blob := GetRandBlob(i)
-		commitment, _, err := GenerateCommitmentAndProof(blob)
-		require.NoError(t, err)
-		comms = append(comms, commitment[:])
-		blobs = append(blobs, blob)
-	}
-
-	dbBlock.Block.Body.BlobKzgCommitments = comms
-	sBlock, err := blocks.NewSignedBeaconBlock(dbBlock)
-	require.NoError(t, err)
-	sCars, err := peerdas.DataColumnSidecars(sBlock, blobs)
-	require.NoError(t, err)
-
-	for i, sidecar := range sCars {
-		verified, err := peerdas.VerifyDataColumnSidecarKZGProofs(sidecar)
-		require.NoError(t, err)
-		require.Equal(t, true, verified, fmt.Sprintf("sidecar %d failed", i))
-	}
-}
-
-func TestHypergeomCDF(t *testing.T) {
-	// Test case from https://en.wikipedia.org/wiki/Hypergeometric_distribution
-	// Population size: 1000, number of successes in population: 500, sample size: 10, number of successes in sample: 5
-	// Expected result: 0.072
-	const (
-		expected = 0.0796665913283742
-		margin   = 0.000001
-	)
-
-	actual := peerdas.HypergeomCDF(5, 128, 65, 16)
-	require.Equal(t, true, expected-margin <= actual && actual <= expected+margin)
-}
-
-func TestExtendedSampleCount(t *testing.T) {
-	const samplesPerSlot = 16
-
-	testCases := []struct {
-		name                string
-		allowedMissings     uint64
-		extendedSampleCount uint64
-	}{
-		{name: "allowedMissings=0", allowedMissings: 0, extendedSampleCount: 16},
-		{name: "allowedMissings=1", allowedMissings: 1, extendedSampleCount: 20},
-		{name: "allowedMissings=2", allowedMissings: 2, extendedSampleCount: 24},
-		{name: "allowedMissings=3", allowedMissings: 3, extendedSampleCount: 27},
-		{name: "allowedMissings=4", allowedMissings: 4, extendedSampleCount: 29},
-		{name: "allowedMissings=5", allowedMissings: 5, extendedSampleCount: 32},
-		{name: "allowedMissings=6", allowedMissings: 6, extendedSampleCount: 35},
-		{name: "allowedMissings=7", allowedMissings: 7, extendedSampleCount: 37},
-		{name: "allowedMissings=8", allowedMissings: 8, extendedSampleCount: 40},
-		{name: "allowedMissings=9", allowedMissings: 9, extendedSampleCount: 42},
-		{name: "allowedMissings=10", allowedMissings: 10, extendedSampleCount: 44},
-		{name: "allowedMissings=11", allowedMissings: 11, extendedSampleCount: 47},
-		{name: "allowedMissings=12", allowedMissings: 12, extendedSampleCount: 49},
-		{name: "allowedMissings=13", allowedMissings: 13, extendedSampleCount: 51},
-		{name: "allowedMissings=14", allowedMissings: 14, extendedSampleCount: 53},
-		{name: "allowedMissings=15", allowedMissings: 15, extendedSampleCount: 55},
-		{name: "allowedMissings=16", allowedMissings: 16, extendedSampleCount: 57},
-		{name: "allowedMissings=17", allowedMissings: 17, extendedSampleCount: 59},
-		{name: "allowedMissings=18", allowedMissings: 18, extendedSampleCount: 61},
-		{name: "allowedMissings=19", allowedMissings: 19, extendedSampleCount: 63},
-		{name: "allowedMissings=20", allowedMissings: 20, extendedSampleCount: 65},
-	}
-
-	for _, tc := range testCases {
-		t.Run(tc.name, func(t *testing.T) {
-			result := peerdas.ExtendedSampleCount(samplesPerSlot, tc.allowedMissings)
-			require.Equal(t, tc.extendedSampleCount, result)
-		})
-	}
-}

beacon-chain/core/time/slot_epoch.go

@@ -53,11 +53,6 @@ func HigherEqualThanAltairVersionAndEpoch(s state.BeaconState, e primitives.Epoc
 	return s.Version() >= version.Altair && e >= params.BeaconConfig().AltairForkEpoch
 }
 
-// PeerDASIsActive checks whether peerDAS is active at the provided slot.
-func PeerDASIsActive(slot primitives.Slot) bool {
-	return params.PeerDASEnabled() && slots.ToEpoch(slot) >= params.BeaconConfig().Eip7594ForkEpoch
-}
-
 // CanUpgradeToAltair returns true if the input `slot` can upgrade to Altair.
 // Spec code:
 // If state.slot % SLOTS_PER_EPOCH == 0 and compute_epoch_at_slot(state.slot) == ALTAIR_FORK_EPOCH

beacon-chain/das/BUILD.bazel

@@ -4,7 +4,6 @@ go_library(
     name = "go_default_library",
     srcs = [
         "availability.go",
-        "availability_columns.go",
         "cache.go",
         "iface.go",
         "mock.go",
@@ -21,7 +20,6 @@ go_library(
         "//runtime/logging:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
     ],

beacon-chain/das/availability_columns.go

@@ -1,151 +0,0 @@
-package das
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	errors "github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	log "github.com/sirupsen/logrus"
-)
-
-// LazilyPersistentStoreColumn is an implementation of AvailabilityStore to be used when batch syncing data columns.
-// This implementation will hold any blobs passed to Persist until the IsDataAvailable is called for their
-// block, at which time they will undergo full verification and be saved to the disk.
-type LazilyPersistentStoreColumn struct {
-	store    *filesystem.BlobStorage
-	cache    *cache
-	verifier ColumnBatchVerifier
-	nodeID   enode.ID
-}
-
-type ColumnBatchVerifier interface {
-	VerifiedRODataColumns(ctx context.Context, blk blocks.ROBlock, sc []blocks.RODataColumn) ([]blocks.VerifiedRODataColumn, error)
-}
-
-func NewLazilyPersistentStoreColumn(store *filesystem.BlobStorage, verifier ColumnBatchVerifier, id enode.ID) *LazilyPersistentStoreColumn {
-	return &LazilyPersistentStoreColumn{
-		store:    store,
-		cache:    newCache(),
-		verifier: verifier,
-		nodeID:   id,
-	}
-}
-
-// TODO: Very Ugly, change interface to allow for columns and blobs
-func (s *LazilyPersistentStoreColumn) Persist(current primitives.Slot, sc ...blocks.ROBlob) error {
-	return nil
-}
-
-// PersistColumns adds columns to the working column cache. columns stored in this cache will be persisted
-// for at least as long as the node is running. Once IsDataAvailable succeeds, all blobs referenced
-// by the given block are guaranteed to be persisted for the remainder of the retention period.
-func (s *LazilyPersistentStoreColumn) PersistColumns(current primitives.Slot, sc ...blocks.RODataColumn) error {
-	if len(sc) == 0 {
-		return nil
-	}
-	if len(sc) > 1 {
-		first := sc[0].BlockRoot()
-		for i := 1; i < len(sc); i++ {
-			if first != sc[i].BlockRoot() {
-				return errMixedRoots
-			}
-		}
-	}
-	if !params.WithinDAPeriod(slots.ToEpoch(sc[0].Slot()), slots.ToEpoch(current)) {
-		return nil
-	}
-	key := keyFromColumn(sc[0])
-	entry := s.cache.ensure(key)
-	for i := range sc {
-		if err := entry.stashColumns(&sc[i]); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// IsDataAvailable returns nil if all the commitments in the given block are persisted to the db and have been verified.
-// BlobSidecars already in the db are assumed to have been previously verified against the block.
-func (s *LazilyPersistentStoreColumn) IsDataAvailable(ctx context.Context, current primitives.Slot, b blocks.ROBlock) error {
-	blockCommitments, err := fullCommitmentsToCheck(b, current)
-	if err != nil {
-		return errors.Wrapf(err, "could check data availability for block %#x", b.Root())
-	}
-	// Return early for blocks that are pre-deneb or which do not have any commitments.
-	if blockCommitments.count() == 0 {
-		return nil
-	}
-
-	key := keyFromBlock(b)
-	entry := s.cache.ensure(key)
-	defer s.cache.delete(key)
-	root := b.Root()
-	sumz, err := s.store.WaitForSummarizer(ctx)
-	if err != nil {
-		log.WithField("root", fmt.Sprintf("%#x", b.Root())).
-			WithError(err).
-			Debug("Failed to receive BlobStorageSummarizer within IsDataAvailable")
-	} else {
-		entry.setDiskSummary(sumz.Summary(root))
-	}
-
-	// Verify we have all the expected sidecars, and fail fast if any are missing or inconsistent.
-	// We don't try to salvage problematic batches because this indicates a misbehaving peer and we'd rather
-	// ignore their response and decrease their peer score.
-	sidecars, err := entry.filterColumns(root, blockCommitments)
-	if err != nil {
-		return errors.Wrap(err, "incomplete BlobSidecar batch")
-	}
-	// Do thorough verifications of each BlobSidecar for the block.
-	// Same as above, we don't save BlobSidecars if there are any problems with the batch.
-	vscs, err := s.verifier.VerifiedRODataColumns(ctx, b, sidecars)
-	if err != nil {
-		var me verification.VerificationMultiError
-		ok := errors.As(err, &me)
-		if ok {
-			fails := me.Failures()
-			lf := make(log.Fields, len(fails))
-			for i := range fails {
-				lf[fmt.Sprintf("fail_%d", i)] = fails[i].Error()
-			}
-			log.WithFields(lf).
-				Debug("invalid ColumnSidecars received")
-		}
-		return errors.Wrapf(err, "invalid ColumnSidecars received for block %#x", root)
-	}
-	// Ensure that each column sidecar is written to disk.
-	for i := range vscs {
-		if err := s.store.SaveDataColumn(vscs[i]); err != nil {
-			return errors.Wrapf(err, "failed to save ColumnSidecar index %d for block %#x", vscs[i].ColumnIndex, root)
-		}
-	}
-	// All ColumnSidecars are persisted - da check succeeds.
-	return nil
-}
-
-func fullCommitmentsToCheck(b blocks.ROBlock, current primitives.Slot) (safeCommitmentsArray, error) {
-	var ar safeCommitmentsArray
-	if b.Version() < version.Deneb {
-		return ar, nil
-	}
-	// We are only required to check within MIN_EPOCHS_FOR_DATA_COLUMN_SIDECARS_REQUESTS
-	if !params.WithinDAPeriod(slots.ToEpoch(b.Block().Slot()), slots.ToEpoch(current)) {
-		return ar, nil
-	}
-	kc, err := b.Block().Body().BlobKzgCommitments()
-	if err != nil {
-		return ar, err
-	}
-	for i := range ar {
-		copy(ar[i], kc)
-	}
-	return ar, nil
-}

beacon-chain/das/cache.go

@@ -2,7 +2,6 @@ package das
 
 import (
 	"bytes"
-	"reflect"
 
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
@@ -39,10 +38,6 @@ func keyFromSidecar(sc blocks.ROBlob) cacheKey {
 	return cacheKey{slot: sc.Slot(), root: sc.BlockRoot()}
 }
 
-func keyFromColumn(sc blocks.RODataColumn) cacheKey {
-	return cacheKey{slot: sc.Slot(), root: sc.BlockRoot()}
-}
-
 // keyFromBlock is a convenience method for constructing a cacheKey from a ROBlock value.
 func keyFromBlock(b blocks.ROBlock) cacheKey {
 	return cacheKey{slot: b.Block().Slot(), root: b.Root()}
@@ -66,7 +61,6 @@ func (c *cache) delete(key cacheKey) {
 // cacheEntry holds a fixed-length cache of BlobSidecars.
 type cacheEntry struct {
 	scs         [fieldparams.MaxBlobsPerBlock]*blocks.ROBlob
-	colScs      [fieldparams.NumberOfColumns]*blocks.RODataColumn
 	diskSummary filesystem.BlobStorageSummary
 }
 
@@ -88,17 +82,6 @@ func (e *cacheEntry) stash(sc *blocks.ROBlob) error {
 	return nil
 }
 
-func (e *cacheEntry) stashColumns(sc *blocks.RODataColumn) error {
-	if sc.ColumnIndex >= fieldparams.NumberOfColumns {
-		return errors.Wrapf(errIndexOutOfBounds, "index=%d", sc.ColumnIndex)
-	}
-	if e.colScs[sc.ColumnIndex] != nil {
-		return errors.Wrapf(ErrDuplicateSidecar, "root=%#x, index=%d, commitment=%#x", sc.BlockRoot(), sc.ColumnIndex, sc.KzgCommitments)
-	}
-	e.colScs[sc.ColumnIndex] = sc
-	return nil
-}
-
 // filter evicts sidecars that are not committed to by the block and returns custom
 // errors if the cache is missing any of the commitments, or if the commitments in
 // the cache do not match those found in the block. If err is nil, then all expected
@@ -134,35 +117,6 @@ func (e *cacheEntry) filter(root [32]byte, kc safeCommitmentArray) ([]blocks.ROB
 	return scs, nil
 }
 
-func (e *cacheEntry) filterColumns(root [32]byte, kc safeCommitmentsArray) ([]blocks.RODataColumn, error) {
-	if e.diskSummary.AllAvailable(kc.count()) {
-		return nil, nil
-	}
-	scs := make([]blocks.RODataColumn, 0, kc.count())
-	for i := uint64(0); i < fieldparams.NumberOfColumns; i++ {
-		// We already have this blob, we don't need to write it or validate it.
-		if e.diskSummary.HasIndex(i) {
-			continue
-		}
-		if kc[i] == nil {
-			if e.colScs[i] != nil {
-				return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, no block commitment", root, i, e.scs[i].KzgCommitment)
-			}
-			continue
-		}
-
-		if e.colScs[i] == nil {
-			return nil, errors.Wrapf(errMissingSidecar, "root=%#x, index=%#x", root, i)
-		}
-		if !reflect.DeepEqual(kc[i], e.colScs[i].KzgCommitments) {
-			return nil, errors.Wrapf(errCommitmentMismatch, "root=%#x, index=%#x, commitment=%#x, block commitment=%#x", root, i, e.colScs[i].KzgCommitments, kc[i])
-		}
-		scs = append(scs, *e.colScs[i])
-	}
-
-	return scs, nil
-}
-
 // safeCommitmentArray is a fixed size array of commitment byte slices. This is helpful for avoiding
 // gratuitous bounds checks.
 type safeCommitmentArray [fieldparams.MaxBlobsPerBlock][]byte
@@ -175,14 +129,3 @@ func (s safeCommitmentArray) count() int {
 	}
 	return fieldparams.MaxBlobsPerBlock
 }
-
-type safeCommitmentsArray [fieldparams.NumberOfColumns][][]byte
-
-func (s safeCommitmentsArray) count() int {
-	for i := range s {
-		if s[i] == nil {
-			return i
-		}
-	}
-	return fieldparams.NumberOfColumns
-}

beacon-chain/db/filesystem/BUILD.bazel

@@ -13,7 +13,6 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem",
     visibility = ["//visibility:public"],
     deps = [
-        "//async/event:go_default_library",
         "//beacon-chain/verification:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",

beacon-chain/db/filesystem/blob.go

@@ -12,7 +12,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/async/event"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/verification"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
@@ -40,15 +39,8 @@ const (
 	directoryPermissions = 0700
 )
 
-type (
-	// BlobStorageOption is a functional option for configuring a BlobStorage.
-	BlobStorageOption func(*BlobStorage) error
-
-	RootIndexPair struct {
-		Root  [fieldparams.RootLength]byte
-		Index uint64
-	}
-)
+// BlobStorageOption is a functional option for configuring a BlobStorage.
+type BlobStorageOption func(*BlobStorage) error
 
 // WithBasePath is a required option that sets the base path of blob storage.
 func WithBasePath(base string) BlobStorageOption {
@@ -78,10 +70,7 @@ func WithSaveFsync(fsync bool) BlobStorageOption {
 // attempt to hold a file lock to guarantee exclusive control of the blob storage directory, so this should only be
 // initialized once per beacon node.
 func NewBlobStorage(opts ...BlobStorageOption) (*BlobStorage, error) {
-	b := &BlobStorage{
-		DataColumnFeed: new(event.Feed),
-	}
-
+	b := &BlobStorage{}
 	for _, o := range opts {
 		if err := o(b); err != nil {
 			return nil, errors.Wrap(err, "failed to create blob storage")
@@ -110,7 +99,6 @@ type BlobStorage struct {
 	fsync           bool
 	fs              afero.Fs
 	pruner          *blobPruner
-	DataColumnFeed  *event.Feed
 }
 
 // WarmCache runs the prune routine with an expiration of slot of 0, so nothing will be pruned, but the pruner's cache
@@ -233,110 +221,6 @@ func (bs *BlobStorage) Save(sidecar blocks.VerifiedROBlob) error {
 	return nil
 }
 
-// SaveDataColumn saves a data column to our local filesystem.
-func (bs *BlobStorage) SaveDataColumn(column blocks.VerifiedRODataColumn) error {
-	startTime := time.Now()
-	fname := namerForDataColumn(column)
-	sszPath := fname.path()
-	exists, err := afero.Exists(bs.fs, sszPath)
-	if err != nil {
-		return err
-	}
-
-	if exists {
-		log.Trace("Ignoring a duplicate data column sidecar save attempt")
-		return nil
-	}
-
-	if bs.pruner != nil {
-		hRoot, err := column.SignedBlockHeader.Header.HashTreeRoot()
-		if err != nil {
-			return err
-		}
-		if err := bs.pruner.notify(hRoot, column.SignedBlockHeader.Header.Slot, column.ColumnIndex); err != nil {
-			return errors.Wrapf(err, "problem maintaining pruning cache/metrics for sidecar with root=%#x", hRoot)
-		}
-	}
-
-	// Serialize the ethpb.DataColumnSidecar to binary data using SSZ.
-	sidecarData, err := column.MarshalSSZ()
-	if err != nil {
-		return errors.Wrap(err, "failed to serialize sidecar data")
-	} else if len(sidecarData) == 0 {
-		return errSidecarEmptySSZData
-	}
-
-	if err := bs.fs.MkdirAll(fname.dir(), directoryPermissions); err != nil {
-		return err
-	}
-	partPath := fname.partPath(fmt.Sprintf("%p", sidecarData))
-
-	partialMoved := false
-	// Ensure the partial file is deleted.
-	defer func() {
-		if partialMoved {
-			return
-		}
-		// It's expected to error if the save is successful.
-		err = bs.fs.Remove(partPath)
-		if err == nil {
-			log.WithFields(logrus.Fields{
-				"partPath": partPath,
-			}).Debugf("Removed partial file")
-		}
-	}()
-
-	// Create a partial file and write the serialized data to it.
-	partialFile, err := bs.fs.Create(partPath)
-	if err != nil {
-		return errors.Wrap(err, "failed to create partial file")
-	}
-
-	n, err := partialFile.Write(sidecarData)
-	if err != nil {
-		closeErr := partialFile.Close()
-		if closeErr != nil {
-			return closeErr
-		}
-		return errors.Wrap(err, "failed to write to partial file")
-	}
-	if bs.fsync {
-		if err := partialFile.Sync(); err != nil {
-			return err
-		}
-	}
-
-	if err := partialFile.Close(); err != nil {
-		return err
-	}
-
-	if n != len(sidecarData) {
-		return fmt.Errorf("failed to write the full bytes of sidecarData, wrote only %d of %d bytes", n, len(sidecarData))
-	}
-
-	if n == 0 {
-		return errEmptyBlobWritten
-	}
-
-	// Atomically rename the partial file to its final name.
-	err = bs.fs.Rename(partPath, sszPath)
-	if err != nil {
-		return errors.Wrap(err, "failed to rename partial file to final name")
-	}
-	partialMoved = true
-
-	// Notify the data column notifier that a new data column has been saved.
-	bs.DataColumnFeed.Send(RootIndexPair{
-		Root:  column.BlockRoot(),
-		Index: column.ColumnIndex,
-	})
-
-	// TODO: Use new metrics for data columns
-	blobsWrittenCounter.Inc()
-	blobSaveLatency.Observe(float64(time.Since(startTime).Milliseconds()))
-	return nil
-}
-
 // Get retrieves a single BlobSidecar by its root and index.
 // Since BlobStorage only writes blobs that have undergone full verification, the return
 // value is always a VerifiedROBlob.
@@ -362,20 +246,6 @@ func (bs *BlobStorage) Get(root [32]byte, idx uint64) (blocks.VerifiedROBlob, er
 	return verification.BlobSidecarNoop(ro)
 }
 
-// GetColumn retrieves a single DataColumnSidecar by its root and index.
-func (bs *BlobStorage) GetColumn(root [32]byte, idx uint64) (*ethpb.DataColumnSidecar, error) {
-	expected := blobNamer{root: root, index: idx}
-	encoded, err := afero.ReadFile(bs.fs, expected.path())
-	if err != nil {
-		return nil, err
-	}
-	s := &ethpb.DataColumnSidecar{}
-	if err := s.UnmarshalSSZ(encoded); err != nil {
-		return nil, err
-	}
-	return s, nil
-}
-
 // Remove removes all blobs for a given root.
 func (bs *BlobStorage) Remove(root [32]byte) error {
 	rootDir := blobNamer{root: root}.dir()
@@ -419,61 +289,6 @@ func (bs *BlobStorage) Indices(root [32]byte) ([fieldparams.MaxBlobsPerBlock]boo
 	return mask, nil
 }
 
-// ColumnIndices retrieve the stored column indexes from our filesystem.
-func (bs *BlobStorage) ColumnIndices(root [32]byte) (map[uint64]bool, error) {
-	custody := make(map[uint64]bool, fieldparams.NumberOfColumns)
-
-	// Get all the files in the directory.
-	rootDir := blobNamer{root: root}.dir()
-	entries, err := afero.ReadDir(bs.fs, rootDir)
-	if err != nil {
-		// If the directory does not exist, we do not custody any columns.
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-
-		return nil, errors.Wrap(err, "read directory")
-	}
-
-	// Iterate over all the entries in the directory.
-	for _, entry := range entries {
-		// If the entry is a directory, skip it.
-		if entry.IsDir() {
-			continue
-		}
-
-		// If the entry does not have the correct extension, skip it.
-		name := entry.Name()
-		if !strings.HasSuffix(name, sszExt) {
-			continue
-		}
-
-		// The file should be in the `<index>.<extension>` format.
-		// Skip the file if it does not match the format.
-		parts := strings.Split(name, ".")
-		if len(parts) != 2 {
-			continue
-		}
-
-		// Get the column index from the file name.
-		columnIndexStr := parts[0]
-		columnIndex, err := strconv.ParseUint(columnIndexStr, 10, 64)
-		if err != nil {
-			return nil, errors.Wrapf(err, "unexpected directory entry breaks listing, %s", parts[0])
-		}
-
-		// If the column index is out of bounds, return an error.
-		if columnIndex >= fieldparams.NumberOfColumns {
-			return nil, errors.Wrapf(errIndexOutOfBounds, "invalid index %d", columnIndex)
-		}
-
-		// Mark the column index as in custody.
-		custody[columnIndex] = true
-	}
-
-	return custody, nil
-}
-
 // Clear deletes all files on the filesystem.
 func (bs *BlobStorage) Clear() error {
 	dirs, err := listDir(bs.fs, ".")
@@ -506,10 +321,6 @@ func namerForSidecar(sc blocks.VerifiedROBlob) blobNamer {
 	return blobNamer{root: sc.BlockRoot(), index: sc.Index}
 }
 
-func namerForDataColumn(col blocks.VerifiedRODataColumn) blobNamer {
-	return blobNamer{root: col.BlockRoot(), index: col.ColumnIndex}
-}
-
 func (p blobNamer) dir() string {
 	return rootString(p.root)
 }

beacon-chain/db/filesystem/cache.go

@@ -9,7 +9,7 @@ import (
 )
 
 // blobIndexMask is a bitmask representing the set of blob indices that are currently set.
-type blobIndexMask [fieldparams.NumberOfColumns]bool
+type blobIndexMask [fieldparams.MaxBlobsPerBlock]bool
 
 // BlobStorageSummary represents cached information about the BlobSidecars on disk for each root the cache knows about.
 type BlobStorageSummary struct {
@@ -26,15 +26,6 @@ func (s BlobStorageSummary) HasIndex(idx uint64) bool {
 	return s.mask[idx]
 }
 
-// HasDataColumnIndex true if the DataColumnSidecar at the given index is available in the filesystem.
-func (s BlobStorageSummary) HasDataColumnIndex(idx uint64) bool {
-	// Protect from panic, but assume callers are sophisticated enough to not need an error telling them they have an invalid idx.
-	if idx >= fieldparams.NumberOfColumns {
-		return false
-	}
-	return s.mask[idx]
-}
-
 // AllAvailable returns true if we have all blobs for all indices from 0 to count-1.
 func (s BlobStorageSummary) AllAvailable(count int) bool {
 	if count > fieldparams.MaxBlobsPerBlock {
@@ -48,21 +39,6 @@ func (s BlobStorageSummary) AllAvailable(count int) bool {
 	return true
 }
 
-// AllDataColumnsAvailable returns true if we have all datacolumns for corresponding indices.
-func (s BlobStorageSummary) AllDataColumnsAvailable(indices map[uint64]bool) bool {
-	if uint64(len(indices)) > fieldparams.NumberOfColumns {
-		return false
-	}
-
-	for indice := range indices {
-		if !s.mask[indice] {
-			return false
-		}
-	}
-
-	return true
-}
-
 // BlobStorageSummarizer can be used to receive a summary of metadata about blobs on disk for a given root.
 // The BlobStorageSummary can be used to check which indices (if any) are available for a given block by root.
 type BlobStorageSummarizer interface {
@@ -92,12 +68,9 @@ func (s *blobStorageCache) Summary(root [32]byte) BlobStorageSummary {
 }
 
 func (s *blobStorageCache) ensure(key [32]byte, slot primitives.Slot, idx uint64) error {
-	// TODO: Separate blob index checks from data column index checks
-	/*
-		if idx >= fieldparams.MaxBlobsPerBlock {
-			return errIndexOutOfBounds
-		}
-	*/
+	if idx >= fieldparams.MaxBlobsPerBlock {
+		return errIndexOutOfBounds
+	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
 	v := s.cache[key]

beacon-chain/db/filesystem/cache_test.go

@@ -9,7 +9,6 @@ import (
 )
 
 func TestSlotByRoot_Summary(t *testing.T) {
-	t.Skip("Use new test for data columns")
 	var noneSet, allSet, firstSet, lastSet, oneSet blobIndexMask
 	firstSet[0] = true
 	lastSet[len(lastSet)-1] = true

beacon-chain/db/kv/blocks.go

@@ -23,10 +23,10 @@ import (
 	"go.opencensus.io/trace"
 )
 
-// Used to represent errors for inconsistent slot ranges.
+// used to represent errors for inconsistent slot ranges.
 var errInvalidSlotRange = errors.New("invalid end slot and start slot provided")
 
-// Block retrieval by root. Return nil if block is not found.
+// Block retrieval by root.
 func (s *Store) Block(ctx context.Context, blockRoot [32]byte) (interfaces.ReadOnlySignedBeaconBlock, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.Block")
 	defer span.End()

beacon-chain/node/BUILD.bazel

@@ -69,7 +69,6 @@ go_library(
         "@com_github_gorilla_mux//:go_default_library",
         "@com_github_pkg_errors//:go_default_library",
         "@com_github_prometheus_client_golang//prometheus:go_default_library",
-        "@com_github_prysmaticlabs_fastssz//:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
     ],

beacon-chain/node/config.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/ethereum/go-ethereum/common"
-	fastssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v5/cmd"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -197,7 +196,3 @@ func configureExecutionSetting(cliCtx *cli.Context) error {
 		" Default fee recipient will be used as a fall back", checksumAddress.Hex())
 	return params.SetActive(c)
 }
-
-func configureFastSSZHashingAlgorithm() {
-	fastssz.EnableVectorizedHTR = true
-}

beacon-chain/node/node.go

@@ -277,8 +277,6 @@ func configureBeacon(cliCtx *cli.Context) error {
 		return errors.Wrap(err, "could not configure execution setting")
 	}
 
-	configureFastSSZHashingAlgorithm()
-
 	return nil
 }
 
@@ -990,7 +988,6 @@ func (b *BeaconNode) registerRPCService(router *mux.Router) error {
 		FinalizationFetcher:           chainService,
 		BlockReceiver:                 chainService,
 		BlobReceiver:                  chainService,
-		DataColumnReceiver:            chainService,
 		AttestationReceiver:           chainService,
 		GenesisTimeFetcher:            chainService,
 		GenesisFetcher:                chainService,

beacon-chain/p2p/BUILD.bazel

@@ -7,7 +7,6 @@ go_library(
         "broadcaster.go",
         "config.go",
         "connection_gater.go",
-        "custody.go",
         "dial_relay_node.go",
         "discovery.go",
         "doc.go",
@@ -47,7 +46,6 @@ 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",
@@ -58,7 +56,6 @@ 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/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
@@ -77,8 +74,6 @@ go_library(
         "//runtime/version:go_default_library",
         "//time:go_default_library",
         "//time/slots:go_default_library",
-        "@com_github_btcsuite_btcd_btcec_v2//:go_default_library",
-        "@com_github_ethereum_go_ethereum//crypto:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/discover:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enode:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
@@ -120,7 +115,6 @@ 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",
@@ -142,11 +136,9 @@ 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/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",
@@ -159,7 +151,6 @@ go_test(
         "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
-        "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//consensus-types/wrapper:go_default_library",
         "//container/leaky-bucket:go_default_library",

beacon-chain/p2p/broadcaster.go

@@ -9,18 +9,16 @@ import (
 
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
-	"github.com/sirupsen/logrus"
-	"go.opencensus.io/trace"
-	"google.golang.org/protobuf/proto"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	"github.com/sirupsen/logrus"
+	"go.opencensus.io/trace"
+	"google.golang.org/protobuf/proto"
 )
 
 // ErrMessageNotMapped occurs on a Broadcast attempt when a message has not been defined in the
@@ -98,12 +96,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 [fieldparams.VersionLength]byte,
-) {
+func (s *Service) internalBroadcastAttestation(ctx context.Context, subnet uint64, att ethpb.Att, forkDigest [4]byte) {
 	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastAttestation")
 	defer span.End()
 	ctx = trace.NewContext(context.Background(), span) // clear parent context / deadline.
@@ -159,7 +152,7 @@ func (s *Service) internalBroadcastAttestation(
 	}
 }
 
-func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMsg *ethpb.SyncCommitteeMessage, forkDigest [fieldparams.VersionLength]byte) {
+func (s *Service) broadcastSyncCommittee(ctx context.Context, subnet uint64, sMsg *ethpb.SyncCommitteeMessage, forkDigest [4]byte) {
 	_, span := trace.StartSpan(ctx, "p2p.broadcastSyncCommittee")
 	defer span.End()
 	ctx = trace.NewContext(context.Background(), span) // clear parent context / deadline.
@@ -235,12 +228,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 [fieldparams.VersionLength]byte,
-) {
+func (s *Service) internalBroadcastBlob(ctx context.Context, subnet uint64, blobSidecar *ethpb.BlobSidecar, forkDigest [4]byte) {
 	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastBlob")
 	defer span.End()
 	ctx = trace.NewContext(context.Background(), span) // clear parent context / deadline.
@@ -255,7 +243,7 @@ func (s *Service) internalBroadcastBlob(
 	s.subnetLocker(wrappedSubIdx).RUnlock()
 
 	if !hasPeer {
-		blobSidecarBroadcastAttempts.Inc()
+		blobSidecarCommitteeBroadcastAttempts.Inc()
 		if err := func() error {
 			s.subnetLocker(wrappedSubIdx).Lock()
 			defer s.subnetLocker(wrappedSubIdx).Unlock()
@@ -264,7 +252,7 @@ func (s *Service) internalBroadcastBlob(
 				return err
 			}
 			if ok {
-				blobSidecarBroadcasts.Inc()
+				blobSidecarCommitteeBroadcasts.Inc()
 				return nil
 			}
 			return errors.New("failed to find peers for subnet")
@@ -280,99 +268,6 @@ func (s *Service) internalBroadcastBlob(
 	}
 }
 
-// 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.
-// TODO: Add tests
-func (s *Service) BroadcastDataColumn(ctx context.Context, columnSubnet uint64, dataColumnSidecar *ethpb.DataColumnSidecar) error {
-	// Add tracing to the function.
-	ctx, span := trace.StartSpan(ctx, "p2p.BroadcastBlob")
-	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", columnSubnet)
-	}
-
-	// 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, columnSubnet, dataColumnSidecar, forkDigest)
-
-	return nil
-}
-
-func (s *Service) internalBroadcastDataColumn(
-	ctx context.Context,
-	columnSubnet uint64,
-	dataColumnSidecar *ethpb.DataColumnSidecar,
-	forkDigest [fieldparams.VersionLength]byte,
-) {
-	// Add tracing to the function.
-	_, span := trace.StartSpan(ctx, "p2p.internalBroadcastDataColumn")
-	defer span.End()
-
-	// Increase the number of broadcast attempts.
-	dataColumnSidecarBroadcastAttempts.Inc()
-
-	// Clear parent context / deadline.
-	ctx = trace.NewContext(context.Background(), span)
-
-	// Define a one-slot length context timeout.
-	oneSlot := time.Duration(params.BeaconConfig().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
-
-	// Check if we have peers with this subnet.
-	hasPeer := func() bool {
-		s.subnetLocker(wrappedSubIdx).RLock()
-		defer s.subnetLocker(wrappedSubIdx).RUnlock()
-
-		return s.hasPeerWithSubnet(topic)
-	}()
-
-	// If no peers are found, attempt to find peers with this subnet.
-	if !hasPeer {
-		if err := func() error {
-			s.subnetLocker(wrappedSubIdx).Lock()
-			defer s.subnetLocker(wrappedSubIdx).Unlock()
-
-			ok, err := s.FindPeersWithSubnet(ctx, topic, columnSubnet, 1 /*threshold*/)
-			if err != nil {
-				return errors.Wrap(err, "find peers for subnet")
-			}
-
-			if ok {
-				return nil
-			}
-			return errors.New("failed to find peers for subnet")
-		}(); err != nil {
-			log.WithError(err).Error("Failed to find peers")
-			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)
-	}
-
-	// Increase the number of successful broadcasts.
-	dataColumnSidecarBroadcasts.Inc()
-}
-
 // 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")
@@ -402,18 +297,14 @@ func (s *Service) broadcastObject(ctx context.Context, obj ssz.Marshaler, topic
 	return nil
 }
 
-func attestationToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
+func attestationToTopic(subnet uint64, forkDigest [4]byte) string {
 	return fmt.Sprintf(AttestationSubnetTopicFormat, forkDigest, subnet)
 }
 
-func syncCommitteeToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
+func syncCommitteeToTopic(subnet uint64, forkDigest [4]byte) string {
 	return fmt.Sprintf(SyncCommitteeSubnetTopicFormat, forkDigest, subnet)
 }
 
-func blobSubnetToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
+func blobSubnetToTopic(subnet uint64, forkDigest [4]byte) string {
 	return fmt.Sprintf(BlobSubnetTopicFormat, forkDigest, subnet)
 }
-
-func dataColumnSubnetToTopic(subnet uint64, forkDigest [fieldparams.VersionLength]byte) string {
-	return fmt.Sprintf(DataColumnSubnetTopicFormat, forkDigest, subnet)
-}

beacon-chain/p2p/broadcaster_test.go

@@ -13,16 +13,11 @@ import (
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/prysmaticlabs/go-bitfield"
-	"google.golang.org/protobuf/proto"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers/scorers"
 	p2ptest "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
@@ -30,6 +25,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
+	"google.golang.org/protobuf/proto"
 )
 
 func TestService_Broadcast(t *testing.T) {
@@ -524,70 +520,3 @@ func TestService_BroadcastBlob(t *testing.T) {
 	require.NoError(t, p.BroadcastBlob(ctx, subnet, blobSidecar))
 	require.Equal(t, false, util.WaitTimeout(&wg, 1*time.Second), "Failed to receive pubsub within 1s")
 }
-
-func TestService_BroadcastDataColumn(t *testing.T) {
-	require.NoError(t, kzg.Start())
-	p1 := p2ptest.NewTestP2P(t)
-	p2 := p2ptest.NewTestP2P(t)
-	p1.Connect(p2)
-	require.NotEqual(t, 0, len(p1.BHost.Network().Peers()), "No peers")
-
-	p := &Service{
-		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{},
-		}),
-	}
-
-	b, err := blocks.NewSignedBeaconBlock(util.NewBeaconBlockElectra())
-	require.NoError(t, err)
-	blobs := make([]kzg.Blob, fieldparams.MaxBlobsPerBlock)
-	sidecars, err := peerdas.DataColumnSidecars(b, blobs)
-	require.NoError(t, err)
-
-	sidecar := sidecars[0]
-	subnet := uint64(0)
-	topic := DataColumnSubnetTopicFormat
-	GossipTypeMapping[reflect.TypeOf(sidecar)] = topic
-	digest, err := p.currentForkDigest()
-	require.NoError(t, err)
-	topic = fmt.Sprintf(topic, digest, subnet)
-
-	// External peer subscribes to the topic.
-	topic += p.Encoding().ProtocolSuffix()
-	sub, err := p2.SubscribeToTopic(topic)
-	require.NoError(t, err)
-
-	time.Sleep(50 * time.Millisecond) // libp2p fails without this delay...
-
-	// Async listen for the pubsub, must be before the broadcast.
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func(tt *testing.T) {
-		defer wg.Done()
-		ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
-		defer cancel()
-
-		msg, err := sub.Next(ctx)
-		require.NoError(t, err)
-
-		result := &ethpb.DataColumnSidecar{}
-		require.NoError(t, p.Encoding().DecodeGossip(msg.Data, result))
-		require.DeepEqual(t, result, sidecar)
-	}(t)
-
-	// Attempt to broadcast nil object should fail.
-	ctx := context.Background()
-	require.ErrorContains(t, "attempted to broadcast nil", p.BroadcastDataColumn(ctx, subnet, nil))
-
-	// Broadcast to peers and wait.
-	require.NoError(t, p.BroadcastDataColumn(ctx, subnet, sidecar))
-	require.Equal(t, false, util.WaitTimeout(&wg, 1*time.Second), "Failed to receive pubsub within 1s")
-}

beacon-chain/p2p/connection_gater_test.go

@@ -336,7 +336,7 @@ func TestService_InterceptAddrDial_Public(t *testing.T) {
 		}),
 	}
 	var err error
-	//test with public filter
+	// test with public filter
 	cidr := "public"
 	ip := "212.67.10.122"
 	s.addrFilter, err = configureFilter(&Config{AllowListCIDR: cidr})
@@ -348,7 +348,7 @@ func TestService_InterceptAddrDial_Public(t *testing.T) {
 		t.Errorf("Expected multiaddress with ip %s to not be rejected since we allow public addresses", ip)
 	}
 
-	ip = "192.168.1.0" //this is private and should fail
+	ip = "192.168.1.0" // this is private and should fail
 	multiAddress, err = ma.NewMultiaddr(fmt.Sprintf("/ip4/%s/tcp/%d", ip, 3000))
 	require.NoError(t, err)
 	valid = s.InterceptAddrDial("", multiAddress)
@@ -356,7 +356,7 @@ func TestService_InterceptAddrDial_Public(t *testing.T) {
 		t.Errorf("Expected multiaddress with ip %s to be rejected since we are only allowing public addresses", ip)
 	}
 
-	//test with public allow filter, with a public address added to the deny list
+	// test with public allow filter, with a public address added to the deny list
 	invalidPublicIp := "212.67.10.122"
 	validPublicIp := "91.65.69.69"
 	s.addrFilter, err = configureFilter(&Config{AllowListCIDR: "public", DenyListCIDR: []string{"212.67.89.112/16"}})
@@ -384,7 +384,7 @@ func TestService_InterceptAddrDial_Private(t *testing.T) {
 		}),
 	}
 	var err error
-	//test with private filter
+	// test with private filter
 	cidr := "private"
 	s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr}})
 	require.NoError(t, err)
@@ -413,7 +413,7 @@ func TestService_InterceptAddrDial_AllowPrivate(t *testing.T) {
 		}),
 	}
 	var err error
-	//test with private filter
+	// test with private filter
 	cidr := "private"
 	s.addrFilter, err = configureFilter(&Config{AllowListCIDR: cidr})
 	require.NoError(t, err)
@@ -442,7 +442,7 @@ func TestService_InterceptAddrDial_DenyPublic(t *testing.T) {
 		}),
 	}
 	var err error
-	//test with private filter
+	// test with private filter
 	cidr := "public"
 	s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr}})
 	require.NoError(t, err)
@@ -471,7 +471,7 @@ func TestService_InterceptAddrDial_AllowConflict(t *testing.T) {
 		}),
 	}
 	var err error
-	//test with private filter
+	// test with private filter
 	cidr := "public"
 	s.addrFilter, err = configureFilter(&Config{DenyListCIDR: []string{cidr, "192.168.0.0/16"}})
 	require.NoError(t, err)

beacon-chain/p2p/custody.go

@@ -1,103 +0,0 @@
-package p2p
-
-import (
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-)
-
-// GetValidCustodyPeers returns a list of peers that custody a super set of the local node's custody columns.
-func (s *Service) GetValidCustodyPeers(peers []peer.ID) ([]peer.ID, error) {
-	// Get the total number of columns.
-	numberOfColumns := params.BeaconConfig().NumberOfColumns
-
-	localCustodySubnetCount := peerdas.CustodySubnetCount()
-	localCustodyColumns, err := peerdas.CustodyColumns(s.NodeID(), localCustodySubnetCount)
-	if err != nil {
-		return nil, errors.Wrap(err, "custody columns for local node")
-	}
-
-	localCustotyColumnsCount := uint64(len(localCustodyColumns))
-
-	// Find the valid peers.
-	validPeers := make([]peer.ID, 0, len(peers))
-
-loop:
-	for _, pid := range peers {
-		// Get the custody subnets count of the remote peer.
-		remoteCustodySubnetCount := s.CustodyCountFromRemotePeer(pid)
-
-		// Get the remote node ID from the peer ID.
-		remoteNodeID, err := ConvertPeerIDToNodeID(pid)
-		if err != nil {
-			return nil, errors.Wrap(err, "convert peer ID to node ID")
-		}
-
-		// Get the custody columns of the remote peer.
-		remoteCustodyColumns, err := peerdas.CustodyColumns(remoteNodeID, remoteCustodySubnetCount)
-		if err != nil {
-			return nil, errors.Wrap(err, "custody columns")
-		}
-
-		remoteCustodyColumnsCount := uint64(len(remoteCustodyColumns))
-
-		// If the remote peer custodies less columns than the local node, skip it.
-		if remoteCustodyColumnsCount < localCustotyColumnsCount {
-			continue
-		}
-
-		// If the remote peers custodies all the possible columns, add it to the list.
-		if remoteCustodyColumnsCount == numberOfColumns {
-			copiedId := pid
-			validPeers = append(validPeers, copiedId)
-			continue
-		}
-
-		// Filter out invalid peers.
-		for c := range localCustodyColumns {
-			if !remoteCustodyColumns[c] {
-				continue loop
-			}
-		}
-
-		copiedId := pid
-
-		// Add valid peer to list
-		validPeers = append(validPeers, copiedId)
-	}
-
-	return validPeers, nil
-}
-
-// CustodyCountFromRemotePeer retrieves the custody count from a remote peer.
-func (s *Service) CustodyCountFromRemotePeer(pid peer.ID) uint64 {
-	// By default, we assume the peer custodies the minimum number of subnets.
-	custodyRequirement := params.BeaconConfig().CustodyRequirement
-
-	// Retrieve the ENR of the peer.
-	record, err := s.peers.ENR(pid)
-	if err != nil {
-		log.WithError(err).WithFields(logrus.Fields{
-			"peerID":       pid,
-			"defaultValue": custodyRequirement,
-		}).Error("Failed to retrieve ENR for peer, defaulting to the default value")
-
-		return custodyRequirement
-	}
-
-	// Retrieve the custody subnets count from the ENR.
-	custodyCount, err := peerdas.CustodyCountFromRecord(record)
-	if err != nil {
-		log.WithError(err).WithFields(logrus.Fields{
-			"peerID":       pid,
-			"defaultValue": custodyRequirement,
-		}).Debug("Failed to retrieve custody count from ENR for peer, defaulting to the default value")
-
-		return custodyRequirement
-	}
-
-	return custodyCount
-}

beacon-chain/p2p/custody_test.go

@@ -1,163 +0,0 @@
-package p2p
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"net"
-	"testing"
-	"time"
-
-	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/ethereum/go-ethereum/p2p/enr"
-	"github.com/libp2p/go-libp2p/core/crypto"
-	"github.com/libp2p/go-libp2p/core/network"
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers/scorers"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	ecdsaprysm "github.com/prysmaticlabs/prysm/v5/crypto/ecdsa"
-	prysmNetwork "github.com/prysmaticlabs/prysm/v5/network"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-)
-
-func createPeer(t *testing.T, privateKeyOffset int, custodyCount uint64) (*enr.Record, peer.ID, *ecdsa.PrivateKey) {
-	privateKeyBytes := make([]byte, 32)
-	for i := 0; i < 32; i++ {
-		privateKeyBytes[i] = byte(privateKeyOffset + i)
-	}
-
-	unmarshalledPrivateKey, err := crypto.UnmarshalSecp256k1PrivateKey(privateKeyBytes)
-	require.NoError(t, err)
-
-	privateKey, err := ecdsaprysm.ConvertFromInterfacePrivKey(unmarshalledPrivateKey)
-	require.NoError(t, err)
-
-	peerID, err := peer.IDFromPrivateKey(unmarshalledPrivateKey)
-	require.NoError(t, err)
-
-	record := &enr.Record{}
-	record.Set(peerdas.Csc(custodyCount))
-	record.Set(enode.Secp256k1(privateKey.PublicKey))
-
-	return record, peerID, privateKey
-}
-
-func TestGetValidCustodyPeers(t *testing.T) {
-	genesisValidatorRoot := make([]byte, 32)
-
-	for i := 0; i < 32; i++ {
-		genesisValidatorRoot[i] = byte(i)
-	}
-
-	service := &Service{
-		cfg:                   &Config{},
-		genesisTime:           time.Now(),
-		genesisValidatorsRoot: genesisValidatorRoot,
-		peers: peers.NewStatus(context.Background(), &peers.StatusConfig{
-			ScorerParams: &scorers.Config{},
-		}),
-	}
-
-	ipAddrString, err := prysmNetwork.ExternalIPv4()
-	require.NoError(t, err)
-	ipAddr := net.ParseIP(ipAddrString)
-
-	custodyRequirement := params.BeaconConfig().CustodyRequirement
-	dataColumnSidecarSubnetCount := params.BeaconConfig().DataColumnSidecarSubnetCount
-
-	// Peer 1 custodies exactly the same columns than us.
-	// (We use the same keys pair than ours for simplicity)
-	peer1Record, peer1ID, localPrivateKey := createPeer(t, 1, custodyRequirement)
-
-	// Peer 2 custodies all the columns.
-	peer2Record, peer2ID, _ := createPeer(t, 2, dataColumnSidecarSubnetCount)
-
-	// Peer 3 custodies different columns than us (but the same count).
-	// (We use the same public key than peer 2 for simplicity)
-	peer3Record, peer3ID, _ := createPeer(t, 3, custodyRequirement)
-
-	// Peer 4 custodies less columns than us.
-	peer4Record, peer4ID, _ := createPeer(t, 4, custodyRequirement-1)
-
-	listener, err := service.createListener(ipAddr, localPrivateKey)
-	require.NoError(t, err)
-
-	service.dv5Listener = listener
-
-	service.peers.Add(peer1Record, peer1ID, nil, network.DirOutbound)
-	service.peers.Add(peer2Record, peer2ID, nil, network.DirOutbound)
-	service.peers.Add(peer3Record, peer3ID, nil, network.DirOutbound)
-	service.peers.Add(peer4Record, peer4ID, nil, network.DirOutbound)
-
-	actual, err := service.GetValidCustodyPeers([]peer.ID{peer1ID, peer2ID, peer3ID, peer4ID})
-	require.NoError(t, err)
-
-	expected := []peer.ID{peer1ID, peer2ID}
-	require.DeepSSZEqual(t, expected, actual)
-}
-
-func TestCustodyCountFromRemotePeer(t *testing.T) {
-	const (
-		expected uint64 = 7
-		pid             = "test-id"
-	)
-
-	csc := peerdas.Csc(expected)
-
-	// Define a nil record
-	var nilRecord *enr.Record = nil
-
-	// Define an empty record (record with non `csc` entry)
-	emptyRecord := &enr.Record{}
-
-	// Define a nominal record
-	nominalRecord := &enr.Record{}
-	nominalRecord.Set(csc)
-
-	testCases := []struct {
-		name     string
-		record   *enr.Record
-		expected uint64
-	}{
-		{
-			name:     "nominal",
-			record:   nominalRecord,
-			expected: expected,
-		},
-		{
-			name:     "nil",
-			record:   nilRecord,
-			expected: params.BeaconConfig().CustodyRequirement,
-		},
-		{
-			name:     "empty",
-			record:   emptyRecord,
-			expected: params.BeaconConfig().CustodyRequirement,
-		},
-	}
-
-	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{},
-			})
-
-			// Add a new peer with the record.
-			peers.Add(tc.record, pid, nil, network.DirOutbound)
-
-			// Create a new service.
-			service := &Service{
-				peers: peers,
-			}
-
-			// Retrieve the custody count from the remote peer.
-			actual := service.CustodyCountFromRemotePeer(pid)
-
-			// Verify the result.
-			require.Equal(t, tc.expected, actual)
-		})
-	}
-
-}

beacon-chain/p2p/discovery.go

@@ -15,9 +15,7 @@ import (
 	ma "github.com/multiformats/go-multiaddr"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
 	"github.com/prysmaticlabs/prysm/v5/config/features"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
@@ -44,18 +42,16 @@ const (
 	udp6
 )
 
-const quickProtocolEnrKey = "quic"
-
 type quicProtocol uint16
 
 // quicProtocol is the "quic" key, which holds the QUIC port of the node.
-func (quicProtocol) ENRKey() string { return quickProtocolEnrKey }
+func (quicProtocol) ENRKey() string { return "quic" }
 
-// RefreshPersistentSubnets checks that we are tracking our local persistent subnets for a variety of gossip topics.
-// This routine checks for our attestation, sync committee and data column subnets and updates them if they have
-// been rotated.
-func (s *Service) RefreshPersistentSubnets() {
-	// return early if discv5 isnt running
+// RefreshENR uses an epoch to refresh the enr entry for our node
+// with the tracked committee ids for the epoch, allowing our node
+// to be dynamically discoverable by others given our tracked committee ids.
+func (s *Service) RefreshENR() {
+	// return early if discv5 isn't running
 	if s.dv5Listener == nil || !s.isInitialized() {
 		return
 	}
@@ -64,10 +60,6 @@ func (s *Service) RefreshPersistentSubnets() {
 		log.WithError(err).Error("Could not initialize persistent subnets")
 		return
 	}
-	if err := initializePersistentColumnSubnets(s.dv5Listener.LocalNode().ID()); err != nil {
-		log.WithError(err).Error("Could not initialize persistent column subnets")
-		return
-	}
 
 	bitV := bitfield.NewBitvector64()
 	committees := cache.SubnetIDs.GetAllSubnets()
@@ -266,10 +258,6 @@ func (s *Service) createLocalNode(
 		localNode.Set(quicEntry)
 	}
 
-	if params.PeerDASEnabled() {
-		localNode.Set(peerdas.Csc(peerdas.CustodySubnetCount()))
-	}
-
 	localNode.SetFallbackIP(ipAddr)
 	localNode.SetFallbackUDP(udpPort)
 
@@ -358,8 +346,6 @@ func (s *Service) filterPeer(node *enode.Node) bool {
 
 	// Ignore nodes that are already active.
 	if s.peers.IsActive(peerData.ID) {
-		// Constantly update enr for known peers
-		s.peers.UpdateENR(node.Record(), peerData.ID)
 		return false
 	}
 

beacon-chain/p2p/discovery_test.go

@@ -20,11 +20,8 @@ import (
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/prysmaticlabs/go-bitfield"
-	logTest "github.com/sirupsen/logrus/hooks/test"
-
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers/peerdata"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers/scorers"
@@ -40,6 +37,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
+	logTest "github.com/sirupsen/logrus/hooks/test"
 )
 
 var discoveryWaitTime = 1 * time.Second
@@ -133,10 +131,6 @@ func TestStartDiscV5_DiscoverAllPeers(t *testing.T) {
 }
 
 func TestCreateLocalNode(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig()
-	cfg.Eip7594ForkEpoch = 1
-	params.OverrideBeaconConfig(cfg)
 	testCases := []struct {
 		name          string
 		cfg           *Config
@@ -233,11 +227,6 @@ 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 custody_subnet_count config.
-			custodySubnetCount := new(uint64)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(peerdas.CustodySubnetCountEnrKey, custodySubnetCount)))
-			require.Equal(t, uint64(1), *custodySubnetCount)
 		})
 	}
 }
@@ -612,7 +601,7 @@ func TestRefreshENR_ForkBoundaries(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			s := tt.svcBuilder(t)
-			s.RefreshPersistentSubnets()
+			s.RefreshENR()
 			tt.postValidation(t, s)
 			s.dv5Listener.Close()
 			cache.SubnetIDs.EmptyAllCaches()

beacon-chain/p2p/gossip_scoring_params.go

@@ -121,7 +121,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), strings.Contains(topic, GossipDataColumnSidecarMessage):
+	case strings.Contains(topic, GossipBlobSidecarMessage):
 		// TODO(Deneb): Using the default block scoring. But this should be updated.
 		return defaultBlockTopicParams(), nil
 	default:

beacon-chain/p2p/gossip_topic_mappings.go

@@ -22,13 +22,13 @@ var gossipTopicMappings = map[string]proto.Message{
 	SyncCommitteeSubnetTopicFormat:            &ethpb.SyncCommitteeMessage{},
 	BlsToExecutionChangeSubnetTopicFormat:     &ethpb.SignedBLSToExecutionChange{},
 	BlobSubnetTopicFormat:                     &ethpb.BlobSidecar{},
-	DataColumnSubnetTopicFormat:               &ethpb.DataColumnSidecar{},
 }
 
 // GossipTopicMappings is a function to return the assigned data type
 // versioned by epoch.
 func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
-	if topic == BlockSubnetTopicFormat {
+	switch topic {
+	case BlockSubnetTopicFormat:
 		if epoch >= params.BeaconConfig().ElectraForkEpoch {
 			return &ethpb.SignedBeaconBlockElectra{}
 		}
@@ -44,8 +44,25 @@ func GossipTopicMappings(topic string, epoch primitives.Epoch) proto.Message {
 		if epoch >= params.BeaconConfig().AltairForkEpoch {
 			return &ethpb.SignedBeaconBlockAltair{}
 		}
+		return gossipTopicMappings[topic]
+	case AttestationSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.AttestationElectra{}
+		}
+		return gossipTopicMappings[topic]
+	case AttesterSlashingSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.AttesterSlashingElectra{}
+		}
+		return gossipTopicMappings[topic]
+	case AggregateAndProofSubnetTopicFormat:
+		if epoch >= params.BeaconConfig().ElectraForkEpoch {
+			return &ethpb.SignedAggregateAttestationAndProofElectra{}
+		}
+		return gossipTopicMappings[topic]
+	default:
+		return gossipTopicMappings[topic]
 	}
-	return gossipTopicMappings[topic]
 }
 
 // AllTopics returns all topics stored in our
@@ -76,4 +93,7 @@ func init() {
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockDeneb{})] = BlockSubnetTopicFormat
 	// Specially handle Electra objects.
 	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedBeaconBlockElectra{})] = BlockSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.AttestationElectra{})] = AttestationSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.AttesterSlashingElectra{})] = AttesterSlashingSubnetTopicFormat
+	GossipTypeMapping[reflect.TypeOf(&ethpb.SignedAggregateAttestationAndProofElectra{})] = AggregateAndProofSubnetTopicFormat
 }

beacon-chain/p2p/gossip_topic_mappings_test.go

@@ -22,20 +22,20 @@ func TestMappingHasNoDuplicates(t *testing.T) {
 	}
 }
 
-func TestGossipTopicMappings_CorrectBlockType(t *testing.T) {
+func TestGossipTopicMappings_CorrectType(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	bCfg := params.BeaconConfig().Copy()
 	altairForkEpoch := primitives.Epoch(100)
-	BellatrixForkEpoch := primitives.Epoch(200)
-	CapellaForkEpoch := primitives.Epoch(300)
-	DenebForkEpoch := primitives.Epoch(400)
-	ElectraForkEpoch := primitives.Epoch(500)
+	bellatrixForkEpoch := primitives.Epoch(200)
+	capellaForkEpoch := primitives.Epoch(300)
+	denebForkEpoch := primitives.Epoch(400)
+	electraForkEpoch := primitives.Epoch(500)
 
 	bCfg.AltairForkEpoch = altairForkEpoch
-	bCfg.BellatrixForkEpoch = BellatrixForkEpoch
-	bCfg.CapellaForkEpoch = CapellaForkEpoch
-	bCfg.DenebForkEpoch = DenebForkEpoch
-	bCfg.ElectraForkEpoch = ElectraForkEpoch
+	bCfg.BellatrixForkEpoch = bellatrixForkEpoch
+	bCfg.CapellaForkEpoch = capellaForkEpoch
+	bCfg.DenebForkEpoch = denebForkEpoch
+	bCfg.ElectraForkEpoch = electraForkEpoch
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.AltairForkVersion)] = primitives.Epoch(100)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.BellatrixForkVersion)] = primitives.Epoch(200)
 	bCfg.ForkVersionSchedule[bytesutil.ToBytes4(bCfg.CapellaForkVersion)] = primitives.Epoch(300)
@@ -47,29 +47,83 @@ func TestGossipTopicMappings_CorrectBlockType(t *testing.T) {
 	pMessage := GossipTopicMappings(BlockSubnetTopicFormat, 0)
 	_, ok := pMessage.(*ethpb.SignedBeaconBlock)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, 0)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, 0)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, 0)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Altair Fork
 	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, altairForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockAltair)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, altairForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Bellatrix Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, BellatrixForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, bellatrixForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockBellatrix)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, bellatrixForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Capella Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, CapellaForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, capellaForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockCapella)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, capellaForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Deneb Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, DenebForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, denebForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockDeneb)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.Attestation)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashing)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, denebForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProof)
+	assert.Equal(t, true, ok)
 
 	// Electra Fork
-	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, ElectraForkEpoch)
+	pMessage = GossipTopicMappings(BlockSubnetTopicFormat, electraForkEpoch)
 	_, ok = pMessage.(*ethpb.SignedBeaconBlockElectra)
 	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttestationSubnetTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.AttestationElectra)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AttesterSlashingSubnetTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.AttesterSlashingElectra)
+	assert.Equal(t, true, ok)
+	pMessage = GossipTopicMappings(AggregateAndProofSubnetTopicFormat, electraForkEpoch)
+	_, ok = pMessage.(*ethpb.SignedAggregateAttestationAndProofElectra)
+	assert.Equal(t, true, ok)
 }

beacon-chain/p2p/interfaces.go

@@ -3,7 +3,6 @@ package p2p
 import (
 	"context"
 
-	"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"
@@ -29,12 +28,6 @@ type P2P interface {
 	ConnectionHandler
 	PeersProvider
 	MetadataProvider
-	CustodyHandler
-}
-
-type Acceser interface {
-	Broadcaster
-	PeerManager
 }
 
 // Broadcaster broadcasts messages to peers over the p2p pubsub protocol.
@@ -43,7 +36,6 @@ type Broadcaster interface {
 	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
-	BroadcastDataColumn(ctx context.Context, columnSubnet uint64, dataColumnSidecar *ethpb.DataColumnSidecar) error
 }
 
 // SetStreamHandler configures p2p to handle streams of a certain topic ID.
@@ -89,9 +81,8 @@ type PeerManager interface {
 	PeerID() peer.ID
 	Host() host.Host
 	ENR() *enr.Record
-	NodeID() enode.ID
 	DiscoveryAddresses() ([]multiaddr.Multiaddr, error)
-	RefreshPersistentSubnets()
+	RefreshENR()
 	FindPeersWithSubnet(ctx context.Context, topic string, subIndex uint64, threshold int) (bool, error)
 	AddPingMethod(reqFunc func(ctx context.Context, id peer.ID) error)
 }
@@ -111,8 +102,3 @@ type MetadataProvider interface {
 	Metadata() metadata.Metadata
 	MetadataSeq() uint64
 }
-
-type CustodyHandler interface {
-	CustodyCountFromRemotePeer(peer.ID) uint64
-	GetValidCustodyPeers([]peer.ID) ([]peer.ID, error)
-}

beacon-chain/p2p/monitoring.go

@@ -60,25 +60,17 @@ var (
 			"the subnet. The beacon node increments this counter when the broadcast is blocked " +
 			"until a subnet peer can be found.",
 	})
-	blobSidecarBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
+	blobSidecarCommitteeBroadcasts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_blob_sidecar_committee_broadcasts",
-		Help: "The number of blob sidecar messages that were broadcast with no peer on.",
+		Help: "The number of blob sidecar committee 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.",
 	})
-	blobSidecarBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
+	blobSidecarCommitteeBroadcastAttempts = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_blob_sidecar_committee_attempted_broadcasts",
-		Help: "The number of blob sidecar messages that were attempted to be broadcast.",
-	})
-	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 messages that were attempted to be broadcast.",
+		Help: "The number of blob sidecar committee messages that were attempted to be broadcast.",
 	})
 
 	// Gossip Tracer Metrics

beacon-chain/p2p/peers/status.go

@@ -159,14 +159,6 @@ func (p *Status) Add(record *enr.Record, pid peer.ID, address ma.Multiaddr, dire
 	p.addIpToTracker(pid)
 }
 
-func (p *Status) UpdateENR(record *enr.Record, pid peer.ID) {
-	p.store.Lock()
-	defer p.store.Unlock()
-	if peerData, ok := p.store.PeerData(pid); ok {
-		peerData.Enr = record
-	}
-}
-
 // Address returns the multiaddress of the given remote peer.
 // This will error if the peer does not exist.
 func (p *Status) Address(pid peer.ID) (ma.Multiaddr, error) {

beacon-chain/p2p/pubsub.go

@@ -165,14 +165,14 @@ func (s *Service) pubsubOptions() []pubsub.Option {
 func parsePeersEnr(peers []string) ([]peer.AddrInfo, error) {
 	addrs, err := PeersFromStringAddrs(peers)
 	if err != nil {
-		return nil, fmt.Errorf("cannot convert peers raw ENRs into multiaddresses: %v", err)
+		return nil, fmt.Errorf("Cannot convert peers raw ENRs into multiaddresses: %v", err)
 	}
 	if len(addrs) == 0 {
-		return nil, fmt.Errorf("converting peers raw ENRs into multiaddresses resulted in an empty list")
+		return nil, fmt.Errorf("Converting peers raw ENRs into multiaddresses resulted in an empty list")
 	}
 	directAddrInfos, err := peer.AddrInfosFromP2pAddrs(addrs...)
 	if err != nil {
-		return nil, fmt.Errorf("cannot convert peers multiaddresses into AddrInfos: %v", err)
+		return nil, fmt.Errorf("Cannot convert peers multiaddresses into AddrInfos: %v", err)
 	}
 	return directAddrInfos, nil
 }

beacon-chain/p2p/pubsub_filter_test.go

@@ -90,7 +90,7 @@ 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 || topic == DataColumnSubnetTopicFormat {
+		if topic == AttestationSubnetTopicFormat || topic == SyncCommitteeSubnetTopicFormat || topic == BlobSubnetTopicFormat {
 			formatting = append(formatting, 0 /* some subnet ID */)
 		}
 

beacon-chain/p2p/rpc_topic_mappings.go

@@ -43,12 +43,6 @@ const BlobSidecarsByRangeName = "/blob_sidecars_by_range"
 // BlobSidecarsByRootName is the name for the BlobSidecarsByRoot v1 message topic.
 const BlobSidecarsByRootName = "/blob_sidecars_by_root"
 
-// DataColumnSidecarsByRootName is the name for the DataColumnSidecarsByRoot v1 message topic.
-const DataColumnSidecarsByRootName = "/data_column_sidecars_by_root"
-
-// DataColumnSidecarsByRangeName is the name for the DataColumnSidecarsByRange v1 message topic.
-const DataColumnSidecarsByRangeName = "/data_column_sidecars_by_range"
-
 const (
 	// V1 RPC Topics
 	// RPCStatusTopicV1 defines the v1 topic for the status rpc method.
@@ -71,12 +65,6 @@ const (
 	// 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 = protocolPrefix + BlobSidecarsByRootName + SchemaVersionV1
-	// RPCDataColumnSidecarsByRootTopicV1 is a topic for requesting data column sidecars by their block root. New in PeerDAS.
-	// /eth2/beacon_chain/req/data_column_sidecars_by_root/1
-	RPCDataColumnSidecarsByRootTopicV1 = protocolPrefix + DataColumnSidecarsByRootName + SchemaVersionV1
-	// RPCDataColumnSidecarsByRangeTopicV1 is a topic for requesting data column sidecars by their slot. New in PeerDAS.
-	// /eth2/beacon_chain/req/data_column_sidecars_by_range/1
-	RPCDataColumnSidecarsByRangeTopicV1 = protocolPrefix + DataColumnSidecarsByRangeName + SchemaVersionV1
 
 	// V2 RPC Topics
 	// RPCBlocksByRangeTopicV2 defines v2 the topic for the blocks by range rpc method.
@@ -113,10 +101,6 @@ var RPCTopicMappings = map[string]interface{}{
 	RPCBlobSidecarsByRangeTopicV1: new(pb.BlobSidecarsByRangeRequest),
 	// BlobSidecarsByRoot v1 Message
 	RPCBlobSidecarsByRootTopicV1: new(p2ptypes.BlobSidecarsByRootReq),
-	// DataColumnSidecarsByRange v1 Message
-	RPCDataColumnSidecarsByRangeTopicV1: new(pb.DataColumnSidecarsByRangeRequest),
-	// DataColumnSidecarsByRoot v1 Message
-	RPCDataColumnSidecarsByRootTopicV1: new(p2ptypes.DataColumnSidecarsByRootReq),
 }
 
 // Maps all registered protocol prefixes.
@@ -135,8 +119,6 @@ var messageMapping = map[string]bool{
 	MetadataMessageName:            true,
 	BlobSidecarsByRangeName:        true,
 	BlobSidecarsByRootName:         true,
-	DataColumnSidecarsByRootName:   true,
-	DataColumnSidecarsByRangeName:  true,
 }
 
 // Maps all the RPC messages which are to updated in altair.

beacon-chain/p2p/service.go

@@ -226,7 +226,7 @@ func (s *Service) Start() {
 	}
 	// Initialize metadata according to the
 	// current epoch.
-	s.RefreshPersistentSubnets()
+	s.RefreshENR()
 
 	// Periodic functions.
 	async.RunEvery(s.ctx, params.BeaconConfig().TtfbTimeoutDuration(), func() {
@@ -234,7 +234,7 @@ func (s *Service) Start() {
 	})
 	async.RunEvery(s.ctx, 30*time.Minute, s.Peers().Prune)
 	async.RunEvery(s.ctx, time.Duration(params.BeaconConfig().RespTimeout)*time.Second, s.updateMetrics)
-	async.RunEvery(s.ctx, refreshRate, s.RefreshPersistentSubnets)
+	async.RunEvery(s.ctx, refreshRate, s.RefreshENR)
 	async.RunEvery(s.ctx, 1*time.Minute, func() {
 		inboundQUICCount := len(s.peers.InboundConnectedWithProtocol(peers.QUIC))
 		inboundTCPCount := len(s.peers.InboundConnectedWithProtocol(peers.TCP))
@@ -358,15 +358,6 @@ 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 [32]byte{}
-	}
-	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

@@ -11,18 +11,17 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
-	"go.opencensus.io/trace"
-
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	"github.com/prysmaticlabs/prysm/v5/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/wrapper"
 	"github.com/prysmaticlabs/prysm/v5/crypto/hash"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	mathutil "github.com/prysmaticlabs/prysm/v5/math"
+	"go.opencensus.io/trace"
+
+	"github.com/prysmaticlabs/prysm/v5/config/params"
 	pb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
@@ -35,8 +34,8 @@ var syncCommsSubnetEnrKey = params.BeaconNetworkConfig().SyncCommsSubnetKey
 // The value used with the subnet, inorder
 // to create an appropriate key to retrieve
 // the relevant lock. This is used to differentiate
-// sync subnets from others. This is deliberately
-// chosen as more than 64 (attestation subnet count).
+// sync subnets from attestation subnets. This is deliberately
+// chosen as more than 64(attestation subnet count).
 const syncLockerVal = 100
 
 // The value used with the blob sidecar subnet, in order
@@ -46,13 +45,6 @@ const syncLockerVal = 100
 // chosen more than sync and attestation subnet combined.
 const blobSubnetLockerVal = 110
 
-// 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
-
 // FindPeersWithSubnet performs a network search for peers
 // subscribed to a particular subnet. Then it tries to connect
 // with those peers. This method will block until either:
@@ -215,25 +207,6 @@ func initializePersistentSubnets(id enode.ID, epoch primitives.Epoch) error {
 	return nil
 }
 
-func initializePersistentColumnSubnets(id enode.ID) error {
-	_, ok, expTime := cache.ColumnSubnetIDs.GetColumnSubnets()
-	if ok && expTime.After(time.Now()) {
-		return nil
-	}
-	subsMap, err := peerdas.CustodyColumnSubnets(id, peerdas.CustodySubnetCount())
-	if err != nil {
-		return err
-	}
-
-	subs := make([]uint64, 0, len(subsMap))
-	for sub := range subsMap {
-		subs = append(subs, sub)
-	}
-
-	cache.ColumnSubnetIDs.AddColumnSubnets(subs)
-	return nil
-}
-
 // Spec pseudocode definition:
 //
 // def compute_subscribed_subnets(node_id: NodeID, epoch: Epoch) -> Sequence[SubnetID]:
@@ -383,11 +356,10 @@ 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 re-used
-// between both the attestation, sync and blob 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
+// between both the attestation and sync subnets. In
+// order to differentiate between attestation and sync
+// subnets. Sync subnets are stored by (subnet+syncLockerVal). This
+// is to prevent conflicts while allowing both subnets
 // to use a single locker.
 func (s *Service) subnetLocker(i uint64) *sync.RWMutex {
 	s.subnetsLockLock.Lock()

beacon-chain/p2p/subnets_test.go

@@ -81,7 +81,7 @@ func TestStartDiscV5_FindPeersWithSubnet(t *testing.T) {
 	bootNodeENR := bootListener.Self().String()
 
 	// Create 3 nodes, each subscribed to a different subnet.
-	// Each node is connected to the boostrap node.
+	// Each node is connected to the bootstrap node.
 	services := make([]*Service, 0, 3)
 
 	for i := 1; i <= 3; i++ {

beacon-chain/p2p/testing/BUILD.bazel

@@ -17,11 +17,9 @@ 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/params:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
         "@com_github_ethereum_go_ethereum//crypto:go_default_library",

beacon-chain/p2p/testing/fuzz_p2p.go

@@ -3,7 +3,6 @@ package testing
 import (
 	"context"
 
-	"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"
@@ -28,166 +27,148 @@ func NewFuzzTestP2P() *FakeP2P {
 }
 
 // Encoding -- fake.
-func (*FakeP2P) Encoding() encoder.NetworkEncoding {
+func (_ *FakeP2P) Encoding() encoder.NetworkEncoding {
 	return &encoder.SszNetworkEncoder{}
 }
 
 // AddConnectionHandler -- fake.
-func (*FakeP2P) AddConnectionHandler(_, _ func(ctx context.Context, id peer.ID) error) {
+func (_ *FakeP2P) AddConnectionHandler(_, _ func(ctx context.Context, id peer.ID) error) {
 
 }
 
 // AddDisconnectionHandler -- fake.
-func (*FakeP2P) AddDisconnectionHandler(_ func(ctx context.Context, id peer.ID) error) {
+func (_ *FakeP2P) AddDisconnectionHandler(_ func(ctx context.Context, id peer.ID) error) {
 }
 
 // AddPingMethod -- fake.
-func (*FakeP2P) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {
+func (_ *FakeP2P) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {
 
 }
 
 // PeerID -- fake.
-func (*FakeP2P) PeerID() peer.ID {
+func (_ *FakeP2P) PeerID() peer.ID {
 	return "fake"
 }
 
 // ENR returns the enr of the local peer.
-func (*FakeP2P) ENR() *enr.Record {
+func (_ *FakeP2P) ENR() *enr.Record {
 	return new(enr.Record)
 }
 
-// NodeID returns the node id of the local peer.
-func (*FakeP2P) NodeID() enode.ID {
-	return [32]byte{}
-}
-
 // DiscoveryAddresses -- fake
-func (*FakeP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
+func (_ *FakeP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return nil, nil
 }
 
 // FindPeersWithSubnet mocks the p2p func.
-func (*FakeP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
+func (_ *FakeP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
 	return false, nil
 }
 
 // RefreshENR mocks the p2p func.
-func (*FakeP2P) RefreshPersistentSubnets() {}
+func (_ *FakeP2P) RefreshENR() {}
 
 // LeaveTopic -- fake.
-func (*FakeP2P) LeaveTopic(_ string) error {
+func (_ *FakeP2P) LeaveTopic(_ string) error {
 	return nil
 }
 
 // Metadata -- fake.
-func (*FakeP2P) Metadata() metadata.Metadata {
+func (_ *FakeP2P) Metadata() metadata.Metadata {
 	return nil
 }
 
 // Peers -- fake.
-func (*FakeP2P) Peers() *peers.Status {
+func (_ *FakeP2P) Peers() *peers.Status {
 	return nil
 }
 
 // PublishToTopic -- fake.
-func (*FakeP2P) PublishToTopic(_ context.Context, _ string, _ []byte, _ ...pubsub.PubOpt) error {
+func (_ *FakeP2P) PublishToTopic(_ context.Context, _ string, _ []byte, _ ...pubsub.PubOpt) error {
 	return nil
 }
 
 // Send -- fake.
-func (*FakeP2P) Send(_ context.Context, _ interface{}, _ string, _ peer.ID) (network.Stream, error) {
+func (_ *FakeP2P) Send(_ context.Context, _ interface{}, _ string, _ peer.ID) (network.Stream, error) {
 	return nil, nil
 }
 
 // PubSub -- fake.
-func (*FakeP2P) PubSub() *pubsub.PubSub {
+func (_ *FakeP2P) PubSub() *pubsub.PubSub {
 	return nil
 }
 
 // MetadataSeq -- fake.
-func (*FakeP2P) MetadataSeq() uint64 {
+func (_ *FakeP2P) MetadataSeq() uint64 {
 	return 0
 }
 
 // SetStreamHandler -- fake.
-func (*FakeP2P) SetStreamHandler(_ string, _ network.StreamHandler) {
+func (_ *FakeP2P) SetStreamHandler(_ string, _ network.StreamHandler) {
 
 }
 
 // SubscribeToTopic -- fake.
-func (*FakeP2P) SubscribeToTopic(_ string, _ ...pubsub.SubOpt) (*pubsub.Subscription, error) {
+func (_ *FakeP2P) SubscribeToTopic(_ string, _ ...pubsub.SubOpt) (*pubsub.Subscription, error) {
 	return nil, nil
 }
 
 // JoinTopic -- fake.
-func (*FakeP2P) JoinTopic(_ string, _ ...pubsub.TopicOpt) (*pubsub.Topic, error) {
+func (_ *FakeP2P) JoinTopic(_ string, _ ...pubsub.TopicOpt) (*pubsub.Topic, error) {
 	return nil, nil
 }
 
 // Host -- fake.
-func (*FakeP2P) Host() host.Host {
+func (_ *FakeP2P) Host() host.Host {
 	return nil
 }
 
 // Disconnect -- fake.
-func (*FakeP2P) Disconnect(_ peer.ID) error {
+func (_ *FakeP2P) Disconnect(_ peer.ID) error {
 	return nil
 }
 
 // Broadcast -- fake.
-func (*FakeP2P) Broadcast(_ context.Context, _ proto.Message) error {
+func (_ *FakeP2P) Broadcast(_ context.Context, _ proto.Message) error {
 	return nil
 }
 
 // BroadcastAttestation -- fake.
-func (*FakeP2P) BroadcastAttestation(_ context.Context, _ uint64, _ ethpb.Att) error {
+func (_ *FakeP2P) BroadcastAttestation(_ context.Context, _ uint64, _ ethpb.Att) error {
 	return nil
 }
 
 // BroadcastSyncCommitteeMessage -- fake.
-func (*FakeP2P) BroadcastSyncCommitteeMessage(_ context.Context, _ uint64, _ *ethpb.SyncCommitteeMessage) error {
+func (_ *FakeP2P) BroadcastSyncCommitteeMessage(_ context.Context, _ uint64, _ *ethpb.SyncCommitteeMessage) error {
 	return nil
 }
 
 // BroadcastBlob -- fake.
-func (*FakeP2P) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.BlobSidecar) error {
-	return nil
-}
-
-// BroadcastDataColumn -- fake.
-func (*FakeP2P) BroadcastDataColumn(_ context.Context, _ uint64, _ *ethpb.DataColumnSidecar) error {
+func (_ *FakeP2P) BroadcastBlob(_ context.Context, _ uint64, _ *ethpb.BlobSidecar) error {
 	return nil
 }
 
 // InterceptPeerDial -- fake.
-func (*FakeP2P) InterceptPeerDial(peer.ID) (allow bool) {
+func (_ *FakeP2P) InterceptPeerDial(peer.ID) (allow bool) {
 	return true
 }
 
 // InterceptAddrDial -- fake.
-func (*FakeP2P) InterceptAddrDial(peer.ID, multiaddr.Multiaddr) (allow bool) {
+func (_ *FakeP2P) InterceptAddrDial(peer.ID, multiaddr.Multiaddr) (allow bool) {
 	return true
 }
 
 // InterceptAccept -- fake.
-func (*FakeP2P) InterceptAccept(_ network.ConnMultiaddrs) (allow bool) {
+func (_ *FakeP2P) InterceptAccept(_ network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptSecured -- fake.
-func (*FakeP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiaddrs) (allow bool) {
+func (_ *FakeP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptUpgraded -- fake.
-func (*FakeP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
+func (_ *FakeP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
 	return true, 0
 }
-
-func (*FakeP2P) CustodyCountFromRemotePeer(peer.ID) uint64 {
-	return 0
-}
-
-func (*FakeP2P) GetValidCustodyPeers(peers []peer.ID) ([]peer.ID, error) {
-	return peers, nil
-}

beacon-chain/p2p/testing/mock_broadcaster.go

@@ -48,12 +48,6 @@ func (m *MockBroadcaster) BroadcastBlob(context.Context, uint64, *ethpb.BlobSide
 	return nil
 }
 
-// BroadcastDataColumn broadcasts a data column for mock.
-func (m *MockBroadcaster) BroadcastDataColumn(context.Context, uint64, *ethpb.DataColumnSidecar) 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_host.go

@@ -18,12 +18,12 @@ type MockHost struct {
 }
 
 // ID --
-func (*MockHost) ID() peer.ID {
+func (_ *MockHost) ID() peer.ID {
 	return ""
 }
 
 // Peerstore --
-func (*MockHost) Peerstore() peerstore.Peerstore {
+func (_ *MockHost) Peerstore() peerstore.Peerstore {
 	return nil
 }
 
@@ -33,46 +33,46 @@ func (m *MockHost) Addrs() []ma.Multiaddr {
 }
 
 // Network --
-func (*MockHost) Network() network.Network {
+func (_ *MockHost) Network() network.Network {
 	return nil
 }
 
 // Mux --
-func (*MockHost) Mux() protocol.Switch {
+func (_ *MockHost) Mux() protocol.Switch {
 	return nil
 }
 
 // Connect --
-func (*MockHost) Connect(_ context.Context, _ peer.AddrInfo) error {
+func (_ *MockHost) Connect(_ context.Context, _ peer.AddrInfo) error {
 	return nil
 }
 
 // SetStreamHandler --
-func (*MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {}
+func (_ *MockHost) SetStreamHandler(_ protocol.ID, _ network.StreamHandler) {}
 
 // SetStreamHandlerMatch --
-func (*MockHost) SetStreamHandlerMatch(protocol.ID, func(id protocol.ID) bool, network.StreamHandler) {
+func (_ *MockHost) SetStreamHandlerMatch(protocol.ID, func(id protocol.ID) bool, network.StreamHandler) {
 }
 
 // RemoveStreamHandler --
-func (*MockHost) RemoveStreamHandler(_ protocol.ID) {}
+func (_ *MockHost) RemoveStreamHandler(_ protocol.ID) {}
 
 // NewStream --
-func (*MockHost) NewStream(_ context.Context, _ peer.ID, _ ...protocol.ID) (network.Stream, error) {
+func (_ *MockHost) NewStream(_ context.Context, _ peer.ID, _ ...protocol.ID) (network.Stream, error) {
 	return nil, nil
 }
 
 // Close --
-func (*MockHost) Close() error {
+func (_ *MockHost) Close() error {
 	return nil
 }
 
 // ConnManager --
-func (*MockHost) ConnManager() connmgr.ConnManager {
+func (_ *MockHost) ConnManager() connmgr.ConnManager {
 	return nil
 }
 
 // EventBus --
-func (*MockHost) EventBus() event.Bus {
+func (_ *MockHost) EventBus() event.Bus {
 	return nil
 }

beacon-chain/p2p/testing/mock_peermanager.go

@@ -4,7 +4,6 @@ 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"
@@ -21,7 +20,7 @@ type MockPeerManager struct {
 }
 
 // Disconnect .
-func (*MockPeerManager) Disconnect(peer.ID) error {
+func (_ *MockPeerManager) Disconnect(peer.ID) error {
 	return nil
 }
 
@@ -40,11 +39,6 @@ func (m MockPeerManager) ENR() *enr.Record {
 	return m.Enr
 }
 
-// NodeID .
-func (m MockPeerManager) NodeID() enode.ID {
-	return [32]byte{}
-}
-
 // DiscoveryAddresses .
 func (m MockPeerManager) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	if m.FailDiscoveryAddr {
@@ -54,12 +48,12 @@ func (m MockPeerManager) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 }
 
 // RefreshENR .
-func (MockPeerManager) RefreshPersistentSubnets() {}
+func (_ MockPeerManager) RefreshENR() {}
 
 // FindPeersWithSubnet .
-func (MockPeerManager) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
+func (_ MockPeerManager) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
 	return true, nil
 }
 
 // AddPingMethod .
-func (MockPeerManager) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {}
+func (_ MockPeerManager) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {}

beacon-chain/p2p/testing/p2p.go

@@ -10,7 +10,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	core "github.com/libp2p/go-libp2p/core"
@@ -23,11 +22,9 @@ import (
 	swarmt "github.com/libp2p/go-libp2p/p2p/net/swarm/testing"
 	"github.com/multiformats/go-multiaddr"
 	ssz "github.com/prysmaticlabs/fastssz"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/encoder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers/scorers"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/metadata"
 	"github.com/sirupsen/logrus"
@@ -53,10 +50,9 @@ type TestP2P struct {
 }
 
 // NewTestP2P initializes a new p2p test service.
-func NewTestP2P(t *testing.T, opts ...swarmt.Option) *TestP2P {
-	opts = append(opts, swarmt.OptDisableQUIC)
+func NewTestP2P(t *testing.T) *TestP2P {
 	ctx := context.Background()
-	h := bhost.NewBlankHost(swarmt.GenSwarm(t, opts...))
+	h := bhost.NewBlankHost(swarmt.GenSwarm(t, swarmt.OptDisableQUIC))
 	ps, err := pubsub.NewFloodSub(ctx, h,
 		pubsub.WithMessageSigning(false),
 		pubsub.WithStrictSignatureVerification(false),
@@ -187,12 +183,6 @@ func (p *TestP2P) BroadcastBlob(context.Context, uint64, *ethpb.BlobSidecar) err
 	return nil
 }
 
-// BroadcastDataColumn broadcasts a data column for mock.
-func (p *TestP2P) BroadcastDataColumn(context.Context, uint64, *ethpb.DataColumnSidecar) 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)
@@ -242,7 +232,7 @@ func (p *TestP2P) LeaveTopic(topic string) error {
 }
 
 // Encoding returns ssz encoding.
-func (*TestP2P) Encoding() encoder.NetworkEncoding {
+func (_ *TestP2P) Encoding() encoder.NetworkEncoding {
 	return &encoder.SszNetworkEncoder{}
 }
 
@@ -269,17 +259,12 @@ func (p *TestP2P) Host() host.Host {
 }
 
 // ENR returns the enr of the local peer.
-func (*TestP2P) ENR() *enr.Record {
+func (_ *TestP2P) ENR() *enr.Record {
 	return new(enr.Record)
 }
 
-// NodeID returns the node id of the local peer.
-func (*TestP2P) NodeID() enode.ID {
-	return [32]byte{}
-}
-
 // DiscoveryAddresses --
-func (*TestP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
+func (_ *TestP2P) DiscoveryAddresses() ([]multiaddr.Multiaddr, error) {
 	return nil, nil
 }
 
@@ -361,7 +346,7 @@ func (p *TestP2P) Send(ctx context.Context, msg interface{}, topic string, pid p
 }
 
 // Started always returns true.
-func (*TestP2P) Started() bool {
+func (_ *TestP2P) Started() bool {
 	return true
 }
 
@@ -371,12 +356,12 @@ func (p *TestP2P) Peers() *peers.Status {
 }
 
 // FindPeersWithSubnet mocks the p2p func.
-func (*TestP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
+func (_ *TestP2P) FindPeersWithSubnet(_ context.Context, _ string, _ uint64, _ int) (bool, error) {
 	return false, nil
 }
 
 // RefreshENR mocks the p2p func.
-func (*TestP2P) RefreshPersistentSubnets() {}
+func (_ *TestP2P) RefreshENR() {}
 
 // ForkDigest mocks the p2p func.
 func (p *TestP2P) ForkDigest() ([4]byte, error) {
@@ -394,54 +379,31 @@ func (p *TestP2P) MetadataSeq() uint64 {
 }
 
 // AddPingMethod mocks the p2p func.
-func (*TestP2P) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {
+func (_ *TestP2P) AddPingMethod(_ func(ctx context.Context, id peer.ID) error) {
 	// no-op
 }
 
 // InterceptPeerDial .
-func (*TestP2P) InterceptPeerDial(peer.ID) (allow bool) {
+func (_ *TestP2P) InterceptPeerDial(peer.ID) (allow bool) {
 	return true
 }
 
 // InterceptAddrDial .
-func (*TestP2P) InterceptAddrDial(peer.ID, multiaddr.Multiaddr) (allow bool) {
+func (_ *TestP2P) InterceptAddrDial(peer.ID, multiaddr.Multiaddr) (allow bool) {
 	return true
 }
 
 // InterceptAccept .
-func (*TestP2P) InterceptAccept(_ network.ConnMultiaddrs) (allow bool) {
+func (_ *TestP2P) InterceptAccept(_ network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptSecured .
-func (*TestP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiaddrs) (allow bool) {
+func (_ *TestP2P) InterceptSecured(network.Direction, peer.ID, network.ConnMultiaddrs) (allow bool) {
 	return true
 }
 
 // InterceptUpgraded .
-func (*TestP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
+func (_ *TestP2P) InterceptUpgraded(network.Conn) (allow bool, reason control.DisconnectReason) {
 	return true, 0
 }
-
-func (s *TestP2P) CustodyCountFromRemotePeer(pid peer.ID) uint64 {
-	// By default, we assume the peer custodies the minimum number of subnets.
-	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.
-	custodyCount, err := peerdas.CustodyCountFromRecord(record)
-	if err != nil {
-		return custodyRequirement
-	}
-
-	return custodyCount
-}
-
-func (*TestP2P) GetValidCustodyPeers(peers []peer.ID) ([]peer.ID, error) {
-	return peers, nil
-}

beacon-chain/p2p/topics.go

@@ -30,9 +30,6 @@ const (
 	GossipBlsToExecutionChangeMessage = "bls_to_execution_change"
 	// GossipBlobSidecarMessage is the name for the blob sidecar message type.
 	GossipBlobSidecarMessage = "blob_sidecar"
-	// 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.
@@ -55,6 +52,4 @@ const (
 	BlsToExecutionChangeSubnetTopicFormat = GossipProtocolAndDigest + GossipBlsToExecutionChangeMessage
 	// BlobSubnetTopicFormat is the topic format for the blob subnet.
 	BlobSubnetTopicFormat = GossipProtocolAndDigest + GossipBlobSidecarMessage + "_%d"
-	// DataColumnSubnetTopicFormat is the topic format for the data column subnet.
-	DataColumnSubnetTopicFormat = GossipProtocolAndDigest + GossipDataColumnSidecarMessage + "_%d"
 )

beacon-chain/p2p/types/BUILD.bazel

@@ -43,6 +43,7 @@ go_test(
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_prysmaticlabs_fastssz//:go_default_library",

beacon-chain/p2p/types/object_mapping.go

@@ -26,7 +26,13 @@ var (
 	BlockMap map[[4]byte]func() (interfaces.ReadOnlySignedBeaconBlock, error)
 	// MetaDataMap maps the fork-version to the underlying data type for that
 	// particular fork period.
-	MetaDataMap map[[4]byte]func() metadata.Metadata
+	MetaDataMap map[[4]byte]func() (metadata.Metadata, error)
+	// AttestationMap maps the fork-version to the underlying data type for that
+	// particular fork period.
+	AttestationMap map[[4]byte]func() (ethpb.Att, error)
+	// AggregateAttestationMap maps the fork-version to the underlying data type for that
+	// particular fork period.
+	AggregateAttestationMap map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error)
 )
 
 // InitializeDataMaps initializes all the relevant object maps. This function is called to
@@ -67,24 +73,68 @@ func InitializeDataMaps() {
 	}
 
 	// Reset our metadata map.
-	MetaDataMap = map[[4]byte]func() metadata.Metadata{
-		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{})
+	MetaDataMap = map[[4]byte]func() (metadata.Metadata, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
 		},
-		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() metadata.Metadata {
-			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{})
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (metadata.Metadata, error) {
+			return wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}), nil
+		},
+	}
+
+	// Reset our attestation map.
+	AttestationMap = map[[4]byte]func() (ethpb.Att, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.Attestation{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.Att, error) {
+			return &ethpb.AttestationElectra{}, nil
+		},
+	}
+
+	// Reset our aggregate attestation map.
+	AggregateAttestationMap = map[[4]byte]func() (ethpb.SignedAggregateAttAndProof, error){
+		bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().AltairForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().BellatrixForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().CapellaForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().DenebForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProof{}, nil
+		},
+		bytesutil.ToBytes4(params.BeaconConfig().ElectraForkVersion): func() (ethpb.SignedAggregateAttAndProof, error) {
+			return &ethpb.SignedAggregateAttestationAndProofElectra{}, nil
 		},
 	}
 }

beacon-chain/p2p/types/object_mapping_test.go

@@ -5,7 +5,9 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
+	"github.com/prysmaticlabs/prysm/v5/testing/require"
 )
 
 func TestInitializeDataMaps(t *testing.T) {
@@ -44,8 +46,36 @@ func TestInitializeDataMaps(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			tt.action()
-			_, ok := BlockMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			bFunc, ok := BlockMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
 			assert.Equal(t, tt.exists, ok)
+			if tt.exists {
+				b, err := bFunc()
+				require.NoError(t, err)
+				generic, err := b.PbGenericBlock()
+				require.NoError(t, err)
+				assert.NotNil(t, generic.GetPhase0())
+			}
+			mdFunc, ok := MetaDataMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			if tt.exists {
+				md, err := mdFunc()
+				require.NoError(t, err)
+				assert.NotNil(t, md.MetadataObjV0())
+			}
+			assert.Equal(t, tt.exists, ok)
+			attFunc, ok := AttestationMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			if tt.exists {
+				att, err := attFunc()
+				require.NoError(t, err)
+				assert.Equal(t, version.Phase0, att.Version())
+			}
+			assert.Equal(t, tt.exists, ok)
+			aggFunc, ok := AggregateAttestationMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+			assert.Equal(t, tt.exists, ok)
+			if tt.exists {
+				agg, err := aggFunc()
+				require.NoError(t, err)
+				assert.Equal(t, version.Phase0, agg.Version())
+			}
 		})
 	}
 }

beacon-chain/p2p/types/rpc_errors.go

@@ -9,15 +9,10 @@ var (
 	ErrInvalidSequenceNum     = errors.New("invalid sequence number provided")
 	ErrGeneric                = errors.New("internal service error")
 
-	ErrRateLimited      = errors.New("rate limited")
-	ErrIODeadline       = errors.New("i/o deadline exceeded")
-	ErrInvalidRequest   = errors.New("invalid range, step or count")
-	ErrBlobLTMinRequest = errors.New("blob epoch < minimum_request_epoch")
-
-	ErrDataColumnLTMinRequest   = errors.New("data column epoch < minimum_request_epoch")
-	ErrMaxBlobReqExceeded       = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
-	ErrMaxDataColumnReqExceeded = errors.New("requested more than MAX_REQUEST_DATA_COLUMN_SIDECARS")
-
+	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")
+	ErrMaxBlobReqExceeded  = errors.New("requested more than MAX_REQUEST_BLOB_SIDECARS")
 	ErrResourceUnavailable = errors.New("resource requested unavailable")
-	ErrInvalidColumnIndex  = errors.New("invalid column index requested")
 )

beacon-chain/p2p/types/types.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
-
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
@@ -208,94 +207,7 @@ func (s BlobSidecarsByRootReq) Len() int {
 	return len(s)
 }
 
-// =====================================
-// DataColumnSidecarsByRootReq section
-// =====================================
-var _ ssz.Marshaler = (*DataColumnSidecarsByRootReq)(nil)
-var _ ssz.Unmarshaler = (*DataColumnSidecarsByRootReq)(nil)
-var _ sort.Interface = (*DataColumnSidecarsByRootReq)(nil)
-
-// DataColumnSidecarsByRootReq is used to specify a list of data column targets (root+index) in a DataColumnSidecarsByRoot RPC request.
-type DataColumnSidecarsByRootReq []*eth.DataColumnIdentifier
-
-// 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 *DataColumnSidecarsByRootReq) UnmarshalSSZ(buf []byte) error {
-	bufLen := len(buf)
-	maxLen := int(params.BeaconConfig().MaxRequestDataColumnSidecars) * dataColumnIdSize
-	if bufLen > maxLen {
-		return errors.Errorf("expected buffer with length of up to %d but received length %d", maxLen, bufLen)
-	}
-	if bufLen%dataColumnIdSize != 0 {
-		return errors.Wrapf(ssz.ErrIncorrectByteSize, "size=%d", bufLen)
-	}
-	count := bufLen / dataColumnIdSize
-	*d = make([]*eth.DataColumnIdentifier, count)
-	for i := 0; i < count; i++ {
-		id := &eth.DataColumnIdentifier{}
-		err := id.UnmarshalSSZ(buf[i*dataColumnIdSize : (i+1)*dataColumnIdSize])
-		if err != nil {
-			return err
-		}
-		(*d)[i] = id
-	}
-	return nil
-}
-
-// MarshalSSZ implements ssz.Marshaler. It serializes the DataColumnSidecarsByRootReq value to a byte slice.
-func (d *DataColumnSidecarsByRootReq) MarshalSSZ() ([]byte, error) {
-	buf := make([]byte, d.SizeSSZ())
-	for i, id := range *d {
-		bytes, err := id.MarshalSSZ()
-		if err != nil {
-			return nil, err
-		}
-		copy(buf[i*dataColumnIdSize:(i+1)*dataColumnIdSize], bytes)
-	}
-
-	return buf, nil
-}
-
-// MarshalSSZTo implements ssz.Marshaler. It appends the serialized DataColumnSidecarsByRootReq value to the provided byte slice.
-func (d *DataColumnSidecarsByRootReq) MarshalSSZTo(dst []byte) ([]byte, error) {
-	mobj, err := d.MarshalSSZ()
-	if err != nil {
-		return nil, err
-	}
-	return append(dst, mobj...), nil
-}
-
-// SizeSSZ implements ssz.Marshaler. It returns the size of the serialized representation.
-func (d *DataColumnSidecarsByRootReq) SizeSSZ() int {
-	return len(*d) * dataColumnIdSize
-}
-
-// Len implements sort.Interface. It returns the number of elements in the collection.
-func (d DataColumnSidecarsByRootReq) Len() int {
-	return len(d)
-}
-
-// Less implements sort.Interface. It reports whether the element with index i must sort before the element with index j.
-func (d DataColumnSidecarsByRootReq) Less(i int, j int) bool {
-	rootCmp := bytes.Compare(d[i].BlockRoot, d[j].BlockRoot)
-	if rootCmp != 0 {
-		return rootCmp < 0
-	}
-
-	return d[i].ColumnIndex < d[j].ColumnIndex
-}
-
-// Swap implements sort.Interface. It swaps the elements with indexes i and j.
-func (d DataColumnSidecarsByRootReq) Swap(i int, j int) {
-	d[i], d[j] = d[j], d[i]
-}
-
 func init() {
-	blobSizer := &eth.BlobIdentifier{}
-	blobIdSize = blobSizer.SizeSSZ()
-
-	dataColumnSizer := &eth.DataColumnIdentifier{}
-	dataColumnIdSize = dataColumnSizer.SizeSSZ()
+	sizer := &eth.BlobIdentifier{}
+	blobIdSize = sizer.SizeSSZ()
 }

beacon-chain/p2p/types/types_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 
 	ssz "github.com/prysmaticlabs/fastssz"
-
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -195,136 +194,3 @@ func hexDecodeOrDie(t *testing.T, str string) []byte {
 	require.NoError(t, err)
 	return decoded
 }
-
-// =====================================
-// DataColumnSidecarsByRootReq section
-// =====================================
-func generateDataColumnIdentifiers(n int) []*eth.DataColumnIdentifier {
-	r := make([]*eth.DataColumnIdentifier, n)
-	for i := 0; i < n; i++ {
-		r[i] = &eth.DataColumnIdentifier{
-			BlockRoot:   bytesutil.PadTo([]byte{byte(i)}, 32),
-			ColumnIndex: uint64(i),
-		}
-	}
-	return r
-}
-
-func TestDataColumnSidecarsByRootReq_MarshalUnmarshal(t *testing.T) {
-	cases := []struct {
-		name         string
-		ids          []*eth.DataColumnIdentifier
-		marshalErr   error
-		unmarshalErr string
-		unmarshalMod func([]byte) []byte
-	}{
-		{
-			name: "empty list",
-		},
-		{
-			name: "single item list",
-			ids:  generateDataColumnIdentifiers(1),
-		},
-		{
-			name: "10 item list",
-			ids:  generateDataColumnIdentifiers(10),
-		},
-		{
-			name: "wonky unmarshal size",
-			ids:  generateDataColumnIdentifiers(10),
-			unmarshalMod: func(in []byte) []byte {
-				in = append(in, byte(0))
-				return in
-			},
-			unmarshalErr: ssz.ErrIncorrectByteSize.Error(),
-		},
-		{
-			name: "size too big",
-			ids:  generateDataColumnIdentifiers(1),
-			unmarshalMod: func(in []byte) []byte {
-				maxLen := params.BeaconConfig().MaxRequestDataColumnSidecars * uint64(dataColumnIdSize)
-				add := make([]byte, maxLen)
-				in = append(in, add...)
-				return in
-			},
-			unmarshalErr: "expected buffer with length of up to",
-		},
-	}
-
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			req := DataColumnSidecarsByRootReq(c.ids)
-			bytes, err := req.MarshalSSZ()
-			if c.marshalErr != nil {
-				require.ErrorIs(t, err, c.marshalErr)
-				return
-			}
-			require.NoError(t, err)
-			if c.unmarshalMod != nil {
-				bytes = c.unmarshalMod(bytes)
-			}
-			got := &DataColumnSidecarsByRootReq{}
-			err = got.UnmarshalSSZ(bytes)
-			if c.unmarshalErr != "" {
-				require.ErrorContains(t, c.unmarshalErr, err)
-				return
-			}
-			require.NoError(t, err)
-			for i, id := range *got {
-				require.DeepEqual(t, c.ids[i], id)
-			}
-		})
-	}
-
-	// Test MarshalSSZTo
-	req := DataColumnSidecarsByRootReq(generateDataColumnIdentifiers(10))
-	buf := make([]byte, 0)
-	buf, err := req.MarshalSSZTo(buf)
-	require.NoError(t, err)
-	require.Equal(t, len(buf), int(req.SizeSSZ()))
-
-	var unmarshalled DataColumnSidecarsByRootReq
-	err = unmarshalled.UnmarshalSSZ(buf)
-	require.NoError(t, err)
-	require.DeepEqual(t, req, unmarshalled)
-}
-
-func TestDataColumnSidecarsByRootReq_Sort(t *testing.T) {
-	ids := []*eth.DataColumnIdentifier{
-		{
-			BlockRoot:   bytesutil.PadTo([]byte{3}, 32),
-			ColumnIndex: 0,
-		},
-		{
-			BlockRoot:   bytesutil.PadTo([]byte{2}, 32),
-			ColumnIndex: 2,
-		},
-		{
-			BlockRoot:   bytesutil.PadTo([]byte{2}, 32),
-			ColumnIndex: 1,
-		},
-		{
-			BlockRoot:   bytesutil.PadTo([]byte{1}, 32),
-			ColumnIndex: 2,
-		},
-		{
-			BlockRoot:   bytesutil.PadTo([]byte{0}, 32),
-			ColumnIndex: 3,
-		},
-	}
-	req := DataColumnSidecarsByRootReq(ids)
-	require.Equal(t, true, req.Less(4, 3))
-	require.Equal(t, true, req.Less(3, 2))
-	require.Equal(t, true, req.Less(2, 1))
-	require.Equal(t, true, req.Less(1, 0))
-	require.Equal(t, 5, req.Len())
-
-	ids = []*eth.DataColumnIdentifier{
-		{
-			BlockRoot:   bytesutil.PadTo([]byte{0}, 32),
-			ColumnIndex: 3,
-		},
-	}
-	req = DataColumnSidecarsByRootReq(ids)
-	require.Equal(t, 1, req.Len())
-}

beacon-chain/p2p/utils.go

@@ -12,15 +12,10 @@ import (
 	"path"
 	"time"
 
-	"github.com/btcsuite/btcd/btcec/v2"
-	gCrypto "github.com/ethereum/go-ethereum/crypto"
-	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/libp2p/go-libp2p/core/crypto"
-	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/wrapper"
 	ecdsaprysm "github.com/prysmaticlabs/prysm/v5/crypto/ecdsa"
 	"github.com/prysmaticlabs/prysm/v5/io/file"
@@ -67,7 +62,6 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 	}
 
 	if defaultKeysExist {
-		log.WithField("filePath", defaultKeyPath).Info("Reading static P2P private key from a file. To generate a new random private key at every start, please remove this file.")
 		return privKeyFromFile(defaultKeyPath)
 	}
 
@@ -77,8 +71,8 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 		return nil, err
 	}
 
-	// If the StaticPeerID flag is not set and if peerDAS is not enabled, return the private key.
-	if !(cfg.StaticPeerID || params.PeerDASEnabled()) {
+	// If the StaticPeerID flag is not set, return the private key.
+	if !cfg.StaticPeerID {
 		return ecdsaprysm.ConvertFromInterfacePrivKey(priv)
 	}
 
@@ -95,7 +89,7 @@ func privKey(cfg *Config) (*ecdsa.PrivateKey, error) {
 		return nil, err
 	}
 
-	log.WithField("path", defaultKeyPath).Info("Wrote network key to file")
+	log.Info("Wrote network key to file")
 	// Read the key from the defaultKeyPath file just written
 	// for the strongest guarantee that the next start will be the same as this one.
 	return privKeyFromFile(defaultKeyPath)
@@ -179,23 +173,3 @@ func verifyConnectivity(addr string, port uint, protocol string) {
 		}
 	}
 }
-
-func ConvertPeerIDToNodeID(pid peer.ID) (enode.ID, error) {
-	// Retrieve the public key object of the peer under "crypto" form.
-	pubkeyObjCrypto, err := pid.ExtractPublicKey()
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "extract public key")
-	}
-	// Extract the bytes representation of the public key.
-	compressedPubKeyBytes, err := pubkeyObjCrypto.Raw()
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "public key raw")
-	}
-	// Retrieve the public key object of the peer under "SECP256K1" form.
-	pubKeyObjSecp256k1, err := btcec.ParsePubKey(compressedPubKeyBytes)
-	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "parse public key")
-	}
-	newPubkey := &ecdsa.PublicKey{Curve: gCrypto.S256(), X: pubKeyObjSecp256k1.X(), Y: pubKeyObjSecp256k1.Y()}
-	return enode.PubkeyToIDV4(newPubkey), nil
-}

beacon-chain/p2p/utils_test.go

@@ -6,7 +6,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/p2p/enode"
-	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/testing/assert"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
@@ -65,19 +64,3 @@ func TestSerializeENR(t *testing.T) {
 		assert.ErrorContains(t, "could not serialize nil record", err)
 	})
 }
-
-func TestConvertPeerIDToNodeID(t *testing.T) {
-	const (
-		peerIDStr         = "16Uiu2HAmRrhnqEfybLYimCiAYer2AtZKDGamQrL1VwRCyeh2YiFc"
-		expectedNodeIDStr = "eed26c5d2425ab95f57246a5dca87317c41cacee4bcafe8bbe57e5965527c290"
-	)
-
-	peerID, err := peer.Decode(peerIDStr)
-	require.NoError(t, err)
-
-	actualNodeID, err := ConvertPeerIDToNodeID(peerID)
-	require.NoError(t, err)
-
-	actualNodeIDStr := actualNodeID.String()
-	require.Equal(t, expectedNodeIDStr, actualNodeIDStr)
-}

beacon-chain/rpc/endpoints.go

@@ -70,7 +70,7 @@ func (s *Service) endpoints(
 	endpoints = append(endpoints, s.eventsEndpoints()...)
 	endpoints = append(endpoints, s.prysmBeaconEndpoints(ch, stater)...)
 	endpoints = append(endpoints, s.prysmNodeEndpoints()...)
-	endpoints = append(endpoints, s.prysmValidatorEndpoints(coreService, stater)...)
+	endpoints = append(endpoints, s.prysmValidatorEndpoints(coreService)...)
 	if enableDebug {
 		endpoints = append(endpoints, s.debugEndpoints(stater)...)
 	}
@@ -143,7 +143,7 @@ func (s *Service) builderEndpoints(stater lookup.Stater) []endpoint {
 	}
 }
 
-func (s *Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
+func (*Service) blobEndpoints(blocker lookup.Blocker) []endpoint {
 	server := &blob.Server{
 		Blocker: blocker,
 	}
@@ -777,7 +777,7 @@ func (s *Service) beaconEndpoints(
 	}
 }
 
-func (s *Service) configEndpoints() []endpoint {
+func (*Service) configEndpoints() []endpoint {
 	const namespace = "config"
 	return []endpoint{
 		{
@@ -1045,7 +1045,7 @@ func (s *Service) prysmNodeEndpoints() []endpoint {
 	}
 }
 
-func (s *Service) prysmValidatorEndpoints(coreService *core.Service, stater lookup.Stater) []endpoint {
+func (*Service) prysmValidatorEndpoints(coreService *core.Service) []endpoint {
 	server := &validatorprysm.Server{
 		CoreService: coreService,
 	}

beacon-chain/rpc/eth/config/handlers_test.go

@@ -80,7 +80,6 @@ func TestGetSpec(t *testing.T) {
 	config.DenebForkEpoch = 105
 	config.ElectraForkVersion = []byte("ElectraForkVersion")
 	config.ElectraForkEpoch = 107
-	config.Eip7594ForkEpoch = 109
 	config.BLSWithdrawalPrefixByte = byte('b')
 	config.ETH1AddressWithdrawalPrefixByte = byte('c')
 	config.GenesisDelay = 24
@@ -194,7 +193,7 @@ func TestGetSpec(t *testing.T) {
 	data, ok := resp.Data.(map[string]interface{})
 	require.Equal(t, true, ok)
 
-	assert.Equal(t, 156, len(data))
+	assert.Equal(t, 155, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -272,8 +271,6 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "0x"+hex.EncodeToString([]byte("ElectraForkVersion")), v)
 			case "ELECTRA_FORK_EPOCH":
 				assert.Equal(t, "107", v)
-			case "EIP7594_FORK_EPOCH":
-				assert.Equal(t, "109", v)
 			case "MIN_ANCHOR_POW_BLOCK_DIFFICULTY":
 				assert.Equal(t, "1000", v)
 			case "BLS_WITHDRAWAL_PREFIX":

beacon-chain/rpc/eth/validator/BUILD.bazel

@@ -5,6 +5,7 @@ go_library(
     srcs = [
         "handlers.go",
         "handlers_block.go",
+        "log.go",
         "server.go",
     ],
     importpath = "github.com/prysmaticlabs/prysm/v5/beacon-chain/rpc/eth/validator",

beacon-chain/rpc/eth/validator/handlers.go

@@ -31,7 +31,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/network/httputil"
 	ethpbalpha "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"github.com/prysmaticlabs/prysm/v5/time/slots"
-	log "github.com/sirupsen/logrus"
+	"github.com/sirupsen/logrus"
 	"go.opencensus.io/trace"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
@@ -592,7 +592,7 @@ func (s *Server) PrepareBeaconProposer(w http.ResponseWriter, r *http.Request) {
 	if len(validatorIndices) == 0 {
 		return
 	}
-	log.WithFields(log.Fields{
+	log.WithFields(logrus.Fields{
 		"validatorIndices": validatorIndices,
 	}).Info("Updated fee recipient addresses")
 }

beacon-chain/rpc/eth/validator/handlers_block.go

@@ -220,8 +220,9 @@ func (s *Server) produceBlockV3(ctx context.Context, w http.ResponseWriter, r *h
 
 	consensusBlockValue, httpError := getConsensusBlockValue(ctx, s.BlockRewardFetcher, v1alpha1resp.Block)
 	if httpError != nil {
-		httputil.WriteError(w, httpError)
-		return
+		log.WithError(httpError).Debug("Failed to get consensus block value")
+		// Having the consensus block value is not critical to block production
+		consensusBlockValue = ""
 	}
 
 	w.Header().Set(api.ExecutionPayloadBlindedHeader, fmt.Sprintf("%v", v1alpha1resp.IsBlinded))
@@ -297,7 +298,7 @@ func getConsensusBlockValue(ctx context.Context, blockRewardsFetcher rewards.Blo
 		}
 	}
 	if bb.Version() == version.Phase0 {
-		// ignore for phase 0
+		// Getting the block value for Phase 0 is very hard, so we ignore it
 		return "", nil
 	}
 	// Get consensus payload value which is the same as the total from the block rewards api.

beacon-chain/rpc/eth/validator/log.go

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

beacon-chain/rpc/prysm/v1alpha1/validator/BUILD.bazel

@@ -1,5 +1,3 @@
-# gazelle:ignore
-
 load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 
 go_library(
@@ -37,7 +35,6 @@ go_library(
         "//api/client/builder:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/builder:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
@@ -47,7 +44,6 @@ go_library(
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -177,6 +173,7 @@ common_deps = [
     "@org_golang_google_protobuf//types/known/emptypb:go_default_library",
 ]
 
+# gazelle:ignore
 go_test(
     name = "go_default_test",
     timeout = "moderate",

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -13,20 +13,15 @@ import (
 	"github.com/pkg/errors"
 	builderapi "github.com/prysmaticlabs/prysm/v5/api/client/builder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/cache"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
 	blockfeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/block"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/operation"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/helpers"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/transition"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/kv"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v5/config/features"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
@@ -266,13 +261,7 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 }
 
 // ProposeBeaconBlock handles the proposal of beacon blocks.
-// TODO: Add tests
 func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSignedBeaconBlock) (*ethpb.ProposeResponse, error) {
-	var (
-		blobSidecars       []*ethpb.BlobSidecar
-		dataColumnSideCars []*ethpb.DataColumnSidecar
-	)
-
 	ctx, span := trace.StartSpan(ctx, "ProposerServer.ProposeBeaconBlock")
 	defer span.End()
 
@@ -284,18 +273,15 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 	if err != nil {
 		return nil, status.Errorf(codes.InvalidArgument, "%s: %v", "decode block failed", err)
 	}
-	isPeerDASEnabled := coreTime.PeerDASIsActive(block.Block().Slot())
 
+	var sidecars []*ethpb.BlobSidecar
 	if block.IsBlinded() {
-		block, blobSidecars, dataColumnSideCars, err = vs.handleBlindedBlock(ctx, block, isPeerDASEnabled)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "%s: %v", "handle blinded block", err)
-		}
+		block, sidecars, err = vs.handleBlindedBlock(ctx, block)
 	} else {
-		blobSidecars, dataColumnSideCars, err = handleUnblindedBlock(block, req, isPeerDASEnabled)
-		if err != nil {
-			return nil, status.Errorf(codes.Internal, "%s: %v", "handle unblided block", err)
-		}
+		sidecars, err = vs.handleUnblindedBlock(block, req)
+	}
+	if err != nil {
+		return nil, status.Errorf(codes.Internal, "%s: %v", "handle block failed", err)
 	}
 
 	root, err := block.Block().HashTreeRoot()
@@ -316,14 +302,8 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		errChan <- nil
 	}()
 
-	if isPeerDASEnabled {
-		if err := vs.broadcastAndReceiveDataColumns(ctx, dataColumnSideCars, root); err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not broadcast/receive data columns: %v", err)
-		}
-	} else {
-		if err := vs.broadcastAndReceiveBlobs(ctx, blobSidecars, root); err != nil {
-			return nil, status.Errorf(codes.Internal, "Could not broadcast/receive blobs: %v", err)
-		}
+	if err := vs.broadcastAndReceiveBlobs(ctx, sidecars, root); err != nil {
+		return nil, status.Errorf(codes.Internal, "Could not broadcast/receive blobs: %v", err)
 	}
 
 	wg.Wait()
@@ -335,83 +315,47 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 }
 
 // handleBlindedBlock processes blinded beacon blocks.
-func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.SignedBeaconBlock, isPeerDASEnabled bool) (interfaces.SignedBeaconBlock, []*ethpb.BlobSidecar, []*ethpb.DataColumnSidecar, error) {
+func (vs *Server) handleBlindedBlock(ctx context.Context, block interfaces.SignedBeaconBlock) (interfaces.SignedBeaconBlock, []*ethpb.BlobSidecar, error) {
 	if block.Version() < version.Bellatrix {
-		return nil, nil, nil, errors.New("pre-Bellatrix blinded block")
+		return nil, nil, errors.New("pre-Bellatrix blinded block")
 	}
-
 	if vs.BlockBuilder == nil || !vs.BlockBuilder.Configured() {
-		return nil, nil, nil, errors.New("unconfigured block builder")
+		return nil, nil, errors.New("unconfigured block builder")
 	}
 
 	copiedBlock, err := block.Copy()
 	if err != nil {
-		return nil, nil, nil, errors.Wrap(err, "block copy")
+		return nil, nil, err
 	}
 
 	payload, bundle, err := vs.BlockBuilder.SubmitBlindedBlock(ctx, block)
 	if err != nil {
-		return nil, nil, nil, errors.Wrap(err, "submit blinded block")
+		return nil, nil, errors.Wrap(err, "submit blinded block failed")
 	}
 
 	if err := copiedBlock.Unblind(payload); err != nil {
-		return nil, nil, nil, errors.Wrap(err, "unblind")
+		return nil, nil, errors.Wrap(err, "unblind failed")
 	}
 
-	if isPeerDASEnabled {
-		dataColumnSideCars, err := unblindDataColumnsSidecars(copiedBlock, bundle)
-		if err != nil {
-			return nil, nil, nil, errors.Wrap(err, "unblind data columns sidecars")
-		}
-
-		return copiedBlock, nil, dataColumnSideCars, nil
-	}
-
-	blobSidecars, err := unblindBlobsSidecars(copiedBlock, bundle)
+	sidecars, err := unblindBlobsSidecars(copiedBlock, bundle)
 	if err != nil {
-		return nil, nil, nil, errors.Wrap(err, "unblind blobs sidecars")
+		return nil, nil, errors.Wrap(err, "unblind sidecars failed")
 	}
 
-	return copiedBlock, blobSidecars, nil, nil
+	return copiedBlock, sidecars, nil
 }
 
 // handleUnblindedBlock processes unblinded beacon blocks.
-func handleUnblindedBlock(block interfaces.SignedBeaconBlock, req *ethpb.GenericSignedBeaconBlock, isPeerDASEnabled bool) ([]*ethpb.BlobSidecar, []*ethpb.DataColumnSidecar, error) {
+func (vs *Server) handleUnblindedBlock(block interfaces.SignedBeaconBlock, req *ethpb.GenericSignedBeaconBlock) ([]*ethpb.BlobSidecar, error) {
 	dbBlockContents := req.GetDeneb()
-
 	if dbBlockContents == nil {
-		return nil, nil, nil
+		return nil, nil
 	}
-
-	if isPeerDASEnabled {
-		// Convert blobs from slices to array.
-		blobs := make([]kzg.Blob, 0, len(dbBlockContents.Blobs))
-		for _, blob := range dbBlockContents.Blobs {
-			if len(blob) != kzg.BytesPerBlob {
-				return nil, nil, errors.Errorf("invalid blob size. expected %d bytes, got %d bytes", kzg.BytesPerBlob, len(blob))
-			}
-
-			blobs = append(blobs, kzg.Blob(blob))
-		}
-
-		dataColumnSideCars, err := peerdas.DataColumnSidecars(block, blobs)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "data column sidecars")
-		}
-
-		return nil, dataColumnSideCars, nil
-	}
-
-	blobSidecars, err := BuildBlobSidecars(block, dbBlockContents.Blobs, dbBlockContents.KzgProofs)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "build blob sidecars")
-	}
-
-	return blobSidecars, nil, nil
+	return BuildBlobSidecars(block, dbBlockContents.Blobs, dbBlockContents.KzgProofs)
 }
 
 // broadcastReceiveBlock broadcasts a block and handles its reception.
-func (vs *Server) broadcastReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, root [fieldparams.RootLength]byte) error {
+func (vs *Server) broadcastReceiveBlock(ctx context.Context, block interfaces.SignedBeaconBlock, root [32]byte) error {
 	protoBlock, err := block.Proto()
 	if err != nil {
 		return errors.Wrap(err, "protobuf conversion failed")
@@ -427,7 +371,7 @@ func (vs *Server) broadcastReceiveBlock(ctx context.Context, block interfaces.Si
 }
 
 // broadcastAndReceiveBlobs handles the broadcasting and reception of blob sidecars.
-func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethpb.BlobSidecar, root [fieldparams.RootLength]byte) error {
+func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethpb.BlobSidecar, root [32]byte) error {
 	eg, eCtx := errgroup.WithContext(ctx)
 	for i, sc := range sidecars {
 		// Copy the iteration instance to a local variable to give each go-routine its own copy to play with.
@@ -456,53 +400,6 @@ func (vs *Server) broadcastAndReceiveBlobs(ctx context.Context, sidecars []*ethp
 	return eg.Wait()
 }
 
-// broadcastAndReceiveDataColumns handles the broadcasting and reception of data columns sidecars.
-func (vs *Server) broadcastAndReceiveDataColumns(ctx context.Context, sidecars []*ethpb.DataColumnSidecar, root [fieldparams.RootLength]byte) error {
-	eg, _ := errgroup.WithContext(ctx)
-
-	dataColumnsWithholdCount := features.Get().DataColumnsWithholdCount
-
-	for i, sd := range sidecars {
-		// Copy the iteration instance to a local variable to give each go-routine its own copy to play with.
-		// See https://golang.org/doc/faq#closures_and_goroutines for more details.
-		colIdx, sidecar := i, sd
-
-		eg.Go(func() error {
-			// Compute the subnet index based on the column index.
-			subnet := uint64(colIdx) % params.BeaconConfig().DataColumnSidecarSubnetCount
-
-			if colIdx < dataColumnsWithholdCount {
-				log.WithFields(logrus.Fields{
-					"root":            fmt.Sprintf("%#x", root),
-					"subnet":          subnet,
-					"dataColumnIndex": colIdx,
-				}).Warning("Withholding data column")
-			} else {
-				if err := vs.P2P.BroadcastDataColumn(ctx, subnet, sidecar); err != nil {
-					return errors.Wrap(err, "broadcast data column")
-				}
-			}
-
-			roDataColumn, err := blocks.NewRODataColumnWithRoot(sidecar, root)
-			if err != nil {
-				return errors.Wrap(err, "new read-only data column with root")
-			}
-
-			verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
-			if err := vs.DataColumnReceiver.ReceiveDataColumn(ctx, verifiedRODataColumn); err != nil {
-				return errors.Wrap(err, "receive data column")
-			}
-
-			vs.OperationNotifier.OperationFeed().Send(&feed.Event{
-				Type: operation.DataColumnSidecarReceived,
-				Data: &operation.DataColumnSidecarReceivedData{DataColumn: &verifiedRODataColumn},
-			})
-			return nil
-		})
-	}
-	return eg.Wait()
-}
-
 // PrepareBeaconProposer caches and updates the fee recipient for the given proposer.
 func (vs *Server) PrepareBeaconProposer(
 	_ context.Context, request *ethpb.PrepareBeaconProposerRequest,

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_execution_payload.go

@@ -72,6 +72,7 @@ func (vs *Server) getLocalPayload(ctx context.Context, blk interfaces.ReadOnlyBe
 	}
 	setFeeRecipientIfBurnAddress(&val)
 
+	var err error
 	if ok && payloadId != [8]byte{} {
 		// Payload ID is cache hit. Return the cached payload ID.
 		var pid primitives.PayloadID

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go

@@ -943,7 +943,7 @@ func TestProposer_ProposeBlock_OK(t *testing.T) {
 				return &ethpb.GenericSignedBeaconBlock{Block: blk}
 			},
 			useBuilder: true,
-			err:        "unblind blobs sidecars: commitment value doesn't match block",
+			err:        "unblind sidecars failed: commitment value doesn't match block",
 		},
 	}
 

beacon-chain/rpc/prysm/v1alpha1/validator/server.go

@@ -67,7 +67,6 @@ type Server struct {
 	SyncCommitteePool      synccommittee.Pool
 	BlockReceiver          blockchain.BlockReceiver
 	BlobReceiver           blockchain.BlobReceiver
-	DataColumnReceiver     blockchain.DataColumnReceiver
 	MockEth1Votes          bool
 	Eth1BlockFetcher       execution.POWBlockFetcher
 	PendingDepositsFetcher depositsnapshot.PendingDepositsFetcher

beacon-chain/rpc/prysm/v1alpha1/validator/unblinder.go

@@ -4,8 +4,6 @@ import (
 	"bytes"
 
 	"github.com/pkg/errors"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
 	consensusblocks "github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
@@ -70,29 +68,3 @@ func unblindBlobsSidecars(block interfaces.SignedBeaconBlock, bundle *enginev1.B
 	}
 	return sidecars, nil
 }
-
-// TODO: Add tests
-func unblindDataColumnsSidecars(block interfaces.SignedBeaconBlock, bundle *enginev1.BlobsBundle) ([]*ethpb.DataColumnSidecar, error) {
-	// Check if the block is at least a Deneb block.
-	if block.Version() < version.Deneb {
-		return nil, nil
-	}
-
-	// Convert blobs from slices to array.
-	blobs := make([]kzg.Blob, 0, len(bundle.Blobs))
-	for _, blob := range bundle.Blobs {
-		if len(blob) != kzg.BytesPerBlob {
-			return nil, errors.Errorf("invalid blob size. expected %d bytes, got %d bytes", kzg.BytesPerBlob, len(blob))
-		}
-
-		blobs = append(blobs, kzg.Blob(blob))
-	}
-
-	// Retrieve data columns from blobs.
-	dataColumnSidecars, err := peerdas.DataColumnSidecars(block, blobs)
-	if err != nil {
-		return nil, errors.Wrap(err, "data column sidecars")
-	}
-
-	return dataColumnSidecars, nil
-}

beacon-chain/rpc/service.go

@@ -4,7 +4,6 @@ package rpc
 
 import (
 	"context"
-	"fmt"
 	"net"
 	"sync"
 
@@ -108,7 +107,6 @@ type Config struct {
 	AttestationReceiver           blockchain.AttestationReceiver
 	BlockReceiver                 blockchain.BlockReceiver
 	BlobReceiver                  blockchain.BlobReceiver
-	DataColumnReceiver            blockchain.DataColumnReceiver
 	ExecutionChainService         execution.Chain
 	ChainStartFetcher             execution.ChainStartFetcher
 	ExecutionChainInfoFetcher     execution.ChainInfoFetcher
@@ -155,7 +153,7 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		connectedRPCClients: make(map[net.Addr]bool),
 	}
 
-	address := fmt.Sprintf("%s:%s", s.cfg.Host, s.cfg.Port)
+	address := net.JoinHostPort(s.cfg.Host, s.cfg.Port)
 	lis, err := net.Listen("tcp", address)
 	if err != nil {
 		log.WithError(err).Errorf("Could not listen to port in Start() %s", address)
@@ -251,7 +249,6 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		P2P:                    s.cfg.Broadcaster,
 		BlockReceiver:          s.cfg.BlockReceiver,
 		BlobReceiver:           s.cfg.BlobReceiver,
-		DataColumnReceiver:     s.cfg.DataColumnReceiver,
 		MockEth1Votes:          s.cfg.MockEth1Votes,
 		Eth1BlockFetcher:       s.cfg.ExecutionChainService,
 		PendingDepositsFetcher: s.cfg.PendingDepositFetcher,

beacon-chain/slasher/receive.go

@@ -141,7 +141,7 @@ func (s *Service) processAttestations(
 
 	start := time.Now()
 
-	// Check for attestatinos slashings (double, sourrounding, surrounded votes).
+	// Check for attestations slashings (double, surrounding, surrounded votes).
 	slashings, err := s.checkSlashableAttestations(ctx, currentEpoch, validAttestations)
 	if err != nil {
 		log.WithError(err).Error(couldNotCheckSlashableAtt)

beacon-chain/state/stateutil/BUILD.bazel

@@ -16,7 +16,6 @@ go_library(
         "pending_consolidations_root.go",
         "pending_partial_withdrawals_root.go",
         "reference.go",
-        "slice_root.go",
         "sync_committee.root.go",
         "trie_helpers.go",
         "unrealized_justification.go",

beacon-chain/state/stateutil/historical_summaries_root.go

@@ -2,9 +2,10 @@ package stateutil
 
 import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
 func HistoricalSummariesRoot(summaries []*ethpb.HistoricalSummary) ([32]byte, error) {
-	return SliceRoot(summaries, fieldparams.HistoricalRootsLength)
+	return ssz.SliceRoot(summaries, fieldparams.HistoricalRootsLength)
 }

beacon-chain/state/stateutil/pending_balance_deposits_root.go

@@ -2,9 +2,10 @@ package stateutil
 
 import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
 func PendingBalanceDepositsRoot(slice []*ethpb.PendingBalanceDeposit) ([32]byte, error) {
-	return SliceRoot(slice, fieldparams.PendingBalanceDepositsLimit)
+	return ssz.SliceRoot(slice, fieldparams.PendingBalanceDepositsLimit)
 }

beacon-chain/state/stateutil/pending_consolidations_root.go

@@ -2,9 +2,10 @@ package stateutil
 
 import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
 func PendingConsolidationsRoot(slice []*ethpb.PendingConsolidation) ([32]byte, error) {
-	return SliceRoot(slice, fieldparams.PendingConsolidationsLimit)
+	return ssz.SliceRoot(slice, fieldparams.PendingConsolidationsLimit)
 }

beacon-chain/state/stateutil/pending_partial_withdrawals_root.go

@@ -2,9 +2,10 @@ package stateutil
 
 import (
 	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
+	"github.com/prysmaticlabs/prysm/v5/encoding/ssz"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 )
 
 func PendingPartialWithdrawalsRoot(slice []*ethpb.PendingPartialWithdrawal) ([32]byte, error) {
-	return SliceRoot(slice, fieldparams.PendingPartialWithdrawalsLimit)
+	return ssz.SliceRoot(slice, fieldparams.PendingPartialWithdrawalsLimit)
 }

beacon-chain/sync/BUILD.bazel

@@ -7,8 +7,6 @@ go_library(
         "block_batcher.go",
         "broadcast_bls_changes.go",
         "context.go",
-        "data_columns_reconstruct.go",
-        "data_columns_sampling.go",
         "deadlines.go",
         "decode_pubsub.go",
         "doc.go",
@@ -27,8 +25,6 @@ go_library(
         "rpc_blob_sidecars_by_range.go",
         "rpc_blob_sidecars_by_root.go",
         "rpc_chunked_response.go",
-        "rpc_data_column_sidecars_by_range.go",
-        "rpc_data_column_sidecars_by_root.go",
         "rpc_goodbye.go",
         "rpc_metadata.go",
         "rpc_ping.go",
@@ -41,7 +37,6 @@ go_library(
         "subscriber_beacon_blocks.go",
         "subscriber_blob_sidecar.go",
         "subscriber_bls_to_execution_change.go",
-        "subscriber_data_column_sidecar.go",
         "subscriber_handlers.go",
         "subscriber_sync_committee_message.go",
         "subscriber_sync_contribution_proof.go",
@@ -49,10 +44,10 @@ go_library(
         "validate_aggregate_proof.go",
         "validate_attester_slashing.go",
         "validate_beacon_attestation.go",
+        "validate_beacon_attestation_electra.go",
         "validate_beacon_blocks.go",
         "validate_blob.go",
         "validate_bls_to_execution_change.go",
-        "validate_data_column.go",
         "validate_proposer_slashing.go",
         "validate_sync_committee_message.go",
         "validate_sync_contribution_proof.go",
@@ -69,7 +64,6 @@ go_library(
         "//async/abool:go_default_library",
         "//async/event:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/blocks:go_default_library",
@@ -78,9 +72,7 @@ go_library(
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
-        "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
         "//beacon-chain/core/transition/interop:go_default_library",
         "//beacon-chain/db:go_default_library",
@@ -159,7 +151,6 @@ go_test(
         "block_batcher_test.go",
         "broadcast_bls_changes_test.go",
         "context_test.go",
-        "data_columns_sampling_test.go",
         "decode_pubsub_test.go",
         "error_test.go",
         "fork_watcher_test.go",
@@ -170,7 +161,6 @@ go_test(
         "rpc_beacon_blocks_by_root_test.go",
         "rpc_blob_sidecars_by_range_test.go",
         "rpc_blob_sidecars_by_root_test.go",
-        "rpc_chunked_response_test.go",
         "rpc_goodbye_test.go",
         "rpc_handler_test.go",
         "rpc_metadata_test.go",
@@ -187,6 +177,7 @@ go_test(
         "sync_test.go",
         "validate_aggregate_proof_test.go",
         "validate_attester_slashing_test.go",
+        "validate_beacon_attestation_electra_test.go",
         "validate_beacon_attestation_test.go",
         "validate_beacon_blocks_test.go",
         "validate_blob_test.go",
@@ -201,14 +192,12 @@ go_test(
     deps = [
         "//async/abool:go_default_library",
         "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/cache:go_default_library",
         "//beacon-chain/core/altair:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/operation:go_default_library",
         "//beacon-chain/core/helpers:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/core/signing:go_default_library",
         "//beacon-chain/core/time:go_default_library",
         "//beacon-chain/core/transition:go_default_library",
@@ -253,25 +242,20 @@ go_test(
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/attestation:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
-        "//runtime/version:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "//testing/util:go_default_library",
         "//time:go_default_library",
         "//time/slots: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_d4l3k_messagediff//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",
         "@com_github_ethereum_go_ethereum//core/types:go_default_library",
         "@com_github_ethereum_go_ethereum//p2p/enr:go_default_library",
         "@com_github_golang_snappy//:go_default_library",
         "@com_github_libp2p_go_libp2p//core:go_default_library",
-        "@com_github_libp2p_go_libp2p//core/crypto:go_default_library",
         "@com_github_libp2p_go_libp2p//core/network:go_default_library",
         "@com_github_libp2p_go_libp2p//core/peer:go_default_library",
         "@com_github_libp2p_go_libp2p//core/protocol:go_default_library",
-        "@com_github_libp2p_go_libp2p//p2p/net/swarm/testing:go_default_library",
         "@com_github_libp2p_go_libp2p_pubsub//:go_default_library",
         "@com_github_libp2p_go_libp2p_pubsub//pb:go_default_library",
         "@com_github_patrickmn_go_cache//:go_default_library",

beacon-chain/sync/data_columns_reconstruct.go

@@ -1,318 +0,0 @@
-package sync
-
-import (
-	"context"
-	"fmt"
-	"sort"
-	"time"
-
-	"github.com/pkg/errors"
-	"github.com/sirupsen/logrus"
-
-	kzg "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/time/slots"
-)
-
-const broadCastMissingDataColumnsTimeIntoSlot = 3 * time.Second
-
-// recoverCellsAndProofs recovers the cells and proofs from the data column sidecars.
-func recoverCellsAndProofs(
-	dataColumnSideCars []*ethpb.DataColumnSidecar,
-	columnsCount int,
-	blockRoot [fieldparams.RootLength]byte,
-) ([]kzg.CellsAndProofs, error) {
-	if len(dataColumnSideCars) == 0 {
-		return nil, errors.New("no data column sidecars")
-	}
-
-	// Check if all columns have the same length.
-	blobCount := len(dataColumnSideCars[0].DataColumn)
-	for _, sidecar := range dataColumnSideCars {
-		length := len(sidecar.DataColumn)
-
-		if length != blobCount {
-			return nil, errors.New("columns do not have the same length")
-		}
-	}
-
-	// Recover cells and compute proofs.
-	recoveredCellsAndProofs := make([]kzg.CellsAndProofs, 0, blobCount)
-
-	for blobIndex := 0; blobIndex < blobCount; blobIndex++ {
-		start := time.Now()
-
-		cellsId := make([]uint64, 0, columnsCount)
-		cells := make([]kzg.Cell, 0, columnsCount)
-
-		for _, sidecar := range dataColumnSideCars {
-			// Build the cell ids.
-			cellsId = append(cellsId, sidecar.ColumnIndex)
-
-			// Get the cell.
-			column := sidecar.DataColumn
-			cell := column[blobIndex]
-
-			cells = append(cells, kzg.Cell(cell))
-		}
-
-		// Recover the cells and proofs for the corresponding blob
-		cellsAndProofs, err := kzg.RecoverCellsAndKZGProofs(cellsId, cells)
-
-		if err != nil {
-			return nil, errors.Wrapf(err, "recover cells and KZG proofs for blob %d", blobIndex)
-		}
-
-		recoveredCellsAndProofs = append(recoveredCellsAndProofs, cellsAndProofs)
-
-		log.WithFields(logrus.Fields{
-			"elapsed": time.Since(start),
-			"index":   blobIndex,
-			"root":    fmt.Sprintf("%x", blockRoot),
-		}).Debug("Recovered cells and proofs")
-	}
-
-	return recoveredCellsAndProofs, nil
-}
-
-func (s *Service) reconstructDataColumns(ctx context.Context, verifiedRODataColumn blocks.VerifiedRODataColumn) error {
-	// Lock to prevent concurrent reconstruction.
-	s.dataColumsnReconstructionLock.Lock()
-	defer s.dataColumsnReconstructionLock.Unlock()
-
-	// Get the block root.
-	blockRoot := verifiedRODataColumn.BlockRoot()
-
-	// Get the columns we store.
-	storedDataColumns, err := s.cfg.blobStorage.ColumnIndices(blockRoot)
-	if err != nil {
-		return errors.Wrap(err, "columns indices")
-	}
-
-	storedColumnsCount := len(storedDataColumns)
-	numberOfColumns := fieldparams.NumberOfColumns
-
-	// If less than half of the columns are stored, reconstruction is not possible.
-	// If all columns are stored, no need to reconstruct.
-	if storedColumnsCount < numberOfColumns/2 || storedColumnsCount == numberOfColumns {
-		return nil
-	}
-
-	// Retrieve the custodied columns.
-	custodiedColumns, err := peerdas.CustodyColumns(s.cfg.p2p.NodeID(), peerdas.CustodySubnetCount())
-	if err != nil {
-		return errors.Wrap(err, "custodied columns")
-	}
-
-	// Load the data columns sidecars.
-	dataColumnSideCars := make([]*ethpb.DataColumnSidecar, 0, storedColumnsCount)
-	for index := range storedDataColumns {
-		dataColumnSidecar, err := s.cfg.blobStorage.GetColumn(blockRoot, index)
-		if err != nil {
-			return errors.Wrap(err, "get column")
-		}
-
-		dataColumnSideCars = append(dataColumnSideCars, dataColumnSidecar)
-	}
-
-	// Recover cells and proofs
-	recoveredCellsAndProofs, err := recoverCellsAndProofs(dataColumnSideCars, storedColumnsCount, blockRoot)
-	if err != nil {
-		return errors.Wrap(err, "recover cells and proofs")
-	}
-
-	// Reconstruct the data columns sidecars.
-	dataColumnSidecars, err := peerdas.DataColumnSidecarsForReconstruct(
-		verifiedRODataColumn.KzgCommitments,
-		verifiedRODataColumn.SignedBlockHeader,
-		verifiedRODataColumn.KzgCommitmentsInclusionProof,
-		recoveredCellsAndProofs,
-	)
-	if err != nil {
-		return errors.Wrap(err, "data column sidecars")
-	}
-
-	// Save the data columns sidecars in the database.
-	for _, dataColumnSidecar := range dataColumnSidecars {
-		shouldSave := custodiedColumns[dataColumnSidecar.ColumnIndex]
-		if !shouldSave {
-			// We do not custody this column, so we dot not need to save it.
-			continue
-		}
-
-		roDataColumn, err := blocks.NewRODataColumnWithRoot(dataColumnSidecar, blockRoot)
-		if err != nil {
-			return errors.Wrap(err, "new read-only data column with root")
-		}
-
-		verifiedRoDataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
-		if err := s.cfg.blobStorage.SaveDataColumn(verifiedRoDataColumn); err != nil {
-			return errors.Wrap(err, "save column")
-		}
-	}
-
-	log.WithField("root", fmt.Sprintf("%x", blockRoot)).Debug("Data columns reconstructed and saved successfully")
-
-	// Schedule the broadcast.
-	if err := s.scheduleReconstructedDataColumnsBroadcast(ctx, blockRoot, verifiedRODataColumn); err != nil {
-		return errors.Wrap(err, "schedule reconstructed data columns broadcast")
-	}
-
-	return nil
-}
-
-func (s *Service) scheduleReconstructedDataColumnsBroadcast(
-	ctx context.Context,
-	blockRoot [fieldparams.RootLength]byte,
-	dataColumn blocks.VerifiedRODataColumn,
-) error {
-	// Retrieve the slot of the block.
-	slot := dataColumn.Slot()
-
-	// Get the time corresponding to the start of the slot.
-	slotStart, err := slots.ToTime(uint64(s.cfg.chain.GenesisTime().Unix()), slot)
-	if err != nil {
-		return errors.Wrap(err, "to time")
-	}
-
-	// Compute when to broadcast the missing data columns.
-	broadcastTime := slotStart.Add(broadCastMissingDataColumnsTimeIntoSlot)
-
-	// Compute the waiting time. This could be negative. In such a case, broadcast immediately.
-	waitingTime := time.Until(broadcastTime)
-
-	time.AfterFunc(waitingTime, func() {
-		s.dataColumsnReconstructionLock.Lock()
-		defer s.deleteReceivedDataColumns(blockRoot)
-		defer s.dataColumsnReconstructionLock.Unlock()
-
-		// Get the received by gossip data columns.
-		receivedDataColumns := s.receivedDataColumns(blockRoot)
-		if receivedDataColumns == nil {
-			log.WithField("root", fmt.Sprintf("%x", blockRoot)).Error("No received data columns")
-		}
-
-		// Get the data columns we should store.
-		custodiedDataColumns, err := peerdas.CustodyColumns(s.cfg.p2p.NodeID(), peerdas.CustodySubnetCount())
-		if err != nil {
-			log.WithError(err).Error("Custody columns")
-		}
-
-		// Get the data columns we actually store.
-		storedDataColumns, err := s.cfg.blobStorage.ColumnIndices(blockRoot)
-		if err != nil {
-			log.WithField("root", fmt.Sprintf("%x", blockRoot)).WithError(err).Error("Columns indices")
-			return
-		}
-
-		// Compute the missing data columns (data columns we should custody but we do not have received via gossip.)
-		missingColumns := make(map[uint64]bool, len(custodiedDataColumns))
-		for column := range custodiedDataColumns {
-			if ok := receivedDataColumns[column]; !ok {
-				missingColumns[column] = true
-			}
-		}
-
-		// Exit early if there are no missing data columns.
-		// This is the happy path.
-		if len(missingColumns) == 0 {
-			return
-		}
-
-		for column := range missingColumns {
-			if ok := storedDataColumns[column]; !ok {
-				// This column was not received nor reconstructed. This should not happen.
-				log.WithFields(logrus.Fields{
-					"root":   fmt.Sprintf("%x", blockRoot),
-					"slot":   slot,
-					"column": column,
-				}).Error("Data column not received nor reconstructed.")
-				continue
-			}
-
-			// Get the non received but reconstructed data column.
-			dataColumnSidecar, err := s.cfg.blobStorage.GetColumn(blockRoot, column)
-			if err != nil {
-				log.WithError(err).Error("Get column")
-				continue
-			}
-
-			// Compute the subnet for this column.
-			subnet := column % params.BeaconConfig().DataColumnSidecarSubnetCount
-
-			// Broadcast the missing data column.
-			if err := s.cfg.p2p.BroadcastDataColumn(ctx, subnet, dataColumnSidecar); err != nil {
-				log.WithError(err).Error("Broadcast data column")
-			}
-		}
-
-		// Get the missing data columns under sorted form.
-		missingColumnsList := make([]uint64, 0, len(missingColumns))
-		for column := range missingColumns {
-			missingColumnsList = append(missingColumnsList, column)
-		}
-
-		// Sort the missing data columns.
-		sort.Slice(missingColumnsList, func(i, j int) bool {
-			return missingColumnsList[i] < missingColumnsList[j]
-		})
-
-		log.WithFields(logrus.Fields{
-			"root":         fmt.Sprintf("%x", blockRoot),
-			"slot":         slot,
-			"timeIntoSlot": broadCastMissingDataColumnsTimeIntoSlot,
-			"columns":      missingColumnsList,
-		}).Debug("Broadcasting not seen via gossip but reconstructed data columns.")
-	})
-
-	return nil
-}
-
-// setReceivedDataColumn marks the data column for a given root as received.
-func (s *Service) setReceivedDataColumn(root [fieldparams.RootLength]byte, columnIndex uint64) {
-	s.receivedDataColumnsFromRootLock.Lock()
-	defer s.receivedDataColumnsFromRootLock.Unlock()
-
-	// Get all the received data columns for this root.
-	receivedDataColumns, ok := s.receivedDataColumnsFromRoot[root]
-	if !ok {
-		// Create the map for this block root if needed.
-		receivedDataColumns = make(map[uint64]bool, params.BeaconConfig().NumberOfColumns)
-		s.receivedDataColumnsFromRoot[root] = receivedDataColumns
-	}
-
-	// Mark the data column as received.
-	receivedDataColumns[columnIndex] = true
-}
-
-// receivedDataColumns returns the received data columns for a given root.
-func (s *Service) receivedDataColumns(root [fieldparams.RootLength]byte) map[uint64]bool {
-	s.receivedDataColumnsFromRootLock.RLock()
-	defer s.receivedDataColumnsFromRootLock.RUnlock()
-
-	// Get all the received data columns for this root.
-	receivedDataColumns, ok := s.receivedDataColumnsFromRoot[root]
-	if !ok {
-		return nil
-	}
-
-	// Copy the received data columns.
-	copied := make(map[uint64]bool, len(receivedDataColumns))
-	for column, received := range receivedDataColumns {
-		copied[column] = received
-	}
-
-	return copied
-}
-
-// deleteReceivedDataColumns deletes the received data columns for a given root.
-func (s *Service) deleteReceivedDataColumns(root [fieldparams.RootLength]byte) {
-	s.receivedDataColumnsFromRootLock.Lock()
-	defer s.receivedDataColumnsFromRootLock.Unlock()
-
-	delete(s.receivedDataColumnsFromRoot, root)
-}

beacon-chain/sync/data_columns_sampling.go

@@ -1,456 +0,0 @@
-package sync
-
-import (
-	"context"
-	"fmt"
-	"sort"
-
-	"github.com/libp2p/go-libp2p/core/peer"
-	"github.com/pkg/errors"
-	coreTime "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/time"
-	"github.com/sirupsen/logrus"
-
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed"
-	statefeed "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/feed/state"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
-	fieldparams "github.com/prysmaticlabs/prysm/v5/config/fieldparams"
-	"github.com/prysmaticlabs/prysm/v5/config/params"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	"github.com/prysmaticlabs/prysm/v5/crypto/rand"
-	eth "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-)
-
-type roundSummary struct {
-	RequestedColumns []uint64
-	MissingColumns   map[uint64]bool
-}
-
-// randomizeColumns returns a slice containing all columns in a random order.
-func randomizeColumns(columns map[uint64]bool) []uint64 {
-	// Create a slice from columns.
-	randomized := make([]uint64, 0, len(columns))
-	for column := range columns {
-		randomized = append(randomized, column)
-	}
-
-	// Shuffle the slice.
-	rand.NewGenerator().Shuffle(len(randomized), func(i, j int) {
-		randomized[i], randomized[j] = randomized[j], randomized[i]
-	})
-
-	return randomized
-}
-
-// sortedSliceFromMap returns a sorted slices of keys from a map.
-func sortedSliceFromMap(m map[uint64]bool) []uint64 {
-	result := make([]uint64, 0, len(m))
-	for k := range m {
-		result = append(result, k)
-	}
-
-	sort.Slice(result, func(i, j int) bool {
-		return result[i] < result[j]
-	})
-
-	return result
-}
-
-// custodyColumnsFromPeer returns the columns the peer should custody.
-func (s *Service) custodyColumnsFromPeer(pid peer.ID) (map[uint64]bool, error) {
-	// Retrieve the custody count of the peer.
-	custodySubnetCount := s.cfg.p2p.CustodyCountFromRemotePeer(pid)
-
-	// Extract the node ID from the peer ID.
-	nodeID, err := p2p.ConvertPeerIDToNodeID(pid)
-	if err != nil {
-		return nil, errors.Wrap(err, "extract node ID")
-	}
-
-	// Determine which columns the peer should custody.
-	custodyColumns, err := peerdas.CustodyColumns(nodeID, custodySubnetCount)
-	if err != nil {
-		return nil, errors.Wrap(err, "custody columns")
-	}
-
-	return custodyColumns, nil
-}
-
-// verifyColumn verifies the retrieved column against the root, the index,
-// the KZG inclusion and the KZG proof.
-func verifyColumn(
-	roDataColumn blocks.RODataColumn,
-	root [32]byte,
-	pid peer.ID,
-	requestedColumns map[uint64]bool,
-) bool {
-	retrievedColumn := roDataColumn.ColumnIndex
-
-	// Filter out columns with incorrect root.
-	actualRoot := roDataColumn.BlockRoot()
-	if actualRoot != root {
-		log.WithFields(logrus.Fields{
-			"peerID":        pid,
-			"requestedRoot": fmt.Sprintf("%#x", root),
-			"actualRoot":    fmt.Sprintf("%#x", actualRoot),
-		}).Debug("Retrieved root does not match requested root")
-
-		return false
-	}
-
-	// Filter out columns that were not requested.
-	if !requestedColumns[retrievedColumn] {
-		columnsToSampleList := sortedSliceFromMap(requestedColumns)
-
-		log.WithFields(logrus.Fields{
-			"peerID":           pid,
-			"requestedColumns": columnsToSampleList,
-			"retrievedColumn":  retrievedColumn,
-		}).Debug("Retrieved column was not requested")
-
-		return false
-	}
-
-	// Filter out columns which did not pass the KZG inclusion proof verification.
-	if err := blocks.VerifyKZGInclusionProofColumn(roDataColumn.DataColumnSidecar); err != nil {
-		log.WithFields(logrus.Fields{
-			"peerID": pid,
-			"root":   fmt.Sprintf("%#x", root),
-			"index":  retrievedColumn,
-		}).Debug("Failed to verify KZG inclusion proof for retrieved column")
-
-		return false
-	}
-
-	// Filter out columns which did not pass the KZG proof verification.
-	verified, err := peerdas.VerifyDataColumnSidecarKZGProofs(roDataColumn.DataColumnSidecar)
-	if err != nil {
-		log.WithFields(logrus.Fields{
-			"peerID": pid,
-			"root":   fmt.Sprintf("%#x", root),
-			"index":  retrievedColumn,
-		}).Debug("Error when verifying KZG proof for retrieved column")
-
-		return false
-	}
-
-	if !verified {
-		log.WithFields(logrus.Fields{
-			"peerID": pid,
-			"root":   fmt.Sprintf("%#x", root),
-			"index":  retrievedColumn,
-		}).Debug("Failed to verify KZG proof for retrieved column")
-
-		return false
-	}
-
-	return true
-}
-
-// sampleDataColumnsFromPeer samples data columns from a peer.
-// It returns the retrieved columns.
-func (s *Service) sampleDataColumnsFromPeer(
-	pid peer.ID,
-	requestedColumns map[uint64]bool,
-	root [fieldparams.RootLength]byte,
-) (map[uint64]bool, error) {
-	// Build the data column identifiers.
-	dataColumnIdentifiers := make(types.DataColumnSidecarsByRootReq, 0, len(requestedColumns))
-	for index := range requestedColumns {
-		dataColumnIdentifiers = append(dataColumnIdentifiers, &eth.DataColumnIdentifier{
-			BlockRoot:   root[:],
-			ColumnIndex: index,
-		})
-	}
-
-	// Send the request.
-	roDataColumns, err := SendDataColumnSidecarByRoot(s.ctx, s.cfg.clock, s.cfg.p2p, pid, s.ctxMap, &dataColumnIdentifiers)
-	if err != nil {
-		return nil, errors.Wrap(err, "send data column sidecar by root")
-	}
-
-	retrievedColumns := make(map[uint64]bool, len(roDataColumns))
-
-	for _, roDataColumn := range roDataColumns {
-		if verifyColumn(roDataColumn, root, pid, requestedColumns) {
-			retrievedColumns[roDataColumn.ColumnIndex] = true
-		}
-	}
-
-	if len(retrievedColumns) == len(requestedColumns) {
-		// This is the happy path.
-		log.WithFields(logrus.Fields{
-			"peerID":           pid,
-			"root":             fmt.Sprintf("%#x", root),
-			"requestedColumns": sortedSliceFromMap(requestedColumns),
-		}).Debug("All requested columns were successfully sampled from peer")
-
-		return retrievedColumns, nil
-	}
-
-	// Some columns are missing.
-	log.WithFields(logrus.Fields{
-		"peerID":           pid,
-		"root":             fmt.Sprintf("%#x", root),
-		"requestedColumns": sortedSliceFromMap(requestedColumns),
-		"retrievedColumns": sortedSliceFromMap(retrievedColumns),
-	}).Warning("Some requested columns were not sampled from peer")
-
-	return retrievedColumns, nil
-}
-
-// sampleDataColumnsFromPeers samples data columns from active peers.
-// It returns the retrieved columns count.
-// If one peer fails to return a column it should custody, the column is considered as missing.
-func (s *Service) sampleDataColumnsFromPeers(
-	columnsToSample []uint64,
-	root [fieldparams.RootLength]byte,
-) (map[uint64]bool, error) {
-	// Build all remaining columns to sample.
-	remainingColumnsToSample := make(map[uint64]bool, len(columnsToSample))
-	for _, column := range columnsToSample {
-		remainingColumnsToSample[column] = true
-	}
-
-	// Get the active peers from the p2p service.
-	activePids := s.cfg.p2p.Peers().Active()
-
-	retrievedColumns := make(map[uint64]bool, len(columnsToSample))
-
-	// Query all peers until either all columns to request are retrieved or all active peers are queried (whichever comes first).
-	for i := 0; len(remainingColumnsToSample) > 0 && i < len(activePids); i++ {
-		// Get the peer ID.
-		pid := activePids[i]
-
-		// Get the custody columns of the peer.
-		peerCustodyColumns, err := s.custodyColumnsFromPeer(pid)
-		if err != nil {
-			return nil, errors.Wrap(err, "custody columns from peer")
-		}
-
-		// Compute the intersection of the peer custody columns and the remaining columns to request.
-		peerRequestedColumns := make(map[uint64]bool, len(peerCustodyColumns))
-		for column := range remainingColumnsToSample {
-			if peerCustodyColumns[column] {
-				peerRequestedColumns[column] = true
-			}
-		}
-
-		// Remove the newsly requested columns from the remaining columns to request.
-		for column := range peerRequestedColumns {
-			delete(remainingColumnsToSample, column)
-		}
-
-		// Sample data columns from the peer.
-		peerRetrievedColumns, err := s.sampleDataColumnsFromPeer(pid, peerRequestedColumns, root)
-		if err != nil {
-			return nil, errors.Wrap(err, "sample data columns from peer")
-		}
-
-		// Update the retrieved columns.
-		for column := range peerRetrievedColumns {
-			retrievedColumns[column] = true
-		}
-	}
-
-	return retrievedColumns, nil
-}
-
-// incrementalDAS samples data columns from active peers using incremental DAS.
-// https://ethresear.ch/t/lossydas-lossy-incremental-and-diagonal-sampling-for-data-availability/18963#incrementaldas-dynamically-increase-the-sample-size-10
-func (s *Service) incrementalDAS(
-	root [fieldparams.RootLength]byte,
-	columns []uint64,
-	sampleCount uint64,
-) (bool, []roundSummary, error) {
-	columnsCount, missingColumnsCount := uint64(len(columns)), uint64(0)
-	firstColumnToSample, extendedSampleCount := uint64(0), peerdas.ExtendedSampleCount(sampleCount, 0)
-
-	roundSummaries := make([]roundSummary, 0, 1) // We optimistically allocate only one round summary.
-
-	for round := 1; ; /*No exit condition */ round++ {
-		if extendedSampleCount > columnsCount {
-			// We already tried to sample all possible columns, this is the unhappy path.
-			log.WithField("root", fmt.Sprintf("%#x", root)).Warning("Some columns are still missing after sampling all possible columns")
-			return false, roundSummaries, nil
-		}
-
-		// Get the columns to sample for this round.
-		columnsToSample := columns[firstColumnToSample:extendedSampleCount]
-		columnsToSampleCount := extendedSampleCount - firstColumnToSample
-
-		// Sample the data columns from the peers.
-		retrievedSamples, err := s.sampleDataColumnsFromPeers(columnsToSample, root)
-		if err != nil {
-			return false, nil, errors.Wrap(err, "sample data columns from peers")
-		}
-
-		// Compute the missing samples.
-		missingSamples := make(map[uint64]bool, max(0, len(columnsToSample)-len(retrievedSamples)))
-		for _, column := range columnsToSample {
-			if !retrievedSamples[column] {
-				missingSamples[column] = true
-			}
-		}
-
-		roundSummaries = append(roundSummaries, roundSummary{
-			RequestedColumns: columnsToSample,
-			MissingColumns:   missingSamples,
-		})
-
-		retrievedSampleCount := uint64(len(retrievedSamples))
-
-		if retrievedSampleCount == columnsToSampleCount {
-			// All columns were correctly sampled, this is the happy path.
-			log.WithFields(logrus.Fields{
-				"root":         fmt.Sprintf("%#x", root),
-				"roundsNeeded": round,
-			}).Debug("All columns were successfully sampled")
-			return true, roundSummaries, nil
-		}
-
-		if retrievedSampleCount > columnsToSampleCount {
-			// This should never happen.
-			return false, nil, errors.New("retrieved more columns than requested")
-		}
-
-		// Some columns are missing, we need to extend the sample size.
-		missingColumnsCount += columnsToSampleCount - retrievedSampleCount
-
-		firstColumnToSample = extendedSampleCount
-		oldExtendedSampleCount := extendedSampleCount
-		extendedSampleCount = peerdas.ExtendedSampleCount(sampleCount, missingColumnsCount)
-
-		log.WithFields(logrus.Fields{
-			"root":                fmt.Sprintf("%#x", root),
-			"round":               round,
-			"missingColumnsCount": missingColumnsCount,
-			"currentSampleCount":  oldExtendedSampleCount,
-			"nextSampleCount":     extendedSampleCount,
-		}).Debug("Some columns are still missing after sampling this round.")
-	}
-}
-
-// DataColumnSamplingRoutine runs incremental DAS on block when received.
-func (s *Service) DataColumnSamplingRoutine(ctx context.Context) {
-	// Get the custody subnets count.
-	custodySubnetsCount := peerdas.CustodySubnetCount()
-
-	// Create a subscription to the state feed.
-	stateChannel := make(chan *feed.Event, 1)
-	stateSub := s.cfg.stateNotifier.StateFeed().Subscribe(stateChannel)
-
-	// Unsubscribe from the state feed when the function returns.
-	defer stateSub.Unsubscribe()
-
-	// Retrieve the number of columns.
-	columnsCount := params.BeaconConfig().NumberOfColumns
-
-	// Retrieve all columns we custody.
-	custodyColumns, err := peerdas.CustodyColumns(s.cfg.p2p.NodeID(), custodySubnetsCount)
-	if err != nil {
-		log.WithError(err).Error("Failed to get custody columns")
-		return
-	}
-
-	custodyColumnsCount := uint64(len(custodyColumns))
-
-	// Compute the number of columns to sample.
-	if custodyColumnsCount >= columnsCount/2 {
-		log.WithFields(logrus.Fields{
-			"custodyColumnsCount": custodyColumnsCount,
-			"columnsCount":        columnsCount,
-		}).Debug("The node custodies at least the half the data columns, no need to sample")
-		return
-	}
-
-	samplesCount := min(params.BeaconConfig().SamplesPerSlot, columnsCount/2-custodyColumnsCount)
-
-	// Compute all the columns we do NOT custody.
-	nonCustodyColums := make(map[uint64]bool, columnsCount-custodyColumnsCount)
-	for i := uint64(0); i < columnsCount; i++ {
-		if !custodyColumns[i] {
-			nonCustodyColums[i] = true
-		}
-	}
-
-	for {
-		select {
-		case e := <-stateChannel:
-			s.processEvent(e, nonCustodyColums, samplesCount)
-
-		case <-s.ctx.Done():
-			log.Debug("Context closed, exiting goroutine")
-			return
-
-		case err := <-stateSub.Err():
-			log.WithError(err).Error("Subscription to state feed failed")
-		}
-	}
-}
-
-func (s *Service) processEvent(e *feed.Event, nonCustodyColums map[uint64]bool, samplesCount uint64) {
-	if e.Type != statefeed.BlockProcessed {
-		return
-	}
-
-	data, ok := e.Data.(*statefeed.BlockProcessedData)
-	if !ok {
-		log.Error("Event feed data is not of type *statefeed.BlockProcessedData")
-		return
-	}
-
-	if !data.Verified {
-		// We only process blocks that have been verified
-		log.Error("Data is not verified")
-		return
-	}
-
-	if data.SignedBlock.Version() < version.Deneb {
-		log.Debug("Pre Deneb block, skipping data column sampling")
-		return
-	}
-
-	if coreTime.PeerDASIsActive(data.Slot) {
-		// We do not trigger sampling if peerDAS is not active yet.
-		return
-	}
-
-	// Get the commitments for this block.
-	commitments, err := data.SignedBlock.Block().Body().BlobKzgCommitments()
-	if err != nil {
-		log.WithError(err).Error("Failed to get blob KZG commitments")
-		return
-	}
-
-	// Skip if there are no commitments.
-	if len(commitments) == 0 {
-		log.Debug("No commitments in block, skipping data column sampling")
-		return
-	}
-
-	// Ramdomize all columns.
-	randomizedColumns := randomizeColumns(nonCustodyColums)
-
-	// Sample data columns with incremental DAS.
-	ok, _, err = s.incrementalDAS(data.BlockRoot, randomizedColumns, samplesCount)
-	if err != nil {
-		log.WithError(err).Error("Error during incremental DAS")
-	}
-
-	if ok {
-		log.WithFields(logrus.Fields{
-			"root":        fmt.Sprintf("%#x", data.BlockRoot),
-			"columns":     randomizedColumns,
-			"sampleCount": samplesCount,
-		}).Debug("Data column sampling successful")
-	} else {
-		log.WithFields(logrus.Fields{
-			"root":        fmt.Sprintf("%#x", data.BlockRoot),
-			"columns":     randomizedColumns,
-			"sampleCount": samplesCount,
-		}).Warning("Data column sampling failed")
-	}
-}

beacon-chain/sync/data_columns_sampling_test.go

@@ -1,286 +0,0 @@
-package sync
-
-import (
-	"bytes"
-	"context"
-	"crypto/sha256"
-	"encoding/binary"
-	"testing"
-
-	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
-	GoKZG "github.com/crate-crypto/go-kzg-4844"
-	"github.com/ethereum/go-ethereum/p2p/enr"
-	"github.com/libp2p/go-libp2p/core/crypto"
-	"github.com/libp2p/go-libp2p/core/network"
-	swarmt "github.com/libp2p/go-libp2p/p2p/net/swarm/testing"
-	kzg "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/kzg"
-	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/peerdas"
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/peers"
-	p2ptest "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
-	p2pTypes "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
-	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
-	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-	"github.com/prysmaticlabs/prysm/v5/testing/require"
-	"github.com/prysmaticlabs/prysm/v5/testing/util"
-	"github.com/sirupsen/logrus"
-)
-
-func TestRandomizeColumns(t *testing.T) {
-	const count uint64 = 128
-
-	// Generate columns.
-	columns := make(map[uint64]bool, count)
-	for i := uint64(0); i < count; i++ {
-		columns[i] = true
-	}
-
-	// Randomize columns.
-	randomizedColumns := randomizeColumns(columns)
-
-	// Convert back to a map.
-	randomizedColumnsMap := make(map[uint64]bool, count)
-	for _, column := range randomizedColumns {
-		randomizedColumnsMap[column] = true
-	}
-
-	// Check duplicates and missing columns.
-	require.Equal(t, len(columns), len(randomizedColumnsMap))
-
-	// Check the values.
-	for column := range randomizedColumnsMap {
-		require.Equal(t, true, column < count)
-	}
-}
-
-// createAndConnectPeer creates a peer with a private key `offset` fixed.
-// The peer is added and connected to `p2pService`
-func createAndConnectPeer(
-	t *testing.T,
-	p2pService *p2ptest.TestP2P,
-	chainService *mock.ChainService,
-	dataColumnSidecars []*ethpb.DataColumnSidecar,
-	custodyCount uint64,
-	columnsNotToRespond map[uint64]bool,
-	offset int,
-) {
-	// Create the private key, depending on the offset.
-	privateKeyBytes := make([]byte, 32)
-	for i := 0; i < 32; i++ {
-		privateKeyBytes[i] = byte(offset + i)
-	}
-
-	privateKey, err := crypto.UnmarshalSecp256k1PrivateKey(privateKeyBytes)
-	require.NoError(t, err)
-
-	// Create the peer.
-	peer := p2ptest.NewTestP2P(t, swarmt.OptPeerPrivateKey(privateKey))
-
-	// TODO: Do not hardcode the topic.
-	peer.SetStreamHandler("/eth2/beacon_chain/req/data_column_sidecars_by_root/1/ssz_snappy", func(stream network.Stream) {
-		// Decode the request.
-		req := new(p2pTypes.DataColumnSidecarsByRootReq)
-		err := peer.Encoding().DecodeWithMaxLength(stream, req)
-		require.NoError(t, err)
-
-		for _, identifier := range *req {
-			// Filter out the columns not to respond.
-			if columnsNotToRespond[identifier.ColumnIndex] {
-				continue
-			}
-
-			// Create the response.
-			resp := dataColumnSidecars[identifier.ColumnIndex]
-
-			// Send the response.
-			err := WriteDataColumnSidecarChunk(stream, chainService, p2pService.Encoding(), resp)
-			require.NoError(t, err)
-		}
-
-		// Close the stream.
-		closeStream(stream, log)
-	})
-
-	// Create the record and set the custody count.
-	enr := &enr.Record{}
-	enr.Set(peerdas.Csc(custodyCount))
-
-	// Add the peer and connect it.
-	p2pService.Peers().Add(enr, peer.PeerID(), nil, network.DirOutbound)
-	p2pService.Peers().SetConnectionState(peer.PeerID(), peers.PeerConnected)
-	p2pService.Connect(peer)
-}
-
-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) kzg.Blob {
-	var blob kzg.Blob
-	for i := 0; i < len(blob); i += 32 {
-		fieldElementBytes := getRandFieldElement(seed + int64(i))
-		copy(blob[i:i+32], fieldElementBytes[:])
-	}
-	return blob
-}
-
-func generateCommitmentAndProof(blob *kzg.Blob) (*kzg.Commitment, *kzg.Proof, error) {
-	commitment, err := kzg.BlobToKZGCommitment(blob)
-	if err != nil {
-		return nil, nil, err
-	}
-	proof, err := kzg.ComputeBlobKZGProof(blob, commitment)
-	if err != nil {
-		return nil, nil, err
-	}
-	return &commitment, &proof, err
-}
-
-func TestIncrementalDAS(t *testing.T) {
-	const (
-		blobCount                 = 3
-		custodyRequirement uint64 = 1
-	)
-
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	// Generate random blobs, commitments and inclusion proofs.
-	blobs := make([]kzg.Blob, blobCount)
-	kzgCommitments := make([][]byte, blobCount)
-	kzgProofs := make([][]byte, blobCount)
-
-	for i := int64(0); i < blobCount; i++ {
-		blob := getRandBlob(int64(i))
-
-		kzgCommitment, kzgProof, err := generateCommitmentAndProof(&blob)
-		require.NoError(t, err)
-
-		blobs[i] = blob
-		kzgCommitments[i] = kzgCommitment[:]
-		kzgProofs[i] = kzgProof[:]
-	}
-
-	dbBlock := util.NewBeaconBlockDeneb()
-	dbBlock.Block.Body.BlobKzgCommitments = kzgCommitments
-	sBlock, err := blocks.NewSignedBeaconBlock(dbBlock)
-	require.NoError(t, err)
-
-	dataColumnSidecars, err := peerdas.DataColumnSidecars(sBlock, blobs)
-	require.NoError(t, err)
-
-	blockRoot, err := dataColumnSidecars[0].GetSignedBlockHeader().Header.HashTreeRoot()
-	require.NoError(t, err)
-
-	testCases := []struct {
-		name                     string
-		samplesCount             uint64
-		possibleColumnsToRequest []uint64
-		columnsNotToRespond      map[uint64]bool
-		expectedSuccess          bool
-		expectedRoundSummaries   []roundSummary
-	}{
-		{
-			name:                     "All columns are correctly sampled in a single round",
-			samplesCount:             5,
-			possibleColumnsToRequest: []uint64{70, 35, 99, 6, 38, 3, 67, 102, 12, 44, 76, 108},
-			columnsNotToRespond:      map[uint64]bool{},
-			expectedSuccess:          true,
-			expectedRoundSummaries: []roundSummary{
-				{
-					RequestedColumns: []uint64{70, 35, 99, 6, 38},
-					MissingColumns:   map[uint64]bool{},
-				},
-			},
-		},
-		{
-			name:                     "Two missing columns in the first round, ok in the second round",
-			samplesCount:             5,
-			possibleColumnsToRequest: []uint64{70, 35, 99, 6, 38, 3, 67, 102, 12, 44, 76, 108},
-			columnsNotToRespond:      map[uint64]bool{6: true, 70: true},
-			expectedSuccess:          true,
-			expectedRoundSummaries: []roundSummary{
-				{
-					RequestedColumns: []uint64{70, 35, 99, 6, 38},
-					MissingColumns:   map[uint64]bool{70: true, 6: true},
-				},
-				{
-					RequestedColumns: []uint64{3, 67, 102, 12, 44, 76},
-					MissingColumns:   map[uint64]bool{},
-				},
-			},
-		},
-		{
-			name:                     "Two missing columns in the first round, one missing in the second round. Fail to sample.",
-			samplesCount:             5,
-			possibleColumnsToRequest: []uint64{70, 35, 99, 6, 38, 3, 67, 102, 12, 44, 76, 108},
-			columnsNotToRespond:      map[uint64]bool{6: true, 70: true, 3: true},
-			expectedSuccess:          false,
-			expectedRoundSummaries: []roundSummary{
-				{
-					RequestedColumns: []uint64{70, 35, 99, 6, 38},
-					MissingColumns:   map[uint64]bool{70: true, 6: true},
-				},
-				{
-					RequestedColumns: []uint64{3, 67, 102, 12, 44, 76},
-					MissingColumns:   map[uint64]bool{3: true},
-				},
-			},
-		},
-	}
-
-	for _, tc := range testCases {
-		// Create a context.
-		ctx := context.Background()
-
-		// Create the p2p service.
-		p2pService := p2ptest.NewTestP2P(t)
-
-		// Create a peer custodying `custodyRequirement` subnets.
-		chainService, clock := defaultMockChain(t)
-
-		// Custody columns: [6, 38, 70, 102]
-		createAndConnectPeer(t, p2pService, chainService, dataColumnSidecars, custodyRequirement, tc.columnsNotToRespond, 1)
-
-		// Custody columns: [3, 35, 67, 99]
-		createAndConnectPeer(t, p2pService, chainService, dataColumnSidecars, custodyRequirement, tc.columnsNotToRespond, 2)
-
-		// Custody columns: [12, 44, 76, 108]
-		createAndConnectPeer(t, p2pService, chainService, dataColumnSidecars, custodyRequirement, tc.columnsNotToRespond, 3)
-
-		service := &Service{
-			cfg: &config{
-				p2p:   p2pService,
-				clock: clock,
-			},
-			ctx:    ctx,
-			ctxMap: map[[4]byte]int{{245, 165, 253, 66}: version.Deneb},
-		}
-
-		actualSuccess, actualRoundSummaries, err := service.incrementalDAS(blockRoot, tc.possibleColumnsToRequest, tc.samplesCount)
-
-		require.NoError(t, err)
-		require.Equal(t, tc.expectedSuccess, actualSuccess)
-		require.DeepEqual(t, tc.expectedRoundSummaries, actualRoundSummaries)
-	}
-}

beacon-chain/sync/decode_pubsub.go

@@ -1,13 +1,20 @@
 package sync
 
 import (
+	"fmt"
 	"reflect"
 	"strings"
 
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	"github.com/pkg/errors"
 	ssz "github.com/prysmaticlabs/fastssz"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
+	"github.com/prysmaticlabs/prysm/v5/config/params"
+	"github.com/prysmaticlabs/prysm/v5/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
 	"google.golang.org/protobuf/proto"
 )
@@ -39,8 +46,6 @@ func (s *Service) decodePubsubMessage(msg *pubsub.Message) (ssz.Unmarshaler, err
 		topic = p2p.GossipTypeMapping[reflect.TypeOf(&ethpb.SyncCommitteeMessage{})]
 	case strings.Contains(topic, p2p.GossipBlobSidecarMessage):
 		topic = p2p.GossipTypeMapping[reflect.TypeOf(&ethpb.BlobSidecar{})]
-	case strings.Contains(topic, p2p.GossipDataColumnSidecarMessage):
-		topic = p2p.GossipTypeMapping[reflect.TypeOf(&ethpb.DataColumnSidecar{})]
 	}
 
 	base := p2p.GossipTopicMappings(topic, 0)
@@ -52,11 +57,12 @@ func (s *Service) decodePubsubMessage(msg *pubsub.Message) (ssz.Unmarshaler, err
 		return nil, errors.Errorf("message of %T does not support marshaller interface", base)
 	}
 	// Handle different message types across forks.
-	if topic == p2p.BlockSubnetTopicFormat {
-		m, err = extractBlockDataType(fDigest[:], s.cfg.clock)
-		if err != nil {
-			return nil, err
-		}
+	dt, err := extractValidDataTypeFromTopic(topic, fDigest[:], s.cfg.clock)
+	if err != nil {
+		return nil, err
+	}
+	if dt != nil {
+		m = dt
 	}
 	if err := s.cfg.p2p.Encoding().DecodeGossip(msg.Data, m); err != nil {
 		return nil, err
@@ -73,3 +79,48 @@ func (*Service) replaceForkDigest(topic string) (string, error) {
 	subStrings[2] = "%x"
 	return strings.Join(subStrings, "/"), nil
 }
+
+func extractValidDataTypeFromTopic(topic string, digest []byte, clock *startup.Clock) (ssz.Unmarshaler, error) {
+	switch topic {
+	case p2p.BlockSubnetTopicFormat:
+		return extractDataTypeFromTypeMap(types.BlockMap, digest, clock)
+	case p2p.AttestationSubnetTopicFormat:
+		return extractDataTypeFromTypeMap(types.AttestationMap, digest, clock)
+	case p2p.AggregateAndProofSubnetTopicFormat:
+		return extractDataTypeFromTypeMap(types.AggregateAttestationMap, digest, clock)
+	}
+	return nil, nil
+}
+
+func extractDataTypeFromTypeMap[T any](typeMap map[[4]byte]func() (T, error), digest []byte, tor blockchain.TemporalOracle) (T, error) {
+	var zero T
+
+	if len(digest) == 0 {
+		f, ok := typeMap[bytesutil.ToBytes4(params.BeaconConfig().GenesisForkVersion)]
+		if !ok {
+			return zero, fmt.Errorf("no %T type exists for the genesis fork version", zero)
+		}
+		return f()
+	}
+	if len(digest) != forkDigestLength {
+		return zero, errors.Errorf("invalid digest returned, wanted a length of %d but received %d", forkDigestLength, len(digest))
+	}
+	vRoot := tor.GenesisValidatorsRoot()
+	for k, f := range typeMap {
+		rDigest, err := signing.ComputeForkDigest(k[:], vRoot[:])
+		if err != nil {
+			return zero, err
+		}
+		if rDigest == bytesutil.ToBytes4(digest) {
+			return f()
+		}
+	}
+	return zero, errors.Wrapf(
+		ErrNoValidDigest,
+		"could not extract %T data type, saw digest=%#x, genesis=%v, vr=%#x",
+		zero,
+		digest,
+		tor.GenesisTime(),
+		tor.GenesisValidatorsRoot(),
+	)
+}

beacon-chain/sync/decode_pubsub_test.go

@@ -11,15 +11,20 @@ import (
 	"github.com/d4l3k/messagediff"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	pb "github.com/libp2p/go-libp2p-pubsub/pb"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain"
 	mock "github.com/prysmaticlabs/prysm/v5/beacon-chain/blockchain/testing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/core/signing"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p"
 	p2ptesting "github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/testing"
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/p2p/types"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/startup"
 	"github.com/prysmaticlabs/prysm/v5/config/params"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v5/consensus-types/interfaces"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/wrapper"
+	enginev1 "github.com/prysmaticlabs/prysm/v5/proto/engine/v1"
 	ethpb "github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/v5/proto/prysm/v1alpha1/metadata"
 	"github.com/prysmaticlabs/prysm/v5/testing/require"
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
@@ -109,3 +114,197 @@ func TestService_decodePubsubMessage(t *testing.T) {
 		})
 	}
 }
+
+func TestExtractDataType(t *testing.T) {
+	// Precompute digests
+	genDigest, err := signing.ComputeForkDigest(params.BeaconConfig().GenesisForkVersion, params.BeaconConfig().ZeroHash[:])
+	require.NoError(t, err)
+	altairDigest, err := signing.ComputeForkDigest(params.BeaconConfig().AltairForkVersion, params.BeaconConfig().ZeroHash[:])
+	require.NoError(t, err)
+	bellatrixDigest, err := signing.ComputeForkDigest(params.BeaconConfig().BellatrixForkVersion, params.BeaconConfig().ZeroHash[:])
+	require.NoError(t, err)
+	capellaDigest, err := signing.ComputeForkDigest(params.BeaconConfig().CapellaForkVersion, params.BeaconConfig().ZeroHash[:])
+	require.NoError(t, err)
+	denebDigest, err := signing.ComputeForkDigest(params.BeaconConfig().DenebForkVersion, params.BeaconConfig().ZeroHash[:])
+	require.NoError(t, err)
+	electraDigest, err := signing.ComputeForkDigest(params.BeaconConfig().ElectraForkVersion, params.BeaconConfig().ZeroHash[:])
+	require.NoError(t, err)
+
+	type args struct {
+		digest []byte
+		chain  blockchain.ChainInfoFetcher
+	}
+	tests := []struct {
+		name          string
+		args          args
+		wantBlock     interfaces.ReadOnlySignedBeaconBlock
+		wantMd        metadata.Metadata
+		wantAtt       ethpb.Att
+		wantAggregate ethpb.SignedAggregateAttAndProof
+		wantErr       bool
+	}{
+		{
+			name: "no digest",
+			args: args{
+				digest: []byte{},
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantMd:        wrapper.WrappedMetadataV0(&ethpb.MetaDataV0{}),
+			wantAtt:       &ethpb.Attestation{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
+			wantErr:       false,
+		},
+		{
+			name: "invalid digest",
+			args: args{
+				digest: []byte{0x00, 0x01},
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock:     nil,
+			wantMd:        nil,
+			wantAtt:       nil,
+			wantAggregate: nil,
+			wantErr:       true,
+		},
+		{
+			name: "non existent digest",
+			args: args{
+				digest: []byte{0x00, 0x01, 0x02, 0x03},
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock:     nil,
+			wantMd:        nil,
+			wantAtt:       nil,
+			wantAggregate: nil,
+			wantErr:       true,
+		},
+		{
+			name: "genesis fork version",
+			args: args{
+				digest: genDigest[:],
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlock{Block: &ethpb.BeaconBlock{Body: &ethpb.BeaconBlockBody{}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantAtt:       &ethpb.Attestation{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
+			wantErr:       false,
+		},
+		{
+			name: "altair fork version",
+			args: args{
+				digest: altairDigest[:],
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockAltair{Block: &ethpb.BeaconBlockAltair{Body: &ethpb.BeaconBlockBodyAltair{}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:       &ethpb.Attestation{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
+			wantErr:       false,
+		},
+		{
+			name: "bellatrix fork version",
+			args: args{
+				digest: bellatrixDigest[:],
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockBellatrix{Block: &ethpb.BeaconBlockBellatrix{Body: &ethpb.BeaconBlockBodyBellatrix{ExecutionPayload: &enginev1.ExecutionPayload{}}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:       &ethpb.Attestation{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
+			wantErr:       false,
+		},
+		{
+			name: "capella fork version",
+			args: args{
+				digest: capellaDigest[:],
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockCapella{Block: &ethpb.BeaconBlockCapella{Body: &ethpb.BeaconBlockBodyCapella{ExecutionPayload: &enginev1.ExecutionPayloadCapella{}}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:       &ethpb.Attestation{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
+			wantErr:       false,
+		},
+		{
+			name: "deneb fork version",
+			args: args{
+				digest: denebDigest[:],
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockDeneb{Block: &ethpb.BeaconBlockDeneb{Body: &ethpb.BeaconBlockBodyDeneb{ExecutionPayload: &enginev1.ExecutionPayloadDeneb{}}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:       &ethpb.Attestation{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProof{},
+			wantErr:       false,
+		},
+		{
+			name: "electra fork version",
+			args: args{
+				digest: electraDigest[:],
+				chain:  &mock.ChainService{ValidatorsRoot: [32]byte{}},
+			},
+			wantBlock: func() interfaces.ReadOnlySignedBeaconBlock {
+				wsb, err := blocks.NewSignedBeaconBlock(&ethpb.SignedBeaconBlockElectra{Block: &ethpb.BeaconBlockElectra{Body: &ethpb.BeaconBlockBodyElectra{ExecutionPayload: &enginev1.ExecutionPayloadElectra{}}}})
+				require.NoError(t, err)
+				return wsb
+			}(),
+			wantMd:        wrapper.WrappedMetadataV1(&ethpb.MetaDataV1{}),
+			wantAtt:       &ethpb.AttestationElectra{},
+			wantAggregate: &ethpb.SignedAggregateAttestationAndProofElectra{},
+			wantErr:       false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotBlock, err := extractDataTypeFromTypeMap(types.BlockMap, tt.args.digest, tt.args.chain)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("block: error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotBlock, tt.wantBlock) {
+				t.Errorf("block: got = %v, want %v", gotBlock, tt.wantBlock)
+			}
+			gotAtt, err := extractDataTypeFromTypeMap(types.AttestationMap, tt.args.digest, tt.args.chain)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("attestation: error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAtt, tt.wantAtt) {
+				t.Errorf("attestation: got = %v, want %v", gotAtt, tt.wantAtt)
+			}
+			gotAggregate, err := extractDataTypeFromTypeMap(types.AggregateAttestationMap, tt.args.digest, tt.args.chain)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("aggregate: error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(gotAggregate, tt.wantAggregate) {
+				t.Errorf("aggregate: got = %v, want %v", gotAggregate, tt.wantAggregate)
+			}
+		})
+	}
+}

beacon-chain/sync/fork_watcher.go

@@ -67,11 +67,6 @@ func (s *Service) registerForUpcomingFork(currEpoch primitives.Epoch) error {
 			s.registerRPCHandlersDeneb()
 		}
 	}
-	// Specially handle peerDAS
-	if params.PeerDASEnabled() && currEpoch+1 == params.BeaconConfig().Eip7594ForkEpoch {
-		s.registerRPCHandlersPeerDAS()
-	}
-
 	return nil
 }
 
@@ -126,9 +121,5 @@ func (s *Service) deregisterFromPastFork(currEpoch primitives.Epoch) error {
 			}
 		}
 	}
-	// Handle PeerDAS as its a special case.
-	if params.PeerDASEnabled() && currEpoch > 0 && (currEpoch-1) == params.BeaconConfig().Eip7594ForkEpoch {
-		s.unregisterBlobHandlers()
-	}
 	return nil
 }

beacon-chain/sync/fuzz_exports.go

@@ -22,7 +22,7 @@ func NewRegularSyncFuzz(opts ...Option) *Service {
 		cancel:               cancel,
 		slotToPendingBlocks:  gcache.New(time.Second, 2*time.Second),
 		seenPendingBlocks:    make(map[[32]byte]bool),
-		blkRootToPendingAtts: make(map[[32]byte][]*ethpb.SignedAggregateAttestationAndProof),
+		blkRootToPendingAtts: make(map[[32]byte][]ethpb.SignedAggregateAttAndProof),
 	}
 	r.rateLimiter = newRateLimiter(r.cfg.p2p)