Init sync fixes

- Only save finalized checkpoint to DB if it's newer than previous
  checkpoint
- Do not save Justified checkpoints to DB

api/client/builder/client.go

@@ -274,6 +274,9 @@ func non200Err(response *http.Response) error {
 	if err != nil {
 		body = "(Unable to read response body.)"
 	} else {
+		if jsonErr := json.Unmarshal(bodyBytes, &errMessage); jsonErr != nil {
+			return errors.Wrap(jsonErr, "unable to read response body")
+		}
 		body = "response body:\n" + string(bodyBytes)
 	}
 	msg := fmt.Sprintf("code=%d, url=%s, body=%s", response.StatusCode, response.Request.URL, body)
@@ -282,25 +285,13 @@ func non200Err(response *http.Response) error {
 		log.WithError(ErrNoContent).Debug(msg)
 		return ErrNoContent
 	case 400:
-		if jsonErr := json.Unmarshal(bodyBytes, &errMessage); jsonErr != nil {
-			return errors.Wrap(jsonErr, "unable to read response body")
-		}
 		log.WithError(ErrBadRequest).Debug(msg)
 		return errors.Wrap(ErrBadRequest, errMessage.Message)
 	case 404:
-		if jsonErr := json.Unmarshal(bodyBytes, &errMessage); jsonErr != nil {
-			return errors.Wrap(jsonErr, "unable to read response body")
-		}
 		log.WithError(ErrNotFound).Debug(msg)
 		return errors.Wrap(ErrNotFound, errMessage.Message)
-	case 500:
-		if jsonErr := json.Unmarshal(bodyBytes, &errMessage); jsonErr != nil {
-			return errors.Wrap(jsonErr, "unable to read response body")
-		}
-		log.WithError(ErrNotOK).Debug(msg)
-		return errors.Wrap(ErrNotOK, errMessage.Message)
 	default:
 		log.WithError(ErrNotOK).Debug(msg)
-		return errors.Wrap(ErrNotOK, fmt.Sprintf("unsupported error code: %d", response.StatusCode))
+		return errors.Wrap(ErrNotOK, errMessage.Message)
 	}
 }

api/client/builder/client_test.go

@@ -144,23 +144,6 @@ func TestClient_GetHeader(t *testing.T) {
 	_, err := c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
 	require.ErrorIs(t, err, ErrNotOK)
 
-	hc = &http.Client{
-		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
-			require.Equal(t, expectedPath, r.URL.Path)
-			return &http.Response{
-				StatusCode: http.StatusNoContent,
-				Body:       io.NopCloser(bytes.NewBuffer([]byte("No header is available."))),
-				Request:    r.Clone(ctx),
-			}, nil
-		}),
-	}
-	c = &Client{
-		hc:      hc,
-		baseURL: &url.URL{Host: "localhost:3500", Scheme: "http"},
-	}
-	_, err = c.GetHeader(ctx, slot, bytesutil.ToBytes32(parentHash), bytesutil.ToBytes48(pubkey))
-	require.ErrorIs(t, err, ErrNoContent)
-
 	hc = &http.Client{
 		Transport: roundtrip(func(r *http.Request) (*http.Response, error) {
 			require.Equal(t, expectedPath, r.URL.Path)

beacon-chain/blockchain/execution_engine.go

@@ -89,7 +89,7 @@ func (s *Service) notifyForkchoiceUpdate(ctx context.Context, arg *notifyForkcho
 			}
 			return payloadID, nil
 		case execution.ErrInvalidPayloadStatus:
-			forkchoiceUpdatedInvalidNodeCount.Inc()
+			newPayloadInvalidNodeCount.Inc()
 			headRoot := arg.headRoot
 			if len(lastValidHash) == 0 {
 				lastValidHash = defaultLatestValidHash

beacon-chain/blockchain/execution_engine_test.go

@@ -1155,18 +1155,6 @@ func Test_UpdateLastValidatedCheckpoint(t *testing.T) {
 	require.Equal(t, false, optimistic)
 	require.DeepEqual(t, validCheckpoint.Root, cp.Root)
 	require.Equal(t, validCheckpoint.Epoch, cp.Epoch)
-
-	// Checkpoint with a lower epoch
-	oldCp, err := service.cfg.BeaconDB.FinalizedCheckpoint(ctx)
-	require.NoError(t, err)
-	invalidCp := &ethpb.Checkpoint{
-		Epoch: oldCp.Epoch - 1,
-	}
-	// Nothing should happen as we no-op on an invalid checkpoint.
-	require.NoError(t, service.updateFinalized(ctx, invalidCp))
-	got, err := service.cfg.BeaconDB.FinalizedCheckpoint(ctx)
-	require.NoError(t, err)
-	require.DeepEqual(t, oldCp, got)
 }
 
 func TestService_removeInvalidBlockAndState(t *testing.T) {

beacon-chain/blockchain/log.go

@@ -8,7 +8,6 @@ import (
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
-	consensusBlocks "github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/interfaces"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
@@ -52,15 +51,10 @@ func logStateTransitionData(b interfaces.BeaconBlock) error {
 		}
 		log = log.WithField("payloadHash", fmt.Sprintf("%#x", bytesutil.Trunc(p.BlockHash())))
 		txs, err := p.Transactions()
-		switch {
-		case errors.Is(err, consensusBlocks.ErrUnsupportedGetter):
-		case err != nil:
+		if err != nil {
 			return err
-		default:
-			log = log.WithField("txCount", len(txs))
-			txsPerSlotCount.Set(float64(len(txs)))
 		}
-
+		log = log.WithField("txCount", len(txs))
 	}
 	log.Info("Finished applying state transition")
 	return nil

beacon-chain/blockchain/metrics.go

@@ -158,47 +158,10 @@ var (
 		Name: "forkchoice_updated_optimistic_node_count",
 		Help: "Count the number of optimistic nodes after forkchoiceUpdated EE call",
 	})
-	forkchoiceUpdatedInvalidNodeCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "forkchoice_updated_invalid_node_count",
-		Help: "Count the number of invalid nodes after forkchoiceUpdated EE call",
-	})
-	txsPerSlotCount = promauto.NewGauge(prometheus.GaugeOpts{
-		Name: "txs_per_slot_count",
-		Help: "Count the number of txs per slot",
-	})
 	missedPayloadIDFilledCount = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "missed_payload_id_filled_count",
 		Help: "",
 	})
-	onBlockProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "on_block_processing_milliseconds",
-		Help: "Total time in milliseconds to complete a call to onBlock()",
-	})
-	stateTransitionProcessingTime = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "state_transition_processing_milliseconds",
-		Help: "Total time to call a state transition in onBlock()",
-	})
-	processAttsElapsedTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "process_attestations_milliseconds",
-			Help:    "Captures latency for process attestations (forkchoice) in milliseconds",
-			Buckets: []float64{1, 5, 20, 100, 500, 1000},
-		},
-	)
-	newAttHeadElapsedTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "new_att_head_milliseconds",
-			Help:    "Captures latency for new attestation head in milliseconds",
-			Buckets: []float64{1, 5, 20, 100, 500, 1000},
-		},
-	)
-	newBlockHeadElapsedTime = promauto.NewHistogram(
-		prometheus.HistogramOpts{
-			Name:    "new_block_head_milliseconds",
-			Help:    "Captures latency for new block head in milliseconds",
-			Buckets: []float64{1, 5, 20, 100, 500, 1000},
-		},
-	)
 )
 
 // reportSlotMetrics reports slot related metrics.

beacon-chain/blockchain/process_block.go

@@ -98,7 +98,6 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	if err := consensusblocks.BeaconBlockIsNil(signed); err != nil {
 		return invalidBlock{error: err}
 	}
-	startTime := time.Now()
 	b := signed.Block()
 
 	preState, err := s.getBlockPreState(ctx, b)
@@ -116,13 +115,10 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 	if err != nil {
 		return err
 	}
-	stateTransitionStartTime := time.Now()
 	postState, err := transition.ExecuteStateTransition(ctx, preState, signed)
 	if err != nil {
 		return invalidBlock{error: err}
 	}
-	stateTransitionProcessingTime.Observe(float64(time.Since(stateTransitionStartTime).Milliseconds()))
-
 	postStateVersion, postStateHeader, err := getStateVersionAndPayload(postState)
 	if err != nil {
 		return err
@@ -186,14 +182,10 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		msg := fmt.Sprintf("could not read balances for state w/ justified checkpoint %#x", justified.Root)
 		return errors.Wrap(err, msg)
 	}
-
-	start := time.Now()
 	headRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
 	if err != nil {
 		log.WithError(err).Warn("Could not update head")
 	}
-	newBlockHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
-
 	if err := s.notifyEngineIfChangedHead(ctx, headRoot); err != nil {
 		return err
 	}
@@ -225,16 +217,6 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 		}
 	}()
 
-	// Save justified check point to db.
-	postStateJustifiedEpoch := postState.CurrentJustifiedCheckpoint().Epoch
-	if justified.Epoch > currStoreJustifiedEpoch || (justified.Epoch == postStateJustifiedEpoch && justified.Epoch > preStateJustifiedEpoch) {
-		if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{
-			Epoch: justified.Epoch, Root: justified.Root[:],
-		}); err != nil {
-			return err
-		}
-	}
-
 	// Save finalized check point to db and more.
 	postStateFinalizedEpoch := postState.FinalizedCheckpoint().Epoch
 	finalized := s.ForkChoicer().FinalizedCheckpoint()
@@ -270,11 +252,7 @@ func (s *Service) onBlock(ctx context.Context, signed interfaces.SignedBeaconBlo
 
 	}
 	defer reportAttestationInclusion(b)
