0g-chain/x/incentive/keeper/rewards.go
Derrick Lee f52a581ea9
Add GetSynchronizedClaim and swap adapter (#1386)
* Add source adapters to keeper, implement GetSynchronizedClaim

* Iterate acc shares sorted

* Add swap adapter, update tests to use swap claimtype

* Add swap adapter test

* Add tests for non-empty pools

* Iterate over source ids instead of sorted keys
2022-11-14 17:55:10 -08:00

119 lines
3.9 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.Dec,
) {
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.Dec,
) 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)
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.GetClaim(ctx, claimType, owner)
if !found {
return types.Claim{}, false
}
// Fetch all source IDs from indexes
var sourceIDs []string
k.IterateRewardIndexesByClaimType(ctx, claimType, func(rewardIndexes types.TypedRewardIndexes) bool {
sourceIDs = append(sourceIDs, rewardIndexes.CollateralType)
return false
})
adapter := k.GetSourceAdapter(claimType)
accShares := adapter.OwnerSharesBySource(ctx, owner, sourceIDs)
// Synchronize claim for each source ID
for _, sourceID := range sourceIDs {
claim = k.synchronizeClaim(ctx, claim, sourceID, owner, accShares[sourceID])
}
return claim, true
}