feat: rewards v2.1 (#214)

rewards v2.1 implementation
Layr-Labs · Feb 10, 2025 · 8721649 · 8721649
2 parents c582a65 + 2f9f9f5
commit 8721649
Show file tree

Hide file tree

Showing 102 changed files with 6,005 additions and 259 deletions.
diff --git a/.gitignore b/.gitignore
@@ -32,6 +32,7 @@ node_modules
 chart_releases
 /snapshots/**/*.sql
 /snapshots/**/*.csv
-*.sql
-*.dump
+/*.sql
+/*.dump
 .env
+!/pkg/eigenState/stateMigrator/**/*.sql
diff --git a/VERSION b/VERSION
@@ -1 +1 @@
-v3.0.0-rc.2
+v3.0.0-rc.4
diff --git a/cmd/database.go b/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 {

diff --git a/cmd/debugger/main.go b/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 {

diff --git a/cmd/operatorRestakedStrategies.go b/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))

diff --git a/cmd/rpc.go b/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))

diff --git a/cmd/run.go b/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 {

diff --git a/internal/config/config.go b/internal/config/config.go
@@ -34,11 +34,12 @@ const (
 
 // Rewards forks named after rivers
 const (
-	RewardsFork_Nile    ForkName = "nile"
-	RewardsFork_Amazon  ForkName = "amazon"
-	RewardsFork_Panama  ForkName = "panama"
-	RewardsFork_Arno    ForkName = "arno"
-	RewardsFork_Trinity ForkName = "trinity"
+	RewardsFork_Nile        ForkName = "nile"
+	RewardsFork_Amazon      ForkName = "amazon"
+	RewardsFork_Panama      ForkName = "panama"
+	RewardsFork_Arno        ForkName = "arno"
+	RewardsFork_Trinity     ForkName = "trinity"
+	RewardsFork_Mississippi ForkName = "mississippi"
 )
 
 func normalizeFlagName(name string) string {
@@ -287,33 +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_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-05",
+				BlockNumber: 3293200,
+			},
 		}, 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_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: 3327000,
+			},
 		}, 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_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")
@@ -378,14 +428,31 @@ 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
 }
 
+func (c *Config) IsRewardsV2_1EnabledForCutoffDate(cutoffDate string) (bool, error) {
+	forks, err := c.GetRewardsSqlForkDates()
+	if err != nil {
+		return false, err
+	}
+	cutoffDateTime, err := time.Parse(time.DateOnly, cutoffDate)
+	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].Date)
+	if err != nil {
+		return false, errors.Join(fmt.Errorf("failed to parse Mississippi fork date %s", forks[RewardsFork_Mississippi].Date), err)
+	}
+
+	return cutoffDateTime.Compare(mississippiForkDateTime) >= 0, nil
+}
+
 // CanIgnoreIncorrectRewardsRoot returns true if the rewards root can be ignored for the given block number
 //
 // Due to inconsistencies in the rewards root calculation on testnet, we know that some roots

diff --git a/pkg/contractStore/coreContracts/preprod.json b/pkg/contractStore/coreContracts/preprod.json
diff --git a/pkg/contractStore/coreContracts/testnet.json b/pkg/contractStore/coreContracts/testnet.json
diff --git a/pkg/eigenState/avsOperators/avsOperators.go b/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
+}
diff --git a/pkg/eigenState/avsOperators/avsOperatorsIntegration_test.go b/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)
 

diff --git a/pkg/eigenState/avsOperators/avsOperators_test.go b/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,

diff --git a/pkg/eigenState/defaultOperatorSplits/defaultOperatorSplits.go b/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
+}
diff --git a/pkg/eigenState/defaultOperatorSplits/defaultOperatorSplits_test.go b/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)
 

diff --git a/pkg/eigenState/disabledDistributionRoots/disabledDistributionRoots.go b/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
+}
diff --git a/pkg/eigenState/disabledDistributionRoots/disabledDistributionRoots_test.go b/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) {

diff --git a/pkg/eigenState/eigenState.go b/pkg/eigenState/eigenState.go
@@ -6,8 +6,12 @@ import (
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/defaultOperatorSplits"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/disabledDistributionRoots"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorAVSSplits"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorDirectedOperatorSetRewardSubmissions"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorDirectedRewardSubmissions"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorPISplits"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorSetOperatorRegistrations"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorSetSplits"
+	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorSetStrategyRegistrations"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/operatorShares"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/rewardSubmissions"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/stakerDelegations"
@@ -68,5 +72,21 @@ func LoadEigenStateModels(
 		l.Sugar().Errorw("Failed to create DefaultOperatorSplitModel", zap.Error(err))
 		return err
 	}
+	if _, err := operatorDirectedOperatorSetRewardSubmissions.NewOperatorDirectedOperatorSetRewardSubmissionsModel(sm, grm, l, cfg); err != nil {
+		l.Sugar().Errorw("Failed to create OperatorDirectedOperatorSetRewardSubmissionsModel", zap.Error(err))
+		return err
+	}
+	if _, err := operatorSetSplits.NewOperatorSetSplitModel(sm, grm, l, cfg); err != nil {
+		l.Sugar().Errorw("Failed to create OperatorSetSplitModel", zap.Error(err))
+		return err
+	}
+	if _, err := operatorSetOperatorRegistrations.NewOperatorSetOperatorRegistrationModel(sm, grm, l, cfg); err != nil {
+		l.Sugar().Errorw("Failed to create OperatorSetOperatorRegistrationModel", zap.Error(err))
+		return err
+	}
+	if _, err := operatorSetStrategyRegistrations.NewOperatorSetStrategyRegistrationModel(sm, grm, l, cfg); err != nil {
+		l.Sugar().Errorw("Failed to create OperatorSetStrategyRegistrationModel", zap.Error(err))
+		return err
+	}
 	return nil
 }
diff --git a/pkg/eigenState/eigenstate_test.go b/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)

diff --git a/pkg/eigenState/operatorAVSSplits/operatorAVSSplits.go b/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
+}