multiple improvements

Author: Wondertan

store/store.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"slices"
 	"sync"
 	"sync/atomic"
 	"time"
@@ -357,136 +356,7 @@ func (s *Store[H]) HasAt(ctx context.Context, height uint64) bool {
 	return head.Height() >= height && height >= tail.Height()
 }
 
-func (s *Store[H]) OnDelete(fn func(context.Context, uint64) error) {
-	s.onDeleteMu.Lock()
-	defer s.onDeleteMu.Unlock()
-
-	s.onDelete = append(s.onDelete, func(ctx context.Context, height uint64) (rerr error) {
-		defer func() {
-			err := recover()
-			if err != nil {
-				rerr = fmt.Errorf("header/store: user provided onDelete panicked on %d with: %s", height, err)
-			}
-		}()
-		return fn(ctx, height)
-	})
-}
-
-// DeleteTo implements [header.Store] interface.
-func (s *Store[H]) DeleteTo(ctx context.Context, to uint64) error {
-	// ensure all the pending headers are synchronized
-	err := s.Sync(ctx)
-	if err != nil {
-		return err
-	}
-
-	head, err := s.Head(ctx)
-	if err != nil {
-		return fmt.Errorf("header/store: reading head: %w", err)
-	}
-	if head.Height()+1 < to {
-		_, err := s.getByHeight(ctx, to)
-		if errors.Is(err, header.ErrNotFound) {
-			return fmt.Errorf(
-				"header/store: delete to %d beyond current head(%d)",
-				to,
-				head.Height(),
-			)
-		}
-		if err != nil {
-			return fmt.Errorf("delete to potential new head: %w", err)
-		}
-
-		//  if `to` is bigger than the current head and is stored - allow delete, making `to` a new head
-	}
-
-	tail, err := s.Tail(ctx)
-	if err != nil {
-		return fmt.Errorf("header/store: reading tail: %w", err)
-	}
-	if tail.Height() >= to {
-		return fmt.Errorf("header/store: delete to %d below current tail(%d)", to, tail.Height())
-	}
-
-	if err := s.deleteRange(ctx, tail.Height(), to); err != nil {
-		return fmt.Errorf("header/store: delete to height %d: %w", to, err)
-	}
-
-	if head.Height()+1 == to {
-		// this is the case where we have deleted all the headers
-		// wipe the store
-		if err := s.wipe(ctx); err != nil {
-			return fmt.Errorf("header/store: wipe: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (s *Store[H]) deleteRange(ctx context.Context, from, to uint64) (rerr error) {
-	s.onDeleteMu.Lock()
-	onDelete := slices.Clone(s.onDelete)
-	s.onDeleteMu.Unlock()
-
-	batch, err := s.ds.Batch(ctx)
-	if err != nil {
-		return fmt.Errorf("new batch: %w", err)
-	}
-
-	height := from
-	defer func() {
-		// make new context to always save progress
-		ctx := context.Background()
-
-		log.Infow("deleted headers", "from_height", from, "to_height", to)
-		newTailHeight := to
-		if rerr != nil {
-			log.Warnw("partial delete with error", "expected_to_height", newTailHeight, "actual_to_height", height, "err", err)
-			newTailHeight = height
-		}
-
-		err = s.setTail(ctx, batch, newTailHeight)
-		if err != nil {
-			rerr = errors.Join(rerr, fmt.Errorf("setting tail to %d: %w", newTailHeight, err))
-		}
-
-		if err := batch.Commit(ctx); err != nil {
-			rerr = errors.Join(rerr, fmt.Errorf("committing delete batch [%d:%d): %w", from, newTailHeight, err))
-		}
-	}()
-
-	for ; height < to; height++ {
-		hash, err := s.heightIndex.HashByHeight(ctx, height, false)
-		if errors.Is(err, datastore.ErrNotFound) {
-			log.Warnf("attempt to delete header that's not found", "height", height)
-			continue
-		}
-		if err != nil {
-			return fmt.Errorf("hash by height %d: %w", height, err)
-		}
-
-		for _, deleteFn := range onDelete {
-			if err := deleteFn(ctx, height); err != nil {
-				return fmt.Errorf("on delete handler for %d: %w", height, err)
-			}
-		}
-
-		if err := batch.Delete(ctx, hashKey(hash)); err != nil {
-			return fmt.Errorf("delete hash key (%X): %w", hash, err)
-		}
-		if err := batch.Delete(ctx, heightKey(height)); err != nil {
-			return fmt.Errorf("delete height key (%d): %w", height, err)
-		}
-
-		s.cache.Remove(hash.String())
-		s.heightIndex.cache.Remove(height)
-		s.pending.DeleteRange(height, height+1)
-	}
-
-	return nil
-}
-
-func (s *Store[H]) setTail(ctx context.Context, batch datastore.Batch, to uint64) error {
+func (s *Store[H]) setTail(ctx context.Context, write datastore.Write, to uint64) error {
 	newTail, err := s.getByHeight(ctx, to)
 	if errors.Is(err, header.ErrNotFound) {
 		return nil
@@ -497,19 +367,16 @@ func (s *Store[H]) setTail(ctx context.Context, batch datastore.Batch, to uint64
 
 	// set directly to `to`, avoiding iteration in recedeTail
 	s.tailHeader.Store(&newTail)
-	if err := writeHeaderHashTo(ctx, batch, newTail, tailKey); err != nil {
+	if err := writeHeaderHashTo(ctx, write, newTail, tailKey); err != nil {
 		return fmt.Errorf("writing tailKey in batch: %w", err)
 	}
 	log.Infow("new tail", "height", newTail.Height(), "hash", newTail.Hash())
 	s.metrics.newTail(newTail.Height())
 
 	// update head as well, if delete went over it
-	head, err := s.Head(ctx)
-	if err != nil {
-		return err
-	}
-	if to > head.Height() {
-		if err := writeHeaderHashTo(ctx, batch, newTail, headKey); err != nil {
+	head, _ := s.Head(ctx)
+	if head.IsZero() || to > head.Height() {
+		if err := writeHeaderHashTo(ctx, write, newTail, headKey); err != nil {
 			return fmt.Errorf("writing headKey in batch: %w", err)
 		}
 		s.contiguousHead.Store(&newTail)
@@ -817,7 +684,7 @@ func (s *Store[H]) deinit() {
 
 func writeHeaderHashTo[H header.Header[H]](
 	ctx context.Context,
-	batch datastore.Batch,
+	write datastore.Write,
 	h H,
 	key datastore.Key,
 ) error {
@@ -826,7 +693,7 @@ func writeHeaderHashTo[H header.Header[H]](
 		return err
 	}
 
-	if err := batch.Put(ctx, key, hashBytes); err != nil {
+	if err := write.Put(ctx, key, hashBytes); err != nil {
 		return err
 	}