updates

Author: julienrbrt

block/aggregation.go

@@ -38,45 +38,56 @@ 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.
+	errChan := make(chan error)
 	if m.config.Node.LazyMode {
-		if err := m.lazyAggregationLoop(ctx, blockTimer); err != nil {
-			if errors.Is(err, ErrNoRecover) {
-				panic(err)
-			} else {
-				m.logger.Error("error in lazy aggregation loop", "error", err)
+		m.lazyAggregationLoop(ctx, blockTimer, errChan)
+		select {
+		case err := <-errChan:
+			if err != nil {
+				if errors.Is(err, ErrNoRecover) {
+					panic(err)
+				} else {
+					m.logger.Error("error in lazy aggregation loop", "error", err)
+				}
 			}
+		default:
 		}
 	} else {
-		if err := m.normalAggregationLoop(ctx, blockTimer); err != nil {
-			if errors.Is(err, ErrNoRecover) {
-				panic(err)
-			} else {
-				m.logger.Error("error in normal aggregation loop", "error", err)
+		m.normalAggregationLoop(ctx, blockTimer, errChan)
+		select {
+		case err := <-errChan:
+			if err != nil {
+				if errors.Is(err, ErrNoRecover) {
+					panic(err)
+				} else {
+					m.logger.Error("error in normal aggregation loop", "error", err)
+				}
 			}
+		default:
 		}
 	}
 }
 
-func (m *Manager) lazyAggregationLoop(ctx context.Context, blockTimer *time.Timer) error {
+func (m *Manager) lazyAggregationLoop(ctx context.Context, blockTimer *time.Timer, errChan chan<- error) {
 	// lazyTimer triggers block publication even during inactivity
 	lazyTimer := time.NewTimer(0)
 	defer lazyTimer.Stop()
 
 	for {
 		select {
 		case <-ctx.Done():
-			return nil
+			return
 
 		case <-lazyTimer.C:
 			m.logger.Debug("Lazy timer triggered block production")
 			if err := m.produceBlock(ctx, "lazy_timer", lazyTimer, blockTimer); err != nil {
-				return err
+				errChan <- err
 			}
 
 		case <-blockTimer.C:
 			if m.txsAvailable {
 				if err := m.produceBlock(ctx, "block_timer", lazyTimer, blockTimer); err != nil {
-					return err
+					errChan <- err
 				}
 				m.txsAvailable = false
 			} else {
@@ -107,17 +118,17 @@ func (m *Manager) produceBlock(ctx context.Context, mode string, lazyTimer, bloc
 	return nil
 }
 
-func (m *Manager) normalAggregationLoop(ctx context.Context, blockTimer *time.Timer) error {
+func (m *Manager) normalAggregationLoop(ctx context.Context, blockTimer *time.Timer, errChan chan<- error) {
 	for {
 		select {
 		case <-ctx.Done():
-			return nil
+			return
 		case <-blockTimer.C:
 			// Define the start time for the block production period
 			start := time.Now()
 
 			if err := m.publishBlock(ctx); err != nil && ctx.Err() == nil {
-				return fmt.Errorf("error while publishing block: %w", err)
+				errChan <- fmt.Errorf("error while publishing block: %w", err)
 			}
 
 			m.logger.Debug("Successfully published block")

block/lazy_aggregation_test.go

@@ -99,7 +99,7 @@ func TestLazyAggregationLoop_BlockTimerTrigger(t *testing.T) {
 		blockTimer := time.NewTimer(0) // Fire immediately first time
 		defer blockTimer.Stop()
 
-		require.NoError(m.lazyAggregationLoop(ctx, blockTimer))
+		m.lazyAggregationLoop(ctx, blockTimer, make(chan<- error, 0))
 	}()
 
 	// Wait for at least one block to be published
@@ -137,7 +137,7 @@ func TestLazyAggregationLoop_LazyTimerTrigger(t *testing.T) {
 		blockTimer := time.NewTimer(0) // Fire immediately first time
 		defer blockTimer.Stop()
 
-		require.NoError(m.lazyAggregationLoop(ctx, blockTimer))
+		m.lazyAggregationLoop(ctx, blockTimer, make(chan<- error, 0))
 	}()
 
 	// Wait for the first publish call triggered by the initial immediate lazyTimer fire
@@ -186,7 +186,9 @@ func TestLazyAggregationLoop_PublishError(t *testing.T) {
 		blockTimer := time.NewTimer(0)
 		defer blockTimer.Stop()
 
-		require.Error(m.lazyAggregationLoop(ctx, blockTimer))
+		errChan := make(chan error, 1)
+		m.lazyAggregationLoop(ctx, blockTimer, errChan)
+		require.Error(<-errChan)
 	}()
 
 	// Wait for the first publish attempt (which will fail)
@@ -265,7 +267,7 @@ func TestLazyAggregationLoop_TxNotification(t *testing.T) {
 		// Start with a timer that won't fire immediately
 		blockTimer := time.NewTimer(blockTime)
 		defer blockTimer.Stop()
-		require.NoError(m.lazyAggregationLoop(ctx, blockTimer))
+		m.lazyAggregationLoop(ctx, blockTimer, make(chan<- error, 0))
 	}()
 
 	// Wait for the initial lazy timer to fire and publish a block
@@ -367,7 +369,7 @@ func TestNormalAggregationLoop_TxNotification(t *testing.T) {
 		blockTimer := time.NewTimer(blockTime)
 		defer blockTimer.Stop()
 
-		require.NoError(m.normalAggregationLoop(ctx, blockTimer))
+		m.normalAggregationLoop(ctx, blockTimer, make(chan<- error, 0))
 	}()
 
 	// Wait for the first block to be published by the timer

node/full_node_integration_test.go

@@ -255,8 +255,7 @@ func (s *FullNodeTestSuite) TestSubmitBlocksToDA() {
 		require.NoError(err)
 		currentDAHeight := s.node.blockManager.GetDAIncludedHeight()
 		pendingHeaders, _ := s.node.blockManager.PendingHeaders().GetPendingHeaders()
-		s.T().Logf("Post-trigger check %d - Height: %d, DA Height: %d, Pending: %d",
-			i, currentHeight, currentDAHeight, len(pendingHeaders))
+		s.T().Logf("Post-trigger check %d - Height: %d, DA Height: %d, Pending: %d", i, currentHeight, currentDAHeight, len(pendingHeaders))
 	}
 
 	// Final assertions with more detailed error messages