fix: warn and override non-CAT mempool type

cmd/celestia-appd/cmd/override_p2p_config.go

@@ -18,16 +18,20 @@ const (
 // their config.toml file. If the user has configured higher values, those are
 // preserved.
 func overrideP2PConfig(cmd *cobra.Command, logger log.Logger) error {
+	sctx := server.GetServerContextFromCmd(cmd)
+	cfg := sctx.Config
+
+	// Always override mempool type to CAT before checking bypass flag because
+	// non-CAT mempools are fundamentally unsupported and must not be bypassable.
+	overrideMempoolType(cfg, logger)
+
 	// Check if overrides should be bypassed
 	bypass, err := cmd.Flags().GetBool(bypassOverridesFlagKey)
 	if err == nil && bypass {
 		logger.Info("Bypassing config overrides due to flag")
 		return nil
 	}
 
-	sctx := server.GetServerContextFromCmd(cmd)
-	cfg := sctx.Config
-
 	// Get the default config to extract the minimum required values
 	defaultCfg := app.DefaultConsensusConfig()
 	minSendRate := defaultCfg.P2P.SendRate
@@ -65,15 +69,6 @@ func overrideMempoolConfig(cfg, defaultCfg *tmcfg.Config, logger log.Logger) {
 	const minTTLNumBlocks = int64(36)
 	const minMaxTxsBytes = int64(400 * mebibyte) // 400 MiB
 
-	// Force mempool type to CAT if it's not already set to CAT
-	if cfg.Mempool.Type != tmcfg.MempoolTypeCAT {
-		logger.Info("Overriding Mempool Type to CAT",
-			"configured", cfg.Mempool.Type,
-			"default", tmcfg.MempoolTypeCAT,
-		)
-		cfg.Mempool.Type = tmcfg.MempoolTypeCAT
-	}
-
 	// Override TTLNumBlocks if it's less than the minimum and not 0
 	// If it's 0, the user has explicitly disabled it, so we leave it alone
 	if cfg.Mempool.TTLNumBlocks > 0 && cfg.Mempool.TTLNumBlocks < minTTLNumBlocks {
@@ -120,3 +115,15 @@ func overrideMempoolConfig(cfg, defaultCfg *tmcfg.Config, logger log.Logger) {
 		cfg.Mempool.MaxTxsBytes = minMaxTxsBytes
 	}
 }
+
+// overrideMempoolType overrides the mempool type to CAT if it is set to
+// anything else. Non-CAT mempools are fundamentally unsupported.
+func overrideMempoolType(cfg *tmcfg.Config, logger log.Logger) {
+	if cfg.Mempool.Type != tmcfg.MempoolTypeCAT {
+		logger.Warn("Overriding unsupported mempool type to CAT",
+			"configured", cfg.Mempool.Type,
+			"required", tmcfg.MempoolTypeCAT,
+		)
+		cfg.Mempool.Type = tmcfg.MempoolTypeCAT
+	}
+}

cmd/celestia-appd/cmd/override_p2p_config_test.go

@@ -384,7 +384,7 @@ func TestOverrideP2PConfig_BypassFlag(t *testing.T) {
 	cfg.SetRoot(tempDir)
 	cfg.P2P.SendRate = 5 * mebibyte
 	cfg.P2P.RecvRate = 5 * mebibyte
-	cfg.Mempool.Type = tmcfg.MempoolTypeFlood
+	cfg.Mempool.Type = tmcfg.MempoolTypeCAT
 	cfg.Mempool.TTLNumBlocks = 10
 	cfg.Mempool.TTLDuration = 5 * time.Minute
 	cfg.Mempool.MaxGossipDelay = 60 * time.Second
@@ -428,8 +428,8 @@ func TestOverrideP2PConfig_BypassFlag(t *testing.T) {
 		"P2P SendRate should not be overridden when bypass flag is set")
 	require.Equal(t, int64(5*mebibyte), modifiedCfg.P2P.RecvRate,
 		"P2P RecvRate should not be overridden when bypass flag is set")
-	require.Equal(t, tmcfg.MempoolTypeFlood, modifiedCfg.Mempool.Type,
-		"Mempool Type should not be overridden when bypass flag is set")
+	require.Equal(t, tmcfg.MempoolTypeCAT, modifiedCfg.Mempool.Type,
+		"Mempool Type should be CAT")
 	require.Equal(t, int64(10), modifiedCfg.Mempool.TTLNumBlocks,
 		"Mempool TTLNumBlocks should not be overridden when bypass flag is set")
 	require.Equal(t, 5*time.Minute, modifiedCfg.Mempool.TTLDuration,
@@ -439,3 +439,93 @@ func TestOverrideP2PConfig_BypassFlag(t *testing.T) {
 	require.Equal(t, int64(100*mebibyte), modifiedCfg.Mempool.MaxTxsBytes,
 		"Mempool MaxTxsBytes should not be overridden when bypass flag is set")
 }
+
+// TestOverrideP2PConfig_OverridesNonCATMempool tests that overrideP2PConfig
+// overrides a non-CAT mempool type to CAT with a warning instead of erroring.
+func TestOverrideP2PConfig_OverridesNonCATMempool(t *testing.T) {
+	tempDir := t.TempDir()
+	configDir := filepath.Join(tempDir, "config")
+	require.NoError(t, os.MkdirAll(configDir, 0o755))
+
+	cfg := app.DefaultConsensusConfig()
+	cfg.SetRoot(tempDir)
+	cfg.Mempool.Type = tmcfg.MempoolTypeFlood
+
+	configPath := filepath.Join(configDir, "config.toml")
+	tmcfg.WriteConfigFile(configPath, cfg)
+
+	cmd := &cobra.Command{Use: "test"}
+	logger := log.NewNopLogger()
+
+	loadedCfg, err := loadCometBFTConfig(configPath, tempDir)
+	require.NoError(t, err)
+
+	sctx := server.NewDefaultContext()
+	sctx.Config = loadedCfg
+	sctx.Logger = logger
+
+	ctx := context.WithValue(context.Background(), server.ServerContextKey, sctx)
+	cmd.SetContext(ctx)
+
+	err = overrideP2PConfig(cmd, logger)
+	require.NoError(t, err)
+
+	modifiedCfg := server.GetServerContextFromCmd(cmd).Config
+	require.Equal(t, tmcfg.MempoolTypeCAT, modifiedCfg.Mempool.Type,
+		"Non-CAT mempool type should be overridden to CAT")
+}
+
+// TestOverrideP2PConfig_BypassFlagDoesNotBypassMempoolTypeOverride tests that
+// the bypass flag does not bypass the mempool type override.
+func TestOverrideP2PConfig_BypassFlagDoesNotBypassMempoolTypeOverride(t *testing.T) {
+	tempDir := t.TempDir()
+	configDir := filepath.Join(tempDir, "config")
+	require.NoError(t, os.MkdirAll(configDir, 0o755))
+
+	cfg := app.DefaultConsensusConfig()
+	cfg.SetRoot(tempDir)
+	cfg.Mempool.Type = tmcfg.MempoolTypeFlood
+
+	configPath := filepath.Join(configDir, "config.toml")
+	tmcfg.WriteConfigFile(configPath, cfg)
+
+	cmd := &cobra.Command{Use: "test"}
+	cmd.Flags().Bool(bypassOverridesFlagKey, false, "bypass all config overrides")
+	require.NoError(t, cmd.Flags().Set(bypassOverridesFlagKey, "true"))
+
+	logger := log.NewNopLogger()
+
+	loadedCfg, err := loadCometBFTConfig(configPath, tempDir)
+	require.NoError(t, err)
+
+	sctx := server.NewDefaultContext()
+	sctx.Config = loadedCfg
+	sctx.Logger = logger
+
+	ctx := context.WithValue(context.Background(), server.ServerContextKey, sctx)
+	cmd.SetContext(ctx)
+
+	err = overrideP2PConfig(cmd, logger)
+	require.NoError(t, err)
+
+	modifiedCfg := server.GetServerContextFromCmd(cmd).Config
+	require.Equal(t, tmcfg.MempoolTypeCAT, modifiedCfg.Mempool.Type,
+		"Mempool type override should not be bypassable")
+}
+
+// TestOverrideMempoolType tests the overrideMempoolType function directly.
+func TestOverrideMempoolType(t *testing.T) {
+	t.Run("no-op for CAT mempool", func(t *testing.T) {
+		cfg := app.DefaultConsensusConfig()
+		cfg.Mempool.Type = tmcfg.MempoolTypeCAT
+		overrideMempoolType(cfg, log.NewNopLogger())
+		require.Equal(t, tmcfg.MempoolTypeCAT, cfg.Mempool.Type)
+	})
+
+	t.Run("overrides flood mempool to CAT", func(t *testing.T) {
+		cfg := app.DefaultConsensusConfig()
+		cfg.Mempool.Type = tmcfg.MempoolTypeFlood
+		overrideMempoolType(cfg, log.NewNopLogger())
+		require.Equal(t, tmcfg.MempoolTypeCAT, cfg.Mempool.Type)
+	})
+}

docs/release-notes/release-notes.md

@@ -36,6 +36,10 @@ v7 enforces a minimum `min-retain-blocks` value of 3000. This ensures nodes reta
 - `1-2999`: automatically overridden to 3000 with a log warning
 - `>= 3000`: retain at least that many blocks
 
+##### Mempool Type
+
+The mempool `type` field has been removed from new `config.toml` files because celestia-app only supports the CAT mempool. If your existing `config.toml` still contains a mempool `type`, it will be ignored and overridden to `cat` at startup with a warning. You can safely remove the `type` line from the `[mempool]` section of your `config.toml`.
+
 ### State Machine Changes (v7.0.0)
 
 #### Blocked Module Account Addresses