[CL Incentives]: Sync global uptime accumulators upon tick crossing

x/concentrated-liquidity/incentives_test.go

@@ -83,31 +83,34 @@ var (
 )
 
 type ExpectedUptimes struct {
-	emptyExpectedAccumValues   []sdk.DecCoins
-	hundredTokensSingleDenom   []sdk.DecCoins
-	hundredTokensMultiDenom    []sdk.DecCoins
-	twoHundredTokensMultiDenom []sdk.DecCoins
-	varyingTokensSingleDenom   []sdk.DecCoins
-	varyingTokensMultiDenom    []sdk.DecCoins
+	emptyExpectedAccumValues     []sdk.DecCoins
+	hundredTokensSingleDenom     []sdk.DecCoins
+	hundredTokensMultiDenom      []sdk.DecCoins
+	twoHundredTokensMultiDenom   []sdk.DecCoins
+	threeHundredTokensMultiDenom []sdk.DecCoins
+	varyingTokensSingleDenom     []sdk.DecCoins
+	varyingTokensMultiDenom      []sdk.DecCoins
 }
 
 // getExpectedUptimes returns a base set of expected values for testing based on the number
 // of supported uptimes at runtime. This abstraction exists only to ensure backwards-compatibility
 // of incentives-related tests if the supported uptimes are ever changed.
 func getExpectedUptimes() ExpectedUptimes {
 	expUptimes := ExpectedUptimes{
-		emptyExpectedAccumValues:   []sdk.DecCoins{},
-		hundredTokensSingleDenom:   []sdk.DecCoins{},
-		hundredTokensMultiDenom:    []sdk.DecCoins{},
-		twoHundredTokensMultiDenom: []sdk.DecCoins{},
-		varyingTokensSingleDenom:   []sdk.DecCoins{},
-		varyingTokensMultiDenom:    []sdk.DecCoins{},
+		emptyExpectedAccumValues:     []sdk.DecCoins{},
+		hundredTokensSingleDenom:     []sdk.DecCoins{},
+		hundredTokensMultiDenom:      []sdk.DecCoins{},
+		twoHundredTokensMultiDenom:   []sdk.DecCoins{},
+		threeHundredTokensMultiDenom: []sdk.DecCoins{},
+		varyingTokensSingleDenom:     []sdk.DecCoins{},
+		varyingTokensMultiDenom:      []sdk.DecCoins{},
 	}
 	for i := range types.SupportedUptimes {
 		expUptimes.emptyExpectedAccumValues = append(expUptimes.emptyExpectedAccumValues, cl.EmptyCoins)
 		expUptimes.hundredTokensSingleDenom = append(expUptimes.hundredTokensSingleDenom, sdk.NewDecCoins(cl.HundredFooCoins))
 		expUptimes.hundredTokensMultiDenom = append(expUptimes.hundredTokensMultiDenom, sdk.NewDecCoins(cl.HundredFooCoins, cl.HundredBarCoins))
 		expUptimes.twoHundredTokensMultiDenom = append(expUptimes.twoHundredTokensMultiDenom, sdk.NewDecCoins(cl.HundredFooCoins.Add(cl.HundredFooCoins), cl.HundredBarCoins.Add(cl.HundredBarCoins)))
+		expUptimes.threeHundredTokensMultiDenom = append(expUptimes.threeHundredTokensMultiDenom, sdk.NewDecCoins(cl.HundredFooCoins.Add(cl.HundredFooCoins).Add(cl.HundredFooCoins), cl.HundredBarCoins.Add(cl.HundredBarCoins).Add(cl.HundredBarCoins)))
 		expUptimes.varyingTokensSingleDenom = append(expUptimes.varyingTokensSingleDenom, sdk.NewDecCoins(cl.HundredFooCoins.Add(sdk.NewDecCoin("foo", sdk.NewInt(int64(i))))))
 		expUptimes.varyingTokensMultiDenom = append(expUptimes.varyingTokensMultiDenom, sdk.NewDecCoins(cl.HundredFooCoins.Add(sdk.NewDecCoin("foo", sdk.NewInt(int64(i)))), cl.HundredBarCoins.Add(sdk.NewDecCoin("bar", sdk.NewInt(int64(i*3))))))
 	}
@@ -139,6 +142,19 @@ func chargeIncentive(incentiveRecord types.IncentiveRecord, timeElapsed time.Dur
 	return incentiveRecord
 }
 
+// Helper for adding a predetermined amount to each global uptime accum in clPool
+func addToUptimeAccums(ctx sdk.Context, poolId uint64, clKeeper *cl.Keeper,  addValues []sdk.DecCoins) error {
+	poolUptimeAccumulators, err := clKeeper.GetUptimeAccumulators(ctx, poolId)
+	if err != nil {
+		return err
+	}
+
+	for uptimeIndex, uptimeAccum := range poolUptimeAccumulators {
+		uptimeAccum.AddToAccumulator(addValues[uptimeIndex])
+	}
+
+	return nil
+}
 func createIncentiveRecord(incentiveDenom string, remainingAmt, emissionRate sdk.Dec, startTime time.Time, minUpTime time.Duration) types.IncentiveRecord {
 	return types.IncentiveRecord{
 		IncentiveDenom:  incentiveDenom,

x/concentrated-liquidity/tick.go

@@ -63,13 +63,31 @@ func (k Keeper) crossTick(ctx sdk.Context, poolId uint64, tickIndex int64, swapS
 		return sdk.Dec{}, err
 	}
 
-	accum, err := k.getFeeAccumulator(ctx, poolId)
+	feeAccum, err := k.getFeeAccumulator(ctx, poolId)
 	if err != nil {
 		return sdk.Dec{}, err
 	}
 
 	// subtract tick's fee growth outside from current fee growth global, including the fee growth of the current swap.
-	tickInfo.FeeGrowthOutside = accum.GetValue().Add(swapStateFeeGrowth).Sub(tickInfo.FeeGrowthOutside)
+	tickInfo.FeeGrowthOutside = feeAccum.GetValue().Add(swapStateFeeGrowth).Sub(tickInfo.FeeGrowthOutside)
+
+	// Update global accums to now before uptime outside changes
+	if err := k.updateUptimeAccumulatorsToNow(ctx, poolId); err != nil {
+		return sdk.Dec{}, err
+	}
+
+	uptimeAccums, err := k.getUptimeAccumulators(ctx, poolId)
+	if err != nil {
+		return sdk.Dec{}, err
+	}
+
+	// For each supported uptime, subtract tick's uptime growth outside from the respective uptime accumulator
+	// This is functionally equivalent to "flipping" the trackers once the tick is crossed
+	updatedUptimeTrackers := tickInfo.UptimeTrackers
+	for uptimeId, uptimeAccum := range uptimeAccums {
+		updatedUptimeTrackers[uptimeId].UptimeGrowthOutside = uptimeAccum.GetValue().Sub(updatedUptimeTrackers[uptimeId].UptimeGrowthOutside)
+	}
+
 	k.SetTickInfo(ctx, poolId, tickIndex, tickInfo)
 
 	return tickInfo.LiquidityNet, nil
@@ -94,7 +112,23 @@ func (k Keeper) getTickInfo(ctx sdk.Context, poolId uint64, tickIndex int64) (ti
 			return tickStruct, err
 		}
 
-		return model.TickInfo{LiquidityGross: sdk.ZeroDec(), LiquidityNet: sdk.ZeroDec(), FeeGrowthOutside: initialFeeGrowthOutside}, nil
+		// Sync global uptime accumulators to ensure the uptime tracker init values are up to date.
+		if err := k.updateUptimeAccumulatorsToNow(ctx, poolId); err != nil {
+			return tickStruct, err
+		}
+
+		// Initialize uptime trackers for the new tick to the appropriate starting values.
+		valuesToAdd, err := k.getInitialUptimeGrowthOutsidesForTick(ctx, poolId, tickIndex)
+		if err != nil {
+			return tickStruct, err
+		}
+
+		initialUptimeTrackers := []model.UptimeTracker{}
+		for _, uptimeTrackerValue := range valuesToAdd {
+			initialUptimeTrackers = append(initialUptimeTrackers, model.UptimeTracker{UptimeGrowthOutside: uptimeTrackerValue})
+		}
+
+		return model.TickInfo{LiquidityGross: sdk.ZeroDec(), LiquidityNet: sdk.ZeroDec(), FeeGrowthOutside: initialFeeGrowthOutside, UptimeTrackers: initialUptimeTrackers}, nil
 	}
 	if err != nil {
 		return tickStruct, err