Save and Read State Diff Functions (#15438)

* bucket | configs | flag | cache

* save and read state diff

* remove named mutex

* remove named mutex

* save and read state diff

* fix linter

* set offset while creating cache

* save and read state diff

* fix linter

* rebase

* fix tests

* Update beacon-chain/db/kv/state_diff_helpers.go

Co-authored-by: Potuz <potuz@prysmaticlabs.com>

* adjustments to key

* remove lvl parameter when it's 0

* use named suffixes

---------

Co-authored-by: Potuz <potuz@prysmaticlabs.com>

api/client/beacon/BUILD.bazel

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

api/client/beacon/client.go

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

api/server/structs/endpoints_node.go

@@ -25,10 +25,8 @@ type Identity struct {
 }
 
 type Metadata struct {
-	SeqNumber         string `json:"seq_number"`
-	Attnets           string `json:"attnets"`
-	Syncnets          string `json:"syncnets"`
-	CustodyGroupCount string `json:"custody_group_count"`
+	SeqNumber string `json:"seq_number"`
+	Attnets   string `json:"attnets"`
 }
 
 type GetPeerResponse struct {

beacon-chain/blockchain/service.go

@@ -31,7 +31,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/stategen"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -111,26 +110,22 @@ var ErrMissingClockSetter = errors.New("blockchain Service initialized without a
 type blobNotifierMap struct {
 	sync.RWMutex
 	notifiers map[[32]byte]chan uint64
-	// TODO: Separate blobs from data columns
-	// seenIndex map[[32]byte][]bool
-	seenIndex map[[32]byte][fieldparams.NumberOfColumns]bool
+	seenIndex map[[32]byte][]bool
 }
 
 // notifyIndex notifies a blob by its index for a given root.
 // It uses internal maps to keep track of seen indices and notifier channels.
 func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitives.Slot) {
-	// TODO: Separate blobs from data columns
-	// maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
-	// if idx >= uint64(maxBlobsPerBlock) {
-	// 	return
-	// }
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	if idx >= uint64(maxBlobsPerBlock) {
+		return
+	}
 
 	bn.Lock()
 	seen := bn.seenIndex[root]
-	// TODO: Separate blobs from data columns
-	// if seen == nil {
-	// seen = make([]bool, maxBlobsPerBlock)
-	// }
+	if seen == nil {
+		seen = make([]bool, maxBlobsPerBlock)
+	}
 	if seen[idx] {
 		bn.Unlock()
 		return
@@ -141,9 +136,7 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 	// Retrieve or create the notifier channel for the given root.
 	c, ok := bn.notifiers[root]
 	if !ok {
-		// TODO: Separate blobs from data columns
-		// c = make(chan uint64, maxBlobsPerBlock)
-		c = make(chan uint64, fieldparams.NumberOfColumns)
+		c = make(chan uint64, maxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 
@@ -153,15 +146,12 @@ func (bn *blobNotifierMap) notifyIndex(root [32]byte, idx uint64, slot primitive
 }
 
 func (bn *blobNotifierMap) forRoot(root [32]byte, slot primitives.Slot) chan uint64 {
-	// TODO: Separate blobs from data columns
-	// maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
+	maxBlobsPerBlock := params.BeaconConfig().MaxBlobsPerBlock(slot)
 	bn.Lock()
 	defer bn.Unlock()
 	c, ok := bn.notifiers[root]
 	if !ok {
-		// TODO: Separate blobs from data columns
-		// c = make(chan uint64, maxBlobsPerBlock)
-		c = make(chan uint64, fieldparams.NumberOfColumns)
+		c = make(chan uint64, maxBlobsPerBlock)
 		bn.notifiers[root] = c
 	}
 	return c
@@ -187,9 +177,7 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 	ctx, cancel := context.WithCancel(ctx)
 	bn := &blobNotifierMap{
 		notifiers: make(map[[32]byte]chan uint64),
-		// TODO: Separate blobs from data columns
-		// seenIndex: make(map[[32]byte][]bool),
-		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
+		seenIndex: make(map[[32]byte][]bool),
 	}
 	srv := &Service{
 		ctx:                  ctx,

beacon-chain/blockchain/service_test.go

@@ -587,9 +587,7 @@ func (s *MockClockSetter) SetClock(g *startup.Clock) error {
 func TestNotifyIndex(t *testing.T) {
 	// Initialize a blobNotifierMap
 	bn := &blobNotifierMap{
-		// TODO: Separate blobs from data columns
-		// seenIndex: make(map[[32]byte][]bool),
-		seenIndex: make(map[[32]byte][fieldparams.NumberOfColumns]bool),
+		seenIndex: make(map[[32]byte][]bool),
 		notifiers: make(map[[32]byte]chan uint64),
 	}
 

beacon-chain/core/altair/upgrade.go

@@ -12,6 +12,47 @@ import (
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/attestation"
 )
 
+// ConvertToAltair converts a Phase 0 beacon state to an Altair beacon state.
+func ConvertToAltair(state state.BeaconState) (state.BeaconState, error) {
+	epoch := time.CurrentEpoch(state)
+
+	numValidators := state.NumValidators()
+	s := &ethpb.BeaconStateAltair{
+		GenesisTime:           state.GenesisTime(),
+		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
+		Slot:                  state.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: state.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().AltairForkVersion,
+			Epoch:           epoch,
+		},
+		LatestBlockHeader:           state.LatestBlockHeader(),
+		BlockRoots:                  state.BlockRoots(),
+		StateRoots:                  state.StateRoots(),
+		HistoricalRoots:             state.HistoricalRoots(),
+		Eth1Data:                    state.Eth1Data(),
+		Eth1DataVotes:               state.Eth1DataVotes(),
+		Eth1DepositIndex:            state.Eth1DepositIndex(),
+		Validators:                  state.Validators(),
+		Balances:                    state.Balances(),
+		RandaoMixes:                 state.RandaoMixes(),
+		Slashings:                   state.Slashings(),
+		PreviousEpochParticipation:  make([]byte, numValidators),
+		CurrentEpochParticipation:   make([]byte, numValidators),
+		JustificationBits:           state.JustificationBits(),
+		PreviousJustifiedCheckpoint: state.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:  state.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:         state.FinalizedCheckpoint(),
+		InactivityScores:            make([]uint64, numValidators),
+	}
+
+	newState, err := state_native.InitializeFromProtoUnsafeAltair(s)
+	if err != nil {
+		return nil, err
+	}
+	return newState, nil
+}
+
 // UpgradeToAltair updates input state to return the version Altair state.
 //
 // Spec code:
@@ -64,39 +105,7 @@ import (
 //	post.next_sync_committee = get_next_sync_committee(post)
 //	return post
 func UpgradeToAltair(ctx context.Context, state state.BeaconState) (state.BeaconState, error) {
-	epoch := time.CurrentEpoch(state)
-
-	numValidators := state.NumValidators()
-	s := &ethpb.BeaconStateAltair{
-		GenesisTime:           state.GenesisTime(),
-		GenesisValidatorsRoot: state.GenesisValidatorsRoot(),
-		Slot:                  state.Slot(),
-		Fork: &ethpb.Fork{
-			PreviousVersion: state.Fork().CurrentVersion,
-			CurrentVersion:  params.BeaconConfig().AltairForkVersion,
-			Epoch:           epoch,
-		},
-		LatestBlockHeader:           state.LatestBlockHeader(),
-		BlockRoots:                  state.BlockRoots(),
-		StateRoots:                  state.StateRoots(),
-		HistoricalRoots:             state.HistoricalRoots(),
-		Eth1Data:                    state.Eth1Data(),
-		Eth1DataVotes:               state.Eth1DataVotes(),
-		Eth1DepositIndex:            state.Eth1DepositIndex(),
-		Validators:                  state.Validators(),
-		Balances:                    state.Balances(),
-		RandaoMixes:                 state.RandaoMixes(),
-		Slashings:                   state.Slashings(),
-		PreviousEpochParticipation:  make([]byte, numValidators),
-		CurrentEpochParticipation:   make([]byte, numValidators),
-		JustificationBits:           state.JustificationBits(),
-		PreviousJustifiedCheckpoint: state.PreviousJustifiedCheckpoint(),
-		CurrentJustifiedCheckpoint:  state.CurrentJustifiedCheckpoint(),
-		FinalizedCheckpoint:         state.FinalizedCheckpoint(),
-		InactivityScores:            make([]uint64, numValidators),
-	}
-
-	newState, err := state_native.InitializeFromProtoUnsafeAltair(s)
+	newState, err := ConvertToAltair(state)
 	if err != nil {
 		return nil, err
 	}

beacon-chain/core/blocks/BUILD.bazel

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

beacon-chain/core/blocks/signature.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/crypto/bls"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1/attestation"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -95,30 +96,12 @@ 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 := params.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.
 func VerifyBlockSignatureUsingCurrentFork(beaconState state.ReadOnlyBeaconState, blk interfaces.ReadOnlySignedBeaconBlock, blkRoot [32]byte) error {
 	currentEpoch := slots.ToEpoch(blk.Block().Slot())
-	fork, err := params.Fork(currentEpoch)
+	fork, err := forks.Fork(currentEpoch)
 	if err != nil {
 		return err
 	}

beacon-chain/core/electra/upgrade.go

@@ -15,6 +15,129 @@ import (
 	"github.com/pkg/errors"
 )
 
+// ConvertToElectra converts a Deneb beacon state to an Electra beacon state.
+func ConvertToElectra(beaconState state.BeaconState) (state.BeaconState, error) {
+	currentSyncCommittee, err := beaconState.CurrentSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	nextSyncCommittee, err := beaconState.NextSyncCommittee()
+	if err != nil {
+		return nil, err
+	}
+	prevEpochParticipation, err := beaconState.PreviousEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	currentEpochParticipation, err := beaconState.CurrentEpochParticipation()
+	if err != nil {
+		return nil, err
+	}
+	inactivityScores, err := beaconState.InactivityScores()
+	if err != nil {
+		return nil, err
+	}
+	payloadHeader, err := beaconState.LatestExecutionPayloadHeader()
+	if err != nil {
+		return nil, err
+	}
+	txRoot, err := payloadHeader.TransactionsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wdRoot, err := payloadHeader.WithdrawalsRoot()
+	if err != nil {
+		return nil, err
+	}
+	wi, err := beaconState.NextWithdrawalIndex()
+	if err != nil {
+		return nil, err
+	}
+	vi, err := beaconState.NextWithdrawalValidatorIndex()
+	if err != nil {
+		return nil, err
+	}
+	summaries, err := beaconState.HistoricalSummaries()
+	if err != nil {
+		return nil, err
+	}
+	excessBlobGas, err := payloadHeader.ExcessBlobGas()
+	if err != nil {
+		return nil, err
+	}
+	blobGasUsed, err := payloadHeader.BlobGasUsed()
+	if err != nil {
+		return nil, err
+	}
+
+	s := &ethpb.BeaconStateElectra{
+		GenesisTime:           beaconState.GenesisTime(),
+		GenesisValidatorsRoot: beaconState.GenesisValidatorsRoot(),
+		Slot:                  beaconState.Slot(),
+		Fork: &ethpb.Fork{
+			PreviousVersion: beaconState.Fork().CurrentVersion,
+			CurrentVersion:  params.BeaconConfig().ElectraForkVersion,
+			Epoch:           time.CurrentEpoch(beaconState),
+		},
+		LatestBlockHeader:           beaconState.LatestBlockHeader(),
+		BlockRoots:                  beaconState.BlockRoots(),
+		StateRoots:                  beaconState.StateRoots(),
+		HistoricalRoots:             beaconState.HistoricalRoots(),
+		Eth1Data:                    beaconState.Eth1Data(),
+		Eth1DataVotes:               beaconState.Eth1DataVotes(),
+		Eth1DepositIndex:            beaconState.Eth1DepositIndex(),
+		Validators:                  beaconState.Validators(),
+		Balances:                    beaconState.Balances(),
+		RandaoMixes:                 beaconState.RandaoMixes(),
+		Slashings:                   beaconState.Slashings(),
+		PreviousEpochParticipation:  prevEpochParticipation,
+		CurrentEpochParticipation:   currentEpochParticipation,
+		JustificationBits:           beaconState.JustificationBits(),
+		PreviousJustifiedCheckpoint: beaconState.PreviousJustifiedCheckpoint(),
+		CurrentJustifiedCheckpoint:  beaconState.CurrentJustifiedCheckpoint(),
+		FinalizedCheckpoint:         beaconState.FinalizedCheckpoint(),
+		InactivityScores:            inactivityScores,
+		CurrentSyncCommittee:        currentSyncCommittee,
+		NextSyncCommittee:           nextSyncCommittee,
+		LatestExecutionPayloadHeader: &enginev1.ExecutionPayloadHeaderDeneb{
+			ParentHash:       payloadHeader.ParentHash(),
+			FeeRecipient:     payloadHeader.FeeRecipient(),
+			StateRoot:        payloadHeader.StateRoot(),
+			ReceiptsRoot:     payloadHeader.ReceiptsRoot(),
+			LogsBloom:        payloadHeader.LogsBloom(),
+			PrevRandao:       payloadHeader.PrevRandao(),
+			BlockNumber:      payloadHeader.BlockNumber(),
+			GasLimit:         payloadHeader.GasLimit(),
+			GasUsed:          payloadHeader.GasUsed(),
+			Timestamp:        payloadHeader.Timestamp(),
+			ExtraData:        payloadHeader.ExtraData(),
+			BaseFeePerGas:    payloadHeader.BaseFeePerGas(),
+			BlockHash:        payloadHeader.BlockHash(),
+			TransactionsRoot: txRoot,
+			WithdrawalsRoot:  wdRoot,
+			ExcessBlobGas:    excessBlobGas,
+			BlobGasUsed:      blobGasUsed,
+		},
+		NextWithdrawalIndex:          wi,
+		NextWithdrawalValidatorIndex: vi,
+		HistoricalSummaries:          summaries,
+
+		DepositRequestsStartIndex:  params.BeaconConfig().UnsetDepositRequestsStartIndex,
+		DepositBalanceToConsume:    0,
+		EarliestConsolidationEpoch: helpers.ActivationExitEpoch(slots.ToEpoch(beaconState.Slot())),
+		PendingDeposits:            make([]*ethpb.PendingDeposit, 0),
+		PendingPartialWithdrawals:  make([]*ethpb.PendingPartialWithdrawal, 0),
+		PendingConsolidations:      make([]*ethpb.PendingConsolidation, 0),
+	}
+
+	// need to cast the beaconState to use in helper functions
+	post, err := state_native.InitializeFromProtoUnsafeElectra(s)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to initialize post electra beaconState")
+	}
+	return post, nil
+}
+
 // UpgradeToElectra updates inputs a generic state to return the version Electra state.
 //
 // nolint:dupword

beacon-chain/core/execution/BUILD.bazel

@@ -7,6 +7,7 @@ go_library(
     visibility = [
         "//beacon-chain:__subpackages__",
         "//cmd/prysmctl/testnet:__pkg__",
+        "//consensus-types/hdiff:__subpackages__",
         "//testing/spectest:__subpackages__",
         "//validator/client:__pkg__",
     ],

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

@@ -38,14 +38,11 @@ const (
 	// SingleAttReceived is sent after a single attestation object is received from gossip or rpc
 	SingleAttReceived = 9
 
-	// DataColumnSidecarReceived is sent after a data column sidecar is received from gossip or rpc.
-	DataColumnSidecarReceived = 10
-
 	// BlockGossipReceived is sent after a block has been received from gossip or API that passes validation rules.
-	BlockGossipReceived = 11
+	BlockGossipReceived = 10
 
 	// DataColumnReceived is sent after a data column has been seen after gossip validation rules.
-	DataColumnReceived = 12
+	DataColumnReceived = 11
 )
 
 // UnAggregatedAttReceivedData is the data sent with UnaggregatedAttReceived events.
@@ -97,11 +94,6 @@ type SingleAttReceivedData struct {
 	Attestation ethpb.Att
 }
 
-// DataColumnSidecarReceivedData is the data sent with DataColumnSidecarReceived events.
-type DataColumnSidecarReceivedData struct {
-	DataColumn *blocks.VerifiedRODataColumn
-}
-
 // BlockGossipReceivedData is the data sent with BlockGossipReceived events.
 type BlockGossipReceivedData struct {
 	// SignedBlock is the block that was received.

beacon-chain/core/helpers/beacon_committee.go

@@ -669,11 +669,11 @@ func ComputeCommittee(
 // InitializeProposerLookahead computes the list of the proposer indices for the next MIN_SEED_LOOKAHEAD + 1 epochs.
 func InitializeProposerLookahead(ctx context.Context, state state.ReadOnlyBeaconState, epoch primitives.Epoch) ([]uint64, error) {
 	lookAhead := make([]uint64, 0, uint64(params.BeaconConfig().MinSeedLookahead+1)*uint64(params.BeaconConfig().SlotsPerEpoch))
+	indices, err := ActiveValidatorIndices(ctx, state, epoch)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not get active indices")
+	}
 	for i := range params.BeaconConfig().MinSeedLookahead + 1 {
-		indices, err := ActiveValidatorIndices(ctx, state, epoch+i)
-		if err != nil {
-			return nil, errors.Wrap(err, "could not get active indices")
-		}
 		proposerIndices, err := PrecomputeProposerIndices(state, indices, epoch+i)
 		if err != nil {
 			return nil, errors.Wrap(err, "could not compute proposer indices")

beacon-chain/core/helpers/sync_committee_test.go

@@ -78,7 +78,6 @@ func TestIsCurrentEpochSyncCommittee_UsingCommittee(t *testing.T) {
 
 func TestIsCurrentEpochSyncCommittee_DoesNotExist(t *testing.T) {
 	helpers.ClearCache()
-	params.SetupTestConfigCleanup(t)
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)
 	syncCommittee := &ethpb.SyncCommittee{
@@ -265,7 +264,6 @@ func TestCurrentEpochSyncSubcommitteeIndices_UsingCommittee(t *testing.T) {
 }
 
 func TestCurrentEpochSyncSubcommitteeIndices_DoesNotExist(t *testing.T) {
-	params.SetupTestConfigCleanup(t)
 	helpers.ClearCache()
 
 	validators := make([]*ethpb.Validator, params.BeaconConfig().SyncCommitteeSize)

beacon-chain/core/peerdas/BUILD.bazel

@@ -7,7 +7,6 @@ go_library(
         "info.go",
         "metrics.go",
         "p2p_interface.go",
-        "peer_sampling.go",
         "reconstruction.go",
         "validator.go",
         "verification.go",
@@ -45,7 +44,6 @@ go_test(
         "das_core_test.go",
         "info_test.go",
         "p2p_interface_test.go",
-        "peer_sampling_test.go",
         "reconstruction_test.go",
         "utils_test.go",
         "validator_test.go",

beacon-chain/core/peerdas/p2p_interface.go

@@ -10,7 +10,10 @@ import (
 	"github.com/pkg/errors"
 )
 
-const kzgPosition = 11 // The index of the KZG commitment list in the Body
+const (
+	CustodyGroupCountEnrKey = "cgc"
+	kzgPosition             = 11 // The index of the KZG commitment list in the Body
+)
 
 var (
 	ErrIndexTooLarge               = errors.New("column index is larger than the specified columns count")
@@ -27,7 +30,7 @@ var (
 // https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#custody-group-count
 type Cgc uint64
 
-func (Cgc) ENRKey() string { return params.BeaconNetworkConfig().CustodyGroupCountKey }
+func (Cgc) ENRKey() string { return CustodyGroupCountEnrKey }
 
 // VerifyDataColumnSidecar verifies if the data column sidecar is valid.
 // https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/p2p-interface.md#verify_data_column_sidecar

beacon-chain/core/peerdas/peer_sampling.go

@@ -1,56 +0,0 @@
-package peerdas
-
-import (
-	"math/big"
-
-	"github.com/OffchainLabs/prysm/v6/config/params"
-)
-
-// ExtendedSampleCount computes, for a given number of samples per slot and allowed failures the
-// number of samples we should actually query from peers.
-// https://github.com/ethereum/consensus-specs/blob/v1.5.0-beta.5/specs/fulu/peer-sampling.md#get_extended_sample_count
-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
-}
-
-// 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
-}

beacon-chain/core/peerdas/peer_sampling_test.go

@@ -1,60 +0,0 @@
-package peerdas_test
-
-import (
-	"testing"
-
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
-	"github.com/OffchainLabs/prysm/v6/testing/require"
-)
-
-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)
-		})
-	}
-}
-
-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)
-}

beacon-chain/core/signing/BUILD.bazel

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

beacon-chain/core/signing/signature.go

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

beacon-chain/core/signing/signature_test.go

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

beacon-chain/core/time/slot_epoch.go

@@ -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.FuluEnabled() && slots.ToEpoch(slot) >= params.BeaconConfig().FuluForkEpoch
-}
-
 // 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/db/BUILD.bazel

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

beacon-chain/db/kv/BUILD.bazel

@@ -25,6 +25,9 @@ go_library(
         "migration_state_validators.go",
         "schema.go",
         "state.go",
+        "state_diff.go",
+        "state_diff_cache.go",
+        "state_diff_helpers.go",
         "state_summary.go",
         "state_summary_cache.go",
         "utils.go",
@@ -38,19 +41,21 @@ go_library(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
+        "//consensus-types/hdiff:go_default_library",
         "//consensus-types/interfaces:go_default_library",
         "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//container/slice:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//encoding/ssz/detect:go_default_library",
-        "//genesis:go_default_library",
         "//io/file:go_default_library",
+        "//math:go_default_library",
         "//monitoring/progress:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
@@ -94,6 +99,7 @@ go_test(
         "migration_archived_index_test.go",
         "migration_block_slot_index_test.go",
         "migration_state_validators_test.go",
+        "state_diff_test.go",
         "state_summary_test.go",
         "state_test.go",
         "utils_test.go",
@@ -106,6 +112,7 @@ go_test(
         "//beacon-chain/db/filters:go_default_library",
         "//beacon-chain/db/iface:go_default_library",
         "//beacon-chain/state:go_default_library",
+        "//beacon-chain/state/genesis:go_default_library",
         "//beacon-chain/state/state-native:go_default_library",
         "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
@@ -115,7 +122,7 @@ go_test(
         "//consensus-types/light-client:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
-        "//genesis/embedded:go_default_library",
+        "//math:go_default_library",
         "//proto/dbval:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",

beacon-chain/db/kv/genesis.go

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

beacon-chain/db/kv/kv.go

@@ -91,6 +91,7 @@ type Store struct {
 	blockCache          *ristretto.Cache[string, interfaces.ReadOnlySignedBeaconBlock]
 	validatorEntryCache *ristretto.Cache[[]byte, *ethpb.Validator]
 	stateSummaryCache   *stateSummaryCache
+	stateDiffCache      *stateDiffCache
 	ctx                 context.Context
 }
 
@@ -112,6 +113,7 @@ var Buckets = [][]byte{
 	lightClientUpdatesBucket,
 	lightClientBootstrapBucket,
 	lightClientSyncCommitteeBucket,
+	stateDiffBucket,
 	// Indices buckets.
 	blockSlotIndicesBucket,
 	stateSlotIndicesBucket,
@@ -182,6 +184,7 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		blockCache:          blockCache,
 		validatorEntryCache: validatorCache,
 		stateSummaryCache:   newStateSummaryCache(),
+		stateDiffCache:      nil,
 		ctx:                 ctx,
 	}
 	for _, o := range opts {
@@ -200,6 +203,14 @@ func NewKVStore(ctx context.Context, dirPath string, opts ...KVStoreOption) (*St
 		return nil, err
 	}
 
+	if features.Get().EnableStateDiff {
+		sdCache, err := newStateDiffCache(kv)
+		if err != nil {
+			return nil, err
+		}
+		kv.stateDiffCache = sdCache
+	}
+
 	return kv, nil
 }
 

beacon-chain/db/kv/schema.go

@@ -16,6 +16,7 @@ var (
 	stateValidatorsBucket = []byte("state-validators")
 	feeRecipientBucket    = []byte("fee-recipient")
 	registrationBucket    = []byte("registration")
+	stateDiffBucket       = []byte("state-diff")
 
 	// Light Client Updates Bucket
 	lightClientUpdatesBucket       = []byte("light-client-updates")

beacon-chain/db/kv/state.go

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

beacon-chain/db/kv/state_diff.go

@@ -0,0 +1,232 @@
+package kv
+
+import (
+	"context"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/hdiff"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/pkg/errors"
+	bolt "go.etcd.io/bbolt"
+)
+
+const (
+	stateSuffix     = "_s"
+	validatorSuffix = "_v"
+	balancesSuffix  = "_b"
+)
+
+/*
+	We use a level-based approach to save state diffs. The levels are 0-6, where each level corresponds to an exponent of 2 (exponents[lvl]).
+	The data at level 0 is saved every 2**exponent[0] slots and always contains a full state snapshot that is used as a base for the delta saved at other levels.
+*/
+
+// saveStateByDiff takes a state and decides between saving a full state snapshot or a diff.
+func (s *Store) saveStateByDiff(ctx context.Context, st state.ReadOnlyBeaconState) error {
+	_, span := trace.StartSpan(ctx, "BeaconDB.saveStateByDiff")
+	defer span.End()
+
+	if st == nil {
+		return errors.New("state is nil")
+	}
+
+	slot := st.Slot()
+	offset := s.getOffset()
+	if uint64(slot) < offset {
+		return ErrSlotBeforeOffset
+	}
+
+	// Find the level to save the state.
+	lvl := computeLevel(offset, slot)
+	if lvl == -1 {
+		return nil
+	}
+
+	// Save full state if level is 0.
+	if lvl == 0 {
+		return s.saveFullSnapshot(st)
+	}
+
+	// Get anchor state to compute the diff from.
+	anchorState, err := s.getAnchorState(offset, lvl, slot)
+	if err != nil {
+		return err
+	}
+
+	err = s.saveHdiff(lvl, anchorState, st)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// stateByDiff retrieves the full state for a given slot.
+func (s *Store) stateByDiff(ctx context.Context, slot primitives.Slot) (state.BeaconState, error) {
+	offset := s.getOffset()
+	if uint64(slot) < offset {
+		return nil, ErrSlotBeforeOffset
+	}
+
+	snapshot, diffChain, err := s.getBaseAndDiffChain(offset, slot)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, diff := range diffChain {
+		snapshot, err = hdiff.ApplyDiff(ctx, snapshot, diff)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return snapshot, nil
+}
+
+// SaveHdiff computes the diff between the anchor state and the current state and saves it to the database.
+func (s *Store) saveHdiff(lvl int, anchor, st state.ReadOnlyBeaconState) error {
+	slot := uint64(st.Slot())
+	key := makeKey(lvl, slot)
+
+	diff, err := hdiff.Diff(anchor, st)
+	if err != nil {
+		return err
+	}
+
+	err = s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bolt.ErrBucketNotFound
+		}
+		buf := append(key, stateSuffix...)
+		if err := bucket.Put(buf, diff.StateDiff); err != nil {
+			return err
+		}
+		buf = append(key, validatorSuffix...)
+		if err := bucket.Put(buf, diff.ValidatorDiffs); err != nil {
+			return err
+		}
+		buf = append(key, balancesSuffix...)
+		if err := bucket.Put(buf, diff.BalancesDiff); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	// Save the full state to the cache (if not the last level).
+	if lvl != len(params.StateHierarchyExponents())-1 {
+		err = s.stateDiffCache.setAnchor(lvl, st)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// SaveFullSnapshot saves the full level 0 state snapshot to the database.
+func (s *Store) saveFullSnapshot(st state.ReadOnlyBeaconState) error {
+	slot := uint64(st.Slot())
+	key := makeKey(0, slot)
+	stateBytes, err := st.MarshalSSZ()
+	if err != nil {
+		return err
+	}
+	// add version key to value
+	enc, err := addKey(st.Version(), stateBytes)
+	if err != nil {
+		return err
+	}
+
+	err = s.db.Update(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bolt.ErrBucketNotFound
+		}
+
+		if err := bucket.Put(key, enc); err != nil {
+			return err
+		}
+
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	// Save the full state to the cache, and invalidate other levels.
+	s.stateDiffCache.clearAnchors()
+	err = s.stateDiffCache.setAnchor(0, st)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Store) getDiff(lvl int, slot uint64) (hdiff.HdiffBytes, error) {
+	key := makeKey(lvl, slot)
+	var stateDiff []byte
+	var validatorDiff []byte
+	var balancesDiff []byte
+
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bolt.ErrBucketNotFound
+		}
+		buf := append(key, stateSuffix...)
+		stateDiff = bucket.Get(buf)
+		if stateDiff == nil {
+			return errors.New("state diff not found")
+		}
+		buf = append(key, validatorSuffix...)
+		validatorDiff = bucket.Get(buf)
+		if validatorDiff == nil {
+			return errors.New("validator diff not found")
+		}
+		buf = append(key, balancesSuffix...)
+		balancesDiff = bucket.Get(buf)
+		if balancesDiff == nil {
+			return errors.New("balances diff not found")
+		}
+		return nil
+	})
+
+	if err != nil {
+		return hdiff.HdiffBytes{}, err
+	}
+
+	return hdiff.HdiffBytes{
+		StateDiff:      stateDiff,
+		ValidatorDiffs: validatorDiff,
+		BalancesDiff:   balancesDiff,
+	}, nil
+}
+
+func (s *Store) getFullSnapshot(slot uint64) (state.BeaconState, error) {
+	key := makeKey(0, slot)
+	var enc []byte
+
+	err := s.db.View(func(tx *bolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bolt.ErrBucketNotFound
+		}
+		enc = bucket.Get(key)
+		if enc == nil {
+			return errors.New("state not found")
+		}
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return s.decodeStateSnapshot(enc)
+}

beacon-chain/db/kv/state_diff_cache.go

@@ -0,0 +1,77 @@
+package kv
+
+import (
+	"encoding/binary"
+	"errors"
+	"sync"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"go.etcd.io/bbolt"
+)
+
+type stateDiffCache struct {
+	sync.RWMutex
+	anchors []state.ReadOnlyBeaconState
+	offset  uint64
+}
+
+func newStateDiffCache(s *Store) (*stateDiffCache, error) {
+	var offset uint64
+
+	err := s.db.View(func(tx *bbolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bbolt.ErrBucketNotFound
+		}
+
+		offsetBytes := bucket.Get([]byte("offset"))
+		if offsetBytes == nil {
+			return errors.New("state diff cache: offset not found")
+		}
+		offset = binary.LittleEndian.Uint64(offsetBytes)
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &stateDiffCache{
+		anchors: make([]state.ReadOnlyBeaconState, len(params.StateHierarchyExponents())),
+		offset:  offset,
+	}, nil
+}
+
+func (c *stateDiffCache) getAnchor(level int) state.ReadOnlyBeaconState {
+	c.RLock()
+	defer c.RUnlock()
+	return c.anchors[level]
+}
+
+func (c *stateDiffCache) setAnchor(level int, anchor state.ReadOnlyBeaconState) error {
+	c.Lock()
+	defer c.Unlock()
+	if level >= len(c.anchors) || level < 0 {
+		return errors.New("state diff cache: anchor level out of range")
+	}
+	c.anchors[level] = anchor
+	return nil
+}
+
+func (c *stateDiffCache) getOffset() uint64 {
+	c.RLock()
+	defer c.RUnlock()
+	return c.offset
+}
+
+func (c *stateDiffCache) setOffset(offset uint64) {
+	c.Lock()
+	defer c.Unlock()
+	c.offset = offset
+}
+
+func (c *stateDiffCache) clearAnchors() {
+	c.Lock()
+	defer c.Unlock()
+	c.anchors = make([]state.ReadOnlyBeaconState, len(params.StateHierarchyExponents()))
+}

beacon-chain/db/kv/state_diff_helpers.go

@@ -0,0 +1,234 @@
+package kv
+
+import (
+	"context"
+	"encoding/binary"
+	"errors"
+	"fmt"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/hdiff"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/math"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"go.etcd.io/bbolt"
+)
+
+var (
+	offsetKey           = []byte("offset")
+	ErrSlotBeforeOffset = errors.New("slot is before root offset")
+)
+
+func makeKey(level int, slot uint64) []byte {
+	buf := make([]byte, 16)
+	buf[0] = byte(level)
+	binary.LittleEndian.PutUint64(buf[1:], slot)
+	return buf
+}
+
+func (s *Store) getAnchorState(offset uint64, lvl int, slot primitives.Slot) (anchor state.ReadOnlyBeaconState, err error) {
+	if lvl <= 0 || lvl >= len(params.StateHierarchyExponents()) {
+		return nil, errors.New("invalid value for level")
+	}
+
+	relSlot := uint64(slot) - offset
+	prevExp := params.StateHierarchyExponents()[lvl-1]
+	span := math.PowerOf2(prevExp)
+	anchorSlot := primitives.Slot((relSlot / span * span) + offset)
+
+	// anchorLvl can be [0, lvl-1]
+	anchorLvl := computeLevel(offset, anchorSlot)
+	if anchorLvl == -1 {
+		return nil, errors.New("could not compute anchor level")
+	}
+
+	// Check if we have the anchor in cache.
+	anchor = s.stateDiffCache.getAnchor(anchorLvl)
+	if anchor != nil {
+		return anchor, nil
+	}
+
+	// If not, load it from the database.
+	anchor, err = s.stateByDiff(context.Background(), anchorSlot)
+	if err != nil {
+		return nil, err
+	}
+
+	// Save it in the cache.
+	err = s.stateDiffCache.setAnchor(anchorLvl, anchor)
+	if err != nil {
+		return nil, err
+	}
+	return anchor, nil
+}
+
+// computeLevel computes the level in the diff tree. Returns -1 in case slot should not be in tree.
+func computeLevel(offset uint64, slot primitives.Slot) int {
+	rel := uint64(slot) - offset
+	for i, exp := range params.StateHierarchyExponents() {
+		span := math.PowerOf2(exp)
+		if rel%span == 0 {
+			return i
+		}
+	}
+	// If rel isn’t on any of the boundaries, we should ignore saving it.
+	return -1
+}
+
+func (s *Store) setOffset(slot primitives.Slot) error {
+	err := s.db.Update(func(tx *bbolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bbolt.ErrBucketNotFound
+		}
+
+		offsetBytes := bucket.Get(offsetKey)
+		if offsetBytes != nil {
+			return fmt.Errorf("offset already set to %d", binary.LittleEndian.Uint64(offsetBytes))
+		}
+
+		offsetBytes = make([]byte, 8)
+		binary.LittleEndian.PutUint64(offsetBytes, uint64(slot))
+		if err := bucket.Put(offsetKey, offsetBytes); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	// Save the offset in the cache.
+	s.stateDiffCache.setOffset(uint64(slot))
+	return nil
+}
+
+func (s *Store) getOffset() uint64 {
+	return s.stateDiffCache.getOffset()
+}
+
+func keyForSnapshot(v int) []byte {
+	switch v {
+	case version.Fulu:
+		return fuluKey
+	case version.Electra:
+		return ElectraKey
+	case version.Deneb:
+		return denebKey
+	case version.Capella:
+		return capellaKey
+	case version.Bellatrix:
+		return bellatrixKey
+	case version.Altair:
+		return altairKey
+	default:
+		// Phase0
+		return []byte{}
+	}
+}
+
+func addKey(v int, bytes []byte) ([]byte, error) {
+	key := keyForSnapshot(v)
+	enc := make([]byte, len(key)+len(bytes))
+	copy(enc, key)
+	copy(enc[len(key):], bytes)
+	return enc, nil
+}
+
+func (s *Store) decodeStateSnapshot(enc []byte) (state.BeaconState, error) {
+	switch {
+	case hasFuluKey(enc):
+		var fuluState ethpb.BeaconStateFulu
+		if err := fuluState.UnmarshalSSZ(enc[len(ElectraKey):]); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafeFulu(&fuluState)
+	case HasElectraKey(enc):
+		var electraState ethpb.BeaconStateElectra
+		if err := electraState.UnmarshalSSZ(enc[len(ElectraKey):]); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafeElectra(&electraState)
+	case hasDenebKey(enc):
+		var denebState ethpb.BeaconStateDeneb
+		if err := denebState.UnmarshalSSZ(enc[len(denebKey):]); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafeDeneb(&denebState)
+	case hasCapellaKey(enc):
+		var capellaState ethpb.BeaconStateCapella
+		if err := capellaState.UnmarshalSSZ(enc[len(capellaKey):]); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafeCapella(&capellaState)
+	case hasBellatrixKey(enc):
+		var bellatrixState ethpb.BeaconStateBellatrix
+		if err := bellatrixState.UnmarshalSSZ(enc[len(bellatrixKey):]); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafeBellatrix(&bellatrixState)
+	case hasAltairKey(enc):
+		var altairState ethpb.BeaconStateAltair
+		if err := altairState.UnmarshalSSZ(enc[len(altairKey):]); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafeAltair(&altairState)
+	default:
+		var phase0State ethpb.BeaconState
+		if err := phase0State.UnmarshalSSZ(enc); err != nil {
+			return nil, err
+		}
+		return state_native.InitializeFromProtoUnsafePhase0(&phase0State)
+	}
+}
+
+func (s *Store) getBaseAndDiffChain(offset uint64, slot primitives.Slot) (state.BeaconState, []hdiff.HdiffBytes, error) {
+	rel := uint64(slot) - offset
+	lvl := computeLevel(offset, slot)
+	if lvl == -1 {
+		return nil, nil, errors.New("slot not in tree")
+	}
+
+	exponents := params.StateHierarchyExponents()
+
+	baseSpan := math.PowerOf2(exponents[0])
+	baseAnchorSlot := (rel / baseSpan * baseSpan) + offset
+
+	var diffChainIndices []uint64
+	for i := 1; i <= lvl; i++ {
+		span := math.PowerOf2(exponents[i])
+		diffSlot := rel / span * span
+		if diffSlot == baseAnchorSlot {
+			continue
+		}
+		diffChainIndices = appendUnique(diffChainIndices, diffSlot+offset)
+	}
+
+	baseSnapshot, err := s.getFullSnapshot(baseAnchorSlot)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	diffChain := make([]hdiff.HdiffBytes, 0, len(diffChainIndices))
+	for _, diffSlot := range diffChainIndices {
+		diff, err := s.getDiff(computeLevel(offset, primitives.Slot(diffSlot)), diffSlot)
+		if err != nil {
+			return nil, nil, err
+		}
+		diffChain = append(diffChain, diff)
+	}
+
+	return baseSnapshot, diffChain, nil
+}
+
+func appendUnique(s []uint64, v uint64) []uint64 {
+	for _, x := range s {
+		if x == v {
+			return s
+		}
+	}
+	return append(s, v)
+}

beacon-chain/db/kv/state_diff_test.go

@@ -0,0 +1,577 @@
+package kv
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"math/rand"
+	"testing"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/math"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/OffchainLabs/prysm/v6/runtime/version"
+	"github.com/OffchainLabs/prysm/v6/testing/require"
+	"github.com/OffchainLabs/prysm/v6/testing/util"
+	"go.etcd.io/bbolt"
+)
+
+func TestStateDiff_LoadOrInitOffset(t *testing.T) {
+	db := setupDB(t)
+	err := setOffsetInDB(db, 10)
+	require.NoError(t, err)
+	offset := db.getOffset()
+	require.Equal(t, uint64(10), offset)
+
+	err = db.setOffset(10)
+	require.ErrorContains(t, "offset already set", err)
+	offset = db.getOffset()
+	require.Equal(t, uint64(10), offset)
+}
+
+func TestStateDiff_ComputeLevel(t *testing.T) {
+	db := setupDB(t)
+
+	err := setOffsetInDB(db, 0)
+	require.NoError(t, err)
+
+	offset := db.getOffset()
+
+	// 2 ** 21
+	lvl := computeLevel(offset, primitives.Slot(math.PowerOf2(21)))
+	require.Equal(t, 0, lvl)
+
+	// 2 ** 21 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(21)*3))
+	require.Equal(t, 0, lvl)
+
+	// 2 ** 18
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(18)))
+	require.Equal(t, 1, lvl)
+
+	// 2 ** 18 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(18)*3))
+	require.Equal(t, 1, lvl)
+
+	// 2 ** 16
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(16)))
+	require.Equal(t, 2, lvl)
+
+	// 2 ** 16 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(16)*3))
+	require.Equal(t, 2, lvl)
+
+	// 2 ** 13
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(13)))
+	require.Equal(t, 3, lvl)
+
+	// 2 ** 13 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(13)*3))
+	require.Equal(t, 3, lvl)
+
+	// 2 ** 11
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(11)))
+	require.Equal(t, 4, lvl)
+
+	// 2 ** 11 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(11)*3))
+	require.Equal(t, 4, lvl)
+
+	// 2 ** 9
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(9)))
+	require.Equal(t, 5, lvl)
+
+	// 2 ** 9 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(9)*3))
+	require.Equal(t, 5, lvl)
+
+	// 2 ** 5
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(5)))
+	require.Equal(t, 6, lvl)
+
+	// 2 ** 5 * 3
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(5)*3))
+	require.Equal(t, 6, lvl)
+
+	// 2 ** 7
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(7)))
+	require.Equal(t, 6, lvl)
+
+	// 2 ** 5 + 1
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(5)+1))
+	require.Equal(t, -1, lvl)
+
+	// 2 ** 5 + 16
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(5)+16))
+	require.Equal(t, -1, lvl)
+
+	// 2 ** 5 + 32
+	lvl = computeLevel(offset, primitives.Slot(math.PowerOf2(5)+32))
+	require.Equal(t, 6, lvl)
+
+}
+
+func TestStateDiff_SaveFullSnapshot(t *testing.T) {
+	// test for every version
+	for v := 0; v < 6; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			db := setupDB(t)
+
+			// Create state with slot 0
+			st, enc := createState(t, 0, v)
+
+			err := setOffsetInDB(db, 0)
+			require.NoError(t, err)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			err = db.db.View(func(tx *bbolt.Tx) error {
+				bucket := tx.Bucket(stateDiffBucket)
+				if bucket == nil {
+					return bbolt.ErrBucketNotFound
+				}
+				s := bucket.Get(makeKey(0, uint64(0)))
+				if s == nil {
+					return bbolt.ErrIncompatibleValue
+				}
+				require.DeepSSZEqual(t, enc, s)
+				return nil
+			})
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestStateDiff_SaveAndReadFullSnapshot(t *testing.T) {
+	// test for every version
+	for v := 0; v < 6; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			db := setupDB(t)
+
+			st, _ := createState(t, 0, v)
+
+			err := setOffsetInDB(db, 0)
+			require.NoError(t, err)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			readSt, err := db.stateByDiff(context.Background(), 0)
+			require.NoError(t, err)
+			require.NotNil(t, readSt)
+
+			stSSZ, err := st.MarshalSSZ()
+			require.NoError(t, err)
+			readStSSZ, err := readSt.MarshalSSZ()
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, stSSZ, readStSSZ)
+		})
+	}
+}
+
+func TestStateDiff_SaveDiff(t *testing.T) {
+	// test for every version
+	for v := 0; v < 6; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			db := setupDB(t)
+
+			// Create state with slot 2**21
+			slot := primitives.Slot(math.PowerOf2(21))
+			st, enc := createState(t, slot, v)
+
+			err := setOffsetInDB(db, uint64(slot))
+			require.NoError(t, err)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			err = db.db.View(func(tx *bbolt.Tx) error {
+				bucket := tx.Bucket(stateDiffBucket)
+				if bucket == nil {
+					return bbolt.ErrBucketNotFound
+				}
+				s := bucket.Get(makeKey(0, uint64(slot)))
+				if s == nil {
+					return bbolt.ErrIncompatibleValue
+				}
+				require.DeepSSZEqual(t, enc, s)
+				return nil
+			})
+			require.NoError(t, err)
+
+			// create state with slot 2**18 (+2**21)
+			slot = primitives.Slot(math.PowerOf2(18) + math.PowerOf2(21))
+			st, _ = createState(t, slot, v)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			key := makeKey(1, uint64(slot))
+			err = db.db.View(func(tx *bbolt.Tx) error {
+				bucket := tx.Bucket(stateDiffBucket)
+				if bucket == nil {
+					return bbolt.ErrBucketNotFound
+				}
+				buf := append(key, "_s"...)
+				s := bucket.Get(buf)
+				if s == nil {
+					return bbolt.ErrIncompatibleValue
+				}
+				buf = append(key, "_v"...)
+				v := bucket.Get(buf)
+				if v == nil {
+					return bbolt.ErrIncompatibleValue
+				}
+				buf = append(key, "_b"...)
+				b := bucket.Get(buf)
+				if b == nil {
+					return bbolt.ErrIncompatibleValue
+				}
+				return nil
+			})
+			require.NoError(t, err)
+		})
+	}
+}
+
+func TestStateDiff_SaveAndReadDiff(t *testing.T) {
+	// test for every version
+	for v := 0; v < 6; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			db := setupDB(t)
+
+			st, _ := createState(t, 0, v)
+
+			err := setOffsetInDB(db, 0)
+			require.NoError(t, err)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			slot := primitives.Slot(math.PowerOf2(5))
+			st, _ = createState(t, slot, v)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			readSt, err := db.stateByDiff(context.Background(), slot)
+			require.NoError(t, err)
+			require.NotNil(t, readSt)
+
+			stSSZ, err := st.MarshalSSZ()
+			require.NoError(t, err)
+			readStSSZ, err := readSt.MarshalSSZ()
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, stSSZ, readStSSZ)
+		})
+	}
+}
+
+func TestStateDiff_SaveAndReadDiff_MultipleLevels(t *testing.T) {
+	// test for every version
+	for v := 0; v < 6; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			db := setupDB(t)
+
+			st, _ := createState(t, 0, v)
+
+			err := setOffsetInDB(db, 0)
+			require.NoError(t, err)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			slot := primitives.Slot(math.PowerOf2(11))
+			st, _ = createState(t, slot, v)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			readSt, err := db.stateByDiff(context.Background(), slot)
+			require.NoError(t, err)
+			require.NotNil(t, readSt)
+
+			stSSZ, err := st.MarshalSSZ()
+			require.NoError(t, err)
+			readStSSZ, err := readSt.MarshalSSZ()
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, stSSZ, readStSSZ)
+
+			slot = primitives.Slot(math.PowerOf2(11) + math.PowerOf2(9))
+			st, _ = createState(t, slot, v)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			readSt, err = db.stateByDiff(context.Background(), slot)
+			require.NoError(t, err)
+			require.NotNil(t, readSt)
+
+			stSSZ, err = st.MarshalSSZ()
+			require.NoError(t, err)
+			readStSSZ, err = readSt.MarshalSSZ()
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, stSSZ, readStSSZ)
+
+			slot = primitives.Slot(math.PowerOf2(11) + math.PowerOf2(9) + math.PowerOf2(5))
+			st, _ = createState(t, slot, v)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			readSt, err = db.stateByDiff(context.Background(), slot)
+			require.NoError(t, err)
+			require.NotNil(t, readSt)
+
+			stSSZ, err = st.MarshalSSZ()
+			require.NoError(t, err)
+			readStSSZ, err = readSt.MarshalSSZ()
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, stSSZ, readStSSZ)
+		})
+	}
+}
+
+func TestStateDiff_SaveAndReadDiffForkTransition(t *testing.T) {
+	// test for every version
+	for v := 0; v < 5; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			db := setupDB(t)
+
+			st, _ := createState(t, 0, v)
+
+			err := setOffsetInDB(db, 0)
+			require.NoError(t, err)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			slot := primitives.Slot(math.PowerOf2(5))
+			st, _ = createState(t, slot, v+1)
+
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+
+			readSt, err := db.stateByDiff(context.Background(), slot)
+			require.NoError(t, err)
+			require.NotNil(t, readSt)
+
+			stSSZ, err := st.MarshalSSZ()
+			require.NoError(t, err)
+			readStSSZ, err := readSt.MarshalSSZ()
+			require.NoError(t, err)
+			require.DeepSSZEqual(t, stSSZ, readStSSZ)
+		})
+	}
+}
+
+func TestStateDiff_OffsetCache(t *testing.T) {
+	// test for slot numbers 0 and 1 for every version
+	for slotNum := 0; slotNum < 2; slotNum++ {
+		// test for every version
+		for v := 0; v < 6; v++ {
+			t.Run(fmt.Sprintf("slotNum=%d,%s", slotNum, version.String(v)), func(t *testing.T) {
+				db := setupDB(t)
+
+				slot := primitives.Slot(slotNum)
+				err := setOffsetInDB(db, uint64(slot))
+				require.NoError(t, err)
+				st, _ := createState(t, slot, v)
+				err = db.saveStateByDiff(context.Background(), st)
+				require.NoError(t, err)
+
+				offset := db.stateDiffCache.getOffset()
+				require.Equal(t, uint64(slotNum), offset)
+
+				slot2 := primitives.Slot(uint64(slotNum) + math.PowerOf2(params.StateHierarchyExponents()[0]))
+				st2, _ := createState(t, slot2, v)
+				err = db.saveStateByDiff(context.Background(), st2)
+				require.NoError(t, err)
+
+				offset = db.stateDiffCache.getOffset()
+				require.Equal(t, uint64(slot), offset)
+			})
+		}
+	}
+}
+
+func TestStateDiff_AnchorCache(t *testing.T) {
+	// test for every version
+	for v := 0; v < 6; v++ {
+		t.Run(version.String(v), func(t *testing.T) {
+			exponents := params.StateHierarchyExponents()
+			localCache := make([]state.ReadOnlyBeaconState, len(exponents)-1)
+			db := setupDB(t)
+			err := setOffsetInDB(db, 0) // lvl 0
+			require.NoError(t, err)
+
+			// at first the cache should be empty
+			for i := 0; i < len(params.StateHierarchyExponents()); i++ {
+				anchor := db.stateDiffCache.getAnchor(i)
+				require.IsNil(t, anchor)
+			}
+
+			// add level 0
+			slot := primitives.Slot(0) // offset 0 is already set
+			st, _ := createState(t, slot, v)
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+			localCache[0] = st
+
+			// level 0 should be the same
+			require.DeepEqual(t, localCache[0], db.stateDiffCache.getAnchor(0))
+
+			// rest of the cache should be nil
+			for i := 1; i < len(exponents)-1; i++ {
+				require.IsNil(t, db.stateDiffCache.getAnchor(i))
+			}
+
+			// skip last level as it does not get cached
+			for i := len(exponents) - 2; i > 0; i-- {
+				slot = primitives.Slot(math.PowerOf2(exponents[i]))
+				st, _ := createState(t, slot, v)
+				err = db.saveStateByDiff(context.Background(), st)
+				require.NoError(t, err)
+				localCache[i] = st
+
+				// anchor cache must match local cache
+				for i := 0; i < len(exponents)-1; i++ {
+					if localCache[i] == nil {
+						require.IsNil(t, db.stateDiffCache.getAnchor(i))
+						continue
+					}
+					localSSZ, err := localCache[i].MarshalSSZ()
+					require.NoError(t, err)
+					anchorSSZ, err := db.stateDiffCache.getAnchor(i).MarshalSSZ()
+					require.NoError(t, err)
+					require.DeepSSZEqual(t, localSSZ, anchorSSZ)
+				}
+			}
+
+			// moving to a new tree should invalidate the cache except for level 0
+			twoTo21 := math.PowerOf2(21)
+			slot = primitives.Slot(twoTo21)
+			st, _ = createState(t, slot, v)
+			err = db.saveStateByDiff(context.Background(), st)
+			require.NoError(t, err)
+			localCache = make([]state.ReadOnlyBeaconState, len(exponents)-1)
+			localCache[0] = st
+
+			// level 0 should be the same
+			require.DeepEqual(t, localCache[0], db.stateDiffCache.getAnchor(0))
+
+			// rest of the cache should be nil
+			for i := 1; i < len(exponents)-1; i++ {
+				require.IsNil(t, db.stateDiffCache.getAnchor(i))
+			}
+		})
+	}
+}
+
+func createState(t *testing.T, slot primitives.Slot, v int) (state.ReadOnlyBeaconState, []byte) {
+	p := params.BeaconConfig()
+	var st state.BeaconState
+	var err error
+	switch v {
+	case version.Altair:
+		st, err = util.NewBeaconStateAltair()
+		require.NoError(t, err)
+		err = st.SetFork(&ethpb.Fork{
+			PreviousVersion: p.GenesisForkVersion,
+			CurrentVersion:  p.AltairForkVersion,
+			Epoch:           p.AltairForkEpoch,
+		})
+		require.NoError(t, err)
+	case version.Bellatrix:
+		st, err = util.NewBeaconStateBellatrix()
+		require.NoError(t, err)
+		err = st.SetFork(&ethpb.Fork{
+			PreviousVersion: p.AltairForkVersion,
+			CurrentVersion:  p.BellatrixForkVersion,
+			Epoch:           p.BellatrixForkEpoch,
+		})
+		require.NoError(t, err)
+	case version.Capella:
+		st, err = util.NewBeaconStateCapella()
+		require.NoError(t, err)
+		err = st.SetFork(&ethpb.Fork{
+			PreviousVersion: p.BellatrixForkVersion,
+			CurrentVersion:  p.CapellaForkVersion,
+			Epoch:           p.CapellaForkEpoch,
+		})
+		require.NoError(t, err)
+	case version.Deneb:
+		st, err = util.NewBeaconStateDeneb()
+		require.NoError(t, err)
+		err = st.SetFork(&ethpb.Fork{
+			PreviousVersion: p.CapellaForkVersion,
+			CurrentVersion:  p.DenebForkVersion,
+			Epoch:           p.DenebForkEpoch,
+		})
+		require.NoError(t, err)
+	case version.Electra:
+		st, err = util.NewBeaconStateElectra()
+		require.NoError(t, err)
+		err = st.SetFork(&ethpb.Fork{
+			PreviousVersion: p.DenebForkVersion,
+			CurrentVersion:  p.ElectraForkVersion,
+			Epoch:           p.ElectraForkEpoch,
+		})
+		require.NoError(t, err)
+	default:
+		st, err = util.NewBeaconState()
+		require.NoError(t, err)
+		err = st.SetFork(&ethpb.Fork{
+			PreviousVersion: p.GenesisForkVersion,
+			CurrentVersion:  p.GenesisForkVersion,
+			Epoch:           0,
+		})
+		require.NoError(t, err)
+	}
+
+	err = st.SetSlot(slot)
+	require.NoError(t, err)
+	slashings := make([]uint64, 8192)
+	slashings[0] = uint64(rand.Intn(10))
+	err = st.SetSlashings(slashings)
+	require.NoError(t, err)
+	stssz, err := st.MarshalSSZ()
+	require.NoError(t, err)
+	enc, err := addKey(v, stssz)
+	require.NoError(t, err)
+	return st, enc
+}
+
+func setOffsetInDB(s *Store, offset uint64) error {
+	err := s.db.Update(func(tx *bbolt.Tx) error {
+		bucket := tx.Bucket(stateDiffBucket)
+		if bucket == nil {
+			return bbolt.ErrBucketNotFound
+		}
+
+		offsetBytes := bucket.Get(offsetKey)
+		if offsetBytes != nil {
+			return fmt.Errorf("offset already set to %d", binary.LittleEndian.Uint64(offsetBytes))
+		}
+
+		offsetBytes = make([]byte, 8)
+		binary.LittleEndian.PutUint64(offsetBytes, offset)
+		if err := bucket.Put(offsetKey, offsetBytes); err != nil {
+			return err
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+
+	sdCache, err := newStateDiffCache(s)
+	if err != nil {
+		return err
+	}
+	s.stateDiffCache = sdCache
+	return nil
+}

beacon-chain/db/kv/wss_test.go

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

beacon-chain/execution/BUILD.bazel

@@ -31,7 +31,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/transition:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/execution/types:go_default_library",
@@ -98,7 +97,6 @@ go_test(
     embed = [":go_default_library"],
     deps = [
         "//async/event:go_default_library",
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/cache/depositsnapshot:go_default_library",
         "//beacon-chain/core/feed:go_default_library",
         "//beacon-chain/core/feed/state:go_default_library",

beacon-chain/execution/engine_client.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/execution/types"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
@@ -45,16 +44,11 @@ var (
 		GetPayloadMethodV3,
 		GetPayloadBodiesByHashV1,
 		GetPayloadBodiesByRangeV1,
-		GetBlobsV1,
 	}
 	electraEngineEndpoints = []string{
 		NewPayloadMethodV4,
 		GetPayloadMethodV4,
 	}
-	fuluEngineEndpoints = []string{
-		GetPayloadMethodV5,
-		GetBlobsV2,
-	}
 )
 
 const (
@@ -79,8 +73,6 @@ const (
 	GetPayloadMethodV3 = "engine_getPayloadV3"
 	// GetPayloadMethodV4 is the get payload method added for electra
 	GetPayloadMethodV4 = "engine_getPayloadV4"
-	// GetPayloadMethodV5 is the get payload method added for fulu
-	GetPayloadMethodV5 = "engine_getPayloadV5"
 	// BlockByHashMethod request string for JSON-RPC.
 	BlockByHashMethod = "eth_getBlockByHash"
 	// BlockByNumberMethod request string for JSON-RPC.
@@ -93,21 +85,11 @@ const (
 	ExchangeCapabilities = "engine_exchangeCapabilities"
 	// GetBlobsV1 request string for JSON-RPC.
 	GetBlobsV1 = "engine_getBlobsV1"
-	// GetBlobsV2 request string for JSON-RPC.
-	GetBlobsV2 = "engine_getBlobsV2"
 	// Defines the seconds before timing out engine endpoints with non-block execution semantics.
-	// TODO: Remove temporarily needed hack since geth takes an input blobs txs with blobs proofs, and
-	// does the heavy lifting of building cells proofs, while normally this is done by the tx sender.
-	// This is a cool hack because it lets the CL to act as if the tx sender actually computed the cells proofs.
-	// The only counter part is the `engine_getPayloadv<x>` takes a lot of time.
-	// defaultEngineTimeout = time.Second
-	defaultEngineTimeout = 2 * time.Second
+	defaultEngineTimeout = time.Second
 )
 
-var (
-	errInvalidPayloadBodyResponse  = errors.New("engine api payload body response is invalid")
-	errMissingBlobsAndProofsFromEL = errors.New("engine api payload body response is missing blobs and proofs")
-)
+var errInvalidPayloadBodyResponse = errors.New("engine api payload body response is invalid")
 
 // ForkchoiceUpdatedResponse is the response kind received by the
 // engine_forkchoiceUpdatedV1 endpoint.
@@ -126,7 +108,6 @@ type Reconstructor interface {
 		ctx context.Context, blindedBlocks []interfaces.ReadOnlySignedBeaconBlock,
 	) ([]interfaces.SignedBeaconBlock, error)
 	ReconstructBlobSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte, hi func(uint64) bool) ([]blocks.VerifiedROBlob, error)
-	ReconstructDataColumnSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) ([]blocks.VerifiedRODataColumn, error)
 }
 
 // EngineCaller defines a client that can interact with an Ethereum
@@ -276,9 +257,6 @@ func (s *Service) ForkchoiceUpdated(
 
 func getPayloadMethodAndMessage(slot primitives.Slot) (string, proto.Message) {
 	pe := slots.ToEpoch(slot)
-	if pe >= params.BeaconConfig().FuluForkEpoch {
-		return GetPayloadMethodV5, &pb.ExecutionBundleFulu{}
-	}
 	if pe >= params.BeaconConfig().ElectraForkEpoch {
 		return GetPayloadMethodV4, &pb.ExecutionBundleElectra{}
 	}
@@ -311,7 +289,7 @@ func (s *Service) GetPayload(ctx context.Context, payloadId [8]byte, slot primit
 	}
 	res, err := blocks.NewGetPayloadResponse(result)
 	if err != nil {
-		return nil, errors.Wrap(err, "new get payload response")
+		return nil, err
 	}
 	return res, nil
 }
@@ -320,36 +298,33 @@ func (s *Service) ExchangeCapabilities(ctx context.Context) ([]string, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.ExchangeCapabilities")
 	defer span.End()
 
+	// Only check for electra related engine methods if it has been activated.
 	if params.ElectraEnabled() {
 		supportedEngineEndpoints = append(supportedEngineEndpoints, electraEngineEndpoints...)
 	}
-
-	if params.FuluEnabled() {
-		supportedEngineEndpoints = append(supportedEngineEndpoints, fuluEngineEndpoints...)
-	}
-
-	elSupportedEndpointsSlice := make([]string, len(supportedEngineEndpoints))
-	if err := s.rpcClient.CallContext(ctx, &elSupportedEndpointsSlice, ExchangeCapabilities, supportedEngineEndpoints); err != nil {
+	var result []string
+	err := s.rpcClient.CallContext(ctx, &result, ExchangeCapabilities, supportedEngineEndpoints)
+	if err != nil {
 		return nil, handleRPCError(err)
 	}
 
-	elSupportedEndpoints := make(map[string]bool, len(elSupportedEndpointsSlice))
-	for _, method := range elSupportedEndpointsSlice {
-		elSupportedEndpoints[method] = true
-	}
-
-	unsupported := make([]string, 0, len(supportedEngineEndpoints))
-	for _, method := range supportedEngineEndpoints {
-		if !elSupportedEndpoints[method] {
-			unsupported = append(unsupported, method)
+	var unsupported []string
+	for _, s1 := range supportedEngineEndpoints {
+		supported := false
+		for _, s2 := range result {
+			if s1 == s2 {
+				supported = true
+				break
+			}
+		}
+		if !supported {
+			unsupported = append(unsupported, s1)
 		}
 	}
-
 	if len(unsupported) != 0 {
-		log.WithField("methods", unsupported).Warning("Connected execution client does not support some requested engine methods")
+		log.Warnf("Please update client, detected the following unsupported engine methods: %s", unsupported)
 	}
-
-	return elSupportedEndpointsSlice, nil
+	return result, handleRPCError(err)
 }
 
 // GetTerminalBlockHash returns the valid terminal block hash based on total difficulty.
@@ -520,10 +495,9 @@ func (s *Service) HeaderByNumber(ctx context.Context, number *big.Int) (*types.H
 func (s *Service) GetBlobs(ctx context.Context, versionedHashes []common.Hash) ([]*pb.BlobAndProof, error) {
 	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetBlobs")
 	defer span.End()
-
 	// If the execution engine does not support `GetBlobsV1`, return early to prevent encountering an error later.
 	if !s.capabilityCache.has(GetBlobsV1) {
-		return nil, errors.New(fmt.Sprintf("%s is not supported", GetBlobsV1))
+		return nil, nil
 	}
 
 	result := make([]*pb.BlobAndProof, len(versionedHashes))
@@ -531,19 +505,6 @@ func (s *Service) GetBlobs(ctx context.Context, versionedHashes []common.Hash) (
 	return result, handleRPCError(err)
 }
 
-func (s *Service) GetBlobsV2(ctx context.Context, versionedHashes []common.Hash) ([]*pb.BlobAndProofV2, error) {
-	ctx, span := trace.StartSpan(ctx, "powchain.engine-api-client.GetBlobsV2")
-	defer span.End()
-
-	if !s.capabilityCache.has(GetBlobsV2) {
-		return nil, errors.New(fmt.Sprintf("%s is not supported", GetBlobsV2))
-	}
-
-	result := make([]*pb.BlobAndProofV2, len(versionedHashes))
-	err := s.rpcClient.CallContext(ctx, &result, GetBlobsV2, versionedHashes)
-	return result, handleRPCError(err)
-}
-
 // ReconstructFullBlock takes in a blinded beacon block and reconstructs
 // a beacon block with a full execution payload via the engine API.
 func (s *Service) ReconstructFullBlock(
@@ -654,73 +615,6 @@ func (s *Service) ReconstructBlobSidecars(ctx context.Context, block interfaces.
 	return verifiedBlobs, nil
 }
 
-// ReconstructDataColumnSidecars reconstructs the verified data column sidecars for a given beacon block.
-// It retrieves the KZG commitments from the block body, fetches the associated blobs and cell proofs from the EL,
-// and constructs the corresponding verified read-only data column sidecars.
-func (s *Service) ReconstructDataColumnSidecars(ctx context.Context, signedROBlock interfaces.ReadOnlySignedBeaconBlock, blockRoot [fieldparams.RootLength]byte) ([]blocks.VerifiedRODataColumn, error) {
-	block := signedROBlock.Block()
-
-	log := log.WithFields(logrus.Fields{
-		"root": fmt.Sprintf("%#x", blockRoot),
-		"slot": block.Slot(),
-	})
-
-	kzgCommitments, err := block.Body().BlobKzgCommitments()
-	if err != nil {
-		return nil, wrapWithBlockRoot(err, blockRoot, "blob KZG commitments")
-	}
-
-	// Collect KZG hashes for all blobs
-	var kzgHashes []common.Hash
-	for _, commitment := range kzgCommitments {
-		kzgHashes = append(kzgHashes, primitives.ConvertKzgCommitmentToVersionedHash(commitment))
-	}
-
-	// Fetch all blobsAndCellsProofs from EL
-	blobAndProofV2s, err := s.GetBlobsV2(ctx, kzgHashes)
-	if err != nil {
-		return nil, wrapWithBlockRoot(err, blockRoot, "get blobs V2")
-	}
-
-	// Return early if nothing is returned from the EL.
-	if len(blobAndProofV2s) == 0 {
-		log.Debug("No blobs returned from EL")
-		return nil, nil
-	}
-
-	// Extract the blobs and proofs from the blobAndProofV2s.
-	blobs := make([][]byte, 0, len(blobAndProofV2s))
-	cellProofs := make([][]byte, 0, len(blobAndProofV2s))
-	for _, blobsAndProofs := range blobAndProofV2s {
-		if blobsAndProofs == nil {
-			return nil, wrapWithBlockRoot(errMissingBlobsAndProofsFromEL, blockRoot, "")
-		}
-		blobs = append(blobs, blobsAndProofs.Blob)
-		cellProofs = append(cellProofs, blobsAndProofs.KzgProofs...)
-	}
-
-	dataColumnSidecars, err := peerdas.ConstructDataColumnSidecars(signedROBlock, blobs, cellProofs)
-	if err != nil {
-		return nil, wrapWithBlockRoot(err, blockRoot, "construct data column sidecars")
-	}
-
-	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(dataColumnSidecars))
-	for _, dataColumnSidecar := range dataColumnSidecars {
-		roDataColumn, err := blocks.NewRODataColumnWithRoot(dataColumnSidecar, blockRoot)
-		if err != nil {
-			return nil, wrapWithBlockRoot(err, blockRoot, "new read-only data column with root")
-		}
-
-		// We trust the execution layer we are connected to, so we can upgrade the read only data column sidecar into a verified one.
-		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
-		verifiedRODataColumns = append(verifiedRODataColumns, verifiedRODataColumn)
-	}
-
-	log.Debug("Data columns successfully reconstructed from EL")
-
-	return verifiedRODataColumns, nil
-}
-
 func fullPayloadFromPayloadBody(
 	header interfaces.ExecutionData, body *pb.ExecutionPayloadBody, bVersion int,
 ) (interfaces.ExecutionData, error) {
@@ -1008,8 +902,3 @@ func toBlockNumArg(number *big.Int) string {
 	}
 	return hexutil.EncodeBig(number)
 }
-
-// wrapWithBlockRoot returns a new error with the given block root.
-func wrapWithBlockRoot(err error, blockRoot [32]byte, message string) error {
-	return errors.Wrap(err, fmt.Sprintf("%s for block %#x", message, blockRoot))
-}

beacon-chain/execution/engine_client_test.go

@@ -13,7 +13,6 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	mocks "github.com/OffchainLabs/prysm/v6/beacon-chain/execution/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
@@ -168,7 +167,6 @@ func TestClient_HTTP(t *testing.T) {
 	cfg.CapellaForkEpoch = 1
 	cfg.DenebForkEpoch = 2
 	cfg.ElectraForkEpoch = 3
-	cfg.FuluForkEpoch = 4
 	params.OverrideBeaconConfig(cfg)
 
 	t.Run(GetPayloadMethod, func(t *testing.T) {
@@ -319,11 +317,11 @@ func TestClient_HTTP(t *testing.T) {
 		require.DeepEqual(t, uint64(2), g)
 
 		commitments := [][]byte{bytesutil.PadTo([]byte("commitment1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("commitment2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, commitments, resp.BlobsBundler.GetKzgCommitments())
+		require.DeepEqual(t, commitments, resp.BlobsBundle.KzgCommitments)
 		proofs := [][]byte{bytesutil.PadTo([]byte("proof1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("proof2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, proofs, resp.BlobsBundler.GetProofs())
+		require.DeepEqual(t, proofs, resp.BlobsBundle.Proofs)
 		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
-		require.DeepEqual(t, blobs, resp.BlobsBundler.GetBlobs())
+		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
 	})
 	t.Run(GetPayloadMethodV4, func(t *testing.T) {
 		payloadId := [8]byte{1}
@@ -374,11 +372,11 @@ func TestClient_HTTP(t *testing.T) {
 		require.DeepEqual(t, uint64(2), g)
 
 		commitments := [][]byte{bytesutil.PadTo([]byte("commitment1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("commitment2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, commitments, resp.BlobsBundler.GetKzgCommitments())
+		require.DeepEqual(t, commitments, resp.BlobsBundle.KzgCommitments)
 		proofs := [][]byte{bytesutil.PadTo([]byte("proof1"), fieldparams.BLSPubkeyLength), bytesutil.PadTo([]byte("proof2"), fieldparams.BLSPubkeyLength)}
-		require.DeepEqual(t, proofs, resp.BlobsBundler.GetProofs())
+		require.DeepEqual(t, proofs, resp.BlobsBundle.Proofs)
 		blobs := [][]byte{bytesutil.PadTo([]byte("a"), fieldparams.BlobLength), bytesutil.PadTo([]byte("b"), fieldparams.BlobLength)}
-		require.DeepEqual(t, blobs, resp.BlobsBundler.GetBlobs())
+		require.DeepEqual(t, blobs, resp.BlobsBundle.Blobs)
 		requests := &pb.ExecutionRequests{
 			Deposits: []*pb.DepositRequest{
 				{
@@ -407,52 +405,7 @@ func TestClient_HTTP(t *testing.T) {
 
 		require.DeepEqual(t, requests, resp.ExecutionRequests)
 	})
-	t.Run(GetPayloadMethodV5, func(t *testing.T) {
-		payloadId := [8]byte{1}
-		want, ok := fix["ExecutionBundleFulu"].(*pb.GetPayloadV5ResponseJson)
-		require.Equal(t, true, ok)
-		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Content-Type", "application/json")
-			defer func() {
-				require.NoError(t, r.Body.Close())
-			}()
-			enc, err := io.ReadAll(r.Body)
-			require.NoError(t, err)
-			jsonRequestString := string(enc)
 
-			reqArg, err := json.Marshal(pb.PayloadIDBytes(payloadId))
-			require.NoError(t, err)
-
-			// We expect the JSON string RPC request contains the right arguments.
-			require.Equal(t, true, strings.Contains(
-				jsonRequestString, string(reqArg),
-			))
-			resp := map[string]interface{}{
-				"jsonrpc": "2.0",
-				"id":      1,
-				"result":  want,
-			}
-			err = json.NewEncoder(w).Encode(resp)
-			require.NoError(t, err)
-		}))
-		defer srv.Close()
-
-		rpcClient, err := rpc.DialHTTP(srv.URL)
-		require.NoError(t, err)
-		defer rpcClient.Close()
-
-		client := &Service{}
-		client.rpcClient = rpcClient
-
-		// We call the RPC method via HTTP and expect a proper result.
-		resp, err := client.GetPayload(ctx, payloadId, 4*params.BeaconConfig().SlotsPerEpoch)
-		require.NoError(t, err)
-		_, ok = resp.BlobsBundler.(*pb.BlobsBundleV2)
-		if !ok {
-			t.Logf("resp.BlobsBundler has unexpected type: %T", resp.BlobsBundler)
-		}
-		require.Equal(t, ok, true)
-	})
 	t.Run(ForkchoiceUpdatedMethod+" VALID status", func(t *testing.T) {
 		forkChoiceState := &pb.ForkchoiceState{
 			HeadBlockHash:      []byte("head"),
@@ -1586,7 +1539,6 @@ func fixtures() map[string]interface{} {
 		"ExecutionPayloadCapellaWithValue":  s.ExecutionPayloadWithValueCapella,
 		"ExecutionPayloadDenebWithValue":    s.ExecutionPayloadWithValueDeneb,
 		"ExecutionBundleElectra":            s.ExecutionBundleElectra,
-		"ExecutionBundleFulu":               s.ExecutionBundleFulu,
 		"ValidPayloadStatus":                s.ValidPayloadStatus,
 		"InvalidBlockHashStatus":            s.InvalidBlockHashStatus,
 		"AcceptedStatus":                    s.AcceptedStatus,
@@ -1822,36 +1774,6 @@ func fixturesStruct() *payloadFixtures {
 			append([]byte{pb.WithdrawalRequestType}, withdrawalRequestBytes...),
 			append([]byte{pb.ConsolidationRequestType}, consolidationRequestBytes...)},
 	}
-	executionBundleFixtureFulu := &pb.GetPayloadV5ResponseJson{
-		ShouldOverrideBuilder: true,
-		ExecutionPayload: &pb.ExecutionPayloadDenebJSON{
-			ParentHash:    &common.Hash{'a'},
-			FeeRecipient:  &common.Address{'b'},
-			StateRoot:     &common.Hash{'c'},
-			ReceiptsRoot:  &common.Hash{'d'},
-			LogsBloom:     &hexutil.Bytes{'e'},
-			PrevRandao:    &common.Hash{'f'},
-			BaseFeePerGas: "0x123",
-			BlockHash:     &common.Hash{'g'},
-			Transactions:  []hexutil.Bytes{{'h'}},
-			Withdrawals:   []*pb.Withdrawal{},
-			BlockNumber:   &hexUint,
-			GasLimit:      &hexUint,
-			GasUsed:       &hexUint,
-			Timestamp:     &hexUint,
-			BlobGasUsed:   &bgu,
-			ExcessBlobGas: &ebg,
-		},
-		BlockValue: "0x11fffffffff",
-		BlobsBundle: &pb.BlobBundleV2JSON{
-			Commitments: []hexutil.Bytes{[]byte("commitment1"), []byte("commitment2")},
-			Proofs:      []hexutil.Bytes{[]byte("proof1"), []byte("proof2")},
-			Blobs:       []hexutil.Bytes{{'a'}, {'b'}},
-		},
-		ExecutionRequests: []hexutil.Bytes{append([]byte{pb.DepositRequestType}, depositRequestBytes...),
-			append([]byte{pb.WithdrawalRequestType}, withdrawalRequestBytes...),
-			append([]byte{pb.ConsolidationRequestType}, consolidationRequestBytes...)},
-	}
 	parent := bytesutil.PadTo([]byte("parentHash"), fieldparams.RootLength)
 	sha3Uncles := bytesutil.PadTo([]byte("sha3Uncles"), fieldparams.RootLength)
 	miner := bytesutil.PadTo([]byte("miner"), fieldparams.FeeRecipientLength)
@@ -1946,7 +1868,6 @@ func fixturesStruct() *payloadFixtures {
 		ExecutionPayloadWithValueCapella:  executionPayloadWithValueFixtureCapella,
 		ExecutionPayloadWithValueDeneb:    executionPayloadWithValueFixtureDeneb,
 		ExecutionBundleElectra:            executionBundleFixtureElectra,
-		ExecutionBundleFulu:               executionBundleFixtureFulu,
 		ValidPayloadStatus:                validStatus,
 		InvalidBlockHashStatus:            inValidBlockHashStatus,
 		AcceptedStatus:                    acceptedStatus,
@@ -1971,7 +1892,6 @@ type payloadFixtures struct {
 	ExecutionPayloadWithValueCapella  *pb.GetPayloadV2ResponseJson
 	ExecutionPayloadWithValueDeneb    *pb.GetPayloadV3ResponseJson
 	ExecutionBundleElectra            *pb.GetPayloadV4ResponseJson
-	ExecutionBundleFulu               *pb.GetPayloadV5ResponseJson
 	ValidPayloadStatus                *pb.PayloadStatus
 	InvalidBlockHashStatus            *pb.PayloadStatus
 	AcceptedStatus                    *pb.PayloadStatus
@@ -2441,7 +2361,7 @@ func Test_ExchangeCapabilities(t *testing.T) {
 		for _, item := range results {
 			require.NotNil(t, item)
 		}
-		assert.LogsContain(t, logHook, "Connected execution client does not support some requested engine methods")
+		assert.LogsContain(t, logHook, "Please update client, detected the following unsupported engine methods:")
 	})
 	t.Run("list of items", func(t *testing.T) {
 		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -2504,7 +2424,7 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	t.Run("get-blobs end point is not supported", func(t *testing.T) {
 		hi := mockSummary(t, []bool{true, true, true, true, true, false})
 		verifiedBlobs, err := client.ReconstructBlobSidecars(ctx, sb, r, hi)
-		require.ErrorContains(t, "engine_getBlobsV1 is not supported", err)
+		require.NoError(t, err)
 		require.Equal(t, 0, len(verifiedBlobs))
 	})
 
@@ -2556,76 +2476,6 @@ func TestReconstructBlobSidecars(t *testing.T) {
 	})
 }
 
-func TestReconstructDataColumnSidecars(t *testing.T) {
-	// Start the trusted setup.
-	err := kzg.Start()
-	require.NoError(t, err)
-
-	// Setup right fork epoch
-	params.SetupTestConfigCleanup(t)
-	cfg := params.BeaconConfig().Copy()
-	cfg.CapellaForkEpoch = 1
-	cfg.DenebForkEpoch = 2
-	cfg.ElectraForkEpoch = 3
-	cfg.FuluForkEpoch = 4
-	params.OverrideBeaconConfig(cfg)
-
-	client := &Service{capabilityCache: &capabilityCache{}}
-	b := util.NewBeaconBlockFulu()
-	b.Block.Slot = 4 * params.BeaconConfig().SlotsPerEpoch
-	kzgCommitments := createRandomKzgCommitments(t, 6)
-	b.Block.Body.BlobKzgCommitments = kzgCommitments
-	r, err := b.Block.HashTreeRoot()
-	require.NoError(t, err)
-	sb, err := blocks.NewSignedBeaconBlock(b)
-	require.NoError(t, err)
-
-	ctx := context.Background()
-
-	t.Run("GetBlobsV2 is not supported", func(t *testing.T) {
-		_, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
-		require.ErrorContains(t, "get blobs V2 for block", err)
-	})
-
-	t.Run("nothing received", func(t *testing.T) {
-		srv := createBlobServerV2(t, 0, []bool{})
-		defer srv.Close()
-
-		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
-		defer rpcClient.Close()
-
-		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
-		require.NoError(t, err)
-		require.Equal(t, 0, len(dataColumns))
-	})
-
-	t.Run("receiving all blobs", func(t *testing.T) {
-		blobMasks := []bool{true, true, true, true, true, true}
-		srv := createBlobServerV2(t, 6, blobMasks)
-		defer srv.Close()
-
-		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
-		defer rpcClient.Close()
-
-		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
-		require.NoError(t, err)
-		require.Equal(t, 128, len(dataColumns))
-	})
-
-	t.Run("missing some blobs", func(t *testing.T) {
-		blobMasks := []bool{false, true, true, true, true, true}
-		srv := createBlobServerV2(t, 6, blobMasks)
-		defer srv.Close()
-
-		rpcClient, client := setupRpcClientV2(t, srv.URL, client)
-		defer rpcClient.Close()
-
-		dataColumns, err := client.ReconstructDataColumnSidecars(ctx, sb, r)
-		require.ErrorContains(t, errMissingBlobsAndProofsFromEL.Error(), err)
-		require.Equal(t, 0, len(dataColumns))
-	})
-}
-
 func createRandomKzgCommitments(t *testing.T, num int) [][]byte {
 	kzgCommitments := make([][]byte, num)
 	for i := range kzgCommitments {
@@ -2661,42 +2511,6 @@ func createBlobServer(t *testing.T, numBlobs int, callbackFuncs ...func()) *http
 	}))
 }
 
-func createBlobServerV2(t *testing.T, numBlobs int, blobMasks []bool) *httptest.Server {
-	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Content-Type", "application/json")
-		defer func() {
-			require.NoError(t, r.Body.Close())
-		}()
-
-		require.Equal(t, len(blobMasks), numBlobs)
-
-		blobAndCellProofs := make([]*pb.BlobAndProofV2Json, numBlobs)
-		for i := range blobAndCellProofs {
-			if !blobMasks[i] {
-				continue
-			}
-
-			blobAndCellProofs[i] = &pb.BlobAndProofV2Json{
-				Blob:      []byte("0xblob"),
-				KzgProofs: []hexutil.Bytes{},
-			}
-			for j := 0; j < int(params.BeaconConfig().NumberOfColumns); j++ {
-				cellProof := make([]byte, 48)
-				blobAndCellProofs[i].KzgProofs = append(blobAndCellProofs[i].KzgProofs, cellProof)
-			}
-		}
-
-		respJSON := map[string]interface{}{
-			"jsonrpc": "2.0",
-			"id":      1,
-			"result":  blobAndCellProofs,
-		}
-
-		err := json.NewEncoder(w).Encode(respJSON)
-		require.NoError(t, err)
-	}))
-}
-
 func setupRpcClient(t *testing.T, url string, client *Service) (*rpc.Client, *Service) {
 	rpcClient, err := rpc.DialHTTP(url)
 	require.NoError(t, err)
@@ -2708,12 +2522,6 @@ func setupRpcClient(t *testing.T, url string, client *Service) (*rpc.Client, *Se
 	return rpcClient, client
 }
 
-func setupRpcClientV2(t *testing.T, url string, client *Service) (*rpc.Client, *Service) {
-	rpcClient, client := setupRpcClient(t, url, client)
-	client.capabilityCache = &capabilityCache{capabilities: map[string]interface{}{GetBlobsV2: nil}}
-	return rpcClient, client
-}
-
 func testNewBlobVerifier() verification.NewBlobVerifier {
 	return func(b blocks.ROBlob, reqs []verification.Requirement) verification.BlobVerifier {
 		return &verification.MockBlobVerifier{

beacon-chain/execution/testing/mock_engine_client.go

@@ -38,8 +38,6 @@ type EngineClient struct {
 	ErrGetPayload               error
 	BlobSidecars                []blocks.VerifiedROBlob
 	ErrorBlobSidecars           error
-	DataColumnSidecars          []blocks.VerifiedRODataColumn
-	ErrorDataColumnSidecars     error
 }
 
 // NewPayload --
@@ -115,10 +113,6 @@ func (e *EngineClient) ReconstructBlobSidecars(context.Context, interfaces.ReadO
 	return e.BlobSidecars, e.ErrorBlobSidecars
 }
 
-func (e *EngineClient) ReconstructDataColumnSidecars(ctx context.Context, block interfaces.ReadOnlySignedBeaconBlock, blockRoot [32]byte) ([]blocks.VerifiedRODataColumn, error) {
-	return e.DataColumnSidecars, e.ErrorDataColumnSidecars
-}
-
 // GetTerminalBlockHash --
 func (e *EngineClient) GetTerminalBlockHash(ctx context.Context, transitionTime uint64) ([]byte, bool, error) {
 	ttd := new(big.Int)

beacon-chain/node/BUILD.bazel

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

beacon-chain/node/clear_db.go

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

beacon-chain/node/node.go

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

beacon-chain/node/options.go

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

beacon-chain/p2p/BUILD.bazel

@@ -71,6 +71,7 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
         "//network:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",
         "//runtime:go_default_library",
@@ -167,6 +168,7 @@ go_test(
         "//crypto/hash:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//network:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//proto/prysm/v1alpha1/metadata:go_default_library",

beacon-chain/p2p/broadcaster.go

@@ -15,6 +15,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/crypto/hash"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/pkg/errors"
@@ -278,8 +279,14 @@ func (s *Service) BroadcastLightClientOptimisticUpdate(ctx context.Context, upda
 		return errors.New("attempted to broadcast nil light client optimistic update")
 	}
 
-	digest := params.ForkDigest(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
-	if err := s.broadcastObject(ctx, update, lcOptimisticToTopic(digest)); err != nil {
+	forkDigest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(update.AttestedHeader().Beacon().Slot), s.genesisValidatorsRoot)
+	if err != nil {
+		err := errors.Wrap(err, "could not retrieve fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
+	if err := s.broadcastObject(ctx, update, lcOptimisticToTopic(forkDigest)); err != nil {
 		log.WithError(err).Debug("Failed to broadcast light client optimistic update")
 		err := errors.Wrap(err, "could not publish message")
 		tracing.AnnotateError(span, err)
@@ -298,7 +305,13 @@ func (s *Service) BroadcastLightClientFinalityUpdate(ctx context.Context, update
 		return errors.New("attempted to broadcast nil light client finality update")
 	}
 
-	forkDigest := params.ForkDigest(slots.ToEpoch(update.AttestedHeader().Beacon().Slot))
+	forkDigest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(update.AttestedHeader().Beacon().Slot), s.genesisValidatorsRoot)
+	if err != nil {
+		err := errors.Wrap(err, "could not retrieve fork digest")
+		tracing.AnnotateError(span, err)
+		return err
+	}
+
 	if err := s.broadcastObject(ctx, update, lcFinalityToTopic(forkDigest)); err != nil {
 		log.WithError(err).Debug("Failed to broadcast light client finality update")
 		err := errors.Wrap(err, "could not publish message")

beacon-chain/p2p/broadcaster_test.go

@@ -16,13 +16,12 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	p2ptest "github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/testing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
-	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/wrapper"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	testpb "github.com/OffchainLabs/prysm/v6/proto/testing"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
@@ -62,7 +61,6 @@ func TestService_Broadcast(t *testing.T) {
 	topic := "/eth2/%x/testing"
 	// Set a test gossip mapping for testpb.TestSimpleMessage.
 	GossipTypeMapping[reflect.TypeOf(msg)] = topic
-	p.clock = startup.NewClock(p.genesisTime, bytesutil.ToBytes32(p.genesisValidatorsRoot))
 	digest, err := p.currentForkDigest()
 	require.NoError(t, err)
 	topic = fmt.Sprintf(topic, digest)
@@ -552,7 +550,9 @@ func TestService_BroadcastLightClientOptimisticUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientOptimisticUpdateTopicFormat
-	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, params.ForkDigest(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot)))
+	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
+	require.NoError(t, err)
+	topic := fmt.Sprintf(LightClientOptimisticUpdateTopicFormat, digest)
 
 	// External peer subscribes to the topic.
 	topic += p.Encoding().ProtocolSuffix()
@@ -617,7 +617,9 @@ func TestService_BroadcastLightClientFinalityUpdate(t *testing.T) {
 	require.NoError(t, err)
 
 	GossipTypeMapping[reflect.TypeOf(msg)] = LightClientFinalityUpdateTopicFormat
-	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, params.ForkDigest(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot)))
+	digest, err := forks.ForkDigestFromEpoch(slots.ToEpoch(msg.AttestedHeader().Beacon().Slot), p.genesisValidatorsRoot)
+	require.NoError(t, err)
+	topic := fmt.Sprintf(LightClientFinalityUpdateTopicFormat, digest)
 
 	// External peer subscribes to the topic.
 	topic += p.Encoding().ProtocolSuffix()

beacon-chain/p2p/discovery.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/cache"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
@@ -223,11 +222,29 @@ func (s *Service) RefreshPersistentSubnets() {
 	// Get the sync subnet bitfield in our metadata.
 	currentBitSInMetadata := s.Metadata().SyncnetsBitfield()
 
+	// Is our sync bitvector record up to date?
 	isBitSUpToDate := bytes.Equal(bitS, inRecordBitS) && bytes.Equal(bitS, currentBitSInMetadata)
 
 	// Compare current epoch with the Fulu fork epoch.
 	fuluForkEpoch := params.BeaconConfig().FuluForkEpoch
 
+	// We add `1` to the current epoch because we want to prepare one epoch before the Fulu fork.
+	if currentEpoch+1 < fuluForkEpoch {
+		// Altair behaviour.
+		if metadataVersion == version.Altair && isBitVUpToDate && isBitSUpToDate {
+			// Nothing to do, return early.
+			return
+		}
+
+		// Some data have changed, update our record and metadata.
+		s.updateSubnetRecordWithMetadataV2(bitV, bitS)
+
+		// Ping all peers to inform them of new metadata
+		s.pingPeersAndLogEnr()
+
+		return
+	}
+
 	// Get the current custody group count.
 	custodyGroupCount := s.cfg.CustodyInfo.ActualGroupCount()
 
@@ -238,26 +255,6 @@ func (s *Service) RefreshPersistentSubnets() {
 		return
 	}
 
-	// We add `1` to the current epoch because we want to prepare one epoch before the Fulu fork.
-	if currentEpoch+1 < fuluForkEpoch {
-		// Is our custody group count record up to date?
-		isCustodyGroupCountUpToDate := custodyGroupCount == inRecordCustodyGroupCount
-
-		// Altair behaviour.
-		if metadataVersion == version.Altair && isBitVUpToDate && isBitSUpToDate && (!params.FuluEnabled() || isCustodyGroupCountUpToDate) {
-			// Nothing to do, return early.
-			return
-		}
-
-		// Some data have changed, update our record and metadata.
-		s.updateSubnetRecordWithMetadataV2(bitV, bitS, custodyGroupCount)
-
-		// Ping all peers to inform them of new metadata
-		s.pingPeersAndLogEnr()
-
-		return
-	}
-
 	// Get the custody group count in our metadata.
 	inMetadataCustodyGroupCount := s.Metadata().CustodyGroupCount()
 
@@ -390,7 +387,6 @@ func (s *Service) listenForNewNodes() {
 				s.Peers().RandomizeBackOff(peerInfo.ID)
 				wg.Add(1)
 				go func(info *peer.AddrInfo) {
-					log.WithField("enr", node.String()).WithField("peerInfo", info.String()).Debug("attempting to connect with peer")
 					if err := s.connectWithPeer(s.ctx, *info); err != nil {
 						log.WithError(err).Tracef("Could not connect with peer %s", info.String())
 					}
@@ -508,10 +504,8 @@ func (s *Service) createLocalNode(
 	localNode.SetFallbackIP(ipAddr)
 	localNode.SetFallbackUDP(udpPort)
 
-	clock := startup.NewClock(s.genesisTime, [32]byte(s.genesisValidatorsRoot))
-	currentEntry := params.GetNetworkScheduleEntry(clock.CurrentEpoch())
-	nextEntry := params.NextNetworkScheduleEntry(clock.CurrentEpoch())
-	if err := updateENR(localNode, currentEntry, nextEntry); err != nil {
+	localNode, err = addForkEntry(localNode, s.genesisTime, s.genesisValidatorsRoot)
+	if err != nil {
 		return nil, errors.Wrap(err, "could not add eth2 fork version entry to enr")
 	}
 

beacon-chain/p2p/discovery_test.go

@@ -250,7 +250,7 @@ func TestCreateLocalNode(t *testing.T) {
 
 			// Check cgc config.
 			custodyGroupCount := new(uint64)
-			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(params.BeaconNetworkConfig().CustodyGroupCountKey, custodyGroupCount)))
+			require.NoError(t, localNode.Node().Record().Load(enr.WithEntry(peerdas.CustodyGroupCountEnrKey, custodyGroupCount)))
 			require.Equal(t, params.BeaconConfig().CustodyRequirement, *custodyGroupCount)
 		})
 	}
@@ -621,7 +621,7 @@ func checkPingCountCacheMetadataRecord(
 	if expected.custodyGroupCount != nil {
 		// Check custody subnet count in ENR.
 		var actualCustodyGroupCount uint64
-		err := service.dv5Listener.LocalNode().Node().Record().Load(enr.WithEntry(params.BeaconNetworkConfig().CustodyGroupCountKey, &actualCustodyGroupCount))
+		err := service.dv5Listener.LocalNode().Node().Record().Load(enr.WithEntry(peerdas.CustodyGroupCountEnrKey, &actualCustodyGroupCount))
 		require.NoError(t, err)
 		require.Equal(t, *expected.custodyGroupCount, actualCustodyGroupCount)
 

beacon-chain/p2p/fork.go

@@ -3,10 +3,13 @@ package p2p
 import (
 	"bytes"
 	"fmt"
+	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	prysmTime "github.com/OffchainLabs/prysm/v6/time"
+	"github.com/OffchainLabs/prysm/v6/time/slots"
 	"github.com/ethereum/go-ethereum/p2p/enode"
 	"github.com/ethereum/go-ethereum/p2p/enr"
 	"github.com/pkg/errors"
@@ -22,9 +25,7 @@ func (s *Service) currentForkDigest() ([4]byte, error) {
 	if !s.isInitialized() {
 		return [4]byte{}, errors.New("state is not initialized")
 	}
-
-	clock := startup.NewClock(s.genesisTime, [32]byte(s.genesisValidatorsRoot))
-	return params.ForkDigest(clock.CurrentEpoch()), nil
+	return forks.CreateForkDigest(s.genesisTime, s.genesisValidatorsRoot)
 }
 
 // Compares fork ENRs between an incoming peer's record and our node's
@@ -73,36 +74,41 @@ func (s *Service) compareForkENR(record *enr.Record) error {
 	return nil
 }
 
-func updateENR(node *enode.LocalNode, entry, next params.NetworkScheduleEntry) error {
+// Adds a fork entry as an ENR record under the Ethereum consensus EnrKey for
+// the local node. The fork entry is an ssz-encoded enrForkID type
+// which takes into account the current fork version from the current
+// epoch to create a fork digest, the next fork version,
+// and the next fork epoch.
+func addForkEntry(
+	node *enode.LocalNode,
+	genesisTime time.Time,
+	genesisValidatorsRoot []byte,
+) (*enode.LocalNode, error) {
+	digest, err := forks.CreateForkDigest(genesisTime, genesisValidatorsRoot)
+	if err != nil {
+		return nil, err
+	}
+	currentSlot := slots.Since(genesisTime)
+	currentEpoch := slots.ToEpoch(currentSlot)
+	if prysmTime.Now().Before(genesisTime) {
+		currentEpoch = 0
+	}
+	nextForkVersion, nextForkEpoch, err := forks.NextForkData(currentEpoch)
+	if err != nil {
+		return nil, err
+	}
 	enrForkID := &pb.ENRForkID{
-		CurrentForkDigest: entry.ForkDigest[:],
-		NextForkVersion:   next.ForkVersion[:],
-		NextForkEpoch:     next.Epoch,
+		CurrentForkDigest: digest[:],
+		NextForkVersion:   nextForkVersion[:],
+		NextForkEpoch:     nextForkEpoch,
 	}
-	if entry.Epoch == next.Epoch {
-		enrForkID.NextForkEpoch = params.BeaconConfig().FarFutureEpoch
-	}
-	logFields := logrus.Fields{
-		"CurrentForkDigest": fmt.Sprintf("%#x", enrForkID.CurrentForkDigest),
-		"NextForkVersion":   fmt.Sprintf("%#x", enrForkID.NextForkVersion),
-		"NextForkEpoch":     fmt.Sprintf("%d", enrForkID.NextForkEpoch),
-	}
-	if params.BeaconConfig().FuluForkEpoch != params.BeaconConfig().FarFutureEpoch {
-		if entry.ForkDigest == next.ForkDigest {
-			node.Set(enr.WithEntry(nfdEnrKey, make([]byte, len(next.ForkDigest))))
-		} else {
-			node.Set(enr.WithEntry(nfdEnrKey, next.ForkDigest[:]))
-		}
-		logFields[nfdEnrKey] = fmt.Sprintf("%#x", next.ForkDigest)
-	}
-	log.WithFields(logFields).Info("updating ENR Fork ID")
 	enc, err := enrForkID.MarshalSSZ()
 	if err != nil {
-		return err
+		return nil, err
 	}
 	forkEntry := enr.WithEntry(eth2ENRKey, enc)
 	node.Set(forkEntry)
-	return nil
+	return node, nil
 }
 
 // Retrieves an enrForkID from an ENR record by key lookup

beacon-chain/p2p/fork_test.go

@@ -10,11 +10,11 @@ import (
 
 	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/signing"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
@@ -230,8 +230,10 @@ func TestDiscv5_AddRetrieveForkEntryENR(t *testing.T) {
 	nextForkVersion := []byte{0, 0, 0, 1}
 	params.OverrideBeaconConfig(c)
 
-	clock := startup.NewClock(time.Now(), [32]byte{})
-	digest := params.ForkDigest(clock.CurrentEpoch())
+	genesisTime := time.Now()
+	genesisValidatorsRoot := make([]byte, 32)
+	digest, err := forks.CreateForkDigest(genesisTime, make([]byte, 32))
+	require.NoError(t, err)
 	enrForkID := &pb.ENRForkID{
 		CurrentForkDigest: digest[:],
 		NextForkVersion:   nextForkVersion,
@@ -253,7 +255,7 @@ func TestDiscv5_AddRetrieveForkEntryENR(t *testing.T) {
 	localNode := enode.NewLocalNode(db, pkey)
 	localNode.Set(entry)
 
-	want, err := signing.ComputeForkDigest([]byte{0, 0, 0, 0}, clock.GenesisValidatorsRootSlice())
+	want, err := signing.ComputeForkDigest([]byte{0, 0, 0, 0}, genesisValidatorsRoot)
 	require.NoError(t, err)
 
 	resp, err := forkEntry(localNode.Node().Record())
@@ -280,11 +282,7 @@ func TestAddForkEntry_Genesis(t *testing.T) {
 	params.OverrideBeaconConfig(bCfg)
 
 	localNode := enode.NewLocalNode(db, pkey)
-	clock := startup.NewClock(time.Now(), bCfg.GenesisValidatorsRoot)
-	current := clock.CurrentEpoch()
-	entry := params.GetNetworkScheduleEntry(current)
-	next := params.GetNetworkScheduleEntry(entry.Epoch)
-	require.NoError(t, updateENR(localNode, entry, next))
+	localNode, err = addForkEntry(localNode, time.Now().Add(10*time.Second), bytesutil.PadTo([]byte{'A', 'B', 'C', 'D'}, 32))
 	require.NoError(t, err)
 	forkEntry, err := forkEntry(localNode.Node().Record())
 	require.NoError(t, err)

beacon-chain/p2p/fork_watcher.go

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

beacon-chain/p2p/handshake.go

@@ -10,7 +10,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/peerdata"
 	prysmTime "github.com/OffchainLabs/prysm/v6/time"
-	"github.com/libp2p/go-libp2p/core/host"
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-libp2p/core/peer"
 	"github.com/pkg/errors"
@@ -28,22 +27,6 @@ func peerMultiaddrString(conn network.Conn) string {
 	return fmt.Sprintf("%s/p2p/%s", remoteMultiaddr, remotePeerID)
 }
 
-func peerAgentString(pid peer.ID, host host.Host) string {
-	const unknownAgent = "unknown"
-
-	rawAgent, err := host.Peerstore().Get(pid, "AgentVersion")
-	if err != nil {
-		return unknownAgent
-	}
-
-	agent, ok := rawAgent.(string)
-	if !ok {
-		return unknownAgent
-	}
-
-	return agent
-}
-
 func (s *Service) connectToPeer(conn network.Conn) {
 	s.peers.SetConnectionState(conn.RemotePeer(), peers.Connected)
 	// Go through the handshake process.
@@ -76,7 +59,6 @@ func (s *Service) disconnectFromPeerOnError(
 		WithError(badPeerErr).
 		WithFields(logrus.Fields{
 			"multiaddr":            peerMultiaddrString(conn),
-			"agent":                peerAgentString(remotePeerID, s.host),
 			"direction":            conn.Stat().Direction.String(),
 			"remainingActivePeers": len(s.peers.Active()),
 		}).

beacon-chain/p2p/message_id.go

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

beacon-chain/p2p/message_id_test.go

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

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

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

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

@@ -5,6 +5,7 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/peerdata"
 	"github.com/libp2p/go-libp2p/core/peer"
+	"github.com/pkg/errors"
 )
 
 var _ Scorer = (*BadResponsesScorer)(nil)
@@ -128,14 +129,13 @@ func (s *BadResponsesScorer) IsBadPeer(pid peer.ID) error {
 
 // isBadPeerNoLock is lock-free version of IsBadPeer.
 func (s *BadResponsesScorer) isBadPeerNoLock(pid peer.ID) error {
-	// if peerData, ok := s.store.PeerData(pid); ok {
-	// TODO: Remote this out of devnet
-	// if peerData.BadResponses >= s.config.Threshold {
-	// return errors.Errorf("peer exceeded bad responses threshold: got %d, threshold %d", peerData.BadResponses, s.config.Threshold)
-	// }
+	if peerData, ok := s.store.PeerData(pid); ok {
+		if peerData.BadResponses >= s.config.Threshold {
+			return errors.Errorf("peer exceeded bad responses threshold: got %d, threshold %d", peerData.BadResponses, s.config.Threshold)
+		}
 
-	// return nil
-	// }
+		return nil
+	}
 
 	return nil
 }

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

@@ -1,6 +1,7 @@
 package scorers_test
 
 import (
+	"sort"
 	"testing"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
@@ -12,41 +13,39 @@ import (
 	"github.com/libp2p/go-libp2p/core/peer"
 )
 
-// TODO: Uncomment when out of devnet
-// func TestScorers_BadResponses_Score(t *testing.T) {
-// 	const pid = "peer1"
+func TestScorers_BadResponses_Score(t *testing.T) {
+	const pid = "peer1"
 
-// 	ctx, cancel := context.WithCancel(context.Background())
-// 	defer cancel()
+	ctx := t.Context()
 
-// 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold: 4,
-// 			},
-// 		},
-// 	})
-// 	scorer := peerStatuses.Scorers().BadResponsesScorer()
+	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold: 4,
+			},
+		},
+	})
+	scorer := peerStatuses.Scorers().BadResponsesScorer()
 
-// 	assert.Equal(t, 0., scorer.Score(pid), "Unexpected score for unregistered peer")
+	assert.Equal(t, 0., scorer.Score(pid), "Unexpected score for unregistered peer")
 
-// 	scorer.Increment(pid)
-// 	assert.NoError(t, scorer.IsBadPeer(pid))
-// 	assert.Equal(t, -2.5, scorer.Score(pid))
+	scorer.Increment(pid)
+	assert.NoError(t, scorer.IsBadPeer(pid))
+	assert.Equal(t, -2.5, scorer.Score(pid))
 
-// 	scorer.Increment(pid)
-// 	assert.NoError(t, scorer.IsBadPeer(pid))
-// 	assert.Equal(t, float64(-5), scorer.Score(pid))
+	scorer.Increment(pid)
+	assert.NoError(t, scorer.IsBadPeer(pid))
+	assert.Equal(t, float64(-5), scorer.Score(pid))
 
-// 	scorer.Increment(pid)
-// 	assert.NoError(t, scorer.IsBadPeer(pid))
-// 	assert.Equal(t, float64(-7.5), scorer.Score(pid))
+	scorer.Increment(pid)
+	assert.NoError(t, scorer.IsBadPeer(pid))
+	assert.Equal(t, float64(-7.5), scorer.Score(pid))
 
-// 	scorer.Increment(pid)
-// 	assert.NotNil(t, scorer.IsBadPeer(pid))
-// 	assert.Equal(t, -100.0, scorer.Score(pid))
-// }
+	scorer.Increment(pid)
+	assert.NotNil(t, scorer.IsBadPeer(pid))
+	assert.Equal(t, -100.0, scorer.Score(pid))
+}
 
 func TestScorers_BadResponses_ParamsThreshold(t *testing.T) {
 	ctx := t.Context()
@@ -138,60 +137,56 @@ func TestScorers_BadResponses_Decay(t *testing.T) {
 	assert.Equal(t, 1, badResponses, "unexpected bad responses for pid3")
 }
 
-// TODO: Uncomment when out of devnet
-// func TestScorers_BadResponses_IsBadPeer(t *testing.T) {
-// 	ctx, cancel := context.WithCancel(context.Background())
-// 	defer cancel()
+func TestScorers_BadResponses_IsBadPeer(t *testing.T) {
+	ctx := t.Context()
 
-// 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
-// 		PeerLimit:    30,
-// 		ScorerParams: &scorers.Config{},
-// 	})
-// 	scorer := peerStatuses.Scorers().BadResponsesScorer()
-// 	pid := peer.ID("peer1")
-// 	assert.NoError(t, scorer.IsBadPeer(pid))
+	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
+		PeerLimit:    30,
+		ScorerParams: &scorers.Config{},
+	})
+	scorer := peerStatuses.Scorers().BadResponsesScorer()
+	pid := peer.ID("peer1")
+	assert.NoError(t, scorer.IsBadPeer(pid))
 
-// 	peerStatuses.Add(nil, pid, nil, network.DirUnknown)
-// 	assert.NoError(t, scorer.IsBadPeer(pid))
+	peerStatuses.Add(nil, pid, nil, network.DirUnknown)
+	assert.NoError(t, scorer.IsBadPeer(pid))
 
-// 	for i := 0; i < scorers.DefaultBadResponsesThreshold; i++ {
-// 		scorer.Increment(pid)
-// 		if i == scorers.DefaultBadResponsesThreshold-1 {
-// 			assert.NotNil(t, scorer.IsBadPeer(pid), "Unexpected peer status")
-// 		} else {
-// 			assert.NoError(t, scorer.IsBadPeer(pid), "Unexpected peer status")
-// 		}
-// 	}
-// }
+	for i := 0; i < scorers.DefaultBadResponsesThreshold; i++ {
+		scorer.Increment(pid)
+		if i == scorers.DefaultBadResponsesThreshold-1 {
+			assert.NotNil(t, scorer.IsBadPeer(pid), "Unexpected peer status")
+		} else {
+			assert.NoError(t, scorer.IsBadPeer(pid), "Unexpected peer status")
+		}
+	}
+}
 
-// TODO: Uncomment when out of devnet
-// func TestScorers_BadResponses_BadPeers(t *testing.T) {
-// 	ctx, cancel := context.WithCancel(context.Background())
-// 	defer cancel()
+func TestScorers_BadResponses_BadPeers(t *testing.T) {
+	ctx := t.Context()
 
-// 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
-// 		PeerLimit:    30,
-// 		ScorerParams: &scorers.Config{},
-// 	})
-// 	scorer := peerStatuses.Scorers().BadResponsesScorer()
-// 	pids := []peer.ID{peer.ID("peer1"), peer.ID("peer2"), peer.ID("peer3"), peer.ID("peer4"), peer.ID("peer5")}
-// 	for i := 0; i < len(pids); i++ {
-// 		peerStatuses.Add(nil, pids[i], nil, network.DirUnknown)
-// 	}
-// 	for i := 0; i < scorers.DefaultBadResponsesThreshold; i++ {
-// 		scorer.Increment(pids[1])
-// 		scorer.Increment(pids[2])
-// 		scorer.Increment(pids[4])
-// 	}
-// 	assert.NoError(t, scorer.IsBadPeer(pids[0]), "Invalid peer status")
-// 	assert.NotNil(t, scorer.IsBadPeer(pids[1]), "Invalid peer status")
-// 	assert.NotNil(t, scorer.IsBadPeer(pids[2]), "Invalid peer status")
-// 	assert.NoError(t, scorer.IsBadPeer(pids[3]), "Invalid peer status")
-// 	assert.NotNil(t, scorer.IsBadPeer(pids[4]), "Invalid peer status")
-// 	want := []peer.ID{pids[1], pids[2], pids[4]}
-// 	badPeers := scorer.BadPeers()
-// 	sort.Slice(badPeers, func(i, j int) bool {
-// 		return badPeers[i] < badPeers[j]
-// 	})
-// 	assert.DeepEqual(t, want, badPeers, "Unexpected list of bad peers")
-// }
+	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
+		PeerLimit:    30,
+		ScorerParams: &scorers.Config{},
+	})
+	scorer := peerStatuses.Scorers().BadResponsesScorer()
+	pids := []peer.ID{peer.ID("peer1"), peer.ID("peer2"), peer.ID("peer3"), peer.ID("peer4"), peer.ID("peer5")}
+	for i := 0; i < len(pids); i++ {
+		peerStatuses.Add(nil, pids[i], nil, network.DirUnknown)
+	}
+	for i := 0; i < scorers.DefaultBadResponsesThreshold; i++ {
+		scorer.Increment(pids[1])
+		scorer.Increment(pids[2])
+		scorer.Increment(pids[4])
+	}
+	assert.NoError(t, scorer.IsBadPeer(pids[0]), "Invalid peer status")
+	assert.NotNil(t, scorer.IsBadPeer(pids[1]), "Invalid peer status")
+	assert.NotNil(t, scorer.IsBadPeer(pids[2]), "Invalid peer status")
+	assert.NoError(t, scorer.IsBadPeer(pids[3]), "Invalid peer status")
+	assert.NotNil(t, scorer.IsBadPeer(pids[4]), "Invalid peer status")
+	want := []peer.ID{pids[1], pids[2], pids[4]}
+	badPeers := scorer.BadPeers()
+	sort.Slice(badPeers, func(i, j int) bool {
+		return badPeers[i] < badPeers[j]
+	})
+	assert.DeepEqual(t, want, badPeers, "Unexpected list of bad peers")
+}

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

@@ -42,7 +42,7 @@ func TestScorers_Gossip_Score(t *testing.T) {
 			},
 			check: func(scorer *scorers.GossipScorer) {
 				assert.Equal(t, 10.0, scorer.Score("peer1"), "Unexpected score")
-				assert.NoError(t, scorer.IsBadPeer("peer1"), "Unexpected bad peer")
+				assert.Equal(t, nil, scorer.IsBadPeer("peer1"), "Unexpected bad peer")
 				_, _, topicMap, err := scorer.GossipData("peer1")
 				assert.NoError(t, err)
 				assert.Equal(t, uint64(100), topicMap["a"].TimeInMesh, "incorrect time in mesh")

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

@@ -112,7 +112,7 @@ func (s *PeerStatusScorer) BadPeers() []peer.ID {
 }
 
 // SetPeerStatus sets chain state data for a given peer.
-func (s *PeerStatusScorer) SetPeerStatus(pid peer.ID, chainState *pb.StatusV2, validationError error) {
+func (s *PeerStatusScorer) SetPeerStatus(pid peer.ID, chainState *pb.Status, validationError error) {
 	s.store.Lock()
 	defer s.store.Unlock()
 
@@ -130,14 +130,14 @@ func (s *PeerStatusScorer) SetPeerStatus(pid peer.ID, chainState *pb.StatusV2, v
 // PeerStatus gets the chain state of the given remote peer.
 // This can return nil if there is no known chain state for the peer.
 // This will error if the peer does not exist.
-func (s *PeerStatusScorer) PeerStatus(pid peer.ID) (*pb.StatusV2, error) {
+func (s *PeerStatusScorer) PeerStatus(pid peer.ID) (*pb.Status, error) {
 	s.store.RLock()
 	defer s.store.RUnlock()
 	return s.peerStatusNoLock(pid)
 }
 
 // peerStatusNoLock lock-free version of PeerStatus.
-func (s *PeerStatusScorer) peerStatusNoLock(pid peer.ID) (*pb.StatusV2, error) {
+func (s *PeerStatusScorer) peerStatusNoLock(pid peer.ID) (*pb.Status, error) {
 	if peerData, ok := s.store.PeerData(pid); ok {
 		if peerData.ChainState == nil {
 			return nil, peerdata.ErrNoPeerStatus

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

@@ -35,7 +35,7 @@ func TestScorers_PeerStatus_Score(t *testing.T) {
 			name: "existent bad peer",
 			update: func(scorer *scorers.PeerStatusScorer) {
 				scorer.SetHeadSlot(0)
-				scorer.SetPeerStatus("peer1", &pb.StatusV2{
+				scorer.SetPeerStatus("peer1", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: 64,
 				}, p2ptypes.ErrWrongForkDigestVersion)
@@ -48,7 +48,7 @@ func TestScorers_PeerStatus_Score(t *testing.T) {
 			name: "existent peer no head slot for the host node is known",
 			update: func(scorer *scorers.PeerStatusScorer) {
 				scorer.SetHeadSlot(0)
-				scorer.SetPeerStatus("peer1", &pb.StatusV2{
+				scorer.SetPeerStatus("peer1", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: 64,
 				}, nil)
@@ -61,7 +61,7 @@ func TestScorers_PeerStatus_Score(t *testing.T) {
 			name: "existent peer head is before ours",
 			update: func(scorer *scorers.PeerStatusScorer) {
 				scorer.SetHeadSlot(128)
-				scorer.SetPeerStatus("peer1", &pb.StatusV2{
+				scorer.SetPeerStatus("peer1", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: 64,
 				}, nil)
@@ -75,12 +75,12 @@ func TestScorers_PeerStatus_Score(t *testing.T) {
 			update: func(scorer *scorers.PeerStatusScorer) {
 				headSlot := primitives.Slot(128)
 				scorer.SetHeadSlot(headSlot)
-				scorer.SetPeerStatus("peer1", &pb.StatusV2{
+				scorer.SetPeerStatus("peer1", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: headSlot + 64,
 				}, nil)
 				// Set another peer to a higher score.
-				scorer.SetPeerStatus("peer2", &pb.StatusV2{
+				scorer.SetPeerStatus("peer2", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: headSlot + 128,
 				}, nil)
@@ -95,7 +95,7 @@ func TestScorers_PeerStatus_Score(t *testing.T) {
 			update: func(scorer *scorers.PeerStatusScorer) {
 				headSlot := primitives.Slot(128)
 				scorer.SetHeadSlot(headSlot)
-				scorer.SetPeerStatus("peer1", &pb.StatusV2{
+				scorer.SetPeerStatus("peer1", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: headSlot + 64,
 				}, nil)
@@ -108,7 +108,7 @@ func TestScorers_PeerStatus_Score(t *testing.T) {
 			name: "existent peer no max known slot",
 			update: func(scorer *scorers.PeerStatusScorer) {
 				scorer.SetHeadSlot(0)
-				scorer.SetPeerStatus("peer1", &pb.StatusV2{
+				scorer.SetPeerStatus("peer1", &pb.Status{
 					HeadRoot: make([]byte, 32),
 					HeadSlot: 0,
 				}, nil)
@@ -141,7 +141,7 @@ func TestScorers_PeerStatus_IsBadPeer(t *testing.T) {
 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer(pid))
 	assert.NoError(t, peerStatuses.Scorers().PeerStatusScorer().IsBadPeer(pid))
 
-	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid, &pb.StatusV2{}, p2ptypes.ErrWrongForkDigestVersion)
+	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid, &pb.Status{}, p2ptypes.ErrWrongForkDigestVersion)
 	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer(pid))
 	assert.NotNil(t, peerStatuses.Scorers().PeerStatusScorer().IsBadPeer(pid))
 }
@@ -160,9 +160,9 @@ func TestScorers_PeerStatus_BadPeers(t *testing.T) {
 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer(pid3))
 	assert.NoError(t, peerStatuses.Scorers().PeerStatusScorer().IsBadPeer(pid3))
 
-	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid1, &pb.StatusV2{}, p2ptypes.ErrWrongForkDigestVersion)
-	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid2, &pb.StatusV2{}, nil)
-	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid3, &pb.StatusV2{}, p2ptypes.ErrWrongForkDigestVersion)
+	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid1, &pb.Status{}, p2ptypes.ErrWrongForkDigestVersion)
+	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid2, &pb.Status{}, nil)
+	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus(pid3, &pb.Status{}, p2ptypes.ErrWrongForkDigestVersion)
 	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer(pid1))
 	assert.NotNil(t, peerStatuses.Scorers().PeerStatusScorer().IsBadPeer(pid1))
 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer(pid2))
@@ -179,12 +179,12 @@ func TestScorers_PeerStatus_PeerStatus(t *testing.T) {
 	})
 	status, err := peerStatuses.Scorers().PeerStatusScorer().PeerStatus("peer1")
 	require.ErrorContains(t, peerdata.ErrPeerUnknown.Error(), err)
-	assert.Equal(t, (*pb.StatusV2)(nil), status)
+	assert.Equal(t, (*pb.Status)(nil), status)
 
-	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus("peer1", &pb.StatusV2{
+	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus("peer1", &pb.Status{
 		HeadSlot: 128,
 	}, nil)
-	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus("peer2", &pb.StatusV2{
+	peerStatuses.Scorers().PeerStatusScorer().SetPeerStatus("peer2", &pb.Status{
 		HeadSlot: 128,
 	}, p2ptypes.ErrInvalidEpoch)
 	status, err = peerStatuses.Scorers().PeerStatusScorer().PeerStatus("peer1")

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

@@ -211,102 +211,99 @@ func TestScorers_Service_Score(t *testing.T) {
 	})
 }
 
-// TODO: Uncomment when out of devnet
-// func TestScorers_Service_loop(t *testing.T) {
-// 	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
-// 	defer cancel()
+func TestScorers_Service_loop(t *testing.T) {
+	ctx, cancel := context.WithTimeout(t.Context(), 3*time.Second)
+	defer cancel()
 
-// 	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold:     5,
-// 				DecayInterval: 50 * time.Millisecond,
-// 			},
-// 			BlockProviderScorerConfig: &scorers.BlockProviderScorerConfig{
-// 				DecayInterval: 25 * time.Millisecond,
-// 				Decay:         64,
-// 			},
-// 		},
-// 	})
-// 	s1 := peerStatuses.Scorers().BadResponsesScorer()
-// 	s2 := peerStatuses.Scorers().BlockProviderScorer()
+	peerStatuses := peers.NewStatus(ctx, &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold:     5,
+				DecayInterval: 50 * time.Millisecond,
+			},
+			BlockProviderScorerConfig: &scorers.BlockProviderScorerConfig{
+				DecayInterval: 25 * time.Millisecond,
+				Decay:         64,
+			},
+		},
+	})
+	s1 := peerStatuses.Scorers().BadResponsesScorer()
+	s2 := peerStatuses.Scorers().BlockProviderScorer()
 
-// 	pid1 := peer.ID("peer1")
-// 	peerStatuses.Add(nil, pid1, nil, network.DirUnknown)
-// 	for i := 0; i < s1.Params().Threshold+5; i++ {
-// 		s1.Increment(pid1)
-// 	}
-// 	assert.NotNil(t, s1.IsBadPeer(pid1), "Peer should be marked as bad")
+	pid1 := peer.ID("peer1")
+	peerStatuses.Add(nil, pid1, nil, network.DirUnknown)
+	for i := 0; i < s1.Params().Threshold+5; i++ {
+		s1.Increment(pid1)
+	}
+	assert.NotNil(t, s1.IsBadPeer(pid1), "Peer should be marked as bad")
 
-// 	s2.IncrementProcessedBlocks("peer1", 221)
-// 	assert.Equal(t, uint64(221), s2.ProcessedBlocks("peer1"))
+	s2.IncrementProcessedBlocks("peer1", 221)
+	assert.Equal(t, uint64(221), s2.ProcessedBlocks("peer1"))
 
-// 	done := make(chan struct{}, 1)
-// 	go func() {
-// 		defer func() {
-// 			done <- struct{}{}
-// 		}()
-// 		ticker := time.NewTicker(50 * time.Millisecond)
-// 		defer ticker.Stop()
-// 		for {
-// 			select {
-// 			case <-ticker.C:
-// 				if s1.IsBadPeer(pid1) == nil && s2.ProcessedBlocks("peer1") == 0 {
-// 					return
-// 				}
-// 			case <-ctx.Done():
-// 				t.Error("Timed out")
-// 				return
-// 			}
-// 		}
-// 	}()
+	done := make(chan struct{}, 1)
+	go func() {
+		defer func() {
+			done <- struct{}{}
+		}()
+		ticker := time.NewTicker(50 * time.Millisecond)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				if s1.IsBadPeer(pid1) == nil && s2.ProcessedBlocks("peer1") == 0 {
+					return
+				}
+			case <-ctx.Done():
+				t.Error("Timed out")
+				return
+			}
+		}
+	}()
 
-// 	<-done
-// 	assert.NoError(t, s1.IsBadPeer(pid1), "Peer should not be marked as bad")
-// 	assert.Equal(t, uint64(0), s2.ProcessedBlocks("peer1"), "No blocks are expected")
-// }
+	<-done
+	assert.NoError(t, s1.IsBadPeer(pid1), "Peer should not be marked as bad")
+	assert.Equal(t, uint64(0), s2.ProcessedBlocks("peer1"), "No blocks are expected")
+}
 
-// TODO: Uncomment when out of devnet
-// func TestScorers_Service_IsBadPeer(t *testing.T) {
-// 	peerStatuses := peers.NewStatus(context.Background(), &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold:     2,
-// 				DecayInterval: 50 * time.Second,
-// 			},
-// 		},
-// 	})
+func TestScorers_Service_IsBadPeer(t *testing.T) {
+	peerStatuses := peers.NewStatus(t.Context(), &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold:     2,
+				DecayInterval: 50 * time.Second,
+			},
+		},
+	})
 
-// 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer1"))
-// 	peerStatuses.Scorers().BadResponsesScorer().Increment("peer1")
-// 	peerStatuses.Scorers().BadResponsesScorer().Increment("peer1")
-// 	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer("peer1"))
-// }
+	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer1"))
+	peerStatuses.Scorers().BadResponsesScorer().Increment("peer1")
+	peerStatuses.Scorers().BadResponsesScorer().Increment("peer1")
+	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer("peer1"))
+}
 
-// TODO: Uncomment when out of devnet
-// func TestScorers_Service_BadPeers(t *testing.T) {
-// 	peerStatuses := peers.NewStatus(context.Background(), &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold:     2,
-// 				DecayInterval: 50 * time.Second,
-// 			},
-// 		},
-// 	})
+func TestScorers_Service_BadPeers(t *testing.T) {
+	peerStatuses := peers.NewStatus(t.Context(), &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold:     2,
+				DecayInterval: 50 * time.Second,
+			},
+		},
+	})
 
-// 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer1"))
-// 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer2"))
-// 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer3"))
-// 	assert.Equal(t, 0, len(peerStatuses.Scorers().BadPeers()))
-// 	for _, pid := range []peer.ID{"peer1", "peer3"} {
-// 		peerStatuses.Scorers().BadResponsesScorer().Increment(pid)
-// 		peerStatuses.Scorers().BadResponsesScorer().Increment(pid)
-// 	}
-// 	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer("peer1"))
-// 	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer2"))
-// 	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer("peer3"))
-// 	assert.Equal(t, 2, len(peerStatuses.Scorers().BadPeers()))
-// }
+	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer1"))
+	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer2"))
+	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer3"))
+	assert.Equal(t, 0, len(peerStatuses.Scorers().BadPeers()))
+	for _, pid := range []peer.ID{"peer1", "peer3"} {
+		peerStatuses.Scorers().BadResponsesScorer().Increment(pid)
+		peerStatuses.Scorers().BadResponsesScorer().Increment(pid)
+	}
+	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer("peer1"))
+	assert.NoError(t, peerStatuses.Scorers().IsBadPeer("peer2"))
+	assert.NotNil(t, peerStatuses.Scorers().IsBadPeer("peer3"))
+	assert.Equal(t, 2, len(peerStatuses.Scorers().BadPeers()))
+}

beacon-chain/p2p/peers/status.go

@@ -205,14 +205,14 @@ func (p *Status) ENR(pid peer.ID) (*enr.Record, error) {
 }
 
 // SetChainState sets the chain state of the given remote peer.
-func (p *Status) SetChainState(pid peer.ID, chainState *pb.StatusV2) {
+func (p *Status) SetChainState(pid peer.ID, chainState *pb.Status) {
 	p.scorers.PeerStatusScorer().SetPeerStatus(pid, chainState, nil)
 }
 
 // ChainState gets the chain state of the given remote peer.
 // This will error if the peer does not exist.
 // This will error if there is no known chain state for the peer.
-func (p *Status) ChainState(pid peer.ID) (*pb.StatusV2, error) {
+func (p *Status) ChainState(pid peer.ID) (*pb.Status, error) {
 	return p.scorers.PeerStatusScorer().PeerStatus(pid)
 }
 
@@ -705,47 +705,31 @@ func (p *Status) deprecatedPrune() {
 	p.tallyIPTracker()
 }
 
-// BestFinalized returns the highest finalized epoch equal to or higher than `ourFinalizedEpoch`
-// that is agreed upon by the majority of peers, and the peers agreeing on this finalized epoch.
-// This method may not return the absolute highest finalized epoch, but the finalized epoch in which
-// most peers can serve blocks (plurality voting). Ideally, all peers would be reporting the same
-// finalized epoch but some may be behind due to their own latency, or because of their finalized
-// epoch at the time we queried them. Returns epoch number and list of peers that are at or beyond
-// that epoch.
+// BestFinalized returns the highest finalized epoch equal to or higher than ours that is agreed
+// upon by the majority of peers. This method may not return the absolute highest finalized, but
+// the finalized epoch in which most peers can serve blocks (plurality voting).
+// Ideally, all peers would be reporting the same finalized epoch but some may be behind due to their
+// own latency, or because of their finalized epoch at the time we queried them.
+// Returns epoch number and list of peers that are at or beyond that epoch.
 func (p *Status) BestFinalized(maxPeers int, ourFinalizedEpoch primitives.Epoch) (primitives.Epoch, []peer.ID) {
-	// Retrieve all connected peers.
 	connected := p.Connected()
-
-	// key: finalized epoch, value: number of peers that support this finalized epoch.
 	finalizedEpochVotes := make(map[primitives.Epoch]uint64)
-
-	// key: peer ID, value: finalized epoch of the peer.
 	pidEpoch := make(map[peer.ID]primitives.Epoch, len(connected))
-
-	// key: peer ID, value: head slot of the peer.
 	pidHead := make(map[peer.ID]primitives.Slot, len(connected))
-
 	potentialPIDs := make([]peer.ID, 0, len(connected))
 	for _, pid := range connected {
 		peerChainState, err := p.ChainState(pid)
-
-		// Skip if the peer's finalized epoch is not defined, or if the peer's finalized epoch is
-		// lower than ours.
-		if err != nil || peerChainState == nil || peerChainState.FinalizedEpoch < ourFinalizedEpoch {
-			continue
+		if err == nil && peerChainState != nil && peerChainState.FinalizedEpoch >= ourFinalizedEpoch {
+			finalizedEpochVotes[peerChainState.FinalizedEpoch]++
+			pidEpoch[pid] = peerChainState.FinalizedEpoch
+			potentialPIDs = append(potentialPIDs, pid)
+			pidHead[pid] = peerChainState.HeadSlot
 		}
-
-		finalizedEpochVotes[peerChainState.FinalizedEpoch]++
-
-		pidEpoch[pid] = peerChainState.FinalizedEpoch
-		pidHead[pid] = peerChainState.HeadSlot
-
-		potentialPIDs = append(potentialPIDs, pid)
 	}
 
 	// Select the target epoch, which is the epoch most peers agree upon.
-	// If there is a tie, select the highest epoch.
-	targetEpoch, mostVotes := primitives.Epoch(0), uint64(0)
+	var targetEpoch primitives.Epoch
+	var mostVotes uint64
 	for epoch, count := range finalizedEpochVotes {
 		if count > mostVotes || (count == mostVotes && epoch > targetEpoch) {
 			mostVotes = count
@@ -753,12 +737,11 @@ func (p *Status) BestFinalized(maxPeers int, ourFinalizedEpoch primitives.Epoch)
 		}
 	}
 
-	// Sort PIDs by finalized (epoch, head), in decreasing order.
+	// Sort PIDs by finalized epoch, in decreasing order.
 	sort.Slice(potentialPIDs, func(i, j int) bool {
 		if pidEpoch[potentialPIDs[i]] == pidEpoch[potentialPIDs[j]] {
 			return pidHead[potentialPIDs[i]] > pidHead[potentialPIDs[j]]
 		}
-
 		return pidEpoch[potentialPIDs[i]] > pidEpoch[potentialPIDs[j]]
 	})
 
@@ -781,42 +764,26 @@ func (p *Status) BestFinalized(maxPeers int, ourFinalizedEpoch primitives.Epoch)
 // BestNonFinalized returns the highest known epoch, higher than ours,
 // and is shared by at least minPeers.
 func (p *Status) BestNonFinalized(minPeers int, ourHeadEpoch primitives.Epoch) (primitives.Epoch, []peer.ID) {
-	// Retrieve all connected peers.
 	connected := p.Connected()
-
-	// Calculate our head slot.
-	slotsPerEpoch := params.BeaconConfig().SlotsPerEpoch
-	ourHeadSlot := slotsPerEpoch.Mul(uint64(ourHeadEpoch))
-
-	// key: head epoch, value: number of peers that support this epoch.
 	epochVotes := make(map[primitives.Epoch]uint64)
-
-	// key: peer ID, value: head epoch of the peer.
 	pidEpoch := make(map[peer.ID]primitives.Epoch, len(connected))
-
-	// key: peer ID, value: head slot of the peer.
 	pidHead := make(map[peer.ID]primitives.Slot, len(connected))
-
 	potentialPIDs := make([]peer.ID, 0, len(connected))
 
+	ourHeadSlot := params.BeaconConfig().SlotsPerEpoch.Mul(uint64(ourHeadEpoch))
 	for _, pid := range connected {
 		peerChainState, err := p.ChainState(pid)
-		// Skip if the peer's head epoch is not defined, or if the peer's head slot is
-		// lower or equal than ours.
-		if err != nil || peerChainState == nil || peerChainState.HeadSlot <= ourHeadSlot {
-			continue
+		if err == nil && peerChainState != nil && peerChainState.HeadSlot > ourHeadSlot {
+			epoch := slots.ToEpoch(peerChainState.HeadSlot)
+			epochVotes[epoch]++
+			pidEpoch[pid] = epoch
+			pidHead[pid] = peerChainState.HeadSlot
+			potentialPIDs = append(potentialPIDs, pid)
 		}
-
-		epoch := slots.ToEpoch(peerChainState.HeadSlot)
-
-		epochVotes[epoch]++
-		pidEpoch[pid] = epoch
-		pidHead[pid] = peerChainState.HeadSlot
-		potentialPIDs = append(potentialPIDs, pid)
 	}
 
 	// Select the target epoch, which has enough peers' votes (>= minPeers).
-	targetEpoch := primitives.Epoch(0)
+	var targetEpoch primitives.Epoch
 	for epoch, votes := range epochVotes {
 		if votes >= uint64(minPeers) && targetEpoch < epoch {
 			targetEpoch = epoch
@@ -1045,23 +1012,16 @@ func (p *Status) isfromBadIP(pid peer.ID) error {
 		return nil
 	}
 
-	// ip, err := manet.ToIP(peerData.Address)
-	// if err != nil {
-	// 	return errors.Wrap(err, "to ip")
-	// }
+	ip, err := manet.ToIP(peerData.Address)
+	if err != nil {
+		return errors.Wrap(err, "to ip")
+	}
 
-	// if val, ok := p.ipTracker[ip.String()]; ok {
-	// if val > CollocationLimit {
-	// TODO: Remove this out of denvet.
-	// return errors.Errorf("colocation limit exceeded: got %d - limit %d", val, CollocationLimit)
-	// log.WithFields(logrus.Fields{
-	// 	"pid":             pid,
-	// 	"ip":              ip.String(),
-	// 	"colocationCount": val,
-	// 	"colocationLimit": CollocationLimit,
-	// }).Debug("Colocation limit exceeded. Peer should be banned.")
-	// }
-	// }
+	if val, ok := p.ipTracker[ip.String()]; ok {
+		if val > CollocationLimit {
+			return errors.Errorf("collocation limit exceeded: got %d - limit %d", val, CollocationLimit)
+		}
+	}
 
 	return nil
 }

beacon-chain/p2p/peers/status_test.go

@@ -2,6 +2,7 @@ package peers_test
 
 import (
 	"crypto/rand"
+	"strconv"
 	"testing"
 	"time"
 
@@ -288,7 +289,7 @@ func TestPeerChainState(t *testing.T) {
 	require.NoError(t, err)
 
 	finalizedEpoch := primitives.Epoch(123)
-	p.SetChainState(id, &pb.StatusV2{FinalizedEpoch: finalizedEpoch})
+	p.SetChainState(id, &pb.Status{FinalizedEpoch: finalizedEpoch})
 
 	resChainState, err := p.ChainState(id)
 	require.NoError(t, err)
@@ -323,60 +324,59 @@ func TestPeerWithNilChainState(t *testing.T) {
 
 	resChainState, err := p.ChainState(id)
 	require.Equal(t, peerdata.ErrNoPeerStatus, err)
-	var nothing *pb.StatusV2
+	var nothing *pb.Status
 	require.Equal(t, resChainState, nothing)
 }
 
-// TODO: Uncomment when out of devnet
-// func TestPeerBadResponses(t *testing.T) {
-// 	maxBadResponses := 2
-// 	p := peers.NewStatus(context.Background(), &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold: maxBadResponses,
-// 			},
-// 		},
-// 	})
+func TestPeerBadResponses(t *testing.T) {
+	maxBadResponses := 2
+	p := peers.NewStatus(t.Context(), &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold: maxBadResponses,
+			},
+		},
+	})
 
-// 	id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR")
-// 	require.NoError(t, err)
-// 	{
-// 		_, err := id.MarshalBinary()
-// 		require.NoError(t, err)
-// 	}
+	id, err := peer.Decode("16Uiu2HAkyWZ4Ni1TpvDS8dPxsozmHY85KaiFjodQuV6Tz5tkHVeR")
+	require.NoError(t, err)
+	{
+		_, err := id.MarshalBinary()
+		require.NoError(t, err)
+	}
 
-// 	assert.NoError(t, p.IsBad(id), "Peer marked as bad when should be good")
+	assert.NoError(t, p.IsBad(id), "Peer marked as bad when should be good")
 
-// 	address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000")
-// 	require.NoError(t, err, "Failed to create address")
-// 	direction := network.DirInbound
-// 	p.Add(new(enr.Record), id, address, direction)
+	address, err := ma.NewMultiaddr("/ip4/213.202.254.180/tcp/13000")
+	require.NoError(t, err, "Failed to create address")
+	direction := network.DirInbound
+	p.Add(new(enr.Record), id, address, direction)
 
-// 	scorer := p.Scorers().BadResponsesScorer()
-// 	resBadResponses, err := scorer.Count(id)
-// 	require.NoError(t, err)
-// 	assert.Equal(t, 0, resBadResponses, "Unexpected bad responses")
-// 	assert.NoError(t, p.IsBad(id), "Peer marked as bad when should be good")
+	scorer := p.Scorers().BadResponsesScorer()
+	resBadResponses, err := scorer.Count(id)
+	require.NoError(t, err)
+	assert.Equal(t, 0, resBadResponses, "Unexpected bad responses")
+	assert.NoError(t, p.IsBad(id), "Peer marked as bad when should be good")
 
-// 	scorer.Increment(id)
-// 	resBadResponses, err = scorer.Count(id)
-// 	require.NoError(t, err)
-// 	assert.Equal(t, 1, resBadResponses, "Unexpected bad responses")
-// 	assert.NoError(t, p.IsBad(id), "Peer marked as bad when should be good")
+	scorer.Increment(id)
+	resBadResponses, err = scorer.Count(id)
+	require.NoError(t, err)
+	assert.Equal(t, 1, resBadResponses, "Unexpected bad responses")
+	assert.NoError(t, p.IsBad(id), "Peer marked as bad when should be good")
 
-// 	scorer.Increment(id)
-// 	resBadResponses, err = scorer.Count(id)
-// 	require.NoError(t, err)
-// 	assert.Equal(t, 2, resBadResponses, "Unexpected bad responses")
-// 	assert.NotNil(t, p.IsBad(id), "Peer not marked as bad when it should be")
+	scorer.Increment(id)
+	resBadResponses, err = scorer.Count(id)
+	require.NoError(t, err)
+	assert.Equal(t, 2, resBadResponses, "Unexpected bad responses")
+	assert.NotNil(t, p.IsBad(id), "Peer not marked as bad when it should be")
 
-// 	scorer.Increment(id)
-// 	resBadResponses, err = scorer.Count(id)
-// 	require.NoError(t, err)
-// 	assert.Equal(t, 3, resBadResponses, "Unexpected bad responses")
-// 	assert.NotNil(t, p.IsBad(id), "Peer not marked as bad when it should be")
-// }
+	scorer.Increment(id)
+	resBadResponses, err = scorer.Count(id)
+	require.NoError(t, err)
+	assert.Equal(t, 3, resBadResponses, "Unexpected bad responses")
+	assert.NotNil(t, p.IsBad(id), "Peer not marked as bad when it should be")
+}
 
 func TestAddMetaData(t *testing.T) {
 	maxBadResponses := 2
@@ -495,102 +495,100 @@ func TestPeerValidTime(t *testing.T) {
 	assert.Equal(t, numPeersConnected, len(p.Connected()), "Unexpected number of connected peers")
 }
 
-// TODO: Uncomment when out of devnet
-// func TestPrune(t *testing.T) {
-// 	maxBadResponses := 2
-// 	p := peers.NewStatus(context.Background(), &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold: maxBadResponses,
-// 			},
-// 		},
-// 	})
+func TestPrune(t *testing.T) {
+	maxBadResponses := 2
+	p := peers.NewStatus(t.Context(), &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold: maxBadResponses,
+			},
+		},
+	})
 
-// 	for i := 0; i < p.MaxPeerLimit()+100; i++ {
-// 		if i%7 == 0 {
-// 			// Peer added as disconnected.
-// 			_ = addPeer(t, p, peers.PeerDisconnected)
-// 		}
-// 		// Peer added to peer handler.
-// 		_ = addPeer(t, p, peers.PeerConnected)
-// 	}
+	for i := 0; i < p.MaxPeerLimit()+100; i++ {
+		if i%7 == 0 {
+			// Peer added as disconnected.
+			_ = addPeer(t, p, peers.Disconnected)
+		}
+		// Peer added to peer handler.
+		_ = addPeer(t, p, peers.Connected)
+	}
 
-// 	disPeers := p.Disconnected()
-// 	firstPID := disPeers[0]
-// 	secondPID := disPeers[1]
-// 	thirdPID := disPeers[2]
+	disPeers := p.Disconnected()
+	firstPID := disPeers[0]
+	secondPID := disPeers[1]
+	thirdPID := disPeers[2]
 
-// 	scorer := p.Scorers().BadResponsesScorer()
+	scorer := p.Scorers().BadResponsesScorer()
 
-// 	// Make first peer a bad peer
-// 	scorer.Increment(firstPID)
-// 	scorer.Increment(firstPID)
+	// Make first peer a bad peer
+	scorer.Increment(firstPID)
+	scorer.Increment(firstPID)
 
-// 	// Add bad response for p2.
-// 	scorer.Increment(secondPID)
+	// Add bad response for p2.
+	scorer.Increment(secondPID)
 
-// 	// Prune peers
-// 	p.Prune()
+	// Prune peers
+	p.Prune()
 
-// 	// Bad peer is expected to still be kept in handler.
-// 	badRes, err := scorer.Count(firstPID)
-// 	assert.NoError(t, err, "error is supposed to be  nil")
-// 	assert.Equal(t, 2, badRes, "Did not get expected amount")
+	// Bad peer is expected to still be kept in handler.
+	badRes, err := scorer.Count(firstPID)
+	assert.NoError(t, err, "error is supposed to be  nil")
+	assert.Equal(t, 2, badRes, "Did not get expected amount")
 
-// 	// Not so good peer is pruned away so that we can reduce the
-// 	// total size of the handler.
-// 	_, err = scorer.Count(secondPID)
-// 	assert.ErrorContains(t, "peer unknown", err)
+	// Not so good peer is pruned away so that we can reduce the
+	// total size of the handler.
+	_, err = scorer.Count(secondPID)
+	assert.ErrorContains(t, "peer unknown", err)
 
-// 	// Last peer has been removed.
-// 	_, err = scorer.Count(thirdPID)
-// 	assert.ErrorContains(t, "peer unknown", err)
-// }
+	// Last peer has been removed.
+	_, err = scorer.Count(thirdPID)
+	assert.ErrorContains(t, "peer unknown", err)
+}
 
-// TODO: Uncomment when out of devnet
-// func TestPeerIPTracker(t *testing.T) {
-// 	resetCfg := features.InitWithReset(&features.Flags{
-// 		EnablePeerScorer: false,
-// 	})
-// 	defer resetCfg()
-// 	maxBadResponses := 2
-// 	p := peers.NewStatus(context.Background(), &peers.StatusConfig{
-// 		PeerLimit: 30,
-// 		ScorerParams: &scorers.Config{
-// 			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
-// 				Threshold: maxBadResponses,
-// 			},
-// 		},
-// 	})
+func TestPeerIPTracker(t *testing.T) {
+	resetCfg := features.InitWithReset(&features.Flags{
+		EnablePeerScorer: false,
+	})
+	defer resetCfg()
+	maxBadResponses := 2
+	p := peers.NewStatus(t.Context(), &peers.StatusConfig{
+		PeerLimit: 30,
+		ScorerParams: &scorers.Config{
+			BadResponsesScorerConfig: &scorers.BadResponsesScorerConfig{
+				Threshold: maxBadResponses,
+			},
+		},
+	})
 
-// 	badIP := "211.227.218.116"
-// 	var badPeers []peer.ID
-// 	for i := 0; i < peers.CollocationLimit+10; i++ {
-// 		port := strconv.Itoa(3000 + i)
-// 		addr, err := ma.NewMultiaddr("/ip4/" + badIP + "/tcp/" + port)
-// 		if err != nil {
-// 			t.Fatal(err)
-// 		}
-// 		badPeers = append(badPeers, createPeer(t, p, addr, network.DirUnknown, peerdata.PeerConnectionState(ethpb.ConnectionState_DISCONNECTED)))
-// 	}
-// 	for _, pr := range badPeers {
-// 		assert.NotNil(t, p.IsBad(pr), "peer with bad ip is not bad")
-// 	}
+	badIP := "211.227.218.116"
+	var badPeers []peer.ID
+	for i := 0; i < peers.CollocationLimit+10; i++ {
+		port := strconv.Itoa(3000 + i)
+		addr, err := ma.NewMultiaddr("/ip4/" + badIP + "/tcp/" + port)
+		if err != nil {
+			t.Fatal(err)
+		}
+		badPeers = append(badPeers, createPeer(t, p, addr, network.DirUnknown, peerdata.ConnectionState(ethpb.ConnectionState_DISCONNECTED)))
+	}
+	for _, pr := range badPeers {
+		assert.NotNil(t, p.IsBad(pr), "peer with bad ip is not bad")
+	}
 
-// 	// Add in bad peers, so that our records are trimmed out
-// 	// from the peer store.
-// 	for i := 0; i < p.MaxPeerLimit()+100; i++ {
-// 		// Peer added to peer handler.
-// 		pid := addPeer(t, p, peers.PeerDisconnected)
-// 		p.Scorers().BadResponsesScorer().Increment(pid)
-// 	}
-// 	p.Prune()
+	// Add in bad peers, so that our records are trimmed out
+	// from the peer store.
+	for i := 0; i < p.MaxPeerLimit()+100; i++ {
+		// Peer added to peer handler.
+		pid := addPeer(t, p, peers.Disconnected)
+		p.Scorers().BadResponsesScorer().Increment(pid)
+	}
+	p.Prune()
 
-// 	for _, pr := range badPeers {
-// 		assert.NoError(t, p.IsBad(pr), "peer with good ip is regarded as bad")
-// 	}
-// }
+	for _, pr := range badPeers {
+		assert.NoError(t, p.IsBad(pr), "peer with good ip is regarded as bad")
+	}
+}
 
 func TestTrimmedOrderedPeers(t *testing.T) {
 	p := peers.NewStatus(t.Context(), &peers.StatusConfig{
@@ -618,7 +616,7 @@ func TestTrimmedOrderedPeers(t *testing.T) {
 
 	// Peer 1
 	pid1 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid1, &pb.StatusV2{
+	p.SetChainState(pid1, &pb.Status{
 		HeadSlot:       3 * params.BeaconConfig().SlotsPerEpoch,
 		FinalizedEpoch: 3,
 		FinalizedRoot:  mockroot3[:],
@@ -626,7 +624,7 @@ func TestTrimmedOrderedPeers(t *testing.T) {
 
 	// Peer 2
 	pid2 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid2, &pb.StatusV2{
+	p.SetChainState(pid2, &pb.Status{
 		HeadSlot:       4 * params.BeaconConfig().SlotsPerEpoch,
 		FinalizedEpoch: 4,
 		FinalizedRoot:  mockroot4[:],
@@ -634,7 +632,7 @@ func TestTrimmedOrderedPeers(t *testing.T) {
 
 	// Peer 3
 	pid3 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid3, &pb.StatusV2{
+	p.SetChainState(pid3, &pb.Status{
 		HeadSlot:       5 * params.BeaconConfig().SlotsPerEpoch,
 		FinalizedEpoch: 5,
 		FinalizedRoot:  mockroot5[:],
@@ -642,7 +640,7 @@ func TestTrimmedOrderedPeers(t *testing.T) {
 
 	// Peer 4
 	pid4 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid4, &pb.StatusV2{
+	p.SetChainState(pid4, &pb.Status{
 		HeadSlot:       2 * params.BeaconConfig().SlotsPerEpoch,
 		FinalizedEpoch: 2,
 		FinalizedRoot:  mockroot2[:],
@@ -650,7 +648,7 @@ func TestTrimmedOrderedPeers(t *testing.T) {
 
 	// Peer 5
 	pid5 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid5, &pb.StatusV2{
+	p.SetChainState(pid5, &pb.Status{
 		HeadSlot:       2 * params.BeaconConfig().SlotsPerEpoch,
 		FinalizedEpoch: 2,
 		FinalizedRoot:  mockroot2[:],
@@ -1014,7 +1012,7 @@ func TestStatus_BestPeer(t *testing.T) {
 				},
 			})
 			for _, peerConfig := range tt.peers {
-				p.SetChainState(addPeer(t, p, peers.Connected), &pb.StatusV2{
+				p.SetChainState(addPeer(t, p, peers.Connected), &pb.Status{
 					FinalizedEpoch: peerConfig.finalizedEpoch,
 					HeadSlot:       peerConfig.headSlot,
 				})
@@ -1041,7 +1039,7 @@ func TestBestFinalized_returnsMaxValue(t *testing.T) {
 	for i := 0; i <= maxPeers+100; i++ {
 		p.Add(new(enr.Record), peer.ID(rune(i)), nil, network.DirOutbound)
 		p.SetConnectionState(peer.ID(rune(i)), peers.Connected)
-		p.SetChainState(peer.ID(rune(i)), &pb.StatusV2{
+		p.SetChainState(peer.ID(rune(i)), &pb.Status{
 			FinalizedEpoch: 10,
 		})
 	}
@@ -1064,7 +1062,7 @@ func TestStatus_BestNonFinalized(t *testing.T) {
 	for i, headSlot := range peerSlots {
 		p.Add(new(enr.Record), peer.ID(rune(i)), nil, network.DirOutbound)
 		p.SetConnectionState(peer.ID(rune(i)), peers.Connected)
-		p.SetChainState(peer.ID(rune(i)), &pb.StatusV2{
+		p.SetChainState(peer.ID(rune(i)), &pb.Status{
 			HeadSlot: headSlot,
 		})
 	}
@@ -1087,17 +1085,17 @@ func TestStatus_CurrentEpoch(t *testing.T) {
 	})
 	// Peer 1
 	pid1 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid1, &pb.StatusV2{
+	p.SetChainState(pid1, &pb.Status{
 		HeadSlot: params.BeaconConfig().SlotsPerEpoch * 4,
 	})
 	// Peer 2
 	pid2 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid2, &pb.StatusV2{
+	p.SetChainState(pid2, &pb.Status{
 		HeadSlot: params.BeaconConfig().SlotsPerEpoch * 5,
 	})
 	// Peer 3
 	pid3 := addPeer(t, p, peers.Connected)
-	p.SetChainState(pid3, &pb.StatusV2{
+	p.SetChainState(pid3, &pb.Status{
 		HeadSlot: params.BeaconConfig().SlotsPerEpoch * 4,
 	})
 

beacon-chain/p2p/pubsub_filter.go

@@ -1,12 +1,12 @@
 package p2p
 
 import (
-	"encoding/hex"
 	"fmt"
 	"strings"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
 	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/libp2p/go-libp2p/core/peer"
@@ -32,14 +32,6 @@ var _ pubsub.SubscriptionFilter = (*Service)(nil)
 // (Note: BlobSidecar is not included in this list since it is superseded by DataColumnSidecar)
 const pubsubSubscriptionRequestLimit = 500
 
-func (s *Service) setAllForkDigests() {
-	entries := params.SortedNetworkScheduleEntries()
-	s.allForkDigests = make(map[[4]byte]struct{}, len(entries))
-	for _, entry := range entries {
-		s.allForkDigests[entry.ForkDigest] = struct{}{}
-	}
-}
-
 // CanSubscribe returns true if the topic is of interest and we could subscribe to it.
 func (s *Service) CanSubscribe(topic string) bool {
 	if !s.isInitialized() {
@@ -56,18 +48,50 @@ func (s *Service) CanSubscribe(topic string) bool {
 	if parts[1] != "eth2" {
 		return false
 	}
-
-	var digest [4]byte
-	dl, err := hex.Decode(digest[:], []byte(parts[2]))
-	if err == nil && dl != 4 {
-		err = fmt.Errorf("expected 4 bytes, got %d", dl)
-	}
+	phase0ForkDigest, err := s.currentForkDigest()
 	if err != nil {
-		log.WithError(err).WithField("topic", topic).WithField("digest", parts[2]).Error("CanSubscribe failed to parse message")
+		log.WithError(err).Error("Could not determine fork digest")
 		return false
 	}
-	if _, ok := s.allForkDigests[digest]; !ok {
-		log.WithField("topic", topic).WithField("digest", fmt.Sprintf("%#x", digest)).Error("CanSubscribe failed to find digest in allForkDigests")
+	altairForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().AltairForkEpoch, s.genesisValidatorsRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not determine altair fork digest")
+		return false
+	}
+	bellatrixForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().BellatrixForkEpoch, s.genesisValidatorsRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not determine Bellatrix fork digest")
+		return false
+	}
+	capellaForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().CapellaForkEpoch, s.genesisValidatorsRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not determine Capella fork digest")
+		return false
+	}
+	denebForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().DenebForkEpoch, s.genesisValidatorsRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not determine Deneb fork digest")
+		return false
+	}
+	electraForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().ElectraForkEpoch, s.genesisValidatorsRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not determine Electra fork digest")
+		return false
+	}
+	fuluForkDigest, err := forks.ForkDigestFromEpoch(params.BeaconConfig().FuluForkEpoch, s.genesisValidatorsRoot)
+	if err != nil {
+		log.WithError(err).Error("Could not determine Fulu fork digest")
+		return false
+	}
+	switch parts[2] {
+	case fmt.Sprintf("%x", phase0ForkDigest):
+	case fmt.Sprintf("%x", altairForkDigest):
+	case fmt.Sprintf("%x", bellatrixForkDigest):
+	case fmt.Sprintf("%x", capellaForkDigest):
+	case fmt.Sprintf("%x", denebForkDigest):
+	case fmt.Sprintf("%x", electraForkDigest):
+	case fmt.Sprintf("%x", fuluForkDigest):
+	default:
 		return false
 	}
 

beacon-chain/p2p/pubsub_filter_test.go

@@ -11,6 +11,8 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
+	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	prysmTime "github.com/OffchainLabs/prysm/v6/time"
 	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
@@ -21,8 +23,10 @@ func TestService_CanSubscribe(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	currentFork := [4]byte{0x01, 0x02, 0x03, 0x04}
 	validProtocolSuffix := "/" + encoder.ProtocolSuffixSSZSnappy
-	clock := startup.NewClock(time.Now(), [32]byte{})
-	digest := params.ForkDigest(clock.CurrentEpoch())
+	genesisTime := time.Now()
+	var valRoot [32]byte
+	digest, err := forks.CreateForkDigest(genesisTime, valRoot[:])
+	assert.NoError(t, err)
 	type test struct {
 		name  string
 		topic string
@@ -104,12 +108,11 @@ func TestService_CanSubscribe(t *testing.T) {
 		}
 		tests = append(tests, tt)
 	}
-	valRoot := clock.GenesisValidatorsRoot()
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			s := &Service{
 				genesisValidatorsRoot: valRoot[:],
-				genesisTime:           clock.GenesisTime(),
+				genesisTime:           genesisTime,
 			}
 			if got := s.CanSubscribe(tt.topic); got != tt.want {
 				t.Errorf("CanSubscribe(%s) = %v, want %v", tt.topic, got, tt.want)
@@ -217,8 +220,10 @@ func TestGossipTopicMapping_scanfcheck_GossipTopicFormattingSanityCheck(t *testi
 func TestService_FilterIncomingSubscriptions(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	validProtocolSuffix := "/" + encoder.ProtocolSuffixSSZSnappy
-	clock := startup.NewClock(time.Now(), [32]byte{})
-	digest := params.ForkDigest(clock.CurrentEpoch())
+	genesisTime := time.Now()
+	var valRoot [32]byte
+	digest, err := forks.CreateForkDigest(genesisTime, valRoot[:])
+	assert.NoError(t, err)
 	type args struct {
 		id   peer.ID
 		subs []*pubsubpb.RPC_SubOpts
@@ -315,12 +320,11 @@ func TestService_FilterIncomingSubscriptions(t *testing.T) {
 			},
 		},
 	}
-	valRoot := clock.GenesisValidatorsRoot()
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			s := &Service{
 				genesisValidatorsRoot: valRoot[:],
-				genesisTime:           clock.GenesisTime(),
+				genesisTime:           genesisTime,
 			}
 			got, err := s.FilterIncomingSubscriptions(tt.args.id, tt.args.subs)
 			if (err != nil) != tt.wantErr {

beacon-chain/p2p/rpc_topic_mappings.go

@@ -108,8 +108,6 @@ const (
 	RPCDataColumnSidecarsByRangeTopicV1 = protocolPrefix + DataColumnSidecarsByRangeName + SchemaVersionV1
 
 	// V2 RPC Topics
-	// RPCStatusTopicV2 defines the v1 topic for the status rpc method.
-	RPCStatusTopicV2 = protocolPrefix + StatusMessageName + SchemaVersionV2
 	// RPCBlocksByRangeTopicV2 defines v2 the topic for the blocks by range rpc method.
 	RPCBlocksByRangeTopicV2 = protocolPrefix + BeaconBlocksByRangeMessageName + SchemaVersionV2
 	// RPCBlocksByRootTopicV2 defines the v2 topic for the blocks by root rpc method.
@@ -132,7 +130,6 @@ var (
 	RPCTopicMappings = map[string]interface{}{
 		// RPC Status Message
 		RPCStatusTopicV1: new(pb.Status),
-		RPCStatusTopicV2: new(pb.StatusV2),
 
 		// RPC Goodbye Message
 		RPCGoodByeTopicV1: new(primitives.SSZUint64),
@@ -177,8 +174,7 @@ var (
 		protocolPrefix: true,
 	}
 
-	// Maps all the protocol message names for the different rpc
-	// topics.
+	// Maps all the protocol message names for the different rpc topics.
 	messageMapping = map[string]bool{
 		StatusMessageName:               true,
 		GoodbyeMessageName:              true,
@@ -205,7 +201,6 @@ var (
 
 	// Maps all the RPC messages which are to updated in fulu.
 	fuluMapping = map[string]string{
-		StatusMessageName:   SchemaVersionV2,
 		MetadataMessageName: SchemaVersionV3,
 	}
 

beacon-chain/p2p/rpc_topic_mappings_test.go

@@ -141,11 +141,6 @@ func TestTopicFromMessage_CorrectType(t *testing.T) {
 		require.NoError(t, err)
 		require.Equal(t, "/eth2/beacon_chain/req/beacon_blocks_by_range/2", topic)
 
-		// Modified in fulu fork.
-		topic, err = TopicFromMessage(StatusMessageName, fuluForkEpoch)
-		require.NoError(t, err)
-		require.Equal(t, "/eth2/beacon_chain/req/status/2", topic)
-
 		// Modified both in altair and fulu fork.
 		topic, err = TopicFromMessage(MetadataMessageName, fuluForkEpoch)
 		require.NoError(t, err)

beacon-chain/p2p/service.go

@@ -14,7 +14,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/types"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/config/features"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	leakybucket "github.com/OffchainLabs/prysm/v6/container/leaky-bucket"
@@ -83,8 +82,6 @@ type Service struct {
 	genesisTime           time.Time
 	genesisValidatorsRoot []byte
 	activeValidatorCount  uint64
-	clock                 *startup.Clock
-	allForkDigests        map[[4]byte]struct{}
 }
 
 // NewService initializes a new p2p service compatible with shared.Service interface. No
@@ -434,11 +431,10 @@ func (s *Service) awaitStateInitialized() {
 	if err != nil {
 		log.WithError(err).Fatal("failed to receive initial genesis data")
 	}
-	s.setAllForkDigests()
 	s.genesisTime = clock.GenesisTime()
 	gvr := clock.GenesisValidatorsRoot()
 	s.genesisValidatorsRoot = gvr[:]
-	_, err = s.currentForkDigest()
+	_, err = s.currentForkDigest() // initialize fork digest cache
 	if err != nil {
 		log.WithError(err).Error("Could not initialize fork digest")
 	}

beacon-chain/p2p/service_test.go

@@ -10,9 +10,12 @@ import (
 
 	mock "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/encoder"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers"
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/p2p/peers/scorers"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/startup"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	prysmTime "github.com/OffchainLabs/prysm/v6/time"
@@ -345,57 +348,58 @@ func TestService_JoinLeaveTopic(t *testing.T) {
 func initializeStateWithForkDigest(_ context.Context, t *testing.T, gs startup.ClockSetter) [4]byte {
 	gt := prysmTime.Now()
 	gvr := bytesutil.ToBytes32(bytesutil.PadTo([]byte("genesis validators root"), 32))
-	clock := startup.NewClock(gt, gvr)
-	require.NoError(t, gs.SetClock(clock))
+	require.NoError(t, gs.SetClock(startup.NewClock(gt, gvr)))
+
+	fd, err := forks.CreateForkDigest(gt, gvr[:])
+	require.NoError(t, err)
 
 	time.Sleep(50 * time.Millisecond) // wait for pubsub filter to initialize.
 
-	return params.ForkDigest(clock.CurrentEpoch())
+	return fd
 }
 
-// TODO: Uncomment when out of devnet
-// func TestService_connectWithPeer(t *testing.T) {
-// 	params.SetupTestConfigCleanup(t)
-// 	tests := []struct {
-// 		name    string
-// 		peers   *peers.Status
-// 		info    peer.AddrInfo
-// 		wantErr string
-// 	}{
-// 		{
-// 			name: "bad peer",
-// 			peers: func() *peers.Status {
-// 				ps := peers.NewStatus(context.Background(), &peers.StatusConfig{
-// 					ScorerParams: &scorers.Config{},
-// 				})
-// 				for i := 0; i < 10; i++ {
-// 					ps.Scorers().BadResponsesScorer().Increment("bad")
-// 				}
-// 				return ps
-// 			}(),
-// 			info:    peer.AddrInfo{ID: "bad"},
-// 			wantErr: "refused to connect to bad peer",
-// 		},
-// 	}
-// 	for _, tt := range tests {
-// 		t.Run(tt.name, func(t *testing.T) {
-// 			h, _, _ := createHost(t, 34567)
-// 			defer func() {
-// 				if err := h.Close(); err != nil {
-// 					t.Fatal(err)
-// 				}
-// 			}()
-// 			ctx := context.Background()
-// 			s := &Service{
-// 				host:  h,
-// 				peers: tt.peers,
-// 			}
-// 			err := s.connectWithPeer(ctx, tt.info)
-// 			if len(tt.wantErr) > 0 {
-// 				require.ErrorContains(t, tt.wantErr, err)
-// 			} else {
-// 				require.NoError(t, err)
-// 			}
-// 		})
-// 	}
-// }
+func TestService_connectWithPeer(t *testing.T) {
+	params.SetupTestConfigCleanup(t)
+	tests := []struct {
+		name    string
+		peers   *peers.Status
+		info    peer.AddrInfo
+		wantErr string
+	}{
+		{
+			name: "bad peer",
+			peers: func() *peers.Status {
+				ps := peers.NewStatus(t.Context(), &peers.StatusConfig{
+					ScorerParams: &scorers.Config{},
+				})
+				for i := 0; i < 10; i++ {
+					ps.Scorers().BadResponsesScorer().Increment("bad")
+				}
+				return ps
+			}(),
+			info:    peer.AddrInfo{ID: "bad"},
+			wantErr: "refused to connect to bad peer",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			h, _, _ := createHost(t, 34567)
+			defer func() {
+				if err := h.Close(); err != nil {
+					t.Fatal(err)
+				}
+			}()
+			ctx := t.Context()
+			s := &Service{
+				host:  h,
+				peers: tt.peers,
+			}
+			err := s.connectWithPeer(ctx, tt.info)
+			if len(tt.wantErr) > 0 {
+				require.ErrorContains(t, tt.wantErr, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

beacon-chain/p2p/subnets.go

@@ -23,6 +23,7 @@ import (
 	"github.com/holiman/uint256"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/go-bitfield"
+	"github.com/sirupsen/logrus"
 )
 
 var (
@@ -34,8 +35,6 @@ var (
 	custodyGroupCountEnrKey = params.BeaconNetworkConfig().CustodyGroupCountKey
 )
 
-const nfdEnrKey = "nfd" // The ENR record key for "nfd" (Next Fork Digest).
-
 // The value used with the subnet, in order
 // to create an appropriate key to retrieve
 // the relevant lock. This is used to differentiate
@@ -75,8 +74,8 @@ func (s *Service) nodeFilter(topic string, index uint64) (func(node *enode.Node)
 
 // searchForPeers performs a network search for peers subscribed to a particular subnet.
 // It exits as soon as one of these conditions is met:
-// - It looped during `batchPeriod` duration, or
-// - It found `peersToFindCount“ peers corresponding to the `filter` criteria, or
+// - It looped through `batchSize` nodes.
+// - It found `peersToFindCount“ peers corresponding to the `filter` criteria.
 // - Iterator is exhausted.
 func searchForPeers(
 	iterator enode.Iterator,
@@ -148,6 +147,8 @@ func (s *Service) FindPeersWithSubnet(
 	index uint64,
 	threshold int,
 ) (bool, error) {
+	const minLogInterval = 1 * time.Minute
+
 	ctx, span := trace.StartSpan(ctx, "p2p.FindPeersWithSubnet")
 	defer span.End()
 
@@ -167,29 +168,41 @@ func (s *Service) FindPeersWithSubnet(
 		return false, errors.Wrap(err, "node filter")
 	}
 
-	peersSummary := func(topic string, threshold int) int {
+	peersSummary := func(topic string, threshold int) (int, int) {
 		// Retrieve how many peers we have for this topic.
 		peerCountForTopic := len(s.pubsub.ListPeers(topic))
 
 		// Compute how many peers we are missing to reach the threshold.
 		missingPeerCountForTopic := max(0, threshold-peerCountForTopic)
 
-		return missingPeerCountForTopic
+		return peerCountForTopic, missingPeerCountForTopic
 	}
 
 	// Compute how many peers we are missing to reach the threshold.
-	missingPeerCountForTopic := peersSummary(topic, threshold)
+	peerCountForTopic, missingPeerCountForTopic := peersSummary(topic, threshold)
 
 	// Exit early if we have enough peers.
 	if missingPeerCountForTopic == 0 {
 		return true, nil
 	}
 
+	log := log.WithFields(logrus.Fields{
+		"topic":           topic,
+		"targetPeerCount": threshold,
+	})
+
+	log.WithField("currentPeerCount", peerCountForTopic).Debug("Searching for new peers for a subnet - start")
+
+	lastLogTime := time.Now()
+
 	wg := new(sync.WaitGroup)
 	for {
 		// If the context is done, we can exit the loop. This is the unhappy path.
-		if ctx.Err() != nil {
-			return false, nil
+		if err := ctx.Err(); err != nil {
+			return false, errors.Errorf(
+				"unable to find requisite number of peers for topic %s - only %d out of %d peers available after searching",
+				topic, peerCountForTopic, threshold,
+			)
 		}
 
 		// Search for new peers in the network.
@@ -212,14 +225,20 @@ func (s *Service) FindPeersWithSubnet(
 			wg.Wait()
 		}
 
-		missingPeerCountForTopic := peersSummary(topic, threshold)
+		peerCountForTopic, missingPeerCountForTopic := peersSummary(topic, threshold)
 
 		// If we have enough peers, we can exit the loop. This is the happy path.
 		if missingPeerCountForTopic == 0 {
 			break
 		}
+
+		if time.Since(lastLogTime) > minLogInterval {
+			lastLogTime = time.Now()
+			log.WithField("currentPeerCount", peerCountForTopic).Debug("Searching for new peers for a subnet - continue")
+		}
 	}
 
+	log.WithField("currentPeerCount", threshold).Debug("Searching for new peers for a subnet - success")
 	return true, nil
 }
 
@@ -317,23 +336,11 @@ func (s *Service) updateSubnetRecordWithMetadata(bitV bitfield.Bitvector64) {
 // with a new value for a bitfield of subnets tracked. It also record's
 // the sync committee subnet in the enr. It also updates the node's
 // metadata by increasing the sequence number and the subnets tracked by the node.
-func (s *Service) updateSubnetRecordWithMetadataV2(
-	bitVAtt bitfield.Bitvector64,
-	bitVSync bitfield.Bitvector4,
-	custodyGroupCount uint64,
-) {
+func (s *Service) updateSubnetRecordWithMetadataV2(bitVAtt bitfield.Bitvector64, bitVSync bitfield.Bitvector4) {
 	entry := enr.WithEntry(attSubnetEnrKey, &bitVAtt)
 	subEntry := enr.WithEntry(syncCommsSubnetEnrKey, &bitVSync)
-
-	localNode := s.dv5Listener.LocalNode()
-	localNode.Set(entry)
-	localNode.Set(subEntry)
-
-	if params.FuluEnabled() {
-		custodyGroupCountEntry := enr.WithEntry(custodyGroupCountEnrKey, custodyGroupCount)
-		localNode.Set(custodyGroupCountEntry)
-	}
-
+	s.dv5Listener.LocalNode().Set(entry)
+	s.dv5Listener.LocalNode().Set(subEntry)
 	s.metaData = wrapper.WrappedMetadataV1(&pb.MetaDataV1{
 		SeqNumber: s.metaData.SequenceNumber() + 1,
 		Attnets:   bitVAtt,
@@ -360,8 +367,10 @@ func (s *Service) updateSubnetRecordWithMetadataV3(
 	localNode.Set(syncSubnetsEntry)
 	localNode.Set(custodyGroupCountEntry)
 
+	newSeqNumber := s.metaData.SequenceNumber() + 1
+
 	s.metaData = wrapper.WrappedMetadataV2(&pb.MetaDataV2{
-		SeqNumber:         s.metaData.SequenceNumber() + 1,
+		SeqNumber:         newSeqNumber,
 		Attnets:           bitVAtt,
 		Syncnets:          bitVSync,
 		CustodyGroupCount: custodyGroupCount,

beacon-chain/p2p/testing/mock_peersprovider.go

@@ -65,7 +65,7 @@ func (m *MockPeersProvider) Peers() *peers.Status {
 		}
 		m.peers.Add(createENR(), id0, ma0, network.DirInbound)
 		m.peers.SetConnectionState(id0, peers.Connected)
-		m.peers.SetChainState(id0, &pb.StatusV2{FinalizedEpoch: 10})
+		m.peers.SetChainState(id0, &pb.Status{FinalizedEpoch: 10})
 		id1, err := peer.Decode(MockRawPeerId1)
 		if err != nil {
 			log.WithError(err).Debug("Cannot decode")
@@ -76,7 +76,7 @@ func (m *MockPeersProvider) Peers() *peers.Status {
 		}
 		m.peers.Add(createENR(), id1, ma1, network.DirOutbound)
 		m.peers.SetConnectionState(id1, peers.Connected)
-		m.peers.SetChainState(id1, &pb.StatusV2{FinalizedEpoch: 11})
+		m.peers.SetChainState(id1, &pb.Status{FinalizedEpoch: 11})
 	}
 	return m.peers
 }

beacon-chain/p2p/types/types.go

@@ -206,8 +206,8 @@ func (s BlobSidecarsByRootReq) Swap(i, j int) {
 }
 
 // Len is the number of elements in the collection.
-func (s *BlobSidecarsByRootReq) Len() int {
-	return len(*s)
+func (s BlobSidecarsByRootReq) Len() int {
+	return len(s)
 }
 
 // ====================================

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

@@ -9,6 +9,7 @@ go_library(
         "//api/server/structs:go_default_library",
         "//config/params:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
+        "//network/forks:go_default_library",
         "//network/httputil:go_default_library",
         "@com_github_ethereum_go_ethereum//common/hexutil:go_default_library",
     ],
@@ -21,6 +22,9 @@ go_test(
     deps = [
         "//api/server/structs:go_default_library",
         "//config/params:go_default_library",
+        "//consensus-types/primitives:go_default_library",
+        "//encoding/bytesutil:go_default_library",
+        "//network/forks:go_default_library",
         "//testing/assert:go_default_library",
         "//testing/require:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",

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

@@ -10,6 +10,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 )
@@ -32,25 +33,34 @@ func GetForkSchedule(w http.ResponseWriter, r *http.Request) {
 	_, span := trace.StartSpan(r.Context(), "config.GetForkSchedule")
 	defer span.End()
 
-	schedule := params.SortedForkSchedule()
-	data := make([]*structs.Fork, 0, len(schedule))
+	schedule := params.BeaconConfig().ForkVersionSchedule
 	if len(schedule) == 0 {
 		httputil.WriteJson(w, &structs.GetForkScheduleResponse{
-			Data: data,
+			Data: make([]*structs.Fork, 0),
 		})
+		return
 	}
-	previous := schedule[0]
-	for _, entry := range schedule {
-		data = append(data, &structs.Fork{
-			PreviousVersion: hexutil.Encode(previous.ForkVersion[:]),
-			CurrentVersion:  hexutil.Encode(entry.ForkVersion[:]),
-			Epoch:           fmt.Sprintf("%d", entry.Epoch),
-		})
-		previous = entry
+
+	versions := forks.SortedForkVersions(schedule)
+	chainForks := make([]*structs.Fork, len(schedule))
+	var previous, current []byte
+	for i, v := range versions {
+		if i == 0 {
+			previous = params.BeaconConfig().GenesisForkVersion
+		} else {
+			previous = current
+		}
+		copyV := v
+		current = copyV[:]
+		chainForks[i] = &structs.Fork{
+			PreviousVersion: hexutil.Encode(previous),
+			CurrentVersion:  hexutil.Encode(current),
+			Epoch:           fmt.Sprintf("%d", schedule[v]),
+		}
 	}
 
 	httputil.WriteJson(w, &structs.GetForkScheduleResponse{
-		Data: data,
+		Data: chainForks,
 	})
 }
 

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

@@ -11,6 +11,9 @@ import (
 
 	"github.com/OffchainLabs/prysm/v6/api/server/structs"
 	"github.com/OffchainLabs/prysm/v6/config/params"
+	"github.com/OffchainLabs/prysm/v6/consensus-types/primitives"
+	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/ethereum/go-ethereum/common"
@@ -583,34 +586,43 @@ func TestGetSpec(t *testing.T) {
 
 func TestForkSchedule_Ok(t *testing.T) {
 	t.Run("ok", func(t *testing.T) {
+		genesisForkVersion := []byte("Genesis")
+		firstForkVersion, firstForkEpoch := []byte("Firs"), primitives.Epoch(100)
+		secondForkVersion, secondForkEpoch := []byte("Seco"), primitives.Epoch(200)
+		thirdForkVersion, thirdForkEpoch := []byte("Thir"), primitives.Epoch(300)
 
 		params.SetupTestConfigCleanup(t)
 		config := params.BeaconConfig().Copy()
-		config.InitializeForkSchedule()
+		config.GenesisForkVersion = genesisForkVersion
+		// Create fork schedule adding keys in non-sorted order.
+		schedule := make(map[[4]byte]primitives.Epoch, 3)
+		schedule[bytesutil.ToBytes4(secondForkVersion)] = secondForkEpoch
+		schedule[bytesutil.ToBytes4(firstForkVersion)] = firstForkEpoch
+		schedule[bytesutil.ToBytes4(thirdForkVersion)] = thirdForkEpoch
+		config.ForkVersionSchedule = schedule
+		params.OverrideBeaconConfig(config)
 
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/config/fork_schedule", nil)
 		writer := httptest.NewRecorder()
 		writer.Body = &bytes.Buffer{}
 
-		genesisStr, firstStr, secondStr := hexutil.Encode(config.GenesisForkVersion), hexutil.Encode(config.AltairForkVersion), hexutil.Encode(config.BellatrixForkVersion)
 		GetForkSchedule(writer, request)
 		require.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.GetForkScheduleResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		schedule := params.SortedForkSchedule()
-		require.Equal(t, len(schedule), len(resp.Data))
+		require.Equal(t, 3, len(resp.Data))
 		fork := resp.Data[0]
-		assert.Equal(t, genesisStr, fork.PreviousVersion)
-		assert.Equal(t, genesisStr, fork.CurrentVersion)
-		assert.Equal(t, fmt.Sprintf("%d", config.GenesisEpoch), fork.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(genesisForkVersion), fork.PreviousVersion)
+		assert.DeepEqual(t, hexutil.Encode(firstForkVersion), fork.CurrentVersion)
+		assert.Equal(t, fmt.Sprintf("%d", firstForkEpoch), fork.Epoch)
 		fork = resp.Data[1]
-		assert.Equal(t, genesisStr, fork.PreviousVersion)
-		assert.Equal(t, firstStr, fork.CurrentVersion)
-		assert.Equal(t, fmt.Sprintf("%d", config.AltairForkEpoch), fork.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(firstForkVersion), fork.PreviousVersion)
+		assert.DeepEqual(t, hexutil.Encode(secondForkVersion), fork.CurrentVersion)
+		assert.Equal(t, fmt.Sprintf("%d", secondForkEpoch), fork.Epoch)
 		fork = resp.Data[2]
-		assert.Equal(t, firstStr, fork.PreviousVersion)
-		assert.Equal(t, secondStr, fork.CurrentVersion)
-		assert.Equal(t, fmt.Sprintf("%d", config.BellatrixForkEpoch), fork.Epoch)
+		assert.DeepEqual(t, hexutil.Encode(secondForkVersion), fork.PreviousVersion)
+		assert.DeepEqual(t, hexutil.Encode(thirdForkVersion), fork.CurrentVersion)
+		assert.Equal(t, fmt.Sprintf("%d", thirdForkEpoch), fork.Epoch)
 	})
 	t.Run("correct number of forks", func(t *testing.T) {
 		request := httptest.NewRequest(http.MethodGet, "http://example.com/eth/v1/config/fork_schedule", nil)
@@ -621,7 +633,7 @@ func TestForkSchedule_Ok(t *testing.T) {
 		require.Equal(t, http.StatusOK, writer.Code)
 		resp := &structs.GetForkScheduleResponse{}
 		require.NoError(t, json.Unmarshal(writer.Body.Bytes(), resp))
-		os := params.SortedForkSchedule()
-		assert.Equal(t, len(os), len(resp.Data))
+		os := forks.NewOrderedSchedule(params.BeaconConfig())
+		assert.Equal(t, os.Len(), len(resp.Data))
 	})
 }

beacon-chain/rpc/eth/light-client/BUILD.bazel

@@ -20,6 +20,7 @@ go_library(
         "//config/params:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
+        "//network/forks:go_default_library",
         "//network/httputil:go_default_library",
         "//runtime/version:go_default_library",
         "//time/slots:go_default_library",

beacon-chain/rpc/eth/light-client/handlers.go

@@ -11,6 +11,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	"github.com/OffchainLabs/prysm/v6/network/httputil"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -114,7 +115,7 @@ func (s *Server) GetLightClientUpdatesByRange(w http.ResponseWriter, req *http.R
 
 			updateSlot := update.AttestedHeader().Beacon().Slot
 			updateEpoch := slots.ToEpoch(updateSlot)
-			updateFork, err := params.Fork(updateEpoch)
+			updateFork, err := forks.Fork(updateEpoch)
 			if err != nil {
 				httputil.HandleError(w, "Could not get fork Version: "+err.Error(), http.StatusInternalServerError)
 				return

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

@@ -83,10 +83,8 @@ func (s *Server) GetIdentity(w http.ResponseWriter, r *http.Request) {
 			P2PAddresses:       p2pAddresses,
 			DiscoveryAddresses: discoveryAddresses,
 			Metadata: &structs.Metadata{
-				SeqNumber:         strconv.FormatUint(s.MetadataProvider.MetadataSeq(), 10),
-				Attnets:           hexutil.Encode(s.MetadataProvider.Metadata().AttnetsBitfield()),
-				Syncnets:          hexutil.Encode(s.MetadataProvider.Metadata().SyncnetsBitfield()),
-				CustodyGroupCount: strconv.FormatUint(s.MetadataProvider.Metadata().CustodyGroupCount(), 10),
+				SeqNumber: strconv.FormatUint(s.MetadataProvider.MetadataSeq(), 10),
+				Attnets:   hexutil.Encode(s.MetadataProvider.Metadata().AttnetsBitfield()),
 			},
 		},
 	}

beacon-chain/rpc/lookup/BUILD.bazel

@@ -10,13 +10,11 @@ go_library(
     visibility = ["//visibility:public"],
     deps = [
         "//beacon-chain/blockchain:go_default_library",
-        "//beacon-chain/core/peerdas:go_default_library",
         "//beacon-chain/db:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/rpc/core:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
-        "//cmd/beacon-chain/flags:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
@@ -38,7 +36,6 @@ go_test(
     ],
     embed = [":go_default_library"],
     deps = [
-        "//beacon-chain/blockchain/kzg:go_default_library",
         "//beacon-chain/blockchain/testing:go_default_library",
         "//beacon-chain/db/filesystem:go_default_library",
         "//beacon-chain/db/testing:go_default_library",
@@ -50,16 +47,12 @@ go_test(
         "//beacon-chain/verification:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
-        "//consensus-types/interfaces:go_default_library",
         "//consensus-types/primitives:go_default_library",
         "//encoding/bytesutil:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//testing/assert: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_ethereum_go_ethereum//common/hexutil:go_default_library",
-        "@com_github_sirupsen_logrus//:go_default_library",
     ],
 )

beacon-chain/rpc/lookup/blocker.go

@@ -3,15 +3,12 @@ package lookup
 import (
 	"context"
 	"fmt"
-	"math"
 	"strconv"
 
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/rpc/core"
-	"github.com/OffchainLabs/prysm/v6/cmd/beacon-chain/flags"
 	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
@@ -52,7 +49,6 @@ type BeaconDbBlocker struct {
 	ChainInfoFetcher   blockchain.ChainInfoFetcher
 	GenesisTimeFetcher blockchain.TimeFetcher
 	BlobStorage        *filesystem.BlobStorage
-	DataColumnStorage  *filesystem.DataColumnStorage
 }
 
 // Block returns the beacon block for a given identifier. The identifier can be one of:
@@ -133,137 +129,6 @@ func (p *BeaconDbBlocker) Block(ctx context.Context, id []byte) (interfaces.Read
 	return blk, nil
 }
 
-// blobsFromStoredBlobs retrieves blobs corresponding to `indices` and `root` from the store.
-// This function expects blobs to be stored directly (aka. no data columns).
-func (p *BeaconDbBlocker) blobsFromStoredBlobs(indices []int, root []byte, commitments [][]byte) ([]*blocks.VerifiedROBlob, *core.RpcError) {
-	sum := p.BlobStorage.Summary(bytesutil.ToBytes32(root))
-
-	if len(indices) == 0 {
-		for index := range commitments {
-			if sum.HasIndex(uint64(index)) {
-				indices = append(indices, index)
-			}
-		}
-	} else {
-		for _, index := range indices {
-			if uint64(index) >= sum.MaxBlobsForEpoch() {
-				return nil, &core.RpcError{
-					Err:    fmt.Errorf("requested index %d is bigger than the maximum possible blob count %d", index, sum.MaxBlobsForEpoch()),
-					Reason: core.BadRequest,
-				}
-			}
-
-			if !sum.HasIndex(uint64(index)) {
-				return nil, &core.RpcError{
-					Err:    fmt.Errorf("requested index %d not found", index),
-					Reason: core.NotFound,
-				}
-			}
-		}
-	}
-
-	blobs := make([]*blocks.VerifiedROBlob, 0, len(indices))
-	for _, index := range indices {
-		vblob, err := p.BlobStorage.Get(bytesutil.ToBytes32(root), uint64(index))
-		if err != nil {
-			return nil, &core.RpcError{
-				Err:    fmt.Errorf("could not retrieve blob for block root %#x at index %d", root, index),
-				Reason: core.Internal,
-			}
-		}
-		blobs = append(blobs, &vblob)
-	}
-
-	return blobs, nil
-}
-
-// blobsFromStoredDataColumns retrieves data columns from the store, reconstruct the whole matrix if needed, convert the matrix to blobs,
-// and then returns blobs corresponding to `indices` and `root` from the store,
-// This function expects data columns to be stored (aka. no blobs).
-// If not enough data columns are available to extract blobs from them (either directly or after reconstruction), an error is returned.
-func (p *BeaconDbBlocker) blobsFromStoredDataColumns(block blocks.ROBlock, indices []int, rootBytes []byte) ([]*blocks.VerifiedROBlob, *core.RpcError) {
-	root := bytesutil.ToBytes32(rootBytes)
-
-	// Use all indices if none are provided.
-	if len(indices) == 0 {
-		commitments, err := block.Block().Body().BlobKzgCommitments()
-		if err != nil {
-			return nil, &core.RpcError{
-				Err:    errors.Wrap(err, "could not retrieve blob commitments"),
-				Reason: core.Internal,
-			}
-		}
-
-		for index := range commitments {
-			indices = append(indices, index)
-		}
-	}
-
-	// Count how many columns we have in the store.
-	summary := p.DataColumnStorage.Summary(root)
-	stored := summary.Stored()
-	count := uint64(len(stored))
-
-	if count < peerdas.MinimumColumnsCountToReconstruct() {
-		// There is no way to reconstruct the data columns.
-		return nil, &core.RpcError{
-			Err:    errors.Errorf("the node does not custody enough data columns to reconstruct blobs. Please start the beacon node with the `--%s` flag to ensure this call to success, or retry later if it is already the case.", flags.SubscribeAllDataSubnets.Name),
-			Reason: core.NotFound,
-		}
-	}
-
-	// Retrieve from the database needed data columns.
-	verifiedRoDataColumnSidecars, err := p.neededDataColumnSidecars(root, stored)
-	if err != nil {
-		return nil, &core.RpcError{
-			Err:    errors.Wrap(err, "needed data column sidecars"),
-			Reason: core.Internal,
-		}
-	}
-
-	verifiedRoBlobSidecars, err := peerdas.ReconstructBlobs(block, verifiedRoDataColumnSidecars, indices)
-	if err != nil {
-		return nil, &core.RpcError{
-			Err:    errors.Wrap(err, "blobs from data columns"),
-			Reason: core.Internal,
-		}
-	}
-
-	return verifiedRoBlobSidecars, nil
-}
-
-func (p *BeaconDbBlocker) neededDataColumnSidecars(root [fieldparams.RootLength]byte, stored map[uint64]bool) ([]blocks.VerifiedRODataColumn, error) {
-	// Check if we have all the non-extended data columns.
-	cellsPerBlob := fieldparams.CellsPerBlob
-	blobIndices := make([]uint64, 0, cellsPerBlob)
-	hasAllBlobColumns := true
-	for i := range uint64(cellsPerBlob) {
-		if !stored[i] {
-			hasAllBlobColumns = false
-			break
-		}
-		blobIndices = append(blobIndices, i)
-	}
-
-	if hasAllBlobColumns {
-		// Retrieve only the non-extended data columns.
-		verifiedRoSidecars, err := p.DataColumnStorage.Get(root, blobIndices)
-		if err != nil {
-			return nil, errors.Wrap(err, "data columns storage get")
-		}
-
-		return verifiedRoSidecars, nil
-	}
-
-	// Retrieve all the data columns.
-	verifiedRoSidecars, err := p.DataColumnStorage.Get(root, nil)
-	if err != nil {
-		return nil, errors.Wrap(err, "data columns storage get")
-	}
-
-	return verifiedRoSidecars, nil
-}
-
 // Blobs returns the blobs for a given block id identifier and blob indices. The identifier can be one of:
 //   - "head" (canonical head in node's view)
 //   - "genesis"
@@ -347,55 +212,64 @@ func (p *BeaconDbBlocker) Blobs(ctx context.Context, id string, indices []int) (
 
 	root := bytesutil.ToBytes32(rootSlice)
 
-	roSignedBlock, err := p.BeaconDB.Block(ctx, root)
+	b, err := p.BeaconDB.Block(ctx, root)
 	if err != nil {
 		return nil, &core.RpcError{Err: errors.Wrapf(err, "failed to retrieve block %#x from db", rootSlice), Reason: core.Internal}
 	}
-
-	if roSignedBlock == nil {
+	if b == nil {
 		return nil, &core.RpcError{Err: fmt.Errorf("block %#x not found in db", rootSlice), Reason: core.NotFound}
 	}
 
-	// If block is not in the retention window, return 200 w/ empty list
-	if !p.BlobStorage.WithinRetentionPeriod(slots.ToEpoch(roSignedBlock.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
+	// if block is not in the retention window, return 200 w/ empty list
+	if !p.BlobStorage.WithinRetentionPeriod(slots.ToEpoch(b.Block().Slot()), slots.ToEpoch(p.GenesisTimeFetcher.CurrentSlot())) {
 		return make([]*blocks.VerifiedROBlob, 0), nil
 	}
 
-	roBlock := roSignedBlock.Block()
-
-	commitments, err := roBlock.Body().BlobKzgCommitments()
+	commitments, err := b.Block().Body().BlobKzgCommitments()
 	if err != nil {
 		return nil, &core.RpcError{Err: errors.Wrapf(err, "failed to retrieve kzg commitments from block %#x", rootSlice), Reason: core.Internal}
 	}
-
 	// if there are no commitments return 200 w/ empty list
 	if len(commitments) == 0 {
 		return make([]*blocks.VerifiedROBlob, 0), nil
 	}
 
-	// Get the slot of the block.
-	blockSlot := roBlock.Slot()
+	sum := p.BlobStorage.Summary(root)
 
-	// Get the first peerDAS epoch.
-	fuluForkEpoch := params.BeaconConfig().FuluForkEpoch
-
-	// Compute the first peerDAS slot.
-	fuluForkSlot := primitives.Slot(math.MaxUint64)
-	if fuluForkEpoch != primitives.Epoch(math.MaxUint64) {
-		fuluForkSlot, err = slots.EpochStart(fuluForkEpoch)
-		if err != nil {
-			return nil, &core.RpcError{Err: errors.Wrap(err, "could not calculate peerDAS start slot"), Reason: core.Internal}
+	if len(indices) == 0 {
+		for i := range commitments {
+			if sum.HasIndex(uint64(i)) {
+				indices = append(indices, i)
+			}
+		}
+	} else {
+		for _, ix := range indices {
+			if uint64(ix) >= sum.MaxBlobsForEpoch() {
+				return nil, &core.RpcError{
+					Err:    fmt.Errorf("requested index %d is bigger than the maximum possible blob count %d", ix, sum.MaxBlobsForEpoch()),
+					Reason: core.BadRequest,
+				}
+			}
+			if !sum.HasIndex(uint64(ix)) {
+				return nil, &core.RpcError{
+					Err:    fmt.Errorf("requested index %d not found", ix),
+					Reason: core.NotFound,
+				}
+			}
 		}
 	}
 
-	if blockSlot >= fuluForkSlot {
-		roBlock, err := blocks.NewROBlockWithRoot(roSignedBlock, root)
+	blobs := make([]*blocks.VerifiedROBlob, len(indices))
+	for i, index := range indices {
+		vblob, err := p.BlobStorage.Get(root, uint64(index))
 		if err != nil {
-			return nil, &core.RpcError{Err: errors.Wrapf(err, "failed to create roBlock with root %#x", root), Reason: core.Internal}
+			return nil, &core.RpcError{
+				Err:    fmt.Errorf("could not retrieve blob for block root %#x at index %d", rootSlice, index),
+				Reason: core.Internal,
+			}
 		}
-
-		return p.blobsFromStoredDataColumns(roBlock, indices, rootSlice)
+		blobs[i] = &vblob
 	}
 
-	return p.blobsFromStoredBlobs(indices, rootSlice, commitments)
+	return blobs, nil
 }

beacon-chain/rpc/lookup/blocker_test.go

@@ -1,9 +1,6 @@
 package lookup
 
 import (
-	"bytes"
-	"crypto/sha256"
-	"encoding/binary"
 	"fmt"
 	"math"
 	"net/http"
@@ -11,7 +8,6 @@ import (
 	"testing"
 	"time"
 
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/kzg"
 	mockChain "github.com/OffchainLabs/prysm/v6/beacon-chain/blockchain/testing"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/filesystem"
 	testDB "github.com/OffchainLabs/prysm/v6/beacon-chain/db/testing"
@@ -20,16 +16,12 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/verification"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
-	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/testing/assert"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/consensys/gnark-crypto/ecc/bls12-381/fr"
-	GoKZG "github.com/crate-crypto/go-kzg-4844"
 	"github.com/ethereum/go-ethereum/common/hexutil"
-	"github.com/sirupsen/logrus"
 )
 
 func TestGetBlock(t *testing.T) {
@@ -165,118 +157,6 @@ func TestGetBlock(t *testing.T) {
 	}
 }
 
-func deterministicRandomness(seed int64) [32]byte {
-	// Converts an int64 to a byte slice
-	buf := new(bytes.Buffer)
-	err := binary.Write(buf, binary.BigEndian, seed)
-	if err != nil {
-		logrus.WithError(err).Error("Failed to write int64 to bytes buffer")
-		return [32]byte{}
-	}
-	bytes := buf.Bytes()
-
-	return sha256.Sum256(bytes)
-}
-
-// Returns a serialized random field element in big-endian
-func getRandFieldElement(seed int64) [32]byte {
-	bytes := deterministicRandomness(seed)
-	var r fr.Element
-	r.SetBytes(bytes[:])
-
-	return GoKZG.SerializeScalar(r)
-}
-
-// Returns a random blob using the passed seed as entropy
-func getRandBlob(seed int64) kzg.Blob {
-	var blob kzg.Blob
-	for i := 0; i < len(blob); i += 32 {
-		fieldElementBytes := getRandFieldElement(seed + int64(i))
-		copy(blob[i:i+32], fieldElementBytes[:])
-	}
-	return blob
-}
-
-func generateCommitmentAndProof(blob *kzg.Blob) (*kzg.Commitment, *kzg.Proof, error) {
-	commitment, err := kzg.BlobToKZGCommitment(blob)
-	if err != nil {
-		return nil, nil, err
-	}
-	proof, err := kzg.ComputeBlobKZGProof(blob, commitment)
-	if err != nil {
-		return nil, nil, err
-	}
-	return &commitment, &proof, err
-}
-
-func generateRandomBlocSignedBeaconBlockkAndVerifiedRoBlobs(t *testing.T, blobCount int) (interfaces.SignedBeaconBlock, []*blocks.VerifiedROBlob) {
-	// Create a protobuf signed beacon block.
-	signedBeaconBlockPb := util.NewBeaconBlockDeneb()
-
-	// Generate random blobs and their corresponding commitments and proofs.
-	blobs := make([]kzg.Blob, 0, blobCount)
-	blobKzgCommitments := make([]*kzg.Commitment, 0, blobCount)
-	blobKzgProofs := make([]*kzg.Proof, 0, blobCount)
-
-	for blobIndex := range blobCount {
-		// Create a random blob.
-		blob := getRandBlob(int64(blobIndex))
-		blobs = append(blobs, blob)
-
-		// Generate a blobKZGCommitment for the blob.
-		blobKZGCommitment, proof, err := generateCommitmentAndProof(&blob)
-		require.NoError(t, err)
-
-		blobKzgCommitments = append(blobKzgCommitments, blobKZGCommitment)
-		blobKzgProofs = append(blobKzgProofs, proof)
-	}
-
-	// Set the commitments into the block.
-	blobZkgCommitmentsBytes := make([][]byte, 0, blobCount)
-	for _, blobKZGCommitment := range blobKzgCommitments {
-		blobZkgCommitmentsBytes = append(blobZkgCommitmentsBytes, blobKZGCommitment[:])
-	}
-
-	signedBeaconBlockPb.Block.Body.BlobKzgCommitments = blobZkgCommitmentsBytes
-
-	// Generate verified RO blobs.
-	verifiedROBlobs := make([]*blocks.VerifiedROBlob, 0, blobCount)
-
-	// Create a signed beacon block from the protobuf.
-	signedBeaconBlock, err := blocks.NewSignedBeaconBlock(signedBeaconBlockPb)
-	require.NoError(t, err)
-
-	commitmentInclusionProof, err := blocks.MerkleProofKZGCommitments(signedBeaconBlock.Block().Body())
-	require.NoError(t, err)
-
-	for blobIndex := range blobCount {
-		blob := blobs[blobIndex]
-		blobKZGCommitment := blobKzgCommitments[blobIndex]
-		blobKzgProof := blobKzgProofs[blobIndex]
-
-		// Get the signed beacon block header.
-		signedBeaconBlockHeader, err := signedBeaconBlock.Header()
-		require.NoError(t, err)
-
-		blobSidecar := &ethpb.BlobSidecar{
-			Index:                    uint64(blobIndex),
-			Blob:                     blob[:],
-			KzgCommitment:            blobKZGCommitment[:],
-			KzgProof:                 blobKzgProof[:],
-			SignedBlockHeader:        signedBeaconBlockHeader,
-			CommitmentInclusionProof: commitmentInclusionProof,
-		}
-
-		roBlob, err := blocks.NewROBlob(blobSidecar)
-		require.NoError(t, err)
-
-		verifiedROBlob := blocks.NewVerifiedROBlob(roBlob)
-		verifiedROBlobs = append(verifiedROBlobs, &verifiedROBlob)
-	}
-
-	return signedBeaconBlock, verifiedROBlobs
-}
-
 func TestGetBlob(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	cfg := params.BeaconConfig().Copy()

beacon-chain/rpc/prysm/v1alpha1/beacon/config_test.go

@@ -12,7 +12,6 @@ import (
 )
 
 func TestServer_GetBeaconConfig(t *testing.T) {
-	t.Skip("this is a weird test")
 	ctx := t.Context()
 	bs := &Server{}
 	res, err := bs.GetBeaconConfig(ctx, &emptypb.Empty{})

beacon-chain/rpc/prysm/v1alpha1/debug/p2p.go

@@ -109,8 +109,6 @@ func (ds *Server) getPeer(pid peer.ID) (*ethpb.DebugPeerResponse, error) {
 			peerInfo.MetadataV0 = metadata.MetadataObjV0()
 		case metadata.MetadataObjV1() != nil:
 			peerInfo.MetadataV1 = metadata.MetadataObjV1()
-		case metadata.MetadataObjV2() != nil:
-			peerInfo.MetadataV2 = metadata.MetadataObjV2()
 		}
 	}
 	addresses := peerStore.Addrs(pid)
@@ -129,7 +127,7 @@ func (ds *Server) getPeer(pid peer.ID) (*ethpb.DebugPeerResponse, error) {
 	if err != nil {
 		// In the event chain state is non existent, we
 		// initialize with the zero value.
-		pStatus = new(ethpb.StatusV2)
+		pStatus = new(ethpb.Status)
 	}
 	lastUpdated, err := peers.ChainStateLastUpdated(pid)
 	if err != nil {
@@ -152,17 +150,6 @@ func (ds *Server) getPeer(pid peer.ID) (*ethpb.DebugPeerResponse, error) {
 		BehaviourPenalty:   float32(bPenalty),
 		ValidationError:    errorToString(peers.Scorers().ValidationError(pid)),
 	}
-
-	// Convert statusV2 into status
-	// TODO: Should we do it this way or the other way around?
-	peerStatus := &ethpb.Status{
-		ForkDigest:     pStatus.ForkDigest,
-		FinalizedRoot:  pStatus.FinalizedRoot,
-		FinalizedEpoch: pStatus.FinalizedEpoch,
-		HeadRoot:       pStatus.HeadRoot,
-		HeadSlot:       pStatus.HeadSlot,
-	}
-
 	return &ethpb.DebugPeerResponse{
 		ListeningAddresses: stringAddrs,
 		Direction:          pbDirection,
@@ -170,7 +157,7 @@ func (ds *Server) getPeer(pid peer.ID) (*ethpb.DebugPeerResponse, error) {
 		PeerId:             pid.String(),
 		Enr:                enr,
 		PeerInfo:           peerInfo,
-		PeerStatus:         peerStatus,
+		PeerStatus:         pStatus,
 		LastUpdated:        unixTime,
 		ScoreInfo:          scoreInfo,
 	}, nil

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(
@@ -39,7 +37,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",
@@ -50,7 +47,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",
@@ -88,6 +84,7 @@ go_library(
         "//math:go_default_library",
         "//monitoring/tracing:go_default_library",
         "//monitoring/tracing/trace:go_default_library",
+        "//network/forks:go_default_library",
         "//proto/engine/v1:go_default_library",
         "//proto/eth/v1:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
@@ -183,6 +180,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/construct_generic_block.go

@@ -8,18 +8,13 @@ import (
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
-	"github.com/pkg/errors"
 	"google.golang.org/protobuf/proto"
 )
 
 // constructGenericBeaconBlock constructs a `GenericBeaconBlock` based on the block version and other parameters.
-func (vs *Server) constructGenericBeaconBlock(
-	sBlk interfaces.SignedBeaconBlock,
-	blobsBundler enginev1.BlobsBundler,
-	winningBid primitives.Wei,
-) (*ethpb.GenericBeaconBlock, error) {
+func (vs *Server) constructGenericBeaconBlock(sBlk interfaces.SignedBeaconBlock, blobsBundle *enginev1.BlobsBundle, winningBid primitives.Wei) (*ethpb.GenericBeaconBlock, error) {
 	if sBlk == nil || sBlk.Block() == nil {
-		return nil, errors.New("block cannot be nil")
+		return nil, fmt.Errorf("block cannot be nil")
 	}
 
 	blockProto, err := sBlk.Block().Proto()
@@ -39,21 +34,12 @@ func (vs *Server) constructGenericBeaconBlock(
 		return vs.constructBellatrixBlock(blockProto, isBlinded, bidStr), nil
 	case version.Capella:
 		return vs.constructCapellaBlock(blockProto, isBlinded, bidStr), nil
-	case version.Deneb, version.Electra:
-		bundle, ok := blobsBundler.(*enginev1.BlobsBundle)
-		if blobsBundler != nil && !ok {
-			return nil, fmt.Errorf("expected *BlobsBundler, got %T", blobsBundler)
-		}
-		if sBlk.Version() == version.Deneb {
-			return vs.constructDenebBlock(blockProto, isBlinded, bidStr, bundle), nil
-		}
-		return vs.constructElectraBlock(blockProto, isBlinded, bidStr, bundle), nil
+	case version.Deneb:
+		return vs.constructDenebBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
+	case version.Electra:
+		return vs.constructElectraBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
 	case version.Fulu:
-		bundle, ok := blobsBundler.(*enginev1.BlobsBundleV2)
-		if blobsBundler != nil && !ok {
-			return nil, fmt.Errorf("expected *BlobsBundleV2, got %T", blobsBundler)
-		}
-		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, bundle), nil
+		return vs.constructFuluBlock(blockProto, isBlinded, bidStr, blobsBundle), nil
 	default:
 		return nil, fmt.Errorf("unknown block version: %d", sBlk.Version())
 	}
@@ -106,7 +92,7 @@ func (vs *Server) constructElectraBlock(blockProto proto.Message, isBlinded bool
 	return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_Electra{Electra: electraContents}, IsBlinded: false, PayloadValue: payloadValue}
 }
 
-func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundleV2) *ethpb.GenericBeaconBlock {
+func (vs *Server) constructFuluBlock(blockProto proto.Message, isBlinded bool, payloadValue string, bundle *enginev1.BlobsBundle) *ethpb.GenericBeaconBlock {
 	if isBlinded {
 		return &ethpb.GenericBeaconBlock{Block: &ethpb.GenericBeaconBlock_BlindedFulu{BlindedFulu: blockProto.(*ethpb.BlindedBeaconBlockFulu)}, IsBlinded: true, PayloadValue: payloadValue}
 	}

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

@@ -29,19 +29,12 @@ func TestConstructGenericBeaconBlock(t *testing.T) {
 		require.NoError(t, err)
 		r1, err := eb.Block.HashTreeRoot()
 		require.NoError(t, err)
-		bundle := &enginev1.BlobsBundleV2{
-			KzgCommitments: [][]byte{{1, 2, 3}},
-			Proofs:         [][]byte{{4, 5, 6}},
-			Blobs:          [][]byte{{7, 8, 9}},
-		}
-		result, err := vs.constructGenericBeaconBlock(b, bundle, primitives.ZeroWei())
+		result, err := vs.constructGenericBeaconBlock(b, nil, primitives.ZeroWei())
 		require.NoError(t, err)
 		r2, err := result.GetFulu().Block.HashTreeRoot()
 		require.NoError(t, err)
 		require.Equal(t, r1, r2)
 		require.Equal(t, result.IsBlinded, false)
-		require.DeepEqual(t, bundle.Blobs, result.GetFulu().GetBlobs())
-		require.DeepEqual(t, bundle.Proofs, result.GetFulu().GetKzgProofs())
 	})
 
 	// Test for Electra version

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

@@ -15,13 +15,9 @@ import (
 	blockfeed "github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/block"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/feed/operation"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/helpers"
-	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/peerdas"
-	coreTime "github.com/OffchainLabs/prysm/v6/beacon-chain/core/time"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/core/transition"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/db/kv"
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
-	"github.com/OffchainLabs/prysm/v6/config/features"
-	fieldparams "github.com/OffchainLabs/prysm/v6/config/fieldparams"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/blocks"
 	"github.com/OffchainLabs/prysm/v6/consensus-types/interfaces"
@@ -62,31 +58,28 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	if err != nil {
 		log.WithError(err).Error("Could not convert slot to time")
 	}
-
-	log := log.WithField("slot", req.Slot)
-	log.WithField("sinceSlotStartTime", time.Since(t)).Info("Begin building block")
+	log.WithFields(logrus.Fields{
+		"slot":               req.Slot,
+		"sinceSlotStartTime": time.Since(t),
+	}).Info("Begin building block")
 
 	// A syncing validator should not produce a block.
 	if vs.SyncChecker.Syncing() {
-		log.Error("Fail to build block: node is syncing")
 		return nil, status.Error(codes.Unavailable, "Syncing to latest head, not ready to respond")
 	}
 	// An optimistic validator MUST NOT produce a block (i.e., sign across the DOMAIN_BEACON_PROPOSER domain).
 	if slots.ToEpoch(req.Slot) >= params.BeaconConfig().BellatrixForkEpoch {
 		if err := vs.optimisticStatus(ctx); err != nil {
-			log.WithError(err).Error("Fail to build block: node is optimistic")
 			return nil, status.Errorf(codes.Unavailable, "Validator is not ready to propose: %v", err)
 		}
 	}
 
 	head, parentRoot, err := vs.getParentState(ctx, req.Slot)
 	if err != nil {
-		log.WithError(err).Error("Fail to build block: could not get parent state")
 		return nil, err
 	}
 	sBlk, err := getEmptyBlock(req.Slot)
 	if err != nil {
-		log.WithError(err).Error("Fail to build block: could not get empty block")
 		return nil, status.Errorf(codes.Internal, "Could not prepare block: %v", err)
 	}
 	// Set slot, graffiti, randao reveal, and parent root.
@@ -98,7 +91,6 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	// Set proposer index.
 	idx, err := helpers.BeaconProposerIndex(ctx, head)
 	if err != nil {
-		log.WithError(err).Error("Fail to build block: could not calculate proposer index")
 		return nil, fmt.Errorf("could not calculate proposer index %w", err)
 	}
 	sBlk.SetProposerIndex(idx)
@@ -109,7 +101,7 @@ func (vs *Server) GetBeaconBlock(ctx context.Context, req *ethpb.BlockRequest) (
 	}
 
 	resp, err := vs.BuildBlockParallel(ctx, sBlk, head, req.SkipMevBoost, builderBoostFactor)
-	log = log.WithFields(logrus.Fields{
+	log := log.WithFields(logrus.Fields{
 		"slot":               req.Slot,
 		"sinceSlotStartTime": time.Since(t),
 		"validator":          sBlk.Block().ProposerIndex(),
@@ -240,7 +232,7 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 	}()
 
 	winningBid := primitives.ZeroWei()
-	var bundle enginev1.BlobsBundler
+	var bundle *enginev1.BlobsBundle
 	if sBlk.Version() >= version.Bellatrix {
 		local, err := vs.getLocalPayload(ctx, sBlk.Block(), head)
 		if err != nil {
@@ -282,13 +274,7 @@ func (vs *Server) BuildBlockParallel(ctx context.Context, sBlk interfaces.Signed
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // 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()
 
@@ -300,12 +286,12 @@ 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)
+		block, sidecars, err = vs.handleBlindedBlock(ctx, block)
 	} else if block.Version() >= version.Deneb {
-		blobSidecars, dataColumnSideCars, err = vs.handleUnblindedBlock(block, req, isPeerDASEnabled)
+		sidecars, err = vs.blobSidecarsFromUnblindedBlock(block, req)
 	}
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "%s: %v", "handle block failed", err)
@@ -316,10 +302,9 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		return nil, status.Errorf(codes.Internal, "Could not hash tree root: %v", err)
 	}
 
-	slot := block.Block().Slot()
-
 	var wg sync.WaitGroup
 	errChan := make(chan error, 1)
+
 	wg.Add(1)
 	go func() {
 		defer wg.Done()
@@ -330,14 +315,8 @@ func (vs *Server) ProposeBeaconBlock(ctx context.Context, req *ethpb.GenericSign
 		errChan <- nil
 	}()
 
-	if isPeerDASEnabled {
-		if err := vs.broadcastAndReceiveDataColumns(ctx, dataColumnSideCars, root, slot); 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()
@@ -349,75 +328,46 @@ 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 := peerdas.ConstructDataColumnSidecars(block, bundle.GetBlobs(), bundle.GetProofs())
-		if err != nil {
-			return nil, nil, nil, errors.Wrap(err, "construct data column 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: commitment value doesn't match block")
+		return nil, nil, errors.Wrap(err, "unblind blobs sidecars: commitment value doesn't match block")
 	}
 
-	return copiedBlock, blobSidecars, nil, nil
+	return copiedBlock, sidecars, nil
 }
 
-func (vs *Server) handleUnblindedBlock(
-	block interfaces.SignedBeaconBlock,
-	req *ethpb.GenericSignedBeaconBlock,
-	isPeerDASEnabled bool,
-) ([]*ethpb.BlobSidecar, []*ethpb.DataColumnSidecar, error) {
+func (vs *Server) blobSidecarsFromUnblindedBlock(block interfaces.SignedBeaconBlock, req *ethpb.GenericSignedBeaconBlock) ([]*ethpb.BlobSidecar, error) {
 	rawBlobs, proofs, err := blobsAndProofs(req)
 	if err != nil {
-		return nil, nil, err
+		return nil, err
 	}
-
-	if isPeerDASEnabled {
-		dataColumnSideCars, err := peerdas.ConstructDataColumnSidecars(block, rawBlobs, proofs)
-		if err != nil {
-			return nil, nil, errors.Wrap(err, "construct data column sidecars")
-		}
-
-		return nil, dataColumnSideCars, nil
-	}
-
-	blobSidecars, err := BuildBlobSidecars(block, rawBlobs, proofs)
-	if err != nil {
-		return nil, nil, errors.Wrap(err, "build blob sidecars")
-	}
-
-	return blobSidecars, nil, nil
+	return BuildBlobSidecars(block, rawBlobs, proofs)
 }
 
 // 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")
@@ -433,7 +383,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.
@@ -462,69 +412,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,
-	slot primitives.Slot,
-) error {
-	dataColumnsWithholdCount := features.Get().DataColumnsWithholdCount
-	verifiedRODataColumns := make([]blocks.VerifiedRODataColumn, 0, len(sidecars))
-
-	eg, _ := errgroup.WithContext(ctx)
-	for _, sd := range sidecars {
-		roDataColumn, err := blocks.NewRODataColumnWithRoot(sd, root)
-		if err != nil {
-			return errors.Wrap(err, "new read-only data column with root")
-		}
-
-		// We build this block ourselves, so we can upgrade the read only data column sidecar into a verified one.
-		verifiedRODataColumn := blocks.NewVerifiedRODataColumn(roDataColumn)
-		verifiedRODataColumns = append(verifiedRODataColumns, verifiedRODataColumn)
-
-		// 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.
-		sidecar := sd
-		eg.Go(func() error {
-			if sidecar.Index < dataColumnsWithholdCount {
-				log.WithFields(logrus.Fields{
-					"root":  fmt.Sprintf("%#x", root),
-					"slot":  slot,
-					"index": sidecar.Index,
-				}).Warning("Withholding data column")
-
-				return nil
-			}
-
-			// Compute the subnet index based on the column index.
-			subnet := peerdas.ComputeSubnetForDataColumnSidecar(sidecar.Index)
-
-			if err := vs.P2P.BroadcastDataColumn(root, subnet, sidecar); err != nil {
-				return errors.Wrap(err, "broadcast data column")
-			}
-
-			return nil
-		})
-	}
-
-	if err := eg.Wait(); err != nil {
-		return errors.Wrap(err, "wait for data columns to be broadcasted")
-	}
-
-	if err := vs.DataColumnReceiver.ReceiveDataColumns(verifiedRODataColumns); err != nil {
-		return errors.Wrap(err, "receive data column")
-	}
-
-	for _, verifiedRODataColumn := range verifiedRODataColumns {
-		vs.OperationNotifier.OperationFeed().Send(&feed.Event{
-			Type: operation.DataColumnSidecarReceived,
-			Data: &operation.DataColumnSidecarReceivedData{DataColumn: &verifiedRODataColumn}, // #nosec G601
-		})
-	}
-	return nil
-}
-
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.
 //
 // PrepareBeaconProposer caches and updates the fee recipient for the given proposer.

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

@@ -19,6 +19,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/encoding/ssz"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing"
 	"github.com/OffchainLabs/prysm/v6/monitoring/tracing/trace"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	enginev1 "github.com/OffchainLabs/prysm/v6/proto/engine/v1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"github.com/OffchainLabs/prysm/v6/time/slots"
@@ -53,7 +54,7 @@ const blockBuilderTimeout = 1 * time.Second
 const gasLimitAdjustmentFactor = 1024
 
 // Sets the execution data for the block. Execution data can come from local EL client or remote builder depends on validator registration and circuit breaker conditions.
-func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse, bid builder.Bid, builderBoostFactor primitives.Gwei) (primitives.Wei, enginev1.BlobsBundler, error) {
+func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse, bid builder.Bid, builderBoostFactor primitives.Gwei) (primitives.Wei, *enginev1.BlobsBundle, error) {
 	_, span := trace.StartSpan(ctx, "ProposerServer.setExecutionData")
 	defer span.End()
 
@@ -68,13 +69,13 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 
 	// Use local payload if builder payload is nil.
 	if bid == nil {
-		return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 	}
 
 	builderPayload, err := bid.Header()
 	if err != nil {
 		log.WithError(err).Warn("Proposer: failed to retrieve header from BuilderBid")
-		return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 	}
 
 	switch {
@@ -83,7 +84,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 		if err != nil {
 			tracing.AnnotateError(span, err)
 			log.WithError(err).Warn("Proposer: failed to match withdrawals root")
-			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 		}
 
 		// Compare payload values between local and builder. Default to the local value if it is higher.
@@ -96,7 +97,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 				"minBuilderBid":    minBid,
 				"builderGweiValue": builderValueGwei,
 			}).Warn("Proposer: using local execution payload because min bid not attained")
-			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 		}
 
 		// Use local block if min difference is not attained
@@ -107,7 +108,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 				"minBidDiff":       minDiff,
 				"builderGweiValue": builderValueGwei,
 			}).Warn("Proposer: using local execution payload because min difference with local value was not attained")
-			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 		}
 
 		// Use builder payload if the following in true:
@@ -132,7 +133,7 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 				bidDeneb, ok := bid.(builder.BidDeneb)
 				if !ok {
 					log.Warnf("bid type %T does not implement builder.BidDeneb", bid)
-					return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+					return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 				} else {
 					builderKzgCommitments = bidDeneb.BlobKzgCommitments()
 				}
@@ -143,14 +144,14 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 				bidElectra, ok := bid.(builder.BidElectra)
 				if !ok {
 					log.Warnf("bid type %T does not implement builder.BidElectra", bid)
-					return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+					return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 				} else {
 					executionRequests = bidElectra.ExecutionRequests()
 				}
 			}
 			if err := setBuilderExecution(blk, builderPayload, builderKzgCommitments, executionRequests); err != nil {
 				log.WithError(err).Warn("Proposer: failed to set builder payload")
-				return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+				return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 			} else {
 				return bid.Value(), nil, nil
 			}
@@ -170,11 +171,11 @@ func setExecutionData(ctx context.Context, blk interfaces.SignedBeaconBlock, loc
 			trace.Int64Attribute("builderGweiValue", int64(builderValueGwei)),     // lint:ignore uintcast -- This is OK for tracing.
 			trace.Int64Attribute("builderBoostFactor", int64(builderBoostFactor)), // lint:ignore uintcast -- This is OK for tracing.
 		)
-		return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+		return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 	default: // Bellatrix case.
 		if err := setBuilderExecution(blk, builderPayload, nil, nil); err != nil {
 			log.WithError(err).Warn("Proposer: failed to set builder payload")
-			return local.Bid, local.BlobsBundler, setLocalExecution(blk, local)
+			return local.Bid, local.BlobsBundle, setLocalExecution(blk, local)
 		} else {
 			return bid.Value(), nil, nil
 		}
@@ -219,9 +220,14 @@ func (vs *Server) getPayloadHeaderFromBuilder(
 	if signedBid == nil || signedBid.IsNil() {
 		return nil, errors.New("builder returned nil bid")
 	}
-	epoch := slots.ToEpoch(slot)
-	entry := params.GetNetworkScheduleEntry(epoch)
-	forkName := version.String(entry.VersionEnum)
+	fork, err := forks.Fork(slots.ToEpoch(slot))
+	if err != nil {
+		return nil, errors.Wrap(err, "unable to get fork information")
+	}
+	forkName, ok := params.BeaconConfig().ForkVersionNames[bytesutil.ToBytes4(fork.CurrentVersion)]
+	if !ok {
+		return nil, errors.New("unable to find current fork in schedule")
+	}
 	if !strings.EqualFold(version.String(signedBid.Version()), forkName) {
 		return nil, fmt.Errorf("builder bid response version: %d is different from head block version: %d for epoch %d", signedBid.Version(), b.Version(), slots.ToEpoch(slot))
 	}
@@ -369,8 +375,8 @@ func matchingWithdrawalsRoot(local, builder interfaces.ExecutionData) (bool, err
 // It delegates to setExecution for the actual work.
 func setLocalExecution(blk interfaces.SignedBeaconBlock, local *blocks.GetPayloadResponse) error {
 	var kzgCommitments [][]byte
-	if local.BlobsBundler != nil {
-		kzgCommitments = local.BlobsBundler.GetKzgCommitments()
+	if local.BlobsBundle != nil {
+		kzgCommitments = local.BlobsBundle.KzgCommitments
 	}
 	if local.ExecutionRequests != nil {
 		if err := blk.SetExecutionRequests(local.ExecutionRequests); err != nil {

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

@@ -519,7 +519,7 @@ func TestServer_setExecutionData(t *testing.T) {
 			PayloadIDBytes: id,
 			GetPayloadResponse: &blocks.GetPayloadResponse{
 				ExecutionData: ed,
-				BlobsBundler:  blobsBundle,
+				BlobsBundle:   blobsBundle,
 				Bid:           primitives.ZeroWei(),
 			},
 		}
@@ -527,7 +527,7 @@ func TestServer_setExecutionData(t *testing.T) {
 		res, err := vs.getLocalPayload(ctx, blk.Block(), capellaTransitionState)
 		require.NoError(t, err)
 		require.Equal(t, uint64(4), res.ExecutionData.BlockNumber())
-		require.DeepEqual(t, res.BlobsBundler, blobsBundle)
+		require.DeepEqual(t, res.BlobsBundle, blobsBundle)
 	})
 	t.Run("Can get builder payload and blobs in Deneb", func(t *testing.T) {
 		cfg := params.BeaconConfig().Copy()

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

@@ -529,7 +529,7 @@ func TestServer_GetBeaconBlock_Deneb(t *testing.T) {
 		PayloadIDBytes: &enginev1.PayloadIDBytes{1},
 		GetPayloadResponse: &blocks.GetPayloadResponse{
 			ExecutionData: ed,
-			BlobsBundler:  bundle,
+			BlobsBundle:   bundle,
 		},
 	}
 

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

@@ -29,6 +29,7 @@ import (
 	"github.com/OffchainLabs/prysm/v6/beacon-chain/sync"
 	"github.com/OffchainLabs/prysm/v6/config/params"
 	"github.com/OffchainLabs/prysm/v6/encoding/bytesutil"
+	"github.com/OffchainLabs/prysm/v6/network/forks"
 	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
 	"github.com/OffchainLabs/prysm/v6/runtime/version"
 	"google.golang.org/grpc/codes"
@@ -66,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
@@ -155,7 +155,7 @@ func (vs *Server) ValidatorIndex(ctx context.Context, req *ethpb.ValidatorIndexR
 //
 // DomainData fetches the current domain version information from the beacon state.
 func (vs *Server) DomainData(ctx context.Context, request *ethpb.DomainRequest) (*ethpb.DomainResponse, error) {
-	fork, err := params.Fork(request.Epoch)
+	fork, err := forks.Fork(request.Epoch)
 	if err != nil {
 		return nil, err
 	}

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

@@ -22,7 +22,6 @@ import (
 	"github.com/OffchainLabs/prysm/v6/testing/mock"
 	"github.com/OffchainLabs/prysm/v6/testing/require"
 	"github.com/OffchainLabs/prysm/v6/testing/util"
-	"github.com/ethereum/go-ethereum/common/hexutil"
 	logTest "github.com/sirupsen/logrus/hooks/test"
 	"go.uber.org/mock/gomock"
 	"google.golang.org/grpc/codes"
@@ -319,16 +318,23 @@ func TestWaitForChainStart_NotStartedThenLogFired(t *testing.T) {
 }
 
 func TestServer_DomainData_Exits(t *testing.T) {
-	params.SetActiveTestCleanup(t, params.MainnetConfig())
-	cfg := params.BeaconConfig()
-	beaconState := &ethpb.BeaconStateDeneb{
-		Slot:                  1 + primitives.Slot(cfg.DenebForkEpoch)*cfg.SlotsPerEpoch,
-		GenesisValidatorsRoot: cfg.GenesisValidatorsRoot[:],
+	params.SetupTestConfigCleanup(t)
+	cfg := params.BeaconConfig().Copy()
+	cfg.ForkVersionSchedule = map[[4]byte]primitives.Epoch{
+		[4]byte(cfg.GenesisForkVersion):   primitives.Epoch(0),
+		[4]byte(cfg.AltairForkVersion):    primitives.Epoch(5),
+		[4]byte(cfg.BellatrixForkVersion): primitives.Epoch(10),
+		[4]byte(cfg.CapellaForkVersion):   primitives.Epoch(15),
+		[4]byte(cfg.DenebForkVersion):     primitives.Epoch(20),
+	}
+	params.OverrideBeaconConfig(cfg)
+	beaconState := &ethpb.BeaconStateBellatrix{
+		Slot: 4000,
 	}
 	block := util.NewBeaconBlock()
 	genesisRoot, err := block.Block.HashTreeRoot()
 	require.NoError(t, err, "Could not get signing root")
-	s, err := state_native.InitializeFromProtoUnsafeDeneb(beaconState)
+	s, err := state_native.InitializeFromProtoUnsafeBellatrix(beaconState)
 	require.NoError(t, err)
 	vs := &Server{
 		Ctx:               t.Context(),
@@ -336,19 +342,14 @@ func TestServer_DomainData_Exits(t *testing.T) {
 		HeadFetcher:       &mockChain.ChainService{State: s, Root: genesisRoot[:]},
 	}
 
-	epoch := cfg.DenebForkEpoch
 	reqDomain, err := vs.DomainData(t.Context(), &ethpb.DomainRequest{
-		Epoch:  epoch,
-		Domain: cfg.DomainDeposit[:],
+		Epoch:  100,
+		Domain: params.BeaconConfig().DomainDeposit[:],
 	})
-	entry := params.GetNetworkScheduleEntry(epoch)
-	require.Equal(t, entry.ForkVersion, [4]byte(cfg.DenebForkVersion))
-
 	assert.NoError(t, err)
-	gvr := cfg.GenesisValidatorsRoot
-	wantedDomain, err := signing.ComputeDomain(cfg.DomainDeposit, entry.ForkVersion[:], gvr[:])
+	wantedDomain, err := signing.ComputeDomain(params.BeaconConfig().DomainDeposit, params.BeaconConfig().DenebForkVersion, make([]byte, 32))
 	assert.NoError(t, err)
-	assert.Equal(t, true, hexutil.Encode(reqDomain.SignatureDomain), hexutil.Encode(wantedDomain))
+	assert.DeepEqual(t, reqDomain.SignatureDomain, wantedDomain)
 
 	beaconStateNew := &ethpb.BeaconStateDeneb{
 		Slot: 4000,
@@ -359,11 +360,11 @@ func TestServer_DomainData_Exits(t *testing.T) {
 
 	reqDomain, err = vs.DomainData(t.Context(), &ethpb.DomainRequest{
 		Epoch:  100,
-		Domain: cfg.DomainVoluntaryExit[:],
+		Domain: params.BeaconConfig().DomainVoluntaryExit[:],
 	})
 	require.NoError(t, err)
 
-	wantedDomain, err = signing.ComputeDomain(cfg.DomainVoluntaryExit, cfg.CapellaForkVersion, make([]byte, 32))
+	wantedDomain, err = signing.ComputeDomain(params.BeaconConfig().DomainVoluntaryExit, params.BeaconConfig().CapellaForkVersion, make([]byte, 32))
 	require.NoError(t, err)
 
 	assert.DeepEqual(t, reqDomain.SignatureDomain, wantedDomain)

beacon-chain/rpc/service.go

@@ -89,7 +89,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
@@ -121,7 +120,6 @@ type Config struct {
 	Router                    *http.ServeMux
 	ClockWaiter               startup.ClockWaiter
 	BlobStorage               *filesystem.BlobStorage
-	DataColumnStorage         *filesystem.DataColumnStorage
 	TrackedValidatorsCache    *cache.TrackedValidatorsCache
 	PayloadIDCache            *cache.PayloadIDCache
 	LCStore                   *lightClient.Store
@@ -198,7 +196,6 @@ func NewService(ctx context.Context, cfg *Config) *Service {
 		ChainInfoFetcher:   s.cfg.ChainInfoFetcher,
 		GenesisTimeFetcher: s.cfg.GenesisTimeFetcher,
 		BlobStorage:        s.cfg.BlobStorage,
-		DataColumnStorage:  s.cfg.DataColumnStorage,
 	}
 	rewardFetcher := &rewards.BlockRewardService{Replayer: ch, DB: s.cfg.BeaconDB}
 	coreService := &core.Service{
@@ -239,7 +236,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/startup/clock.go

@@ -35,21 +35,12 @@ func (g *Clock) GenesisValidatorsRoot() [32]byte {
 	return g.vr
 }
 
-// GenesisValidatorsRoot returns the genesis state validator root as a slice for convenience.
-func (g *Clock) GenesisValidatorsRootSlice() []byte {
-	return g.vr[:]
-}
-
 // CurrentSlot returns the current slot relative to the time.Time value that Clock embeds.
 func (g *Clock) CurrentSlot() types.Slot {
 	now := g.now()
 	return slots.Duration(g.t, now)
 }
 
-func (g *Clock) CurrentEpoch() types.Epoch {
-	return slots.ToEpoch(g.CurrentSlot())
-}
-
 // SlotStart computes the time the given slot begins.
 func (g *Clock) SlotStart(slot types.Slot) time.Time {
 	return slots.BeginsAt(slot, g.t)

beacon-chain/state/genesis/BUILD.bazel

@@ -3,15 +3,14 @@ load("@prysm//tools/go:def.bzl", "go_library", "go_test")
 go_library(
     name = "go_default_library",
     srcs = [
-        "lookup.go",
-        "mainnet.go",
+        "genesis.go",
+        "genesis_mainnet.go",
     ],
     embedsrcs = ["mainnet.ssz.snappy"],
-    importpath = "github.com/OffchainLabs/prysm/v6/genesis/embedded",
+    importpath = "github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis",
     visibility = [
         "//beacon-chain/db:__subpackages__",
         "//config/params:__pkg__",
-        "//genesis:__pkg__",
     ],
     deps = [
         "//beacon-chain/state:go_default_library",

beacon-chain/state/genesis/genesis.go

@@ -0,0 +1,34 @@
+package genesis
+
+import (
+	_ "embed"
+
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state"
+	state_native "github.com/OffchainLabs/prysm/v6/beacon-chain/state/state-native"
+	ethpb "github.com/OffchainLabs/prysm/v6/proto/prysm/v1alpha1"
+	"github.com/golang/snappy"
+)
+
+var embeddedStates = map[string]*[]byte{}
+
+// State returns a copy of the genesis state from a hardcoded value.
+func State(name string) (state.BeaconState, error) {
+	sb, exists := embeddedStates[name]
+	if exists {
+		return load(*sb)
+	}
+	return nil, nil
+}
+
+// load a compressed ssz state file into a beacon state struct.
+func load(b []byte) (state.BeaconState, error) {
+	st := &ethpb.BeaconState{}
+	b, err := snappy.Decode(nil /*dst*/, b)
+	if err != nil {
+		return nil, err
+	}
+	if err := st.UnmarshalSSZ(b); err != nil {
+		return nil, err
+	}
+	return state_native.InitializeFromProtoUnsafePhase0(st)
+}

beacon-chain/state/genesis/genesis_mainnet.go

@@ -1,7 +1,7 @@
 //go:build !noMainnetGenesis
 // +build !noMainnetGenesis
 
-package embedded
+package genesis
 
 import (
 	_ "embed"

beacon-chain/state/genesis/genesis_test.go

@@ -1,10 +1,10 @@
-package embedded_test
+package genesis_test
 
 import (
 	"testing"
 
+	"github.com/OffchainLabs/prysm/v6/beacon-chain/state/genesis"
 	"github.com/OffchainLabs/prysm/v6/config/params"
-	"github.com/OffchainLabs/prysm/v6/genesis/embedded"
 )
 
 func TestGenesisState(t *testing.T) {
@@ -17,7 +17,7 @@ func TestGenesisState(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			st, err := embedded.ByName(tt.name)
+			st, err := genesis.State(tt.name)
 			if err != nil {
 				t.Fatal(err)
 			}

beacon-chain/state/interfaces.go

@@ -264,6 +264,8 @@ type WriteOnlyEth1Data interface {
 	AppendEth1DataVotes(val *ethpb.Eth1Data) error
 	SetEth1DepositIndex(val uint64) error
 	ExitEpochAndUpdateChurn(exitBalance primitives.Gwei) (primitives.Epoch, error)
+	SetExitBalanceToConsume(val primitives.Gwei) error
+	SetEarliestExitEpoch(val primitives.Epoch) error
 }
 
 // WriteOnlyValidators defines a struct which only has write access to validators methods.
@@ -331,6 +333,7 @@ type WriteOnlyWithdrawals interface {
 	DequeuePendingPartialWithdrawals(num uint64) error
 	SetNextWithdrawalIndex(i uint64) error
 	SetNextWithdrawalValidatorIndex(i primitives.ValidatorIndex) error
+	SetPendingPartialWithdrawals(val []*ethpb.PendingPartialWithdrawal) error
 }
 
 type WriteOnlyConsolidations interface {
@@ -350,7 +353,3 @@ type WriteOnlyDeposits interface {
 type WriteOnlyProposerLookahead interface {
 	SetProposerLookahead([]primitives.ValidatorIndex) error
 }
-
-func IsNil(s BeaconState) bool {
-	return s == nil || s.IsNil()
-}

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

@@ -75,3 +75,33 @@ func (b *BeaconState) ExitEpochAndUpdateChurn(exitBalance primitives.Gwei) (prim
 
 	return b.earliestExitEpoch, nil
 }
+
+// SetExitBalanceToConsume sets the exit balance to consume. This method mutates the state.
+func (b *BeaconState) SetExitBalanceToConsume(exitBalanceToConsume primitives.Gwei) error {
+	if b.version < version.Electra {
+		return errNotSupported("SetExitBalanceToConsume", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.exitBalanceToConsume = exitBalanceToConsume
+	b.markFieldAsDirty(types.ExitBalanceToConsume)
+
+	return nil
+}
+
+// SetEarliestExitEpoch sets the earliest exit epoch. This method mutates the state.
+func (b *BeaconState) SetEarliestExitEpoch(earliestExitEpoch primitives.Epoch) error {
+	if b.version < version.Electra {
+		return errNotSupported("SetEarliestExitEpoch", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	b.earliestExitEpoch = earliestExitEpoch
+	b.markFieldAsDirty(types.EarliestExitEpoch)
+
+	return nil
+}

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

@@ -100,3 +100,22 @@ func (b *BeaconState) DequeuePendingPartialWithdrawals(n uint64) error {
 
 	return nil
 }
+
+// SetPendingPartialWithdrawals sets the pending partial withdrawals. This method mutates the state.
+func (b *BeaconState) SetPendingPartialWithdrawals(pendingPartialWithdrawals []*eth.PendingPartialWithdrawal) error {
+	if b.version < version.Electra {
+		return errNotSupported("SetPendingPartialWithdrawals", b.version)
+	}
+
+	b.lock.Lock()
+	defer b.lock.Unlock()
+
+	if pendingPartialWithdrawals == nil {
+		return errors.New("cannot set nil pending partial withdrawals")
+	}
+
+	b.pendingPartialWithdrawals = pendingPartialWithdrawals
+	b.markFieldAsDirty(types.PendingPartialWithdrawals)
+
+	return nil
+}

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

@@ -34,7 +34,3 @@ var fieldMap map[types.FieldIndex]types.DataType
 func errNotSupported(funcName string, ver int) error {
 	return fmt.Errorf("%s is not supported for %s", funcName, version.String(ver))
 }
-
-func IsNil(s state.BeaconState) bool {
-	return s == nil || s.IsNil()
-}