fix

Author: serichoi65

internal/config/config.go

@@ -862,14 +862,11 @@ func (c *Config) IsRewardsV2_1EnabledForCutoffDate(cutoffDate string) (bool, err
 }
 
 func (c *Config) IsRewardsV2_2EnabledForCutoffDate(cutoffDate string) (bool, error) {
-<<<<<<< HEAD
-=======
 	// Check global flag first - if disabled, return false regardless of date
 	if !c.Rewards.RewardsV2_2Enabled {
 		return false, nil
 	}
 
->>>>>>> e7a0eb58 (feat: implement Operator Set Rewards with Unique & Total Stake)
 	forks, err := c.GetRewardsSqlForkDates()
 	if err != nil {
 		return false, err
@@ -878,10 +875,6 @@ func (c *Config) IsRewardsV2_2EnabledForCutoffDate(cutoffDate string) (bool, err
 	if err != nil {
 		return false, errors.Join(fmt.Errorf("failed to parse cutoff date %s", cutoffDate), err)
 	}
-<<<<<<< HEAD
-	// TODO: Need to change to fork sabine
-=======
->>>>>>> e7a0eb58 (feat: implement Operator Set Rewards with Unique & Total Stake)
 	pecosForkDateTime, err := time.Parse(time.DateOnly, forks[RewardsFork_Pecos].Date)
 	if err != nil {
 		return false, errors.Join(fmt.Errorf("failed to parse Pecos fork date %s", forks[RewardsFork_Pecos].Date), err)

pkg/postgres/migrations/202511141700_withdrawalQueueAndAllocationRounding/up.go

@@ -32,10 +32,14 @@ func (m *Migration) Up(db *sql.DB, grm *gorm.DB, cfg *config.Config) error {
 			strategy varchar not null,
 			operator_set_id bigint not null,
 			magnitude numeric not null,
+			max_magnitude numeric not null,
 			snapshot date not null,
 			primary key (operator, avs, strategy, operator_set_id, snapshot)
 		)`,
 
+		// Add max_magnitude column if table already exists without it
+		`ALTER TABLE operator_allocation_snapshots ADD COLUMN IF NOT EXISTS max_magnitude numeric NOT NULL DEFAULT '0'`,
+
 		// =============================================================================
 		// PART 3: Update operator_allocations table for allocation/deallocation rounding
 		// =============================================================================

pkg/rewards/15_goldOperatorOperatorSetUniqueStakeRewards.go

@@ -136,7 +136,7 @@ func (rc *RewardsCalculator) GenerateGold15OperatorOperatorSetUniqueStakeRewards
 	query, err := rewardsUtils.RenderQueryTemplate(_15_goldOperatorOperatorSetUniqueStakeRewardsQuery, map[string]interface{}{
 		"destTableName":                    destTableName,
 		"activeODRewardsTable":             allTableNames[rewardsUtils.Table_11_ActiveODOperatorSetRewards],
-		"operatorAllocationSnapshotsTable": allTableNames[rewardsUtils.Table_OperatorAllocationSnapshots],
+		"operatorAllocationSnapshotsTable": "operator_allocation_snapshots",
 		"operatorShareSnapshotsTable":      "operator_share_snapshots",
 	})
 	if err != nil {

pkg/rewards/17_goldAvsOperatorSetUniqueStakeRewards.go

@@ -159,7 +159,7 @@ func (rc *RewardsCalculator) GenerateGold17AvsOperatorSetUniqueStakeRewardsTable
 	query, err := rewardsUtils.RenderQueryTemplate(_17_goldAvsOperatorSetUniqueStakeRewardsQuery, map[string]interface{}{
 		"destTableName":                    destTableName,
 		"activeODRewardsTable":             allTableNames[rewardsUtils.Table_11_ActiveODOperatorSetRewards],
-		"operatorAllocationSnapshotsTable": allTableNames[rewardsUtils.Table_OperatorAllocationSnapshots],
+		"operatorAllocationSnapshotsTable": "operator_allocation_snapshots",
 	})
 	if err != nil {
 		rc.logger.Sugar().Errorw("Failed to render query template", "error", err)

pkg/rewards/operatorAllocationSnapshots.go

@@ -7,7 +7,7 @@ import (
 )
 
 const operatorAllocationSnapshotsQuery = `
-	insert into operator_allocation_snapshots(operator, avs, strategy, operator_set_id, magnitude, snapshot)
+	insert into operator_allocation_snapshots(operator, avs, strategy, operator_set_id, magnitude, max_magnitude, snapshot)
 	WITH ranked_allocation_records as (
 		SELECT *,
 			   ROW_NUMBER() OVER (PARTITION BY operator, avs, strategy, operator_set_id, cast(block_time AS DATE) ORDER BY block_time DESC, log_index DESC) AS rn
@@ -86,16 +86,48 @@ const operatorAllocationSnapshotsQuery = `
 	cleaned_records as (
 		SELECT * FROM allocation_windows
 		WHERE start_time < end_time
+	),
+	-- Get the latest max_magnitude for each (operator, strategy) as of the cutoff date
+	latest_max_magnitudes as (
+		SELECT
+			omm.operator,
+			omm.strategy,
+			omm.max_magnitude,
+			ROW_NUMBER() OVER (
+				PARTITION BY omm.operator, omm.strategy
+				ORDER BY omm.block_number DESC, omm.log_index DESC
+			) AS rn
+		FROM operator_max_magnitudes omm
+		INNER JOIN blocks b ON omm.block_number = b.number
+		WHERE b.block_time < TIMESTAMP '{{.cutoffDate}}'
+	),
+	-- Join allocations with max_magnitudes
+	allocations_with_max as (
+		SELECT
+			cr.operator,
+			cr.avs,
+			cr.strategy,
+			cr.operator_set_id,
+			cr.magnitude,
+			COALESCE(lmm.max_magnitude, '0') as max_magnitude,
+			cr.start_time,
+			cr.end_time
+		FROM cleaned_records cr
+		LEFT JOIN latest_max_magnitudes lmm
+			ON cr.operator = lmm.operator
+			AND cr.strategy = lmm.strategy
+			AND lmm.rn = 1
 	)
 	SELECT
 		operator,
 		avs,
 		strategy,
 		operator_set_id,
 		magnitude,
+		max_magnitude,
 		cast(day AS DATE) AS snapshot
 	FROM
-		cleaned_records
+		allocations_with_max
 	CROSS JOIN
 		generate_series(DATE(start_time), DATE(end_time) - interval '1' day, interval '1' day) AS day
 	on conflict do nothing;

pkg/rewards/operatorShareSnapshots.go

@@ -66,7 +66,7 @@ combined_snapshots as (
 	SELECT
 		coalesce(base.operator, alloc.operator) as operator,
 		coalesce(base.strategy, alloc.strategy) as strategy,
-		coalesce(alloc.total_magnitude::text, base.shares) as shares,
+		coalesce(alloc.total_magnitude, base.shares::numeric) as shares,
 		coalesce(base.snapshot, alloc.snapshot) as snapshot
 	FROM base_snapshots base
 	FULL OUTER JOIN allocation_adjustments alloc

pkg/rewards/rewardsV2_2_integration_test.go

@@ -3,7 +3,6 @@ package rewards
 import (
 	"fmt"
 	"math/big"
-	"strings"
 	"testing"
 	"time"
 
@@ -268,14 +267,13 @@ func Test_RewardsV2_2_WithWithdrawalQueue_Integration(t *testing.T) {
 			err := rc.generateSnapshotData(snapshotDate)
 			require.NoError(t, err)
 
-			// Check operator allocation snapshots
+			// Check operator allocation snapshots (persistent table, not per-date)
 			var allocatedStake string
-			tableName := fmt.Sprintf("operator_allocation_snapshots_%s", strings.ReplaceAll(snapshotDate, "-", "_"))
-			query := fmt.Sprintf(`
+			query := `
 				SELECT COALESCE(SUM(magnitude::numeric), 0)::text
-				FROM %s
+				FROM operator_allocation_snapshots
 				WHERE snapshot = $1 AND operator = $2
-			`, tableName)
+			`
 			err = grm.Raw(query, snapshotDate, "operator1").Scan(&allocatedStake).Error
 			require.NoError(t, err)
 

pkg/rewards/rewardsV2_2_test.go

@@ -301,7 +301,8 @@ func Test_RewardsV2_2(t *testing.T) {
 			assert.Nil(t, err)
 
 			// V2.2 specific validation - ensure operator allocations snapshot was created
-			operatorAllocSnapshotTable := goldTableNames[rewardsUtils.Table_OperatorAllocationSnapshots]
+			// Note: operator_allocation_snapshots is a persistent table without date suffix
+			operatorAllocSnapshotTable := "operator_allocation_snapshots"
 			rows, err = getRowCountForTable(grm, operatorAllocSnapshotTable)
 			assert.Nil(t, err)
 			t.Logf("Operator allocation snapshots: %v", rows)

pkg/rewards/stakerShareSnapshots.go

@@ -68,7 +68,7 @@ const stakerShareSnapshotsQuery = `
 		SELECT
 			coalesce(base.staker, wq.staker) as staker,
 			coalesce(base.strategy, wq.strategy) as strategy,
-			(coalesce(base.shares::numeric, 0) + coalesce(wq.shares::numeric, 0))::text as shares,
+			(coalesce(base.shares::numeric, 0) + coalesce(wq.shares::numeric, 0)) as shares,
 			coalesce(base.snapshot, wq.snapshot) as snapshot
 		FROM base_snapshots base
 		FULL OUTER JOIN withdrawal_queue_adjustments wq

pkg/rewards/tables.go

@@ -160,5 +160,6 @@ type OperatorAllocationSnapshot struct {
 	Strategy      string
 	OperatorSetId uint64
 	Magnitude     string
+	MaxMagnitude  string
 	Snapshot      time.Time
 }