Add giga config and unify garbage collector logic

sei-db/common/utils/path.go

@@ -74,6 +74,13 @@ func GetReceiptStorePath(homePath string, backend string) string {
 	return filepath.Join(homePath, "data", "ledger", "receipt", backend)
 }
 
+// GetBlockStorePath returns the path for the ledger block store, which sits alongside the
+// receipt store under data/ledger. There is no legacy fallback: the block store has only
+// ever lived at this path.
+func GetBlockStorePath(homePath string) string {
+	return filepath.Join(homePath, "data", "ledger", "block")
+}
+
 func GetChangelogPath(dbPath string) string {
 	return filepath.Join(dbPath, "changelog")
 }

sei-db/common/utils/path_test.go

@@ -135,6 +135,14 @@ func TestGetReceiptStorePath_LegacyExists(t *testing.T) {
 	assert.Equal(t, legacy, got)
 }
 
+// --- GetBlockStorePath ---
+
+func TestGetBlockStorePath_NewNode(t *testing.T) {
+	home := t.TempDir()
+	got := GetBlockStorePath(home)
+	assert.Equal(t, filepath.Join(home, "data", "ledger", "block"), got)
+}
+
 // --- GetChangelogPath (unchanged, but verify) ---
 
 func TestGetChangelogPath(t *testing.T) {

sei-db/config/giga_config.go

@@ -0,0 +1,67 @@
+package config
+
+import (
+	"fmt"
+
+	"github.com/sei-protocol/sei-chain/sei-db/common/utils"
+	"github.com/sei-protocol/sei-chain/sei-db/ledger_db/block/littblock"
+	"github.com/sei-protocol/sei-chain/sei-db/management/gc"
+	flatkvConfig "github.com/sei-protocol/sei-chain/sei-db/state_db/sc/flatkv/config"
+)
+
+// GigaStorageConfig is an in-process composition of store configs for Giga storage.
+// It is intentionally not read from app.toml (no mapstructure tags, no TOML section):
+// callers build it via DefaultGigaStorageConfig. Nested knobs live on the store and
+// collector configs they already own (StateStoreConfig, ReceiptStoreConfig,
+// gc.StorageGarbageCollectorConfig) rather than being redeclared here — in particular
+// RollbackWindow has a single source of truth in
+// gc.DefaultStorageGarbageCollectorConfig; per-store extras live on each
+// PrunableStore via GetRetentionWindow.
+type GigaStorageConfig struct {
+	HomePath        string
+	FlatKVConfig    *flatkvConfig.Config
+	SSConfig        StateStoreConfig
+	ReceiptDBConfig ReceiptStoreConfig
+	BlockDBConfig   *littblock.LittBlockConfig
+	PruningConfig   *gc.StorageGarbageCollectorConfig
+}
+
+// DefaultGigaStorageConfig returns a GigaStorageConfig whose store directories match the
+// layout below, and whose pruning knobs are gc.DefaultStorageGarbageCollectorConfig():
+//
+//	data/state_commit/flatkv
+//	data/state_store/evm/{backend}   (sole SS; no Cosmos SS in Giga)
+//	data/ledger/receipt/{backend}
+//	data/ledger/block
+//
+// Giga opens SS via evm.NewEVMStateStore(dir, ssConfig) directly — not through
+// composite.NewCompositeStateStore — so the EVM path lives on EVMDBDirectory (the
+// argument callers pass as dir). DBDirectory and EVMSplit are left at their defaults:
+// they only matter for the composite path, which Giga does not use.
+//
+// Unlike the other Default*Config helpers in this package, this can fail: the block-store
+// default wraps littdb.DefaultConfig, which validates the directory path.
+func DefaultGigaStorageConfig(homePath string) (GigaStorageConfig, error) {
+	blockDBConfig, err := littblock.DefaultConfig(utils.GetBlockStorePath(homePath))
+	if err != nil {
+		return GigaStorageConfig{}, fmt.Errorf("failed to build block db config: %w", err)
+	}
+
+	flatKV := flatkvConfig.DefaultConfig()
+	flatKV.DataDir = utils.GetFlatKVPath(homePath)
+
+	ssConfig := DefaultStateStoreConfig()
+	ssConfig.EVMDBDirectory = utils.GetEVMStateStorePath(homePath, ssConfig.Backend)
+
+	receiptConfig := DefaultReceiptStoreConfig()
+	receiptConfig.DBDirectory = utils.GetReceiptStorePath(homePath, receiptConfig.Backend)
+
+	return GigaStorageConfig{
+		HomePath:        homePath,
+		FlatKVConfig:    flatKV,
+		SSConfig:        ssConfig,
+		ReceiptDBConfig: receiptConfig,
+		BlockDBConfig:   blockDBConfig,
+		PruningConfig:   gc.DefaultStorageGarbageCollectorConfig(),
+	}, nil
+}

sei-db/config/giga_config_test.go

@@ -0,0 +1,34 @@
+package config
+
+import (
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/sei-protocol/sei-chain/sei-db/common/utils"
+)
+
+// TestDefaultGigaStorageConfigDirectories pins Giga's EVM-only SS layout: the path
+// for evm.NewEVMStateStore lives on EVMDBDirectory. Giga does not use composite, so
+// DBDirectory stays empty and EVMSplit stays at its default.
+func TestDefaultGigaStorageConfigDirectories(t *testing.T) {
+	home := t.TempDir()
+	cfg, err := DefaultGigaStorageConfig(home)
+	require.NoError(t, err)
+
+	require.Equal(t, home, cfg.HomePath)
+	require.False(t, cfg.SSConfig.EVMSplit)
+	require.Empty(t, cfg.SSConfig.DBDirectory)
+	require.Equal(t, utils.GetEVMStateStorePath(home, cfg.SSConfig.Backend), cfg.SSConfig.EVMDBDirectory)
+
+	require.Equal(t, utils.GetFlatKVPath(home), cfg.FlatKVConfig.DataDir)
+	require.Equal(t, utils.GetReceiptStorePath(home, cfg.ReceiptDBConfig.Backend), cfg.ReceiptDBConfig.DBDirectory)
+	require.NotNil(t, cfg.BlockDBConfig.Litt)
+	require.Equal(t, []string{utils.GetBlockStorePath(home)}, cfg.BlockDBConfig.Litt.Paths)
+
+	require.Equal(t,
+		filepath.Join(home, "data", "state_store", "evm", cfg.SSConfig.Backend),
+		cfg.SSConfig.EVMDBDirectory,
+	)
+}

sei-db/management/gc/api.go

@@ -0,0 +1,64 @@
+package gc
+
+// InfiniteRetentionWindow is the conventional GetRetentionWindow value meaning "never
+// prune this store." Any negative value is treated the same: the store does not vote
+// and is never passed to PruneBelow.
+//
+// Note: elsewhere in this repo (KeepRecent / MinRetainBlocks) 0 often means "keep
+// forever." Here 0 means "no extra beyond the shared RollbackWindow," so infinite
+// retention needs a negative sentinel.
+const InfiniteRetentionWindow int64 = -1
+
+// PrunableStore is a store whose old data may be dropped by the StorageGarbageCollector.
+type PrunableStore interface {
+	// Name identifies the store (logging / errors). Duplicate names are allowed;
+	// the collector keys answers by index, not by name.
+	Name() string
+
+	// PruneBelow may drop data for all blocks below blockNumber.
+	// The store may perform the deletion asynchronously.
+	PruneBelow(blockNumber uint64) error
+
+	// GetRetentionWindow is how many extra blocks beyond the shared RollbackWindow
+	// this store needs to keep servable. Cut line (head = min non-zero GetLatestBlock):
+	//
+	//	retention < 0  → store ignored (cutLine treated as 0; conventionally -1)
+	//	retention >= 0  → cutLine = head - RollbackWindow - retention
+	//
+	// RollbackWindow is shared so every store stays consistent under rollback.
+	// Retention is optional history on top — kept so the store can still serve queries
+	// after a rollback that consumes the entire rollback window.
+	//
+	// Because the collector prunes every participating store to the *lowest*
+	// GetPruningBoundary, a large retention on one store effectively deepens pruning
+	// for the others (see StorageGarbageCollector). Read this as an input to that
+	// shared min, not as an independently applied per-store policy.
+	//
+	// Contract by store kind:
+	//   - Contiguous (blockDB, receiptDB, state WAL): -1 / 0 / positive as configured.
+	//   - SC: always 0 (only needs the shared rollback window for snapshots).
+	//   - SS: always 0 (SS prunes its own version history via KeepRecent; the collector
+	//     only drives SS snapshot pruning for the shared rollback window).
+	GetRetentionWindow() int64
+
+	// GetPruningBoundary returns the oldest block this store must keep to remain able to
+	// serve cutLine, or 0 to opt out of this cycle (not participate in calculating min prune height).
+	//
+	// Contiguous stores can restore to any height they hold → return cutLine.
+	//
+	// Snapshot stores can restore only at snapshot heights → return the newest completed
+	// snapshot ≤ cutLine, or the oldest completed snapshot if every snapshot is above
+	// cutLine (none can be dropped yet). No completed snapshot → 0.
+	//
+	// Assumption: snapshot creation finishes quickly enough that an in-flight write need
+	// not be reserved; modeling long-running snapshot writes is out of scope.
+	GetPruningBoundary(cutLine uint64) uint64
+
+	// GetLatestBlock returns the highest block this store has ingested.
+	//
+	// 0 means "nothing ingested yet" and is ignored when computing the global head, so a store
+	// still filling does not stall pruning for the rest of the fleet. It does not mean
+	// "disabled": a store disabled for this node is not instantiated and never reaches the
+	// collector. See StorageGarbageCollector for why skipping a 0 head is safe.
+	GetLatestBlock() (uint64, error)
+}