Refuse to start a mock_chain_validation build outside its reserve role

app/config_fuzz_test.go

@@ -347,8 +347,8 @@ func FuzzSCWriteMode(f *testing.F) {
 
 		cfg := parseSCConfigs(opts)
 
-		// enable-auto defaults to true and only an explicit key changes it.
-		effectiveAuto := true
+		// enable-auto takes its in-code default and only an explicit key changes it.
+		effectiveAuto := config.DefaultStateCommitConfig().WriteModeEnableAuto
 		if setAuto {
 			effectiveAuto = auto
 		}
@@ -507,14 +507,14 @@ func FuzzReadGenesisStreamImport(f *testing.F) {
 // TestParseSCConfigsAbsentBaseline records what an app.toml with no
 // [state-commit] section resolves to. It is not the in-code default: the two
 // unguarded reads clobber Enable to false and Directory to "", and the write mode
-// resolves to auto because enable-auto defaults to true. The Enable clobber is the
+// follows whatever enable-auto defaults to on this build. The Enable clobber is the
 // reason a node whose app.toml predates the section refuses to boot — SetupSeiDB
 // panics on !Enable rather than falling back.
 func TestParseSCConfigsAbsentBaseline(t *testing.T) {
 	want := config.DefaultStateCommitConfig()
 	want.Enable = false // unguarded read of an absent key
 	want.Directory = "" // unguarded read of an absent key
-	want.WriteMode = sctypes.Auto
+	want.WriteMode = wantAbsentAutoWriteMode
 	want.HashLogger.Version = version.Version // stamped from the build, not from config
 
 	got := parseSCConfigs(configtest.AppOpts{})
@@ -631,7 +631,7 @@ func TestKeyNamesMatchTheRecordedNames(t *testing.T) {
 // this package and sei-cosmos/server/config, and regenerating only one leaves the other red, so
 // regenerate both and read both diffs.
 func TestDefaultsMatchTheRecordedValues(t *testing.T) {
-	configtest.CheckDefaults(t, "state-commit", config.DefaultStateCommitConfig())
+	configtest.CheckDefaults(t, stateCommitRecord, config.DefaultStateCommitConfig())
 	configtest.CheckDefaults(t, "state-store", config.DefaultStateStoreConfig())
 	configtest.CheckDefaults(t, "light_invariance", DefaultLightInvarianceConfig)
 	configtest.CheckDefaults(t, "genesis", DefaultGenesisConfig)

app/config_register_agreement_test.go

@@ -22,7 +22,7 @@ var whatANodeRunsToday = map[string]string{
 	FlagSSPruneInterval:     "0",
 	FlagSSImportNumWorkers:  "0",
 	FlagSCEnable:            "false",
-	FlagSCWriteMode:         "auto",
+	FlagSCWriteMode:         scWriteModeANodeRuns,
 }
 
 // whyItMatters says what a node gets today, for the keys where that is worth stating.
@@ -42,15 +42,18 @@ var whyItMatters = map[string]string{
 // Per mode because the section answers per mode for two of these settings and the reader does not answer
 // per mode at all. An archive node declares the retention the reader also produces, so that key agrees for
 // archive and disagrees everywhere else; the store toggle is the reverse.
+//
+// Every entry ends in scWriteModeDivergence, which holds sc-write-mode on builds where the two sides
+// disagree and is empty on the one build where they do not.
 var theDivergences = map[registry.Mode][]string{
-	registry.ModeValidator: {FlagSSBackend, FlagSSAsyncWriterBuffer, FlagSSKeepRecent,
-		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable, FlagSCWriteMode},
-	registry.ModeSeed: {FlagSSBackend, FlagSSAsyncWriterBuffer, FlagSSKeepRecent,
-		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable, FlagSCWriteMode},
-	registry.ModeFull: {FlagSSEnable, FlagSSBackend, FlagSSAsyncWriterBuffer, FlagSSKeepRecent,
-		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable, FlagSCWriteMode},
-	registry.ModeArchive: {FlagSSEnable, FlagSSBackend, FlagSSAsyncWriterBuffer,
-		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable, FlagSCWriteMode},
+	registry.ModeValidator: append([]string{FlagSSBackend, FlagSSAsyncWriterBuffer, FlagSSKeepRecent,
+		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable}, scWriteModeDivergence...),
+	registry.ModeSeed: append([]string{FlagSSBackend, FlagSSAsyncWriterBuffer, FlagSSKeepRecent,
+		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable}, scWriteModeDivergence...),
+	registry.ModeFull: append([]string{FlagSSEnable, FlagSSBackend, FlagSSAsyncWriterBuffer, FlagSSKeepRecent,
+		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable}, scWriteModeDivergence...),
+	registry.ModeArchive: append([]string{FlagSSEnable, FlagSSBackend, FlagSSAsyncWriterBuffer,
+		FlagSSPruneInterval, FlagSSImportNumWorkers, FlagSCEnable}, scWriteModeDivergence...),
 }
 
 // readerValues is what each section's reader produces for a file carrying no keys at all.

app/seidb_test.go

@@ -76,10 +76,10 @@ func TestNewDefaultConfig(t *testing.T) {
 	ssConfig := parseSSConfigs(appOpts)
 	receiptConfig, err := config.ReadReceiptConfig(appOpts)
 	assert.NoError(t, err)
-	// WriteModeEnableAuto defaults to true, so parseSCConfigs resolves the effective
-	// WriteMode to auto, overriding the fixed-fallback default (memiavl_only).
+	// parseSCConfigs resolves the effective WriteMode through WriteModeEnableAuto,
+	// so it is the one field that need not equal the fixed-fallback default.
 	expectedSC := config.DefaultStateCommitConfig()
-	expectedSC.WriteMode = sctypes.Auto
+	expectedSC.WriteMode = wantAbsentAutoWriteMode
 	// parseSCConfigs is a raw parse and does not align FlatKV with memIAVL (that
 	// happens in composite.NewCompositeCommitStore), so the parsed config matches
 	// the in-code defaults verbatim apart from the resolved write mode.
@@ -169,7 +169,7 @@ func TestParseSCConfigs_LegacyCosmosOnlyWriteMode(t *testing.T) {
 		FlagSCEnable:    true,
 		FlagSCWriteMode: "cosmos_only",
 	})
-	assert.Equal(t, sctypes.Auto, scConfig.WriteMode)
+	assert.Equal(t, wantAbsentAutoWriteMode, scConfig.WriteMode)
 
 	scConfig = parseSCConfigs(mapAppOpts{
 		FlagSCEnable:              true,

app/testdata/state-commit.reserve.golden

@@ -0,0 +1,71 @@
+Enable = bool(true)
+Directory = string("")
+AsyncCommitBuffer = int(0)
+WriteMode = types.WriteMode("memiavl_only")
+WriteModeEnableAuto = bool(false)
+MemIAVLConfig.AsyncCommitBuffer = int(100)
+MemIAVLConfig.SnapshotKeepRecent = uint32(1)
+MemIAVLConfig.SnapshotInterval = uint32(10000)
+MemIAVLConfig.SnapshotMinTimeInterval = uint32(3600)
+MemIAVLConfig.SnapshotWriterLimit = int(4)
+MemIAVLConfig.SnapshotPrefetchThreshold = float64(0.8)
+MemIAVLConfig.SnapshotWriteRateMBps = int(100)
+FlatKVConfig.DataDir = string("")
+FlatKVConfig.Fsync = bool(false)
+FlatKVConfig.AsyncWriteBuffer = int(0)
+FlatKVConfig.SnapshotInterval = uint32(10000)
+FlatKVConfig.SnapshotKeepRecent = uint32(1)
+FlatKVConfig.ExternalPruning = bool(false)
+FlatKVConfig.EnablePebbleMetrics = bool(true)
+FlatKVConfig.EnableReadWriteMetrics = bool(false)
+FlatKVConfig.AccountDBConfig.DataDir = string("")
+FlatKVConfig.AccountDBConfig.EnableMetrics = bool(true)
+FlatKVConfig.AccountDBConfig.EnableReadWriteMetrics = bool(false)
+FlatKVConfig.AccountDBConfig.MetricsScrapeInterval = time.Duration(10s)
+FlatKVConfig.AccountCacheConfig.ShardCount = uint64(8)
+FlatKVConfig.AccountCacheConfig.MaxSize = uint64(1073741824)
+FlatKVConfig.AccountCacheConfig.EstimatedOverheadPerEntry = uint64(250)
+FlatKVConfig.AccountCacheConfig.MetricsName = string("")
+FlatKVConfig.AccountCacheConfig.MetricsScrapeInterval = time.Duration(0s)
+FlatKVConfig.CodeDBConfig.DataDir = string("")
+FlatKVConfig.CodeDBConfig.EnableMetrics = bool(true)
+FlatKVConfig.CodeDBConfig.EnableReadWriteMetrics = bool(false)
+FlatKVConfig.CodeDBConfig.MetricsScrapeInterval = time.Duration(10s)
+FlatKVConfig.CodeCacheConfig.ShardCount = uint64(8)
+FlatKVConfig.CodeCacheConfig.MaxSize = uint64(536870912)
+FlatKVConfig.CodeCacheConfig.EstimatedOverheadPerEntry = uint64(250)
+FlatKVConfig.CodeCacheConfig.MetricsName = string("")
+FlatKVConfig.CodeCacheConfig.MetricsScrapeInterval = time.Duration(0s)
+FlatKVConfig.StorageDBConfig.DataDir = string("")
+FlatKVConfig.StorageDBConfig.EnableMetrics = bool(true)
+FlatKVConfig.StorageDBConfig.EnableReadWriteMetrics = bool(false)
+FlatKVConfig.StorageDBConfig.MetricsScrapeInterval = time.Duration(10s)
+FlatKVConfig.StorageCacheConfig.ShardCount = uint64(8)
+FlatKVConfig.StorageCacheConfig.MaxSize = uint64(4294967296)
+FlatKVConfig.StorageCacheConfig.EstimatedOverheadPerEntry = uint64(250)
+FlatKVConfig.StorageCacheConfig.MetricsName = string("")
+FlatKVConfig.StorageCacheConfig.MetricsScrapeInterval = time.Duration(0s)
+FlatKVConfig.MiscDBConfig.DataDir = string("")
+FlatKVConfig.MiscDBConfig.EnableMetrics = bool(true)
+FlatKVConfig.MiscDBConfig.EnableReadWriteMetrics = bool(false)
+FlatKVConfig.MiscDBConfig.MetricsScrapeInterval = time.Duration(10s)
+FlatKVConfig.MiscCacheConfig.ShardCount = uint64(8)
+FlatKVConfig.MiscCacheConfig.MaxSize = uint64(536870912)
+FlatKVConfig.MiscCacheConfig.EstimatedOverheadPerEntry = uint64(250)
+FlatKVConfig.MiscCacheConfig.MetricsName = string("")
+FlatKVConfig.MiscCacheConfig.MetricsScrapeInterval = time.Duration(0s)
+FlatKVConfig.ReaderThreadsPerCore = float64(2)
+FlatKVConfig.ReaderConstantThreadCount = int(0)
+FlatKVConfig.ReaderPoolQueueSize = int(1024)
+FlatKVConfig.MiscPoolThreadsPerCore = float64(4)
+FlatKVConfig.MiscConstantThreadCount = int(0)
+FlatKVConfig.LtHashThreadsPerCore = float64(1)
+HistoricalProofMaxInFlight = int(1)
+HistoricalProofRateLimit = float64(1)
+HistoricalProofBurst = int(1)
+HashLogger.Enable = bool(true)
+HashLogger.Directory = string("")
+HashLogger.BlocksToRetain = uint(0)
+HashLogger.TargetFileSize = uint(16777216)
+HashLogger.MaxDiskSize = uint(17179869184)
+HashLogger.Version = string("")

app/write_mode_default_test.go

@@ -0,0 +1,30 @@
+//go:build !mock_chain_validation
+
+package app
+
+import (
+	sctypes "github.com/sei-protocol/sei-chain/sei-db/state_db/sc/types"
+)
+
+// The four values below are everything in this package's configuration records
+// that moves with sc-write-mode-enable-auto's in-code default. The reserve build
+// declares that key false where this one declares it true, so it carries a
+// write_mode_mock_chain_validation_test.go stating each of these the other way.
+
+// stateCommitRecord names this build's [state-commit] defaults record. The two
+// builds keep separate records because a shared one would be rewritten by
+// whichever build regenerated it last, losing the value the reviewer needed.
+const stateCommitRecord = "state-commit"
+
+// wantAbsentAutoWriteMode is the mode parseSCConfigs resolves memiavl_only to
+// when app.toml carries no sc-write-mode-enable-auto key.
+const wantAbsentAutoWriteMode = sctypes.Auto
+
+// scWriteModeDivergence is the tail of every theDivergences entry. sc-write-mode
+// belongs on those lists here, because the section declares memiavl_only and a
+// node missing the key runs auto instead.
+var scWriteModeDivergence = []string{FlagSCWriteMode}
+
+// scWriteModeANodeRuns is what sc-write-mode resolves to for a file carrying no
+// keys at all.
+const scWriteModeANodeRuns = "auto"

app/write_mode_mock_chain_validation_test.go

@@ -0,0 +1,22 @@
+//go:build mock_chain_validation
+
+package app
+
+import (
+	sctypes "github.com/sei-protocol/sei-chain/sei-db/state_db/sc/types"
+)
+
+// See write_mode_default_test.go for what these four values are and why each
+// build states them separately. This build declares sc-write-mode-enable-auto
+// false, so an explicit sc-write-mode is honored rather than replaced by auto.
+
+const stateCommitRecord = "state-commit.reserve"
+
+const wantAbsentAutoWriteMode = sctypes.MemiavlOnly
+
+// scWriteModeDivergence is empty here. The section declares memiavl_only and a
+// node missing the key runs memiavl_only, so this is the one build on which
+// sc-write-mode is not a setting whose declared and running values disagree.
+var scWriteModeDivergence []string
+
+const scWriteModeANodeRuns = "memiavl_only"

sei-cosmos/server/config/config_fuzz_test.go

@@ -224,8 +224,8 @@ func FuzzGetConfigGRPCDurationClamps(f *testing.F) {
 // FuzzGetConfigWriteMode pins GetConfig's own copy of the write-mode resolution.
 //
 // The rules match app/seidb.go — always parse, then let sc-write-mode-enable-auto
-// (default true, flipped only by an explicit key) decide whether the parsed mode is
-// honored — but the mechanism differs: GetConfig returns an error where seidb.go
+// (the in-code default, flipped only by an explicit key) decide whether the parsed
+// mode is honored — but the mechanism differs: GetConfig returns an error where seidb.go
 // panics. Both parsers must agree on the resolved mode for a node's store choice
 // and its reported config to describe the same thing, so the agreement is asserted
 // against the shared helpers rather than restated.
@@ -261,7 +261,7 @@ func FuzzGetConfigWriteMode(f *testing.F) {
 			t.Fatalf("sc-write-mode = %q must parse, got %v", mode, err)
 		}
 
-		effectiveAuto := true
+		effectiveAuto := config.DefaultStateCommitConfig().WriteModeEnableAuto
 		if setAuto {
 			effectiveAuto = auto
 		}
@@ -743,7 +743,7 @@ func TestDefaultsMatchTheRecordedValues(t *testing.T) {
 	// the other leaves that other one red.
 	configtest.CheckDefaults(t, "state-sync", DefaultConfig().StateSync)
 
-	configtest.CheckDefaults(t, "server_config", DefaultConfig(),
+	configtest.CheckDefaults(t, serverConfigRecord, DefaultConfig(),
 		configtest.DerivedDefault{
 			Path: "ConcurrencyWorkers", Want: max(10, min(runtime.NumCPU()*2, 128)),
 			Why: "max(10, min(runtime.NumCPU()*2, 128))",

sei-cosmos/server/config/config_test.go

@@ -640,88 +640,9 @@ func TestGetConfigRejectsInvalidWriteMode(t *testing.T) {
 	require.Contains(t, err.Error(), "bogus_mode")
 }
 
-// TestGetConfigLegacyMemiavlOnlyResolvesToAuto guards the existing-fleet
-// upgrade path: a config written by an older binary carries an explicit
-// sc-write-mode = "memiavl_only" but no sc-write-mode-enable-auto key. The absent
-// key must default to true so the node resolves to auto and can follow a
-// governance-driven migration without any app.toml edit.
-func TestGetConfigLegacyMemiavlOnlyResolvesToAuto(t *testing.T) {
-	v := viper.New()
-
-	v.Set("minimum-gas-prices", DefaultMinGasPrices)
-	v.Set("telemetry.global-labels", []interface{}{})
-	v.Set("state-commit.sc-write-mode", "memiavl_only")
-
-	cfg, err := GetConfig(v)
-	require.NoError(t, err)
-	require.True(t, cfg.StateCommit.WriteModeEnableAuto)
-	require.Equal(t, sctypes.Auto, cfg.StateCommit.WriteMode,
-		"absent sc-write-mode-enable-auto must default to true and override an explicit memiavl_only")
-}
-
-func TestGetConfigLegacyCosmosOnlyResolvesToAuto(t *testing.T) {
-	v := viper.New()
-
-	v.Set("minimum-gas-prices", DefaultMinGasPrices)
-	v.Set("telemetry.global-labels", []interface{}{})
-	v.Set("state-commit.sc-write-mode", "cosmos_only")
-
-	cfg, err := GetConfig(v)
-	require.NoError(t, err)
-	require.True(t, cfg.StateCommit.WriteModeEnableAuto)
-	require.Equal(t, sctypes.Auto, cfg.StateCommit.WriteMode,
-		"v6.4/v6.5 app.toml files with cosmos_only must parse before auto mode is applied")
-}
-
-// TestGetConfigPinnedModeRequiresAutoDisabled verifies that an explicit
-// sc-write-mode is only honored when sc-write-mode-enable-auto = false. With auto
-// enabled (the default), the explicit mode is ignored and the node runs in auto.
-func TestGetConfigPinnedModeRequiresAutoDisabled(t *testing.T) {
-	for _, mode := range []sctypes.WriteMode{
-		sctypes.FlatKVOnly,
-		sctypes.EVMMigrated,
-		sctypes.TestOnlyDualWrite,
-	} {
-		t.Run(string(mode)+"/auto-disabled-pins", func(t *testing.T) {
-			v := viper.New()
-			v.Set("minimum-gas-prices", DefaultMinGasPrices)
-			v.Set("telemetry.global-labels", []interface{}{})
-			v.Set("state-commit.sc-write-mode-enable-auto", false)
-			v.Set("state-commit.sc-write-mode", string(mode))
-
-			cfg, err := GetConfig(v)
-			require.NoError(t, err)
-			require.False(t, cfg.StateCommit.WriteModeEnableAuto)
-			require.Equal(t, mode, cfg.StateCommit.WriteMode,
-				"with auto disabled the explicit mode must be honored as a pin")
-		})
-
-		t.Run(string(mode)+"/auto-enabled-overrides", func(t *testing.T) {
-			v := viper.New()
-			v.Set("minimum-gas-prices", DefaultMinGasPrices)
-			v.Set("telemetry.global-labels", []interface{}{})
-			v.Set("state-commit.sc-write-mode", string(mode))
-
-			cfg, err := GetConfig(v)
-			require.NoError(t, err)
-			require.True(t, cfg.StateCommit.WriteModeEnableAuto)
-			require.Equal(t, sctypes.Auto, cfg.StateCommit.WriteMode,
-				"with auto enabled (default) the explicit mode must be ignored in favor of auto")
-		})
-	}
-}
-
-func TestGetConfigEmptyWriteModeUsesDefault(t *testing.T) {
-	v := viper.New()
-
-	v.Set("minimum-gas-prices", DefaultMinGasPrices)
-	v.Set("telemetry.global-labels", []interface{}{})
-
-	cfg, err := GetConfig(v)
-	require.NoError(t, err)
-	require.Equal(t, sctypes.Auto, cfg.StateCommit.WriteMode,
-		"unset sc-write-mode must fall back to the in-code default")
-}
+// The write-mode resolution records live in write_mode_default_test.go and its
+// mock_chain_validation counterpart: the reserve build defaults
+// sc-write-mode-enable-auto the other way, so every resolution differs by build.
 
 func TestGetConfigStateStore(t *testing.T) {
 	v := viper.New()
@@ -758,17 +679,6 @@ func TestGetConfigStateStore(t *testing.T) {
 	require.True(t, cfg.StateStore.SeparateEVMSubDBs)
 }
 
-func TestDefaultStateCommitConfig(t *testing.T) {
-	cfg := DefaultConfig()
-
-	require.True(t, cfg.StateCommit.Enable)
-	require.Empty(t, cfg.StateCommit.Directory)
-	// WriteMode is the fixed fallback (memiavl_only); WriteModeEnableAuto
-	// defaults true, so the effective default after resolution is auto.
-	require.Equal(t, sctypes.MemiavlOnly, cfg.StateCommit.WriteMode)
-	require.True(t, cfg.StateCommit.WriteModeEnableAuto)
-}
-
 func TestDefaultStateStoreConfig(t *testing.T) {
 	cfg := DefaultConfig()