refactor!: replace experiments with features configuration

BREAKING CHANGE: The configuration structure has changed from
`experiments` to `features`. The new model uses an allow-list
approach where features are enabled by default and can be
disabled per network via `disabled_networks`, instead of the
previous enabled/disabled toggle with explicit network lists.

- Rename `experiments` YAML key to `features`
- Replace `ExperimentSettings` struct with `FeatureSettings`
- Change API response field from `experiments` to `features`
- Update API response structure: `name`+`enabled`+`networks`
 becomes `path`+`disabled_networks`
- Update tests and example configuration accordingly

Author: mattevans

config.example.yaml

@@ -119,16 +119,17 @@ networks:
   # Note: Networks from cartographoor are automatically added with all metadata.
   # Only add entries here to disable, override, or add custom networks.
 
-# Experiment feature flags
-# Controls which experiments are available per network
-# By default, experiments are enabled for all networks unless overridden
-experiments:
-  live-slots:
-    enabled: true
-    networks: ["mainnet"]  # Only enabled for mainnet
-
-  block-production:
-    enabled: false         # Disabled for all networks
-
-  attestation-performance:
-    enabled: true          # Enabled for all networks (no networks specified = default)
+# Feature flags
+# Controls which features are available per network
+# By default, features are enabled for all networks unless explicitly disabled
+features:
+  # Example: Live slots feature - disable for all networks except mainnet
+  - path: "/ethereum/live-slots"
+    disabled_networks: ["sepolia", "holesky"]
+
+  # Example: Block production feature - disabled for all networks
+  - path: "/ethereum/block-production"
+    disabled_networks: []  # Empty array, but you'd list all networks to truly disable everywhere
+
+  # Example: Attestation performance - enabled for all networks (no disabled_networks specified)
+  - path: "/ethereum/attestation-performance"

internal/api/config.go

@@ -18,8 +18,8 @@ var _ http.Handler = (*ConfigHandler)(nil)
 
 // ConfigResponse is the JSON response for /api/v1/config.
 type ConfigResponse struct {
-	Networks    []NetworkInfo `json:"networks"`
-	Experiments []Experiment  `json:"experiments"`
+	Networks []NetworkInfo `json:"networks"`
+	Features []Feature     `json:"features"`
 }
 
 // NetworkInfo represents network metadata.
@@ -43,11 +43,11 @@ type Fork struct {
 	MinClientVersions map[string]string `json:"min_client_versions"` // Map of client name to version
 }
 
