code cleanups

Author: julienrbrt

pkg/sequencers/based/sequencer.go

@@ -128,16 +128,11 @@ func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.Get
 	// If we have no cached transactions or we've consumed all from the current DA epoch,
 	// fetch the next DA epoch
 	if daHeight > 0 && (len(s.currentBatchTxs) == 0 || s.checkpoint.TxIndex >= uint64(len(s.currentBatchTxs))) {
-		daEndTime, daEndHeight, err := s.fetchNextDAEpoch(ctx, req.MaxBytes)
+		daEndHeight, err := s.fetchNextDAEpoch(ctx, req.MaxBytes)
 		if err != nil {
 			return nil, err
 		}
 		daHeight = daEndHeight
-
-		if daEndTime.After(s.currentDAEndTime) {
-			s.currentDAEndTime = daEndTime
-		}
-		s.currentEpochTxCount = uint64(len(s.currentBatchTxs))
 	}
 
 	// Get remaining transactions from checkpoint position
@@ -242,7 +237,7 @@ func (s *BasedSequencer) getMaxGas(ctx context.Context) uint64 {
 }
 
 // fetchNextDAEpoch fetches transactions from the next DA epoch
-func (s *BasedSequencer) fetchNextDAEpoch(ctx context.Context, maxBytes uint64) (time.Time, uint64, error) {
+func (s *BasedSequencer) fetchNextDAEpoch(ctx context.Context, maxBytes uint64) (uint64, error) {
 	currentDAHeight := s.checkpoint.DAHeight
 
 	s.logger.Debug().
@@ -254,16 +249,16 @@ func (s *BasedSequencer) fetchNextDAEpoch(ctx context.Context, maxBytes uint64)
 	if err != nil {
 		// Check if forced inclusion is not configured
 		if errors.Is(err, block.ErrForceInclusionNotConfigured) {
-			return time.Time{}, 0, block.ErrForceInclusionNotConfigured
+			return 0, block.ErrForceInclusionNotConfigured
 		} else if errors.Is(err, datypes.ErrHeightFromFuture) {
 			// If we get a height from future error, stay at current position
 			// We'll retry the same height on the next call until DA produces that block
 			s.logger.Debug().
 				Uint64("da_height", currentDAHeight).
 				Msg("DA height from future, waiting for DA to produce block")
-			return time.Time{}, 0, nil
+			return 0, nil
 		}
-		return time.Time{}, 0, fmt.Errorf("failed to retrieve forced inclusion transactions: %w", err)
+		return 0, fmt.Errorf("failed to retrieve forced inclusion transactions: %w", err)
 	}
 
 	// Validate and filter transactions by size
@@ -292,8 +287,13 @@ func (s *BasedSequencer) fetchNextDAEpoch(ctx context.Context, maxBytes uint64)
 
 	// Cache the transactions for this DA epoch
 	s.currentBatchTxs = validTxs
+	s.currentEpochTxCount = uint64(len(validTxs))
+
+	if daEndTime := forcedTxsEvent.Timestamp.UTC(); daEndTime.After(s.currentDAEndTime) {
+		s.currentDAEndTime = daEndTime
+	}
 
-	return forcedTxsEvent.Timestamp.UTC(), forcedTxsEvent.EndDaHeight, nil
+	return forcedTxsEvent.EndDaHeight, nil
 }
 
 // VerifyBatch verifies a batch of transactions

pkg/sequencers/single/sequencer.go

@@ -84,16 +84,17 @@ func NewSequencer(
 	executor execution.Executor,
 ) (*Sequencer, error) {
 	s := &Sequencer{
-		db:              db,
-		logger:          logger,
-		daClient:        daClient,
-		cfg:             cfg,
-		batchTime:       cfg.Node.BlockTime.Duration,
-		Id:              id,
-		queue:           NewBatchQueue(db, "batches", maxQueueSize),
-		checkpointStore: seqcommon.NewCheckpointStore(db, ds.NewKey("/single/checkpoint")),
-		genesis:         genesis,
-		executor:        executor,
+		db:               db,
+		logger:           logger,
+		daClient:         daClient,
+		cfg:              cfg,
+		batchTime:        cfg.Node.BlockTime.Duration,
+		Id:               id,
+		queue:            NewBatchQueue(db, "batches", maxQueueSize),
+		checkpointStore:  seqcommon.NewCheckpointStore(db, ds.NewKey("/single/checkpoint")),
+		genesis:          genesis,
+		currentDAEndTime: genesis.StartTime,
+		executor:         executor,
 	}
 	s.SetDAHeight(genesis.DAStartHeight) // default value, will be overridden by executor or submitter
 	s.daStartHeight.Store(genesis.DAStartHeight)
@@ -463,10 +464,6 @@ func (c *Sequencer) fetchNextDAEpoch(ctx context.Context, maxBytes uint64) (uint
 		return 0, fmt.Errorf("failed to retrieve forced inclusion transactions: %w", err)
 	}
 
-	// Store DA epoch end time for timestamp usage during catch-up
-	if !forcedTxsEvent.Timestamp.IsZero() {
-		c.currentDAEndTime = forcedTxsEvent.Timestamp.UTC()
-	}
 	// Record total tx count for the epoch so the timestamp jitter can be computed
 	// after oversized txs are filtered out below.
 
@@ -494,9 +491,15 @@ func (c *Sequencer) fetchNextDAEpoch(ctx context.Context, maxBytes uint64) (uint
 		Bool("catching_up", c.catchUpState.Load() == catchUpInProgress).
 		Msg("fetched forced inclusion transactions from DA")
 
+	// Cache the transactions for this DA epoch
 	c.cachedForcedInclusionTxs = validTxs
 	c.currentEpochTxCount = uint64(len(validTxs))
 
+	// Store DA epoch end time for timestamp usage during catch-up
+	if daEndTime := forcedTxsEvent.Timestamp.UTC(); forcedTxsEvent.Timestamp.UTC().After(c.currentDAEndTime) {
+		c.currentDAEndTime = daEndTime
+	}
+
 	return forcedTxsEvent.EndDaHeight, nil
 }
 
@@ -558,6 +561,10 @@ func (c *Sequencer) updateCatchUpState(ctx context.Context) {
 			Msg("initialized catch-up timestamp floor from last block time")
 	}
 
+	if c.lastCatchUpTimestamp.After(c.currentDAEndTime) {
+		c.currentDAEndTime = c.lastCatchUpTimestamp
+	}
+
 	c.catchUpState.Store(catchUpInProgress)
 	c.logger.Warn().
 		Uint64("checkpoint_da_height", currentDAHeight).

test/e2e/evm_force_inclusion_e2e_test.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
+	"math/big"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -849,7 +850,6 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
 		"--evnode.clear_cache",
 		"--evm.engine-url", env.Endpoints.GetFullNodeEngineURL(),
 		"--evm.eth-url", env.Endpoints.GetFullNodeEthURL(),
-		"--evnode.log.level", "debug",
 	)
 	sut.AwaitNodeLive(t, env.Endpoints.GetFullNodeRPCAddress(), NodeStartupTimeout)
 	t.Log("Sync node restarted as normal full node")
@@ -915,6 +915,48 @@ func TestEvmSequencerCatchUpBasedSequencerE2E(t *testing.T) {
 	require.NoError(t, err)
 	t.Logf("Sequencer caught up to height: %d", seqHeader.Number.Uint64())
 
+	t.Log("Phase 9b: Compare Sequencer Caught-Up Blocks with Full Node Blocks")
+
+	// The sequencer caught up by replaying DA blocks, so its blocks from height 1
+	// through basedSeqFinalHeight must be identical to what the full node has
+	// (the full node synced the same DA chain). Compare block hashes, state roots,
+	// and transaction counts at every height to prove deterministic replay.
+	for h := uint64(1); h <= basedSeqFinalHeight; h++ {
+		height := new(big.Int).SetUint64(h)
+
+		seqBlock, err := seqClient.BlockByNumber(ctx, height)
+		require.NoError(t, err, "sequencer should have block %d", h)
+
+		fnBlock, err := fnClient.BlockByNumber(ctx, height)
+		require.NoError(t, err, "full node should have block %d", h)
+
+		seqTime := seqBlock.Time()
+		fnTime := fnBlock.Time()
+		if seqBlock.Hash() != fnBlock.Hash() {
+			t.Logf("❌ Block %d MISMATCH: seqHash=%s fnHash=%s seqTime=%d fnTime=%d timeDelta=%d seqTxs=%d fnTxs=%d seqRoot=%s fnRoot=%s",
+				h, seqBlock.Hash().Hex(), fnBlock.Hash().Hex(),
+				seqTime, fnTime, int64(seqTime)-int64(fnTime),
+				len(seqBlock.Transactions()), len(fnBlock.Transactions()),
+				seqBlock.Root().Hex(), fnBlock.Root().Hex())
+		}
+
+		require.Equal(t, seqBlock.Hash(), fnBlock.Hash(),
+			"block hash mismatch at height %d: sequencer=%s fullnode=%s seqTime=%d fnTime=%d timeDelta=%d (%v != %v)",
+			h, seqBlock.Hash().Hex(), fnBlock.Hash().Hex(), seqTime, fnTime, int64(seqTime)-int64(fnTime), seqBlock, fnBlock)
+
+		require.Equal(t, seqBlock.Root(), fnBlock.Root(),
+			"state root mismatch at height %d: sequencer=%s fullnode=%s",
+			h, seqBlock.Root().Hex(), fnBlock.Root().Hex())
+
+		require.Equal(t, len(seqBlock.Transactions()), len(fnBlock.Transactions()),
+			"tx count mismatch at height %d: sequencer=%d fullnode=%d",
+			h, len(seqBlock.Transactions()), len(fnBlock.Transactions()))
+
+		t.Logf("✅ Block %d matches: hash=%s stateRoot=%s txs=%d",
+			h, seqBlock.Hash().Hex(), seqBlock.Root().Hex(), len(seqBlock.Transactions()))
+	}
+	t.Logf("All %d blocks match between sequencer and full node", basedSeqFinalHeight)
+
 	// ===== PHASE 10: Verify Nodes Are in Sync =====
 	t.Log("Phase 10: Verify Nodes Are in Sync")