/
rewards_earn.go
363 lines (303 loc) · 11.1 KB
/
rewards_earn.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
package keeper
import (
"errors"
"fmt"
"sort"
"time"
sdkmath "cosmossdk.io/math"
sdk "github.com/cosmos/cosmos-sdk/types"
earntypes "github.com/zeta-protocol/black/x/earn/types"
"github.com/zeta-protocol/black/x/incentive/types"
distrtypes "github.com/cosmos/cosmos-sdk/x/distribution/types"
)
// AccumulateEarnRewards calculates new rewards to distribute this block and updates the global indexes to reflect this.
// The provided rewardPeriod must be valid to avoid panics in calculating time durations.
func (k Keeper) AccumulateEarnRewards(ctx sdk.Context, rewardPeriod types.MultiRewardPeriod) error {
if rewardPeriod.CollateralType == "bfury" {
return k.accumulateEarnBblackRewards(ctx, rewardPeriod)
}
k.accumulateEarnRewards(
ctx,
rewardPeriod.CollateralType,
rewardPeriod.Start,
rewardPeriod.End,
sdk.NewDecCoinsFromCoins(rewardPeriod.RewardsPerSecond...),
)
return nil
}
func GetProportionalRewardsPerSecond(
rewardPeriod types.MultiRewardPeriod,
totalBblackSupply sdkmath.Int,
singleBblackSupply sdkmath.Int,
) sdk.DecCoins {
// Rate per bfury-xxx = rewardsPerSecond * % of bfury-xxx
// = rewardsPerSecond * (bfury-xxx / total bfury)
// = (rewardsPerSecond * bfury-xxx) / total bfury
newRate := sdk.NewDecCoins()
// Prevent division by zero, if there are no total shares then there are no
// rewards.
if totalBblackSupply.IsZero() {
return newRate
}
for _, rewardCoin := range rewardPeriod.RewardsPerSecond {
scaledAmount := sdk.NewDecFromInt(rewardCoin.Amount).
Mul(sdk.NewDecFromInt(singleBblackSupply)).
Quo(sdk.NewDecFromInt(totalBblackSupply))
newRate = newRate.Add(sdk.NewDecCoinFromDec(rewardCoin.Denom, scaledAmount))
}
return newRate
}
// accumulateEarnBblackRewards does the same as AccumulateEarnRewards but for
// *all* bfury vaults.
func (k Keeper) accumulateEarnBblackRewards(ctx sdk.Context, rewardPeriod types.MultiRewardPeriod) error {
// All bfury vault denoms
bfuryVaultsDenoms := make(map[string]bool)
// bfury vault denoms from earn records (non-empty vaults)
k.earnKeeper.IterateVaultRecords(ctx, func(record earntypes.VaultRecord) (stop bool) {
if k.liquidKeeper.IsDerivativeDenom(ctx, record.TotalShares.Denom) {
bfuryVaultsDenoms[record.TotalShares.Denom] = true
}
return false
})
// bfury vault denoms from past incentive indexes, may include vaults
// that were fully withdrawn.
k.IterateEarnRewardIndexes(ctx, func(vaultDenom string, indexes types.RewardIndexes) (stop bool) {
if k.liquidKeeper.IsDerivativeDenom(ctx, vaultDenom) {
bfuryVaultsDenoms[vaultDenom] = true
}
return false
})
totalBblackValue, err := k.liquidKeeper.GetTotalDerivativeValue(ctx)
if err != nil {
return err
}
i := 0
sortedBblackVaultsDenoms := make([]string, len(bfuryVaultsDenoms))
for vaultDenom := range bfuryVaultsDenoms {
sortedBblackVaultsDenoms[i] = vaultDenom
i++
}
// Sort the vault denoms to ensure deterministic iteration order.
sort.Strings(sortedBblackVaultsDenoms)
// Accumulate rewards for each bfury vault.
for _, bfuryDenom := range sortedBblackVaultsDenoms {
derivativeValue, err := k.liquidKeeper.GetDerivativeValue(ctx, bfuryDenom)
if err != nil {
return err
}
k.accumulateBblackEarnRewards(
ctx,
bfuryDenom,
rewardPeriod.Start,
rewardPeriod.End,
GetProportionalRewardsPerSecond(
rewardPeriod,
totalBblackValue.Amount,
derivativeValue.Amount,
),
)
}
return nil
}
func (k Keeper) accumulateBblackEarnRewards(
ctx sdk.Context,
collateralType string,
periodStart time.Time,
periodEnd time.Time,
periodRewardsPerSecond sdk.DecCoins,
) {
// Collect staking rewards for this validator, does not have any start/end
// period time restrictions.
stakingRewards := k.collectDerivativeStakingRewards(ctx, collateralType)
// Collect incentive rewards
// **Total rewards** for vault per second, NOT per share
perSecondRewards := k.collectPerSecondRewards(
ctx,
collateralType,
periodStart,
periodEnd,
periodRewardsPerSecond,
)
// **Total rewards** for vault per second, NOT per share
rewards := stakingRewards.Add(perSecondRewards...)
// Distribute rewards by incrementing indexes
indexes, found := k.GetEarnRewardIndexes(ctx, collateralType)
if !found {
indexes = types.RewardIndexes{}
}
totalSourceShares := k.getEarnTotalSourceShares(ctx, collateralType)
var increment types.RewardIndexes
if totalSourceShares.GT(sdk.ZeroDec()) {
// Divide total rewards by total shares to get the reward **per share**
// Leave as nil if no source shares
increment = types.NewRewardIndexesFromCoins(rewards).Quo(totalSourceShares)
}
updatedIndexes := indexes.Add(increment)
if len(updatedIndexes) > 0 {
// the store panics when setting empty or nil indexes
k.SetEarnRewardIndexes(ctx, collateralType, updatedIndexes)
}
}
func (k Keeper) collectDerivativeStakingRewards(ctx sdk.Context, collateralType string) sdk.DecCoins {
rewards, err := k.liquidKeeper.CollectStakingRewardsByDenom(ctx, collateralType, types.IncentiveMacc)
if err != nil {
if !errors.Is(err, distrtypes.ErrNoValidatorDistInfo) &&
!errors.Is(err, distrtypes.ErrEmptyDelegationDistInfo) {
panic(fmt.Sprintf("failed to collect staking rewards for %s: %s", collateralType, err))
}
// otherwise there's no validator or delegation yet
rewards = nil
}
// Bug with NewDecCoinsFromCoins when calling passing 0 amount Coin, see
// https://github.com/cosmos/cosmos-sdk/pull/12903
// Fix is in Cosmos-SDK v0.47.0
var decCoins sdk.DecCoins
for _, coin := range rewards {
if coin.IsValid() {
decCoins = append(decCoins, sdk.NewDecCoinFromCoin(coin))
}
}
return decCoins
}
func (k Keeper) collectPerSecondRewards(
ctx sdk.Context,
collateralType string,
periodStart time.Time,
periodEnd time.Time,
periodRewardsPerSecond sdk.DecCoins,
) sdk.DecCoins {
previousAccrualTime, found := k.GetEarnRewardAccrualTime(ctx, collateralType)
if !found {
previousAccrualTime = ctx.BlockTime()
}
rewards, accumulatedTo := types.CalculatePerSecondRewards(
periodStart,
periodEnd,
periodRewardsPerSecond,
previousAccrualTime,
ctx.BlockTime(),
)
k.SetEarnRewardAccrualTime(ctx, collateralType, accumulatedTo)
// Don't need to move funds as they're assumed to be in the IncentiveMacc module account already.
return rewards
}
func (k Keeper) accumulateEarnRewards(
ctx sdk.Context,
collateralType string,
periodStart time.Time,
periodEnd time.Time,
periodRewardsPerSecond sdk.DecCoins,
) {
previousAccrualTime, found := k.GetEarnRewardAccrualTime(ctx, collateralType)
if !found {
previousAccrualTime = ctx.BlockTime()
}
indexes, found := k.GetEarnRewardIndexes(ctx, collateralType)
if !found {
indexes = types.RewardIndexes{}
}
acc := types.NewAccumulator(previousAccrualTime, indexes)
totalSourceShares := k.getEarnTotalSourceShares(ctx, collateralType)
acc.AccumulateDecCoins(
periodStart,
periodEnd,
periodRewardsPerSecond,
totalSourceShares,
ctx.BlockTime(),
)
k.SetEarnRewardAccrualTime(ctx, collateralType, acc.PreviousAccumulationTime)
if len(acc.Indexes) > 0 {
// the store panics when setting empty or nil indexes
k.SetEarnRewardIndexes(ctx, collateralType, acc.Indexes)
}
}
// getEarnTotalSourceShares fetches the sum of all source shares for a earn reward.
// In the case of earn, these are the total (earn module) shares in a particular vault.
func (k Keeper) getEarnTotalSourceShares(ctx sdk.Context, vaultDenom string) sdk.Dec {
totalShares, found := k.earnKeeper.GetVaultTotalShares(ctx, vaultDenom)
if !found {
return sdk.ZeroDec()
}
return totalShares.Amount
}
// InitializeEarnReward creates a new claim with zero rewards and indexes matching the global indexes.
// If the claim already exists it just updates the indexes.
func (k Keeper) InitializeEarnReward(ctx sdk.Context, vaultDenom string, owner sdk.AccAddress) {
claim, found := k.GetEarnClaim(ctx, owner)
if !found {
claim = types.NewEarnClaim(owner, sdk.Coins{}, nil)
}
globalRewardIndexes, found := k.GetEarnRewardIndexes(ctx, vaultDenom)
if !found {
globalRewardIndexes = types.RewardIndexes{}
}
claim.RewardIndexes = claim.RewardIndexes.With(vaultDenom, globalRewardIndexes)
k.SetEarnClaim(ctx, claim)
}
// SynchronizeEarnReward updates the claim object by adding any accumulated rewards
// and updating the reward index value.
func (k Keeper) SynchronizeEarnReward(
ctx sdk.Context,
vaultDenom string,
owner sdk.AccAddress,
shares sdk.Dec,
) {
claim, found := k.GetEarnClaim(ctx, owner)
if !found {
return
}
claim = k.synchronizeEarnReward(ctx, claim, vaultDenom, owner, shares)
k.SetEarnClaim(ctx, claim)
}
// synchronizeEarnReward updates the reward and indexes in a earn claim for one vault.
func (k *Keeper) synchronizeEarnReward(
ctx sdk.Context,
claim types.EarnClaim,
vaultDenom string,
owner sdk.AccAddress,
shares sdk.Dec,
) types.EarnClaim {
globalRewardIndexes, found := k.GetEarnRewardIndexes(ctx, vaultDenom)
if !found {
// The global factor is only not found if
// - the vault has not started accumulating rewards yet (either there is no reward specified in params, or the reward start time hasn't been hit)
// - OR it was wrongly deleted from state (factors should never be removed while unsynced claims exist)
// If not found we could either skip this sync, or assume the global factor is zero.
// Skipping will avoid storing unnecessary factors in the claim for non rewarded vaults.
// And in the event a global factor is wrongly deleted, it will avoid this function panicking when calculating rewards.
return claim
}
userRewardIndexes, found := claim.RewardIndexes.Get(vaultDenom)
if !found {
// Normally the reward indexes should always be found.
// But if a vault was not rewarded then becomes rewarded (ie a reward period is added to params), then the indexes will be missing from claims for that vault.
// So given the reward period was just added, assume the starting value for any global reward indexes, which is an empty slice.
userRewardIndexes = types.RewardIndexes{}
}
newRewards, err := k.CalculateRewards(userRewardIndexes, globalRewardIndexes, shares)
if err != nil {
// Global reward factors should never decrease, as it would lead to a negative update to claim.Rewards.
// This panics if a global reward factor decreases or disappears between the old and new indexes.
panic(fmt.Sprintf("corrupted global reward indexes found: %v", err))
}
claim.Reward = claim.Reward.Add(newRewards...)
claim.RewardIndexes = claim.RewardIndexes.With(vaultDenom, globalRewardIndexes)
return claim
}
// GetSynchronizedEarnClaim fetches a earn claim from the store and syncs rewards for all rewarded vaults.
func (k Keeper) GetSynchronizedEarnClaim(ctx sdk.Context, owner sdk.AccAddress) (types.EarnClaim, bool) {
claim, found := k.GetEarnClaim(ctx, owner)
if !found {
return types.EarnClaim{}, false
}
shares, found := k.earnKeeper.GetVaultAccountShares(ctx, owner)
if !found {
shares = earntypes.NewVaultShares()
}
k.IterateEarnRewardIndexes(ctx, func(vaultDenom string, _ types.RewardIndexes) bool {
vaultAmount := shares.AmountOf(vaultDenom)
claim = k.synchronizeEarnReward(ctx, claim, vaultDenom, owner, vaultAmount)
return false
})
return claim, true
}