reward_manager.gno

  1package launchpad
  2
  3import (
  4	"errors"
  5
  6	ufmt "gno.land/p/nt/ufmt/v0"
  7	"gno.land/r/gnoswap/launchpad"
  8
  9	gnsmath "gno.land/p/gnoswap/gnsmath/v1"
 10	u256 "gno.land/p/gnoswap/uint256/v1"
 11)
 12
 13// Helper functions for RewardManager
 14
 15func isRewardManagerInitialized(r *launchpad.RewardManager) bool {
 16	return r.Rewards().Size() > 0
 17}
 18
 19// isPreDepositRewardRefundable reports whether rewards accrued without any
 20// deposit are left unallocated. newRewardManager marks this by starting the
 21// accumulated time at the distribute start time.
 22func isPreDepositRewardRefundable(r *launchpad.RewardManager) bool {
 23	return r.AccumulatedTime() > 0
 24}
 25
 26func getDepositRewardState(r *launchpad.RewardManager, depositId string) (*launchpad.RewardState, error) {
 27	rewardStateI := r.Rewards().Get(depositId)
 28	if rewardStateI == nil {
 29		return nil, makeErrorWithDetails(errNotExistDeposit, ufmt.Sprintf("(%s)", depositId))
 30	}
 31
 32	rewardState, ok := rewardStateI.(*launchpad.RewardState)
 33	if !ok {
 34		return nil, ufmt.Errorf("failed to cast rewardState to *launchpad.RewardState: %T", rewardStateI)
 35	}
 36
 37	return rewardState, nil
 38}
 39
 40func calculateRewardPerDepositX128(r *launchpad.RewardManager, rewardPerSecondX128 *u256.Uint, totalStaked int64, currentTime int64) (*u256.Uint, error) {
 41	accumulatedTime := r.AccumulatedTime()
 42	if r.DistributeStartTime() > accumulatedTime {
 43		accumulatedTime = r.DistributeStartTime()
 44	}
 45
 46	// not started yet
 47	if currentTime < accumulatedTime {
 48		return u256.Zero(), nil
 49	}
 50
 51	// past distribute end time
 52	if accumulatedTime > r.DistributeEndTime() {
 53		return u256.Zero(), nil
 54	}
 55
 56	// past distribute end time, set to distribute end time
 57	if currentTime > r.DistributeEndTime() {
 58		currentTime = r.DistributeEndTime()
 59	}
 60
 61	if rewardPerSecondX128.IsZero() {
 62		return nil, makeErrorWithDetails(
 63			errNoLeftReward,
 64			ufmt.Sprintf("rewardPerSecond(%d)", rewardPerSecondX128),
 65		)
 66	}
 67
 68	// no left reward
 69	if totalStaked == 0 {
 70		return u256.Zero(), nil
 71	}
 72
 73	// timeDuration * rewardPerSecond / totalStaked
 74	timeDuration := currentTime - accumulatedTime
 75	rewardPerDepositX128 := u256.MulDiv(
 76		u256.NewUintFromInt64(timeDuration),
 77		rewardPerSecondX128,
 78		u256.NewUintFromInt64(totalStaked),
 79	)
 80
 81	return rewardPerDepositX128, nil
 82}
 83
 84func addRewardStateByDeposit(r *launchpad.RewardManager, deposit launchpad.Deposit) *launchpad.RewardState {
 85	// Pre-start deposits accrue rewards from the distribute start time.
 86	adjustedDistributeStartTime := deposit.CreatedAt()
 87	if adjustedDistributeStartTime < r.DistributeStartTime() {
 88		adjustedDistributeStartTime = r.DistributeStartTime()
 89	}
 90
 91	claimableTime := adjustedDistributeStartTime + r.RewardClaimableDuration()
 92	if claimableTime > r.DistributeEndTime() {
 93		claimableTime = r.DistributeEndTime()
 94	}
 95
 96	rewardState := launchpad.NewRewardState(
 97		r.AccumulatedRewardPerDepositX128().Clone(),
 98		deposit.DepositAmount(),
 99		adjustedDistributeStartTime,
100		r.DistributeEndTime(),
101		claimableTime,
102	)
103
104	// if the first deposit, set the distribute start time
105	if !isRewardManagerInitialized(r) {
106		rewardState.SetDistributeStartTime(r.DistributeStartTime())
107		rewardState.SetDistributeEndTime(r.DistributeEndTime())
108		rewardState.SetAccumulatedTime(r.DistributeStartTime())
109		rewardState.SetPriceDebtX128(u256.Zero())
110	}
111
112	return addRewardState(r, deposit, rewardState)
113}
114
115func addRewardState(r *launchpad.RewardManager, deposit launchpad.Deposit, rewardState *launchpad.RewardState) *launchpad.RewardState {
116	addActiveRewardState(r, rewardState)
117	r.SetReward(deposit.ID(), rewardState)
118
119	return rewardState
120}
121
122func removeRewardState(r *launchpad.RewardManager, depositId string) error {
123	rewardState, err := getDepositRewardState(r, depositId)
124	if err != nil {
125		return err
126	}
127
128	removeActiveRewardState(r, rewardState)
129	r.RemoveReward(depositId)
130	return nil
131}
132
133func addActiveRewardState(r *launchpad.RewardManager, rewardState *launchpad.RewardState) {
134	debt, overflow := u256.Zero().MulOverflow(
135		rewardState.PriceDebtX128(),
136		u256.NewUintFromInt64(rewardState.DepositAmount()),
137	)
138	if overflow {
139		panic(errors.New(errOverflow))
140	}
141
142	r.SetActiveDepositAmount(gnsmath.SafeAddInt64(r.ActiveDepositAmount(), rewardState.DepositAmount()))
143	r.SetActivePriceDebtX128(u256.Zero().Add(r.ActivePriceDebtX128(), debt))
144}
145
146func removeActiveRewardState(r *launchpad.RewardManager, rewardState *launchpad.RewardState) {
147	debt, overflow := u256.Zero().MulOverflow(
148		rewardState.PriceDebtX128(),
149		u256.NewUintFromInt64(rewardState.DepositAmount()),
150	)
151	if overflow {
152		panic(errors.New(errOverflow))
153	}
154
155	r.SetActiveDepositAmount(gnsmath.SafeSubInt64(r.ActiveDepositAmount(), rewardState.DepositAmount()))
156	r.SetActiveClaimedAmount(gnsmath.SafeSubInt64(r.ActiveClaimedAmount(), rewardState.ClaimedAmount()))
157	r.SetActivePriceDebtX128(u256.Zero().Sub(r.ActivePriceDebtX128(), debt))
158}
159
160func addRewardPerDepositX128(r *launchpad.RewardManager, rewardPerDepositX128 *u256.Uint, currentTime int64) error {
161	if rewardPerDepositX128.IsZero() {
162		return nil
163	}
164
165	if r.AccumulatedTime() > currentTime || r.DistributeStartTime() > currentTime {
166		return nil
167	}
168
169	if currentTime > r.DistributeEndTime() {
170		currentTime = r.DistributeEndTime()
171	}
172
173	accumulated := u256.Zero().Add(r.AccumulatedRewardPerDepositX128(), rewardPerDepositX128)
174	r.SetAccumulatedRewardPerDepositX128(accumulated)
175	r.SetAccumulatedTime(currentTime)
176
177	return nil
178}
179
180// updateRewardPerDepositX128 updates the reward per deposit state.
181// This function calculates and updates the accumulated reward per deposit
182// based on the current total deposit amount and time.
183//
184// Parameters:
185// - totalDepositAmount (int64): Current total deposit amount
186// - time (int64): Current timestamp
187//
188// Returns:
189// - error: If the update fails
190func updateRewardPerDepositX128(r *launchpad.RewardManager, totalDepositAmount int64, currentTime int64) error {
191	if currentTime <= 0 {
192		return makeErrorWithDetails(errInvalidTime, "time must be positive")
193	}
194
195	// Calculate and update rewards
196	rewardPerDepositX128, err := calculateRewardPerDepositX128(
197		r,
198		r.DistributeAmountPerSecondX128(),
199		totalDepositAmount,
200		currentTime,
201	)
202	if err != nil {
203		return err
204	}
205
206	// Without deposits, only advance the accumulated time so that the rewards
207	// of this period stay refundable instead of going to the next depositor.
208	if totalDepositAmount == 0 && isPreDepositRewardRefundable(r) {
209		if currentTime > r.DistributeEndTime() {
210			currentTime = r.DistributeEndTime()
211		}
212
213		if currentTime > r.AccumulatedTime() {
214			r.SetAccumulatedTime(currentTime)
215		}
216
217		return nil
218	}
219
220	err = addRewardPerDepositX128(r, rewardPerDepositX128, currentTime)
221	if err != nil {
222		return err
223	}
224
225	return nil
226}
227
228func updateDistributeAmountPerSecondX128(r *launchpad.RewardManager, totalDistributeAmount int64, distributeStartTime int64, distributeEndTime int64) {
229	// Use time duration for per-second calculation
230	timeDuration := distributeEndTime - distributeStartTime
231	if timeDuration <= 0 {
232		return
233	}
234
235	totalDistributeAmountX128 := u256.Zero().Lsh(
236		u256.NewUintFromInt64(totalDistributeAmount),
237		128,
238	)
239
240	// Divide by time duration in seconds
241	amountPerSecondX128 := u256.Zero().Div(
242		totalDistributeAmountX128,
243		u256.NewUintFromInt64(timeDuration),
244	)
245
246	r.SetDistributeAmountPerSecondX128(amountPerSecondX128)
247	r.SetDistributeStartTime(distributeStartTime)
248	r.SetDistributeEndTime(distributeEndTime)
249}
250
251// collectReward processes the reward collection for a specific deposit.
252// This function ensures that the reward collection is valid and updates
253// the claimed amount accordingly.
254//
255// Parameters:
256// - depositId (string): The ID of the deposit
257// - currentTime (int64): Current timestamp
258//
259// Returns:
260// - int64: The amount of reward collected
261// - error: If the collection fails
262func collectReward(r *launchpad.RewardManager, depositId string, currentTime int64) (int64, error) {
263	if currentTime < r.AccumulatedTime() {
264		return 0, makeErrorWithDetails(
265			errInvalidRewardState,
266			ufmt.Sprintf("currentTime %d is less than AccumulatedTime %d", currentTime, r.AccumulatedTime()),
267		)
268	}
269
270	rewardState, err := getDepositRewardState(r, depositId)
271	if err != nil {
272		return 0, err
273	}
274
275	if !isRewardStateClaimable(rewardState, currentTime) {
276		return 0, makeErrorWithDetails(
277			errInvalidRewardState,
278			ufmt.Sprintf("currentTime %d is less than claimableTime %d", currentTime, rewardState.ClaimableTime()),
279		)
280	}
281
282	if currentTime < rewardState.DistributeStartTime() {
283		return 0, makeErrorWithDetails(
284			errInvalidRewardState,
285			ufmt.Sprintf("currentTime %d is less than DistributeStartTime %d", currentTime, rewardState.DistributeStartTime()),
286		)
287	}
288
289	claimableReward := calculateClaimableReward(rewardState, r.AccumulatedRewardPerDepositX128())
290	if claimableReward == 0 {
291		return 0, nil
292	}
293
294	rewardState.SetClaimedAmount(rewardState.ClaimedAmount() + claimableReward)
295	rewards := r.Rewards()
296	rewards.Set(depositId, rewardState)
297	r.SetRewards(rewards)
298	r.SetTotalClaimedAmount(r.TotalClaimedAmount() + claimableReward)
299	r.SetActiveClaimedAmount(gnsmath.SafeAddInt64(r.ActiveClaimedAmount(), claimableReward))
300
301	return claimableReward, nil
302}
303
304// newRewardManager returns a pointer to a new RewardManager with the given values.
305func newRewardManager(
306	totalDistributeAmount int64,
307	distributeStartTime int64,
308	distributeEndTime int64,
309	rewardCollectableDuration int64,
310) *launchpad.RewardManager {
311	manager := launchpad.NewRewardManager(totalDistributeAmount, distributeStartTime, distributeEndTime, rewardCollectableDuration)
312
313	updateDistributeAmountPerSecondX128(manager, totalDistributeAmount, distributeStartTime, distributeEndTime)
314	manager.SetAccumulatedTime(distributeStartTime)
315
316	return manager
317}
318
319// calculateMaximumClaimableRewardsForActiveDeposits reserves every active
320// claim without traversing the attacker-controlled reward tree. Aggregating
321// before Q128 truncation retains rounding dust but cannot under-reserve claims.
322func calculateMaximumClaimableRewardsForActiveDeposits(r *launchpad.RewardManager) int64 {
323	reward, overflow := u256.Zero().MulOverflow(
324		r.AccumulatedRewardPerDepositX128(),
325		u256.NewUintFromInt64(r.ActiveDepositAmount()),
326	)
327	if overflow {
328		panic(errors.New(errOverflow))
329	}
330
331	reward = reward.Sub(reward, r.ActivePriceDebtX128()).Rsh(reward, 128)
332	totalReward := gnsmath.SafeConvertToInt64(reward)
333	if totalReward <= r.ActiveClaimedAmount() {
334		return 0
335	}
336
337	return gnsmath.SafeSubInt64(totalReward, r.ActiveClaimedAmount())
338}