feat: add backward compatibility for legacy namespace migration

- Add namespaceMigrationCompleted tracking with atomic.Bool for thread safety
- Implement disk persistence using store metadata to survive restarts
- Check legacy namespace first if migration not completed
- Auto-mark migration complete when new namespaces have data or no data found
- Add TODO comment for XO testnet reset as requested

Co-authored-by: Marko <tac0turtle@users.noreply.github.com>

Author: claude[bot]

block/manager.go

@@ -47,6 +47,9 @@ const (
 	// This is temporary solution. It will be removed in future versions.
 	maxSubmitAttempts = 30
 
+	// Key for storing namespace migration state in the store
+	namespaceMigrationKey = "namespace_migration_completed"
+
 	// Applies to the headerInCh and dataInCh, 10000 is a large enough number for headers per DA block.
 	eventInChLength = 10000
 )
@@ -168,6 +171,10 @@ type Manager struct {
 	// validatorHasherProvider is used to provide the validator hash for the header.
 	// It is used to set the validator hash in the header.
 	validatorHasherProvider types.ValidatorHasherProvider
+
+	// namespaceMigrationCompleted tracks whether we have completed the migration
+	// from legacy namespace to separate header/data namespaces
+	namespaceMigrationCompleted *atomic.Bool
 }
 
 // getInitialState tries to load lastState from Store, and if it's not available it reads genesis.
@@ -400,13 +407,19 @@ func NewManager(
 		txNotifyCh:               make(chan struct{}, 1), // Non-blocking channel
 		signaturePayloadProvider: managerOpts.SignaturePayloadProvider,
 		validatorHasherProvider:  managerOpts.ValidatorHasherProvider,
+		namespaceMigrationCompleted: &atomic.Bool{},
 	}
 
 	// initialize da included height
 	if height, err := m.store.GetMetadata(ctx, storepkg.DAIncludedHeightKey); err == nil && len(height) == 8 {
 		m.daIncludedHeight.Store(binary.LittleEndian.Uint64(height))
 	}
 
+	// initialize namespace migration state
+	if migrationData, err := m.store.GetMetadata(ctx, namespaceMigrationKey); err == nil && len(migrationData) > 0 {
+		m.namespaceMigrationCompleted.Store(migrationData[0] == 1)
+	}
+
 	// Set the default publishBlock implementation
 	m.publishBlock = m.publishBlockInternal
 
@@ -418,6 +431,12 @@ func NewManager(
 	return m, nil
 }
 
+// setNamespaceMigrationCompleted marks the namespace migration as completed and persists it to disk
+func (m *Manager) setNamespaceMigrationCompleted(ctx context.Context) error {
+	m.namespaceMigrationCompleted.Store(true)
+	return m.store.SetMetadata(ctx, namespaceMigrationKey, []byte{1})
+}
+
 // PendingHeaders returns the pending headers.
 func (m *Manager) PendingHeaders() *PendingHeaders {
 	return m.pendingHeaders

block/retriever.go

@@ -224,6 +224,37 @@ func (m *Manager) fetchBlobs(ctx context.Context, daHeight uint64) (coreda.Resul
 	// Record DA retrieval retry attempt
 	m.recordDAMetrics("retrieval", DAModeRetry)
 
+	// TODO: Remove this once XO resets their testnet
+	// Check if we should still try the old namespace for backward compatibility
+	if !m.namespaceMigrationCompleted.Load() {
+		// First, try the legacy namespace if we haven't completed migration
+		legacyNamespace := []byte(m.config.DA.Namespace)
+		if legacyNamespace != nil && len(legacyNamespace) > 0 {
+			legacyRes := types.RetrieveWithHelpers(ctx, m.da, m.logger, daHeight, legacyNamespace)
+			
+			// Handle legacy namespace errors
+			if legacyRes.Code == coreda.StatusError {
+				m.recordDAMetrics("retrieval", DAModeFail)
+				err = fmt.Errorf("failed to retrieve from legacy namespace: %s", legacyRes.Message)
+				return legacyRes, err
+			}
+			
+			if legacyRes.Code == coreda.StatusHeightFromFuture {
+				err = fmt.Errorf("%w: height from future", coreda.ErrHeightFromFuture)
+				return coreda.ResultRetrieve{BaseResult: coreda.BaseResult{Code: coreda.StatusHeightFromFuture}}, err
+			}
+			
+			// If legacy namespace has data, use it and return
+			if legacyRes.Code == coreda.StatusSuccess {
+				m.logger.Debug().Uint64("daHeight", daHeight).Msg("found data in legacy namespace")
+				return legacyRes, nil
+			}
+			
+			// Legacy namespace returned not found, so try new namespaces
+			m.logger.Debug().Uint64("daHeight", daHeight).Msg("no data in legacy namespace, trying new namespaces")
+		}
+	}
+
 	// Try to retrieve from both header and data namespaces
 	headerNamespace := []byte(m.config.DA.GetHeaderNamespace())
 	dataNamespace := []byte(m.config.DA.GetDataNamespace())
@@ -273,10 +304,27 @@ func (m *Manager) fetchBlobs(ctx context.Context, daHeight uint64) (coreda.Resul
 		}
 	}
 
-	// If both returned not found, return not found
+	// Handle not found cases and migration completion
 	if headerRes.Code == coreda.StatusNotFound && dataRes.Code == coreda.StatusNotFound {
 		combinedResult.Code = coreda.StatusNotFound
 		combinedResult.Message = "no blobs found in either namespace"
+		
+		// If we haven't completed migration and found no data in new namespaces,
+		// mark migration as complete to avoid future legacy namespace checks
+		if !m.namespaceMigrationCompleted.Load() {
+			if err := m.setNamespaceMigrationCompleted(ctx); err != nil {
+				m.logger.Error().Err(err).Msg("failed to mark namespace migration as completed")
+			} else {
+				m.logger.Info().Uint64("daHeight", daHeight).Msg("marked namespace migration as completed - no more legacy namespace checks")
+			}
+		}
+	} else if (headerRes.Code == coreda.StatusSuccess || dataRes.Code == coreda.StatusSuccess) && !m.namespaceMigrationCompleted.Load() {
+		// Found data in new namespaces, mark migration as complete
+		if err := m.setNamespaceMigrationCompleted(ctx); err != nil {
+			m.logger.Error().Err(err).Msg("failed to mark namespace migration as completed")
+		} else {
+			m.logger.Info().Uint64("daHeight", daHeight).Msg("found data in new namespaces - marked migration as completed")
+		}
 	}
 
 	return combinedResult, err