-// Experiment represents experiment configuration.
-type Experiment struct {
-	Name     string   `json:"name"`
-	Enabled  bool     `json:"enabled"`
-	Networks []string `json:"networks"` // empty = all networks
+// Feature represents feature configuration.
+// Features are enabled by default for all networks unless explicitly disabled.
+type Feature struct {
+	Path             string   `json:"path"`
+	DisabledNetworks []string `json:"disabled_networks"`
 }
 
 // ConfigHandler handles /api/v1/config requests.
@@ -98,8 +98,8 @@ func (h *ConfigHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 // This ensures both endpoints use the same logic and return consistent data.
 func (h *ConfigHandler) GetConfigData(ctx context.Context) ConfigResponse {
 	return ConfigResponse{
-		Networks:    h.buildNetworks(ctx),
-		Experiments: h.buildExperiments(ctx),
+		Networks: h.buildNetworks(ctx),
+		Features: h.buildFeatures(ctx),
 	}
 }
 
@@ -173,28 +173,27 @@ func (h *ConfigHandler) buildNetworks(ctx context.Context) []NetworkInfo {
 	return networks
 }
 
-// buildExperiments converts config experiments map to API response array.
-func (h *ConfigHandler) buildExperiments(_ context.Context) []Experiment {
-	experiments := make([]Experiment, 0, len(h.config.Experiments))
+// buildFeatures converts config features slice to API response array.
+func (h *ConfigHandler) buildFeatures(_ context.Context) []Feature {
+	features := make([]Feature, 0, len(h.config.Features))
 
-	for name, settings := range h.config.Experiments {
-		// Copy networks slice to avoid sharing underlying array
-		networks := make([]string, len(settings.Networks))
-		copy(networks, settings.Networks)
+	for _, feature := range h.config.Features {
+		// Copy disabled_networks slice to avoid sharing underlying array
+		disabledNetworks := make([]string, len(feature.DisabledNetworks))
+		copy(disabledNetworks, feature.DisabledNetworks)
 
-		experiments = append(experiments, Experiment{
-			Name:     name,
-			Enabled:  settings.Enabled,
-			Networks: networks,
+		features = append(features, Feature{
+			Path:             feature.Path,
+			DisabledNetworks: disabledNetworks,
 		})
 	}
 
-	// Sort experiments alphabetically by name for deterministic ordering
-	sort.Slice(experiments, func(i, j int) bool {
-		return experiments[i].Name < experiments[j].Name
+	// Sort features alphabetically by path for deterministic ordering
+	sort.Slice(features, func(i, j int) bool {
+		return features[i].Path < features[j].Path
 	})
 
-	return experiments
+	return features
 }
 
 // transformForks converts cartographoor.Forks to API Forks format (for snake_case output).

internal/api/config_test.go

@@ -24,7 +24,7 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 		method         string
 		cartoNetworks  map[string]*cartographoor.Network
 		configNetworks []config.NetworkConfig
-		experiments    map[string]config.ExperimentSettings
+		features       []config.FeatureSettings
 		expectedStatus int
 		validateResp   func(t *testing.T, resp *ConfigResponse)
 	}{
@@ -41,10 +41,10 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 				},
 			},
 			configNetworks: []config.NetworkConfig{},
-			experiments: map[string]config.ExperimentSettings{
-				"test-experiment": {
-					Enabled:  true,
-					Networks: []string{"mainnet"},
+			features: []config.FeatureSettings{
+				{
+					Path:             "/ethereum/test-feature",
+					DisabledNetworks: []string{"sepolia"},
 				},
 			},
 			expectedStatus: http.StatusOK,
@@ -53,16 +53,16 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 
 				require.NotNil(t, resp)
 				assert.Len(t, resp.Networks, 1)
-				assert.Len(t, resp.Experiments, 1)
+				assert.Len(t, resp.Features, 1)
 
 				// Verify network data
 				assert.Equal(t, "mainnet", resp.Networks[0].Name)
 				assert.Equal(t, "Ethereum Mainnet", resp.Networks[0].DisplayName)
 				assert.Equal(t, int64(1), resp.Networks[0].ChainID)
 
-				// Verify experiment data
-				assert.Equal(t, "test-experiment", resp.Experiments[0].Name)
-				assert.True(t, resp.Experiments[0].Enabled)
+				// Verify feature data
+				assert.Equal(t, "/ethereum/test-feature", resp.Features[0].Path)
+				assert.Equal(t, []string{"sepolia"}, resp.Features[0].DisabledNetworks)
 			},
 		},
 		{
@@ -91,7 +91,7 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 					Enabled: boolPtr(false),
 				},
 			},
-			experiments:    map[string]config.ExperimentSettings{},
+			features:       []config.FeatureSettings{},
 			expectedStatus: http.StatusOK,
 			validateResp: func(t *testing.T, resp *ConfigResponse) {
 				t.Helper()
@@ -106,14 +106,14 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 			method:         http.MethodGet,
 			cartoNetworks:  map[string]*cartographoor.Network{},
 			configNetworks: []config.NetworkConfig{},
-			experiments:    map[string]config.ExperimentSettings{},
+			features:       []config.FeatureSettings{},
 			expectedStatus: http.StatusOK,
 			validateResp: func(t *testing.T, resp *ConfigResponse) {
 				t.Helper()
 
 				require.NotNil(t, resp)
 				assert.Empty(t, resp.Networks)
-				assert.Empty(t, resp.Experiments)
+				assert.Empty(t, resp.Features)
 			},
 		},
 	}
@@ -148,8 +148,8 @@ func TestConfigHandler_ServeHTTP(t *testing.T) {
 			}
 
 			cfg := &config.Config{
-				Networks:    tt.configNetworks,
-				Experiments: tt.experiments,
+				Networks: tt.configNetworks,
+				Features: tt.features,
 			}
 
 			logger := logrus.New()
@@ -313,25 +313,25 @@ func TestConfigHandler_buildNetworks(t *testing.T) {
 	}
 }
 
-func TestConfigHandler_buildExperiments(t *testing.T) {
+func TestConfigHandler_buildFeatures(t *testing.T) {
 	tests := []struct {
-		name        string
-		experiments map[string]config.ExperimentSettings
-		expected    int
+		name     string
+		features []config.FeatureSettings
+		expected int
 	}{
 		{
-			name: "experiments sorted alphabetically",
-			experiments: map[string]config.ExperimentSettings{
-				"zebra":  {Enabled: true},
-				"alpha":  {Enabled: false},
-				"middle": {Enabled: true},
+			name: "features sorted alphabetically by path",
+			features: []config.FeatureSettings{
+				{Path: "/zebra", DisabledNetworks: []string{}},
+				{Path: "/alpha", DisabledNetworks: []string{"mainnet"}},
+				{Path: "/middle", DisabledNetworks: []string{}},
 			},
 			expected: 3,
 		},
 		{
-			name:        "empty experiments",
-			experiments: map[string]config.ExperimentSettings{},
-			expected:    0,
+			name:     "empty features",
+			features: []config.FeatureSettings{},
+			expected: 0,
 		},
 	}
 
@@ -343,22 +343,22 @@ func TestConfigHandler_buildExperiments(t *testing.T) {
 			logger.SetOutput(io.Discard)
 
 			cfg := &config.Config{
-				Experiments: tt.experiments,
+				Features: tt.features,
 			}
 
 			handler := &ConfigHandler{
 				config: cfg,
 				logger: logger,
 			}
 
-			result := handler.buildExperiments(context.Background())
+			result := handler.buildFeatures(context.Background())
 
 			assert.Len(t, result, tt.expected)
 
 			// Verify sorting
 			for i := 1; i < len(result); i++ {
-				assert.True(t, result[i-1].Name < result[i].Name,
-					"experiments should be sorted alphabetically")
+				assert.True(t, result[i-1].Path < result[i].Path,
+					"features should be sorted alphabetically by path")
 			}
 		})
 	}

internal/config/config.go

@@ -15,14 +15,14 @@ import (
 
 // Config represents the complete application configuration.
 type Config struct {
-	Server        ServerConfig                  `yaml:"server"`
-	Redis         RedisConfig                   `yaml:"redis"`
-	Leader        LeaderConfig                  `yaml:"leader"`
-	Networks      []NetworkConfig               `yaml:"networks"`
-	Experiments   map[string]ExperimentSettings `yaml:"experiments"`
-	Cartographoor cartographoor.Config          `yaml:"cartographoor"`
-	Bounds        BoundsConfig                  `yaml:"bounds"`
-	RateLimiting  RateLimitingConfig            `yaml:"rate_limiting"`
+	Server        ServerConfig         `yaml:"server"`
+	Redis         RedisConfig          `yaml:"redis"`
+	Leader        LeaderConfig         `yaml:"leader"`
+	Networks      []NetworkConfig      `yaml:"networks"`
+	Features      []FeatureSettings    `yaml:"features"`
+	Cartographoor cartographoor.Config `yaml:"cartographoor"`
+	Bounds        BoundsConfig         `yaml:"bounds"`
+	RateLimiting  RateLimitingConfig   `yaml:"rate_limiting"`
 }
 
 // ServerConfig contains HTTP server settings.

internal/config/networks.go

@@ -23,10 +23,11 @@ type NetworkConfig struct {
 	GenesisDelay *int64 `yaml:"genesis_delay,omitempty"` // Optional: Genesis delay in seconds
 }
 
-// ExperimentSettings defines settings for a single experiment.
-type ExperimentSettings struct {
-	Enabled  bool     `yaml:"enabled"`
-	Networks []string `yaml:"networks,omitempty"` // Empty/omitted = all networks
+// FeatureSettings defines settings for a single feature.
+// Features are enabled by default for all networks unless explicitly disabled.
+type FeatureSettings struct {
+	Path             string   `yaml:"path"`                        // Feature path (e.g., "/ethereum/data-availability/das-custody")
+	DisabledNetworks []string `yaml:"disabled_networks,omitempty"` // Networks where this feature is disabled
 }
 
 // Validate validates a network configuration.