feat: add StateRoot migration construct

.gitignore

@@ -32,6 +32,7 @@ node_modules
 chart_releases
 /snapshots/**/*.sql
 /snapshots/**/*.csv
-*.sql
-*.dump
+/*.sql
+/*.dump
 .env
+!/pkg/eigenState/stateMigrator/**/*.sql

cmd/database.go

@@ -12,6 +12,7 @@ import (
 	"github.com/Layr-Labs/sidecar/pkg/contractStore/postgresContractStore"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateManager"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateMigrator"
 	"github.com/Layr-Labs/sidecar/pkg/eventBus"
 	"github.com/Layr-Labs/sidecar/pkg/fetcher"
 	"github.com/Layr-Labs/sidecar/pkg/indexer"
@@ -87,7 +88,12 @@ var runDatabaseCmd = &cobra.Command{
 			log.Fatalln(err)
 		}
 
-		sm := stateManager.NewEigenStateManager(l, grm)
+		smig, err := stateMigrator.NewStateMigrator(grm, cfg, l)
+		if err != nil {
+			l.Sugar().Fatalw("Failed to create state migrator", zap.Error(err))
+		}
+
+		sm := stateManager.NewEigenStateManager(smig, l, grm)
 		msm := metaStateManager.NewMetaStateManager(grm, l, cfg)
 
 		if err := eigenState.LoadEigenStateModels(sm, grm, l, cfg); err != nil {

cmd/debugger/main.go

@@ -9,6 +9,7 @@ import (
 	"github.com/Layr-Labs/sidecar/pkg/contractManager"
 	"github.com/Layr-Labs/sidecar/pkg/contractStore/postgresContractStore"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateMigrator"
 	"github.com/Layr-Labs/sidecar/pkg/eventBus"
 	"github.com/Layr-Labs/sidecar/pkg/fetcher"
 	"github.com/Layr-Labs/sidecar/pkg/indexer"
@@ -83,7 +84,12 @@ func main() {
 		log.Fatalln(err)
 	}
 
-	sm := stateManager.NewEigenStateManager(l, grm)
+	smig, err := stateMigrator.NewStateMigrator(grm, cfg, l)
+	if err != nil {
+		l.Sugar().Fatalw("Failed to create state migrator", zap.Error(err))
+	}
+
+	sm := stateManager.NewEigenStateManager(smig, l, grm)
 	msm := metaStateManager.NewMetaStateManager(grm, l, cfg)
 
 	if err := eigenState.LoadEigenStateModels(sm, grm, l, cfg); err != nil {

cmd/operatorRestakedStrategies.go

@@ -12,6 +12,7 @@ import (
 	"github.com/Layr-Labs/sidecar/pkg/contractStore/postgresContractStore"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateManager"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateMigrator"
 	"github.com/Layr-Labs/sidecar/pkg/fetcher"
 	"github.com/Layr-Labs/sidecar/pkg/indexer"
 	"github.com/Layr-Labs/sidecar/pkg/postgres"
@@ -75,7 +76,12 @@ var runOperatorRestakedStrategiesCmd = &cobra.Command{
 			log.Fatalln(err)
 		}
 
-		sm := stateManager.NewEigenStateManager(l, grm)
+		smig, err := stateMigrator.NewStateMigrator(grm, cfg, l)
+		if err != nil {
+			l.Sugar().Fatalw("Failed to create state migrator", zap.Error(err))
+		}
+
+		sm := stateManager.NewEigenStateManager(smig, l, grm)
 
 		if err := eigenState.LoadEigenStateModels(sm, grm, l, cfg); err != nil {
 			l.Sugar().Fatalw("Failed to load eigen state models", zap.Error(err))

cmd/rpc.go

@@ -7,6 +7,7 @@ import (
 	"github.com/Layr-Labs/sidecar/internal/version"
 	sidecarClient "github.com/Layr-Labs/sidecar/pkg/clients/sidecar"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateMigrator"
 	"github.com/Layr-Labs/sidecar/pkg/eventBus"
 	"github.com/Layr-Labs/sidecar/pkg/postgres"
 	"github.com/Layr-Labs/sidecar/pkg/proofs"
@@ -82,7 +83,12 @@ var rpcCmd = &cobra.Command{
 			log.Fatalln(err)
 		}
 
-		sm := stateManager.NewEigenStateManager(l, grm)
+		smig, err := stateMigrator.NewStateMigrator(grm, cfg, l)
+		if err != nil {
+			l.Sugar().Fatalw("Failed to create state migrator", zap.Error(err))
+		}
+
+		sm := stateManager.NewEigenStateManager(smig, l, grm)
 
 		if err := eigenState.LoadEigenStateModels(sm, grm, l, cfg); err != nil {
 			l.Sugar().Fatalw("Failed to load eigen state models", zap.Error(err))

cmd/run.go

@@ -11,6 +11,7 @@ import (
 	"github.com/Layr-Labs/sidecar/pkg/contractManager"
 	"github.com/Layr-Labs/sidecar/pkg/contractStore/postgresContractStore"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/stateMigrator"
 	"github.com/Layr-Labs/sidecar/pkg/eventBus"
 	"github.com/Layr-Labs/sidecar/pkg/fetcher"
 	"github.com/Layr-Labs/sidecar/pkg/indexer"
@@ -102,7 +103,12 @@ var runCmd = &cobra.Command{
 			log.Fatalln(err)
 		}
 
-		sm := stateManager.NewEigenStateManager(l, grm)
+		smig, err := stateMigrator.NewStateMigrator(grm, cfg, l)
+		if err != nil {
+			l.Sugar().Fatalw("Failed to create state migrator", zap.Error(err))
+		}
+
+		sm := stateManager.NewEigenStateManager(smig, l, grm)
 		msm := metaStateManager.NewMetaStateManager(grm, l, cfg)
 
 		if err := eigenState.LoadEigenStateModels(sm, grm, l, cfg); err != nil {

internal/config/config.go

@@ -288,36 +288,82 @@ func (c *Config) GetGenesisBlockNumber() uint64 {
 	}
 }
 
-type ForkMap map[ForkName]string
+type Fork struct {
+	Date        string
+	BlockNumber uint64
+}
+
+type ForkMap map[ForkName]Fork
 
 func (c *Config) GetRewardsSqlForkDates() (ForkMap, error) {
 	switch c.Chain {
 	case Chain_Preprod:
 		return ForkMap{
-			RewardsFork_Amazon:      "1970-01-01", // Amazon hard fork was never on preprod as we backfilled
-			RewardsFork_Nile:        "2024-08-14", // Last calculation end timestamp was 8-13: https://holesky.etherscan.io/tx/0xb5a6855e88c79312b7c0e1c9f59ae9890b97f157ea27e69e4f0fadada4712b64#eventlog
-			RewardsFork_Panama:      "2024-10-01",
-			RewardsFork_Arno:        "2024-12-11",
-			RewardsFork_Trinity:     "2025-01-09",
-			RewardsFork_Mississippi: "2025-02-03",
+			RewardsFork_Amazon: Fork{
+				Date: "1970-01-01",
+			},
+			RewardsFork_Nile: Fork{
+				Date: "2024-08-14", // Last calculation end timestamp was 8-13: https://holesky.etherscan.io/tx/0xb5a6855e88c79312b7c0e1c9f59ae9890b97f157ea27e69e4f0fadada4712b64#eventlog},
+			},
+			RewardsFork_Panama: Fork{
+				Date: "2024-10-01",
+			},
+			RewardsFork_Arno: Fork{
+				Date: "2024-12-11",
+			},
+			RewardsFork_Trinity: Fork{
+				Date: "2025-01-09",
+			},
+			RewardsFork_Mississippi: Fork{
+				Date:        "2025-02-04",
+				BlockNumber: 3287006,
+			},
 		}, nil
 	case Chain_Holesky:
 		return ForkMap{
-			RewardsFork_Amazon:      "1970-01-01", // Amazon hard fork was never on testnet as we backfilled
-			RewardsFork_Nile:        "2024-08-13", // Last calculation end timestamp was 8-12: https://holesky.etherscan.io/tx/0x5fc81b5ed2a78b017ef313c181d8627737a97fef87eee85acedbe39fc8708c56#eventlog
-			RewardsFork_Panama:      "2024-10-01",
-			RewardsFork_Arno:        "2024-12-13",
-			RewardsFork_Trinity:     "2025-01-09",
-			RewardsFork_Mississippi: "2025-02-10",
+			RewardsFork_Amazon: Fork{
+				Date: "1970-01-01", // Amazon hard fork was never on testnet as we backfilled
+			},
+			RewardsFork_Nile: Fork{
+				Date: "2024-08-13", // Last calculation end timestamp was 8-12: https://holesky.etherscan.io/tx/0x5fc81b5ed2a78b017ef313c181d8627737a97fef87eee85acedbe39fc8708c56#eventlog
+			},
+			RewardsFork_Panama: Fork{
+				Date: "2024-10-01",
+			},
+			RewardsFork_Arno: Fork{
+				Date: "2024-12-13",
+			},
+			RewardsFork_Trinity: Fork{
+				Date: "2025-01-09",
+			},
+			RewardsFork_Mississippi: Fork{
+				Date:        "2025-02-10",
+				BlockNumber: 3323306,
+			},
 		}, nil
 	case Chain_Mainnet:
 		return ForkMap{
-			RewardsFork_Amazon:      "2024-08-02", // Last calculation end timestamp was 8-01: https://etherscan.io/tx/0x2aff6f7b0132092c05c8f6f41a5e5eeeb208aa0d95ebcc9022d7823e343dd012#eventlog
-			RewardsFork_Nile:        "2024-08-12", // Last calculation end timestamp was 8-11: https://etherscan.io/tx/0x922d29d93c02d189fc2332041f01a80e0007cd7a625a5663ef9d30082f7ef66f#eventlog
-			RewardsFork_Panama:      "2024-10-01",
-			RewardsFork_Arno:        "2025-01-21",
-			RewardsFork_Trinity:     "2025-01-21",
-			RewardsFork_Mississippi: "2025-03-27",
+			RewardsFork_Amazon: Fork{
+				Date: "2024-08-02", // Last calculation end timestamp was 8-01: https://etherscan.io/tx/0x2aff6f7b0132092c05c8f6f41a5e5eeeb208aa0d95ebcc9022d7823e343dd012#eventlog
+			},
+			RewardsFork_Nile: Fork{
+				Date: "2024-08-12", // Last calculation end timestamp was 8-11: https://etherscan.io/tx/0x922d29d93c02d189fc2332041f01a80e0007cd7a625a5663ef9d30082f7ef66f#eventlog
+			},
+			RewardsFork_Panama: Fork{
+				Date: "2024-10-01",
+			},
+			RewardsFork_Arno: Fork{
+				Date: "2025-01-21",
+			},
+			RewardsFork_Trinity: Fork{
+				Date: "2025-01-21",
+			},
+			RewardsFork_Mississippi: Fork{
+				Date: "2025-03-27",
+				// mississippi fork on mainnet doesnt have a fork date since we didnt need to backfill
+				// any data for it like we did for preprod and holesky
+				BlockNumber: 0,
+			},
 		}, nil
 	}
 	return nil, errors.New("unsupported chain")
@@ -382,9 +428,9 @@ func (c *Config) IsRewardsV2EnabledForCutoffDate(cutoffDate string) (bool, error
 	if err != nil {
 		return false, errors.Join(fmt.Errorf("failed to parse cutoff date %s", cutoffDate), err)
 	}
-	arnoForkDateTime, err := time.Parse(time.DateOnly, forks[RewardsFork_Arno])
+	arnoForkDateTime, err := time.Parse(time.DateOnly, forks[RewardsFork_Arno].Date)
 	if err != nil {
-		return false, errors.Join(fmt.Errorf("failed to parse Arno fork date %s", forks[RewardsFork_Arno]), err)
+		return false, errors.Join(fmt.Errorf("failed to parse Arno fork date %s", forks[RewardsFork_Arno].Date), err)
 	}
 
 	return cutoffDateTime.Compare(arnoForkDateTime) >= 0, nil
@@ -399,9 +445,9 @@ func (c *Config) IsRewardsV2_1EnabledForCutoffDate(cutoffDate string) (bool, err
 	if err != nil {
 		return false, errors.Join(fmt.Errorf("failed to parse cutoff date %s", cutoffDate), err)
 	}
-	mississippiForkDateTime, err := time.Parse(time.DateOnly, forks[RewardsFork_Mississippi])
+	mississippiForkDateTime, err := time.Parse(time.DateOnly, forks[RewardsFork_Mississippi].Date)
 	if err != nil {
-		return false, errors.Join(fmt.Errorf("failed to parse Mississippi fork date %s", forks[RewardsFork_Mississippi]), err)
+		return false, errors.Join(fmt.Errorf("failed to parse Mississippi fork date %s", forks[RewardsFork_Mississippi].Date), err)
 	}
 
 	return cutoffDateTime.Compare(mississippiForkDateTime) >= 0, nil

pkg/eigenState/avsOperators/avsOperators.go

@@ -286,3 +286,7 @@ func (a *AvsOperatorsModel) ListForBlockRange(startBlockNumber uint64, endBlockN
 	}
 	return base.CastCommittedStateToInterface(records), nil
 }
+
+func (a *AvsOperatorsModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}

pkg/eigenState/avsOperators/avsOperatorsIntegration_test.go

@@ -77,7 +77,7 @@ func Test_AvsOperatorsIntegration(t *testing.T) {
 		if !tests.LargeTestsEnabled() {
 			t.Skipf("Skipping large test")
 		}
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 		model, err := NewAvsOperatorsModel(esm, grm, l, cfg)
 		assert.Nil(t, err)
 

pkg/eigenState/avsOperators/avsOperators_test.go

@@ -56,13 +56,13 @@ func Test_AvsOperatorState(t *testing.T) {
 	}
 
 	t.Run("Should create a new AvsOperatorState", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 		avsOperatorState, err := NewAvsOperatorsModel(esm, grm, l, cfg)
 		assert.Nil(t, err)
 		assert.NotNil(t, avsOperatorState)
 	})
 	t.Run("Should correctly generate state across multiple blocks", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 		blocks := []uint64{
 			300,
 			301,

pkg/eigenState/defaultOperatorSplits/defaultOperatorSplits.go

@@ -283,3 +283,7 @@ func (dos *DefaultOperatorSplitModel) ListForBlockRange(startBlockNumber uint64,
 	}
 	return base.CastCommittedStateToInterface(splits), nil
 }
+
+func (dos *DefaultOperatorSplitModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}

pkg/eigenState/defaultOperatorSplits/defaultOperatorSplits_test.go

@@ -74,7 +74,7 @@ func Test_DefaultOperatorSplit(t *testing.T) {
 	}
 
 	t.Run("Test each event type", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 
 		model, err := NewDefaultOperatorSplitModel(esm, grm, l, cfg)
 

pkg/eigenState/disabledDistributionRoots/disabledDistributionRoots.go

@@ -272,3 +272,7 @@ func (ddr *DisabledDistributionRootsModel) ListForBlockRange(startBlockNumber ui
 	}
 	return base.CastCommittedStateToInterface(records), nil
 }
+
+func (ddr *DisabledDistributionRootsModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}

pkg/eigenState/disabledDistributionRoots/disabledDistributionRoots_test.go

@@ -56,7 +56,7 @@ func Test_DisabledDistributionRoots(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	esm := stateManager.NewEigenStateManager(l, grm)
+	esm := stateManager.NewEigenStateManager(nil, l, grm)
 	model, err := NewDisabledDistributionRootsModel(esm, grm, l, cfg)
 
 	t.Run("Parse a disabled distribution root", func(t *testing.T) {

pkg/eigenState/eigenstate_test.go

@@ -46,11 +46,11 @@ func Test_EigenStateManager(t *testing.T) {
 	}
 
 	t.Run("Should create a new EigenStateManager", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 		assert.NotNil(t, esm)
 	})
 	t.Run("Should create a state root with states from models", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 		avsOperatorsModel, err := avsOperators.NewAvsOperatorsModel(esm, grm, l, cfg)
 		assert.Nil(t, err)
 		assert.NotNil(t, avsOperatorsModel)

pkg/eigenState/operatorAVSSplits/operatorAVSSplits.go

@@ -333,3 +333,7 @@ func (oar *OperatorAVSSplitModel) ListForBlockRange(startBlockNumber uint64, end
 	}
 	return base.CastCommittedStateToInterface(splits), nil
 }
+
+func (oas *OperatorAVSSplitModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}

pkg/eigenState/operatorAVSSplits/operatorAVSSplits_test.go

@@ -75,7 +75,7 @@ func Test_OperatorAVSSplit(t *testing.T) {
 	}
 
 	t.Run("Test each event type", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 
 		model, err := NewOperatorAVSSplitModel(esm, grm, l, cfg)
 

pkg/eigenState/operatorDirectedOperatorSetRewardSubmissions/operatorDirectedOperatorSetRewardSubmissions.go

@@ -437,3 +437,21 @@ func (od *OperatorDirectedOperatorSetRewardSubmissionsModel) sortValuesForMerkle
 func (od *OperatorDirectedOperatorSetRewardSubmissionsModel) DeleteState(startBlockNumber uint64, endBlockNumber uint64) error {
 	return od.BaseEigenState.DeleteState("operator_directed_operator_set_reward_submissions", startBlockNumber, endBlockNumber, od.DB)
 }
+
+func (od *OperatorDirectedOperatorSetRewardSubmissionsModel) ListForBlockRange(startBlockNumber uint64, endBlockNumber uint64) ([]interface{}, error) {
+	records := make([]*OperatorDirectedOperatorSetRewardSubmission, 0)
+	res := od.DB.Where("block_number >= ? AND block_number <= ?", startBlockNumber, endBlockNumber).Find(&records)
+	if res.Error != nil {
+		od.logger.Sugar().Errorw("Failed to list records for block range",
+			zap.Error(res.Error),
+			zap.Uint64("startBlockNumber", startBlockNumber),
+			zap.Uint64("endBlockNumber", endBlockNumber),
+		)
+		return nil, res.Error
+	}
+	return base.CastCommittedStateToInterface(records), nil
+}
+
+func (od *OperatorDirectedOperatorSetRewardSubmissionsModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}

pkg/eigenState/operatorDirectedOperatorSetRewardSubmissions/operatorDirectedOperatorSetRewardSubmissions_test.go

@@ -61,7 +61,7 @@ func Test_OperatorDirectedOperatorSetRewardSubmissions(t *testing.T) {
 	}
 
 	t.Run("Test each event type", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 
 		model, err := NewOperatorDirectedOperatorSetRewardSubmissionsModel(esm, grm, l, cfg)
 

pkg/eigenState/operatorDirectedRewardSubmissions/operatorDirectedRewardSubmissions.go

@@ -445,3 +445,7 @@ func (odrs *OperatorDirectedRewardSubmissionsModel) ListForBlockRange(startBlock
 	}
 	return base.CastCommittedStateToInterface(submissions), nil
 }
+
+func (odrs *OperatorDirectedRewardSubmissionsModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}

pkg/eigenState/operatorDirectedRewardSubmissions/operatorDirectedRewardSubmissions_test.go

@@ -75,7 +75,7 @@ func Test_OperatorDirectedRewardSubmissions(t *testing.T) {
 	}
 
 	t.Run("Test each event type", func(t *testing.T) {
-		esm := stateManager.NewEigenStateManager(l, grm)
+		esm := stateManager.NewEigenStateManager(nil, l, grm)
 
 		model, err := NewOperatorDirectedRewardSubmissionsModel(esm, grm, l, cfg)
 

pkg/eigenState/operatorPISplits/operatorPISplits.go

@@ -329,3 +329,7 @@ func (ops *OperatorPISplitModel) ListForBlockRange(startBlockNumber uint64, endB
 	}
 	return base.CastCommittedStateToInterface(splits), nil
 }
+
+func (ops *OperatorPISplitModel) IsActiveForBlockHeight(blockHeight uint64) (bool, error) {
+	return true, nil
+}