package keeper import ( "fmt" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/kava-labs/kava/x/incentive/keeper/accumulators" "github.com/kava-labs/kava/x/incentive/types" ) // AccumulateRewards 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) AccumulateRewards( ctx sdk.Context, claimType types.ClaimType, rewardPeriod types.MultiRewardPeriod, ) error { var accumulator types.RewardAccumulator switch claimType { case types.CLAIM_TYPE_EARN: accumulator = accumulators.NewEarnAccumulator(k.Store, k.liquidKeeper, k.earnKeeper, k.Adapters) default: accumulator = accumulators.NewBasicAccumulator(k.Store, k.Adapters) } return accumulator.AccumulateRewards(ctx, claimType, rewardPeriod) } // 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.Store.GetClaim(ctx, claimType, owner) if !found { claim = types.NewClaim(claimType, owner, sdk.Coins{}, nil) } globalRewardIndexes, found := k.Store.GetRewardIndexesOfClaimType(ctx, claimType, sourceID) if !found { globalRewardIndexes = types.RewardIndexes{} } claim.RewardIndexes = claim.RewardIndexes.With(sourceID, globalRewardIndexes) k.Store.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.Dec, ) { claim, found := k.Store.GetClaim(ctx, claimType, owner) if !found { return } claim = k.synchronizeClaim(ctx, claim, sourceID, owner, shares) k.Store.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.Dec, ) types.Claim { globalRewardIndexes, found := k.Store.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) 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 } // GetSynchronizedClaim fetches a claim from the store and syncs rewards for all // rewarded sourceIDs. func (k Keeper) GetSynchronizedClaim( ctx sdk.Context, claimType types.ClaimType, owner sdk.AccAddress, ) (types.Claim, bool) { claim, found := k.Store.GetClaim(ctx, claimType, owner) if !found { return types.Claim{}, false } // Fetch all source IDs from indexes var sourceIDs []string k.Store.IterateRewardIndexesByClaimType(ctx, claimType, func(rewardIndexes types.TypedRewardIndexes) bool { sourceIDs = append(sourceIDs, rewardIndexes.CollateralType) return false }) accShares := k.Adapters.OwnerSharesBySource(ctx, claimType, owner, sourceIDs) // Synchronize claim for each source ID for _, share := range accShares { claim = k.synchronizeClaim(ctx, claim, share.ID, owner, share.Shares) } return claim, true }