package keeper_test import ( "time" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/staking" abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/crypto/ed25519" tmtime "github.com/tendermint/tendermint/types/time" "github.com/kava-labs/kava/app" cdptypes "github.com/kava-labs/kava/x/cdp/types" "github.com/kava-labs/kava/x/hard" hardtypes "github.com/kava-labs/kava/x/hard/types" "github.com/kava-labs/kava/x/incentive/types" ) func (suite *KeeperTestSuite) TestAccumulateUSDXMintingRewards() { type args struct { ctype string rewardsPerSecond sdk.Coin initialTime time.Time initialTotalPrincipal sdk.Coin timeElapsed int expectedRewardFactor sdk.Dec } type test struct { name string args args } testCases := []test{ { "7 seconds", args{ ctype: "bnb-a", rewardsPerSecond: c("ukava", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), initialTotalPrincipal: c("usdx", 1000000000000), timeElapsed: 7, expectedRewardFactor: d("0.000000856478000000"), }, }, { "1 day", args{ ctype: "bnb-a", rewardsPerSecond: c("ukava", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), initialTotalPrincipal: c("usdx", 1000000000000), timeElapsed: 86400, expectedRewardFactor: d("0.0105713856"), }, }, { "0 seconds", args{ ctype: "bnb-a", rewardsPerSecond: c("ukava", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), initialTotalPrincipal: c("usdx", 1000000000000), timeElapsed: 0, expectedRewardFactor: d("0.0"), }, }, } for _, tc := range testCases { suite.Run(tc.name, func() { suite.SetupWithGenState() suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // setup cdp state cdpKeeper := suite.app.GetCDPKeeper() cdpKeeper.SetTotalPrincipal(suite.ctx, tc.args.ctype, cdptypes.DefaultStableDenom, tc.args.initialTotalPrincipal.Amount) // setup incentive state params := types.NewParams( types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, tc.args.initialTime.Add(time.Hour*24*365*5), ) suite.keeper.SetParams(suite.ctx, params) suite.keeper.SetPreviousUSDXMintingAccrualTime(suite.ctx, tc.args.ctype, tc.args.initialTime) suite.keeper.SetUSDXMintingRewardFactor(suite.ctx, tc.args.ctype, sdk.ZeroDec()) updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * tc.args.timeElapsed)) suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) rewardPeriod, found := suite.keeper.GetUSDXMintingRewardPeriod(suite.ctx, tc.args.ctype) suite.Require().True(found) err := suite.keeper.AccumulateUSDXMintingRewards(suite.ctx, rewardPeriod) suite.Require().NoError(err) rewardFactor, found := suite.keeper.GetUSDXMintingRewardFactor(suite.ctx, tc.args.ctype) suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) }) } } func (suite *KeeperTestSuite) TestSynchronizeUSDXMintingReward() { type args struct { ctype string rewardsPerSecond sdk.Coin initialTime time.Time initialCollateral sdk.Coin initialPrincipal sdk.Coin blockTimes []int expectedRewardFactor sdk.Dec expectedRewards sdk.Coin } type test struct { name string args args } testCases := []test{ { "10 blocks", args{ ctype: "bnb-a", rewardsPerSecond: c("ukava", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), initialCollateral: c("bnb", 1000000000000), initialPrincipal: c("usdx", 10000000000), blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, expectedRewardFactor: d("0.001223540000000000"), expectedRewards: c("ukava", 12235400), }, }, { "10 blocks - long block time", args{ ctype: "bnb-a", rewardsPerSecond: c("ukava", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), initialCollateral: c("bnb", 1000000000000), initialPrincipal: c("usdx", 10000000000), blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, expectedRewardFactor: d("10.57138560000000000"), expectedRewards: c("ukava", 105713856000), }, }, } for _, tc := range testCases { suite.Run(tc.name, func() { suite.SetupWithGenState() suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // setup incentive state params := types.NewParams( types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, tc.args.initialTime.Add(time.Hour*24*365*5), ) suite.keeper.SetParams(suite.ctx, params) suite.keeper.SetPreviousUSDXMintingAccrualTime(suite.ctx, tc.args.ctype, tc.args.initialTime) suite.keeper.SetUSDXMintingRewardFactor(suite.ctx, tc.args.ctype, sdk.ZeroDec()) // setup account state sk := suite.app.GetSupplyKeeper() sk.MintCoins(suite.ctx, cdptypes.ModuleName, sdk.NewCoins(tc.args.initialCollateral)) sk.SendCoinsFromModuleToAccount(suite.ctx, cdptypes.ModuleName, suite.addrs[0], sdk.NewCoins(tc.args.initialCollateral)) // setup cdp state cdpKeeper := suite.app.GetCDPKeeper() err := cdpKeeper.AddCdp(suite.ctx, suite.addrs[0], tc.args.initialCollateral, tc.args.initialPrincipal, tc.args.ctype) suite.Require().NoError(err) claim, found := suite.keeper.GetUSDXMintingClaim(suite.ctx, suite.addrs[0]) suite.Require().True(found) suite.Require().Equal(sdk.ZeroDec(), claim.RewardIndexes[0].RewardFactor) var timeElapsed int previousBlockTime := suite.ctx.BlockTime() for _, t := range tc.args.blockTimes { timeElapsed += t updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) previousBlockTime = updatedBlockTime blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) rewardPeriod, found := suite.keeper.GetUSDXMintingRewardPeriod(blockCtx, tc.args.ctype) suite.Require().True(found) err := suite.keeper.AccumulateUSDXMintingRewards(blockCtx, rewardPeriod) suite.Require().NoError(err) } updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) cdp, found := cdpKeeper.GetCdpByOwnerAndCollateralType(suite.ctx, suite.addrs[0], tc.args.ctype) suite.Require().True(found) suite.Require().NotPanics(func() { suite.keeper.SynchronizeUSDXMintingReward(suite.ctx, cdp) }) rewardFactor, found := suite.keeper.GetUSDXMintingRewardFactor(suite.ctx, tc.args.ctype) suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) claim, found = suite.keeper.GetUSDXMintingClaim(suite.ctx, suite.addrs[0]) suite.Require().True(found) suite.Require().Equal(tc.args.expectedRewardFactor, claim.RewardIndexes[0].RewardFactor) suite.Require().Equal(tc.args.expectedRewards, claim.Reward) }) } } // func (suite *KeeperTestSuite) TestAccumulateHardBorrowRewards() { // type args struct { // borrow sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // timeElapsed int // expectedRewardFactor sdk.Dec // } // type test struct { // name string // args args // } // testCases := []test{ // { // "7 seconds", // args{ // borrow: c("bnb", 1000000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // timeElapsed: 7, // expectedRewardFactor: d("0.000000856478000001"), // }, // }, // { // "1 day", // args{ // borrow: c("bnb", 1000000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // timeElapsed: 86400, // expectedRewardFactor: d("0.010571385600010177"), // }, // }, // { // "0 seconds", // args{ // borrow: c("bnb", 1000000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // timeElapsed: 0, // expectedRewardFactor: d("0.0"), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardBorrowRewardAccrualTime(suite.ctx, tc.args.borrow.Denom, tc.args.initialTime) // defaultRewardIndexes := types.RewardIndexes{types.NewRewardIndex(types.HardLiquidityRewardDenom, sdk.ZeroDec())} // suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom, defaultRewardIndexes) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.borrow.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetBorrowInterestFactor(suite.ctx, tc.args.borrow.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.borrow.Denom, tc.args.initialTime) // // User deposits and borrows to increase total borrowed amount // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, sdk.NewCoins(sdk.NewCoin(tc.args.borrow.Denom, tc.args.borrow.Amount.Mul(sdk.NewInt(2))))) // suite.Require().NoError(err) // err = hardKeeper.Borrow(suite.ctx, userAddr, sdk.NewCoins(tc.args.borrow)) // suite.Require().NoError(err) // // Set up chain context at future time // runAtTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * tc.args.timeElapsed)) // runCtx := suite.ctx.WithBlockTime(runAtTime) // // Run Hard begin blocker in order to update the denom's index factor // hard.BeginBlocker(runCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardBorrowRewardPeriods(runCtx, tc.args.borrow.Denom) // suite.Require().True(found) // err = suite.keeper.AccumulateHardBorrowRewards(runCtx, rewardPeriod) // suite.Require().NoError(err) // rewardIndexes, found := suite.keeper.GetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom) // suite.Require().True(found) // rewardFactor, found := rewardIndexes.GetRewardIndex(types.HardLiquidityRewardDenom) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) // }) // } // } // func (suite *KeeperTestSuite) TestSynchronizeHardBorrowReward() { // type args struct { // borrow sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // borrow: c("bnb", 10000000000), // TODO: 2 decimal diff from TestAccumulateHardBorrowRewards's borrow // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("0.001223540000173228"), // expectedRewards: c("hard", 12235400), // }, // }, // { // "10 blocks - long block time", // args{ // borrow: c("bnb", 10000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("10.571385603126235340"), // expectedRewards: c("hard", 105713856031), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardBorrowRewardAccrualTime(suite.ctx, tc.args.borrow.Denom, tc.args.initialTime) // defaultRewardIndexes := types.RewardIndexes{types.NewRewardIndex(types.HardLiquidityRewardDenom, sdk.ZeroDec())} // suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom, defaultRewardIndexes) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.borrow.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetBorrowInterestFactor(suite.ctx, tc.args.borrow.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.borrow.Denom, tc.args.initialTime) // // User deposits and borrows to increase total borrowed amount // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, sdk.NewCoins(sdk.NewCoin(tc.args.borrow.Denom, tc.args.borrow.Amount.Mul(sdk.NewInt(2))))) // suite.Require().NoError(err) // err = hardKeeper.Borrow(suite.ctx, userAddr, sdk.NewCoins(tc.args.borrow)) // suite.Require().NoError(err) // // Check that Hard hooks initialized a HardLiquidityProviderClaim // claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.BorrowRewardIndexes[0].RewardIndexes[0].RewardFactor) // // Run accumulator at several intervals // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // // Run Hard begin blocker for each block ctx to update denom's interest factor // hard.BeginBlocker(blockCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardBorrowRewardPeriods(blockCtx, tc.args.borrow.Denom) // suite.Require().True(found) // err := suite.keeper.AccumulateHardBorrowRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // // After we've accumulated, run synchronize // borrow, found := hardKeeper.GetBorrow(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().NotPanics(func() { // suite.keeper.SynchronizeHardBorrowReward(suite.ctx, borrow) // }) // // Check that reward factor and claim have been updated as expected // rewardIndexes, found := suite.keeper.GetHardBorrowRewardIndexes(suite.ctx, tc.args.borrow.Denom) // suite.Require().True(found) // rewardFactor, found := rewardIndexes.GetRewardIndex(types.HardLiquidityRewardDenom) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) // claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, claim.BorrowRewardIndexes[0].RewardIndexes[0].RewardFactor) // suite.Require().Equal(tc.args.expectedRewards, claim.Reward) // }) // } // } // func (suite *KeeperTestSuite) TestAccumulateHardSupplyRewards() { // type args struct { // deposit sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // timeElapsed int // expectedRewardFactor sdk.Dec // } // type test struct { // name string // args args // } // testCases := []test{ // { // "7 seconds", // args{ // deposit: c("bnb", 1000000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // timeElapsed: 7, // expectedRewardFactor: d("0.000000856478000000"), // }, // }, // { // "1 day", // args{ // deposit: c("bnb", 1000000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // timeElapsed: 86400, // expectedRewardFactor: d("0.010571385600000000"), // }, // }, // { // "0 seconds", // args{ // deposit: c("bnb", 1000000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // timeElapsed: 0, // expectedRewardFactor: d("0.0"), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // Set up incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, tc.args.deposit.Denom, tc.args.initialTime) // defaultRewardIndexes := types.RewardIndexes{types.NewRewardIndex(types.HardLiquidityRewardDenom, sdk.ZeroDec())} // suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom, defaultRewardIndexes) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.deposit.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.deposit.Denom, tc.args.initialTime) // // User deposits to increase total supplied amount // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, sdk.NewCoins(tc.args.deposit)) // suite.Require().NoError(err) // // Set up chain context at future time // runAtTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * tc.args.timeElapsed)) // runCtx := suite.ctx.WithBlockTime(runAtTime) // // Run Hard begin blocker in order to update the denom's index factor // hard.BeginBlocker(runCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardSupplyRewardPeriods(runCtx, tc.args.deposit.Denom) // suite.Require().True(found) // err = suite.keeper.AccumulateHardSupplyRewards(runCtx, rewardPeriod) // suite.Require().NoError(err) // rewardIndexes, found := suite.keeper.GetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom) // suite.Require().True(found) // rewardFactor, found := rewardIndexes.GetRewardIndex(types.HardLiquidityRewardDenom) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) // }) // } // } // func (suite *KeeperTestSuite) TestSynchronizeHardSupplyReward() { // type args struct { // deposit sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // deposit: c("bnb", 10000000000), // TODO: 2 decimal diff // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("0.001223540000000000"), // expectedRewards: c("hard", 12235400), // }, // }, // { // "10 blocks - long block time", // args{ // deposit: c("bnb", 10000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("10.571385600000000000"), // expectedRewards: c("hard", 105713856000), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, tc.args.deposit.Denom, tc.args.initialTime) // defaultRewardIndexes := types.RewardIndexes{types.NewRewardIndex(types.HardLiquidityRewardDenom, sdk.ZeroDec())} // suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, tc.args.deposit.Denom, defaultRewardIndexes) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.deposit.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetBorrowInterestFactor(suite.ctx, tc.args.deposit.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.deposit.Denom, tc.args.initialTime) // // User deposits and borrows to increase total borrowed amount // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, sdk.NewCoins(tc.args.deposit)) // suite.Require().NoError(err) // // Check that Hard hooks initialized a HardLiquidityProviderClaim // claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.SupplyRewardIndexes[0].RewardIndexes[0].RewardFactor) // // Run accumulator at several intervals // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // // Run Hard begin blocker for each block ctx to update denom's interest factor // hard.BeginBlocker(blockCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardSupplyRewardPeriods(blockCtx, tc.args.deposit.Denom) // suite.Require().True(found) // err := suite.keeper.AccumulateHardSupplyRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // // After we've accumulated, run synchronize // deposit, found := hardKeeper.GetDeposit(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().NotPanics(func() { // suite.keeper.SynchronizeHardSupplyReward(suite.ctx, deposit) // }) // // Check that reward factor and claim have been updated as expected // rewardIndexes, found := suite.keeper.GetHardBorrowRewardIndexes(suite.ctx, tc.args.deposit.Denom) // suite.Require().True(found) // rewardFactor, found := rewardIndexes.GetRewardIndex(types.HardLiquidityRewardDenom) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) // claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, claim.SupplyRewardIndexes[0].RewardIndexes[0].RewardFactor) // suite.Require().Equal(tc.args.expectedRewards, claim.Reward) // }) // } // } // func (suite *KeeperTestSuite) TestUpdateHardSupplyIndexDenoms() { // type args struct { // firstDeposit sdk.Coins // secondDeposit sdk.Coins // rewardsPerSecond sdk.Coin // initialTime time.Time // expectedSupplyIndexDenoms []string // } // type test struct { // name string // args args // } // testCases := []test{ // { // "update adds one supply reward index", // args{ // firstDeposit: cs(c("bnb", 10000000000)), // secondDeposit: cs(c("ukava", 10000000000)), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // expectedSupplyIndexDenoms: []string{"bnb", "ukava"}, // }, // }, // { // "update adds multiple supply reward indexes", // args{ // firstDeposit: cs(c("bnb", 10000000000)), // secondDeposit: cs(c("ukava", 10000000000), c("btcb", 10000000000), c("xrp", 10000000000)), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // expectedSupplyIndexDenoms: []string{"bnb", "ukava", "btcb", "xrp"}, // }, // }, // { // "update doesn't add duplicate supply reward index for same denom", // args{ // firstDeposit: cs(c("bnb", 10000000000)), // secondDeposit: cs(c("bnb", 5000000000)), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // expectedSupplyIndexDenoms: []string{"bnb"}, // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // Set up generic reward periods // var multiRewardPeriods types.MultiRewardPeriods // var rewardPeriods types.RewardPeriods // for _, denom := range tc.args.expectedSupplyIndexDenoms { // rewardPeriod := types.NewRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond) // rewardPeriods = append(rewardPeriods, rewardPeriod) // multiRewardPeriod := types.NewMultiRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond)) // multiRewardPeriods = append(multiRewardPeriods, multiRewardPeriod) // } // // Setup incentive state // params := types.NewParams( // rewardPeriods, multiRewardPeriods, multiRewardPeriods, rewardPeriods, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // // Set each denom's previous accrual time and supply reward factor // defaultRewardIndexes := types.RewardIndexes{types.NewRewardIndex(types.HardLiquidityRewardDenom, sdk.ZeroDec())} // for _, denom := range tc.args.expectedSupplyIndexDenoms { // suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, denom, tc.args.initialTime) // suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, denom, defaultRewardIndexes) // } // // User deposits (first time) // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, tc.args.firstDeposit) // suite.Require().NoError(err) // // Confirm that a claim was created and populated with the correct supply indexes // claimAfterFirstDeposit, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // for _, coin := range tc.args.firstDeposit { // _, hasIndex := claimAfterFirstDeposit.HasSupplyRewardIndex(coin.Denom) // suite.Require().True(hasIndex) // } // suite.Require().True(len(claimAfterFirstDeposit.SupplyRewardIndexes) == len(tc.args.firstDeposit)) // // User deposits (second time) // err = hardKeeper.Deposit(suite.ctx, userAddr, tc.args.secondDeposit) // suite.Require().NoError(err) // // Confirm that the claim contains all expected supply indexes // claimAfterSecondDeposit, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // for _, denom := range tc.args.expectedSupplyIndexDenoms { // _, hasIndex := claimAfterSecondDeposit.HasSupplyRewardIndex(denom) // suite.Require().True(hasIndex) // } // suite.Require().True(len(claimAfterSecondDeposit.SupplyRewardIndexes) == len(tc.args.expectedSupplyIndexDenoms)) // }) // } // } // func (suite *KeeperTestSuite) TestUpdateHardBorrowIndexDenoms() { // type args struct { // initialDeposit sdk.Coins // firstBorrow sdk.Coins // secondBorrow sdk.Coins // rewardsPerSecond sdk.Coin // initialTime time.Time // expectedBorrowIndexDenoms []string // } // type test struct { // name string // args args // } // testCases := []test{ // { // "update adds one borrow reward index", // args{ // initialDeposit: cs(c("bnb", 10000000000)), // firstBorrow: cs(c("bnb", 50000000)), // secondBorrow: cs(c("ukava", 500000000)), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // expectedBorrowIndexDenoms: []string{"bnb", "ukava"}, // }, // }, // { // "update adds multiple borrow supply reward indexes", // args{ // initialDeposit: cs(c("btcb", 10000000000)), // firstBorrow: cs(c("btcb", 50000000)), // secondBorrow: cs(c("ukava", 500000000), c("bnb", 50000000000), c("xrp", 50000000000)), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // expectedBorrowIndexDenoms: []string{"btcb", "ukava", "bnb", "xrp"}, // }, // }, // { // "update doesn't add duplicate borrow reward index for same denom", // args{ // initialDeposit: cs(c("bnb", 100000000000)), // firstBorrow: cs(c("bnb", 50000000)), // secondBorrow: cs(c("bnb", 50000000000)), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // expectedBorrowIndexDenoms: []string{"bnb"}, // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account so it can service borrow requests // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := tc.args.firstBorrow.Add(tc.args.secondBorrow...) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // Set up generic reward periods // var multiRewardPeriods types.MultiRewardPeriods // var rewardPeriods types.RewardPeriods // for _, denom := range tc.args.expectedBorrowIndexDenoms { // rewardPeriod := types.NewRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond) // rewardPeriods = append(rewardPeriods, rewardPeriod) // multiRewardPeriod := types.NewMultiRewardPeriod(true, denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond)) // multiRewardPeriods = append(multiRewardPeriods, multiRewardPeriod) // } // // Setup incentive state // params := types.NewParams( // rewardPeriods, multiRewardPeriods, multiRewardPeriods, rewardPeriods, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // defaultRewardIndexes := types.RewardIndexes{types.NewRewardIndex(types.HardLiquidityRewardDenom, sdk.ZeroDec())} // // Set each initial deposit denom's previous accrual time and supply reward factor // for _, coin := range tc.args.initialDeposit { // suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, coin.Denom, tc.args.initialTime) // suite.keeper.SetHardSupplyRewardIndexes(suite.ctx, coin.Denom, defaultRewardIndexes) // } // // Set each expected borrow denom's previous accrual time and borrow reward factor // for _, denom := range tc.args.expectedBorrowIndexDenoms { // suite.keeper.SetPreviousHardBorrowRewardAccrualTime(suite.ctx, denom, tc.args.initialTime) // suite.keeper.SetHardBorrowRewardIndexes(suite.ctx, denom, defaultRewardIndexes) // } // // User deposits initial funds (so that user can borrow) // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, tc.args.initialDeposit) // suite.Require().NoError(err) // // Confirm that claim exists but no borrow reward indexes have been added // claimAfterDeposit, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(0, len(claimAfterDeposit.BorrowRewardIndexes)) // // User borrows (first time) // err = hardKeeper.Borrow(suite.ctx, userAddr, tc.args.firstBorrow) // suite.Require().NoError(err) // // Confirm that claim's borrow reward indexes have been updated // claimAfterFirstBorrow, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // for _, coin := range tc.args.firstBorrow { // _, hasIndex := claimAfterFirstBorrow.HasBorrowRewardIndex(coin.Denom) // suite.Require().True(hasIndex) // } // suite.Require().True(len(claimAfterFirstBorrow.BorrowRewardIndexes) == len(tc.args.firstBorrow)) // // User borrows (second time) // err = hardKeeper.Borrow(suite.ctx, userAddr, tc.args.secondBorrow) // suite.Require().NoError(err) // // Confirm that claim's borrow reward indexes contain expected values // claimAfterSecondBorrow, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // for _, coin := range tc.args.secondBorrow { // _, hasIndex := claimAfterSecondBorrow.HasBorrowRewardIndex(coin.Denom) // suite.Require().True(hasIndex) // } // suite.Require().True(len(claimAfterSecondBorrow.BorrowRewardIndexes) == len(tc.args.expectedBorrowIndexDenoms)) // }) // } // } func (suite *KeeperTestSuite) TestAccumulateHardDelegatorRewards() { type args struct { delegation sdk.Coin rewardsPerSecond sdk.Coin initialTime time.Time timeElapsed int expectedRewardFactor sdk.Dec } type test struct { name string args args } testCases := []test{ { "7 seconds", args{ delegation: c("ukava", 1_000_000), rewardsPerSecond: c("hard", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), timeElapsed: 7, expectedRewardFactor: d("0.428239000000000000"), }, }, { "1 day", args{ delegation: c("ukava", 1_000_000), rewardsPerSecond: c("hard", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), timeElapsed: 86400, expectedRewardFactor: d("5285.692800000000000000"), }, }, { "0 seconds", args{ delegation: c("ukava", 1_000_000), rewardsPerSecond: c("hard", 122354), initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), timeElapsed: 0, expectedRewardFactor: d("0.0"), }, }, } for _, tc := range testCases { suite.Run(tc.name, func() { suite.SetupWithGenState() suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // Mint coins to hard module account supplyKeeper := suite.app.GetSupplyKeeper() hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // Set up incentive state params := types.NewParams( types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, tc.args.initialTime.Add(time.Hour*24*365*5), ) suite.keeper.SetParams(suite.ctx, params) suite.keeper.SetPreviousHardDelegatorRewardAccrualTime(suite.ctx, tc.args.delegation.Denom, tc.args.initialTime) suite.keeper.SetHardDelegatorRewardFactor(suite.ctx, tc.args.delegation.Denom, sdk.ZeroDec()) // Set up hard state (interest factor for the relevant denom) suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.delegation.Denom, tc.args.initialTime) err := suite.deliverMsgCreateValidator(suite.ctx, suite.validatorAddrs[0], tc.args.delegation) suite.Require().NoError(err) suite.deliverMsgDelegate(suite.ctx, suite.addrs[0], suite.validatorAddrs[0], tc.args.delegation) suite.Require().NoError(err) staking.EndBlocker(suite.ctx, suite.stakingKeeper) // Set up chain context at future time runAtTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * tc.args.timeElapsed)) runCtx := suite.ctx.WithBlockTime(runAtTime) // Run Hard begin blocker in order to update the denom's index factor hard.BeginBlocker(runCtx, suite.hardKeeper) rewardPeriod, found := suite.keeper.GetHardDelegatorRewardPeriod(runCtx, tc.args.delegation.Denom) suite.Require().True(found) err = suite.keeper.AccumulateHardDelegatorRewards(runCtx, rewardPeriod) suite.Require().NoError(err) rewardFactor, found := suite.keeper.GetHardDelegatorRewardFactor(runCtx, tc.args.delegation.Denom) suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) }) } } // func (suite *KeeperTestSuite) TestSynchronizeHardDelegatorReward() { // type args struct { // delegation sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // delegation: c("ukava", 1_000_000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("6.117700000000000000"), // expectedRewards: c("hard", 6117700), // }, // }, // { // "10 blocks - long block time", // args{ // delegation: c("ukava", 1_000_000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("52856.928000000000000000"), // expectedRewards: c("hard", 52856928000), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.MultiRewardPeriods{types.NewMultiRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), cs(tc.args.rewardsPerSecond))}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardDelegatorRewardAccrualTime(suite.ctx, tc.args.delegation.Denom, tc.args.initialTime) // suite.keeper.SetHardDelegatorRewardFactor(suite.ctx, tc.args.delegation.Denom, sdk.ZeroDec()) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.delegation.Denom, tc.args.initialTime) // // Delegator delegates // err := suite.deliverMsgCreateValidator(suite.ctx, suite.validatorAddrs[0], tc.args.delegation) // suite.Require().NoError(err) // suite.deliverMsgDelegate(suite.ctx, suite.addrs[0], suite.validatorAddrs[0], tc.args.delegation) // suite.Require().NoError(err) // staking.EndBlocker(suite.ctx, suite.stakingKeeper) // // Check that Staking hooks initialized a HardLiquidityProviderClaim // claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[0]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.DelegatorRewardIndexes[0].RewardFactor) // // Run accumulator at several intervals // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // // Run Hard begin blocker for each block ctx to update denom's interest factor // hard.BeginBlocker(blockCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardDelegatorRewardPeriod(blockCtx, tc.args.delegation.Denom) // suite.Require().True(found) // err := suite.keeper.AccumulateHardDelegatorRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // // After we've accumulated, run synchronize // suite.Require().NotPanics(func() { // suite.keeper.SynchronizeHardDelegatorRewards(suite.ctx, suite.addrs[0]) // }) // // Check that reward factor and claim have been updated as expected // rewardFactor, found := suite.keeper.GetHardDelegatorRewardFactor(suite.ctx, tc.args.delegation.Denom) // suite.Require().Equal(tc.args.expectedRewardFactor, rewardFactor) // claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[0]) // suite.Require().True(found) // suite.Require().Equal(tc.args.expectedRewardFactor, claim.DelegatorRewardIndexes[0].RewardFactor) // suite.Require().Equal(tc.args.expectedRewards, claim.Reward) // }) // } // } // func (suite *KeeperTestSuite) TestSimulateHardSupplyRewardSynchronization() { // type args struct { // deposit sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // deposit: c("bnb", 10000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("0.001223540000000000"), // expectedRewards: c("hard", 12235400), // }, // }, // { // "10 blocks - long block time", // args{ // deposit: c("bnb", 10000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("10.571385600000000000"), // expectedRewards: c("hard", 105713856000), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.deposit.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardSupplyRewardAccrualTime(suite.ctx, tc.args.deposit.Denom, tc.args.initialTime) // suite.keeper.SetHardSupplyRewardFactor(suite.ctx, tc.args.deposit.Denom, sdk.ZeroDec()) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.deposit.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetBorrowInterestFactor(suite.ctx, tc.args.deposit.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.deposit.Denom, tc.args.initialTime) // // User deposits and borrows to increase total borrowed amount // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, sdk.NewCoins(tc.args.deposit)) // suite.Require().NoError(err) // // Check that Hard hooks initialized a HardLiquidityProviderClaim // claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.SupplyRewardIndexes[0].RewardFactor) // // Run accumulator at several intervals // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // // Run Hard begin blocker for each block ctx to update denom's interest factor // hard.BeginBlocker(blockCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardSupplyRewardPeriod(blockCtx, tc.args.deposit.Denom) // suite.Require().True(found) // err := suite.keeper.AccumulateHardSupplyRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(claim.SupplyRewardIndexes[0].RewardFactor, sdk.ZeroDec()) // suite.Require().Equal(claim.Reward, sdk.NewCoin("hard", sdk.ZeroInt())) // updatedClaim := suite.keeper.SimulateHardSynchronization(suite.ctx, claim) // suite.Require().Equal(updatedClaim.SupplyRewardIndexes[0].RewardFactor, tc.args.expectedRewardFactor) // suite.Require().Equal(updatedClaim.Reward, tc.args.expectedRewards) // }) // } // } // func (suite *KeeperTestSuite) TestSimulateHardBorrowRewardSynchronization() { // type args struct { // borrow sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // borrow: c("bnb", 10000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("0.001223540000173228"), // expectedRewards: c("hard", 12235400), // }, // }, // { // "10 blocks - long block time", // args{ // borrow: c("bnb", 10000000000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("10.571385603126235340"), // expectedRewards: c("hard", 105713856031), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.borrow.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardBorrowRewardAccrualTime(suite.ctx, tc.args.borrow.Denom, tc.args.initialTime) // suite.keeper.SetHardBorrowRewardFactor(suite.ctx, tc.args.borrow.Denom, sdk.ZeroDec()) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetSupplyInterestFactor(suite.ctx, tc.args.borrow.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetBorrowInterestFactor(suite.ctx, tc.args.borrow.Denom, sdk.MustNewDecFromStr("1.0")) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.borrow.Denom, tc.args.initialTime) // // User deposits and borrows to increase total borrowed amount // hardKeeper := suite.app.GetHardKeeper() // userAddr := suite.addrs[3] // err := hardKeeper.Deposit(suite.ctx, userAddr, sdk.NewCoins(sdk.NewCoin(tc.args.borrow.Denom, tc.args.borrow.Amount.Mul(sdk.NewInt(2))))) // suite.Require().NoError(err) // err = hardKeeper.Borrow(suite.ctx, userAddr, sdk.NewCoins(tc.args.borrow)) // suite.Require().NoError(err) // // Check that Hard hooks initialized a HardLiquidityProviderClaim // claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.BorrowRewardIndexes[0].RewardFactor) // // Run accumulator at several intervals // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // // Run Hard begin blocker for each block ctx to update denom's interest factor // hard.BeginBlocker(blockCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardBorrowRewardPeriod(blockCtx, tc.args.borrow.Denom) // suite.Require().True(found) // err := suite.keeper.AccumulateHardBorrowRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[3]) // suite.Require().True(found) // suite.Require().Equal(claim.BorrowRewardIndexes[0].RewardFactor, sdk.ZeroDec()) // suite.Require().Equal(claim.Reward, sdk.NewCoin("hard", sdk.ZeroInt())) // updatedClaim := suite.keeper.SimulateHardSynchronization(suite.ctx, claim) // suite.Require().Equal(updatedClaim.BorrowRewardIndexes[0].RewardFactor, tc.args.expectedRewardFactor) // suite.Require().Equal(updatedClaim.Reward, tc.args.expectedRewards) // }) // } // } // func (suite *KeeperTestSuite) TestSimulateHardDelegatorRewardSynchronization() { // type args struct { // delegation sdk.Coin // rewardsPerSecond sdk.Coin // initialTime time.Time // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // delegation: c("ukava", 1_000_000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("6.117700000000000000"), // expectedRewards: c("hard", 6117700), // }, // }, // { // "10 blocks - long block time", // args{ // delegation: c("ukava", 1_000_000), // rewardsPerSecond: c("hard", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("52856.928000000000000000"), // expectedRewards: c("hard", 52856928000), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // Mint coins to hard module account // supplyKeeper := suite.app.GetSupplyKeeper() // hardMaccCoins := sdk.NewCoins(sdk.NewCoin("usdx", sdk.NewInt(200000000))) // supplyKeeper.MintCoins(suite.ctx, hardtypes.ModuleAccountName, hardMaccCoins) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.delegation.Denom, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousHardDelegatorRewardAccrualTime(suite.ctx, tc.args.delegation.Denom, tc.args.initialTime) // suite.keeper.SetHardDelegatorRewardFactor(suite.ctx, tc.args.delegation.Denom, sdk.ZeroDec()) // // Set up hard state (interest factor for the relevant denom) // suite.hardKeeper.SetPreviousAccrualTime(suite.ctx, tc.args.delegation.Denom, tc.args.initialTime) // // Delegator delegates // err := suite.deliverMsgCreateValidator(suite.ctx, suite.validatorAddrs[0], tc.args.delegation) // suite.Require().NoError(err) // suite.deliverMsgDelegate(suite.ctx, suite.addrs[0], suite.validatorAddrs[0], tc.args.delegation) // suite.Require().NoError(err) // staking.EndBlocker(suite.ctx, suite.stakingKeeper) // // Check that Staking hooks initialized a HardLiquidityProviderClaim // claim, found := suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[0]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.DelegatorRewardIndexes[0].RewardFactor) // // Run accumulator at several intervals // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // // Run Hard begin blocker for each block ctx to update denom's interest factor // hard.BeginBlocker(blockCtx, suite.hardKeeper) // rewardPeriod, found := suite.keeper.GetHardDelegatorRewardPeriod(blockCtx, tc.args.delegation.Denom) // suite.Require().True(found) // err := suite.keeper.AccumulateHardDelegatorRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // claim, found = suite.keeper.GetHardLiquidityProviderClaim(suite.ctx, suite.addrs[0]) // suite.Require().True(found) // suite.Require().Equal(claim.DelegatorRewardIndexes[0].RewardFactor, sdk.ZeroDec()) // suite.Require().Equal(claim.Reward, sdk.NewCoin("hard", sdk.ZeroInt())) // updatedClaim := suite.keeper.SimulateHardSynchronization(suite.ctx, claim) // suite.Require().Equal(updatedClaim.DelegatorRewardIndexes[0].RewardFactor, tc.args.expectedRewardFactor) // suite.Require().Equal(updatedClaim.Reward, tc.args.expectedRewards) // }) // } // } // func (suite *KeeperTestSuite) TestSimulateUSDXMintingRewardSynchronization() { // type args struct { // ctype string // rewardsPerSecond sdk.Coin // initialTime time.Time // initialCollateral sdk.Coin // initialPrincipal sdk.Coin // blockTimes []int // expectedRewardFactor sdk.Dec // expectedRewards sdk.Coin // } // type test struct { // name string // args args // } // testCases := []test{ // { // "10 blocks", // args{ // ctype: "bnb-a", // rewardsPerSecond: c("ukava", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // initialCollateral: c("bnb", 1000000000000), // initialPrincipal: c("usdx", 10000000000), // blockTimes: []int{10, 10, 10, 10, 10, 10, 10, 10, 10, 10}, // expectedRewardFactor: d("0.001223540000000000"), // expectedRewards: c("ukava", 12235400), // }, // }, // { // "10 blocks - long block time", // args{ // ctype: "bnb-a", // rewardsPerSecond: c("ukava", 122354), // initialTime: time.Date(2020, 12, 15, 14, 0, 0, 0, time.UTC), // initialCollateral: c("bnb", 1000000000000), // initialPrincipal: c("usdx", 10000000000), // blockTimes: []int{86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400, 86400}, // expectedRewardFactor: d("10.57138560000000000"), // expectedRewards: c("ukava", 105713856000), // }, // }, // } // for _, tc := range testCases { // suite.Run(tc.name, func() { // suite.SetupWithGenState() // suite.ctx = suite.ctx.WithBlockTime(tc.args.initialTime) // // setup incentive state // params := types.NewParams( // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.RewardPeriods{types.NewRewardPeriod(true, tc.args.ctype, tc.args.initialTime, tc.args.initialTime.Add(time.Hour*24*365*4), tc.args.rewardsPerSecond)}, // types.Multipliers{types.NewMultiplier(types.MultiplierName("small"), 1, d("0.25")), types.NewMultiplier(types.MultiplierName("large"), 12, d("1.0"))}, // tc.args.initialTime.Add(time.Hour*24*365*5), // ) // suite.keeper.SetParams(suite.ctx, params) // suite.keeper.SetPreviousUSDXMintingAccrualTime(suite.ctx, tc.args.ctype, tc.args.initialTime) // suite.keeper.SetUSDXMintingRewardFactor(suite.ctx, tc.args.ctype, sdk.ZeroDec()) // // setup account state // sk := suite.app.GetSupplyKeeper() // sk.MintCoins(suite.ctx, cdptypes.ModuleName, sdk.NewCoins(tc.args.initialCollateral)) // sk.SendCoinsFromModuleToAccount(suite.ctx, cdptypes.ModuleName, suite.addrs[0], sdk.NewCoins(tc.args.initialCollateral)) // // setup cdp state // cdpKeeper := suite.app.GetCDPKeeper() // err := cdpKeeper.AddCdp(suite.ctx, suite.addrs[0], tc.args.initialCollateral, tc.args.initialPrincipal, tc.args.ctype) // suite.Require().NoError(err) // claim, found := suite.keeper.GetUSDXMintingClaim(suite.ctx, suite.addrs[0]) // suite.Require().True(found) // suite.Require().Equal(sdk.ZeroDec(), claim.RewardIndexes[0].RewardFactor) // var timeElapsed int // previousBlockTime := suite.ctx.BlockTime() // for _, t := range tc.args.blockTimes { // timeElapsed += t // updatedBlockTime := previousBlockTime.Add(time.Duration(int(time.Second) * t)) // previousBlockTime = updatedBlockTime // blockCtx := suite.ctx.WithBlockTime(updatedBlockTime) // rewardPeriod, found := suite.keeper.GetUSDXMintingRewardPeriod(blockCtx, tc.args.ctype) // suite.Require().True(found) // err := suite.keeper.AccumulateUSDXMintingRewards(blockCtx, rewardPeriod) // suite.Require().NoError(err) // } // updatedBlockTime := suite.ctx.BlockTime().Add(time.Duration(int(time.Second) * timeElapsed)) // suite.ctx = suite.ctx.WithBlockTime(updatedBlockTime) // claim, found = suite.keeper.GetUSDXMintingClaim(suite.ctx, suite.addrs[0]) // suite.Require().True(found) // suite.Require().Equal(claim.RewardIndexes[0].RewardFactor, sdk.ZeroDec()) // suite.Require().Equal(claim.Reward, sdk.NewCoin("ukava", sdk.ZeroInt())) // updatedClaim := suite.keeper.SimulateUSDXMintingSynchronization(suite.ctx, claim) // suite.Require().Equal(tc.args.expectedRewardFactor, updatedClaim.RewardIndexes[0].RewardFactor) // suite.Require().Equal(tc.args.expectedRewards, updatedClaim.Reward) // }) // } // } func (suite *KeeperTestSuite) SetupWithGenState() { config := sdk.GetConfig() app.SetBech32AddressPrefixes(config) _, allAddrs := app.GeneratePrivKeyAddressPairs(10) suite.addrs = allAddrs[:5] for _, a := range allAddrs[5:] { suite.validatorAddrs = append(suite.validatorAddrs, sdk.ValAddress(a)) } tApp := app.NewTestApp() ctx := tApp.NewContext(true, abci.Header{Height: 1, Time: tmtime.Now()}) tApp.InitializeFromGenesisStates( coinsAuthGenState(allAddrs, cs(c("ukava", 5_000_000))), stakingGenesisState(), NewPricefeedGenStateMulti(), NewCDPGenStateMulti(), NewHardGenStateMulti(), ) suite.app = tApp suite.ctx = ctx suite.keeper = tApp.GetIncentiveKeeper() suite.hardKeeper = tApp.GetHardKeeper() suite.stakingKeeper = tApp.GetStakingKeeper() } func coinsAuthGenState(addresses []sdk.AccAddress, coins sdk.Coins) app.GenesisState { coinsList := []sdk.Coins{} for range addresses { coinsList = append(coinsList, coins) } // Load up our primary user address if len(addresses) >= 4 { coinsList[3] = sdk.NewCoins( sdk.NewCoin("bnb", sdk.NewInt(1000000000000000)), sdk.NewCoin("ukava", sdk.NewInt(1000000000000000)), sdk.NewCoin("btcb", sdk.NewInt(1000000000000000)), sdk.NewCoin("xrp", sdk.NewInt(1000000000000000)), ) } return app.NewAuthGenState(addresses, coinsList) } func stakingGenesisState() app.GenesisState { genState := staking.DefaultGenesisState() genState.Params.BondDenom = "ukava" return app.GenesisState{ staking.ModuleName: staking.ModuleCdc.MustMarshalJSON(genState), } } func (suite *KeeperTestSuite) deliverMsgCreateValidator(ctx sdk.Context, address sdk.ValAddress, selfDelegation sdk.Coin) error { msg := staking.NewMsgCreateValidator( address, ed25519.GenPrivKey().PubKey(), selfDelegation, staking.Description{}, staking.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec()), sdk.NewInt(1_000_000), ) handleStakingMsg := staking.NewHandler(suite.stakingKeeper) _, err := handleStakingMsg(ctx, msg) return err } func (suite *KeeperTestSuite) deliverMsgDelegate(ctx sdk.Context, delegator sdk.AccAddress, validator sdk.ValAddress, amount sdk.Coin) error { msg := staking.NewMsgDelegate( delegator, validator, amount, ) handleStakingMsg := staking.NewHandler(suite.stakingKeeper) _, err := handleStakingMsg(ctx, msg) return err }