mirror of
https://github.com/0glabs/0g-chain.git
synced 2024-10-04 08:25:18 +00:00
3fc2a63556
* update claim attribute type to MultiRewardIndexes * update param attribute type to MultiRewardPeriods * keeper: update params to match types * keeper: update delegator core keeper methods * keeper: update InitializeHardDelegatorReward * keeper: update SynchronizeHardDelegatorRewards * remove reward factor in favor of reward indexes * update querier * fix test: delegator init test * fix test: delegator sync test * implement delegator reward accumulation * fix test: delegator general tests * add legact types, update v0_11 -> v0_14 migration * remove duplicate import form v0_15 migration * implement v0_15incentive migration * test data and migration test * add multiple reward denoms to init/sync tests * update delegator test with multiple reward coins * clean up simulation sync * types: introduce DelegatorClaim, refactor HardClaim * add core DelegateClaim store methods * refactor delegator reward init, accumulation, sync * update hooks * update params and genesis logic * update abci * update types tests * update querier types/keeper for compile * update supply rewards tests * update borrow reward tests * update delegator reward tests * update handler/genesis test for compile * add new msg type * implement delegator claim payouts * submission + handling of new msg * implement new querier types/keeper logic * add new queries to cli/rest * update migration * register new msgs/types on codec * remove delegator syncing from hard sync method
229 lines
8.0 KiB
Go
229 lines
8.0 KiB
Go
package incentive
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
"github.com/kava-labs/kava/x/incentive/keeper"
|
|
"github.com/kava-labs/kava/x/incentive/types"
|
|
)
|
|
|
|
// InitGenesis initializes the store state from a genesis state.
|
|
func InitGenesis(ctx sdk.Context, k keeper.Keeper, supplyKeeper types.SupplyKeeper, cdpKeeper types.CdpKeeper, gs types.GenesisState) {
|
|
|
|
// check if the module account exists
|
|
moduleAcc := supplyKeeper.GetModuleAccount(ctx, types.IncentiveMacc)
|
|
if moduleAcc == nil {
|
|
panic(fmt.Sprintf("%s module account has not been set", types.IncentiveMacc))
|
|
}
|
|
|
|
if err := gs.Validate(); err != nil {
|
|
panic(fmt.Sprintf("failed to validate %s genesis state: %s", types.ModuleName, err))
|
|
}
|
|
|
|
for _, rp := range gs.Params.USDXMintingRewardPeriods {
|
|
_, found := cdpKeeper.GetCollateral(ctx, rp.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("usdx minting collateral type %s not found in cdp collateral types", rp.CollateralType))
|
|
}
|
|
k.SetUSDXMintingRewardFactor(ctx, rp.CollateralType, sdk.ZeroDec())
|
|
}
|
|
|
|
for _, mrp := range gs.Params.HardSupplyRewardPeriods {
|
|
newRewardIndexes := types.RewardIndexes{}
|
|
for _, rc := range mrp.RewardsPerSecond {
|
|
ri := types.NewRewardIndex(rc.Denom, sdk.ZeroDec())
|
|
newRewardIndexes = append(newRewardIndexes, ri)
|
|
}
|
|
k.SetHardSupplyRewardIndexes(ctx, mrp.CollateralType, newRewardIndexes)
|
|
}
|
|
|
|
for _, mrp := range gs.Params.HardBorrowRewardPeriods {
|
|
newRewardIndexes := types.RewardIndexes{}
|
|
for _, rc := range mrp.RewardsPerSecond {
|
|
ri := types.NewRewardIndex(rc.Denom, sdk.ZeroDec())
|
|
newRewardIndexes = append(newRewardIndexes, ri)
|
|
}
|
|
k.SetHardBorrowRewardIndexes(ctx, mrp.CollateralType, newRewardIndexes)
|
|
}
|
|
|
|
for _, drp := range gs.Params.DelegatorRewardPeriods {
|
|
newRewardIndexes := types.RewardIndexes{}
|
|
for _, rc := range drp.RewardsPerSecond {
|
|
ri := types.NewRewardIndex(rc.Denom, sdk.ZeroDec())
|
|
newRewardIndexes = append(newRewardIndexes, ri)
|
|
}
|
|
k.SetDelegatorRewardIndexes(ctx, drp.CollateralType, newRewardIndexes)
|
|
}
|
|
|
|
k.SetParams(ctx, gs.Params)
|
|
|
|
for _, gat := range gs.USDXAccumulationTimes {
|
|
k.SetPreviousUSDXMintingAccrualTime(ctx, gat.CollateralType, gat.PreviousAccumulationTime)
|
|
}
|
|
|
|
for _, gat := range gs.HardSupplyAccumulationTimes {
|
|
k.SetPreviousHardSupplyRewardAccrualTime(ctx, gat.CollateralType, gat.PreviousAccumulationTime)
|
|
}
|
|
|
|
for _, gat := range gs.HardBorrowAccumulationTimes {
|
|
k.SetPreviousHardBorrowRewardAccrualTime(ctx, gat.CollateralType, gat.PreviousAccumulationTime)
|
|
}
|
|
|
|
for _, gat := range gs.DelegatorAccumulationTimes {
|
|
k.SetPreviousDelegatorRewardAccrualTime(ctx, gat.CollateralType, gat.PreviousAccumulationTime)
|
|
}
|
|
for _, gat := range gs.SwapAccumulationTimes {
|
|
k.SetSwapRewardAccrualTime(ctx, gat.CollateralType, gat.PreviousAccumulationTime)
|
|
}
|
|
|
|
for i, claim := range gs.USDXMintingClaims {
|
|
for j, ri := range claim.RewardIndexes {
|
|
if ri.RewardFactor != sdk.ZeroDec() {
|
|
gs.USDXMintingClaims[i].RewardIndexes[j].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
k.SetUSDXMintingClaim(ctx, claim)
|
|
}
|
|
|
|
for i, claim := range gs.HardLiquidityProviderClaims {
|
|
for j, mri := range claim.SupplyRewardIndexes {
|
|
for k, ri := range mri.RewardIndexes {
|
|
if ri.RewardFactor != sdk.ZeroDec() {
|
|
gs.HardLiquidityProviderClaims[i].SupplyRewardIndexes[j].RewardIndexes[k].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
}
|
|
for j, mri := range claim.BorrowRewardIndexes {
|
|
for k, ri := range mri.RewardIndexes {
|
|
if ri.RewardFactor != sdk.ZeroDec() {
|
|
gs.HardLiquidityProviderClaims[i].BorrowRewardIndexes[j].RewardIndexes[k].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
}
|
|
k.SetHardLiquidityProviderClaim(ctx, claim)
|
|
}
|
|
|
|
for i, claim := range gs.DelegatorClaims {
|
|
for j, mri := range claim.RewardIndexes {
|
|
for k, ri := range mri.RewardIndexes {
|
|
if ri.RewardFactor != sdk.ZeroDec() {
|
|
gs.DelegatorClaims[i].RewardIndexes[j].RewardIndexes[k].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
}
|
|
k.SetDelegatorClaim(ctx, claim)
|
|
}
|
|
}
|
|
|
|
// ExportGenesis export genesis state for incentive module
|
|
func ExportGenesis(ctx sdk.Context, k keeper.Keeper) types.GenesisState {
|
|
params := k.GetParams(ctx)
|
|
|
|
usdxClaims := k.GetAllUSDXMintingClaims(ctx)
|
|
hardClaims := k.GetAllHardLiquidityProviderClaims(ctx)
|
|
delegatorClaims := k.GetAllDelegatorClaims(ctx)
|
|
|
|
synchronizedUsdxClaims := types.USDXMintingClaims{}
|
|
synchronizedHardClaims := types.HardLiquidityProviderClaims{}
|
|
synchronizedDelegatorClaims := types.DelegatorClaims{}
|
|
|
|
for _, usdxClaim := range usdxClaims {
|
|
claim, err := k.SynchronizeUSDXMintingClaim(ctx, usdxClaim)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for i := range claim.RewardIndexes {
|
|
claim.RewardIndexes[i].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
synchronizedUsdxClaims = append(synchronizedUsdxClaims, claim)
|
|
}
|
|
|
|
for _, hardClaim := range hardClaims {
|
|
k.SynchronizeHardLiquidityProviderClaim(ctx, hardClaim.Owner)
|
|
claim, found := k.GetHardLiquidityProviderClaim(ctx, hardClaim.Owner)
|
|
if !found {
|
|
panic("hard liquidity provider claim should always be found after synchronization")
|
|
}
|
|
for i, bri := range claim.BorrowRewardIndexes {
|
|
for j := range bri.RewardIndexes {
|
|
claim.BorrowRewardIndexes[i].RewardIndexes[j].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
for i, sri := range claim.SupplyRewardIndexes {
|
|
for j := range sri.RewardIndexes {
|
|
claim.SupplyRewardIndexes[i].RewardIndexes[j].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
synchronizedHardClaims = append(synchronizedHardClaims, claim)
|
|
}
|
|
|
|
for _, delegatorClaim := range delegatorClaims {
|
|
claim, err := k.SynchronizeDelegatorClaim(ctx, delegatorClaim)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
for i, ri := range claim.RewardIndexes {
|
|
for j := range ri.RewardIndexes {
|
|
claim.RewardIndexes[i].RewardIndexes[j].RewardFactor = sdk.ZeroDec()
|
|
}
|
|
}
|
|
synchronizedDelegatorClaims = append(synchronizedDelegatorClaims, delegatorClaim)
|
|
}
|
|
|
|
var usdxMintingGats GenesisAccumulationTimes
|
|
for _, rp := range params.USDXMintingRewardPeriods {
|
|
pat, found := k.GetPreviousUSDXMintingAccrualTime(ctx, rp.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("expected previous usdx minting reward accrual time to be set in state for %s", rp.CollateralType))
|
|
}
|
|
gat := types.NewGenesisAccumulationTime(rp.CollateralType, pat)
|
|
usdxMintingGats = append(usdxMintingGats, gat)
|
|
}
|
|
|
|
var hardSupplyGats GenesisAccumulationTimes
|
|
for _, rp := range params.HardSupplyRewardPeriods {
|
|
pat, found := k.GetPreviousHardSupplyRewardAccrualTime(ctx, rp.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("expected previous hard supply reward accrual time to be set in state for %s", rp.CollateralType))
|
|
}
|
|
gat := types.NewGenesisAccumulationTime(rp.CollateralType, pat)
|
|
hardSupplyGats = append(hardSupplyGats, gat)
|
|
}
|
|
|
|
var hardBorrowGats GenesisAccumulationTimes
|
|
for _, rp := range params.HardBorrowRewardPeriods {
|
|
pat, found := k.GetPreviousHardBorrowRewardAccrualTime(ctx, rp.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("expected previous hard borrow reward accrual time to be set in state for %s", rp.CollateralType))
|
|
}
|
|
gat := types.NewGenesisAccumulationTime(rp.CollateralType, pat)
|
|
hardBorrowGats = append(hardBorrowGats, gat)
|
|
}
|
|
|
|
var delegatorGats GenesisAccumulationTimes
|
|
for _, rp := range params.DelegatorRewardPeriods {
|
|
pat, found := k.GetPreviousDelegatorRewardAccrualTime(ctx, rp.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("expected previous delegator reward accrual time to be set in state for %s", rp.CollateralType))
|
|
}
|
|
gat := types.NewGenesisAccumulationTime(rp.CollateralType, pat)
|
|
delegatorGats = append(delegatorGats, gat)
|
|
}
|
|
|
|
var swapGats GenesisAccumulationTimes
|
|
for _, rp := range params.SwapRewardPeriods {
|
|
pat, found := k.GetSwapRewardAccrualTime(ctx, rp.CollateralType)
|
|
if !found {
|
|
panic(fmt.Sprintf("expected previous swap reward accrual time to be set in state for %s", rp.CollateralType))
|
|
}
|
|
gat := types.NewGenesisAccumulationTime(rp.CollateralType, pat)
|
|
swapGats = append(swapGats, gat)
|
|
}
|
|
|
|
return types.NewGenesisState(params, usdxMintingGats, hardSupplyGats,
|
|
hardBorrowGats, delegatorGats, swapGats, synchronizedUsdxClaims,
|
|
synchronizedHardClaims, synchronizedDelegatorClaims)
|
|
}
|