refactor: retrieve highest da height in cache

Author: julienrbrt

block/internal/cache/generic_cache.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 	"sync"
+	"sync/atomic"
 )
 
 // Cache is a generic cache that maintains items that are seen and hard confirmed
@@ -18,6 +19,8 @@ type Cache[T any] struct {
 	daIncluded *sync.Map
 	// hashByHeight tracks the hash associated with each height for pruning
 	hashByHeight *sync.Map
+	// maxDAHeight tracks the maximum DA height seen
+	maxDAHeight atomic.Uint64
 }
 
 // NewCache returns a new Cache struct
@@ -27,6 +30,7 @@ func NewCache[T any]() *Cache[T] {
 		hashes:        new(sync.Map),
 		daIncluded:    new(sync.Map),
 		hashByHeight:  new(sync.Map),
+		maxDAHeight:   atomic.Uint64{},
 	}
 }
 
@@ -91,13 +95,29 @@ func (c *Cache[T]) getDAIncluded(hash string) (uint64, bool) {
 func (c *Cache[T]) setDAIncluded(hash string, daHeight uint64, blockHeight uint64) {
 	c.daIncluded.Store(hash, daHeight)
 	c.hashByHeight.Store(blockHeight, hash)
+
+	// Update max DA height if necessary
+	current := c.maxDAHeight.Load()
+	if daHeight <= current {
+		return
+	}
+
+	if c.maxDAHeight.CompareAndSwap(current, daHeight) {
+		return
+	}
 }
 
 // removeDAIncluded removes the DA-included status of the hash
 func (c *Cache[T]) removeDAIncluded(hash string) {
 	c.daIncluded.Delete(hash)
 }
 
+// daHeight returns the maximum DA height from all DA-included items.
+// Returns 0 if no items are DA-included.
+func (c *Cache[T]) daHeight() uint64 {
+	return c.maxDAHeight.Load()
+}
+
 // deleteAllForHeight removes all items and their associated data from the cache at the given height
 func (c *Cache[T]) deleteAllForHeight(height uint64) {
 	c.itemsByHeight.Delete(height)
@@ -231,6 +251,11 @@ func (c *Cache[T]) LoadFromDisk(folderPath string) error {
 	}
 	for k, v := range daIncludedMap {
 		c.daIncluded.Store(k, v)
+		// Update max DA height during load
+		current := c.maxDAHeight.Load()
+		if v > current {
+			_ = c.maxDAHeight.CompareAndSwap(current, v)
+		}
 	}
 
 	return nil

block/internal/cache/manager.go

@@ -49,6 +49,7 @@ type Manager interface {
 	GetHeaderDAIncluded(hash string) (uint64, bool)
 	SetHeaderDAIncluded(hash string, daHeight uint64, blockHeight uint64)
 	RemoveHeaderDAIncluded(hash string)
+	DaHeight() uint64
 
 	// Data operations
 	IsDataSeen(hash string) bool
@@ -165,6 +166,11 @@ func (m *implementation) RemoveHeaderDAIncluded(hash string) {
 	m.headerCache.removeDAIncluded(hash)
 }
 
+// DaHeight fetches the heighest da height contained in the processed cache.
+func (m *implementation) DaHeight() uint64 {
+	return max(m.headerCache.maxDAHeight.Load(), m.dataCache.maxDAHeight.Load())
+}
+
 // Data operations
 func (m *implementation) IsDataSeen(hash string) bool {
 	return m.dataCache.isSeen(hash)

block/internal/syncing/syncer.go

@@ -177,7 +177,7 @@ func (s *Syncer) SetLastState(state types.State) {
 
 // GetDAHeight returns the current DA height
 func (s *Syncer) GetDAHeight() uint64 {
-	return s.daHeight.Load()
+	return max(s.daHeight.Load(), s.cache.DaHeight())
 }
 
 // SetDAHeight updates the DA height
@@ -217,7 +217,7 @@ func (s *Syncer) initializeState() error {
 	s.SetLastState(state)
 
 	// Set DA height
-	s.SetDAHeight(state.DAHeight)
+	s.SetDAHeight(max(s.genesis.DAStartHeight, s.cache.DaHeight()))
 
 	s.logger.Info().
 		Uint64("height", state.LastBlockHeight).