@@ -3,6 +3,7 @@ package staker
33import (
44 "gno.land/r/gnoswap/v1/consts"
55 "gno.land/r/gnoswap/v1/gns"
6+ en "gno.land/r/gnoswap/v1/emission"
67
78 u256 "gno.land/p/gnoswap/uint256"
89)
@@ -25,49 +26,51 @@ type Reward struct {
2526}
2627
2728func calcPositionRewardByWarmups(currentHeight uint64, tokenId uint64) []Reward {
28- deposit := deposits.Get(tokenId)
29- emissionUpdateHeights, emissionUpdates := gns.EmissionUpdates(deposit.lastCollectHeight, currentHeight)
30- internalRewards, internalPenalties, externalRewards, externalPenalties := CalcPositionReward(currentHeight, tokenId, deposits, pools, poolTier, emissionUpdateHeights, emissionUpdates)
29+ rewards := CalcPositionReward(CalcPositionRewardParam{
30+ CurrentHeight: currentHeight,
31+ Deposits: deposits,
32+ Pools: pools,
33+ PoolTier: poolTier,
34+ TokenId: tokenId,
35+ })
3136
32- rewards := make([]Reward, len(internalRewards))
33- for i := range internalRewards {
34- rewards[i] = Reward{}
35- rewards[i].Internal = internalRewards[i]
36- rewards[i].InternalPenalty = internalPenalties[i]
37- if len(externalRewards) > i {
38- rewards[i].External = externalRewards[i]
39- rewards[i].ExternalPenalty = externalPenalties[i]
40- }
41- }
4237 return rewards
4338}
4439
4540func calcPositionReward(currentHeight uint64, tokenId uint64) Reward {
46- deposit := deposits.Get(tokenId)
47- emissionUpdateHeights, emissionUpdates := gns.EmissionUpdates(deposit.lastCollectHeight, currentHeight)
48- internalRewards, internalPenalties, externalRewards, externalPenalties := CalcPositionReward(currentHeight, tokenId, deposits, pools, poolTier, emissionUpdateHeights, emissionUpdates)
41+ rewards := CalcPositionReward(CalcPositionRewardParam{
42+ CurrentHeight: currentHeight,
43+ Deposits: deposits,
44+ Pools: pools,
45+ PoolTier: poolTier,
46+ TokenId: tokenId,
47+ })
4948
5049 internal := uint64(0)
51- for _, reward := range internalRewards {
52- internal += reward
50+ for _, reward := range rewards {
51+ internal += reward.Internal
5352 }
5453
5554 internalPenalty := uint64(0)
56- for _, penalty := range internalPenalties {
57- internalPenalty += penalty
55+ for _, reward := range rewards {
56+ internalPenalty += reward.InternalPenalty
5857 }
5958
6059 externalReward := make(map[string]uint64)
61- for _, external := range externalRewards {
62- for incentive, reward := range external {
63- externalReward[incentive] += reward
60+ for _, reward := range rewards {
61+ if reward.External != nil {
62+ for incentive, reward := range reward.External {
63+ externalReward[incentive] += reward
64+ }
6465 }
6566 }
6667
6768 externalPenalty := make(map[string]uint64)
68- for _, external := range externalPenalties {
69- for incentive, penalty := range external {
70- externalPenalty[incentive] += penalty
69+ for _, reward := range rewards {
70+ if reward.ExternalPenalty != nil {
71+ for incentive, penalty := range reward.ExternalPenalty {
72+ externalPenalty[incentive] += penalty
73+ }
7174 }
7275 }
7376
@@ -79,41 +82,74 @@ func calcPositionReward(currentHeight uint64, tokenId uint64) Reward {
7982 }
8083}
8184
82- func CalcPositionReward(currentHeight uint64, tokenId uint64, deposits *Deposits, pools *Pools, poolTier *PoolTier, emissionUpdateHeights []uint64, emissionUpdates []uint64) ([]uint64, []uint64, []map[string]uint64, []map[string]uint64) {
83- // cache per-tier and per-pool rewards
84- poolTier.cacheReward(currentHeight, emissionUpdateHeights, emissionUpdates)
85+ type CalcPositionRewardParam struct {
86+ // Environmental variables
87+ CurrentHeight uint64
88+ Deposits *Deposits
89+ Pools *Pools
90+ PoolTier *PoolTier
8591
86- deposit := deposits.Get(tokenId)
92+ // Position variables
93+ TokenId uint64
94+ }
95+
96+ func CalcPositionReward(param CalcPositionRewardParam) []Reward {
97+ println("===== CalcPositionReward", param.TokenId)
98+
99+ // cache per-pool rewards in the internal incentive(tiers)
100+ param.PoolTier.cacheReward(param.CurrentHeight, param.Pools)
101+
102+ deposit := param.Deposits.Get(param.TokenId)
87103 poolPath := deposit.targetPoolPath
88104
89- pool, ok := pools .Get(poolPath)
105+ pool, ok := param.Pools .Get(poolPath)
90106 if !ok {
91- pool = NewPool(poolPath, currentHeight )
92- pools .Set(poolPath, pool)
107+ pool = NewPool(poolPath, param.CurrentHeight )
108+ param.Pools .Set(poolPath, pool)
93109 }
94110
95- pool.cacheInternalReward(poolTier, currentHeight)
96-
97- pool.cacheExternalReward(currentHeight)
98-
111+ // cacheInternalReward is called by poolTier.cacheReward
112+ pool.cacheExternalReward(param.CurrentHeight)
99113 // eligible(in-range) intervals for a position
100- upperTick := pool.ticks.Get(deposit.tickUpper)
101- lowerTick := pool.ticks.Get(deposit.tickLower)
114+ // XXX: Tick ordering code, memoing for future
115+ tickUpper := deposit.tickUpper
116+ tickLower := deposit.tickLower
117+ token0, token1, _ := poolPathDivide(poolPath)
118+ if token1 < token0 {
119+ tickUpper, tickLower = -tickLower, -tickUpper
120+ }
121+ upperTick := pool.ticks.Get(tickUpper)
122+ lowerTick := pool.ticks.Get(tickLower)
123+ // XXX: Tick ordering code, memoing for future
102124
103125 lastCollectHeight := deposit.lastCollectHeight
126+ println("===== lastCollectHeight", param.TokenId, lastCollectHeight)
104127
105128 initialUpperCross := upperTick.previousCross(lastCollectHeight)
106129 initialLowerCross := lowerTick.previousCross(lastCollectHeight)
107130 currentlyInRange := initialUpperCross && !initialLowerCross
108131
109- tickUpperCrosses := upperTick.crossInfo(lastCollectHeight, currentHeight )
110- tickLowerCrosses := lowerTick.crossInfo(lastCollectHeight, currentHeight )
132+ tickUpperCrosses := upperTick.crossInfo(lastCollectHeight, param.CurrentHeight )
133+ tickLowerCrosses := lowerTick.crossInfo(lastCollectHeight, param.CurrentHeight )
111134
112- internalRewards, internalPenalties := pool.InternalRewardOf(deposit).Calculate(int64(lastCollectHeight), int64(currentHeight ), currentlyInRange, tickUpperCrosses, tickLowerCrosses)
135+ internalRewards, internalPenalties := pool.InternalRewardOf(deposit).Calculate(int64(lastCollectHeight), int64(param.CurrentHeight ), currentlyInRange, tickUpperCrosses, tickLowerCrosses)
113136
114- externalRewards, externalPenalties := pool.ExternalRewardOf(deposit).Calculate(int64(lastCollectHeight), int64(currentHeight ), currentlyInRange, tickUpperCrosses, tickLowerCrosses)
137+ externalRewards, externalPenalties := pool.ExternalRewardOf(deposit).Calculate(int64(lastCollectHeight), int64(param.CurrentHeight ), currentlyInRange, tickUpperCrosses, tickLowerCrosses)
115138
116- return internalRewards, internalPenalties, externalRewards, externalPenalties
139+ rewards := make([]Reward, len(internalRewards))
140+ for i := range internalRewards {
141+ rewards[i] = Reward{
142+ Internal: internalRewards[i],
143+ InternalPenalty: internalPenalties[i],
144+ }
145+ if externalRewards != nil {
146+ if len(externalRewards[i]) > 0 {
147+ rewards[i].External = externalRewards[i]
148+ rewards[i].ExternalPenalty = externalPenalties[i]
149+ }
150+ }
151+ }
152+ return rewards
117153}
118154
119155func ProcessUnClaimableReward(poolPath string, endHeight uint64) (uint64, map[string]uint64) {
0 commit comments