Add profile to sync block path

.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

api/server/middleware/middleware.go

@@ -50,7 +50,7 @@ func ContentTypeHandler(acceptedMediaTypes []string) mux.MiddlewareFunc {
 
 			accepted := false
 			for _, acceptedType := range acceptedMediaTypes {
-				if strings.Contains(strings.TrimSpace(contentType), strings.TrimSpace(acceptedType)) {
+				if strings.TrimSpace(contentType) == strings.TrimSpace(acceptedType) {
 					accepted = true
 					break
 				}

api/server/middleware/middleware_test.go

@@ -96,11 +96,6 @@ func TestContentTypeHandler(t *testing.T) {
 			expectedStatusCode: http.StatusOK,
 			isGet:              true,
 		},
-		{
-			name:               "Content type contains charset is ok",
-			contentType:        "application/json; charset=utf-8",
-			expectedStatusCode: http.StatusOK,
-		},
 	}
 
 	for _, tt := range tests {

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/electra/BUILD.bazel

@@ -3,7 +3,6 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "attestation.go",
         "churn.go",
         "consolidations.go",
         "deposits.go",

beacon-chain/core/electra/attestation.go

@@ -1,7 +0,0 @@
-package electra
-
-import "github.com/prysmaticlabs/prysm/v5/beacon-chain/core/altair"
-
-var (
-	ProcessAttestationsNoVerifySignature = altair.ProcessAttestationsNoVerifySignature
-)

beacon-chain/core/electra/deposits.go

@@ -77,11 +77,11 @@ func ProcessPendingBalanceDeposits(ctx context.Context, st state.BeaconState, ac
 	}
 }
 
-// ProcessDepositRequests is a function as part of electra to process execution layer deposits
-func ProcessDepositRequests(ctx context.Context, beaconState state.BeaconState, requests []*enginev1.DepositRequest) (state.BeaconState, error) {
-	_, span := trace.StartSpan(ctx, "electra.ProcessDepositRequests")
+// ProcessDepositReceipts is a function as part of electra to process execution layer deposits
+func ProcessDepositReceipts(ctx context.Context, beaconState state.BeaconState, receipts []*enginev1.DepositReceipt) (state.BeaconState, error) {
+	_, span := trace.StartSpan(ctx, "electra.ProcessDepositReceipts")
 	defer span.End()
 	// TODO: replace with 6110 logic
-	// return b.ProcessDepositRequests(beaconState, requests)
+	// return b.ProcessDepositReceipts(beaconState, receipts)
 	return beaconState, nil
 }

beacon-chain/core/electra/upgrade.go

@@ -38,7 +38,7 @@ import (
 //	    withdrawals_root=pre.latest_execution_payload_header.withdrawals_root,
 //	    blob_gas_used=pre.latest_execution_payload_header.blob_gas_used,
 //	    excess_blob_gas=pre.latest_execution_payload_header.excess_blob_gas,
-//	    deposit_requests_root=Root(),  # [New in Electra:EIP6110]
+//	    deposit_receipts_root=Root(),  # [New in Electra:EIP6110]
 //	    withdrawal_requests_root=Root(),  # [New in Electra:EIP7002],
 //	)
 //
@@ -94,7 +94,7 @@ import (
 //	    # Deep history valid from Capella onwards
 //	    historical_summaries=pre.historical_summaries,
 //	    # [New in Electra:EIP6110]
-//	    deposit_requests_start_index=UNSET_DEPOSIT_REQUESTS_START_INDEX,
+//	    deposit_receipts_start_index=UNSET_DEPOSIT_RECEIPTS_START_INDEX,
 //	    # [New in Electra:EIP7251]
 //	    deposit_balance_to_consume=0,
 //	    exit_balance_to_consume=0,
@@ -261,14 +261,14 @@ func UpgradeToElectra(beaconState state.BeaconState) (state.BeaconState, error)
 			WithdrawalsRoot:        wdRoot,
 			ExcessBlobGas:          excessBlobGas,
 			BlobGasUsed:            blobGasUsed,
-			DepositRequestsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP6110]
+			DepositReceiptsRoot:    bytesutil.Bytes32(0), // [New in Electra:EIP6110]
 			WithdrawalRequestsRoot: bytesutil.Bytes32(0), // [New in Electra:EIP7002]
 		},
 		NextWithdrawalIndex:          wi,
 		NextWithdrawalValidatorIndex: vi,
 		HistoricalSummaries:          summaries,
 
-		DepositRequestsStartIndex:     params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		DepositReceiptsStartIndex:     params.BeaconConfig().UnsetDepositReceiptsStartIndex,
 		DepositBalanceToConsume:       0,
 		ExitBalanceToConsume:          helpers.ActivationExitChurnLimit(primitives.Gwei(tab)),
 		EarliestExitEpoch:             earliestExitEpoch,

beacon-chain/core/electra/upgrade_test.go

@@ -128,7 +128,7 @@ func TestUpgradeToElectra(t *testing.T) {
 		BlockHash:              prevHeader.BlockHash(),
 		TransactionsRoot:       txRoot,
 		WithdrawalsRoot:        wdRoot,
-		DepositRequestsRoot:    bytesutil.Bytes32(0),
+		DepositReceiptsRoot:    bytesutil.Bytes32(0),
 		WithdrawalRequestsRoot: bytesutil.Bytes32(0),
 	}
 	require.DeepEqual(t, wanted, protoHeader)
@@ -145,9 +145,9 @@ func TestUpgradeToElectra(t *testing.T) {
 	require.NoError(t, err)
 	require.Equal(t, 0, len(summaries))
 
-	startIndex, err := mSt.DepositRequestsStartIndex()
+	startIndex, err := mSt.DepositReceiptsStartIndex()
 	require.NoError(t, err)
-	require.Equal(t, params.BeaconConfig().UnsetDepositRequestsStartIndex, startIndex)
+	require.Equal(t, params.BeaconConfig().UnsetDepositReceiptsStartIndex, startIndex)
 
 	balance, err := mSt.DepositBalanceToConsume()
 	require.NoError(t, err)

beacon-chain/core/electra/withdrawals.go

@@ -19,15 +19,15 @@ import (
 	"go.opencensus.io/trace"
 )
 
-// ProcessWithdrawalRequests processes the validator withdrawals from the provided execution payload
+// ProcessExecutionLayerWithdrawalRequests processes the validator withdrawals from the provided execution payload
 // into the beacon state triggered by the execution layer.
 //
 // Spec pseudocode definition:
 //
-// def process_withdrawal_request(
+// def process_execution_layer_withdrawal_request(
 //
 //		state: BeaconState,
-//		withdrawal_request: WithdrawalRequest
+//		execution_layer_withdrawal_request: ExecutionLayerWithdrawalRequest
 //
 //	 ) -> None:
 //	   amount = execution_layer_withdrawal_request.amount
@@ -86,8 +86,8 @@ import (
 //	   amount=to_withdraw,
 //	   withdrawable_epoch=withdrawable_epoch,
 //	   ))
-func ProcessWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.WithdrawalRequest) (state.BeaconState, error) {
-	ctx, span := trace.StartSpan(ctx, "electra.ProcessWithdrawalRequests")
+func ProcessExecutionLayerWithdrawalRequests(ctx context.Context, st state.BeaconState, wrs []*enginev1.ExecutionLayerWithdrawalRequest) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "electra.ProcessExecutionLayerWithdrawalRequests")
 	defer span.End()
 	currentEpoch := slots.ToEpoch(st.Slot())
 	for _, wr := range wrs {

beacon-chain/core/electra/withdrawals_test.go

@@ -19,7 +19,7 @@ import (
 	"github.com/sirupsen/logrus/hooks/test"
 )
 
-func TestProcessWithdrawRequests(t *testing.T) {
+func TestProcessExecutionLayerWithdrawRequests(t *testing.T) {
 	logHook := test.NewGlobal()
 	source, err := hexutil.Decode("0xb20a608c624Ca5003905aA834De7156C68b2E1d0")
 	require.NoError(t, err)
@@ -30,7 +30,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	require.NoError(t, err)
 	type args struct {
 		st  state.BeaconState
-		wrs []*enginev1.WithdrawalRequest
+		wrs []*enginev1.ExecutionLayerWithdrawalRequest
 	}
 	tests := []struct {
 		name    string
@@ -56,7 +56,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -121,7 +121,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -190,7 +190,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -227,7 +227,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					require.NoError(t, preSt.SetValidators([]*eth.Validator{v}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -266,7 +266,7 @@ func TestProcessWithdrawRequests(t *testing.T) {
 					}))
 					return preSt
 				}(),
-				wrs: []*enginev1.WithdrawalRequest{
+				wrs: []*enginev1.ExecutionLayerWithdrawalRequest{
 					{
 						SourceAddress:   source,
 						ValidatorPubkey: bytesutil.SafeCopyBytes(val.PublicKey),
@@ -284,9 +284,9 @@ func TestProcessWithdrawRequests(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 
-			got, err := electra.ProcessWithdrawalRequests(context.Background(), tt.args.st, tt.args.wrs)
+			got, err := electra.ProcessExecutionLayerWithdrawalRequests(context.Background(), tt.args.st, tt.args.wrs)
 			if (err != nil) != tt.wantErr {
-				t.Errorf("ProcessWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
+				t.Errorf("ProcessExecutionLayerWithdrawalRequests() error = %v, wantErr %v", err, tt.wantErr)
 				return
 			}
 			tt.wantFn(t, got)

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/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/core/transition/transition_no_verify_sig.go

@@ -227,7 +227,7 @@ func ProcessBlockNoVerifyAnySig(
 //	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
 //	    # [Modified in Electra:EIP6110]
 //	    # Disable former deposit mechanism once all prior deposits are processed
-//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_receipts_start_index)
 //	    if state.eth1_deposit_index < eth1_deposit_index_limit:
 //	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
 //	    else:
@@ -245,7 +245,7 @@ func ProcessBlockNoVerifyAnySig(
 //	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
 //	    # [New in Electra:EIP7002:EIP7251]
 //	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
-//	    for_ops(body.execution_payload.deposit_requests, process_deposit_requests)  # [New in Electra:EIP6110]
+//	    for_ops(body.execution_payload.deposit_receipts, process_deposit_receipt)  # [New in Electra:EIP6110]
 //	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
 func ProcessOperationsNoVerifyAttsSigs(
 	ctx context.Context,
@@ -401,7 +401,7 @@ func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
 //	def process_operations(state: BeaconState, body: BeaconBlockBody) -> None:
 //	    # [Modified in Electra:EIP6110]
 //	    # Disable former deposit mechanism once all prior deposits are processed
-//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_requests_start_index)
+//	    eth1_deposit_index_limit = min(state.eth1_data.deposit_count, state.deposit_receipts_start_index)
 //	    if state.eth1_deposit_index < eth1_deposit_index_limit:
 //	        assert len(body.deposits) == min(MAX_DEPOSITS, eth1_deposit_index_limit - state.eth1_deposit_index)
 //	    else:
@@ -419,7 +419,7 @@ func VerifyBlobCommitmentCount(blk interfaces.ReadOnlyBeaconBlock) error {
 //	    for_ops(body.bls_to_execution_changes, process_bls_to_execution_change)
 //	    # [New in Electra:EIP7002:EIP7251]
 //	    for_ops(body.execution_payload.withdrawal_requests, process_execution_layer_withdrawal_request)
-//	    for_ops(body.execution_payload.deposit_requests, process_deposit_requests)  # [New in Electra:EIP6110]
+//	    for_ops(body.execution_payload.deposit_receipts, process_deposit_receipt)  # [New in Electra:EIP6110]
 //	    for_ops(body.consolidations, process_consolidation)  # [New in Electra:EIP7251]
 func electraOperations(
 	ctx context.Context,
@@ -445,12 +445,12 @@ func electraOperations(
 	if !ok {
 		return nil, errors.New("could not cast execution data to electra execution data")
 	}
-	st, err = electra.ProcessWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
+	st, err = electra.ProcessExecutionLayerWithdrawalRequests(ctx, st, exe.WithdrawalRequests())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process execution layer withdrawal requests")
 	}
 
-	st, err = electra.ProcessDepositRequests(ctx, st, exe.DepositRequests()) // TODO: EIP-6110 deposit changes.
+	st, err = electra.ProcessDepositReceipts(ctx, st, exe.DepositReceipts()) // TODO: EIP-6110 deposit changes.
 	if err != nil {
 		return nil, errors.Wrap(err, "could not process deposit receipts")
 	}

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/db/kv/state_test.go

@@ -149,7 +149,7 @@ func TestState_CanSaveRetrieve(t *testing.T) {
 					BlockHash:              make([]byte, 32),
 					TransactionsRoot:       make([]byte, 32),
 					WithdrawalsRoot:        make([]byte, 32),
-					DepositRequestsRoot:    make([]byte, 32),
+					DepositReceiptsRoot:    make([]byte, 32),
 					WithdrawalRequestsRoot: make([]byte, 32),
 				})
 				require.NoError(t, err)

beacon-chain/execution/engine_client.go

@@ -631,7 +631,7 @@ func fullPayloadFromPayloadBody(
 				Withdrawals:        body.Withdrawals,
 				ExcessBlobGas:      ebg,
 				BlobGasUsed:        bgu,
-				DepositRequests:    dr,
+				DepositReceipts:    dr,
 				WithdrawalRequests: wr,
 			}) // We can't get the block value and don't care about the block value for this instance
 	default:
@@ -780,8 +780,8 @@ func buildEmptyExecutionPayload(v int) (proto.Message, error) {
 			BlockHash:          make([]byte, fieldparams.RootLength),
 			Transactions:       make([][]byte, 0),
 			Withdrawals:        make([]*pb.Withdrawal, 0),
-			WithdrawalRequests: make([]*pb.WithdrawalRequest, 0),
-			DepositRequests:    make([]*pb.DepositRequest, 0),
+			WithdrawalRequests: make([]*pb.ExecutionLayerWithdrawalRequest, 0),
+			DepositReceipts:    make([]*pb.DepositReceipt, 0),
 		}, nil
 	default:
 		return nil, errors.Wrapf(ErrUnsupportedVersion, "version=%s", version.String(v))

beacon-chain/execution/engine_client_test.go

@@ -1559,7 +1559,7 @@ func fixturesStruct() *payloadFixtures {
 		Withdrawals:        []*pb.Withdrawal{},
 		BlobGasUsed:        2,
 		ExcessBlobGas:      3,
-		DepositRequests:    dr,
+		DepositReceipts:    dr,
 		WithdrawalRequests: wr,
 	}
 	hexUint := hexutil.Uint64(1)

beacon-chain/execution/payload_body_test.go

@@ -66,7 +66,7 @@ func payloadToBody(t *testing.T, ed interfaces.ExecutionData) *pb.ExecutionPaylo
 	}
 	eed, isElectra := ed.(interfaces.ExecutionDataElectra)
 	if isElectra {
-		body.DepositRequests = pb.ProtoDepositRequestsToJson(eed.DepositRequests())
+		body.DepositRequests = pb.ProtoDepositRequestsToJson(eed.DepositReceipts())
 		body.WithdrawalRequests = pb.ProtoWithdrawalRequestsToJson(eed.WithdrawalRequests())
 	}
 	return body

beacon-chain/node/node.go

@@ -120,6 +120,7 @@ type BeaconNode struct {
 	initialSyncComplete     chan struct{}
 	BlobStorage             *filesystem.BlobStorage
 	BlobStorageOptions      []filesystem.BlobStorageOption
+	blobRetentionEpochs     primitives.Epoch
 	verifyInitWaiter        *verification.InitializerWaiter
 	syncChecker             *initialsync.SyncChecker
 }
@@ -990,7 +991,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/node/options.go

@@ -5,6 +5,7 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/builder"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/db/filesystem"
 	"github.com/prysmaticlabs/prysm/v5/beacon-chain/execution"
+	"github.com/prysmaticlabs/prysm/v5/consensus-types/primitives"
 )
 
 // Option for beacon node configuration.
@@ -50,3 +51,11 @@ func WithBlobStorageOptions(opt ...filesystem.BlobStorageOption) Option {
 		return nil
 	}
 }
+
+// WithBlobRetentionEpochs sets the blobRetentionEpochs value, used in kv store initialization.
+func WithBlobRetentionEpochs(e primitives.Epoch) Option {
+	return func(bn *BeaconNode) error {
+		bn.blobRetentionEpochs = e
+		return nil
+	}
+}

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/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,17 +42,15 @@ 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() {
+// 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 isnt 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,7 +22,6 @@ 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

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/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/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/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
@@ -150,8 +149,7 @@ func TestGetSpec(t *testing.T) {
 	config.MaxAttestationsElectra = 89
 	config.MaxWithdrawalRequestsPerPayload = 90
 	config.MaxCellsInExtendedMatrix = 91
-	config.UnsetDepositRequestsStartIndex = 92
-	config.MaxDepositRequestsPerPayload = 93
+	config.UnsetDepositReceiptsStartIndex = 92
 
 	var dbp [4]byte
 	copy(dbp[:], []byte{'0', '0', '0', '1'})
@@ -194,7 +192,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, 154, len(data))
 	for k, v := range data {
 		t.Run(k, func(t *testing.T) {
 			switch k {
@@ -272,8 +270,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":
@@ -529,10 +525,8 @@ func TestGetSpec(t *testing.T) {
 				assert.Equal(t, "90", v)
 			case "MAX_CELLS_IN_EXTENDED_MATRIX":
 				assert.Equal(t, "91", v)
-			case "UNSET_DEPOSIT_REQUESTS_START_INDEX":
+			case "UNSET_DEPOSIT_RECEIPTS_START_INDEX":
 				assert.Equal(t, "92", v)
-			case "MAX_DEPOSIT_REQUESTS_PER_PAYLOAD":
-				assert.Equal(t, "93", v)
 			default:
 				t.Errorf("Incorrect key: %s", k)
 			}

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

@@ -630,14 +630,14 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 	require.NoError(t, err)
 	timeStamp, err := slots.ToTime(beaconState.GenesisTime(), electraSlot+1)
 	require.NoError(t, err)
-	dr := []*enginev1.DepositRequest{{
+	dr := []*enginev1.DepositReceipt{{
 		Pubkey:                bytesutil.PadTo(privKeys[0].PublicKey().Marshal(), 48),
 		WithdrawalCredentials: bytesutil.PadTo([]byte("wc"), 32),
 		Amount:                123,
 		Signature:             bytesutil.PadTo([]byte("sig"), 96),
 		Index:                 456,
 	}}
-	wr := []*enginev1.WithdrawalRequest{
+	wr := []*enginev1.ExecutionLayerWithdrawalRequest{
 		{
 			SourceAddress:   bytesutil.PadTo([]byte("sa"), 20),
 			ValidatorPubkey: bytesutil.PadTo(privKeys[1].PublicKey().Marshal(), 48),
@@ -654,7 +654,7 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 		PrevRandao:         random,
 		BaseFeePerGas:      make([]byte, fieldparams.RootLength),
 		BlockHash:          make([]byte, fieldparams.RootLength),
-		DepositRequests:    dr,
+		DepositReceipts:    dr,
 		WithdrawalRequests: wr,
 	}
 
@@ -680,7 +680,7 @@ func TestServer_GetBeaconBlock_Electra(t *testing.T) {
 	got, err := proposerServer.GetBeaconBlock(ctx, req)
 	require.NoError(t, err)
 	p := got.GetElectra().Block.Body.ExecutionPayload
-	require.DeepEqual(t, dr, p.DepositRequests)
+	require.DeepEqual(t, dr, p.DepositReceipts)
 	require.DeepEqual(t, wr, p.WithdrawalRequests)
 }
 
@@ -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

@@ -108,7 +108,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
@@ -251,7 +250,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/state/interfaces.go

@@ -219,7 +219,7 @@ type ReadOnlySyncCommittee interface {
 
 type ReadOnlyDeposits interface {
 	DepositBalanceToConsume() (primitives.Gwei, error)
-	DepositRequestsStartIndex() (uint64, error)
+	DepositReceiptsStartIndex() (uint64, error)
 	PendingBalanceDeposits() ([]*ethpb.PendingBalanceDeposit, error)
 }
 
@@ -327,7 +327,7 @@ type WriteOnlyConsolidations interface {
 
 type WriteOnlyDeposits interface {
 	AppendPendingBalanceDeposit(index primitives.ValidatorIndex, amount uint64) error
-	SetDepositRequestsStartIndex(index uint64) error
+	SetDepositReceiptsStartIndex(index uint64) error
 	SetPendingBalanceDeposits(val []*ethpb.PendingBalanceDeposit) error
 	SetDepositBalanceToConsume(primitives.Gwei) error
 }

beacon-chain/state/state-native/BUILD.bazel

@@ -12,7 +12,7 @@ go_library(
         "getters_block.go",
         "getters_checkpoint.go",
         "getters_consolidation.go",
-        "getters_deposit_requests.go",
+        "getters_deposit_receipts.go",
         "getters_eth1.go",
         "getters_exit.go",
         "getters_misc.go",
@@ -33,7 +33,7 @@ go_library(
         "setters_checkpoint.go",
         "setters_churn.go",
         "setters_consolidation.go",
-        "setters_deposit_requests.go",
+        "setters_deposit_receipts.go",
         "setters_eth1.go",
         "setters_misc.go",
         "setters_participation.go",
@@ -94,7 +94,7 @@ go_test(
         "getters_block_test.go",
         "getters_checkpoint_test.go",
         "getters_consolidation_test.go",
-        "getters_deposit_requests_test.go",
+        "getters_deposit_receipts_test.go",
         "getters_exit_test.go",
         "getters_participation_test.go",
         "getters_test.go",
@@ -109,7 +109,7 @@ go_test(
         "setters_balance_deposits_test.go",
         "setters_churn_test.go",
         "setters_consolidation_test.go",
-        "setters_deposit_requests_test.go",
+        "setters_deposit_receipts_test.go",
         "setters_eth1_test.go",
         "setters_misc_test.go",
         "setters_participation_test.go",

beacon-chain/state/state-native/beacon_state_mainnet.go

@@ -62,7 +62,7 @@ type BeaconState struct {
 	nextWithdrawalValidatorIndex        primitives.ValidatorIndex
 
 	// Electra fields
-	depositRequestsStartIndex     uint64
+	depositReceiptsStartIndex     uint64
 	depositBalanceToConsume       primitives.Gwei
 	exitBalanceToConsume          primitives.Gwei
 	earliestExitEpoch             primitives.Epoch
@@ -119,7 +119,7 @@ type beaconStateMarshalable struct {
 	LatestExecutionPayloadHeaderElectra *enginev1.ExecutionPayloadHeaderElectra `json:"latest_execution_payload_header_electra" yaml:"latest_execution_payload_header_electra"`
 	NextWithdrawalIndex                 uint64                                  `json:"next_withdrawal_index" yaml:"next_withdrawal_index"`
 	NextWithdrawalValidatorIndex        primitives.ValidatorIndex               `json:"next_withdrawal_validator_index" yaml:"next_withdrawal_validator_index"`
-	DepositRequestsStartIndex           uint64                                  `json:"deposit_requests_start_index" yaml:"deposit_requests_start_index"`
+	DepositReceiptsStartIndex           uint64                                  `json:"deposit_receipts_start_index" yaml:"deposit_receipts_start_index"`
 	DepositBalanceToConsume             primitives.Gwei                         `json:"deposit_balance_to_consume" yaml:"deposit_balance_to_consume"`
 	ExitBalanceToConsume                primitives.Gwei                         `json:"exit_balance_to_consume" yaml:"exit_balance_to_consume"`
 	EarliestExitEpoch                   primitives.Epoch                        `json:"earliest_exit_epoch" yaml:"earliest_exit_epoch"`
@@ -189,7 +189,7 @@ func (b *BeaconState) MarshalJSON() ([]byte, error) {
 		LatestExecutionPayloadHeaderElectra: b.latestExecutionPayloadHeaderElectra,
 		NextWithdrawalIndex:                 b.nextWithdrawalIndex,
 		NextWithdrawalValidatorIndex:        b.nextWithdrawalValidatorIndex,
-		DepositRequestsStartIndex:           b.depositRequestsStartIndex,
+		DepositReceiptsStartIndex:           b.depositReceiptsStartIndex,
 		DepositBalanceToConsume:             b.depositBalanceToConsume,
 		ExitBalanceToConsume:                b.exitBalanceToConsume,
 		EarliestExitEpoch:                   b.earliestExitEpoch,

beacon-chain/state/state-native/beacon_state_minimal.go

@@ -62,7 +62,7 @@ type BeaconState struct {
 	nextWithdrawalValidatorIndex        primitives.ValidatorIndex
 
 	// Electra fields
-	depositRequestsStartIndex     uint64
+	depositReceiptsStartIndex     uint64
 	depositBalanceToConsume       primitives.Gwei
 	exitBalanceToConsume          primitives.Gwei
 	earliestExitEpoch             primitives.Epoch
@@ -119,7 +119,7 @@ type beaconStateMarshalable struct {
 	LatestExecutionPayloadHeaderElectra *enginev1.ExecutionPayloadHeaderElectra `json:"latest_execution_payload_header_electra" yaml:"latest_execution_payload_header_electra"`
 	NextWithdrawalIndex                 uint64                                  `json:"next_withdrawal_index" yaml:"next_withdrawal_index"`
 	NextWithdrawalValidatorIndex        primitives.ValidatorIndex               `json:"next_withdrawal_validator_index" yaml:"next_withdrawal_validator_index"`
-	DepositRequestsStartIndex           uint64                                  `json:"deposit_requests_start_index" yaml:"deposit_requests_start_index"`
+	DepositReceiptsStartIndex           uint64                                  `json:"deposit_receipts_start_index" yaml:"deposit_receipts_start_index"`
 	DepositBalanceToConsume             primitives.Gwei                         `json:"deposit_balance_to_consume" yaml:"deposit_balance_to_consume"`
 	ExitBalanceToConsume                primitives.Gwei                         `json:"exit_balance_to_consume" yaml:"exit_balance_to_consume"`
 	EarliestExitEpoch                   primitives.Epoch                        `json:"earliest_exit_epoch" yaml:"earliest_exit_epoch"`
@@ -189,7 +189,7 @@ func (b *BeaconState) MarshalJSON() ([]byte, error) {
 		LatestExecutionPayloadHeaderElectra: b.latestExecutionPayloadHeaderElectra,
 		NextWithdrawalIndex:                 b.nextWithdrawalIndex,
 		NextWithdrawalValidatorIndex:        b.nextWithdrawalValidatorIndex,
-		DepositRequestsStartIndex:           b.depositRequestsStartIndex,
+		DepositReceiptsStartIndex:           b.depositReceiptsStartIndex,
 		DepositBalanceToConsume:             b.depositBalanceToConsume,
 		ExitBalanceToConsume:                b.exitBalanceToConsume,
 		EarliestExitEpoch:                   b.earliestExitEpoch,

beacon-chain/state/state-native/getters_deposit_receipts.go

@@ -0,0 +1,16 @@
+package state_native
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+// DepositReceiptsStartIndex is used for returning the deposit receipts start index which is used for eip6110
+func (b *BeaconState) DepositReceiptsStartIndex() (uint64, error) {
+	if b.version < version.Electra {
+		return 0, errNotSupported("DepositReceiptsStartIndex", b.version)
+	}
+	b.lock.RLock()
+	defer b.lock.RUnlock()
+
+	return b.depositReceiptsStartIndex, nil
+}

beacon-chain/state/state-native/getters_deposit_receipts_test.go

@@ -9,17 +9,17 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestDepositRequestsStartIndex(t *testing.T) {
+func TestDepositReceiptsStartIndex(t *testing.T) {
 	t.Run("previous fork returns expected error", func(t *testing.T) {
 		dState, _ := util.DeterministicGenesisState(t, 1)
-		_, err := dState.DepositRequestsStartIndex()
+		_, err := dState.DepositReceiptsStartIndex()
 		require.ErrorContains(t, "is not supported", err)
 	})
 	t.Run("electra returns expected value", func(t *testing.T) {
 		want := uint64(2)
-		dState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{DepositRequestsStartIndex: want})
+		dState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{DepositReceiptsStartIndex: want})
 		require.NoError(t, err)
-		got, err := dState.DepositRequestsStartIndex()
+		got, err := dState.DepositReceiptsStartIndex()
 		require.NoError(t, err)
 		require.Equal(t, want, got)
 	})

beacon-chain/state/state-native/getters_deposit_requests.go

@@ -1,16 +0,0 @@
-package state_native
-
-import (
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-)
-
-// DepositRequestsStartIndex is used for returning the deposit receipts start index which is used for eip6110
-func (b *BeaconState) DepositRequestsStartIndex() (uint64, error) {
-	if b.version < version.Electra {
-		return 0, errNotSupported("DepositRequestsStartIndex", b.version)
-	}
-	b.lock.RLock()
-	defer b.lock.RUnlock()
-
-	return b.depositRequestsStartIndex, nil
-}

beacon-chain/state/state-native/getters_state.go

@@ -202,7 +202,7 @@ func (b *BeaconState) ToProtoUnsafe() interface{} {
 			NextWithdrawalIndex:           b.nextWithdrawalIndex,
 			NextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
 			HistoricalSummaries:           b.historicalSummaries,
-			DepositRequestsStartIndex:     b.depositRequestsStartIndex,
+			DepositReceiptsStartIndex:     b.depositReceiptsStartIndex,
 			DepositBalanceToConsume:       b.depositBalanceToConsume,
 			ExitBalanceToConsume:          b.exitBalanceToConsume,
 			EarliestExitEpoch:             b.earliestExitEpoch,
@@ -408,7 +408,7 @@ func (b *BeaconState) ToProto() interface{} {
 			NextWithdrawalIndex:           b.nextWithdrawalIndex,
 			NextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
 			HistoricalSummaries:           b.historicalSummariesVal(),
-			DepositRequestsStartIndex:     b.depositRequestsStartIndex,
+			DepositReceiptsStartIndex:     b.depositReceiptsStartIndex,
 			DepositBalanceToConsume:       b.depositBalanceToConsume,
 			ExitBalanceToConsume:          b.exitBalanceToConsume,
 			EarliestExitEpoch:             b.earliestExitEpoch,

beacon-chain/state/state-native/hasher.go

@@ -281,9 +281,9 @@ func ComputeFieldRootsWithHasher(ctx context.Context, state *BeaconState) ([][]b
 	}
 
 	if state.version >= version.Electra {
-		// DepositRequestsStartIndex root.
-		drsiRoot := ssz.Uint64Root(state.depositRequestsStartIndex)
-		fieldRoots[types.DepositRequestsStartIndex.RealPosition()] = drsiRoot[:]
+		// DepositReceiptsStartIndex root.
+		drsiRoot := ssz.Uint64Root(state.depositReceiptsStartIndex)
+		fieldRoots[types.DepositReceiptsStartIndex.RealPosition()] = drsiRoot[:]
 
 		// DepositBalanceToConsume root.
 		dbtcRoot := ssz.Uint64Root(uint64(state.depositBalanceToConsume))

beacon-chain/state/state-native/setters_deposit_receipts.go

@@ -0,0 +1,21 @@
+package state_native
+
+import (
+	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native/types"
+	"github.com/prysmaticlabs/prysm/v5/runtime/version"
+)
+
+// SetDepositReceiptsStartIndex for the beacon state. Updates the DepositReceiptsStartIndex
+func (b *BeaconState) SetDepositReceiptsStartIndex(index uint64) error {
+	if b.version < version.Electra {
+		return errNotSupported("SetDepositReceiptsStartIndex", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.depositReceiptsStartIndex = index
+	b.markFieldAsDirty(types.DepositReceiptsStartIndex)
+	b.rebuildTrie[types.DepositReceiptsStartIndex] = true
+	return nil
+}

beacon-chain/state/state-native/setters_deposit_receipts_test.go

@@ -9,18 +9,18 @@ import (
 	"github.com/prysmaticlabs/prysm/v5/testing/util"
 )
 
-func TestSetDepositRequestsStartIndex(t *testing.T) {
+func TestSetDepositReceiptsStartIndex(t *testing.T) {
 	t.Run("previous fork returns expected error", func(t *testing.T) {
 		dState, _ := util.DeterministicGenesisState(t, 1)
-		require.ErrorContains(t, "is not supported", dState.SetDepositRequestsStartIndex(1))
+		require.ErrorContains(t, "is not supported", dState.SetDepositReceiptsStartIndex(1))
 	})
 	t.Run("electra sets expected value", func(t *testing.T) {
 		old := uint64(2)
-		dState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{DepositRequestsStartIndex: old})
+		dState, err := state_native.InitializeFromProtoElectra(&ethpb.BeaconStateElectra{DepositReceiptsStartIndex: old})
 		require.NoError(t, err)
 		want := uint64(3)
-		require.NoError(t, dState.SetDepositRequestsStartIndex(want))
-		got, err := dState.DepositRequestsStartIndex()
+		require.NoError(t, dState.SetDepositReceiptsStartIndex(want))
+		got, err := dState.DepositReceiptsStartIndex()
 		require.NoError(t, err)
 		require.Equal(t, want, got)
 	})

beacon-chain/state/state-native/setters_deposit_requests.go

@@ -1,21 +0,0 @@
-package state_native
-
-import (
-	"github.com/prysmaticlabs/prysm/v5/beacon-chain/state/state-native/types"
-	"github.com/prysmaticlabs/prysm/v5/runtime/version"
-)
-
-// SetDepositRequestsStartIndex for the beacon state. Updates the DepositRequestsStartIndex
-func (b *BeaconState) SetDepositRequestsStartIndex(index uint64) error {
-	if b.version < version.Electra {
-		return errNotSupported("SetDepositRequestsStartIndex", b.version)
-	}
-
-	b.lock.Lock()
-	defer b.lock.Unlock()
-
-	b.depositRequestsStartIndex = index
-	b.markFieldAsDirty(types.DepositRequestsStartIndex)
-	b.rebuildTrie[types.DepositRequestsStartIndex] = true
-	return nil
-}

beacon-chain/state/state-native/state_trie.go

@@ -100,7 +100,7 @@ var electraFields = append(
 	types.NextWithdrawalValidatorIndex,
 	types.HistoricalSummaries,
 	types.LatestExecutionPayloadHeaderElectra,
-	types.DepositRequestsStartIndex,
+	types.DepositReceiptsStartIndex,
 	types.DepositBalanceToConsume,
 	types.ExitBalanceToConsume,
 	types.EarliestExitEpoch,
@@ -744,7 +744,7 @@ func InitializeFromProtoUnsafeElectra(st *ethpb.BeaconStateElectra) (state.Beaco
 		nextWithdrawalIndex:                 st.NextWithdrawalIndex,
 		nextWithdrawalValidatorIndex:        st.NextWithdrawalValidatorIndex,
 		historicalSummaries:                 st.HistoricalSummaries,
-		depositRequestsStartIndex:           st.DepositRequestsStartIndex,
+		depositReceiptsStartIndex:           st.DepositReceiptsStartIndex,
 		depositBalanceToConsume:             st.DepositBalanceToConsume,
 		exitBalanceToConsume:                st.ExitBalanceToConsume,
 		earliestExitEpoch:                   st.EarliestExitEpoch,
@@ -862,7 +862,7 @@ func (b *BeaconState) Copy() state.BeaconState {
 		eth1DepositIndex:              b.eth1DepositIndex,
 		nextWithdrawalIndex:           b.nextWithdrawalIndex,
 		nextWithdrawalValidatorIndex:  b.nextWithdrawalValidatorIndex,
-		depositRequestsStartIndex:     b.depositRequestsStartIndex,
+		depositReceiptsStartIndex:     b.depositReceiptsStartIndex,
 		depositBalanceToConsume:       b.depositBalanceToConsume,
 		exitBalanceToConsume:          b.exitBalanceToConsume,
 		earliestExitEpoch:             b.earliestExitEpoch,
@@ -1286,8 +1286,8 @@ func (b *BeaconState) rootSelector(ctx context.Context, field types.FieldIndex)
 		return ssz.Uint64Root(uint64(b.nextWithdrawalValidatorIndex)), nil
 	case types.HistoricalSummaries:
 		return stateutil.HistoricalSummariesRoot(b.historicalSummaries)
-	case types.DepositRequestsStartIndex:
-		return ssz.Uint64Root(b.depositRequestsStartIndex), nil
+	case types.DepositReceiptsStartIndex:
+		return ssz.Uint64Root(b.depositReceiptsStartIndex), nil
 	case types.DepositBalanceToConsume:
 		return ssz.Uint64Root(uint64(b.depositBalanceToConsume)), nil
 	case types.ExitBalanceToConsume:

beacon-chain/state/state-native/types/types.go

@@ -96,8 +96,8 @@ func (f FieldIndex) String() string {
 		return "nextWithdrawalValidatorIndex"
 	case HistoricalSummaries:
 		return "historicalSummaries"
-	case DepositRequestsStartIndex:
-		return "depositRequestsStartIndex"
+	case DepositReceiptsStartIndex:
+		return "depositReceiptsStartIndex"
 	case DepositBalanceToConsume:
 		return "depositBalanceToConsume"
 	case ExitBalanceToConsume:
@@ -179,7 +179,7 @@ func (f FieldIndex) RealPosition() int {
 		return 26
 	case HistoricalSummaries:
 		return 27
-	case DepositRequestsStartIndex:
+	case DepositReceiptsStartIndex:
 		return 28
 	case DepositBalanceToConsume:
 		return 29
@@ -253,7 +253,7 @@ const (
 	NextWithdrawalIndex
 	NextWithdrawalValidatorIndex
 	HistoricalSummaries
-	DepositRequestsStartIndex     // Electra: EIP-6110
+	DepositReceiptsStartIndex     // Electra: EIP-6110
 	DepositBalanceToConsume       // Electra: EIP-7251
 	ExitBalanceToConsume          // Electra: EIP-7251
 	EarliestExitEpoch             // Electra: EIP-7251

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",
@@ -52,7 +47,6 @@ go_library(
         "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 +63,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 +71,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 +150,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",
@@ -201,14 +191,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 +241,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)
-}