external reward tip

Author: mconcat

emission.txt

@@ -44,12 +44,12 @@ var (
 // - Governance Stakers: 0%
 func init() {
 	distributionBpsPct = avl.NewTree()
-	distributionBpsPct.Set(strconv.Itoa(LIQUIDITY_STAKER), 7500)
-	distributionBpsPct.Set(strconv.Itoa(DEVOPS), 2000)
-	distributionBpsPct.Set(strconv.Itoa(COMMUNITY_POOL), 500)
-	distributionBpsPct.Set(strconv.Itoa(GOV_STAKER), 0)
+	distributionBpsPct.Set(strconv.Itoa(LIQUIDITY_STAKER), uint64(7500))
+	distributionBpsPct.Set(strconv.Itoa(DEVOPS), uint64(2000))
+	distributionBpsPct.Set(strconv.Itoa(COMMUNITY_POOL), uint64(500))
+	distributionBpsPct.Set(strconv.Itoa(GOV_STAKER), uint64(0))
 
-	addStakerPerBlockMintUpdate(uint64(std.GetHeight()), gns.GetCurrentEmission() * 7500)
+	addStakerPerBlockMintUpdate(uint64(std.GetHeight()), gns.GetCurrentEmission() * uint64(7500))
 }
 
 var (
@@ -254,8 +254,8 @@ func distributeToTarget(amount uint64) uint64 {
 			))
 		}
 
-		pct := iPct.(int)
-		distAmount := calculateAmount(amount, uint64(pct))
+		pct := iPct.(uint64)
+		distAmount := calculateAmount(amount, pct)
 		totalSent += distAmount
 
 		transferToTarget(targetInt, distAmount)

emission/distribution.gno

