Init sync fixes

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

beacon-chain/blockchain/process_block.go

@@ -217,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()
@@ -403,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

@@ -135,11 +135,18 @@ func (s *Service) verifyBlkFinalizedSlot(b interfaces.BeaconBlock) error {
 }
 
 // updateFinalized saves the init sync blocks, finalized checkpoint, migrates
-// to cold old states and saves the last validated checkpoint to DB
+// to cold old states and saves the last validated checkpoint to DB. It returns
+// early if the new checkpoint is older than the one on db.
 func (s *Service) updateFinalized(ctx context.Context, cp *ethpb.Checkpoint) error {
 	ctx, span := trace.StartSpan(ctx, "blockChain.updateFinalized")
 	defer span.End()
 
+	// return early if new checkpoint is not newer than the one in DB
+	currentFinalizedEpoch := s.FinalizedCheckpt().Epoch
+	if cp.Epoch <= currentFinalizedEpoch {
+		return nil
+	}
+
 	// Blocks need to be saved so that we can retrieve finalized block from
 	// DB when migrating states.
 	if err := s.cfg.BeaconDB.SaveBlocks(ctx, s.getInitSyncBlocks()); err != nil {

beacon-chain/blockchain/process_block_test.go

@@ -1190,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()
@@ -1238,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/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/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/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/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/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,

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(),