updates

Author: julienrbrt

block/internal/da/forced_inclusion_retriever.go

@@ -62,6 +62,10 @@ func (r *ForcedInclusionRetriever) RetrieveForcedIncludedTxs(ctx context.Context
 		return nil, ErrForceInclusionNotConfigured
 	}
 
+	if daHeight < r.daStartHeight {
+		return nil, ErrForceInclusionNotConfigured
+	}
+
 	epochStart, epochEnd, currentEpochNumber := types.CalculateEpochBoundaries(daHeight, r.daStartHeight, r.daEpochSize)
 
 	if daHeight != epochEnd {

block/internal/executing/executor.go

@@ -197,21 +197,13 @@ func (e *Executor) initializeState() error {
 			LastBlockHeight: e.genesis.InitialHeight - 1,
 			LastBlockTime:   e.genesis.StartTime,
 			AppHash:         stateRoot,
-			// DA start height is usually 0 at InitChain unless it is a re-genesis.
-			// The sequencer does not know at which DA block its first block will be included.
+			// DA start height is usually 0 at InitChain unless it is a re-genesis or a based sequencer.
 			DAHeight: e.genesis.DAStartHeight,
 		}
 	}
 
 	e.setLastState(state)
-	// Defer setting sequencer DA height at genesis. At chain genesis there are no
-	// included DA blocks yet, so the sequencer shouldn't be updated with the
-	// state's DA height until we've produced/observed at least the first included
-	// block. Only set the sequencer DA height when the chain has progressed past
-	// the initial genesis height.
-	if state.LastBlockHeight >= e.genesis.InitialHeight {
-		e.sequencer.SetDAHeight(state.DAHeight)
-	}
+	e.sequencer.SetDAHeight(state.DAHeight)
 
 	// Initialize store height using batch for atomicity
 	batch, err := e.store.NewBatch(e.ctx)

sequencers/based/sequencer.go

@@ -53,8 +53,8 @@ func NewBasedSequencer(
 		fiRetriever:     fiRetriever,
 		logger:          logger.With().Str("component", "based_sequencer").Logger(),
 		checkpointStore: seqcommon.NewCheckpointStore(db, ds.NewKey("/based/checkpoint")),
-		daHeight:        atomic.Uint64{}, // empty, set by executor or submitter
 	}
+	bs.SetDAHeight(genesis.DAStartHeight) // based sequencers need community approval of da start height given no submission are done
 
 	// Load checkpoint from DB, or initialize if none exists
 	loadCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
@@ -96,11 +96,11 @@ func (s *BasedSequencer) SubmitBatchTxs(ctx context.Context, req coresequencer.S
 // GetNextBatch retrieves the next batch of transactions from the DA layer using the checkpoint
 // It treats DA as a queue and only persists where it is in processing
 func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextBatchRequest) (*coresequencer.GetNextBatchResponse, error) {
-	// If we have no cached transactions or we've consumed all from the current DA block,
-	// fetch the next DA epoch
 	daHeight := s.GetDAHeight()
 
-	if len(s.currentBatchTxs) == 0 || s.checkpoint.TxIndex >= uint64(len(s.currentBatchTxs)) {
+	// If we have no cached transactions or we've consumed all from the current DA block,
+	// 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)
 		if err != nil {
 			return nil, err

sequencers/single/sequencer.go

@@ -86,16 +86,8 @@ func NewSequencer(
 
 	// Load checkpoint from DB, or initialize if none exists
 	checkpoint, err := s.checkpointStore.Load(loadCtx)
-	if err != nil {
-		if errors.Is(err, seqcommon.ErrCheckpointNotFound) {
-			// No checkpoint exists, initialize with current DA height
-			s.checkpoint = &seqcommon.Checkpoint{
-				DAHeight: s.GetDAHeight(),
-				TxIndex:  0,
-			}
-		} else {
-			return nil, fmt.Errorf("failed to load checkpoint from DB: %w", err)
-		}
+	if err != nil && errors.Is(err, seqcommon.ErrCheckpointNotFound) {
+		return nil, fmt.Errorf("failed to load checkpoint from DB: %w", err)
 	} else {
 		s.checkpoint = checkpoint
 		// If we had a non-zero tx index, we're resuming from a crash mid-block
@@ -147,10 +139,19 @@ func (c *Sequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextB
 		return nil, ErrInvalidId
 	}
 
+	daHeight := c.GetDAHeight()
+
+	// checkpoint init path, only hit when sequencer is bootstrapping
+	if daHeight > 0 && c.checkpoint == nil {
+		c.checkpoint = &seqcommon.Checkpoint{
+			DAHeight: daHeight,
+			TxIndex:  0,
+		}
+	}
+
 	// If we have no cached transactions or we've consumed all from the current cache,
 	// fetch the next DA epoch
-	daHeight := c.GetDAHeight()
-	if len(c.cachedForcedInclusionTxs) == 0 || c.checkpoint.TxIndex >= uint64(len(c.cachedForcedInclusionTxs)) {
+	if daHeight > 0 && (len(c.cachedForcedInclusionTxs) == 0 || c.checkpoint.TxIndex >= uint64(len(c.cachedForcedInclusionTxs))) {
 		daEndHeight, err := c.fetchNextDAEpoch(ctx, req.MaxBytes)
 		if err != nil {
 			return nil, err