-	if err := s.handleEpochBoundary(ctx, postState); err != nil {
-		return err
-	}
-	onBlockProcessingTime.Observe(float64(time.Since(startTime).Milliseconds()))
-	return nil
+	return s.handleEpochBoundary(ctx, postState)
 }
 
 func getStateVersionAndPayload(st state.BeaconState) (int, *enginev1.ExecutionPayloadHeader, error) {
@@ -415,12 +393,6 @@ func (s *Service) onBlockBatch(ctx context.Context, blks []interfaces.SignedBeac
 			tracing.AnnotateError(span, err)
 			return err
 		}
-		if i > 0 && jCheckpoints[i].Epoch > jCheckpoints[i-1].Epoch {
-			if err := s.cfg.BeaconDB.SaveJustifiedCheckpoint(ctx, jCheckpoints[i]); err != nil {
-				tracing.AnnotateError(span, err)
-				return err
-			}
-		}
 		if i > 0 && fCheckpoints[i].Epoch > fCheckpoints[i-1].Epoch {
 			if err := s.updateFinalized(ctx, fCheckpoints[i]); err != nil {
 				tracing.AnnotateError(span, err)

beacon-chain/blockchain/process_block_helpers.go

@@ -142,11 +142,8 @@ func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) err
 	defer span.End()
 
 	// return early if new checkpoint is not newer than the one in DB
-	currentFinalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(ctx)
-	if err != nil {
-		return err
-	}
-	if cp.Epoch <= currentFinalized.Epoch {
+	currentFinalizedEpoch := s.FinalizedCheckpt().Epoch
+	if cp.Epoch <= currentFinalizedEpoch {
 		return nil
 	}
 
@@ -277,7 +274,7 @@ func (s *Service) fillInForkChoiceMissingBlocks(ctx context.Context, blk interfa
 	if len(pendingNodes) == 1 {
 		return nil
 	}
-	if root != s.ensureRootNotZeros(finalized.Root) && !s.ForkChoicer().HasNode(root) {
+	if root != s.ensureRootNotZeros(finalized.Root) {
 		return errNotDescendantOfFinalized
 	}
 	return s.cfg.ForkChoiceStore.InsertOptimisticChain(ctx, pendingNodes)

beacon-chain/blockchain/process_block_test.go

@@ -1170,7 +1170,6 @@ func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
 
 	gs, keys := util.DeterministicGenesisState(t, 32)
 	require.NoError(t, service.saveGenesisData(ctx, gs))
-	require.NoError(t, fcs.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Root: service.originBlockRoot}))
 
 	testState := gs.Copy()
 	for i := types.Slot(1); i <= 4*params.BeaconConfig().SlotsPerEpoch; i++ {
@@ -1191,10 +1190,6 @@ func TestOnBlock_CanFinalize_WithOnTick(t *testing.T) {
 	require.Equal(t, types.Epoch(2), cp.Epoch)
 
 	// The update should persist in DB.
-	j, err := service.cfg.BeaconDB.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	cp = service.CurrentJustifiedCheckpt()
-	require.Equal(t, j.Epoch, cp.Epoch)
 	f, err := service.cfg.BeaconDB.FinalizedCheckpoint(ctx)
 	require.NoError(t, err)
 	cp = service.FinalizedCheckpt()
@@ -1239,10 +1234,6 @@ func TestOnBlock_CanFinalize(t *testing.T) {
 	require.Equal(t, types.Epoch(2), cp.Epoch)
 
 	// The update should persist in DB.
-	j, err := service.cfg.BeaconDB.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	cp = service.CurrentJustifiedCheckpt()
-	require.Equal(t, j.Epoch, cp.Epoch)
 	f, err := service.cfg.BeaconDB.FinalizedCheckpoint(ctx)
 	require.NoError(t, err)
 	cp = service.FinalizedCheckpt()

beacon-chain/blockchain/receive_attestation.go

@@ -147,22 +147,17 @@ func (s *Service) UpdateHead(ctx context.Context) error {
 	s.processAttestationsLock.Lock()
 	defer s.processAttestationsLock.Unlock()
 
-	start := time.Now()
 	s.processAttestations(ctx)
-	processAttsElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
 
 	justified := s.ForkChoicer().JustifiedCheckpoint()
 	balances, err := s.justifiedBalances.get(ctx, justified.Root)
 	if err != nil {
 		return err
 	}
-	start = time.Now()
 	newHeadRoot, err := s.cfg.ForkChoiceStore.Head(ctx, balances)
 	if err != nil {
 		log.WithError(err).Warn("Resolving fork due to new attestation")
 	}
-	newAttHeadElapsedTime.Observe(float64(time.Since(start).Milliseconds()))
-
 	s.headLock.RLock()
 	if s.headRoot() != newHeadRoot {
 		log.WithFields(logrus.Fields{

beacon-chain/blockchain/service.go

@@ -191,13 +191,6 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 	}
 	spawnCountdownIfPreGenesis(s.ctx, s.genesisTime, s.cfg.BeaconDB)
 
-	justified, err := s.cfg.BeaconDB.JustifiedCheckpoint(s.ctx)
-	if err != nil {
-		return errors.Wrap(err, "could not get justified checkpoint")
-	}
-	if justified == nil {
-		return errNilJustifiedCheckpoint
-	}
 	finalized, err := s.cfg.BeaconDB.FinalizedCheckpoint(s.ctx)
 	if err != nil {
 		return errors.Wrap(err, "could not get finalized checkpoint")
@@ -214,8 +207,8 @@ func (s *Service) StartFromSavedState(saved state.BeaconState) error {
 		forkChoicer = protoarray.New()
 	}
 	s.cfg.ForkChoiceStore = forkChoicer
-	if err := forkChoicer.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: justified.Epoch,
-		Root: bytesutil.ToBytes32(justified.Root)}); err != nil {
+	if err := forkChoicer.UpdateJustifiedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,
+		Root: bytesutil.ToBytes32(finalized.Root)}); err != nil {
 		return errors.Wrap(err, "could not update forkchoice's justified checkpoint")
 	}
 	if err := forkChoicer.UpdateFinalizedCheckpoint(&forkchoicetypes.Checkpoint{Epoch: finalized.Epoch,

beacon-chain/blockchain/service_test.go

@@ -158,7 +158,6 @@ func TestChainStartStop_Initialized(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	require.NoError(t, beaconDB.SaveHeadBlockRoot(ctx, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
-	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 	ss := &ethpb.StateSummary{
 		Slot: 1,
@@ -192,7 +191,6 @@ func TestChainStartStop_GenesisZeroHashes(t *testing.T) {
 	require.NoError(t, beaconDB.SaveState(ctx, s, blkRoot))
 	require.NoError(t, beaconDB.SaveGenesisBlockRoot(ctx, blkRoot))
 	require.NoError(t, beaconDB.SaveBlock(ctx, wsb))
-	require.NoError(t, beaconDB.SaveJustifiedCheckpoint(ctx, &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}))
 	require.NoError(t, beaconDB.SaveFinalizedCheckpoint(ctx, &ethpb.Checkpoint{Root: blkRoot[:]}))
 	chainService.cfg.FinalizedStateAtStartUp = s
 	// Test the start function.

beacon-chain/blockchain/weak_subjectivity_checks.go

@@ -30,7 +30,8 @@ type WeakSubjectivityVerifier struct {
 // NewWeakSubjectivityVerifier validates a checkpoint, and if valid, uses it to initialize a weak subjectivity verifier.
 func NewWeakSubjectivityVerifier(wsc *ethpb.Checkpoint, db weakSubjectivityDB) (*WeakSubjectivityVerifier, error) {
 	if wsc == nil || len(wsc.Root) == 0 || wsc.Epoch == 0 {
-		log.Debug("--weak-subjectivity-checkpoint not provided")
+		log.Info("--weak-subjectivity-checkpoint not provided. Prysm recommends providing a weak subjectivity checkpoint " +
+			"for nodes synced from genesis, or manual verification of block and state roots for checkpoint sync nodes.")
 		return &WeakSubjectivityVerifier{
 			enabled: false,
 		}, nil

beacon-chain/builder/service.go

@@ -2,6 +2,7 @@ package builder
 
 import (
 	"context"
+	"fmt"
 	"time"
 
 	"github.com/pkg/errors"
@@ -65,12 +66,12 @@ func NewService(ctx context.Context, opts ...Option) (*Service, error) {
 
 		// Is the builder up?
 		if err := s.c.Status(ctx); err != nil {
-			log.WithError(err).Error("Failed to check builder status")
-		} else {
-			log.WithField("endpoint", c.NodeURL()).Info("Builder has been configured")
-			log.Warn("Outsourcing block construction to external builders adds non-trivial delay to block propagation time.  " +
-				"Builder-constructed blocks or fallback blocks may get orphaned. Use at your own risk!")
+			return nil, fmt.Errorf("could not connect to builder: %v", err)
 		}
+
+		log.WithField("endpoint", c.NodeURL()).Info("Builder has been configured")
+		log.Warn("Outsourcing block construction to external builders adds non-trivial delay to block propagation time.  " +
+			"Builder-constructed blocks or fallback blocks may get orphaned. Use at your own risk!")
 	}
 	return s, nil
 }

beacon-chain/core/helpers/BUILD.bazel

@@ -7,7 +7,6 @@ go_library(
         "beacon_committee.go",
         "block.go",
         "genesis.go",
-        "metrics.go",
         "randao.go",
         "rewards_penalties.go",
         "shuffle.go",

beacon-chain/core/helpers/attestation.go

@@ -51,11 +51,10 @@ func ValidateSlotTargetEpoch(data *ethpb.AttestationData) error {
 // committee count as an argument allows cheaper computation at run time.
 //
 // Spec pseudocode definition:
-//
-//	def is_aggregator(state: BeaconState, slot: Slot, index: CommitteeIndex, slot_signature: BLSSignature) -> bool:
-//	 committee = get_beacon_committee(state, slot, index)
-//	 modulo = max(1, len(committee) // TARGET_AGGREGATORS_PER_COMMITTEE)
-//	 return bytes_to_uint64(hash(slot_signature)[0:8]) % modulo == 0
+//   def is_aggregator(state: BeaconState, slot: Slot, index: CommitteeIndex, slot_signature: BLSSignature) -> bool:
+//    committee = get_beacon_committee(state, slot, index)
+//    modulo = max(1, len(committee) // TARGET_AGGREGATORS_PER_COMMITTEE)
+//    return bytes_to_uint64(hash(slot_signature)[0:8]) % modulo == 0
 func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 	modulo := uint64(1)
 	if committeeCount/params.BeaconConfig().TargetAggregatorsPerCommittee > 1 {
@@ -69,10 +68,9 @@ func IsAggregator(committeeCount uint64, slotSig []byte) (bool, error) {
 // AggregateSignature returns the aggregated signature of the input attestations.
 //
 // Spec pseudocode definition:
-//
-//	def get_aggregate_signature(attestations: Sequence[Attestation]) -> BLSSignature:
-//	 signatures = [attestation.signature for attestation in attestations]
-//	 return bls.Aggregate(signatures)
+//   def get_aggregate_signature(attestations: Sequence[Attestation]) -> BLSSignature:
+//    signatures = [attestation.signature for attestation in attestations]
+//    return bls.Aggregate(signatures)
 func AggregateSignature(attestations []*ethpb.Attestation) (bls.Signature, error) {
 	sigs := make([]bls.Signature, len(attestations))
 	var err error
@@ -97,15 +95,14 @@ func IsAggregated(attestation *ethpb.Attestation) bool {
 //
 // Spec pseudocode definition:
 // def compute_subnet_for_attestation(committees_per_slot: uint64, slot: Slot, committee_index: CommitteeIndex) -> uint64:
+//    """
+//    Compute the correct subnet for an attestation for Phase 0.
+//    Note, this mimics expected future behavior where attestations will be mapped to their shard subnet.
+//    """
+//    slots_since_epoch_start = uint64(slot % SLOTS_PER_EPOCH)
+//    committees_since_epoch_start = committees_per_slot * slots_since_epoch_start
 //
-//	"""
-//	Compute the correct subnet for an attestation for Phase 0.
-//	Note, this mimics expected future behavior where attestations will be mapped to their shard subnet.
-//	"""
-//	slots_since_epoch_start = uint64(slot % SLOTS_PER_EPOCH)
-//	committees_since_epoch_start = committees_per_slot * slots_since_epoch_start
-//
-//	return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
+//    return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
 func ComputeSubnetForAttestation(activeValCount uint64, att *ethpb.Attestation) uint64 {
 	return ComputeSubnetFromCommitteeAndSlot(activeValCount, att.Data.CommitteeIndex, att.Data.Slot)
 }
@@ -115,15 +112,14 @@ func ComputeSubnetForAttestation(activeValCount uint64, att *ethpb.Attestation)
 //
 // Spec pseudocode definition:
 // def compute_subnet_for_attestation(committees_per_slot: uint64, slot: Slot, committee_index: CommitteeIndex) -> uint64:
+//    """
+//    Compute the correct subnet for an attestation for Phase 0.
+//    Note, this mimics expected future behavior where attestations will be mapped to their shard subnet.
+//    """
+//    slots_since_epoch_start = uint64(slot % SLOTS_PER_EPOCH)
+//    committees_since_epoch_start = committees_per_slot * slots_since_epoch_start
 //
-//	"""
-//	Compute the correct subnet for an attestation for Phase 0.
-//	Note, this mimics expected future behavior where attestations will be mapped to their shard subnet.
-//	"""
-//	slots_since_epoch_start = uint64(slot % SLOTS_PER_EPOCH)
-//	committees_since_epoch_start = committees_per_slot * slots_since_epoch_start
-//
-//	return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
+//    return uint64((committees_since_epoch_start + committee_index) % ATTESTATION_SUBNET_COUNT)
 func ComputeSubnetFromCommitteeAndSlot(activeValCount uint64, comIdx types.CommitteeIndex, attSlot types.Slot) uint64 {
 	slotSinceStart := slots.SinceEpochStarts(attSlot)
 	comCount := SlotCommitteeCount(activeValCount)
@@ -137,15 +133,13 @@ func ComputeSubnetFromCommitteeAndSlot(activeValCount uint64, comIdx types.Commi
 // slots.
 //
 // Example:
-//
-//	ATTESTATION_PROPAGATION_SLOT_RANGE = 5
-//	clockDisparity = 24 seconds
-//	current_slot = 100
-//	invalid_attestation_slot = 92
-//	invalid_attestation_slot = 103
-//	valid_attestation_slot = 98
-//	valid_attestation_slot = 101
-//
+//   ATTESTATION_PROPAGATION_SLOT_RANGE = 5
+//   clockDisparity = 24 seconds
+//   current_slot = 100
+//   invalid_attestation_slot = 92
+//   invalid_attestation_slot = 103
+//   valid_attestation_slot = 98
+//   valid_attestation_slot = 101
 // In the attestation must be within the range of 95 to 102 in the example above.
 func ValidateAttestationTime(attSlot types.Slot, genesisTime time.Time, clockDisparity time.Duration) error {
 	if err := slots.ValidateClock(attSlot, uint64(genesisTime.Unix())); err != nil {
@@ -176,19 +170,13 @@ func ValidateAttestationTime(attSlot types.Slot, genesisTime time.Time, clockDis
 	lowerBounds := lowerTime.Add(-clockDisparity)
 
 	// Verify attestation slot within the time range.
-	attError := fmt.Errorf(
-		"attestation slot %d not within attestation propagation range of %d to %d (current slot)",
-		attSlot,
-		lowerBoundsSlot,
-		currentSlot,
-	)
-	if attTime.Before(lowerBounds) {
-		attReceivedTooEarlyCount.Inc()
-		return attError
-	}
-	if attTime.After(upperBounds) {
-		attReceivedTooLateCount.Inc()
-		return attError
+	if attTime.Before(lowerBounds) || attTime.After(upperBounds) {
+		return fmt.Errorf(
+			"attestation slot %d not within attestation propagation range of %d to %d (current slot)",
+			attSlot,
+			lowerBoundsSlot,
+			currentSlot,
+		)
 	}
 	return nil
 }

beacon-chain/core/helpers/metrics.go

@@ -1,17 +0,0 @@
-package helpers
-
-import (
-	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
-)
-
-var (
-	attReceivedTooEarlyCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "attestation_too_early_total",
-		Help: "Increased when an attestation is considered too early",
-	})
-	attReceivedTooLateCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "attestation_too_late_total",
-		Help: "Increased when an attestation is considered too late",
-	})
-)

beacon-chain/db/iface/interface.go

@@ -40,7 +40,6 @@ type ReadOnlyDatabase interface {
 	HasStateSummary(ctx context.Context, blockRoot [32]byte) bool
 	HighestSlotStatesBelow(ctx context.Context, slot types.Slot) ([]state.ReadOnlyBeaconState, error)
 	// Checkpoint operations.
-	JustifiedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error)
 	FinalizedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error)
 	ArchivedPointRoot(ctx context.Context, slot types.Slot) [32]byte
 	HasArchivedPoint(ctx context.Context, slot types.Slot) bool
@@ -76,7 +75,6 @@ type NoHeadAccessDatabase interface {
 	SaveStateSummary(ctx context.Context, summary *ethpb.StateSummary) error
 	SaveStateSummaries(ctx context.Context, summaries []*ethpb.StateSummary) error
 	// Checkpoint operations.
-	SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	SaveLastValidatedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error
 	// Deposit contract related handlers.

beacon-chain/db/kv/BUILD.bazel

@@ -57,7 +57,6 @@ go_library(
         "//monitoring/tracing:go_default_library",
         "//proto/prysm/v1alpha1:go_default_library",
         "//runtime/version:go_default_library",
-        "//time:go_default_library",
         "//time/slots:go_default_library",
         "@com_github_dgraph_io_ristretto//:go_default_library",
         "@com_github_ethereum_go_ethereum//common:go_default_library",

beacon-chain/db/kv/blocks_test.go

@@ -259,16 +259,12 @@ func TestStore_DeleteJustifiedBlock(t *testing.T) {
 	b.Block.Slot = 1
 	root, err := b.Block.HashTreeRoot()
 	require.NoError(t, err)
-	cp := &ethpb.Checkpoint{
-		Root: root[:],
-	}
 	st, err := util.NewBeaconState()
 	require.NoError(t, err)
 	blk, err := blocks.NewSignedBeaconBlock(b)
 	require.NoError(t, err)
 	require.NoError(t, db.SaveBlock(ctx, blk))
 	require.NoError(t, db.SaveState(ctx, st, root))
-	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
 	require.ErrorIs(t, db.DeleteBlock(ctx, root), ErrDeleteJustifiedAndFinalized)
 }
 

beacon-chain/db/kv/checkpoint.go

@@ -14,24 +14,6 @@ import (
 
 var errMissingStateForCheckpoint = errors.New("missing state summary for checkpoint root")
 
-// JustifiedCheckpoint returns the latest justified checkpoint in beacon chain.
-func (s *Store) JustifiedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error) {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.JustifiedCheckpoint")
-	defer span.End()
-	var checkpoint *ethpb.Checkpoint
-	err := s.db.View(func(tx *bolt.Tx) error {
-		bkt := tx.Bucket(checkpointBucket)
-		enc := bkt.Get(justifiedCheckpointKey)
-		if enc == nil {
-			checkpoint = &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-			return nil
-		}
-		checkpoint = &ethpb.Checkpoint{}
-		return decode(ctx, enc, checkpoint)
-	})
-	return checkpoint, err
-}
-
 // FinalizedCheckpoint returns the latest finalized checkpoint in beacon chain.
 func (s *Store) FinalizedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.FinalizedCheckpoint")
@@ -50,29 +32,6 @@ func (s *Store) FinalizedCheckpoint(ctx context.Context) (*ethpb.Checkpoint, err
 	return checkpoint, err
 }
 
-// SaveJustifiedCheckpoint saves justified checkpoint in beacon chain.
-func (s *Store) SaveJustifiedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error {
-	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveJustifiedCheckpoint")
-	defer span.End()
-
-	enc, err := encode(ctx, checkpoint)
-	if err != nil {
-		return err
-	}
-	return s.db.Update(func(tx *bolt.Tx) error {
-		bucket := tx.Bucket(checkpointBucket)
-		hasStateSummary := s.hasStateSummaryBytes(tx, bytesutil.ToBytes32(checkpoint.Root))
-		hasStateInDB := tx.Bucket(stateBucket).Get(checkpoint.Root) != nil
-		if !(hasStateInDB || hasStateSummary) {
-			log.Warnf("Recovering state summary for justified root: %#x", bytesutil.Trunc(checkpoint.Root))
-			if err := recoverStateSummary(ctx, tx, checkpoint.Root); err != nil {
-				return errors.Wrapf(errMissingStateForCheckpoint, "could not save justified checkpoint, finalized root: %#x", bytesutil.Trunc(checkpoint.Root))
-			}
-		}
-		return bucket.Put(justifiedCheckpointKey, enc)
-	})
-}
-
 // SaveFinalizedCheckpoint saves finalized checkpoint in beacon chain.
 func (s *Store) SaveFinalizedCheckpoint(ctx context.Context, checkpoint *ethpb.Checkpoint) error {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.SaveFinalizedCheckpoint")

beacon-chain/db/kv/checkpoint_test.go

@@ -14,44 +14,6 @@ import (
 	"google.golang.org/protobuf/proto"
 )
 
-func TestStore_JustifiedCheckpoint_CanSaveRetrieve(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	root := bytesutil.ToBytes32([]byte{'A'})
-	cp := &ethpb.Checkpoint{
-		Epoch: 10,
-		Root:  root[:],
-	}
-	st, err := util.NewBeaconState()
-	require.NoError(t, err)
-	require.NoError(t, st.SetSlot(1))
-	require.NoError(t, db.SaveState(ctx, st, root))
-	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
-
-	retrieved, err := db.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}
-
-func TestStore_JustifiedCheckpoint_Recover(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-	blk := util.HydrateSignedBeaconBlock(&ethpb.SignedBeaconBlock{})
-	r, err := blk.Block.HashTreeRoot()
-	require.NoError(t, err)
-	cp := &ethpb.Checkpoint{
-		Epoch: 2,
-		Root:  r[:],
-	}
-	wb, err := blocks.NewSignedBeaconBlock(blk)
-	require.NoError(t, err)
-	require.NoError(t, db.SaveBlock(ctx, wb))
-	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
-	retrieved, err := db.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}
-
 func TestStore_FinalizedCheckpoint_CanSaveRetrieve(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()
@@ -108,16 +70,6 @@ func TestStore_FinalizedCheckpoint_Recover(t *testing.T) {
 	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
 }
 
-func TestStore_JustifiedCheckpoint_DefaultIsZeroHash(t *testing.T) {
-	db := setupDB(t)
-	ctx := context.Background()
-
-	cp := &ethpb.Checkpoint{Root: params.BeaconConfig().ZeroHash[:]}
-	retrieved, err := db.JustifiedCheckpoint(ctx)
-	require.NoError(t, err)
-	assert.Equal(t, true, proto.Equal(cp, retrieved), "Wanted %v, received %v", cp, retrieved)
-}
-
 func TestStore_FinalizedCheckpoint_DefaultIsZeroHash(t *testing.T) {
 	db := setupDB(t)
 	ctx := context.Background()

beacon-chain/db/kv/kv.go

@@ -55,14 +55,6 @@ var (
 		Name: "validator_entry_cache_delete_total",
 		Help: "The total number of cache deletes on the validator entry cache.",
 	})
-	stateReadingTime = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "db_beacon_state_reading_milliseconds",
-		Help: "Milliseconds it takes to read a beacon state from the DB",
-	})
-	stateSavingTime = promauto.NewSummary(prometheus.SummaryOpts{
-		Name: "db_beacon_state_saving_milliseconds",
-		Help: "Milliseconds it takes to save a beacon state to the DB",
-	})
 )
 
 // BlockCacheSize specifies 1000 slots worth of blocks cached, which

beacon-chain/db/kv/state.go

@@ -20,7 +20,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v3/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	"github.com/prysmaticlabs/prysm/v3/time"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
 	bolt "go.etcd.io/bbolt"
 	"go.opencensus.io/trace"
@@ -31,7 +30,6 @@ import (
 func (s *Store) State(ctx context.Context, blockRoot [32]byte) (state.BeaconState, error) {
 	ctx, span := trace.StartSpan(ctx, "BeaconDB.State")
 	defer span.End()
-	startTime := time.Now()
 	enc, err := s.stateBytes(ctx, blockRoot)
 	if err != nil {
 		return nil, err
@@ -46,12 +44,7 @@ func (s *Store) State(ctx context.Context, blockRoot [32]byte) (state.BeaconStat
 		return nil, valErr
 	}
 
-	st, err := s.unmarshalState(ctx, enc, valEntries)
-	if err != nil {
-		return nil, err
-	}
-	stateReadingTime.Observe(float64(time.Since(startTime).Milliseconds()))
-	return st, err
+	return s.unmarshalState(ctx, enc, valEntries)
 }
 
 // StateOrError is just like State(), except it only returns a non-error response
@@ -134,7 +127,6 @@ func (s *Store) SaveStates(ctx context.Context, states []state.ReadOnlyBeaconSta
 	if states == nil {
 		return errors.New("nil state")
 	}
-	startTime := time.Now()
 	multipleEncs := make([][]byte, len(states))
 	for i, st := range states {
 		stateBytes, err := marshalState(ctx, st)
@@ -144,7 +136,7 @@ func (s *Store) SaveStates(ctx context.Context, states []state.ReadOnlyBeaconSta
 		multipleEncs[i] = stateBytes
 	}
 
-	if err := s.db.Update(func(tx *bolt.Tx) error {
+	return s.db.Update(func(tx *bolt.Tx) error {
 		bucket := tx.Bucket(stateBucket)
 		for i, rt := range blockRoots {
 			indicesByBucket := createStateIndicesFromStateSlot(ctx, states[i].Slot())
@@ -156,11 +148,7 @@ func (s *Store) SaveStates(ctx context.Context, states []state.ReadOnlyBeaconSta
 			}
 		}
 		return nil
-	}); err != nil {
-		return err
-	}
-	stateSavingTime.Observe(float64(time.Since(startTime).Milliseconds()))
-	return nil
+	})
 }
 
 type withValidators interface {
@@ -772,10 +760,8 @@ func createStateIndicesFromStateSlot(ctx context.Context, slot types.Slot) map[s
 // Only following states would be kept:
 // 1.) state_slot % archived_interval == 0. (e.g. archived_interval=2048, states with slot 2048, 4096... etc)
 // 2.) archived_interval - archived_interval/3 < state_slot % archived_interval
-//
-//	(e.g. archived_interval=2048, states with slots after 1365).
-//	This is to tolerate skip slots. Not every state lays on the boundary.
-//
+//   (e.g. archived_interval=2048, states with slots after 1365).
+//   This is to tolerate skip slots. Not every state lays on the boundary.
 // 3.) state with current finalized root
 // 4.) unfinalized States
 func (s *Store) CleanUpDirtyStates(ctx context.Context, slotsPerArchivedPoint types.Slot) error {

beacon-chain/db/kv/wss.go

@@ -93,9 +93,6 @@ func (s *Store) SaveOrigin(ctx context.Context, serState, serBlock []byte) error
 		Epoch: types.Epoch(slotEpoch),
 		Root:  blockRoot[:],
 	}
-	if err = s.SaveJustifiedCheckpoint(ctx, chkpt); err != nil {
-		return errors.Wrap(err, "could not mark checkpoint sync block as justified")
-	}
 	if err = s.SaveFinalizedCheckpoint(ctx, chkpt); err != nil {
 		return errors.Wrap(err, "could not mark checkpoint sync block as finalized")
 	}

beacon-chain/execution/check_transition_config.go

@@ -24,18 +24,12 @@ var (
 	configMismatchLog              = "Configuration mismatch between your execution client and Prysm. " +
 		"Please check your execution client and restart it with the proper configuration. If this is not done, " +
 		"your node will not be able to complete the proof-of-stake transition"
-	needsEnginePortLog = "Could not check execution client configuration. " +
-		"You are probably connecting to your execution client on the wrong port. For the Ethereum " +
-		"merge, you will need to connect to your " +
-		"execution client on port 8551 rather than 8545. This is known as the 'engine API' port and needs to be " +
-		"authenticated if connecting via HTTP. See our documentation on how to set up this up here " +
-		"https://docs.prylabs.network/docs/execution-node/authentication"
 )
 
 // Checks the transition configuration between Prysm and the connected execution node to ensure
 // there are no differences in terminal block difficulty and block hash.
 // If there are any discrepancies, we must log errors to ensure users can resolve
-// the problem and be ready for the merge transition.
+//the problem and be ready for the merge transition.
 func (s *Service) checkTransitionConfiguration(
 	ctx context.Context, blockNotifications chan *feed.Event,
 ) {
@@ -54,14 +48,10 @@ func (s *Service) checkTransitionConfiguration(
 	}
 	err := s.ExchangeTransitionConfiguration(ctx, cfg)
 	if err != nil {
-		switch {
-		case errors.Is(err, ErrConfigMismatch):
+		if errors.Is(err, ErrConfigMismatch) {
 			log.WithError(err).Fatal(configMismatchLog)
-		case errors.Is(err, ErrMethodNotFound):
-			log.WithError(err).Error(needsEnginePortLog)
-		default:
-			log.WithError(err).Error("Could not check configuration values between execution and consensus client")
 		}
+		log.WithError(err).Error("Could not check configuration values between execution and consensus client")
 	}
 
 	// We poll the execution client to see if the transition configuration has changed.
@@ -125,9 +115,6 @@ func (s *Service) handleExchangeConfigurationError(err error) {
 		s.runError = err
 		log.WithError(err).Error(configMismatchLog)
 		return
-	} else if errors.Is(err, ErrMethodNotFound) {
-		log.WithError(err).Error(needsEnginePortLog)
-		return
 	}
 	log.WithError(err).Error("Could not check configuration values between execution and consensus client")
 }

beacon-chain/execution/engine_client.go

@@ -537,31 +537,22 @@ func handleRPCError(err error) error {
 	}
 	switch e.ErrorCode() {
 	case -32700:
-		errParseCount.Inc()
 		return ErrParse
 	case -32600:
-		errInvalidRequestCount.Inc()
 		return ErrInvalidRequest
 	case -32601:
-		errMethodNotFoundCount.Inc()
 		return ErrMethodNotFound
 	case -32602:
-		errInvalidParamsCount.Inc()
 		return ErrInvalidParams
 	case -32603:
-		errInternalCount.Inc()
 		return ErrInternal
 	case -38001:
-		errUnknownPayloadCount.Inc()
 		return ErrUnknownPayload
 	case -38002:
-		errInvalidForkchoiceStateCount.Inc()
 		return ErrInvalidForkchoiceState
 	case -38003:
-		errInvalidPayloadAttributesCount.Inc()
 		return ErrInvalidPayloadAttributes
 	case -32000:
-		errServerErrorCount.Inc()
 		// Only -32000 status codes are data errors in the RPC specification.
 		errWithData, ok := err.(rpc.DataError)
 		if !ok {

beacon-chain/execution/metrics.go

@@ -31,42 +31,6 @@ var (
 			Buckets: []float64{25, 50, 100, 200, 500, 1000, 2000, 4000},
 		},
 	)
-	errParseCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_parse_error_count",
-		Help: "The number of errors that occurred while parsing execution payload",
-	})
-	errInvalidRequestCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_invalid_request_count",
-		Help: "The number of errors that occurred due to invalid request",
-	})
-	errMethodNotFoundCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_method_not_found_count",
-		Help: "The number of errors that occurred due to method not found",
-	})
-	errInvalidParamsCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_invalid_params_count",
-		Help: "The number of errors that occurred due to invalid params",
-	})
-	errInternalCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_internal_error_count",
-		Help: "The number of errors that occurred due to internal error",
-	})
-	errUnknownPayloadCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_unknown_payload_count",
-		Help: "The number of errors that occurred due to unknown payload",
-	})
-	errInvalidForkchoiceStateCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_invalid_forkchoice_state_count",
-		Help: "The number of errors that occurred due to invalid forkchoice state",
-	})
-	errInvalidPayloadAttributesCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_invalid_payload_attributes_count",
-		Help: "The number of errors that occurred due to invalid payload attributes",
-	})
-	errServerErrorCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "execution_server_error_count",
-		Help: "The number of errors that occurred due to server error",
-	})
 	reconstructedExecutionPayloadCount = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "reconstructed_execution_payload_count",
 		Help: "Count the number of execution payloads that are reconstructed using JSON-RPC from payload headers",

beacon-chain/execution/rpc_connection.go

@@ -38,13 +38,7 @@ func (s *Service) setupExecutionClientConnections(ctx context.Context, currEndpo
 	// Ensure we have the correct chain and deposit IDs.
 	if err := ensureCorrectExecutionChain(ctx, fetcher); err != nil {
 		client.Close()
-		errStr := err.Error()
-		if strings.Contains(errStr, "401 Unauthorized") {
-			errStr = "could not verify execution chain ID as your connection is not authenticated. " +
-				"If connecting to your execution client via HTTP, you will need to set up JWT authentication. " +
-				"See our documentation here https://docs.prylabs.network/docs/execution-node/authentication"
-		}
-		return errors.Wrap(err, errStr)
+		return errors.Wrap(err, "could not make initial request to verify execution chain ID")
 	}
 	s.updateConnectedETH1(true)
 	s.runError = nil

beacon-chain/execution/service.go

@@ -66,6 +66,10 @@ var (
 	logThreshold = 8
 	// period to log chainstart related information
 	logPeriod = 1 * time.Minute
+	// threshold of how old we will accept an eth1 node's head to be.
+	eth1Threshold = 20 * time.Minute
+	// error when eth1 node is too far behind.
+	errFarBehind = errors.Errorf("eth1 head is more than %s behind from current wall clock time", eth1Threshold.String())
 )
 
 // ChainStartFetcher retrieves information pertaining to the chain start event
@@ -600,6 +604,11 @@ func (s *Service) run(done <-chan struct{}) {
 				log.WithError(err).Debug("Could not fetch latest eth1 header")
 				continue
 			}
+			if eth1HeadIsBehind(head.Time) {
+				s.pollConnectionStatus(s.ctx)
+				log.WithError(errFarBehind).Debug("Could not get an up to date eth1 header")
+				continue
+			}
 			s.processBlockHeader(head)
 			s.handleETH1FollowDistance()
 		case <-chainstartTicker.C:
@@ -825,3 +834,11 @@ func dedupEndpoints(endpoints []string) []string {
 	}
 	return newEndpoints
 }
+
+// Checks if the provided timestamp is beyond the prescribed bound from
+// the current wall clock time.
+func eth1HeadIsBehind(timestamp uint64) bool {
+	timeout := prysmTime.Now().Add(-eth1Threshold)
+	// check that web3 client is syncing
+	return time.Unix(int64(timestamp), 0).Before(timeout) // lint:ignore uintcast -- timestamp will not exceed int64 in your lifetime.
+}

beacon-chain/execution/service_test.go

@@ -146,7 +146,7 @@ func TestStart_OK(t *testing.T) {
 		WithDepositContractAddress(testAcc.ContractAddr),
 		WithDatabase(beaconDB),
 	)
-	require.NoError(t, err, "unable to setup execution service")
+	require.NoError(t, err, "unable to setup web3 ETH1.0 chain service")
 	web3Service = setDefaultMocks(web3Service)
 	web3Service.rpcClient = &mockExecution.RPCClient{Backend: testAcc.Backend}
 	web3Service.depositContractCaller, err = contracts.NewDepositContractCaller(testAcc.ContractAddr, testAcc.Backend)
@@ -156,7 +156,7 @@ func TestStart_OK(t *testing.T) {
 	web3Service.Start()
 	if len(hook.Entries) > 0 {
 		msg := hook.LastEntry().Message
-		want := "Could not connect to execution endpoint"
+		want := "Could not connect to ETH1.0 chain RPC client"
 		if strings.Contains(want, msg) {
 			t.Errorf("incorrect log, expected %s, got %s", want, msg)
 		}
@@ -752,6 +752,15 @@ func TestService_ValidateDepositContainers(t *testing.T) {
 	}
 }
 
+func TestTimestampIsChecked(t *testing.T) {
+	timestamp := uint64(time.Now().Unix())
+	assert.Equal(t, false, eth1HeadIsBehind(timestamp))
+
+	// Give an older timestmap beyond threshold.
+	timestamp = uint64(time.Now().Add(-eth1Threshold).Add(-1 * time.Minute).Unix())
+	assert.Equal(t, true, eth1HeadIsBehind(timestamp))
+}
+
 func TestETH1Endpoints(t *testing.T) {
 	server, firstEndpoint, err := mockExecution.SetupRPCServer()
 	require.NoError(t, err)

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

@@ -36,6 +36,7 @@ func New() *ForkChoice {
 		nodeByRoot:                    make(map[[fieldparams.RootLength]byte]*Node),
 		nodeByPayload:                 make(map[[fieldparams.RootLength]byte]*Node),
 		slashedIndices:                make(map[types.ValidatorIndex]bool),
+		pruneThreshold:                defaultPruneThreshold,
 		receivedBlocksLastEpoch:       [fieldparams.SlotsPerEpoch]types.Slot{},
 	}
 

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

@@ -11,6 +11,15 @@ import (
 	v1 "github.com/prysmaticlabs/prysm/v3/proto/eth/v1"
 )
 
+// depth returns the length of the path to the root of Fork Choice
+func (n *Node) depth() uint64 {
+	ret := uint64(0)
+	for node := n.parent; node != nil; node = node.parent {
+		ret += 1
+	}
+	return ret
+}
+
 // applyWeightChanges recomputes the weight of the node passed as an argument and all of its descendants,
 // using the current balance stored in each node. This function requires a lock
 // in Store.nodesLock

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

@@ -140,6 +140,25 @@ func TestNode_UpdateBestDescendant_LowerWeightChild(t *testing.T) {
 	assert.Equal(t, s.treeRootNode.children[0], s.treeRootNode.bestDescendant)
 }
 
+func TestNode_TestDepth(t *testing.T) {
+	f := setup(1, 1)
+	ctx := context.Background()
+	// Input child is best descendant
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), indexToHash(1), params.BeaconConfig().ZeroHash, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	state, blkRoot, err = prepareForkchoiceState(ctx, 3, indexToHash(3), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 1, 1)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+
+	s := f.store
+	require.Equal(t, s.nodeByRoot[indexToHash(2)].depth(), uint64(2))
+	require.Equal(t, s.nodeByRoot[indexToHash(3)].depth(), uint64(1))
+}
+
 func TestNode_ViableForHead(t *testing.T) {
 	tests := []struct {
 		n              *Node

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

@@ -70,5 +70,5 @@ func (f *ForkChoice) NewSlot(ctx context.Context, slot types.Slot) error {
 	if !features.Get().DisablePullTips {
 		f.updateUnrealizedCheckpoints()
 	}
-	return f.store.prune(ctx)
+	return nil
 }

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

@@ -12,6 +12,10 @@ import (
 	"go.opencensus.io/trace"
 )
 
+// This defines the minimal number of block nodes that can be in the tree
+// before getting pruned upon new finalization.
+const defaultPruneThreshold = 256
+
 // applyProposerBoostScore applies the current proposer boost scores to the
 // relevant nodes. This function requires a lock in Store.nodesLock.
 func (s *Store) applyProposerBoostScore(newBalances []uint64) error {
@@ -55,6 +59,11 @@ func (s *Store) proposerBoost() [fieldparams.RootLength]byte {
 	return s.proposerBoostRoot
 }
 
+// PruneThreshold of fork choice store.
+func (s *Store) PruneThreshold() uint64 {
+	return s.pruneThreshold
+}
+
 // head starts from justified root and then follows the best descendant links
 // to find the best block for head. This function assumes a lock on s.nodesLock
 func (s *Store) head(ctx context.Context) ([32]byte, error) {
@@ -206,7 +215,8 @@ func (s *Store) pruneFinalizedNodeByRootMap(ctx context.Context, node, finalized
 	return nil
 }
 
-// prune prunes the fork choice store. It removes all nodes that compete with the finalized root.
+// prune prunes the fork choice store with the new finalized root. The store is only pruned if the input
+// root is different than the current store finalized root, and the number of the store has met prune threshold.
 // This function does not prune for invalid optimistically synced nodes, it deals only with pruning upon finalization
 func (s *Store) prune(ctx context.Context) error {
 	ctx, span := trace.StartSpan(ctx, "doublyLinkedForkchoice.Prune")
@@ -222,8 +232,10 @@ func (s *Store) prune(ctx context.Context) error {
 	if !ok || finalizedNode == nil {
 		return errUnknownFinalizedRoot
 	}
-	// return early if we haven't changed the finalized checkpoint
-	if finalizedNode.parent == nil {
+
+	// The number of the nodes has not met the prune threshold.
+	// Pruning at small numbers incurs more cost than benefit.
+	if finalizedNode.depth() < s.pruneThreshold {
 		return nil
 	}
 

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

@@ -12,6 +12,15 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/testing/require"
 )
 
+func TestStore_PruneThreshold(t *testing.T) {
+	s := &Store{
+		pruneThreshold: defaultPruneThreshold,
+	}
+	if got := s.PruneThreshold(); got != defaultPruneThreshold {
+		t.Errorf("PruneThreshold() = %v, want %v", got, defaultPruneThreshold)
+	}
+}
+
 func TestStore_JustifiedEpoch(t *testing.T) {
 	j := types.Epoch(100)
 	f := setup(j, j)
@@ -145,6 +154,30 @@ func TestStore_Insert(t *testing.T) {
 	assert.Equal(t, indexToHash(100), child.root, "Incorrect root")
 }
 
+func TestStore_Prune_LessThanThreshold(t *testing.T) {
+	// Define 100 nodes in store.
+	numOfNodes := uint64(100)
+	f := setup(0, 0)
+	ctx := context.Background()
+	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
+	require.NoError(t, err)
+	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	for i := uint64(2); i < numOfNodes; i++ {
+		state, blkRoot, err = prepareForkchoiceState(ctx, types.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
+		require.NoError(t, err)
+		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	}
+
+	s := f.store
+	s.pruneThreshold = 100
+
+	// Finalized root has depth 99 so everything before it should be pruned,
+	// but PruneThreshold is at 100 so nothing will be pruned.
+	s.finalizedCheckpoint.Root = indexToHash(99)
+	require.NoError(t, s.prune(context.Background()))
+	assert.Equal(t, 100, len(s.nodeByRoot), "Incorrect nodes count")
+}
+
 func TestStore_Prune_MoreThanThreshold(t *testing.T) {
 	// Define 100 nodes in store.
 	numOfNodes := uint64(100)
@@ -160,6 +193,7 @@ func TestStore_Prune_MoreThanThreshold(t *testing.T) {
 	}
 
 	s := f.store
+	s.pruneThreshold = 0
 
 	// Finalized root is at index 99 so everything before 99 should be pruned.
 	s.finalizedCheckpoint.Root = indexToHash(99)
@@ -182,6 +216,7 @@ func TestStore_Prune_MoreThanOnce(t *testing.T) {
 	}
 
 	s := f.store
+	s.pruneThreshold = 0
 
 	// Finalized root is at index 11 so everything before 11 should be pruned.
 	s.finalizedCheckpoint.Root = indexToHash(10)
@@ -194,25 +229,6 @@ func TestStore_Prune_MoreThanOnce(t *testing.T) {
 	assert.Equal(t, 80, len(s.nodeByRoot), "Incorrect nodes count")
 }
 
-func TestStore_Prune_ReturnEarly(t *testing.T) {
-	// Define 100 nodes in store.
-	numOfNodes := uint64(100)
-	f := setup(0, 0)
-	ctx := context.Background()
-	state, blkRoot, err := prepareForkchoiceState(ctx, 1, indexToHash(1), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
-	require.NoError(t, err)
-	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	for i := uint64(2); i < numOfNodes; i++ {
-		state, blkRoot, err = prepareForkchoiceState(ctx, types.Slot(i), indexToHash(i), indexToHash(i-1), params.BeaconConfig().ZeroHash, 0, 0)
-		require.NoError(t, err)
-		require.NoError(t, f.InsertNode(ctx, state, blkRoot))
-	}
-	require.NoError(t, f.store.prune(ctx))
-	nodeCount := f.NodeCount()
-	require.NoError(t, f.store.prune(ctx))
-	require.Equal(t, nodeCount, f.NodeCount())
-}
-
 // This unit tests starts with a simple branch like this
 //
 //       - 1
@@ -229,6 +245,7 @@ func TestStore_Prune_NoDanglingBranch(t *testing.T) {
 	state, blkRoot, err = prepareForkchoiceState(ctx, 2, indexToHash(2), params.BeaconConfig().ZeroHash, params.BeaconConfig().ZeroHash, 0, 0)
 	require.NoError(t, err)
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
+	f.store.pruneThreshold = 0
 
 	s := f.store
 	s.finalizedCheckpoint.Root = indexToHash(1)
@@ -313,6 +330,7 @@ func TestStore_PruneMapsNodes(t *testing.T) {
 	require.NoError(t, f.InsertNode(ctx, state, blkRoot))
 
 	s := f.store
+	s.pruneThreshold = 0
 	s.finalizedCheckpoint.Root = indexToHash(1)
 	require.NoError(t, s.prune(context.Background()))
 	require.Equal(t, len(s.nodeByRoot), 1)

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

@@ -24,6 +24,7 @@ type Store struct {
 	unrealizedFinalizedCheckpoint *forkchoicetypes.Checkpoint            // best unrealized finalized checkpoint in store.
 	prevJustifiedCheckpoint       *forkchoicetypes.Checkpoint            // previous justified checkpoint in store.
 	finalizedCheckpoint           *forkchoicetypes.Checkpoint            // latest finalized epoch in store.
+	pruneThreshold                uint64                                 // do not prune tree unless threshold is reached.
 	proposerBoostRoot             [fieldparams.RootLength]byte           // latest block root that was boosted after being received in a timely manner.
 	previousProposerBoostRoot     [fieldparams.RootLength]byte           // previous block root that was boosted after being received in a timely manner.
 	previousProposerBoostScore    uint64                                 // previous proposer boosted root score.

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

@@ -261,6 +261,14 @@ func TestVotes_CanFindHead(t *testing.T) {
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 3")
 
+	// Verify pruning below the prune threshold does not affect head.
+	f.store.pruneThreshold = 1000
+	prevRoot := f.store.finalizedCheckpoint.Root
+	f.store.finalizedCheckpoint.Root = indexToHash(5)
+	require.NoError(t, f.store.prune(context.Background()))
+	assert.Equal(t, 11, len(f.store.nodeByRoot), "Incorrect nodes length after prune")
+
+	f.store.finalizedCheckpoint.Root = prevRoot
 	r, err = f.Head(context.Background(), balances)
 	require.NoError(t, err)
 	assert.Equal(t, indexToHash(10), r, "Incorrect head for with justified epoch at 3")
@@ -281,11 +289,13 @@ func TestVotes_CanFindHead(t *testing.T) {
 	//          8
 	//         / \
 	//        9  10
+	f.store.pruneThreshold = 1
 	f.store.finalizedCheckpoint.Root = indexToHash(5)
 	require.NoError(t, f.store.prune(context.Background()))
 	assert.Equal(t, 5, len(f.store.nodeByRoot), "Incorrect nodes length after prune")
 	// we pruned artificially the justified root.
 	f.store.justifiedCheckpoint.Root = indexToHash(5)
+	f.store.finalizedCheckpoint.Root = prevRoot
 
 	r, err = f.Head(context.Background(), balances)
 	require.NoError(t, err)

beacon-chain/forkchoice/protoarray/BUILD.bazel

@@ -64,7 +64,6 @@ go_test(
         "//beacon-chain/forkchoice/types:go_default_library",
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/v3:go_default_library",
-        "//config/features:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",
         "//consensus-types/primitives:go_default_library",

beacon-chain/forkchoice/protoarray/store.go

@@ -885,15 +885,6 @@ func (s *Store) viableForHead(node *Node) bool {
 	// It's also viable if we are in genesis epoch.
 	justified := s.justifiedCheckpoint.Epoch == node.justifiedEpoch || s.justifiedCheckpoint.Epoch == 0
 	finalized := s.finalizedCheckpoint.Epoch == node.finalizedEpoch || s.finalizedCheckpoint.Epoch == 0
-	if features.Get().EnableDefensivePull {
-		currentEpoch := slots.EpochsSinceGenesis(time.Unix(int64(s.genesisTime), 0))
-		if !justified && s.justifiedCheckpoint.Epoch+1 == currentEpoch {
-			if node.unrealizedJustifiedEpoch+1 >= currentEpoch {
-				justified = true
-				finalized = true
-			}
-		}
-	}
 
 	return justified && finalized
 }

beacon-chain/forkchoice/protoarray/store_test.go

@@ -7,7 +7,6 @@ import (
 
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice"
 	forkchoicetypes "github.com/prysmaticlabs/prysm/v3/beacon-chain/forkchoice/types"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/consensus-types/blocks"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
@@ -888,43 +887,6 @@ func TestStore_ViableForHead(t *testing.T) {
 	}
 }
 
-func TestStore_ViableForHead_DefensivePull(t *testing.T) {
-	resetCfg := features.InitWithReset(&features.Flags{
-		EnableDefensivePull: true,
-	})
-	defer resetCfg()
-
-	tests := []struct {
-		n              *Node
-		justifiedEpoch types.Epoch
-		finalizedEpoch types.Epoch
-		currentEpoch   types.Epoch
-		want           bool
-	}{
-		{&Node{}, 0, 0, 0, true},
-		{&Node{}, 1, 0, 1, false},
-		{&Node{}, 0, 1, 1, false},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 1}, 1, 1, 1, true},
-		{&Node{finalizedEpoch: 1, justifiedEpoch: 1}, 2, 2, 2, false},
-		{&Node{finalizedEpoch: 3, justifiedEpoch: 4}, 4, 3, 3, true},
-		{&Node{unrealizedFinalizedEpoch: 3, unrealizedJustifiedEpoch: 4}, 3, 2, 4, true},
-		{&Node{unrealizedFinalizedEpoch: 2, unrealizedJustifiedEpoch: 3}, 3, 2, 4, true},
-		{&Node{unrealizedFinalizedEpoch: 1, unrealizedJustifiedEpoch: 2}, 3, 2, 4, false},
-	}
-	for _, tc := range tests {
-		jc := &forkchoicetypes.Checkpoint{Epoch: tc.justifiedEpoch}
-		fc := &forkchoicetypes.Checkpoint{Epoch: tc.finalizedEpoch}
-		currentTime := uint64(time.Now().Unix())
-		driftSeconds := uint64(params.BeaconConfig().SlotsPerEpoch) * params.BeaconConfig().SecondsPerSlot
-		s := &Store{
-			justifiedCheckpoint: jc,
-			finalizedCheckpoint: fc,
-			genesisTime:         currentTime - driftSeconds*uint64(tc.currentEpoch),
-		}
-		assert.Equal(t, tc.want, s.viableForHead(tc.n))
-	}
-}
-
 func TestStore_HasParent(t *testing.T) {
 	tests := []struct {
 		m    map[[32]byte]uint64

beacon-chain/p2p/monitoring.go

@@ -1,39 +1,20 @@
 package p2p
 
 import (
-	"strings"
-
-	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promauto"
 )
 
 var (
-	knownAgentVersions = []string{
-		"lighthouse",
-		"nimbus",
-		"prysm",
-		"teku",
-		"js-libp2p",
-		"rust-libp2p",
-	}
 	p2pPeerCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
 		Name: "p2p_peer_count",
 		Help: "The number of peers in a given state.",
 	},
 		[]string{"state"})
-	connectedPeersCount = promauto.NewGaugeVec(prometheus.GaugeOpts{
-		Name: "connected_libp2p_peers",
-		Help: "Tracks the total number of connected libp2p peers by agent string",
-	},
-		[]string{"agent"},
-	)
-	avgScoreConnectedClients = promauto.NewGaugeVec(prometheus.GaugeOpts{
-		Name: "connected_libp2p_peers_average_scores",
-		Help: "Tracks the overall p2p scores of connected libp2p peers by agent string",
-	},
-		[]string{"agent"},
-	)
+	totalPeerCount = promauto.NewGauge(prometheus.GaugeOpts{
+		Name: "libp2p_peers",
+		Help: "Tracks the total number of libp2p peers",
+	})
 	repeatPeerConnections = promauto.NewCounter(prometheus.CounterOpts{
 		Name: "p2p_repeat_attempts",
 		Help: "The number of repeat attempts the connection handler is triggered for a peer.",
@@ -65,60 +46,10 @@ var (
 )
 
 func (s *Service) updateMetrics() {
-	connectedPeers := s.peers.Connected()
-	p2pPeerCount.WithLabelValues("Connected").Set(float64(len(connectedPeers)))
+	totalPeerCount.Set(float64(len(s.peers.Connected())))
+	p2pPeerCount.WithLabelValues("Connected").Set(float64(len(s.peers.Connected())))
 	p2pPeerCount.WithLabelValues("Disconnected").Set(float64(len(s.peers.Disconnected())))
 	p2pPeerCount.WithLabelValues("Connecting").Set(float64(len(s.peers.Connecting())))
 	p2pPeerCount.WithLabelValues("Disconnecting").Set(float64(len(s.peers.Disconnecting())))
 	p2pPeerCount.WithLabelValues("Bad").Set(float64(len(s.peers.Bad())))
-
-	store := s.Host().Peerstore()
-	numConnectedPeersByClient := make(map[string]float64)
-	peerScoresByClient := make(map[string][]float64)
-	for i := 0; i < len(connectedPeers); i++ {
-		p := connectedPeers[i]
-		pid, err := peer.Decode(p.String())
-		if err != nil {
-			log.WithError(err).Debug("Could not decode peer string")
-			continue
-		}
-
-		// Get the agent data.
-		rawAgent, err := store.Get(pid, "AgentVersion")
-		agent, ok := rawAgent.(string)
-		if err != nil || !ok {
-			agent = "unknown"
-		}
-		foundName := "unknown"
-		for _, knownAgent := range knownAgentVersions {
-			// If the agent string matches one of our known agents, we set
-			// the value to our own, sanitized string.
-			if strings.Contains(strings.ToLower(agent), knownAgent) {
-				foundName = knownAgent
-			}
-		}
-		numConnectedPeersByClient[foundName] += 1
-
-		// Get peer scoring data.
-		overallScore := s.peers.Scorers().Score(pid)
-		peerScoresByClient[foundName] = append(peerScoresByClient[foundName], overallScore)
-	}
-	for agent, total := range numConnectedPeersByClient {
-		connectedPeersCount.WithLabelValues(agent).Set(total)
-	}
-	for agent, scoringData := range peerScoresByClient {
-		avgScore := average(scoringData)
-		avgScoreConnectedClients.WithLabelValues(agent).Set(avgScore)
-	}
-}
-
-func average(xs []float64) float64 {
-	if len(xs) == 0 {
-		return 0
-	}
-	total := 0.0
-	for _, v := range xs {
-		total += v
-	}
-	return total / float64(len(xs))
 }

beacon-chain/p2p/parameter_test.go

@@ -44,5 +44,5 @@ func TestHeartbeatParameters(t *testing.T) {
 func TestMiscParameters(t *testing.T) {
 	params.SetupTestConfigCleanup(t)
 	setPubSubParameters()
-	assert.Equal(t, rSubD, 8, "rSubD")
+	assert.Equal(t, randomSubD, pubsub.RandomSubD, "randomSubD")
 }

beacon-chain/p2p/pubsub.go

@@ -8,10 +8,8 @@ import (
 
 	"github.com/libp2p/go-libp2p-core/peer"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
-	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/pkg/errors"
 	"github.com/prysmaticlabs/prysm/v3/cmd/beacon-chain/flags"
-	"github.com/prysmaticlabs/prysm/v3/config/params"
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	pbrpc "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
 )
@@ -34,7 +32,7 @@ const (
 	gossipSubHeartbeatInterval = 700 * time.Millisecond // frequency of heartbeat, milliseconds
 
 	// misc
-	rSubD = 8 // random gossip target
+	randomSubD = 6 // random gossip target
 )
 
 var errInvalidTopic = errors.New("invalid topic format")
@@ -130,25 +128,6 @@ func (s *Service) peerInspector(peerMap map[peer.ID]*pubsub.PeerScoreSnapshot) {
 	}
 }
 
-// Creates a list of pubsub options to configure out router with.
-func (s *Service) pubsubOptions() []pubsub.Option {
-	psOpts := []pubsub.Option{
-		pubsub.WithMessageSignaturePolicy(pubsub.StrictNoSign),
-		pubsub.WithNoAuthor(),
-		pubsub.WithMessageIdFn(func(pmsg *pubsubpb.Message) string {
-			return MsgID(s.genesisValidatorsRoot, pmsg)
-		}),
-		pubsub.WithSubscriptionFilter(s),
-		pubsub.WithPeerOutboundQueueSize(pubsubQueueSize),
-		pubsub.WithMaxMessageSize(int(params.BeaconNetworkConfig().GossipMaxSizeBellatrix)),
-		pubsub.WithValidateQueueSize(pubsubQueueSize),
-		pubsub.WithPeerScore(peerScoringParams()),
-		pubsub.WithPeerScoreInspect(s.peerInspector, time.Minute),
-		pubsub.WithGossipSubParams(pubsubGossipParam()),
-	}
-	return psOpts
-}
-
 // creates a custom gossipsub parameter set.
 func pubsubGossipParam() pubsub.GossipSubParams {
 	gParams := pubsub.DefaultGossipSubParams()

beacon-chain/p2p/service.go

@@ -18,6 +18,7 @@ import (
 	"github.com/libp2p/go-libp2p-core/peer"
 	"github.com/libp2p/go-libp2p-core/protocol"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	pubsubpb "github.com/libp2p/go-libp2p-pubsub/pb"
 	"github.com/libp2p/go-libp2p/p2p/protocol/identify"
 	"github.com/multiformats/go-multiaddr"
 	"github.com/pkg/errors"
@@ -138,7 +139,19 @@ func NewService(ctx context.Context, cfg *Config) (*Service, error) {
 	// due to libp2p's gossipsub implementation not taking into
 	// account previously added peers when creating the gossipsub
 	// object.
-	psOpts := s.pubsubOptions()
+	psOpts := []pubsub.Option{
+		pubsub.WithMessageSignaturePolicy(pubsub.StrictNoSign),
+		pubsub.WithNoAuthor(),
+		pubsub.WithMessageIdFn(func(pmsg *pubsubpb.Message) string {
+			return MsgID(s.genesisValidatorsRoot, pmsg)
+		}),
+		pubsub.WithSubscriptionFilter(s),
+		pubsub.WithPeerOutboundQueueSize(pubsubQueueSize),
+		pubsub.WithValidateQueueSize(pubsubQueueSize),
+		pubsub.WithPeerScore(peerScoringParams()),
+		pubsub.WithPeerScoreInspect(s.peerInspector, time.Minute),
+		pubsub.WithGossipSubParams(pubsubGossipParam()),
+	}
 	// Set the pubsub global parameters that we require.
 	setPubSubParameters()
 	// Reinitialize them in the event we are running a custom config.
@@ -232,7 +245,9 @@ func (s *Service) Start() {
 	})
 	async.RunEvery(s.ctx, 30*time.Minute, s.Peers().Prune)
 	async.RunEvery(s.ctx, params.BeaconNetworkConfig().RespTimeout, s.updateMetrics)
-	async.RunEvery(s.ctx, refreshRate, s.RefreshENR)
+	async.RunEvery(s.ctx, refreshRate, func() {
+		s.RefreshENR()
+	})
 	async.RunEvery(s.ctx, 1*time.Minute, func() {
 		log.WithFields(logrus.Fields{
 			"inbound":     len(s.peers.InboundConnected()),

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

@@ -53,7 +53,6 @@ go_library(
         "//beacon-chain/state:go_default_library",
         "//beacon-chain/state/stategen:go_default_library",
         "//beacon-chain/sync:go_default_library",
-        "//config/features:go_default_library",
         "//config/fieldparams:go_default_library",
         "//config/params:go_default_library",
         "//consensus-types/blocks:go_default_library",

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

@@ -127,8 +127,9 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Sl
 		return nil, errors.New("builder returned nil bid")
 	}
 
-	v := new(big.Int).SetBytes(bytesutil.ReverseByteOrder(bid.Message.Value))
-	if v.String() == "0" {
+	v := bid.Message.Value
+
+	if new(big.Int).SetBytes(bytesutil.ReverseByteOrder(v)).String() == "0" {
 		return nil, errors.New("builder returned header with 0 bid amount")
 	}
 
@@ -158,7 +159,7 @@ func (vs *Server) getPayloadHeaderFromBuilder(ctx context.Context, slot types.Sl
 	}
 
 	log.WithFields(logrus.Fields{
-		"value":         v.String(),
+		"bid":           bytesutil.BytesToUint64BigEndian(bid.Message.Value),
 		"builderPubKey": fmt.Sprintf("%#x", bid.Message.Pubkey),
 		"blockHash":     fmt.Sprintf("%#x", bid.Message.Header.BlockHash),
 	}).Info("Received header with bid")

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

@@ -8,7 +8,6 @@ import (
 	fastssz "github.com/prysmaticlabs/fastssz"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/core/blocks"
 	"github.com/prysmaticlabs/prysm/v3/beacon-chain/state"
-	"github.com/prysmaticlabs/prysm/v3/config/features"
 	"github.com/prysmaticlabs/prysm/v3/config/params"
 	types "github.com/prysmaticlabs/prysm/v3/consensus-types/primitives"
 	"github.com/prysmaticlabs/prysm/v3/crypto/hash"
@@ -107,9 +106,6 @@ func (vs *Server) canonicalEth1Data(
 		canonicalEth1Data = beaconState.Eth1Data()
 		eth1BlockHash = bytesutil.ToBytes32(beaconState.Eth1Data().BlockHash)
 	}
-	if features.Get().DisableStakinContractCheck && eth1BlockHash == [32]byte{} {
-		return canonicalEth1Data, new(big.Int).SetInt64(0), nil
-	}
 	_, canonicalEth1DataHeight, err := vs.Eth1BlockFetcher.BlockExists(ctx, eth1BlockHash)
 	if err != nil {
 		return nil, nil, errors.Wrap(err, "could not fetch eth1data height")

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

@@ -123,9 +123,6 @@ func (vs *Server) ValidatorIndex(ctx context.Context, req *ethpb.ValidatorIndexR
 	if err != nil {
 		return nil, status.Errorf(codes.Internal, "Could not determine head state: %v", err)
 	}
-	if st == nil || st.IsNil() {
-		return nil, status.Errorf(codes.Internal, "head state is empty")
-	}
 	index, ok := st.ValidatorIndexByPubkey(bytesutil.ToBytes48(req.PublicKey))
 	if !ok {
 		return nil, status.Errorf(codes.NotFound, "Could not find validator index for public key %#x", req.PublicKey)

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

@@ -48,18 +48,6 @@ func TestValidatorIndex_OK(t *testing.T) {
 	assert.NoError(t, err, "Could not get validator index")
 }
 
-func TestValidatorIndex_StateEmpty(t *testing.T) {
-	Server := &Server{
-		HeadFetcher: &mockChain.ChainService{},
-	}
-	pubKey := pubKey(1)
-	req := &ethpb.ValidatorIndexRequest{
-		PublicKey: pubKey,
-	}
-	_, err := Server.ValidatorIndex(context.Background(), req)
-	assert.ErrorContains(t, "head state is empty", err)
-}
-
 func TestWaitForActivation_ContextClosed(t *testing.T) {
 	beaconState, err := v1.InitializeFromProto(&ethpb.BeaconState{
 		Slot:       0,

beacon-chain/rpc/statefetcher/fetcher.go

@@ -253,10 +253,7 @@ func (p *StateProvider) finalizedStateRoot(ctx context.Context) ([]byte, error)
 }
 
 func (p *StateProvider) justifiedStateRoot(ctx context.Context) ([]byte, error) {
-	cp, err := p.BeaconDB.JustifiedCheckpoint(ctx)
-	if err != nil {
-		return nil, errors.Wrap(err, "could not get justified checkpoint")
-	}
+	cp := p.ChainInfoFetcher.CurrentJustifiedCheckpt()
 	b, err := p.BeaconDB.Block(ctx, bytesutil.ToBytes32(cp.Root))
 	if err != nil {
 		return nil, errors.Wrap(err, "could not get justified block")

beacon-chain/rpc/statefetcher/fetcher_test.go

@@ -284,10 +284,6 @@ func TestGetStateRoot(t *testing.T) {
 		blk.Block.Slot = 40
 		root, err := blk.Block.HashTreeRoot()
 		require.NoError(t, err)
-		cp := &ethpb.Checkpoint{
-			Epoch: 5,
-			Root:  root[:],
-		}
 		// a valid chain is required to save finalized checkpoint.
 		util.SaveBlock(t, ctx, db, blk)
 		st, err := util.NewBeaconState()
@@ -295,7 +291,6 @@ func TestGetStateRoot(t *testing.T) {
 		require.NoError(t, st.SetSlot(1))
 		// a state is required to save checkpoint
 		require.NoError(t, db.SaveState(ctx, st, root))
-		require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
 
 		p := StateProvider{
 			BeaconDB: db,

beacon-chain/state/stategen/metrics.go

@@ -13,16 +13,4 @@ var (
 			Buckets: []float64{64, 256, 1024, 2048, 4096},
 		},
 	)
-	replayBlocksSummary = promauto.NewSummary(
-		prometheus.SummaryOpts{
-			Name: "replay_blocks_milliseconds",
-			Help: "Time it took to replay blocks",
-		},
-	)
-	replayToSlotSummary = promauto.NewSummary(
-		prometheus.SummaryOpts{
-			Name: "replay_to_slot_milliseconds",
-			Help: "Time it took to replay to slot",
-		},
-	)
 )

beacon-chain/state/stategen/replayer.go

@@ -119,7 +119,6 @@ func (rs *stateReplayer) ReplayBlocks(ctx context.Context) (state.BeaconState, e
 	log.WithFields(logrus.Fields{
 		"duration": duration,
 	}).Debug("Finished calling process_blocks on all blocks in ReplayBlocks")
-	replayBlocksSummary.Observe(float64(duration.Milliseconds()))
 	return s, nil
 }
 
@@ -151,14 +150,14 @@ func (rs *stateReplayer) ReplayToSlot(ctx context.Context, replayTo types.Slot)
 
 	// err will be handled after the bookend log
 	s, err = ReplayProcessSlots(ctx, s, replayTo)
-	if err != nil {
-		return nil, errors.Wrap(err, fmt.Sprintf("ReplayToSlot failed to seek to slot %d after applying blocks", replayTo))
-	}
+
 	duration := time.Since(start)
 	log.WithFields(logrus.Fields{
 		"duration": duration,
 	}).Debug("time spent in process_slots")
-	replayToSlotSummary.Observe(float64(duration.Milliseconds()))
+	if err != nil {
+		return nil, errors.Wrap(err, fmt.Sprintf("ReplayToSlot failed to seek to slot %d after applying blocks", replayTo))
+	}
 
 	return s, nil
 }

beacon-chain/sync/initial-sync/round_robin.go

@@ -131,7 +131,7 @@ func (s *Service) processFetchedData(
 
 	// Use Batch Block Verify to process and verify batches directly.
 	if err := s.processBatchedBlocks(ctx, genesis, data.blocks, s.cfg.Chain.ReceiveBlockBatch); err != nil {
-		log.WithError(err).Warn("Skip processing batched blocks")
+		log.WithError(err).Warn("Batch is not processed")
 	}
 }
 
@@ -260,7 +260,7 @@ func (s *Service) processBatchedBlocks(ctx context.Context, genesis time.Time,
 	headSlot := s.cfg.Chain.HeadSlot()
 	for headSlot >= firstBlock.Block().Slot() && s.isProcessedBlock(ctx, firstBlock, blkRoot) {
 		if len(blks) == 1 {
-			return fmt.Errorf("headSlot:%d, blockSlot:%d , root %#x:%w", headSlot, firstBlock.Block().Slot(), blkRoot, errBlockAlreadyProcessed)
+			return errors.New("no good blocks in batch")
 		}
 		blks = blks[1:]
 		firstBlock = blks[0]

beacon-chain/sync/initial-sync/round_robin_test.go

@@ -457,7 +457,7 @@ func TestService_processBlockBatch(t *testing.T) {
 			ctx context.Context, blocks []interfaces.SignedBeaconBlock, blockRoots [][32]byte) error {
 			return nil
 		})
-		assert.ErrorContains(t, "block is already processed", err)
+		assert.ErrorContains(t, "no good blocks in batch", err)
 
 		var badBatch2 []interfaces.SignedBeaconBlock
 		for i, b := range batch2 {

beacon-chain/sync/metrics.go

@@ -89,38 +89,6 @@ var (
 			Buckets: []float64{250, 500, 1000, 1500, 2000, 4000, 8000, 16000},
 		},
 	)
-
-	// Attestation processing granular error tracking.
-	attBadBlockCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "gossip_attestation_bad_block_total",
-		Help: "Increased when a gossip attestation references a bad block",
-	})
-	attBadLmdConsistencyCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "gossip_attestation_bad_lmd_consistency_total",
-		Help: "Increased when a gossip attestation has bad LMD GHOST consistency",
-	})
-	attBadSelectionProofCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "gossip_attestation_bad_selection_proof_total",
-		Help: "Increased when a gossip attestation has a bad selection proof",
-	})
-	attBadSignatureBatchCount = promauto.NewCounter(prometheus.CounterOpts{
-		Name: "gossip_attestation_bad_signature_batch_total",
-		Help: "Increased when a gossip attestation has a bad signature batch",
-	})
-
-	// Attestation and block gossip verification performance.
-	aggregateAttestationVerificationGossipSummary = promauto.NewSummary(
-		prometheus.SummaryOpts{
-			Name: "gossip_aggregate_attestation_verification_milliseconds",
-			Help: "Time to verify gossiped attestations",
-		},
-	)
-	blockVerificationGossipSummary = promauto.NewSummary(
-		prometheus.SummaryOpts{
-			Name: "gossip_block_verification_milliseconds",
-			Help: "Time to verify gossiped blocks",
-		},
-	)
 )
 
 func (s *Service) updateMetrics() {

beacon-chain/sync/validate_aggregate_proof.go

@@ -20,7 +20,6 @@ import (
 	"github.com/prysmaticlabs/prysm/v3/encoding/bytesutil"
 	"github.com/prysmaticlabs/prysm/v3/monitoring/tracing"
 	ethpb "github.com/prysmaticlabs/prysm/v3/proto/prysm/v1alpha1"
-	prysmTime "github.com/prysmaticlabs/prysm/v3/time"
 	"github.com/prysmaticlabs/prysm/v3/time/slots"
 	"go.opencensus.io/trace"
 )
@@ -28,7 +27,6 @@ import (
 // validateAggregateAndProof verifies the aggregated signature and the selection proof is valid before forwarding to the
 // network and downstream services.
 func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, msg *pubsub.Message) (pubsub.ValidationResult, error) {
-	receivedTime := prysmTime.Now()
 	if pid == s.cfg.p2p.PeerID() {
 		return pubsub.ValidationAccept, nil
 	}
@@ -77,11 +75,8 @@ func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, ms
 
 	// Attestation's slot is within ATTESTATION_PROPAGATION_SLOT_RANGE and early attestation
 	// processing tolerance.
-	if err := helpers.ValidateAttestationTime(
-		m.Message.Aggregate.Data.Slot,
-		s.cfg.chain.GenesisTime(),
-		earlyAttestationProcessingTolerance,
-	); err != nil {
+	if err := helpers.ValidateAttestationTime(m.Message.Aggregate.Data.Slot, s.cfg.chain.GenesisTime(),
+		earlyAttestationProcessingTolerance); err != nil {
 		tracing.AnnotateError(span, err)
 		return pubsub.ValidationIgnore, err
 	}
@@ -94,7 +89,6 @@ func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, ms
 	if s.hasBadBlock(bytesutil.ToBytes32(m.Message.Aggregate.Data.BeaconBlockRoot)) ||
 		s.hasBadBlock(bytesutil.ToBytes32(m.Message.Aggregate.Data.Target.Root)) ||
 		s.hasBadBlock(bytesutil.ToBytes32(m.Message.Aggregate.Data.Source.Root)) {
-		attBadBlockCount.Inc()
 		return pubsub.ValidationReject, errors.New("bad block referenced in attestation data")
 	}
 
@@ -120,8 +114,6 @@ func (s *Service) validateAggregateAndProof(ctx context.Context, pid peer.ID, ms
 
 	msg.ValidatorData = m
 
-	aggregateAttestationVerificationGossipSummary.Observe(float64(prysmTime.Since(receivedTime).Milliseconds()))
-
 	return pubsub.ValidationAccept, nil
 }
 
@@ -135,7 +127,6 @@ func (s *Service) validateAggregatedAtt(ctx context.Context, signed *ethpb.Signe
 	// but it's invalid in the spirit of the protocol. Here we choose safety over profit.
 	if err := s.cfg.chain.VerifyLmdFfgConsistency(ctx, signed.Message.Aggregate); err != nil {
 		tracing.AnnotateError(span, err)
-		attBadLmdConsistencyCount.Inc()
 		return pubsub.ValidationReject, err
 	}
 
@@ -177,7 +168,6 @@ func (s *Service) validateAggregatedAtt(ctx context.Context, signed *ethpb.Signe
 	if err != nil {
 		wrappedErr := errors.Wrapf(err, "Could not validate selection for validator %d", signed.Message.AggregatorIndex)
 		tracing.AnnotateError(span, wrappedErr)
-		attBadSelectionProofCount.Inc()
 		return pubsub.ValidationReject, wrappedErr
 	}
 

beacon-chain/sync/validate_beacon_attestation.go

@@ -124,7 +124,6 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 	if s.hasBadBlock(bytesutil.ToBytes32(att.Data.BeaconBlockRoot)) ||
 		s.hasBadBlock(bytesutil.ToBytes32(att.Data.Target.Root)) ||
 		s.hasBadBlock(bytesutil.ToBytes32(att.Data.Source.Root)) {
-		attBadBlockCount.Inc()
 		return pubsub.ValidationReject, errors.New("attestation data references bad block root")
 	}
 
@@ -142,7 +141,6 @@ func (s *Service) validateCommitteeIndexBeaconAttestation(ctx context.Context, p
 	}
 	if err := s.cfg.chain.VerifyLmdFfgConsistency(ctx, att); err != nil {
 		tracing.AnnotateError(span, err)
-		attBadLmdConsistencyCount.Inc()
 		return pubsub.ValidationReject, err
 	}
 
@@ -224,7 +222,6 @@ func (s *Service) validateUnaggregatedAttWithState(ctx context.Context, a *eth.A
 	set, err := blocks.AttestationSignatureBatch(ctx, bs, []*eth.Attestation{a})
 	if err != nil {
 		tracing.AnnotateError(span, err)
-		attBadSignatureBatchCount.Inc()
 		return pubsub.ValidationReject, err
 	}
 	return s.validateWithBatchVerifier(ctx, "attestation", set)

beacon-chain/sync/validate_beacon_blocks.go

@@ -204,8 +204,6 @@ func (s *Service) validateBeaconBlockPubSub(ctx context.Context, pid peer.ID, ms
 		"proposerIndex":      blk.Block().ProposerIndex(),
 		"graffiti":           string(blk.Block().Body().Graffiti()),
 	}).Debug("Received block")
-
-	blockVerificationGossipSummary.Observe(float64(prysmTime.Since(receivedTime).Milliseconds()))
 	return pubsub.ValidationAccept, nil
 }
 
@@ -255,17 +253,16 @@ func (s *Service) validateBeaconBlock(ctx context.Context, blk interfaces.Signed
 
 // validateBellatrixBeaconBlock validates the block for the Bellatrix fork.
 // spec code:
+//   If the execution is enabled for the block -- i.e. is_execution_enabled(state, block.body) then validate the following:
+//      [REJECT] The block's execution payload timestamp is correct with respect to the slot --
+//      i.e. execution_payload.timestamp == compute_timestamp_at_slot(state, block.slot).
 //
-//	If the execution is enabled for the block -- i.e. is_execution_enabled(state, block.body) then validate the following:
-//	   [REJECT] The block's execution payload timestamp is correct with respect to the slot --
-//	   i.e. execution_payload.timestamp == compute_timestamp_at_slot(state, block.slot).
-//
-//	   If exection_payload verification of block's parent by an execution node is not complete:
-//	      [REJECT] The block's parent (defined by block.parent_root) passes all validation (excluding execution
-//	       node verification of the block.body.execution_payload).
-//	   otherwise:
-//	      [IGNORE] The block's parent (defined by block.parent_root) passes all validation (including execution
-//	       node verification of the block.body.execution_payload).
+//      If exection_payload verification of block's parent by an execution node is not complete:
+//         [REJECT] The block's parent (defined by block.parent_root) passes all validation (excluding execution
+//          node verification of the block.body.execution_payload).
+//      otherwise:
+//         [IGNORE] The block's parent (defined by block.parent_root) passes all validation (including execution
+//          node verification of the block.body.execution_payload).
 func (s *Service) validateBellatrixBeaconBlock(ctx context.Context, parentState state.BeaconState, blk interfaces.BeaconBlock) error {
 	// Error if block and state are not the same version
 	if parentState.Version() != blk.Version() {

cmd/prysmctl/BUILD.bazel

@@ -11,11 +11,9 @@ go_library(
     importpath = "github.com/prysmaticlabs/prysm/v3/cmd/prysmctl",
     visibility = ["//visibility:private"],
     deps = [
-        "//cmd/prysmctl/checkpointsync:go_default_library",
-        "//cmd/prysmctl/deprecated:go_default_library",
+        "//cmd/prysmctl/checkpoint:go_default_library",
         "//cmd/prysmctl/p2p:go_default_library",
         "//cmd/prysmctl/testnet:go_default_library",
-        "//cmd/prysmctl/weaksubjectivity:go_default_library",
         "@com_github_sirupsen_logrus//:go_default_library",
         "@com_github_urfave_cli_v2//:go_default_library",
     ],

cmd/prysmctl/checkpoint/BUILD.bazel

@@ -3,10 +3,11 @@ load("@prysm//tools/go:def.bzl", "go_library")
 go_library(
     name = "go_default_library",
     srcs = [
-        "cmd.go",
-        "download.go",
+        "checkpoint.go",
+        "latest.go",
+        "save.go",
     ],
-    importpath = "github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/checkpointsync",
+    importpath = "github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/checkpoint",
     visibility = ["//visibility:public"],
     deps = [
         "//api/client/beacon:go_default_library",

cmd/prysmctl/checkpoint/checkpoint.go

@@ -6,9 +6,9 @@ var Commands = []*cli.Command{
 	{
 		Name:    "checkpoint",
 		Aliases: []string{"cpt"},
-		Usage:   "deprecated",
+		Usage:   "commands for managing checkpoint syncing",
 		Subcommands: []*cli.Command{
-			checkpointCmd,
+			latestCmd,
 			saveCmd,
 		},
 	},

cmd/prysmctl/checkpoint/latest.go

@@ -1,4 +1,4 @@
-package weaksubjectivity
+package checkpoint
 
 import (
 	"context"
@@ -9,38 +9,37 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-var checkpointFlags = struct {
+var latestFlags = struct {
 	BeaconNodeHost string
 	Timeout        time.Duration
 }{}
 
-var checkpointCmd = &cli.Command{
-	Name:    "checkpoint",
-	Aliases: []string{"cpt"},
-	Usage:   "Compute the latest weak subjectivity checkpoint (block_root:epoch) using trusted server data.",
-	Action:  cliActionCheckpoint,
+var latestCmd = &cli.Command{
+	Name:   "latest",
+	Usage:  "Compute the latest weak subjectivity checkpoint (block_root:epoch) using trusted server data.",
+	Action: cliActionLatest,
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:        "beacon-node-host",
 			Usage:       "host:port for beacon node to query",
-			Destination: &checkpointFlags.BeaconNodeHost,
+			Destination: &latestFlags.BeaconNodeHost,
 			Value:       "http://localhost:3500",
 		},
 		&cli.DurationFlag{
 			Name:        "http-timeout",
 			Usage:       "timeout for http requests made to beacon-node-url (uses duration format, ex: 2m31s). default: 2m",
-			Destination: &checkpointFlags.Timeout,
+			Destination: &latestFlags.Timeout,
 			Value:       time.Minute * 2,
 		},
 	},
 }
 
-func cliActionCheckpoint(_ *cli.Context) error {
+func cliActionLatest(_ *cli.Context) error {
 	ctx := context.Background()
-	f := checkpointFlags
+	f := latestFlags
 
 	opts := []beacon.ClientOpt{beacon.WithTimeout(f.Timeout)}
-	client, err := beacon.NewClient(checkpointFlags.BeaconNodeHost, opts...)
+	client, err := beacon.NewClient(latestFlags.BeaconNodeHost, opts...)
 	if err != nil {
 		return err
 	}

cmd/prysmctl/checkpoint/save.go

@@ -1,4 +1,4 @@
-package checkpointsync
+package checkpoint
 
 import (
 	"context"
@@ -10,38 +10,37 @@ import (
 	"github.com/urfave/cli/v2"
 )
 
-var downloadFlags = struct {
+var saveFlags = struct {
 	BeaconNodeHost string
 	Timeout        time.Duration
 }{}
 
-var downloadCmd = &cli.Command{
-	Name:    "download",
-	Aliases: []string{"dl"},
-	Usage:   "Download the latest finalized state and the most recent block it integrates. To be used for checkpoint sync.",
-	Action:  cliActionDownload,
+var saveCmd = &cli.Command{
+	Name:   "save",
+	Usage:  "Save the latest finalized header and the most recent block it integrates. To be used for checkpoint sync.",
+	Action: cliActionSave,
 	Flags: []cli.Flag{
 		&cli.StringFlag{
 			Name:        "beacon-node-host",
 			Usage:       "host:port for beacon node connection",
-			Destination: &downloadFlags.BeaconNodeHost,
+			Destination: &saveFlags.BeaconNodeHost,
 			Value:       "localhost:3500",
 		},
 		&cli.DurationFlag{
 			Name:        "http-timeout",
 			Usage:       "timeout for http requests made to beacon-node-url (uses duration format, ex: 2m31s). default: 4m",
-			Destination: &downloadFlags.Timeout,
+			Destination: &saveFlags.Timeout,
 			Value:       time.Minute * 4,
 		},
 	},
 }
 
-func cliActionDownload(_ *cli.Context) error {
+func cliActionSave(_ *cli.Context) error {
 	ctx := context.Background()
-	f := downloadFlags
+	f := saveFlags
 
 	opts := []beacon.ClientOpt{beacon.WithTimeout(f.Timeout)}
-	client, err := beacon.NewClient(downloadFlags.BeaconNodeHost, opts...)
+	client, err := beacon.NewClient(saveFlags.BeaconNodeHost, opts...)
 	if err != nil {
 		return err
 	}

cmd/prysmctl/checkpointsync/cmd.go

@@ -1,14 +0,0 @@
-package checkpointsync
-
-import "github.com/urfave/cli/v2"
-
-var Commands = []*cli.Command{
-	{
-		Name:    "checkpoint-sync",
-		Aliases: []string{"cpt-sync"},
-		Usage:   "commands for managing checkpoint sync",
-		Subcommands: []*cli.Command{
-			downloadCmd,
-		},
-	},
-}

cmd/prysmctl/deprecated/BUILD.bazel

@@ -1,12 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = ["cmd.go"],
-    importpath = "github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/deprecated",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//cmd/prysmctl/deprecated/checkpoint:go_default_library",
-        "@com_github_urfave_cli_v2//:go_default_library",
-    ],
-)

cmd/prysmctl/deprecated/checkpoint/BUILD.bazel

@@ -1,13 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "checkpoint.go",
-        "latest.go",
-        "save.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/deprecated/checkpoint",
-    visibility = ["//visibility:public"],
-    deps = ["@com_github_urfave_cli_v2//:go_default_library"],
-)

cmd/prysmctl/deprecated/checkpoint/latest.go

@@ -1,17 +0,0 @@
-package checkpoint
-
-import (
-	"fmt"
-
-	"github.com/urfave/cli/v2"
-)
-
-var checkpointCmd = &cli.Command{
-	Name:   "latest",
-	Usage:  "deprecated - please use 'prysmctl weak-subjectivity checkpoint' instead!",
-	Action: cliDeprecatedLatest,
-}
-
-func cliDeprecatedLatest(_ *cli.Context) error {
-	return fmt.Errorf("This command has moved. Please use 'prysmctl weak-subjectivity checkpoint' instead!")
-}

cmd/prysmctl/deprecated/checkpoint/save.go

@@ -1,17 +0,0 @@
-package checkpoint
-
-import (
-	"fmt"
-
-	"github.com/urfave/cli/v2"
-)
-
-var saveCmd = &cli.Command{
-	Name:   "save",
-	Usage:  "deprecated - please use 'prysmctl checkpoint-sync download' instead!",
-	Action: cliActionDeprecatedSave,
-}
-
-func cliActionDeprecatedSave(_ *cli.Context) error {
-	return fmt.Errorf("This command has moved. Please use 'prysmctl checkpoint-sync download' instead!")
-}

cmd/prysmctl/deprecated/cmd.go

@@ -1,12 +0,0 @@
-package deprecated
-
-import (
-	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/deprecated/checkpoint"
-	"github.com/urfave/cli/v2"
-)
-
-var Commands = []*cli.Command{}
-
-func init() {
-	Commands = append(Commands, checkpoint.Commands...)
-}

cmd/prysmctl/main.go

@@ -3,11 +3,9 @@ package main
 import (
 	"os"
 
-	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/checkpointsync"
-	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/deprecated"
+	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/checkpoint"
 	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/p2p"
 	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/testnet"
-	"github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/weaksubjectivity"
 	log "github.com/sirupsen/logrus"
 	"github.com/urfave/cli/v2"
 )
@@ -25,12 +23,7 @@ func main() {
 }
 
 func init() {
-	// contains the old checkpoint sync subcommands. these commands should display help/warn messages
-	// pointing to their new locations
-	prysmctlCommands = append(prysmctlCommands, deprecated.Commands...)
-
-	prysmctlCommands = append(prysmctlCommands, checkpointsync.Commands...)
-	prysmctlCommands = append(prysmctlCommands, p2p.Commands...)
+	prysmctlCommands = append(prysmctlCommands, checkpoint.Commands...)
 	prysmctlCommands = append(prysmctlCommands, testnet.Commands...)
-	prysmctlCommands = append(prysmctlCommands, weaksubjectivity.Commands...)
+	prysmctlCommands = append(prysmctlCommands, p2p.Commands...)
 }

cmd/prysmctl/weaksubjectivity/BUILD.bazel

@@ -1,15 +0,0 @@
-load("@prysm//tools/go:def.bzl", "go_library")
-
-go_library(
-    name = "go_default_library",
-    srcs = [
-        "checkpoint.go",
-        "cmd.go",
-    ],
-    importpath = "github.com/prysmaticlabs/prysm/v3/cmd/prysmctl/weaksubjectivity",
-    visibility = ["//visibility:public"],
-    deps = [
-        "//api/client/beacon:go_default_library",
-        "@com_github_urfave_cli_v2//:go_default_library",
-    ],
-)

cmd/prysmctl/weaksubjectivity/cmd.go

@@ -1,14 +0,0 @@
-package weaksubjectivity
-
-import "github.com/urfave/cli/v2"
-
-var Commands = []*cli.Command{
-	{
-		Name:    "weak-subjectivity",
-		Aliases: []string{"ws"},
-		Usage:   "commands dealing with weak subjectivity",
-		Subcommands: []*cli.Command{
-			checkpointCmd,
-		},
-	},
-}

config/features/config.go

@@ -69,8 +69,6 @@ type Flags struct {
 	EnableOnlyBlindedBeaconBlocks     bool // EnableOnlyBlindedBeaconBlocks enables only storing blinded beacon blocks in the DB post-Bellatrix fork.
 	EnableStartOptimistic             bool // EnableStartOptimistic treats every block as optimistic at startup.
 
-	DisableStakinContractCheck bool // Disables check for deposit contract when proposing blocks
-
 	// KeystoreImportDebounceInterval specifies the time duration the validator waits to reload new keys if they have
 	// changed on disk. This feature is for advanced use cases only.
 	KeystoreImportDebounceInterval time.Duration
@@ -216,10 +214,7 @@ func ConfigureBeaconChain(ctx *cli.Context) error {
 		logEnabled(enableDefensivePull)
 		cfg.EnableDefensivePull = true
 	}
-	if ctx.Bool(disableStakinContractCheck.Name) {
-		logEnabled(disableStakinContractCheck)
-		cfg.DisableStakinContractCheck = true
-	}
+
 	if ctx.Bool(disableVecHTR.Name) {
 		logEnabled(disableVecHTR)
 	} else {

config/features/deprecated_flags.go

@@ -90,8 +90,6 @@ var deprecatedFlags = []cli.Flag{
 	deprecatedFallbackProvider,
 }
 
-// deprecatedBeaconFlags contains flags that are still used by other components
-// and therefore cannot be added to deprecatedFlags
 var deprecatedBeaconFlags = []cli.Flag{
 	deprecatedBackupWebHookFlag,
 }

config/features/flags.go

@@ -83,10 +83,6 @@ var (
 			"a foolproof method to find duplicate instances in the network. Your validator will still be" +
 			" vulnerable if it is being run in unsafe configurations.",
 	}
-	disableStakinContractCheck = &cli.BoolFlag{
-		Name:  "disable-staking-contract-check",
-		Usage: "Disables checking of staking contract deposits when proposing blocks, useful for devnets",
-	}
 	enableHistoricalSpaceRepresentation = &cli.BoolFlag{
 		Name: "enable-historical-state-representation",
 		Usage: "Enables the beacon chain to save historical states in a space efficient manner." +

consensus-types/blocks/factory.go

@@ -24,6 +24,8 @@ var (
 	ErrNilObject = errors.New("received nil object")
 	// ErrNilSignedBeaconBlock is returned when a nil signed beacon block is received.
 	ErrNilSignedBeaconBlock = errors.New("signed beacon block can't be nil")
+	errNilBeaconBlock       = errors.New("beacon block can't be nil")
+	errNilBeaconBlockBody   = errors.New("beacon block body can't be nil")
 )
 
 // NewSignedBeaconBlock creates a signed beacon block from a protobuf signed beacon block.

consensus-types/blocks/getters.go

@@ -17,6 +17,12 @@ func BeaconBlockIsNil(b interfaces.SignedBeaconBlock) error {
 	if b == nil || b.IsNil() {
 		return ErrNilSignedBeaconBlock
 	}
+	if b.Block().IsNil() {
+		return errNilBeaconBlock
+	}
+	if b.Block().Body().IsNil() {
+		return errNilBeaconBlockBody
+	}
 	return nil
 }
 

network/auth.go

@@ -9,7 +9,7 @@ import (
 )
 
 // DefaultRPCHTTPTimeout for HTTP requests via an RPC connection to an execution node.
-const DefaultRPCHTTPTimeout = time.Second * 30
+const DefaultRPCHTTPTimeout = time.Second * 6
 
 // This creates a custom HTTP transport which we can attach to our HTTP client
 // in order to inject JWT auth strings into our HTTP request headers. Authentication

testing/spectest/shared/common/forkchoice/service.go

@@ -38,7 +38,6 @@ func startChainService(t testing.TB, st state.BeaconState, block interfaces.Sign
 		Root:  r[:],
 	}
 	require.NoError(t, db.SaveState(ctx, st, r))
-	require.NoError(t, db.SaveJustifiedCheckpoint(ctx, cp))
 	require.NoError(t, db.SaveFinalizedCheckpoint(ctx, cp))
 	attPool, err := attestations.NewService(ctx, &attestations.Config{
 		Pool: attestations.NewPool(),

validator/client/validator.go

@@ -938,7 +938,7 @@ func (v *validator) logDuties(slot types.Slot, duties []*ethpb.DutiesResponse_Du
 	}
 	for i := types.Slot(0); i < params.BeaconConfig().SlotsPerEpoch; i++ {
 		startTime := slots.StartTime(v.genesisTime, slotOffset+i)
-		durationTillDuty := time.Until(startTime) + time.Second
+		durationTillDuty := time.Until(startTime)
 
 		if len(attesterKeys[i]) > 0 {
 			log.WithFields(logrus.Fields{