@@ -22,30 +22,24 @@ var (
 func MintAndDistributeGns() uint64 {
 	assertOnlyNotHalted()
 
-	println("AAA")
 	currentHeight := std.GetHeight()
 	lastMintedHeight := gns.GetLastMintedHeight()
 	if lastMintedHeight >= currentHeight {
 		// Skip if we've already minted tokens at this height
 		return 0
 	}
-	println("BBB")
-
 	// Mint new tokens and add any leftover amounts from previous distribution
 	mintedEmissionRewardAmount := gns.MintGns(a2u(consts.EMISSION_ADDR))
 	if hasLeftGNSAmount() {
 		mintedEmissionRewardAmount += GetLeftGNSAmount()
 		setLeftGNSAmount(0)
 	}
-	println("CCC")
 	// Distribute tokens and track any undistributed amount
 	distributedGNSAmount := distributeToTarget(mintedEmissionRewardAmount)
-	println("DDD")
 	if mintedEmissionRewardAmount != distributedGNSAmount {
 		setLeftGNSAmount(mintedEmissionRewardAmount - distributedGNSAmount)
 	}
 
-	println("DDD")
 	// Emit event with distribution details
 	prevAddr, prevPkgPath := getPrevAsString()
 	std.Emit(
@@ -59,10 +53,8 @@ func MintAndDistributeGns() uint64 {
 		"internal_totalSupply", ufmt.Sprintf("%d", gns.TotalSupply()),
 	)
 
-	println("EEE")
 	setLastExecutedHeight(currentHeight)
 
-	println("FFF")
 	return distributedGNSAmount
 }
 

emission/emission.gno

@@ -94,8 +94,6 @@ type CalcPositionRewardParam struct {
 }
 
 func CalcPositionReward(param CalcPositionRewardParam) []Reward {
-	println("===== CalcPositionReward", param.TokenId)
-
 	// cache per-pool rewards in the internal incentive(tiers)
 	param.PoolTier.cacheReward(param.CurrentHeight, param.Pools)
 
@@ -123,7 +121,6 @@ func CalcPositionReward(param CalcPositionRewardParam) []Reward {
 	// XXX: Tick ordering code, memoing for future
 
 	lastCollectHeight := deposit.lastCollectHeight
-	println("===== lastCollectHeight", param.TokenId, lastCollectHeight)
 
 	initialUpperCross := upperTick.previousCross(lastCollectHeight)
 	initialLowerCross := lowerTick.previousCross(lastCollectHeight)

staker/calculate_pool_position_reward.gno

@@ -15,6 +15,11 @@ type IncentiveBound struct {
 	IsEnter   bool
 }
 
+type IncentiveRewardEntry struct {
+	ActiveIncentives []string
+	TotalStakedLiquidity *u256.Uint
+}
+
 // per-pool incentives
 type Incentives struct {
 	byTime    *avl.Tree // (startTime, endTime, creator, rewardToken) => ExternalIncentive
@@ -23,7 +28,9 @@ type Incentives struct {
 
 	incentiveBound *UintTree // blockNumber -> []IncentiveBound
 
-	rewardCache           *RewardCacheTree // blockNumber -> map[string]*u256.Uint
+	currentIncentives []string
+
+	rewardCache           *RewardCacheTree // blockNumber -> IncentiveRewardEntry
 	lastRewardCacheHeight *uint64
 }
 
@@ -37,6 +44,8 @@ func NewIncentives(currentHeight uint64) Incentives {
 
 		rewardCache:           NewRewardCacheTree(),
 		lastRewardCacheHeight: &currentHeight,
+
+		currentIncentives: []string{},
 	}
 }
 
@@ -81,12 +90,15 @@ func (self *Incentives) GetBound(height uint64) []IncentiveBound {
 }
 
 // cacheReward() MUST be called before this function
-func (self *Incentives) CurrentReward(currentHeight uint64) map[string]*u256.Uint {
+func (self *Incentives) CurrentReward(currentHeight uint64) IncentiveRewardEntry {
 	value := self.rewardCache.CurrentReward(currentHeight)
 	if value == nil {
-		return make(map[string]*u256.Uint)
+		return IncentiveRewardEntry{
+			ActiveIncentives: []string{},
+			TotalStakedLiquidity: u256.Zero(),
+		}
 	}
-	return value.(map[string]*u256.Uint)
+	return value.(IncentiveRewardEntry)
 }
 
 func (self *Incentives) create(
@@ -129,22 +141,35 @@ func (self *Incentives) cacheRewardPerLiquidityUnit(startHeight, endHeight uint6
 
 	self.incentiveBound.Iterate(startHeight, endHeight, func(key uint64, value interface{}) bool {
 		bound := value.([]IncentiveBound)
-		reward := make(map[string]*u256.Uint)
-		for incentiveId, ratio := range currentReward {
-			reward[incentiveId] = ratio
+		reward := IncentiveRewardEntry{
+			ActiveIncentives: []string{},
+			TotalStakedLiquidity: currentReward.TotalStakedLiquidity.Clone(),
 		}
+		copy(reward.ActiveIncentives, currentReward.ActiveIncentives)
 		for _, bound := range bound {
 			if bound.IsEnter {
-				delta := u256.NewUint(bound.Incentive.rewardPerBlock)
-				deltaQ192 := delta.Mul(delta, q192)
-				ratio := u256.Zero().Div(deltaQ192, stakedLiquidity)
-				reward[bound.Incentive.incentiveId] = ratio
+				reward.ActiveIncentives = append(reward.ActiveIncentives, bound.Incentive.incentiveId)
 			} else {
-				delete(reward, bound.Incentive.incentiveId)
+				for i, incentiveId := range reward.ActiveIncentives {
+					if incentiveId == bound.Incentive.incentiveId {
+						reward.ActiveIncentives = append(reward.ActiveIncentives[:i], reward.ActiveIncentives[i+1:]...)
+						break
+					}
+				}
 			}
 		}
 		self.rewardCache.Set(key, reward)
 		return false
 	})
 	*self.lastRewardCacheHeight = endHeight
-}
+}
+
+func (self *Incentives) updateRewardByLiquidityChange(currentHeight uint64, liquidity *u256.Uint) {
+	entry := IncentiveRewardEntry{
+		ActiveIncentives: []string{},
+		TotalStakedLiquidity: liquidity.Clone(),
+	}
+	copy(entry.ActiveIncentives, self.currentIncentives)
+
+	self.rewardCache.Set(currentHeight, entry)
+}

staker/reward_calculation_incentives.gno

@@ -71,8 +71,7 @@ type Pool struct {
 	lastUnclaimableHeight *uint64
 	unclaimableAcc *uint64
 
-	tierReward *uint64 // per liquidity, (internal reward / total staked liquidity) * Q192
-	tierRewardTotal *uint64 // total internal reward, used for unclaimable reward calculation
+	tierRewardTotal *uint64 // current total internal reward per block, used for unclaimable reward calculation
 
 	rewardCache           *RewardCacheTree // blockNumber -> *u256.Uint
 	lastRewardCacheHeight *uint64
@@ -84,15 +83,13 @@ type Pool struct {
 
 func NewPool(poolPath string, currentHeight uint64) *Pool {
 	unclaimableAcc := uint64(0)
-	tierReward := uint64(0)
 	tierRewardTotal := uint64(0)
 
 	return &Pool{
 		poolPath:              poolPath,
 		stakedLiquidity:       NewUintTree(),
 		lastUnclaimableHeight: &currentHeight,
 		unclaimableAcc:        &unclaimableAcc,
-		tierReward:            &tierReward,
 		tierRewardTotal:       &tierRewardTotal,
 		rewardCache:           NewRewardCacheTree(),
 		lastRewardCacheHeight: &currentHeight,
@@ -129,6 +126,8 @@ func (self *Pool) updateRewardByLiquidityChange(currentTierReward uint64, curren
 	ratio = u256.Zero().Mul(ratio, q192)
 	ratio = u256.Zero().Div(ratio, liquidity)
 	self.rewardCache.Set(currentHeight, ratio)
+
+	self.incentives.updateRewardByLiquidityChange(currentHeight, liquidity)
 }
 
 func (self *Pool) cacheRewardPerLiquidityUnit(startHeight, endHeight uint64, currentTierReward uint64) {
@@ -176,6 +175,11 @@ func (self *Pool) cacheInternalReward(currentHeight uint64, emissionUpdate en.Em
 }
 
 func (self *Pool) cacheExternalReward(endHeight uint64) {
+	self.stakedLiquidity.Iterate(0, 9999999, func(key uint64, value interface{}) bool {
+		println("(((cacheExternalReward)))", key, value.(*u256.Uint).ToString())
+		return false
+	})
+
 	startHeight := *self.incentives.lastRewardCacheHeight
 	currentStakedLiquidity := self.CurrentStakedLiquidity(startHeight)
 
@@ -187,6 +191,11 @@ func (self *Pool) cacheExternalReward(endHeight uint64) {
 	})
 
 	self.incentives.cacheRewardPerLiquidityUnit(startHeight, endHeight, currentStakedLiquidity)
+
+	self.incentives.rewardCache.Iterate(0, 9999999, func(key uint64, value interface{}) bool {
+		println("cacheExternalReward", key, value)
+		return false
+	})
 }
 
 type ExternalRewardState struct {
@@ -501,7 +510,7 @@ func (self *Pool) processUnclaimableReward(poolTier *PoolTier, endHeight uint64)
 	internalUnClaimable := *self.unclaimableAcc
 	*self.unclaimableAcc = 0
 	externalUnClaimable := make(map[string]uint64)
-	for incentiveId := range self.incentives.CurrentReward(startHeight) {
+	for _, incentiveId := range self.incentives.CurrentReward(startHeight).ActiveIncentives {
 		externalUnClaimable[incentiveId] = self.UnclaimableExternalReward(incentiveId, startHeight, endHeight)
 	}
 	self.lastUnclaimableHeight = &endHeight

staker/reward_calculation_pool.gno

@@ -63,22 +63,18 @@ func TierRatioFromCounts(tier1Count, tier2Count, tier3Count uint64) *TierRatio {
 // RewardDenominator[i] = TierCount[i] * TierRatioLCM / (TierRatio[i] * 100)
 // TierReward[i] = Emission * TierRatioLCM / RewardDenominator[i] / 100
 func (self *TierRatio) IntoRewardDenominators(counts []uint64) []uint64 {
-	println("IntoRewardDenominators", self, counts)
 	result := make([]uint64, 4)
 	for i := 1; i < 4; i++ {
 		if counts[i] == 0 {
 			result[i] = 0
 		} else {
-			println("IntoRewardDenominators", i, counts[i], self.Get(uint64(i)))
 			result[i] = counts[i] * TierRatioLCM / (self.Get(uint64(i)))
 		}
 	}
-	println("IntoRewardDenominators result", result)
 	return result
 }
 
 func ApplyDenominator(emission uint64, denominator uint64) uint64 {
-	println(">>>> ApplyDenominator", emission, TierRatioLCM, denominator)
 	if denominator == 0 {
 		return 0
 	}
@@ -236,8 +232,6 @@ func (self *PoolTier) cacheReward(currentHeight uint64, pools *Pools) {
 	// - msPerBlock is changed
 	// - emission distribution ratio is changed
 	// during the period of PoolTier.lastRewardCacheHeight to currentHeight
-	println("cacheReward", *self.lastRewardCacheHeight, currentHeight)
-	println("emissionUpdate", self.emissionUpdate(*self.lastRewardCacheHeight, currentHeight))
 
 	emissionUpdate := self.emissionUpdate(*self.lastRewardCacheHeight, currentHeight)
 	if emissionUpdate.IsEmpty() {
@@ -246,11 +240,10 @@ func (self *PoolTier) cacheReward(currentHeight uint64, pools *Pools) {
 
 	rewardDenominators := self.tierRatio.IntoRewardDenominators(self.CurrentCounts())
 
-	println(">>>> rewardDenominators", rewardDenominators)
 	self.membership.Iterate("", "", func(key string, value interface{}) bool {
 		pool, ok := pools.Get(key)
 		if !ok {
-			panic("cacheReward: pool not found")
+			panic("pool not found")
 		}
 
 		pool.cacheInternalReward(currentHeight, emissionUpdate, rewardDenominators[value.(uint64)])

staker/reward_calculation_pool_tier.gno

@@ -330,6 +330,10 @@ func TickCrossHook(pools *Pools, height func() int64) func(poolPath string, tick
 		tick.updateCross(blockNumber, zeroForOne)
 
 		liquidityInRangeDelta := tick.stakedLiquidityDelta
+		if liquidityInRangeDelta.Sign() == 0 {
+			return
+		}
+
 		if zeroForOne {
 			liquidityInRangeDelta = i256.Zero().Neg(liquidityInRangeDelta)
 		}
@@ -344,11 +348,13 @@ func TickCrossHook(pools *Pools, height func() int64) func(poolPath string, tick
 			if stakedLiquidity.Sign() == 1 {
 				// StakedLiquidity moved from positive to zero, start unclaimable period
 				pool.startInternalUnclaimablePeriod(blockNumber)
+				pool.startExternalUnclaimablePeriod(blockNumber)
 			}
 		case 1:
 			if stakedLiquidity.Sign() == 0 {
 				// StakedLiquidity moved from zero to positive, end unclaimable period
 				pool.endInternalUnclaimablePeriod(blockNumber)
+				pool.endExternalUnclaimablePeriod(blockNumber)
 			}
 		}
 

staker/reward_calculation_tick.gno

@@ -169,16 +169,13 @@ type RewardCalculationFunc = func(blockNumbers uint64, poolReward interface{})
 func (self *RewardCacheTree) RewardPerInterval(startHeight, endHeight uint64, f RewardCalculationFunc) {
 	currentPoolReward := self.CurrentReward(startHeight)
 	currentHeight := startHeight
-	println("RewardPerInterval 0:", startHeight, endHeight, currentPoolReward)
 	self.Iterate(startHeight, endHeight, func(height uint64, poolReward interface{}) bool {
-		println("RewardPerInterval 1:", height, currentHeight, poolReward, currentPoolReward)
 		f(height-currentHeight, currentPoolReward)
 		currentHeight = height
 		currentPoolReward = poolReward
 		return false
 	})
 	if endHeight > currentHeight {
-		println("RewardPerInterval 2:", endHeight, currentHeight, currentPoolReward)
 		f(endHeight-currentHeight, currentPoolReward)
 	}
 }

staker/reward_calculation_types.gno

@@ -649,5 +649,8 @@ func getTokenPairBalanceFromPosition(poolPath string, tokenId uint64) (string, s
 func getTickOf(tokenId uint64) (int32, int32) {
 	tickLower := pn.PositionGetPositionTickLower(tokenId)
 	tickUpper := pn.PositionGetPositionTickUpper(tokenId)
-	return tickLower, tickUpper
+	if tickUpper < tickLower {
+		panic(ufmt.Sprintf("tickUpper(%d) is less than tickLower(%d)", tickUpper.id, tickLower.id))
+	}
+	return tickLower.id, tickUpper.id
 }