align

Author: julienrbrt

block/internal/submitting/submitter.go

@@ -219,6 +219,7 @@ func (s *Submitter) processDAInclusionLoop() {
 
 				// Set final height in executor
 				if err := s.setFinalWithRetry(nextHeight, header.Height()); err != nil {
+					s.sendCriticalError(fmt.Errorf("failed to set final height: %w", err))
 					s.logger.Error().Err(err).Uint64("height", nextHeight).Msg("failed to set final height")
 					break
 				}
@@ -243,9 +244,7 @@ func (s *Submitter) setFinalWithRetry(nextHeight uint64, headerHeight uint64) er
 	for attempt := 1; attempt <= common.MaxRetriesBeforeHalt; attempt++ {
 		if err := s.exec.SetFinal(s.ctx, nextHeight); err != nil {
 			if attempt == common.MaxRetriesBeforeHalt {
-				err = fmt.Errorf("failed to set final height after %d attempts: %w", attempt, err)
-				s.sendCriticalError(err)
-				return err
+				return fmt.Errorf("failed to set final height after %d attempts: %w", attempt, err)
 			}
 
 			s.logger.Error().Err(err).

block/internal/syncing/syncer.go

@@ -482,19 +482,11 @@ func (s *Syncer) applyBlock(header types.Header, data *types.Data, currentState
 
 	// Execute transactions
 	ctx := context.WithValue(s.ctx, types.HeaderContextKey, header)
-	newAppHash, _, err := s.exec.ExecuteTxs(ctx, rawTxs, header.Height(),
-		header.Time(), currentState.AppHash)
+	newAppHash, err := s.executeTxsWithRetry(ctx, rawTxs, header, currentState)
 	if err != nil {
-		s.retriesBeforeHalt[header.Height()]++
-		if s.retriesBeforeHalt[header.Height()] > common.MaxRetriesBeforeHalt {
-			s.sendCriticalError(fmt.Errorf("failed to execute transactions: %w", err))
-			return types.State{}, fmt.Errorf("failed to execute transactions: %w", err)
-		}
-
-		time.Sleep(common.MaxRetriesTimeout) // sleep before retrying
-		return types.State{}, fmt.Errorf("failed to execute transactions (retry %d / %d): %w", s.retriesBeforeHalt[header.Height()], common.MaxRetriesBeforeHalt, err)
+		s.sendCriticalError(fmt.Errorf("failed to execute transactions: %w", err))
+		return types.State{}, fmt.Errorf("failed to execute transactions: %w", err)
 	}
-	delete(s.retriesBeforeHalt, header.Height())
 
 	// Create new state
 	newState, err := currentState.NextState(header, newAppHash)
@@ -505,6 +497,31 @@ func (s *Syncer) applyBlock(header types.Header, data *types.Data, currentState
 	return newState, nil
 }
 
+// executeTxsWithRetry executes transactions with retry logic
+func (s *Syncer) executeTxsWithRetry(ctx context.Context, rawTxs [][]byte, header types.Header, currentState types.State) ([]byte, error) {
+	for attempt := 1; attempt <= common.MaxRetriesBeforeHalt; attempt++ {
+		newAppHash, _, err := s.exec.ExecuteTxs(ctx, rawTxs, header.Height(), header.Time(), currentState.AppHash)
+		if err != nil {
+			if attempt == common.MaxRetriesBeforeHalt {
+				return nil, fmt.Errorf("failed to execute transactions: %w", err)
+			}
+
+			s.logger.Error().Err(err).
+				Int("attempt", attempt).
+				Int("max_attempts", common.MaxRetriesBeforeHalt).
+				Uint64("height", header.Height()).
+				Msg("failed to execute transactions, retrying")
+
+			time.Sleep(common.MaxRetriesTimeout)
+			continue
+		}
+
+		return newAppHash, nil
+	}
+
+	return nil, nil
+}
+
 // validateBlock validates a synced block
 func (s *Syncer) validateBlock(
 	lastState types.State,