feat: incentive accumulator upgrade handler migration

app/upgrades/v23/upgrades.go

@@ -1,6 +1,8 @@
 package v23
 
 import (
+	"sort"
+
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/cosmos/cosmos-sdk/types/module"
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
@@ -9,8 +11,12 @@ import (
 
 	"github.com/osmosis-labs/osmosis/v22/app/keepers"
 	"github.com/osmosis-labs/osmosis/v22/app/upgrades"
+	concentratedliquidity "github.com/osmosis-labs/osmosis/v22/x/concentrated-liquidity"
+	concentratedtypes "github.com/osmosis-labs/osmosis/v22/x/concentrated-liquidity/types"
 )
 
+const mainnetChainID = "osmosis-1"
+
 func CreateUpgradeHandler(
 	mm *module.Manager,
 	configurator module.Configurator,
@@ -27,6 +33,46 @@ func CreateUpgradeHandler(
 
 		keepers.IncentivesKeeper.SetParam(ctx, incentivestypes.KeyInternalUptime, incentivestypes.DefaultConcentratedUptime)
 
+		// Snapshot the pool ID migration threshold
+		// Get the next pool ID
+		nextPoolId := keepers.PoolManagerKeeper.GetNextPoolId(ctx)
+
+		lastPoolID := nextPoolId - 1
+
+		keepers.ConcentratedLiquidityKeeper.SetIncentivePoolIDMigrationThreshold(ctx, lastPoolID)
+
+		// We only perform the migration on mainnet pools since we hard-coded the pool IDs to migrate
+		// in the types package. To ensure correctness, we will spin up a state-exported mainnet testnet
+		// with the same chain ID.
+		if ctx.ChainID() == mainnetChainID {
+			if err := migrateMainnetPools(ctx, *keepers.ConcentratedLiquidityKeeper); err != nil {
+				return nil, err
+			}
+		}
+
 		return migrations, nil
 	}
 }
+
+// migrateMainnetPools migrates the specified mainnet pools to the new accumulator scaling factor.
+func migrateMainnetPools(ctx sdk.Context, concentratedKeeper concentratedliquidity.Keeper) error {
+
+	poolIDsToMigrate := make([]uint64, 0, len(concentratedtypes.MigratedIncentiveAccumulatorPoolIDs))
+	for poolID := range concentratedtypes.MigratedIncentiveAccumulatorPoolIDs {
+		poolIDsToMigrate = append(poolIDsToMigrate, poolID)
+	}
+
+	// Sort for determinism
+	sort.Slice(poolIDsToMigrate, func(i, j int) bool {
+		return poolIDsToMigrate[i] < poolIDsToMigrate[j]
+	})
+
+	// Migrate concentrated pools
+	for _, poolId := range poolIDsToMigrate {
+		if err := concentratedKeeper.MigrateAccumulatorToScalingFactor(ctx, poolId); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

osmoutils/accum/accum.go

@@ -65,6 +65,19 @@ func MakeAccumulatorWithValueAndShare(accumStore store.KVStore, accumName string
 	return setAccumulator(&newAccum, accumValue, totalShares)
 }
 
+// OverwriteAccumulatorUnsafe overwrites the accumulator with the given name in accumStore.
+// Use with caution as this method is only meant for use in migrations.
+func OverwriteAccumulatorUnsafe(accumStore store.KVStore, accumName string, accumValue sdk.DecCoins, totalShares osmomath.Dec) error {
+	if !accumStore.Has(formatAccumPrefixKey(accumName)) {
+		return errors.New("Accumulator with given name does not exist in store")
+	}
+
+	newAccum := AccumulatorObject{accumStore, accumName, accumValue, totalShares}
+
+	// Stores accumulator in state
+	return setAccumulator(&newAccum, accumValue, totalShares)
+}
+
 // Gets the current value of the accumulator corresponding to accumName in accumStore
 func GetAccumulator(accumStore store.KVStore, accumName string) (*AccumulatorObject, error) {
 	accumContent := AccumulatorContent{}

proto/osmosis/concentratedliquidity/v1beta1/genesis.proto

@@ -71,6 +71,10 @@ message GenesisState {
 
   uint64 next_incentive_record_id = 5
       [ (gogoproto.moretags) = "yaml:\"next_incentive_record_id\"" ];
+
+  uint64 incentives_accumulator_pool_id_migration_threshold = 6
+      [ (gogoproto.moretags) =
+            "yaml:\"incentives_accumulator_pool_id_migration_threshold\"" ];
 }
 
 message AccumObject {

x/concentrated-liquidity/export_test.go

@@ -24,6 +24,8 @@ var (
 	TwoHundredFooCoins      = sdk.NewDecCoin("foo", osmomath.NewInt(200))
 	TwoHundredBarCoins      = sdk.NewDecCoin("bar", osmomath.NewInt(200))
 	PerUnitLiqScalingFactor = perUnitLiqScalingFactor
+
+	OneDecScalingFactor = oneDecScalingFactor
 )
 
 func (k Keeper) SetPool(ctx sdk.Context, pool types.ConcentratedPoolExtension) error {
@@ -232,8 +234,8 @@ func (k Keeper) CreateUptimeAccumulators(ctx sdk.Context, poolId uint64) error {
 	return k.createUptimeAccumulators(ctx, poolId)
 }
 
-func CalcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, qualifyingLiquidity osmomath.Dec, timeElapsed osmomath.Dec, poolIncentiveRecords []types.IncentiveRecord) (sdk.DecCoins, []types.IncentiveRecord, error) {
-	return calcAccruedIncentivesForAccum(ctx, accumUptime, qualifyingLiquidity, timeElapsed, poolIncentiveRecords, 0)
+func CalcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, qualifyingLiquidity osmomath.Dec, timeElapsed osmomath.Dec, poolIncentiveRecords []types.IncentiveRecord, scalingFactorForPool osmomath.Dec) (sdk.DecCoins, []types.IncentiveRecord, error) {
+	return calcAccruedIncentivesForAccum(ctx, accumUptime, qualifyingLiquidity, timeElapsed, poolIncentiveRecords, 0, scalingFactorForPool)
 }
 
 func (k Keeper) UpdateGivenPoolUptimeAccumulatorsToNow(ctx sdk.Context, pool types.ConcentratedPoolExtension, uptimeAccums []*accum.AccumulatorObject) error {
@@ -346,8 +348,8 @@ func (k Keeper) GetPoolHookContract(ctx sdk.Context, poolId uint64, actionPrefix
 	return k.getPoolHookContract(ctx, poolId, actionPrefix)
 }
 
-func ScaleUpTotalEmittedAmount(totalEmittedAmount osmomath.Dec) (scaledTotalEmittedAmount osmomath.Dec, err error) {
-	return scaleUpTotalEmittedAmount(totalEmittedAmount)
+func ScaleUpTotalEmittedAmount(totalEmittedAmount osmomath.Dec, scalingFactor osmomath.Dec) (scaledTotalEmittedAmount osmomath.Dec, err error) {
+	return scaleUpTotalEmittedAmount(totalEmittedAmount, scalingFactor)
 }
 
 func ComputeTotalIncentivesToEmit(timeElapsedSeconds osmomath.Dec, emissionRate osmomath.Dec) (totalEmittedAmount osmomath.Dec, err error) {

x/concentrated-liquidity/genesis.go

@@ -103,6 +103,8 @@ func (k Keeper) InitGenesis(ctx sdk.Context, genState genesis.GenesisState) {
 
 	// set total liquidity
 	k.setTotalLiquidity(ctx, totalLiquidity)
+
+	k.SetIncentivePoolIDMigrationThreshold(ctx, genState.IncentivesAccumulatorPoolIdMigrationThreshold)
 }
 
 // ExportGenesis returns the concentrated-liquidity module's exported genesis state.
@@ -230,12 +232,19 @@ func (k Keeper) ExportGenesis(ctx sdk.Context) *genesis.GenesisState {
 		})
 	}
 
+	// Get the incentive pool ID migration threshold
+	incentivesAccumulatorPoolIDMigrationThreshold, err := k.GetIncentivePoolIDMigrationThreshold(ctx)
+	if err != nil {
+		panic(err)
+	}
+
 	return &genesis.GenesisState{
 		Params:                k.GetParams(ctx),
 		PoolData:              poolData,
 		PositionData:          positionData,
 		NextPositionId:        k.GetNextPositionId(ctx),
 		NextIncentiveRecordId: k.GetNextIncentiveRecordId(ctx),
+		IncentivesAccumulatorPoolIdMigrationThreshold: incentivesAccumulatorPoolIDMigrationThreshold,
 	}
 }
 

x/concentrated-liquidity/incentives.go

@@ -27,7 +27,10 @@ import (
 //
 // More analysis on the choice of scaling factor can be found here:
 // https://hackmd.io/o3oqT8VhSPKAiqNl_mlxXQ
-var perUnitLiqScalingFactor = osmomath.NewDec(1e15).MulMut(osmomath.NewDec(1e12))
+var (
+	perUnitLiqScalingFactor = osmomath.NewDec(1e15).MulMut(osmomath.NewDec(1e12))
+	oneDecScalingFactor     = osmomath.OneDec()
+)
 
 // createUptimeAccumulators creates accumulator objects in store for each supported uptime for the given poolId.
 // The accumulators are initialized with the default (zero) values.
@@ -191,6 +194,11 @@ func (k Keeper) updateGivenPoolUptimeAccumulatorsToNow(ctx sdk.Context, pool typ
 		return err
 	}
 
+	incentiveScalingFactorForPool, err := k.getIncentiveScalingFactorForPool(ctx, poolId)
+	if err != nil {
+		return err
+	}
+
 	// We optimistically assume that all liquidity on the active tick qualifies and handle
 	// uptime-related checks in forfeiting logic.
 
@@ -200,7 +208,7 @@ func (k Keeper) updateGivenPoolUptimeAccumulatorsToNow(ctx sdk.Context, pool typ
 		for uptimeIndex := range uptimeAccums {
 			// Get relevant uptime-level values
 			curUptimeDuration := types.SupportedUptimes[uptimeIndex]
-			incentivesToAddToCurAccum, updatedPoolRecords, err := calcAccruedIncentivesForAccum(ctx, curUptimeDuration, qualifyingLiquidity, timeElapsedSec, poolIncentiveRecords, poolId)
+			incentivesToAddToCurAccum, updatedPoolRecords, err := calcAccruedIncentivesForAccum(ctx, curUptimeDuration, qualifyingLiquidity, timeElapsedSec, poolIncentiveRecords, poolId, incentiveScalingFactorForPool)
 			if err != nil {
 				return err
 			}
@@ -233,7 +241,7 @@ func (k Keeper) updateGivenPoolUptimeAccumulatorsToNow(ctx sdk.Context, pool typ
 // Returns the IncentivesPerLiquidity value and an updated list of IncentiveRecords that
 // reflect emitted incentives
 // Returns error if the qualifying liquidity/time elapsed are zero.
-func calcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, liquidityInAccum osmomath.Dec, timeElapsed osmomath.Dec, poolIncentiveRecords []types.IncentiveRecord, poolID uint64) (sdk.DecCoins, []types.IncentiveRecord, error) {
+func calcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, liquidityInAccum osmomath.Dec, timeElapsed osmomath.Dec, poolIncentiveRecords []types.IncentiveRecord, poolID uint64, incentiveScalingFactorForPool osmomath.Dec) (sdk.DecCoins, []types.IncentiveRecord, error) {
 	if !liquidityInAccum.IsPositive() || !timeElapsed.IsPositive() {
 		return sdk.DecCoins{}, []types.IncentiveRecord{}, types.QualifyingLiquidityOrTimeElapsedNotPositiveError{QualifyingLiquidity: liquidityInAccum, TimeElapsed: timeElapsed}
 	}
@@ -260,7 +268,7 @@ func calcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, l
 
 		// We scale up the remaining rewards to avoid truncation to zero
 		// when dividing by the liquidity in the accumulator.
-		scaledTotalEmittedAmount, err := scaleUpTotalEmittedAmount(totalEmittedAmount)
+		scaledTotalEmittedAmount, err := scaleUpTotalEmittedAmount(totalEmittedAmount, incentiveScalingFactorForPool)
 		if err != nil {
 			ctx.Logger().Info(types.IncentiveOverflowPlaceholderName, "pool_id", poolID, "incentive_id", incentiveRecord.IncentiveId, "time_elapsed", timeElapsed, "emission_rate", incentiveRecordBody.EmissionRate, "error", err.Error())
 			// Silently ignore the truncated incentive record to avoid halting the entire accumulator update.
@@ -295,7 +303,7 @@ func calcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, l
 
 			// We scale up the remaining rewards to avoid truncation to zero
 			// when dividing by the liquidity in the accumulator.
-			remainingRewardsScaled, err := scaleUpTotalEmittedAmount(remainingRewards)
+			remainingRewardsScaled, err := scaleUpTotalEmittedAmount(remainingRewards, incentiveScalingFactorForPool)
 			if err != nil {
 				ctx.Logger().Info(types.IncentiveOverflowPlaceholderName, "pool_id", poolID, "incentive_id", incentiveRecord.IncentiveId, "time_elapsed", timeElapsed, "emission_rate", incentiveRecordBody.EmissionRate, "error", err.Error())
 				// Silently ignore the truncated incentive record to avoid halting the entire accumulator update.
@@ -320,7 +328,7 @@ func calcAccruedIncentivesForAccum(ctx sdk.Context, accumUptime time.Duration, l
 
 // scaleUpTotalEmittedAmount scales up the total emitted amount to avoid truncation to zero.
 // Returns error if the total emitted amount is too high and causes overflow when applying scaling factor.
-func scaleUpTotalEmittedAmount(totalEmittedAmount osmomath.Dec) (scaledTotalEmittedAmount osmomath.Dec, err error) {
+func scaleUpTotalEmittedAmount(totalEmittedAmount osmomath.Dec, scalingFactor osmomath.Dec) (scaledTotalEmittedAmount osmomath.Dec, err error) {
 	defer func() {
 		r := recover()
 
@@ -1032,3 +1040,46 @@ func emitAccumulatorUpdateTelemetry(ctx sdk.Context, truncatedPlaceholder, emitt
 		ctx.Logger().Info(emittedPlaceholder, "pool_id", poolID, "total_liq", liquidityInAccum, "per_unit_liq", rewardsPerUnitOfLiquidity, "total_amt", rewardsTotal, extraKeyVals)
 	}
 }
+
+func (k Keeper) getIncentiveScalingFactorForPool(ctx sdk.Context, poolID uint64) (osmomath.Dec, error) {
+	migrationThreshold, err := k.GetIncentivePoolIDMigrationThreshold(ctx)
+	if err != nil {
+		return osmomath.Dec{}, err
+	}
+
+	if poolID > migrationThreshold {
+		return perUnitLiqScalingFactor, nil
+	}
+
+	_, isMigrated := types.MigratedIncentiveAccumulatorPoolIDs[poolID]
+
+	if isMigrated {
+		return perUnitLiqScalingFactor, nil
+	}
+
+	return oneDecScalingFactor, nil
+}
+
+// SetIncentivePoolIDMigrationThreshold sets the pool ID migration threshold to the last pool ID.
+func (k Keeper) SetIncentivePoolIDMigrationThreshold(ctx sdk.Context, poolIDThreshold uint64) {
+
+	// Set the pool ID migration threshold to the last pool ID
+	store := ctx.KVStore(k.storeKey)
+
+	store.Set(types.KeyIncentiveAccumulatorMigrationThreshold, sdk.Uint64ToBigEndian(poolIDThreshold))
+}
+
+// GetIncentivePoolIDMigrationThreshold returns the pool ID migration threshold.
+func (k Keeper) GetIncentivePoolIDMigrationThreshold(ctx sdk.Context) (uint64, error) {
+	store := ctx.KVStore(k.storeKey)
+
+	bz := store.Get(types.KeyIncentiveAccumulatorMigrationThreshold)
+
+	if bz == nil {
+		return 0, fmt.Errorf("incentive accumulator migration threshold not found")
+	}
+
+	threshold := sdk.BigEndianToUint64(bz)
+
+	return threshold, nil
+}

x/concentrated-liquidity/incentives_test.go

@@ -734,7 +734,7 @@ func (s *KeeperTestSuite) TestCalcAccruedIncentivesForAccum() {
 				s.PrepareConcentratedPool()
 
 				// system under test
-				actualResult, updatedPoolRecords, err := cl.CalcAccruedIncentivesForAccum(s.Ctx, tc.accumUptime, tc.qualifyingLiquidity, osmomath.NewDec(int64(tc.timeElapsed)).Quo(osmomath.MustNewDecFromStr("1000000000")), tc.poolIncentiveRecords)
+				actualResult, updatedPoolRecords, err := cl.CalcAccruedIncentivesForAccum(s.Ctx, tc.accumUptime, tc.qualifyingLiquidity, osmomath.NewDec(int64(tc.timeElapsed)).Quo(osmomath.MustNewDecFromStr("1000000000")), tc.poolIncentiveRecords, cl.OneDecScalingFactor)
 				if tc.expectedPass {
 					s.Require().NoError(err)
 
@@ -3682,11 +3682,11 @@ func (s *KeeperTestSuite) TestIncentiveTruncation() {
 // This test shows that the scaling factor is applied correctly to the total incentive amount.
 // If overflow occurs, the function returns error as opposed to panicking.
 func (s *KeeperTestSuite) TestScaledUpTotalIncentiveAmount() {
-	scaledIncentiveAmount, err := cl.ScaleUpTotalEmittedAmount(osmomath.NewDec(1))
+	scaledIncentiveAmount, err := cl.ScaleUpTotalEmittedAmount(osmomath.NewDec(1), cl.PerUnitLiqScalingFactor)
 	s.Require().NoError(err)
 	s.Require().Equal(osmomath.NewDec(1).Mul(cl.PerUnitLiqScalingFactor), scaledIncentiveAmount)
 
-	_, err = cl.ScaleUpTotalEmittedAmount(oneE60Dec)
+	_, err = cl.ScaleUpTotalEmittedAmount(oneE60Dec, cl.PerUnitLiqScalingFactor)
 	s.Require().Error(err)
 	s.Require().ErrorContains(err, "overflow")
 }

x/concentrated-liquidity/pool.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/osmosis-labs/osmosis/osmomath"
 	"github.com/osmosis-labs/osmosis/osmoutils"
+	"github.com/osmosis-labs/osmosis/osmoutils/accum"
 	"github.com/osmosis-labs/osmosis/v22/x/concentrated-liquidity/model"
 	types "github.com/osmosis-labs/osmosis/v22/x/concentrated-liquidity/types"
 	lockuptypes "github.com/osmosis-labs/osmosis/v22/x/lockup/types"
@@ -418,3 +419,54 @@ func (k Keeper) GetUserUnbondingPositions(ctx sdk.Context, address sdk.AccAddres
 	}
 	return userPositionsWithPeriodLocks, nil
 }
+
+func (k Keeper) MigrateAccumulatorToScalingFactor(ctx sdk.Context, poolId uint64) error {
+	// Get pool-global incentive accumulator
+	uptimeAccums, err := k.GetUptimeAccumulators(ctx, poolId)
+	if err != nil {
+		return err
+	}
+
+	// Get all position IDs belonging to the pool
+	positionIDs, err := k.GetAllPositionIdsForPoolId(ctx, types.KeyPoolPosition(poolId), poolId)
+	if err != nil {
+		return err
+	}
+
+	// For each uptime accimulator, multiply the value by the per-unit liquidity scaling factor
+	// and overwrite the accumulator with the new value.
+	for uptimeIndex, uptimeAccum := range uptimeAccums {
+		value := uptimeAccum.GetValue().MulDecTruncate(perUnitLiqScalingFactor)
+		if err := accum.OverwriteAccumulatorUnsafe(ctx.KVStore(k.storeKey), types.KeyUptimeAccumulator(poolId, uint64(uptimeIndex)), value, uptimeAccum.GetTotalShares()); err != nil {
+			return err
+		}
+
+		// For each position ID, multiply the value by the per-unit liquidity scaling factor
+		// and overwrite the accumulator with the new value.
+		for _, positionID := range positionIDs {
+
+			positionPrefix := types.KeyPositionId(positionID)
+
+			if !uptimeAccum.HasPosition(string(positionPrefix)) {
+				return fmt.Errorf("position ID %d not found in uptime accumulator %d in pool %d", positionID, uptimeIndex, poolId)
+			}
+
+			positionSnapshot, err := uptimeAccum.GetPosition(string(positionPrefix))
+			if err != nil {
+				return err
+			}
+
+			positionSnapshotValue := positionSnapshot.GetAccumValuePerShare()
+
+			// Multiply the value by the per-unit liquidity scaling factor
+			newValue := positionSnapshotValue.MulDecTruncate(perUnitLiqScalingFactor)
+
+			// Overwrite the position accumulator with the new value
+			if err := uptimeAccum.SetPositionIntervalAccumulation(string(positionPrefix), newValue); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

x/concentrated-liquidity/position_test.go

@@ -314,7 +314,7 @@ func (s *KeeperTestSuite) TestInitOrUpdatePosition() {
 					// Track how much the current uptime accum has grown by
 					actualUptimeAccumDelta[uptimeIndex] = newUptimeAccumValues[uptimeIndex].Sub(initUptimeAccumValues[uptimeIndex])
 					if timeElapsedSec.IsPositive() {
-						expectedGrowthCurAccum, _, err := cl.CalcAccruedIncentivesForAccum(s.Ctx, uptime, test.param.liquidityDelta, timeElapsedSec, expectedIncentiveRecords)
+						expectedGrowthCurAccum, _, err := cl.CalcAccruedIncentivesForAccum(s.Ctx, uptime, test.param.liquidityDelta, timeElapsedSec, expectedIncentiveRecords, cl.OneDecScalingFactor)
 						s.Require().NoError(err)
 						expectedUptimeAccumValueGrowth[uptimeIndex] = expectedGrowthCurAccum
 					}

x/concentrated-liquidity/types/genesis/genesis.go

@@ -11,6 +11,8 @@ func DefaultGenesis() *GenesisState {
 		Params:                types.DefaultParams(),
 		NextPositionId:        1,
 		NextIncentiveRecordId: 1,
+		// By default, the migration threshold is set to 0, which means no pools are migrated.
+		IncentivesAccumulatorPoolIdMigrationThreshold: 0,
 	}
 }