refactor: fix epoch bumping

Author: julienrbrt

sequencers/based/sequencer.go

@@ -67,7 +67,7 @@ func (s *BasedSequencer) SubmitBatchTxs(ctx context.Context, req coresequencer.S
 // GetNextBatch retrieves the next batch of transactions from the DA layer
 // It fetches forced inclusion transactions and returns them as the next batch
 func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextBatchRequest) (*coresequencer.GetNextBatchResponse, error) {
-	currentDAHeight := s.daHeight.Load()
+	currentDAHeight := s.GetDAHeight()
 
 	s.logger.Debug().Uint64("da_height", currentDAHeight).Msg("fetching forced inclusion transactions from DA")
 
@@ -88,11 +88,11 @@ func (s *BasedSequencer) GetNextBatch(ctx context.Context, req coresequencer.Get
 		}
 	}
 
-	// Update DA height based on the retrieved event
-	if forcedTxsEvent.EndDaHeight > currentDAHeight {
-		s.SetDAHeight(forcedTxsEvent.EndDaHeight)
-	} else if forcedTxsEvent.StartDaHeight > currentDAHeight {
-		s.SetDAHeight(forcedTxsEvent.StartDaHeight)
+	// Update DA height.
+	// If we are in between epochs, we still need to bump the da height.
+	// At the end of an epoch, we need to bump to go to the next epoch.
+	if forcedTxsEvent.EndDaHeight >= currentDAHeight {
+		s.SetDAHeight(forcedTxsEvent.EndDaHeight + 1)
 	}
 
 	// Add forced inclusion transactions to the queue with validation

sequencers/common/size_validation.go

@@ -12,7 +12,7 @@ const (
 // This checks against the DA layer limit, not the per-batch limit.
 // Returns true if the blob is within the absolute size limit, false otherwise.
 func ValidateBlobSize(blob []byte) bool {
-	return uint64(len(blob)) <= AbsoluteMaxBlobSize
+	return uint64(GetBlobSize(blob)) <= AbsoluteMaxBlobSize
 }
 
 // WouldExceedCumulativeSize checks if adding a blob would exceed the cumulative size limit for a batch.

sequencers/single/sequencer.go

@@ -130,9 +130,9 @@ func (c *Sequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextB
 		return nil, ErrInvalidId
 	}
 
-	currentDAHeight := c.daHeight.Load()
+	currentDAHeight := c.GetDAHeight()
 
-	forcedEvent, err := c.fiRetriever.RetrieveForcedIncludedTxs(ctx, currentDAHeight)
+	forcedTxsEvent, err := c.fiRetriever.RetrieveForcedIncludedTxs(ctx, currentDAHeight)
 	if err != nil {
 		if errors.Is(err, coreda.ErrHeightFromFuture) {
 			c.logger.Debug().
@@ -143,25 +143,27 @@ func (c *Sequencer) GetNextBatch(ctx context.Context, req coresequencer.GetNextB
 		}
 
 		// Still create an empty forced inclusion event
-		forcedEvent = &block.ForcedInclusionEvent{
+		forcedTxsEvent = &block.ForcedInclusionEvent{
 			Txs:           [][]byte{},
 			StartDaHeight: currentDAHeight,
 			EndDaHeight:   currentDAHeight,
 		}
 	}
 
 	// Always try to process forced inclusion transactions (including pending from previous epochs)
-	forcedTxs := c.processForcedInclusionTxs(forcedEvent, req.MaxBytes)
-	if forcedEvent.EndDaHeight > currentDAHeight {
-		c.SetDAHeight(forcedEvent.EndDaHeight)
-	} else if forcedEvent.StartDaHeight > currentDAHeight {
-		c.SetDAHeight(forcedEvent.StartDaHeight)
+	forcedTxs := c.processForcedInclusionTxs(forcedTxsEvent, req.MaxBytes)
+
+	// Update DA height.
+	// If we are in between epochs, we still need to bump the da height.
+	// At the end of an epoch, we need to bump to go to the next epoch.
+	if forcedTxsEvent.EndDaHeight >= currentDAHeight {
+		c.SetDAHeight(forcedTxsEvent.EndDaHeight + 1)
 	}
 
 	c.logger.Debug().
 		Int("tx_count", len(forcedTxs)).
-		Uint64("da_height_start", forcedEvent.StartDaHeight).
-		Uint64("da_height_end", forcedEvent.EndDaHeight).
+		Uint64("da_height_start", forcedTxsEvent.StartDaHeight).
+		Uint64("da_height_end", forcedTxsEvent.EndDaHeight).
 		Msg("retrieved forced inclusion transactions from DA")
 
 	// Calculate size used by forced inclusion transactions