remove header namespace config

Author: julienrbrt

block/namespace_test.go

@@ -131,8 +131,8 @@ func TestProcessNextDAHeaderAndData_MixedResults(t *testing.T) {
 			t.Parallel()
 
 			daConfig := config.DAConfig{
-				HeaderNamespace: "test-headers",
-				DataNamespace:   "test-data",
+				Namespace:     "test-headers",
+				DataNamespace: "test-data",
 			}
 			manager, mockDA, _, cancel := setupManagerForNamespaceTest(t, daConfig)
 			daManager := newDARetriever(manager)
@@ -184,40 +184,28 @@ func TestProcessNextDAHeaderAndData_MixedResults(t *testing.T) {
 // TestLegacyNamespaceDetection tests the legacy namespace fallback behavior
 func TestLegacyNamespaceDetection(t *testing.T) {
 	t.Parallel()
-
 	tests := []struct {
-		name            string
-		legacyNamespace string
-		headerNamespace string
-		dataNamespace   string
+		name          string
+		namespace     string
+		dataNamespace string
 	}{
 		{
 			// When only legacy namespace is set, it acts as both header and data namespace
-			name:            "only legacy namespace configured",
-			legacyNamespace: "old-namespace",
-			headerNamespace: "",
-			dataNamespace:   "",
-		},
-		{
-			// Should check both namespaces. It will behave as legacy when data namespace is empty
-			name:            "all namespaces configured",
-			legacyNamespace: "old-namespace",
-			headerNamespace: "old-namespace",
-			dataNamespace:   "new-data",
+			name:          "only legacy namespace configured",
+			namespace:     "namespace",
+			dataNamespace: "",
 		},
 		{
 			// Should check both namespaces. It will behave as legacy when data namespace is empty
-			name:            "only legacy namespaces and data",
-			legacyNamespace: "old-namespace",
-			headerNamespace: "",
-			dataNamespace:   "new-data",
+			name:          "all namespaces configured",
+			namespace:     "old-namespace",
+			dataNamespace: "new-data",
 		},
 		{
 			// Should use default namespaces only
-			name:            "no namespaces configured",
-			legacyNamespace: "",
-			headerNamespace: "",
-			dataNamespace:   "",
+			name:          "no namespaces configured",
+			namespace:     "",
+			dataNamespace: "",
 		},
 	}
 
@@ -226,27 +214,24 @@ func TestLegacyNamespaceDetection(t *testing.T) {
 			t.Parallel()
 
 			daConfig := config.DAConfig{
-				Namespace:       tt.legacyNamespace,
-				HeaderNamespace: tt.headerNamespace,
-				DataNamespace:   tt.dataNamespace,
+				Namespace:     tt.namespace,
+				DataNamespace: tt.dataNamespace,
 			}
 
-			// Test the GetHeaderNamespace and GetDataNamespace methods
-			headerNS := daConfig.GetHeaderNamespace()
+			// Test the GetNamespace and GetDataNamespace methods
+			headerNS := daConfig.GetNamespace()
 			dataNS := daConfig.GetDataNamespace()
 
-			if tt.headerNamespace != "" {
-				assert.Equal(t, tt.headerNamespace, headerNS)
-			} else if tt.legacyNamespace != "" {
-				assert.Equal(t, tt.legacyNamespace, headerNS)
+			if tt.namespace != "" {
+				assert.Equal(t, tt.namespace, headerNS)
 			} else {
 				assert.Equal(t, "rollkit-headers", headerNS) // Default
 			}
 
 			if tt.dataNamespace != "" {
 				assert.Equal(t, tt.dataNamespace, dataNS)
-			} else if tt.legacyNamespace != "" {
-				assert.Equal(t, tt.legacyNamespace, dataNS)
+			} else if tt.namespace != "" {
+				assert.Equal(t, tt.namespace, dataNS)
 			} else {
 				assert.Equal(t, "rollkit-data", dataNS) // Default
 			}
@@ -256,54 +241,36 @@ func TestLegacyNamespaceDetection(t *testing.T) {
 			daManager := newDARetriever(manager)
 			defer cancel()
 
-			// Check if we should expect a legacy namespace check
-			// Legacy check happens when migration is not completed and legacy namespace is configured
-			if tt.legacyNamespace != "" {
-				// When legacy namespace is the same as header/data namespaces,
+			// Check if we should expect a namespace check
+			if tt.namespace != "" {
+				// When  namespace is the same as data namespaces,
 				// only one call is expected
-				if tt.legacyNamespace == headerNS && headerNS == dataNS {
-					// All three namespaces are the same, so we'll get 1 call.
-					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(tt.legacyNamespace)).Return(&coreda.GetIDsResult{
-						IDs: []coreda.ID{},
-					}, coreda.ErrBlobNotFound).Once()
-				} else if tt.legacyNamespace == headerNS || tt.legacyNamespace == dataNS {
-					// Legacy matches one of the new namespaces
-					// Plus none or one depending on whether header == data
-					totalCalls := 1 // legacy call
-					if headerNS == dataNS {
-						totalCalls += 1 // header and data are same
-					}
-					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(tt.legacyNamespace)).Return(&coreda.GetIDsResult{
-						IDs: []coreda.ID{},
-					}, coreda.ErrBlobNotFound).Times(totalCalls)
-
-					// Mock the non-matching namespace if header != data
-					if headerNS != dataNS {
-						nonMatchingNS := headerNS
-						if tt.legacyNamespace == headerNS {
-							nonMatchingNS = dataNS
-						}
-						mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(nonMatchingNS)).Return(&coreda.GetIDsResult{
-							IDs: []coreda.ID{},
-						}, coreda.ErrBlobNotFound).Once()
-					}
-				} else {
-					t.Fatalf("Should never happen, forbidden by config")
-				}
-			} else {
-				// No legacy namespace configured, just mock the new namespace calls
 				if headerNS == dataNS {
-					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(headerNS)).Return(&coreda.GetIDsResult{
+					// All 2 namespaces are the same, so we'll get 1 call.
+					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(tt.namespace)).Return(&coreda.GetIDsResult{
 						IDs: []coreda.ID{},
 					}, coreda.ErrBlobNotFound).Once()
-				} else {
-					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(headerNS)).Return(&coreda.GetIDsResult{
+				} else if tt.namespace != dataNS {
+					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(tt.namespace)).Return(&coreda.GetIDsResult{
 						IDs: []coreda.ID{},
 					}, coreda.ErrBlobNotFound).Once()
-					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(dataNS)).Return(&coreda.GetIDsResult{
+
+					mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(tt.dataNamespace)).Return(&coreda.GetIDsResult{
 						IDs: []coreda.ID{},
 					}, coreda.ErrBlobNotFound).Once()
+
+				} else {
+					t.Fatalf("Should never happen, forbidden by config")
 				}
+			} else {
+				// No namespace configured, just use default
+
+				mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(headerNS)).Return(&coreda.GetIDsResult{
+					IDs: []coreda.ID{},
+				}, coreda.ErrBlobNotFound).Once()
+				mockDA.On("GetIDs", mock.Anything, uint64(100), []byte(dataNS)).Return(&coreda.GetIDsResult{
+					IDs: []coreda.ID{},
+				}, coreda.ErrBlobNotFound).Once()
 			}
 
 			ctx := context.Background()

block/retriever_da.go

@@ -460,20 +460,13 @@ func (m *Manager) fetchBlobs(ctx context.Context, daHeight uint64) (coreda.Resul
 	m.recordDAMetrics("retrieval", DAModeRetry)
 
 	// Try to retrieve from both header and data namespaces
-	headerNamespace := []byte(m.config.DA.GetHeaderNamespace())
+	headerNamespace := []byte(m.config.DA.GetNamespace())
 	dataNamespace := []byte(m.config.DA.GetDataNamespace())
 
-	// Sanity check, enforced by the config validation earlier
-	if m.config.DA.Namespace != m.config.DA.GetHeaderNamespace() && m.config.DA.Namespace != m.config.DA.GetDataNamespace() {
-		return coreda.ResultRetrieve{
-			BaseResult: coreda.BaseResult{Code: 1337},
-		}, fmt.Errorf("invalid config, namespace mismatch")
-	}
-
 	// Retrieve headers
 	headerRes := types.RetrieveWithHelpers(ctx, m.da, m.logger, daHeight, headerNamespace)
 
-	// Both namespace are the same, so we are using the legacy flow.
+	// Both namespace are the same, so we are not fetching from data namespace
 	if bytes.Equal(headerNamespace, dataNamespace) {
 		err := m.validateBlobResponse(headerRes, daHeight)
 		return headerRes, err

block/submitter.go

@@ -158,7 +158,7 @@ func (m *Manager) submitHeadersToDA(ctx context.Context, headersToSubmit []*type
 			m.sendNonBlockingSignalToDAIncluderCh()
 		},
 		"header",
-		[]byte(m.config.DA.GetHeaderNamespace()),
+		[]byte(m.config.DA.GetNamespace()),
 	)
 }