mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-10-04 16:35:18 +00:00
c2061f626e
* Add init/sync claim methods * Add todo * Make GetSynchronizedClaim method todo * Remove GetSynchronizedClaim Work moved to different task * Update GetRewardIndexesOfClaimType method
89 lines
3.1 KiB
Go
89 lines
3.1 KiB
Go
package keeper
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
"github.com/kava-labs/kava/x/incentive/types"
|
|
)
|
|
|
|
// InitializeClaim 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) InitializeClaim(
|
|
ctx sdk.Context,
|
|
claimType types.ClaimType,
|
|
sourceID string,
|
|
owner sdk.AccAddress,
|
|
) {
|
|
claim, found := k.GetClaim(ctx, claimType, owner)
|
|
if !found {
|
|
claim = types.NewClaim(claimType, owner, sdk.Coins{}, nil)
|
|
}
|
|
|
|
globalRewardIndexes, found := k.GetRewardIndexesOfClaimType(ctx, claimType, sourceID)
|
|
if !found {
|
|
globalRewardIndexes = types.RewardIndexes{}
|
|
}
|
|
|
|
claim.RewardIndexes = claim.RewardIndexes.With(sourceID, globalRewardIndexes)
|
|
k.SetClaim(ctx, claim)
|
|
}
|
|
|
|
// SynchronizeClaim updates the claim object by adding any accumulated rewards
|
|
// and updating the reward index value.
|
|
func (k Keeper) SynchronizeClaim(
|
|
ctx sdk.Context,
|
|
claimType types.ClaimType,
|
|
sourceID string,
|
|
owner sdk.AccAddress,
|
|
shares sdk.Int,
|
|
) {
|
|
claim, found := k.GetClaim(ctx, claimType, owner)
|
|
if !found {
|
|
return
|
|
}
|
|
|
|
claim = k.synchronizeClaim(ctx, claim, sourceID, owner, shares)
|
|
k.SetClaim(ctx, claim)
|
|
}
|
|
|
|
// synchronizeClaim updates the reward and indexes in a claim for one sourceID.
|
|
func (k *Keeper) synchronizeClaim(
|
|
ctx sdk.Context,
|
|
claim types.Claim,
|
|
sourceID string,
|
|
owner sdk.AccAddress,
|
|
shares sdk.Int,
|
|
) types.Claim {
|
|
globalRewardIndexes, found := k.GetRewardIndexesOfClaimType(ctx, claim.Type, sourceID)
|
|
if !found {
|
|
// The global factor is only not found if
|
|
// - the pool 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 pools.
|
|
// 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(sourceID)
|
|
if !found {
|
|
// Normally the reward indexes should always be found.
|
|
// But if a pool was not rewarded then becomes rewarded (ie a reward period is added to params), then the indexes will be missing from claims for that pool.
|
|
// 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.ToDec())
|
|
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(sourceID, globalRewardIndexes)
|
|
|
|
return claim
|
|
}
|