fixes

Author: julienrbrt

block/internal/da/async_block_retriever.go

@@ -157,7 +157,7 @@ func (f *asyncBlockRetriever) GetCachedBlock(ctx context.Context, daHeight uint6
 
 	block := &BlockData{
 		Height:    pbBlock.Height,
-		Timestamp: time.Unix(pbBlock.Timestamp, 0).UTC(),
+		Timestamp: time.Unix(0, pbBlock.Timestamp).UTC(),
 		Blobs:     pbBlock.Blobs,
 	}
 
@@ -261,7 +261,7 @@ func (f *asyncBlockRetriever) fetchAndCacheBlock(height uint64) {
 	// Serialize and cache the block
 	pbBlock := &pb.BlockData{
 		Height:    block.Height,
-		Timestamp: block.Timestamp.Unix(),
+		Timestamp: block.Timestamp.UnixNano(),
 		Blobs:     block.Blobs,
 	}
 	data, err := proto.Marshal(pbBlock)

block/internal/da/async_block_retriever_test.go

@@ -201,7 +201,7 @@ func TestAsyncBlockRetriever_StopGracefully(t *testing.T) {
 func TestBlockData_Serialization(t *testing.T) {
 	block := &BlockData{
 		Height:    100,
-		Timestamp: time.Unix(12345, 0).UTC(),
+		Timestamp: time.Unix(12345, 123456789).UTC(),
 		Blobs: [][]byte{
 			[]byte("blob1"),
 			[]byte("blob2"),
@@ -212,7 +212,7 @@ func TestBlockData_Serialization(t *testing.T) {
 	// Serialize using protobuf
 	pbBlock := &pb.BlockData{
 		Height:    block.Height,
-		Timestamp: block.Timestamp.Unix(),
+		Timestamp: block.Timestamp.UnixNano(),
 		Blobs:     block.Blobs,
 	}
 	data, err := proto.Marshal(pbBlock)
@@ -226,11 +226,11 @@ func TestBlockData_Serialization(t *testing.T) {
 
 	decoded := &BlockData{
 		Height:    decodedPb.Height,
-		Timestamp: time.Unix(decodedPb.Timestamp, 0).UTC(),
+		Timestamp: time.Unix(0, decodedPb.Timestamp).UTC(),
 		Blobs:     decodedPb.Blobs,
 	}
 
-	assert.Equal(t, block.Timestamp.Unix(), decoded.Timestamp.Unix())
+	assert.Equal(t, block.Timestamp.UnixNano(), decoded.Timestamp.UnixNano())
 	assert.Equal(t, block.Height, decoded.Height)
 	assert.Equal(t, len(block.Blobs), len(decoded.Blobs))
 	for i := range block.Blobs {
@@ -248,7 +248,7 @@ func TestBlockData_SerializationEmpty(t *testing.T) {
 	// Serialize using protobuf
 	pbBlock := &pb.BlockData{
 		Height:    block.Height,
-		Timestamp: block.Timestamp.Unix(),
+		Timestamp: block.Timestamp.UnixNano(),
 		Blobs:     block.Blobs,
 	}
 	data, err := proto.Marshal(pbBlock)
@@ -261,7 +261,7 @@ func TestBlockData_SerializationEmpty(t *testing.T) {
 
 	decoded := &BlockData{
 		Height:    decodedPb.Height,
-		Timestamp: time.Unix(decodedPb.Timestamp, 0).UTC(),
+		Timestamp: time.Unix(0, decodedPb.Timestamp).UTC(),
 		Blobs:     decodedPb.Blobs,
 	}
 

block/internal/syncing/syncer.go

@@ -309,6 +309,19 @@ func (s *Syncer) initializeState() error {
 	}
 	s.SetLastState(state)
 
+	// Initialize lastCheckedEpochEnd based on the restored state's DA height so that
+	// VerifyForcedInclusionTxs resumes from where we left off instead of re-scanning
+	// all epochs from genesis on every startup.
+	if epochSize := s.genesis.DAEpochForcedInclusion; epochSize > 0 && state.DAHeight >= s.genesis.DAStartHeight {
+		firstEpochEnd := s.genesis.DAStartHeight + epochSize - 1
+		if state.DAHeight >= firstEpochEnd {
+			// The last completed epoch end that is fully behind state.DAHeight.
+			elapsed := state.DAHeight - firstEpochEnd
+			completedEpochs := elapsed / epochSize
+			s.lastCheckedEpochEnd = firstEpochEnd + completedEpochs*epochSize
+		}
+	}
+
 	// Set DA height to the maximum of the genesis start height, the state's DA height, and the cached DA height.
 	// The cache's DaHeight() is initialized from store metadata, so it's always correct even after cache clear.
 	s.daRetrieverHeight.Store(max(s.genesis.DAStartHeight, s.cache.DaHeight(), state.DAHeight))
@@ -915,7 +928,7 @@ func (s *Syncer) VerifyForcedInclusionTxs(ctx context.Context, daHeight uint64,
 	s.daBlockBytes[daHeight] = blockBytes
 	s.forcedInclusionMu.Unlock()
 
-	if daHeight < daStart {
+	if daHeight < daStart || daHeight < s.getLastState().DAHeight {
 		return nil
 	}
 
@@ -926,7 +939,17 @@ func (s *Syncer) VerifyForcedInclusionTxs(ctx context.Context, daHeight uint64,
 
 	var maliciousCount int
 
-	for epochEnd := daStart + epochSize - 1; ; epochEnd += epochSize {
+	// Resume from the last checked epoch rather than re-scanning from genesis.
+	// If no epoch has been checked yet, start from the first epoch end.
+	firstEpochEnd := daStart + epochSize - 1
+	var startEpochEnd uint64
+	if s.lastCheckedEpochEnd == 0 || s.lastCheckedEpochEnd < firstEpochEnd {
+		startEpochEnd = firstEpochEnd
+	} else {
+		startEpochEnd = s.lastCheckedEpochEnd + epochSize
+	}
+
+	for epochEnd := startEpochEnd; ; epochEnd += epochSize {
 		epochStart := epochEnd - (epochSize - 1)
 		gracePeriod := s.gracePeriodForEpoch(epochStart, epochEnd)
 		graceBoundary := epochEnd + gracePeriod*epochSize

pkg/sequencers/based/sequencer.go

@@ -59,7 +59,7 @@ func NewBasedSequencer(
 		logger:           logger.With().Str("component", "based_sequencer").Logger(),
 		checkpointStore:  seqcommon.NewCheckpointStore(db, ds.NewKey("/based/checkpoint")),
 		executor:         executor,
-		currentDAEndTime: genesis.StartTime,
+		currentDAEndTime: genesis.StartTime.UTC(),
 	}
 
 	// Read state from the store to allow nodes to restart as based sequencers on a chain that had ran previously with a different sequencer type, and to initialize the timestamp floor for monotonicity guarantees after restart.
@@ -210,13 +210,6 @@ doneProcessing:
 	// the next epoch starts at nextDaEndTime - N*1ms >= prevDaEndTime.
 	epochStart := s.currentDAEndTime.Add(-time.Duration(s.currentEpochTxCount) * time.Millisecond)
 	timestamp := epochStart.Add(time.Duration(txIndexForTimestamp) * time.Millisecond)
-
-	// Clamp: the DA-derived timestamp may predate blocks that were
-	// produced or synced with wall-clock time before the node restarted
-	// as a based sequencer.  Ensure strict monotonicity.
-	if !s.lastTimestamp.IsZero() && !timestamp.After(s.lastTimestamp) {
-		timestamp = s.lastTimestamp.Add(time.Millisecond)
-	}
 	s.lastTimestamp = timestamp
 
 	if len(validTxs) == 0 {

pkg/sequencers/based/sequencer_test.go

@@ -167,12 +167,13 @@ func TestBasedSequencer_GetNextBatch_EmptyDA(t *testing.T) {
 		LastBatchData: nil,
 	}
 
+	// Empty epoch has no valid txs — sequencer returns ErrNoBatch
 	resp, err := seq.GetNextBatch(context.Background(), req)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.NotNil(t, resp.Batch)
-	// Should return empty batch when DA has no transactions
-	assert.Equal(t, 0, len(resp.Batch.Transactions))
+	require.ErrorIs(t, err, block.ErrNoBatch)
+	require.Nil(t, resp)
+
+	// Checkpoint should still advance past the empty epoch
+	assert.Equal(t, uint64(101), seq.checkpoint.DAHeight)
 
 	mockRetriever.AssertExpectations(t)
 }
@@ -339,12 +340,13 @@ func TestBasedSequencer_GetNextBatch_ForcedInclusionExceedsMaxBytes(t *testing.T
 		LastBatchData: nil,
 	}
 
+	// All txs are skipped due to size — sequencer returns ErrNoBatch
 	resp, err := seq.GetNextBatch(context.Background(), req)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.NotNil(t, resp.Batch)
-	// Should return empty batch since transaction exceeds max bytes
-	assert.Equal(t, 0, len(resp.Batch.Transactions))
+	require.ErrorIs(t, err, block.ErrNoBatch)
+	require.Nil(t, resp)
+
+	// Checkpoint should still advance past the epoch with the oversized tx
+	assert.Equal(t, uint64(101), seq.checkpoint.DAHeight)
 
 	mockRetriever.AssertExpectations(t)
 }
@@ -430,13 +432,12 @@ func TestBasedSequencer_GetNextBatch_HeightFromFuture(t *testing.T) {
 		LastBatchData: nil,
 	}
 
-	// Should not error, but return empty batch
+	// DA hasn't produced that block yet — sequencer returns ErrNoBatch
 	resp, err := seq.GetNextBatch(context.Background(), req)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	assert.Equal(t, 0, len(resp.Batch.Transactions))
+	require.ErrorIs(t, err, block.ErrNoBatch)
+	require.Nil(t, resp)
 
-	// DA height should stay the same
+	// DA height should stay the same — checkpoint must not advance
 	assert.Equal(t, uint64(100), seq.checkpoint.DAHeight)
 
 	mockRetriever.AssertExpectations(t)
@@ -665,24 +666,21 @@ func TestBasedSequencer_GetNextBatch_EmptyDABatch_IncreasesDAHeight(t *testing.T
 	assert.Equal(t, uint64(100), seq.GetDAHeight())
 	assert.Equal(t, uint64(100), seq.checkpoint.DAHeight)
 
-	// First batch - empty DA block at height 100
+	// First call — empty DA epoch at height 100, no txs → ErrNoBatch.
+	// Checkpoint must still advance so the next call moves to epoch 101.
 	resp, err := seq.GetNextBatch(context.Background(), req)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.NotNil(t, resp.Batch)
-	assert.Equal(t, 0, len(resp.Batch.Transactions))
+	require.ErrorIs(t, err, block.ErrNoBatch)
+	require.Nil(t, resp)
 
 	// DA height should have increased to 101 even though no transactions were processed
 	assert.Equal(t, uint64(101), seq.GetDAHeight())
 	assert.Equal(t, uint64(101), seq.checkpoint.DAHeight)
 	assert.Equal(t, uint64(0), seq.checkpoint.TxIndex)
 
-	// Second batch - empty DA block at height 101
+	// Second call — empty DA epoch at height 101, no txs → ErrNoBatch.
 	resp, err = seq.GetNextBatch(context.Background(), req)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.NotNil(t, resp.Batch)
-	assert.Equal(t, 0, len(resp.Batch.Transactions))
+	require.ErrorIs(t, err, block.ErrNoBatch)
+	require.Nil(t, resp)
 
 	// DA height should have increased to 102
 	assert.Equal(t, uint64(102), seq.GetDAHeight())
@@ -801,7 +799,8 @@ func TestBasedSequencer_GetNextBatch_TimestampAdjustment_PartialBatch(t *testing
 }
 
 func TestBasedSequencer_GetNextBatch_TimestampAdjustment_EmptyBatch(t *testing.T) {
-	// Test that timestamp is zero when batch is empty
+	// Test that an empty DA epoch returns ErrNoBatch (no valid txs to include).
+	// The checkpoint must still advance past the empty epoch.
 	daEndTime := time.Date(2024, 1, 1, 12, 0, 0, 0, time.UTC)
 
 	mockRetriever := common.NewMockForcedInclusionRetriever(t)
@@ -825,15 +824,13 @@ func TestBasedSequencer_GetNextBatch_TimestampAdjustment_EmptyBatch(t *testing.T
 		LastBatchData: nil,
 	}
 
+	// Empty epoch — no valid txs, sequencer returns ErrNoBatch
 	resp, err := seq.GetNextBatch(context.Background(), req)
-	require.NoError(t, err)
-	require.NotNil(t, resp)
-	require.NotNil(t, resp.Batch)
-	assert.Equal(t, 0, len(resp.Batch.Transactions))
+	require.ErrorIs(t, err, block.ErrNoBatch)
+	require.Nil(t, resp)
 
-	// When batch is empty, there are 0 remaining txs, so timestamp = daEndTime
-	expectedTimestamp := daEndTime
-	assert.Equal(t, expectedTimestamp, resp.Timestamp)
+	// Checkpoint must have advanced so the next call moves past this epoch
+	assert.Equal(t, uint64(101), seq.checkpoint.DAHeight)
 
 	mockRetriever.AssertExpectations(t)
 }

pkg/sequencers/single/sequencer.go

@@ -93,7 +93,7 @@ func NewSequencer(
 		queue:            NewBatchQueue(db, "batches", maxQueueSize),
 		checkpointStore:  seqcommon.NewCheckpointStore(db, ds.NewKey("/single/checkpoint")),
 		genesis:          genesis,
-		currentDAEndTime: genesis.StartTime,
+		currentDAEndTime: genesis.StartTime.UTC(),
 		executor:         executor,
 	}
 	s.SetDAHeight(genesis.DAStartHeight) // default value, will be overridden by executor or submitter
@@ -358,20 +358,15 @@ func (c *Sequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextB
 	// The last block of an epoch lands exactly on daEndTime; the first block of
 	// the next epoch starts at nextDaEndTime - N*1ms >= prevDaEndTime.
 	// During normal operation, use wall-clock time instead.
-	timestamp := time.Now()
-	if c.catchUpState.Load() == catchUpInProgress {
+	timestamp := time.Now().UTC()
+	currentBatchHasForcedTxs := forcedTxConsumedCount > 0
+	if c.catchUpState.Load() == catchUpInProgress || currentBatchHasForcedTxs {
 		epochStart := c.currentDAEndTime.Add(-time.Duration(c.currentEpochTxCount) * time.Millisecond)
 		timestamp = epochStart.Add(time.Duration(txIndexForTimestamp) * time.Millisecond)
-
-		// Clamp: the DA-derived timestamp may predate blocks that were
-		// produced with time.Now() before the sequencer was restarted.
-		// Ensure strict monotonicity relative to the last produced block.
-		if !c.lastCatchUpTimestamp.IsZero() && !timestamp.After(c.lastCatchUpTimestamp) {
-			timestamp = c.lastCatchUpTimestamp.Add(time.Millisecond)
-		}
 		c.lastCatchUpTimestamp = timestamp
 	}
 
+	// In catch up modes, only produce blocks for force included txs.
 	if c.isCatchingUp() && len(batchTxs) == 0 {
 		return nil, block.ErrNoBatch
 	}

pkg/sequencers/single/sequencer_test.go

@@ -2103,22 +2103,22 @@ func TestSequencer_CatchUp_MonotonicTimestamps_EmptyEpoch(t *testing.T) {
 		LastBatchData: nil,
 	}
 
-	// First call processes the empty epoch 100 — empty batch, but checkpoint advances
-	resp1, err := seq.GetNextBatch(ctx, req)
-	require.NoError(t, err)
+	// First call processes the empty epoch 100 — no txs while catching up → ErrNoBatch.
+	// The checkpoint must still advance to 101 so the next call moves on.
+	_, err = seq.GetNextBatch(ctx, req)
+	require.ErrorIs(t, err, block.ErrNoBatch, "empty catch-up epoch should return ErrNoBatch")
 	assert.True(t, seq.isCatchingUp())
-	assert.Equal(t, 0, len(resp1.Batch.Transactions), "empty epoch should produce empty batch")
-	assert.Equal(t, emptyEpochTimestamp, resp1.Timestamp,
-		"empty epoch batch should use epoch DA end time (0 remaining)")
+	assert.Equal(t, uint64(101), seq.checkpoint.DAHeight, "checkpoint should have advanced past empty epoch")
 
-	// Second call processes epoch 101 — should have later timestamp
+	// Second call processes epoch 101 — has a forced tx, should succeed with a
+	// DA-derived timestamp after emptyEpochTimestamp.
 	resp2, err := seq.GetNextBatch(ctx, req)
 	require.NoError(t, err)
 	assert.True(t, seq.isCatchingUp())
 	assert.Equal(t, 1, len(resp2.Batch.Transactions))
-	assert.True(t, resp2.Timestamp.After(resp1.Timestamp),
+	assert.True(t, resp2.Timestamp.After(emptyEpochTimestamp),
 		"epoch 101 timestamp (%v) must be after empty epoch 100 timestamp (%v)",
-		resp2.Timestamp, resp1.Timestamp)
+		resp2.Timestamp, emptyEpochTimestamp)
 }
 
 func TestSequencer_GetNextBatch_GasFilteringPreservesUnprocessedTxs(t *testing.T) {

proto/evnode/v1/da.proto

@@ -6,6 +6,6 @@ option go_package = "github.com/evstack/ev-node/types/pb/evnode/v1";
 // BlockData contains data retrieved from a single DA height.
 message BlockData {
   uint64 height = 1;
-  int64 timestamp = 2; // Unix timestamp in seconds
+  int64 timestamp = 2; // Unix timestamp in nanoseconds
   repeated bytes blobs = 3;
 }

test/e2e/evm_force_inclusion_e2e_test.go

@@ -970,6 +970,7 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
 
 	// ===== PHASE 10: Verify Nodes Are in Sync =====
 	t.Log("Phase 10: Verify Nodes Are in Sync")
+	time.Sleep(4 * time.Second) // hack to give some head start to the sequencer, otherwise it will pass immediatelly.
 
 	// Wait for sync node to catch up to sequencer
 	require.Eventually(t, func() bool {
@@ -982,8 +983,8 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
 		syncHeaderNb, seqHeaderNb := fnHeader.Number.Uint64(), seqHeader.Number.Uint64()
 		t.Logf("Sync node height is %d and seq node height is %d", syncHeaderNb, seqHeaderNb)
 
-		return syncHeaderNb >= seqHeaderNb
-	}, 30*time.Second, 1*time.Second, "Sync node should catch up to sequencer")
+		return syncHeaderNb >= seqHeaderNb-10 // catching up within a 10 blocks range
+	}, 15*time.Second, 1*time.Second, "Sync node should catch up to sequencer")
 
 	// Verify both nodes have all forced inclusion txs
 	for i, txHash := range forcedTxHashes {