feedback

Author: julienrbrt

block/internal/cache/generic_cache.go

@@ -3,6 +3,7 @@ package cache
 import (
 	"context"
 	"encoding/binary"
+	"fmt"
 	"sync"
 	"sync/atomic"
 
@@ -148,14 +149,14 @@ func (c *Cache[T]) setDAIncluded(hash string, daHeight uint64, blockHeight uint6
 	c.daIncluded.Add(hash, daHeight)
 	c.hashByHeight.Add(blockHeight, hash)
 	c.setMaxDAHeight(daHeight)
-	c.persistSnapshot(context.Background())
+	_ = c.persistSnapshot(context.Background())
 }
 
 // removeDAIncluded removes the DA-included status of the hash from the cache
 // and rewrites the window snapshot.
 func (c *Cache[T]) removeDAIncluded(hash string) {
 	c.daIncluded.Remove(hash)
-	c.persistSnapshot(context.Background())
+	_ = c.persistSnapshot(context.Background())
 }
 
 // daHeight returns the maximum DA height from all DA-included items.
@@ -200,15 +201,15 @@ func (c *Cache[T]) deleteAllForHeight(height uint64) {
 		c.daIncluded.Remove(hash)
 	}
 
-	c.persistSnapshot(context.Background())
+	_ = c.persistSnapshot(context.Background())
 }
 
 // persistSnapshot writes all current in-flight [blockHeight, daHeight] pairs
 // to the store under a single key. Called on every mutation; payload is tiny
 // (typically <10 entries × 16 bytes).
-func (c *Cache[T]) persistSnapshot(ctx context.Context) {
+func (c *Cache[T]) persistSnapshot(ctx context.Context) error {
 	if c.store == nil || c.storeKeyPrefix == "" {
-		return
+		return nil
 	}
 
 	heights := c.hashByHeight.Keys()
@@ -225,7 +226,7 @@ func (c *Cache[T]) persistSnapshot(ctx context.Context) {
 		entries = append(entries, snapshotEntry{blockHeight: h, daHeight: daH})
 	}
 
-	_ = c.store.SetMetadata(ctx, c.snapshotKey(), encodeSnapshot(entries))
+	return c.store.SetMetadata(ctx, c.snapshotKey(), encodeSnapshot(entries))
 }
 
 // encodeSnapshot serialises a slice of snapshotEntry values into a byte slice.
@@ -298,7 +299,9 @@ func (c *Cache[T]) SaveToStore(ctx context.Context) error {
 	if c.store == nil {
 		return nil
 	}
-	c.persistSnapshot(ctx)
+	if err := c.persistSnapshot(ctx); err != nil {
+		return fmt.Errorf("saving cache snapshot: %w", err)
+	}
 	return nil
 }
 
@@ -307,6 +310,8 @@ func (c *Cache[T]) ClearFromStore(ctx context.Context) error {
 	if c.store == nil {
 		return nil
 	}
-	_ = c.store.DeleteMetadata(ctx, c.snapshotKey())
+	if err := c.store.DeleteMetadata(ctx, c.snapshotKey()); err != nil {
+		return fmt.Errorf("clearing cache snapshot: %w", err)
+	}
 	return nil
 }

block/internal/cache/generic_cache_test.go

@@ -325,10 +325,14 @@ func TestCache_ClearFromStore(t *testing.T) {
 	c.setDAIncluded("hash1", 100, 1)
 	c.setDAIncluded("hash2", 200, 2)
 
+	// Verify the snapshot key was written before clearing.
+	_, err := st.GetMetadata(ctx, "clear-test/__snap")
+	require.NoError(t, err, "snapshot key should exist before ClearFromStore")
+
 	require.NoError(t, c.ClearFromStore(ctx))
 
-	_, err := st.GetMetadata(ctx, "clear-test/hash1")
-	assert.Error(t, err, "key should have been removed from store")
+	_, err = st.GetMetadata(ctx, "clear-test/__snap")
+	assert.Error(t, err, "snapshot key should have been removed from store")
 }
 
 // ---------------------------------------------------------------------------

block/internal/executing/executor.go

@@ -422,10 +422,7 @@ func (e *Executor) executionLoop() {
 			txsAvailable = false
 			// reset timer accounting for time spent producing the block
 			elapsed := time.Since(start)
-			remaining := e.config.Node.BlockTime.Duration - elapsed
-			if remaining <= 0 {
-				remaining = 0
-			}
+			remaining := max(e.config.Node.BlockTime.Duration-elapsed, 0)
 			blockTimer.Reset(remaining)
 
 		case <-lazyTimerCh:

pkg/sequencers/single/sequencer_test.go

@@ -1368,7 +1368,7 @@ func TestSequencer_CatchUp_SkipsMempoolDuringCatchUp(t *testing.T) {
 	require.NoError(t, err)
 
 	// Submit several mempool transactions
-	for i := 0; i < 5; i++ {
+	for range 5 {
 		_, err = seq.SubmitBatchTxs(ctx, coresequencer.SubmitBatchTxsRequest{
 			Id:    []byte("test-chain"),
 			Batch: &coresequencer.Batch{Transactions: [][]byte{[]byte("mempool-tx")}},
@@ -1741,7 +1741,7 @@ func TestSequencer_CatchUp_MultiEpochReplay(t *testing.T) {
 	}
 
 	// Process the 3 old epochs — all should be catch-up (no mempool)
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		resp, err := seq.GetNextBatch(ctx, req)
 		require.NoError(t, err)
 		assert.True(t, seq.isCatchingUp(), "should be catching up during epoch %d", 100+i)
@@ -2005,7 +2005,7 @@ func TestSequencer_CatchUp_MonotonicTimestamps(t *testing.T) {
 
 	// Produce 3 blocks from epoch 100 (1 tx each due to gas filter)
 	var timestamps []time.Time
-	for i := 0; i < 3; i++ {
+	for i := range 3 {
 		resp, err := seq.GetNextBatch(ctx, req)
 		require.NoError(t, err)
 		assert.True(t, seq.isCatchingUp(), "should be catching up during block %d", i)