create operator_allocation_snapshots table for rounding logic

Author: serichoi65

pkg/eigenState/operatorAllocations/operatorAllocations.go

@@ -7,7 +7,6 @@ import (
 	"slices"
 	"sort"
 	"strings"
-	"time"
 
 	"github.com/Layr-Labs/sidecar/internal/config"
 	"github.com/Layr-Labs/sidecar/pkg/eigenState/base"
@@ -28,7 +27,6 @@ type OperatorAllocation struct {
 	BlockNumber     uint64
 	TransactionHash string
 	LogIndex        uint64
-	EffectiveDate   string // Rounded date when allocation takes effect (YYYY-MM-DD)
 }
 
 type OperatorAllocationModel struct {
@@ -121,27 +119,6 @@ func (oa *OperatorAllocationModel) handleOperatorAllocationCreatedEvent(log *sto
 		LogIndex:        log.LogIndex,
 	}
 
-	// Sabine fork: Apply rounding logic and populate date fields
-	isSabineForkActive, err := oa.IsActiveForSabineForkBlockHeight(log.BlockNumber)
-	if err != nil {
-		return nil, err
-	}
-	if isSabineForkActive {
-		effectiveDateStr, err := oa.calculateAllocationDates(
-			log.BlockNumber,
-			magnitude,
-			strings.ToLower(outputData.Operator),
-			strings.ToLower(outputData.OperatorSet.Avs),
-			strings.ToLower(outputData.Strategy),
-			outputData.OperatorSet.Id,
-		)
-		if err != nil {
-			return nil, err
-		}
-
-		split.EffectiveDate = effectiveDateStr
-	}
-
 	return split, nil
 }
 
@@ -363,123 +340,3 @@ func (oa *OperatorAllocationModel) IsActiveForBlockHeight(blockHeight uint64) (b
 
 	return blockHeight >= forks[config.RewardsFork_Brazos].BlockNumber, nil
 }
-
-func (oa *OperatorAllocationModel) IsActiveForSabineForkBlockHeight(blockHeight uint64) (bool, error) {
-	forks, err := oa.globalConfig.GetRewardsSqlForkDates()
-	if err != nil {
-		oa.logger.Sugar().Errorw("Failed to get rewards sql fork dates", zap.Error(err))
-		return false, err
-	}
-
-	return blockHeight >= forks[config.RewardsFork_Sabine].BlockNumber, nil
-}
-
-// calculateAllocationDates calculates the effective date for an allocation
-// This encapsulates the logic for querying block data and applying rounding rules
-// Block timestamp can be derived from block_number FK to blocks table
-func (oa *OperatorAllocationModel) calculateAllocationDates(
-	blockNumber uint64,
-	magnitude *big.Int,
-	operator string,
-	avs string,
-	strategy string,
-	operatorSetId uint64,
-) (effectiveDateStr string, err error) {
-	// 1. Get block timestamp from blocks table
-	var block storage.Block
-	result := oa.DB.Where("number = ?", blockNumber).First(&block)
-	if result.Error != nil {
-		oa.logger.Sugar().Errorw("Failed to query block timestamp",
-			zap.Error(result.Error),
-			zap.Uint64("blockNumber", blockNumber),
-		)
-		return "", fmt.Errorf("failed to query block timestamp: %w", result.Error)
-	}
-
-	// 2. Get previous allocation magnitude for comparison
-	previousMagnitude, err := oa.getPreviousAllocationMagnitude(
-		operator,
-		avs,
-		strategy,
-		operatorSetId,
-		blockNumber,
-	)
-	if err != nil {
-		oa.logger.Sugar().Errorw("Failed to get previous allocation magnitude",
-			zap.Error(err),
-			zap.Uint64("blockNumber", blockNumber),
-			zap.String("operator", operator),
-			zap.String("avs", avs),
-			zap.String("strategy", strategy),
-			zap.Uint64("operatorSetId", operatorSetId),
-		)
-		return "", fmt.Errorf("failed to get previous allocation magnitude: %w", err)
-	}
-
-	// 3. Determine effective date using rounding rules
-	effectiveDate := oa.determineEffectiveDate(block.BlockTime, magnitude, previousMagnitude)
-
-	// 4. Format and return date string
-	effectiveDateStr = effectiveDate.Format("2006-01-02")
-
-	return effectiveDateStr, nil
-}
-
-// getPreviousAllocationMagnitude retrieves the most recent allocation magnitude
-// for the given operator-avs-strategy combination before the specified block number
-func (oa *OperatorAllocationModel) getPreviousAllocationMagnitude(
-	operator string,
-	avs string,
-	strategy string,
-	operatorSetId uint64,
-	currentBlockNumber uint64,
-) (*big.Int, error) {
-	var previousAllocation OperatorAllocation
-
-	result := oa.DB.
-		Where("operator = ?", operator).
-		Where("avs = ?", avs).
-		Where("strategy = ?", strategy).
-		Where("operator_set_id = ?", operatorSetId).
-		Where("block_number < ?", currentBlockNumber).
-		Order("block_number DESC, log_index DESC").
-		Limit(1).
-		First(&previousAllocation)
-
-	if result.Error != nil {
-		if result.Error == gorm.ErrRecordNotFound {
-			// No previous allocation found, return 0
-			return big.NewInt(0), nil
-		}
-		return nil, result.Error
-	}
-
-	magnitude, success := new(big.Int).SetString(previousAllocation.Magnitude, 10)
-	if !success {
-		return nil, fmt.Errorf("failed to parse previous magnitude: %s", previousAllocation.Magnitude)
-	}
-
-	return magnitude, nil
-}
-
-// determineEffectiveDate determines the effective date for an allocation based on rounding rules
-// - Allocation (increase): Round UP to next day
-// - Deallocation (decrease): Round DOWN to current day
-func (oa *OperatorAllocationModel) determineEffectiveDate(
-	blockTimestamp time.Time,
-	newMagnitude *big.Int,
-	previousMagnitude *big.Int,
-) time.Time {
-	blockTimestamp = blockTimestamp.UTC()
-	comparison := newMagnitude.Cmp(previousMagnitude)
-
-	year, month, day := blockTimestamp.Date()
-	midnightUTC := time.Date(year, month, day, 0, 0, 0, 0, time.UTC)
-
-	if comparison > 0 {
-		// Allocation (increase) - always round up to next day
-		return midnightUTC.Add(24 * time.Hour)
-	}
-	// Deallocation (decrease or no change) - round down to current day
-	return midnightUTC
-}