Add recovery history retention pruning

Co-authored-by: julienrbrt <29894366+julienrbrt@users.noreply.github.com>

Author: Copilot

apps/evm/cmd/rollback.go

@@ -73,6 +73,7 @@ func NewRollbackCmd() *cobra.Command {
 			if err != nil {
 				cmd.Printf("Warning: failed to create engine client, skipping EL rollback: %v\n", err)
 			} else {
+				engineClient.SetExecMetaRetention(nodeConfig.Node.StateHistoryRetention)
 				if err := engineClient.Rollback(goCtx, height); err != nil {
 					return fmt.Errorf("failed to rollback execution layer: %w", err)
 				}

apps/evm/cmd/run.go

@@ -69,6 +69,7 @@ var RunCmd = &cobra.Command{
 
 		// Attach logger to the EVM engine client if available
 		if ec, ok := executor.(*evm.EngineClient); ok {
+			ec.SetExecMetaRetention(nodeConfig.Node.StateHistoryRetention)
 			ec.SetLogger(logger.With().Str("module", "engine_client").Logger())
 		}
 

apps/evm/go.mod

@@ -222,3 +222,7 @@ replace (
 	google.golang.org/genproto/googleapis/api => google.golang.org/genproto/googleapis/api v0.0.0-20240213162025-012b6fc9bca9
 	google.golang.org/genproto/googleapis/rpc => google.golang.org/genproto/googleapis/rpc v0.0.0-20240213162025-012b6fc9bca9
 )
+
+replace github.com/evstack/ev-node => ../../
+
+replace github.com/evstack/ev-node/execution/evm => ../../execution/evm

execution/evm/execution.go

@@ -270,6 +270,15 @@ func (c *EngineClient) SetLogger(l zerolog.Logger) {
 	c.logger = l
 }
 
+// SetExecMetaRetention configures how many recent execution metadata entries are retained.
+// A value of 0 keeps all entries.
+func (c *EngineClient) SetExecMetaRetention(limit uint64) {
+	if c.store == nil {
+		return
+	}
+	c.store.SetExecMetaRetention(limit)
+}
+
 // InitChain initializes the blockchain with the given genesis parameters
 func (c *EngineClient) InitChain(ctx context.Context, genesisTime time.Time, initialHeight uint64, chainID string) ([]byte, error) {
 	if initialHeight != 1 {

execution/evm/store.go

@@ -85,14 +85,21 @@ func (em *ExecMeta) FromProto(other *pb.ExecMeta) error {
 // EVMStore wraps a ds.Batching datastore with a prefix for EVM execution data.
 // This keeps EVM-specific data isolated from other ev-node data.
 type EVMStore struct {
-	db ds.Batching
+	db                ds.Batching
+	execMetaRetention uint64
 }
 
 // NewEVMStore creates a new EVMStore wrapping the given datastore.
 func NewEVMStore(db ds.Batching) *EVMStore {
 	return &EVMStore{db: db}
 }
 
+// SetExecMetaRetention sets the number of recent exec meta entries to keep.
+// A value of 0 keeps all exec meta history.
+func (s *EVMStore) SetExecMetaRetention(limit uint64) {
+	s.execMetaRetention = limit
+}
+
 // execMetaKey returns the datastore key for ExecMeta at a given height.
 func execMetaKey(height uint64) ds.Key {
 	heightBytes := make([]byte, 8)
@@ -137,6 +144,13 @@ func (s *EVMStore) SaveExecMeta(ctx context.Context, meta *ExecMeta) error {
 		return fmt.Errorf("failed to save exec meta: %w", err)
 	}
 
+	if s.execMetaRetention > 0 && meta.Height > s.execMetaRetention {
+		pruneHeight := meta.Height - s.execMetaRetention
+		if err := s.db.Delete(ctx, execMetaKey(pruneHeight)); err != nil && !errors.Is(err, ds.ErrNotFound) {
+			return fmt.Errorf("failed to prune exec meta at height %d: %w", pruneHeight, err)
+		}
+	}
+
 	return nil
 }
 

execution/evm/store_test.go

@@ -0,0 +1,39 @@
+package evm
+
+import (
+	"context"
+	"testing"
+
+	ds "github.com/ipfs/go-datastore"
+	dssync "github.com/ipfs/go-datastore/sync"
+	"github.com/stretchr/testify/require"
+)
+
+func TestSaveExecMetaPrunesHistory(t *testing.T) {
+	t.Parallel()
+
+	store := NewEVMStore(dssync.MutexWrap(ds.NewMapDatastore()))
+	store.SetExecMetaRetention(2)
+
+	ctx := context.Background()
+	for height := uint64(1); height <= 3; height++ {
+		require.NoError(t, store.SaveExecMeta(ctx, &ExecMeta{
+			Height: height,
+			Stage:  ExecStageStarted,
+		}))
+	}
+
+	meta, err := store.GetExecMeta(ctx, 1)
+	require.NoError(t, err)
+	require.Nil(t, meta)
+
+	meta, err = store.GetExecMeta(ctx, 2)
+	require.NoError(t, err)
+	require.NotNil(t, meta)
+	require.Equal(t, uint64(2), meta.Height)
+
+	meta, err = store.GetExecMeta(ctx, 3)
+	require.NoError(t, err)
+	require.NotNil(t, meta)
+	require.Equal(t, uint64(3), meta.Height)
+}

node/full.go

@@ -83,6 +83,9 @@ func newFullNode(
 
 	mainKV := store.NewEvNodeKVStore(database)
 	baseStore := store.New(mainKV)
+	if defaultStore, ok := baseStore.(*store.DefaultStore); ok {
+		defaultStore.SetStateHistoryRetention(nodeConfig.Node.StateHistoryRetention)
+	}
 
 	// Wrap with cached store for LRU caching of headers and block data
 	cachedStore, err := store.NewCachedStore(baseStore)

node/light.go

@@ -50,6 +50,9 @@ func newLightNode(
 
 	componentLogger := logger.With().Str("component", "HeaderSyncService").Logger()
 	baseStore := store.New(database)
+	if defaultStore, ok := baseStore.(*store.DefaultStore); ok {
+		defaultStore.SetStateHistoryRetention(conf.Node.StateHistoryRetention)
+	}
 
 	// Wrap with cached store for LRU caching of headers
 	cachedStore, err := store.NewCachedStore(baseStore)

pkg/config/config.go

@@ -51,6 +51,8 @@ const (
 	FlagReadinessMaxBlocksBehind = FlagPrefixEvnode + "node.readiness_max_blocks_behind"
 	// FlagScrapeInterval is a flag for specifying the reaper scrape interval
 	FlagScrapeInterval = FlagPrefixEvnode + "node.scrape_interval"
+	// FlagStateHistoryRetention is a flag for specifying how much state/exec metadata history to keep
+	FlagStateHistoryRetention = FlagPrefixEvnode + "node.state_history_retention"
 	// FlagClearCache is a flag for clearing the cache
 	FlagClearCache = FlagPrefixEvnode + "clear_cache"
 
@@ -257,6 +259,7 @@ type NodeConfig struct {
 	LazyMode                 bool            `mapstructure:"lazy_mode" yaml:"lazy_mode" comment:"Enables lazy aggregation mode, where blocks are only produced when transactions are available or after LazyBlockTime. Optimizes resources by avoiding empty block creation during periods of inactivity."`
 	LazyBlockInterval        DurationWrapper `mapstructure:"lazy_block_interval" yaml:"lazy_block_interval" comment:"Maximum interval between blocks in lazy aggregation mode (LazyAggregator). Ensures blocks are produced periodically even without transactions to keep the chain active. Generally larger than BlockTime."`
 	ScrapeInterval           DurationWrapper `mapstructure:"scrape_interval" yaml:"scrape_interval" comment:"Interval at which the reaper polls the execution layer for new transactions. Lower values reduce transaction detection latency but increase RPC load. Examples: \"250ms\", \"500ms\", \"1s\"."`
+	StateHistoryRetention    uint64          `mapstructure:"state_history_retention" yaml:"state_history_retention" comment:"Number of recent heights to keep state and execution metadata for recovery (0 keeps all)."`
 
 	// Readiness / health configuration
 	ReadinessWindowSeconds   uint64 `mapstructure:"readiness_window_seconds" yaml:"readiness_window_seconds" comment:"Time window in seconds used to calculate ReadinessMaxBlocksBehind based on block time. Default: 15 seconds."`
@@ -436,6 +439,7 @@ func AddFlags(cmd *cobra.Command) {
 	cmd.Flags().Uint64(FlagReadinessWindowSeconds, def.Node.ReadinessWindowSeconds, "time window in seconds for calculating readiness threshold based on block time (default: 15s)")
 	cmd.Flags().Uint64(FlagReadinessMaxBlocksBehind, def.Node.ReadinessMaxBlocksBehind, "how many blocks behind best-known head the node can be and still be considered ready (0 = must be at head)")
 	cmd.Flags().Duration(FlagScrapeInterval, def.Node.ScrapeInterval.Duration, "interval at which the reaper polls the execution layer for new transactions")
+	cmd.Flags().Uint64(FlagStateHistoryRetention, def.Node.StateHistoryRetention, "number of recent heights to keep state and execution metadata for recovery (0 keeps all)")
 
 	// Data Availability configuration flags
 	cmd.Flags().String(FlagDAAddress, def.DA.Address, "DA address (host:port)")

pkg/config/config_test.go

@@ -33,6 +33,7 @@ func TestDefaultConfig(t *testing.T) {
 	assert.Equal(t, uint64(0), def.Node.MaxPendingHeadersAndData)
 	assert.Equal(t, false, def.Node.LazyMode)
 	assert.Equal(t, 60*time.Second, def.Node.LazyBlockInterval.Duration)
+	assert.Equal(t, uint64(5000), def.Node.StateHistoryRetention)
 	assert.Equal(t, "file", def.Signer.SignerType)
 	assert.Equal(t, "config", def.Signer.SignerPath)
 	assert.Equal(t, "127.0.0.1:7331", def.RPC.Address)
@@ -64,6 +65,7 @@ func TestAddFlags(t *testing.T) {
 	assertFlagValue(t, flags, FlagReadinessWindowSeconds, DefaultConfig().Node.ReadinessWindowSeconds)
 	assertFlagValue(t, flags, FlagReadinessMaxBlocksBehind, DefaultConfig().Node.ReadinessMaxBlocksBehind)
 	assertFlagValue(t, flags, FlagScrapeInterval, DefaultConfig().Node.ScrapeInterval)
+	assertFlagValue(t, flags, FlagStateHistoryRetention, DefaultConfig().Node.StateHistoryRetention)
 
 	// DA flags
 	assertFlagValue(t, flags, FlagDAAddress, DefaultConfig().DA.Address)
@@ -112,7 +114,7 @@ func TestAddFlags(t *testing.T) {
 	assertFlagValue(t, flags, FlagRPCEnableDAVisualization, DefaultConfig().RPC.EnableDAVisualization)
 
 	// Count the number of flags we're explicitly checking
-	expectedFlagCount := 63 // Update this number if you add more flag checks above
+	expectedFlagCount := 64 // Update this number if you add more flag checks above
 
 	// Get the actual number of flags (both regular and persistent)
 	actualFlagCount := 0