feat: Submit empty blocks to DA when no txs (#2234)

<!--
Please read and fill out this form before submitting your PR.

Please make sure you have reviewed our contributors guide before
submitting your
first PR.

NOTE: PR titles should follow semantic commits:
https://www.conventionalcommits.org/en/v1.0.0/
-->

## Overview

This pr recreates the legacy default design in which blocks are created
at a set interval, even if there are no txs

---------

Co-authored-by: tac0turtle <you@example.com>
Co-authored-by: Manav Aggarwal <manavaggarwal1234@gmail.com>

Author: 3 people

block/aggregation.go

@@ -36,7 +36,7 @@ func (m *Manager) AggregationLoop(ctx context.Context) {
 	// Lazy Aggregator mode.
 	// In Lazy Aggregator mode, blocks are built only when there are
 	// transactions or every LazyBlockTime.
-	if m.config.Node.LazyAggregator {
+	if m.config.Node.LazyMode {
 		m.lazyAggregationLoop(ctx, blockTimer)
 		return
 	}
@@ -55,21 +55,37 @@ func (m *Manager) lazyAggregationLoop(ctx context.Context, blockTimer *time.Time
 			return
 
 		case <-lazyTimer.C:
-		case <-blockTimer.C:
-		}
+			m.logger.Debug("Lazy timer triggered block production")
+			m.produceBlock(ctx, "lazy_timer", lazyTimer, blockTimer)
 
-		// Reset the start time
-		start := time.Now()
+		case <-blockTimer.C:
+			m.logger.Debug("Block timer triggered block production")
+			if m.txsAvailable {
+				m.produceBlock(ctx, "block_timer", lazyTimer, blockTimer)
+			}
+			m.txsAvailable = false
 
-		// Attempt to publish the block regardless of activity
-		if err := m.publishBlock(ctx); err != nil && ctx.Err() == nil {
-			m.logger.Error("error while publishing block", "error", err)
+		case <-m.txNotifyCh:
+			m.txsAvailable = true
 		}
+	}
+}
+
+// produceBlock handles the common logic for producing a block and resetting timers
+func (m *Manager) produceBlock(ctx context.Context, trigger string, lazyTimer, blockTimer *time.Timer) {
+	// Record the start time
+	start := time.Now()
 
-		// Reset both timers for the next aggregation window
-		lazyTimer.Reset(getRemainingSleep(start, m.config.Node.LazyBlockTime.Duration))
-		blockTimer.Reset(getRemainingSleep(start, m.config.Node.BlockTime.Duration))
+	// Attempt to publish the block
+	if err := m.publishBlock(ctx); err != nil && ctx.Err() == nil {
+		m.logger.Error("error while publishing block", "trigger", trigger, "error", err)
+	} else {
+		m.logger.Debug("Successfully published block", "trigger", trigger)
 	}
+
+	// Reset both timers for the next aggregation window
+	lazyTimer.Reset(getRemainingSleep(start, m.config.Node.LazyBlockInterval.Duration))
+	blockTimer.Reset(getRemainingSleep(start, m.config.Node.BlockTime.Duration))
 }
 
 func (m *Manager) normalAggregationLoop(ctx context.Context, blockTimer *time.Timer) {
@@ -87,6 +103,12 @@ func (m *Manager) normalAggregationLoop(ctx context.Context, blockTimer *time.Ti
 			// Reset the blockTimer to signal the next block production
 			// period based on the block time.
 			blockTimer.Reset(getRemainingSleep(start, m.config.Node.BlockTime.Duration))
+
+		case <-m.txNotifyCh:
+			// Transaction notifications are intentionally ignored in normal mode
+			// to avoid triggering block production outside the scheduled intervals.
+			// We just update the txsAvailable flag for tracking purposes
+			m.txsAvailable = true
 		}
 	}
 }

block/aggregation_test.go

@@ -45,8 +45,8 @@ func TestAggregationLoop_Normal_BasicInterval(t *testing.T) {
 		logger:    logger,
 		config: config.Config{
 			Node: config.NodeConfig{
-				BlockTime:      config.DurationWrapper{Duration: blockTime},
-				LazyAggregator: false,
+				BlockTime: config.DurationWrapper{Duration: blockTime},
+				LazyMode:  false,
 			},
 			DA: config.DAConfig{
 				BlockTime: config.DurationWrapper{Duration: 1 * time.Second},
@@ -142,8 +142,8 @@ func TestAggregationLoop_Normal_PublishBlockError(t *testing.T) {
 		logger:    mockLogger,
 		config: config.Config{
 			Node: config.NodeConfig{
-				BlockTime:      config.DurationWrapper{Duration: blockTime},
-				LazyAggregator: false,
+				BlockTime: config.DurationWrapper{Duration: blockTime},
+				LazyMode:  false,
 			},
 			DA: config.DAConfig{
 				BlockTime: config.DurationWrapper{Duration: 1 * time.Second},