Merge pull request #51 from sei-protocol/feat/sc-write-mode-enable-auto

feat: add storage.state_commit.write_mode_enable_auto

Author: blindchaser

config.go

@@ -333,6 +333,14 @@ type StateCommitConfig struct {
 	WriteMode         WriteMode `toml:"write_mode"`
 	ReadMode          ReadMode  `toml:"read_mode"`
 
+	// WriteModeEnableAuto controls whether the binary derives its write mode
+	// from committed migration state instead of honoring WriteMode. Nil leaves
+	// the key out of the rendered app.toml, which the binary reads as enabled.
+	// Set it to false to pin a node to its explicit WriteMode; such a node does
+	// not follow a governance-driven migration and diverges once the chain
+	// migrates, which is what a reserve node is for.
+	WriteModeEnableAuto *bool `toml:"write_mode_enable_auto"`
+
 	MemIAVL MemIAVLConfig `toml:"memiavl"`
 }
 

config_test.go

@@ -1,11 +1,14 @@
 package seiconfig
 
 import (
+	"bytes"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/BurntSushi/toml"
 )
 
 const testRPCAddr = "tcp://0.0.0.0:26657"
@@ -445,6 +448,85 @@ func TestApplyOverrides_Bool(t *testing.T) {
 	}
 }
 
+// TestWriteModeEnableAuto_Tristate covers the three states a reserve node
+// depends on: absent so the binary's default applies, explicitly false to pin
+// the node to its own write mode, and explicitly true.
+func TestWriteModeEnableAuto_Tristate(t *testing.T) {
+	encode := func(t *testing.T, cfg *SeiConfig) string {
+		t.Helper()
+		var buf bytes.Buffer
+		if err := toml.NewEncoder(&buf).Encode(cfg.toLegacyApp()); err != nil {
+			t.Fatalf("encoding app.toml: %v", err)
+		}
+		return buf.String()
+	}
+
+	t.Run("unset omits the key", func(t *testing.T) {
+		cfg := Default()
+		if cfg.Storage.StateCommit.WriteModeEnableAuto != nil {
+			t.Fatal("default should leave WriteModeEnableAuto unset")
+		}
+		if got := encode(t, cfg); strings.Contains(got, "sc-write-mode-enable-auto") {
+			t.Error("unset value must not render the key, so the binary keeps its own default")
+		}
+	})
+
+	t.Run("override to false renders false", func(t *testing.T) {
+		cfg := Default()
+		if err := ApplyOverrides(cfg, map[string]string{
+			"storage.state_commit.write_mode_enable_auto": "false",
+		}); err != nil {
+			t.Fatalf("ApplyOverrides: %v", err)
+		}
+		got := cfg.Storage.StateCommit.WriteModeEnableAuto
+		if got == nil || *got {
+			t.Fatalf("WriteModeEnableAuto: got %v, want pointer to false", got)
+		}
+		if out := encode(t, cfg); !strings.Contains(out, "sc-write-mode-enable-auto = false") {
+			t.Error("an explicit false must render; omitempty on a pointer drops only nil")
+		}
+	})
+
+	t.Run("override to true renders true", func(t *testing.T) {
+		cfg := Default()
+		if err := ApplyOverrides(cfg, map[string]string{
+			"storage.state_commit.write_mode_enable_auto": "true",
+		}); err != nil {
+			t.Fatalf("ApplyOverrides: %v", err)
+		}
+		got := cfg.Storage.StateCommit.WriteModeEnableAuto
+		if got == nil || !*got {
+			t.Fatalf("WriteModeEnableAuto: got %v, want pointer to true", got)
+		}
+		if out := encode(t, cfg); !strings.Contains(out, "sc-write-mode-enable-auto = true") {
+			t.Error("an explicit true must render")
+		}
+	})
+}
+
+// TestWriteModeEnableAuto_RoundTrip checks that reading back a rendered
+// app.toml preserves the pin, so a re-render does not silently unpin the node.
+func TestWriteModeEnableAuto_RoundTrip(t *testing.T) {
+	for _, want := range []*bool{nil, boolPtr(false), boolPtr(true)} {
+		cfg := Default()
+		cfg.Storage.StateCommit.WriteModeEnableAuto = want
+
+		back := fromLegacy(cfg.toLegacyTendermint(), cfg.toLegacyApp())
+		got := back.Storage.StateCommit.WriteModeEnableAuto
+
+		switch {
+		case want == nil && got != nil:
+			t.Errorf("unset round-tripped to %v", *got)
+		case want != nil && got == nil:
+			t.Errorf("%v round-tripped to unset", *want)
+		case want != nil && got != nil && *want != *got:
+			t.Errorf("round-trip: got %v, want %v", *got, *want)
+		}
+	}
+}
+
+func boolPtr(b bool) *bool { return &b }
+
 func TestApplyOverrides_Uint(t *testing.T) {
 	cfg := Default()
 	if err := ApplyOverrides(cfg, map[string]string{

enrichments.go

@@ -219,6 +219,9 @@ func DefaultEnrichments() map[string][]FieldOption {
 		"storage.state_commit.write_mode": {
 			WithDescription("EVM write routing: cosmos_only, dual_write, split_write, evm_only."),
 		},
+		"storage.state_commit.write_mode_enable_auto": {
+			WithDescription("Derive the write mode from committed migration state instead of honoring write_mode. Unset means enabled. Set false to pin a node, which then does not follow a governance-driven migration."),
+		},
 		"storage.state_commit.read_mode": {
 			WithDescription("EVM read routing: cosmos_only, evm_first, split_read."),
 		},

legacy.go

@@ -261,6 +261,10 @@ type legacyStateCommit struct {
 	AsyncCommitBuffer int    `toml:"sc-async-commit-buffer"`
 	WriteMode         string `toml:"sc-write-mode,omitempty"`
 	ReadMode          string `toml:"sc-read-mode,omitempty"`
+	// omitempty on a pointer omits only nil, so an explicit false still
+	// renders. A bare bool could not express the pin: omitempty would drop
+	// false, and without omitempty every node would emit the key.
+	WriteModeEnableAuto *bool `toml:"sc-write-mode-enable-auto,omitempty"`
 
 	KeepRecent                uint32  `toml:"sc-keep-recent"`
 	SnapshotInterval          uint32  `toml:"sc-snapshot-interval"`
@@ -589,6 +593,7 @@ func (cfg *SeiConfig) toLegacyApp() legacyAppConfig {
 			AsyncCommitBuffer:         cfg.Storage.StateCommit.AsyncCommitBuffer,
 			WriteMode:                 string(cfg.Storage.StateCommit.WriteMode),
 			ReadMode:                  string(cfg.Storage.StateCommit.ReadMode),
+			WriteModeEnableAuto:       cfg.Storage.StateCommit.WriteModeEnableAuto,
 			KeepRecent:                cfg.Storage.StateCommit.MemIAVL.SnapshotKeepRecent,
 			SnapshotInterval:          cfg.Storage.StateCommit.MemIAVL.SnapshotInterval,
 			SnapshotMinTimeInterval:   cfg.Storage.StateCommit.MemIAVL.SnapshotMinTimeInterval,
@@ -849,11 +854,12 @@ func fromLegacy(tm legacyTendermintConfig, app legacyAppConfig) *SeiConfig {
 			CompactionInterval:  app.CompactionInterval,
 			IAVLDisableFastNode: app.IAVLDisableFastNode,
 			StateCommit: StateCommitConfig{
-				Enable:            app.StateCommit.Enable,
-				Directory:         app.StateCommit.Directory,
-				AsyncCommitBuffer: app.StateCommit.AsyncCommitBuffer,
-				WriteMode:         WriteMode(app.StateCommit.WriteMode),
-				ReadMode:          ReadMode(app.StateCommit.ReadMode),
+				Enable:              app.StateCommit.Enable,
+				Directory:           app.StateCommit.Directory,
+				AsyncCommitBuffer:   app.StateCommit.AsyncCommitBuffer,
+				WriteMode:           WriteMode(app.StateCommit.WriteMode),
+				ReadMode:            ReadMode(app.StateCommit.ReadMode),
+				WriteModeEnableAuto: app.StateCommit.WriteModeEnableAuto,
 				MemIAVL: MemIAVLConfig{
 					SnapshotKeepRecent:        app.StateCommit.KeepRecent,
 					SnapshotInterval:          app.StateCommit.SnapshotInterval,

resolve.go

@@ -119,6 +119,17 @@ func setFieldByPath(cfg *SeiConfig, path string, value string) error {
 }
 
 func setReflectValue(v reflect.Value, s string) error {
+	// A pointer field is the tri-state form: nil renders as an absent key, so
+	// the binary's own default applies. Allocate before setting, otherwise an
+	// override on such a field reaches the type switch as a pointer and is
+	// rejected as unsupported.
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			v.Set(reflect.New(v.Type().Elem()))
+		}
+		return setReflectValue(v.Elem(), s)
+	}
+
 	if v.Type() == reflect.TypeFor[Duration]() {
 		var d Duration
 		if err := d.UnmarshalText([]byte(s)); err != nil {